puppet 6.23.0 → 7.0.0

data/lib/puppet/util/monkey_patches.rb

@@ -32,13 +32,6 @@ end
 # (#19151) Reject all SSLv2 ciphers and handshakes
 require 'puppet/ssl/openssl_loader'
 unless Puppet::Util::Platform.jruby_fips?
-  unless defined?(OpenSSL::SSL::TLS1_VERSION)
-    module OpenSSL::SSL
-      # see https://github.com/ruby/ruby/commit/609103dbb5fb182eec12f052226c43e39b907682#diff-09f822c26289f5347111795ca22ed7ed1cfadd6ebd28f987991d1d414eef565aR2755-R2759
-      OpenSSL::SSL::TLS1_VERSION = 0x301
-    end
-  end
-
   class OpenSSL::SSL::SSLContext
     if DEFAULT_PARAMS[:options]
       DEFAULT_PARAMS[:options] |= OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
@@ -109,49 +102,3 @@ unless Puppet::Util::Platform.jruby_fips?
     end
   end
 end
-
-unless Puppet::Util::Platform.jruby_fips?
-  unless OpenSSL::PKey::EC.instance_methods.include?(:private?)
-    class OpenSSL::PKey::EC
-      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/7c971e61f04
-      alias :private? :private_key?
-    end
-  end
-
-  unless OpenSSL::PKey::EC.singleton_methods.include?(:generate)
-    class OpenSSL::PKey::EC
-      # Added in ruby 2.4.0 in https://github.com/ruby/ruby/commit/85500b66342
-      def self.generate(string)
-        ec = OpenSSL::PKey::EC.new(string)
-        ec.generate_key
-      end
-    end
-  end
-end
-
-# The Enumerable#uniq method was added in Ruby 2.4.0 (https://bugs.ruby-lang.org/issues/11090)
-# This is a backport to earlier Ruby versions.
-#
-unless Enumerable.instance_methods.include?(:uniq)
-  module Enumerable
-    def uniq
-      result = []
-      uniq_map = {}
-      if block_given?
-        each do |value|
-          key = yield value
-          next if uniq_map.has_key?(key)
-          uniq_map[key] = true
-          result << value
-        end
-      else
-        each do |value|
-          next if uniq_map.has_key?(value)
-          uniq_map[value] = true
-          result << value
-        end
-      end
-      result
-    end
-  end
-end

data/lib/puppet/util/posix.rb

@@ -12,18 +12,11 @@ module Puppet::Util::POSIX
   class << self
     # Returns an array of all the groups that the user's a member of.
     def groups_of(user)
-      begin
-        require 'puppet/ffi/posix'
-        groups = get_groups_list(user)
-      rescue StandardError, LoadError => e
-        Puppet.debug("Falling back to Puppet::Etc.group: #{e.message}")
-
-        groups = []
-        Puppet::Etc.group do |group|
-          groups << group.name if group.mem.include?(user)
-        end
+      groups = []
+      Puppet::Etc.group do |group|
+        groups << group.name if group.mem.include?(user)
       end
-
+  
       uniq_groups = groups.uniq
       if uniq_groups != groups
         Puppet.debug(_('Removing any duplicate group entries'))
@@ -31,39 +24,6 @@ module Puppet::Util::POSIX
 
       uniq_groups
     end
-
-    private
-    def get_groups_list(user)
-      raise LoadError, "The 'getgrouplist' method is not available" unless Puppet::FFI::POSIX::Functions.respond_to?(:getgrouplist)
-
-      user_gid = Puppet::Etc.getpwnam(user).gid
-      ngroups = Puppet::FFI::POSIX::Constants::MAXIMUM_NUMBER_OF_GROUPS
-
-      while true do # rubocop:disable Lint/LiteralInCondition
-        FFI::MemoryPointer.new(:int) do |ngroups_ptr|
-          FFI::MemoryPointer.new(:uint, ngroups) do |groups_ptr|
-            old_ngroups = ngroups
-            ngroups_ptr.write_int(ngroups)
-
-            if Puppet::FFI::POSIX::Functions::getgrouplist(user, user_gid, groups_ptr, ngroups_ptr) != -1
-              groups_gids = groups_ptr.get_array_of_uint(0, ngroups_ptr.read_int)
-
-              result = []
-              groups_gids.each do |group_gid|
-                group_info = Puppet::Etc.getgrgid(group_gid)
-                result |= [group_info.name] if group_info.mem.include?(user)
-              end
-              return result
-            end
-
-            ngroups = ngroups_ptr.read_int
-            if ngroups <= old_ngroups
-              ngroups *= 2
-            end
-          end
-        end
-      end
-    end
   end
 
   # Retrieve a field from a POSIX Etc object.  The id can be either an integer
