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