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