facter 4.0.26 → 4.0.32

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      module FFI
+        module Ioctl
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC, '/usr/lib/libsocket.so'
+
+          attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
+          attach_function :open_socket, :socket, %i[int int int], :int
+          attach_function :close_socket, :shutdown, %i[int 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)
+            result = ioctl_base(fd, call_const, pointer)
+            Ioctl.close_socket(fd, 2)
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative 'ffi/ffi.rb'
+require 'ipaddr'
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Networking < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @interfaces = {}
+
+        BINDINGS_KEY = {
+          FFI::AF_INET => :bindings,
+          FFI::AF_INET6 => :bindings6
+        }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            lifreqs = load_interfaces
+            @interfaces = {}
+
+            lifreqs.each do |lifreq|
+              @interfaces[lifreq.name] ||= {}
+
+              add_mac(lifreq)
+              add_bindings(lifreq)
+              add_mtu(lifreq)
+              add_dhcp(lifreq.name)
+            end
+
+            @fact_list = { interfaces: @interfaces } unless @interfaces.empty?
+            primary_interface
+
+            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+
+            @fact_list[fact_name]
+          end
+
+          def add_mac(lifreq)
+            arp = FFI::Arpreq.new_for_ioctl(lifreq)
+
+            ioctl = FFI::Ioctl.ioctl(FFI::SIOCGARP, arp, lifreq.ss_family)
+
+            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+
+            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 = ::Resolvers::Utils::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)
+
+            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+
+            @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.debug("Error! #{::FFI::LastError.error}")
+            else
+              netmask = inet_ntop(netmask_lifreq, lifreq.ss_family)
+              [netmask, calculate_mask_length(netmask)]
+            end
+          end
+
+          def inet_ntop(lifreq, ss_family)
+            sockaddr = FFI::Sockaddr.new(lifreq.lifru_addr.to_ptr)
+            sockaddr_in = FFI::SockaddrIn.new(sockaddr.to_ptr)
+            ip = FFI::InAddr.new(sockaddr_in[:sin_addr].to_ptr)
+            buffer_size = FFI::INET_ADDRSTRLEN
+            buffer_size = FFI::INET6_ADDRSTRLEN if ss_family == FFI::AF_INET6
+            buffer = ::FFI::MemoryPointer.new(:char, buffer_size)
+
+            FFI::Ioctl.inet_ntop(ss_family, ip.to_ptr, buffer.to_ptr, buffer.size)
+          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.debug("Error! #{::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)
+
+            @log.debug("Error! #{::FFI::LastError.error}") if ioctl == -1
+
+            interfaces = []
+            interface_count.times do |i|
+              interfaces << FFI::Lifreq.new(lifconf[:lifc_buf] + (i * FFI::Lifreq.size))
+            end
+
+            interfaces
+          end
+
+          def calculate_mask_length(netmask)
+            ipaddr = IPAddr.new(netmask)
+            ipaddr.to_i.to_s(2).count('1')
+          end
+
+          def primary_interface
+            result = Facter::Core::Execution.execute('route -n get default', logger: log)
+
+            @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+          end
+
+          def add_dhcp(interface_name)
+            result = Facter::Core::Execution.execute("dhcpinfo -i #{interface_name} ServerID", logger: log)
+
+            @interfaces[interface_name][:dhcp] = result.chomp
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Resolvers
+  module Utils
+    module Networking
+      class << self
+        # Creates a hash with IP, netmask and network. Works for IPV4 and IPV6
+        # @param [String] addr The IP address
+        # @param [Integer] mask_length Number of 1 bits the netmask has
+        #
+        # @return [Hash] Hash containing ip address, netmask and network
+        def build_binding(addr, mask_length)
+          ip = IPAddr.new(addr)
+          mask_helper = ip.ipv6? ? 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' : '255.255.255.255'
+          mask = IPAddr.new(mask_helper).mask(mask_length)
+
+          { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+        end
+
+        def expand_main_bindings(networking_facts)
+          primary = networking_facts[:primary_interface]
+          interfaces = networking_facts[:interfaces]
+
+          expand_interfaces(interfaces) unless interfaces.nil?
+          expand_primary_interface(networking_facts, primary) unless primary.nil? || interfaces.nil?
+        end
+
+        def get_scope(ip)
+          require 'socket'
+
+          scope6 = []
+          addrinfo = Addrinfo.new(['AF_INET6', 0, nil, ip], :INET6)
+
+          scope6 << 'compat,' if IPAddr.new(ip).ipv4_compat?
+          scope6 << if addrinfo.ipv6_linklocal?
+                      'link'
+                    elsif addrinfo.ipv6_sitelocal?
+                      'site'
+                    elsif addrinfo.ipv6_loopback?
+                      'host'
+                    else 'global'
+                    end
+          scope6.join
+        end
+
+        def find_valid_binding(bindings)
+          bindings.each do |binding|
+            return binding unless ignored_ip_address(binding[:address])
+          end
+          bindings.empty? ? nil : bindings.first
+        end
+
+        def ignored_ip_address(addr)
+          addr.empty? || addr.start_with?('127.', '169.254.') || addr.start_with?('fe80') || addr.eql?('::1')
+        end
+
+        private
+
+        def expand_interfaces(interfaces)
+          interfaces.each_value do |values|
+            expand_binding(values, values[:bindings]) if values[:bindings]
+            expand_binding(values, values[:bindings6], false) if values[:bindings6]
+          end
+        end
+
+        def expand_primary_interface(networking_facts, primary)
+          networking_facts[:interfaces][primary].each do |key, value|
+            networking_facts[key] = value unless %i[bindings bindings6].include?(key)
+          end
+        end
+
+        def expand_binding(values, bindings, ipv4_type = true)
+          binding = find_valid_binding(bindings)
+          ip_protocol_type = ipv4_type ? '' : '6'
+
+          values["ip#{ip_protocol_type}".to_sym] = binding[:address]
+          values["netmask#{ip_protocol_type}".to_sym] = binding[:netmask]
+          values["network#{ip_protocol_type}".to_sym] = binding[:network]
+          values[:scope6] = get_scope(binding[:address]) unless ipv4_type
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/windows/aio_agent_version.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class AioAgentVersion < BaseResolver
+        REGISTRY_PATH = 'SOFTWARE\\Puppet Labs\\Puppet'
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_version(fact_name) }
+          end
+
+          def read_version(fact_name)
+            ::Win32::Registry::HKEY_LOCAL_MACHINE.open(REGISTRY_PATH) do |reg|
+              build_fact_list(reg)
+            end
+
+            @fact_list[fact_name]
+          rescue Win32::Registry::Error
+            log.debug("The registry path #{REGISTRY_PATH} does not exist")
+          end
+
+          def build_fact_list(reg)
+            puppet_aio_path = read_for_64_bit(reg) || read_for_32_bit(reg)
+
+            return if puppet_aio_path.nil? || puppet_aio_path.empty?
+
+            puppet_aio_version_path = File.join(puppet_aio_path, 'VERSION')
+            aio_agent_version = Util::FileHelper.safe_read(puppet_aio_version_path, nil)&.chomp
+
+            @fact_list[:aio_agent_version] = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
+          end
+
+          def read_for_64_bit(reg)
+            reg.read('RememberedInstallDir64')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 64 bit registry')
+            nil
+          end
+
+          def read_for_32_bit(reg)
+            reg.read('RememberedInstallDir')[1]
+          rescue Win32::Registry::Error
+            log.debug('Could not read Puppet AIO path from 32 bit registry')
+            nil
+          end
+        end
+      end
+    end
+  end
+end