@@ -184,17 +144,8 @@ module Puppet::Util::POSIX
       name = get_posix_field(location, :name, id)
       check_value = name
     end
-
     if check_value != field
-      check_value_id = get_posix_field(location, id_field, check_value) if check_value
-
-      if id == check_value_id
-        Puppet.debug("Multiple entries found for resource: '#{location}' with #{id_field}: #{id}")
-        return id
-      else
-        Puppet.debug("The value retrieved: '#{check_value}' is different than the required state: '#{field}', searching in all entries")
-        return search_posix_field(location, id_field, field)
-      end
+      return search_posix_field(location, id_field, field)
     else
       return id
     end

data/lib/puppet/util/rdoc.rb

@@ -26,13 +26,6 @@ module Puppet::Util::RDoc
 
     options << "--force-update"
     options += [ "--charset", charset] if charset
-    # Rdoc root default is Dir.pwd, but the win32-dir gem monkey patches Dir.pwd
-    # replacing Ruby's normal / with \.  When RDoc generates relative paths it
-    # uses relative_path_from that will generate errors when the slashes don't
-    # properly match.  This is a workaround for that issue.
-    if Puppet::Util::Platform.windows? && RDoc::VERSION !~ /^[0-3]\./
-      options += [ "--root", Dir.pwd.tr('\\', '/')]
-    end
     options += files
 
     # launch the documentation process

data/lib/puppet/util/retry_action.rb

@@ -7,7 +7,7 @@ module Puppet::Util::RetryAction
   # Execute the supplied block retrying with exponential backoff.
   #
   # @param [Hash] options the retry options
-  # @option options [FixNum] :retries Maximum number of times to retry.
+  # @option options [Integer] :retries Maximum number of times to retry.
   # @option options [Array<Exception>] :retry_exceptions ([StandardError]) Optional array of exceptions that are allowed to be retried.
   # @yield The block to be executed.
   def self.retry_action(options = {})

data/lib/puppet/util/run_mode.rb

@@ -74,6 +74,10 @@ module Puppet
         which_dir("/opt/puppetlabs/puppet/cache", "~/.puppetlabs/opt/puppet/cache")
       end
 
+      def public_dir
+        which_dir("/opt/puppetlabs/puppet/public", "~/.puppetlabs/opt/puppet/public")
+      end
+
       def run_dir
         which_dir("/var/run/puppetlabs", "~/.puppetlabs/var/run")
       end
@@ -96,6 +100,10 @@ module Puppet
         which_dir(File.join(windows_common_base("puppet/cache")), "~/.puppetlabs/opt/puppet/cache")
       end
 
+      def public_dir
+        which_dir(File.join(windows_common_base("puppet/public")), "~/.puppetlabs/opt/puppet/public")
+      end
+
       def run_dir
         which_dir(File.join(windows_common_base("puppet/var/run")), "~/.puppetlabs/var/run")
       end
@@ -107,7 +115,7 @@ module Puppet
     private
 
       def windows_common_base(*extra)
-        [Dir::COMMON_APPDATA, "PuppetLabs"] + extra
+        [ENV['ALLUSERSPROFILE'], "PuppetLabs"] + extra
       end
     end
   end

data/lib/puppet/util/selinux.rb

@@ -13,10 +13,6 @@ require 'pathname'
 
 module Puppet::Util::SELinux
 
-  S_IFREG = 0100000
-  S_IFDIR = 0040000
-  S_IFLNK = 0120000
-
   def self.selinux_support?
     return false unless defined?(Selinux)
     if Selinux.is_selinux_enabled == 1
@@ -42,7 +38,7 @@ module Puppet::Util::SELinux
 
   # Retrieve and return the default context of the file.  If we don't have
   # SELinux support or if the SELinux call fails to file a default then return nil.
