puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

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

@@ -140,7 +140,12 @@ class Puppet::Util::Windows::EventLog
   # @api private
   def from_string_to_wide_string(str, &block)
     str = wide_string(str)
-    FFI::MemoryPointer.from_wide_string(str) { |ptr| yield ptr }
+    FFI::MemoryPointer.new(:uchar, str.bytesize) do |ptr|
+      # uchar here is synonymous with byte
+      ptr.put_array_of_uchar(0, str.bytes.to_a)
+
+      yield ptr
+    end
 
     # ptr has already had free called, so nothing to return
     nil

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

@@ -41,7 +41,6 @@ module Puppet::Util::Windows::SID
     # = 8 + max sub identifiers (15) * 4
     MAXIMUM_SID_BYTE_LENGTH = 68
 
-    ERROR_INVALID_PARAMETER   = 87
     ERROR_INSUFFICIENT_BUFFER = 122
 
     def self.lookup_account_name(system_name = nil, account_name)
@@ -49,7 +48,9 @@ module Puppet::Util::Windows::SID
       begin
         if system_name
           system_name_wide = Puppet::Util::Windows::String.wide_string(system_name)
-          system_name_ptr = FFI::MemoryPointer.from_wide_string(system_name_wide)
+          # uchar here is synonymous with byte
+          system_name_ptr = FFI::MemoryPointer.new(:byte, system_name_wide.bytesize)
+          system_name_ptr.put_array_of_uchar(0, system_name_wide.bytes.to_a)
         end
 
         FFI::MemoryPointer.from_string_to_wide_string(account_name) do |account_name_ptr|
@@ -100,7 +101,9 @@ module Puppet::Util::Windows::SID
       begin
         if system_name
           system_name_wide = Puppet::Util::Windows::String.wide_string(system_name)
-          system_name_ptr = FFI::MemoryPointer.from_wide_string(system_name_wide)
+          # uchar here is synonymous with byte
+          system_name_ptr = FFI::MemoryPointer.new(:byte, system_name_wide.bytesize)
+          system_name_ptr.put_array_of_uchar(0, system_name_wide.bytes.to_a)
         end
 
         FFI::MemoryPointer.new(:byte, sid_bytes.length) do |sid_ptr|
@@ -109,11 +112,6 @@ module Puppet::Util::Windows::SID
               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
-                  raise Puppet::Util::Windows::Error.new(_('Byte array for lookup_account_sid is invalid: %{sid_bytes}') % { sid_bytes: sid_bytes }, ERROR_INVALID_PARAMETER)
-                end
-
                 success = LookupAccountSidW(system_name_ptr, sid_ptr, FFI::Pointer::NULL, name_length_ptr,
                   FFI::Pointer::NULL, domain_length_ptr, name_use_enum_ptr)
                 last_error = FFI.errno

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

@@ -7,39 +7,15 @@ module Puppet::Util::Windows::Process
   extend FFI::Library
 
   WAIT_TIMEOUT = 0x102
-  WAIT_INTERVAL = 200
-  # https://docs.microsoft.com/en-us/windows/desktop/ProcThread/process-creation-flags
-  CREATE_NO_WINDOW = 0x08000000
-  #https://docs.microsoft.com/en-us/windows/desktop/ProcThread/process-security-and-access-rights
-  PROCESS_QUERY_INFORMATION = 0x0400
-  # https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#maximum-path-length-limitation
-  MAX_PATH_LENGTH = 32767
 
   def execute(command, arguments, stdin, stdout, stderr)
-    create_args = {
-      :command_line => command,
-      :startup_info => {
-        :stdin => stdin,
-        :stdout => stdout,
-        :stderr => stderr
-      },
-      :close_handles => false,
-    }
-    if arguments[:suppress_window]
-      create_args[:creation_flags] = CREATE_NO_WINDOW
-    end
-    cwd = arguments[:cwd]
-    if cwd
-      Dir.chdir(cwd) { Process.create(create_args) }
-    else
-      Process.create(create_args)
-    end
+    Process.create( :command_line => command, :startup_info => {:stdin => stdin, :stdout => stdout, :stderr => stderr}, :close_handles => false )
   end
   module_function :execute
 
   def wait_process(handle)
-    while WaitForSingleObject(handle, WAIT_INTERVAL) == WAIT_TIMEOUT
-      sleep(0)
+    while WaitForSingleObject(handle, 0) == WAIT_TIMEOUT
+      sleep(1)
     end
 
     exit_status = -1
@@ -66,26 +42,6 @@ module Puppet::Util::Windows::Process
   end
   module_function :get_current_process
 
-  def open_process(desired_access, inherit_handle, process_id, &block)
-    phandle = nil
-    inherit = inherit_handle ? FFI::WIN32_TRUE : FFI::WIN32_FALSE
-    begin
-      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})")
-      end
-
-      yield phandle
-    ensure
-      FFI::WIN32.CloseHandle(phandle) if phandle
-    end
-
-    # phandle has had CloseHandle called against it, so nothing to return
-    nil
-  end
-  module_function :open_process
-
   def open_process_token(handle, desired_access, &block)
     token_handle = nil
     begin
@@ -121,33 +77,6 @@ module Puppet::Util::Windows::Process
   end
   module_function :with_process_token
 
