win32-service 0.7.2 → 0.8.0

data/examples/demo_daemon_ctl.rb

@@ -37,7 +37,7 @@
 require 'win32/service'
 require 'rbconfig'
 include Win32
-include Config
+include RbConfig
 
 # Make sure you're using the version you think you're using.
 puts 'VERSION: ' + Service::VERSION
@@ -46,7 +46,7 @@ SERVICE_NAME = 'DemoSvc'
 SERVICE_DISPLAYNAME = 'Demo'
 
 # Quote the full path to deal with possible spaces in the path name.
-ruby = File.join(CONFIG['bindir'], 'ruby').tr('/', '\\')
+ruby = File.join(CONFIG['bindir'], CONFIG['ruby_install_name']).tr('/', '\\')
 path = ' "' + File.dirname(File.expand_path($0)).tr('/', '\\')
 path += '\demo_daemon.rb"'
 cmd = ruby + path
@@ -62,7 +62,7 @@ case ARGV[0].downcase
          :description      => 'Sample Ruby service',
          :binary_path_name => cmd
       )
-      puts 'Service ' + SERVICE_NAME + ' installed'      
+      puts 'Service ' + SERVICE_NAME + ' installed'
    when 'start'
       if Service.status(SERVICE_NAME).current_state != 'running'
          Service.start(SERVICE_NAME, nil, 'hello', 'world')

data/examples/demo_services.rb

@@ -1,30 +1,30 @@
-#######################################################################
-# demo_services.rb
-#
-# Test script for general futzing that shows off the basic
-# capabilities of this library. Modify as you see fit.
-#
-# You can run this sample program via the "example:services" task.
-#######################################################################
-require 'win32/service'
-include Win32
-
-puts "VERSION: " + Service::VERSION
-
-p Service.exists?('Schedule')
-p Service.exists?('bogusxxx')
-
-status = Service.status('Schedule')
-p status
-
-info = Service.config_info('Schedule')
-
-print "\n\nShowing config info for Schedule service\n\n"
-p info
-
-print "\n\nAbout to show all services\n\n"
-sleep 10
-
-Service.services{ |struct|
-  p struct
-}
+#######################################################################
+# demo_services.rb
+#
+# Test script for general futzing that shows off the basic
+# capabilities of this library. Modify as you see fit.
+#
+# You can run this sample program via the "example:services" task.
+#######################################################################
+require 'win32/service'
+include Win32
+
+puts "VERSION: " + Service::VERSION
+
+p Service.exists?('Schedule')
+p Service.exists?('bogusxxx')
+
+status = Service.status('Schedule')
+p status
+
+info = Service.config_info('Schedule')
+
+print "\n\nShowing config info for Schedule service\n\n"
+p info
+
+print "\n\nAbout to show all services\n\n"
+sleep 10
+
+Service.services{ |struct|
+  p struct
+}

data/lib/win32/daemon.rb

