source3/librpc/gen_ndr/svcctl.h

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