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