puppet 6.0.5-x64-mingw32 → 8.8.1-x64-mingw32

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

@@ -1,5 +1,7 @@
-require 'puppet/util/windows'
-require 'ffi'
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative '../../../puppet/ffi/windows'
 
 module Puppet::Util::Windows
   # This module is designed to provide an API between the windows system and puppet for
@@ -7,297 +9,37 @@ module Puppet::Util::Windows
   #
   # for an overview of the service state transitions see: https://docs.microsoft.com/en-us/windows/desktop/Services/service-status-transitions
   module Service
-    extend FFI::Library
     extend Puppet::Util::Windows::String
 
-    FILE = Puppet::Util::Windows::File
-
-    # integer value of the floor for timeouts when waiting for service pending states.
-    # puppet will wait the length of dwWaitHint if it is longer than this value, but
-    # 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
-    SERVICE_CONTROL_PAUSE                 = 0x00000002
-    SERVICE_CONTROL_CONTINUE              = 0x00000003
-    SERVICE_CONTROL_INTERROGATE           = 0x00000004
-    SERVICE_CONTROL_SHUTDOWN              = 0x00000005
-    SERVICE_CONTROL_PARAMCHANGE           = 0x00000006
-    SERVICE_CONTROL_NETBINDADD            = 0x00000007
-    SERVICE_CONTROL_NETBINDREMOVE         = 0x00000008
-    SERVICE_CONTROL_NETBINDENABLE         = 0x00000009
-    SERVICE_CONTROL_NETBINDDISABLE        = 0x0000000A
-    SERVICE_CONTROL_DEVICEEVENT           = 0x0000000B
-    SERVICE_CONTROL_HARDWAREPROFILECHANGE = 0x0000000C
-    SERVICE_CONTROL_POWEREVENT            = 0x0000000D
-    SERVICE_CONTROL_SESSIONCHANGE         = 0x0000000E
-    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
-    SERVICE_AUTO_START = 0x00000002
-    SERVICE_BOOT_START = 0x00000000
-    SERVICE_DEMAND_START = 0x00000003
-    SERVICE_DISABLED = 0x00000004
-    SERVICE_SYSTEM_START = 0x00000001
-    SERVICE_START_TYPES = {
-      SERVICE_AUTO_START => :SERVICE_AUTO_START,
-      SERVICE_BOOT_START => :SERVICE_BOOT_START,
-      SERVICE_DEMAND_START => :SERVICE_DEMAND_START,
-      SERVICE_DISABLED => :SERVICE_DISABLED,
-      SERVICE_SYSTEM_START => :SERVICE_SYSTEM_START,
-    }
-
-    # Service type codes
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-changeserviceconfigw
-    SERVICE_FILE_SYSTEM_DRIVER  = 0x00000002
-    SERVICE_KERNEL_DRIVER       = 0x00000001
-    SERVICE_WIN32_OWN_PROCESS   = 0x00000010
-    SERVICE_WIN32_SHARE_PROCESS = 0x00000020
-    SERVICE_USER_OWN_PROCESS    = 0x00000050
-    SERVICE_USER_SHARE_PROCESS  = 0x00000060
-    # Available only if service is also SERVICE_WIN32_OWN_PROCESS or SERVICE_WIN32_SHARE_PROCESS
-    SERVICE_INTERACTIVE_PROCESS = 0x00000100
-    ALL_SERVICE_TYPES =
-      SERVICE_FILE_SYSTEM_DRIVER |
-      SERVICE_KERNEL_DRIVER |
-      SERVICE_WIN32_OWN_PROCESS |
-      SERVICE_WIN32_SHARE_PROCESS
-
-    # Current state codes
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_service_status_process
-    SERVICE_CONTINUE_PENDING = 0x00000005
-    SERVICE_PAUSE_PENDING    = 0x00000006
-    SERVICE_PAUSED           = 0x00000007
-    SERVICE_RUNNING          = 0x00000004
-    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_CONTINUE_PENDING => :SERVICE_CONTINUE_PENDING,
-      SERVICE_PAUSE_PENDING => :SERVICE_PAUSE_PENDING,
-      SERVICE_PAUSED => :SERVICE_PAUSED,
-      SERVICE_RUNNING => :SERVICE_RUNNING,
-      SERVICE_START_PENDING => :SERVICE_START_PENDING,
-      SERVICE_STOP_PENDING => :SERVICE_STOP_PENDING,
-      SERVICE_STOPPED => :SERVICE_STOPPED,
-    }
-
-    # Service accepts control codes
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_service_status_process
-    SERVICE_ACCEPT_STOP                  = 0x00000001
-    SERVICE_ACCEPT_PAUSE_CONTINUE        = 0x00000002
-    SERVICE_ACCEPT_SHUTDOWN              = 0x00000004
-    SERVICE_ACCEPT_PARAMCHANGE           = 0x00000008
-    SERVICE_ACCEPT_NETBINDCHANGE         = 0x00000010
-    SERVICE_ACCEPT_HARDWAREPROFILECHANGE = 0x00000020
-    SERVICE_ACCEPT_POWEREVENT            = 0x00000040
-    SERVICE_ACCEPT_SESSIONCHANGE         = 0x00000080
-    SERVICE_ACCEPT_PRESHUTDOWN           = 0x00000100
-    SERVICE_ACCEPT_TIMECHANGE            = 0x00000200
-    SERVICE_ACCEPT_TRIGGEREVENT          = 0x00000400
-    SERVICE_ACCEPT_USER_LOGOFF           = 0x00000800
-
-    # Service manager access codes
-    # https://docs.microsoft.com/en-us/windows/desktop/Services/service-security-and-access-rights
-    SC_MANAGER_CREATE_SERVICE     = 0x00000002
-    SC_MANAGER_CONNECT            = 0x00000001
-    SC_MANAGER_ENUMERATE_SERVICE  = 0x00000004
-    SC_MANAGER_LOCK               = 0x00000008
-    SC_MANAGER_MODIFY_BOOT_CONFIG = 0x00000020
-    SC_MANAGER_QUERY_LOCK_STATUS  = 0x00000010
-    SC_MANAGER_ALL_ACCESS         =
-      FILE::STANDARD_RIGHTS_REQUIRED |
-      SC_MANAGER_CREATE_SERVICE      |
-      SC_MANAGER_CONNECT             |
-      SC_MANAGER_ENUMERATE_SERVICE   |
-      SC_MANAGER_LOCK                |
-      SC_MANAGER_MODIFY_BOOT_CONFIG  |
-      SC_MANAGER_QUERY_LOCK_STATUS
-
-
-    # Service access codes
-    # https://docs.microsoft.com/en-us/windows/desktop/Services/service-security-and-access-rights
-    SERVICE_CHANGE_CONFIG        = 0x0002
-    SERVICE_ENUMERATE_DEPENDENTS = 0x0008
-    SERVICE_INTERROGATE          = 0x0080
-    SERVICE_PAUSE_CONTINUE       = 0x0040
-    SERVICE_QUERY_STATUS         = 0x0004
-    SERVICE_QUERY_CONFIG         = 0x0001
-    SERVICE_START                = 0x0010
-    SERVICE_STOP                 = 0x0020
-    SERVICE_USER_DEFINED_CONTROL = 0x0100
-    SERVICE_ALL_ACCESS           =
-      FILE::STANDARD_RIGHTS_REQUIRED |
-      SERVICE_CHANGE_CONFIG          |
-      SERVICE_ENUMERATE_DEPENDENTS   |
-      SERVICE_INTERROGATE            |
-      SERVICE_PAUSE_CONTINUE         |
-      SERVICE_QUERY_STATUS           |
-      SERVICE_QUERY_CONFIG           |
-      SERVICE_START                  |
-      SERVICE_STOP                   |
-      SERVICE_USER_DEFINED_CONTROL
-
-    # Service config codes
-    # From the windows 10 SDK:
-    # //
-    # // Value to indicate no change to an optional parameter
-    # //
-    # #define SERVICE_NO_CHANGE              0xffffffff
-    SERVICE_NO_CHANGE = 0xffffffff
-
-    # Service enum codes
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-enumservicesstatusexa
-    SERVICE_ACTIVE = 0x00000001
-    SERVICE_INACTIVE = 0x00000002
-    SERVICE_STATE_ALL =
-      SERVICE_ACTIVE |
-      SERVICE_INACTIVE
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_enum_service_status_processw
-    SERVICENAME_MAX = 256
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_service_status_process
-    # typedef struct _SERVICE_STATUS_PROCESS {
-    #   DWORD dwServiceType;
-    #   DWORD dwCurrentState;
-    #   DWORD dwControlsAccepted;
-    #   DWORD dwWin32ExitCode;
-    #   DWORD dwServiceSpecificExitCode;
-    #   DWORD dwCheckPoint;
-    #   DWORD dwWaitHint;
-    #   DWORD dwProcessId;
-    #   DWORD dwServiceFlags;
-    # } SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;
-    class SERVICE_STATUS_PROCESS < FFI::Struct
-      layout(
-        :dwServiceType, :dword,
-        :dwCurrentState, :dword,
-        :dwControlsAccepted, :dword,
-        :dwWin32ExitCode, :dword,
-        :dwServiceSpecificExitCode, :dword,
-        :dwCheckPoint, :dword,
-        :dwWaitHint, :dword,
-        :dwProcessId, :dword,
-        :dwServiceFlags, :dword
-      )
-    end
+    include Puppet::FFI::Windows::Constants
+    extend Puppet::FFI::Windows::Constants
 
