librpc/gen_ndr/svcctl.h

   1 /* header auto-generated by pidl */
   2
   3 #include <stdint.h>
   4
   5 #include "librpc/gen_ndr/misc.h"
   6 #include "librpc/gen_ndr/security.h"
   7 #ifndef _HEADER_svcctl
   8 #define _HEADER_svcctl
   9
  10 #define SERVICE_TYPE_KERNEL_DRIVER      ( 0x01 )
  11 #define SERVICE_TYPE_FS_DRIVER  ( 0x02 )
  12 #define SERVICE_TYPE_ADAPTER    ( 0x04 )
  13 #define SERVICE_TYPE_RECOGNIZER_DRIVER  ( 0x08 )
  14 #define SERVICE_TYPE_DRIVER     ( SERVICE_TYPE_KERNEL_DRIVER|SERVICE_TYPE_FS_DRIVER|SERVICE_TYPE_RECOGNIZER_DRIVER )
  15 #define SERVICE_TYPE_WIN32_OWN_PROCESS  ( 0x10 )
  16 #define SERVICE_TYPE_WIN32_SHARE_PROCESS        ( 0x20 )
  17 #define SERVICE_TYPE_WIN32      ( SERVICE_TYPE_WIN32_OWN_PROCESS|SERVICE_TYPE_WIN32_SHARE_PROCESS )
  18 #define SV_TYPE_ALL     ( 0xFFFFFFFF )
  19 #define SC_MANAGER_READ_ACCESS  ( (SEC_STD_READ_CONTROL|SC_RIGHT_MGR_CONNECT|SC_RIGHT_MGR_ENUMERATE_SERVICE|SC_RIGHT_MGR_QUERY_LOCK_STATUS) )
  20 #define SC_MANAGER_EXECUTE_ACCESS       ( SC_MANAGER_READ_ACCESS )
  21 #define SC_MANAGER_WRITE_ACCESS ( (SEC_STD_REQUIRED|SC_MANAGER_READ_ACCESS|SC_RIGHT_MGR_CREATE_SERVICE|SC_RIGHT_MGR_LOCK|SC_RIGHT_MGR_MODIFY_BOOT_CONFIG) )
  22 #define SC_MANAGER_ALL_ACCESS   ( SC_MANAGER_WRITE_ACCESS )
  23 #define SERVICE_READ_ACCESS     ( (SEC_STD_READ_CONTROL|SC_RIGHT_SVC_ENUMERATE_DEPENDENTS|SC_RIGHT_SVC_INTERROGATE|SC_RIGHT_SVC_QUERY_CONFIG|SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_USER_DEFINED_CONTROL) )
  24 #define SERVICE_EXECUTE_ACCESS  ( (SERVICE_READ_ACCESS|SC_RIGHT_SVC_START|SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE) )
  25 #define SERVICE_WRITE_ACCESS    ( (SEC_STD_REQUIRED|SERVICE_READ_ACCESS|SERVICE_EXECUTE_ACCESS|SC_RIGHT_SVC_CHANGE_CONFIG) )
  26 #define SERVICE_ALL_ACCESS      ( SERVICE_WRITE_ACCESS )
  27 struct SERVICE_LOCK_STATUS {
  28         uint32_t is_locked;
  29         const char *lock_owner;/* [unique,charset(UTF16)] */
  30         uint32_t lock_duration;
  31 };
  32
  33 enum svcctl_ServiceStatus
  34 #ifndef USE_UINT_ENUMS
  35  {
  36         SVCCTL_STATE_UNKNOWN=0x00000000,
  37         SVCCTL_STOPPED=0x00000001,
  38         SVCCTL_START_PENDING=0x00000002,
  39         SVCCTL_STOP_PENDING=0x00000003,
  40         SVCCTL_RUNNING=0x00000004,
  41         SVCCTL_CONTINUE_PENDING=0x00000005,
  42         SVCCTL_PAUSE_PENDING=0x00000006,
  43         SVCCTL_PAUSED=0x00000007
  44 }
  45 #else
  46  { __donnot_use_enum_svcctl_ServiceStatus=0x7FFFFFFF}
  47 #define SVCCTL_STATE_UNKNOWN ( 0x00000000 )
  48 #define SVCCTL_STOPPED ( 0x00000001 )
  49 #define SVCCTL_START_PENDING ( 0x00000002 )
  50 #define SVCCTL_STOP_PENDING ( 0x00000003 )
  51 #define SVCCTL_RUNNING ( 0x00000004 )
  52 #define SVCCTL_CONTINUE_PENDING ( 0x00000005 )
  53 #define SVCCTL_PAUSE_PENDING ( 0x00000006 )
  54 #define SVCCTL_PAUSED ( 0x00000007 )
  55 #endif
  56 ;
  57
  58 /* bitmap svcctl_ControlsAccepted */
  59 #define SVCCTL_ACCEPT_NONE ( 0x00000000 )
  60 #define SVCCTL_ACCEPT_STOP ( 0x00000001 )
  61 #define SVCCTL_ACCEPT_PAUSE_CONTINUE ( 0x00000002 )
  62 #define SVCCTL_ACCEPT_SHUTDOWN ( 0x00000004 )
  63 #define SVCCTL_ACCEPT_PARAMCHANGE ( 0x00000008 )
  64 #define SVCCTL_ACCEPT_NETBINDCHANGE ( 0x00000010 )
  65 #define SVCCTL_ACCEPT_HARDWAREPROFILECHANGE ( 0x00000020 )
  66 #define SVCCTL_ACCEPT_POWEREVENT ( 0x00000040 )
  67
  68 struct SERVICE_STATUS {
  69         uint32_t type;
  70         enum svcctl_ServiceStatus state;
  71         uint32_t controls_accepted;
  72         WERROR win32_exit_code;
  73         uint32_t service_exit_code;
  74         uint32_t check_point;
  75         uint32_t wait_hint;
  76 };
  77
  78 struct SERVICE_STATUS_PROCESS {
  79         struct SERVICE_STATUS status;
  80         uint32_t process_id;
  81         uint32_t service_flags;
  82 }/* [public] */;
  83
  84 struct ENUM_SERVICE_STATUSW {
  85         const char * service_name;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */
  86         const char * display_name;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */
  87         struct SERVICE_STATUS status;
  88 }/* [gensize,public] */;
  89
  90 struct ENUM_SERVICE_STATUSA {
  91         const char * service_name;/* [relative,flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
  92         const char * display_name;/* [relative,flag(LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM)] */
  93         struct SERVICE_STATUS status;
  94 }/* [gensize,public] */;
  95
  96 /* bitmap svcctl_ServerType */
  97 #define SV_TYPE_WORKSTATION ( 0x00000001 )
  98 #define SV_TYPE_SERVER ( 0x00000002 )
  99 #define SV_TYPE_SQLSERVER ( 0x00000004 )
 100 #define SV_TYPE_DOMAIN_CTRL ( 0x00000008 )
 101 #define SV_TYPE_DOMAIN_BAKCTRL ( 0x00000010 )
 102 #define SV_TYPE_TIME_SOURCE ( 0x00000020 )
 103 #define SV_TYPE_AFP ( 0x00000040 )
 104 #define SV_TYPE_NOVELL ( 0x00000080 )
 105 #define SV_TYPE_DOMAIN_MEMBER ( 0x00000100 )
 106 #define SV_TYPE_PRINTQ_SERVER ( 0x00000200 )
 107 #define SV_TYPE_DIALIN_SERVER ( 0x00000400 )
 108 #define SV_TYPE_SERVER_UNIX ( 0x00000800 )
 109 #define SV_TYPE_NT ( 0x00001000 )
 110 #define SV_TYPE_WFW ( 0x00002000 )
 111 #define SV_TYPE_SERVER_MFPN ( 0x00004000 )
 112 #define SV_TYPE_SERVER_NT ( 0x00008000 )
 113 #define SV_TYPE_POTENTIAL_BROWSER ( 0x00010000 )
 114 #define SV_TYPE_BACKUP_BROWSER ( 0x00020000 )
 115 #define SV_TYPE_MASTER_BROWSER ( 0x00040000 )
 116 #define SV_TYPE_DOMAIN_MASTER ( 0x00080000 )
 117 #define SV_TYPE_SERVER_OSF ( 0x00100000 )
 118 #define SV_TYPE_SERVER_VMS ( 0x00200000 )
 119 #define SV_TYPE_WIN95_PLUS ( 0x00400000 )
 120 #define SV_TYPE_DFS_SERVER ( 0x00800000 )
 121 #define SV_TYPE_ALTERNATE_XPORT ( 0x20000000 )
 122 #define SV_TYPE_LOCAL_LIST_ONLY ( 0x40000000 )
 123 #define SV_TYPE_DOMAIN_ENUM ( 0x80000000 )
 124
 125 enum SERVICE_CONTROL
 126 #ifndef USE_UINT_ENUMS
 127  {
 128         SVCCTL_CONTROL_STOP=0x00000001,
 129         SVCCTL_CONTROL_PAUSE=0x00000002,
 130         SVCCTL_CONTROL_CONTINUE=0x00000003,
 131         SVCCTL_CONTROL_INTERROGATE=0x00000004,
 132         SVCCTL_CONTROL_SHUTDOWN=0x00000005
 133 }
 134 #else
 135  { __donnot_use_enum_SERVICE_CONTROL=0x7FFFFFFF}
 136 #define SVCCTL_CONTROL_STOP ( 0x00000001 )
 137 #define SVCCTL_CONTROL_PAUSE ( 0x00000002 )
 138 #define SVCCTL_CONTROL_CONTINUE ( 0x00000003 )
 139 #define SVCCTL_CONTROL_INTERROGATE ( 0x00000004 )
 140 #define SVCCTL_CONTROL_SHUTDOWN ( 0x00000005 )
 141 #endif
 142 ;
 143
 144 enum svcctl_ErrorControl
 145 #ifndef USE_UINT_ENUMS
 146  {
 147         SVCCTL_SVC_ERROR_IGNORE=0x00000000,
 148         SVCCTL_SVC_ERROR_NORMAL=0x00000001,
 149         SVCCTL_SVC_ERROR_CRITICAL=0x00000002,
 150         SVCCTL_SVC_ERROR_SEVERE=0x00000003
 151 }
 152 #else
 153  { __donnot_use_enum_svcctl_ErrorControl=0x7FFFFFFF}
 154 #define SVCCTL_SVC_ERROR_IGNORE ( 0x00000000 )
 155 #define SVCCTL_SVC_ERROR_NORMAL ( 0x00000001 )
 156 #define SVCCTL_SVC_ERROR_CRITICAL ( 0x00000002 )
 157 #define SVCCTL_SVC_ERROR_SEVERE ( 0x00000003 )
 158 #endif
 159 ;
 160
 161 enum svcctl_StartType
 162 #ifndef USE_UINT_ENUMS
 163  {
 164         SVCCTL_BOOT_START=0x00000000,
 165         SVCCTL_SYSTEM_START=0x00000001,
 166         SVCCTL_AUTO_START=0x00000002,
 167         SVCCTL_DEMAND_START=0x00000003,
 168         SVCCTL_DISABLED=0x00000004
 169 }
 170 #else
 171  { __donnot_use_enum_svcctl_StartType=0x7FFFFFFF}
 172 #define SVCCTL_BOOT_START ( 0x00000000 )
 173 #define SVCCTL_SYSTEM_START ( 0x00000001 )
 174 #define SVCCTL_AUTO_START ( 0x00000002 )
 175 #define SVCCTL_DEMAND_START ( 0x00000003 )
 176 #define SVCCTL_DISABLED ( 0x00000004 )
 177 #endif
 178 ;
 179
 180 enum svcctl_ServiceState
 181 #ifndef USE_UINT_ENUMS
 182  {
 183         SERVICE_STATE_ACTIVE=0x00000001,
 184         SERVICE_STATE_INACTIVE=0x00000002,
 185         SERVICE_STATE_ALL=(SERVICE_STATE_ACTIVE|SERVICE_STATE_INACTIVE)
 186 }
 187 #else
 188  { __donnot_use_enum_svcctl_ServiceState=0x7FFFFFFF}
 189 #define SERVICE_STATE_ACTIVE ( 0x00000001 )
 190 #define SERVICE_STATE_INACTIVE ( 0x00000002 )
 191 #define SERVICE_STATE_ALL ( (SERVICE_STATE_ACTIVE|SERVICE_STATE_INACTIVE) )
 192 #endif
 193 ;
 194
 195 /* bitmap svcctl_MgrAccessMask */
 196 #define SC_RIGHT_MGR_CONNECT ( 0x0001 )
 197 #define SC_RIGHT_MGR_CREATE_SERVICE ( 0x0002 )
 198 #define SC_RIGHT_MGR_ENUMERATE_SERVICE ( 0x0004 )
 199 #define SC_RIGHT_MGR_LOCK ( 0x0008 )
 200 #define SC_RIGHT_MGR_QUERY_LOCK_STATUS ( 0x0010 )
 201 #define SC_RIGHT_MGR_MODIFY_BOOT_CONFIG ( 0x0020 )
 202
 203 /* bitmap svcctl_ServiceAccessMask */
 204 #define SC_RIGHT_SVC_QUERY_CONFIG ( 0x0001 )
 205 #define SC_RIGHT_SVC_CHANGE_CONFIG ( 0x0002 )
 206 #define SC_RIGHT_SVC_QUERY_STATUS ( 0x0004 )
 207 #define SC_RIGHT_SVC_ENUMERATE_DEPENDENTS ( 0x0008 )
 208 #define SC_RIGHT_SVC_START ( 0x0010 )
 209 #define SC_RIGHT_SVC_STOP ( 0x0020 )
 210 #define SC_RIGHT_SVC_PAUSE_CONTINUE ( 0x0040 )
 211 #define SC_RIGHT_SVC_INTERROGATE ( 0x0080 )
 212 #define SC_RIGHT_SVC_USER_DEFINED_CONTROL ( 0x0100 )
 213
 214 struct QUERY_SERVICE_CONFIG {
 215         uint32_t service_type;
 216         enum svcctl_StartType start_type;
 217         enum svcctl_ErrorControl error_control;
 218         const char *executablepath;/* [unique,range(0,8192),charset(UTF16)] */
 219         const char *loadordergroup;/* [unique,range(0,8192),charset(UTF16)] */
 220         uint32_t tag_id;
 221         const char *dependencies;/* [unique,range(0,8192),charset(UTF16)] */
 222         const char *startname;/* [unique,range(0,8192),charset(UTF16)] */
 223         const char *displayname;/* [unique,range(0,8192),charset(UTF16)] */
 224 }/* [gensize,public] */;
 225
 226 enum svcctl_ConfigLevel
 227 #ifndef USE_UINT_ENUMS
 228  {
 229         SERVICE_CONFIG_DESCRIPTION=0x00000001,
 230         SERVICE_CONFIG_FAILURE_ACTIONS=0x00000002
 231 }
 232 #else
 233  { __donnot_use_enum_svcctl_ConfigLevel=0x7FFFFFFF}
 234 #define SERVICE_CONFIG_DESCRIPTION ( 0x00000001 )
 235 #define SERVICE_CONFIG_FAILURE_ACTIONS ( 0x00000002 )
 236 #endif
 237 ;
 238
 239 struct SERVICE_DESCRIPTION {
 240         const char * description;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */
 241 }/* [gensize,public] */;
 242
 243 enum SC_ACTION_TYPE
 244 #ifndef USE_UINT_ENUMS
 245  {
 246         SC_ACTION_NONE=0,
 247         SC_ACTION_RESTART=1,
 248         SC_ACTION_REBOOT=2,
 249         SC_ACTION_RUN_COMMAND=3
 250 }
 251 #else
 252  { __donnot_use_enum_SC_ACTION_TYPE=0x7FFFFFFF}
 253 #define SC_ACTION_NONE ( 0 )
 254 #define SC_ACTION_RESTART ( 1 )
 255 #define SC_ACTION_REBOOT ( 2 )
 256 #define SC_ACTION_RUN_COMMAND ( 3 )
 257 #endif
 258 ;
 259
 260 struct SC_ACTION {
 261         enum SC_ACTION_TYPE type;
 262         uint32_t delay;
 263 };
 264
 265 struct SERVICE_FAILURE_ACTIONS {
 266         uint32_t reset_period;
 267         const char * rebootmsg;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */
 268         const char * command;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM)] */
 269         uint32_t num_actions;/* [range(0,1024)] */
 270         struct SC_ACTION *actions;/* [relative,size_is(num_actions)] */
 271 }/* [gensize,public] */;
 272
 273 enum svcctl_StatusLevel
 274 #ifndef USE_UINT_ENUMS
 275  {
 276         SVC_STATUS_PROCESS_INFO=0x00000000
 277 }
 278 #else
 279  { __donnot_use_enum_svcctl_StatusLevel=0x7FFFFFFF}
 280 #define SVC_STATUS_PROCESS_INFO ( 0x00000000 )
 281 #endif
 282 ;
 283
 284
 285 struct svcctl_CloseServiceHandle {
 286         struct {
 287                 struct policy_handle *handle;/* [ref] */
 288         } in;
 289
 290         struct {
 291                 struct policy_handle *handle;/* [ref] */
 292                 WERROR result;
 293         } out;
 294
 295 };
 296
 297
 298 struct svcctl_ControlService {
 299         struct {
 300                 struct policy_handle *handle;/* [ref] */
 301                 enum SERVICE_CONTROL control;
 302         } in;
 303
 304         struct {
 305                 struct SERVICE_STATUS *service_status;/* [ref] */
 306                 WERROR result;
 307         } out;
 308
 309 };
 310
 311
 312 struct svcctl_DeleteService {
 313         struct {
 314                 struct policy_handle *handle;/* [ref] */
 315         } in;
 316
 317         struct {
 318                 WERROR result;
 319         } out;
 320
 321 };
 322
 323
 324 struct svcctl_LockServiceDatabase {
 325         struct {
 326                 struct policy_handle *handle;/* [ref] */
 327         } in;
 328
 329         struct {
 330                 struct policy_handle *lock;/* [ref] */
 331                 WERROR result;
 332         } out;
 333
 334 };
 335
 336
 337 struct svcctl_QueryServiceObjectSecurity {
 338         struct {
 339                 struct policy_handle *handle;/* [ref] */
 340                 uint32_t security_flags;
 341                 uint32_t buffer_size;/* [range(0,0x40000)] */
 342         } in;
 343
 344         struct {
 345                 uint8_t *buffer;/* [ref,size_is(buffer_size)] */
 346                 uint32_t *needed;/* [ref,range(0,0x40000)] */
 347                 WERROR result;
 348         } out;
 349
 350 };
 351
 352
 353 struct svcctl_SetServiceObjectSecurity {
 354         struct {
 355                 struct policy_handle *handle;/* [ref] */
 356                 uint32_t security_flags;
 357                 uint8_t *buffer;/* [ref,size_is(buffer_size)] */
 358                 uint32_t buffer_size;
 359         } in;
 360
 361         struct {
 362                 WERROR result;
 363         } out;
 364
 365 };
 366
 367
 368 struct svcctl_QueryServiceStatus {
 369         struct {
 370                 struct policy_handle *handle;/* [ref] */
 371         } in;
 372
 373         struct {
 374                 struct SERVICE_STATUS *service_status;/* [ref] */
 375                 WERROR result;
 376         } out;
 377
 378 };
 379
 380
 381 struct svcctl_SetServiceStatus {
 382         struct {
 383                 WERROR result;
 384         } out;
 385
 386 };
 387
 388
 389 struct svcctl_UnlockServiceDatabase {
 390         struct {
 391                 struct policy_handle *lock;/* [ref] */
 392         } in;
 393
 394         struct {
 395                 struct policy_handle *lock;/* [ref] */
 396                 WERROR result;
 397         } out;
 398
 399 };
 400
 401
 402 struct svcctl_NotifyBootConfigStatus {
 403         struct {
 404                 WERROR result;
 405         } out;
 406
 407 };
 408
 409
 410 struct svcctl_SCSetServiceBitsW {
 411         struct {
 412                 struct policy_handle *handle;/* [ref] */
 413                 uint32_t bits;
 414                 uint32_t bitson;
 415                 uint32_t immediate;
 416         } in;
 417
 418         struct {
 419                 WERROR result;
 420         } out;
 421
 422 };
 423
 424
 425 struct svcctl_ChangeServiceConfigW {
 426         struct {
 427                 struct policy_handle *handle;/* [ref] */
 428                 uint32_t type;
 429                 enum svcctl_StartType start_type;
 430                 enum svcctl_ErrorControl error_control;
 431                 const char *binary_path;/* [unique,charset(UTF16)] */
 432                 const char *load_order_group;/* [unique,charset(UTF16)] */
 433                 const char *dependencies;/* [unique,charset(UTF16)] */
 434                 const char *service_start_name;/* [unique,charset(UTF16)] */
 435                 const char *password;/* [unique,charset(UTF16)] */
 436                 const char *display_name;/* [unique,charset(UTF16)] */
 437         } in;
 438
 439         struct {
 440                 uint32_t *tag_id;/* [ref] */
 441                 WERROR result;
 442         } out;
 443
 444 };
 445
 446
 447 struct svcctl_CreateServiceW {
 448         struct {
 449                 struct policy_handle *scmanager_handle;/* [ref] */
 450                 const char *ServiceName;/* [charset(UTF16)] */
 451                 const char *DisplayName;/* [unique,charset(UTF16)] */
 452                 uint32_t desired_access;
 453                 uint32_t type;
 454                 enum svcctl_StartType start_type;
 455                 enum svcctl_ErrorControl error_control;
 456                 const char *binary_path;/* [charset(UTF16)] */
 457                 const char *LoadOrderGroupKey;/* [unique,charset(UTF16)] */
 458                 uint8_t *dependencies;/* [unique,size_is(dependencies_size)] */
 459                 uint32_t dependencies_size;
 460                 const char *service_start_name;/* [unique,charset(UTF16)] */
 461                 uint8_t *password;/* [unique,size_is(password_size)] */
 462                 uint32_t password_size;
 463                 uint32_t *TagId;/* [unique] */
 464         } in;
 465
 466         struct {
 467                 struct policy_handle *handle;/* [ref] */
 468                 uint32_t *TagId;/* [unique] */
 469                 WERROR result;
 470         } out;
 471
 472 };
 473
 474
 475 struct svcctl_EnumDependentServicesW {
 476         struct {
 477                 struct policy_handle *service;/* [ref] */
 478                 uint32_t state;
 479                 uint32_t buf_size;/* [range(0,0x40000)] */
 480         } in;
 481
 482         struct {
 483                 uint8_t *service_status;/* [ref,size_is(buf_size)] */
 484                 uint32_t *bytes_needed;/* [ref,range(0,0x40000)] */
 485                 uint32_t *services_returned;/* [ref,range(0,0x40000)] */
 486                 WERROR result;
 487         } out;
 488
 489 };
 490
 491
 492 struct svcctl_EnumServicesStatusW {
 493         struct {
 494                 struct policy_handle *handle;/* [ref] */
 495                 uint32_t type;
 496                 enum svcctl_ServiceState state;
 497                 uint32_t buf_size;/* [range(0,0x40000)] */
 498                 uint32_t *resume_handle;/* [unique] */
 499         } in;
 500
 501         struct {
 502                 uint8_t *service;/* [ref,size_is(buf_size)] */
 503                 uint32_t *bytes_needed;/* [ref,range(0,0x40000)] */
 504                 uint32_t *services_returned;/* [ref,range(0,0x40000)] */
 505                 uint32_t *resume_handle;/* [unique] */
 506                 WERROR result;
 507         } out;
 508
 509 };
 510
 511
 512 struct svcctl_OpenSCManagerW {
 513         struct {
 514                 const char *MachineName;/* [unique,charset(UTF16)] */
 515                 const char *DatabaseName;/* [unique,charset(UTF16)] */
 516                 uint32_t access_mask;
 517         } in;
 518
 519         struct {
 520                 struct policy_handle *handle;/* [ref] */
 521                 WERROR result;
 522         } out;
 523
 524 };
 525
 526
 527 struct svcctl_OpenServiceW {
 528         struct {
 529                 struct policy_handle *scmanager_handle;/* [ref] */
 530                 const char *ServiceName;/* [charset(UTF16)] */
 531                 uint32_t access_mask;
 532         } in;
 533
 534         struct {
 535                 struct policy_handle *handle;/* [ref] */
 536                 WERROR result;
 537         } out;
 538
 539 };
 540
 541
 542 struct svcctl_QueryServiceConfigW {
 543         struct {
 544                 struct policy_handle *handle;/* [ref] */
 545                 uint32_t buf_size;/* [range(0,8192)] */
 546         } in;
 547
 548         struct {
 549                 struct QUERY_SERVICE_CONFIG *query;/* [ref] */
 550                 uint32_t *bytes_needed;/* [ref,range(0,8192)] */
 551                 WERROR result;
 552         } out;
 553
 554 };
 555
 556
 557 struct svcctl_QueryServiceLockStatusW {
 558         struct {
 559                 struct policy_handle *handle;/* [ref] */
 560                 uint32_t buf_size;
 561         } in;
 562
 563         struct {
 564                 struct SERVICE_LOCK_STATUS *lock_status;/* [ref] */
 565                 uint32_t *required_buf_size;/* [ref] */
 566                 WERROR result;
 567         } out;
 568
 569 };
 570
 571
 572 struct svcctl_StartServiceW {
 573         struct {
 574                 struct policy_handle *handle;/* [ref] */
 575                 uint32_t NumArgs;
 576                 const char *Arguments;/* [unique,charset(UTF16)] */
 577         } in;
 578
 579         struct {
 580                 WERROR result;
 581         } out;
 582
 583 };
 584
 585
 586 struct svcctl_GetServiceDisplayNameW {
 587         struct {
 588                 struct policy_handle *handle;/* [ref] */
 589                 const char *service_name;/* [unique,charset(UTF16)] */
 590                 uint32_t *display_name_length;/* [unique] */
 591         } in;
 592
 593         struct {
 594                 const char **display_name;/* [ref,charset(UTF16)] */
 595                 uint32_t *display_name_length;/* [unique] */
 596                 WERROR result;
 597         } out;
 598
 599 };
 600
 601
 602 struct svcctl_GetServiceKeyNameW {
 603         struct {
 604                 struct policy_handle *handle;/* [ref] */
 605                 const char *service_name;/* [unique,charset(UTF16)] */
 606                 uint32_t *display_name_length;/* [unique] */
 607         } in;
 608
 609         struct {
 610                 const char **key_name;/* [ref,charset(UTF16)] */
 611                 uint32_t *display_name_length;/* [unique] */
 612                 WERROR result;
 613         } out;
 614
 615 };
 616
 617
 618 struct svcctl_SCSetServiceBitsA {
 619         struct {
 620                 struct policy_handle *handle;/* [ref] */
 621                 uint32_t bits;
 622                 uint32_t bitson;
 623                 uint32_t immediate;
 624         } in;
 625
 626         struct {
 627                 WERROR result;
 628         } out;
 629
 630 };
 631
 632
 633 struct svcctl_ChangeServiceConfigA {
 634         struct {
 635                 struct policy_handle *handle;/* [ref] */
 636                 uint32_t type;
 637                 enum svcctl_StartType start_type;
 638                 enum svcctl_ErrorControl error_control;
 639                 const char *binary_path;/* [unique,charset(UTF16)] */
 640                 const char *load_order_group;/* [unique,charset(UTF16)] */
 641                 const char *dependencies;/* [unique,charset(UTF16)] */
 642                 const char *service_start_name;/* [unique,charset(UTF16)] */
 643                 const char *password;/* [unique,charset(UTF16)] */
 644                 const char *display_name;/* [unique,charset(UTF16)] */
 645         } in;
 646
 647         struct {
 648                 uint32_t *tag_id;/* [ref] */
 649                 WERROR result;
 650         } out;
 651
 652 };
 653
 654
 655 struct svcctl_CreateServiceA {
 656         struct {
 657                 struct policy_handle *handle;/* [ref] */
 658                 const char *ServiceName;/* [unique,charset(UTF16)] */
 659                 const char *DisplayName;/* [unique,charset(UTF16)] */
 660                 uint32_t desired_access;
 661                 uint32_t type;
 662                 enum svcctl_StartType start_type;
 663                 enum svcctl_ErrorControl error_control;
 664                 const char *binary_path;/* [unique,charset(UTF16)] */
 665                 const char *LoadOrderGroupKey;/* [unique,charset(UTF16)] */
 666                 const char *dependencies;/* [unique,charset(UTF16)] */
 667                 const char *service_start_name;/* [unique,charset(UTF16)] */
 668                 const char *password;/* [unique,charset(UTF16)] */
 669         } in;
 670
 671         struct {
 672                 uint32_t *TagId;/* [unique] */
 673                 WERROR result;
 674         } out;
 675
 676 };
 677
 678
 679 struct svcctl_EnumDependentServicesA {
 680         struct {
 681                 struct policy_handle *service;/* [ref] */
 682                 uint32_t state;
 683                 uint32_t buf_size;
 684         } in;
 685
 686         struct {
 687                 struct ENUM_SERVICE_STATUSA *service_status;/* [unique] */
 688                 uint32_t *bytes_needed;/* [ref] */
 689                 uint32_t *services_returned;/* [ref] */
 690                 WERROR result;
 691         } out;
 692
 693 };
 694
 695
 696 struct svcctl_EnumServicesStatusA {
 697         struct {
 698                 struct policy_handle *handle;/* [ref] */
 699                 uint32_t type;
 700                 enum svcctl_ServiceState state;
 701                 uint32_t buf_size;
 702                 uint32_t *resume_handle;/* [unique] */
 703         } in;
 704
 705         struct {
 706                 uint8_t *service;/* [size_is(buf_size)] */
 707                 uint32_t *bytes_needed;/* [ref] */
 708                 uint32_t *services_returned;/* [ref] */
 709                 uint32_t *resume_handle;/* [unique] */
 710                 WERROR result;
 711         } out;
 712
 713 };
 714
 715
 716 struct svcctl_OpenSCManagerA {
 717         struct {
 718                 const char *MachineName;/* [unique,charset(UTF16)] */
 719                 const char *DatabaseName;/* [unique,charset(UTF16)] */
 720                 uint32_t access_mask;
 721         } in;
 722
 723         struct {
 724                 struct policy_handle *handle;/* [ref] */
 725                 WERROR result;
 726         } out;
 727
 728 };
 729
 730
 731 struct svcctl_OpenServiceA {
 732         struct {
 733                 struct policy_handle *scmanager_handle;/* [ref] */
 734                 const char *ServiceName;/* [unique,charset(UTF16)] */
 735                 uint32_t access_mask;
 736         } in;
 737
 738         struct {
 739                 WERROR result;
 740         } out;
 741
 742 };
 743
 744
 745 struct svcctl_QueryServiceConfigA {
 746         struct {
 747                 struct policy_handle *handle;/* [ref] */
 748                 uint32_t buf_size;
 749         } in;
 750
 751         struct {
 752                 uint8_t *query;
 753                 uint32_t *bytes_needed;/* [ref] */
 754                 WERROR result;
 755         } out;
 756
 757 };
 758
 759
 760 struct svcctl_QueryServiceLockStatusA {
 761         struct {
 762                 struct policy_handle *handle;/* [ref] */
 763                 uint32_t buf_size;
 764         } in;
 765
 766         struct {
 767                 struct SERVICE_LOCK_STATUS *lock_status;/* [ref] */
 768                 uint32_t *required_buf_size;/* [ref] */
 769                 WERROR result;
 770         } out;
 771
 772 };
 773
 774
 775 struct svcctl_StartServiceA {
 776         struct {
 777                 struct policy_handle *handle;/* [ref] */
 778                 uint32_t NumArgs;
 779                 const char *Arguments;/* [unique,charset(UTF16)] */
 780         } in;
 781
 782         struct {
 783                 WERROR result;
 784         } out;
 785
 786 };
 787
 788
 789 struct svcctl_GetServiceDisplayNameA {
 790         struct {
 791                 struct policy_handle *handle;/* [ref] */
 792                 const char *service_name;/* [unique,charset(UTF16)] */
 793                 uint32_t *display_name_length;/* [unique] */
 794         } in;
 795
 796         struct {
 797                 const char **display_name;/* [ref,charset(UTF16)] */
 798                 uint32_t *display_name_length;/* [unique] */
 799                 WERROR result;
 800         } out;
 801
 802 };
 803
 804
 805 struct svcctl_GetServiceKeyNameA {
 806         struct {
 807                 struct policy_handle *handle;/* [ref] */
 808                 const char *service_name;/* [unique,charset(UTF16)] */
 809                 uint32_t *display_name_length;/* [unique] */
 810         } in;
 811
 812         struct {
 813                 const char **key_name;/* [ref,charset(UTF16)] */
 814                 uint32_t *display_name_length;/* [unique] */
 815                 WERROR result;
 816         } out;
 817
 818 };
 819
 820
 821 struct svcctl_GetCurrentGroupeStateW {
 822         struct {
 823                 WERROR result;
 824         } out;
 825
 826 };
 827
 828
 829 struct svcctl_EnumServiceGroupW {
 830         struct {
 831                 WERROR result;
 832         } out;
 833
 834 };
 835
 836
 837 struct svcctl_ChangeServiceConfig2A {
 838         struct {
 839                 struct policy_handle *handle;/* [ref] */
 840                 uint32_t info_level;
 841                 uint8_t *info;/* [unique] */
 842         } in;
 843
 844         struct {
 845                 WERROR result;
 846         } out;
 847
 848 };
 849
 850
 851 struct svcctl_ChangeServiceConfig2W {
 852         struct {
 853                 struct policy_handle *handle;/* [ref] */
 854                 uint32_t info_level;
 855                 uint8_t *info;/* [unique] */
 856         } in;
 857
 858         struct {
 859                 WERROR result;
 860         } out;
 861
 862 };
 863
 864
 865 struct svcctl_QueryServiceConfig2A {
 866         struct {
 867                 struct policy_handle *handle;/* [ref] */
 868                 enum svcctl_ConfigLevel info_level;
 869                 uint32_t buf_size;
 870         } in;
 871
 872         struct {
 873                 uint8_t *buffer;
 874                 uint32_t *bytes_needed;/* [ref] */
 875                 WERROR result;
 876         } out;
 877
 878 };
 879
 880
 881 struct svcctl_QueryServiceConfig2W {
 882         struct {
 883                 struct policy_handle *handle;/* [ref] */
 884                 enum svcctl_ConfigLevel info_level;
 885                 uint32_t buf_size;/* [range(0,8192)] */
 886         } in;
 887
 888         struct {
 889                 uint8_t *buffer;/* [ref,size_is(buf_size)] */
 890                 uint32_t *bytes_needed;/* [ref,range(0,8192)] */
 891                 WERROR result;
 892         } out;
 893
 894 };
 895
 896
 897 struct svcctl_QueryServiceStatusEx {
 898         struct {
 899                 struct policy_handle *handle;/* [ref] */
 900                 enum svcctl_StatusLevel info_level;
 901                 uint32_t buf_size;/* [range(0,8192)] */
 902         } in;
 903
 904         struct {
 905                 uint8_t *buffer;/* [ref,size_is(buf_size)] */
 906                 uint32_t *bytes_needed;/* [ref,range(0,8192)] */
 907                 WERROR result;
 908         } out;
 909
 910 };
 911
 912
 913 struct EnumServicesStatusExA {
 914         struct {
 915                 struct policy_handle *scmanager;/* [ref] */
 916                 uint32_t info_level;
 917                 uint32_t type;
 918                 enum svcctl_ServiceState state;
 919                 uint32_t buf_size;
 920                 uint32_t *resume_handle;/* [unique] */
 921         } in;
 922
 923         struct {
 924                 uint8_t *services;
 925                 uint32_t *bytes_needed;/* [ref] */
 926                 uint32_t *service_returned;/* [ref] */
 927                 const char **group_name;/* [ref,charset(UTF16)] */
 928                 uint32_t *resume_handle;/* [unique] */
 929                 WERROR result;
 930         } out;
 931
 932 };
 933
 934
 935 struct EnumServicesStatusExW {
 936         struct {
 937                 struct policy_handle *scmanager;/* [ref] */
 938                 uint32_t info_level;
 939                 uint32_t type;
 940                 enum svcctl_ServiceState state;
 941                 uint32_t buf_size;/* [range(0,0x40000)] */
 942                 const char *group_name;/* [unique,charset(UTF16)] */
 943                 uint32_t *resume_handle;/* [unique,range(0,0x40000)] */
 944         } in;
 945
 946         struct {
 947                 uint8_t *services;/* [ref,size_is(buf_size)] */
 948                 uint32_t *bytes_needed;/* [ref,range(0,0x40000)] */
 949                 uint32_t *service_returned;/* [ref,range(0,0x40000)] */
 950                 uint32_t *resume_handle;/* [unique,range(0,0x40000)] */
 951                 WERROR result;
 952         } out;
 953
 954 };
 955
 956
 957 struct svcctl_SCSendTSMessage {
 958         struct {
 959                 WERROR result;
 960         } out;
 961
 962 };
 963
 964 #endif /* _HEADER_svcctl */