home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 May / PCFMay2001.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / winsvc.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  26.1 KB  |  1,007 lines
  1. /*++ BUILD Version: 0010    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1995-1998  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     winsvc.h
  8.  
  9. Abstract:
  10.  
  11.     Header file for the Service Control Manager
  12.  
  13. Environment:
  14.  
  15.     User Mode - Win32
  16.  
  17. --*/
  18. #ifndef _WINSVC_
  19. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  20. #define _WINSVC_
  21.  
  22. //
  23. // Define API decoration for direct importing of DLL references.
  24. //
  25.  
  26. #if !defined(WINADVAPI)
  27. #if !defined(_ADVAPI32_)
  28. #define WINADVAPI DECLSPEC_IMPORT
  29. #else
  30. #define WINADVAPI
  31. #endif
  32. #endif
  33.  
  34. #ifdef __cplusplus
  35. extern "C" {
  36. #endif
  37.  
  38. //
  39. // Constants
  40. //
  41.  
  42. //
  43. // Service database names
  44. //
  45.  
  46. #define SERVICES_ACTIVE_DATABASEW      L"ServicesActive"
  47. #define SERVICES_FAILED_DATABASEW      L"ServicesFailed"
  48.  
  49. #define SERVICES_ACTIVE_DATABASEA      "ServicesActive"
  50. #define SERVICES_FAILED_DATABASEA      "ServicesFailed"
  51.  
  52. //
  53. // Character to designate that a name is a group
  54. //
  55.  
  56. #define SC_GROUP_IDENTIFIERW           L'+'
  57. #define SC_GROUP_IDENTIFIERA           '+'
  58.  
  59. #ifdef UNICODE
  60.  
  61. #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEW
  62. #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEW
  63.  
  64.  
  65. #define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERW
  66.  
  67. #else // ndef UNICODE
  68.  
  69. #define SERVICES_ACTIVE_DATABASE       SERVICES_ACTIVE_DATABASEA
  70. #define SERVICES_FAILED_DATABASE       SERVICES_FAILED_DATABASEA
  71.  
  72. #define SC_GROUP_IDENTIFIER            SC_GROUP_IDENTIFIERA
  73. #endif // ndef UNICODE
  74.  
  75.  
  76. //
  77. // Value to indicate no change to an optional parameter
  78. //
  79. #define SERVICE_NO_CHANGE              0xffffffff
  80.  
  81. //
  82. // Service State -- for Enum Requests (Bit Mask)
  83. //
  84. #define SERVICE_ACTIVE                 0x00000001
  85. #define SERVICE_INACTIVE               0x00000002
  86. #define SERVICE_STATE_ALL              (SERVICE_ACTIVE   | \
  87.                                         SERVICE_INACTIVE)
  88.  
  89. //
  90. // Controls
  91. //
  92. #define SERVICE_CONTROL_STOP                   0x00000001
  93. #define SERVICE_CONTROL_PAUSE                  0x00000002
  94. #define SERVICE_CONTROL_CONTINUE               0x00000003
  95. #define SERVICE_CONTROL_INTERROGATE            0x00000004
  96. #define SERVICE_CONTROL_SHUTDOWN               0x00000005
  97. #define SERVICE_CONTROL_PARAMCHANGE            0x00000006
  98. #define SERVICE_CONTROL_NETBINDADD             0x00000007
  99. #define SERVICE_CONTROL_NETBINDREMOVE          0x00000008
  100. #define SERVICE_CONTROL_NETBINDENABLE          0x00000009
  101. #define SERVICE_CONTROL_NETBINDDISABLE         0x0000000A
  102. #define SERVICE_CONTROL_DEVICEEVENT            0x0000000B
  103. #define SERVICE_CONTROL_HARDWAREPROFILECHANGE  0x0000000C
  104. #define SERVICE_CONTROL_POWEREVENT             0x0000000D
  105.  
  106. //
  107. // Service State -- for CurrentState
  108. //
  109. #define SERVICE_STOPPED                        0x00000001
  110. #define SERVICE_START_PENDING                  0x00000002
  111. #define SERVICE_STOP_PENDING                   0x00000003
  112. #define SERVICE_RUNNING                        0x00000004
  113. #define SERVICE_CONTINUE_PENDING               0x00000005
  114. #define SERVICE_PAUSE_PENDING                  0x00000006
  115. #define SERVICE_PAUSED                         0x00000007
  116.  
  117. //
  118. // Controls Accepted  (Bit Mask)
  119. //
  120. #define SERVICE_ACCEPT_STOP                    0x00000001
  121. #define SERVICE_ACCEPT_PAUSE_CONTINUE          0x00000002
  122. #define SERVICE_ACCEPT_SHUTDOWN                0x00000004
  123. #define SERVICE_ACCEPT_PARAMCHANGE             0x00000008
  124. #define SERVICE_ACCEPT_NETBINDCHANGE           0x00000010
  125. #define SERVICE_ACCEPT_HARDWAREPROFILECHANGE   0x00000020
  126. #define SERVICE_ACCEPT_POWEREVENT              0x00000040
  127.  
  128. //
  129. // Service Control Manager object specific access types
  130. //
  131. #define SC_MANAGER_CONNECT             0x0001
  132. #define SC_MANAGER_CREATE_SERVICE      0x0002
  133. #define SC_MANAGER_ENUMERATE_SERVICE   0x0004
  134. #define SC_MANAGER_LOCK                0x0008
  135. #define SC_MANAGER_QUERY_LOCK_STATUS   0x0010
  136. #define SC_MANAGER_MODIFY_BOOT_CONFIG  0x0020
  137.  
  138. #define SC_MANAGER_ALL_ACCESS          (STANDARD_RIGHTS_REQUIRED      | \
  139.                                         SC_MANAGER_CONNECT            | \
  140.                                         SC_MANAGER_CREATE_SERVICE     | \
  141.                                         SC_MANAGER_ENUMERATE_SERVICE  | \
  142.                                         SC_MANAGER_LOCK               | \
  143.                                         SC_MANAGER_QUERY_LOCK_STATUS  | \
  144.                                         SC_MANAGER_MODIFY_BOOT_CONFIG)
  145.  
  146.  
  147.  
  148. //
  149. // Service object specific access type
  150. //
  151. #define SERVICE_QUERY_CONFIG           0x0001
  152. #define SERVICE_CHANGE_CONFIG          0x0002
  153. #define SERVICE_QUERY_STATUS           0x0004
  154. #define SERVICE_ENUMERATE_DEPENDENTS   0x0008
  155. #define SERVICE_START                  0x0010
  156. #define SERVICE_STOP                   0x0020
  157. #define SERVICE_PAUSE_CONTINUE         0x0040
  158. #define SERVICE_INTERROGATE            0x0080
  159. #define SERVICE_USER_DEFINED_CONTROL   0x0100
  160.  
  161. #define SERVICE_ALL_ACCESS             (STANDARD_RIGHTS_REQUIRED     | \
  162.                                         SERVICE_QUERY_CONFIG         | \
  163.                                         SERVICE_CHANGE_CONFIG        | \
  164.                                         SERVICE_QUERY_STATUS         | \
  165.                                         SERVICE_ENUMERATE_DEPENDENTS | \
  166.                                         SERVICE_START                | \
  167.                                         SERVICE_STOP                 | \
  168.                                         SERVICE_PAUSE_CONTINUE       | \
  169.                                         SERVICE_INTERROGATE          | \
  170.                                         SERVICE_USER_DEFINED_CONTROL)
  171.  
  172. //
  173. // Service flags for QueryServiceStatusEx
  174. //
  175. #define SERVICE_RUNS_IN_SYSTEM_PROCESS  0x00000001
  176.  
  177. //
  178. // Info levels for ChangeServiceConfig2 and QueryServiceConfig2
  179. //
  180. #define SERVICE_CONFIG_DESCRIPTION     1
  181. #define SERVICE_CONFIG_FAILURE_ACTIONS 2
  182.  
  183. //
  184. // Service description string
  185. //
  186. typedef struct _SERVICE_DESCRIPTIONA {
  187.     LPSTR       lpDescription;
  188. } SERVICE_DESCRIPTIONA, *LPSERVICE_DESCRIPTIONA;
  189. //
  190. // Service description string
  191. //
  192. typedef struct _SERVICE_DESCRIPTIONW {
  193.     LPWSTR      lpDescription;
  194. } SERVICE_DESCRIPTIONW, *LPSERVICE_DESCRIPTIONW;
  195. #ifdef UNICODE
  196. typedef SERVICE_DESCRIPTIONW SERVICE_DESCRIPTION;
  197. typedef LPSERVICE_DESCRIPTIONW LPSERVICE_DESCRIPTION;
  198. #else
  199. typedef SERVICE_DESCRIPTIONA SERVICE_DESCRIPTION;
  200. typedef LPSERVICE_DESCRIPTIONA LPSERVICE_DESCRIPTION;
  201. #endif // UNICODE
  202.  
  203. //
  204. // Actions to take on service failure
  205. //
  206. typedef enum _SC_ACTION_TYPE {
  207.         SC_ACTION_NONE          = 0,
  208.         SC_ACTION_RESTART       = 1,
  209.         SC_ACTION_REBOOT        = 2,
  210.         SC_ACTION_RUN_COMMAND   = 3
  211. } SC_ACTION_TYPE;
  212.  
  213. typedef struct _SC_ACTION {
  214.     SC_ACTION_TYPE  Type;
  215.     DWORD           Delay;
  216. } SC_ACTION, *LPSC_ACTION;
  217.  
  218. typedef struct _SERVICE_FAILURE_ACTIONSA {
  219.     DWORD       dwResetPeriod;
  220.     LPSTR       lpRebootMsg;
  221.     LPSTR       lpCommand;
  222.     DWORD       cActions;
  223. #ifdef MIDL_PASS
  224.     [size_is(cActions)]
  225. #endif
  226.     SC_ACTION * lpsaActions;
  227. } SERVICE_FAILURE_ACTIONSA, *LPSERVICE_FAILURE_ACTIONSA;
  228. typedef struct _SERVICE_FAILURE_ACTIONSW {
  229.     DWORD       dwResetPeriod;
  230.     LPWSTR      lpRebootMsg;
  231.     LPWSTR      lpCommand;
  232.     DWORD       cActions;
  233. #ifdef MIDL_PASS
  234.     [size_is(cActions)]
  235. #endif
  236.     SC_ACTION * lpsaActions;
  237. } SERVICE_FAILURE_ACTIONSW, *LPSERVICE_FAILURE_ACTIONSW;
  238. #ifdef UNICODE
  239. typedef SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONS;
  240. typedef LPSERVICE_FAILURE_ACTIONSW LPSERVICE_FAILURE_ACTIONS;
  241. #else
  242. typedef SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONS;
  243. typedef LPSERVICE_FAILURE_ACTIONSA LPSERVICE_FAILURE_ACTIONS;
  244. #endif // UNICODE
  245.  
  246.  
  247. //
  248. // Handle Types
  249. //
  250.  
  251. DECLARE_HANDLE(SC_HANDLE);
  252. typedef SC_HANDLE   *LPSC_HANDLE;
  253.  
  254. DECLARE_HANDLE(SERVICE_STATUS_HANDLE);
  255.  
  256. //
  257. // Info levels for QueryServiceStatusEx
  258. //
  259.  
  260. typedef enum _SC_STATUS_TYPE {
  261.         SC_STATUS_PROCESS_INFO      = 0
  262. } SC_STATUS_TYPE;
  263.  
  264. //
  265. // Info levels for EnumServicesStatusEx
  266. //
  267. typedef enum _SC_ENUM_TYPE {
  268.         SC_ENUM_PROCESS_INFO        = 0
  269. } SC_ENUM_TYPE;
  270.  
  271.  
  272. //
  273. // Service Status Structures
  274. //
  275.  
  276. typedef struct _SERVICE_STATUS {
  277.     DWORD   dwServiceType;
  278.     DWORD   dwCurrentState;
  279.     DWORD   dwControlsAccepted;
  280.     DWORD   dwWin32ExitCode;
  281.     DWORD   dwServiceSpecificExitCode;
  282.     DWORD   dwCheckPoint;
  283.     DWORD   dwWaitHint;
  284. } SERVICE_STATUS, *LPSERVICE_STATUS;
  285.  
  286. typedef struct _SERVICE_STATUS_PROCESS {
  287.     DWORD   dwServiceType;
  288.     DWORD   dwCurrentState;
  289.     DWORD   dwControlsAccepted;
  290.     DWORD   dwWin32ExitCode;
  291.     DWORD   dwServiceSpecificExitCode;
  292.     DWORD   dwCheckPoint;
  293.     DWORD   dwWaitHint;
  294.     DWORD   dwProcessId;
  295.     DWORD   dwServiceFlags;
  296. } SERVICE_STATUS_PROCESS, *LPSERVICE_STATUS_PROCESS;
  297.  
  298.  
  299. //
  300. // Service Status Enumeration Structure
  301. //
  302.  
  303. typedef struct _ENUM_SERVICE_STATUSA {
  304.     LPSTR             lpServiceName;
  305.     LPSTR             lpDisplayName;
  306.     SERVICE_STATUS    ServiceStatus;
  307. } ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
  308. typedef struct _ENUM_SERVICE_STATUSW {
  309.     LPWSTR            lpServiceName;
  310.     LPWSTR            lpDisplayName;
  311.     SERVICE_STATUS    ServiceStatus;
  312. } ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
  313. #ifdef UNICODE
  314. typedef ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUS;
  315. typedef LPENUM_SERVICE_STATUSW LPENUM_SERVICE_STATUS;
  316. #else
  317. typedef ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUS;
  318. typedef LPENUM_SERVICE_STATUSA LPENUM_SERVICE_STATUS;
  319. #endif // UNICODE
  320.  
  321. typedef struct _ENUM_SERVICE_STATUS_PROCESSA {
  322.     LPSTR                     lpServiceName;
  323.     LPSTR                     lpDisplayName;
  324.     SERVICE_STATUS_PROCESS    ServiceStatusProcess;
  325. } ENUM_SERVICE_STATUS_PROCESSA, *LPENUM_SERVICE_STATUS_PROCESSA;
  326. typedef struct _ENUM_SERVICE_STATUS_PROCESSW {
  327.     LPWSTR                    lpServiceName;
  328.     LPWSTR                    lpDisplayName;
  329.     SERVICE_STATUS_PROCESS    ServiceStatusProcess;
  330. } ENUM_SERVICE_STATUS_PROCESSW, *LPENUM_SERVICE_STATUS_PROCESSW;
  331. #ifdef UNICODE
  332. typedef ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESS;
  333. typedef LPENUM_SERVICE_STATUS_PROCESSW LPENUM_SERVICE_STATUS_PROCESS;
  334. #else
  335. typedef ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESS;
  336. typedef LPENUM_SERVICE_STATUS_PROCESSA LPENUM_SERVICE_STATUS_PROCESS;
  337. #endif // UNICODE
  338.  
  339. //
  340. // Structures for the Lock API functions
  341. //
  342.  
  343. typedef LPVOID  SC_LOCK;
  344.  
  345. typedef struct _QUERY_SERVICE_LOCK_STATUSA {
  346.     DWORD   fIsLocked;
  347.     LPSTR   lpLockOwner;
  348.     DWORD   dwLockDuration;
  349. } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
  350. typedef struct _QUERY_SERVICE_LOCK_STATUSW {
  351.     DWORD   fIsLocked;
  352.     LPWSTR  lpLockOwner;
  353.     DWORD   dwLockDuration;
  354. } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
  355. #ifdef UNICODE
  356. typedef QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUS;
  357. typedef LPQUERY_SERVICE_LOCK_STATUSW LPQUERY_SERVICE_LOCK_STATUS;
  358. #else
  359. typedef QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUS;
  360. typedef LPQUERY_SERVICE_LOCK_STATUSA LPQUERY_SERVICE_LOCK_STATUS;
  361. #endif // UNICODE
  362.  
  363.  
  364.  
  365. //
  366. // Query Service Configuration Structure
  367. //
  368.  
  369. typedef struct _QUERY_SERVICE_CONFIGA {
  370.     DWORD   dwServiceType;
  371.     DWORD   dwStartType;
  372.     DWORD   dwErrorControl;
  373.     LPSTR   lpBinaryPathName;
  374.     LPSTR   lpLoadOrderGroup;
  375.     DWORD   dwTagId;
  376.     LPSTR   lpDependencies;
  377.     LPSTR   lpServiceStartName;
  378.     LPSTR   lpDisplayName;
  379. } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
  380. typedef struct _QUERY_SERVICE_CONFIGW {
  381.     DWORD   dwServiceType;
  382.     DWORD   dwStartType;
  383.     DWORD   dwErrorControl;
  384.     LPWSTR  lpBinaryPathName;
  385.     LPWSTR  lpLoadOrderGroup;
  386.     DWORD   dwTagId;
  387.     LPWSTR  lpDependencies;
  388.     LPWSTR  lpServiceStartName;
  389.     LPWSTR  lpDisplayName;
  390. } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
  391. #ifdef UNICODE
  392. typedef QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIG;
  393. typedef LPQUERY_SERVICE_CONFIGW LPQUERY_SERVICE_CONFIG;
  394. #else
  395. typedef QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIG;
  396. typedef LPQUERY_SERVICE_CONFIGA LPQUERY_SERVICE_CONFIG;
  397. #endif // UNICODE
  398.  
  399.  
  400.  
  401. //
  402. // Function Prototype for the Service Main Function
  403. //
  404.  
  405. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONW)(
  406.     DWORD   dwNumServicesArgs,
  407.     LPWSTR  *lpServiceArgVectors
  408.     );
  409.  
  410. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONA)(
  411.     DWORD   dwNumServicesArgs,
  412.     LPSTR   *lpServiceArgVectors
  413.     );
  414.  
  415. #ifdef UNICODE
  416. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONW
  417. #else
  418. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONA
  419. #endif //UNICODE
  420.  
  421.  
  422. //
  423. // Service Start Table
  424. //
  425.  
  426. typedef struct _SERVICE_TABLE_ENTRYA {
  427.     LPSTR                       lpServiceName;
  428.     LPSERVICE_MAIN_FUNCTIONA    lpServiceProc;
  429. }SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
  430. typedef struct _SERVICE_TABLE_ENTRYW {
  431.     LPWSTR                      lpServiceName;
  432.     LPSERVICE_MAIN_FUNCTIONW    lpServiceProc;
  433. }SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
  434. #ifdef UNICODE
  435. typedef SERVICE_TABLE_ENTRYW SERVICE_TABLE_ENTRY;
  436. typedef LPSERVICE_TABLE_ENTRYW LPSERVICE_TABLE_ENTRY;
  437. #else
  438. typedef SERVICE_TABLE_ENTRYA SERVICE_TABLE_ENTRY;
  439. typedef LPSERVICE_TABLE_ENTRYA LPSERVICE_TABLE_ENTRY;
  440. #endif // UNICODE
  441.  
  442. //
  443. // Prototype for the Service Control Handler Function
  444. //
  445.  
  446. typedef VOID (WINAPI *LPHANDLER_FUNCTION)(
  447.     DWORD    dwControl
  448.     );
  449.  
  450. typedef DWORD (WINAPI *LPHANDLER_FUNCTION_EX)(
  451.     DWORD    dwControl,
  452.     DWORD    dwEventType,
  453.     LPVOID   lpEventData,
  454.     LPVOID   lpContext
  455.     );
  456.  
  457.  
  458. ///////////////////////////////////////////////////////////////////////////
  459. // API Function Prototypes
  460. ///////////////////////////////////////////////////////////////////////////
  461.  
  462. WINADVAPI
  463. BOOL
  464. WINAPI
  465. ChangeServiceConfigA(
  466.     SC_HANDLE    hService,
  467.     DWORD        dwServiceType,
  468.     DWORD        dwStartType,
  469.     DWORD        dwErrorControl,
  470.     LPCSTR     lpBinaryPathName,
  471.     LPCSTR     lpLoadOrderGroup,
  472.     LPDWORD      lpdwTagId,
  473.     LPCSTR     lpDependencies,
  474.     LPCSTR     lpServiceStartName,
  475.     LPCSTR     lpPassword,
  476.     LPCSTR     lpDisplayName
  477.     );
  478. WINADVAPI
  479. BOOL
  480. WINAPI
  481. ChangeServiceConfigW(
  482.     SC_HANDLE    hService,
  483.     DWORD        dwServiceType,
  484.     DWORD        dwStartType,
  485.     DWORD        dwErrorControl,
  486.     LPCWSTR     lpBinaryPathName,
  487.     LPCWSTR     lpLoadOrderGroup,
  488.     LPDWORD      lpdwTagId,
  489.     LPCWSTR     lpDependencies,
  490.     LPCWSTR     lpServiceStartName,
  491.     LPCWSTR     lpPassword,
  492.     LPCWSTR     lpDisplayName
  493.     );
  494. #ifdef UNICODE
  495. #define ChangeServiceConfig  ChangeServiceConfigW
  496. #else
  497. #define ChangeServiceConfig  ChangeServiceConfigA
  498. #endif // !UNICODE
  499.  
  500. WINADVAPI
  501. BOOL
  502. WINAPI
  503. ChangeServiceConfig2A(
  504.     SC_HANDLE    hService,
  505.     DWORD        dwInfoLevel,
  506.     LPVOID       lpInfo
  507.     );
  508. WINADVAPI
  509. BOOL
  510. WINAPI
  511. ChangeServiceConfig2W(
  512.     SC_HANDLE    hService,
  513.     DWORD        dwInfoLevel,
  514.     LPVOID       lpInfo
  515.     );
  516. #ifdef UNICODE
  517. #define ChangeServiceConfig2  ChangeServiceConfig2W
  518. #else
  519. #define ChangeServiceConfig2  ChangeServiceConfig2A
  520. #endif // !UNICODE
  521.  
  522. WINADVAPI
  523. BOOL
  524. WINAPI
  525. CloseServiceHandle(
  526.     SC_HANDLE   hSCObject
  527.     );
  528.  
  529. WINADVAPI
  530. BOOL
  531. WINAPI
  532. ControlService(
  533.     SC_HANDLE           hService,
  534.     DWORD               dwControl,
  535.     LPSERVICE_STATUS    lpServiceStatus
  536.     );
  537.  
  538. WINADVAPI
  539. SC_HANDLE
  540. WINAPI
  541. CreateServiceA(
  542.     SC_HANDLE    hSCManager,
  543.     LPCSTR     lpServiceName,
  544.     LPCSTR     lpDisplayName,
  545.     DWORD        dwDesiredAccess,
  546.     DWORD        dwServiceType,
  547.     DWORD        dwStartType,
  548.     DWORD        dwErrorControl,
  549.     LPCSTR     lpBinaryPathName,
  550.     LPCSTR     lpLoadOrderGroup,
  551.     LPDWORD      lpdwTagId,
  552.     LPCSTR     lpDependencies,
  553.     LPCSTR     lpServiceStartName,
  554.     LPCSTR     lpPassword
  555.     );
  556. WINADVAPI
  557. SC_HANDLE
  558. WINAPI
  559. CreateServiceW(
  560.     SC_HANDLE    hSCManager,
  561.     LPCWSTR     lpServiceName,
  562.     LPCWSTR     lpDisplayName,
  563.     DWORD        dwDesiredAccess,
  564.     DWORD        dwServiceType,
  565.     DWORD        dwStartType,
  566.     DWORD        dwErrorControl,
  567.     LPCWSTR     lpBinaryPathName,
  568.     LPCWSTR     lpLoadOrderGroup,
  569.     LPDWORD      lpdwTagId,
  570.     LPCWSTR     lpDependencies,
  571.     LPCWSTR     lpServiceStartName,
  572.     LPCWSTR     lpPassword
  573.     );
  574. #ifdef UNICODE
  575. #define CreateService  CreateServiceW
  576. #else
  577. #define CreateService  CreateServiceA
  578. #endif // !UNICODE
  579.  
  580. WINADVAPI
  581. BOOL
  582. WINAPI
  583. DeleteService(
  584.     SC_HANDLE   hService
  585.     );
  586.  
  587. WINADVAPI
  588. BOOL
  589. WINAPI
  590. EnumDependentServicesA(
  591.     SC_HANDLE               hService,
  592.     DWORD                   dwServiceState,
  593.     LPENUM_SERVICE_STATUSA  lpServices,
  594.     DWORD                   cbBufSize,
  595.     LPDWORD                 pcbBytesNeeded,
  596.     LPDWORD                 lpServicesReturned
  597.     );
  598. WINADVAPI
  599. BOOL
  600. WINAPI
  601. EnumDependentServicesW(
  602.     SC_HANDLE               hService,
  603.     DWORD                   dwServiceState,
  604.     LPENUM_SERVICE_STATUSW  lpServices,
  605.     DWORD                   cbBufSize,
  606.     LPDWORD                 pcbBytesNeeded,
  607.     LPDWORD                 lpServicesReturned
  608.     );
  609. #ifdef UNICODE
  610. #define EnumDependentServices  EnumDependentServicesW
  611. #else
  612. #define EnumDependentServices  EnumDependentServicesA
  613. #endif // !UNICODE
  614.  
  615. WINADVAPI
  616. BOOL
  617. WINAPI
  618. EnumServicesStatusA(
  619.     SC_HANDLE               hSCManager,
  620.     DWORD                   dwServiceType,
  621.     DWORD                   dwServiceState,
  622.     LPENUM_SERVICE_STATUSA  lpServices,
  623.     DWORD                   cbBufSize,
  624.     LPDWORD                 pcbBytesNeeded,
  625.     LPDWORD                 lpServicesReturned,
  626.     LPDWORD                 lpResumeHandle
  627.     );
  628. WINADVAPI
  629. BOOL
  630. WINAPI
  631. EnumServicesStatusW(
  632.     SC_HANDLE               hSCManager,
  633.     DWORD                   dwServiceType,
  634.     DWORD                   dwServiceState,
  635.     LPENUM_SERVICE_STATUSW  lpServices,
  636.     DWORD                   cbBufSize,
  637.     LPDWORD                 pcbBytesNeeded,
  638.     LPDWORD                 lpServicesReturned,
  639.     LPDWORD                 lpResumeHandle
  640.     );
  641. #ifdef UNICODE
  642. #define EnumServicesStatus  EnumServicesStatusW
  643. #else
  644. #define EnumServicesStatus  EnumServicesStatusA
  645. #endif // !UNICODE
  646.  
  647. WINADVAPI
  648. BOOL
  649. WINAPI
  650. EnumServicesStatusExA(
  651.     SC_HANDLE                  hSCManager,
  652.     SC_ENUM_TYPE               InfoLevel,
  653.     DWORD                      dwServiceType,
  654.     DWORD                      dwServiceState,
  655.     LPBYTE                     lpServices,
  656.     DWORD                      cbBufSize,
  657.     LPDWORD                    pcbBytesNeeded,
  658.     LPDWORD                    lpServicesReturned,
  659.     LPDWORD                    lpResumeHandle,
  660.     LPCSTR                   pszGroupName
  661.     );
  662. WINADVAPI
  663. BOOL
  664. WINAPI
  665. EnumServicesStatusExW(
  666.     SC_HANDLE                  hSCManager,
  667.     SC_ENUM_TYPE               InfoLevel,
  668.     DWORD                      dwServiceType,
  669.     DWORD                      dwServiceState,
  670.     LPBYTE                     lpServices,
  671.     DWORD                      cbBufSize,
  672.     LPDWORD                    pcbBytesNeeded,
  673.     LPDWORD                    lpServicesReturned,
  674.     LPDWORD                    lpResumeHandle,
  675.     LPCWSTR                   pszGroupName
  676.     );
  677. #ifdef UNICODE
  678. #define EnumServicesStatusEx  EnumServicesStatusExW
  679. #else
  680. #define EnumServicesStatusEx  EnumServicesStatusExA
  681. #endif // !UNICODE
  682.  
  683. WINADVAPI
  684. BOOL
  685. WINAPI
  686. GetServiceKeyNameA(
  687.     SC_HANDLE               hSCManager,
  688.     LPCSTR                lpDisplayName,
  689.     LPSTR                 lpServiceName,
  690.     LPDWORD                 lpcchBuffer
  691.     );
  692. WINADVAPI
  693. BOOL
  694. WINAPI
  695. GetServiceKeyNameW(
  696.     SC_HANDLE               hSCManager,
  697.     LPCWSTR                lpDisplayName,
  698.     LPWSTR                 lpServiceName,
  699.     LPDWORD                 lpcchBuffer
  700.     );
  701. #ifdef UNICODE
  702. #define GetServiceKeyName  GetServiceKeyNameW
  703. #else
  704. #define GetServiceKeyName  GetServiceKeyNameA
  705. #endif // !UNICODE
  706.  
  707. WINADVAPI
  708. BOOL
  709. WINAPI
  710. GetServiceDisplayNameA(
  711.     SC_HANDLE               hSCManager,
  712.     LPCSTR                lpServiceName,
  713.     LPSTR                 lpDisplayName,
  714.     LPDWORD                 lpcchBuffer
  715.     );
  716. WINADVAPI
  717. BOOL
  718. WINAPI
  719. GetServiceDisplayNameW(
  720.     SC_HANDLE               hSCManager,
  721.     LPCWSTR                lpServiceName,
  722.     LPWSTR                 lpDisplayName,
  723.     LPDWORD                 lpcchBuffer
  724.     );
  725. #ifdef UNICODE
  726. #define GetServiceDisplayName  GetServiceDisplayNameW
  727. #else
  728. #define GetServiceDisplayName  GetServiceDisplayNameA
  729. #endif // !UNICODE
  730.  
  731. WINADVAPI
  732. SC_LOCK
  733. WINAPI
  734. LockServiceDatabase(
  735.     SC_HANDLE   hSCManager
  736.     );
  737.  
  738. WINADVAPI
  739. BOOL
  740. WINAPI
  741. NotifyBootConfigStatus(
  742.     BOOL     BootAcceptable
  743.     );
  744.  
  745. WINADVAPI
  746. SC_HANDLE
  747. WINAPI
  748. OpenSCManagerA(
  749.     LPCSTR lpMachineName,
  750.     LPCSTR lpDatabaseName,
  751.     DWORD   dwDesiredAccess
  752.     );
  753. WINADVAPI
  754. SC_HANDLE
  755. WINAPI
  756. OpenSCManagerW(
  757.     LPCWSTR lpMachineName,
  758.     LPCWSTR lpDatabaseName,
  759.     DWORD   dwDesiredAccess
  760.     );
  761. #ifdef UNICODE
  762. #define OpenSCManager  OpenSCManagerW
  763. #else
  764. #define OpenSCManager  OpenSCManagerA
  765. #endif // !UNICODE
  766.  
  767. WINADVAPI
  768. SC_HANDLE
  769. WINAPI
  770. OpenServiceA(
  771.     SC_HANDLE   hSCManager,
  772.     LPCSTR    lpServiceName,
  773.     DWORD       dwDesiredAccess
  774.     );
  775. WINADVAPI
  776. SC_HANDLE
  777. WINAPI
  778. OpenServiceW(
  779.     SC_HANDLE   hSCManager,
  780.     LPCWSTR    lpServiceName,
  781.     DWORD       dwDesiredAccess
  782.     );
  783. #ifdef UNICODE
  784. #define OpenService  OpenServiceW
  785. #else
  786. #define OpenService  OpenServiceA
  787. #endif // !UNICODE
  788.  
  789. WINADVAPI
  790. BOOL
  791. WINAPI
  792. QueryServiceConfigA(
  793.     SC_HANDLE               hService,
  794.     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
  795.     DWORD                   cbBufSize,
  796.     LPDWORD                 pcbBytesNeeded
  797.     );
  798. WINADVAPI
  799. BOOL
  800. WINAPI
  801. QueryServiceConfigW(
  802.     SC_HANDLE               hService,
  803.     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
  804.     DWORD                   cbBufSize,
  805.     LPDWORD                 pcbBytesNeeded
  806.     );
  807. #ifdef UNICODE
  808. #define QueryServiceConfig  QueryServiceConfigW
  809. #else
  810. #define QueryServiceConfig  QueryServiceConfigA
  811. #endif // !UNICODE
  812.  
  813. WINADVAPI
  814. BOOL
  815. WINAPI
  816. QueryServiceConfig2A(
  817.     SC_HANDLE   hService,
  818.     DWORD       dwInfoLevel,
  819.     LPBYTE      lpBuffer,
  820.     DWORD       cbBufSize,
  821.     LPDWORD     pcbBytesNeeded
  822.     );
  823. WINADVAPI
  824. BOOL
  825. WINAPI
  826. QueryServiceConfig2W(
  827.     SC_HANDLE   hService,
  828.     DWORD       dwInfoLevel,
  829.     LPBYTE      lpBuffer,
  830.     DWORD       cbBufSize,
  831.     LPDWORD     pcbBytesNeeded
  832.     );
  833. #ifdef UNICODE
  834. #define QueryServiceConfig2  QueryServiceConfig2W
  835. #else
  836. #define QueryServiceConfig2  QueryServiceConfig2A
  837. #endif // !UNICODE
  838.  
  839. WINADVAPI
  840. BOOL
  841. WINAPI
  842. QueryServiceLockStatusA(
  843.     SC_HANDLE                       hSCManager,
  844.     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
  845.     DWORD                           cbBufSize,
  846.     LPDWORD                         pcbBytesNeeded
  847.     );
  848. WINADVAPI
  849. BOOL
  850. WINAPI
  851. QueryServiceLockStatusW(
  852.     SC_HANDLE                       hSCManager,
  853.     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
  854.     DWORD                           cbBufSize,
  855.     LPDWORD                         pcbBytesNeeded
  856.     );
  857. #ifdef UNICODE
  858. #define QueryServiceLockStatus  QueryServiceLockStatusW
  859. #else
  860. #define QueryServiceLockStatus  QueryServiceLockStatusA
  861. #endif // !UNICODE
  862.  
  863. WINADVAPI
  864. BOOL
  865. WINAPI
  866. QueryServiceObjectSecurity(
  867.     SC_HANDLE               hService,
  868.     SECURITY_INFORMATION    dwSecurityInformation,
  869.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
  870.     DWORD                   cbBufSize,
  871.     LPDWORD                 pcbBytesNeeded
  872.     );
  873.  
  874. WINADVAPI
  875. BOOL
  876. WINAPI
  877. QueryServiceStatus(
  878.     SC_HANDLE           hService,
  879.     LPSERVICE_STATUS    lpServiceStatus
  880.     );
  881.  
  882. WINADVAPI
  883. BOOL
  884. WINAPI
  885. QueryServiceStatusEx(
  886.     SC_HANDLE           hService,
  887.     SC_STATUS_TYPE      InfoLevel,
  888.     LPBYTE              lpBuffer,
  889.     DWORD               cbBufSize,
  890.     LPDWORD             pcbBytesNeeded
  891.     );
  892.  
  893. WINADVAPI
  894. SERVICE_STATUS_HANDLE
  895. WINAPI
  896. RegisterServiceCtrlHandlerA(
  897.     LPCSTR             lpServiceName,
  898.     LPHANDLER_FUNCTION   lpHandlerProc
  899.     );
  900. WINADVAPI
  901. SERVICE_STATUS_HANDLE
  902. WINAPI
  903. RegisterServiceCtrlHandlerW(
  904.     LPCWSTR             lpServiceName,
  905.     LPHANDLER_FUNCTION   lpHandlerProc
  906.     );
  907. #ifdef UNICODE
  908. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerW
  909. #else
  910. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerA
  911. #endif // !UNICODE
  912.  
  913. WINADVAPI
  914. SERVICE_STATUS_HANDLE
  915. WINAPI
  916. RegisterServiceCtrlHandlerExA(
  917.     LPCSTR                lpServiceName,
  918.     LPHANDLER_FUNCTION_EX   lpHandlerProc,
  919.     LPVOID                  lpContext
  920.     );
  921. WINADVAPI
  922. SERVICE_STATUS_HANDLE
  923. WINAPI
  924. RegisterServiceCtrlHandlerExW(
  925.     LPCWSTR                lpServiceName,
  926.     LPHANDLER_FUNCTION_EX   lpHandlerProc,
  927.     LPVOID                  lpContext
  928.     );
  929. #ifdef UNICODE
  930. #define RegisterServiceCtrlHandlerEx  RegisterServiceCtrlHandlerExW
  931. #else
  932. #define RegisterServiceCtrlHandlerEx  RegisterServiceCtrlHandlerExA
  933. #endif // !UNICODE
  934.  
  935. WINADVAPI
  936. BOOL
  937. WINAPI
  938. SetServiceObjectSecurity(
  939.     SC_HANDLE               hService,
  940.     SECURITY_INFORMATION    dwSecurityInformation,
  941.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor
  942.     );
  943.  
  944. WINADVAPI
  945. BOOL
  946. WINAPI
  947. SetServiceStatus(
  948.     SERVICE_STATUS_HANDLE   hServiceStatus,
  949.     LPSERVICE_STATUS        lpServiceStatus
  950.     );
  951.  
  952. WINADVAPI
  953. BOOL
  954. WINAPI
  955. StartServiceCtrlDispatcherA(
  956.     CONST SERVICE_TABLE_ENTRYA *lpServiceStartTable
  957.     );
  958. WINADVAPI
  959. BOOL
  960. WINAPI
  961. StartServiceCtrlDispatcherW(
  962.     CONST SERVICE_TABLE_ENTRYW *lpServiceStartTable
  963.     );
  964. #ifdef UNICODE
  965. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherW
  966. #else
  967. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherA
  968. #endif // !UNICODE
  969.  
  970.  
  971. WINADVAPI
  972. BOOL
  973. WINAPI
  974. StartServiceA(
  975.     SC_HANDLE            hService,
  976.     DWORD                dwNumServiceArgs,
  977.     LPCSTR             *lpServiceArgVectors
  978.     );
  979. WINADVAPI
  980. BOOL
  981. WINAPI
  982. StartServiceW(
  983.     SC_HANDLE            hService,
  984.     DWORD                dwNumServiceArgs,
  985.     LPCWSTR             *lpServiceArgVectors
  986.     );
  987. #ifdef UNICODE
  988. #define StartService  StartServiceW
  989. #else
  990. #define StartService  StartServiceA
  991. #endif // !UNICODE
  992.  
  993. WINADVAPI
  994. BOOL
  995. WINAPI
  996. UnlockServiceDatabase(
  997.     SC_LOCK     ScLock
  998.     );
  999.  
  1000.  
  1001. #ifdef __cplusplus
  1002. }
  1003. #endif
  1004.  
  1005. #pragma option pop /*P_O_Pop*/
  1006. #endif // _WINSVC_
  1007.