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