← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/idl/srvsvc.idl

  • 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/idl/srvsvc.idl
 
1
#include "idl_types.h"
 
2
 
 
3
/*
 
4
  srvsvc interface definitions
 
5
*/
 
6
import "security.idl", "svcctl.idl";
 
7
 
 
8
[ uuid("4b324fc8-1670-01d3-1278-5a47bf6ee188"),
 
9
  version(3.0),
 
10
  endpoint("ncacn_np:[\\pipe\\srvsvc]", "ncacn_ip_tcp:", "ncalrpc:"),
 
11
  pointer_default(unique),
 
12
  helpstring("Server Service")
 
13
] interface srvsvc
 
14
{
 
15
        typedef bitmap svcctl_ServerType svcctl_ServerType;
 
16
        typedef bitmap security_secinfo security_secinfo;
 
17
 
 
18
/**************************/
 
19
/* srvsvc_NetCharDev      */
 
20
/**************************/
 
21
        typedef struct {
 
22
                [string,charset(UTF16)] uint16 *device;
 
23
        } srvsvc_NetCharDevInfo0;
 
24
 
 
25
        typedef struct {
 
26
                uint32 count;
 
27
                [size_is(count)] srvsvc_NetCharDevInfo0 *array;
 
28
        } srvsvc_NetCharDevCtr0;
 
29
 
 
30
        typedef struct {
 
31
                [string,charset(UTF16)] uint16 *device;
 
32
                uint32 status;
 
33
                [string,charset(UTF16)] uint16 *user;
 
34
                uint32 time;
 
35
        } srvsvc_NetCharDevInfo1;
 
36
 
 
37
        typedef struct {
 
38
                uint32 count;
 
39
                [size_is(count)] srvsvc_NetCharDevInfo1 *array;
 
40
        } srvsvc_NetCharDevCtr1;
 
41
 
 
42
        typedef union {
 
43
                [case(0)] srvsvc_NetCharDevInfo0 *info0;
 
44
                [case(1)] srvsvc_NetCharDevInfo1 *info1;
 
45
                [default] ;
 
46
        } srvsvc_NetCharDevInfo;
 
47
 
 
48
        typedef union {
 
49
                [case(0)] srvsvc_NetCharDevCtr0 *ctr0;
 
50
                [case(1)] srvsvc_NetCharDevCtr1 *ctr1;
 
51
                [default] ;
 
52
        } srvsvc_NetCharDevCtr;
 
53
 
 
54
        typedef struct {
 
55
                uint32 level;
 
56
                [switch_is(level)] srvsvc_NetCharDevCtr ctr;
 
57
        } srvsvc_NetCharDevInfoCtr;
 
58
 
 
59
        /******************/
 
60
        /* Function: 0x00 */
 
61
        WERROR srvsvc_NetCharDevEnum(
 
62
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
63
                [in,out,ref]  srvsvc_NetCharDevInfoCtr *info_ctr,
 
64
                [in]   uint32 max_buffer,
 
65
                [out,ref]   uint32 *totalentries,
 
66
                [in,out,unique]   uint32 *resume_handle
 
67
                );
 
68
 
 
69
        /******************/
 
70
        /* Function: 0x01 */
 
71
        WERROR srvsvc_NetCharDevGetInfo(
 
72
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
73
                [in]   [string,charset(UTF16)] uint16 device_name[],
 
74
                [in]   uint32 level,
 
75
                [out,ref,switch_is(level)]   srvsvc_NetCharDevInfo *info
 
76
                );
 
77
 
 
78
        /******************/
 
79
        /* Function: 0x02 */
 
80
        WERROR srvsvc_NetCharDevControl(
 
81
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
82
                [in]   [string,charset(UTF16)] uint16 device_name[],
 
83
                [in]   uint32 opcode
 
84
                );
 
85
 
 
86
/**************************/
 
87
/* srvsvc_NetCharDevQ     */
 
88
/**************************/
 
89
        typedef struct {
 
90
                [string,charset(UTF16)] uint16 *device;
 
91
        } srvsvc_NetCharDevQInfo0;
 
92
 
 
93
        typedef struct {
 
94
                uint32 count;
 
95
                [size_is(count)] srvsvc_NetCharDevQInfo0 *array;
 
96
        } srvsvc_NetCharDevQCtr0;
 
97
 
 
98
        typedef struct {
 
99
                [string,charset(UTF16)] uint16 *device;
 
100
                uint32 priority;
 
101
                [string,charset(UTF16)] uint16 *devices;
 
102
                uint32 users;
 
103
                uint32 num_ahead;
 
104
        } srvsvc_NetCharDevQInfo1;
 
105
 
 
106
        typedef struct {
 
107
                uint32 count;
 
108
                [size_is(count)] srvsvc_NetCharDevQInfo1 *array;
 
109
        } srvsvc_NetCharDevQCtr1;
 
110
 
 
111
        typedef union {
 
112
                [case(0)] srvsvc_NetCharDevQInfo0 *info0;
 
113
                [case(1)] srvsvc_NetCharDevQInfo1 *info1;
 
114
                [default] ;
 
115
        } srvsvc_NetCharDevQInfo;
 
116
 
 
117
        typedef union {
 
118
                [case(0)] srvsvc_NetCharDevQCtr0 *ctr0;
 
119
                [case(1)] srvsvc_NetCharDevQCtr1 *ctr1;
 
120
                [default] ;
 
121
        } srvsvc_NetCharDevQCtr;
 
122
 
 
123
        typedef struct {
 
124
                uint32 level;
 
125
                [switch_is(level)] srvsvc_NetCharDevQCtr ctr;
 
126
        } srvsvc_NetCharDevQInfoCtr;
 
127
 
 
128
        /******************/
 
129
        /* Function: 0x03 */
 
130
        WERROR srvsvc_NetCharDevQEnum(
 
131
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
132
                [in,unique]   [string,charset(UTF16)] uint16 *user,
 
133
                [in,out,ref]  srvsvc_NetCharDevQInfoCtr *info_ctr,
 
134
                [in]   uint32 max_buffer,
 
135
                [out,ref]   uint32 *totalentries,
 
136
                [in,out,unique]   uint32 *resume_handle
 
137
                );
 
138
 
 
139
        /******************/
 
140
        /* Function: 0x04 */
 
141
        WERROR srvsvc_NetCharDevQGetInfo(
 
142
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
143
                [in]   [string,charset(UTF16)] uint16 queue_name[],
 
144
                [in]   [string,charset(UTF16)] uint16 user[],
 
145
                [in]   uint32 level,
 
146
                [out,switch_is(level),ref]   srvsvc_NetCharDevQInfo *info
 
147
                );
 
148
 
 
149
        /******************/
 
150
        /* Function: 0x05 */
 
151
        WERROR srvsvc_NetCharDevQSetInfo(
 
152
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
153
                [in]   [string,charset(UTF16)] uint16 queue_name[],
 
154
                [in]   uint32 level,
 
155
                [in,switch_is(level)]   srvsvc_NetCharDevQInfo info,
 
156
                [in,out,unique]   uint32 *parm_error
 
157
                );
 
158
 
 
159
        /******************/
 
160
        /* Function: 0x06 */
 
161
        WERROR srvsvc_NetCharDevQPurge(
 
162
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
163
                [in]   [string,charset(UTF16)] uint16 queue_name[]
 
164
                );
 
165
 
 
166
        /******************/
 
167
        /* Function: 0x07 */
 
168
        WERROR srvsvc_NetCharDevQPurgeSelf(
 
169
                [in,unique] [string,charset(UTF16)] uint16 *server_unc,
 
170
                [in]   [string,charset(UTF16)] uint16 queue_name[],
 
171
                [in]   [string,charset(UTF16)] uint16 computer_name[]
 
172
                );
 
173
 
 
174
/**************************/
 
175
/* srvsvc_NetConn         */
 
176
/**************************/
 
177
        typedef struct {
 
178
                uint32 conn_id;
 
179
        } srvsvc_NetConnInfo0;
 
180
 
 
181
        typedef struct {
 
182
                uint32 count;
 
183
                [size_is(count)] srvsvc_NetConnInfo0 *array;
 
184
        } srvsvc_NetConnCtr0;
 
185
 
 
186
        typedef struct {
 
187
                uint32 conn_id;
 
188
                uint32 conn_type;
 
189
                uint32 num_open;
 
190
                uint32 num_users;
 
191
                uint32 conn_time;
 
192
                [string,charset(UTF16)] uint16 *user;
 
193
                [string,charset(UTF16)] uint16 *share;
 
194
        } srvsvc_NetConnInfo1;
 
195
 
 
196
        typedef struct {
 
197
                uint32 count;
 
198
                [size_is(count)] srvsvc_NetConnInfo1 *array;
 
199
        } srvsvc_NetConnCtr1;
 
200
 
 
201
        typedef union {
 
202
                [case(0)] srvsvc_NetConnCtr0 *ctr0;
 
203
                [case(1)] srvsvc_NetConnCtr1 *ctr1;
 
204
                [default] ;
 
205
        } srvsvc_NetConnCtr;
 
206
 
 
207
        typedef struct {
 
208
                uint32 level;
 
209
                [switch_is(level)] srvsvc_NetConnCtr ctr;
 
210
        } srvsvc_NetConnInfoCtr;
 
211
 
 
212
        /******************/
 
213
        /* Function: 0x08 */
 
214
        WERROR srvsvc_NetConnEnum(
 
215
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
216
                [in,unique]   [string,charset(UTF16)] uint16 *path,
 
217
                [in,out,ref]  srvsvc_NetConnInfoCtr *info_ctr,
 
218
                [in]   uint32 max_buffer,
 
219
                [out,ref]   uint32 *totalentries,
 
220
                [in,out,unique]   uint32 *resume_handle
 
221
                );
 
222
 
 
223
/**************************/
 
224
/* srvsvc_NetFile         */
 
225
/**************************/
 
226
        typedef struct {
 
227
                uint32 fid;
 
228
        } srvsvc_NetFileInfo2;
 
229
 
 
230
        typedef struct {
 
231
                uint32 count;
 
232
                [size_is(count)] srvsvc_NetFileInfo2 *array;
 
233
        } srvsvc_NetFileCtr2;
 
234
 
 
235
        typedef struct {
 
236
                uint32 fid;
 
237
                uint32 permissions;
 
238
                uint32 num_locks;
 
239
                [string,charset(UTF16)] uint16 *path;
 
240
                [string,charset(UTF16)] uint16 *user;
 
241
        } srvsvc_NetFileInfo3;
 
242
 
 
243
        typedef struct {
 
244
                uint32 count;
 
245
                [size_is(count)] srvsvc_NetFileInfo3 *array;
 
246
        } srvsvc_NetFileCtr3;
 
247
 
 
248
        typedef union {
 
249
                [case(2)] srvsvc_NetFileInfo2 *info2;
 
250
                [case(3)] srvsvc_NetFileInfo3 *info3;
 
251
                [default] ;
 
252
        } srvsvc_NetFileInfo;
 
253
 
 
254
        typedef union {
 
255
                [case(2)] srvsvc_NetFileCtr2 *ctr2;
 
256
                [case(3)] srvsvc_NetFileCtr3 *ctr3;
 
257
                [default] ;
 
258
        } srvsvc_NetFileCtr;
 
259
 
 
260
        typedef struct {
 
261
                uint32 level;
 
262
                [switch_is(level)] srvsvc_NetFileCtr ctr;
 
263
        } srvsvc_NetFileInfoCtr;
 
264
 
 
265
        /******************/
 
266
        /* Function: 0x09 */
 
267
        WERROR srvsvc_NetFileEnum(
 
268
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
269
                [in,unique]   [string,charset(UTF16)] uint16 *path,
 
270
                [in,unique]   [string,charset(UTF16)] uint16 *user,
 
271
                [in,out,ref]   srvsvc_NetFileInfoCtr *info_ctr,
 
272
                [in]   uint32 max_buffer,
 
273
                [out,ref]   uint32 *totalentries,
 
274
                [in,out,unique]   uint32 *resume_handle
 
275
                );
 
276
 
 
277
        /******************/
 
278
        /* Function: 0x0a */
 
279
        WERROR srvsvc_NetFileGetInfo(
 
280
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
281
                [in]   uint32 fid,
 
282
                [in]   uint32 level,
 
283
                [out,switch_is(level),ref]   srvsvc_NetFileInfo *info
 
284
                );
 
285
 
 
286
        /******************/
 
287
        /* Function: 0x0b */
 
288
        WERROR srvsvc_NetFileClose(
 
289
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
290
                [in]   uint32 fid
 
291
                );
 
292
 
 
293
/**************************/
 
294
/* srvsvc_NetSess         */
 
295
/**************************/
 
296
        typedef struct {
 
297
                [string,charset(UTF16)] uint16 *client;
 
298
        } srvsvc_NetSessInfo0;
 
299
 
 
300
        typedef struct {
 
301
                uint32 count;
 
302
                [size_is(count)] srvsvc_NetSessInfo0 *array;
 
303
        } srvsvc_NetSessCtr0;
 
304
 
 
305
        typedef struct {
 
306
                [string,charset(UTF16)] uint16 *client;
 
307
                [string,charset(UTF16)] uint16 *user;
 
308
                uint32 num_open;
 
309
                uint32 time;
 
310
                uint32 idle_time;
 
311
                uint32 user_flags;
 
312
        } srvsvc_NetSessInfo1;
 
313
 
 
314
        typedef struct {
 
315
                uint32 count;
 
316
                [size_is(count)] srvsvc_NetSessInfo1 *array;
 
317
        } srvsvc_NetSessCtr1;
 
318
 
 
319
        typedef struct {
 
320
                [string,charset(UTF16)] uint16 *client;
 
321
                [string,charset(UTF16)] uint16 *user;
 
322
                uint32 num_open;
 
323
                uint32 time;
 
324
                uint32 idle_time;
 
325
                uint32 user_flags;
 
326
                [string,charset(UTF16)] uint16 *client_type;
 
327
        } srvsvc_NetSessInfo2;
 
328
 
 
329
        typedef struct {
 
330
                uint32 count;
 
331
                [size_is(count)] srvsvc_NetSessInfo2 *array;
 
332
        } srvsvc_NetSessCtr2;
 
333
 
 
334
        typedef struct {
 
335
                [string,charset(UTF16)] uint16 *client;
 
336
                [string,charset(UTF16)] uint16 *user;
 
337
                uint32 time;
 
338
                uint32 idle_time;
 
339
        } srvsvc_NetSessInfo10;
 
340
 
 
341
        typedef struct {
 
342
                uint32 count;
 
343
                [size_is(count)] srvsvc_NetSessInfo10 *array;
 
344
        } srvsvc_NetSessCtr10;
 
345
 
 
346
        typedef struct {
 
347
                [string,charset(UTF16)] uint16 *client;
 
348
                [string,charset(UTF16)] uint16 *user;
 
349
                uint32 num_open;
 
350
                uint32 time;
 
351
                uint32 idle_time;
 
352
                uint32 user_flags;
 
353
                [string,charset(UTF16)] uint16 *client_type;
 
354
                [string,charset(UTF16)] uint16 *transport;
 
355
        } srvsvc_NetSessInfo502;
 
356
 
 
357
        typedef struct {
 
358
                uint32 count;
 
359
                [size_is(count)] srvsvc_NetSessInfo502 *array;
 
360
        } srvsvc_NetSessCtr502;
 
361
 
 
362
        typedef union {
 
363
                [case(0)] srvsvc_NetSessCtr0 *ctr0;
 
364
                [case(1)] srvsvc_NetSessCtr1 *ctr1;
 
365
                [case(2)] srvsvc_NetSessCtr2 *ctr2;
 
366
                [case(10)] srvsvc_NetSessCtr10 *ctr10;
 
367
                [case(502)] srvsvc_NetSessCtr502 *ctr502;
 
368
                [default] ;
 
369
        } srvsvc_NetSessCtr;
 
370
 
 
371
        /******************/
 
372
        /* Function: 0x0c */
 
373
 
 
374
        typedef struct {
 
375
                uint32 level;
 
376
                [switch_is(level)] srvsvc_NetSessCtr ctr;
 
377
        } srvsvc_NetSessInfoCtr;
 
378
 
 
379
        WERROR srvsvc_NetSessEnum(
 
380
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
381
                [in,unique]   [string,charset(UTF16)] uint16 *client,
 
382
                [in,unique]   [string,charset(UTF16)] uint16 *user,
 
383
                [in,out,ref]   srvsvc_NetSessInfoCtr *info_ctr,
 
384
                [in]   uint32 max_buffer,
 
385
                [out,ref]   uint32 *totalentries,
 
386
                [in,out,unique]   uint32 *resume_handle
 
387
                );
 
388
 
 
389
        /******************/
 
390
        /* Function: 0x0d */
 
391
        WERROR srvsvc_NetSessDel(
 
392
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
393
                [in,unique]   [string,charset(UTF16)] uint16 *client,
 
394
                [in,unique]   [string,charset(UTF16)] uint16 *user
 
395
                );
 
396
 
 
397
/**************************/
 
398
/* srvsvc_NetShare        */
 
399
/**************************/
 
400
 
 
401
        /* share types */
 
402
        const uint32 STYPE_TEMPORARY = 0x40000000; /* share is a temporary one */
 
403
        const uint32 STYPE_HIDDEN    = 0x80000000; /* share is a hidden one */
 
404
 
 
405
        typedef [v1_enum, flag(NDR_PAHEX)] enum {
 
406
                STYPE_DISKTREE = 0,
 
407
                STYPE_DISKTREE_TEMPORARY = STYPE_DISKTREE|STYPE_TEMPORARY,
 
408
                STYPE_DISKTREE_HIDDEN    = STYPE_DISKTREE|STYPE_HIDDEN,
 
409
                STYPE_PRINTQ   = 1,
 
410
                STYPE_PRINTQ_TEMPORARY = STYPE_PRINTQ|STYPE_TEMPORARY,
 
411
                STYPE_PRINTQ_HIDDEN    = STYPE_PRINTQ|STYPE_HIDDEN,
 
412
                STYPE_DEVICE   = 2,     /* Serial device */
 
413
                STYPE_DEVICE_TEMPORARY = STYPE_DEVICE|STYPE_TEMPORARY,
 
414
                STYPE_DEVICE_HIDDEN    = STYPE_DEVICE|STYPE_HIDDEN,
 
415
                STYPE_IPC      = 3,     /* Interprocess communication (IPC) */
 
416
                STYPE_IPC_TEMPORARY = STYPE_IPC|STYPE_TEMPORARY,
 
417
                STYPE_IPC_HIDDEN    = STYPE_IPC|STYPE_HIDDEN
 
418
        } srvsvc_ShareType;
 
419
 
 
420
        typedef struct {
 
421
                [string,charset(UTF16)] uint16 *name;
 
422
        } srvsvc_NetShareInfo0;
 
423
 
 
424
        typedef struct {
 
425
                uint32 count;
 
426
                [size_is(count)] srvsvc_NetShareInfo0 *array;
 
427
        } srvsvc_NetShareCtr0;
 
428
 
 
429
        typedef struct {
 
430
                [string,charset(UTF16)] uint16 *name;
 
431
                srvsvc_ShareType type;
 
432
                [string,charset(UTF16)] uint16 *comment;
 
433
        } srvsvc_NetShareInfo1;
 
434
 
 
435
        typedef struct {
 
436
                uint32 count;
 
437
                [size_is(count)] srvsvc_NetShareInfo1 *array;
 
438
        } srvsvc_NetShareCtr1;
 
439
 
 
440
        typedef struct {
 
441
                [string,charset(UTF16)] uint16 *name;
 
442
                srvsvc_ShareType type;
 
443
                [string,charset(UTF16)] uint16 *comment;
 
444
                uint32 permissions;
 
445
                uint32 max_users;
 
446
                uint32 current_users;
 
447
                [string,charset(UTF16)] uint16 *path;
 
448
                [string,charset(UTF16)] uint16 *password;
 
449
        } srvsvc_NetShareInfo2;
 
450
 
 
451
        typedef struct {
 
452
                uint32 count;
 
453
                [size_is(count)] srvsvc_NetShareInfo2 *array;
 
454
        } srvsvc_NetShareCtr2;
 
455
 
 
456
        typedef struct {
 
457
                [string,charset(UTF16)] uint16 *name;
 
458
                srvsvc_ShareType type;
 
459
                [string,charset(UTF16)] uint16 *comment;
 
460
                uint32 csc_policy;
 
461
        } srvsvc_NetShareInfo501;
 
462
 
 
463
        typedef struct {
 
464
                uint32 count;
 
465
                [size_is(count)] srvsvc_NetShareInfo501 *array;
 
466
        } srvsvc_NetShareCtr501;
 
467
 
 
468
        typedef struct {
 
469
                [string,charset(UTF16)] uint16 *name;
 
470
                srvsvc_ShareType type;
 
471
                [string,charset(UTF16)] uint16 *comment;
 
472
                uint32 permissions;
 
473
                uint32 max_users;
 
474
                uint32 current_users;
 
475
                [string,charset(UTF16)] uint16 *path;
 
476
                [string,charset(UTF16)] uint16 *password;
 
477
                sec_desc_buf sd_buf;
 
478
        } srvsvc_NetShareInfo502;
 
479
 
 
480
        typedef struct {
 
481
                uint32 count;
 
482
                [size_is(count)] srvsvc_NetShareInfo502 *array;
 
483
        } srvsvc_NetShareCtr502;
 
484
 
 
485
        typedef struct {
 
486
                [string,charset(UTF16)] uint16 *comment;
 
487
        } srvsvc_NetShareInfo1004;
 
488
 
 
489
        typedef struct {
 
490
                uint32 count;
 
491
                [size_is(count)] srvsvc_NetShareInfo1004 *array;
 
492
        } srvsvc_NetShareCtr1004;
 
493
 
 
494
        typedef bitmap {
 
495
                SHARE_1005_IN_DFS               = 0x00000001,
 
496
                SHARE_1005_DFS_ROOT             = 0x00000002
 
497
        } NetShareInfo1005Flags;
 
498
 
 
499
        const uint32 SHARE_1005_CSC_POLICY_MASK = 0x00000030;
 
500
        const uint32 SHARE_1005_CSC_POLICY_SHIFT = 4;
 
501
 
 
502
        typedef struct {
 
503
                NetShareInfo1005Flags dfs_flags;
 
504
        } srvsvc_NetShareInfo1005;
 
505
 
 
506
        typedef struct {
 
507
                uint32 count;
 
508
                [size_is(count)] srvsvc_NetShareInfo1005 *array;
 
509
        } srvsvc_NetShareCtr1005;
 
510
 
 
511
        typedef struct {
 
512
                uint32 max_users;
 
513
        } srvsvc_NetShareInfo1006;
 
514
 
 
515
        typedef struct {
 
516
                uint32 count;
 
517
                [size_is(count)] srvsvc_NetShareInfo1006 *array;
 
518
        } srvsvc_NetShareCtr1006;
 
519
 
 
520
        typedef struct {
 
521
                uint32 flags;
 
522
                [string,charset(UTF16)] uint16 *alternate_directory_name;
 
523
        } srvsvc_NetShareInfo1007;
 
524
 
 
525
        typedef struct {
 
526
                uint32 count;
 
527
                [size_is(count)] srvsvc_NetShareInfo1007 *array;
 
528
        } srvsvc_NetShareCtr1007;
 
529
 
 
530
        typedef struct {
 
531
                uint32 count;
 
532
                [size_is(count)] sec_desc_buf *array;
 
533
        } srvsvc_NetShareCtr1501;
 
534
 
 
535
        typedef union {
 
536
                [case(0)] srvsvc_NetShareInfo0 *info0;
 
537
                [case(1)] srvsvc_NetShareInfo1 *info1;
 
538
                [case(2)] srvsvc_NetShareInfo2 *info2;
 
539
                [case(501)] srvsvc_NetShareInfo501 *info501;
 
540
                [case(502)] srvsvc_NetShareInfo502 *info502;
 
541
                [case(1004)] srvsvc_NetShareInfo1004 *info1004;
 
542
                [case(1005)] srvsvc_NetShareInfo1005 *info1005;
 
543
                [case(1006)] srvsvc_NetShareInfo1006 *info1006;
 
544
                [case(1007)] srvsvc_NetShareInfo1007 *info1007;
 
545
                [case(1501)] sec_desc_buf *info1501;
 
546
                [default] ;
 
547
        } srvsvc_NetShareInfo;
 
548
 
 
549
        typedef union {
 
550
                [case(0)] srvsvc_NetShareCtr0 *ctr0;
 
551
                [case(1)] srvsvc_NetShareCtr1 *ctr1;
 
552
                [case(2)] srvsvc_NetShareCtr2 *ctr2;
 
553
                [case(501)] srvsvc_NetShareCtr501 *ctr501;
 
554
                [case(502)] srvsvc_NetShareCtr502 *ctr502;
 
555
                [case(1004)] srvsvc_NetShareCtr1004 *ctr1004;
 
556
                [case(1005)] srvsvc_NetShareCtr1005 *ctr1005;
 
557
                [case(1006)] srvsvc_NetShareCtr1006 *ctr1006;
 
558
                [case(1007)] srvsvc_NetShareCtr1007 *ctr1007;
 
559
                [case(1501)] srvsvc_NetShareCtr1501 *ctr1501;
 
560
                [default] ;
 
561
        } srvsvc_NetShareCtr;
 
562
 
 
563
        typedef struct {
 
564
                uint32 level;
 
565
                [switch_is(level)] srvsvc_NetShareCtr ctr;
 
566
        } srvsvc_NetShareInfoCtr;
 
567
 
 
568
        /******************/
 
569
        /* Function: 0x0e */
 
570
        WERROR srvsvc_NetShareAdd(
 
571
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
572
                [in]   uint32 level,
 
573
                [in,ref,switch_is(level)] srvsvc_NetShareInfo *info,
 
574
                [in,out,unique]   uint32 *parm_error
 
575
                );
 
576
 
 
577
        /******************/
 
578
        /* Function: 0x0f */
 
579
        WERROR srvsvc_NetShareEnumAll (
 
580
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
581
                [in,out,ref] srvsvc_NetShareInfoCtr *info_ctr,
 
582
                [in]   uint32 max_buffer,
 
583
                [out,ref]  uint32 *totalentries,
 
584
                [in,out,unique]   uint32 *resume_handle
 
585
                );
 
586
 
 
587
        /******************/
 
588
        /* Function: 0x10 */
 
589
        WERROR srvsvc_NetShareGetInfo(
 
590
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
591
                [in]   [string,charset(UTF16)] uint16 share_name[],
 
592
                [in]   uint32 level,
 
593
                [out,ref,switch_is(level)] srvsvc_NetShareInfo *info
 
594
                );
 
595
 
 
596
        /******************/
 
597
        /* Function: 0x11 */
 
598
        WERROR srvsvc_NetShareSetInfo(
 
599
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
600
                [in]   [string,charset(UTF16)] uint16 share_name[],
 
601
                [in]   uint32 level,
 
602
                [in,ref,switch_is(level)] srvsvc_NetShareInfo *info,
 
603
                [in,out,unique]   uint32 *parm_error
 
604
                );
 
605
 
 
606
        /******************/
 
607
        /* Function: 0x12 */
 
608
        WERROR srvsvc_NetShareDel(
 
609
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
610
                [in]   [string,charset(UTF16)] uint16 share_name[],
 
611
                [in]   uint32 reserved
 
612
                );
 
613
 
 
614
        /******************/
 
615
        /* Function: 0x13 */
 
616
        WERROR srvsvc_NetShareDelSticky(
 
617
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
618
                [in]   [string,charset(UTF16)] uint16 share_name[],
 
619
                [in]   uint32 reserved
 
620
                );
 
621
 
 
622
        /******************/
 
623
        /* Function: 0x14 */
 
624
        WERROR srvsvc_NetShareCheck(
 
625
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
626
                [in]   [string,charset(UTF16)] uint16 device_name[],
 
627
                [out,ref]  srvsvc_ShareType *type
 
628
                );
 
629
 
 
630
/**************************/
 
631
/* srvsvc_NetSrv          */
 
632
/**************************/
 
633
        typedef [public,v1_enum] enum {
 
634
                PLATFORM_ID_DOS = 300,
 
635
                PLATFORM_ID_OS2 = 400,
 
636
                PLATFORM_ID_NT  = 500,
 
637
                PLATFORM_ID_OSF = 600,
 
638
                PLATFORM_ID_VMS = 700
 
639
        } srvsvc_PlatformId;
 
640
 
 
641
        typedef [public] struct {
 
642
                srvsvc_PlatformId platform_id;
 
643
                [string,charset(UTF16)] uint16 *server_name;
 
644
        } srvsvc_NetSrvInfo100;
 
645
 
 
646
        typedef [public] struct {
 
647
                srvsvc_PlatformId platform_id;
 
648
                [string,charset(UTF16)] uint16 *server_name;
 
649
                uint32 version_major;
 
650
                uint32 version_minor;
 
651
                svcctl_ServerType server_type;
 
652
                [string,charset(UTF16)] uint16 *comment;
 
653
        } srvsvc_NetSrvInfo101;
 
654
 
 
655
        typedef struct {
 
656
                srvsvc_PlatformId platform_id;
 
657
                [string,charset(UTF16)] uint16 *server_name;
 
658
                uint32 version_major;
 
659
                uint32 version_minor;
 
660
                svcctl_ServerType server_type;
 
661
                [string,charset(UTF16)] uint16 *comment;
 
662
                uint32 users;
 
663
                uint32 disc;
 
664
                uint32 hidden;
 
665
                uint32 announce;
 
666
                uint32 anndelta;
 
667
                uint32 licenses;
 
668
                [string,charset(UTF16)] uint16 *userpath;
 
669
        } srvsvc_NetSrvInfo102;
 
670
 
 
671
        typedef struct {
 
672
                uint32 ulist_mtime;
 
673
                uint32 glist_mtime;
 
674
                uint32 alist_mtime;
 
675
                [string,charset(UTF16)] uint16 *alerts;
 
676
                uint32 security;
 
677
                uint32 numadmin;
 
678
                uint32 lanmask;
 
679
                [string,charset(UTF16)] uint16 *guestaccount;
 
680
                uint32 chdevs;
 
681
                uint32 chdevqs;
 
682
                uint32 chdevjobs;
 
683
                uint32 connections;
 
684
                uint32 shares;
 
685
                uint32 openfiles;
 
686
                uint32 sessopen;
 
687
                uint32 sesssvc;
 
688
                uint32 sessreqs;
 
689
                uint32 opensearch;
 
690
                uint32 activelocks;
 
691
                uint32 numreqbufs;
 
692
                uint32 sizereqbufs;
 
693
                uint32 numbigbufs;
 
694
                uint32 numfiletasks;
 
695
                uint32 alertsched;
 
696
                uint32 erroralert;
 
697
                uint32 logonalert;
 
698
                uint32 accessalert;
 
699
                uint32 diskalert;
 
700
                uint32 netioalert;
 
701
                uint32 maxaudits;
 
702
                [string,charset(UTF16)] uint16 *srvheuristics;
 
703
        } srvsvc_NetSrvInfo402;
 
704
 
 
705
        typedef struct {
 
706
                uint32 ulist_mtime;
 
707
                uint32 glist_mtime;
 
708
                uint32 alist_mtime;
 
709
                [string,charset(UTF16)] uint16 *alerts;
 
710
                uint32 security;
 
711
                uint32 numadmin;
 
712
                uint32 lanmask;
 
713
                [string,charset(UTF16)] uint16 *guestaccount;
 
714
                uint32 chdevs;
 
715
                uint32 chdevqs;
 
716
                uint32 chdevjobs;
 
717
                uint32 connections;
 
718
                uint32 shares;
 
719
                uint32 openfiles;
 
720
                uint32 sessopen;
 
721
                uint32 sesssvc;
 
722
                uint32 sessreqs;
 
723
                uint32 opensearch;
 
724
                uint32 activelocks;
 
725
                uint32 numreqbufs;
 
726
                uint32 sizereqbufs;
 
727
                uint32 numbigbufs;
 
728
                uint32 numfiletasks;
 
729
                uint32 alertsched;
 
730
                uint32 erroralert;
 
731
                uint32 logonalert;
 
732
                uint32 accessalert;
 
733
                uint32 diskalert;
 
734
                uint32 netioalert;
 
735
                uint32 maxaudits;
 
736
                [string,charset(UTF16)] uint16 *srvheuristics;
 
737
                uint32 auditedevents;
 
738
                uint32 auditprofile;
 
739
                [string,charset(UTF16)] uint16 *autopath;
 
740
        } srvsvc_NetSrvInfo403;
 
741
 
 
742
        typedef struct {
 
743
                uint32 sessopen;
 
744
                uint32 sesssvc;
 
745
                uint32 opensearch;
 
746
                uint32 sizereqbufs;
 
747
                uint32 initworkitems;
 
748
                uint32 maxworkitems;
 
749
                uint32 rawworkitems;
 
750
                uint32 irpstacksize;
 
751
                uint32 maxrawbuflen;
 
752
                uint32 sessusers;
 
753
                uint32 sessconns;
 
754
                uint32 maxpagedmemoryusage;
 
755
                uint32 maxnonpagedmemoryusage;
 
756
                uint32 enablesoftcompat;
 
757
                uint32 enableforcedlogoff;
 
758
                uint32 timesource;
 
759
                uint32 acceptdownlevelapis;
 
760
                uint32 lmannounce;
 
761
        } srvsvc_NetSrvInfo502;
 
762
 
 
763
        typedef struct{
 
764
                uint32 sessopen;
 
765
                uint32 sesssvc;
 
766
                uint32 opensearch;
 
767
                uint32 sizereqbufs;
 
768
                uint32 initworkitems;
 
769
                uint32 maxworkitems;
 
770
                uint32 rawworkitems;
 
771
                uint32 irpstacksize;
 
772
                uint32 maxrawbuflen;
 
773
                uint32 sessusers;
 
774
                uint32 sessconns;
 
775
                uint32 maxpagedmemoryusage;
 
776
                uint32 maxnonpagedmemoryusage;
 
777
                uint32 enablesoftcompat;
 
778
                uint32 enableforcedlogoff;
 
779
                uint32 timesource;
 
780
                uint32 acceptdownlevelapis;
 
781
                uint32 lmannounce;
 
782
                [string,charset(UTF16)] uint16 *domain;
 
783
                uint32 maxcopyreadlen;
 
784
                uint32 maxcopywritelen;
 
785
                uint32 minkeepsearch;
 
786
                uint32 maxkeepsearch;
 
787
                uint32 minkeepcomplsearch;
 
788
                uint32 maxkeepcomplsearch;
 
789
                uint32 threadcountadd;
 
790
                uint32 numlockthreads;
 
791
                uint32 scavtimeout;
 
792
                uint32 minrcvqueue;
 
793
                uint32 minfreeworkitems;
 
794
                uint32 xactmemsize;
 
795
                uint32 threadpriority;
 
796
                uint32 maxmpxct;
 
797
                uint32 oplockbreakwait;
 
798
                uint32 oplockbreakresponsewait;
 
799
                uint32 enableoplocks;
 
800
                uint32 enableoplockforceclose;
 
801
                uint32 enablefcbopens;
 
802
                uint32 enableraw;
 
803
                uint32 enablesharednetdrives;
 
804
                uint32 minfreeconnections;
 
805
                uint32 maxfreeconnections;
 
806
        } srvsvc_NetSrvInfo503;
 
807
 
 
808
        typedef struct{
 
809
                uint32 sessopen;
 
810
                uint32 sesssvc;
 
811
                uint32 opensearch;
 
812
                uint32 sizereqbufs;
 
813
                uint32 initworkitems;
 
814
                uint32 maxworkitems;
 
815
                uint32 rawworkitems;
 
816
                uint32 irpstacksize;
 
817
                uint32 maxrawbuflen;
 
818
                uint32 sessusers;
 
819
                uint32 sessconns;
 
820
                uint32 maxpagedmemoryusage;
 
821
                uint32 maxnonpagedmemoryusage;
 
822
                uint32 enablesoftcompat;
 
823
                uint32 enableforcedlogoff;
 
824
                uint32 timesource;
 
825
                uint32 acceptdownlevelapis;
 
826
                uint32 lmannounce;
 
827
                [string,charset(UTF16)] uint16 *domain;
 
828
                uint32 maxcopyreadlen;
 
829
                uint32 maxcopywritelen;
 
830
                uint32 minkeepsearch;
 
831
                uint32 minkeepcomplsearch;
 
832
                uint32 maxkeepcomplsearch;
 
833
                uint32 threadcountadd;
 
834
                uint32 numlockthreads;
 
835
                uint32 scavtimeout;
 
836
                uint32 minrcvqueue;
 
837
                uint32 minfreeworkitems;
 
838
                uint32 xactmemsize;
 
839
                uint32 threadpriority;
 
840
                uint32 maxmpxct;
 
841
                uint32 oplockbreakwait;
 
842
                uint32 oplockbreakresponsewait;
 
843
                uint32 enableoplocks;
 
844
                uint32 enableoplockforceclose;
 
845
                uint32 enablefcbopens;
 
846
                uint32 enableraw;
 
847
                uint32 enablesharednetdrives;
 
848
                uint32 minfreeconnections;
 
849
                uint32 maxfreeconnections;
 
850
                uint32 initsesstable;
 
851
                uint32 initconntable;
 
852
                uint32 initfiletable;
 
853
                uint32 initsearchtable;
 
854
                uint32 alertsched;
 
855
                uint32 errortreshold;
 
856
                uint32 networkerrortreshold;
 
857
                uint32 diskspacetreshold;
 
858
                uint32 reserved;
 
859
                uint32 maxlinkdelay;
 
860
                uint32 minlinkthroughput;
 
861
                uint32 linkinfovalidtime;
 
862
                uint32 scavqosinfoupdatetime;
 
863
                uint32 maxworkitemidletime;
 
864
        } srvsvc_NetSrvInfo599;
 
865
 
 
866
        typedef struct{
 
867
                [string,charset(UTF16)] uint16 *comment;
 
868
        } srvsvc_NetSrvInfo1005;
 
869
 
 
870
        typedef struct{
 
871
                uint32 disc;
 
872
        } srvsvc_NetSrvInfo1010;
 
873
 
 
874
        typedef struct{
 
875
                uint32 hidden;
 
876
        } srvsvc_NetSrvInfo1016;
 
877
 
 
878
        typedef struct{
 
879
                uint32 announce;
 
880
        } srvsvc_NetSrvInfo1017;
 
881
 
 
882
        typedef struct{
 
883
                uint32 anndelta;
 
884
        } srvsvc_NetSrvInfo1018;
 
885
 
 
886
        typedef struct{
 
887
                uint32 users;
 
888
        } srvsvc_NetSrvInfo1107;
 
889
 
 
890
        typedef struct{
 
891
                uint32 sessopens;
 
892
        } srvsvc_NetSrvInfo1501;
 
893
 
 
894
        typedef struct{
 
895
                uint32 sessvcs;
 
896
        } srvsvc_NetSrvInfo1502;
 
897
 
 
898
        typedef struct{
 
899
                uint32 opensearch;
 
900
        } srvsvc_NetSrvInfo1503;
 
901
 
 
902
        typedef struct{
 
903
                uint32 maxworkitems;
 
904
        } srvsvc_NetSrvInfo1506;
 
905
 
 
906
        typedef struct{
 
907
                uint32 maxrawbuflen;
 
908
        } srvsvc_NetSrvInfo1509;
 
909
 
 
910
        typedef struct{
 
911
                uint32 sessusers;
 
912
        } srvsvc_NetSrvInfo1510;
 
913
 
 
914
        typedef struct{
 
915
                uint32 sesscons;
 
916
        } srvsvc_NetSrvInfo1511;
 
917
 
 
918
        typedef struct{
 
919
                uint32 maxnonpagedmemoryusage;
 
920
        } srvsvc_NetSrvInfo1512;
 
921
 
 
922
        typedef struct{
 
923
                uint32 maxpagedmemoryusage;
 
924
        } srvsvc_NetSrvInfo1513;
 
925
 
 
926
        typedef struct{
 
927
                uint32 enablesoftcompat;
 
928
        } srvsvc_NetSrvInfo1514;
 
929
 
 
930
        typedef struct{
 
931
                uint32 enableforcedlogoff;
 
932
        } srvsvc_NetSrvInfo1515;
 
933
 
 
934
        typedef struct{
 
935
                uint32 timesource;
 
936
        } srvsvc_NetSrvInfo1516;
 
937
 
 
938
        typedef struct{
 
939
                uint32 lmannounce;
 
940
        } srvsvc_NetSrvInfo1518;
 
941
 
 
942
        typedef struct{
 
943
                uint32 maxcopyreadlen;
 
944
        } srvsvc_NetSrvInfo1520;
 
945
 
 
946
        typedef struct{
 
947
                uint32 maxcopywritelen;
 
948
        } srvsvc_NetSrvInfo1521;
 
949
 
 
950
        typedef struct{
 
951
                uint32 minkeepsearch;
 
952
        } srvsvc_NetSrvInfo1522;
 
953
 
 
954
        typedef struct{
 
955
                uint32 maxkeepsearch;
 
956
        } srvsvc_NetSrvInfo1523;
 
957
 
 
958
        typedef struct{
 
959
                uint32 minkeepcomplsearch;
 
960
        } srvsvc_NetSrvInfo1524;
 
961
 
 
962
        typedef struct{
 
963
                uint32 maxkeepcomplsearch;
 
964
        } srvsvc_NetSrvInfo1525;
 
965
 
 
966
        typedef struct{
 
967
                uint32 scavtimeout;
 
968
        } srvsvc_NetSrvInfo1528;
 
969
 
 
970
        typedef struct{
 
971
                uint32 minrcvqueue;
 
972
        } srvsvc_NetSrvInfo1529;
 
973
 
 
974
        typedef struct{
 
975
                uint32 minfreeworkitems;
 
976
        } srvsvc_NetSrvInfo1530;
 
977
 
 
978
        typedef struct{
 
979
                uint32 maxmpxct;
 
980
        } srvsvc_NetSrvInfo1533;
 
981
 
 
982
        typedef struct{
 
983
                uint32 oplockbreakwait;
 
984
        } srvsvc_NetSrvInfo1534;
 
985
 
 
986
        typedef struct{
 
987
                uint32 oplockbreakresponsewait;
 
988
        } srvsvc_NetSrvInfo1535;
 
989
 
 
990
        typedef struct{
 
991
                uint32 enableoplocks;
 
992
        } srvsvc_NetSrvInfo1536;
 
993
 
 
994
        typedef struct{
 
995
                uint32 enableoplockforceclose;
 
996
        } srvsvc_NetSrvInfo1537;
 
997
 
 
998
        typedef struct{
 
999
                uint32 enablefcbopens;
 
1000
        } srvsvc_NetSrvInfo1538;
 
1001
 
 
1002
        typedef struct{
 
1003
                uint32 enableraw;
 
1004
        } srvsvc_NetSrvInfo1539;
 
1005
 
 
1006
        typedef struct{
 
1007
                uint32 enablesharednetdrives;
 
1008
        } srvsvc_NetSrvInfo1540;
 
1009
 
 
1010
        typedef struct{
 
1011
                uint32 minfreeconnections;
 
1012
        } srvsvc_NetSrvInfo1541;
 
1013
 
 
1014
        typedef struct{
 
1015
                uint32 maxfreeconnections;
 
1016
        } srvsvc_NetSrvInfo1542;
 
1017
 
 
1018
        typedef struct{
 
1019
                uint32 initsesstable;
 
1020
        } srvsvc_NetSrvInfo1543;
 
1021
 
 
1022
        typedef struct{
 
1023
                uint32 initconntable;
 
1024
        } srvsvc_NetSrvInfo1544;
 
1025
 
 
1026
        typedef struct{
 
1027
                uint32 initfiletable;
 
1028
        } srvsvc_NetSrvInfo1545;
 
1029
 
 
1030
        typedef struct{
 
1031
                uint32 initsearchtable;
 
1032
        } srvsvc_NetSrvInfo1546;
 
1033
 
 
1034
        typedef struct{
 
1035
                uint32 alertsched;
 
1036
        } srvsvc_NetSrvInfo1547;
 
1037
 
 
1038
        typedef struct{
 
1039
                uint32 errortreshold;
 
1040
        } srvsvc_NetSrvInfo1548;
 
1041
 
 
1042
        typedef struct{
 
1043
                uint32 networkerrortreshold;
 
1044
        } srvsvc_NetSrvInfo1549;
 
1045
 
 
1046
        typedef struct{
 
1047
                uint32 diskspacetreshold;
 
1048
        } srvsvc_NetSrvInfo1550;
 
1049
 
 
1050
        typedef struct{
 
1051
                uint32 maxlinkdelay;
 
1052
        } srvsvc_NetSrvInfo1552;
 
1053
 
 
1054
        typedef struct{
 
1055
                uint32 minlinkthroughput;
 
1056
        } srvsvc_NetSrvInfo1553;
 
1057
 
 
1058
        typedef struct{
 
1059
                uint32 linkinfovalidtime;
 
1060
        } srvsvc_NetSrvInfo1554;
 
1061
 
 
1062
        typedef struct{
 
1063
                uint32 scavqosinfoupdatetime;
 
1064
        } srvsvc_NetSrvInfo1555;
 
1065
 
 
1066
        typedef struct{
 
1067
                uint32 maxworkitemidletime;
 
1068
        } srvsvc_NetSrvInfo1556;
 
1069
 
 
1070
 
 
1071
        typedef union{
 
1072
                [case(100)]     srvsvc_NetSrvInfo100 *info100;
 
1073
                [case(101)]     srvsvc_NetSrvInfo101 *info101;
 
1074
                [case(102)]     srvsvc_NetSrvInfo102 *info102;
 
1075
                [case(402)]     srvsvc_NetSrvInfo402 *info402;
 
1076
                [case(403)]     srvsvc_NetSrvInfo403 *info403;
 
1077
                [case(502)]     srvsvc_NetSrvInfo502 *info502;
 
1078
                [case(503)]     srvsvc_NetSrvInfo503 *info503;
 
1079
                [case(599)]     srvsvc_NetSrvInfo599 *info599;
 
1080
                [case(1005)]    srvsvc_NetSrvInfo1005 *info1005;
 
1081
                [case(1010)]    srvsvc_NetSrvInfo1010 *info1010;
 
1082
                [case(1016)]    srvsvc_NetSrvInfo1016 *info1016;
 
1083
                [case(1017)]    srvsvc_NetSrvInfo1017 *info1017;
 
1084
                [case(1018)]    srvsvc_NetSrvInfo1018 *info1018;
 
1085
                [case(1107)]    srvsvc_NetSrvInfo1107 *info1107;
 
1086
                [case(1501)]    srvsvc_NetSrvInfo1501 *info1501;
 
1087
                [case(1502)]    srvsvc_NetSrvInfo1502 *info1502;
 
1088
                [case(1503)]    srvsvc_NetSrvInfo1503 *info1503;
 
1089
                [case(1506)]    srvsvc_NetSrvInfo1506 *info1506;
 
1090
                [case(1509)]    srvsvc_NetSrvInfo1509 *info1509;
 
1091
                [case(1510)]    srvsvc_NetSrvInfo1510 *info1510;
 
1092
                [case(1511)]    srvsvc_NetSrvInfo1511 *info1511;
 
1093
                [case(1512)]    srvsvc_NetSrvInfo1512 *info1512;
 
1094
                [case(1513)]    srvsvc_NetSrvInfo1513 *info1513;
 
1095
                [case(1514)]    srvsvc_NetSrvInfo1514 *info1514;
 
1096
                [case(1515)]    srvsvc_NetSrvInfo1515 *info1515;
 
1097
                [case(1516)]    srvsvc_NetSrvInfo1516 *info1516;
 
1098
                [case(1518)]    srvsvc_NetSrvInfo1518 *info1518;
 
1099
                [case(1520)]    srvsvc_NetSrvInfo1520 *info1520;
 
1100
                [case(1521)]    srvsvc_NetSrvInfo1521 *info1521;
 
1101
                [case(1522)]    srvsvc_NetSrvInfo1522 *info1522;
 
1102
                [case(1523)]    srvsvc_NetSrvInfo1523 *info1523;
 
1103
                [case(1524)]    srvsvc_NetSrvInfo1524 *info1524;
 
1104
                [case(1525)]    srvsvc_NetSrvInfo1525 *info1525;
 
1105
                [case(1528)]    srvsvc_NetSrvInfo1528 *info1528;
 
1106
                [case(1529)]    srvsvc_NetSrvInfo1529 *info1529;
 
1107
                [case(1530)]    srvsvc_NetSrvInfo1530 *info1530;
 
1108
                [case(1533)]    srvsvc_NetSrvInfo1533 *info1533;
 
1109
                [case(1534)]    srvsvc_NetSrvInfo1534 *info1534;
 
1110
                [case(1535)]    srvsvc_NetSrvInfo1535 *info1535;
 
1111
                [case(1536)]    srvsvc_NetSrvInfo1536 *info1536;
 
1112
                [case(1537)]    srvsvc_NetSrvInfo1537 *info1537;
 
1113
                [case(1538)]    srvsvc_NetSrvInfo1538 *info1538;
 
1114
                [case(1539)]    srvsvc_NetSrvInfo1539 *info1539;
 
1115
                [case(1540)]    srvsvc_NetSrvInfo1540 *info1540;
 
1116
                [case(1541)]    srvsvc_NetSrvInfo1541 *info1541;
 
1117
                [case(1542)]    srvsvc_NetSrvInfo1542 *info1542;
 
1118
                [case(1543)]    srvsvc_NetSrvInfo1543 *info1543;
 
1119
                [case(1544)]    srvsvc_NetSrvInfo1544 *info1544;
 
1120
                [case(1545)]    srvsvc_NetSrvInfo1545 *info1545;
 
1121
                [case(1546)]    srvsvc_NetSrvInfo1546 *info1546;
 
1122
                [case(1547)]    srvsvc_NetSrvInfo1547 *info1547;
 
1123
                [case(1548)]    srvsvc_NetSrvInfo1548 *info1548;
 
1124
                [case(1549)]    srvsvc_NetSrvInfo1549 *info1549;
 
1125
                [case(1550)]    srvsvc_NetSrvInfo1550 *info1550;
 
1126
                [case(1552)]    srvsvc_NetSrvInfo1552 *info1552;
 
1127
                [case(1553)]    srvsvc_NetSrvInfo1553 *info1553;
 
1128
                [case(1554)]    srvsvc_NetSrvInfo1554 *info1554;
 
1129
                [case(1555)]    srvsvc_NetSrvInfo1555 *info1555;
 
1130
                [case(1556)]    srvsvc_NetSrvInfo1556 *info1556;
 
1131
                [default];
 
1132
        } srvsvc_NetSrvInfo;
 
1133
 
 
1134
        /******************/
 
1135
        /* Function: 0x15 */
 
1136
        WERROR srvsvc_NetSrvGetInfo(
 
1137
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1138
                [in]   uint32 level,
 
1139
                [out,ref,switch_is(level)] srvsvc_NetSrvInfo *info
 
1140
                );
 
1141
 
 
1142
        /******************/
 
1143
        /* Function: 0x16 */
 
1144
        WERROR srvsvc_NetSrvSetInfo(
 
1145
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1146
                [in]   uint32 level,
 
1147
                [in,ref,switch_is(level)] srvsvc_NetSrvInfo *info,
 
1148
                [in,out,unique]   uint32 *parm_error
 
1149
                );
 
1150
 
 
1151
/**************************/
 
1152
/* srvsvc_NetDisk         */
 
1153
/**************************/
 
1154
        typedef struct {
 
1155
                /*
 
1156
                 * In theory this should be:
 
1157
                 *      [charset(UTF16),string] uint16 annotation[3]
 
1158
                 * But midl treats this as:
 
1159
                 *      [charset(UTF16),string] uint16 annotation[]
 
1160
                 * and pidl doesn't support this yet
 
1161
                 */
 
1162
                [value(0)] uint32 __disk_offset;
 
1163
                [value(strlen(disk)+1)] uint32 __disk_length;
 
1164
                [charset(UTF16)] uint16 disk[__disk_length];
 
1165
        } srvsvc_NetDiskInfo0;
 
1166
 
 
1167
        typedef struct {
 
1168
                uint32 count;
 
1169
                [size_is(count), length_is(count)] srvsvc_NetDiskInfo0 *disks;
 
1170
        } srvsvc_NetDiskInfo;
 
1171
 
 
1172
        /******************/
 
1173
        /* Function: 0x17 */
 
1174
        WERROR srvsvc_NetDiskEnum(
 
1175
                [in,unique]      [string,charset(UTF16)] uint16 *server_unc,
 
1176
                [in]      uint32 level,
 
1177
                [in,out,ref]  srvsvc_NetDiskInfo *info,
 
1178
                [in]      uint32 maxlen,
 
1179
                [out,ref]     uint32 *totalentries,
 
1180
                [in,out,unique]  uint32 *resume_handle
 
1181
                );
 
1182
 
 
1183
/**************************/
 
1184
/* srvsvc_NetStatistics   */
 
1185
/**************************/
 
1186
        typedef struct {
 
1187
                uint32 start;
 
1188
                uint32 fopens;
 
1189
                uint32 devopens;
 
1190
                uint32 jobsqueued;
 
1191
                uint32 sopens;
 
1192
                uint32 stimeouts;
 
1193
                uint32 serrorout;
 
1194
                uint32 pwerrors;
 
1195
                uint32 permerrors;
 
1196
                uint32 syserrors;
 
1197
                uint32 bytessent_low;
 
1198
                uint32 bytessent_high;
 
1199
                uint32 bytesrcvd_low;
 
1200
                uint32 bytesrcvd_high;
 
1201
                uint32 avresponse;
 
1202
                uint32 reqbufneed;
 
1203
                uint32 bigbufneed;
 
1204
        } srvsvc_Statistics;
 
1205
 
 
1206
        /******************/
 
1207
        /* Function: 0x18 */
 
1208
        WERROR srvsvc_NetServerStatisticsGet(
 
1209
                [in,unique]      [string,charset(UTF16)] uint16 *server_unc,
 
1210
                [in,unique]      [string,charset(UTF16)] uint16 *service,
 
1211
                [in]      uint32 level,
 
1212
                [in]      uint32 options,
 
1213
                [out,ref]     srvsvc_Statistics **stats
 
1214
                );
 
1215
 
 
1216
/**************************/
 
1217
/* srvsvc_NetTransport    */
 
1218
/**************************/
 
1219
        typedef struct {
 
1220
                uint32 vcs;
 
1221
                [string,charset(UTF16)] uint16 *name;
 
1222
                [size_is(addr_len)] uint8 *addr;
 
1223
                uint32 addr_len;
 
1224
                [string,charset(UTF16)] uint16 *net_addr;
 
1225
        } srvsvc_NetTransportInfo0;
 
1226
 
 
1227
        /******************/
 
1228
        /* Function: 0x19 */
 
1229
        WERROR srvsvc_NetTransportAdd(
 
1230
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1231
                [in] uint32 level,
 
1232
                [in,switch_is(level)]   srvsvc_NetTransportInfo info
 
1233
                );
 
1234
 
 
1235
        typedef struct {
 
1236
                uint32 count;
 
1237
                [size_is(count)] srvsvc_NetTransportInfo0 *array;
 
1238
        } srvsvc_NetTransportCtr0;
 
1239
 
 
1240
        typedef struct {
 
1241
                uint32 vcs;
 
1242
                [string,charset(UTF16)] uint16 *name;
 
1243
                [size_is(addr_len)] uint8 *addr;
 
1244
                uint32 addr_len;
 
1245
                [string,charset(UTF16)] uint16 *net_addr;
 
1246
                [string,charset(UTF16)] uint16 *domain;
 
1247
        } srvsvc_NetTransportInfo1;
 
1248
 
 
1249
        typedef struct {
 
1250
                uint32 count;
 
1251
                [size_is(count)] srvsvc_NetTransportInfo1 *array;
 
1252
        } srvsvc_NetTransportCtr1;
 
1253
 
 
1254
        typedef struct {
 
1255
                uint32 vcs;
 
1256
                [string,charset(UTF16)] uint16 *name;
 
1257
                [size_is(addr_len)] uint8 *addr;
 
1258
                uint32 addr_len;
 
1259
                [string,charset(UTF16)] uint16 *net_addr;
 
1260
                [string,charset(UTF16)] uint16 *domain;
 
1261
                uint32 unknown;
 
1262
        } srvsvc_NetTransportInfo2;
 
1263
 
 
1264
        typedef struct {
 
1265
                uint32 count;
 
1266
                [size_is(count)] srvsvc_NetTransportInfo2 *array;
 
1267
        } srvsvc_NetTransportCtr2;
 
1268
 
 
1269
        typedef struct {
 
1270
                uint32 vcs;
 
1271
                [string,charset(UTF16)] uint16 *name;
 
1272
                [size_is(addr_len)] uint8 *addr;
 
1273
                uint32 addr_len;
 
1274
                [string,charset(UTF16)] uint16 *net_addr;
 
1275
                [string,charset(UTF16)] uint16 *domain;
 
1276
                uint32 unknown1;
 
1277
                uint32 unknown2;
 
1278
                uint8 unknown3[256];
 
1279
        } srvsvc_NetTransportInfo3;
 
1280
 
 
1281
        typedef struct {
 
1282
                uint32 count;
 
1283
                [size_is(count)] srvsvc_NetTransportInfo3 *array;
 
1284
        } srvsvc_NetTransportCtr3;
 
1285
 
 
1286
        typedef union {
 
1287
                [case(0)] srvsvc_NetTransportCtr0 *ctr0;
 
1288
                [case(1)] srvsvc_NetTransportCtr1 *ctr1;
 
1289
                [case(2)] srvsvc_NetTransportCtr2 *ctr2;
 
1290
                [case(3)] srvsvc_NetTransportCtr3 *ctr3;
 
1291
                [default];
 
1292
        } srvsvc_NetTransportCtr;
 
1293
 
 
1294
        typedef struct {
 
1295
                uint32 level;
 
1296
                [switch_is(level)] srvsvc_NetTransportCtr ctr;
 
1297
        } srvsvc_NetTransportInfoCtr;
 
1298
 
 
1299
        /******************/
 
1300
        /* Function: 0x1a */
 
1301
        WERROR srvsvc_NetTransportEnum(
 
1302
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1303
                [in,out,ref] srvsvc_NetTransportInfoCtr *transports,
 
1304
                [in]   uint32 max_buffer,
 
1305
                [out,ref]   uint32 *totalentries,
 
1306
                [in,out,unique]   uint32 *resume_handle
 
1307
                );
 
1308
 
 
1309
        /******************/
 
1310
        /* Function: 0x1b */
 
1311
        WERROR srvsvc_NetTransportDel(
 
1312
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1313
                [in]    uint32 level,
 
1314
                [in]    srvsvc_NetTransportInfo0 *info0
 
1315
                );
 
1316
 
 
1317
/**************************/
 
1318
/* srvsvc_NetRemoteTOD    */
 
1319
/**************************/
 
1320
        typedef struct {
 
1321
                uint32 elapsed; /* time(NULL) */
 
1322
                uint32 msecs; /* milliseconds till system reboot (uptime) */
 
1323
                uint32 hours;
 
1324
                uint32 mins;
 
1325
                uint32 secs;
 
1326
                uint32 hunds;
 
1327
                int32 timezone; /* in minutes */
 
1328
                uint32 tinterval; /* clock tick interval in 0.0001 second units; 310 on windows */
 
1329
                uint32 day;
 
1330
                uint32 month;
 
1331
                uint32 year;
 
1332
                uint32 weekday;
 
1333
        } srvsvc_NetRemoteTODInfo;
 
1334
 
 
1335
        /******************/
 
1336
        /* Function: 0x1c */
 
1337
        WERROR srvsvc_NetRemoteTOD(
 
1338
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1339
                [out,ref]     srvsvc_NetRemoteTODInfo **info
 
1340
                );
 
1341
 
 
1342
/**************************/
 
1343
/* srvsvc_NetServiceBits  */
 
1344
/**************************/
 
1345
        /******************/
 
1346
        /* Function: 0x1d */
 
1347
        WERROR srvsvc_NetSetServiceBits(
 
1348
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1349
                [in,unique]   [string,charset(UTF16)] uint16 *transport,
 
1350
                [in]   uint32 servicebits,
 
1351
                [in]   uint32 updateimmediately
 
1352
                );
 
1353
 
 
1354
/**************************/
 
1355
/* srvsvc_NetPath         */
 
1356
/**************************/
 
1357
        /******************/
 
1358
        /* Function: 0x1e */
 
1359
        WERROR srvsvc_NetPathType(
 
1360
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1361
                [in]   [string,charset(UTF16)] uint16 path[],
 
1362
                [in]   uint32 pathflags,
 
1363
                [out,ref]   uint32 *pathtype
 
1364
                );
 
1365
 
 
1366
        /******************/
 
1367
        /* Function: 0x1f */
 
1368
        WERROR srvsvc_NetPathCanonicalize(
 
1369
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1370
                [in]   [string,charset(UTF16)] uint16 path[],
 
1371
                [out]  [size_is(maxbuf)] uint8 can_path[],
 
1372
                [in]   uint32 maxbuf,
 
1373
                [in]   [string,charset(UTF16)] uint16 prefix[],
 
1374
                [in,out,ref] uint32 *pathtype,
 
1375
                [in]    uint32 pathflags
 
1376
                );
 
1377
 
 
1378
        /******************/
 
1379
        /* Function: 0x20 */
 
1380
        WERROR srvsvc_NetPathCompare(
 
1381
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1382
                [in]   [string,charset(UTF16)] uint16 path1[],
 
1383
                [in]   [string,charset(UTF16)] uint16 path2[],
 
1384
                [in]    uint32 pathtype,
 
1385
                [in]    uint32 pathflags
 
1386
                );
 
1387
 
 
1388
/**************************/
 
1389
/* srvsvc_NetName         */
 
1390
/**************************/
 
1391
        /******************/
 
1392
        /* Function: 0x21 */
 
1393
        WERROR srvsvc_NetNameValidate(
 
1394
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1395
                [in]   [string,charset(UTF16)] uint16 name[],
 
1396
                [in]    uint32 name_type,
 
1397
                [in]    uint32 flags
 
1398
                );
 
1399
 
 
1400
        /******************/
 
1401
        /* Function: 0x22 */
 
1402
        [todo] WERROR srvsvc_NETRPRNAMECANONICALIZE(
 
1403
                );
 
1404
 
 
1405
        /******************/
 
1406
        /* Function: 0x23 */
 
1407
        WERROR srvsvc_NetPRNameCompare(
 
1408
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1409
                [in]   [string,charset(UTF16)] uint16 name1[],
 
1410
                [in]   [string,charset(UTF16)] uint16 name2[],
 
1411
                [in]    uint32 name_type,
 
1412
                [in]    uint32 flags
 
1413
                );
 
1414
 
 
1415
/**************************/
 
1416
/* srvsvc_NetShare ...    */
 
1417
/**************************/
 
1418
        /******************/
 
1419
        /* Function: 0x24 */
 
1420
        /* Note, there must be some way to return entries read vs
 
1421
           total entries ... */
 
1422
        WERROR srvsvc_NetShareEnum(
 
1423
                [in,unique]       [string,charset(UTF16)] uint16 *server_unc,
 
1424
                [in,out,ref]   srvsvc_NetShareInfoCtr *info_ctr,
 
1425
                [in]       uint32 max_buffer,
 
1426
                [out,ref]      uint32 *totalentries,
 
1427
                [in,out,unique]   uint32 *resume_handle
 
1428
                );
 
1429
 
 
1430
        /******************/
 
1431
        /* Function: 0x25 */
 
1432
        WERROR srvsvc_NetShareDelStart(
 
1433
                [in,unique]       [string,charset(UTF16)] uint16 *server_unc,
 
1434
                [in]       [string,charset(UTF16)] uint16 share[],
 
1435
                [in]       uint32 reserved,
 
1436
                [out,unique] policy_handle *hnd
 
1437
                );
 
1438
 
 
1439
        /******************/
 
1440
        /* Function: 0x26 */
 
1441
        WERROR srvsvc_NetShareDelCommit(
 
1442
                [in, out,unique] policy_handle *hnd
 
1443
                );
 
1444
 
 
1445
        /******************/
 
1446
        /* Function: 0x27 */
 
1447
        WERROR srvsvc_NetGetFileSecurity(
 
1448
                [in,unique]       [string,charset(UTF16)] uint16 *server_unc,
 
1449
                [in,unique]       [string,charset(UTF16)] uint16 *share,
 
1450
                [in]       [string,charset(UTF16)] uint16 file[],
 
1451
                [in]       security_secinfo securityinformation,
 
1452
                [out,ref]  sec_desc_buf **sd_buf
 
1453
                );
 
1454
 
 
1455
        /******************/
 
1456
        /* Function: 0x28 */
 
1457
        WERROR srvsvc_NetSetFileSecurity(
 
1458
                [in,unique]       [string,charset(UTF16)] uint16 *server_unc,
 
1459
                [in,unique]       [string,charset(UTF16)] uint16 *share,
 
1460
                [in]       [string,charset(UTF16)] uint16 file[],
 
1461
                [in]       security_secinfo securityinformation,
 
1462
                [in,ref]   sec_desc_buf *sd_buf
 
1463
                );
 
1464
 
 
1465
 
 
1466
 
 
1467
        typedef [switch_type(uint32)] union {
 
1468
                [case(0)] srvsvc_NetTransportInfo0 info0;
 
1469
                [case(1)] srvsvc_NetTransportInfo1 info1;
 
1470
                [case(2)] srvsvc_NetTransportInfo2 info2;
 
1471
                [case(3)] srvsvc_NetTransportInfo3 info3;
 
1472
        } srvsvc_NetTransportInfo;
 
1473
 
 
1474
        /******************/
 
1475
        /* Function: 0x29 */
 
1476
        WERROR srvsvc_NetServerTransportAddEx(
 
1477
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1478
                [in] uint32 level,
 
1479
                [in,switch_is(level)]   srvsvc_NetTransportInfo info
 
1480
                );
 
1481
 
 
1482
        /******************/
 
1483
        /* Function: 0x2a */
 
1484
        WERROR srvsvc_NetServerSetServiceBitsEx(
 
1485
                [in,unique]   [string,charset(UTF16)] uint16 *server_unc,
 
1486
                [in,unique]   [string,charset(UTF16)] uint16 *emulated_server_unc,
 
1487
                [in,unique]   [string,charset(UTF16)] uint16 *transport,
 
1488
                [in]   uint32 servicebitsofinterest,
 
1489
                [in]   uint32 servicebits,
 
1490
                [in]   uint32 updateimmediately
 
1491
                );
 
1492
 
 
1493
        /******************/
 
1494
        /* Function: 0x2b */
 
1495
        [todo] WERROR srvsvc_NETRDFSGETVERSION(
 
1496
                );
 
1497
 
 
1498
        /******************/
 
1499
        /* Function: 0x2c */
 
1500
        [todo] WERROR srvsvc_NETRDFSCREATELOCALPARTITION(
 
1501
                );
 
1502
 
 
1503
        /******************/
 
1504
        /* Function: 0x2d */
 
1505
        [todo] WERROR srvsvc_NETRDFSDELETELOCALPARTITION(
 
1506
                );
 
1507
 
 
1508
        /******************/
 
1509
        /* Function: 0x2e */
 
1510
        [todo] WERROR srvsvc_NETRDFSSETLOCALVOLUMESTATE(
 
1511
                );
 
1512
 
 
1513
        /******************/
 
1514
        /* Function: 0x2f */
 
1515
        [todo] WERROR srvsvc_NETRDFSSETSERVERINFO(
 
1516
                );
 
1517
 
 
1518
        /******************/
 
1519
        /* Function: 0x30 */
 
1520
        [todo] WERROR srvsvc_NETRDFSCREATEEXITPOINT(
 
1521
                );
 
1522
 
 
1523
        /******************/
 
1524
        /* Function: 0x31 */
 
1525
        [todo] WERROR srvsvc_NETRDFSDELETEEXITPOINT(
 
1526
                );
 
1527
 
 
1528
        /******************/
 
1529
        /* Function: 0x32 */
 
1530
        [todo] WERROR srvsvc_NETRDFSMODIFYPREFIX(
 
1531
                );
 
1532
 
 
1533
        /******************/
 
1534
        /* Function: 0x33 */
 
1535
        [todo] WERROR srvsvc_NETRDFSFIXLOCALVOLUME(
 
1536
                );
 
1537
 
 
1538
        /******************/
 
1539
        /* Function: 0x34 */
 
1540
        [todo] WERROR srvsvc_NETRDFSMANAGERREPORTSITEINFO(
 
1541
                );
 
1542
 
 
1543
        /******************/
 
1544
        /* Function: 0x35 */
 
1545
        [todo] WERROR srvsvc_NETRSERVERTRANSPORTDELEX(
 
1546
                );
 
1547
}