@@ -0,0 +1,345 @@
+require File.join(File.dirname(__FILE__), 'windows', 'helper')
+require File.join(File.dirname(__FILE__), 'windows', 'constants')
+require File.join(File.dirname(__FILE__), 'windows', 'structs')
+require File.join(File.dirname(__FILE__), 'windows', 'functions')
+
+require 'ffi'
+
+# The Win32 module serves as a namespace only.
+module Win32
+
+  # The Daemon class
+  class Daemon
+    include Windows::Constants
+    include Windows::Structs
+    include Windows::Functions
+
+    extend Windows::Structs
+    extend Windows::Functions
+
+    # The version of this library
+    VERSION = '0.8.0'
+
+    private
+
+    # 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
+
+    # 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_SHUTDOWN
+      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
+
+    # Handles control signals from the service control manager.
+    Service_Ctrl_ex = Proc.new do |dwCtrlCode,dwEventType,lpEventData,lpContext|
+      @@waiting_control_code = dwCtrlCode;
+
+      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
+      end
+
+      # Set the status of the service.
+      SetTheServiceStatus.call(dwState, NO_ERROR, 0, 0)
+
+      # Tell service_main thread to stop.
+      if dwCtrlCode == SERVICE_CONTROL_STOP || dwCtrlCode == SERVICE_CONTROL_SHUTDOWN
+        if !SetEvent(@@hStopEvent)
+          SetTheServiceStatus.call(SERVICE_STOPPED, FFI.errno, 0, 0)
+        end
+      end
+    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..-1]
+      else
+        @@Argv = nil
+      end
+
+      # Register the service ctrl handler.
+      @@ssh = RegisterServiceCtrlHandlerEx(
+        lpszServiceName,
+        Service_Ctrl_ex,
+        nil
+      )
+
+      # No service to stop, no service handle to notify, nothing to do but exit.
+      return 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
+
+      # Stop the service.
+      SetTheServiceStatus.call(SERVICE_STOPPED, NO_ERROR, 0, 0)
+    end
+
+    ThreadProc = FFI::Function.new(:ulong,[:pointer]) do |lpParameter|
+      ste = FFI::MemoryPointer.new(SERVICE_TABLE_ENTRY, 2)
+
+      s = SERVICE_TABLE_ENTRY.new(ste[0])
+      s[:lpServiceName] = FFI::MemoryPointer.from_string('')
+      s[:lpServiceProc] = Service_Main
+
+      s = SERVICE_TABLE_ENTRY.new(ste[1])
+      s[:lpServiceName] = nil
+      s[:lpServiceProc] = nil
+
+      # No service to step, no service handle, no ruby exceptions, just terminate the thread..
+      if !StartServiceCtrlDispatcher(ste)
+        return 1
+      end
+
+      return 0
+    end
+
+    public
+
+    # 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 = CreateEvent(nil, true, false, nil)
+
+      if @@hStartEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      # Create the event to signal the service to stop.
+      @@hStopEvent = CreateEvent(nil, true, false, nil)
+
+      if @@hStopEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      # Create the event to signal the service that stop has completed
+      @@hStopCompletedEvent = CreateEvent(nil, true, false, nil)
+
+      if @@hStopCompletedEvent == 0
+        raise SystemCallError.new('CreateEvent', FFI.errno)
+      end
+
+      hThread = CreateThread(nil, 0, ThreadProc, nil, 0, nil)
+
+      if hThread == 0
+        raise SystemCallError.new('CreateThread', FFI.errno)
+      end
+
+      events = FFI::MemoryPointer.new(:pointer, FFI::Pointer.size*2)
+      events.put_pointer(0, FFI::Pointer.new(hThread))
+      events.put_pointer(FFI::Pointer.size, FFI::Pointer.new(@@hStartEvent))
+
+      while ((index = WaitForMultipleObjects(2, events, false, 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
+        while(WaitForSingleObject(@@hStopEvent, 10) == 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')
+      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 # Daemon
+end # Win32

data/lib/win32/service.rb

@@ -1,11 +1,7 @@
-require 'rubygems'
-require 'windows/error'
-require 'windows/service'
-require 'windows/file'
-require 'windows/process'
-require 'windows/security'
-require 'windows/msvcrt/string'
-require 'windows/msvcrt/buffer'
+require File.join(File.dirname(__FILE__), 'windows', 'helper')
+require File.join(File.dirname(__FILE__), 'windows', 'constants')
+require File.join(File.dirname(__FILE__), 'windows', 'structs')
+require File.join(File.dirname(__FILE__), 'windows', 'functions')
 
 # The Win32 module serves as a namespace only.
 module Win32
@@ -13,32 +9,18 @@ module Win32
   # The Service class encapsulates services controller actions, such as
   # creating, starting, configuring or deleting services.
   class Service
+    include Windows::Constants
+    include Windows::Structs
+    include Windows::Functions
+
+    extend Windows::Structs
+    extend Windows::Functions
 
-    # This is the error typically raised if one of the Service methods
-    # should fail for any reason.
-    class Error < StandardError; end
-      
-    include Windows::Error
-    include Windows::Service
-    include Windows::File
-    include Windows::Process
-    include Windows::Security
-    include Windows::MSVCRT::String
-    include Windows::MSVCRT::Buffer
-           
-    extend Windows::Error
-    extend Windows::Service
-    extend Windows::File
-    extend Windows::Process
-    extend Windows::Security
-    extend Windows::MSVCRT::String
-    extend Windows::MSVCRT::Buffer
-      
     # The version of the win32-service library
-    VERSION = '0.7.2'
-      
+    VERSION = '0.8.0'
+
     # SCM security and access rights
-      
+
     # Includes STANDARD_RIGHTS_REQUIRED, in addition to all other rights
     MANAGER_ALL_ACCESS = SC_MANAGER_ALL_ACCESS
 
@@ -89,7 +71,7 @@ module Win32
 
     # Required to call ControlService with a user defined control code
     USER_DEFINED_CONTROL = SERVICE_USER_DEFINED_CONTROL
-      
+
     # Service Types
 
     # Driver service
@@ -109,7 +91,7 @@ module Win32
 
     DRIVER = SERVICE_DRIVER
     TYPE_ALL = SERVICE_TYPE_ALL
-      
+
     # Service start options
 
     # A service started automatically by the SCM during system startup
@@ -126,7 +108,7 @@ module Win32
 
     # A service that cannot be started
     DISABLED = SERVICE_DISABLED
-      
+
     # Error control
 
     # Error logged, startup continues
@@ -140,9 +122,9 @@ module Win32
 
     # Error logged, startup fails, system restarted last known good config
     ERROR_CRITICAL = SERVICE_ERROR_CRITICAL
-      
+
     # Current state
- 
+
     # Service is not running
     STOPPED = SERVICE_STOPPED
 
@@ -163,7 +145,7 @@ module Win32
 
     # Service is paused
     PAUSED = SERVICE_PAUSED
-    
+
     # Service controls
 
     # Notifies service that it should stop
@@ -206,9 +188,9 @@ module Win32
 
     # Run a command
     ACTION_RUN_COMMAND = SC_ACTION_RUN_COMMAND
-      
+
     # :stopdoc: #
- 
+
     StatusStruct = Struct.new(
       'ServiceStatus',
       :service_type,
@@ -235,7 +217,7 @@ module Win32
       :service_start_name,
       :display_name
     )
-      
+
     ServiceStruct = Struct.new(
       'ServiceInfo',
       :service_name,
@@ -266,7 +248,7 @@ module Win32
     )
 
     # :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.
@@ -311,7 +293,7 @@ module Win32
     #      :display_name       => 'This is some service',
     #    )
     #
-    def initialize(options={})        
+    def initialize(options={})
       unless options.is_a?(Hash)
         raise ArgumentError, 'options parameter must be a hash'
       end
@@ -339,7 +321,7 @@ module Win32
         'failure_actions'        => nil,
         'failure_delay'          => 0,
         'host'                   => nil,
-        'service_name'           => nil            
+        'service_name'           => nil
       }
 
       # Validate the hash options
@@ -350,24 +332,22 @@ module Win32
         end
         opts[key] = value
       }
-         
+
       unless opts['service_name']
-        raise ArgumentError, 'No service_name specified'            
+        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, 0, SC_MANAGER_CREATE_SERVICE)
+        handle_scm = OpenSCManager(host, nil, SC_MANAGER_CREATE_SERVICE)
+
+        FFI.raise_windows_error('OpenSCManager') if handle_scm == 0
 
-        if handle_scm == 0
-          raise Error, get_last_error
-        end
-        
         # Display name defaults to service_name
         opts['display_name'] ||= service_name
 
@@ -377,12 +357,13 @@ module Win32
           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(
@@ -395,19 +376,17 @@ module Win32
           opts['error_control'],
           opts['binary_path_name'],
           opts['load_order_group'],
-          0,
+          nil,
           dependencies,
           opts['service_start_name'],
           opts['password']
         )
 
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
+        FFI.raise_windows_error('CreateService') if handle_scs == 0
 
         if opts['description']
-          description = 0.chr * 4 # sizeof(SERVICE_DESCRIPTION)
-          description[0,4] = [opts['description']].pack('p*')
+          description = SERVICE_DESCRIPTION.new
+          description[:lpDescription] = FFI::MemoryPointer.from_string(opts['description'])
 
           bool = ChangeServiceConfig2(
             handle_scs,
@@ -415,16 +394,14 @@ module Win32
             description
           )
 
-          unless bool
-            raise Error, get_last_error
-          end
+          FFI.raise_windows_error('ChangeServiceConfig2') unless bool
         end
-         
+
         if opts['failure_reset_period'] || opts['failure_reboot_message'] ||
            opts['failure_command'] || opts['failure_actions']
         then
           Service.configure_failure_actions(handle_scs, opts)
-        end         
+        end
       ensure
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
         CloseServiceHandle(handle_scm) if handle_scm && handle_scm > 0
@@ -476,7 +453,7 @@ module Win32
     #       :description        => 'A custom service I wrote just for fun'
     #    )
     #
-    def self.configure(options={})    
+    def self.configure(options={})
       unless options.is_a?(Hash)
         raise ArgumentError, 'options parameter must be a hash'
       end
@@ -513,11 +490,11 @@ module Win32
         end
         opts[key] = value
       }