+    include Puppet::FFI::Windows::Structs
+    extend Puppet::FFI::Windows::Structs
 
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/ns-winsvc-_enum_service_status_processw
-    # typedef struct _ENUM_SERVICE_STATUS_PROCESSW {
-    #   LPWSTR                 lpServiceName;
-    #   LPWSTR                 lpDisplayName;
-    #   SERVICE_STATUS_PROCESS ServiceStatusProcess;
-    # } ENUM_SERVICE_STATUS_PROCESSW, *LPENUM_SERVICE_STATUS_PROCESSW;
-    class ENUM_SERVICE_STATUS_PROCESSW < FFI::Struct
-      layout(
-        :lpServiceName, :pointer,
-        :lpDisplayName, :pointer,
-        :ServiceStatusProcess, SERVICE_STATUS_PROCESS
-      )
-    end
-
-    # typedef struct _SERVICE_STATUS {
-    #   DWORD dwServiceType;
-    #   DWORD dwCurrentState;
-    #   DWORD dwControlsAccepted;
-    #   DWORD dwWin32ExitCode;
-    #   DWORD dwServiceSpecificExitCode;
-    #   DWORD dwCheckPoint;
-    #   DWORD dwWaitHint;
-    # } SERVICE_STATUS, *LPSERVICE_STATUS;
-    class SERVICE_STATUS < FFI::Struct
-      layout(
-        :dwServiceType, :dword,
-        :dwCurrentState, :dword,
-        :dwControlsAccepted, :dword,
-        :dwWin32ExitCode, :dword,
-        :dwServiceSpecificExitCode, :dword,
-        :dwCheckPoint, :dword,
-        :dwWaitHint, :dword,
-      )
-    end
-
-    # typedef struct _QUERY_SERVICE_CONFIGW {
-    #   DWORD  dwServiceType;
-    #   DWORD  dwStartType;
-    #   DWORD  dwErrorControl;
-    #   LPWSTR lpBinaryPathName;
-    #   LPWSTR lpLoadOrderGroup;
-    #   DWORD  dwTagId;
-    #   LPWSTR lpDependencies;
-    #   LPWSTR lpServiceStartName;
-    #   LPWSTR lpDisplayName;
-    # } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
-    class QUERY_SERVICE_CONFIGW < FFI::Struct
-      layout(
-        :dwServiceType, :dword,
-        :dwStartType, :dword,
-        :dwErrorControl, :dword,
-        :lpBinaryPathName, :pointer,
-        :lpLoadOrderGroup, :pointer,
-        :dwTagId, :dword,
-        :lpDependencies, :pointer,
-        :lpServiceStartName, :pointer,
-        :lpDisplayName, :pointer,
-      )
-    end
+    include Puppet::FFI::Windows::Functions
+    extend Puppet::FFI::Windows::Functions
 
     # Returns true if the service exists, false otherwise.
     #
