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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WinSvc.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：26k
源码类别：

模拟服务器

开发平台：

C/C++

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