← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/svcctl.h

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

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