facter 4.0.50 → 4.2.0

data/lib/facter/util/facts/posix/virtual_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      module Posix
+        module VirtualDetector
+          class << self
+            def platform
+              @@fact_value ||= check_docker_lxc || check_freebsd || check_gce || retrieve_from_virt_what
+              @@fact_value ||= check_vmware || check_open_vz || check_vserver || check_xen || check_other_facts
+              @@fact_value ||= check_lspci || 'physical'
+
+              @@fact_value
+            end
+
+            private
+
+            def check_docker_lxc
+              Facter::Resolvers::Containers.resolve(:vm)
+            end
+
+            def check_gce
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              'gce' if bios_vendor&.include?('Google')
+            end
+
+            def check_vmware
+              Facter::Resolvers::Vmware.resolve(:vm)
+            end
+
+            def retrieve_from_virt_what
+              Facter::Resolvers::VirtWhat.resolve(:vm)
+            end
+
+            def check_open_vz
+              Facter::Resolvers::OpenVz.resolve(:vm)
+            end
+
+            def check_vserver
+              Facter::Resolvers::VirtWhat.resolve(:vserver)
+            end
+
+            def check_xen
+              Facter::Resolvers::Xen.resolve(:vm)
+            end
+
+            def check_freebsd
+              return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+              Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+            end
+
+            def check_other_facts
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              return 'kvm' if bios_vendor&.include?('Amazon EC2')
+
+              product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+              return unless product_name
+
+              Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+              nil
+            end
+
+            def check_lspci
+              Facter::Resolvers::Lspci.resolve(:vm)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/unit_converter.rb

@@ -10,7 +10,7 @@ module Facter
 
             value_in_bytes = value_in_bytes.to_i
 
-            (value_in_bytes / (1024.0 * 1024.0)).round(2)
+            (value_in_bytes / (1024.0 * 1024.0))
           end
 
           def hertz_to_human_readable(speed)
@@ -19,7 +19,7 @@ module Facter
 
             validated_speed, metric_prefix = determine_metric_prefix(speed)
 
-            format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + metric_prefix + 'Hz'
+            format('%<displayed_speed>.2f', displayed_speed: validated_speed.round(2)).to_s + ' ' + metric_prefix + 'Hz'
           end
 
           def bytes_to_human_readable(bytes)

