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