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