reactos/include/reactos/idl/svcctl.idl

   1 /*
   2  * Service Control Manager (SCM) interface definition
   3  */
   4
   5 //#include <windef.h>
   6 //#include <winsvc.h>
   7
   8 #define BYTE unsigned char
   9 #define DWORD unsigned long
  10 #define BOOL unsigned long
  11 #define SC_HANDLE unsigned int
  12 #define SC_LOCK unsigned int
  13 #define SERVICE_STATUS_HANDLE unsigned long
  14 #define SC_STATUS_TYPE unsigned long
  15 #define SC_ENUM_TYPE unsigned long
  16 #define LPSTR char*
  17 #define LPCSTR char*
  18 #define LPWSTR wchar_t*
  19 #define LPCWSTR wchar_t*
  20 #define LPBYTE unsigned char*
  21 #define LPDWORD unsigned long*
  22
  23 [
  24   uuid(367abb81-9844-35f1-ad32-98f038001003),
  25   version(2.0),
  26   pointer_default(unique),
  27   explicit_handle
  28 ]
  29 interface svcctl
  30 {
  31 cpp_quote("#if 0")
  32   typedef struct _SERVICE_STATUS
  33   {
  34     DWORD dwServiceType;
  35     DWORD dwCurrentState;
  36     DWORD dwControlsAccepted;
  37     DWORD dwWin32ExitCode;
  38     DWORD dwServiceSpecificExitCode;
  39     DWORD dwCheckPoint;
  40     DWORD dwWaitHint;
  41   } SERVICE_STATUS, *LPSERVICE_STATUS;
  42 cpp_quote("#endif")
  43
  44   /* Function 0 */
  45   DWORD ScmrCloseServiceHandle([in] handle_t BindingHandle,
  46                                [in] SC_HANDLE hSCObject);
  47
  48   /* Function 1 */
  49   DWORD ScmrControlService([in] handle_t BindingHandle,
  50                            [in] SC_HANDLE hService,
  51                            [in] DWORD dwControl,
  52                            [out] SERVICE_STATUS *lpServiceStatus);
  53 /*                           [out] LPSERVICE_STATUS lpServiceStatus); */
  54
  55   /* Function 2 */
  56   DWORD ScmrDeleteService([in] handle_t BindingHandle,
  57                           [in] SC_HANDLE hService);
  58
  59   /* Function 3 */
  60   DWORD ScmrLockServiceDatabase([in] handle_t BindingHandle,
  61                                 [in] SC_HANDLE hSCManager,
  62                                 [out] SC_LOCK *hLock);
  63
  64   /* Function 4 */
  65   DWORD ScmrQueryServiceObjectSecurity([in] handle_t BindingHandle,
  66                                        [in] SC_HANDLE hService,
  67                                        [in] DWORD dwSecurityInformation,
  68                                        [out, size_is(dwSecuityDescriptorSize)] unsigned char *lpSecurityDescriptor,
  69                                        [in] DWORD dwSecuityDescriptorSize,
  70                                        [out] LPDWORD pcbBytesNeeded);
  71
  72   /* Function 5 */
  73   DWORD ScmrSetServiceObjectSecurity([in] handle_t BindingHandle,
  74                                      [in] SC_HANDLE hService,
  75                                      [in] DWORD dwSecurityInformation,
  76                                      [in, size_is(dwSecuityDescriptorSize)] unsigned char *lpSecurityDescriptor,
  77                                      [in] DWORD dwSecuityDescriptorSize);
  78
  79   /* Function 6 */
  80   DWORD ScmrQueryServiceStatus([in] handle_t BindingHandle,
  81                                [in] SC_HANDLE hSCManager,
  82                                [out] SERVICE_STATUS *lpServiceStatus);
  83 /*                               [out] LPSERVICE_STATUS lpServiceStatus); */
  84
  85   /* Function 7 */
  86   DWORD ScmrSetServiceStatus([in] handle_t BindingHandle,
  87                              [in] SERVICE_STATUS_HANDLE hServiceStatus); /* FIXME */
  88
  89   /* Function 8 */
  90   DWORD ScmrUnlockServiceDatabase([in] handle_t BindingHandle,
  91                                   [in] SC_LOCK hLock);
  92
  93   /* Function 9 */
  94   DWORD ScmrNotifyBootConfigStatus([in] handle_t BindingHandle,
  95                                    [in] BOOL BootAcceptable);
  96
  97   /* Function 10 */
  98   DWORD ScmrSetServiceBitsW([in] handle_t BindingHandle,
  99                             [in] SERVICE_STATUS_HANDLE hServiceStatus,
 100                             [in] DWORD dwServiceBits,
 101                             [in] BOOL bSetBitsOn,
 102                             [in] BOOL bUpdateImmediately,
 103                             [in, string, unique] LPWSTR lpString);
 104
 105   /* Function 11 */
 106   DWORD ScmrChangeServiceConfigW([in] handle_t BindingHandle,
 107                                  [in] SC_HANDLE hSCManager,
 108                                  [in] DWORD dwServiceType,
 109                                  [in] DWORD dwStartType,
 110                                  [in] DWORD dwErrorControl,
 111                                  [in, string, unique] LPCWSTR lpBinaryPathName,
 112                                  [in, string, unique] LPCWSTR lpLoadOrderGroup,
 113                                  [in, out, unique] LPDWORD lpdwTagId,
 114                                  [in, size_is(dwDependenciesLength), unique] LPCWSTR lpDependencies,
 115                                  [in] DWORD dwDependenciesLength,
 116                                  [in, string, unique] LPCWSTR lpServiceStartName,
 117                                  [in, size_is(dwPasswordLength), unique] LPCWSTR lpPassword,
 118                                  [in] DWORD dwPasswordLength,
 119                                  [in, string, unique] LPCWSTR lpDisplayName);
 120
 121   /* Function 12 */
 122   DWORD ScmrCreateServiceW([in] handle_t BindingHandle,
 123                            [in] SC_HANDLE hSCManager,
 124                            [in, string, ref] LPCWSTR lpServiceName,
 125                            [in, string, unique] LPCWSTR lpDisplayName,
 126                            [in] DWORD dwDesiredAccess,
 127                            [in] DWORD dwServiceType,
 128                            [in] DWORD dwStartType,
 129                            [in] DWORD dwErrorControl,
 130                            [in, string, ref] LPCWSTR lpBinaryPathName,
 131                            [in, string, unique] LPCWSTR lpLoadOrderGroup,
 132                            [in, out, unique] LPDWORD lpdwTagId,
 133                            [in, size_is(dwDependenciesLength), unique] LPCWSTR lpDependencies,
 134                            [in] DWORD dwDependenciesLength,
 135                            [in, string, unique] LPCWSTR lpServiceStartName,
 136                            [in, size_is(dwPasswordLength), unique] LPCWSTR lpPassword,
 137                            [in] DWORD dwPasswordLength,
 138                            [out] SC_HANDLE *hService);
 139
 140   /* Function 13 */
 141   DWORD ScmrEnumDependentServicesW([in] handle_t BindingHandle,
 142                                    [in] SC_HANDLE hService,
 143                                    [in] DWORD dwServiceState,
 144                                    [out, unique, size_is(cbBufSize)] LPBYTE lpServices,
 145                                    [in] DWORD cbBufSize,
 146                                    [out] LPDWORD pcbBytesNeeded,
 147                                    [out] LPDWORD lpServicesReturned);
 148
 149   /* Function 14 */
 150   DWORD ScmrEnumServicesStatusW([in] handle_t BindingHandle,
 151                                 [in] SC_HANDLE hSCManager,
 152                                 [in] DWORD dwServiceType,
 153                                 [in] DWORD dwServiceState,
 154                                 [out, unique, size_is(dwBufSize)] LPBYTE lpServices,
 155                                 [in] DWORD dwBufSize,
 156                                 [out] LPDWORD pcbBytesNeeded,
 157                                 [out] LPDWORD lpServicesReturned,
 158                                 [in, out, unique] LPDWORD lpResumeHandle);
 159
 160   /* Function 15 */
 161   DWORD ScmrOpenSCManagerW([in] handle_t BindingHandle,
 162                            [in, string, unique] LPCWSTR lpMachineName,
 163                            [in, string, unique] LPCWSTR lpDatabaseName,
 164                            [in] DWORD dwDesiredAccess,
 165                            [out] SC_HANDLE *hScm);
 166
 167   /* Function 16 */
 168   DWORD ScmrOpenServiceW([in] handle_t BindingHandle,
 169                          [in] SC_HANDLE hSCManager,
 170                          [in, string] LPCWSTR lpServiceName,
 171                          [in] DWORD dwDesiredAccess,
 172                          [out] SC_HANDLE *hScm);
 173
 174   /* Function 17 */
 175   DWORD ScmrQueryServiceConfigW([in] handle_t BindingHandle,
 176                                 [in] SC_HANDLE hService,
 177                                 [out, unique, size_is(cbBufSize)] LPBYTE lpServiceConfig,
 178                                 [in] DWORD cbBufSize,
 179                                 [out] LPDWORD pcbBytesNeeded);
 180
 181   /* Function 18 */
 182   DWORD ScmrQueryServiceLockStatusW([in] handle_t BindingHandle,
 183                                     [in] SC_HANDLE hSCManager,
 184                                     [out, unique, size_is(cbBufSize)] LPBYTE lpLockStatus,
 185                                     [in] DWORD cbBufSize,
 186                                     [out] LPDWORD pcbBytesNeeded);
 187
 188   /* Function 19 */
 189   DWORD ScmrStartServiceW([in] handle_t BindingHandle,
 190                           [in] SC_HANDLE hService,
 191                           [in] DWORD dwNumServiceArgs,
 192                           [in, size_is(cbBufSize)] LPBYTE lpServiceArgBuffer,
 193                           [in] DWORD cbBufSize);
 194
 195   /* FIXME: This is the correct interface but WIDL doesn't support it yet! */
 196 //  DWORD ScmrStartServiceW([in] handle_t BindingHandle,
 197 //                          [in] SC_HANDLE hService,
 198 //                          [in] DWORD dwNumServiceArgs,
 199 //                          [in, string, size_is(dwNumServiceArgs, ), unique] LPWSTR *lpServiceArgVectors);
 200
 201   /* Function 20 */
 202   DWORD ScmrGetServiceDisplayNameW([in] handle_t BindingHandle,
 203                                    [in] SC_HANDLE hSCManager,
 204                                    [in, string, ref] LPCWSTR lpServiceName,
 205                                    [out, size_is(*lpcchBuffer), unique] LPWSTR lpDisplayName,
 206                                    [in, out, ref] LPDWORD lpcchBuffer);
 207
 208   /* Function 21 */
 209   DWORD ScmrGetServiceKeyNameW([in] handle_t BindingHandle,
 210                                [in] SC_HANDLE hSCManager,
 211                                [in, string, ref] LPCWSTR lpDisplayName,
 212                                [out, size_is(*lpcchBuffer), unique] LPWSTR lpServiceName,
 213                                [in, out, ref] LPDWORD lpcchBuffer);
 214
 215   /* Function 22 */
 216   DWORD ScmrSetServiceBitsA([in] handle_t BindingHandle,
 217                             [in] SERVICE_STATUS_HANDLE hServiceStatus,
 218                             [in] DWORD dwServiceBits,
 219                             [in] BOOL bSetBitsOn,
 220                             [in] BOOL bUpdateImmediately,
 221                             [in, string, unique] LPSTR lpString);
 222
 223   /* Function 23 */
 224   DWORD ScmrChangeServiceConfigA([in] handle_t BindingHandle,
 225                                  [in] SC_HANDLE hSCManager,
 226                                  [in] DWORD dwServiceType,
 227                                  [in] DWORD dwStartType,
 228                                  [in] DWORD dwErrorControl,
 229                                  [in, string, unique] LPCSTR lpBinaryPathName,
 230                                  [in, string, unique] LPCSTR lpLoadOrderGroup,
 231                                  [in, out, unique] LPDWORD lpdwTagId,
 232                                  [in, size_is(dwDependenciesLength), unique] LPCSTR lpDependencies,
 233                                  [in] DWORD dwDependenciesLength,
 234                                  [in, string, unique] LPCSTR lpServiceStartName,
 235                                  [in, size_is(dwPasswordLength), unique] LPCSTR lpPassword,
 236                                  [in] DWORD dwPasswordLength,
 237                                  [in, string, unique] LPCSTR lpDisplayName);
 238
 239   /* Function 24 */
 240   DWORD ScmrCreateServiceA([in] handle_t BindingHandle,
 241                            [in] SC_HANDLE hSCManager,
 242                            [in, string, ref] LPCSTR lpServiceName,
 243                            [in, string, unique] LPCSTR lpDisplayName,
 244                            [in] DWORD dwDesiredAccess,
 245                            [in] DWORD dwServiceType,
 246                            [in] DWORD dwStartType,
 247                            [in] DWORD dwErrorControl,
 248                            [in, string, ref] LPCSTR lpBinaryPathName,
 249                            [in, string, unique] LPCSTR lpLoadOrderGroup,
 250                            [in, out, unique] LPDWORD lpdwTagId,
 251                            [in, size_is(dwDependenciesLength), unique] LPCSTR lpDependencies,
 252                            [in] DWORD dwDependenciesLength,
 253                            [in, string, unique] LPCSTR lpServiceStartName,
 254                            [in, size_is(dwPasswordLength), unique] LPCSTR lpPassword,
 255                            [in] DWORD dwPasswordLength,
 256                            [out] SC_HANDLE *hService);
 257
 258   /* Function 25 */
 259   DWORD ScmrEnumDependentServicesA([in] handle_t BindingHandle,
 260                                    [in] SC_HANDLE hService,
 261                                    [in] DWORD dwServiceState,
 262                                    [out, unique, size_is(cbBufSize)] LPBYTE lpServices,
 263                                    [in] DWORD cbBufSize,
 264                                    [out] LPDWORD pcbBytesNeeded,
 265                                    [out] LPDWORD lpServicesReturned);
 266
 267   /* Function 26 */
 268   DWORD ScmrEnumServicesStatusA([in] handle_t BindingHandle,
 269                                 [in] SC_HANDLE hSCManager,
 270                                 [in] DWORD dwServiceType,
 271                                 [in] DWORD dwServiceState,
 272                                 [out, unique, size_is(dwBufSize)] LPBYTE lpServices,
 273                                 [in] DWORD dwBufSize,
 274                                 [out] LPDWORD pcbBytesNeeded,
 275                                 [out] LPDWORD lpServicesReturned,
 276                                 [in, out, unique] LPDWORD lpResumeHandle);
 277
 278   /* Function 27 */
 279   DWORD ScmrOpenSCManagerA([in] handle_t BindingHandle,
 280                            [in, string, unique] LPCSTR lpMachineName,
 281                            [in, string, unique] LPCSTR lpDatabaseName,
 282                            [in] DWORD dwDesiredAccess,
 283                            [out] SC_HANDLE *hScm);
 284
 285   /* Function 28 */
 286   SC_HANDLE ScmrOpenServiceA([in] handle_t BindingHandle,
 287                              [in] SC_HANDLE hSCManager,
 288                              [in, string] LPCSTR lpServiceName,
 289                              [in] DWORD dwDesiredAccess,
 290                              [out] SC_HANDLE *hScm);
 291
 292   /* Function 29 */
 293   DWORD ScmrQueryServiceConfigA([in] handle_t BindingHandle,
 294                                 [in] SC_HANDLE hService,
 295                                 [out, unique, size_is(cbBufSize)] LPBYTE lpServiceConfig,
 296                                 [in] DWORD cbBufSize,
 297                                 [out] LPDWORD pcbBytesNeeded);
 298
 299   /* Function 30 */
 300   DWORD ScmrQueryServiceLockStatusA([in] handle_t BindingHandle,
 301                                     [in] SC_HANDLE hSCManager,
 302                                     [out, unique, size_is(cbBufSize)] LPBYTE lpLockStatus,
 303                                     [in] DWORD cbBufSize,
 304                                     [out] LPDWORD pcbBytesNeeded);
 305
 306   /* Function 31 */
 307   DWORD ScmrStartServiceA([in] handle_t BindingHandle,
 308                           [in] SC_HANDLE hService,
 309                           [in] DWORD dwNumServiceArgs,
 310                           [in, size_is(cbBufSize)] LPBYTE lpServiceArgBuffer,
 311                           [in] DWORD cbBufSize);
 312
 313   /* FIXME: This is the correct interface but WIDL doesn't support it yet! */
 314 //  DWORD ScmrStartServiceA([in] handle_t BindingHandle,
 315 //                          [in] SC_HANDLE hService,
 316 //                          [in] DWORD dwNumServiceArgs,
 317 //                          [in, unique, string, size_is(dwNumServiceArgs, )] LPSTR *lpServiceArgVectors);
 318
 319   /* Function 32 */
 320   DWORD ScmrGetServiceDisplayNameA([in] handle_t BindingHandle,
 321                                    [in] SC_HANDLE hSCManager,
 322                                    [in, string, ref] LPCSTR lpServiceName,
 323                                    [out, unique, size_is(*lpcchBuffer)] LPSTR lpDisplayName,
 324                                    [in, out, ref] LPDWORD lpcchBuffer);
 325
 326   /* Function 33 */
 327   DWORD ScmrGetServiceKeyNameA([in] handle_t BindingHandle,
 328                                [in] SC_HANDLE hSCManager,
 329                                [in, string, ref] LPCSTR lpDisplayName,
 330                                [out, unique, size_is(*lpcchBuffer)] LPSTR lpServiceName,
 331                                [in, out, ref] LPDWORD lpcchBuffer);
 332
 333   /* Function 34 */
 334   DWORD ScmrGetCurrentGroupStateW([in] handle_t BindingHandle); /* FIXME */
 335
 336   /* Function 35 */
 337   DWORD ScmrEnumServiceGroupW([in] handle_t BindingHandle); /* FIXME */
 338
 339   /* Function 36 */
 340   DWORD ScmrChangeServiceConfig2A([in] handle_t BindingHandle,
 341                                   [in] SC_HANDLE hService,
 342                                   [in] DWORD dwInfoLevel,
 343                                   [in, size_is(dwInfoSize)] LPBYTE lpInfo,
 344                                   [in] DWORD dwInfoSize);
 345
 346   /* Function 37 */
 347   DWORD ScmrChangeServiceConfig2W([in] handle_t BindingHandle,
 348                                   [in] SC_HANDLE hService,
 349                                   [in] DWORD dwInfoLevel,
 350                                   [in, size_is(dwInfoSize)] LPBYTE lpInfo,
 351                                   [in] DWORD dwInfoSize);
 352
 353   /* Function 38 */
 354   DWORD ScmrQueryServiceConfig2A([in] handle_t BindingHandle,
 355                                  [in] SC_HANDLE hService,
 356                                  [in] DWORD dwInfoLevel,
 357                                  [out, unique, size_is(cbBufSize)] LPBYTE lpBuffer,
 358                                  [in] DWORD cbBufSize,
 359                                  [out] LPDWORD pcbBytesNeeded);
 360
 361   /* Function 39 */
 362   DWORD ScmrQueryServiceConfig2W([in] handle_t BindingHandle,
 363                                  [in] SC_HANDLE hService,
 364                                  [in] DWORD dwInfoLevel,
 365                                  [out, unique, size_is(cbBufSize)] LPBYTE lpBuffer,
 366                                  [in] DWORD cbBufSize,
 367                                  [out] LPDWORD pcbBytesNeeded);
 368
 369   /* Function 40 */
 370   DWORD ScmrQueryServiceStatusEx([in] handle_t BindingHandle,
 371                                  [in] SC_HANDLE hService,
 372                                  [in] SC_STATUS_TYPE InfoLevel,
 373                                  [out, unique, size_is(cbBufSize)] LPBYTE lpBuffer,
 374                                  [in] DWORD cbBufSize,
 375                                  [out] LPDWORD pcbBytesNeeded);
 376
 377   /* Function 41 */
 378   DWORD ScmrEnumServicesStatusExA([in] handle_t BindingHandle,
 379                                   [in] SC_HANDLE hService,
 380                                   [in] SC_ENUM_TYPE InfoLevel,
 381                                   [in] DWORD dwServiceType,
 382                                   [in] DWORD dwServiceState,
 383                                   [out, unique, size_is(cbBufSize)] LPBYTE lpServices,
 384                                   [in] DWORD cbBufSize,
 385                                   [out] LPDWORD pcbBytesNeeded,
 386                                   [out] LPDWORD lpServicesReturned,
 387                                   [in, out, unique] LPDWORD lpResumeHandle,
 388                                   [in, string, unique] LPCSTR pszGroupName);
 389
 390   /* Function 42 */
 391   DWORD ScmrEnumServicesStatusExW([in] handle_t BindingHandle,
 392                                   [in] SC_HANDLE hService,
 393                                   [in] SC_ENUM_TYPE InfoLevel,
 394                                   [in] DWORD dwServiceType,
 395                                   [in] DWORD dwServiceState,
 396                                   [out, unique, size_is(cbBufSize)] LPBYTE lpServices,
 397                                   [in] DWORD cbBufSize,
 398                                   [out] LPDWORD pcbBytesNeeded,
 399                                   [out] LPDWORD lpServicesReturned,
 400                                   [in, out, unique] LPDWORD lpResumeHandle,
 401                                   [in, string, unique] LPCWSTR pszGroupName);
 402
 403   /* Function 43 */
 404   /* ScmrSendTSMessage */
 405 }