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