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