-  def get_process_image_name_by_pid(pid)
-    image_name = ""
-
-    Puppet::Util::Windows::Security.with_privilege(Puppet::Util::Windows::Security::SE_DEBUG_NAME) do
-      open_process(PROCESS_QUERY_INFORMATION, false, pid) do |phandle|
-        FFI::MemoryPointer.new(:dword, 1) do |exe_name_length_ptr|
-          # UTF is 2 bytes/char:
-          max_chars = MAX_PATH_LENGTH + 1
-          exe_name_length_ptr.write_dword(max_chars)
-          FFI::MemoryPointer.new(:wchar, max_chars) do |exe_name_ptr|
-            use_win32_path_format = 0
-            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}")
-            end
-            image_name = exe_name_ptr.read_wide_string(exe_name_length_ptr.read_dword)
-          end
-        end
-      end
-    end
-
-    image_name
-  end
-  module_function :get_process_image_name_by_pid
-
   def lookup_privilege_value(name, system_name = '', &block)
     FFI::MemoryPointer.new(LUID.size) do |luid_ptr|
       result = LookupPrivilegeValueW(
@@ -417,16 +346,6 @@ module Puppet::Util::Windows::Process
   attach_function_private :SetEnvironmentVariableW,
     [:lpcwstr, :lpcwstr], :win32_bool
 
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320(v=vs.85).aspx
-  # HANDLE WINAPI OpenProcess(
-  #   _In_   DWORD DesiredAccess,
-  #   _In_   BOOL InheritHandle,
-  #   _In_   DWORD ProcessId
-  # );
-  ffi_lib :kernel32
-  attach_function_private :OpenProcess,
-    [:dword, :win32_bool, :dword], :handle
-
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379295(v=vs.85).aspx
   # BOOL WINAPI OpenProcessToken(
   #   _In_   HANDLE ProcessHandle,
@@ -437,16 +356,6 @@ module Puppet::Util::Windows::Process
   attach_function_private :OpenProcessToken,
     [:handle, :dword, :phandle], :win32_bool
 
-  # https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-queryfullprocessimagenamew
-  # BOOL WINAPI QueryFullProcessImageName(
-  #   _In_   HANDLE hProcess,
-  #   _In_   DWORD dwFlags,
-  #   _Out_  LPWSTR lpExeName,
-  #   _In_   PDWORD lpdwSize,
-  # );
-  ffi_lib :kernel32
-  attach_function_private :QueryFullProcessImageNameW,
-    [:handle, :dword, :lpwstr, :pdword], :win32_bool
 
   # https://msdn.microsoft.com/en-us/library/windows/desktop/aa379261(v=vs.85).aspx
   # typedef struct _LUID {

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

@@ -46,12 +46,11 @@ module Puppet::Util::Windows
 
       subkey_max_len, _ = reg_query_info_key_max_lengths(key)
 
-      loop do
+      begin
         subkey, filetime = reg_enum_key(key, index, subkey_max_len)
         yield subkey, filetime if !subkey.nil?
         index += 1
-        break if subkey.nil?
-      end
+      end while !subkey.nil?
 
       index
     end
@@ -66,40 +65,17 @@ module Puppet::Util::Windows
       vals
     end
 
-    # Retrieve a set of values from a registry key given their names
-    # Value names listed but not found in the registry will not be added to the
-    # resultant Hashtable
-    #
-    # @param key [RegistryKey] An open handle to a Registry Key
-    # @param names [String[]] An array of names of registry values to return if they exist
-    # @return [Hashtable<String, Object>] A hashtable of all of the found values in the registry key
-    def values_by_name(key, names)
-      vals = {}
-      names.each do |name|
-        FFI::Pointer.from_string_to_wide_string(name) do |subkeyname_ptr|
-          begin
-            _, vals[name] = read(key, subkeyname_ptr)
-          rescue Puppet::Util::Windows::Error => e
-            # ignore missing names, but raise other errors
-            raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
-          end
-        end
-      end
-      vals
-    end
-
     def each_value(key, &block)
       index = 0
       subkey = nil
 
       _, value_max_len = reg_query_info_key_max_lengths(key)
 
-      loop do
+      begin
         subkey, type, data = reg_enum_value(key, index, value_max_len)
         yield subkey, type, data if !subkey.nil?
         index += 1
-        break if subkey.nil?
-      end
+      end while !subkey.nil?
 
       index
     end
@@ -110,16 +86,13 @@ module Puppet::Util::Windows
 
     private
 
-    # max number of wide characters including NULL terminator
-    MAX_KEY_CHAR_LENGTH = 255 + 1
-
-    def reg_enum_key(key, index, max_key_char_length = MAX_KEY_CHAR_LENGTH)
+    def reg_enum_key(key, index, max_key_length = Win32::Registry::Constants::MAX_KEY_LENGTH)
       subkey, filetime = nil, nil
 
       FFI::MemoryPointer.new(:dword) do |subkey_length_ptr|
         FFI::MemoryPointer.new(FFI::WIN32::FILETIME.size) do |filetime_ptr|
-          FFI::MemoryPointer.new(:wchar, max_key_char_length) do |subkey_ptr|
-            subkey_length_ptr.write_dword(max_key_char_length)
+          FFI::MemoryPointer.new(:wchar, max_key_length) do |subkey_ptr|
+            subkey_length_ptr.write_dword(max_key_length)
 
             # RegEnumKeyEx cannot be called twice to properly size the buffer
             result = RegEnumKeyExW(key.hkey, index,
@@ -131,7 +104,7 @@ module Puppet::Util::Windows
 
             if result != FFI::ERROR_SUCCESS
               msg = _("Failed to enumerate %{key} registry keys at index %{index}") % { key: key.keyname, index: index }
-              raise Puppet::Util::Windows::Error.new(msg, result)
+              raise Puppet::Util::Windows::Error.new(msg)
             end
 
             filetime = FFI::WIN32::FILETIME.new(filetime_ptr)
@@ -144,10 +117,7 @@ module Puppet::Util::Windows
       [subkey, filetime]
     end
 
-    # max number of wide characters including NULL terminator
-    MAX_VALUE_CHAR_LENGTH = 16383 + 1
-
-    def reg_enum_value(key, index, max_value_length = MAX_VALUE_CHAR_LENGTH)
+    def reg_enum_value(key, index, max_value_length = Win32::Registry::Constants::MAX_VALUE_LENGTH)
       subkey, type, data = nil, nil, nil
 
       FFI::MemoryPointer.new(:dword) do |subkey_length_ptr|
@@ -165,7 +135,7 @@ module Puppet::Util::Windows
 
           if result != FFI::ERROR_SUCCESS
             msg = _("Failed to enumerate %{key} registry values at index %{index}") % { key: key.keyname, index: index }
-            raise Puppet::Util::Windows::Error.new(msg, result)
+            raise Puppet::Util::Windows::Error.new(msg)
           end
 
           subkey_length = subkey_length_ptr.read_dword
@@ -195,7 +165,7 @@ module Puppet::Util::Windows
 
           if status != FFI::ERROR_SUCCESS
             msg = _("Failed to query registry %{key} for sizes") % { key: key.keyname }
-            raise Puppet::Util::Windows::Error.new(msg, status)
+            raise Puppet::Util::Windows::Error.new(msg)
           end
 
           result = [
@@ -240,7 +210,7 @@ module Puppet::Util::Windows
         begin
           case type
             when Win32::Registry::REG_SZ, Win32::Registry::REG_EXPAND_SZ
-              result = [ type, data_ptr.read_wide_string(string_length, Encoding::UTF_8, true) ]
+              result = [ type, data_ptr.read_wide_string(string_length) ]
             when Win32::Registry::REG_MULTI_SZ
               result = [ type, data_ptr.read_wide_string(string_length).split(/\0/) ]
             when Win32::Registry::REG_BINARY
@@ -277,10 +247,8 @@ module Puppet::Util::Windows
               buffer_ptr, length_ptr)
 
             if result != FFI::ERROR_SUCCESS
-              # buffer is raw bytes, *not* chars - less a NULL terminator
-              name_length = (name_ptr.size / FFI.type_size(:wchar)) - 1 if name_ptr.size > 0
-              msg = _("Failed to read registry value %{value} at %{key}") % { value: name_ptr.read_wide_string(name_length), key: key.keyname }
-              raise Puppet::Util::Windows::Error.new(msg, result)
+              msg = _("Failed to read registry value %{value} at %{key}") % { value: name_ptr.read_wide_string, key: key.keyname }
+              raise Puppet::Util::Windows::Error.new(msg)
             end
 
             # allows caller to use FFI MemoryPointer helpers to read / shape

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

@@ -97,7 +97,6 @@ module Puppet::Util::Windows::Security
   FILE = Puppet::Util::Windows::File
 
   SE_BACKUP_NAME              = 'SeBackupPrivilege'
-  SE_DEBUG_NAME               = 'SeDebugPrivilege'
   SE_RESTORE_NAME             = 'SeRestorePrivilege'
 
   DELETE                      = 0x00010000
@@ -201,7 +200,6 @@ module Puppet::Util::Windows::Security
     well_known_world_sid = Puppet::Util::Windows::SID::Everyone
     well_known_nobody_sid = Puppet::Util::Windows::SID::Nobody
     well_known_system_sid = Puppet::Util::Windows::SID::LocalSystem
-    well_known_app_packages_sid = Puppet::Util::Windows::SID::AllAppPackages
 
     mode = S_ISYSTEM_MISSING
 
@@ -236,7 +234,6 @@ module Puppet::Util::Windows::Security
         if (ace.mask & FILE::FILE_APPEND_DATA).nonzero?
           mode |= S_ISVTX
         end
-      when well_known_app_packages_sid
       when well_known_system_sid
       else
         #puts "Warning, unable to map SID into POSIX mode: #{ace.sid}"
@@ -277,7 +274,7 @@ module Puppet::Util::Windows::Security
   # mode. Only a user with the SE_BACKUP_NAME and SE_RESTORE_NAME
   # privileges in their process token can change the mode for objects
   # that they do not have read and write access to.
-  def set_mode(mode, path, protected = true, managing_owner = false, managing_group = false)
+  def set_mode(mode, path, protected = true)
     sd = get_security_descriptor(path)
     well_known_world_sid = Puppet::Util::Windows::SID::Everyone
     well_known_nobody_sid = Puppet::Util::Windows::SID::Nobody
@@ -322,47 +319,11 @@ module Puppet::Util::Windows::Security
       nobody_allow |= FILE::FILE_APPEND_DATA;
     end
 
-    isownergroup = sd.owner == sd.group
-
     # caller is NOT managing SYSTEM by using group or owner, so set to FULL
     if ! [sd.owner, sd.group].include? well_known_system_sid
       # we don't check S_ISYSTEM_MISSING bit, but automatically carry over existing SYSTEM perms
       # by default set SYSTEM perms to full
       system_allow = FILE::FILE_ALL_ACCESS
-    else
-      # It is possible to set SYSTEM with a mode other than Full Control (7) however this makes no sense and in practical terms
-      # should not be done.  We can trap these instances and correct them before being applied.
-      if (sd.owner == well_known_system_sid) && (owner_allow != FILE::FILE_ALL_ACCESS)
-        # If owner and group are both SYSTEM but group is unmanaged the control rights of system will be set to FullControl by
-        # the unmanaged group, so there is no need for the warning
-        if managing_owner && (!isownergroup || managing_group)
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.warning _("Setting control rights for %{path} owner SYSTEM to less than Full Control rights. Setting SYSTEM rights to less than Full Control may have unintented consequences for operations on this file") % { path: path }
-        elsif managing_owner && isownergroup
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("%{path} owner and group both set to user SYSTEM, but group is not managed directly: SYSTEM user rights will be set to FullControl by group") % { path: path }
-        else
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("An attempt to set mode %{mode} on item %{path} would result in the owner, SYSTEM, to have less than Full Control rights. This attempt has been corrected to Full Control") % { mode: mode.to_s(8), path: path }
-          owner_allow = FILE::FILE_ALL_ACCESS
-        end
-      end
-
-      if (sd.group == well_known_system_sid) && (group_allow != FILE::FILE_ALL_ACCESS)
-        # If owner and group are both SYSTEM but owner is unmanaged the control rights of system will be set to FullControl by
-        # the unmanaged owner, so there is no need for the warning.
-        if managing_group && (!isownergroup || managing_owner)
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.warning _("Setting control rights for %{path} group SYSTEM to less than Full Control rights. Setting SYSTEM rights to less than Full Control may have unintented consequences for operations on this file") % { path: path }
-        elsif managing_group && isownergroup
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("%{path} owner and group both set to user SYSTEM, but owner is not managed directly: SYSTEM user rights will be set to FullControl by owner") % { path: path }
-        else
-          #TRANSLATORS 'SYSTEM' is a Windows name and should not be translated
-          Puppet.debug _("An attempt to set mode %{mode} on item %{path} would result in the group, SYSTEM, to have less than Full Control rights. This attempt has been corrected to Full Control") % { mode: mode.to_s(8), path: path }
-          group_allow = FILE::FILE_ALL_ACCESS
-        end
-      end
     end
 
     # even though FILE_DELETE_CHILD only applies to directories, it can be set on files
@@ -378,6 +339,7 @@ module Puppet::Util::Windows::Security
     end
 
     # if owner and group the same, then map group permissions to the one owner ACE
+    isownergroup = sd.owner == sd.group
     if isownergroup
       owner_allow |= group_allow
     end

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

@@ -1,4 +1,3 @@
-# coding: utf-8
 require 'puppet/util/windows'
 require 'ffi'
 
@@ -18,10 +17,6 @@ module Puppet::Util::Windows
     # no shorter
     DEFAULT_TIMEOUT = 30
 
-    # Service error codes
-    # https://docs.microsoft.com/en-us/windows/desktop/debug/system-error-codes--1000-1299-
-    ERROR_SERVICE_DOES_NOT_EXIST = 0x00000424
-
     # Service control codes
     # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-controlserviceexw
     SERVICE_CONTROL_STOP                  = 0x00000001
@@ -41,26 +36,6 @@ module Puppet::Util::Windows
     SERVICE_CONTROL_PRESHUTDOWN           = 0x0000000F
     SERVICE_CONTROL_TIMECHANGE            = 0x00000010
     SERVICE_CONTROL_TRIGGEREVENT          = 0x00000020
-    SERVICE_CONTROL_SIGNALS               = {
-      SERVICE_CONTROL_STOP                  => :SERVICE_CONTROL_STOP,
-      SERVICE_CONTROL_PAUSE                 => :SERVICE_CONTROL_PAUSE,
-      SERVICE_CONTROL_CONTINUE              => :SERVICE_CONTROL_CONTINUE,
-      SERVICE_CONTROL_INTERROGATE           => :SERVICE_CONTROL_INTERROGATE,
-      SERVICE_CONTROL_SHUTDOWN              => :SERVICE_CONTROL_SHUTDOWN,
-      SERVICE_CONTROL_PARAMCHANGE           => :SERVICE_CONTROL_PARAMCHANGE,
-      SERVICE_CONTROL_NETBINDADD            => :SERVICE_CONTROL_NETBINDADD,
-      SERVICE_CONTROL_NETBINDREMOVE         => :SERVICE_CONTROL_NETBINDREMOVE,
-      SERVICE_CONTROL_NETBINDENABLE         => :SERVICE_CONTROL_NETBINDENABLE,
-      SERVICE_CONTROL_NETBINDDISABLE        => :SERVICE_CONTROL_NETBINDDISABLE,
-      SERVICE_CONTROL_DEVICEEVENT           => :SERVICE_CONTROL_DEVICEEVENT,
-      SERVICE_CONTROL_HARDWAREPROFILECHANGE => :SERVICE_CONTROL_HARDWAREPROFILECHANGE,
-      SERVICE_CONTROL_POWEREVENT            => :SERVICE_CONTROL_POWEREVENT,
-      SERVICE_CONTROL_SESSIONCHANGE         => :SERVICE_CONTROL_SESSIONCHANGE,
-      SERVICE_CONTROL_PRESHUTDOWN           => :SERVICE_CONTROL_PRESHUTDOWN,
-      SERVICE_CONTROL_TIMECHANGE            => :SERVICE_CONTROL_TIMECHANGE,
-      SERVICE_CONTROL_TRIGGEREVENT          => :SERVICE_CONTROL_TRIGGEREVENT
-    }
-
 
     # Service start type codes
     # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-changeserviceconfigw
@@ -102,14 +77,7 @@ module Puppet::Util::Windows
     SERVICE_START_PENDING    = 0x00000002
     SERVICE_STOP_PENDING     = 0x00000003
     SERVICE_STOPPED          = 0x00000001
-    UNSAFE_PENDING_STATES    = [SERVICE_START_PENDING, SERVICE_STOP_PENDING]
-    FINAL_STATES             = {
-      SERVICE_CONTINUE_PENDING => SERVICE_RUNNING,
-      SERVICE_PAUSE_PENDING    => SERVICE_PAUSED,
-      SERVICE_START_PENDING    => SERVICE_RUNNING,
-      SERVICE_STOP_PENDING     => SERVICE_STOPPED
-    }
-    SERVICE_STATES           = {
+    SERVICE_STATES = {
       SERVICE_CONTINUE_PENDING => :SERVICE_CONTINUE_PENDING,
       SERVICE_PAUSE_PENDING => :SERVICE_PAUSE_PENDING,
       SERVICE_PAUSED => :SERVICE_PAUSED,
@@ -181,30 +149,7 @@ module Puppet::Util::Windows
     # // Value to indicate no change to an optional parameter
     # //
     # #define SERVICE_NO_CHANGE              0xffffffff
-    # https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-changeserviceconfig2w
-    SERVICE_CONFIG_DESCRIPTION              = 0x00000001
-    SERVICE_CONFIG_FAILURE_ACTIONS          = 0x00000002
-    SERVICE_CONFIG_DELAYED_AUTO_START_INFO  = 0x00000003
-    SERVICE_CONFIG_FAILURE_ACTIONS_FLAG     = 0x00000004
-    SERVICE_CONFIG_SERVICE_SID_INFO         = 0x00000005
-    SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO = 0x00000006
-    SERVICE_CONFIG_PRESHUTDOWN_INFO         = 0x00000007
-    SERVICE_CONFIG_TRIGGER_INFO             = 0x00000008
-    SERVICE_CONFIG_PREFERRED_NODE           = 0x00000009
-    SERVICE_CONFIG_LAUNCH_PROTECTED         = 0x00000012
-    SERVICE_NO_CHANGE                       = 0xffffffff
-    SERVICE_CONFIG_TYPES = {
-      SERVICE_CONFIG_DESCRIPTION => :SERVICE_CONFIG_DESCRIPTION,
-      SERVICE_CONFIG_FAILURE_ACTIONS => :SERVICE_CONFIG_FAILURE_ACTIONS,
-      SERVICE_CONFIG_DELAYED_AUTO_START_INFO => :SERVICE_CONFIG_DELAYED_AUTO_START_INFO,
-      SERVICE_CONFIG_FAILURE_ACTIONS_FLAG => :SERVICE_CONFIG_FAILURE_ACTIONS_FLAG,
-      SERVICE_CONFIG_SERVICE_SID_INFO => :SERVICE_CONFIG_SERVICE_SID_INFO,
-      SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO => :SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO,
-      SERVICE_CONFIG_PRESHUTDOWN_INFO => :SERVICE_CONFIG_PRESHUTDOWN_INFO,
-      SERVICE_CONFIG_TRIGGER_INFO => :SERVICE_CONFIG_TRIGGER_INFO,
-      SERVICE_CONFIG_PREFERRED_NODE => :SERVICE_CONFIG_PREFERRED_NODE,
-      SERVICE_CONFIG_LAUNCH_PROTECTED => :SERVICE_CONFIG_LAUNCH_PROTECTED,
-    }
+    SERVICE_NO_CHANGE = 0xffffffff
 
     # Service enum codes
     # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-enumservicesstatusexa
@@ -243,19 +188,6 @@ module Puppet::Util::Windows
       )
     end
 
-    # https://docs.microsoft.com/en-us/windows/win32/api/winsvc/ns-winsvc-service_delayed_auto_start_info
-    # typedef struct _SERVICE_DELAYED_AUTO_START_INFO {
-    #   BOOL fDelayedAutostart;
-    # } SERVICE_DELAYED_AUTO_START_INFO, *LPSERVICE_DELAYED_AUTO_START_INFO;
-    class SERVICE_DELAYED_AUTO_START_INFO < FFI::Struct
-      layout(:fDelayedAutostart, :int)
-      alias aset []=
-      # Intercept the accessor so that we can handle either true/false or 1/0.
-      # Since there is only one member, there’s no need to check the key name.
-      def []=(key, value)
-        [0, false].include?(value) ? aset(key, 0) : aset(key, 1)
-      end
-    end
 
     # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_enum_service_status_processw
     # typedef struct _ENUM_SERVICE_STATUS_PROCESSW {
@@ -317,121 +249,76 @@ module Puppet::Util::Windows
       )
     end
 
-    # Returns true if the service exists, false otherwise.
-    #
-    # @param [:string] service_name name of the service
-    def exists?(service_name)
-      open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS) do |_|
-        true
-      end
-    rescue Puppet::Util::Windows::Error => e
-      return false if e.code == ERROR_SERVICE_DOES_NOT_EXIST
-      raise e
-    end
-    module_function :exists?
-
-    # Start a windows service
+    # Start a windows service, assume that the service is already in the stopped state
     #
     # @param [:string] service_name name of the service to start
     def start(service_name)
-      Puppet.debug _("Starting the %{service_name} service") % { service_name: service_name }
-
-      valid_initial_states = [
-        SERVICE_STOP_PENDING,
-        SERVICE_STOPPED,
-        SERVICE_START_PENDING
-      ]
-
-      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING) do |service|
+      open_service(service_name, SC_MANAGER_CONNECT, SERVICE_START | SERVICE_QUERY_STATUS) do |service|
+        # don't attempt to fail here if the service isn't stopped because windows error codes
+        # are likely more informative than ours and a failed call to StartServiceW will produce
+        # those errors
+        wait_for_pending_transition(service, SERVICE_STOP_PENDING, SERVICE_STOPPED)
         if StartServiceW(service, 0, FFI::Pointer::NULL) == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error, _("Failed to start the service")