-         
+
       unless opts['service_name']
-        raise ArgumentError, 'No service_name specified'            
+        raise ArgumentError, 'No service_name specified'
       end
-         
+
       service = opts.delete('service_name')
       host = opts.delete('host')
 
@@ -525,14 +502,12 @@ module Win32
       raise TypeError unless host.is_a?(String) if host
 
       begin
-        handle_scm = OpenSCManager(host, 0, SC_MANAGER_CONNECT)
+        handle_scm = OpenSCManager(host, nil, SC_MANAGER_CONNECT)
+
+        FFI.raise_windows_error('OpenSCManager') if handle_scm == 0
 
-        if handle_scm == 0
-          raise Error, get_last_error
-        end
-         
         desired_access = SERVICE_CHANGE_CONFIG
-         
+
         if opts['failure_actions']
           desired_access |= SERVICE_START
         end
@@ -543,9 +518,7 @@ module Win32
           desired_access
         )
 
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
 
         dependencies = opts['dependencies']
 
@@ -557,7 +530,7 @@ module Win32
           if dependencies.is_a?(Array)
             dependencies = dependencies.join("\000")
           end
-            
+
           dependencies += "\000"
         end
 
@@ -568,20 +541,18 @@ module Win32
           opts['error_control'],
           opts['binary_path_name'],
           opts['load_order_group'],
-          0,
+          nil,
           dependencies,
           opts['service_start_name'],
           opts['password'],
           opts['display_name']
         )
 
-        unless bool
-          raise Error, get_last_error
-        end
+        FFI.raise_windows_error('ChangeServiceConfig') unless bool
 
         if opts['description']