-    # @param [:string] service_name name of the service
+    # @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
     #
-    # @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 }
+    # @param [String] service_name name of the service to start
+    # @param optional [Integer] timeout the minumum number of seconds to wait before timing out
+    def start(service_name, timeout: DEFAULT_TIMEOUT)
+      Puppet.debug _("Starting the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
 
       valid_initial_states = [
         SERVICE_STOP_PENDING,
@@ -305,7 +47,7 @@ module Puppet::Util::Windows
         SERVICE_START_PENDING
       ]
 
-      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING) do |service|
+      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING, timeout) do |service|
         if StartServiceW(service, 0, FFI::Pointer::NULL) == FFI::WIN32_FALSE
           raise Puppet::Util::Windows::Error, _("Failed to start the service")
         end
@@ -317,13 +59,14 @@ module Puppet::Util::Windows
 
     # Stop 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 }
+    # @param [String] service_name name of the service to stop
+    # @param optional [Integer] timeout the minumum number of seconds to wait before timing out
+    def stop(service_name, timeout: DEFAULT_TIMEOUT)
+      Puppet.debug _("Stopping the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
 
       valid_initial_states = SERVICE_STATES.keys - [SERVICE_STOPPED]
 
-      transition_service_state(service_name, valid_initial_states, SERVICE_STOPPED) do |service|
+      transition_service_state(service_name, valid_initial_states, SERVICE_STOPPED, timeout) do |service|
         send_service_control_signal(service, SERVICE_CONTROL_STOP)
       end
 
@@ -333,9 +76,10 @@ module Puppet::Util::Windows
 
     # 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 }
+    # @param [String] service_name name of the service to resume
+    # @param optional [Integer] :timeout the minumum number of seconds to wait before timing out
+    def resume(service_name, timeout: DEFAULT_TIMEOUT)
+      Puppet.debug _("Resuming the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
 
       valid_initial_states = [
         SERVICE_PAUSE_PENDING,
@@ -343,10 +87,10 @@ module Puppet::Util::Windows
         SERVICE_CONTINUE_PENDING
       ]
 
-      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING) do |service|
+      transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING, timeout) 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)
+        wait_on_pending_state(service, SERVICE_PAUSE_PENDING, timeout)
 
         send_service_control_signal(service, SERVICE_CONTROL_CONTINUE)
       end
