home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / msinc.pak / WINSVC.H < prev    next >
C/C++ Source or Header  |  1997-07-23  |  19KB  |  752 lines
  1. /*++ BUILD Version: 0010    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1995  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.  
  97. //
  98. // Service State -- for CurrentState
  99. //
  100. #define SERVICE_STOPPED                0x00000001
  101. #define SERVICE_START_PENDING          0x00000002
  102. #define SERVICE_STOP_PENDING           0x00000003
  103. #define SERVICE_RUNNING                0x00000004
  104. #define SERVICE_CONTINUE_PENDING       0x00000005
  105. #define SERVICE_PAUSE_PENDING          0x00000006
  106. #define SERVICE_PAUSED                 0x00000007
  107.  
  108. //
  109. // Controls Accepted  (Bit Mask)
  110. //
  111. #define SERVICE_ACCEPT_STOP            0x00000001
  112. #define SERVICE_ACCEPT_PAUSE_CONTINUE  0x00000002
  113. #define SERVICE_ACCEPT_SHUTDOWN        0x00000004
  114.  
  115. //
  116. // Service Control Manager object specific access types
  117. //
  118. #define SC_MANAGER_CONNECT             0x0001
  119. #define SC_MANAGER_CREATE_SERVICE      0x0002
  120. #define SC_MANAGER_ENUMERATE_SERVICE   0x0004
  121. #define SC_MANAGER_LOCK                0x0008
  122. #define SC_MANAGER_QUERY_LOCK_STATUS   0x0010
  123. #define SC_MANAGER_MODIFY_BOOT_CONFIG  0x0020
  124.  
  125. #define SC_MANAGER_ALL_ACCESS          (STANDARD_RIGHTS_REQUIRED      | \
  126.                                         SC_MANAGER_CONNECT            | \
  127.                                         SC_MANAGER_CREATE_SERVICE     | \
  128.                                         SC_MANAGER_ENUMERATE_SERVICE  | \
  129.                                         SC_MANAGER_LOCK               | \
  130.                                         SC_MANAGER_QUERY_LOCK_STATUS  | \
  131.                                         SC_MANAGER_MODIFY_BOOT_CONFIG)
  132.  
  133.  
  134.  
  135. //
  136. // Service object specific access type
  137. //
  138. #define SERVICE_QUERY_CONFIG           0x0001
  139. #define SERVICE_CHANGE_CONFIG          0x0002
  140. #define SERVICE_QUERY_STATUS           0x0004
  141. #define SERVICE_ENUMERATE_DEPENDENTS   0x0008
  142. #define SERVICE_START                  0x0010
  143. #define SERVICE_STOP                   0x0020
  144. #define SERVICE_PAUSE_CONTINUE         0x0040
  145. #define SERVICE_INTERROGATE            0x0080
  146. #define SERVICE_USER_DEFINED_CONTROL   0x0100
  147.  
  148. #define SERVICE_ALL_ACCESS             (STANDARD_RIGHTS_REQUIRED     | \
  149.                                         SERVICE_QUERY_CONFIG         | \
  150.                                         SERVICE_CHANGE_CONFIG        | \
  151.                                         SERVICE_QUERY_STATUS         | \
  152.                                         SERVICE_ENUMERATE_DEPENDENTS | \
  153.                                         SERVICE_START                | \
  154.                                         SERVICE_STOP                 | \
  155.                                         SERVICE_PAUSE_CONTINUE       | \
  156.                                         SERVICE_INTERROGATE          | \
  157.                                         SERVICE_USER_DEFINED_CONTROL)
  158.  
  159.  
  160. //
  161. // Handle Types
  162. //
  163.  
  164. typedef HANDLE      SC_HANDLE;
  165. typedef SC_HANDLE   *LPSC_HANDLE;
  166.  
  167. typedef DWORD       SERVICE_STATUS_HANDLE;
  168.  
  169. //
  170. // Service Status Structure
  171. //
  172.  
  173. typedef struct _SERVICE_STATUS {
  174.     DWORD   dwServiceType;
  175.     DWORD   dwCurrentState;
  176.     DWORD   dwControlsAccepted;
  177.     DWORD   dwWin32ExitCode;
  178.     DWORD   dwServiceSpecificExitCode;
  179.     DWORD   dwCheckPoint;
  180.     DWORD   dwWaitHint;
  181. } SERVICE_STATUS, *LPSERVICE_STATUS;
  182.  
  183.  
  184.  
  185. //
  186. // Service Status Enumeration Structure
  187. //
  188.  
  189. typedef struct _ENUM_SERVICE_STATUSA {
  190.     LPSTR          lpServiceName;
  191.     LPSTR          lpDisplayName;
  192.     SERVICE_STATUS ServiceStatus;
  193. } ENUM_SERVICE_STATUSA, *LPENUM_SERVICE_STATUSA;
  194. typedef struct _ENUM_SERVICE_STATUSW {
  195.     LPWSTR         lpServiceName;
  196.     LPWSTR         lpDisplayName;
  197.     SERVICE_STATUS ServiceStatus;
  198. } ENUM_SERVICE_STATUSW, *LPENUM_SERVICE_STATUSW;
  199. #ifdef UNICODE
  200. typedef ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUS;
  201. typedef LPENUM_SERVICE_STATUSW LPENUM_SERVICE_STATUS;
  202. #else
  203. typedef ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUS;
  204. typedef LPENUM_SERVICE_STATUSA LPENUM_SERVICE_STATUS;
  205. #endif // UNICODE
  206.  
  207.  
  208. //
  209. // Structures for the Lock API functions
  210. //
  211.  
  212. typedef LPVOID  SC_LOCK;
  213.  
  214. typedef struct _QUERY_SERVICE_LOCK_STATUSA {
  215.     DWORD   fIsLocked;
  216.     LPSTR   lpLockOwner;
  217.     DWORD   dwLockDuration;
  218. } QUERY_SERVICE_LOCK_STATUSA, *LPQUERY_SERVICE_LOCK_STATUSA;
  219. typedef struct _QUERY_SERVICE_LOCK_STATUSW {
  220.     DWORD   fIsLocked;
  221.     LPWSTR  lpLockOwner;
  222.     DWORD   dwLockDuration;
  223. } QUERY_SERVICE_LOCK_STATUSW, *LPQUERY_SERVICE_LOCK_STATUSW;
  224. #ifdef UNICODE
  225. typedef QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUS;
  226. typedef LPQUERY_SERVICE_LOCK_STATUSW LPQUERY_SERVICE_LOCK_STATUS;
  227. #else
  228. typedef QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUS;
  229. typedef LPQUERY_SERVICE_LOCK_STATUSA LPQUERY_SERVICE_LOCK_STATUS;
  230. #endif // UNICODE
  231.  
  232.  
  233.  
  234. //
  235. // Query Service Configuration Structure
  236. //
  237.  
  238. typedef struct _QUERY_SERVICE_CONFIGA {
  239.     DWORD   dwServiceType;
  240.     DWORD   dwStartType;
  241.     DWORD   dwErrorControl;
  242.     LPSTR   lpBinaryPathName;
  243.     LPSTR   lpLoadOrderGroup;
  244.     DWORD   dwTagId;
  245.     LPSTR   lpDependencies;
  246.     LPSTR   lpServiceStartName;
  247.     LPSTR   lpDisplayName;
  248. } QUERY_SERVICE_CONFIGA, *LPQUERY_SERVICE_CONFIGA;
  249. typedef struct _QUERY_SERVICE_CONFIGW {
  250.     DWORD   dwServiceType;
  251.     DWORD   dwStartType;
  252.     DWORD   dwErrorControl;
  253.     LPWSTR  lpBinaryPathName;
  254.     LPWSTR  lpLoadOrderGroup;
  255.     DWORD   dwTagId;
  256.     LPWSTR  lpDependencies;
  257.     LPWSTR  lpServiceStartName;
  258.     LPWSTR  lpDisplayName;
  259. } QUERY_SERVICE_CONFIGW, *LPQUERY_SERVICE_CONFIGW;
  260. #ifdef UNICODE
  261. typedef QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIG;
  262. typedef LPQUERY_SERVICE_CONFIGW LPQUERY_SERVICE_CONFIG;
  263. #else
  264. typedef QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIG;
  265. typedef LPQUERY_SERVICE_CONFIGA LPQUERY_SERVICE_CONFIG;
  266. #endif // UNICODE
  267.  
  268.  
  269.  
  270. //
  271. // Function Prototype for the Service Main Function
  272. //
  273.  
  274. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONW)(
  275.     DWORD   dwNumServicesArgs,
  276.     LPWSTR  *lpServiceArgVectors
  277.     );
  278.  
  279. typedef VOID (WINAPI *LPSERVICE_MAIN_FUNCTIONA)(
  280.     DWORD   dwNumServicesArgs,
  281.     LPSTR   *lpServiceArgVectors
  282.     );
  283.  
  284. #ifdef UNICODE
  285. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONW
  286. #else
  287. #define LPSERVICE_MAIN_FUNCTION LPSERVICE_MAIN_FUNCTIONA
  288. #endif //UNICODE
  289.  
  290.  
  291. //
  292. // Service Start Table
  293. //
  294.  
  295. typedef struct _SERVICE_TABLE_ENTRYA {
  296.     LPSTR                       lpServiceName;
  297.     LPSERVICE_MAIN_FUNCTIONA    lpServiceProc;
  298. }SERVICE_TABLE_ENTRYA, *LPSERVICE_TABLE_ENTRYA;
  299. typedef struct _SERVICE_TABLE_ENTRYW {
  300.     LPWSTR                      lpServiceName;
  301.     LPSERVICE_MAIN_FUNCTIONW    lpServiceProc;
  302. }SERVICE_TABLE_ENTRYW, *LPSERVICE_TABLE_ENTRYW;
  303. #ifdef UNICODE
  304. typedef SERVICE_TABLE_ENTRYW SERVICE_TABLE_ENTRY;
  305. typedef LPSERVICE_TABLE_ENTRYW LPSERVICE_TABLE_ENTRY;
  306. #else
  307. typedef SERVICE_TABLE_ENTRYA SERVICE_TABLE_ENTRY;
  308. typedef LPSERVICE_TABLE_ENTRYA LPSERVICE_TABLE_ENTRY;
  309. #endif // UNICODE
  310.  
  311. //
  312. // Prototype for the Service Control Handler Function
  313. //
  314.  
  315. typedef VOID (WINAPI *LPHANDLER_FUNCTION)(
  316.     DWORD    dwControl
  317.     );
  318.  
  319.  
  320.  
  321. ///////////////////////////////////////////////////////////////////////////
  322. // API Function Prototypes
  323. ///////////////////////////////////////////////////////////////////////////
  324.  
  325. WINADVAPI
  326. BOOL
  327. WINAPI
  328. ChangeServiceConfigA(
  329.     SC_HANDLE    hService,
  330.     DWORD        dwServiceType,
  331.     DWORD        dwStartType,
  332.     DWORD        dwErrorControl,
  333.     LPCSTR     lpBinaryPathName,
  334.     LPCSTR     lpLoadOrderGroup,
  335.     LPDWORD      lpdwTagId,
  336.     LPCSTR     lpDependencies,
  337.     LPCSTR     lpServiceStartName,
  338.     LPCSTR     lpPassword,
  339.     LPCSTR     lpDisplayName
  340.     );
  341. WINADVAPI
  342. BOOL
  343. WINAPI
  344. ChangeServiceConfigW(
  345.     SC_HANDLE    hService,
  346.     DWORD        dwServiceType,
  347.     DWORD        dwStartType,
  348.     DWORD        dwErrorControl,
  349.     LPCWSTR     lpBinaryPathName,
  350.     LPCWSTR     lpLoadOrderGroup,
  351.     LPDWORD      lpdwTagId,
  352.     LPCWSTR     lpDependencies,
  353.     LPCWSTR     lpServiceStartName,
  354.     LPCWSTR     lpPassword,
  355.     LPCWSTR     lpDisplayName
  356.     );
  357. #ifdef UNICODE
  358. #define ChangeServiceConfig  ChangeServiceConfigW
  359. #else
  360. #define ChangeServiceConfig  ChangeServiceConfigA
  361. #endif // !UNICODE
  362.  
  363. WINADVAPI
  364. BOOL
  365. WINAPI
  366. CloseServiceHandle(
  367.     SC_HANDLE   hSCObject
  368.     );
  369.  
  370. WINADVAPI
  371. BOOL
  372. WINAPI
  373. ControlService(
  374.     SC_HANDLE           hService,
  375.     DWORD               dwControl,
  376.     LPSERVICE_STATUS    lpServiceStatus
  377.     );
  378.  
  379. WINADVAPI
  380. SC_HANDLE
  381. WINAPI
  382. CreateServiceA(
  383.     SC_HANDLE    hSCManager,
  384.     LPCSTR     lpServiceName,
  385.     LPCSTR     lpDisplayName,
  386.     DWORD        dwDesiredAccess,
  387.     DWORD        dwServiceType,
  388.     DWORD        dwStartType,
  389.     DWORD        dwErrorControl,
  390.     LPCSTR     lpBinaryPathName,
  391.     LPCSTR     lpLoadOrderGroup,
  392.     LPDWORD      lpdwTagId,
  393.     LPCSTR     lpDependencies,
  394.     LPCSTR     lpServiceStartName,
  395.     LPCSTR     lpPassword
  396.     );
  397. WINADVAPI
  398. SC_HANDLE
  399. WINAPI
  400. CreateServiceW(
  401.     SC_HANDLE    hSCManager,
  402.     LPCWSTR     lpServiceName,
  403.     LPCWSTR     lpDisplayName,
  404.     DWORD        dwDesiredAccess,
  405.     DWORD        dwServiceType,
  406.     DWORD        dwStartType,
  407.     DWORD        dwErrorControl,
  408.     LPCWSTR     lpBinaryPathName,
  409.     LPCWSTR     lpLoadOrderGroup,
  410.     LPDWORD      lpdwTagId,
  411.     LPCWSTR     lpDependencies,
  412.     LPCWSTR     lpServiceStartName,
  413.     LPCWSTR     lpPassword
  414.     );
  415. #ifdef UNICODE
  416. #define CreateService  CreateServiceW
  417. #else
  418. #define CreateService  CreateServiceA
  419. #endif // !UNICODE
  420.  
  421. WINADVAPI
  422. BOOL
  423. WINAPI
  424. DeleteService(
  425.     SC_HANDLE   hService
  426.     );
  427.  
  428. WINADVAPI
  429. BOOL
  430. WINAPI
  431. EnumDependentServicesA(
  432.     SC_HANDLE               hService,
  433.     DWORD                   dwServiceState,
  434.     LPENUM_SERVICE_STATUSA  lpServices,
  435.     DWORD                   cbBufSize,
  436.     LPDWORD                 pcbBytesNeeded,
  437.     LPDWORD                 lpServicesReturned
  438.     );
  439. WINADVAPI
  440. BOOL
  441. WINAPI
  442. EnumDependentServicesW(
  443.     SC_HANDLE               hService,
  444.     DWORD                   dwServiceState,
  445.     LPENUM_SERVICE_STATUSW  lpServices,
  446.     DWORD                   cbBufSize,
  447.     LPDWORD                 pcbBytesNeeded,
  448.     LPDWORD                 lpServicesReturned
  449.     );
  450. #ifdef UNICODE
  451. #define EnumDependentServices  EnumDependentServicesW
  452. #else
  453. #define EnumDependentServices  EnumDependentServicesA
  454. #endif // !UNICODE
  455.  
  456. WINADVAPI
  457. BOOL
  458. WINAPI
  459. EnumServicesStatusA(
  460.     SC_HANDLE               hSCManager,
  461.     DWORD                   dwServiceType,
  462.     DWORD                   dwServiceState,
  463.     LPENUM_SERVICE_STATUSA  lpServices,
  464.     DWORD                   cbBufSize,
  465.     LPDWORD                 pcbBytesNeeded,
  466.     LPDWORD                 lpServicesReturned,
  467.     LPDWORD                 lpResumeHandle
  468.     );
  469. WINADVAPI
  470. BOOL
  471. WINAPI
  472. EnumServicesStatusW(
  473.     SC_HANDLE               hSCManager,
  474.     DWORD                   dwServiceType,
  475.     DWORD                   dwServiceState,
  476.     LPENUM_SERVICE_STATUSW  lpServices,
  477.     DWORD                   cbBufSize,
  478.     LPDWORD                 pcbBytesNeeded,
  479.     LPDWORD                 lpServicesReturned,
  480.     LPDWORD                 lpResumeHandle
  481.     );
  482. #ifdef UNICODE
  483. #define EnumServicesStatus  EnumServicesStatusW
  484. #else
  485. #define EnumServicesStatus  EnumServicesStatusA
  486. #endif // !UNICODE
  487.  
  488. WINADVAPI
  489. BOOL
  490. WINAPI
  491. GetServiceKeyNameA(
  492.     SC_HANDLE               hSCManager,
  493.     LPCSTR                lpDisplayName,
  494.     LPSTR                 lpServiceName,
  495.     LPDWORD                 lpcchBuffer
  496.     );
  497. WINADVAPI
  498. BOOL
  499. WINAPI
  500. GetServiceKeyNameW(
  501.     SC_HANDLE               hSCManager,
  502.     LPCWSTR                lpDisplayName,
  503.     LPWSTR                 lpServiceName,
  504.     LPDWORD                 lpcchBuffer
  505.     );
  506. #ifdef UNICODE
  507. #define GetServiceKeyName  GetServiceKeyNameW
  508. #else
  509. #define GetServiceKeyName  GetServiceKeyNameA
  510. #endif // !UNICODE
  511.  
  512. WINADVAPI
  513. BOOL
  514. WINAPI
  515. GetServiceDisplayNameA(
  516.     SC_HANDLE               hSCManager,
  517.     LPCSTR                lpServiceName,
  518.     LPSTR                 lpDisplayName,
  519.     LPDWORD                 lpcchBuffer
  520.     );
  521. WINADVAPI
  522. BOOL
  523. WINAPI
  524. GetServiceDisplayNameW(
  525.     SC_HANDLE               hSCManager,
  526.     LPCWSTR                lpServiceName,
  527.     LPWSTR                 lpDisplayName,
  528.     LPDWORD                 lpcchBuffer
  529.     );
  530. #ifdef UNICODE
  531. #define GetServiceDisplayName  GetServiceDisplayNameW
  532. #else
  533. #define GetServiceDisplayName  GetServiceDisplayNameA
  534. #endif // !UNICODE
  535.  
  536. WINADVAPI
  537. SC_LOCK
  538. WINAPI
  539. LockServiceDatabase(
  540.     SC_HANDLE   hSCManager
  541.     );
  542.  
  543. WINADVAPI
  544. BOOL
  545. WINAPI
  546. NotifyBootConfigStatus(
  547.     BOOL     BootAcceptable
  548.     );
  549.  
  550. WINADVAPI
  551. SC_HANDLE
  552. WINAPI
  553. OpenSCManagerA(
  554.     LPCSTR lpMachineName,
  555.     LPCSTR lpDatabaseName,
  556.     DWORD   dwDesiredAccess
  557.     );
  558. WINADVAPI
  559. SC_HANDLE
  560. WINAPI
  561. OpenSCManagerW(
  562.     LPCWSTR lpMachineName,
  563.     LPCWSTR lpDatabaseName,
  564.     DWORD   dwDesiredAccess
  565.     );
  566. #ifdef UNICODE
  567. #define OpenSCManager  OpenSCManagerW
  568. #else
  569. #define OpenSCManager  OpenSCManagerA
  570. #endif // !UNICODE
  571.  
  572. WINADVAPI
  573. SC_HANDLE
  574. WINAPI
  575. OpenServiceA(
  576.     SC_HANDLE   hSCManager,
  577.     LPCSTR    lpServiceName,
  578.     DWORD       dwDesiredAccess
  579.     );
  580. WINADVAPI
  581. SC_HANDLE
  582. WINAPI
  583. OpenServiceW(
  584.     SC_HANDLE   hSCManager,
  585.     LPCWSTR    lpServiceName,
  586.     DWORD       dwDesiredAccess
  587.     );
  588. #ifdef UNICODE
  589. #define OpenService  OpenServiceW
  590. #else
  591. #define OpenService  OpenServiceA
  592. #endif // !UNICODE
  593.  
  594. WINADVAPI
  595. BOOL
  596. WINAPI
  597. QueryServiceConfigA(
  598.     SC_HANDLE               hService,
  599.     LPQUERY_SERVICE_CONFIGA lpServiceConfig,
  600.     DWORD                   cbBufSize,
  601.     LPDWORD                 pcbBytesNeeded
  602.     );
  603. WINADVAPI
  604. BOOL
  605. WINAPI
  606. QueryServiceConfigW(
  607.     SC_HANDLE               hService,
  608.     LPQUERY_SERVICE_CONFIGW lpServiceConfig,
  609.     DWORD                   cbBufSize,
  610.     LPDWORD                 pcbBytesNeeded
  611.     );
  612. #ifdef UNICODE
  613. #define QueryServiceConfig  QueryServiceConfigW
  614. #else
  615. #define QueryServiceConfig  QueryServiceConfigA
  616. #endif // !UNICODE
  617.  
  618. WINADVAPI
  619. BOOL
  620. WINAPI
  621. QueryServiceLockStatusA(
  622.     SC_HANDLE                       hSCManager,
  623.     LPQUERY_SERVICE_LOCK_STATUSA    lpLockStatus,
  624.     DWORD                           cbBufSize,
  625.     LPDWORD                         pcbBytesNeeded
  626.     );
  627. WINADVAPI
  628. BOOL
  629. WINAPI
  630. QueryServiceLockStatusW(
  631.     SC_HANDLE                       hSCManager,
  632.     LPQUERY_SERVICE_LOCK_STATUSW    lpLockStatus,
  633.     DWORD                           cbBufSize,
  634.     LPDWORD                         pcbBytesNeeded
  635.     );
  636. #ifdef UNICODE
  637. #define QueryServiceLockStatus  QueryServiceLockStatusW
  638. #else
  639. #define QueryServiceLockStatus  QueryServiceLockStatusA
  640. #endif // !UNICODE
  641.  
  642. WINADVAPI
  643. BOOL
  644. WINAPI
  645. QueryServiceObjectSecurity(
  646.     SC_HANDLE               hService,
  647.     SECURITY_INFORMATION    dwSecurityInformation,
  648.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor,
  649.     DWORD                   cbBufSize,
  650.     LPDWORD                 pcbBytesNeeded
  651.     );
  652.  
  653. WINADVAPI
  654. BOOL
  655. WINAPI
  656. QueryServiceStatus(
  657.     SC_HANDLE           hService,
  658.     LPSERVICE_STATUS    lpServiceStatus
  659.     );
  660.  
  661. WINADVAPI
  662. SERVICE_STATUS_HANDLE
  663. WINAPI
  664. RegisterServiceCtrlHandlerA(
  665.     LPCSTR             lpServiceName,
  666.     LPHANDLER_FUNCTION   lpHandlerProc
  667.     );
  668. WINADVAPI
  669. SERVICE_STATUS_HANDLE
  670. WINAPI
  671. RegisterServiceCtrlHandlerW(
  672.     LPCWSTR             lpServiceName,
  673.     LPHANDLER_FUNCTION   lpHandlerProc
  674.     );
  675. #ifdef UNICODE
  676. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerW
  677. #else
  678. #define RegisterServiceCtrlHandler  RegisterServiceCtrlHandlerA
  679. #endif // !UNICODE
  680.  
  681. WINADVAPI
  682. BOOL
  683. WINAPI
  684. SetServiceObjectSecurity(
  685.     SC_HANDLE               hService,
  686.     SECURITY_INFORMATION    dwSecurityInformation,
  687.     PSECURITY_DESCRIPTOR    lpSecurityDescriptor
  688.     );
  689.  
  690. WINADVAPI
  691. BOOL
  692. WINAPI
  693. SetServiceStatus(
  694.     SERVICE_STATUS_HANDLE   hServiceStatus,
  695.     LPSERVICE_STATUS        lpServiceStatus
  696.     );
  697.  
  698. WINADVAPI
  699. BOOL
  700. WINAPI
  701. StartServiceCtrlDispatcherA(
  702.     LPSERVICE_TABLE_ENTRYA    lpServiceStartTable
  703.     );
  704. WINADVAPI
  705. BOOL
  706. WINAPI
  707. StartServiceCtrlDispatcherW(
  708.     LPSERVICE_TABLE_ENTRYW    lpServiceStartTable
  709.     );
  710. #ifdef UNICODE
  711. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherW
  712. #else
  713. #define StartServiceCtrlDispatcher  StartServiceCtrlDispatcherA
  714. #endif // !UNICODE
  715.  
  716.  
  717. WINADVAPI
  718. BOOL
  719. WINAPI
  720. StartServiceA(
  721.     SC_HANDLE            hService,
  722.     DWORD                dwNumServiceArgs,
  723.     LPCSTR             *lpServiceArgVectors
  724.     );
  725. WINADVAPI
  726. BOOL
  727. WINAPI
  728. StartServiceW(
  729.     SC_HANDLE            hService,
  730.     DWORD                dwNumServiceArgs,
  731.     LPCWSTR             *lpServiceArgVectors
  732.     );
  733. #ifdef UNICODE
  734. #define StartService  StartServiceW
  735. #else
  736. #define StartService  StartServiceA
  737. #endif // !UNICODE
  738.  
  739. WINADVAPI
  740. BOOL
  741. WINAPI
  742. UnlockServiceDatabase(
  743.     SC_LOCK     ScLock
  744.     );
  745.  
  746.  
  747. #ifdef __cplusplus
  748. }
  749. #endif
  750.  
  751. #endif // _WINSVC_
  752.