← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/svcctl.h

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

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=(int)(0x00000000),
43
 
        SVCCTL_STOPPED=(int)(0x00000001),
44
 
        SVCCTL_START_PENDING=(int)(0x00000002),
45
 
        SVCCTL_STOP_PENDING=(int)(0x00000003),
46
 
        SVCCTL_RUNNING=(int)(0x00000004),
47
 
        SVCCTL_CONTINUE_PENDING=(int)(0x00000005),
48
 
        SVCCTL_PAUSE_PENDING=(int)(0x00000006),
49
 
        SVCCTL_PAUSED=(int)(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|LIBNDR_FLAG_ALIGN2)] */
91
 
        const char * display_name;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2)] */
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=(int)(0x00000001),
134
 
        SVCCTL_CONTROL_PAUSE=(int)(0x00000002),
135
 
        SVCCTL_CONTROL_CONTINUE=(int)(0x00000003),
136
 
        SVCCTL_CONTROL_INTERROGATE=(int)(0x00000004),
137
 
        SVCCTL_CONTROL_SHUTDOWN=(int)(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=(int)(0x00000000),
153
 
        SVCCTL_SVC_ERROR_NORMAL=(int)(0x00000001),
154
 
        SVCCTL_SVC_ERROR_CRITICAL=(int)(0x00000002),
155
 
        SVCCTL_SVC_ERROR_SEVERE=(int)(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=(int)(0x00000000),
170
 
        SVCCTL_SYSTEM_START=(int)(0x00000001),
171
 
        SVCCTL_AUTO_START=(int)(0x00000002),
172
 
        SVCCTL_DEMAND_START=(int)(0x00000003),
173
 
        SVCCTL_DISABLED=(int)(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=(int)(0x00000001),
189
 
        SERVICE_STATE_INACTIVE=(int)(0x00000002),
190
 
        SERVICE_STATE_ALL=(int)((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=(int)(0x00000001),
239
 
        SERVICE_CONFIG_FAILURE_ACTIONS=(int)(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|LIBNDR_FLAG_ALIGN2)] */
250
 
}/* [gensize,public] */;
251
 
 
252
 
enum SC_ACTION_TYPE
253
 
#ifndef USE_UINT_ENUMS
254
 
 {
255
 
        SC_ACTION_NONE=(int)(0),
256
 
        SC_ACTION_RESTART=(int)(1),
257
 
        SC_ACTION_REBOOT=(int)(2),
258
 
        SC_ACTION_RUN_COMMAND=(int)(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|LIBNDR_FLAG_ALIGN2)] */
277
 
        const char * command;/* [relative,flag(LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2)] */
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=(int)(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 */