openvox 8.19.0

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Puppet::Util::Windows::COM
+  extend FFI::Library
+
+  ffi_convention :stdcall
+
+  S_OK = 0
+  S_FALSE = 1
+
+  def SUCCEEDED(hr) hr >= 0 end
+  def FAILED(hr) hr < 0 end
+
+  module_function :SUCCEEDED, :FAILED
+
+  def raise_if_hresult_failed(name, *args)
+    failed = FAILED(result = send(name, *args)) and raise _("%{name} failed (hresult %{result}).") % { name: name, result: format('%#08x', result) }
+
+    result
+  ensure
+    yield failed if block_given?
+  end
+
+  module_function :raise_if_hresult_failed
+
+  CLSCTX_INPROC_SERVER = 0x1
+  CLSCTX_INPROC_HANDLER = 0x2
+  CLSCTX_LOCAL_SERVER = 0x4
+  CLSCTX_INPROC_SERVER16 = 0x8
+  CLSCTX_REMOTE_SERVER = 0x10
+  CLSCTX_INPROC_HANDLER16 = 0x20
+  CLSCTX_RESERVED1 = 0x40
+  CLSCTX_RESERVED2 = 0x80
+  CLSCTX_RESERVED3 = 0x100
+  CLSCTX_RESERVED4 = 0x200
+  CLSCTX_NO_CODE_DOWNLOAD = 0x400
+  CLSCTX_RESERVED5 = 0x800
+  CLSCTX_NO_CUSTOM_MARSHAL = 0x1000
+  CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000
+  CLSCTX_NO_FAILURE_LOG = 0x4000
+  CLSCTX_DISABLE_AAA = 0x8000
+  CLSCTX_ENABLE_AAA = 0x10000
+  CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000
+  CLSCTX_ACTIVATE_32_BIT_SERVER = 0x40000
+  CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000
+  CLSCTX_ENABLE_CLOAKING = 0x100000
+  CLSCTX_PS_DLL = -0x80000000
+  CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+  CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+  CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms686615(v=vs.85).aspx
+  # HRESULT CoCreateInstance(
+  #   _In_   REFCLSID rclsid,
+  #   _In_   LPUNKNOWN pUnkOuter,
+  #   _In_   DWORD dwClsContext,
+  #   _In_   REFIID riid,
+  #   _Out_  LPVOID *ppv
+  # );
+  ffi_lib :ole32
+  attach_function_private :CoCreateInstance,
+                          [:pointer, :lpunknown, :dword, :pointer, :lpvoid], :hresult
+
+  # code modified from Unknownr project https://github.com/rpeev/Unknownr
+  # licensed under MIT
+  module Interface
+    def self.[](*args)
+      spec, iid, *ifaces = args.reverse
+
+      spec.each { |_name, signature| signature[0].unshift(:pointer) }
+
+      Class.new(FFI::Struct) do
+        const_set(:IID, iid)
+
+        vtable = Class.new(FFI::Struct) do
+          vtable_hash = (ifaces.map { |iface| iface::VTBL::SPEC.to_a } << spec.to_a).flatten(1).to_h
+          const_set(:SPEC, vtable_hash)
+
+          layout(
+            *self::SPEC.map { |name, signature| [name, callback(*signature)] }.flatten
+          )
+        end
+
+        const_set(:VTBL, vtable)
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  module Helpers
+    def QueryInstance(klass)
+      instance = nil
+
+      FFI::MemoryPointer.new(:pointer) do |ppv|
+        QueryInterface(klass::IID, ppv)
+
+        instance = klass.new(ppv.read_pointer)
+      end
+
+      begin
+        yield instance
+        return self
+      ensure
+        instance.Release
+      end if block_given?
+
+      instance
+    end
+
+    def UseInstance(klass, name, *args)
+      instance = nil
+
+      FFI::MemoryPointer.new(:pointer) do |ppv|
+        send(name, *args, ppv)
+
+        yield instance = klass.new(ppv.read_pointer)
+      end
+
+      self
+    ensure
+      instance.Release if instance && !instance.null?
+    end
+  end
+
+  module Instance
+    def self.[](iface)
+      Class.new(iface) do
+        send(:include, Helpers)
+
+        def initialize(pointer)
+          self.pointer = pointer
+
+          @vtbl = self.class::VTBL.new(self[:lpVtbl])
+        end
+
+        attr_reader :vtbl
+
+        self::VTBL.members.each do |name|
+          define_method(name) do |*args|
+            if Puppet::Util::Windows::COM.FAILED((result = @vtbl[name].call(self, *args)))
+              raise Puppet::Util::Windows::Error.new(_("Failed to call %{klass}::%{name} with HRESULT: %{result}.") % { klass: self, name: name, result: result }, result)
+            end
+
+            result
+          end
+        end
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  module Factory
+    def self.[](iface, clsid)
+      Class.new(iface) do
+        send(:include, Helpers)
+
+        const_set(:CLSID, clsid)
+
+        def initialize(opts = {})
+          @opts = opts
+
+          @opts[:clsctx] ||= CLSCTX_INPROC_SERVER
+
+          FFI::MemoryPointer.new(:pointer) do |ppv|
+            hr = Puppet::Util::Windows::COM.CoCreateInstance(self.class::CLSID, FFI::Pointer::NULL, @opts[:clsctx], self.class::IID, ppv)
+            if Puppet::Util::Windows::COM.FAILED(hr)
+              raise _("CoCreateInstance failed (%{klass}).") % { klass: self.class }
+            end
+
+            self.pointer = ppv.read_pointer
+          end
+
+          @vtbl = self.class::VTBL.new(self[:lpVtbl])
+        end
+
+        attr_reader :vtbl
+
+        self::VTBL.members.each do |name|
+          define_method(name) do |*args|
+            if Puppet::Util::Windows::COM.FAILED((result = @vtbl[name].call(self, *args)))
+              raise Puppet::Util::Windows::Error.new(_("Failed to call %{klass}::%{name} with HRESULT: %{result}.") % { klass: self, name: name, result: result }, result)
+            end
+
+            result
+          end
+        end
+
+        layout \
+          :lpVtbl, :pointer
+      end
+    end
+  end
+
+  IUnknown = Interface[
+    FFI::WIN32::GUID['00000000-0000-0000-C000-000000000046'],
+    QueryInterface: [[:pointer, :pointer], :hresult],
+    AddRef: [[], :win32_ulong],
+    Release: [[], :win32_ulong]
+  ]
+
+  Unknown = Instance[IUnknown]
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
+  # HRESULT CoInitialize(
+  #   _In_opt_  LPVOID pvReserved
+  # );
+  ffi_lib :ole32
+  attach_function_private :CoInitialize, [:lpvoid], :hresult
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms688715(v=vs.85).aspx
+  # void CoUninitialize(void);
+  ffi_lib :ole32
+  attach_function_private :CoUninitialize, [], :void
+
+  def InitializeCom
+    raise_if_hresult_failed(:CoInitialize, FFI::Pointer::NULL)
+
+    at_exit { CoUninitialize() }
+  end
+
+  module_function :InitializeCom
+end

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

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+require_relative '../../../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 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.
+      unless SetServiceStatus(@@ssh, ss)
+        SetEvent(@@hStopEvent)
+      end
+    end
+
+    ERROR_CALL_NOT_IMPLEMENTED = 0x78
+
+    # Handles control signals from the service control manager.
+    Service_Ctrl_ex = proc 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|
+      # 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..]
+      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
+      end
+
+      # Main loop for the service.
+      while WaitForSingleObject(@@hStopCompletedEvent, 1000) != WAIT_OBJECT_0
+      end
+    ensure
+      # Stop the service.
+      SetTheServiceStatus.call(SERVICE_STOPPED, NO_ERROR, 0, 0)
+    end
+
+    # This is a shortcut for Daemon.new + Daemon#mainloop.
+    #
+    def self.mainloop
+      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 = Thread.new do
+        ste = FFI::MemoryPointer.new(SERVICE_TABLE_ENTRYW, 2)
+
+        s = SERVICE_TABLE_ENTRYW.new(ste[0])
+        s[:lpServiceName] = FFI::MemoryPointer.from_string("")
+        s[:lpServiceProc] = Service_Main
+
+        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..
+        StartServiceCtrlDispatcherW(ste)
+      end
+
+      while (index = WaitForSingleObject(@@hStartEvent, 1000)) == WAIT_TIMEOUT
+        # The thread exited, so the show is off.
+        raise "Service_Main thread exited abnormally" unless hThread.alive?
+      end
+
+      if index == WAIT_FAILED
+        raise SystemCallError.new("WaitForSingleObject", FFI.errno)
+      end
+
+      thr = Thread.new do
+        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
+
+      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

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/util/windows'
+require_relative '../../../puppet/error'
+
+# represents an error resulting from a Win32 error code
+class Puppet::Util::Windows::Error < Puppet::Error
+  require 'ffi'
+  extend FFI::Library
+
+  attr_reader :code
+
+  # NOTE: FFI.errno only works properly when prior Win32 calls have been made
+  # through FFI bindings.  Calls made through Win32API do not have their error
+  # codes captured by FFI.errno
+  def initialize(message, code = FFI.errno, original = nil)
+    super(message + ":  #{self.class.format_error_code(code)}", original)
+
+    @code = code
+  end
+
+  # Helper method that wraps FormatMessage that returns a human readable string.
+  def self.format_error_code(code)
+    # specifying 0 will look for LANGID in the following order
+    # 1.Language neutral
+    # 2.Thread LANGID, based on the thread's locale value
+    # 3.User default LANGID, based on the user's default locale value
+    # 4.System default LANGID, based on the system default locale value
+    # 5.US English
+    dwLanguageId = 0
+    flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
+            FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_ARGUMENT_ARRAY |
+            FORMAT_MESSAGE_IGNORE_INSERTS |
+            FORMAT_MESSAGE_MAX_WIDTH_MASK
+    error_string = ''.dup
+
+    # this pointer actually points to a :lpwstr (pointer) since we're letting Windows allocate for us
+    FFI::MemoryPointer.new(:pointer, 1) do |buffer_ptr|
+      length = FormatMessageW(flags, FFI::Pointer::NULL, code, dwLanguageId,
+                              buffer_ptr, 0, FFI::Pointer::NULL)
+
+      if length == FFI::WIN32_FALSE
+        # can't raise same error type here or potentially recurse infinitely
+        raise Puppet::Error, _("FormatMessageW could not format code %{code}") % { code: code }
+      end
+
+      # returns an FFI::Pointer with autorelease set to false, which is what we want
+      buffer_ptr.read_win32_local_pointer do |wide_string_ptr|
+        if wide_string_ptr.null?
+          raise Puppet::Error, _("FormatMessageW failed to allocate buffer for code %{code}") % { code: code }
+        end
+
+        error_string = wide_string_ptr.read_wide_string(length)
+      end
+    end
+
+    error_string
+  end
+
+  ERROR_FILE_NOT_FOUND      = 2
+  ERROR_ACCESS_DENIED       = 5
+
+  FORMAT_MESSAGE_ALLOCATE_BUFFER   = 0x00000100
+  FORMAT_MESSAGE_IGNORE_INSERTS    = 0x00000200
+  FORMAT_MESSAGE_FROM_SYSTEM       = 0x00001000
+  FORMAT_MESSAGE_ARGUMENT_ARRAY    = 0x00002000
+  FORMAT_MESSAGE_MAX_WIDTH_MASK    = 0x000000FF
+
+  ffi_convention :stdcall
+
+  # https://msdn.microsoft.com/en-us/library/windows/desktop/ms679351(v=vs.85).aspx
+  # DWORD WINAPI FormatMessage(
+  #   _In_      DWORD dwFlags,
+  #   _In_opt_  LPCVOID lpSource,
+  #   _In_      DWORD dwMessageId,
+  #   _In_      DWORD dwLanguageId,
+  #   _Out_     LPTSTR lpBuffer,
+  #   _In_      DWORD nSize,
+  #   _In_opt_  va_list *Arguments
+  # );
+  # NOTE: since we're not preallocating the buffer, use a :pointer for lpBuffer
+  ffi_lib :kernel32
+  attach_function_private :FormatMessageW,
+                          [:dword, :lpcvoid, :dword, :dword, :pointer, :dword, :pointer], :dword
+end