puppet 8.3.1-universal-darwin → 8.5.0-universal-darwin

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/ffi/windows'
 
 module Puppet::Util::Windows::File
@@ -28,6 +29,7 @@ module Puppet::Util::Windows::File
     )
 
     return true if result != FFI::WIN32_FALSE
+
     raise Puppet::Util::Windows::Error.new("ReplaceFile(#{target}, #{source})")
   end
   module_function :replace_file
@@ -38,18 +40,21 @@ module Puppet::Util::Windows::File
                          flags)
 
     return true if result != FFI::WIN32_FALSE
-    raise Puppet::Util::Windows::Error.
-      new("MoveFileEx(#{source}, #{target}, #{flags.to_s(8)})")
+
+    raise Puppet::Util::Windows::Error
+      .new("MoveFileEx(#{source}, #{target}, #{flags.to_s(8)})")
   end
   module_function :move_file_ex
 
   def symlink(target, symlink)
     flags = File.directory?(target) ? 0x1 : 0x0
     result = CreateSymbolicLinkW(wide_string(symlink.to_s),
-      wide_string(target.to_s), flags)
+                                 wide_string(target.to_s), flags)
     return true if result != FFI::WIN32_FALSE
+
     raise Puppet::Util::Windows::Error.new(
-      "CreateSymbolicLink(#{symlink}, #{target}, #{flags.to_s(8)})")
+      "CreateSymbolicLink(#{symlink}, #{target}, #{flags.to_s(8)})"
+    )
   end
   module_function :symlink
 
@@ -59,11 +64,11 @@ module Puppet::Util::Windows::File
 
     seen_paths = []
     # follow up to 64 symlinks before giving up
-    0.upto(64) do |depth|
+    0.upto(64) do |_depth|
       # return false if this path has been seen before.  This is protection against circular symlinks
       return false if seen_paths.include?(path.downcase)
 
-      result = get_attributes(path,false)
+      result = get_attributes(path, false)
 
       # return false for path not found
       return false if result == INVALID_FILE_ATTRIBUTES
@@ -121,20 +126,22 @@ module Puppet::Util::Windows::File
   end
   module_function :set_attributes
 
-  #define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
+  # define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
   INVALID_HANDLE_VALUE = FFI::Pointer.new(-1).address
   def self.create_file(file_name, desired_access, share_mode, security_attributes,
-    creation_disposition, flags_and_attributes, template_file_handle)
+                       creation_disposition, flags_and_attributes, template_file_handle)
 
     result = CreateFileW(wide_string(file_name.to_s),
-      desired_access, share_mode, security_attributes, creation_disposition,
-      flags_and_attributes, template_file_handle)
+                         desired_access, share_mode, security_attributes, creation_disposition,
+                         flags_and_attributes, template_file_handle)
 
     return result unless result == INVALID_HANDLE_VALUE
+
     raise Puppet::Util::Windows::Error.new(
-      "CreateFile(#{file_name}, #{desired_access.to_s(8)}, #{share_mode.to_s(8)}, " +
-        "#{security_attributes}, #{creation_disposition.to_s(8)}, " +
-        "#{flags_and_attributes.to_s(8)}, #{template_file_handle})")
+      "CreateFile(#{file_name}, #{desired_access.to_s(8)}, #{share_mode.to_s(8)}, " \
+      "#{security_attributes}, #{creation_disposition.to_s(8)}, " \
+      "#{flags_and_attributes.to_s(8)}, #{template_file_handle})"
+    )
   end
 
   def self.get_reparse_point_data(handle, &block)
@@ -144,16 +151,16 @@ module Puppet::Util::Windows::File
 
       reparse_tag = reparse_data_buffer_ptr.read_win32_ulong
       buffer_type = case reparse_tag
