开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaWinSvc.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：72k
源码类别：

Windows编程

开发平台：

Delphi

JwaWinSvc.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Services API interface Unit for Object Pascal                                }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: winsvc.h, released June 2000. The original Pascal      }
  9. { code is: WinSvc.pas, released December 2000. The initial developer of the    }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaWinSvc;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "WinSvc.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinNT, JwaWinType;
  59. //
  60. // Service database names
  61. //
  63. const
  64.   SERVICES_ACTIVE_DATABASEW = 'ServicesActive';
  65.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASEW}
  66.   SERVICES_FAILED_DATABASEW = 'ServicesFailed';
  67.   {$EXTERNALSYM SERVICES_FAILED_DATABASEW}
  69.   SERVICES_ACTIVE_DATABASEA = 'ServicesActive';
  70.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASEA}
  71.   SERVICES_FAILED_DATABASEA = 'ServicesFailed';
  72.   {$EXTERNALSYM SERVICES_FAILED_DATABASEA}
  74. //
  75. // Character to designate that a name is a group
  76. //
  78.   SC_GROUP_IDENTIFIERW = '+';
  79.   {$EXTERNALSYM SC_GROUP_IDENTIFIERW}
  80.   SC_GROUP_IDENTIFIERA = '+';
  81.   {$EXTERNALSYM SC_GROUP_IDENTIFIERA}
  83. {$IFDEF UNICODE}
  85.   SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEW;
  86.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
  87.   SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEW;
  88.   {$EXTERNALSYM SERVICES_FAILED_DATABASE}
  90.   SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERW;
  91.   {$EXTERNALSYM SC_GROUP_IDENTIFIER}
  93. {$ELSE}
  95.   SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA;
  96.   {$EXTERNALSYM SERVICES_ACTIVE_DATABASE}
  97.   SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA;
  98.   {$EXTERNALSYM SERVICES_FAILED_DATABASE}
  100.   SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA;
  101.   {$EXTERNALSYM SC_GROUP_IDENTIFIER}
  103. {$ENDIF}
  105. //
  106. // Value to indicate no change to an optional parameter
  107. //
  109.   SERVICE_NO_CHANGE = $ffffffff;
  110.   {$EXTERNALSYM SERVICE_NO_CHANGE}
  112. //
  113. // Service State -- for Enum Requests (Bit Mask)
  114. //
  116.   SERVICE_ACTIVE    = $00000001;
  117.   {$EXTERNALSYM SERVICE_ACTIVE}
  118.   SERVICE_INACTIVE  = $00000002;
  119.   {$EXTERNALSYM SERVICE_INACTIVE}
  120.   SERVICE_STATE_ALL = SERVICE_ACTIVE or SERVICE_INACTIVE;
  121.   {$EXTERNALSYM SERVICE_STATE_ALL}
  123. //
  124. // Controls
  125. //
  127.   SERVICE_CONTROL_STOP                  = $00000001;
  128.   {$EXTERNALSYM SERVICE_CONTROL_STOP}
  129.   SERVICE_CONTROL_PAUSE                 = $00000002;
  130.   {$EXTERNALSYM SERVICE_CONTROL_PAUSE}
  131.   SERVICE_CONTROL_CONTINUE              = $00000003;
  132.   {$EXTERNALSYM SERVICE_CONTROL_CONTINUE}
  133.   SERVICE_CONTROL_INTERROGATE           = $00000004;
  134.   {$EXTERNALSYM SERVICE_CONTROL_INTERROGATE}
  135.   SERVICE_CONTROL_SHUTDOWN              = $00000005;
  136.   {$EXTERNALSYM SERVICE_CONTROL_SHUTDOWN}
  137.   SERVICE_CONTROL_PARAMCHANGE           = $00000006;
  138.   {$EXTERNALSYM SERVICE_CONTROL_PARAMCHANGE}
  139.   SERVICE_CONTROL_NETBINDADD            = $00000007;
  140.   {$EXTERNALSYM SERVICE_CONTROL_NETBINDADD}
  141.   SERVICE_CONTROL_NETBINDREMOVE         = $00000008;
  142.   {$EXTERNALSYM SERVICE_CONTROL_NETBINDREMOVE}
  143.   SERVICE_CONTROL_NETBINDENABLE         = $00000009;
  144.   {$EXTERNALSYM SERVICE_CONTROL_NETBINDENABLE}
  145.   SERVICE_CONTROL_NETBINDDISABLE        = $0000000A;
  146.   {$EXTERNALSYM SERVICE_CONTROL_NETBINDDISABLE}
  147.   SERVICE_CONTROL_DEVICEEVENT           = $0000000B;
  148.   {$EXTERNALSYM SERVICE_CONTROL_DEVICEEVENT}
  149.   SERVICE_CONTROL_HARDWAREPROFILECHANGE = $0000000C;
  150.   {$EXTERNALSYM SERVICE_CONTROL_HARDWAREPROFILECHANGE}
  151.   SERVICE_CONTROL_POWEREVENT            = $0000000D;
  152.   {$EXTERNALSYM SERVICE_CONTROL_POWEREVENT}
  153.   SERVICE_CONTROL_SESSIONCHANGE         = $0000000E;
  154.   {$EXTERNALSYM SERVICE_CONTROL_SESSIONCHANGE}
  156. //
  157. // Service State -- for CurrentState
  158. //
  160.   SERVICE_STOPPED          = $00000001;
  161.   {$EXTERNALSYM SERVICE_STOPPED}
  162.   SERVICE_START_PENDING    = $00000002;
  163.   {$EXTERNALSYM SERVICE_START_PENDING}
  164.   SERVICE_STOP_PENDING     = $00000003;
  165.   {$EXTERNALSYM SERVICE_STOP_PENDING}
  166.   SERVICE_RUNNING          = $00000004;
  167.   {$EXTERNALSYM SERVICE_RUNNING}
  168.   SERVICE_CONTINUE_PENDING = $00000005;
  169.   {$EXTERNALSYM SERVICE_CONTINUE_PENDING}
  170.   SERVICE_PAUSE_PENDING    = $00000006;
  171.   {$EXTERNALSYM SERVICE_PAUSE_PENDING}
  172.   SERVICE_PAUSED           = $00000007;
  173.   {$EXTERNALSYM SERVICE_PAUSED}
  175. //
  176. // Controls Accepted  (Bit Mask)
  177. //
  179.   SERVICE_ACCEPT_STOP                  = $00000001;
  180.   {$EXTERNALSYM SERVICE_ACCEPT_STOP}
  181.   SERVICE_ACCEPT_PAUSE_CONTINUE        = $00000002;
  182.   {$EXTERNALSYM SERVICE_ACCEPT_PAUSE_CONTINUE}
  183.   SERVICE_ACCEPT_SHUTDOWN              = $00000004;
  184.   {$EXTERNALSYM SERVICE_ACCEPT_SHUTDOWN}
  185.   SERVICE_ACCEPT_PARAMCHANGE           = $00000008;
  186.   {$EXTERNALSYM SERVICE_ACCEPT_PARAMCHANGE}
  187.   SERVICE_ACCEPT_NETBINDCHANGE         = $00000010;
  188.   {$EXTERNALSYM SERVICE_ACCEPT_NETBINDCHANGE}
  189.   SERVICE_ACCEPT_HARDWAREPROFILECHANGE = $00000020;
  190.   {$EXTERNALSYM SERVICE_ACCEPT_HARDWAREPROFILECHANGE}
  191.   SERVICE_ACCEPT_POWEREVENT            = $00000040;
  192.   {$EXTERNALSYM SERVICE_ACCEPT_POWEREVENT}
  193.   SERVICE_ACCEPT_SESSIONCHANGE         = $00000080;
  194.   {$EXTERNALSYM SERVICE_ACCEPT_SESSIONCHANGE}
  196. //
  197. // Service Control Manager object specific access types
  198. //
  200.   SC_MANAGER_CONNECT            = $0001;
  201.   {$EXTERNALSYM SC_MANAGER_CONNECT}
  202.   SC_MANAGER_CREATE_SERVICE     = $0002;
  203.   {$EXTERNALSYM SC_MANAGER_CREATE_SERVICE}
  204.   SC_MANAGER_ENUMERATE_SERVICE  = $0004;
  205.   {$EXTERNALSYM SC_MANAGER_ENUMERATE_SERVICE}
  206.   SC_MANAGER_LOCK               = $0008;
  207.   {$EXTERNALSYM SC_MANAGER_LOCK}
  208.   SC_MANAGER_QUERY_LOCK_STATUS  = $0010;
  209.   {$EXTERNALSYM SC_MANAGER_QUERY_LOCK_STATUS}
  210.   SC_MANAGER_MODIFY_BOOT_CONFIG = $0020;
  211.   {$EXTERNALSYM SC_MANAGER_MODIFY_BOOT_CONFIG}
  213.   SC_MANAGER_ALL_ACCESS         = STANDARD_RIGHTS_REQUIRED or
  214.                                   SC_MANAGER_CONNECT or
  215.                                   SC_MANAGER_CREATE_SERVICE or
  216.                                   SC_MANAGER_ENUMERATE_SERVICE or
  217.                                   SC_MANAGER_LOCK or
  218.                                   SC_MANAGER_QUERY_LOCK_STATUS or
  219.                                   SC_MANAGER_MODIFY_BOOT_CONFIG;
  220.   {$EXTERNALSYM SC_MANAGER_ALL_ACCESS}
  222. //
  223. // Service object specific access type
  224. //
  226.   SERVICE_QUERY_CONFIG         = $0001;
  227.   {$EXTERNALSYM SERVICE_QUERY_CONFIG}
  228.   SERVICE_CHANGE_CONFIG        = $0002;
  229.   {$EXTERNALSYM SERVICE_CHANGE_CONFIG}
  230.   SERVICE_QUERY_STATUS         = $0004;
  231.   {$EXTERNALSYM SERVICE_QUERY_STATUS}
  232.   SERVICE_ENUMERATE_DEPENDENTS = $0008;
  233.   {$EXTERNALSYM SERVICE_ENUMERATE_DEPENDENTS}
  234.   SERVICE_START                = $0010;
  235.   {$EXTERNALSYM SERVICE_START}
  236.   SERVICE_STOP                 = $0020;
  237.   {$EXTERNALSYM SERVICE_STOP}
  238.   SERVICE_PAUSE_CONTINUE       = $0040;
  239.   {$EXTERNALSYM SERVICE_PAUSE_CONTINUE}
  240.   SERVICE_INTERROGATE          = $0080;
  241.   {$EXTERNALSYM SERVICE_INTERROGATE}
  242.   SERVICE_USER_DEFINED_CONTROL = $0100;
  243.   {$EXTERNALSYM SERVICE_USER_DEFINED_CONTROL}
  245.   SERVICE_ALL_ACCESS           = STANDARD_RIGHTS_REQUIRED or
  246.                                  SERVICE_QUERY_CONFIG or
  247.                                  SERVICE_CHANGE_CONFIG or
  248.                                  SERVICE_QUERY_STATUS or
  249.                                  SERVICE_ENUMERATE_DEPENDENTS or
  250.                                  SERVICE_START or
  251.                                  SERVICE_STOP or
  252.                                  SERVICE_PAUSE_CONTINUE or
  253.                                  SERVICE_INTERROGATE or
  254.                                  SERVICE_USER_DEFINED_CONTROL;
  255.   {$EXTERNALSYM SERVICE_ALL_ACCESS}
  257. //
  258. // Service flags for QueryServiceStatusEx
  259. //
  261.   SERVICE_RUNS_IN_SYSTEM_PROCESS = $00000001;
  262.   {$EXTERNALSYM SERVICE_RUNS_IN_SYSTEM_PROCESS}
  264. //
  265. // Info levels for ChangeServiceConfig2 and QueryServiceConfig2
  266. //
  268.   SERVICE_CONFIG_DESCRIPTION     = 1;
  269.   {$EXTERNALSYM SERVICE_CONFIG_DESCRIPTION}
  270.   SERVICE_CONFIG_FAILURE_ACTIONS = 2;
  271.   {$EXTERNALSYM SERVICE_CONFIG_FAILURE_ACTIONS}
  273. //
  274. // Service description string
  275. //
  277. type
  278.   LPSERVICE_DESCRIPTIONA = ^SERVICE_DESCRIPTIONA;
  279.   {$EXTERNALSYM LPSERVICE_DESCRIPTIONA}
  280.   _SERVICE_DESCRIPTIONA = record
  281.     lpDescription: LPSTR;
  282.   end;
  283.   {$EXTERNALSYM _SERVICE_DESCRIPTIONA}
  284.   SERVICE_DESCRIPTIONA = _SERVICE_DESCRIPTIONA;
  285.   {$EXTERNALSYM SERVICE_DESCRIPTIONA}
  286.   TServiceDescriptionA = SERVICE_DESCRIPTIONA;
  287.   PServiceDescriptionA = LPSERVICE_DESCRIPTIONA;
  289. //
  290. // Service description string
  291. //
  293.   LPSERVICE_DESCRIPTIONW = ^SERVICE_DESCRIPTIONW;
  294.   {$EXTERNALSYM LPSERVICE_DESCRIPTIONW}
  295.   _SERVICE_DESCRIPTIONW = record
  296.     lpDescription: LPWSTR;
  297.   end;
  298.   {$EXTERNALSYM _SERVICE_DESCRIPTIONW}
  299.   SERVICE_DESCRIPTIONW = _SERVICE_DESCRIPTIONW;
  300.   {$EXTERNALSYM SERVICE_DESCRIPTIONW}
  301.   TServiceDescriptionW = SERVICE_DESCRIPTIONW;
  302.   PServiceDescriptionW = LPSERVICE_DESCRIPTIONW;
  304. {$IFDEF UNICODE}
  305.   SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONW;
  306.   {$EXTERNALSYM SERVICE_DESCRIPTION}
  307.   LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONW;
  308.   {$EXTERNALSYM LPSERVICE_DESCRIPTION}
  309.   TServiceDescription = TServiceDescriptionW;
  310.   PServiceDescription = PServiceDescriptionW;
  311. {$ELSE}
  312.   SERVICE_DESCRIPTION = SERVICE_DESCRIPTIONA;
  313.   {$EXTERNALSYM SERVICE_DESCRIPTION}
  314.   LPSERVICE_DESCRIPTION = LPSERVICE_DESCRIPTIONA;
  315.   {$EXTERNALSYM LPSERVICE_DESCRIPTION}
  316.   TServiceDescription = TServiceDescriptionA;
  317.   PServiceDescription = PServiceDescriptionA;
  318. {$ENDIF}
  320. //
  321. // Actions to take on service failure
  322. //
  324.   _SC_ACTION_TYPE = (SC_ACTION_NONE, SC_ACTION_RESTART, SC_ACTION_REBOOT,
  325.     SC_ACTION_RUN_COMMAND);
  326.   {$EXTERNALSYM _SC_ACTION_TYPE}
  327.   SC_ACTION_TYPE = _SC_ACTION_TYPE;
  328.   {$EXTERNALSYM SC_ACTION_TYPE}
  329.   TScActionType = _SC_ACTION_TYPE;
  331.   LPSC_ACTION = ^SC_ACTION;
  332.   {$EXTERNALSYM LPSC_ACTION}
  333.   _SC_ACTION = record
  334.     Type_: SC_ACTION_TYPE;
  335.     Delay: DWORD;
  336.   end;
  337.   {$EXTERNALSYM _SC_ACTION}
  338.   SC_ACTION = _SC_ACTION;
  339.   {$EXTERNALSYM SC_ACTION}
  340.   TScAction = SC_ACTION;
  341.   PScAction = LPSC_ACTION;
  343.   LPSERVICE_FAILURE_ACTIONSA = ^SERVICE_FAILURE_ACTIONSA;
  344.   {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSA}
  345.   _SERVICE_FAILURE_ACTIONSA = record
  346.     dwResetPeriod: DWORD;
  347.     lpRebootMsg: LPSTR;
  348.     lpCommand: LPSTR;
  349.     cActions: DWORD;
  350.     lpsaActions: LPSC_ACTION;
  351.   end;
  352.   {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSA}
  353.   SERVICE_FAILURE_ACTIONSA = _SERVICE_FAILURE_ACTIONSA;
  354.   {$EXTERNALSYM SERVICE_FAILURE_ACTIONSA}
  355.   TServiceFailureActionsA = SERVICE_FAILURE_ACTIONSA;
  356.   PServiceFailureActionsA = LPSERVICE_FAILURE_ACTIONSA;
  358.   LPSERVICE_FAILURE_ACTIONSW = ^SERVICE_FAILURE_ACTIONSW;
  359.   {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONSW}
  360.   _SERVICE_FAILURE_ACTIONSW = record
  361.     dwResetPeriod: DWORD;
  362.     lpRebootMsg: LPWSTR;
  363.     lpCommand: LPWSTR;
  364.     cActions: DWORD;
  365.     lpsaActions: LPSC_ACTION;
  366.   end;
  367.   {$EXTERNALSYM _SERVICE_FAILURE_ACTIONSW}
  368.   SERVICE_FAILURE_ACTIONSW = _SERVICE_FAILURE_ACTIONSW;
  369.   {$EXTERNALSYM SERVICE_FAILURE_ACTIONSW}
  370.   TServiceFailureActionsW = SERVICE_FAILURE_ACTIONSW;
  371.   PServiceFailureActionsW = LPSERVICE_FAILURE_ACTIONSW;
  373. {$IFDEF UNICODE}
  374.   SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSW;
  375.   {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
  376.   LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSW;
  377.   {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
  378.   TServiceFailureActions = TServiceFailureActionsW;
  379.   PServiceFailureActions = PServiceFailureActionsW;
  380. {$ELSE}
  381.   SERVICE_FAILURE_ACTIONS = SERVICE_FAILURE_ACTIONSA;
  382.   {$EXTERNALSYM SERVICE_FAILURE_ACTIONS}
  383.   LPSERVICE_FAILURE_ACTIONS = LPSERVICE_FAILURE_ACTIONSA;
  384.   {$EXTERNALSYM LPSERVICE_FAILURE_ACTIONS}
  385.   TServiceFailureActions = TServiceFailureActionsA;
  386.   PServiceFailureActions = PServiceFailureActionsA;
  387. {$ENDIF}
  389. //
  390. // Handle Types
  391. //
  393.   SC_HANDLE = HANDLE;
  394.   {$EXTERNALSYM SC_HANDLE}
  395.   LPSC_HANDLE = ^SC_HANDLE;
  396.   {$EXTERNALSYM LPSC_HANDLE}
  398.   SERVICE_STATUS_HANDLE = HANDLE;
  399.   {$EXTERNALSYM SERVICE_STATUS_HANDLE}
  401. //
  402. // Info levels for QueryServiceStatusEx
  403. //
  405.   _SC_STATUS_TYPE = (SC_STATUS_PROCESS_INFO);
  406.   {$EXTERNALSYM _SC_STATUS_TYPE}
  407.   SC_STATUS_TYPE = _SC_STATUS_TYPE;
  408.   {$EXTERNALSYM SC_STATUS_TYPE}
  410. //
  411. // Info levels for EnumServicesStatusEx
  412. //
  414.   _SC_ENUM_TYPE = (SC_ENUM_PROCESS_INFO);
  415.   {$EXTERNALSYM _SC_ENUM_TYPE}
  416.   SC_ENUM_TYPE = _SC_ENUM_TYPE;
  417.   {$EXTERNALSYM SC_ENUM_TYPE}
  419. //
  420. // Service Status Structures
  421. //
  423.   LPSERVICE_STATUS = ^SERVICE_STATUS;
  424.   {$EXTERNALSYM LPSERVICE_STATUS}
  425.   _SERVICE_STATUS = record
  426.     dwServiceType: DWORD;
  427.     dwCurrentState: DWORD;
  428.     dwControlsAccepted: DWORD;
  429.     dwWin32ExitCode: DWORD;
  430.     dwServiceSpecificExitCode: DWORD;
  431.     dwCheckPoint: DWORD;
  432.     dwWaitHint: DWORD;
  433.   end;
  434.   {$EXTERNALSYM _SERVICE_STATUS}
  435.   SERVICE_STATUS = _SERVICE_STATUS;
  436.   {$EXTERNALSYM SERVICE_STATUS}
  437.   TServiceStatus = SERVICE_STATUS;
  438.   PServiceStatus = LPSERVICE_STATUS;
  440.   LPSERVICE_STATUS_PROCESS = ^SERVICE_STATUS_PROCESS;
  441.   {$EXTERNALSYM LPSERVICE_STATUS_PROCESS}
  442.   _SERVICE_STATUS_PROCESS = record
  443.     dwServiceType: DWORD;
  444.     dwCurrentState: DWORD;
  445.     dwControlsAccepted: DWORD;
  446.     dwWin32ExitCode: DWORD;
  447.     dwServiceSpecificExitCode: DWORD;
  448.     dwCheckPoint: DWORD;
  449.     dwWaitHint: DWORD;
  450.     dwProcessId: DWORD;
  451.     dwServiceFlags: DWORD;
  452.   end;
  453.   {$EXTERNALSYM _SERVICE_STATUS_PROCESS}
  454.   SERVICE_STATUS_PROCESS = _SERVICE_STATUS_PROCESS;
  455.   {$EXTERNALSYM SERVICE_STATUS_PROCESS}
  456.   TServiceStatusProcess = SERVICE_STATUS_PROCESS;
  457.   PServiceStatusProcess = LPSERVICE_STATUS_PROCESS;
  459. //
  460. // Service Status Enumeration Structure
  461. //
  463.   LPENUM_SERVICE_STATUSA = ^ENUM_SERVICE_STATUSA;
  464.   {$EXTERNALSYM LPENUM_SERVICE_STATUSA}
  465.   _ENUM_SERVICE_STATUSA = record
  466.     lpServiceName: LPSTR;
  467.     lpDisplayName: LPSTR;
  468.     ServiceStatus: SERVICE_STATUS;
  469.   end;
  470.   {$EXTERNALSYM _ENUM_SERVICE_STATUSA}
  471.   ENUM_SERVICE_STATUSA = _ENUM_SERVICE_STATUSA;
  472.   {$EXTERNALSYM ENUM_SERVICE_STATUSA}
  473.   TEnumServiceStatusA = ENUM_SERVICE_STATUSA;
  474.   PEnumServiceStatusA = LPENUM_SERVICE_STATUSA;
  476.   LPENUM_SERVICE_STATUSW = ^ENUM_SERVICE_STATUSW;
  477.   {$EXTERNALSYM LPENUM_SERVICE_STATUSW}
  478.   _ENUM_SERVICE_STATUSW = record
  479.     lpServiceName: LPWSTR;
  480.     lpDisplayName: LPWSTR;
  481.     ServiceStatus: SERVICE_STATUS;
  482.   end;
  483.   {$EXTERNALSYM _ENUM_SERVICE_STATUSW}
  484.   ENUM_SERVICE_STATUSW = _ENUM_SERVICE_STATUSW;
  485.   {$EXTERNALSYM ENUM_SERVICE_STATUSW}
  486.   TEnumServiceStatusW = ENUM_SERVICE_STATUSW;
  487.   PEnumServiceStatusW = LPENUM_SERVICE_STATUSW;
  489. {$IFDEF UNICODE}
  490.   ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSW;
  491.   {$EXTERNALSYM ENUM_SERVICE_STATUS}
  492.   LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSW;
  493.   {$EXTERNALSYM LPENUM_SERVICE_STATUS}
  494.   TEnumServiceStatus = TEnumServiceStatusW;
  495.   PEnumServiceStatus = PEnumServiceStatusW;
  496. {$ELSE}
  497.   ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUSA;
  498.   {$EXTERNALSYM ENUM_SERVICE_STATUS}
  499.   LPENUM_SERVICE_STATUS = LPENUM_SERVICE_STATUSA;
  500.   {$EXTERNALSYM LPENUM_SERVICE_STATUS}
  501.   TEnumServiceStatus = TEnumServiceStatusA;
  502.   PEnumServiceStatus = PEnumServiceStatusA;
  503. {$ENDIF}
  505.   LPENUM_SERVICE_STATUS_PROCESSA = ^ENUM_SERVICE_STATUS_PROCESSA;
  506.   {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSA}
  507.   _ENUM_SERVICE_STATUS_PROCESSA = record
  508.     lpServiceName: LPSTR;
  509.     lpDisplayName: LPSTR;
  510.     ServiceStatusProcess: SERVICE_STATUS_PROCESS;
  511.   end;
  512.   {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSA}
  513.   ENUM_SERVICE_STATUS_PROCESSA = _ENUM_SERVICE_STATUS_PROCESSA;
  514.   {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSA}
  515.   TEnumServiceStatusProcessA = ENUM_SERVICE_STATUS_PROCESSA;
  516.   PEnumServiceStatusProcessA = LPENUM_SERVICE_STATUS_PROCESSA;
  518.   LPENUM_SERVICE_STATUS_PROCESSW = ^ENUM_SERVICE_STATUS_PROCESSW;
  519.   {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESSW}
  520.   _ENUM_SERVICE_STATUS_PROCESSW = record
  521.     lpServiceName: LPWSTR;
  522.     lpDisplayName: LPWSTR;
  523.     ServiceStatusProcess: SERVICE_STATUS_PROCESS;
  524.   end;
  525.   {$EXTERNALSYM _ENUM_SERVICE_STATUS_PROCESSW}
  526.   ENUM_SERVICE_STATUS_PROCESSW = _ENUM_SERVICE_STATUS_PROCESSW;
  527.   {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESSW}
  528.   TEnumServiceStatusProcessW = ENUM_SERVICE_STATUS_PROCESSW;
  529.   PEnumServiceStatusProcessW = LPENUM_SERVICE_STATUS_PROCESSW;
  531. {$IFDEF UNICODE}
  532.   ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSW;
  533.   {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
  534.   LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSW;
  535.   {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
  536.   TEnumServiceStatusProcess = TEnumServiceStatusProcessW;
  537.   PEnumServiceStatusProcess = PEnumServiceStatusProcessW;
  538. {$ELSE}
  539.   ENUM_SERVICE_STATUS_PROCESS = ENUM_SERVICE_STATUS_PROCESSA;
  540.   {$EXTERNALSYM ENUM_SERVICE_STATUS_PROCESS}
  541.   LPENUM_SERVICE_STATUS_PROCESS = LPENUM_SERVICE_STATUS_PROCESSA;
  542.   {$EXTERNALSYM LPENUM_SERVICE_STATUS_PROCESS}
  543.   TEnumServiceStatusProcess = TEnumServiceStatusProcessA;
  544.   PEnumServiceStatusProcess = PEnumServiceStatusProcessA;
  545. {$ENDIF}
  547. //
  548. // Structures for the Lock API functions
  549. //
  551.   SC_LOCK = LPVOID;
  552.   {$EXTERNALSYM SC_LOCK}
  554.   LPQUERY_SERVICE_LOCK_STATUSA = ^QUERY_SERVICE_LOCK_STATUSA;
  555.   {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSA}
  556.   _QUERY_SERVICE_LOCK_STATUSA = record
  557.     fIsLocked: DWORD;
  558.     lpLockOwner: LPSTR;
  559.     dwLockDuration: DWORD;
  560.   end;
  561.   {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSA}
  562.   QUERY_SERVICE_LOCK_STATUSA = _QUERY_SERVICE_LOCK_STATUSA;
  563.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSA}
  564.   TQueryServiceLockStatusA = QUERY_SERVICE_LOCK_STATUSA;
  565.   PQueryServiceLockStatusA = LPQUERY_SERVICE_LOCK_STATUSA;
  567.   LPQUERY_SERVICE_LOCK_STATUSW = ^QUERY_SERVICE_LOCK_STATUSW;
  568.   {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUSW}
  569.   _QUERY_SERVICE_LOCK_STATUSW = record
  570.     fIsLocked: DWORD;
  571.     lpLockOwner: LPWSTR;
  572.     dwLockDuration: DWORD;
  573.   end;
  574.   {$EXTERNALSYM _QUERY_SERVICE_LOCK_STATUSW}
  575.   QUERY_SERVICE_LOCK_STATUSW = _QUERY_SERVICE_LOCK_STATUSW;
  576.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUSW}
  577.   TQueryServiceLockStatusW = QUERY_SERVICE_LOCK_STATUSW;
  578.   PQueryServiceLockStatusW = LPQUERY_SERVICE_LOCK_STATUSW;
  580. {$IFDEF UNICODE}
  581.   QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSW;
  582.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
  583.   LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSW;
  584.   {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
  585.   TQueryServiceLockStatus = TQueryServiceLockStatusW;
  586.   PQueryServiceLockStatus = PQueryServiceLockStatusW;
  587. {$ELSE}
  588.   QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUSA;
  589.   {$EXTERNALSYM QUERY_SERVICE_LOCK_STATUS}
  590.   LPQUERY_SERVICE_LOCK_STATUS = LPQUERY_SERVICE_LOCK_STATUSA;
  591.   {$EXTERNALSYM LPQUERY_SERVICE_LOCK_STATUS}
  592.   TQueryServiceLockStatus = TQueryServiceLockStatusA;
  593.   PQueryServiceLockStatus = PQueryServiceLockStatusA;
  594. {$ENDIF}
  596. //
  597. // Query Service Configuration Structure
  598. //
  600.   LPQUERY_SERVICE_CONFIGA = ^QUERY_SERVICE_CONFIGA;
  601.   {$EXTERNALSYM LPQUERY_SERVICE_CONFIGA}
  602.   _QUERY_SERVICE_CONFIGA = record
  603.     dwServiceType: DWORD;
  604.     dwStartType: DWORD;
  605.     dwErrorControl: DWORD;
  606.     lpBinaryPathName: LPSTR;
  607.     lpLoadOrderGroup: LPSTR;
  608.     dwTagId: DWORD;
  609.     lpDependencies: LPSTR;
  610.     lpServiceStartName: LPSTR;
  611.     lpDisplayName: LPSTR;
  612.   end;
  613.   {$EXTERNALSYM _QUERY_SERVICE_CONFIGA}
  614.   QUERY_SERVICE_CONFIGA = _QUERY_SERVICE_CONFIGA;
  615.   {$EXTERNALSYM QUERY_SERVICE_CONFIGA}
  616.   TQueryServiceConfigA = QUERY_SERVICE_CONFIGA;
  617.   PQueryServiceConfigA = LPQUERY_SERVICE_CONFIGA;
  619.   LPQUERY_SERVICE_CONFIGW = ^QUERY_SERVICE_CONFIGW;
  620.   {$EXTERNALSYM LPQUERY_SERVICE_CONFIGW}
  621.   _QUERY_SERVICE_CONFIGW = record
  622.     dwServiceType: DWORD;
  623.     dwStartType: DWORD;
  624.     dwErrorControl: DWORD;
  625.     lpBinaryPathName: LPWSTR;
  626.     lpLoadOrderGroup: LPWSTR;
  627.     dwTagId: DWORD;
  628.     lpDependencies: LPWSTR;
  629.     lpServiceStartName: LPWSTR;
  630.     lpDisplayName: LPWSTR;
  631.   end;
  632.   {$EXTERNALSYM _QUERY_SERVICE_CONFIGW}
  633.   QUERY_SERVICE_CONFIGW = _QUERY_SERVICE_CONFIGW;
  634.   {$EXTERNALSYM QUERY_SERVICE_CONFIGW}
  635.   TQueryServiceConfigW = QUERY_SERVICE_CONFIGW;
  636.   PQueryServiceConfigW = LPQUERY_SERVICE_CONFIGW;
  638. {$IFDEF UNICODE}
  639.   QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGW;
  640.   {$EXTERNALSYM QUERY_SERVICE_CONFIG}
  641.   LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGW;
  642.   {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
  643.   TQueryServiceConfig = TQueryServiceConfigW;
  644.   PQueryServiceConfig = PQueryServiceConfigW;
  645. {$ELSE}
  646.   QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIGA;
  647.   {$EXTERNALSYM QUERY_SERVICE_CONFIG}
  648.   LPQUERY_SERVICE_CONFIG = LPQUERY_SERVICE_CONFIGA;
  649.   {$EXTERNALSYM LPQUERY_SERVICE_CONFIG}
  650.   TQueryServiceConfig = TQueryServiceConfigA;
  651.   PQueryServiceConfig = PQueryServiceConfigA;
  652. {$ENDIF}
  654. //
  655. // Function Prototype for the Service Main Function
  656. //
  658. type
  659.   LPSERVICE_MAIN_FUNCTIONW = procedure (dwNumServicesArgs: DWORD;
  660.     lpServiceArgVectors: LPWSTR); stdcall;
  661.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONW}
  662.   LPSERVICE_MAIN_FUNCTIONA = procedure (dwNumServicesArgs: DWORD;
  663.     lpServiceArgVectors: LPSTR); stdcall;
  664.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTIONA}
  666.   TServiceMainFunctionA = LPSERVICE_MAIN_FUNCTIONA;
  667.   TServiceMainFunctionW = LPSERVICE_MAIN_FUNCTIONW;
  669. {$IFDEF UNICODE}
  670.   LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONW;
  671.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
  672.   TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONW;
  673. {$ELSE}
  674.   LPSERVICE_MAIN_FUNCTION = LPSERVICE_MAIN_FUNCTIONA;
  675.   {$EXTERNALSYM LPSERVICE_MAIN_FUNCTION}
  676.   TServiceMainFunction = LPSERVICE_MAIN_FUNCTIONA;  
  677. {$ENDIF}
  679. //
  680. // Service Start Table
  681. //
  683.   LPSERVICE_TABLE_ENTRYA = ^SERVICE_TABLE_ENTRYA;
  684.   {$EXTERNALSYM LPSERVICE_TABLE_ENTRYA}
  685.   _SERVICE_TABLE_ENTRYA = record
  686.     lpServiceName: LPSTR;
  687.     lpServiceProc: LPSERVICE_MAIN_FUNCTIONA;
  688.   end;
  689.   {$EXTERNALSYM _SERVICE_TABLE_ENTRYA}
  690.   SERVICE_TABLE_ENTRYA = _SERVICE_TABLE_ENTRYA;
  691.   {$EXTERNALSYM SERVICE_TABLE_ENTRYA}
  692.   TServiceTableEntryA = SERVICE_TABLE_ENTRYA;
  693.   PServiceTableEntryA = LPSERVICE_TABLE_ENTRYA;
  695.   LPSERVICE_TABLE_ENTRYW = ^SERVICE_TABLE_ENTRYW;
  696.   {$EXTERNALSYM LPSERVICE_TABLE_ENTRYW}
  697.   _SERVICE_TABLE_ENTRYW = record
  698.     lpServiceName: LPWSTR;
  699.     lpServiceProc: LPSERVICE_MAIN_FUNCTIONW;
  700.   end;
  701.   {$EXTERNALSYM _SERVICE_TABLE_ENTRYW}
  702.   SERVICE_TABLE_ENTRYW = _SERVICE_TABLE_ENTRYW;
  703.   {$EXTERNALSYM SERVICE_TABLE_ENTRYW}
  704.   TServiceTableEntryW = SERVICE_TABLE_ENTRYW;
  705.   PServiceTableEntryW = LPSERVICE_TABLE_ENTRYW;
  707. {$IFDEF UNICODE}
  708.   SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYW;
  709.   LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYW;
  710.   TServiceTableEntry = TServiceTableEntryW;
  711.   PServiceTableEntry = PServiceTableEntryW;
  712. {$ELSE}
  713.   SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRYA;
  714.   LPSERVICE_TABLE_ENTRY = LPSERVICE_TABLE_ENTRYA;
  715.   TServiceTableEntry = TServiceTableEntryA;
  716.   PServiceTableEntry = PServiceTableEntryA;
  717. {$ENDIF}
  719. //
  720. // Prototype for the Service Control Handler Function
  721. //
  723.   LPHANDLER_FUNCTION = procedure (dwControl: DWORD); stdcall;
  724.   {$EXTERNALSYM LPHANDLER_FUNCTION}
  725.   THandlerFunction = LPHANDLER_FUNCTION;
  727.   LPHANDLER_FUNCTION_EX = function (dwControl, dwEventType: DWORD;
  728.     lpEventData, lpContext: LPVOID): DWORD; stdcall;
  729.   {$EXTERNALSYM LPHANDLER_FUNCTION_EX}
  730.   THandlerFunctionEx = LPHANDLER_FUNCTION_EX;
  732. ///////////////////////////////////////////////////////////////////////////
  733. // API Function Prototypes
  734. ///////////////////////////////////////////////////////////////////////////
  736. function ChangeServiceConfigA(hService: SC_HANDLE; dwServiceType, dwStartType,
  737.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCSTR;
  738.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  739.   lpDisplayName: LPCSTR): BOOL; stdcall;
  740. {$EXTERNALSYM ChangeServiceConfigA}
  741. function ChangeServiceConfigW(hService: SC_HANDLE; dwServiceType, dwStartType,
  742.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCWSTR;
  743.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  744.   lpDisplayName: LPCWSTR): BOOL; stdcall;
  745. {$EXTERNALSYM ChangeServiceConfigW}
  747. {$IFDEF UNICODE}
  748. function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
  749.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCWSTR;
  750.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  751.   lpDisplayName: LPCWSTR): BOOL; stdcall;
  752. {$EXTERNALSYM ChangeServiceConfig}
  753. {$ELSE}
  754. function ChangeServiceConfig(hService: SC_HANDLE; dwServiceType, dwStartType,
  755.   dwErrorControl: DWORD; lpBinaryPathName, lpLoadOrderGroup: LPCSTR;
  756.   lpdwTagId: LPDWORD; lpDependencies, lpServiceStartName, lpPassword,
  757.   lpDisplayName: LPCSTR): BOOL; stdcall;
  758. {$EXTERNALSYM ChangeServiceConfig}
  759. {$ENDIF}
  761. function ChangeServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
  762.   lpInfo: LPVOID): BOOL; stdcall;
  763. {$EXTERNALSYM ChangeServiceConfig2A}
  764. function ChangeServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
  765.   lpInfo: LPVOID): BOOL; stdcall;
  766. {$EXTERNALSYM ChangeServiceConfig2W}
  768. {$IFDEF UNICODE}
  769. function ChangeServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
  770.   lpInfo: LPVOID): BOOL; stdcall;
  771. {$EXTERNALSYM ChangeServiceConfig2}
  772. {$ELSE}
  773. function ChangeServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
  774.   lpInfo: LPVOID): BOOL; stdcall;
  775. {$EXTERNALSYM ChangeServiceConfig2}
  776. {$ENDIF}
  778. function CloseServiceHandle(hSCObject: SC_HANDLE): BOOL; stdcall;
  779. {$EXTERNALSYM CloseServiceHandle}
  781. function ControlService(hService: SC_HANDLE; dwControl: DWORD;
  782.   var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
  783. {$EXTERNALSYM ControlService}
  785. function CreateServiceA(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCSTR;
  786.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  787.   lpBinaryPathName, lpLoadOrderGroup: LPCSTR; lpdwTagId: LPDWORD;
  788.   lpDependencies, lpServiceStartName, lpPassword: LPCSTR): SC_HANDLE; stdcall;
  789. {$EXTERNALSYM CreateServiceA}
  790. function CreateServiceW(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCWSTR;
  791.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  792.   lpBinaryPathName, lpLoadOrderGroup: LPCWSTR; lpdwTagId: LPDWORD;
  793.   lpDependencies, lpServiceStartName, lpPassword: LPCWSTR): SC_HANDLE; stdcall;
  794. {$EXTERNALSYM CreateServiceW}
  796. {$IFDEF UNICODE}
  797. function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCWSTR;
  798.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  799.   lpBinaryPathName, lpLoadOrderGroup: LPCWSTR; lpdwTagId: LPDWORD;
  800.   lpDependencies, lpServiceStartName, lpPassword: LPCWSTR): SC_HANDLE; stdcall;
  801. {$EXTERNALSYM CreateService}
  802. {$ELSE}
  803. function CreateService(hSCManager: SC_HANDLE; lpServiceName, lpDisplayName: LPCSTR;
  804.   dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD;
  805.   lpBinaryPathName, lpLoadOrderGroup: LPCSTR; lpdwTagId: LPDWORD;
  806.   lpDependencies, lpServiceStartName, lpPassword: LPCSTR): SC_HANDLE; stdcall;
  807. {$EXTERNALSYM CreateService}
  808. {$ENDIF}
  810. function DeleteService(hService: SC_HANDLE): BOOL; stdcall;
  811. {$EXTERNALSYM DeleteService}
  813. function EnumDependentServicesA(hService: SC_HANDLE; dwServiceState: DWORD;
  814.   lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD; var pcbBytesNeeded,
  815.   lpServicesReturned: DWORD): BOOL; stdcall;
  816. {$EXTERNALSYM EnumDependentServicesA}
  817. function EnumDependentServicesW(hService: SC_HANDLE; dwServiceState: DWORD;
  818.   lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD; var pcbBytesNeeded,
  819.   lpServicesReturned: DWORD): BOOL; stdcall;
  820. {$EXTERNALSYM EnumDependentServicesW}
  822. {$IFDEF UNICODE}
  823. function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
  824.   lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD; var pcbBytesNeeded,
  825.   lpServicesReturned: DWORD): BOOL; stdcall;
  826. {$EXTERNALSYM EnumDependentServices}
  827. {$ELSE}
  828. function EnumDependentServices(hService: SC_HANDLE; dwServiceState: DWORD;
  829.   lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD; var pcbBytesNeeded,
  830.   lpServicesReturned: DWORD): BOOL; stdcall;
  831. {$EXTERNALSYM EnumDependentServices}
  832. {$ENDIF}
  834. function EnumServicesStatusA(hSCManager: SC_HANDLE; dwServiceType: DWORD;
  835.   dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD;
  836.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  837. {$EXTERNALSYM EnumServicesStatusA}
  838. function EnumServicesStatusW(hSCManager: SC_HANDLE; dwServiceType: DWORD;
  839.   dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD;
  840.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  841. {$EXTERNALSYM EnumServicesStatusW}
  843. {$IFDEF UNICODE}
  844. function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType: DWORD;
  845.   dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSW; cbBufSize: DWORD;
  846.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  847. {$EXTERNALSYM EnumServicesStatus}
  848. {$ELSE}
  849. function EnumServicesStatus(hSCManager: SC_HANDLE; dwServiceType: DWORD;
  850.   dwServiceState: DWORD; lpServices: LPENUM_SERVICE_STATUSA; cbBufSize: DWORD;
  851.   var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD): BOOL; stdcall;
  852. {$EXTERNALSYM EnumServicesStatus}
  853. {$ENDIF}
  855. function EnumServicesStatusExA(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
  856.   dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
  857.   cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
  858.   pszGroupName: LPCSTR): BOOL; stdcall;
  859. {$EXTERNALSYM EnumServicesStatusExA}
  860. function EnumServicesStatusExW(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
  861.   dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
  862.   cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
  863.   pszGroupName: LPCWSTR): BOOL; stdcall;
  864. {$EXTERNALSYM EnumServicesStatusExW}
  866. {$IFDEF UNICODE}
  867. function EnumServicesStatusEx(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
  868.   dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
  869.   cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
  870.   pszGroupName: LPCWSTR): BOOL; stdcall;
  871. {$EXTERNALSYM EnumServicesStatusEx}
  872. {$ELSE}
  873. function EnumServicesStatusEx(hSCManager: SC_HANDLE; InfoLevel: SC_ENUM_TYPE;
  874.   dwServiceType: DWORD; dwServiceState: DWORD; lpServices: LPBYTE;
  875.   cbBufSize: DWORD; var pcbBytesNeeded, lpServicesReturned, lpResumeHandle: DWORD;
  876.   pszGroupName: LPCSTR): BOOL; stdcall;
  877. {$EXTERNALSYM EnumServicesStatusEx}
  878. {$ENDIF}
  880. function GetServiceKeyNameA(hSCManager: SC_HANDLE; lpDisplayName: LPCSTR;
  881.   lpServiceName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  882. {$EXTERNALSYM GetServiceKeyNameA}
  883. function GetServiceKeyNameW(hSCManager: SC_HANDLE; lpDisplayName: LPCWSTR;
  884.   lpServiceName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  885. {$EXTERNALSYM GetServiceKeyNameW}
  887. {$IFDEF UNICODE}
  888. function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName: LPCWSTR;
  889.   lpServiceName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  890. {$EXTERNALSYM GetServiceKeyName}
  891. {$ELSE}
  892. function GetServiceKeyName(hSCManager: SC_HANDLE; lpDisplayName: LPCSTR;
  893.   lpServiceName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  894. {$EXTERNALSYM GetServiceKeyName}
  895. {$ENDIF}
  897. function GetServiceDisplayNameA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
  898.   lpDisplayName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  899. {$EXTERNALSYM GetServiceDisplayNameA}
  900. function GetServiceDisplayNameW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
  901.   lpDisplayName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  902. {$EXTERNALSYM GetServiceDisplayNameW}
  904. {$IFDEF UNICODE}
  905. function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
  906.   lpDisplayName: LPWSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  907. {$EXTERNALSYM GetServiceDisplayName}
  908. {$ELSE}
  909. function GetServiceDisplayName(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
  910.   lpDisplayName: LPSTR; var lpcchBuffer: DWORD): BOOL; stdcall;
  911. {$EXTERNALSYM GetServiceDisplayName}
  912. {$ENDIF}
  914. function LockServiceDatabase(hSCManager: SC_HANDLE): SC_LOCK; stdcall;
  915. {$EXTERNALSYM LockServiceDatabase}
  917. function NotifyBootConfigStatus(BootAcceptable: BOOL): BOOL; stdcall;
  918. {$EXTERNALSYM NotifyBootConfigStatus}
  920. function OpenSCManagerA(lpMachineName: LPCSTR; lpDatabaseName: LPCSTR;
  921.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  922. {$EXTERNALSYM OpenSCManagerA}
  923. function OpenSCManagerW(lpMachineName: LPCWSTR; lpDatabaseName: LPCWSTR;
  924.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  925. {$EXTERNALSYM OpenSCManagerW}
  927. {$IFDEF UNICODE}
  928. function OpenSCManager(lpMachineName: LPCWSTR; lpDatabaseName: LPCWSTR;
  929.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  930. {$EXTERNALSYM OpenSCManager}
  931. {$ELSE}
  932. function OpenSCManager(lpMachineName: LPCSTR; lpDatabaseName: LPCSTR;
  933.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  934. {$EXTERNALSYM OpenSCManager}
  935. {$ENDIF}
  937. function OpenServiceA(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
  938.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  939. {$EXTERNALSYM OpenServiceA}
  940. function OpenServiceW(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
  941.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  942. {$EXTERNALSYM OpenServiceW}
  944. {$IFDEF UNICODE}
  945. function OpenService(hSCManager: SC_HANDLE; lpServiceName: LPCWSTR;
  946.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  947. {$EXTERNALSYM OpenService}
  948. {$ELSE}
  949. function OpenService(hSCManager: SC_HANDLE; lpServiceName: LPCSTR;
  950.   dwDesiredAccess: DWORD): SC_HANDLE; stdcall;
  951. {$EXTERNALSYM OpenService}
  952. {$ENDIF}
  954. function QueryServiceConfigA(hService: SC_HANDLE;
  955.   lpServiceConfig: LPQUERY_SERVICE_CONFIGA; cbBufSize: DWORD;
  956.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  957. {$EXTERNALSYM QueryServiceConfigA}
  958. function QueryServiceConfigW(hService: SC_HANDLE;
  959.   lpServiceConfig: LPQUERY_SERVICE_CONFIGW; cbBufSize: DWORD;
  960.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  961. {$EXTERNALSYM QueryServiceConfigW}
  963. {$IFDEF UNICODE}
  964. function QueryServiceConfig(hService: SC_HANDLE;
  965.   lpServiceConfig: LPQUERY_SERVICE_CONFIGW; cbBufSize: DWORD;
  966.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  967. {$EXTERNALSYM QueryServiceConfig}
  968. {$ELSE}
  969. function QueryServiceConfig(hService: SC_HANDLE;
  970.   lpServiceConfig: LPQUERY_SERVICE_CONFIGA; cbBufSize: DWORD;
  971.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  972. {$EXTERNALSYM QueryServiceConfig}
  973. {$ENDIF}
  975. function QueryServiceConfig2A(hService: SC_HANDLE; dwInfoLevel: DWORD;
  976.   lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
  977. {$EXTERNALSYM QueryServiceConfig2A}
  978. function QueryServiceConfig2W(hService: SC_HANDLE; dwInfoLevel: DWORD;
  979.   lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
  980. {$EXTERNALSYM QueryServiceConfig2W}
  982. {$IFDEF UNICODE}
  983. function QueryServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
  984.   lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
  985. {$EXTERNALSYM QueryServiceConfig2}
  986. {$ELSE}
  987. function QueryServiceConfig2(hService: SC_HANDLE; dwInfoLevel: DWORD;
  988.   lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
  989. {$EXTERNALSYM QueryServiceConfig2}
  990. {$ENDIF}
  992. function QueryServiceLockStatusA(hSCManager: SC_HANDLE;
  993.   lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA; cbBufSize: DWORD;
  994.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  995. {$EXTERNALSYM QueryServiceLockStatusA}
  996. function QueryServiceLockStatusW(hSCManager: SC_HANDLE;
  997.   lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW; cbBufSize: DWORD;
  998.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  999. {$EXTERNALSYM QueryServiceLockStatusW}
  1001. {$IFDEF UNICODE}
  1002. function QueryServiceLockStatus(hSCManager: SC_HANDLE;
  1003.   lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSW; cbBufSize: DWORD;
  1004.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  1005. {$EXTERNALSYM QueryServiceLockStatus}
  1006. {$ELSE}
  1007. function QueryServiceLockStatus(hSCManager: SC_HANDLE;
  1008.   lpLockStatus: LPQUERY_SERVICE_LOCK_STATUSA; cbBufSize: DWORD;
  1009.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  1010. {$EXTERNALSYM QueryServiceLockStatus}
  1011. {$ENDIF}
  1013. function QueryServiceObjectSecurity(hService: SC_HANDLE;
  1014.   dwSecurityInformation: SECURITY_INFORMATION;
  1015.   var lpSecurityDescriptor: SECURITY_DESCRIPTOR; cbBufSize: DWORD;
  1016.   var pcbBytesNeeded: DWORD): BOOL; stdcall;
  1017. {$EXTERNALSYM QueryServiceObjectSecurity}
  1019. function QueryServiceStatus(hService: SC_HANDLE;
  1020.   var lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
  1021. {$EXTERNALSYM QueryServiceStatus}
  1023. function QueryServiceStatusEx(hService: SC_HANDLE; InfoLevel: SC_STATUS_TYPE;
  1024.   lpBuffer: LPBYTE; cbBufSize: DWORD; var pcbBytesNeeded: DWORD): BOOL; stdcall;
  1025. {$EXTERNALSYM QueryServiceStatusEx}
  1027. function RegisterServiceCtrlHandlerA(lpServiceName: LPCSTR;
  1028.   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
  1029. {$EXTERNALSYM RegisterServiceCtrlHandlerA}
  1030. function RegisterServiceCtrlHandlerW(lpServiceName: LPCWSTR;
  1031.   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
  1032. {$EXTERNALSYM RegisterServiceCtrlHandlerW}
  1034. {$IFDEF UNICODE}
  1035. function RegisterServiceCtrlHandler(lpServiceName: LPCWSTR;
  1036.   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
  1037. {$EXTERNALSYM RegisterServiceCtrlHandler}
  1038. {$ELSE}
  1039. function RegisterServiceCtrlHandler(lpServiceName: LPCSTR;
  1040.   lpHandlerProc: LPHANDLER_FUNCTION): SERVICE_STATUS_HANDLE; stdcall;
  1041. {$EXTERNALSYM RegisterServiceCtrlHandler}
  1042. {$ENDIF}
  1044. function RegisterServiceCtrlHandlerExA(lpServiceName: LPCSTR;
  1045.   lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
  1046. {$EXTERNALSYM RegisterServiceCtrlHandlerExA}
  1047. function RegisterServiceCtrlHandlerExW(lpServiceName: LPCWSTR;
  1048.   lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
  1049. {$EXTERNALSYM RegisterServiceCtrlHandlerExW}
  1051. {$IFDEF UNICODE}
  1052. function RegisterServiceCtrlHandlerEx(lpServiceName: LPCWSTR;
  1053.   lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
  1054. {$EXTERNALSYM RegisterServiceCtrlHandlerEx}
  1055. {$ELSE}
  1056. function RegisterServiceCtrlHandlerEx(lpServiceName: LPCSTR;
  1057.   lpHandlerProc: LPHANDLER_FUNCTION_EX; lpContext: LPVOID): SERVICE_STATUS_HANDLE; stdcall;
  1058. {$EXTERNALSYM RegisterServiceCtrlHandlerEx}
  1059. {$ENDIF}
  1061. // 9/4/2002 Changed last parameter from const to pointer - reported by James Ots.
  1063. function SetServiceObjectSecurity(hService: SC_HANDLE;
  1064.   dwSecurityInformation: SECURITY_INFORMATION;
  1065.   lpSecurityDescriptor: PSECURITY_DESCRIPTOR): BOOL; stdcall;
  1066. {$EXTERNALSYM SetServiceObjectSecurity}
  1068. function SetServiceStatus(hServiceStatus: SERVICE_STATUS_HANDLE;
  1069.   const lpServiceStatus: SERVICE_STATUS): BOOL; stdcall;
  1070. {$EXTERNALSYM SetServiceStatus}
  1072. function StartServiceCtrlDispatcherA(lpServiceStartTable: LPSERVICE_TABLE_ENTRYA): BOOL; stdcall;
  1073. {$EXTERNALSYM StartServiceCtrlDispatcherA}
  1074. function StartServiceCtrlDispatcherW(lpServiceStartTable: LPSERVICE_TABLE_ENTRYW): BOOL; stdcall;
  1075. {$EXTERNALSYM StartServiceCtrlDispatcherW}
  1077. {$IFDEF UNICODE}
  1078. function StartServiceCtrlDispatcher(lpServiceStartTable: LPSERVICE_TABLE_ENTRYW): BOOL; stdcall;
  1079. {$EXTERNALSYM StartServiceCtrlDispatcher}
  1080. {$ELSE}
  1081. function StartServiceCtrlDispatcher(lpServiceStartTable: LPSERVICE_TABLE_ENTRYA): BOOL; stdcall;
  1082. {$EXTERNALSYM StartServiceCtrlDispatcher}
  1083. {$ENDIF}
  1085. function StartServiceA(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  1086.   lpServiceArgVectors: LPCSTR): BOOL; stdcall;
  1087. {$EXTERNALSYM StartServiceA}
  1088. function StartServiceW(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  1089.   lpServiceArgVectors: LPCWSTR): BOOL; stdcall;
  1090. {$EXTERNALSYM StartServiceW}
  1092. {$IFDEF UNICODE}
  1093. function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  1094.   lpServiceArgVectors: LPCWSTR): BOOL; stdcall;
  1095. {$EXTERNALSYM StartService}
  1096. {$ELSE}
  1097. function StartService(hService: SC_HANDLE; dwNumServiceArgs: DWORD;
  1098.   lpServiceArgVectors: LPCSTR): BOOL; stdcall;
  1099. {$EXTERNALSYM StartService}
  1100. {$ENDIF}
  1102. function UnlockServiceDatabase(ScLock: SC_LOCK): BOOL; stdcall;
  1103. {$EXTERNALSYM UnlockServiceDatabase}
  1105. implementation
  1107. const
  1108.   advapi32 = 'advapi32.dll';
  1111. {$IFDEF DYNAMIC_LINK}
  1112. var
  1113.   _ChangeServiceConfigA: Pointer;
  1115. function ChangeServiceConfigA;
  1116. begin
  1117.   GetProcedureAddress(_ChangeServiceConfigA, advapi32, 'ChangeServiceConfigA');
  1118.   asm
  1119.     mov esp, ebp
  1120.     pop ebp
  1121.     jmp [_ChangeServiceConfigA]
  1122.   end;
  1123. end;
  1124. {$ELSE}
  1125. function ChangeServiceConfigA; external advapi32 name 'ChangeServiceConfigA';
  1126. {$ENDIF DYNAMIC_LINK}
  1128. {$IFDEF DYNAMIC_LINK}
  1129. var
  1130.   _ChangeServiceConfigW: Pointer;
  1132. function ChangeServiceConfigW;
  1133. begin
  1134.   GetProcedureAddress(_ChangeServiceConfigW, advapi32, 'ChangeServiceConfigW');
  1135.   asm
  1136.     mov esp, ebp
  1137.     pop ebp
  1138.     jmp [_ChangeServiceConfigW]
  1139.   end;
  1140. end;
  1141. {$ELSE}
  1142. function ChangeServiceConfigW; external advapi32 name 'ChangeServiceConfigW';
  1143. {$ENDIF DYNAMIC_LINK}
  1145. {$IFDEF UNICODE}
  1147. {$IFDEF DYNAMIC_LINK}
  1148. var
  1149.   _ChangeServiceConfig: Pointer;
  1151. function ChangeServiceConfig;
  1152. begin
  1153.   GetProcedureAddress(_ChangeServiceConfig, advapi32, 'ChangeServiceConfigW');
  1154.   asm
  1155.     mov esp, ebp
  1156.     pop ebp
  1157.     jmp [_ChangeServiceConfig]
  1158.   end;
  1159. end;
  1160. {$ELSE}
  1161. function ChangeServiceConfig; external advapi32 name 'ChangeServiceConfigW';
  1162. {$ENDIF DYNAMIC_LINK}
  1163. {$ELSE}
  1165. {$IFDEF DYNAMIC_LINK}
  1166. var
  1167.   _ChangeServiceConfig: Pointer;
  1169. function ChangeServiceConfig;
  1170. begin
  1171.   GetProcedureAddress(_ChangeServiceConfig, advapi32, 'ChangeServiceConfigA');
  1172.   asm
  1173.     mov esp, ebp
  1174.     pop ebp
  1175.     jmp [_ChangeServiceConfig]
  1176.   end;
  1177. end;
  1178. {$ELSE}
  1179. function ChangeServiceConfig; external advapi32 name 'ChangeServiceConfigA';
  1180. {$ENDIF DYNAMIC_LINK}
  1181. {$ENDIF}
  1184. {$IFDEF DYNAMIC_LINK}
  1185. var
  1186.   _ChangeServiceConfig2A: Pointer;
  1188. function ChangeServiceConfig2A;
  1189. begin
  1190.   GetProcedureAddress(_ChangeServiceConfig2A, advapi32, 'ChangeServiceConfig2A');
  1191.   asm
  1192.     mov esp, ebp
  1193.     pop ebp
  1194.     jmp [_ChangeServiceConfig2A]
  1195.   end;
  1196. end;
  1197. {$ELSE}
  1198. function ChangeServiceConfig2A; external advapi32 name 'ChangeServiceConfig2A';
  1199. {$ENDIF DYNAMIC_LINK}
  1201. {$IFDEF DYNAMIC_LINK}
  1202. var
  1203.   _ChangeServiceConfig2W: Pointer;
  1205. function ChangeServiceConfig2W;
  1206. begin
  1207.   GetProcedureAddress(_ChangeServiceConfig2W, advapi32, 'ChangeServiceConfig2W');
  1208.   asm
  1209.     mov esp, ebp
  1210.     pop ebp
  1211.     jmp [_ChangeServiceConfig2W]
  1212.   end;
  1213. end;
  1214. {$ELSE}
  1215. function ChangeServiceConfig2W; external advapi32 name 'ChangeServiceConfig2W';
  1216. {$ENDIF DYNAMIC_LINK}
  1218. {$IFDEF UNICODE}
  1220. {$IFDEF DYNAMIC_LINK}
  1221. var
  1222.   _ChangeServiceConfig2: Pointer;
  1224. function ChangeServiceConfig2;
  1225. begin
  1226.   GetProcedureAddress(_ChangeServiceConfig2, advapi32, 'ChangeServiceConfig2W');
  1227.   asm
  1228.     mov esp, ebp
  1229.     pop ebp
  1230.     jmp [_ChangeServiceConfig2]
  1231.   end;
  1232. end;
  1233. {$ELSE}
  1234. function ChangeServiceConfig2; external advapi32 name 'ChangeServiceConfig2W';
  1235. {$ENDIF DYNAMIC_LINK}
  1236. {$ELSE}
  1238. {$IFDEF DYNAMIC_LINK}
  1239. var
  1240.   _ChangeServiceConfig2: Pointer;
  1242. function ChangeServiceConfig2;
  1243. begin
  1244.   GetProcedureAddress(_ChangeServiceConfig2, advapi32, 'ChangeServiceConfig2A');
  1245.   asm
  1246.     mov esp, ebp
  1247.     pop ebp
  1248.     jmp [_ChangeServiceConfig2]
  1249.   end;
  1250. end;
  1251. {$ELSE}
  1252. function ChangeServiceConfig2; external advapi32 name 'ChangeServiceConfig2A';
  1253. {$ENDIF DYNAMIC_LINK}
  1254. {$ENDIF}
  1257. {$IFDEF DYNAMIC_LINK}
  1258. var
  1259.   _CloseServiceHandle: Pointer;
  1261. function CloseServiceHandle;
  1262. begin
  1263.   GetProcedureAddress(_CloseServiceHandle, advapi32, 'CloseServiceHandle');
  1264.   asm
  1265.     mov esp, ebp
  1266.     pop ebp
  1267.     jmp [_CloseServiceHandle]
  1268.   end;
  1269. end;
  1270. {$ELSE}
  1271. function CloseServiceHandle; external advapi32 name 'CloseServiceHandle';
  1272. {$ENDIF DYNAMIC_LINK}
  1274. {$IFDEF DYNAMIC_LINK}
  1275. var
  1276.   _ControlService: Pointer;
  1278. function ControlService;
  1279. begin
  1280.   GetProcedureAddress(_ControlService, advapi32, 'ControlService');
  1281.   asm
  1282.     mov esp, ebp
  1283.     pop ebp
  1284.     jmp [_ControlService]
  1285.   end;
  1286. end;
  1287. {$ELSE}
  1288. function ControlService; external advapi32 name 'ControlService';
  1289. {$ENDIF DYNAMIC_LINK}
  1292. {$IFDEF DYNAMIC_LINK}
  1293. var
  1294.   _CreateServiceA: Pointer;
  1296. function CreateServiceA;
  1297. begin
  1298.   GetProcedureAddress(_CreateServiceA, advapi32, 'CreateServiceA');
  1299.   asm
  1300.     mov esp, ebp
  1301.     pop ebp
  1302.     jmp [_CreateServiceA]
  1303.   end;
  1304. end;
  1305. {$ELSE}
  1306. function CreateServiceA; external advapi32 name 'CreateServiceA';
  1307. {$ENDIF DYNAMIC_LINK}
  1309. {$IFDEF DYNAMIC_LINK}
  1310. var
  1311.   _CreateServiceW: Pointer;
  1313. function CreateServiceW;
  1314. begin
  1315.   GetProcedureAddress(_CreateServiceW, advapi32, 'CreateServiceW');
  1316.   asm
  1317.     mov esp, ebp
  1318.     pop ebp
  1319.     jmp [_CreateServiceW]
  1320.   end;
  1321. end;
  1322. {$ELSE}
  1323. function CreateServiceW; external advapi32 name 'CreateServiceW';
  1324. {$ENDIF DYNAMIC_LINK}
  1326. {$IFDEF UNICODE}
  1328. {$IFDEF DYNAMIC_LINK}
  1329. var
  1330.   _CreateService: Pointer;
  1332. function CreateService;
  1333. begin
  1334.   GetProcedureAddress(_CreateService, advapi32, 'CreateServiceW');
  1335.   asm
  1336.     mov esp, ebp
  1337.     pop ebp
  1338.     jmp [_CreateService]
  1339.   end;
  1340. end;
  1341. {$ELSE}
  1342. function CreateService; external advapi32 name 'CreateServiceW';
  1343. {$ENDIF DYNAMIC_LINK}
  1344. {$ELSE}
  1346. {$IFDEF DYNAMIC_LINK}
  1347. var
  1348.   _CreateService: Pointer;
  1350. function CreateService;
  1351. begin
  1352.   GetProcedureAddress(_CreateService, advapi32, 'CreateServiceA');
  1353.   asm
  1354.     mov esp, ebp
  1355.     pop ebp
  1356.     jmp [_CreateService]
  1357.   end;
  1358. end;
  1359. {$ELSE}
  1360. function CreateService; external advapi32 name 'CreateServiceA';
  1361. {$ENDIF DYNAMIC_LINK}
  1362. {$ENDIF}
  1365. {$IFDEF DYNAMIC_LINK}
  1366. var
  1367.   _DeleteService: Pointer;
  1369. function DeleteService;
  1370. begin
  1371.   GetProcedureAddress(_DeleteService, advapi32, 'DeleteService');
  1372.   asm
  1373.     mov esp, ebp
  1374.     pop ebp
  1375.     jmp [_DeleteService]
  1376.   end;
  1377. end;
  1378. {$ELSE}
  1379. function DeleteService; external advapi32 name 'DeleteService';
  1380. {$ENDIF DYNAMIC_LINK}
  1383. {$IFDEF DYNAMIC_LINK}
  1384. var
  1385.   _EnumDependentServicesA: Pointer;
  1387. function EnumDependentServicesA;
  1388. begin
  1389.   GetProcedureAddress(_EnumDependentServicesA, advapi32, 'EnumDependentServicesA');
  1390.   asm
  1391.     mov esp, ebp
  1392.     pop ebp
  1393.     jmp [_EnumDependentServicesA]
  1394.   end;
  1395. end;
  1396. {$ELSE}
  1397. function EnumDependentServicesA; external advapi32 name 'EnumDependentServicesA';
  1398. {$ENDIF DYNAMIC_LINK}
  1400. {$IFDEF DYNAMIC_LINK}
  1401. var
  1402.   _EnumDependentServicesW: Pointer;
  1404. function EnumDependentServicesW;
  1405. begin
  1406.   GetProcedureAddress(_EnumDependentServicesW, advapi32, 'EnumDependentServicesW');
  1407.   asm
  1408.     mov esp, ebp
  1409.     pop ebp
  1410.     jmp [_EnumDependentServicesW]
  1411.   end;
  1412. end;
  1413. {$ELSE}
  1414. function EnumDependentServicesW; external advapi32 name 'EnumDependentServicesW';
  1415. {$ENDIF DYNAMIC_LINK}
  1417. {$IFDEF UNICODE}
  1419. {$IFDEF DYNAMIC_LINK}
  1420. var
  1421.   _EnumDependentServices: Pointer;
  1423. function EnumDependentServices;
  1424. begin
  1425.   GetProcedureAddress(_EnumDependentServices, advapi32, 'EnumDependentServicesW');
  1426.   asm
  1427.     mov esp, ebp
  1428.     pop ebp
  1429.     jmp [_EnumDependentServices]
  1430.   end;
  1431. end;
  1432. {$ELSE}
  1433. function EnumDependentServices; external advapi32 name 'EnumDependentServicesW';
  1434. {$ENDIF DYNAMIC_LINK}
  1435. {$ELSE}
  1437. {$IFDEF DYNAMIC_LINK}
  1438. var
  1439.   _EnumDependentServices: Pointer;
  1441. function EnumDependentServices;
  1442. begin
  1443.   GetProcedureAddress(_EnumDependentServices, advapi32, 'EnumDependentServicesA');
  1444.   asm
  1445.     mov esp, ebp
  1446.     pop ebp
  1447.     jmp [_EnumDependentServices]
  1448.   end;
  1449. end;
  1450. {$ELSE}
  1451. function EnumDependentServices; external advapi32 name 'EnumDependentServicesA';
  1452. {$ENDIF DYNAMIC_LINK}
  1453. {$ENDIF}
  1456. {$IFDEF DYNAMIC_LINK}
  1457. var
  1458.   _EnumServicesStatusA: Pointer;
  1460. function EnumServicesStatusA;
  1461. begin
  1462.   GetProcedureAddress(_EnumServicesStatusA, advapi32, 'EnumServicesStatusA');
  1463.   asm
  1464.     mov esp, ebp
  1465.     pop ebp
  1466.     jmp [_EnumServicesStatusA]
  1467.   end;
  1468. end;
  1469. {$ELSE}
  1470. function EnumServicesStatusA; external advapi32 name 'EnumServicesStatusA';
  1471. {$ENDIF DYNAMIC_LINK}
  1473. {$IFDEF DYNAMIC_LINK}
  1474. var
  1475.   _EnumServicesStatusW: Pointer;
  1477. function EnumServicesStatusW;
  1478. begin
  1479.   GetProcedureAddress(_EnumServicesStatusW, advapi32, 'EnumServicesStatusW');
  1480.   asm
  1481.     mov esp, ebp
  1482.     pop ebp
  1483.     jmp [_EnumServicesStatusW]
  1484.   end;
  1485. end;
  1486. {$ELSE}
  1487. function EnumServicesStatusW; external advapi32 name 'EnumServicesStatusW';
  1488. {$ENDIF DYNAMIC_LINK}
  1490. {$IFDEF UNICODE}
  1492. {$IFDEF DYNAMIC_LINK}
  1493. var
  1494.   _EnumServicesStatus: Pointer;
  1496. function EnumServicesStatus;
  1497. begin
  1498.   GetProcedureAddress(_EnumServicesStatus, advapi32, 'EnumServicesStatusW');
  1499.   asm
  1500.     mov esp, ebp
  1501.     pop ebp
  1502.     jmp [_EnumServicesStatus]
  1503.   end;
  1504. end;
  1505. {$ELSE}
  1506. function EnumServicesStatus; external advapi32 name 'EnumServicesStatusW';
  1507. {$ENDIF DYNAMIC_LINK}
  1508. {$ELSE}
  1510. {$IFDEF DYNAMIC_LINK}
  1511. var
  1512.   _EnumServicesStatus: Pointer;
  1514. function EnumServicesStatus;
  1515. begin
  1516.   GetProcedureAddress(_EnumServicesStatus, advapi32, 'EnumServicesStatusA');
  1517.   asm
  1518.     mov esp, ebp
  1519.     pop ebp
  1520.     jmp [_EnumServicesStatus]
  1521.   end;
  1522. end;
  1523. {$ELSE}
  1524. function EnumServicesStatus; external advapi32 name 'EnumServicesStatusA';
  1525. {$ENDIF DYNAMIC_LINK}
  1526. {$ENDIF}
  1529. {$IFDEF DYNAMIC_LINK}
  1530. var
  1531.   _EnumServicesStatusExA: Pointer;
  1533. function EnumServicesStatusExA;
  1534. begin
  1535.   GetProcedureAddress(_EnumServicesStatusExA, advapi32, 'EnumServicesStatusExA');
  1536.   asm
  1537.     mov esp, ebp
  1538.     pop ebp
  1539.     jmp [_EnumServicesStatusExA]
  1540.   end;
  1541. end;
  1542. {$ELSE}
  1543. function EnumServicesStatusExA; external advapi32 name 'EnumServicesStatusExA';
  1544. {$ENDIF DYNAMIC_LINK}
  1546. {$IFDEF DYNAMIC_LINK}
  1547. var
  1548.   _EnumServicesStatusExW: Pointer;
  1550. function EnumServicesStatusExW;
  1551. begin
  1552.   GetProcedureAddress(_EnumServicesStatusExW, advapi32, 'EnumServicesStatusExW');
  1553.   asm
  1554.     mov esp, ebp
  1555.     pop ebp
  1556.     jmp [_EnumServicesStatusExW]
  1557.   end;
  1558. end;
  1559. {$ELSE}
  1560. function EnumServicesStatusExW; external advapi32 name 'EnumServicesStatusExW';
  1561. {$ENDIF DYNAMIC_LINK}
  1563. {$IFDEF UNICODE}
  1565. {$IFDEF DYNAMIC_LINK}
  1566. var
  1567.   _EnumServicesStatusEx: Pointer;
  1569. function EnumServicesStatusEx;
  1570. begin
  1571.   GetProcedureAddress(_EnumServicesStatusEx, advapi32, 'EnumServicesStatusExW');
  1572.   asm
  1573.     mov esp, ebp
  1574.     pop ebp
  1575.     jmp [_EnumServicesStatusEx]
  1576.   end;
  1577. end;
  1578. {$ELSE}
  1579. function EnumServicesStatusEx; external advapi32 name 'EnumServicesStatusExW';
  1580. {$ENDIF DYNAMIC_LINK}
  1581. {$ELSE}
  1583. {$IFDEF DYNAMIC_LINK}
  1584. var
  1585.   _EnumServicesStatusEx: Pointer;
  1587. function EnumServicesStatusEx;
  1588. begin
  1589.   GetProcedureAddress(_EnumServicesStatusEx, advapi32, 'EnumServicesStatusExA');
  1590.   asm
  1591.     mov esp, ebp
  1592.     pop ebp
  1593.     jmp [_EnumServicesStatusEx]
  1594.   end;
  1595. end;
  1596. {$ELSE}
  1597. function EnumServicesStatusEx; external advapi32 name 'EnumServicesStatusExA';
  1598. {$ENDIF DYNAMIC_LINK}
  1599. {$ENDIF}
  1602. {$IFDEF DYNAMIC_LINK}
  1603. var
  1604.   _GetServiceKeyNameA: Pointer;
  1606. function GetServiceKeyNameA;
  1607. begin
  1608.   GetProcedureAddress(_GetServiceKeyNameA, advapi32, 'GetServiceKeyNameA');
  1609.   asm
  1610.     mov esp, ebp
  1611.     pop ebp
  1612.     jmp [_GetServiceKeyNameA]
  1613.   end;
  1614. end;
  1615. {$ELSE}
  1616. function GetServiceKeyNameA; external advapi32 name 'GetServiceKeyNameA';
  1617. {$ENDIF DYNAMIC_LINK}
  1619. {$IFDEF DYNAMIC_LINK}
  1620. var
  1621.   _GetServiceKeyNameW: Pointer;
  1623. function GetServiceKeyNameW;
  1624. begin
  1625.   GetProcedureAddress(_GetServiceKeyNameW, advapi32, 'GetServiceKeyNameW');
  1626.   asm
  1627.     mov esp, ebp
  1628.     pop ebp
  1629.     jmp [_GetServiceKeyNameW]
  1630.   end;
  1631. end;
  1632. {$ELSE}
  1633. function GetServiceKeyNameW; external advapi32 name 'GetServiceKeyNameW';
  1634. {$ENDIF DYNAMIC_LINK}
  1636. {$IFDEF UNICODE}
  1638. {$IFDEF DYNAMIC_LINK}
  1639. var
  1640.   _GetServiceKeyName: Pointer;
  1642. function GetServiceKeyName;
  1643. begin
  1644.   GetProcedureAddress(_GetServiceKeyName, advapi32, 'GetServiceKeyNameW');
  1645.   asm
  1646.     mov esp, ebp
  1647.     pop ebp
  1648.     jmp [_GetServiceKeyName]
  1649.   end;
  1650. end;
  1651. {$ELSE}
  1652. function GetServiceKeyName; external advapi32 name 'GetServiceKeyNameW';
  1653. {$ENDIF DYNAMIC_LINK}
  1654. {$ELSE}
  1656. {$IFDEF DYNAMIC_LINK}
  1657. var
  1658.   _GetServiceKeyName: Pointer;
  1660. function GetServiceKeyName;
  1661. begin
  1662.   GetProcedureAddress(_GetServiceKeyName, advapi32, 'GetServiceKeyNameA');
  1663.   asm
  1664.     mov esp, ebp
  1665.     pop ebp
  1666.     jmp [_GetServiceKeyName]
  1667.   end;
  1668. end;
  1669. {$ELSE}
  1670. function GetServiceKeyName; external advapi32 name 'GetServiceKeyNameA';
  1671. {$ENDIF DYNAMIC_LINK}
  1672. {$ENDIF}
  1675. {$IFDEF DYNAMIC_LINK}
  1676. var
  1677.   _GetServiceDisplayNameA: Pointer;
  1679. function GetServiceDisplayNameA;
  1680. begin
  1681.   GetProcedureAddress(_GetServiceDisplayNameA, advapi32, 'GetServiceDisplayNameA');
  1682.   asm
  1683.     mov esp, ebp
  1684.     pop ebp
  1685.     jmp [_GetServiceDisplayNameA]
  1686.   end;
  1687. end;
  1688. {$ELSE}
  1689. function GetServiceDisplayNameA; external advapi32 name 'GetServiceDisplayNameA';
  1690. {$ENDIF DYNAMIC_LINK}
  1692. {$IFDEF DYNAMIC_LINK}
  1693. var
  1694.   _GetServiceDisplayNameW: Pointer;
  1696. function GetServiceDisplayNameW;
  1697. begin
  1698.   GetProcedureAddress(_GetServiceDisplayNameW, advapi32, 'GetServiceDisplayNameW');
  1699.   asm
  1700.     mov esp, ebp
  1701.     pop ebp
  1702.     jmp [_GetServiceDisplayNameW]
  1703.   end;
  1704. end;
  1705. {$ELSE}
  1706. function GetServiceDisplayNameW; external advapi32 name 'GetServiceDisplayNameW';
  1707. {$ENDIF DYNAMIC_LINK}
  1709. {$IFDEF UNICODE}
  1711. {$IFDEF DYNAMIC_LINK}
  1712. var
  1713.   _GetServiceDisplayName: Pointer;
  1715. function GetServiceDisplayName;
  1716. begin
  1717.   GetProcedureAddress(_GetServiceDisplayName, advapi32, 'GetServiceDisplayNameW');
  1718.   asm
  1719.     mov esp, ebp
  1720.     pop ebp
  1721.     jmp [_GetServiceDisplayName]
  1722.   end;
  1723. end;
  1724. {$ELSE}
  1725. function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayNameW';
  1726. {$ENDIF DYNAMIC_LINK}
  1727. {$ELSE}
  1729. {$IFDEF DYNAMIC_LINK}
  1730. var
  1731.   _GetServiceDisplayName: Pointer;
  1733. function GetServiceDisplayName;
  1734. begin
  1735.   GetProcedureAddress(_GetServiceDisplayName, advapi32, 'GetServiceDisplayNameA');
  1736.   asm
  1737.     mov esp, ebp
  1738.     pop ebp
  1739.     jmp [_GetServiceDisplayName]
  1740.   end;
  1741. end;
  1742. {$ELSE}
  1743. function GetServiceDisplayName; external advapi32 name 'GetServiceDisplayNameA';
  1744. {$ENDIF DYNAMIC_LINK}
  1745. {$ENDIF}
  1748. {$IFDEF DYNAMIC_LINK}
  1749. var
  1750.   _LockServiceDatabase: Pointer;
  1752. function LockServiceDatabase;
  1753. begin
  1754.   GetProcedureAddress(_LockServiceDatabase, advapi32, 'LockServiceDatabase');
  1755.   asm
  1756.     mov esp, ebp
  1757.     pop ebp
  1758.     jmp [_LockServiceDatabase]
  1759.   end;
  1760. end;
  1761. {$ELSE}
  1762. function LockServiceDatabase; external advapi32 name 'LockServiceDatabase';
  1763. {$ENDIF DYNAMIC_LINK}
  1766. {$IFDEF DYNAMIC_LINK}
  1767. var
  1768.   _NotifyBootConfigStatus: Pointer;
  1770. function NotifyBootConfigStatus;
  1771. begin
  1772.   GetProcedureAddress(_NotifyBootConfigStatus, advapi32, 'NotifyBootConfigStatus');
  1773.   asm
  1774.     mov esp, ebp
  1775.     pop ebp
  1776.     jmp [_NotifyBootConfigStatus]
  1777.   end;
  1778. end;
  1779. {$ELSE}
  1780. function NotifyBootConfigStatus; external advapi32 name 'NotifyBootConfigStatus';
  1781. {$ENDIF DYNAMIC_LINK}
  1784. {$IFDEF DYNAMIC_LINK}
  1785. var
  1786.   _OpenSCManagerA: Pointer;
  1788. function OpenSCManagerA;
  1789. begin
  1790.   GetProcedureAddress(_OpenSCManagerA, advapi32, 'OpenSCManagerA');
  1791.   asm
  1792.     mov esp, ebp
  1793.     pop ebp
  1794.     jmp [_OpenSCManagerA]
  1795.   end;
  1796. end;
  1797. {$ELSE}
  1798. function OpenSCManagerA; external advapi32 name 'OpenSCManagerA';
  1799. {$ENDIF DYNAMIC_LINK}
  1801. {$IFDEF DYNAMIC_LINK}
  1802. var
  1803.   _OpenSCManagerW: Pointer;
  1805. function OpenSCManagerW;
  1806. begin
  1807.   GetProcedureAddress(_OpenSCManagerW, advapi32, 'OpenSCManagerW');
  1808.   asm
  1809.     mov esp, ebp
  1810.     pop ebp
  1811.     jmp [_OpenSCManagerW]
  1812.   end;
  1813. end;
  1814. {$ELSE}
  1815. function OpenSCManagerW; external advapi32 name 'OpenSCManagerW';
  1816. {$ENDIF DYNAMIC_LINK}
  1818. {$IFDEF UNICODE}
  1820. {$IFDEF DYNAMIC_LINK}
  1821. var
  1822.   _OpenSCManager: Pointer;
  1824. function OpenSCManager;
  1825. begin
  1826.   GetProcedureAddress(_OpenSCManager, advapi32, 'OpenSCManagerW');
  1827.   asm
  1828.     mov esp, ebp
  1829.     pop ebp
  1830.     jmp [_OpenSCManager]
  1831.   end;
  1832. end;
  1833. {$ELSE}
  1834. function OpenSCManager; external advapi32 name 'OpenSCManagerW';
  1835. {$ENDIF DYNAMIC_LINK}
  1836. {$ELSE}
  1838. {$IFDEF DYNAMIC_LINK}
  1839. var
  1840.   _OpenSCManager: Pointer;
  1842. function OpenSCManager;
  1843. begin
  1844.   GetProcedureAddress(_OpenSCManager, advapi32, 'OpenSCManagerA');
  1845.   asm
  1846.     mov esp, ebp
  1847.     pop ebp
  1848.     jmp [_OpenSCManager]
  1849.   end;
  1850. end;
  1851. {$ELSE}
  1852. function OpenSCManager; external advapi32 name 'OpenSCManagerA';
  1853. {$ENDIF DYNAMIC_LINK}
  1854. {$ENDIF}
  1857. {$IFDEF DYNAMIC_LINK}
  1858. var
  1859.   _OpenServiceA: Pointer;
  1861. function OpenServiceA;
  1862. begin
  1863.   GetProcedureAddress(_OpenServiceA, advapi32, 'OpenServiceA');
  1864.   asm
  1865.     mov esp, ebp
  1866.     pop ebp
  1867.     jmp [_OpenServiceA]
  1868.   end;
  1869. end;
  1870. {$ELSE}
  1871. function OpenServiceA; external advapi32 name 'OpenServiceA';
  1872. {$ENDIF DYNAMIC_LINK}
  1874. {$IFDEF DYNAMIC_LINK}
  1875. var
  1876.   _OpenServiceW: Pointer;
  1878. function OpenServiceW;
  1879. begin
  1880.   GetProcedureAddress(_OpenServiceW, advapi32, 'OpenServiceW');
  1881.   asm
  1882.     mov esp, ebp
  1883.     pop ebp
  1884.     jmp [_OpenServiceW]
  1885.   end;
  1886. end;
  1887. {$ELSE}
  1888. function OpenServiceW; external advapi32 name 'OpenServiceW';
  1889. {$ENDIF DYNAMIC_LINK}
  1891. {$IFDEF UNICODE}
  1893. {$IFDEF DYNAMIC_LINK}
  1894. var
  1895.   _OpenService: Pointer;
  1897. function OpenService;
  1898. begin
  1899.   GetProcedureAddress(_OpenService, advapi32, 'OpenServiceW');
  1900.   asm
  1901.     mov esp, ebp
  1902.     pop ebp
  1903.     jmp [_OpenService]
  1904.   end;
  1905. end;
  1906. {$ELSE}
  1907. function OpenService; external advapi32 name 'OpenServiceW';
  1908. {$ENDIF DYNAMIC_LINK}
  1909. {$ELSE}
  1911. {$IFDEF DYNAMIC_LINK}
  1912. var
  1913.   _OpenService: Pointer;
  1915. function OpenService;
  1916. begin
  1917.   GetProcedureAddress(_OpenService, advapi32, 'OpenServiceA');
  1918.   asm
  1919.     mov esp, ebp
  1920.     pop ebp
  1921.     jmp [_OpenService]
  1922.   end;
  1923. end;
  1924. {$ELSE}
  1925. function OpenService; external advapi32 name 'OpenServiceA';
  1926. {$ENDIF DYNAMIC_LINK}
  1927. {$ENDIF}
  1930. {$IFDEF DYNAMIC_LINK}
  1931. var
  1932.   _QueryServiceConfigA: Pointer;
  1934. function QueryServiceConfigA;
  1935. begin
  1936.   GetProcedureAddress(_QueryServiceConfigA, advapi32, 'QueryServiceConfigA');
  1937.   asm
  1938.     mov esp, ebp
  1939.     pop ebp
  1940.     jmp [_QueryServiceConfigA]
  1941.   end;
  1942. end;
  1943. {$ELSE}
  1944. function QueryServiceConfigA; external advapi32 name 'QueryServiceConfigA';
  1945. {$ENDIF DYNAMIC_LINK}
  1947. {$IFDEF DYNAMIC_LINK}
  1948. var
  1949.   _QueryServiceConfigW: Pointer;
  1951. function QueryServiceConfigW;
  1952. begin
  1953.   GetProcedureAddress(_QueryServiceConfigW, advapi32, 'QueryServiceConfigW');
  1954.   asm
  1955.     mov esp, ebp
  1956.     pop ebp
  1957.     jmp [_QueryServiceConfigW]
  1958.   end;
  1959. end;
  1960. {$ELSE}
  1961. function QueryServiceConfigW; external advapi32 name 'QueryServiceConfigW';
  1962. {$ENDIF DYNAMIC_LINK}
  1964. {$IFDEF UNICODE}
  1966. {$IFDEF DYNAMIC_LINK}
  1967. var
  1968.   _QueryServiceConfig: Pointer;
  1970. function QueryServiceConfig;
  1971. begin
  1972.   GetProcedureAddress(_QueryServiceConfig, advapi32, 'QueryServiceConfigW');
  1973.   asm
  1974.     mov esp, ebp
  1975.     pop ebp
  1976.     jmp [_QueryServiceConfig]
  1977.   end;
  1978. end;
  1979. {$ELSE}
  1980. function QueryServiceConfig; external advapi32 name 'QueryServiceConfigW';
  1981. {$ENDIF DYNAMIC_LINK}
  1982. {$ELSE}
  1984. {$IFDEF DYNAMIC_LINK}
  1985. var
  1986.   _QueryServiceConfig: Pointer;
  1988. function QueryServiceConfig;
  1989. begin
  1990.   GetProcedureAddress(_QueryServiceConfig, advapi32, 'QueryServiceConfigA');
  1991.   asm
  1992.     mov esp, ebp
  1993.     pop ebp
  1994.     jmp [_QueryServiceConfig]
  1995.   end;
  1996. end;
  1997. {$ELSE}
  1998. function QueryServiceConfig; external advapi32 name 'QueryServiceConfigA';
  1999. {$ENDIF DYNAMIC_LINK}
  2000. {$ENDIF}
  2003. {$IFDEF DYNAMIC_LINK}
  2004. var
  2005.   _QueryServiceConfig2A: Pointer;
  2007. function QueryServiceConfig2A;
  2008. begin
  2009.   GetProcedureAddress(_QueryServiceConfig2A, advapi32, 'QueryServiceConfig2A');
  2010.   asm
  2011.     mov esp, ebp
  2012.     pop ebp
  2013.     jmp [_QueryServiceConfig2A]
  2014.   end;
  2015. end;
  2016. {$ELSE}
  2017. function QueryServiceConfig2A; external advapi32 name 'QueryServiceConfig2A';
  2018. {$ENDIF DYNAMIC_LINK}
  2020. {$IFDEF DYNAMIC_LINK}
  2021. var
  2022.   _QueryServiceConfig2W: Pointer;
  2024. function QueryServiceConfig2W;
  2025. begin
  2026.   GetProcedureAddress(_QueryServiceConfig2W, advapi32, 'QueryServiceConfig2W');
  2027.   asm
  2028.     mov esp, ebp
  2029.     pop ebp
  2030.     jmp [_QueryServiceConfig2W]
  2031.   end;
  2032. end;
  2033. {$ELSE}
  2034. function QueryServiceConfig2W; external advapi32 name 'QueryServiceConfig2W';
  2035. {$ENDIF DYNAMIC_LINK}
  2037. {$IFDEF UNICODE}
  2039. {$IFDEF DYNAMIC_LINK}
  2040. var
  2041.   _QueryServiceConfig2: Pointer;
  2043. function QueryServiceConfig2;
  2044. begin
  2045.   GetProcedureAddress(_QueryServiceConfig2, advapi32, 'QueryServiceConfig2W');
  2046.   asm
  2047.     mov esp, ebp
  2048.     pop ebp
  2049.     jmp [_QueryServiceConfig2]
  2050.   end;
  2051. end;
  2052. {$ELSE}
  2053. function QueryServiceConfig2; external advapi32 name 'QueryServiceConfig2W';
  2054. {$ENDIF DYNAMIC_LINK}
  2055. {$ELSE}
  2057. {$IFDEF DYNAMIC_LINK}
  2058. var
  2059.   _QueryServiceConfig2: Pointer;
  2061. function QueryServiceConfig2;
  2062. begin
  2063.   GetProcedureAddress(_QueryServiceConfig2, advapi32, 'QueryServiceConfig2A');
  2064.   asm
  2065.     mov esp, ebp
  2066.     pop ebp
  2067.     jmp [_QueryServiceConfig2]
  2068.   end;
  2069. end;
  2070. {$ELSE}
  2071. function QueryServiceConfig2; external advapi32 name 'QueryServiceConfig2A';
  2072. {$ENDIF DYNAMIC_LINK}
  2073. {$ENDIF}
  2076. {$IFDEF DYNAMIC_LINK}
  2077. var
  2078.   _QueryServiceLockStatusA: Pointer;
  2080. function QueryServiceLockStatusA;
  2081. begin
  2082.   GetProcedureAddress(_QueryServiceLockStatusA, advapi32, 'QueryServiceLockStatusA');
  2083.   asm
  2084.     mov esp, ebp
  2085.     pop ebp
  2086.     jmp [_QueryServiceLockStatusA]
  2087.   end;
  2088. end;
  2089. {$ELSE}
  2090. function QueryServiceLockStatusA; external advapi32 name 'QueryServiceLockStatusA';
  2091. {$ENDIF DYNAMIC_LINK}
  2093. {$IFDEF DYNAMIC_LINK}
  2094. var
  2095.   _QueryServiceLockStatusW: Pointer;
  2097. function QueryServiceLockStatusW;
  2098. begin
  2099.   GetProcedureAddress(_QueryServiceLockStatusW, advapi32, 'QueryServiceLockStatusW');
  2100.   asm
  2101.     mov esp, ebp
  2102.     pop ebp
  2103.     jmp [_QueryServiceLockStatusW]
  2104.   end;
  2105. end;
  2106. {$ELSE}
  2107. function QueryServiceLockStatusW; external advapi32 name 'QueryServiceLockStatusW';
  2108. {$ENDIF DYNAMIC_LINK}
  2110. {$IFDEF UNICODE}
  2112. {$IFDEF DYNAMIC_LINK}
  2113. var
  2114.   _QueryServiceLockStatus: Pointer;
  2116. function QueryServiceLockStatus;
  2117. begin
  2118.   GetProcedureAddress(_QueryServiceLockStatus, advapi32, 'QueryServiceLockStatusW');
  2119.   asm
  2120.     mov esp, ebp
  2121.     pop ebp
  2122.     jmp [_QueryServiceLockStatus]
  2123.   end;
  2124. end;
  2125. {$ELSE}
  2126. function QueryServiceLockStatus; external advapi32 name 'QueryServiceLockStatusW';
  2127. {$ENDIF DYNAMIC_LINK}
  2128. {$ELSE}
  2130. {$IFDEF DYNAMIC_LINK}
  2131. var
  2132.   _QueryServiceLockStatus: Pointer;
  2134. function QueryServiceLockStatus;
  2135. begin
  2136.   GetProcedureAddress(_QueryServiceLockStatus, advapi32, 'QueryServiceLockStatusA');
  2137.   asm
  2138.     mov esp, ebp
  2139.     pop ebp
  2140.     jmp [_QueryServiceLockStatus]
  2141.   end;
  2142. end;
  2143. {$ELSE}
  2144. function QueryServiceLockStatus; external advapi32 name 'QueryServiceLockStatusA';
  2145. {$ENDIF DYNAMIC_LINK}
  2146. {$ENDIF}
  2149. {$IFDEF DYNAMIC_LINK}
  2150. var
  2151.   _QueryServiceObjectSecurity: Pointer;
  2153. function QueryServiceObjectSecurity;
  2154. begin
  2155.   GetProcedureAddress(_QueryServiceObjectSecurity, advapi32, 'QueryServiceObjectSecurity');
  2156.   asm
  2157.     mov esp, ebp
  2158.     pop ebp
  2159.     jmp [_QueryServiceObjectSecurity]
  2160.   end;
  2161. end;
  2162. {$ELSE}
  2163. function QueryServiceObjectSecurity; external advapi32 name 'QueryServiceObjectSecurity';
  2164. {$ENDIF DYNAMIC_LINK}
  2166. {$IFDEF DYNAMIC_LINK}
  2167. var
  2168.   _QueryServiceStatus: Pointer;
  2170. function QueryServiceStatus;
  2171. begin
  2172.   GetProcedureAddress(_QueryServiceStatus, advapi32, 'QueryServiceStatus');
  2173.   asm
  2174.     mov esp, ebp
  2175.     pop ebp
  2176.     jmp [_QueryServiceStatus]
  2177.   end;
  2178. end;
  2179. {$ELSE}
  2180. function QueryServiceStatus; external advapi32 name 'QueryServiceStatus';
  2181. {$ENDIF DYNAMIC_LINK}
  2183. {$IFDEF DYNAMIC_LINK}
  2184. var
  2185.   _QueryServiceStatusEx: Pointer;
  2187. function QueryServiceStatusEx;
  2188. begin
  2189.   GetProcedureAddress(_QueryServiceStatusEx, advapi32, 'QueryServiceStatusEx');
  2190.   asm
  2191.     mov esp, ebp
  2192.     pop ebp
  2193.     jmp [_QueryServiceStatusEx]
  2194.   end;
  2195. end;
  2196. {$ELSE}
  2197. function QueryServiceStatusEx; external advapi32 name 'QueryServiceStatusEx';
  2198. {$ENDIF DYNAMIC_LINK}
  2201. {$IFDEF DYNAMIC_LINK}
  2202. var
  2203.   _RegisterServiceCtrlHandlerA: Pointer;
  2205. function RegisterServiceCtrlHandlerA;
  2206. begin
  2207.   GetProcedureAddress(_RegisterServiceCtrlHandlerA, advapi32, 'RegisterServiceCtrlHandlerA');
  2208.   asm
  2209.     mov esp, ebp
  2210.     pop ebp
  2211.     jmp [_RegisterServiceCtrlHandlerA]
  2212.   end;
  2213. end;
  2214. {$ELSE}
  2215. function RegisterServiceCtrlHandlerA; external advapi32 name 'RegisterServiceCtrlHandlerA';
  2216. {$ENDIF DYNAMIC_LINK}
  2218. {$IFDEF DYNAMIC_LINK}
  2219. var
  2220.   _RegisterServiceCtrlHandlerW: Pointer;
  2222. function RegisterServiceCtrlHandlerW;
  2223. begin
  2224.   GetProcedureAddress(_RegisterServiceCtrlHandlerW, advapi32, 'RegisterServiceCtrlHandlerW');
  2225.   asm
  2226.     mov esp, ebp
  2227.     pop ebp
  2228.     jmp [_RegisterServiceCtrlHandlerW]
  2229.   end;
  2230. end;
  2231. {$ELSE}
  2232. function RegisterServiceCtrlHandlerW; external advapi32 name 'RegisterServiceCtrlHandlerW';
  2233. {$ENDIF DYNAMIC_LINK}
  2235. {$IFDEF UNICODE}
  2237. {$IFDEF DYNAMIC_LINK}
  2238. var
  2239.   _RegisterServiceCtrlHandler: Pointer;
  2241. function RegisterServiceCtrlHandler;
  2242. begin
  2243.   GetProcedureAddress(_RegisterServiceCtrlHandler, advapi32, 'RegisterServiceCtrlHandlerW');
  2244.   asm
  2245.     mov esp, ebp
  2246.     pop ebp
  2247.     jmp [_RegisterServiceCtrlHandler]
  2248.   end;
  2249. end;
  2250. {$ELSE}
  2251. function RegisterServiceCtrlHandler; external advapi32 name 'RegisterServiceCtrlHandlerW';
  2252. {$ENDIF DYNAMIC_LINK}
  2253. {$ELSE}
  2255. {$IFDEF DYNAMIC_LINK}
  2256. var
  2257.   _RegisterServiceCtrlHandler: Pointer;
  2259. function RegisterServiceCtrlHandler;
  2260. begin
  2261.   GetProcedureAddress(_RegisterServiceCtrlHandler, advapi32, 'RegisterServiceCtrlHandlerA');
  2262.   asm
  2263.     mov esp, ebp
  2264.     pop ebp
  2265.     jmp [_RegisterServiceCtrlHandler]
  2266.   end;
  2267. end;
  2268. {$ELSE}
  2269. function RegisterServiceCtrlHandler; external advapi32 name 'RegisterServiceCtrlHandlerA';
  2270. {$ENDIF DYNAMIC_LINK}
  2271. {$ENDIF}
  2274. {$IFDEF DYNAMIC_LINK}
  2275. var
  2276.   _RegisterServiceCtrlHandlerExA: Pointer;
  2278. function RegisterServiceCtrlHandlerExA;
  2279. begin
  2280.   GetProcedureAddress(_RegisterServiceCtrlHandlerExA, advapi32, 'RegisterServiceCtrlHandlerExA');
  2281.   asm
  2282.     mov esp, ebp
  2283.     pop ebp
  2284.     jmp [_RegisterServiceCtrlHandlerExA]
  2285.   end;
  2286. end;
  2287. {$ELSE}
  2288. function RegisterServiceCtrlHandlerExA; external advapi32 name 'RegisterServiceCtrlHandlerExA';
  2289. {$ENDIF DYNAMIC_LINK}
  2291. {$IFDEF DYNAMIC_LINK}
  2292. var
  2293.   _RegisterServiceCtrlHandlerExW: Pointer;
  2295. function RegisterServiceCtrlHandlerExW;
  2296. begin
  2297.   GetProcedureAddress(_RegisterServiceCtrlHandlerExW, advapi32, 'RegisterServiceCtrlHandlerExW');
  2298.   asm
  2299.     mov esp, ebp
  2300.     pop ebp
  2301.     jmp [_RegisterServiceCtrlHandlerExW]
  2302.   end;
  2303. end;
  2304. {$ELSE}
  2305. function RegisterServiceCtrlHandlerExW; external advapi32 name 'RegisterServiceCtrlHandlerExW';
  2306. {$ENDIF DYNAMIC_LINK}
  2308. {$IFDEF UNICODE}
  2310. {$IFDEF DYNAMIC_LINK}
  2311. var
  2312.   _RegisterServiceCtrlHandlerEx: Pointer;
  2314. function RegisterServiceCtrlHandlerEx;
  2315. begin
  2316.   GetProcedureAddress(_RegisterServiceCtrlHandlerEx, advapi32, 'RegisterServiceCtrlHandlerExW');
  2317.   asm
  2318.     mov esp, ebp
  2319.     pop ebp
  2320.     jmp [_RegisterServiceCtrlHandlerEx]
  2321.   end;
  2322. end;
  2323. {$ELSE}
  2324. function RegisterServiceCtrlHandlerEx; external advapi32 name 'RegisterServiceCtrlHandlerExW';
  2325. {$ENDIF DYNAMIC_LINK}
  2326. {$ELSE}
  2328. {$IFDEF DYNAMIC_LINK}
  2329. var
  2330.   _RegisterServiceCtrlHandlerEx: Pointer;
  2332. function RegisterServiceCtrlHandlerEx;
  2333. begin
  2334.   GetProcedureAddress(_RegisterServiceCtrlHandlerEx, advapi32, 'RegisterServiceCtrlHandlerExA');
  2335.   asm
  2336.     mov esp, ebp
  2337.     pop ebp
  2338.     jmp [_RegisterServiceCtrlHandlerEx]
  2339.   end;
  2340. end;
  2341. {$ELSE}
  2342. function RegisterServiceCtrlHandlerEx; external advapi32 name 'RegisterServiceCtrlHandlerExA';
  2343. {$ENDIF DYNAMIC_LINK}
  2344. {$ENDIF}
  2347. {$IFDEF DYNAMIC_LINK}
  2348. var
  2349.   _SetServiceObjectSecurity: Pointer;
  2351. function SetServiceObjectSecurity;
  2352. begin
  2353.   GetProcedureAddress(_SetServiceObjectSecurity, advapi32, 'SetServiceObjectSecurity');
  2354.   asm
  2355.     mov esp, ebp
  2356.     pop ebp
  2357.     jmp [_SetServiceObjectSecurity]
  2358.   end;
  2359. end;
  2360. {$ELSE}
  2361. function SetServiceObjectSecurity; external advapi32 name 'SetServiceObjectSecurity';
  2362. {$ENDIF DYNAMIC_LINK}
  2364. {$IFDEF DYNAMIC_LINK}
  2365. var
  2366.   _SetServiceStatus: Pointer;
  2368. function SetServiceStatus;
  2369. begin
  2370.   GetProcedureAddress(_SetServiceStatus, advapi32, 'SetServiceStatus');
  2371.   asm
  2372.     mov esp, ebp
  2373.     pop ebp
  2374.     jmp [_SetServiceStatus]
  2375.   end;
  2376. end;
  2377. {$ELSE}
  2378. function SetServiceStatus; external advapi32 name 'SetServiceStatus';
  2379. {$ENDIF DYNAMIC_LINK}
  2382. {$IFDEF DYNAMIC_LINK}
  2383. var
  2384.   _StartServiceCtrlDispatcherA: Pointer;
  2386. function StartServiceCtrlDispatcherA;
  2387. begin
  2388.   GetProcedureAddress(_StartServiceCtrlDispatcherA, advapi32, 'StartServiceCtrlDispatcherA');
  2389.   asm
  2390.     mov esp, ebp
  2391.     pop ebp
  2392.     jmp [_StartServiceCtrlDispatcherA]
  2393.   end;
  2394. end;
  2395. {$ELSE}
  2396. function StartServiceCtrlDispatcherA; external advapi32 name 'StartServiceCtrlDispatcherA';
  2397. {$ENDIF DYNAMIC_LINK}
  2399. {$IFDEF DYNAMIC_LINK}
  2400. var
  2401.   _StartServiceCtrlDispatcherW: Pointer;
  2403. function StartServiceCtrlDispatcherW;
  2404. begin
  2405.   GetProcedureAddress(_StartServiceCtrlDispatcherW, advapi32, 'StartServiceCtrlDispatcherW');
  2406.   asm
  2407.     mov esp, ebp
  2408.     pop ebp
  2409.     jmp [_StartServiceCtrlDispatcherW]
  2410.   end;
  2411. end;
  2412. {$ELSE}
  2413. function StartServiceCtrlDispatcherW; external advapi32 name 'StartServiceCtrlDispatcherW';
  2414. {$ENDIF DYNAMIC_LINK}
  2416. {$IFDEF UNICODE}
  2418. {$IFDEF DYNAMIC_LINK}
  2419. var
  2420.   _StartServiceCtrlDispatcher: Pointer;
  2422. function StartServiceCtrlDispatcher;
  2423. begin
  2424.   GetProcedureAddress(_StartServiceCtrlDispatcher, advapi32, 'StartServiceCtrlDispatcherW');
  2425.   asm
  2426.     mov esp, ebp
  2427.     pop ebp
  2428.     jmp [_StartServiceCtrlDispatcher]
  2429.   end;
  2430. end;
  2431. {$ELSE}
  2432. function StartServiceCtrlDispatcher; external advapi32 name 'StartServiceCtrlDispatcherW';
  2433. {$ENDIF DYNAMIC_LINK}
  2434. {$ELSE}
  2436. {$IFDEF DYNAMIC_LINK}
  2437. var
  2438.   _StartServiceCtrlDispatcher: Pointer;
  2440. function StartServiceCtrlDispatcher;
  2441. begin
  2442.   GetProcedureAddress(_StartServiceCtrlDispatcher, advapi32, 'StartServiceCtrlDispatcherA');
  2443.   asm
  2444.     mov esp, ebp
  2445.     pop ebp
  2446.     jmp [_StartServiceCtrlDispatcher]
  2447.   end;
  2448. end;
  2449. {$ELSE}
  2450. function StartServiceCtrlDispatcher; external advapi32 name 'StartServiceCtrlDispatcherA';
  2451. {$ENDIF DYNAMIC_LINK}
  2452. {$ENDIF}
  2455. {$IFDEF DYNAMIC_LINK}
  2456. var
  2457.   _StartServiceA: Pointer;
  2459. function StartServiceA;
  2460. begin
  2461.   GetProcedureAddress(_StartServiceA, advapi32, 'StartServiceA');
  2462.   asm
  2463.     mov esp, ebp
  2464.     pop ebp
  2465.     jmp [_StartServiceA]
  2466.   end;
  2467. end;
  2468. {$ELSE}
  2469. function StartServiceA; external advapi32 name 'StartServiceA';
  2470. {$ENDIF DYNAMIC_LINK}
  2472. {$IFDEF DYNAMIC_LINK}
  2473. var
  2474.   _StartServiceW: Pointer;
  2476. function StartServiceW;
  2477. begin
  2478.   GetProcedureAddress(_StartServiceW, advapi32, 'StartServiceW');
  2479.   asm
  2480.     mov esp, ebp
  2481.     pop ebp
  2482.     jmp [_StartServiceW]
  2483.   end;
  2484. end;
  2485. {$ELSE}
  2486. function StartServiceW; external advapi32 name 'StartServiceW';
  2487. {$ENDIF DYNAMIC_LINK}
  2489. {$IFDEF UNICODE}
  2491. {$IFDEF DYNAMIC_LINK}
  2492. var
  2493.   _StartService: Pointer;
  2495. function StartService;
  2496. begin
  2497.   GetProcedureAddress(_StartService, advapi32, 'StartServiceW');
  2498.   asm
  2499.     mov esp, ebp
  2500.     pop ebp
  2501.     jmp [_StartService]
  2502.   end;
  2503. end;
  2504. {$ELSE}
  2505. function StartService; external advapi32 name 'StartServiceW';
  2506. {$ENDIF DYNAMIC_LINK}
  2507. {$ELSE}
  2509. {$IFDEF DYNAMIC_LINK}
  2510. var
  2511.   _StartService: Pointer;
  2513. function StartService;
  2514. begin
  2515.   GetProcedureAddress(_StartService, advapi32, 'StartServiceA');
  2516.   asm
  2517.     mov esp, ebp
  2518.     pop ebp
  2519.     jmp [_StartService]
  2520.   end;
  2521. end;
  2522. {$ELSE}
  2523. function StartService; external advapi32 name 'StartServiceA';
  2524. {$ENDIF DYNAMIC_LINK}
  2525. {$ENDIF}
  2528. {$IFDEF DYNAMIC_LINK}
  2529. var
  2530.   _UnlockServiceDatabase: Pointer;
  2532. function UnlockServiceDatabase;
  2533. begin
  2534.   GetProcedureAddress(_UnlockServiceDatabase, advapi32, 'UnlockServiceDatabase');
  2535.   asm
  2536.     mov esp, ebp
  2537.     pop ebp
  2538.     jmp [_UnlockServiceDatabase]
  2539.   end;
  2540. end;
  2541. {$ELSE}
  2542. function UnlockServiceDatabase; external advapi32 name 'UnlockServiceDatabase';
  2543. {$ENDIF DYNAMIC_LINK}
  2545. end.