IOWA 1.0.0

data/external/windows-pr/lib/windows/registry.rb

@@ -0,0 +1,238 @@
+require 'windows/file'
+
+module Windows
+   module Registry
+      include Windows::File
+      
+      HKEY_CLASSES_ROOT        = 0x80000000
+      KEY_CURRENT_USER         = 0x80000001
+      HKEY_LOCAL_MACHINE       = 0x80000002
+      HKEY_USERS               = 0x80000003
+      HKEY_PERFORMANCE_DATA    = 0x80000004
+      HKEY_PERFORMANCE_TEXT    = 0x80000050
+      HKEY_PERFORMANCE_NLSTEXT = 0x80000060
+      HKEY_CURRENT_CONFIG      = 0x80000005
+      HKEY_DYN_DATA            = 0x80000006
+
+      KEY_QUERY_VALUE         = 0x0001
+      KEY_SET_VALUE           = 0x0002
+      KEY_CREATE_SUB_KEY      = 0x0004
+      KEY_ENUMERATE_SUB_KEYS  = 0x0008
+      KEY_NOTIFY              = 0x0010
+      KEY_CREATE_LINK         = 0x0020
+      KEY_WOW64_32KEY         = 0x0200
+      KEY_WOW64_64KEY         = 0x0100
+      KEY_WOW64_RES           = 0x0300
+
+      KEY_READ = (STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|
+                  KEY_NOTIFY) & (~SYNCHRONIZE)
+
+      KEY_WRITE = (STANDARD_RIGHTS_WRITE|KEY_SET_VALUE|
+                  KEY_CREATE_SUB_KEY) & (~SYNCHRONIZE)
+
+      KEY_EXECUTE = KEY_READ & (~SYNCHRONIZE)
+
+      KEY_ALL_ACCESS = (STANDARD_RIGHTS_ALL|KEY_QUERY_VALUE|KEY_SET_VALUE|
+                  KEY_CREATE_SUB_KEY|KEY_ENUMERATE_SUB_KEYS|KEY_NOTIFY|
+                  KEY_CREATE_LINK) & (~SYNCHRONIZE)
+                  
+      REG_OPTION_RESERVED       = 0
+      REG_OPTION_NON_VOLATILE   = 0
+      REG_OPTION_VOLATILE       = 1
+      REG_OPTION_CREATE_LINK    = 2
+      REG_OPTION_BACKUP_RESTORE = 4
+      REG_OPTION_OPEN_LINK      = 8
+
+      REG_LEGAL_OPTION = REG_OPTION_RESERVED|REG_OPTION_NON_VOLATILE|
+         REG_OPTION_VOLATILE|REG_OPTION_CREATE_LINK|REG_OPTION_BACKUP_RESTORE|
+         REG_OPTION_OPEN_LINK
+
+      REG_CREATED_NEW_KEY     = 1
+      REG_OPENED_EXISTING_KEY = 2
+
+      REG_STANDARD_FORMAT = 1
+      REG_LATEST_FORMAT   = 2
+      REG_NO_COMPRESSION  = 4
+
+      REG_WHOLE_HIVE_VOLATILE = 1
+      REG_REFRESH_HIVE        = 2
+      REG_NO_LAZY_FLUSH       = 4
+      REG_FORCE_RESTORE       = 8
+
+      REG_FORCE_UNLOAD = 1
+
+      REG_NOTIFY_CHANGE_NAME        = 1
+      REG_NOTIFY_CHANGE_ATTRIBUTES  = 2
+      REG_NOTIFY_CHANGE_LAST_SET    = 4
+      REG_NOTIFY_CHANGE_SECURITY    = 8
+
+      REG_LEGAL_CHANGE_FILTER = REG_NOTIFY_CHANGE_NAME|
+         REG_NOTIFY_CHANGE_ATTRIBUTES|REG_NOTIFY_CHANGE_LAST_SET|
+         REG_NOTIFY_CHANGE_SECURITY
+
+      REG_NONE                       = 0
+      REG_SZ                         = 1
+      REG_EXPAND_SZ                  = 2    
+      REG_BINARY                     = 3
+      REG_DWORD                      = 4
+      REG_DWORD_LITTLE_ENDIAN        = 4
+      REG_DWORD_BIG_ENDIAN           = 5
+      REG_LINK                       = 6
+      REG_MULTI_SZ                   = 7
+      REG_RESOURCE_LIST              = 8 
+      REG_FULL_RESOURCE_DESCRIPTOR   = 9
+      REG_RESOURCE_REQUIREMENTS_LIST = 10 
+      REG_QWORD                      = 11 
+      REG_QWORD_LITTLE_ENDIAN        = 11
+
+      RegCloseKey               = Win32API.new('advapi32', 'RegCloseKey', 'L', 'L')
+      RegConnectRegistry        = Win32API.new('advapi32', 'RegConnectRegistry', 'PLP', 'L')
+      RegCreateKey              = Win32API.new('advapi32', 'RegCreateKey', 'LPP', 'L')
+      RegCreateKeyEx            = Win32API.new('advapi32', 'RegCreateKeyEx', 'LPLPLLPPP', 'L')
+      RegDeleteKey              = Win32API.new('advapi32', 'RegDeleteKey', 'LP', 'L')
+      RegDeleteValue            = Win32API.new('advapi32', 'RegDeleteValue', 'LP', 'L')
+      RegDisablePredefinedCache = Win32API.new('advapi32', 'RegDisablePredefinedCache', 'V', 'L')
+      RegEnumKey                = Win32API.new('advapi32', 'RegEnumKey', 'LLPL', 'L')
+      RegEnumKeyEx              = Win32API.new('advapi32', 'RegEnumKeyEx', 'LLPPPPP', 'L')
+      RegEnumValue              = Win32API.new('advapi32', 'RegEnumValue', 'LLPPPPPP', 'L')
+      RegFlushKey               = Win32API.new('advapi32', 'RegFlushKey', 'L', 'L')
+      RegLoadKey                = Win32API.new('advapi32', 'RegLoadKey', 'LPP', 'L')
+      RegNotifyChangeKeyValue   = Win32API.new('advapi32', 'RegNotifyChangeKeyValue', 'LILLI', 'L')
+      RegOpenCurrentUser        = Win32API.new('advapi32', 'RegOpenCurrentUser', 'LP', 'L')
+      RegOpenKey                = Win32API.new('advapi32', 'RegOpenKey', 'LPP', 'L')
+      RegOpenKeyEx              = Win32API.new('advapi32', 'RegOpenKeyEx', 'LPLLP', 'L')
+      RegOpenUserClassesRoot    = Win32API.new('advapi32', 'RegOpenUserClassesRoot', 'LLLP', 'L')
+      RegOverridePredefKey      = Win32API.new('advapi32', 'RegOverridePredefKey', 'LL', 'L')
+      RegQueryInfoKey           = Win32API.new('advapi32', 'RegQueryInfoKey', 'LPPPPPPPPPPP', 'L')
+      RegQueryMultipleValues    = Win32API.new('advapi32', 'RegQueryMultipleValues', 'LPLPP', 'L')
+      RegQueryValueEx           = Win32API.new('advapi32', 'RegQueryValueEx', 'LPPPPP', 'L')
+      RegReplaceKey             = Win32API.new('advapi32', 'RegReplaceKey', 'LPPP', 'L')
+      RegRestoreKey             = Win32API.new('advapi32', 'RegRestoreKey', 'LPL', 'L')
+      RegSaveKey                = Win32API.new('advapi32', 'RegSaveKey', 'LPP', 'L')      
+      RegSetValueEx             = Win32API.new('advapi32', 'RegSetValueEx', 'LPLLPL', 'L')
+      RegUnLoadKey              = Win32API.new('advapi32', 'RegUnLoadKey', 'LP', 'L')
+      
+      # Windows XP or later
+      begin
+         RegSaveKeyEx = Win32API.new('advapi32', 'RegSaveKeyEx', 'LPPL', 'L')
+      rescue Exception
+         # Do nothing - not supported on current platform.  It's up to you to
+         # check for the existence of the constant in your code.
+      end
+
+      def RegCloseKey(key)
+         RegCloseKey.call(key)
+      end
+
+      def RegConnectRegistry(machine, key, result)
+         RegConnectRegistry.call(machine, key, result)
+      end
+
+      def RegCreateKey(key, subkey, result)
+         RegCreateKey.call(key, subkey, result)
+      end
+
+      def RegCreateKeyEx(key, subkey, res, klass, opt, sam, sec, result, disp)
+         RegCreateKeyEx.call(key, subkey, res, klass, opt, sam, sec, result, disp)
+      end
+
+      def RegDeleteKey(key, subkey)
+         RegDeleteKey.call(key, subkey)
+      end
+
+      def RegDeleteValue(key, value)
+         RegDeleteValue.call(key, value)
+      end
+
+      def RegDisablePredefinedCache()
+         RegDisablePredefinedCache.call()
+      end
+
+      def RegEnumKey(key, index, name, size)
+         RegEnumKey.call(key, index, name, size)
+      end
+
+      def RegEnumKeyEx(key, index, name, size, res, klass, ksize, time)
+         RegEnumKeyEx.call(key, index, name, size, res, klass, ksize, time)
+      end
+
+      def RegEnumValue(key, index, value, size, res, type, data, dsize)
+         RegEnumValue.call(key, index, value, size, res, type, data, dsize)
+      end
+
+      def RegOpenKeyEx(key, subkey, options, sam, result)
+         RegOpenKeyEx.call(key, subkey, options, sam, result)
+      end
+
+      def RegFlushKey(key)
+         RegFlushKey.call(key)
+      end
+
+      def RegLoadKey(key, subkey, file)
+         RegLoadKey.call(key, subkey, file)
+      end
+
+      def RegNotifyChangeKeyValue(key, subtree, filter, event, async)
+         RegNotifyChangeKeyValue.call(key, subtree, filter, event, async)
+      end
+
+      def RegOpenCurrentUser(sam, result)
+         RegOpenCurrentUser.call(sam, result)
+      end
+
+      def RegOpenKeyEx(key, subkey, options, sam, result)
+         RegOpenKeyEx.call(key, subkey, options, sam, result)
+      end
+
+      def RegOpenUserClassesRoot(token, options, sam, result)
+         RegOpenUserClassesRoot.call(token, options, sam, result)
+      end
+
+      def RegOverridePredefKey(key, new_key)
+         RegOverridePredefKey.call(key, new_key)
+      end
+
+      def RegQueryInfoKey(key, klass, ksize, res, subkeys, maxkey, maxklass,
+         values, maxname, maxvalue, sec, time)
+         RegQueryInfoKey.call(key, klass, ksize, res, subkeys, maxkey, maxklass,
+            values, maxname, maxvalue, sec, time)
+      end
+
+      def RegQueryMultipleValues(key, val_list, num_vals, buf, size)
+         RegQueryMultipleValues.call(key, val_list, num_vals, buf, size)
+      end
+
+      def RegQueryValueEx(key, value, res, type, data, cbdata)
+         RegQueryValueEx.call(key, value, res, type, data, cbdata)
+      end
+
+      def RegReplaceKey(key, subkey, newfile, oldfile)
+         RegReplaceKey.call(key, subkey, newfile, oldfile)
+      end
+
+      def RegRestoreKey(key, file, flags)
+         RegRestoreKey.call(key, file, flags)
+      end
+
+      def RegSaveKey(key, file, sec)
+         RegSaveKey.call(key, file, sec)
+      end
+
+      def RegSetValueEx(key, value, res, type, data, size)
+         RegSetValueEx.call(key, value, res, type, data, size)
+      end
+
+      def RegUnLoadKey(key, subkey)
+         RegUnLoadKey.call(key, subkey)
+      end
+      
+      # Windows XP or later
+      begin
+         def RegSaveKeyEx(key, file, sec, flags)
+            RegSaveKeyEx.call(key, file, sec, flags)
+         end
+      rescue Exception
+         # Do nothing - not supported on current platform
+      end
+   end
+end

