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