+          raise Puppet::Util::Windows::Error.new(_("Failed to start the service"))
+        end
+        unless wait_for_pending_transition(service, SERVICE_START_PENDING, SERVICE_RUNNING)
+          raise Puppet::Error.new(_("Failed to start the service, after calling StartService the service is not in SERVICE_START_PENDING or SERVICE_RUNNING"))
         end
       end
-
-      Puppet.debug _("Successfully started the %{service_name} service") % { service_name: service_name }
     end
     module_function :start
 
-    # Stop a windows service
+    # Use ControlService to send a stop signal to a windows service
     #
     # @param [:string] service_name name of the service to stop
     def stop(service_name)
-      Puppet.debug _("Stopping the %{service_name} service") % { service_name: service_name }
-
-      valid_initial_states = SERVICE_STATES.keys - [SERVICE_STOPPED]
-
-      transition_service_state(service_name, valid_initial_states, SERVICE_STOPPED) do |service|
-        send_service_control_signal(service, SERVICE_CONTROL_STOP)
+      open_service(service_name, SC_MANAGER_CONNECT, SERVICE_STOP | SERVICE_QUERY_STATUS) do |service|
+        FFI::MemoryPointer.new(SERVICE_STATUS.size) do |status_ptr|
+          status = SERVICE_STATUS.new(status_ptr)
+          # don't attempt to fail here if the service isn't started because windows error codes
+          # are likely more informative than ours and a failed call to ControlService will produce
+          # those errors
+          wait_for_pending_transition(service, SERVICE_START_PENDING, SERVICE_RUNNING)
+          if ControlService(service, SERVICE_CONTROL_STOP, status) == FFI::WIN32_FALSE
+            raise Puppet::Util::Windows::Error.new(_("Failed to send stop control to service, current state is %{current_state}. Failed with") % { current_state: status[:dwCurrentState].to_s })
+          end
+          unless wait_for_pending_transition(service, SERVICE_STOP_PENDING, SERVICE_STOPPED)
+            raise Puppet::Error.new(_("Failed to stop the service, after calling ControlService the service is not in SERVICE_STOP_PENDING or SERVICE_STOPPED"))
+          end
+        end
       end
