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