-  def get_selinux_default_context(file, resource_ensure=nil)
+  def get_selinux_default_context(file)
     return nil unless selinux_support?
     # If the filesystem has no support for SELinux labels, return a default of nil
     # instead of what matchpathcon would return
@@ -52,14 +48,8 @@ module Puppet::Util::SELinux
     begin
       filestat = file_lstat(file)
       mode = filestat.mode
-    rescue Errno::EACCES
+    rescue Errno::EACCES, Errno::ENOENT
       mode = 0
-    rescue Errno::ENOENT
-      if resource_ensure
-        mode = get_create_mode(resource_ensure)
-      else
-        mode = 0
-      end
     end
 
     retval = Selinux.matchpathcon(file, mode)
@@ -146,8 +136,8 @@ module Puppet::Util::SELinux
   # Puppet uses.  This will set the file's SELinux context to the policy's
   # default context (if any) if it differs from the context currently on
   # the file.
-  def set_selinux_default_context(file, resource_ensure=nil)
-    new_context = get_selinux_default_context(file, resource_ensure)
+  def set_selinux_default_context(file)
+    new_context = get_selinux_default_context(file)
     return nil unless new_context
     cur_context = get_selinux_current_context(file)
     if new_context != cur_context
@@ -208,22 +198,6 @@ module Puppet::Util::SELinux
     filesystems.include?(fstype)
   end
 
-  # Get mode file type bits set based on ensure on
-  # the file resource. This helps SELinux determine
-  # what context a new resource being created should have.
-  def get_create_mode(resource_ensure)
-    mode = 0
-    case resource_ensure
-    when :present, :file
-      mode |= S_IFREG
-    when :directory
-      mode |= S_IFDIR
-    when :link
-      mode |= S_IFLNK
-    end
-    mode
-  end
-
   # Internal helper function to read and parse /proc/mounts
   def read_mounts
     mounts = ""

data/lib/puppet/util/windows.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/platform'
+
 module Puppet::Util::Windows
   module ADSI
     class ADSIObject; end
@@ -15,8 +16,6 @@ module Puppet::Util::Windows
   class EventLog; end
 
   if Puppet::Util::Platform.windows?
-    require 'Win32API' # case matters in this require!
-
     # Note: Setting codepage here globally ensures all strings returned via
     # WIN32OLE (Ruby's late-bound COM support) are encoded in Encoding::UTF_8
     #
@@ -24,14 +23,9 @@ module Puppet::Util::Windows
     # to 2048 (at least on US English Windows) and is not listed in the MS
     # locales table, here: https://msdn.microsoft.com/en-us/library/ms912047(v=winembedded.10).aspx
     require 'win32ole' ; WIN32OLE.codepage = WIN32OLE::CP_UTF8
-    # gems
-    require 'win32/process'
-    require 'puppet/util/windows/monkey_patches/dir'
-    require 'win32/dir'
-    require 'win32/service'
 
     # these reference platform specific gems
-    require 'puppet/util/windows/api_types'
+    require 'puppet/ffi/windows'
     require 'puppet/util/windows/string'
     require 'puppet/util/windows/error'
     require 'puppet/util/windows/com'
@@ -49,5 +43,6 @@ module Puppet::Util::Windows
     require 'puppet/util/windows/registry'
     require 'puppet/util/windows/eventlog'
     require 'puppet/util/windows/service'
+    require 'puppet/util/windows/monkey_patches/process'
   end
 end

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

@@ -504,43 +504,6 @@ module Puppet::Util::Windows::ADSI
       user_name
     end
 
-    # https://docs.microsoft.com/en-us/windows/win32/api/secext/ne-secext-extended_name_format
-    NameUnknown           = 0
-    NameFullyQualifiedDN  = 1
-    NameSamCompatible     = 2
-    NameDisplay           = 3
-    NameUniqueId          = 6
-    NameCanonical         = 7
-    NameUserPrincipal     = 8
-    NameCanonicalEx       = 9
-    NameServicePrincipal  = 10
-    NameDnsDomain         = 12
-    NameGivenName         = 13
-    NameSurname           = 14
-
-    def self.current_user_name_with_format(format)
-      user_name = ''
-      max_length = 1024
-
-      FFI::MemoryPointer.new(:lpwstr, max_length * 2 + 1) do |buffer|
-        FFI::MemoryPointer.new(:dword, 1) do |buffer_size|
-          buffer_size.write_dword(max_length + 1)
-
-          if GetUserNameExW(format.to_i, buffer, buffer_size) == FFI::WIN32_FALSE
-            raise Puppet::Util::Windows::Error.new(_("Failed to get user name"), FFI.errno)
-          end
-
-          user_name = buffer.read_wide_string(buffer_size.read_dword).chomp
-        end
-      end
-
-      user_name
-    end
-
-    def self.current_sam_compatible_user_name
-      current_user_name_with_format(NameSamCompatible)
-    end
-
     def self.current_user_sid
       Puppet::Util::Windows::SID.name_to_principal(current_user_name)
     end