-          description = 0.chr * 4 # sizeof(SERVICE_DESCRIPTION)
-          description[0,4] = [opts['description']].pack('p*')
+          description = SERVICE_DESCRIPTION.new
+          description[:lpDescription] = FFI::MemoryPointer.from_string(opts['description'])
 
           bool = ChangeServiceConfig2(
             handle_scs,
@@ -589,9 +560,7 @@ module Win32
             description
           )
 
-          unless bool
-            raise Error, get_last_error
-          end
+          FFI.raise_windows_error('ChangeServiceConfig2') unless bool
         end
 
         if opts['failure_reset_period'] || opts['failure_reboot_message'] ||
@@ -606,24 +575,22 @@ module Win32
 
       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, 0, SC_MANAGER_ENUMERATE_SERVICE)
-         
-        if handle_scm == 0
-          raise Error, get_last_error
-        end
-         
+        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
@@ -631,9 +598,9 @@ module Win32
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
       end
 
-      bool         
+      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.
@@ -647,33 +614,31 @@ module Win32
     # Service.get_display_name('W32Time') => 'Windows Time'
     #
     def self.get_display_name(service, host=nil)
-      handle_scm = OpenSCManager(host, 0, SC_MANAGER_CONNECT)
-        
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-         
-      display_name = 0.chr * 260
-      display_buf  = [display_name.size].pack('L')
+      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_buf
+          display_size
         )
 
-        unless bool
-          raise Error, get_last_error
-        end
+
+        FFI.raise_windows_error('OpenSCManager') unless bool
       ensure
         CloseServiceHandle(handle_scm)
       end
 
-      display_name.unpack('Z*')[0]
+      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.
@@ -687,31 +652,28 @@ module Win32
     # Service.get_service_name('Windows Time') => 'W32Time'
     #
     def self.get_service_name(display_name, host=nil)
-      handle_scm = OpenSCManager(host, 0, SC_MANAGER_CONNECT)
-       
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-         
-      service_name = 0.chr * 260
-      service_buf  = [service_name.size].pack('L')
-         
+      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_buf
+          service_size
         )
 
-        unless bool
-          raise Error, get_last_error
-        end
+        FFI.raise_windows_error('GetServiceKeyName') unless bool
       ensure
         CloseServiceHandle(handle_scm)
       end
 
-      service_name.unpack('Z*')[0]
+      service_name.read_string
     end
 
     # Attempts to start the named +service+ on +host+, or the local machine
@@ -725,42 +687,53 @@ module Win32
     #
     #    # 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)
-    
-      if handle_scm == 0
-	      raise Error, get_last_error
-      end
-         
+
+      FFI.raise_windows_error('OpenSCManager') if handle_scm == 0
+
       begin
         handle_scs = OpenService(handle_scm, service, SERVICE_START)
-                  
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
-           
+
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
+
         num_args = 0
-         
+
         if args.empty?
           args = nil
-        else
-          num_args = args.length
-          args = args.map{ |x| [x].pack('p*') }.join
-        end     
-           
-        unless StartService(handle_scs, num_args, args)
-          raise Error, get_last_error
+        else # TODO: Verify that this works
+          str_ptrs = []
+          num_args = args.size
+
+          # First arg must be service name
+          str_ptrs << FFI::MemoryPointer.from_string(service)
+
+          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
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
         CloseServiceHandle(handle_scm)
       end
-        
-      self                          
+
+      self
     end
-      
+
     # Stops a the given +service+ on +host+, or the local host if no host
     # is specified. Returns self.
     #
@@ -770,14 +743,14 @@ module Win32
     # 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
     #
@@ -791,14 +764,14 @@ module Win32
     # 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.
     #
@@ -808,14 +781,14 @@ module Win32
     # 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.
     #
@@ -830,21 +803,17 @@ module Win32
     #   Service.delete('SomeService') => self
     #
     def self.delete(service, host=nil)
-      handle_scm = OpenSCManager(host, 0, SC_MANAGER_CREATE_SERVICE)
-       
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-       
+      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)
 
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
-       
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
+
         unless DeleteService(handle_scs)
-          raise Error, get_last_error
+          FFI.raise_windows_error('DeleteService')
         end
       ensure
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
@@ -871,72 +840,48 @@ module Win32
 
       handle_scm = OpenSCManager(host, nil, SC_MANAGER_ENUMERATE_SERVICE)
 
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
+      FFI.raise_windows_error('OpenSCManager') if handle_scm == 0
 
       begin
         handle_scs = OpenService(handle_scm, service, SERVICE_QUERY_CONFIG)
 
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
 
         # First, get the buf size needed
-        bytes_needed = [0].pack('L')
+        bytes = FFI::MemoryPointer.new(:ulong)
 
-        bool = QueryServiceConfig(handle_scs, nil, 0, bytes_needed)
+        bool = QueryServiceConfig(handle_scs, nil, 0, bytes)
 