data/external/windows-pr/lib/windows/security.rb

@@ -0,0 +1,89 @@
+require 'Win32API'
+
+module Windows
+   module Security
+      ACL_REVISION                   = 2
+      ACL_REVISION2                  = 2
+      ACL_REVISION3                  = 3
+      ACL_REVISION4                  = 4
+      ALLOW_ACE_LENGTH               = 62
+      DACL_SECURITY_INFORMATION      = 4
+      SE_DACL_PRESENT                = 4
+      SECURITY_DESCRIPTOR_MIN_LENGTH = 20
+      SECURITY_DESCRIPTOR_REVISION   = 1
+      
+      GENERIC_RIGHTS_MASK = 4026597376
+      GENERIC_RIGHTS_CHK  = 4026531840
+      REST_RIGHTS_MASK    = 2097151
+      
+      AddAce          = Win32API.new('advapi32', 'AddAce', 'PLLLL', 'I')
+      CopySid         = Win32API.new('advapi32', 'CopySid', 'LLP', 'I')
+      GetAce          = Win32API.new('advapi32', 'GetAce', 'LLP', 'I')
+      GetFileSecurity = Win32API.new('advapi32', 'GetFileSecurity', 'PLPLP', 'I')      
+      GetLengthSid    = Win32API.new('advapi32', 'GetLengthSid', 'P', 'L')  
+       
+      GetSecurityDescriptorControl = Win32API.new('advapi32', 'GetSecurityDescriptorControl', 'PPP', 'I')
+      GetSecurityDescriptorDacl    = Win32API.new('advapi32', 'GetSecurityDescriptorDacl', 'PPPP', 'I')
+      
+      InitializeAcl                = Win32API.new('advapi32', 'InitializeAcl', 'PLL', 'I')
+      InitializeSecurityDescriptor = Win32API.new('advapi32', 'InitializeSecurityDescriptor', 'PL', 'I')
+        
+      LookupAccountName = Win32API.new('advapi32', 'LookupAccountName', 'PPPPPPP', 'I')
+      LookupAccountSid  = Win32API.new('advapi32', 'LookupAccountSid', 'PLPPPPP', 'I')
+          
+      SetFileSecurity           = Win32API.new('advapi32', 'SetFileSecurity', 'PPP', 'I') 
+      SetSecurityDescriptorDacl = Win32API.new('advapi32', 'SetSecurityDescriptorDacl', 'PIPI', 'I')
+      
+      def AddAce(acl, rev, index, list, length)
+         AddAce.call(acl, rev, index, list, length) != 0
+      end
+      
+      def CopySid(sid_length, sid_buf, sid_source)
+         CopySid.call(sid_length, sid_buf, sid_source) != 0
+      end
+      
+      def GetAce(acl, index, ace)
+         GetAce.call(acl, index, ace) != 0
+      end
+
+      def GetFileSecurity(file, info, descriptor, length, nlength)
+         GetFileSecurity.call(file, info, descriptor, length, nlength) != 0
+      end
+
+      def GetLengthSid(sid)
+         GetLengthSid.call(sid)
+      end
+      
+      def GetSecurityDescriptorControl(descriptor, control, revision)
+         GetSecurityDescriptorControl.call(descriptor, control, revision) != 0
+      end
+
+      def GetSecurityDescriptorDacl(descriptor, dacl_present, dacl, default)
+         GetSecurityDescriptorDacl.call(descriptor, dacl_present, dacl, default) != 0
+      end
+      
+      def InitializeAcl(acl, length, revision = ACL_REVISION)
+         InitializeAcl.call(acl, length, revision) != 0
+      end
+
+      def InitializeSecurityDescriptor(descriptor, revision = SECURITY_DESCRIPTOR_REVISION)
+         InitializeSecurityDescriptor.call(descriptor, revision) != 0
+      end
+
+      def LookupAccountName(sys, name, sid, sid_size, domain, domain_size, use)
+         LookupAccountName.call(sys, name, sid, sid_size, domain, domain_size, use) != 0
+      end
+
+      def LookupAccountSid(sys, sid, name, name_size, domain, domain_size, use)
+         LookupAccountSid.call(sys, sid, name, name_size, domain, domain_size, use) != 0
+      end
+
+      def SetFileSecurity(file, info, descriptor)
+         SetFileSecurity.call(file, info, descriptor) != 0
+      end
+
+      def SetSecurityDescriptorDacl(descriptor, present, dacl, default)
+         SetSecurityDescriptorDacl.call(descriptor, present, dacl, default) != 0
+      end
+   end
+end

