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