win32-srv 1.0.0

data/lib/win32/service.rb

@@ -0,0 +1,1666 @@
+require "ffi/win32/extensions"
+require_relative "windows/version"
+require_relative "windows/constants"
+require_relative "windows/structs"
+require_relative "windows/functions"
+
+# The Win32 module serves as a namespace only.
+module Win32
+
+  # The Service class encapsulates services controller actions, such as
+  # creating, starting, configuring or deleting services.
+  class Service
+    include Windows::ServiceConstants
+    include Windows::ServiceStructs
+    include Windows::ServiceFunctions
+
+    extend Windows::ServiceStructs
+    extend Windows::ServiceFunctions
+
+    # SCM security and access rights
+
+    # Includes STANDARD_RIGHTS_REQUIRED, in addition to all other rights
+    MANAGER_ALL_ACCESS = SC_MANAGER_ALL_ACCESS
+
+    # Required to call the CreateService function
+    MANAGER_CREATE_SERVICE = SC_MANAGER_CREATE_SERVICE
+
+    # Required to connect to the service control manager.
+    MANAGER_CONNECT = SC_MANAGER_CONNECT
+
+    # Required to call the EnumServicesStatusEx function to list services
+    MANAGER_ENUMERATE_SERVICE = SC_MANAGER_ENUMERATE_SERVICE
+
+    # Required to call the LockServiceDatabase function
+    MANAGER_LOCK = SC_MANAGER_LOCK
+
+    # Required to call the NotifyBootConfigStatus function
+    MANAGER_MODIFY_BOOT_CONFIG = SC_MANAGER_MODIFY_BOOT_CONFIG
+
+    # Required to call the QueryServiceLockStatus function
+    MANAGER_QUERY_LOCK_STATUS = SC_MANAGER_QUERY_LOCK_STATUS
+
+    # Includes STANDARD_RIGHTS_REQUIRED in addition to all access rights
+    ALL_ACCESS = SERVICE_ALL_ACCESS
+
+    # Required to call functions that configure existing services
+    CHANGE_CONFIG = SERVICE_CHANGE_CONFIG
+
+    # Required to enumerate all the services dependent on the service
+    ENUMERATE_DEPENDENTS = SERVICE_ENUMERATE_DEPENDENTS
+
+    # Required to make a service report its status immediately
+    INTERROGATE = SERVICE_INTERROGATE
+
+    # Required to control a service with a pause or resume
+    PAUSE_CONTINUE = SERVICE_PAUSE_CONTINUE
+
+    # Required to be able to gather configuration information about a service
+    QUERY_CONFIG = SERVICE_QUERY_CONFIG
+
+    # Required to be ask the SCM about the status of a service
+    QUERY_STATUS = SERVICE_QUERY_STATUS
+
+    # Required to call the StartService function to start the service.
+    START = SERVICE_START
+
+    # Required to call the ControlService function to stop the service.
+    STOP = SERVICE_STOP
+
+    # Required to call ControlService with a user defined control code
+    USER_DEFINED_CONTROL = SERVICE_USER_DEFINED_CONTROL
+
+    # Service Types
+
+    # Driver service
+    KERNEL_DRIVER = SERVICE_KERNEL_DRIVER
+
+    # File system driver service
+    FILE_SYSTEM_DRIVER = SERVICE_FILE_SYSTEM_DRIVER
+
+    # Service that runs in its own process
+    WIN32_OWN_PROCESS = SERVICE_WIN32_OWN_PROCESS
+
+    # Service that shares a process with one or more other services.
+    WIN32_SHARE_PROCESS = SERVICE_WIN32_SHARE_PROCESS
+
+    # The service can interact with the desktop
+    INTERACTIVE_PROCESS = SERVICE_INTERACTIVE_PROCESS
+
+    DRIVER = SERVICE_DRIVER
+    TYPE_ALL = SERVICE_TYPE_ALL
+
+    # Service start options
+
+    # A service started automatically by the SCM during system startup
+    BOOT_START = SERVICE_BOOT_START
+
+    # A device driver started by the IoInitSystem function. Drivers only
+    SYSTEM_START = SERVICE_SYSTEM_START
+
+    # A service started automatically by the SCM during system startup
+    AUTO_START = SERVICE_AUTO_START
+
+    # A service started by the SCM when a process calls StartService
+    DEMAND_START = SERVICE_DEMAND_START
+
+    # A service that cannot be started
+    DISABLED = SERVICE_DISABLED
+
+    # Error control
+
+    # Error logged, startup continues
+    ERROR_IGNORE = SERVICE_ERROR_IGNORE
+
+    # Error logged, pop up message, startup continues
+    ERROR_NORMAL   = SERVICE_ERROR_NORMAL
+
+    # Error logged, startup continues, system restarted last known good config
+    ERROR_SEVERE   = SERVICE_ERROR_SEVERE
+
+    # Error logged, startup fails, system restarted last known good config
+    ERROR_CRITICAL = SERVICE_ERROR_CRITICAL
+
+    # Current state
+
+    # Service is not running
+    STOPPED = SERVICE_STOPPED
+
+    # Service has received a start signal but is not yet running
+    START_PENDING = SERVICE_START_PENDING
+
+    # Service has received a stop signal but is not yet stopped
+    STOP_PENDING  = SERVICE_STOP_PENDING
+
+    # Service is running
+    RUNNING = SERVICE_RUNNING
+
+    # Service has received a signal to resume but is not yet running
+    CONTINUE_PENDING = SERVICE_CONTINUE_PENDING
+
+    # Service has received a signal to pause but is not yet paused
+    PAUSE_PENDING = SERVICE_PAUSE_PENDING
+
+    # Service is paused
+    PAUSED = SERVICE_PAUSED
+
+    # Service controls
+
+    # Notifies service that it should stop
+    CONTROL_STOP = SERVICE_CONTROL_STOP
+
+    # Notifies service that it should pause
+    CONTROL_PAUSE = SERVICE_CONTROL_PAUSE
+
+    # Notifies service that it should resume
+    CONTROL_CONTINUE = SERVICE_CONTROL_CONTINUE
+
+    # Notifies service that it should return its current status information
+    CONTROL_INTERROGATE = SERVICE_CONTROL_INTERROGATE
+
+    # Notifies a service that its parameters have changed
+    CONTROL_PARAMCHANGE = SERVICE_CONTROL_PARAMCHANGE
+
+    # Notifies a service that there is a new component for binding
+    CONTROL_NETBINDADD = SERVICE_CONTROL_NETBINDADD
+
+    # Notifies a service that a component for binding has been removed
+    CONTROL_NETBINDREMOVE = SERVICE_CONTROL_NETBINDREMOVE
+
+    # Notifies a service that a component for binding has been enabled
+    CONTROL_NETBINDENABLE = SERVICE_CONTROL_NETBINDENABLE
+
+    # Notifies a service that a component for binding has been disabled
+    CONTROL_NETBINDDISABLE = SERVICE_CONTROL_NETBINDDISABLE
+
+    # Failure actions
+
+    # No action
+    ACTION_NONE = SC_ACTION_NONE
+
+    # Reboot the computer
+    ACTION_REBOOT = SC_ACTION_REBOOT
+
+    # Restart the service
+    ACTION_RESTART = SC_ACTION_RESTART
+
+    # Run a command
+    ACTION_RUN_COMMAND = SC_ACTION_RUN_COMMAND
+
+    # :stopdoc: #
+
+    StatusStruct = Struct.new(
+      "ServiceStatus",
+      :service_type,
+      :current_state,
+      :controls_accepted,
+      :win32_exit_code,
+      :service_specific_exit_code,
+      :check_point,
+      :wait_hint,
+      :interactive,
+      :pid,
+      :service_flags
+    )
+
+    ConfigStruct = Struct.new(
+      "ServiceConfigInfo",
+      :service_type,
+      :start_type,
+      :error_control,
+      :binary_path_name,
+      :load_order_group,
+      :tag_id,
+      :dependencies,
+      :service_start_name,
+      :display_name
+    )
+
+    ServiceStruct = Struct.new(
+      "ServiceInfo",
+      :service_name,
+      :display_name,
+      :service_type,
+      :current_state,
+      :controls_accepted,
+      :win32_exit_code,
+      :service_specific_exit_code,
+      :check_point,
+      :wait_hint,
+      :binary_path_name,
+      :start_type,
+      :error_control,
+      :load_order_group,
+      :tag_id,
+      :start_name,
+      :dependencies,
+      :description,
+      :interactive,
+      :pid,
+      :service_flags,
+      :reset_period,
+      :reboot_message,
+      :command,
+      :num_actions,
+      :actions,
+      :delayed_start
+    )
+
+    # :startdoc: #
+
+    # Creates a new service with the specified +options+. A +service_name+
+    # must be specified or an ArgumentError is raised. A +host+ option may
+    # be specified. If no host is specified the local machine is used.
+    #
+    # Possible Options:
+    #
+    # * service_name           => nil (you must specify)
+    # * host                   => nil (optional)
+    # * display_name           => service_name
+    # * desired_access         => Service::ALL_ACCESS
+    # * service_type           => Service::WIN32_OWN_PROCESS
+    # * start_type             => Service::DEMAND_START
+    # * error_control          => Service::ERROR_NORMAL
+    # * binary_path_name       => nil
+    # * load_order_group       => nil
+    # * dependencies           => nil
+    # * service_start_name     => nil
+    # * password               => nil
+    # * description            => nil
+    # * failure_reset_period   => nil,
+    # * failure_reboot_message => nil,
+    # * failure_command        => nil,
+    # * failure_actions        => nil,
+    # * failure_delay          => 0
+    #
+    # Example:
+    #
+    #    # Configure everything
+    #    Service.new(
+    #      :service_name       => 'some_service',
+    #      :host               => 'localhost',
+    #      :service_type       => Service::WIN32_OWN_PROCESS,
+    #      :description        => 'A custom service I wrote just for fun',
+    #      :start_type         => Service::AUTO_START,
+    #      :error_control      => Service::ERROR_NORMAL,
+    #      :binary_path_name   => 'C:\path\to\some_service.exe',
+    #      :load_order_group   => 'Network',
+    #      :dependencies       => ['W32Time','Schedule'],
+    #      :service_start_name => 'SomeDomain\\User',
+    #      :password           => 'XXXXXXX',
+    #      :display_name       => 'This is some service',
+    #    )
+    #
+    def initialize(options = {})
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options parameter must be a hash"
+      end
+
+      if options.empty?
+        raise ArgumentError, "no options provided"
+      end
+
+      opts = {
+        "display_name"           => nil,
+        "desired_access"         => SERVICE_ALL_ACCESS,
+        "service_type"           => SERVICE_WIN32_OWN_PROCESS,
+        "start_type"             => SERVICE_DEMAND_START,
+        "error_control"          => SERVICE_ERROR_NORMAL,
+        "binary_path_name"       => nil,
+        "load_order_group"       => nil,
+        "dependencies"           => nil,
+        "service_start_name"     => nil,
+        "password"               => nil,
+        "description"            => nil,
+        "failure_reset_period"   => nil,
+        "failure_reboot_message" => nil,
+        "failure_command"        => nil,
+        "failure_actions"        => nil,
+        "failure_delay"          => 0,
+        "host"                   => nil,
+        "service_name"           => nil,
+      }
+
+      # Validate the hash options
+      options.each { |key, value|
+        key = key.to_s.downcase
+        unless opts.include?(key)
+          raise ArgumentError, "Invalid option '#{key}'"
+        end
+
+        opts[key] = value
+      }
+
+      unless opts["service_name"]
+        raise ArgumentError, "No service_name specified"
+      end
+
+      service_name = opts.delete("service_name")
+      host = opts.delete("host")
+
+      raise TypeError unless service_name.is_a?(String)
+      raise TypeError if host && !host.is_a?(String)
+
+      begin
+        handle_scm = OpenSCManager(host, nil, SC_MANAGER_CREATE_SERVICE)
+
+        FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+        # Display name defaults to service_name
+        opts["display_name"] ||= service_name
+
+        dependencies = opts["dependencies"]
+
+        if dependencies && !dependencies.empty?
+          unless dependencies.is_a?(Array) || dependencies.is_a?(String)
+            raise TypeError, "dependencies must be a string or array"
+          end
+
+          if dependencies.is_a?(Array)
+            dependencies = dependencies.join("\000")
+          end
+
+          dependencies += "\000"
+          dependencies = FFI::MemoryPointer.from_string(dependencies)
+        end
+
+        handle_scs = CreateService(
+          handle_scm,
+          service_name,
+          opts["display_name"],
+          opts["desired_access"],
+          opts["service_type"],
+          opts["start_type"],
+          opts["error_control"],
+          opts["binary_path_name"],
+          opts["load_order_group"],
+          nil,
+          dependencies,
+          opts["service_start_name"],
+          opts["password"]
+        )
+
+        FFI.raise_windows_error("CreateService") if handle_scs == 0
+
+        if opts["description"]
+          description = SERVICE_DESCRIPTION.new
+          description[:lpDescription] = FFI::MemoryPointer.from_string(opts["description"])
+
+          bool = ChangeServiceConfig2(
+            handle_scs,
+            SERVICE_CONFIG_DESCRIPTION,
+            description
+          )
+
+          FFI.raise_windows_error("ChangeServiceConfig2") unless bool
+        end
+
+        if opts["failure_reset_period"] || opts["failure_reboot_message"] ||
+            opts["failure_command"] || opts["failure_actions"]
+          self.class.configure_failure_actions(handle_scs, opts)
+        end
+      ensure
+        self.class.close_service_handle(handle_scs)
+        self.class.close_service_handle(handle_scm)
+      end
+
+      self
+    end
+
+    # Configures the named +service+ on +host+, or the local host if no host
+    # is specified. The +options+ parameter is a hash that can contain any
+    # of the following parameters:
+    #
+    # * service_type
+    # * start_type
+    # * error_control
+    # * binary_path_name
+    # * load_order_group
+    # * dependencies
+    # * service_start_name
+    # * password (used with service_start_name)
+    # * display_name
+    # * description
+    # * failure_reset_period
+    # * failure_reboot_message
+    # * failure_command
+    # * failure_actions
+    # * failure_delay
+    #
+    # Examples:
+    #
+    #    # Configure only the display name
+    #    Service.configure(
+    #      :service_name => 'some_service',
+    #      :display_name => 'Test 33'
+    #    )
+    #
+    #    # Configure everything
+    #    Service.configure(
+    #       :service_name       => 'some_service'
+    #       :service_type       => Service::WIN32_OWN_PROCESS,
+    #       :start_type         => Service::AUTO_START,
+    #       :error_control      => Service::ERROR_NORMAL,
+    #       :binary_path_name   => 'C:\path\to\some_service.exe',
+    #       :load_order_group   => 'Network',
+    #       :dependencies       => ['W32Time','Schedule']
+    #       :service_start_name => 'SomeDomain\\User',
+    #       :password           => 'XXXXXXX',
+    #       :display_name       => 'This is some service',
+    #       :description        => 'A custom service I wrote just for fun'
+    #    )
+    #
+    def self.configure(options = {})
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options parameter must be a hash"
+      end
+
+      if options.empty?
+        raise ArgumentError, "no options provided"
+      end
+
+      opts = {
+        "service_type"           => SERVICE_NO_CHANGE,
+        "start_type"             => SERVICE_NO_CHANGE,
+        "error_control"          => SERVICE_NO_CHANGE,
+        "binary_path_name"       => nil,
+        "load_order_group"       => nil,
+        "dependencies"           => nil,
+        "service_start_name"     => nil,
+        "password"               => nil,
+        "display_name"           => nil,
+        "description"            => nil,
+        "failure_reset_period"   => nil,
+        "failure_reboot_message" => nil,
+        "failure_command"        => nil,
+        "failure_actions"        => nil,
+        "failure_delay"          => 0,
+        "service_name"           => nil,
+        "host"                   => nil,
+        "delayed_start"          => false,
+      }
+
+      # Validate the hash options
+      options.each { |key, value|
+        key = key.to_s.downcase
+        unless opts.include?(key)
+          raise ArgumentError, "Invalid option '#{key}'"
+        end
+
+        opts[key] = value
+      }
+
+      unless opts["service_name"]
+        raise ArgumentError, "No service_name specified"
+      end
+
+      service = opts.delete("service_name")
+      host = opts.delete("host")
+
+      raise TypeError unless service.is_a?(String)
+
+      if host
+        raise TypeError unless host.is_a?(String)
+      end
+
+      begin
+        handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+        FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+        desired_access = SERVICE_CHANGE_CONFIG
+
+        if opts["failure_actions"]
+          desired_access |= SERVICE_START
+        end
+
+        handle_scs = OpenService(
+          handle_scm,
+          service,
+          desired_access
+        )
+
+        FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+        dependencies = opts["dependencies"]
+
+        if dependencies && !dependencies.empty?
+          unless dependencies.is_a?(Array) || dependencies.is_a?(String)
+            raise TypeError, "dependencies must be a string or array"
+          end
+
+          if dependencies.is_a?(Array)
+            dependencies = dependencies.join("\000")
+          end
+
+          dependencies += "\000"
+        end
+
+        bool = ChangeServiceConfig(
+          handle_scs,
+          opts["service_type"],
+          opts["start_type"],
+          opts["error_control"],
+          opts["binary_path_name"],
+          opts["load_order_group"],
+          nil,
+          dependencies,
+          opts["service_start_name"],
+          opts["password"],
+          opts["display_name"]
+        )
+
+        FFI.raise_windows_error("ChangeServiceConfig") unless bool
+
+        if opts["description"]
+          description = SERVICE_DESCRIPTION.new
+          description[:lpDescription] = FFI::MemoryPointer.from_string(opts["description"])
+
+          bool = ChangeServiceConfig2(
+            handle_scs,
+            SERVICE_CONFIG_DESCRIPTION,
+            description
+          )
+
+          FFI.raise_windows_error("ChangeServiceConfig2") unless bool
+        end
+
+        if opts["delayed_start"]
+          delayed_start = SERVICE_DELAYED_AUTO_START_INFO.new
+          delayed_start[:fDelayedAutostart] = opts["delayed_start"]
+
+          bool = ChangeServiceConfig2(
+            handle_scs,
+            SERVICE_CONFIG_DELAYED_AUTO_START_INFO,
+            delayed_start
+          )
+
+          FFI.raise_windows_error("ChangeServiceConfig2") unless bool
+        end
+
+        if opts["failure_reset_period"] || opts["failure_reboot_message"] ||
+            opts["failure_command"] || opts["failure_actions"]
+          configure_failure_actions(handle_scs, opts)
+        end
+      ensure
+        close_service_handle(handle_scs)
+        close_service_handle(handle_scm)
+      end
+
+      self
+    end
+
+    # Returns whether or not +service+ exists on +host+ or localhost, if
+    # no host is specified.
+    #
+    # Example:
+    #
+    # Service.exists?('W32Time') => true
+    #
+    def self.exists?(service, host = nil)
+      bool = false
+
+      begin
+        handle_scm = OpenSCManager(host, nil, SC_MANAGER_ENUMERATE_SERVICE)
+
+        FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+        handle_scs = OpenService(handle_scm, service, SERVICE_QUERY_STATUS)
+        bool = true if handle_scs > 0
+      ensure
+        close_service_handle(handle_scm)
+        close_service_handle(handle_scs)
+      end
+
+      bool
+    end
+
+    # Returns the display name of the specified service name, i.e. the string
+    # displayed in the Services GUI. Raises a Service::Error if the service
+    # name cannot be found.
+    #
+    # If a +host+ is provided, the information will be retrieved from that
+    # host. Otherwise, the information is pulled from the local host (the
+    # default behavior).
+    #
+    # Example:
+    #
+    # Service.get_display_name('W32Time') => 'Windows Time'
+    #
+    def self.get_display_name(service, host = nil)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      display_name = FFI::MemoryPointer.new(260)
+      display_size = FFI::MemoryPointer.new(:ulong)
+      display_size.write_ulong(display_name.size)
+
+      begin
+        bool = GetServiceDisplayName(
+          handle_scm,
+          service,
+          display_name,
+          display_size
+        )
+
+        FFI.raise_windows_error("OpenSCManager") unless bool
+      ensure
+        close_service_handle(handle_scm)
+      end
+
+      display_name.read_string
+    end
+
+    # Returns the service name of the specified service from the provided
+    # +display_name+. Raises a Service::Error if the +display_name+ cannote
+    # be found.
+    #
+    # If a +host+ is provided, the information will be retrieved from that
+    # host. Otherwise, the information is pulled from the local host (the
+    # default behavior).
+    #
+    # Example:
+    #
+    # Service.get_service_name('Windows Time') => 'W32Time'
+    #
+    def self.get_service_name(display_name, host = nil)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      service_name = FFI::MemoryPointer.new(260)
+      service_size = FFI::MemoryPointer.new(:ulong)
+      service_size.write_ulong(service_name.size)
+
+      begin
+        bool = GetServiceKeyName(
+          handle_scm,
+          display_name,
+          service_name,
+          service_size
+        )
+
+        FFI.raise_windows_error("GetServiceKeyName") unless bool
+      ensure
+        close_service_handle(handle_scm)
+      end
+
+      service_name.read_string
+    end
+
+    # Attempts to start the named +service+ on +host+, or the local machine
+    # if no host is provided. If +args+ are provided, they are passed to the
+    # Daemon#service_main method.
+    #
+    # Examples:
+    #
+    #    # Start 'SomeSvc' on the local machine
+    #    Service.start('SomeSvc', nil) => self
+    #
+    #    # Start 'SomeSvc' on host 'foo', passing 'hello' as an argument
+    #    Service.start('SomeSvc', 'foo', 'hello') => self
+    #
+    def self.start(service, host = nil, *args)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      begin
+        handle_scs = OpenService(handle_scm, service, SERVICE_START)
+
+        FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+        num_args = 0
+
+        if args.empty?
+          args = nil
+        else
+          str_ptrs = []
+          num_args = args.size
+
+          args.each { |string|
+            str_ptrs << FFI::MemoryPointer.from_string(string)
+          }
+
+          str_ptrs << nil
+
+          vector = FFI::MemoryPointer.new(:pointer, str_ptrs.size)
+
+          str_ptrs.each_with_index { |p, i|
+            vector[i].put_pointer(0, p)
+          }
+        end
+
+        unless StartService(handle_scs, num_args, vector)
+          FFI.raise_windows_error("StartService")
+        end
+
+      ensure
+        close_service_handle(handle_scs)
+        close_service_handle(handle_scm)
+      end
+
+      self
+    end
+
+    # Stops a the given +service+ on +host+, or the local host if no host
+    # is specified. Returns self.
+    #
+    # Note that attempting to stop an already stopped service raises
+    # Service::Error.
+    #
+    # Example:
+    #
+    #    Service.stop('W32Time') => self
+    #
+    def self.stop(service, host = nil)
+      service_signal = SERVICE_STOP
+      control_signal = SERVICE_CONTROL_STOP
+      send_signal(service, host, service_signal, control_signal)
+      self
+    end
+
+    # Pauses the given +service+ on +host+, or the local host if no host
+    # is specified. Returns self
+    #
+    # Note that pausing a service that is already paused will have
+    # no effect and it will not raise an error.
+    #
+    # Be aware that not all services are configured to accept a pause
+    # command. Attempting to pause a service that isn't setup to receive
+    # a pause command will raise an error.
+    #
+    # Example:
+    #
+    #    Service.pause('Schedule') => self
+    #
+    def self.pause(service, host = nil)
+      service_signal = SERVICE_PAUSE_CONTINUE
+      control_signal = SERVICE_CONTROL_PAUSE
+      send_signal(service, host, service_signal, control_signal)
+      self
+    end
+
+    # Resume the given +service+ on +host+, or the local host if no host
+    # is specified. Returns self.
+    #
+    # Note that resuming a service that's already running will have no
+    # effect and it will not raise an error.
+    #
+    # Example:
+    #
+    #    Service.resume('Schedule') => self
+    #
+    def self.resume(service, host = nil)
+      service_signal = SERVICE_PAUSE_CONTINUE
+      control_signal = SERVICE_CONTROL_CONTINUE
+      send_signal(service, host, service_signal, control_signal)
+      self
+    end
+
+    # Deletes the specified +service+ from +host+, or the local host if
+    # no host is specified. Returns self.
+    #
+    # Technical note. This method is not instantaneous. The service is first
+    # marked for deletion from the service control manager database. Then all
+    # handles to the service are closed. Then an attempt to stop the service
+    # is made. If the service cannot be stopped, the service control manager
+    # database entry is removed when the system is restarted.
+    #
+    # Example:
+    #
+    #   Service.delete('SomeService') => self
+    #
+    def self.delete(service, host = nil)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_CREATE_SERVICE)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      begin
+        handle_scs = OpenService(handle_scm, service, DELETE)
+
+        FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+        unless DeleteService(handle_scs)
+          FFI.raise_windows_error("DeleteService")
+        end
+      ensure
+        close_service_handle(handle_scs)
+        close_service_handle(handle_scm)
+      end
+
+      self
+    end
+
+    # Returns a ServiceConfigInfo struct containing the configuration
+    # information about +service+ on +host+, or the local host if no
+    # host is specified.
+    #
+    # Example:
+    #
+    #   Service.config_info('W32Time') => <struct ServiceConfigInfo ...>
+    #--
+    # This contains less information that the ServiceInfo struct that
+    # is returned with the Service.services method, but is faster for
+    # looking up basic information for a single service.
+    #
+    def self.config_info(service, host = nil)
+      raise TypeError if host && !host.is_a?(String)
+
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_ENUMERATE_SERVICE)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      begin
+        handle_scs = OpenService(handle_scm, service, SERVICE_QUERY_CONFIG)
+
+        FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+        # First, get the buf size needed
+        bytes = FFI::MemoryPointer.new(:ulong)
+
+        bool = QueryServiceConfig(handle_scs, nil, 0, bytes)
+
+        if !bool && FFI.errno != ERROR_INSUFFICIENT_BUFFER
+          FFI.raise_windows_error("QueryServiceConfig")
+        end
+
+        buf = FFI::MemoryPointer.new(:char, bytes.read_ulong)
+        bytes = FFI::MemoryPointer.new(:ulong)
+
+        bool = QueryServiceConfig(handle_scs, buf, buf.size, bytes)
+
+        struct = QUERY_SERVICE_CONFIG.new(buf) # cast the buffer
+
+        FFI.raise_windows_error("QueryServiceConfig") unless bool
+      ensure
+        close_service_handle(handle_scs)
+        close_service_handle(handle_scm)
+      end
+
+      ConfigStruct.new(
+        get_service_type(struct[:dwServiceType]),
+        get_start_type(struct[:dwStartType]),
+        get_error_control(struct[:dwErrorControl]),
+        struct[:lpBinaryPathName].read_string,
+        struct[:lpLoadOrderGroup].read_string,
+        struct[:dwTagId],
+        struct.dependencies,
+        struct[:lpServiceStartName].read_string,
+        struct[:lpDisplayName].read_string
+      )
+    end
+
+    # Returns a ServiceStatus struct indicating the status of service +name+
+    # on +host+, or the localhost if none is provided.
+    #
+    # Example:
+    #
+    # Service.status('W32Time') => <struct Struct::ServiceStatus ...>
+    #
+    def self.status(service, host = nil)
+      status = SERVICE_STATUS_PROCESS.new
+      bytes  = FFI::MemoryPointer.new(:ulong)
+
+      open_sc_manager(host) do |scm_handle|
+        open_service(scm_handle, service, SERVICE_QUERY_STATUS) do |service_handle|
+          bool = QueryServiceStatusEx(
+            service_handle,
+            SC_STATUS_PROCESS_INFO,
+            status,
+            status.size,
+            bytes
+          )
+
+          FFI.raise_windows_error("QueryServiceStatusEx") unless bool
+        end
+      end
+
+      service_type  = get_service_type(status[:dwServiceType])
+      current_state = get_current_state(status[:dwCurrentState])
+      controls      = get_controls_accepted(status[:dwControlsAccepted])
+      interactive   = status[:dwServiceType] & SERVICE_INTERACTIVE_PROCESS > 0
+
+      status_struct = StatusStruct.new(
+        service_type,
+        current_state,
+        controls,
+        status[:dwWin32ExitCode],
+        status[:dwServiceSpecificExitCode],
+        status[:dwCheckPoint],
+        status[:dwWaitHint],
+        interactive,
+        status[:dwProcessId],
+        status[:dwServiceFlags]
+      )
+
+      status_struct
+    end
+
+    # Enumerates over a list of service types on +host+, or the local
+    # machine if no host is specified, yielding a ServiceInfo struct for
+    # each service.
+    #
+    # If a +group+ is specified, then only those services that belong to
+    # that load order group are enumerated. If an empty string is provided,
+    # then only services that do not belong to any group are enumerated. If
+    # this parameter is nil (the default), group membership is ignored and
+    # all services are enumerated. This value is not case sensitive.
+    #
+    # Examples:
+    #
+    #    # Enumerate over all services on the localhost
+    #    Service.services{ |service| p service }
+    #
+    #    # Enumerate over all services on a remote host
+    #    Service.services('some_host'){ |service| p service }
+    #
+    #    # Enumerate over all 'network' services locally
+    #    Service.services(nil, 'network'){ |service| p service }
+    #
+    def self.services(host = nil, group = nil)
+      unless host.nil?
+        raise TypeError unless host.is_a?(String) # Avoid strange errors
+      end
+
+      unless group.nil?
+        raise TypeError unless group.is_a?(String) # Avoid strange errors
+      end
+
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_ENUMERATE_SERVICE)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      bytes_needed      = FFI::MemoryPointer.new(:ulong)
+      services_returned = FFI::MemoryPointer.new(:ulong)
+      resume_handle     = FFI::MemoryPointer.new(:ulong)
+
+      begin
+        # The first call is used to determine the required buffer size
+        bool = EnumServicesStatusEx(
+          handle_scm,
+          SC_ENUM_PROCESS_INFO,
+          SERVICE_WIN32 | SERVICE_DRIVER,
+          SERVICE_STATE_ALL,
+          nil,
+          0,
+          bytes_needed,
+          services_returned,
+          resume_handle,
+          group
+        )
+
+        if !bool && FFI.errno == ERROR_MORE_DATA
+          service_buf = FFI::MemoryPointer.new(:char, bytes_needed.read_ulong)
+        else
+          FFI.raise_windows_error("EnumServiceStatusEx")
+        end
+
+        bool = EnumServicesStatusEx(
+          handle_scm,
+          SC_ENUM_PROCESS_INFO,
+          SERVICE_WIN32 | SERVICE_DRIVER,
+          SERVICE_STATE_ALL,
+          service_buf,
+          service_buf.size,
+          bytes_needed,
+          services_returned,
+          resume_handle,
+          group
+        )
+
+        FFI.raise_windows_error("EnumServiceStatusEx") unless bool
+
+        num_services = services_returned.read_ulong
+
+        services_array = [] unless block_given?
+
+        1.upto(num_services) { |num|
+          # Cast the buffer
+          struct = ENUM_SERVICE_STATUS_PROCESS.new(service_buf)
+
+          service_name = struct[:lpServiceName].read_string
+          display_name = struct[:lpDisplayName].read_string
+
+          service_type  = get_service_type(struct[:ServiceStatusProcess][:dwServiceType])
+          current_state = get_current_state(struct[:ServiceStatusProcess][:dwCurrentState])
+          controls      = get_controls_accepted(struct[:ServiceStatusProcess][:dwControlsAccepted])
+
+          interactive   = struct[:ServiceStatusProcess][:dwServiceType] & SERVICE_INTERACTIVE_PROCESS > 0
+          win_exit_code = struct[:ServiceStatusProcess][:dwWin32ExitCode]
+          ser_exit_code = struct[:ServiceStatusProcess][:dwServiceSpecificExitCode]
+          check_point   = struct[:ServiceStatusProcess][:dwCheckPoint]
+          wait_hint     = struct[:ServiceStatusProcess][:dwWaitHint]
+          pid           = struct[:ServiceStatusProcess][:dwProcessId]
+          service_flags = struct[:ServiceStatusProcess][:dwServiceFlags]
+
+          begin
+            handle_scs = OpenService(
+              handle_scm,
+              service_name,
+              SERVICE_QUERY_CONFIG
+            )
+
+            FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+            config_struct = get_config_info(handle_scs)
+
+            if config_struct != ERROR_FILE_NOT_FOUND
+              binary_path = config_struct[:lpBinaryPathName].read_string
+              load_order  = config_struct[:lpLoadOrderGroup].read_string
+              start_name  = config_struct[:lpServiceStartName].read_string
+              tag_id      = config_struct[:dwTagId]
+
+              start_type = get_start_type(config_struct[:dwStartType])
+              error_ctrl = get_error_control(config_struct[:dwErrorControl])
+
+              deps = config_struct.dependencies
+
+              begin
+                buf = get_config2_info(handle_scs, SERVICE_CONFIG_DESCRIPTION)
+
+                if buf.is_a?(Numeric) || buf.read_pointer.null?
+                  description = ""
+                else
+                  description = buf.read_pointer.read_string
+                end
+              rescue
+                # While being annoying, not being able to get a description is not exceptional
+                warn "WARNING: Failed to retrieve description for the #{service_name} service."
+                description = ""
+              end
+
+              delayed_start = delayed_start(service_name)
+            else
+              warn "WARNING: The registry entry for the #{service_name} service could not be found"
+
+              binary_path = nil
+              load_order  = nil
+              start_name  = nil
+              start_type  = nil
+              error_ctrl  = nil
+              tag_id      = nil
+              deps        = nil
+              description = nil
+            end
+
+            begin
+              buf2 = get_config2_info(handle_scs, SERVICE_CONFIG_FAILURE_ACTIONS)
+
+              if buf2.is_a?(FFI::MemoryPointer)
+                fail_struct = SERVICE_FAILURE_ACTIONS.new(buf2)
+
+                reset_period = fail_struct[:dwResetPeriod]
+                num_actions  = fail_struct[:cActions]
+
+                if fail_struct[:lpRebootMsg].null?
+                  reboot_msg = nil
+                else
+                  reboot_msg = fail_struct[:lpRebootMsg].read_string
+                end
+
+                if fail_struct[:lpCommand].null?
+                  command = nil
+                else
+                  command = fail_struct[:lpCommand].read_string
+                end
+
+                actions = nil
+
+                if num_actions > 0
+                  action_ptr = fail_struct[:lpsaActions]
+
+                  actions = {}
+
+                  num_actions.times { |n|
+                    sc_action = SC_ACTION.new(action_ptr[n * SC_ACTION.size])
+                    delay = sc_action[:Delay]
+                    action_type = get_action_type(sc_action[:Type])
+                    actions[n + 1] = { action_type: action_type, delay: delay }
+                  }
+                end
+              else
+                reset_period = nil
+                reboot_msg   = nil
+                command      = nil
+                actions      = nil
+              end
+            rescue
+              warn "WARNING: Unable to retrieve failure actions for the #{service_name} service"
+              reset_period = nil
+              reboot_msg   = nil
+              command      = nil
+              actions      = nil
+            end
+          ensure
+            close_service_handle(handle_scs)
+          end
+
+          struct = ServiceStruct.new(
+            service_name,
+            display_name,
+            service_type,
+            current_state,
+            controls,
+            win_exit_code,
+            ser_exit_code,
+            check_point,
+            wait_hint,
+            binary_path,
+            start_type,
+            error_ctrl,
+            load_order,
+            tag_id,
+            start_name,
+            deps,
+            description,
+            interactive,
+            pid,
+            service_flags,
+            reset_period,
+            reboot_msg,
+            command,
+            num_actions,
+            actions,
+            delayed_start
+          )
+
+          if block_given?
+            yield struct
+          else
+            services_array << struct
+          end
+
+          service_buf += ENUM_SERVICE_STATUS_PROCESS.size
+        }
+      ensure
+        close_service_handle(handle_scm)
+      end
+
+      block_given? ? nil : services_array
+    end
+
+    #
+    # Attempts to get the delayed_start attribute for the named +service+ on +host+,
+    # or the local machine if no host is provided.
+    #
+    # @example Get 'SomeSvc' delayed start on the local machine
+    #    Service.delayed_start('SomeSvc') # => 1
+    # @example Get 'SomeSvc' delayed start on host foo
+    #    Service.delayed_start('SomeSvc', 'foo') # => 1
+    #
+    # @param service [String] Service name (e.g. `"Dhcp"`)
+    # @param host [String] Host of service (e.g. `"mymachine"`)
+    # @return [Integer, false, nil] Returns `1` when delayed start is enabled
+    #   and `0` when it is not enabled. Returns nil or false when there is
+    #   a problem of some kind.
+    #
+    def self.delayed_start(service, host = nil)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_ENUMERATE_SERVICE)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      handle_scs = OpenService(
+        handle_scm,
+        service,
+        SERVICE_QUERY_CONFIG
+      )
+
+      FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+      delayed_start_buf = get_config2_info(handle_scs, SERVICE_CONFIG_DELAYED_AUTO_START_INFO)
+      if delayed_start_buf.is_a?(FFI::MemoryPointer)
+        delayed_start_info = SERVICE_DELAYED_AUTO_START_INFO.new(delayed_start_buf)
+        delayed_start = delayed_start_info[:fDelayedAutostart]
+      else
+        delayed_start = false
+      end
+    rescue SystemCallError
+      delayed_start = nil
+    ensure
+      close_service_handle(handle_scs)
+      close_service_handle(handle_scm)
+    end
+
+    def self.close_service_handle(handle)
+      case handle
+      when NilClass
+        false
+      when Integer
+        handle > 0 ? CloseServiceHandle(handle) : false
+      else
+        raise ArgumentError, "You must pass a valid handle to ::close_service_handle"
+      end
+    end
+
+    #
+    # Opens an existing service.
+    #
+    # @example
+    #   open_sc_manager do |scm_handle|
+    #     open_service(scm_handle, 'Dhcp', SERVICE_ALL_ACCESS) do |service_handle|
+    #       p service_handle
+    #     end
+    #   end
+    #
+    # @param scm_handle [Integer] pointer to Service Control Manager
+    # @param service_name [String] Name of the service
+    # @param desired_access [Integer] The access to the service. For a list of
+    #   access rights, see `Windows::ServiceConstants`.
+    #
+    # @see Windows::ServiceConstants
+    #
+    def self.open_service(scm_handle, service_name, desired_access)
+       service_handle = OpenService(
+        scm_handle,
+        service_name,
+        desired_access
+      )
+       FFI.raise_windows_error("OpenService") if service_handle == 0
+
+       if block_given?
+         yield service_handle
+       else
+         service_handle
+       end
+    ensure
+      close_service_handle(service_handle) if block_given?
+    end
+
+    #
+    # Establishes a connection to the service control manager on the specified
+    # host and opens the SERVICES_ACTIVE_DATABASE service control manager
+    # database.
+    #
+    # @example
+    #   open_sc_manager(nil, SC_MANAGER_ENUMERATE_SERVICE) do |scm_handle|
+    #     p scm_handle
+    #   end
+    #
+    # @param host [String] Name of host you want to connect to. If `nil` it
+    #   will connect to the local host.
+    # @param desired_access [Integer] The access to the service control
+    #   manager.
+    # @return [Integer] If the function succeeds, the return value is a handle
+    #   to the specified service control manager database. If the function
+    #   fails, the return value is 0.
+    #
+    # @see Windows::ServiceConstants
+    #
+    def self.open_sc_manager(host = nil, desired_access = SC_MANAGER_CONNECT)
+      scm_handle = OpenSCManager(host, nil, desired_access)
+      FFI.raise_windows_error("OpenSCManager") if scm_handle == 0
+
+      if block_given?
+        yield scm_handle
+      else
+        scm_handle
+      end
+    ensure
+      close_service_handle(scm_handle) if block_given?
+    end
+
+    # Configures failure actions for a given service.
+    #
+    def self.configure_failure_actions(handle_scs, opts)
+      if opts["failure_actions"]
+        token_handle = FFI::MemoryPointer.new(:ulong)
+
+        bool = OpenProcessToken(
+          GetCurrentProcess(),
+          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
+          token_handle
+        )
+
+        unless bool
+          error = FFI.errno
+          close_service_handle(handle_scs)
+          raise SystemCallError.new("OpenProcessToken", error)
+        end
+
+        token_handle = token_handle.read_ulong
+
+        # Get the LUID for shutdown privilege.
+        luid = LUID.new
+
+        unless LookupPrivilegeValue("", "SeShutdownPrivilege", luid)
+          error = FFI.errno
+          close_service_handle(handle_scs)
+          raise SystemCallError.new("LookupPrivilegeValue", error)
+        end
+
+        luid_and_attrs = LUID_AND_ATTRIBUTES.new
+        luid_and_attrs[:Luid] = luid
+        luid_and_attrs[:Attributes] = SE_PRIVILEGE_ENABLED
+
+        tkp = TOKEN_PRIVILEGES.new
+        tkp[:PrivilegeCount] = 1
+        tkp[:Privileges][0] = luid_and_attrs
+
+        # Enable shutdown privilege in access token of this process
+        bool = AdjustTokenPrivileges(
+          token_handle,
+          0,
+          tkp,
+          tkp.size,
+          nil,
+          nil
+        )
+
+        unless bool
+          error = FFI.errno
+          close_service_handle(handle_scs)
+          raise SystemCallError.new("AdjustTokenPrivileges", error)
+        end
+      end
+
+      sfa = SERVICE_FAILURE_ACTIONS.new
+
+      if opts["failure_reset_period"]
+        sfa[:dwResetPeriod] = opts["failure_reset_period"]
+      end
+
+      if opts["failure_reboot_message"]
+        sfa[:lpRebootMsg] = FFI::MemoryPointer.from_string(opts["failure_reboot_message"])
+      end
+
+      if opts["failure_command"]
+        sfa[:lpCommand] = FFI::MemoryPointer.from_string(opts["failure_command"])
+      end
+
+      if opts["failure_actions"]
+        action_size = opts["failure_actions"].size
+        action_ptr = FFI::MemoryPointer.new(SC_ACTION, action_size)
+
+        actions = action_size.times.collect do |i|
+          SC_ACTION.new(action_ptr + i * SC_ACTION.size)
+        end
+
+        opts["failure_actions"].each_with_index { |action, i|
+          actions[i][:Type] = action
+          actions[i][:Delay] = opts["failure_delay"]
+        }
+
+        sfa[:cActions] = action_size
+        sfa[:lpsaActions] = action_ptr
+      end
+
+      bool = ChangeServiceConfig2(
+        handle_scs,
+        SERVICE_CONFIG_FAILURE_ACTIONS,
+        sfa
+      )
+
+      unless bool
+        error = FFI.errno
+        close_service_handle(handle_scs)
+        raise SystemCallError.new("ChangeServiceConfig2", error)
+      end
+    end
+
+    # Returns a human readable string indicating the action type.
+    #
+    def self.get_action_type(action_type)
+      case action_type
+        when SC_ACTION_NONE
+          "none"
+        when SC_ACTION_REBOOT
+          "reboot"
+        when SC_ACTION_RESTART
+          "restart"
+        when SC_ACTION_RUN_COMMAND
+          "command"
+        else
+          "unknown"
+      end
+    end
+
+    # Shortcut for QueryServiceConfig. Returns the buffer. In rare cases
+    # the underlying registry entry may have been deleted, but the service
+    # still exists. In that case, the ERROR_FILE_NOT_FOUND value is returned
+    # instead.
+    #
+    def self.get_config_info(handle)
+      bytes_needed = FFI::MemoryPointer.new(:ulong)
+
+      # First attempt at QueryServiceConfig is to get size needed
+      bool = QueryServiceConfig(handle, nil, 0, bytes_needed)
+
+      if !bool && FFI.errno == ERROR_INSUFFICIENT_BUFFER
+        config_buf = FFI::MemoryPointer.new(:char, bytes_needed.read_ulong)
+      elsif FFI.errno == ERROR_FILE_NOT_FOUND
+        return FFI.errno
+      else
+        error = FFI.errno
+        CloseServiceHandle(handle)
+        FFI.raise_windows_error("QueryServiceConfig", error)
+      end
+
+      bytes_needed.clear
+
+      # Second attempt at QueryServiceConfig gets the actual info
+      begin
+        bool = QueryServiceConfig(
+          handle,
+          config_buf,
+          config_buf.size,
+          bytes_needed
+        )
+
+        FFI.raise_windows_error("QueryServiceConfig") unless bool
+      ensure
+        CloseServiceHandle(handle) unless bool
+      end
+
+      QUERY_SERVICE_CONFIG.new(config_buf) # cast the buffer
+    end
+
+    # Shortcut for QueryServiceConfig2. Returns the buffer.
+    #
+    def self.get_config2_info(handle, info_level)
+      bytes_needed = FFI::MemoryPointer.new(:ulong)
+
+      # First attempt at QueryServiceConfig2 is to get size needed
+      bool = QueryServiceConfig2(handle, info_level, nil, 0, bytes_needed)
+
+      err_num = FFI.errno
+
+      # This is a bit hacky since it means we have to check the type of value
+      # we get back, but we don't always want to raise an error either,
+      # depending on what we're trying to get at.
+      #
+      if !bool && err_num == ERROR_INSUFFICIENT_BUFFER
+        config2_buf = FFI::MemoryPointer.new(:char, bytes_needed.read_ulong)
+      elsif [ERROR_FILE_NOT_FOUND, ERROR_RESOURCE_TYPE_NOT_FOUND, ERROR_RESOURCE_NAME_NOT_FOUND].include?(err_num)
+        return err_num
+      else
+        CloseServiceHandle(handle)
+        FFI.raise_windows_error("QueryServiceConfig2", err_num)
+      end
+
+      bytes_needed.clear
+
+      # Second attempt at QueryServiceConfig2 gets the actual info
+      begin
+        bool = QueryServiceConfig2(
+          handle,
+          info_level,
+          config2_buf,
+          config2_buf.size,
+          bytes_needed
+        )
+
+        FFI.raise_windows_error("QueryServiceConfig2") unless bool
+      ensure
+        CloseServiceHandle(handle) unless bool
+      end
+
+      config2_buf
+    end
+
+    # Returns a human readable string indicating the error control
+    #
+    def self.get_error_control(error_control)
+      case error_control
+        when SERVICE_ERROR_CRITICAL
+          "critical"
+        when SERVICE_ERROR_IGNORE
+          "ignore"
+        when SERVICE_ERROR_NORMAL
+          "normal"
+        when SERVICE_ERROR_SEVERE
+          "severe"
+        else
+          nil
+      end
+    end
+
+    # Returns a human readable string indicating the start type.
+    #
+    def self.get_start_type(start_type)
+      case start_type
+        when SERVICE_AUTO_START
+          "auto start"
+        when SERVICE_BOOT_START
+          "boot start"
+        when SERVICE_DEMAND_START
+          "demand start"
+        when SERVICE_DISABLED
+          "disabled"
+        when SERVICE_SYSTEM_START
+          "system start"
+        else
+          nil
+      end
+    end
+
+    # Returns an array of human readable strings indicating the controls
+    # that the service accepts.
+    #
+    def self.get_controls_accepted(controls)
+      array = []
+
+      if controls & SERVICE_ACCEPT_NETBINDCHANGE > 0
+        array << "netbind change"
+      end
+
+      if controls & SERVICE_ACCEPT_PARAMCHANGE > 0
+        array << "param change"
+      end
+
+      if controls & SERVICE_ACCEPT_PAUSE_CONTINUE > 0
+        array << "pause continue"
+      end
+
+      if controls & SERVICE_ACCEPT_SHUTDOWN > 0
+        array << "shutdown"
+      end
+
+      if controls & SERVICE_ACCEPT_PRESHUTDOWN > 0
+        array << "pre-shutdown"
+      end
+
+      if controls & SERVICE_ACCEPT_STOP > 0
+        array << "stop"
+      end
+
+      if controls & SERVICE_ACCEPT_HARDWAREPROFILECHANGE > 0
+        array << "hardware profile change"
+      end
+
+      if controls & SERVICE_ACCEPT_POWEREVENT > 0
+        array << "power event"
+      end
+
+      if controls & SERVICE_ACCEPT_SESSIONCHANGE > 0
+        array << "session change"
+      end
+
+      array
+    end
+
+    # Converts a service state numeric constant into a readable string.
+    #
+    def self.get_current_state(state)
+      case state
+        when SERVICE_CONTINUE_PENDING
+          "continue pending"
+        when SERVICE_PAUSE_PENDING
+          "pause pending"
+        when SERVICE_PAUSED
+          "paused"
+        when SERVICE_RUNNING
+          "running"
+        when SERVICE_START_PENDING
+          "start pending"
+        when SERVICE_STOP_PENDING
+          "stop pending"
+        when SERVICE_STOPPED
+          "stopped"
+        else
+          nil
+      end
+    end
+
+    # Converts a service type numeric constant into a human readable string.
+    #
+    def self.get_service_type(service_type)
+      case service_type
+        when SERVICE_FILE_SYSTEM_DRIVER
+          "file system driver"
+        when SERVICE_KERNEL_DRIVER
+          "kernel driver"
+        when SERVICE_WIN32_OWN_PROCESS
+          "own process"
+        when SERVICE_WIN32_SHARE_PROCESS
+          "share process"
+        when SERVICE_RECOGNIZER_DRIVER
+          "recognizer driver"
+        when SERVICE_DRIVER
+          "driver"
+        when SERVICE_WIN32
+          "win32"
+        when SERVICE_TYPE_ALL
+          "all"
+        when SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS
+          "own process, interactive"
+        when SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_SHARE_PROCESS
+          "share process, interactive"
+        else
+          nil
+      end
+    end
+
+    # A shortcut method that simplifies the various service control methods.
+    #
+    def self.send_signal(service, host, service_signal, control_signal)
+      handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+      FFI.raise_windows_error("OpenSCManager") if handle_scm == 0
+
+      begin
+        handle_scs = OpenService(handle_scm, service, service_signal)
+
+        FFI.raise_windows_error("OpenService") if handle_scs == 0
+
+        status = SERVICE_STATUS.new
+
+        unless ControlService(handle_scs, control_signal, status)
+          FFI.raise_windows_error("ControlService")
+        end
+      ensure
+        close_service_handle(handle_scs)
+        close_service_handle(handle_scm)
+      end
+
+      status
+    end
+
+    class << self
+      alias create new
+      alias getdisplayname get_display_name
+      alias getservicename get_service_name
+    end
+  end
+end