@@ -357,7 +101,7 @@ module Puppet::Util::Windows
 
     # Query the state of a service using QueryServiceStatusEx
     #
-    # @param [:string] service_name name of the service to query
+    # @param [string] service_name name of the service to query
     # @return [string] the status of the service
     def service_state(service_name)
       state = nil
@@ -367,15 +111,17 @@ module Puppet::Util::Windows
         end
       end
       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, _("Unknown Service state '%{current_state}' for '%{service_name}'") % { current_state: state.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
+    # @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
@@ -384,48 +130,76 @@ module Puppet::Util::Windows
           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
+      end
       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, _("Unknown start type '%{start_type}' for '%{service_name}'") % { start_type: start_type.to_s, service_name: service_name }
       end
+
       start_type
     end
     module_function :service_start_type
 
-    # Change the startup mode of a windows service
+    # Query the configuration of a service using QueryServiceConfigW
+    # to find its current logon account
     #
-    # @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
-    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})
+    # @return [String] logon_account account currently set for the service's logon
+    #  in the format "DOMAIN\Account" or ".\Account" if it's a local account
+    def logon_account(service_name)
+      open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_CONFIG) do |service|
+        query_config(service) do |config|
+          return config[:lpServiceStartName].read_arbitrary_wide_string_up_to(Puppet::Util::Windows::ADSI::User::MAX_USERNAME_LENGTH)
+        end
       end
