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