-
-      Puppet.debug _("Successfully stopped the %{service_name} service") % { service_name: service_name }
     end
     module_function :stop
 
-    # Resume a paused windows service
-    #
-    # @param [:string] service_name name of the service to resume
-    def resume(service_name)
-      Puppet.debug _("Resuming the %{service_name} service") % { service_name: service_name }
-
-      valid_initial_states = [
-        SERVICE_PAUSE_PENDING,
-        SERVICE_PAUSED,
-        SERVICE_CONTINUE_PENDING
-      ]
-
-      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING) do |service|
-        # The SERVICE_CONTROL_CONTINUE signal can only be sent when
-        # the service is in the SERVICE_PAUSED state
-        wait_on_pending_state(service, SERVICE_PAUSE_PENDING)
-
-        send_service_control_signal(service, SERVICE_CONTROL_CONTINUE)
-      end
-
-      Puppet.debug _("Successfully resumed the %{service_name} service") % { service_name: service_name }
-    end
-    module_function :resume
-
     # Query the state of a service using QueryServiceStatusEx
     #
     # @param [:string] service_name name of the service to query
     # @return [string] the status of the service
     def service_state(service_name)
-      state = nil
+      status = nil
       open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS) do |service|
-        query_status(service) do |status|
-          state = SERVICE_STATES[status[:dwCurrentState]]
-        end
+        status = query_status(service)
       end
