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