-        if !bool && GetLastError() != ERROR_INSUFFICIENT_BUFFER
-          raise Error, get_last_error
+        if !bool && FFI.errno != ERROR_INSUFFICIENT_BUFFER
+          FFI.raise_windows_error('QueryServiceConfig')
         end
 
-        buf = 0.chr * bytes_needed.unpack('L')[0]
-        bytes = [0].pack('L')
+        buf = FFI::MemoryPointer.new(:char, bytes.read_ulong)
+        bytes = FFI::MemoryPointer.new(:ulong)
 
-        bool = QueryServiceConfig(handle_scs, buf, buf.size, bytes_needed)
+        bool = QueryServiceConfig(handle_scs, buf, buf.size, bytes)
 
-        unless bool
-          raise Error, get_last_error
-        end
+        struct = QUERY_SERVICE_CONFIG.new(buf) # cast the buffer
+
+        FFI.raise_windows_error('QueryServiceConfig') unless bool
       ensure
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
         CloseServiceHandle(handle_scm)
       end
 
-      binary_path_name   = 0.chr * 1024
-      load_order_group   = 0.chr * 1024
-      dependencies       = 0.chr * 1024
-      service_start_name = 0.chr * 260
-      display_name       = 0.chr * 260
-
-      strcpy(binary_path_name, buf[12,4].unpack('L')[0])
-      binary_path_name = binary_path_name.unpack('Z*')[0]
-
-      strcpy(load_order_group, buf[16,4].unpack('L')[0])
-      load_order_group = load_order_group.unpack('Z*')[0]
-
-      dependencies = get_dependencies(buf[24,4].unpack('L').first)
-
-      strcpy(service_start_name, buf[28,4].unpack('L')[0])
-      service_start_name = service_start_name.unpack('Z*')[0]
-
-      strcpy(display_name, buf[32,4].unpack('L')[0])
-      display_name = display_name.unpack('Z*')[0]
-
       ConfigStruct.new(
-        get_service_type(buf[0,4].unpack('L')[0]),
-        get_start_type(buf[4,4].unpack('L')[0]),
-        get_error_control(buf[8,4].unpack('L')[0]),
-        binary_path_name,
-        load_order_group,
-        buf[20,4].unpack('L')[0],
-        dependencies,
-        service_start_name,
-        display_name
+        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[:lpDependencies].read_array_of_null_separated_strings,
+        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.
     #
@@ -945,27 +890,23 @@ module Win32
     # Service.status('W32Time') => <struct Struct::ServiceStatus ...>
     #
     def self.status(service, host=nil)
-      handle_scm = OpenSCManager(host, 0, SC_MANAGER_ENUMERATE_SERVICE)
-          
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-           
+      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_STATUS
         )
-           
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
-           
+
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
+
         # SERVICE_STATUS_PROCESS struct
-        status = [0,0,0,0,0,0,0,0,0].pack('LLLLLLLLL')
-        bytes  = [0].pack('L')
-           
+        status = SERVICE_STATUS_PROCESS.new
+        bytes  = FFI::MemoryPointer.new(:ulong)
+
         bool = QueryServiceStatusEx(
           handle_scs,
           SC_STATUS_PROCESS_INFO,
@@ -973,40 +914,35 @@ module Win32
           status.size,
           bytes
         )
-           
-        unless bool
-          raise Error, get_last_error
-        end
-           
-        dw_service_type = status[0,4].unpack('L').first
-           
-        service_type  = get_service_type(dw_service_type)
-        current_state = get_current_state(status[4,4].unpack('L').first)
-        controls      = get_controls_accepted(status[8,4].unpack('L').first)
-        interactive   = dw_service_type & SERVICE_INTERACTIVE_PROCESS > 0
-           
+
+        FFI.raise_windows_error('QueryServiceStatusEx') unless bool
+
+        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
+
         # Note that the pid and service flags will always return 0 if you're
         # on Windows NT 4 or using a version of Ruby compiled with VC++ 6
         # or earlier.
-        # 
+        #
         status_struct = StatusStruct.new(
           service_type,
           current_state,
           controls,
-          status[12,4].unpack('L').first, # Win32ExitCode
-          status[16,4].unpack('L').first, # ServiceSpecificExitCode
-          status[20,4].unpack('L').first, # CheckPoint
-          status[24,4].unpack('L').first, # WaitHint
+          status[:dwWin32ExitCode],
+          status[:dwServiceSpecificExitCode],
+          status[:dwCheckPoint],
+          status[:dwWaitHint],
           interactive,
-          status[28,4].unpack('L').first, # ProcessId
-          status[32,4].unpack('L').first  # ServiceFlags
+          status[:dwProcessId],
+          status[:dwServiceFlags]
         )
-           
       ensure
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
         CloseServiceHandle(handle_scm)
       end
-       
+
       status_struct
     end
 
@@ -1030,25 +966,23 @@ module Win32
     #
     #    # 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, 0, SC_MANAGER_ENUMERATE_SERVICE)
