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