← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/srvsvc.h

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

Show diffs side-by-side

added added

removed removed

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