-         
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-          
-      bytes_needed      = [0].pack('L')
-      services_returned = [0].pack('L')
-      resume_handle     = [0].pack('L')
+
+      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
@@ -1057,7 +991,7 @@ module Win32
           SC_ENUM_PROCESS_INFO,
           SERVICE_WIN32 | SERVICE_DRIVER,
           SERVICE_STATE_ALL,
-          0,
+          nil,
           0,
           bytes_needed,
           services_returned,
@@ -1065,14 +999,12 @@ module Win32
           group
         )
 
-        err_num = GetLastError()
-
-        if !bool && err_num == ERROR_MORE_DATA
-          service_buf = 0.chr * bytes_needed.unpack('L').first
+        if !bool && FFI.errno == ERROR_MORE_DATA
+          service_buf = FFI::MemoryPointer.new(:char, bytes_needed.read_ulong)
         else
-          raise Error, get_last_error(err_num)
+          FFI.raise_windows_error('EnumServiceStatusEx')
         end
-          
+
         bool = EnumServicesStatusEx(
           handle_scm,
           SC_ENUM_PROCESS_INFO,
@@ -1085,40 +1017,31 @@ module Win32
           resume_handle,
           group
         )
-         
-        unless bool
-          raise Error, get_last_error
-        end
 
-        num_services = services_returned.unpack('L').first
-           
-        index = 0
+        FFI.raise_windows_error('EnumServiceStatusEx') unless bool
+
+        num_services = services_returned.read_ulong
+
         services_array = [] unless block_given?
 
         1.upto(num_services){ |num|
-          service_name = 0.chr * 260
-          display_name = 0.chr * 260
-
-          info = service_buf[index, 44] # sizeof(SERVICE_STATUS_PROCESS)
-
-          strcpy(service_name, info[0,4].unpack('L').first)
-          strcpy(display_name, info[4,4].unpack('L').first)
-
-          service_name = service_name.unpack('Z*')[0]
-          display_name = display_name.unpack('Z*')[0]
-             
-          dw_service_type = info[8,4].unpack('L').first
-       
-          service_type  = get_service_type(dw_service_type)
-          current_state = get_current_state(info[12,4].unpack('L').first)
-          controls      = get_controls_accepted(info[16,4].unpack('L').first)
-          interactive   = dw_service_type & SERVICE_INTERACTIVE_PROCESS > 0
-          win_exit_code = info[20,4].unpack('L').first
-          ser_exit_code = info[24,4].unpack('L').first
-          check_point   = info[28,4].unpack('L').first
-          wait_hint     = info[32,4].unpack('L').first
-          pid           = info[36,4].unpack('L').first
-          service_flags = info[40,4].unpack('L').first
+          # 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(
@@ -1126,43 +1049,34 @@ module Win32
               service_name,
               SERVICE_QUERY_CONFIG
             )
-               
-            if handle_scs == 0
-              raise Error, get_last_error
-            end
 
-            config_buf = get_config_info(handle_scs)
+            FFI.raise_windows_error('OpenService') if handle_scs == 0
 
-            if config_buf != ERROR_FILE_NOT_FOUND
-              binary_path = 0.chr * 1024
-              strcpy(binary_path, config_buf[12,4].unpack('L').first)
-              binary_path = binary_path.unpack('Z*')[0]
+            config_struct = get_config_info(handle_scs)
 
-              load_order = 0.chr * 1024
-              strcpy(load_order, config_buf[16,4].unpack('L').first)
-              load_order = load_order.unpack('Z*')[0]
-           
-              start_name = 0.chr * 1024
-              strcpy(start_name, config_buf[28,4].unpack('L').first)
-              start_name = start_name.unpack('Z*')[0]
-            
-              start_type = get_start_type(config_buf[4,4].unpack('L').first)
-              error_ctrl = get_error_control(config_buf[8,4].unpack('L').first)
+            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]
 
-              tag_id = config_buf[20,4].unpack('L').first
+              start_type = get_start_type(config_struct[:dwStartType])
+              error_ctrl = get_error_control(config_struct[:dwErrorControl])
 
-              deps = get_dependencies(config_buf[24,4].unpack('L').first)
+              deps = config_struct[:lpDependencies].read_array_of_null_separated_strings
 
-              description = 0.chr * 2048
-              buf = get_config2_info(handle_scs, SERVICE_CONFIG_DESCRIPTION) 
+              buf = get_config2_info(handle_scs, SERVICE_CONFIG_DESCRIPTION)
 
-              strcpy(description, buf[0,4].unpack('L').first)
-              description = description.unpack('Z*')[0]
+              if buf.read_pointer.null?
+                description = ''
+              else
+                description = buf.read_pointer.read_string
+              end
             else
               msg = "WARNING: The registry entry for the #{service_name} "
               msg += "service could not be found."
               warn msg
-             
+
               binary_path = nil
               load_order  = nil
               start_name  = nil
@@ -1172,47 +1086,51 @@ module Win32
               deps        = nil
               description = nil
             end
