facter 4.0.41 → 4.0.47

data/lib/facter/util/resolvers/fingerprint.rb

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

data/lib/facter/{resolvers/utils → util/resolvers}/http.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Facter
-  module Resolvers
-    module Utils
+  module Util
+    module Resolvers
       module Http
         @log = Facter::Log.new(self)
 
@@ -27,6 +27,10 @@ module Facter
             make_request(url, headers, timeouts, 'GET')
           end
 
+          def put_request(url, headers = {}, timeouts = {})
+            make_request(url, headers, timeouts, 'PUT')
+          end
+
           private
 
           def make_request(url, headers, timeouts, request_type)
@@ -37,8 +41,10 @@ module Facter
             request = request_obj(headers, uri, request_type)
 
             # Make the request
-            resp = http.request(request)
-            response_code_valid?(resp.code.to_i) ? resp.body : ''
+            response = http.request(request)
+            response.uri = url
+
+            successful_response?(response) ? response.body : ''
           rescue StandardError => e
             @log.debug("Trying to connect to #{url} but got: #{e.message}")
             ''
@@ -52,14 +58,15 @@ module Facter
           end
 
           def request_obj(headers, parsed_url, request_type)
-            return Net::HTTP::Get.new(parsed_url.request_uri, headers) if request_type == 'GET'
-
-            raise StandardError("Unknown http request type: #{request_type}")
+            Module.const_get("Net::HTTP::#{request_type.capitalize}").new(parsed_url.request_uri, headers)
           end
 
-          def response_code_valid?(http_code)
-            @log.debug("Request failed with error code #{http_code}") unless http_code.equal?(200)
-            http_code.equal?(200)
+          def successful_response?(response)
+            success = response.code.to_i.equal?(200)
+
+            @log.debug("Request to #{response.uri} failed with error code #{response.code}") unless success
+
+            success
           end
         end
       end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Util
+    module Resolvers
+      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)
+            return if !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
+end

data/lib/facter/util/resolvers/networking/dhcp.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Networking
+        module Dhcp
+          class << self
+            def get(interface_name, log = nil)
+              dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
+              result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
+              result.chomp!
+
+              result.empty? ? nil : result
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Util
+    module Resolvers
+      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)
+            return if !addr || !mask_length
+
+            ip = IPAddr.new(addr)
+            mask_helper = nil
+            scope = nil
+            if ip.ipv6?
+              scope = get_scope(addr)
+              mask_helper = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+            else
+              mask_helper = '255.255.255.255'
+            end
+            mask = IPAddr.new(mask_helper).mask(mask_length)
+
+            result = { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+            result[:scope6] = scope if scope
+            result
+          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
+
+          def calculate_mask_length(netmask)
+            ipaddr = IPAddr.new(netmask)
+
+            ipaddr.to_i.to_s(2).count('1')
+          end
+
+          def format_mac_address(address)
+            address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
+          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
+end

data/lib/facter/util/resolvers/networking/primary_interface.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Networking
+        module PrimaryInterface
+          @log ||= Log.new(self)
+
+          class << self
+            ROUTE_TABLE_MAPPING = {
+              'Iface' => 0,
+              'Destination' => 1,
+              'Gateway' => 2,
+              'Flags' => 3,
+              'RefCnt' => 4,
+              'Use' => 5,
+              'Metric' => 6,
+              'Mask' => 7,
+              'MTU' => 8,
+              'Window' => 9,
+              'IRTT' => 10
+            }.freeze
+
+            def read_from_route
+              return if Facter::Core::Execution.which('route').nil?
+
+              result = Facter::Core::Execution.execute('route -n get default', logger: @log)
+
+              result.match(/interface: (.+)/)&.captures&.first
+            end
+
+            def read_from_proc_route
+              content = Facter::Util::FileHelper.safe_read('/proc/net/route', '')
+
+              content.each_line.with_index do |line, index|
+                next if index.zero?
+
+                route = line.strip.split("\t")
+                if route.count > 7 &&
+                   route[ROUTE_TABLE_MAPPING['Destination']] == '00000000' &&
+                   route[ROUTE_TABLE_MAPPING['Mask']] == '00000000'
+                  return route[ROUTE_TABLE_MAPPING['Iface']]
+                end
+              end
+
+              nil
+            end
+
+            def read_from_ip_route
+              return if Facter::Core::Execution.which('ip').nil?
+
+              output = Facter::Core::Execution.execute('ip route show default', logger: @log)
+              primary_interface = nil
+              output.each_line do |line|
+                primary_interface = line.strip.split(' ')[4] if line.start_with?('default')
+              end
+
+              primary_interface
+            end
+
+            def find_in_interfaces(interfaces)
+              interfaces.each do |iface_name, interface|
+                interface[:bindings]&.each do |binding|
+                  return iface_name unless Facter::Util::Resolvers::Networking.ignored_ip_address(binding[:address])
+                end
+
+                next unless interface[:bindings6]
+
+                interface[:bindings6].each do |binding|
+                  return iface_name unless Facter::Util::Resolvers::Networking.ignored_ip_address(binding[:address])
+                end
+              end
+
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/resolvers/ssh.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      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
+  end
+end

data/lib/facter/util/resolvers/ssh_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/sha1'
+
+module Facter
+  module Util
+    module Resolvers
+      class SshHelper
+        class << self
+          SSH_NAME = { 'ssh-dss' => 'dsa', 'ecdsa-sha2-nistp256' => 'ecdsa',
+                       'ssh-ed25519' => 'ed25519', 'ssh-rsa' => 'rsa' }.freeze
+          SSH_FINGERPRINT = { 'rsa' => 1, 'dsa' => 2, 'ecdsa' => 3, 'ed25519' => 4 }.freeze
+
+          def create_ssh(key_type, key)
+            key_name = SSH_NAME[key_type]
+            return unless key_name
+
+            decoded_key = Base64.decode64(key)
+            ssh_fp = SSH_FINGERPRINT[key_name]
+            sha1 = "SSHFP #{ssh_fp} 1 #{Digest::SHA1.new.update(decoded_key)}"
+            sha256 = "SSHFP #{ssh_fp} 2 #{Digest::SHA2.new.update(decoded_key)}"
+
+            fingerprint = Facter::Util::Resolvers::FingerPrint.new(sha1, sha256)
+            Facter::Util::Resolvers::Ssh.new(fingerprint, key_type, key, key_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/{resolvers/utils → util/resolvers}/uptime_helper.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Facter
-  module Resolvers
-    module Utils
+  module Util
+    module Resolvers
       module UptimeHelper
         class << self
           def create_uptime_hash(seconds)

data/lib/facter/util/windows/win32ole.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'win32ole'
+
+module Facter
+  module Util
+    module Windows
+      class Win32Ole
+        RPC_C_IMP_LEVEL_IMPERSONATE = 3
+
+        def initialize
+          locator = WIN32OLE.new('WbemScripting.SWbemLocator')
+          @conn = locator.ConnectServer('.', 'root\\cimv2')
+          @conn.Security_.ImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE
+        end
+
+        def return_first(query)
+          result = exec_query(query)
+          return result.to_enum.first if result
+
+          nil
+        end
+
+        def exec_query(query)
+          @conn.execquery(query)
+        end
+      end
+    end
+  end
+end