@@ -555,15 +518,6 @@ module Puppet::Util::Windows::ADSI
     ffi_lib :advapi32
     attach_function_private :GetUserNameW,
       [:lpwstr, :lpdword], :win32_bool
-
-    # https://docs.microsoft.com/en-us/windows/win32/api/secext/nf-secext-getusernameexa
-    # BOOLEAN SEC_ENTRY GetUserNameExA(
-    #   EXTENDED_NAME_FORMAT NameFormat,
-    #   LPSTR                lpNameBuffer,
-    #   PULONG               nSize
-    # );type
-    ffi_lib :secur32
-    attach_function_private :GetUserNameExW, [:uint16, :lpwstr, :pointer], :win32_bool
   end
 
   class UserProfile

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

@@ -0,0 +1,360 @@
+require 'puppet/ffi/windows'
+
+module Puppet::Util::Windows
+
+  # The Daemon class, based on the chef/win32-service implementation
+  class Daemon
+    include Puppet::FFI::Windows::Constants
+    extend Puppet::FFI::Windows::Constants
+
+    include Puppet::FFI::Windows::Structs
+    extend Puppet::FFI::Windows::Structs
+
+    include Puppet::FFI::Windows::Functions
+    extend Puppet::FFI::Windows::Functions
+
+    # 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
+
+    IDLE = 0
+
+    # Misc
+    IDLE_CONTROL_CODE = 0
+    WAIT_OBJECT_0 = 0
+    WAIT_TIMEOUT = 0x00000102
+    WAIT_FAILED = 0xFFFFFFFF
+    NO_ERROR = 0
+
+    # Wraps SetServiceStatus.
+    SetTheServiceStatus = Proc.new do |dwCurrentState, dwWin32ExitCode, dwCheckPoint, dwWaitHint|
+      ss = SERVICE_STATUS.new  # Current status of the service.
+
+      # Disable control requests until the service is started.
+      if dwCurrentState == SERVICE_START_PENDING
+        ss[:dwControlsAccepted] = 0
+      else
+        ss[:dwControlsAccepted] =
+        SERVICE_ACCEPT_STOP|SERVICE_ACCEPT_SHUTDOWN|
+        SERVICE_ACCEPT_PAUSE_CONTINUE|SERVICE_ACCEPT_PARAMCHANGE
+      end
+
+      # Initialize ss structure.
+      ss[:dwServiceType]             = SERVICE_WIN32_OWN_PROCESS
+      ss[:dwServiceSpecificExitCode] = 0
+      ss[:dwCurrentState]            = dwCurrentState
+      ss[:dwWin32ExitCode]           = dwWin32ExitCode
+      ss[:dwCheckPoint]              = dwCheckPoint
+      ss[:dwWaitHint]                = dwWaitHint
+
+      @@dwServiceState = dwCurrentState
+
+      # Send status of the service to the Service Controller.
+      if !SetServiceStatus(@@ssh, ss)
+        SetEvent(@@hStopEvent)
+      end
+    end
+
+    ERROR_CALL_NOT_IMPLEMENTED = 0x78
+
+    # Handles control signals from the service control manager.
+    Service_Ctrl_ex = Proc.new do |dwCtrlCode, dwEventType, lpEventData, lpContext|
+      @@waiting_control_code = dwCtrlCode;
+      return_value = NO_ERROR
+
+      begin
+        dwState = SERVICE_RUNNING
+
+        case dwCtrlCode
+          when SERVICE_CONTROL_STOP
+            dwState = SERVICE_STOP_PENDING
+          when SERVICE_CONTROL_SHUTDOWN
+            dwState = SERVICE_STOP_PENDING
+          when SERVICE_CONTROL_PAUSE
+            dwState = SERVICE_PAUSED
+          when SERVICE_CONTROL_CONTINUE
+            dwState = SERVICE_RUNNING
+          #else
+            # TODO: Handle other control codes? Retain the current state?
+        end
+
+        # Set the status of the service except on interrogation.
+        unless dwCtrlCode == SERVICE_CONTROL_INTERROGATE
+          SetTheServiceStatus.call(dwState, NO_ERROR, 0, 0)
+        end
+
+        # Tell service_main thread to stop.
+        if dwCtrlCode == SERVICE_CONTROL_STOP || dwCtrlCode == SERVICE_CONTROL_SHUTDOWN
+          if SetEvent(@@hStopEvent) == 0
+            SetTheServiceStatus.call(SERVICE_STOPPED, FFI.errno, 0, 0)
+          end
+        end
+      rescue
+        return_value = ERROR_CALL_NOT_IMPLEMENTED
+      end
+
+      return_value
+    end
+
+    # Called by the service control manager after the call to StartServiceCtrlDispatcher.
+    Service_Main = FFI::Function.new(:void, [:ulong, :pointer], :blocking => false) do |dwArgc, lpszArgv|
+      begin
+        # Obtain the name of the service.
+        if lpszArgv.address != 0
+          argv = lpszArgv.get_array_of_string(0, dwArgc)
+          lpszServiceName = argv[0]
+        else
+          lpszServiceName = ''
+        end
+
+        # Args passed to Service.start
+        if(dwArgc > 1)
+          @@Argv = argv[1..-1]
+        else
+          @@Argv = nil
+        end
+
+        # Register the service ctrl handler.
+        @@ssh = RegisterServiceCtrlHandlerExW(
+          lpszServiceName,
+          Service_Ctrl_ex,
+          nil
+        )
+
+        # No service to stop, no service handle to notify, nothing to do but exit.
+        break if @@ssh == 0
+
+        # The service has started.
+        SetTheServiceStatus.call(SERVICE_RUNNING, NO_ERROR, 0, 0)
+
+        SetEvent(@@hStartEvent)
+
+        # Main loop for the service.
+        while(WaitForSingleObject(@@hStopEvent, 1000) != WAIT_OBJECT_0) do
+        end
+
+        # Main loop for the service.
+        while(WaitForSingleObject(@@hStopCompletedEvent, 1000) != WAIT_OBJECT_0) do
+        end
+      ensure
+        # Stop the service.
+        SetTheServiceStatus.call(SERVICE_STOPPED, NO_ERROR, 0, 0)
+      end
+    end
+
+    ThreadProc = FFI::Function.new(:ulong,[:pointer]) do |lpParameter|
+      ste = FFI::MemoryPointer.new(SERVICE_TABLE_ENTRYW, 2)
+
+      s = SERVICE_TABLE_ENTRYW.new(ste[0])
+      s[:lpServiceName] = FFI::MemoryPointer.from_string('')
+      s[:lpServiceProc] = lpParameter
+
+      s = SERVICE_TABLE_ENTRYW.new(ste[1])
+      s[:lpServiceName] = nil
+      s[:lpServiceProc] = nil
+
+      # No service to step, no service handle, no ruby exceptions, just terminate the thread..
+      if !StartServiceCtrlDispatcherW(ste)
+        return 1
+      end
+
+      return 0
+    end
+
+    # This is a shortcut for Daemon.new + Daemon#mainloop.
+    #
+    def self.mainloop
+      self.new.mainloop
+    end
+
+    # This is the method that actually puts your code into a loop and allows it
+    # to run as a service.  The code that is actually run while in the mainloop
+    # is what you defined in your own Daemon#service_main method.
+    #
+    def mainloop
+      @@waiting_control_code = IDLE_CONTROL_CODE
+      @@dwServiceState = 0
+
+      # Redirect STDIN, STDOUT and STDERR to the NUL device if they're still
+      # associated with a tty. This helps newbs avoid Errno::EBADF errors.
+      STDIN.reopen('NUL') if STDIN.isatty
+      STDOUT.reopen('NUL') if STDOUT.isatty
+      STDERR.reopen('NUL') if STDERR.isatty
+
+      # Calling init here so that init failures never even tries to start the
+      # service. Of course that means that init methods must be very quick
+      # because the SCM will be receiving no START_PENDING messages while
+      # init's running.
+      #
+      # TODO: Fix?
+      service_init() if respond_to?('service_init')
+
+      # Create the event to signal the service to start.
+      @@hStartEvent = CreateEventW(nil, 1, 0, nil)
+
+      if @@hStartEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      # Create the event to signal the service to stop.
+      @@hStopEvent = CreateEventW(nil, 1, 0, nil)
+
+      if @@hStopEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      # Create the event to signal the service that stop has completed
+      @@hStopCompletedEvent = CreateEventW(nil, 1, 0, nil)
+
+      if @@hStopCompletedEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      hThread = CreateThread(nil, 0, ThreadProc, Service_Main, 0, nil)
+
+      if hThread == 0
+        raise SystemCallError.new('CreateThread', FFI.errno)
+      end
+
+      events = FFI::MemoryPointer.new(:pointer, 2)
+      events.put_pointer(0, FFI::Pointer.new(hThread))
+      events.put_pointer(FFI::Pointer.size, FFI::Pointer.new(@@hStartEvent))
+
+      while ((index = WaitForMultipleObjects(2, events, 0, 1000)) == WAIT_TIMEOUT) do
+      end
+
+      if index == WAIT_FAILED
+        raise SystemCallError.new('WaitForMultipleObjects', FFI.errno)
+      end
+
+      # The thread exited, so the show is off.
+      if index == WAIT_OBJECT_0
+        raise "Service_Main thread exited abnormally"
+      end
+
+      thr = Thread.new do
+        begin
+          while(WaitForSingleObject(@@hStopEvent, 1000) == WAIT_TIMEOUT)
+            # Check to see if anything interesting has been signaled
+            case @@waiting_control_code
+              when SERVICE_CONTROL_PAUSE
+                service_pause() if respond_to?('service_pause')
+              when SERVICE_CONTROL_CONTINUE
+                service_resume() if respond_to?('service_resume')
+              when SERVICE_CONTROL_INTERROGATE
+                service_interrogate() if respond_to?('service_interrogate')
+              when SERVICE_CONTROL_SHUTDOWN
+                service_shutdown() if respond_to?('service_shutdown')
+              when SERVICE_CONTROL_PARAMCHANGE
+                service_paramchange() if respond_to?('service_paramchange')
+              when SERVICE_CONTROL_NETBINDADD
+                service_netbindadd() if respond_to?('service_netbindadd')
+              when SERVICE_CONTROL_NETBINDREMOVE
+                service_netbindremove() if respond_to?('service_netbindremove')
+              when SERVICE_CONTROL_NETBINDENABLE
+                service_netbindenable() if respond_to?('service_netbindenable')
+              when SERVICE_CONTROL_NETBINDDISABLE
+                service_netbinddisable() if respond_to?('service_netbinddisable')
+            end
+            @@waiting_control_code = IDLE_CONTROL_CODE
+          end
+
+          service_stop() if respond_to?('service_stop')
+        ensure
+          SetEvent(@@hStopCompletedEvent)
+        end
+      end
+
+      if respond_to?('service_main')
+        service_main(*@@Argv)
+      end
+
+      thr.join
+    end
+
+    # Returns the state of the service (as an constant integer) which can be any
+    # of the service status constants, e.g. RUNNING, PAUSED, etc.
+    #
+    # This method is typically used within your service_main method to setup the
+    # loop. For example:
+    #
+    #   class MyDaemon < Daemon
+    #     def service_main
+    #       while state == RUNNING || state == PAUSED || state == IDLE
+    #         # Your main loop here
+    #       end
+    #     end
+    #   end
+    #
+    # See the Daemon#running? method for an abstraction of the above code.
+    #
+    def state
+      @@dwServiceState
+    end
+
+    #
+    # Returns whether or not the service is in a running state, i.e. the service
+    # status is either RUNNING, PAUSED or IDLE.
+    #
+    # This is typically used within your service_main method to setup the main
+    # loop. For example:
+    #
+    #    class MyDaemon < Daemon
+    #       def service_main
+    #          while running?
+    #             # Your main loop here
+    #          end
+    #       end
+    #    end
+    #
+    def running?
+      [SERVICE_RUNNING, SERVICE_PAUSED, 0].include?(@@dwServiceState)
+    end
+  end
+end