+      state = SERVICE_STATES[status[:dwCurrentState]]
       if state.nil?
-        raise Puppet::Error.new(_("Unknown Service state '%{current_state}' for '%{service_name}'") % { current_state: state.to_s, service_name: service_name})
+        raise Puppet::Error.new(_("Unknown Service state '%{current_state}' for '%{service_name}'") % { current_state: status[:dwCurrentState].to_s, service_name: service_name})
       end
       state
     end
     module_function :service_state
 
     # Query the configuration of a service using QueryServiceConfigW
-    # or QueryServiceConfig2W
     #
     # @param [:string] service_name name of the service to query
     # @return [QUERY_SERVICE_CONFIGW.struct] the configuration of the service
     def service_start_type(service_name)
-      start_type = nil
+      config = nil
       open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_CONFIG) do |service|
-        query_config(service) do |config|
-          start_type = SERVICE_START_TYPES[config[:dwStartType]]
-        end
-      end
-      # if the service has type AUTO_START, check if it's a delayed service
-      if start_type == :SERVICE_AUTO_START
-        open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_CONFIG) do |service|
-          query_config2(service, SERVICE_CONFIG_DELAYED_AUTO_START_INFO) do |config|
-            return :SERVICE_DELAYED_AUTO_START if config[:fDelayedAutostart] == 1
-          end
-        end
+        config = query_config(service)
       end