+    end
+    module_function :logon_account
+
+    # Set the startup configuration of a windows service
+    #
+    # @param [String] service_name the name of the service to modify
+    # @param [Hash] options the configuration to be applied. Expected option keys:
+    #   - [Integer] 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
+    #   - [String] logon_account the account to be used by the service for logon
+    #   - [String] logon_password the provided logon_account's password to be used by the service for logon
+    #   - [Bool] delayed whether the service should be started with a delay
+    def set_startup_configuration(service_name, options: {})
+      options[:startup_type] = SERVICE_START_TYPES.key(options[:startup_type]) || SERVICE_NO_CHANGE
+      options[:logon_account] = wide_string(options[:logon_account]) || FFI::Pointer::NULL
+      options[:logon_password] = wide_string(options[:logon_password]) || FFI::Pointer::NULL
+
       open_service(service_name, SC_MANAGER_CONNECT, SERVICE_CHANGE_CONFIG) do |service|
-        # Currently the only thing puppet's API can really manage
-        # in this list is dwStartType (the third param). Thus no
-        # generic function was written to make use of all the params
-        # since the API as-is couldn't use them anyway
         success = ChangeServiceConfigW(
           service,
-          SERVICE_NO_CHANGE,  # dwServiceType
-          startup_code,       # dwStartType
-          SERVICE_NO_CHANGE,  # dwErrorControl
-          FFI::Pointer::NULL, # lpBinaryPathName
-          FFI::Pointer::NULL, # lpLoadOrderGroup
-          FFI::Pointer::NULL, # lpdwTagId
-          FFI::Pointer::NULL, # lpDependencies
-          FFI::Pointer::NULL, # lpServiceStartName
-          FFI::Pointer::NULL, # lpPassword
-          FFI::Pointer::NULL  # lpDisplayName
+          SERVICE_NO_CHANGE,        # dwServiceType
+          options[:startup_type],   # dwStartType
+          SERVICE_NO_CHANGE,        # dwErrorControl
+          FFI::Pointer::NULL,       # lpBinaryPathName
+          FFI::Pointer::NULL,       # lpLoadOrderGroup
+          FFI::Pointer::NULL,       # lpdwTagId
+          FFI::Pointer::NULL,       # lpDependencies
+          options[:logon_account],  # lpServiceStartName
+          options[:logon_password], # lpPassword
+          FFI::Pointer::NULL        # lpDisplayName
         )
         if success == FFI::WIN32_FALSE
-          raise Puppet::Util::Windows::Error.new(_("Failed to update service configuration"))
+          raise Puppet::Util::Windows::Error, _("Failed to update service configuration")
         end
       end
+
+      if options[:startup_type]
+        options[:delayed] ||= false
+        set_startup_mode_delayed(service_name, options[:delayed])
+      end
     end
-    module_function :set_startup_mode
+    module_function :set_startup_configuration
 
     # enumerate over all services in all states and return them as a hash
     #
@@ -481,8 +255,9 @@ module Puppet::Util::Windows
                   FFI::Pointer::NULL
                 )
                 if success == FFI::WIN32_FALSE
-                  raise Puppet::Util::Windows::Error.new(_("Failed to fetch services"))
+                  raise Puppet::Util::Windows::Error, _("Failed to fetch services")
                 end
+
                 # Now that the buffer is populated with services
                 # we pull the data from memory using pointer arithmetic:
                 # the number of services returned by the function is
@@ -530,7 +305,8 @@ module Puppet::Util::Windows
         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
+          raise Puppet::Util::Windows::Error, _("Failed to open a handle to the service") if service == FFI::Pointer::NULL_HANDLE
+
           result = yield service
         end
 
@@ -547,7 +323,8 @@ module Puppet::Util::Windows
       # @param [Integer] scm_access code corresponding to the access type requested for the scm
       def open_scm(scm_access, &block)
         scm = OpenSCManagerW(FFI::Pointer::NULL, FFI::Pointer::NULL, scm_access)
