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