-      when IO_REPARSE_TAG_SYMLINK
-        SYMLINK_REPARSE_DATA_BUFFER
-      when IO_REPARSE_TAG_MOUNT_POINT
-        MOUNT_POINT_REPARSE_DATA_BUFFER
-      when IO_REPARSE_TAG_NFS
-        raise Puppet::Util::Windows::Error.new("Retrieving NFS reparse point data is unsupported")
-      else
-        raise Puppet::Util::Windows::Error.new("DeviceIoControl(#{handle}, " +
-          "FSCTL_GET_REPARSE_POINT) returned unknown tag 0x#{reparse_tag.to_s(16).upcase}")
-      end
+                    when IO_REPARSE_TAG_SYMLINK
+                      SYMLINK_REPARSE_DATA_BUFFER
+                    when IO_REPARSE_TAG_MOUNT_POINT
+                      MOUNT_POINT_REPARSE_DATA_BUFFER
+                    when IO_REPARSE_TAG_NFS
+                      raise Puppet::Util::Windows::Error.new("Retrieving NFS reparse point data is unsupported")
+                    else
+                      raise Puppet::Util::Windows::Error.new("DeviceIoControl(#{handle}, " \
+                                                             "FSCTL_GET_REPARSE_POINT) returned unknown tag 0x#{reparse_tag.to_s(16).upcase}")
+                    end
 
       yield buffer_type.new(reparse_data_buffer_ptr)
     end
@@ -193,9 +200,10 @@ module Puppet::Util::Windows::File
 
       if result == FFI::WIN32_FALSE
         raise Puppet::Util::Windows::Error.new(
-          "DeviceIoControl(#{handle}, #{io_control_code}, " +
-          "#{in_buffer}, #{in_buffer ? in_buffer.size : ''}, " +
-          "#{out_buffer}, #{out_buffer ? out_buffer.size : ''}")
+          "DeviceIoControl(#{handle}, #{io_control_code}, " \
+          "#{in_buffer}, #{in_buffer ? in_buffer.size : ''}, " \
+          "#{out_buffer}, #{out_buffer ? out_buffer.size : ''}"
+        )
       end
     end
 
@@ -206,6 +214,7 @@ module Puppet::Util::Windows::File
     attributes = get_attributes(file_name, false)
 
     return false if (attributes == INVALID_FILE_ATTRIBUTES)
+
     (attributes & FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_REPARSE_POINT
   end
   module_function :reparse_point?
@@ -219,13 +228,14 @@ module Puppet::Util::Windows::File
   def self.open_symlink(link_name)
     begin
       yield handle = create_file(
-      link_name,
-      GENERIC_READ,
-      FILE_SHARE_READ,
-      nil, # security_attributes
-      OPEN_EXISTING,
-      FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
-      0) # template_file
+        link_name,
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        nil, # security_attributes
+        OPEN_EXISTING,
+        FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
+        0
+      ) # template_file
     ensure
       FFI::WIN32.CloseHandle(handle) if handle
     end

data/lib/puppet/util/windows/monkey_patches/process.rb

@@ -29,7 +29,6 @@ module Process
   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX)
 
   class << self
-
     private :SetHandleInformation, :SetErrorMode, :CreateProcessW, :OpenProcess,
             :SetPriorityClass, :CreateProcessWithLogonW, :get_osfhandle, :get_errno
 
@@ -185,7 +184,7 @@ module Process
       raise TypeError unless int_priority.is_a?(Integer)
 
       int = Process.pid if int == 0
-      handle = OpenProcess(PROCESS_SET_INFORMATION, 0 , int)
+      handle = OpenProcess(PROCESS_SET_INFORMATION, 0, int)
 
       if handle == 0
         raise SystemCallError, FFI.errno, "OpenProcess"

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows'
 
 module Puppet::Util::Windows::SID
@@ -21,7 +22,7 @@ module Puppet::Util::Windows::SID
       if (domain && !domain.empty? && @account_type == :SidTypeDomain)
         @domain_account = @domain
       elsif (domain && !domain.empty?)
-        @domain_account =  "#{domain}\\#{@account}"
+        @domain_account = "#{domain}\\#{@account}"
       else
         @domain_account = account
       end
@@ -59,28 +60,28 @@ module Puppet::Util::Windows::SID
             FFI::MemoryPointer.new(:dword, 1) do |sid_length_ptr|
               FFI::MemoryPointer.new(:dword, 1) do |domain_length_ptr|
                 FFI::MemoryPointer.new(:uint32, 1) do |name_use_enum_ptr|