-        raise Puppet::Util::Windows::Error.new(_("Failed to open a handle to the service control manager")) if scm == FFI::Pointer::NULL_HANDLE
+        raise Puppet::Util::Windows::Error, _("Failed to open a handle to the service control manager") if scm == FFI::Pointer::NULL_HANDLE
+
         yield scm
       ensure
         CloseServiceHandle(scm)
@@ -560,8 +337,9 @@ module Puppet::Util::Windows
       #
       # @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)
+      # @param [Integer] final_state the state that the service will transition to
+      # @param [Integer] timeout the minumum number of seconds to wait before timing out
+      def transition_service_state(service_name, valid_initial_states, final_state, timeout, &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|
@@ -592,8 +370,8 @@ module Puppet::Util::Windows
               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)
+              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, timeout)
 
               next
             end
@@ -609,7 +387,7 @@ module Puppet::Util::Windows
             # 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)
+              wait_on_pending_state(service, initial_state, timeout)
               initial_state = FINAL_STATES[initial_state]
             end
 
@@ -618,7 +396,7 @@ module Puppet::Util::Windows
             yield service
 
             Puppet.debug _("Waiting for the transition to finish")
-            wait_on_state_transition(service, initial_state, final_state)
+            wait_on_state_transition(service, initial_state, final_state, timeout)
           end
         end
       rescue => detail
@@ -661,8 +439,9 @@ module Puppet::Util::Windows
               bytes_pointer
             )
             if success == FFI::WIN32_FALSE
-              raise Puppet::Util::Windows::Error.new(_("Service query failed"))
+              raise Puppet::Util::Windows::Error, _("Service query failed")
             end
+
             yield status
           end
         end
@@ -697,14 +476,92 @@ module Puppet::Util::Windows
               bytes_pointer
             )
             if success == FFI::WIN32_FALSE
-              raise Puppet::Util::Windows::Error.new(_("Service query failed"))
+              raise Puppet::Util::Windows::Error, _("Service query failed")
             end
+
             yield config
           end
         end
       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, _("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, _("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
       #
@@ -726,7 +583,8 @@ module Puppet::Util::Windows
       # @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)
+      # @param [Integer] timeout the minumum number of seconds to wait before timing out
+      def wait_on_state_transition(service, initial_state, final_state, timeout)
         # 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
@@ -742,14 +600,15 @@ module Puppet::Util::Windows
         # Wait for the transition to finish
         state = nil
         elapsed_time = 0
-        while elapsed_time <= DEFAULT_TIMEOUT
+        while elapsed_time <= 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)
+              wait_on_pending_state(service, pending_state, timeout)
               return
             end
             sleep(1)
@@ -773,7 +632,8 @@ module Puppet::Util::Windows
       #
       # @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)
+      # @param [Integer] timeout the minumum number of seconds to wait before timing out
+      def wait_on_pending_state(service, pending_state, timeout)
         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] }
@@ -800,8 +660,8 @@ module Puppet::Util::Windows
               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
+              wait_hint = milliseconds_to_seconds(status[:dwWaitHint])
+              timeout = wait_hint < timeout ? timeout : wait_hint
 
               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] }