-            
+
             buf2 = get_config2_info(handle_scs, SERVICE_CONFIG_FAILURE_ACTIONS)
-            
-            if buf2 != ERROR_FILE_NOT_FOUND
-              reset_period = buf2[0,4].unpack('L').first
-            
-              reboot_msg = 0.chr * 260
-              strcpy(reboot_msg, buf2[4,4].unpack('L').first)
-              reboot_msg = reboot_msg.unpack('Z*')[0]
-            
-              command = 0.chr * 260
-              strcpy(command, buf2[8,4].unpack('L').first)
-              command = command.unpack('Z*')[0]
-            
-              num_actions = buf2[12,4].unpack('L').first
+
+            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 = buf2[16,4].unpack('L').first
-                action_buf = [0,0].pack('LL') * num_actions
-                memcpy(action_buf, action_ptr, action_buf.size)
-               
-                i = 0
+                action_ptr = fail_struct[:lpsaActions]
+
                 actions = {}
+
                 num_actions.times{ |n|
-                  action_type, delay = action_buf[i, 8].unpack('LL')
-                  action_type = get_action_type(action_type)
+                  sc_action = SC_ACTION.new(action_ptr[n])
+                  delay = sc_action[:Delay]
+                  action_type = get_action_type(sc_action[:Type])
                   actions[n+1] = {:action_type => action_type, :delay => delay}
-                  i += 8
                 }
               end
             else
-              reset_period   = nil
-              reboot_message = nil
-              command        = nil
-              actions        = nil
+              reset_period = nil
+              reboot_msg   = nil
+              command      = nil
+              actions      = nil
             end
           ensure
             CloseServiceHandle(handle_scs) if handle_scs > 0
           end
-          
+
           struct = ServiceStruct.new(
             service_name,
             display_name,
@@ -1240,55 +1158,55 @@ module Win32
             num_actions,
             actions
           )
-          
+
           if block_given?
              yield struct
           else
              services_array << struct
           end
 
-          index += 44 # sizeof(SERVICE_STATUS_PROCESS)
+          service_buf += ENUM_SERVICE_STATUS_PROCESS.size
         }
       ensure
         CloseServiceHandle(handle_scm)
       end
-       
+
       block_given? ? nil : services_array
     end
-      
+
     private
-      
+
     # Configures failure actions for a given service.
     #
     def self.configure_failure_actions(handle_scs, opts)
       if opts['failure_actions']
         token_handle = 0.chr * 4
-                        
+
         bool = OpenProcessToken(
           GetCurrentProcess(),
           TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
           token_handle
         )
-                           
+
         unless bool
           error = get_last_error
           CloseServiceHandle(handle_scs)
-          raise Error, error            
+          raise Error, error
         end
-                           
+
         token_handle = token_handle.unpack('L').first
-                     
+
         # Get the LUID for shutdown privilege.
         luid = 0.chr * 8
-                     
+
         unless LookupPrivilegeValue('', 'SeShutdownPrivilege', luid)
           error = get_last_error
           CloseServiceHandle(handle_scs)
-          raise Error, error                
+          raise Error, error
         end
-                     
+
         tkp = [1].pack('L') + luid + [SE_PRIVILEGE_ENABLED].pack('L')
-                        
+
         # Enable shutdown privilege in access token of this process
         bool = AdjustTokenPrivileges(
           token_handle,
@@ -1298,69 +1216,69 @@ module Win32
           nil,
           nil
         )
-                        
+
         unless bool
           error = get_last_error
           CloseServiceHandle(handle_scs)
-          raise Error, error                
-        end                              
-      end             
-                              
+          raise Error, error
+        end
+      end
+
       fail_buf = 0.chr * 20 # sizeof(SERVICE_FAILURE_ACTIONS)
 
       if opts['failure_reset_period']
         fail_buf[0,4] = [opts['failure_reset_period']].pack('L')
       end
-         
+
       if opts['failure_reboot_message']
         fail_buf[4,4] = [opts['failure_reboot_message']].pack('p*')
       end
-         
+
       if opts['failure_command']
         fail_buf[8,4] = [opts['failure_command']].pack('p*')
       end
-         
+
       if opts['failure_actions']
         actions = []
-        
+
         opts['failure_actions'].each{ |action|
           action_buf = 0.chr * 8
           action_buf[0, 4] = [action].pack('L')
           action_buf[4, 4] = [opts['failure_delay']].pack('L')
           actions << action_buf
         }
-                        
+
         actions = actions.join
-       
+
         fail_buf[12,4] = [opts['failure_actions'].length].pack('L')
         fail_buf[16,4] = [actions].pack('p*')
       end
-         
+
       bool = ChangeServiceConfig2(
         handle_scs,
         SERVICE_CONFIG_FAILURE_ACTIONS,
         fail_buf
       )
-         
+
       unless bool
         error = get_last_error
         CloseServiceHandle(handle_scs)
         raise Error, error
-      end         
+      end
     end
 
     # Unravels a pointer to an array of dependencies. Takes the address
     # that points the array as an argument.
     #
     def self.get_dependencies(address)