+                  sid_length_ptr.write_dword(MAXIMUM_SID_BYTE_LENGTH)
+                  success = LookupAccountNameW(system_name_ptr, account_name_ptr, sid_ptr, sid_length_ptr,
+                                               FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
+                  last_error = FFI.errno
 
-                sid_length_ptr.write_dword(MAXIMUM_SID_BYTE_LENGTH)
-                success = LookupAccountNameW(system_name_ptr, account_name_ptr, sid_ptr, sid_length_ptr,
-                  FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
-                last_error = FFI.errno
-
-                if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name}, last_error)
-                end
-
-                FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
-                  if LookupAccountNameW(system_name_ptr, account_name_ptr,
-                      sid_ptr, sid_length_ptr,
-                      domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name} )
+                  if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
+                    raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name }, last_error)
                   end
 
-                  # with a SID returned, loop back through lookup_account_sid to retrieve official name
-                  # necessary when accounts like . or '' are passed in
-                  return lookup_account_sid(
-                    system_name,
-                    sid_ptr.read_bytes(sid_length_ptr.read_dword).unpack('C*'))
+                  FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
+                    if LookupAccountNameW(system_name_ptr, account_name_ptr,
+                                          sid_ptr, sid_length_ptr,
+                                          domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
+                      raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountNameW with account: %{account_name}') % { account_name: account_name })
+                    end
+
+                    # with a SID returned, loop back through lookup_account_sid to retrieve official name
+                    # necessary when accounts like . or '' are passed in
+                    return lookup_account_sid(
+                      system_name,
+                      sid_ptr.read_bytes(sid_length_ptr.read_dword).unpack('C*')
+                    )
                   end
                 end
               end
@@ -95,7 +96,7 @@ module Puppet::Util::Windows::SID
     def self.lookup_account_sid(system_name = nil, sid_bytes)
       system_name_ptr = FFI::Pointer::NULL
       if (sid_bytes.nil? || (!sid_bytes.is_a? Array) || (sid_bytes.length == 0))
-        #TRANSLATORS `lookup_account_sid` is a variable name and should not be translated
+        # TRANSLATORS `lookup_account_sid` is a variable name and should not be translated
         raise Puppet::Util::Windows::Error.new(_('Byte array for lookup_account_sid must not be nil and must be at least 1 byte long'))
       end
 
@@ -109,7 +110,6 @@ module Puppet::Util::Windows::SID
           FFI::MemoryPointer.new(:dword, 1) do |name_length_ptr|
             FFI::MemoryPointer.new(:dword, 1) do |domain_length_ptr|
               FFI::MemoryPointer.new(:uint32, 1) do |name_use_enum_ptr|
-
                 sid_ptr.write_array_of_uchar(sid_bytes)
 
                 if Puppet::Util::Windows::SID.IsValidSid(sid_ptr) == FFI::WIN32_FALSE
@@ -117,18 +117,18 @@ module Puppet::Util::Windows::SID
                 end
 
                 success = LookupAccountSidW(system_name_ptr, sid_ptr, FFI::Pointer::NULL, name_length_ptr,
-                  FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
+                                            FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
                 last_error = FFI.errno
 
                 if (success == FFI::WIN32_FALSE && last_error != ERROR_INSUFFICIENT_BUFFER)
-                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes}, last_error)
+                  raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes }, last_error)
                 end
 
                 FFI::MemoryPointer.new(:lpwstr, name_length_ptr.read_dword) do |name_ptr|
                   FFI::MemoryPointer.new(:lpwstr, domain_length_ptr.read_dword) do |domain_ptr|
                     if LookupAccountSidW(system_name_ptr, sid_ptr, name_ptr, name_length_ptr,
-                        domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
-                     raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes} )
+                                         domain_ptr, domain_length_ptr, name_use_enum_ptr) == FFI::WIN32_FALSE
+                      raise Puppet::Util::Windows::Error.new(_('Failed to call LookupAccountSidW with bytes: %{sid_bytes}') % { sid_bytes: sid_bytes })
                     end
 
                     return new(
@@ -136,7 +136,8 @@ module Puppet::Util::Windows::SID
                       sid_bytes,
                       Puppet::Util::Windows::SID.sid_ptr_to_string(sid_ptr),
                       domain_ptr.read_wide_string(domain_length_ptr.read_dword),
-                      SID_NAME_USE[name_use_enum_ptr.read_uint32])
+                      SID_NAME_USE[name_use_enum_ptr.read_uint32]
+                    )
                   end
                 end
               end