+      start_type = SERVICE_START_TYPES[config[:dwStartType]]
       if start_type.nil?
-        raise Puppet::Error.new(_("Unknown start type '%{start_type}' for '%{service_name}'") % { start_type: start_type.to_s, service_name: service_name})
+        raise Puppet::Error.new(_("Unknown start type '%{start_type}' for '%{service_name}'") % { start_type: config[:dwStartType].to_s, service_name: service_name})
       end
       start_type
     end
@@ -439,12 +326,11 @@ module Puppet::Util::Windows
 
     # Change the startup mode of a windows service
     #
-    # @param [String] service_name the name of the service to modify
-    # @param [Integer] startup_type a code corresponding to a start type for
+    # @param [string] service_name the name of the service to modify
+    # @param [Int] startup_type a code corresponding to a start type for
     #  windows service, see the "Service start type codes" section in the
     #  Puppet::Util::Windows::Service file for the list of available codes
-    # @param [Bool] delayed whether the service should be started with a delay
-    def set_startup_mode(service_name, startup_type, delayed=false)
+    def set_startup_mode(service_name, startup_type)
       startup_code = SERVICE_START_TYPES.key(startup_type)
       if startup_code.nil?
         raise Puppet::Error.new(_("Unknown start type %{start_type}") % {startup_type: startup_type.to_s})
@@ -471,7 +357,6 @@ module Puppet::Util::Windows
           raise Puppet::Util::Windows::Error.new(_("Failed to update service configuration"))
         end
       end
-      set_startup_mode_delayed(service_name, delayed)
     end
     module_function :set_startup_mode
 
@@ -571,18 +456,13 @@ module Puppet::Util::Windows
       # @param [Integer] service_access code corresponding to the access type requested for the service
       # @yieldparam [:handle] service the windows native handle used to access
       #   the service
-      # @return the result of the block
       def open_service(service_name, scm_access, service_access, &block)
         service = FFI::Pointer::NULL_HANDLE
-
-        result = nil
         open_scm(scm_access) do |scm|
           service = OpenServiceW(scm, wide_string(service_name), service_access)
           raise Puppet::Util::Windows::Error.new(_("Failed to open a handle to the service")) if service == FFI::Pointer::NULL_HANDLE
-          result = yield service
+          yield service
         end
-
-        result
       ensure
         CloseServiceHandle(service)
       end
@@ -602,78 +482,6 @@ module Puppet::Util::Windows
       end
       private :open_scm
 
-      # @api private
-      # Transition the service to the specified state. The block should perform
-      # the actual transition.
-      #
-      # @param [String] service_name the name of the service to transition
-      # @param [[Integer]] valid_initial_states an array of valid states that the service can transition from
-      # @param [:Integer] final_state the state that the service will transition to
-      def transition_service_state(service_name, valid_initial_states, final_state, &block)
-        service_access = SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_QUERY_STATUS
-        open_service(service_name, SC_MANAGER_CONNECT, service_access) do |service|
-          query_status(service) do |status|
-            initial_state = status[:dwCurrentState]
-            # If the service is already in the final_state, then
-            # no further work needs to be done
-            if initial_state == final_state
-              Puppet.debug _("The service is already in the %{final_state} state. No further work needs to be done.") % { final_state: SERVICE_STATES[final_state] }
-
-              next
-            end
-
-            # Check that initial_state corresponds to a valid
-            # initial state
-            unless valid_initial_states.include?(initial_state)
-              valid_initial_states_str = valid_initial_states.map do |state|
-                SERVICE_STATES[state]
-              end.join(", ")
-
-              raise Puppet::Error, _("The service must be in one of the %{valid_initial_states} states to perform this transition. It is currently in the %{current_state} state.") % { valid_initial_states: valid_initial_states_str, current_state: SERVICE_STATES[initial_state] }
-            end
-
-            # Check if there's a pending transition to the final_state. If so, then wait for
-            # that transition to finish.
-            possible_pending_states = FINAL_STATES.keys.select do |pending_state|
-              # SERVICE_RUNNING has two pending states, SERVICE_START_PENDING and
-              # SERVICE_CONTINUE_PENDING. That is why we need the #select here
-              FINAL_STATES[pending_state] == final_state
-            end
-            if possible_pending_states.include?(initial_state)
-              Puppet.debug _("There is already a pending transition to the %{final_state} state for the %{service_name} service.")  % { final_state: SERVICE_STATES[final_state], service_name: service_name }
-              wait_on_pending_state(service, initial_state)
-
-              next
-            end
-
-            # If we are in an unsafe pending state like SERVICE_START_PENDING
-            # or SERVICE_STOP_PENDING, then we want to wait for that pending
-            # transition to finish before transitioning the service state.
-            # The reason we do this is because SERVICE_START_PENDING is when
-            # the service thread is being created and initialized, while
-            # SERVICE_STOP_PENDING is when the service thread is being cleaned
-            # up and destroyed. Thus there is a chance that when the service is
-            # in either of these states, its service thread may not yet be ready
-            # to perform the state transition (it may not even exist).
-            if UNSAFE_PENDING_STATES.include?(initial_state)
-              Puppet.debug _("The service is in the %{pending_state} state, which is an unsafe pending state.") % { pending_state: SERVICE_STATES[initial_state] }
-              wait_on_pending_state(service, initial_state)
-              initial_state = FINAL_STATES[initial_state]
-            end
-
-            Puppet.debug _("Transitioning the %{service_name} service from %{initial_state} to %{final_state}") % { service_name: service_name, initial_state: SERVICE_STATES[initial_state], final_state: SERVICE_STATES[final_state] }
-
-            yield service
-
-            Puppet.debug _("Waiting for the transition to finish")
-            wait_on_state_transition(service, initial_state, final_state)
-          end
-        end
-      rescue => detail
-        raise Puppet::Error, _("Failed to transition the %{service_name} service to the %{final_state} state. Detail: %{detail}") % { service_name: service_name, final_state: SERVICE_STATES[final_state], detail: detail }, detail.backtrace
-      end
-      private :transition_service_state
-
       # @api private
       # perform QueryServiceStatusEx on a windows service and return the
       # result
