puppet 6.20.0-x64-mingw32 → 7.4.0-x64-mingw32

data/lib/puppet/util/connection.rb

@@ -1,88 +0,0 @@
-require 'puppet'
-require 'puppet/util/warnings'
-
-module Puppet::Util
-  module Connection
-    extend Puppet::Util::Warnings
-
-    # The logic for server and port is kind of gross. In summary:
-    # IF an endpoint-specific setting is requested AND that setting has been set by the user
-    #    Use that setting.
-    #         The defaults for these settings are the "normal" server/serverport settings, so
-    #         when they are unset we instead want to "fall back" to the failover-selected
-    #         host/port pair.
-    # ELSE IF we have a failover-selected host/port
-    #    Use what the failover logic came up with
-    # ELSE IF the server_list setting is in use
-    #    Use the first entry - failover hasn't happened yet, but that
-    #    setting is still authoritative
-    # ELSE
-    #    Go for the legacy server/serverport settings, and hope for the best
-
-    # Determines which server to use based on the specified setting, taking into
-    # account HA fallback from server_list.
-    # @param [Symbol] setting The preferred server setting to use
-    # @return [String] the name of the server for use in the request
-    def self.determine_server(setting)
-      if setting && setting != :server && Puppet.settings.set_by_config?(setting)
-        debug_once _("Selected server from the %{setting} setting: %{server}") % {setting: setting, server: Puppet.settings[setting]}
-        Puppet[setting]
-      else
-        server = Puppet.lookup(:server) do
-          primary_server = Puppet.settings[:server_list][0]
-          if primary_server
-            #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-            debug_once _("Dynamically-bound server lookup failed; using first entry from the `server_list` setting: %{server}") % {server: primary_server[0]}
-            primary_server[0]
-          else
-            setting ||= :server
-            debug_once _("Dynamically-bound server lookup failed, falling back to %{setting} setting: %{server}") % {setting: setting, server: Puppet.settings[setting]}
-            Puppet.settings[setting]
-          end
-        end
-        server
-      end
-    end
-
-    # Determines which port to use based on the specified setting, taking into
-    # account HA fallback from server_list.
-    # For port there's a little bit of an extra snag: setting a specific
-    # server setting and relying on the default port for that server is
-    # common, so we also want to check if the assocaited SERVER setting
-    # has been set by the user. If either of those are set we ignore the
-    # failover-selected port.
-    # @param [Symbol] port_setting The preferred port setting to use
-    # @param [Symbol] server_setting The server setting assoicated with this route.
-    # @return [Integer] the port to use for use in the request
-    def self.determine_port(port_setting, server_setting)
-      if (port_setting && port_setting != :serverport && Puppet.settings.set_by_config?(port_setting)) ||
-         (server_setting && server_setting != :server && Puppet.settings.set_by_config?(server_setting))
-        debug_once _("Selected port from the %{setting} setting: %{port}") % {setting: port_setting, port: Puppet.settings[port_setting].to_i}
-        Puppet.settings[port_setting].to_i
-      else
-        port = Puppet.lookup(:serverport) do
-          primary_server = Puppet.settings[:server_list][0]
-          if primary_server
-            # Port might not be set, so we want to fallback in that
-            # case. We know we don't need to use `setting` here, since
-            # the default value of every port setting is `serverport`
-            if primary_server[1]
-              #TRANSLATORS 'server_list' is the name of a setting and should not be translated
-              debug_once _("Dynamically-bound port lookup failed; using first entry from the `server_list` setting: %{port}") % {port: primary_server[1]}
-              primary_server[1]
-            else
-              #TRANSLATORS 'serverport' is the name of a setting and should not be translated
-              debug_once _("Dynamically-bound port lookup failed; falling back to `serverport` setting: %{port}") % {port: Puppet.settings[:serverport]}
-              Puppet.settings[:serverport]
-            end
-          else
-            port_setting ||= :serverport
-            debug_once _("Dynamically-bound port lookup failed; falling back to %{setting} setting: %{port}") % {setting: port_setting, port: Puppet.settings[port_setting]}
-            Puppet.settings[port_setting]
-          end
-        end
-        port.to_i
-      end
-    end
-  end
-end