@@ -151,6 +152,7 @@ module Puppet::Util::Windows::SID
     # Sanitize the given account name for lookup to avoid known issues
     def self.sanitize_account_name(account_name)
       return account_name unless account_name.start_with?('APPLICATION PACKAGE AUTHORITY\\')
+
       account_name.split('\\').last
     end
     private_class_method :sanitize_account_name
@@ -183,7 +185,7 @@ module Puppet::Util::Windows::SID
     # );
     ffi_lib :advapi32
     attach_function_private :LookupAccountNameW,
-      [:lpcwstr, :lpcwstr, :pointer, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
+                            [:lpcwstr, :lpcwstr, :pointer, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
 
     # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379166(v=vs.85).aspx
     # BOOL WINAPI LookupAccountSid(
@@ -197,6 +199,6 @@ module Puppet::Util::Windows::SID
     # );
     ffi_lib :advapi32
     attach_function_private :LookupAccountSidW,
-      [:lpcwstr, :pointer, :lpwstr, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
+                            [:lpcwstr, :pointer, :lpwstr, :lpdword, :lpwstr, :lpdword, :pointer], :win32_bool
   end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/util/windows/monkey_patches/process'
 require_relative '../../../puppet/ffi/windows'
 
@@ -46,13 +47,14 @@ module Puppet::Util::Windows::Process
       if GetExitCodeProcess(handle, exit_status_ptr) == FFI::WIN32_FALSE
         raise Puppet::Util::Windows::Error.new(_("Failed to get child process exit code"))
       end
+
       exit_status = exit_status_ptr.read_dword
 
       # $CHILD_STATUS is not set when calling win32/process Process.create
       # and since it's read-only, we can't set it. But we can execute a
       # a shell that simply returns the desired exit status, which has the
       # desired effect.
-      %x{#{ENV['COMSPEC']} /c exit #{exit_status}}
+      %x{#{ENV.fetch('COMSPEC', nil)} /c exit #{exit_status}}
     end
 
     exit_status
@@ -72,7 +74,8 @@ module Puppet::Util::Windows::Process
       phandle = OpenProcess(desired_access, inherit, process_id)
       if phandle == FFI::Pointer::NULL_HANDLE
         raise Puppet::Util::Windows::Error.new(
-          "OpenProcess(#{desired_access.to_s(8)}, #{inherit}, #{process_id})")
+          "OpenProcess(#{desired_access.to_s(8)}, #{inherit}, #{process_id})"
+        )
       end
 
       yield phandle
@@ -92,7 +95,8 @@ module Puppet::Util::Windows::Process
         result = OpenProcessToken(handle, desired_access, token_handle_ptr)
         if result == FFI::WIN32_FALSE
           raise Puppet::Util::Windows::Error.new(
-            "OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})")
+            "OpenProcessToken(#{handle}, #{desired_access.to_s(8)}, #{token_handle_ptr})"
+          )
         end
 
         yield token_handle = token_handle_ptr.read_handle
@@ -134,8 +138,9 @@ module Puppet::Util::Windows::Process
             result = QueryFullProcessImageNameW(phandle, use_win32_path_format, exe_name_ptr, exe_name_length_ptr)
             if result == FFI::WIN32_FALSE
               raise Puppet::Util::Windows::Error.new(
-                      "QueryFullProcessImageNameW(phandle, #{use_win32_path_format}, " +
-                      "exe_name_ptr, #{max_chars}")
+                "QueryFullProcessImageNameW(phandle, #{use_win32_path_format}, " \
+                "exe_name_ptr, #{max_chars}"
+              )
             end
             image_name = exe_name_ptr.read_wide_string(exe_name_length_ptr.read_dword)
           end
@@ -153,11 +158,12 @@ module Puppet::Util::Windows::Process
         wide_string(system_name),
         wide_string(name.to_s),
         luid_ptr
-        )
+      )
 
       if result == FFI::WIN32_FALSE
         raise Puppet::Util::Windows::Error.new(
-          "LookupPrivilegeValue(#{system_name}, #{name}, #{luid_ptr})")
+          "LookupPrivilegeValue(#{system_name}, #{name}, #{luid_ptr})"
+        )
       end
 
       yield LUID.new(luid_ptr)
