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