@@ -844,141 +704,5 @@ module Puppet::Util::Windows
       end
       private :milliseconds_to_seconds
     end
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-openscmanagerw
-    # SC_HANDLE OpenSCManagerW(
-    #   LPCWSTR lpMachineName,
-    #   LPCWSTR lpDatabaseName,
-    #   DWORD   dwDesiredAccess
-    # );
-    ffi_lib :advapi32
-    attach_function_private :OpenSCManagerW,
-      [:lpcwstr, :lpcwstr, :dword], :handle
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-openservicew
-    # SC_HANDLE OpenServiceW(
-    #   SC_HANDLE hSCManager,
-    #   LPCWSTR   lpServiceName,
-    #   DWORD     dwDesiredAccess
-    # );
-    ffi_lib :advapi32
-    attach_function_private :OpenServiceW,
-      [:handle, :lpcwstr, :dword], :handle
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-closeservicehandle
-    # BOOL CloseServiceHandle(
-    #   SC_HANDLE hSCObject
-    # );
-    ffi_lib :advapi32
-    attach_function_private :CloseServiceHandle,
-      [:handle], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-queryservicestatusex
-    # BOOL QueryServiceStatusEx(
-    #   SC_HANDLE      hService,
-    #   SC_STATUS_TYPE InfoLevel,
-    #   LPBYTE         lpBuffer,
-    #   DWORD          cbBufSize,
-    #   LPDWORD        pcbBytesNeeded
-    # );
-    SC_STATUS_TYPE = enum(
-      :SC_STATUS_PROCESS_INFO, 0,
-    )
-    ffi_lib :advapi32
-    attach_function_private :QueryServiceStatusEx,
-      [:handle, SC_STATUS_TYPE, :lpbyte, :dword, :lpdword], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-queryserviceconfigw
-    # BOOL QueryServiceConfigW(
-    #   SC_HANDLE               hService,
-    #   LPQUERY_SERVICE_CONFIGW lpServiceConfig,
-    #   DWORD                   cbBufSize,
-    #   LPDWORD                 pcbBytesNeeded
-    # );
-    ffi_lib :advapi32
-    attach_function_private :QueryServiceConfigW,
-      [:handle, :lpbyte, :dword, :lpdword], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/Winsvc/nf-winsvc-startservicew
-    # BOOL StartServiceW(
-    #   SC_HANDLE hService,
-    #   DWORD     dwNumServiceArgs,
-    #   LPCWSTR   *lpServiceArgVectors
-    # );
-    ffi_lib :advapi32
-    attach_function_private :StartServiceW,
-      [:handle, :dword, :pointer], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-controlservice
-    # BOOL ControlService(
-    #   SC_HANDLE        hService,
-    #   DWORD            dwControl,
-    #   LPSERVICE_STATUS lpServiceStatus
-    # );
-    ffi_lib :advapi32
-    attach_function_private :ControlService,
-      [:handle, :dword, :pointer], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-changeserviceconfigw
-    # BOOL ChangeServiceConfigW(
-    #   SC_HANDLE hService,
-    #   DWORD     dwServiceType,
-    #   DWORD     dwStartType,
-    #   DWORD     dwErrorControl,
-    #   LPCWSTR   lpBinaryPathName,
-    #   LPCWSTR   lpLoadOrderGroup,
-    #   LPDWORD   lpdwTagId,
-    #   LPCWSTR   lpDependencies,
-    #   LPCWSTR   lpServiceStartName,
-    #   LPCWSTR   lpPassword,
-    #   LPCWSTR   lpDisplayName
-    # );
-    ffi_lib :advapi32
-    attach_function_private :ChangeServiceConfigW,
-      [
-        :handle,
-        :dword,
-        :dword,
-        :dword,
-        :lpcwstr,
-        :lpcwstr,
-        :lpdword,
-        :lpcwstr,
-        :lpcwstr,
-        :lpcwstr,
-        :lpcwstr
-      ], :win32_bool
-
-
-    # https://docs.microsoft.com/en-us/windows/desktop/api/winsvc/nf-winsvc-enumservicesstatusexw
-    # BOOL EnumServicesStatusExW(
-    #   SC_HANDLE    hSCManager,
-    #   SC_ENUM_TYPE InfoLevel,
-    #   DWORD        dwServiceType,
-    #   DWORD        dwServiceState,
-    #   LPBYTE       lpServices,
-    #   DWORD        cbBufSize,
-    #   LPDWORD      pcbBytesNeeded,
-    #   LPDWORD      lpServicesReturned,
-    #   LPDWORD      lpResumeHandle,
-    #   LPCWSTR      pszGroupName
-    # );
-    SC_ENUM_TYPE = enum(
-      :SC_ENUM_PROCESS_INFO, 0,
-    )
-    ffi_lib :advapi32
-    attach_function_private :EnumServicesStatusExW,
-      [
-        :handle,
-        SC_ENUM_TYPE,
-        :dword,
-        :dword,
-        :lpbyte,
-        :dword,
-        :lpdword,
-        :lpdword,
-        :lpdword,
-        :lpcwstr
-      ], :win32_bool
   end
 end