data/lib/puppet/util/fact_dif.rb

@@ -1,62 +0,0 @@
-require 'json'
-
-class FactDif
-  def initialize(old_output, new_output, exclude_list = [])
-    @c_facter = JSON.parse(old_output)['values']
-    @next_facter = JSON.parse(new_output)['values']
-    @exclude_list = exclude_list
-    @diff = {}
-  end
-
-  def difs
-    search_hash(@c_facter, [])
-
-    @diff
-  end
-
-  private
-
-  def search_hash(sh, path = [])
-    if sh.is_a?(Hash)
-      sh.each do |k, v|
-        search_hash(v, path.push(k))
-        path.pop
-      end
-    elsif sh.is_a?(Array)
-      sh.each_with_index do |v, index|
-        search_hash(v, path.push(index))
-        path.pop
-      end
-    else
-      compare(path, sh)
-    end
-  end
-
-  def compare(fact_path, old_value)
-    new_value = @next_facter.dig(*fact_path)
-    if different?(new_value, old_value) && !excluded?(fact_path.join('.'))
-      @diff[fact_path.join('.')] = { new_value: new_value, old_value: old_value }
-    end
-  end
-
-  def different?(new, old)
-    if old.is_a?(String) && new.is_a?(String)
-      old_values = old.split(',')
-      new_values = new.split(',')
-
-      diff = old_values - new_values
-      # also add new entries only available in Facter 4
-      diff.concat(new_values - old_values)
-
-      return true if diff.any?
-
-      return false
-    end
-
-    old != new
-  end
-
-  def excluded?(fact_name)
-    @exclude_list.any? {|excluded_fact| fact_name =~ /#{excluded_fact}/}
-  end
-end

data/lib/puppet/util/ssl.rb

@@ -1,83 +0,0 @@
-require 'puppet/ssl/openssl_loader'
-
-##
-# SSL is a private module with class methods that help work with x.509
-# subjects and errors.
-#
-# @api private
-module Puppet::Util::SSL
-
-  @@dn_parsers = nil
-  @@no_name = nil
-
-  # Given a DN string, parse it into an OpenSSL certificate subject.  This
-  # method will flexibly handle both OpenSSL and RFC2253 formats, as given by
-  # nginx and Apache, respectively.
-  #
-  # @param [String] dn the x.509 Distinguished Name (DN) string.
-  #
-  # @return [OpenSSL::X509::Name] the certificate subject
-  def self.subject_from_dn(dn)
-    if is_possibly_valid_dn?(dn)
-      parsers = @@dn_parsers ||= [
-            OpenSSL::X509::Name.method(:parse_rfc2253),
-            OpenSSL::X509::Name.method(:parse_openssl)
-        ]
-      parsers.each do |parser|
-        begin
-          return parser.call(dn)
-        rescue OpenSSL::X509::NameError
-        end
-      end
-    end
-
-    @@no_name ||= OpenSSL::X509::Name.new
-  end
-
-  ##
-  # cn_from_subject extracts the CN from the given OpenSSL certificate
-  # subject.
-  #
-  # @api private
-  #
-  # @param [OpenSSL::X509::Name] subject the subject to extract the CN field from
-  #
-  # @return [String, nil] the CN, or nil if not found
-  def self.cn_from_subject(subject)
-    if subject.respond_to? :to_a
-      (subject.to_a.assoc('CN') || [])[1]
-    end
-  end
-
-  def self.is_possibly_valid_dn?(dn)
-    dn =~ /=/
-  end
-
-  ##
-  # Extract and format meaningful error messages from OpenSSL::OpenSSLErrors
-  # and a Validator. Re-raises the error if unknown.
-  #
-  # @api private
-  #
-  # @param [OpenSSL::OpenSSLError] error An error thrown during creating a
-  #   connection
-  # @param [Puppet::SSL::DefaultValidator] verifier A Validator who may have
-  #   invalidated the connection
-  # @param [String] host The DNS name of the other end of the SSL connection
-  #
-  # @raises [Puppet::Error, OpenSSL::OpenSSLError]
-  def self.handle_connection_error(error, verifier, host)
-    # can be nil
-    peer_cert = verifier.peer_certs.last
-
-    if error.message.include? "certificate verify failed"
-      msg = error.message
-      msg << ": [" + verifier.verify_errors.join('; ') + "]"
-      raise Puppet::Error, msg, error.backtrace
-    elsif peer_cert && !OpenSSL::SSL.verify_certificate_identity(peer_cert, host)
-      raise Puppet::SSL::CertMismatchError.new(peer_cert, host)
-    else
-      raise error
-    end
-  end
-end

data/lib/puppet/util/windows/api_types.rb

@@ -1,309 +0,0 @@
-require 'ffi'
-require 'puppet/util/windows/string'
-
-module Puppet::Util::Windows::APITypes
-  module ::FFI
-    WIN32_FALSE = 0
-
-    # standard Win32 error codes
-    ERROR_SUCCESS = 0
-  end
-
-  module ::FFI::Library
-    # Wrapper method for attach_function + private
-    def attach_function_private(*args)
-      attach_function(*args)
-      private args[0]
-    end
-  end
-
-  class ::FFI::Pointer
-    NULL_HANDLE = 0
-    WCHAR_NULL = "\0\0".encode('UTF-16LE').freeze
-
-    def self.from_string_to_wide_string(str, &block)
-      str = Puppet::Util::Windows::String.wide_string(str)
-      FFI::MemoryPointer.from_wide_string(str, &block)
-
-      # ptr has already had free called, so nothing to return
-      nil
-    end
-
-    def read_win32_bool
-      # BOOL is always a 32-bit integer in Win32
-      # some Win32 APIs return 1 for true, while others are non-0
-      read_int32 != FFI::WIN32_FALSE
-    end
-
-    alias_method :read_dword, :read_uint32
-    alias_method :read_win32_ulong, :read_uint32
-    alias_method :read_qword, :read_uint64
-
-    alias_method :read_hresult, :read_int32
-
-    def read_handle
-      type_size == 4 ? read_uint32 : read_uint64
-    end
-
-    alias_method :read_wchar, :read_uint16
-    alias_method :read_word,  :read_uint16
-    alias_method :read_array_of_wchar, :read_array_of_uint16
-
-    def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, strip = false, encode_options = {})
-      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
-      str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-
-      if strip
-        i = str.index(WCHAR_NULL)
-        str = str[0, i] if i
-      end
-
-      str.encode(dst_encoding, str.encoding, encode_options)
-    rescue EncodingError => e
-      Puppet.debug { "Unable to convert value #{str.nil? ? 'nil' : str.dump} to encoding #{dst_encoding} due to #{e.inspect}" }
-      raise
-    end
-
-    # @param max_char_length [Integer] Maximum number of wide chars to return (typically excluding NULLs), *not* bytes
-    # @param null_terminator [Symbol] Number of number of null wchar characters, *not* bytes, that determine the end of the string
-    #   null_terminator = :single_null, then the terminating sequence is two bytes of zero.   This is UNIT16 = 0
-    #   null_terminator = :double_null, then the terminating sequence is four bytes of zero.  This is UNIT32 = 0
-    # @param encode_options [Hash] Accepts the same option hash that may be passed to String#encode in Ruby
-    def read_arbitrary_wide_string_up_to(max_char_length = 512, null_terminator = :single_null, encode_options = {})
-      idx = case null_terminator
-            when :single_null
-              # find index of wide null between 0 and max (exclusive)
-              (0...max_char_length).find do |i|
-                get_uint16(i * 2) == 0
-              end
-            when :double_null
-              # find index of double-wide null between 0 and max - 1 (exclusive)
-              (0...max_char_length - 1).find do |i|
-                get_uint32(i * 2) == 0
-              end
-            else
-              raise _("Unable to read wide strings with %{null_terminator} terminal nulls") % { null_terminator: null_terminator }
-            end
-
-      read_wide_string(idx || max_char_length, Encoding::UTF_8, false, encode_options)
-    end
-
-    def read_win32_local_pointer(&block)
-      ptr = read_pointer
-      begin
-        yield ptr
-      ensure
-        if !ptr.null? && FFI::WIN32::LocalFree(ptr.address) != FFI::Pointer::NULL_HANDLE
-          Puppet.debug "LocalFree memory leak"
-        end
-      end
-
-      # ptr has already had LocalFree called, so nothing to return
-      nil
-    end
-
-    def read_com_memory_pointer(&block)
-      ptr = read_pointer
-      begin
-        yield ptr
-      ensure
-        FFI::WIN32::CoTaskMemFree(ptr) unless ptr.null?
-      end
-
-      # ptr has already had CoTaskMemFree called, so nothing to return
-      nil
-    end
-
-    alias_method :write_dword, :write_uint32
-    alias_method :write_word, :write_uint16
-  end
-
-  class FFI::MemoryPointer
-    # Return a MemoryPointer that points to wide string. This is analogous to the
-    # FFI::MemoryPointer.from_string method.
-    def self.from_wide_string(wstr)
-      ptr = FFI::MemoryPointer.new(:uchar, wstr.bytesize + 2)
-      ptr.put_array_of_uchar(0, wstr.bytes.to_a)
-      ptr.put_uint16(wstr.bytesize, 0)
-
-      yield ptr if block_given?
-
-      ptr
-    end
-  end
-
-  # FFI Types
-  # https://github.com/ffi/ffi/wiki/Types
-
-  # Windows - Common Data Types
-  # https://msdn.microsoft.com/en-us/library/cc230309.aspx
-
-  # Windows Data Types
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
-
-  FFI.typedef :uint16, :word
-  FFI.typedef :uint32, :dword
-  # uintptr_t is defined in an FFI conf as platform specific, either
-  # ulong_long on x64 or just ulong on x86
-  FFI.typedef :uintptr_t, :handle
-  FFI.typedef :uintptr_t, :hwnd
-
-  # buffer_inout is similar to pointer (platform specific), but optimized for buffers
-  FFI.typedef :buffer_inout, :lpwstr
-  # buffer_in is similar to pointer (platform specific), but optimized for CONST read only buffers
-  FFI.typedef :buffer_in, :lpcwstr
-  FFI.typedef :buffer_in, :lpcolestr
-
-  # string is also similar to pointer, but should be used for const char *
-  # NOTE that this is not wide, useful only for A suffixed functions
-  FFI.typedef :string, :lpcstr
-
-  # pointer in FFI is platform specific
-  # NOTE: for API calls with reserved lpvoid parameters, pass a FFI::Pointer::NULL
-  FFI.typedef :pointer, :lpcvoid
-  FFI.typedef :pointer, :lpvoid
-  FFI.typedef :pointer, :lpword
-  FFI.typedef :pointer, :lpbyte
-  FFI.typedef :pointer, :lpdword
-  FFI.typedef :pointer, :pdword
-  FFI.typedef :pointer, :phandle
-  FFI.typedef :pointer, :ulong_ptr
-  FFI.typedef :pointer, :pbool
-  FFI.typedef :pointer, :lpunknown
-
-  # any time LONG / ULONG is in a win32 API definition DO NOT USE platform specific width
-  # which is what FFI uses by default
-  # instead create new aliases for these very special cases
-  # NOTE: not a good idea to redefine FFI :ulong since other typedefs may rely on it
-  FFI.typedef :uint32, :win32_ulong
-  FFI.typedef :int32, :win32_long
-  # FFI bool can be only 1 byte at times,
-  # Win32 BOOL is a signed int, and is always 4 bytes, even on x64
-  # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
-  FFI.typedef :int32, :win32_bool
-
-  # BOOLEAN (unlike BOOL) is a BYTE - typedef unsigned char BYTE;
-  FFI.typedef :uchar, :boolean
-
-  # Same as a LONG, a 32-bit signed integer
-  FFI.typedef :int32, :hresult
-
-  # NOTE: FFI already defines (u)short as a 16-bit (un)signed like this:
-  # FFI.typedef :uint16, :ushort
-  # FFI.typedef :int16, :short
-
-  # 8 bits per byte
-  FFI.typedef :uchar, :byte
-  FFI.typedef :uint16, :wchar
-
-  # Definitions for data types used in LSA structures and functions
-  # https://docs.microsoft.com/en-us/windows/win32/api/ntsecapi/
-  # https://docs.microsoft.com/sr-latn-rs/windows/win32/secmgmt/management-data-types
-  FFI.typedef :pointer, :pwstr
-  FFI.typedef :pointer, :pulong
-  FFI.typedef :pointer, :lsa_handle
-  FFI.typedef :pointer, :plsa_handle
-  FFI.typedef :pointer, :psid
-  FFI.typedef :pointer, :pvoid
-  FFI.typedef :pointer, :plsa_unicode_string
-  FFI.typedef :pointer, :plsa_object_attributes
-  FFI.typedef :uint32,  :ntstatus
-  FFI.typedef :dword,   :access_mask
-
-  module ::FFI::WIN32
-    extend ::FFI::Library
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa373931(v=vs.85).aspx
-    # typedef struct _GUID {
-    #   DWORD Data1;
-    #   WORD  Data2;
-    #   WORD  Data3;
-    #   BYTE  Data4[8];
-    # } GUID;
-    class GUID < FFI::Struct
-      layout :Data1, :dword,
-             :Data2, :word,
-             :Data3, :word,
-             :Data4, [:byte, 8]
-
-      def self.[](s)
-        raise _('Bad GUID format.') unless s =~ /^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i
-
-        new.tap do |guid|
-          guid[:Data1] = s[0, 8].to_i(16)
-          guid[:Data2] = s[9, 4].to_i(16)
-          guid[:Data3] = s[14, 4].to_i(16)
-          guid[:Data4][0] = s[19, 2].to_i(16)
-          guid[:Data4][1] = s[21, 2].to_i(16)
-          s[24, 12].split('').each_slice(2).with_index do |a, i|
-            guid[:Data4][i + 2] = a.join('').to_i(16)
-          end
-        end
-      end
-
-      def ==(other) Windows.memcmp(other, self, size) == 0 end
-    end
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx
-    # typedef struct _SYSTEMTIME {
-    #   WORD wYear;
-    #   WORD wMonth;
-    #   WORD wDayOfWeek;
-    #   WORD wDay;
-    #   WORD wHour;
-    #   WORD wMinute;
-    #   WORD wSecond;
-    #   WORD wMilliseconds;
-    # } SYSTEMTIME, *PSYSTEMTIME;
-    class SYSTEMTIME < FFI::Struct
-      layout :wYear, :word,
-             :wMonth, :word,
-             :wDayOfWeek, :word,
-             :wDay, :word,
-             :wHour, :word,
-             :wMinute, :word,
-             :wSecond, :word,
-             :wMilliseconds, :word
-
-      def to_local_time
-        Time.local(self[:wYear], self[:wMonth], self[:wDay],
-          self[:wHour], self[:wMinute], self[:wSecond], self[:wMilliseconds] * 1000)
-      end
-    end
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724284(v=vs.85).aspx
-    # Contains a 64-bit value representing the number of 100-nanosecond
-    # intervals since January 1, 1601 (UTC).
-    # typedef struct _FILETIME {
-    #   DWORD dwLowDateTime;
-    #   DWORD dwHighDateTime;
-    # } FILETIME, *PFILETIME;
-    class FILETIME < FFI::Struct
-      layout :dwLowDateTime, :dword,
-             :dwHighDateTime, :dword
-    end
-
-    ffi_convention :stdcall
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa366730(v=vs.85).aspx
-    # HLOCAL WINAPI LocalFree(
-    #   _In_  HLOCAL hMem
-    # );
-    ffi_lib :kernel32
-    attach_function :LocalFree, [:handle], :handle
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms724211(v=vs.85).aspx
-    # BOOL WINAPI CloseHandle(
-    #   _In_  HANDLE hObject
-    # );
-    ffi_lib :kernel32
-    attach_function_private :CloseHandle, [:handle], :win32_bool
-
-    # https://msdn.microsoft.com/en-us/library/windows/desktop/ms680722(v=vs.85).aspx
-    # void CoTaskMemFree(
-    #   _In_opt_  LPVOID pv
-    # );
-    ffi_lib :ole32
-    attach_function :CoTaskMemFree, [:lpvoid], :void
-  end
-end