librpc/gen_ndr/svcctl.h

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