@@ -176,18 +182,20 @@ module Puppet::Util::Windows::Process
 
       if return_length <= 0
         raise Puppet::Util::Windows::Error.new(
-          "GetTokenInformation(#{token_handle}, #{token_information}, nil, 0, #{return_length_ptr})")
+          "GetTokenInformation(#{token_handle}, #{token_information}, nil, 0, #{return_length_ptr})"
+        )
       end
 
       # re-call API with properly sized buffer for all results
       FFI::MemoryPointer.new(return_length) do |token_information_buf|
         result = GetTokenInformation(token_handle, token_information,
-          token_information_buf, return_length, return_length_ptr)
+                                     token_information_buf, return_length, return_length_ptr)
 
         if result == FFI::WIN32_FALSE
           raise Puppet::Util::Windows::Error.new(
-            "GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " +
-              "#{return_length}, #{return_length_ptr})")
+            "GetTokenInformation(#{token_handle}, #{token_information}, #{token_information_buf}, " \
+            "#{return_length}, #{return_length_ptr})"
+          )
         end
 
         yield token_information_buf
@@ -208,7 +216,7 @@ module Puppet::Util::Windows::Process
 
     # extract each instance of LUID_AND_ATTRIBUTES
     0.upto(privileges[:count] - 1) do |i|
-      privileges[:privileges] <<  LUID_AND_ATTRIBUTES.new(privilege_ptr[i])
+      privileges[:privileges] << LUID_AND_ATTRIBUTES.new(privilege_ptr[i])
     end
 
     privileges
@@ -308,19 +316,19 @@ module Puppet::Util::Windows::Process
 
     # pass :invalid => :replace to the Ruby String#encode to use replacement characters
     pairs = env_ptr.read_arbitrary_wide_string_up_to(65534, :double_null, { :invalid => :replace })
-      .split(?\x00)
-      .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
-      .reject do |env_str|
-        # reject any string containing the Unicode replacement character
-        if env_str.include?("\uFFFD")
-          Puppet.warning(_("Discarding environment variable %{string} which contains invalid bytes") % { string: env_str })
-          true
-        end
-      end
-      .map { |env_pair| env_pair.split('=', 2) }
-    Hash[ pairs ]
+                   .split(?\x00)
+                   .reject { |env_str| env_str.nil? || env_str.empty? || env_str[0] == '=' }
+                   .reject do |env_str|
+                     # reject any string containing the Unicode replacement character
+                     if env_str.include?("\uFFFD")
+                       Puppet.warning(_("Discarding environment variable %{string} which contains invalid bytes") % { string: env_str })
+                       true
+                     end
+                   end
+                   .map { |env_pair| env_pair.split('=', 2) }
+    pairs.to_h
   ensure
-    if env_ptr && ! env_ptr.null?
+    if env_ptr && !env_ptr.null?
       if FreeEnvironmentStringsW(env_ptr) == FFI::WIN32_FALSE
         Puppet.debug "FreeEnvironmentStringsW memory leak"
       end
@@ -329,7 +337,7 @@ module Puppet::Util::Windows::Process
   module_function :get_environment_strings
 
   def set_environment_variable(name, val)
-    raise Puppet::Util::Windows::Error(_('environment variable name must not be nil or empty')) if ! name || name.empty?
+    raise Puppet::Util::Windows::Error(_('environment variable name must not be nil or empty')) if !name || name.empty?
 
     FFI::MemoryPointer.from_string_to_wide_string(name) do |name_ptr|
       if (val.nil?)
@@ -361,5 +369,4 @@ module Puppet::Util::Windows::Process
     windows_major_version >= 6
   end
   module_function :supports_elevated_security?
-
 end