-      dep_buf = "" 
+      dep_buf = ""
 
       while address != 0
         char_buf = 0.chr
         memcpy(char_buf, address, 1)
-        address += 1             
+        address += 1
         dep_buf += char_buf
-        break if dep_buf[-2,2] == "\0\0"             
+        break if dep_buf[-2,2] == "\0\0"
       end
 
       dependencies = []
@@ -1371,7 +1289,7 @@ module Win32
 
       dependencies
     end
-      
+
     # Returns a human readable string indicating the action type.
     #
     def self.get_action_type(action_type)
@@ -1386,7 +1304,7 @@ module Win32
           'command'
         else
           'unknown'
-       end
+      end
     end
 
     # Shortcut for QueryServiceConfig. Returns the buffer. In rare cases
@@ -1395,24 +1313,22 @@ module Win32
     # instead.
     #
     def self.get_config_info(handle)
-      bytes_needed = [0].pack('L')
+      bytes_needed = FFI::MemoryPointer.new(:ulong)
 
       # First attempt at QueryServiceConfig is to get size needed
-      bool = QueryServiceConfig(handle, 0, 0, bytes_needed)
-
-      err_num = GetLastError()
+      bool = QueryServiceConfig(handle, nil, 0, bytes_needed)
 
-      if !bool && err_num == ERROR_INSUFFICIENT_BUFFER
-        config_buf = 0.chr * bytes_needed.unpack('L').first
-      elsif err_num == ERROR_FILE_NOT_FOUND
-        return err_num
+      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 = get_last_error(err_num)
+        error = FFI.errno
         CloseServiceHandle(handle)
-        raise Error, error
+        FFI.raise_windows_error('QueryServiceConfig', error)
       end
 
-      bytes_needed = [0].pack('L')
+      bytes_needed = FFI::MemoryPointer.new(:ulong)
 
       # Second attempt at QueryServiceConfig gets the actual info
       begin
@@ -1423,34 +1339,34 @@ module Win32
           bytes_needed
         )
 
-        raise Error, get_last_error unless bool
+        FFI.raise_windows_error('QueryServiceConfig') unless bool
       ensure
         CloseServiceHandle(handle) unless bool
       end
 
-      config_buf
+      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 = [0].pack('L')
-         
+    #
+    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, 0, 0, bytes_needed)
+      bool = QueryServiceConfig2(handle, info_level, nil, 0, bytes_needed)
 
-      err_num = GetLastError()
+      err_num = FFI.errno
 
       if !bool && err_num == ERROR_INSUFFICIENT_BUFFER
-        config2_buf = 0.chr * bytes_needed.unpack('L').first
+        config2_buf = FFI::MemoryPointer.new(:char, bytes_needed.read_ulong)
       elsif err_num == ERROR_FILE_NOT_FOUND
         return err_num
       else
         CloseServiceHandle(handle)
-        raise Error, get_last_error(err_num)
+        FFI.raise_windows_error('QueryServiceConfig2', err_num)
       end
-         
-      bytes_needed = [0].pack('L')
+
+      bytes_needed = FFI::MemoryPointer.new(:ulong)
 
       # Second attempt at QueryServiceConfig2 gets the actual info
       begin
@@ -1462,14 +1378,14 @@ module Win32
           bytes_needed
         )
 
-        raise Error, get_last_error unless bool
+        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)
@@ -1486,7 +1402,7 @@ module Win32
           nil
       end
     end
-      
+
     # Returns a human readable string indicating the start type.
     #
     def self.get_start_type(start_type)
@@ -1505,7 +1421,7 @@ module Win32
           nil
       end
     end
-      
+
     # Returns an array of human readable strings indicating the controls
     # that the service accepts.
     #
@@ -1550,9 +1466,9 @@ module Win32
 
       array
     end
-      
+
     # Converts a service state numeric constant into a readable string.
-    # 
+    #
     def self.get_current_state(state)
       case state
         when SERVICE_CONTINUE_PENDING
@@ -1573,9 +1489,9 @@ module Win32
           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
@@ -1602,33 +1518,29 @@ module Win32
           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, 0, SC_MANAGER_CONNECT)
-         
-      if handle_scm == 0
-        raise Error, get_last_error
-      end
-         
+      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)
-         
-        if handle_scs == 0
-          raise Error, get_last_error
-        end
-         
-        status = [0,0,0,0,0,0,0].pack('LLLLLLL')
-         
+
+        FFI.raise_windows_error('OpenService') if handle_scs == 0
+
+        status = SERVICE_STATUS.new
+
         unless ControlService(handle_scs, control_signal, status)
-          raise Error, get_last_error
-        end        
+          FFI.raise_windows_error('ControlService')
+        end
       ensure
         CloseServiceHandle(handle_scs) if handle_scs && handle_scs > 0
         CloseServiceHandle(handle_scm) if handle_scm && handle_scm > 0
       end
-         
+
       status
     end