@@ -711,9 +519,9 @@ module Puppet::Util::Windows
             if success == FFI::WIN32_FALSE
               raise Puppet::Util::Windows::Error.new(_("Service query failed"))
             end
-            yield status
           end
         end
+        status
       end
       private :query_status
 
@@ -723,7 +531,7 @@ module Puppet::Util::Windows
       #
       # @param [:handle] service handle of the service to query
       # @return [QUERY_SERVICE_CONFIGW struct] the result of the query
-      def query_config(service, &block)
+      def query_config(service)
         config = nil
         size_required = nil
         # Fetch the bytes of memory required to be allocated
@@ -747,198 +555,52 @@ module Puppet::Util::Windows
             if success == FFI::WIN32_FALSE
               raise Puppet::Util::Windows::Error.new(_("Service query failed"))
             end
-            yield config
           end
         end
+        config
       end
       private :query_config
 
       # @api private
-      # perform QueryServiceConfig2W on a windows service and return the
-      # result
-      #
-      # @param [:handle] service handle of the service to query
-      # @param [Integer] info_level the configuration information to be queried
-      # @return [QUERY_SERVICE_CONFIG2W struct] the result of the query
-      def query_config2(service, info_level, &block)
-        config = nil
-        size_required = nil
-        # Fetch the bytes of memory required to be allocated
-        # for QueryServiceConfig2W to return succesfully. This
-        # is done by sending NULL and 0 for the pointer and size
-        # respectively, letting the command fail, then reading the
-        # value of pcbBytesNeeded
-        FFI::MemoryPointer.new(:lpword) do |bytes_pointer|
-          # return value will be false from this call, since it's designed
-          # to fail. Just ignore it
-          QueryServiceConfig2W(service, info_level, FFI::Pointer::NULL, 0, bytes_pointer)
-          size_required = bytes_pointer.read_dword
-          FFI::MemoryPointer.new(size_required) do |ssp_ptr|
-            # We need to supply the appropriate struct to be created based on
-            # the info_level
-            case info_level
-            when SERVICE_CONFIG_DELAYED_AUTO_START_INFO
-              config = SERVICE_DELAYED_AUTO_START_INFO.new(ssp_ptr)
-            end
-            success = QueryServiceConfig2W(
-              service,
-              info_level,
-              ssp_ptr,
-              size_required,
-              bytes_pointer
-            )
-            if success == FFI::WIN32_FALSE
-              raise Puppet::Util::Windows::Error.new(_("Service query for %{parameter_name} failed") % { parameter_name: SERVICE_CONFIG_TYPES[info_level] } )
-            end
-            yield config
-          end
-        end
-      end
-      private :query_config2
-
-      # @api private
-      # Sets an optional parameter on a service by calling
-      # ChangeServiceConfig2W
-      #
-      # @param [String] service_name name of service
-      # @param [Integer] change parameter to change
-      # @param [struct] value appropriate struct based on the parameter to change
-      def set_optional_parameter(service_name, change, value)
-        open_service(service_name, SC_MANAGER_CONNECT, SERVICE_CHANGE_CONFIG) do |service|
-          success = ChangeServiceConfig2W(
-            service,
-            change, # dwInfoLevel
-            value,  # lpInfo
-          )
-          if success == FFI::WIN32_FALSE
-            raise Puppet::Util::windows::Error.new(_("Failed to update service %{change} configuration") % { change: change } )
-          end
-        end
-      end
-      private :set_optional_parameter
-
-      # @api private
-      # Controls the delayed auto-start setting of a service
-      #
-      # @param [String] service_name name of service
-      # @param [Bool] delayed whether the service should be started with a delay or not
-      def set_startup_mode_delayed(service_name, delayed)
-        delayed_start = SERVICE_DELAYED_AUTO_START_INFO.new
-        delayed_start[:fDelayedAutostart] = delayed
-        set_optional_parameter(service_name, SERVICE_CONFIG_DELAYED_AUTO_START_INFO, delayed_start)
-      end
-      private :set_startup_mode_delayed
-
-      # @api private
-      # Sends a service control signal to a service
-      #
-      # @param [:handle] service handle to the service
-      # @param [Integer] signal the service control signal to send
-      def send_service_control_signal(service, signal)
-        FFI::MemoryPointer.new(SERVICE_STATUS.size) do |status_ptr|
-          status = SERVICE_STATUS.new(status_ptr)
-          if ControlService(service, signal, status) == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error, _("Failed to send the %{control_signal} signal to the service. Its current state is %{current_state}. Reason for failure:") % { control_signal: SERVICE_CONTROL_SIGNALS[signal], current_state: SERVICE_STATES[status[:dwCurrentState]] }
-          end
-        end
-      end
-
-      # @api private
-      # Waits for a service to transition from one state to
-      # another state.
-      #
-      # @param [:handle] service handle to the service to wait on
-      # @param [Integer] initial_state the state that the service is transitioning from.
-      # @param [Integer] final_state the state that the service is transitioning to
-      def wait_on_state_transition(service, initial_state, final_state)
-        # Get the pending state for this transition. Note that SERVICE_RUNNING
-        # has two possible pending states, which is why we need this logic.
-        if final_state != SERVICE_RUNNING
-          pending_state = FINAL_STATES.key(final_state)
-        elsif initial_state == SERVICE_STOPPED
-          # SERVICE_STOPPED => SERVICE_RUNNING
-          pending_state = SERVICE_START_PENDING
-        else
-          # SERVICE_PAUSED => SERVICE_RUNNING
-          pending_state = SERVICE_CONTINUE_PENDING
-        end
-
-        # Wait for the transition to finish
-        state = nil
-        elapsed_time = 0
-        while elapsed_time <= DEFAULT_TIMEOUT
-
-          query_status(service) do |status|
-            state = status[:dwCurrentState]
-            return if state == final_state
-            if state == pending_state
-              Puppet.debug _("The service transitioned to the %{pending_state} state.") % { pending_state: SERVICE_STATES[pending_state] }
-              wait_on_pending_state(service, pending_state)
-              return
-            end
-            sleep(1)
-            elapsed_time += 1
-          end
-        end
-        # Timed out while waiting for the transition to finish. Raise an error
-        # We can still use the state variable read from the FFI struct because
-        # FFI creates new Integer objects during an assignment of an integer value
-        # stored in an FFI struct. We verified that the '=' operater is safe
-        # from the freed memory since the new ruby object created during the
-        # assignment will remain in ruby memory and remain immutable and constant.
-        raise Puppet::Error, _("Timed out while waiting for the service to transition from %{initial_state} to %{final_state} OR from %{initial_state} to %{pending_state} to %{final_state}. The service's current state is %{current_state}.") % { initial_state: SERVICE_STATES[initial_state], final_state: SERVICE_STATES[final_state], pending_state: SERVICE_STATES[pending_state], current_state: SERVICE_STATES[state] }
-      end
-      private :wait_on_state_transition
-
-      # @api private
-      # Waits for a service to finish transitioning from
-      # a pending state. The service must be in the pending state
-      # before invoking this routine.
+      # waits for a windows service to report final_state if it
+      # is in pending_state
       #
       # @param [:handle] service handle to the service to wait on