data/lib/facter/util/linux/dhcp.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class Dhcp
+        class << self
+          DIRS = %w[/var/lib/dhclient/
+                    /var/lib/dhcp/
+                    /var/lib/dhcp3/
+                    /var/lib/NetworkManager/
+                    /var/db/].freeze
+
+          def dhcp(interface_name, interface_index, logger)
+            @log = logger
+            @log.debug("Get DHCP for interface #{interface_name}")
+
+            dhcp = search_systemd_netif_leases(interface_index, interface_name)
+            dhcp ||= search_dhclient_leases(interface_name)
+            dhcp ||= search_internal_leases(interface_name)
+            dhcp ||= search_with_dhcpcd_command(interface_name)
+            dhcp
+          end
+
+          private
+
+          def search_systemd_netif_leases(index, interface_name)
+            return if index.nil?
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from systemd/netif/leases")
+
+            file_content = Facter::Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+            dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+            dhcp[1] if dhcp
+          end
+
+          def search_dhclient_leases(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhclient leases")
+
+            DIRS.each do |dir|
+              next unless File.readable?(dir)
+
+              lease_files = Dir.entries(dir).select { |file| file =~ /dhclient.*\.lease/ }
+              next if lease_files.empty?
+
+              lease_files.select do |file|
+                content = Facter::Util::FileHelper.safe_read("#{dir}#{file}", nil)
+                next unless content =~ /interface.*#{interface_name}/
+
+                dhcp = content.match(/dhcp-server-identifier ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/)
+                return dhcp[1] if dhcp
+              end
+            end
+
+            nil
+          end
+
+          def search_internal_leases(interface_name)
+            return unless File.readable?('/var/lib/NetworkManager/')
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from NetworkManager leases")
+
+            files = Dir.entries('/var/lib/NetworkManager/').reject { |dir| dir =~ /^\.+$/ }
+            lease_file = files.find { |file| file =~ /internal.*#{interface_name}\.lease/ }
+            return unless lease_file
+
+            dhcp = Facter::Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
+
+            return unless dhcp
+
+            dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+            dhcp[1] if dhcp
+          end
+
+          def search_with_dhcpcd_command(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhcpcd command")
+
+            output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: @log)
+            dhcp = output.match(/dhcp_server_identifier='(.*)'/)
+            dhcp[1] if dhcp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/if_inet6.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Util
+    module Linux
+      class IfInet6
+        class << self
+          IFA_FLAGS = {
+            'temporary' => 0x01,
+            'noad' => 0x02,
+            'optimistic' => 0x04,
+            'dadfailed' => 0x08,
+            'homeaddress' => 0x10,
+            'deprecated' => 0x20,
+            'tentative' => 0x40,
+            'permanent' => 0x80
+            # /proc/net/if_inet6 only supports the old 8bit flags
+            # I have been unable to find a simple solution to accesses
+            # the full 32bit flags.  netlink is all I can could find but
+            # that will likely be ugly
+            # 'managetempaddr' => 0x100,
+            # 'noprefixroute' => 0x200,
+            # 'mcautojoin' => 0x400,
+            # 'stableprivacy' => 0x800
+          }.freeze
+
+          def read_flags
+            return read_flags_from_proc if File.exist?('/proc/net/if_inet6')
+
+            {}
+          end
+
+          private
+
+          def read_flags_from_proc
+            flags = init_flags
+            Facter::Util::FileHelper.safe_read('/proc/net/if_inet6', nil).each_line do |line|
+              iface = line.split
+              next unless iface.size == 6
+
+              ip = parse_ip(iface[0])
+              flags[iface[5]][ip] = parse_ifa_flags(iface[4])
+            end
+            flags
+          end
+
+          def init_flags
+            Hash.new { |h1, k1| h1[k1] = Hash.new { |h2, k2| h2[k2] = [] } }
+          end
+
+          def parse_ifa_flags(flag)
+            flag = flag.hex
+            flags = []
+            IFA_FLAGS.each_pair do |name, value|
+              next if (flag & value).zero?
+
+              flags << name
+            end
+            flags
+          end
+
+          def parse_ip(ip)
+            # The ip address in if_net6 is a long string wit no colons
+            ip = ip.scan(/(\h{4})/).join(':')
+            IPAddr.new(ip).to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/routing_table.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class RoutingTable
+        class << self
+          ROUTE_TYPES = %w[anycast
+                           unicast
+                           broadcast
+                           local
+                           nat
+                           unreachable
+                           prohibit
+                           blackhole
+                           throw].freeze
+
+          def read_routing_table(logger)
+            ipv4_output = Facter::Core::Execution.execute('ip route show', logger: logger)
+            ipv6_output = Facter::Core::Execution.execute('ip -6 route show', logger: logger)
+            routes4 = parse_routes(ipv4_output, true)
+            routes6 = parse_routes(ipv6_output, false)
+            [routes4, routes6]
+          end
+
+          private
+
+          def parse_routes(output, ipv4_type)
+            routes = []
+            output.each_line do |line|
+              parts = line.split(' ').compact
+              next if parts.include?('linkdown')
+
+              delete_invalid_route_type(parts)
+              next if !ipv4_type && !parts[0].include?(':')
+
+              route = construct_route(parts)
+              routes << route unless route[:ip].nil?
+            end
+            routes.uniq
+          end
+
+          def delete_invalid_route_type(parts)
+            route_type = parts[0]
+            parts.delete_at(0) if ROUTE_TYPES.include?(route_type)
+          end
+
+          def construct_route(parts)
+            route = {}
+            dev_index = parts.find_index { |elem| elem == 'dev' }
+            src_index = parts.find_index { |elem| elem == 'src' }
+            route[:interface] = parts[dev_index + 1] if dev_index
+            route[:ip] = parts[src_index + 1] if src_index
+            route
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/socket_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class SocketParser
+        class << self
+          def retrieve_interfaces(logger)
+            require 'socket'
+            @interfaces = {}
+            @log = logger
+            Socket.getifaddrs.each do |ifaddr|
+              populate_interface_info(ifaddr)
+            end
+
+            @interfaces
+          end
+
+          private
+
+          def populate_interface_info(ifaddr)
+            interface_name = ifaddr.name
+            @interfaces[interface_name] = {} if @interfaces[interface_name].nil?
+
+            mac(ifaddr)
+            ip_info_of(ifaddr)
+          end
+
+          def mac(ifaddr)
+            return unless @interfaces[ifaddr.name][:mac].nil?
+
+            mac = search_for_mac(ifaddr)
+            @interfaces[ifaddr.name][:mac] = mac if mac
+          end
+
+          def search_for_mac(ifaddr)
+            mac = mac_from_bonded_interface(ifaddr.name)
+            mac ||= mac_from(ifaddr)
+            mac if !mac.nil? && mac != '00:00:00:00:00:00' && mac =~ /^([0-9A-Fa-f]{2}[:-]){5,19}([0-9A-Fa-f]{2})$/
+          end
+
+          def mac_from_bonded_interface(interface_name)
+            master = bond_master_of(interface_name)
+            return unless master
+
+            output = Facter::Util::FileHelper.safe_read("/proc/net/bonding/#{master}", nil)
+            return unless output
+
+            found_match = false
+            output.each_line do |line|
+              if line.strip == "Slave Interface: #{interface_name}"
+                found_match = true
+              elsif line.include? 'Slave Interface'
+                # if we reached the data block of another interface belonging to the bonded interface
+                found_match = false
+              end
+              return Regexp.last_match(1) if found_match && line =~ /Permanent HW addr: (\S*)/
+            end
+          end
+
+          def bond_master_of(interface_name)
+            content = Facter::Core::Execution.execute("ip link show #{interface_name}", logger: @log)
+            content.match(/master (\S*) /)&.captures&.first
+          end
+
+          def mac_from(ifaddr)
+            if Socket.const_defined? :PF_LINK
+              ifaddr.addr&.getnameinfo&.first # sometimes it returns localhost or ip
+            elsif Socket.const_defined? :PF_PACKET
+              return if ifaddr.addr.nil?
+
+              mac_from_sockaddr_of(ifaddr)
+            end
+          rescue StandardError => e
+            @log.debug("Could not read mac for interface #{ifaddr.name}, got #{e}")
+          end
+
+          def mac_from_sockaddr_of(ifaddr)
+            result = ifaddr.addr.inspect_sockaddr
+            result&.match(/hwaddr=([\h:]+)/)&.captures&.first
+          end
+
+          def ip_info_of(ifaddr)
+            return if ifaddr.addr.nil? || ifaddr.netmask.nil?
+
+            add_binding(ifaddr.name, ifaddr)
+          rescue StandardError => e
+            @log.debug("Could not read binding data, got #{e}")
+          end
+
+          def add_binding(interface_name, ifaddr)
+            ip, netmask, binding_key = binding_data(ifaddr)
+            binding = Facter::Util::Resolvers::Networking.build_binding(ip, netmask)
+            return if binding.nil?
+
+            @interfaces[interface_name][binding_key] = [] if @interfaces[interface_name][binding_key].nil?
+            @interfaces[interface_name][binding_key] << binding
+
+            @log.debug("Adding to interface #{interface_name}, binding:\n#{binding}")
+          end
+
+          def binding_data(ifaddr)
+            # ipv6 ips are retrieved as <ip>%<interface_name>
+            ip = ifaddr.addr.ip_address.split('%').first
+            netmask = ifaddr.netmask.ip_address
+            binding_key = ifaddr.addr.ipv4? ? :bindings : :bindings6
+
+            [ip, netmask, binding_key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/resolvers/ffi/hostname.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Util
+    module Resolvers
+      module Ffi
+        class AddrInfo < ::FFI::Struct
+          layout  :ai_flags, :int,
+                  :ai_family, :int,
+                  :ai_socketype, :int,
+                  :ai_protocol, :int,
+                  :ai_addrlen, :uint,
+                  :ai_addr, :pointer,
+                  :ai_canonname, :string,
+                  :ai_next, :pointer
+        end
+
+        module Hostname
+          HOST_NAME_MAX = 64
+
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC
+
+          attach_function :getaddrinfo, %i[string string pointer pointer], :int
+          attach_function :gethostname, %i[pointer int], :int
+          attach_function :freeaddrinfo, [:pointer], :void
+
+          def self.getffihostname
+            raw_hostname = ::FFI::MemoryPointer.new(:char, HOST_NAME_MAX)
+
+            res = Hostname.gethostname(raw_hostname, HOST_NAME_MAX)
+            return unless res.zero?
+
+            raw_hostname.read_string
+          end
+
+          def self.getffiaddrinfo(hostname) # rubocop:disable  Metrics/AbcSize
+            ret = FFI::MemoryPointer.new(:pointer)
+
+            hints = Facter::Util::Resolvers::Ffi::AddrInfo.new
+            hints[:ai_family] = Socket::AF_UNSPEC
+            hints[:ai_socketype] = Socket::SOCK_STREAM
+            hints[:ai_flags] = Socket::AI_CANONNAME
+
+            res = Hostname.getaddrinfo(hostname, '', hints.to_ptr, ret)
+            log = Log.new(self)
+            log.debug("FFI Getaddrinfo finished with exit status: #{res}")
+            log.debug("FFI Getaddrinfo returned an AddrInfo struct at address: #{ret}")
+            return unless res.zero?
+
+            return if ret == FFI::Pointer::NULL || ret.read_pointer == FFI::Pointer::NULL
+
+            begin
+              addr = Facter::Util::Resolvers::Ffi::AddrInfo.new(ret.read_pointer)
+              name = addr[:ai_canonname]
+              log.debug("FFI AddrInfo struct has the fqdn: #{name}")
+              return if !name || hostname == name
+
+              name
+            ensure
+              Hostname.freeaddrinfo(ret.read_pointer)
+            end
+          end
+        end
+      end
+    end
+  end
+end