data/external/windows-pr/lib/windows/service.rb

@@ -0,0 +1,183 @@
+require 'Win32API'
+
+module Windows
+   module Service
+      # SCM access rights
+      SC_MANAGER_ALL_ACCESS         = 0xF003F
+      SC_MANAGER_CREATE_SERVICE     = 0x0002
+      SC_MANAGER_CONNECT            = 0x0001
+      SC_MANAGER_ENUMERATE_SERVICE  = 0x0004
+      SC_MANAGER_LOCK               = 0x0008
+      SC_MANAGER_MODIFY_BOOT_CONFIG = 0x0020
+      SC_MANAGER_QUERY_LOCK_STATUS  = 0x0010
+      SC_STATUS_PROCESS_INFO        = 0
+      SC_ENUM_PROCESS_INFO          = 0
+      
+      # Service control action types
+      SC_ACTION_NONE        = 0
+      SC_ACTION_REBOOT      = 1
+      SC_ACTION_RESTART     = 2
+      SC_ACTION_RUN_COMMAND = 3
+
+      # Service access rights
+      SERVICE_ALL_ACCESS            = 0xF01FF
+      SERVICE_CHANGE_CONFIG         = 0x0002
+      SERVICE_ENUMERATE_DEPENDENTS  = 0x0008
+      SERVICE_INTERROGATE           = 0x0080
+      SERVICE_PAUSE_CONTINUE        = 0x0040
+      SERVICE_QUERY_CONFIG          = 0x0001
+      SERVICE_QUERY_STATUS          = 0x0004
+      SERVICE_START                 = 0x0010
+      SERVICE_STOP                  = 0x0020
+      SERVICE_USER_DEFINED_CONTROL  = 0x0100
+
+      # Service types
+      SERVICE_KERNEL_DRIVER       = 0x00000001
+      SERVICE_FILE_SYSTEM_DRIVER  = 0x00000002
+      SERVICE_ADAPTER             = 0x00000004
+      SERVICE_RECOGNIZER_DRIVER   = 0x00000008
+      SERVICE_WIN32_OWN_PROCESS   = 0x00000010
+      SERVICE_WIN32_SHARE_PROCESS = 0x00000020
+      SERVICE_WIN32               = 0x00000030
+      SERVICE_INTERACTIVE_PROCESS = 0x00000100
+      SERVICE_DRIVER              = 0x0000000B
+      SERVICE_TYPE_ALL            = 0x0000013F
+
+      # Error control
+      SERVICE_ERROR_IGNORE   = 0x00000000
+      SERVICE_ERROR_NORMAL   = 0x00000001
+      SERVICE_ERROR_SEVERE   = 0x00000002
+      SERVICE_ERROR_CRITICAL = 0x00000003
+
+      # Start types
+      SERVICE_BOOT_START   = 0x00000000
+      SERVICE_SYSTEM_START = 0x00000001
+      SERVICE_AUTO_START   = 0x00000002
+      SERVICE_DEMAND_START = 0x00000003
+      SERVICE_DISABLED     = 0x00000004
+
+      # Service control
+      SERVICE_CONTROL_STOP           = 0x00000001
+      SERVICE_CONTROL_PAUSE          = 0x00000002
+      SERVICE_CONTROL_CONTINUE       = 0x00000003
+      SERVICE_CONTROL_INTERROGATE    = 0x00000004
+      SERVICE_CONTROL_PARAMCHANGE    = 0x00000006
+      SERVICE_CONTROL_NETBINDADD     = 0x00000007
+      SERVICE_CONTROL_NETBINDREMOVE  = 0x00000008
+      SERVICE_CONTROL_NETBINDENABLE  = 0x00000009
+      SERVICE_CONTROL_NETBINDDISABLE = 0x0000000A
+      
+      # Service controls accepted
+      SERVICE_ACCEPT_STOP                  =  0x00000001
+      SERVICE_ACCEPT_PAUSE_CONTINUE        =  0x00000002
+      SERVICE_ACCEPT_SHUTDOWN              =  0x00000004
+      SERVICE_ACCEPT_PARAMCHANGE           =  0x00000008
+      SERVICE_ACCEPT_NETBINDCHANGE         =  0x00000010
+      SERVICE_ACCEPT_HARDWAREPROFILECHANGE =  0x00000020
+      SERVICE_ACCEPT_POWEREVENT            =  0x00000040
+      SERVICE_ACCEPT_SESSIONCHANGE         =  0x00000080
+
+      # Service states
+      SERVICE_ACTIVE    = 0x00000001
+      SERVICE_INACTIVE  = 0x00000002
+      SERVICE_STATE_ALL = 0x00000003
+      
+      # Service current states
+      SERVICE_STOPPED          = 0x00000001
+      SERVICE_START_PENDING    = 0x00000002
+      SERVICE_STOP_PENDING     = 0x00000003
+      SERVICE_RUNNING          = 0x00000004
+      SERVICE_CONTINUE_PENDING = 0x00000005
+      SERVICE_PAUSE_PENDING    = 0x00000006
+      SERVICE_PAUSED           = 0x00000007
+      
+      # Info levels
+      SERVICE_CONFIG_DESCRIPTION              = 1
+      SERVICE_CONFIG_FAILURE_ACTIONS          = 2
+      SERVICE_CONFIG_DELAYED_AUTO_START_INFO  = 3
+      SERVICE_CONFIG_FAILURE_ACTIONS_FLAG     = 4
+      SERVICE_CONFIG_SERVICE_SID_INFO         = 5
+      SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO = 6
+      SERVICE_CONFIG_PRESHUTDOWN_INFO         = 7
+      
+      ChangeServiceConfig           = Win32API.new('advapi32', 'ChangeServiceConfig', 'LLLLPPPPPPP', 'I')
+      ChangeServiceConfig2          = Win32API.new('advapi32', 'ChangeServiceConfig2', 'LLP', 'I')
+      CloseServiceHandle            = Win32API.new('advapi32', 'CloseServiceHandle', 'L', 'I')
+      ControlService                = Win32API.new('advapi32', 'ControlService', 'LLP', 'I')
+      CreateService                 = Win32API.new('advapi32', 'CreateService', 'LPPLLLLPPPPPP', 'L')
+      DeleteService                 = Win32API.new('advapi32', 'DeleteService', 'L', 'I')
+      EnumDependentServices         = Win32API.new('advapi32', 'EnumDependentServices', 'LLPLPP', 'I')
+      EnumServicesStatus            = Win32API.new('advapi32', 'EnumServicesStatus', 'LLLPLPPP', 'I')
+      EnumServicesStatusEx          = Win32API.new('advapi32', 'EnumServicesStatusEx', 'LLLLPLPPPP', 'I')
+      GetServiceDisplayName         = Win32API.new('advapi32', 'GetServiceDisplayName', 'LPPP', 'I')
+      GetServiceKeyName             = Win32API.new('advapi32', 'GetServiceKeyName', 'LPPP', 'I')
+      LockServiceDatabase           = Win32API.new('advapi32', 'LockServiceDatabase', 'L', 'L')
+      NotifyBootConfigStatus        = Win32API.new('advapi32', 'NotifyBootConfigStatus', 'I', 'I')
+      OpenSCManager                 = Win32API.new('advapi32', 'OpenSCManager', 'PPL', 'L')
+      OpenService                   = Win32API.new('advapi32', 'OpenService', 'LPL', 'L')
+      QueryServiceConfig            = Win32API.new('advapi32', 'QueryServiceConfig', 'LPLP', 'I')
+      QueryServiceConfig2           = Win32API.new('advapi32', 'QueryServiceConfig2', 'LLPLP', 'I')
+      QueryServiceLockStatus        = Win32API.new('advapi32', 'QueryServiceLockStatus', 'LPLP', 'I')
+      QueryServiceStatus            = Win32API.new('advapi32', 'QueryServiceStatus', 'LP', 'I')
+      QueryServiceStatusEx          = Win32API.new('advapi32', 'QueryServiceStatusEx', 'LLPLP', 'I')
+      RegisterServiceCtrlHandler    = Win32API.new('advapi32', 'RegisterServiceCtrlHandler', 'PP', 'L')
+      RegisterServiceCtrlHandlerEx  = Win32API.new('advapi32', 'RegisterServiceCtrlHandlerEx', 'PPP', 'L')
+      SetServiceBits                = Win32API.new('advapi32', 'SetServiceBits', 'LLII', 'I')
+      SetServiceStatus              = Win32API.new('advapi32', 'SetServiceStatus', 'LP', 'I')
+      StartService                  = Win32API.new('advapi32', 'StartService', 'LLP', 'I')
+      StartServiceCtrlDispatcher    = Win32API.new('advapi32', 'StartServiceCtrlDispatcher', 'P', 'I')
+      UnlockServiceDatabase         = Win32API.new('advapi32', 'UnlockServiceDatabase', 'L', 'I')
+   
+      def CloseServiceHandle(handle)
+         CloseServiceHandle.call(handle) != 0
+      end
+      
+      def ControlService(service, control, status)
+         ControlService.call(service, control, status) != 0
+      end
+      
+      def DeleteService(handle)
+         DeleteService.call(handle) != 0
+      end
+      
+      def EnumServicesStatusEx(handle, info, s_type, s_state, services, size, bytes, s_returned, rhandle, grp)
+         EnumServicesStatusEx.call(handle, info, s_type, s_state, services, size, bytes, s_returned, rhandle, grp) != 0
+      end
+      
+      def GetServiceDisplayName(handle, service, display, buf)
+         GetServiceDisplayName.call(handle, service, display, buf) != 0
+      end
+      
+      def GetServiceKeyName(handle, display, service, buf)
+         GetServiceKeyName.call(handle, display, service, buf) != 0
+      end
+      
+      def OpenSCManager(host, database, access)
+         OpenSCManager.call(host, database, access)
+      end
+      
+      def OpenService(handle, service, access)
+         OpenService.call(handle, service, access)
+      end
+
+      def QueryServiceConfig(handle, buf, buf_size, bytes)
+         QueryServiceConfig.call(handle, buf, buf_size, bytes) != 0
+      end
+
+      def QueryServiceConfig2(handle, info, buf, buf_size, bytes)
+         QueryServiceConfig2.call(handle, info, buf, buf_size, bytes) != 0
+      end
+      
+      def QueryServiceStatusEx(service, info, buf, size, bytes)
+         QueryServiceStatusEx.call(service, info, buf, size, bytes) != 0
+      end
+      
+      def QueryStatusConfig2(service, info, buf, size, bytes)
+         QueryStatusConfig2.call(service, info, buf, size, bytes) != 0
+      end
+
+      def StartService(handle, num_vec, vec)
+         StartService.call(handle, num_vec, vec)
+      end
+   end
+end