-      # @param [Integer] pending_state the pending state
-      def wait_on_pending_state(service, pending_state)
-        final_state = FINAL_STATES[pending_state]
-
-        Puppet.debug _("Waiting for the pending transition to the %{final_state} state to finish.") % { final_state: SERVICE_STATES[final_state] }
-
+      # @param [Integer] pending_state the state to wait on
+      # @param [Integer] final_state the state indicating the transition is finished
+      # @return [bool] 'true' once the service is reporting final_state,
+      #   'false' if the service was not in pending_state or finaL_state
+      def wait_for_pending_transition(service, pending_state, final_state)
         elapsed_time = 0
         last_checkpoint = -1
         loop do
-          query_status(service) do |status|
-            state = status[:dwCurrentState]
-            checkpoint = status[:dwCheckPoint]
-            wait_hint = status[:dwWaitHint]
-            # Check if our service has finished transitioning to
-            # the final_state OR if an unexpected transition
-            # has occurred
-            return if state == final_state
-            unless state == pending_state
-              raise Puppet::Error, _("Unexpected transition to the %{current_state} state while waiting for the pending transition from %{pending_state} to %{final_state} to finish.") % { current_state: SERVICE_STATES[state], pending_state: SERVICE_STATES[pending_state], final_state: SERVICE_STATES[final_state] }
-            end
-
-            # Check if any progress has been made since our last sleep
-            # using the dwCheckPoint. If no progress has been made then
-            # check if we've timed out, and raise an error if so
-            if checkpoint > last_checkpoint
-              elapsed_time = 0
-              last_checkpoint = checkpoint
-            else
-              wait_hint_in_seconds = milliseconds_to_seconds(wait_hint)
-              timeout = wait_hint_in_seconds < DEFAULT_TIMEOUT ? DEFAULT_TIMEOUT : wait_hint_in_seconds
-
-              if elapsed_time >= timeout
-                raise Puppet::Error, _("Timed out while waiting for the pending transition from %{pending_state} to %{final_state} to finish. The current state is %{current_state}.") % { pending_state: SERVICE_STATES[pending_state], final_state: SERVICE_STATES[final_state], current_state: SERVICE_STATES[state] }
-              end
+          status = query_status(service)
+          state = status[:dwCurrentState]
+          return true if state == final_state
+          unless state == pending_state
+            return false
+          end
+          # When the service is in the pending state we need to do the following:
+          # 1. check if any progress has been made since dwWaitHint using dwCheckPoint,
+          #    and fail if no progress was made
+          # 2. if progress has been made, increment elapsed_time and set last_checkpoint
+          # 3. sleep, then loop again if there was progress.
+          time_to_wait = wait_hint_to_wait_time(status[:dwWaitHint])
+          if status[:dwCheckPoint] > last_checkpoint
+            elapsed_time = 0
+          else
+            timeout = milliseconds_to_seconds(status[:dwWaitHint]);
+            timeout = DEFAULT_TIMEOUT if timeout < DEFAULT_TIMEOUT
+            if elapsed_time >= (timeout)
+              raise Puppet::Error.new(_("No progress made on service operation and dwWaitHint exceeded"))
             end
-            wait_time = wait_hint_to_wait_time(wait_hint)
-            # Wait a bit before rechecking the service's state
-            sleep(wait_time)
-            elapsed_time += wait_time
           end
+          last_checkpoint = status[:dwCheckPoint]
+          sleep(time_to_wait)
+          elapsed_time += time_to_wait
         end
       end
-      private :wait_on_pending_state
+      private :wait_for_pending_transition
 
       # @api private
       #
@@ -1023,18 +685,6 @@ module Puppet::Util::Windows
     attach_function_private :QueryServiceConfigW,
       [:handle, :lpbyte, :dword, :lpdword], :win32_bool
 
-    # https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-queryserviceconfig2w
-    # BOOL QueryServiceConfig2W(
-    #   SC_HANDLE hService,
-    #   DWORD     dwInfoLevel,
-    #   LPBYTE    lpBuffer,
-    #   DWORD     cbBufSize,
-    #   LPDWORD   pcbBytesNeeded
-    # );
-    ffi_lib :advapi32
-    attach_function_private :QueryServiceConfig2W,
-      [:handle, :dword, :lpbyte, :dword, :lpdword], :win32_bool
-
     # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-startservicew
     # BOOL StartServiceW(
     #   SC_HANDLE hService,
@@ -1085,15 +735,6 @@ module Puppet::Util::Windows
         :lpcwstr
       ], :win32_bool
 
-    # https://docs.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-changeserviceconfig2w
-    # BOOL ChangeServiceConfig2W(
-    #   SC_HANDLE hService,
-    #   DWORD     dwInfoLevel,
-    #   LPVOID    lpInfo
-    # );
-    ffi_lib :advapi32
-    attach_function_private :ChangeServiceConfig2W,
-      [:handle, :dword, :lpvoid], :win32_bool
 
     # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-enumservicesstatusexw
     # BOOL EnumServicesStatusExW(