← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/cli_srvsvc.c

  • 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/cli_srvsvc.c
 
1
/*
 
2
 * Unix SMB/CIFS implementation.
 
3
 * client auto-generated by pidl. DO NOT MODIFY!
 
4
 */
 
5
 
 
6
#include "includes.h"
 
7
#include "../librpc/gen_ndr/cli_srvsvc.h"
 
8
 
 
9
NTSTATUS rpccli_srvsvc_NetCharDevEnum(struct rpc_pipe_client *cli,
 
10
                                      TALLOC_CTX *mem_ctx,
 
11
                                      const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
12
                                      struct srvsvc_NetCharDevInfoCtr *info_ctr /* [in,out] [ref] */,
 
13
                                      uint32_t max_buffer /* [in]  */,
 
14
                                      uint32_t *totalentries /* [out] [ref] */,
 
15
                                      uint32_t *resume_handle /* [in,out] [unique] */,
 
16
                                      WERROR *werror)
 
17
{
 
18
        struct srvsvc_NetCharDevEnum r;
 
19
        NTSTATUS status;
 
20
 
 
21
        /* In parameters */
 
22
        r.in.server_unc = server_unc;
 
23
        r.in.info_ctr = info_ctr;
 
24
        r.in.max_buffer = max_buffer;
 
25
        r.in.resume_handle = resume_handle;
 
26
 
 
27
        if (DEBUGLEVEL >= 10) {
 
28
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevEnum, &r);
 
29
        }
 
30
 
 
31
        status = cli->dispatch(cli,
 
32
                                mem_ctx,
 
33
                                &ndr_table_srvsvc,
 
34
                                NDR_SRVSVC_NETCHARDEVENUM,
 
35
                                &r);
 
36
 
 
37
        if (!NT_STATUS_IS_OK(status)) {
 
38
                return status;
 
39
        }
 
40
 
 
41
        if (DEBUGLEVEL >= 10) {
 
42
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, &r);
 
43
        }
 
44
 
 
45
        if (NT_STATUS_IS_ERR(status)) {
 
46
                return status;
 
47
        }
 
48
 
 
49
        /* Return variables */
 
50
        *info_ctr = *r.out.info_ctr;
 
51
        *totalentries = *r.out.totalentries;
 
52
        if (resume_handle && r.out.resume_handle) {
 
53
                *resume_handle = *r.out.resume_handle;
 
54
        }
 
55
 
 
56
        /* Return result */
 
57
        if (werror) {
 
58
                *werror = r.out.result;
 
59
        }
 
60
 
 
61
        return werror_to_ntstatus(r.out.result);
 
62
}
 
63
 
 
64
NTSTATUS rpccli_srvsvc_NetCharDevGetInfo(struct rpc_pipe_client *cli,
 
65
                                         TALLOC_CTX *mem_ctx,
 
66
                                         const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
67
                                         const char *device_name /* [in] [charset(UTF16)] */,
 
68
                                         uint32_t level /* [in]  */,
 
69
                                         union srvsvc_NetCharDevInfo *info /* [out] [ref,switch_is(level)] */,
 
70
                                         WERROR *werror)
 
71
{
 
72
        struct srvsvc_NetCharDevGetInfo r;
 
73
        NTSTATUS status;
 
74
 
 
75
        /* In parameters */
 
76
        r.in.server_unc = server_unc;
 
77
        r.in.device_name = device_name;
 
78
        r.in.level = level;
 
79
 
 
80
        if (DEBUGLEVEL >= 10) {
 
81
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, &r);
 
82
        }
 
83
 
 
84
        status = cli->dispatch(cli,
 
85
                                mem_ctx,
 
86
                                &ndr_table_srvsvc,
 
87
                                NDR_SRVSVC_NETCHARDEVGETINFO,
 
88
                                &r);
 
89
 
 
90
        if (!NT_STATUS_IS_OK(status)) {
 
91
                return status;
 
92
        }
 
93
 
 
94
        if (DEBUGLEVEL >= 10) {
 
95
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, &r);
 
96
        }
 
97
 
 
98
        if (NT_STATUS_IS_ERR(status)) {
 
99
                return status;
 
100
        }
 
101
 
 
102
        /* Return variables */
 
103
        *info = *r.out.info;
 
104
 
 
105
        /* Return result */
 
106
        if (werror) {
 
107
                *werror = r.out.result;
 
108
        }
 
109
 
 
110
        return werror_to_ntstatus(r.out.result);
 
111
}
 
112
 
 
113
NTSTATUS rpccli_srvsvc_NetCharDevControl(struct rpc_pipe_client *cli,
 
114
                                         TALLOC_CTX *mem_ctx,
 
115
                                         const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
116
                                         const char *device_name /* [in] [charset(UTF16)] */,
 
117
                                         uint32_t opcode /* [in]  */,
 
118
                                         WERROR *werror)
 
119
{
 
120
        struct srvsvc_NetCharDevControl r;
 
121
        NTSTATUS status;
 
122
 
 
123
        /* In parameters */
 
124
        r.in.server_unc = server_unc;
 
125
        r.in.device_name = device_name;
 
126
        r.in.opcode = opcode;
 
127
 
 
128
        if (DEBUGLEVEL >= 10) {
 
129
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, &r);
 
130
        }
 
131
 
 
132
        status = cli->dispatch(cli,
 
133
                                mem_ctx,
 
134
                                &ndr_table_srvsvc,
 
135
                                NDR_SRVSVC_NETCHARDEVCONTROL,
 
136
                                &r);
 
137
 
 
138
        if (!NT_STATUS_IS_OK(status)) {
 
139
                return status;
 
140
        }
 
141
 
 
142
        if (DEBUGLEVEL >= 10) {
 
143
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, &r);
 
144
        }
 
145
 
 
146
        if (NT_STATUS_IS_ERR(status)) {
 
147
                return status;
 
148
        }
 
149
 
 
150
        /* Return variables */
 
151
 
 
152
        /* Return result */
 
153
        if (werror) {
 
154
                *werror = r.out.result;
 
155
        }
 
156
 
 
157
        return werror_to_ntstatus(r.out.result);
 
158
}
 
159
 
 
160
NTSTATUS rpccli_srvsvc_NetCharDevQEnum(struct rpc_pipe_client *cli,
 
161
                                       TALLOC_CTX *mem_ctx,
 
162
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
163
                                       const char *user /* [in] [unique,charset(UTF16)] */,
 
164
                                       struct srvsvc_NetCharDevQInfoCtr *info_ctr /* [in,out] [ref] */,
 
165
                                       uint32_t max_buffer /* [in]  */,
 
166
                                       uint32_t *totalentries /* [out] [ref] */,
 
167
                                       uint32_t *resume_handle /* [in,out] [unique] */,
 
168
                                       WERROR *werror)
 
169
{
 
170
        struct srvsvc_NetCharDevQEnum r;
 
171
        NTSTATUS status;
 
172
 
 
173
        /* In parameters */
 
174
        r.in.server_unc = server_unc;
 
175
        r.in.user = user;
 
176
        r.in.info_ctr = info_ctr;
 
177
        r.in.max_buffer = max_buffer;
 
178
        r.in.resume_handle = resume_handle;
 
179
 
 
180
        if (DEBUGLEVEL >= 10) {
 
181
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, &r);
 
182
        }
 
183
 
 
184
        status = cli->dispatch(cli,
 
185
                                mem_ctx,
 
186
                                &ndr_table_srvsvc,
 
187
                                NDR_SRVSVC_NETCHARDEVQENUM,
 
188
                                &r);
 
189
 
 
190
        if (!NT_STATUS_IS_OK(status)) {
 
191
                return status;
 
192
        }
 
193
 
 
194
        if (DEBUGLEVEL >= 10) {
 
195
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, &r);
 
196
        }
 
197
 
 
198
        if (NT_STATUS_IS_ERR(status)) {
 
199
                return status;
 
200
        }
 
201
 
 
202
        /* Return variables */
 
203
        *info_ctr = *r.out.info_ctr;
 
204
        *totalentries = *r.out.totalentries;
 
205
        if (resume_handle && r.out.resume_handle) {
 
206
                *resume_handle = *r.out.resume_handle;
 
207
        }
 
208
 
 
209
        /* Return result */
 
210
        if (werror) {
 
211
                *werror = r.out.result;
 
212
        }
 
213
 
 
214
        return werror_to_ntstatus(r.out.result);
 
215
}
 
216
 
 
217
NTSTATUS rpccli_srvsvc_NetCharDevQGetInfo(struct rpc_pipe_client *cli,
 
218
                                          TALLOC_CTX *mem_ctx,
 
219
                                          const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
220
                                          const char *queue_name /* [in] [charset(UTF16)] */,
 
221
                                          const char *user /* [in] [charset(UTF16)] */,
 
222
                                          uint32_t level /* [in]  */,
 
223
                                          union srvsvc_NetCharDevQInfo *info /* [out] [ref,switch_is(level)] */,
 
224
                                          WERROR *werror)
 
225
{
 
226
        struct srvsvc_NetCharDevQGetInfo r;
 
227
        NTSTATUS status;
 
228
 
 
229
        /* In parameters */
 
230
        r.in.server_unc = server_unc;
 
231
        r.in.queue_name = queue_name;
 
232
        r.in.user = user;
 
233
        r.in.level = level;
 
234
 
 
235
        if (DEBUGLEVEL >= 10) {
 
236
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, &r);
 
237
        }
 
238
 
 
239
        status = cli->dispatch(cli,
 
240
                                mem_ctx,
 
241
                                &ndr_table_srvsvc,
 
242
                                NDR_SRVSVC_NETCHARDEVQGETINFO,
 
243
                                &r);
 
244
 
 
245
        if (!NT_STATUS_IS_OK(status)) {
 
246
                return status;
 
247
        }
 
248
 
 
249
        if (DEBUGLEVEL >= 10) {
 
250
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, &r);
 
251
        }
 
252
 
 
253
        if (NT_STATUS_IS_ERR(status)) {
 
254
                return status;
 
255
        }
 
256
 
 
257
        /* Return variables */
 
258
        *info = *r.out.info;
 
259
 
 
260
        /* Return result */
 
261
        if (werror) {
 
262
                *werror = r.out.result;
 
263
        }
 
264
 
 
265
        return werror_to_ntstatus(r.out.result);
 
266
}
 
267
 
 
268
NTSTATUS rpccli_srvsvc_NetCharDevQSetInfo(struct rpc_pipe_client *cli,
 
269
                                          TALLOC_CTX *mem_ctx,
 
270
                                          const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
271
                                          const char *queue_name /* [in] [charset(UTF16)] */,
 
272
                                          uint32_t level /* [in]  */,
 
273
                                          union srvsvc_NetCharDevQInfo info /* [in] [switch_is(level)] */,
 
274
                                          uint32_t *parm_error /* [in,out] [unique] */,
 
275
                                          WERROR *werror)
 
276
{
 
277
        struct srvsvc_NetCharDevQSetInfo r;
 
278
        NTSTATUS status;
 
279
 
 
280
        /* In parameters */
 
281
        r.in.server_unc = server_unc;
 
282
        r.in.queue_name = queue_name;
 
283
        r.in.level = level;
 
284
        r.in.info = info;
 
285
        r.in.parm_error = parm_error;
 
286
 
 
287
        if (DEBUGLEVEL >= 10) {
 
288
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, &r);
 
289
        }
 
290
 
 
291
        status = cli->dispatch(cli,
 
292
                                mem_ctx,
 
293
                                &ndr_table_srvsvc,
 
294
                                NDR_SRVSVC_NETCHARDEVQSETINFO,
 
295
                                &r);
 
296
 
 
297
        if (!NT_STATUS_IS_OK(status)) {
 
298
                return status;
 
299
        }
 
300
 
 
301
        if (DEBUGLEVEL >= 10) {
 
302
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, &r);
 
303
        }
 
304
 
 
305
        if (NT_STATUS_IS_ERR(status)) {
 
306
                return status;
 
307
        }
 
308
 
 
309
        /* Return variables */
 
310
        if (parm_error && r.out.parm_error) {
 
311
                *parm_error = *r.out.parm_error;
 
312
        }
 
313
 
 
314
        /* Return result */
 
315
        if (werror) {
 
316
                *werror = r.out.result;
 
317
        }
 
318
 
 
319
        return werror_to_ntstatus(r.out.result);
 
320
}
 
321
 
 
322
NTSTATUS rpccli_srvsvc_NetCharDevQPurge(struct rpc_pipe_client *cli,
 
323
                                        TALLOC_CTX *mem_ctx,
 
324
                                        const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
325
                                        const char *queue_name /* [in] [charset(UTF16)] */,
 
326
                                        WERROR *werror)
 
327
{
 
328
        struct srvsvc_NetCharDevQPurge r;
 
329
        NTSTATUS status;
 
330
 
 
331
        /* In parameters */
 
332
        r.in.server_unc = server_unc;
 
333
        r.in.queue_name = queue_name;
 
334
 
 
335
        if (DEBUGLEVEL >= 10) {
 
336
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, &r);
 
337
        }
 
338
 
 
339
        status = cli->dispatch(cli,
 
340
                                mem_ctx,
 
341
                                &ndr_table_srvsvc,
 
342
                                NDR_SRVSVC_NETCHARDEVQPURGE,
 
343
                                &r);
 
344
 
 
345
        if (!NT_STATUS_IS_OK(status)) {
 
346
                return status;
 
347
        }
 
348
 
 
349
        if (DEBUGLEVEL >= 10) {
 
350
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, &r);
 
351
        }
 
352
 
 
353
        if (NT_STATUS_IS_ERR(status)) {
 
354
                return status;
 
355
        }
 
356
 
 
357
        /* Return variables */
 
358
 
 
359
        /* Return result */
 
360
        if (werror) {
 
361
                *werror = r.out.result;
 
362
        }
 
363
 
 
364
        return werror_to_ntstatus(r.out.result);
 
365
}
 
366
 
 
367
NTSTATUS rpccli_srvsvc_NetCharDevQPurgeSelf(struct rpc_pipe_client *cli,
 
368
                                            TALLOC_CTX *mem_ctx,
 
369
                                            const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
370
                                            const char *queue_name /* [in] [charset(UTF16)] */,
 
371
                                            const char *computer_name /* [in] [charset(UTF16)] */,
 
372
                                            WERROR *werror)
 
373
{
 
374
        struct srvsvc_NetCharDevQPurgeSelf r;
 
375
        NTSTATUS status;
 
376
 
 
377
        /* In parameters */
 
378
        r.in.server_unc = server_unc;
 
379
        r.in.queue_name = queue_name;
 
380
        r.in.computer_name = computer_name;
 
381
 
 
382
        if (DEBUGLEVEL >= 10) {
 
383
                NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
 
384
        }
 
385
 
 
386
        status = cli->dispatch(cli,
 
387
                                mem_ctx,
 
388
                                &ndr_table_srvsvc,
 
389
                                NDR_SRVSVC_NETCHARDEVQPURGESELF,
 
390
                                &r);
 
391
 
 
392
        if (!NT_STATUS_IS_OK(status)) {
 
393
                return status;
 
394
        }
 
395
 
 
396
        if (DEBUGLEVEL >= 10) {
 
397
                NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
 
398
        }
 
399
 
 
400
        if (NT_STATUS_IS_ERR(status)) {
 
401
                return status;
 
402
        }
 
403
 
 
404
        /* Return variables */
 
405
 
 
406
        /* Return result */
 
407
        if (werror) {
 
408
                *werror = r.out.result;
 
409
        }
 
410
 
 
411
        return werror_to_ntstatus(r.out.result);
 
412
}
 
413
 
 
414
NTSTATUS rpccli_srvsvc_NetConnEnum(struct rpc_pipe_client *cli,
 
415
                                   TALLOC_CTX *mem_ctx,
 
416
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
417
                                   const char *path /* [in] [unique,charset(UTF16)] */,
 
418
                                   struct srvsvc_NetConnInfoCtr *info_ctr /* [in,out] [ref] */,
 
419
                                   uint32_t max_buffer /* [in]  */,
 
420
                                   uint32_t *totalentries /* [out] [ref] */,
 
421
                                   uint32_t *resume_handle /* [in,out] [unique] */,
 
422
                                   WERROR *werror)
 
423
{
 
424
        struct srvsvc_NetConnEnum r;
 
425
        NTSTATUS status;
 
426
 
 
427
        /* In parameters */
 
428
        r.in.server_unc = server_unc;
 
429
        r.in.path = path;
 
430
        r.in.info_ctr = info_ctr;
 
431
        r.in.max_buffer = max_buffer;
 
432
        r.in.resume_handle = resume_handle;
 
433
 
 
434
        if (DEBUGLEVEL >= 10) {
 
435
                NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, &r);
 
436
        }
 
437
 
 
438
        status = cli->dispatch(cli,
 
439
                                mem_ctx,
 
440
                                &ndr_table_srvsvc,
 
441
                                NDR_SRVSVC_NETCONNENUM,
 
442
                                &r);
 
443
 
 
444
        if (!NT_STATUS_IS_OK(status)) {
 
445
                return status;
 
446
        }
 
447
 
 
448
        if (DEBUGLEVEL >= 10) {
 
449
                NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, &r);
 
450
        }
 
451
 
 
452
        if (NT_STATUS_IS_ERR(status)) {
 
453
                return status;
 
454
        }
 
455
 
 
456
        /* Return variables */
 
457
        *info_ctr = *r.out.info_ctr;
 
458
        *totalentries = *r.out.totalentries;
 
459
        if (resume_handle && r.out.resume_handle) {
 
460
                *resume_handle = *r.out.resume_handle;
 
461
        }
 
462
 
 
463
        /* Return result */
 
464
        if (werror) {
 
465
                *werror = r.out.result;
 
466
        }
 
467
 
 
468
        return werror_to_ntstatus(r.out.result);
 
469
}
 
470
 
 
471
NTSTATUS rpccli_srvsvc_NetFileEnum(struct rpc_pipe_client *cli,
 
472
                                   TALLOC_CTX *mem_ctx,
 
473
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
474
                                   const char *path /* [in] [unique,charset(UTF16)] */,
 
475
                                   const char *user /* [in] [unique,charset(UTF16)] */,
 
476
                                   struct srvsvc_NetFileInfoCtr *info_ctr /* [in,out] [ref] */,
 
477
                                   uint32_t max_buffer /* [in]  */,
 
478
                                   uint32_t *totalentries /* [out] [ref] */,
 
479
                                   uint32_t *resume_handle /* [in,out] [unique] */,
 
480
                                   WERROR *werror)
 
481
{
 
482
        struct srvsvc_NetFileEnum r;
 
483
        NTSTATUS status;
 
484
 
 
485
        /* In parameters */
 
486
        r.in.server_unc = server_unc;
 
487
        r.in.path = path;
 
488
        r.in.user = user;
 
489
        r.in.info_ctr = info_ctr;
 
490
        r.in.max_buffer = max_buffer;
 
491
        r.in.resume_handle = resume_handle;
 
492
 
 
493
        if (DEBUGLEVEL >= 10) {
 
494
                NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, &r);
 
495
        }
 
496
 
 
497
        status = cli->dispatch(cli,
 
498
                                mem_ctx,
 
499
                                &ndr_table_srvsvc,
 
500
                                NDR_SRVSVC_NETFILEENUM,
 
501
                                &r);
 
502
 
 
503
        if (!NT_STATUS_IS_OK(status)) {
 
504
                return status;
 
505
        }
 
506
 
 
507
        if (DEBUGLEVEL >= 10) {
 
508
                NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, &r);
 
509
        }
 
510
 
 
511
        if (NT_STATUS_IS_ERR(status)) {
 
512
                return status;
 
513
        }
 
514
 
 
515
        /* Return variables */
 
516
        *info_ctr = *r.out.info_ctr;
 
517
        *totalentries = *r.out.totalentries;
 
518
        if (resume_handle && r.out.resume_handle) {
 
519
                *resume_handle = *r.out.resume_handle;
 
520
        }
 
521
 
 
522
        /* Return result */
 
523
        if (werror) {
 
524
                *werror = r.out.result;
 
525
        }
 
526
 
 
527
        return werror_to_ntstatus(r.out.result);
 
528
}
 
529
 
 
530
NTSTATUS rpccli_srvsvc_NetFileGetInfo(struct rpc_pipe_client *cli,
 
531
                                      TALLOC_CTX *mem_ctx,
 
532
                                      const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
533
                                      uint32_t fid /* [in]  */,
 
534
                                      uint32_t level /* [in]  */,
 
535
                                      union srvsvc_NetFileInfo *info /* [out] [ref,switch_is(level)] */,
 
536
                                      WERROR *werror)
 
537
{
 
538
        struct srvsvc_NetFileGetInfo r;
 
539
        NTSTATUS status;
 
540
 
 
541
        /* In parameters */
 
542
        r.in.server_unc = server_unc;
 
543
        r.in.fid = fid;
 
544
        r.in.level = level;
 
545
 
 
546
        if (DEBUGLEVEL >= 10) {
 
547
                NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, &r);
 
548
        }
 
549
 
 
550
        status = cli->dispatch(cli,
 
551
                                mem_ctx,
 
552
                                &ndr_table_srvsvc,
 
553
                                NDR_SRVSVC_NETFILEGETINFO,
 
554
                                &r);
 
555
 
 
556
        if (!NT_STATUS_IS_OK(status)) {
 
557
                return status;
 
558
        }
 
559
 
 
560
        if (DEBUGLEVEL >= 10) {
 
561
                NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, &r);
 
562
        }
 
563
 
 
564
        if (NT_STATUS_IS_ERR(status)) {
 
565
                return status;
 
566
        }
 
567
 
 
568
        /* Return variables */
 
569
        *info = *r.out.info;
 
570
 
 
571
        /* Return result */
 
572
        if (werror) {
 
573
                *werror = r.out.result;
 
574
        }
 
575
 
 
576
        return werror_to_ntstatus(r.out.result);
 
577
}
 
578
 
 
579
NTSTATUS rpccli_srvsvc_NetFileClose(struct rpc_pipe_client *cli,
 
580
                                    TALLOC_CTX *mem_ctx,
 
581
                                    const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
582
                                    uint32_t fid /* [in]  */,
 
583
                                    WERROR *werror)
 
584
{
 
585
        struct srvsvc_NetFileClose r;
 
586
        NTSTATUS status;
 
587
 
 
588
        /* In parameters */
 
589
        r.in.server_unc = server_unc;
 
590
        r.in.fid = fid;
 
591
 
 
592
        if (DEBUGLEVEL >= 10) {
 
593
                NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, &r);
 
594
        }
 
595
 
 
596
        status = cli->dispatch(cli,
 
597
                                mem_ctx,
 
598
                                &ndr_table_srvsvc,
 
599
                                NDR_SRVSVC_NETFILECLOSE,
 
600
                                &r);
 
601
 
 
602
        if (!NT_STATUS_IS_OK(status)) {
 
603
                return status;
 
604
        }
 
605
 
 
606
        if (DEBUGLEVEL >= 10) {
 
607
                NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, &r);
 
608
        }
 
609
 
 
610
        if (NT_STATUS_IS_ERR(status)) {
 
611
                return status;
 
612
        }
 
613
 
 
614
        /* Return variables */
 
615
 
 
616
        /* Return result */
 
617
        if (werror) {
 
618
                *werror = r.out.result;
 
619
        }
 
620
 
 
621
        return werror_to_ntstatus(r.out.result);
 
622
}
 
623
 
 
624
NTSTATUS rpccli_srvsvc_NetSessEnum(struct rpc_pipe_client *cli,
 
625
                                   TALLOC_CTX *mem_ctx,
 
626
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
627
                                   const char *client /* [in] [unique,charset(UTF16)] */,
 
628
                                   const char *user /* [in] [unique,charset(UTF16)] */,
 
629
                                   struct srvsvc_NetSessInfoCtr *info_ctr /* [in,out] [ref] */,
 
630
                                   uint32_t max_buffer /* [in]  */,
 
631
                                   uint32_t *totalentries /* [out] [ref] */,
 
632
                                   uint32_t *resume_handle /* [in,out] [unique] */,
 
633
                                   WERROR *werror)
 
634
{
 
635
        struct srvsvc_NetSessEnum r;
 
636
        NTSTATUS status;
 
637
 
 
638
        /* In parameters */
 
639
        r.in.server_unc = server_unc;
 
640
        r.in.client = client;
 
641
        r.in.user = user;
 
642
        r.in.info_ctr = info_ctr;
 
643
        r.in.max_buffer = max_buffer;
 
644
        r.in.resume_handle = resume_handle;
 
645
 
 
646
        if (DEBUGLEVEL >= 10) {
 
647
                NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, &r);
 
648
        }
 
649
 
 
650
        status = cli->dispatch(cli,
 
651
                                mem_ctx,
 
652
                                &ndr_table_srvsvc,
 
653
                                NDR_SRVSVC_NETSESSENUM,
 
654
                                &r);
 
655
 
 
656
        if (!NT_STATUS_IS_OK(status)) {
 
657
                return status;
 
658
        }
 
659
 
 
660
        if (DEBUGLEVEL >= 10) {
 
661
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, &r);
 
662
        }
 
663
 
 
664
        if (NT_STATUS_IS_ERR(status)) {
 
665
                return status;
 
666
        }
 
667
 
 
668
        /* Return variables */
 
669
        *info_ctr = *r.out.info_ctr;
 
670
        *totalentries = *r.out.totalentries;
 
671
        if (resume_handle && r.out.resume_handle) {
 
672
                *resume_handle = *r.out.resume_handle;
 
673
        }
 
674
 
 
675
        /* Return result */
 
676
        if (werror) {
 
677
                *werror = r.out.result;
 
678
        }
 
679
 
 
680
        return werror_to_ntstatus(r.out.result);
 
681
}
 
682
 
 
683
NTSTATUS rpccli_srvsvc_NetSessDel(struct rpc_pipe_client *cli,
 
684
                                  TALLOC_CTX *mem_ctx,
 
685
                                  const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
686
                                  const char *client /* [in] [unique,charset(UTF16)] */,
 
687
                                  const char *user /* [in] [unique,charset(UTF16)] */,
 
688
                                  WERROR *werror)
 
689
{
 
690
        struct srvsvc_NetSessDel r;
 
691
        NTSTATUS status;
 
692
 
 
693
        /* In parameters */
 
694
        r.in.server_unc = server_unc;
 
695
        r.in.client = client;
 
696
        r.in.user = user;
 
697
 
 
698
        if (DEBUGLEVEL >= 10) {
 
699
                NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, &r);
 
700
        }
 
701
 
 
702
        status = cli->dispatch(cli,
 
703
                                mem_ctx,
 
704
                                &ndr_table_srvsvc,
 
705
                                NDR_SRVSVC_NETSESSDEL,
 
706
                                &r);
 
707
 
 
708
        if (!NT_STATUS_IS_OK(status)) {
 
709
                return status;
 
710
        }
 
711
 
 
712
        if (DEBUGLEVEL >= 10) {
 
713
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, &r);
 
714
        }
 
715
 
 
716
        if (NT_STATUS_IS_ERR(status)) {
 
717
                return status;
 
718
        }
 
719
 
 
720
        /* Return variables */
 
721
 
 
722
        /* Return result */
 
723
        if (werror) {
 
724
                *werror = r.out.result;
 
725
        }
 
726
 
 
727
        return werror_to_ntstatus(r.out.result);
 
728
}
 
729
 
 
730
NTSTATUS rpccli_srvsvc_NetShareAdd(struct rpc_pipe_client *cli,
 
731
                                   TALLOC_CTX *mem_ctx,
 
732
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
733
                                   uint32_t level /* [in]  */,
 
734
                                   union srvsvc_NetShareInfo *info /* [in] [ref,switch_is(level)] */,
 
735
                                   uint32_t *parm_error /* [in,out] [unique] */,
 
736
                                   WERROR *werror)
 
737
{
 
738
        struct srvsvc_NetShareAdd r;
 
739
        NTSTATUS status;
 
740
 
 
741
        /* In parameters */
 
742
        r.in.server_unc = server_unc;
 
743
        r.in.level = level;
 
744
        r.in.info = info;
 
745
        r.in.parm_error = parm_error;
 
746
 
 
747
        if (DEBUGLEVEL >= 10) {
 
748
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, &r);
 
749
        }
 
750
 
 
751
        status = cli->dispatch(cli,
 
752
                                mem_ctx,
 
753
                                &ndr_table_srvsvc,
 
754
                                NDR_SRVSVC_NETSHAREADD,
 
755
                                &r);
 
756
 
 
757
        if (!NT_STATUS_IS_OK(status)) {
 
758
                return status;
 
759
        }
 
760
 
 
761
        if (DEBUGLEVEL >= 10) {
 
762
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, &r);
 
763
        }
 
764
 
 
765
        if (NT_STATUS_IS_ERR(status)) {
 
766
                return status;
 
767
        }
 
768
 
 
769
        /* Return variables */
 
770
        if (parm_error && r.out.parm_error) {
 
771
                *parm_error = *r.out.parm_error;
 
772
        }
 
773
 
 
774
        /* Return result */
 
775
        if (werror) {
 
776
                *werror = r.out.result;
 
777
        }
 
778
 
 
779
        return werror_to_ntstatus(r.out.result);
 
780
}
 
781
 
 
782
NTSTATUS rpccli_srvsvc_NetShareEnumAll(struct rpc_pipe_client *cli,
 
783
                                       TALLOC_CTX *mem_ctx,
 
784
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
785
                                       struct srvsvc_NetShareInfoCtr *info_ctr /* [in,out] [ref] */,
 
786
                                       uint32_t max_buffer /* [in]  */,
 
787
                                       uint32_t *totalentries /* [out] [ref] */,
 
788
                                       uint32_t *resume_handle /* [in,out] [unique] */,
 
789
                                       WERROR *werror)
 
790
{
 
791
        struct srvsvc_NetShareEnumAll r;
 
792
        NTSTATUS status;
 
793
 
 
794
        /* In parameters */
 
795
        r.in.server_unc = server_unc;
 
796
        r.in.info_ctr = info_ctr;
 
797
        r.in.max_buffer = max_buffer;
 
798
        r.in.resume_handle = resume_handle;
 
799
 
 
800
        if (DEBUGLEVEL >= 10) {
 
801
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, &r);
 
802
        }
 
803
 
 
804
        status = cli->dispatch(cli,
 
805
                                mem_ctx,
 
806
                                &ndr_table_srvsvc,
 
807
                                NDR_SRVSVC_NETSHAREENUMALL,
 
808
                                &r);
 
809
 
 
810
        if (!NT_STATUS_IS_OK(status)) {
 
811
                return status;
 
812
        }
 
813
 
 
814
        if (DEBUGLEVEL >= 10) {
 
815
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, &r);
 
816
        }
 
817
 
 
818
        if (NT_STATUS_IS_ERR(status)) {
 
819
                return status;
 
820
        }
 
821
 
 
822
        /* Return variables */
 
823
        *info_ctr = *r.out.info_ctr;
 
824
        *totalentries = *r.out.totalentries;
 
825
        if (resume_handle && r.out.resume_handle) {
 
826
                *resume_handle = *r.out.resume_handle;
 
827
        }
 
828
 
 
829
        /* Return result */
 
830
        if (werror) {
 
831
                *werror = r.out.result;
 
832
        }
 
833
 
 
834
        return werror_to_ntstatus(r.out.result);
 
835
}
 
836
 
 
837
NTSTATUS rpccli_srvsvc_NetShareGetInfo(struct rpc_pipe_client *cli,
 
838
                                       TALLOC_CTX *mem_ctx,
 
839
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
840
                                       const char *share_name /* [in] [charset(UTF16)] */,
 
841
                                       uint32_t level /* [in]  */,
 
842
                                       union srvsvc_NetShareInfo *info /* [out] [ref,switch_is(level)] */,
 
843
                                       WERROR *werror)
 
844
{
 
845
        struct srvsvc_NetShareGetInfo r;
 
846
        NTSTATUS status;
 
847
 
 
848
        /* In parameters */
 
849
        r.in.server_unc = server_unc;
 
850
        r.in.share_name = share_name;
 
851
        r.in.level = level;
 
852
 
 
853
        if (DEBUGLEVEL >= 10) {
 
854
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, &r);
 
855
        }
 
856
 
 
857
        status = cli->dispatch(cli,
 
858
                                mem_ctx,
 
859
                                &ndr_table_srvsvc,
 
860
                                NDR_SRVSVC_NETSHAREGETINFO,
 
861
                                &r);
 
862
 
 
863
        if (!NT_STATUS_IS_OK(status)) {
 
864
                return status;
 
865
        }
 
866
 
 
867
        if (DEBUGLEVEL >= 10) {
 
868
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, &r);
 
869
        }
 
870
 
 
871
        if (NT_STATUS_IS_ERR(status)) {
 
872
                return status;
 
873
        }
 
874
 
 
875
        /* Return variables */
 
876
        *info = *r.out.info;
 
877
 
 
878
        /* Return result */
 
879
        if (werror) {
 
880
                *werror = r.out.result;
 
881
        }
 
882
 
 
883
        return werror_to_ntstatus(r.out.result);
 
884
}
 
885
 
 
886
NTSTATUS rpccli_srvsvc_NetShareSetInfo(struct rpc_pipe_client *cli,
 
887
                                       TALLOC_CTX *mem_ctx,
 
888
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
889
                                       const char *share_name /* [in] [charset(UTF16)] */,
 
890
                                       uint32_t level /* [in]  */,
 
891
                                       union srvsvc_NetShareInfo *info /* [in] [ref,switch_is(level)] */,
 
892
                                       uint32_t *parm_error /* [in,out] [unique] */,
 
893
                                       WERROR *werror)
 
894
{
 
895
        struct srvsvc_NetShareSetInfo r;
 
896
        NTSTATUS status;
 
897
 
 
898
        /* In parameters */
 
899
        r.in.server_unc = server_unc;
 
900
        r.in.share_name = share_name;
 
901
        r.in.level = level;
 
902
        r.in.info = info;
 
903
        r.in.parm_error = parm_error;
 
904
 
 
905
        if (DEBUGLEVEL >= 10) {
 
906
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, &r);
 
907
        }
 
908
 
 
909
        status = cli->dispatch(cli,
 
910
                                mem_ctx,
 
911
                                &ndr_table_srvsvc,
 
912
                                NDR_SRVSVC_NETSHARESETINFO,
 
913
                                &r);
 
914
 
 
915
        if (!NT_STATUS_IS_OK(status)) {
 
916
                return status;
 
917
        }
 
918
 
 
919
        if (DEBUGLEVEL >= 10) {
 
920
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, &r);
 
921
        }
 
922
 
 
923
        if (NT_STATUS_IS_ERR(status)) {
 
924
                return status;
 
925
        }
 
926
 
 
927
        /* Return variables */
 
928
        if (parm_error && r.out.parm_error) {
 
929
                *parm_error = *r.out.parm_error;
 
930
        }
 
931
 
 
932
        /* Return result */
 
933
        if (werror) {
 
934
                *werror = r.out.result;
 
935
        }
 
936
 
 
937
        return werror_to_ntstatus(r.out.result);
 
938
}
 
939
 
 
940
NTSTATUS rpccli_srvsvc_NetShareDel(struct rpc_pipe_client *cli,
 
941
                                   TALLOC_CTX *mem_ctx,
 
942
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
943
                                   const char *share_name /* [in] [charset(UTF16)] */,
 
944
                                   uint32_t reserved /* [in]  */,
 
945
                                   WERROR *werror)
 
946
{
 
947
        struct srvsvc_NetShareDel r;
 
948
        NTSTATUS status;
 
949
 
 
950
        /* In parameters */
 
951
        r.in.server_unc = server_unc;
 
952
        r.in.share_name = share_name;
 
953
        r.in.reserved = reserved;
 
954
 
 
955
        if (DEBUGLEVEL >= 10) {
 
956
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, &r);
 
957
        }
 
958
 
 
959
        status = cli->dispatch(cli,
 
960
                                mem_ctx,
 
961
                                &ndr_table_srvsvc,
 
962
                                NDR_SRVSVC_NETSHAREDEL,
 
963
                                &r);
 
964
 
 
965
        if (!NT_STATUS_IS_OK(status)) {
 
966
                return status;
 
967
        }
 
968
 
 
969
        if (DEBUGLEVEL >= 10) {
 
970
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, &r);
 
971
        }
 
972
 
 
973
        if (NT_STATUS_IS_ERR(status)) {
 
974
                return status;
 
975
        }
 
976
 
 
977
        /* Return variables */
 
978
 
 
979
        /* Return result */
 
980
        if (werror) {
 
981
                *werror = r.out.result;
 
982
        }
 
983
 
 
984
        return werror_to_ntstatus(r.out.result);
 
985
}
 
986
 
 
987
NTSTATUS rpccli_srvsvc_NetShareDelSticky(struct rpc_pipe_client *cli,
 
988
                                         TALLOC_CTX *mem_ctx,
 
989
                                         const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
990
                                         const char *share_name /* [in] [charset(UTF16)] */,
 
991
                                         uint32_t reserved /* [in]  */,
 
992
                                         WERROR *werror)
 
993
{
 
994
        struct srvsvc_NetShareDelSticky r;
 
995
        NTSTATUS status;
 
996
 
 
997
        /* In parameters */
 
998
        r.in.server_unc = server_unc;
 
999
        r.in.share_name = share_name;
 
1000
        r.in.reserved = reserved;
 
1001
 
 
1002
        if (DEBUGLEVEL >= 10) {
 
1003
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, &r);
 
1004
        }
 
1005
 
 
1006
        status = cli->dispatch(cli,
 
1007
                                mem_ctx,
 
1008
                                &ndr_table_srvsvc,
 
1009
                                NDR_SRVSVC_NETSHAREDELSTICKY,
 
1010
                                &r);
 
1011
 
 
1012
        if (!NT_STATUS_IS_OK(status)) {
 
1013
                return status;
 
1014
        }
 
1015
 
 
1016
        if (DEBUGLEVEL >= 10) {
 
1017
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, &r);
 
1018
        }
 
1019
 
 
1020
        if (NT_STATUS_IS_ERR(status)) {
 
1021
                return status;
 
1022
        }
 
1023
 
 
1024
        /* Return variables */
 
1025
 
 
1026
        /* Return result */
 
1027
        if (werror) {
 
1028
                *werror = r.out.result;
 
1029
        }
 
1030
 
 
1031
        return werror_to_ntstatus(r.out.result);
 
1032
}
 
1033
 
 
1034
NTSTATUS rpccli_srvsvc_NetShareCheck(struct rpc_pipe_client *cli,
 
1035
                                     TALLOC_CTX *mem_ctx,
 
1036
                                     const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1037
                                     const char *device_name /* [in] [charset(UTF16)] */,
 
1038
                                     enum srvsvc_ShareType *type /* [out] [ref] */,
 
1039
                                     WERROR *werror)
 
1040
{
 
1041
        struct srvsvc_NetShareCheck r;
 
1042
        NTSTATUS status;
 
1043
 
 
1044
        /* In parameters */
 
1045
        r.in.server_unc = server_unc;
 
1046
        r.in.device_name = device_name;
 
1047
 
 
1048
        if (DEBUGLEVEL >= 10) {
 
1049
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, &r);
 
1050
        }
 
1051
 
 
1052
        status = cli->dispatch(cli,
 
1053
                                mem_ctx,
 
1054
                                &ndr_table_srvsvc,
 
1055
                                NDR_SRVSVC_NETSHARECHECK,
 
1056
                                &r);
 
1057
 
 
1058
        if (!NT_STATUS_IS_OK(status)) {
 
1059
                return status;
 
1060
        }
 
1061
 
 
1062
        if (DEBUGLEVEL >= 10) {
 
1063
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, &r);
 
1064
        }
 
1065
 
 
1066
        if (NT_STATUS_IS_ERR(status)) {
 
1067
                return status;
 
1068
        }
 
1069
 
 
1070
        /* Return variables */
 
1071
        *type = *r.out.type;
 
1072
 
 
1073
        /* Return result */
 
1074
        if (werror) {
 
1075
                *werror = r.out.result;
 
1076
        }
 
1077
 
 
1078
        return werror_to_ntstatus(r.out.result);
 
1079
}
 
1080
 
 
1081
NTSTATUS rpccli_srvsvc_NetSrvGetInfo(struct rpc_pipe_client *cli,
 
1082
                                     TALLOC_CTX *mem_ctx,
 
1083
                                     const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1084
                                     uint32_t level /* [in]  */,
 
1085
                                     union srvsvc_NetSrvInfo *info /* [out] [ref,switch_is(level)] */,
 
1086
                                     WERROR *werror)
 
1087
{
 
1088
        struct srvsvc_NetSrvGetInfo r;
 
1089
        NTSTATUS status;
 
1090
 
 
1091
        /* In parameters */
 
1092
        r.in.server_unc = server_unc;
 
1093
        r.in.level = level;
 
1094
 
 
1095
        if (DEBUGLEVEL >= 10) {
 
1096
                NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, &r);
 
1097
        }
 
1098
 
 
1099
        status = cli->dispatch(cli,
 
1100
                                mem_ctx,
 
1101
                                &ndr_table_srvsvc,
 
1102
                                NDR_SRVSVC_NETSRVGETINFO,
 
1103
                                &r);
 
1104
 
 
1105
        if (!NT_STATUS_IS_OK(status)) {
 
1106
                return status;
 
1107
        }
 
1108
 
 
1109
        if (DEBUGLEVEL >= 10) {
 
1110
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, &r);
 
1111
        }
 
1112
 
 
1113
        if (NT_STATUS_IS_ERR(status)) {
 
1114
                return status;
 
1115
        }
 
1116
 
 
1117
        /* Return variables */
 
1118
        *info = *r.out.info;
 
1119
 
 
1120
        /* Return result */
 
1121
        if (werror) {
 
1122
                *werror = r.out.result;
 
1123
        }
 
1124
 
 
1125
        return werror_to_ntstatus(r.out.result);
 
1126
}
 
1127
 
 
1128
NTSTATUS rpccli_srvsvc_NetSrvSetInfo(struct rpc_pipe_client *cli,
 
1129
                                     TALLOC_CTX *mem_ctx,
 
1130
                                     const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1131
                                     uint32_t level /* [in]  */,
 
1132
                                     union srvsvc_NetSrvInfo *info /* [in] [ref,switch_is(level)] */,
 
1133
                                     uint32_t *parm_error /* [in,out] [unique] */,
 
1134
                                     WERROR *werror)
 
1135
{
 
1136
        struct srvsvc_NetSrvSetInfo r;
 
1137
        NTSTATUS status;
 
1138
 
 
1139
        /* In parameters */
 
1140
        r.in.server_unc = server_unc;
 
1141
        r.in.level = level;
 
1142
        r.in.info = info;
 
1143
        r.in.parm_error = parm_error;
 
1144
 
 
1145
        if (DEBUGLEVEL >= 10) {
 
1146
                NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, &r);
 
1147
        }
 
1148
 
 
1149
        status = cli->dispatch(cli,
 
1150
                                mem_ctx,
 
1151
                                &ndr_table_srvsvc,
 
1152
                                NDR_SRVSVC_NETSRVSETINFO,
 
1153
                                &r);
 
1154
 
 
1155
        if (!NT_STATUS_IS_OK(status)) {
 
1156
                return status;
 
1157
        }
 
1158
 
 
1159
        if (DEBUGLEVEL >= 10) {
 
1160
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, &r);
 
1161
        }
 
1162
 
 
1163
        if (NT_STATUS_IS_ERR(status)) {
 
1164
                return status;
 
1165
        }
 
1166
 
 
1167
        /* Return variables */
 
1168
        if (parm_error && r.out.parm_error) {
 
1169
                *parm_error = *r.out.parm_error;
 
1170
        }
 
1171
 
 
1172
        /* Return result */
 
1173
        if (werror) {
 
1174
                *werror = r.out.result;
 
1175
        }
 
1176
 
 
1177
        return werror_to_ntstatus(r.out.result);
 
1178
}
 
1179
 
 
1180
NTSTATUS rpccli_srvsvc_NetDiskEnum(struct rpc_pipe_client *cli,
 
1181
                                   TALLOC_CTX *mem_ctx,
 
1182
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1183
                                   uint32_t level /* [in]  */,
 
1184
                                   struct srvsvc_NetDiskInfo *info /* [in,out] [ref] */,
 
1185
                                   uint32_t maxlen /* [in]  */,
 
1186
                                   uint32_t *totalentries /* [out] [ref] */,
 
1187
                                   uint32_t *resume_handle /* [in,out] [unique] */,
 
1188
                                   WERROR *werror)
 
1189
{
 
1190
        struct srvsvc_NetDiskEnum r;
 
1191
        NTSTATUS status;
 
1192
 
 
1193
        /* In parameters */
 
1194
        r.in.server_unc = server_unc;
 
1195
        r.in.level = level;
 
1196
        r.in.info = info;
 
1197
        r.in.maxlen = maxlen;
 
1198
        r.in.resume_handle = resume_handle;
 
1199
 
 
1200
        if (DEBUGLEVEL >= 10) {
 
1201
                NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, &r);
 
1202
        }
 
1203
 
 
1204
        status = cli->dispatch(cli,
 
1205
                                mem_ctx,
 
1206
                                &ndr_table_srvsvc,
 
1207
                                NDR_SRVSVC_NETDISKENUM,
 
1208
                                &r);
 
1209
 
 
1210
        if (!NT_STATUS_IS_OK(status)) {
 
1211
                return status;
 
1212
        }
 
1213
 
 
1214
        if (DEBUGLEVEL >= 10) {
 
1215
                NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, &r);
 
1216
        }
 
1217
 
 
1218
        if (NT_STATUS_IS_ERR(status)) {
 
1219
                return status;
 
1220
        }
 
1221
 
 
1222
        /* Return variables */
 
1223
        *info = *r.out.info;
 
1224
        *totalentries = *r.out.totalentries;
 
1225
        if (resume_handle && r.out.resume_handle) {
 
1226
                *resume_handle = *r.out.resume_handle;
 
1227
        }
 
1228
 
 
1229
        /* Return result */
 
1230
        if (werror) {
 
1231
                *werror = r.out.result;
 
1232
        }
 
1233
 
 
1234
        return werror_to_ntstatus(r.out.result);
 
1235
}
 
1236
 
 
1237
NTSTATUS rpccli_srvsvc_NetServerStatisticsGet(struct rpc_pipe_client *cli,
 
1238
                                              TALLOC_CTX *mem_ctx,
 
1239
                                              const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1240
                                              const char *service /* [in] [unique,charset(UTF16)] */,
 
1241
                                              uint32_t level /* [in]  */,
 
1242
                                              uint32_t options /* [in]  */,
 
1243
                                              struct srvsvc_Statistics **stats /* [out] [ref] */,
 
1244
                                              WERROR *werror)
 
1245
{
 
1246
        struct srvsvc_NetServerStatisticsGet r;
 
1247
        NTSTATUS status;
 
1248
 
 
1249
        /* In parameters */
 
1250
        r.in.server_unc = server_unc;
 
1251
        r.in.service = service;
 
1252
        r.in.level = level;
 
1253
        r.in.options = options;
 
1254
 
 
1255
        if (DEBUGLEVEL >= 10) {
 
1256
                NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, &r);
 
1257
        }
 
1258
 
 
1259
        status = cli->dispatch(cli,
 
1260
                                mem_ctx,
 
1261
                                &ndr_table_srvsvc,
 
1262
                                NDR_SRVSVC_NETSERVERSTATISTICSGET,
 
1263
                                &r);
 
1264
 
 
1265
        if (!NT_STATUS_IS_OK(status)) {
 
1266
                return status;
 
1267
        }
 
1268
 
 
1269
        if (DEBUGLEVEL >= 10) {
 
1270
                NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, &r);
 
1271
        }
 
1272
 
 
1273
        if (NT_STATUS_IS_ERR(status)) {
 
1274
                return status;
 
1275
        }
 
1276
 
 
1277
        /* Return variables */
 
1278
        *stats = *r.out.stats;
 
1279
 
 
1280
        /* Return result */
 
1281
        if (werror) {
 
1282
                *werror = r.out.result;
 
1283
        }
 
1284
 
 
1285
        return werror_to_ntstatus(r.out.result);
 
1286
}
 
1287
 
 
1288
NTSTATUS rpccli_srvsvc_NetTransportAdd(struct rpc_pipe_client *cli,
 
1289
                                       TALLOC_CTX *mem_ctx,
 
1290
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1291
                                       uint32_t level /* [in]  */,
 
1292
                                       union srvsvc_NetTransportInfo info /* [in] [switch_is(level)] */,
 
1293
                                       WERROR *werror)
 
1294
{
 
1295
        struct srvsvc_NetTransportAdd r;
 
1296
        NTSTATUS status;
 
1297
 
 
1298
        /* In parameters */
 
1299
        r.in.server_unc = server_unc;
 
1300
        r.in.level = level;
 
1301
        r.in.info = info;
 
1302
 
 
1303
        if (DEBUGLEVEL >= 10) {
 
1304
                NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, &r);
 
1305
        }
 
1306
 
 
1307
        status = cli->dispatch(cli,
 
1308
                                mem_ctx,
 
1309
                                &ndr_table_srvsvc,
 
1310
                                NDR_SRVSVC_NETTRANSPORTADD,
 
1311
                                &r);
 
1312
 
 
1313
        if (!NT_STATUS_IS_OK(status)) {
 
1314
                return status;
 
1315
        }
 
1316
 
 
1317
        if (DEBUGLEVEL >= 10) {
 
1318
                NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, &r);
 
1319
        }
 
1320
 
 
1321
        if (NT_STATUS_IS_ERR(status)) {
 
1322
                return status;
 
1323
        }
 
1324
 
 
1325
        /* Return variables */
 
1326
 
 
1327
        /* Return result */
 
1328
        if (werror) {
 
1329
                *werror = r.out.result;
 
1330
        }
 
1331
 
 
1332
        return werror_to_ntstatus(r.out.result);
 
1333
}
 
1334
 
 
1335
NTSTATUS rpccli_srvsvc_NetTransportEnum(struct rpc_pipe_client *cli,
 
1336
                                        TALLOC_CTX *mem_ctx,
 
1337
                                        const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1338
                                        struct srvsvc_NetTransportInfoCtr *transports /* [in,out] [ref] */,
 
1339
                                        uint32_t max_buffer /* [in]  */,
 
1340
                                        uint32_t *totalentries /* [out] [ref] */,
 
1341
                                        uint32_t *resume_handle /* [in,out] [unique] */,
 
1342
                                        WERROR *werror)
 
1343
{
 
1344
        struct srvsvc_NetTransportEnum r;
 
1345
        NTSTATUS status;
 
1346
 
 
1347
        /* In parameters */
 
1348
        r.in.server_unc = server_unc;
 
1349
        r.in.transports = transports;
 
1350
        r.in.max_buffer = max_buffer;
 
1351
        r.in.resume_handle = resume_handle;
 
1352
 
 
1353
        if (DEBUGLEVEL >= 10) {
 
1354
                NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, &r);
 
1355
        }
 
1356
 
 
1357
        status = cli->dispatch(cli,
 
1358
                                mem_ctx,
 
1359
                                &ndr_table_srvsvc,
 
1360
                                NDR_SRVSVC_NETTRANSPORTENUM,
 
1361
                                &r);
 
1362
 
 
1363
        if (!NT_STATUS_IS_OK(status)) {
 
1364
                return status;
 
1365
        }
 
1366
 
 
1367
        if (DEBUGLEVEL >= 10) {
 
1368
                NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, &r);
 
1369
        }
 
1370
 
 
1371
        if (NT_STATUS_IS_ERR(status)) {
 
1372
                return status;
 
1373
        }
 
1374
 
 
1375
        /* Return variables */
 
1376
        *transports = *r.out.transports;
 
1377
        *totalentries = *r.out.totalentries;
 
1378
        if (resume_handle && r.out.resume_handle) {
 
1379
                *resume_handle = *r.out.resume_handle;
 
1380
        }
 
1381
 
 
1382
        /* Return result */
 
1383
        if (werror) {
 
1384
                *werror = r.out.result;
 
1385
        }
 
1386
 
 
1387
        return werror_to_ntstatus(r.out.result);
 
1388
}
 
1389
 
 
1390
NTSTATUS rpccli_srvsvc_NetTransportDel(struct rpc_pipe_client *cli,
 
1391
                                       TALLOC_CTX *mem_ctx,
 
1392
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1393
                                       uint32_t level /* [in]  */,
 
1394
                                       struct srvsvc_NetTransportInfo0 *info0 /* [in] [ref] */,
 
1395
                                       WERROR *werror)
 
1396
{
 
1397
        struct srvsvc_NetTransportDel r;
 
1398
        NTSTATUS status;
 
1399
 
 
1400
        /* In parameters */
 
1401
        r.in.server_unc = server_unc;
 
1402
        r.in.level = level;
 
1403
        r.in.info0 = info0;
 
1404
 
 
1405
        if (DEBUGLEVEL >= 10) {
 
1406
                NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, &r);
 
1407
        }
 
1408
 
 
1409
        status = cli->dispatch(cli,
 
1410
                                mem_ctx,
 
1411
                                &ndr_table_srvsvc,
 
1412
                                NDR_SRVSVC_NETTRANSPORTDEL,
 
1413
                                &r);
 
1414
 
 
1415
        if (!NT_STATUS_IS_OK(status)) {
 
1416
                return status;
 
1417
        }
 
1418
 
 
1419
        if (DEBUGLEVEL >= 10) {
 
1420
                NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, &r);
 
1421
        }
 
1422
 
 
1423
        if (NT_STATUS_IS_ERR(status)) {
 
1424
                return status;
 
1425
        }
 
1426
 
 
1427
        /* Return variables */
 
1428
 
 
1429
        /* Return result */
 
1430
        if (werror) {
 
1431
                *werror = r.out.result;
 
1432
        }
 
1433
 
 
1434
        return werror_to_ntstatus(r.out.result);
 
1435
}
 
1436
 
 
1437
NTSTATUS rpccli_srvsvc_NetRemoteTOD(struct rpc_pipe_client *cli,
 
1438
                                    TALLOC_CTX *mem_ctx,
 
1439
                                    const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1440
                                    struct srvsvc_NetRemoteTODInfo **info /* [out] [ref] */,
 
1441
                                    WERROR *werror)
 
1442
{
 
1443
        struct srvsvc_NetRemoteTOD r;
 
1444
        NTSTATUS status;
 
1445
 
 
1446
        /* In parameters */
 
1447
        r.in.server_unc = server_unc;
 
1448
 
 
1449
        if (DEBUGLEVEL >= 10) {
 
1450
                NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, &r);
 
1451
        }
 
1452
 
 
1453
        status = cli->dispatch(cli,
 
1454
                                mem_ctx,
 
1455
                                &ndr_table_srvsvc,
 
1456
                                NDR_SRVSVC_NETREMOTETOD,
 
1457
                                &r);
 
1458
 
 
1459
        if (!NT_STATUS_IS_OK(status)) {
 
1460
                return status;
 
1461
        }
 
1462
 
 
1463
        if (DEBUGLEVEL >= 10) {
 
1464
                NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, &r);
 
1465
        }
 
1466
 
 
1467
        if (NT_STATUS_IS_ERR(status)) {
 
1468
                return status;
 
1469
        }
 
1470
 
 
1471
        /* Return variables */
 
1472
        *info = *r.out.info;
 
1473
 
 
1474
        /* Return result */
 
1475
        if (werror) {
 
1476
                *werror = r.out.result;
 
1477
        }
 
1478
 
 
1479
        return werror_to_ntstatus(r.out.result);
 
1480
}
 
1481
 
 
1482
NTSTATUS rpccli_srvsvc_NetSetServiceBits(struct rpc_pipe_client *cli,
 
1483
                                         TALLOC_CTX *mem_ctx,
 
1484
                                         const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1485
                                         const char *transport /* [in] [unique,charset(UTF16)] */,
 
1486
                                         uint32_t servicebits /* [in]  */,
 
1487
                                         uint32_t updateimmediately /* [in]  */,
 
1488
                                         WERROR *werror)
 
1489
{
 
1490
        struct srvsvc_NetSetServiceBits r;
 
1491
        NTSTATUS status;
 
1492
 
 
1493
        /* In parameters */
 
1494
        r.in.server_unc = server_unc;
 
1495
        r.in.transport = transport;
 
1496
        r.in.servicebits = servicebits;
 
1497
        r.in.updateimmediately = updateimmediately;
 
1498
 
 
1499
        if (DEBUGLEVEL >= 10) {
 
1500
                NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, &r);
 
1501
        }
 
1502
 
 
1503
        status = cli->dispatch(cli,
 
1504
                                mem_ctx,
 
1505
                                &ndr_table_srvsvc,
 
1506
                                NDR_SRVSVC_NETSETSERVICEBITS,
 
1507
                                &r);
 
1508
 
 
1509
        if (!NT_STATUS_IS_OK(status)) {
 
1510
                return status;
 
1511
        }
 
1512
 
 
1513
        if (DEBUGLEVEL >= 10) {
 
1514
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, &r);
 
1515
        }
 
1516
 
 
1517
        if (NT_STATUS_IS_ERR(status)) {
 
1518
                return status;
 
1519
        }
 
1520
 
 
1521
        /* Return variables */
 
1522
 
 
1523
        /* Return result */
 
1524
        if (werror) {
 
1525
                *werror = r.out.result;
 
1526
        }
 
1527
 
 
1528
        return werror_to_ntstatus(r.out.result);
 
1529
}
 
1530
 
 
1531
NTSTATUS rpccli_srvsvc_NetPathType(struct rpc_pipe_client *cli,
 
1532
                                   TALLOC_CTX *mem_ctx,
 
1533
                                   const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1534
                                   const char *path /* [in] [charset(UTF16)] */,
 
1535
                                   uint32_t pathflags /* [in]  */,
 
1536
                                   uint32_t *pathtype /* [out] [ref] */,
 
1537
                                   WERROR *werror)
 
1538
{
 
1539
        struct srvsvc_NetPathType r;
 
1540
        NTSTATUS status;
 
1541
 
 
1542
        /* In parameters */
 
1543
        r.in.server_unc = server_unc;
 
1544
        r.in.path = path;
 
1545
        r.in.pathflags = pathflags;
 
1546
 
 
1547
        if (DEBUGLEVEL >= 10) {
 
1548
                NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, &r);
 
1549
        }
 
1550
 
 
1551
        status = cli->dispatch(cli,
 
1552
                                mem_ctx,
 
1553
                                &ndr_table_srvsvc,
 
1554
                                NDR_SRVSVC_NETPATHTYPE,
 
1555
                                &r);
 
1556
 
 
1557
        if (!NT_STATUS_IS_OK(status)) {
 
1558
                return status;
 
1559
        }
 
1560
 
 
1561
        if (DEBUGLEVEL >= 10) {
 
1562
                NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, &r);
 
1563
        }
 
1564
 
 
1565
        if (NT_STATUS_IS_ERR(status)) {
 
1566
                return status;
 
1567
        }
 
1568
 
 
1569
        /* Return variables */
 
1570
        *pathtype = *r.out.pathtype;
 
1571
 
 
1572
        /* Return result */
 
1573
        if (werror) {
 
1574
                *werror = r.out.result;
 
1575
        }
 
1576
 
 
1577
        return werror_to_ntstatus(r.out.result);
 
1578
}
 
1579
 
 
1580
NTSTATUS rpccli_srvsvc_NetPathCanonicalize(struct rpc_pipe_client *cli,
 
1581
                                           TALLOC_CTX *mem_ctx,
 
1582
                                           const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1583
                                           const char *path /* [in] [charset(UTF16)] */,
 
1584
                                           uint8_t *can_path /* [out] [size_is(maxbuf)] */,
 
1585
                                           uint32_t maxbuf /* [in]  */,
 
1586
                                           const char *prefix /* [in] [charset(UTF16)] */,
 
1587
                                           uint32_t *pathtype /* [in,out] [ref] */,
 
1588
                                           uint32_t pathflags /* [in]  */,
 
1589
                                           WERROR *werror)
 
1590
{
 
1591
        struct srvsvc_NetPathCanonicalize r;
 
1592
        NTSTATUS status;
 
1593
 
 
1594
        /* In parameters */
 
1595
        r.in.server_unc = server_unc;
 
1596
        r.in.path = path;
 
1597
        r.in.maxbuf = maxbuf;
 
1598
        r.in.prefix = prefix;
 
1599
        r.in.pathtype = pathtype;
 
1600
        r.in.pathflags = pathflags;
 
1601
 
 
1602
        if (DEBUGLEVEL >= 10) {
 
1603
                NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, &r);
 
1604
        }
 
1605
 
 
1606
        status = cli->dispatch(cli,
 
1607
                                mem_ctx,
 
1608
                                &ndr_table_srvsvc,
 
1609
                                NDR_SRVSVC_NETPATHCANONICALIZE,
 
1610
                                &r);
 
1611
 
 
1612
        if (!NT_STATUS_IS_OK(status)) {
 
1613
                return status;
 
1614
        }
 
1615
 
 
1616
        if (DEBUGLEVEL >= 10) {
 
1617
                NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, &r);
 
1618
        }
 
1619
 
 
1620
        if (NT_STATUS_IS_ERR(status)) {
 
1621
                return status;
 
1622
        }
 
1623
 
 
1624
        /* Return variables */
 
1625
        memcpy(can_path, r.out.can_path, (r.in.maxbuf) * sizeof(*can_path));
 
1626
        *pathtype = *r.out.pathtype;
 
1627
 
 
1628
        /* Return result */
 
1629
        if (werror) {
 
1630
                *werror = r.out.result;
 
1631
        }
 
1632
 
 
1633
        return werror_to_ntstatus(r.out.result);
 
1634
}
 
1635
 
 
1636
NTSTATUS rpccli_srvsvc_NetPathCompare(struct rpc_pipe_client *cli,
 
1637
                                      TALLOC_CTX *mem_ctx,
 
1638
                                      const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1639
                                      const char *path1 /* [in] [charset(UTF16)] */,
 
1640
                                      const char *path2 /* [in] [charset(UTF16)] */,
 
1641
                                      uint32_t pathtype /* [in]  */,
 
1642
                                      uint32_t pathflags /* [in]  */,
 
1643
                                      WERROR *werror)
 
1644
{
 
1645
        struct srvsvc_NetPathCompare r;
 
1646
        NTSTATUS status;
 
1647
 
 
1648
        /* In parameters */
 
1649
        r.in.server_unc = server_unc;
 
1650
        r.in.path1 = path1;
 
1651
        r.in.path2 = path2;
 
1652
        r.in.pathtype = pathtype;
 
1653
        r.in.pathflags = pathflags;
 
1654
 
 
1655
        if (DEBUGLEVEL >= 10) {
 
1656
                NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, &r);
 
1657
        }
 
1658
 
 
1659
        status = cli->dispatch(cli,
 
1660
                                mem_ctx,
 
1661
                                &ndr_table_srvsvc,
 
1662
                                NDR_SRVSVC_NETPATHCOMPARE,
 
1663
                                &r);
 
1664
 
 
1665
        if (!NT_STATUS_IS_OK(status)) {
 
1666
                return status;
 
1667
        }
 
1668
 
 
1669
        if (DEBUGLEVEL >= 10) {
 
1670
                NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, &r);
 
1671
        }
 
1672
 
 
1673
        if (NT_STATUS_IS_ERR(status)) {
 
1674
                return status;
 
1675
        }
 
1676
 
 
1677
        /* Return variables */
 
1678
 
 
1679
        /* Return result */
 
1680
        if (werror) {
 
1681
                *werror = r.out.result;
 
1682
        }
 
1683
 
 
1684
        return werror_to_ntstatus(r.out.result);
 
1685
}
 
1686
 
 
1687
NTSTATUS rpccli_srvsvc_NetNameValidate(struct rpc_pipe_client *cli,
 
1688
                                       TALLOC_CTX *mem_ctx,
 
1689
                                       const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1690
                                       const char *name /* [in] [charset(UTF16)] */,
 
1691
                                       uint32_t name_type /* [in]  */,
 
1692
                                       uint32_t flags /* [in]  */,
 
1693
                                       WERROR *werror)
 
1694
{
 
1695
        struct srvsvc_NetNameValidate r;
 
1696
        NTSTATUS status;
 
1697
 
 
1698
        /* In parameters */
 
1699
        r.in.server_unc = server_unc;
 
1700
        r.in.name = name;
 
1701
        r.in.name_type = name_type;
 
1702
        r.in.flags = flags;
 
1703
 
 
1704
        if (DEBUGLEVEL >= 10) {
 
1705
                NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, &r);
 
1706
        }
 
1707
 
 
1708
        status = cli->dispatch(cli,
 
1709
                                mem_ctx,
 
1710
                                &ndr_table_srvsvc,
 
1711
                                NDR_SRVSVC_NETNAMEVALIDATE,
 
1712
                                &r);
 
1713
 
 
1714
        if (!NT_STATUS_IS_OK(status)) {
 
1715
                return status;
 
1716
        }
 
1717
 
 
1718
        if (DEBUGLEVEL >= 10) {
 
1719
                NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, &r);
 
1720
        }
 
1721
 
 
1722
        if (NT_STATUS_IS_ERR(status)) {
 
1723
                return status;
 
1724
        }
 
1725
 
 
1726
        /* Return variables */
 
1727
 
 
1728
        /* Return result */
 
1729
        if (werror) {
 
1730
                *werror = r.out.result;
 
1731
        }
 
1732
 
 
1733
        return werror_to_ntstatus(r.out.result);
 
1734
}
 
1735
 
 
1736
NTSTATUS rpccli_srvsvc_NETRPRNAMECANONICALIZE(struct rpc_pipe_client *cli,
 
1737
                                              TALLOC_CTX *mem_ctx,
 
1738
                                              WERROR *werror)
 
1739
{
 
1740
        struct srvsvc_NETRPRNAMECANONICALIZE r;
 
1741
        NTSTATUS status;
 
1742
 
 
1743
        /* In parameters */
 
1744
 
 
1745
        if (DEBUGLEVEL >= 10) {
 
1746
                NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
 
1747
        }
 
1748
 
 
1749
        status = cli->dispatch(cli,
 
1750
                                mem_ctx,
 
1751
                                &ndr_table_srvsvc,
 
1752
                                NDR_SRVSVC_NETRPRNAMECANONICALIZE,
 
1753
                                &r);
 
1754
 
 
1755
        if (!NT_STATUS_IS_OK(status)) {
 
1756
                return status;
 
1757
        }
 
1758
 
 
1759
        if (DEBUGLEVEL >= 10) {
 
1760
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
 
1761
        }
 
1762
 
 
1763
        if (NT_STATUS_IS_ERR(status)) {
 
1764
                return status;
 
1765
        }
 
1766
 
 
1767
        /* Return variables */
 
1768
 
 
1769
        /* Return result */
 
1770
        if (werror) {
 
1771
                *werror = r.out.result;
 
1772
        }
 
1773
 
 
1774
        return werror_to_ntstatus(r.out.result);
 
1775
}
 
1776
 
 
1777
NTSTATUS rpccli_srvsvc_NetPRNameCompare(struct rpc_pipe_client *cli,
 
1778
                                        TALLOC_CTX *mem_ctx,
 
1779
                                        const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1780
                                        const char *name1 /* [in] [charset(UTF16)] */,
 
1781
                                        const char *name2 /* [in] [charset(UTF16)] */,
 
1782
                                        uint32_t name_type /* [in]  */,
 
1783
                                        uint32_t flags /* [in]  */,
 
1784
                                        WERROR *werror)
 
1785
{
 
1786
        struct srvsvc_NetPRNameCompare r;
 
1787
        NTSTATUS status;
 
1788
 
 
1789
        /* In parameters */
 
1790
        r.in.server_unc = server_unc;
 
1791
        r.in.name1 = name1;
 
1792
        r.in.name2 = name2;
 
1793
        r.in.name_type = name_type;
 
1794
        r.in.flags = flags;
 
1795
 
 
1796
        if (DEBUGLEVEL >= 10) {
 
1797
                NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, &r);
 
1798
        }
 
1799
 
 
1800
        status = cli->dispatch(cli,
 
1801
                                mem_ctx,
 
1802
                                &ndr_table_srvsvc,
 
1803
                                NDR_SRVSVC_NETPRNAMECOMPARE,
 
1804
                                &r);
 
1805
 
 
1806
        if (!NT_STATUS_IS_OK(status)) {
 
1807
                return status;
 
1808
        }
 
1809
 
 
1810
        if (DEBUGLEVEL >= 10) {
 
1811
                NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, &r);
 
1812
        }
 
1813
 
 
1814
        if (NT_STATUS_IS_ERR(status)) {
 
1815
                return status;
 
1816
        }
 
1817
 
 
1818
        /* Return variables */
 
1819
 
 
1820
        /* Return result */
 
1821
        if (werror) {
 
1822
                *werror = r.out.result;
 
1823
        }
 
1824
 
 
1825
        return werror_to_ntstatus(r.out.result);
 
1826
}
 
1827
 
 
1828
NTSTATUS rpccli_srvsvc_NetShareEnum(struct rpc_pipe_client *cli,
 
1829
                                    TALLOC_CTX *mem_ctx,
 
1830
                                    const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1831
                                    struct srvsvc_NetShareInfoCtr *info_ctr /* [in,out] [ref] */,
 
1832
                                    uint32_t max_buffer /* [in]  */,
 
1833
                                    uint32_t *totalentries /* [out] [ref] */,
 
1834
                                    uint32_t *resume_handle /* [in,out] [unique] */,
 
1835
                                    WERROR *werror)
 
1836
{
 
1837
        struct srvsvc_NetShareEnum r;
 
1838
        NTSTATUS status;
 
1839
 
 
1840
        /* In parameters */
 
1841
        r.in.server_unc = server_unc;
 
1842
        r.in.info_ctr = info_ctr;
 
1843
        r.in.max_buffer = max_buffer;
 
1844
        r.in.resume_handle = resume_handle;
 
1845
 
 
1846
        if (DEBUGLEVEL >= 10) {
 
1847
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, &r);
 
1848
        }
 
1849
 
 
1850
        status = cli->dispatch(cli,
 
1851
                                mem_ctx,
 
1852
                                &ndr_table_srvsvc,
 
1853
                                NDR_SRVSVC_NETSHAREENUM,
 
1854
                                &r);
 
1855
 
 
1856
        if (!NT_STATUS_IS_OK(status)) {
 
1857
                return status;
 
1858
        }
 
1859
 
 
1860
        if (DEBUGLEVEL >= 10) {
 
1861
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, &r);
 
1862
        }
 
1863
 
 
1864
        if (NT_STATUS_IS_ERR(status)) {
 
1865
                return status;
 
1866
        }
 
1867
 
 
1868
        /* Return variables */
 
1869
        *info_ctr = *r.out.info_ctr;
 
1870
        *totalentries = *r.out.totalentries;
 
1871
        if (resume_handle && r.out.resume_handle) {
 
1872
                *resume_handle = *r.out.resume_handle;
 
1873
        }
 
1874
 
 
1875
        /* Return result */
 
1876
        if (werror) {
 
1877
                *werror = r.out.result;
 
1878
        }
 
1879
 
 
1880
        return werror_to_ntstatus(r.out.result);
 
1881
}
 
1882
 
 
1883
NTSTATUS rpccli_srvsvc_NetShareDelStart(struct rpc_pipe_client *cli,
 
1884
                                        TALLOC_CTX *mem_ctx,
 
1885
                                        const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1886
                                        const char *share /* [in] [charset(UTF16)] */,
 
1887
                                        uint32_t reserved /* [in]  */,
 
1888
                                        struct policy_handle *hnd /* [out] [unique] */,
 
1889
                                        WERROR *werror)
 
1890
{
 
1891
        struct srvsvc_NetShareDelStart r;
 
1892
        NTSTATUS status;
 
1893
 
 
1894
        /* In parameters */
 
1895
        r.in.server_unc = server_unc;
 
1896
        r.in.share = share;
 
1897
        r.in.reserved = reserved;
 
1898
 
 
1899
        if (DEBUGLEVEL >= 10) {
 
1900
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, &r);
 
1901
        }
 
1902
 
 
1903
        status = cli->dispatch(cli,
 
1904
                                mem_ctx,
 
1905
                                &ndr_table_srvsvc,
 
1906
                                NDR_SRVSVC_NETSHAREDELSTART,
 
1907
                                &r);
 
1908
 
 
1909
        if (!NT_STATUS_IS_OK(status)) {
 
1910
                return status;
 
1911
        }
 
1912
 
 
1913
        if (DEBUGLEVEL >= 10) {
 
1914
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, &r);
 
1915
        }
 
1916
 
 
1917
        if (NT_STATUS_IS_ERR(status)) {
 
1918
                return status;
 
1919
        }
 
1920
 
 
1921
        /* Return variables */
 
1922
        if (hnd && r.out.hnd) {
 
1923
                *hnd = *r.out.hnd;
 
1924
        }
 
1925
 
 
1926
        /* Return result */
 
1927
        if (werror) {
 
1928
                *werror = r.out.result;
 
1929
        }
 
1930
 
 
1931
        return werror_to_ntstatus(r.out.result);
 
1932
}
 
1933
 
 
1934
NTSTATUS rpccli_srvsvc_NetShareDelCommit(struct rpc_pipe_client *cli,
 
1935
                                         TALLOC_CTX *mem_ctx,
 
1936
                                         struct policy_handle *hnd /* [in,out] [unique] */,
 
1937
                                         WERROR *werror)
 
1938
{
 
1939
        struct srvsvc_NetShareDelCommit r;
 
1940
        NTSTATUS status;
 
1941
 
 
1942
        /* In parameters */
 
1943
        r.in.hnd = hnd;
 
1944
 
 
1945
        if (DEBUGLEVEL >= 10) {
 
1946
                NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, &r);
 
1947
        }
 
1948
 
 
1949
        status = cli->dispatch(cli,
 
1950
                                mem_ctx,
 
1951
                                &ndr_table_srvsvc,
 
1952
                                NDR_SRVSVC_NETSHAREDELCOMMIT,
 
1953
                                &r);
 
1954
 
 
1955
        if (!NT_STATUS_IS_OK(status)) {
 
1956
                return status;
 
1957
        }
 
1958
 
 
1959
        if (DEBUGLEVEL >= 10) {
 
1960
                NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, &r);
 
1961
        }
 
1962
 
 
1963
        if (NT_STATUS_IS_ERR(status)) {
 
1964
                return status;
 
1965
        }
 
1966
 
 
1967
        /* Return variables */
 
1968
        if (hnd && r.out.hnd) {
 
1969
                *hnd = *r.out.hnd;
 
1970
        }
 
1971
 
 
1972
        /* Return result */
 
1973
        if (werror) {
 
1974
                *werror = r.out.result;
 
1975
        }
 
1976
 
 
1977
        return werror_to_ntstatus(r.out.result);
 
1978
}
 
1979
 
 
1980
NTSTATUS rpccli_srvsvc_NetGetFileSecurity(struct rpc_pipe_client *cli,
 
1981
                                          TALLOC_CTX *mem_ctx,
 
1982
                                          const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
1983
                                          const char *share /* [in] [unique,charset(UTF16)] */,
 
1984
                                          const char *file /* [in] [charset(UTF16)] */,
 
1985
                                          uint32_t securityinformation /* [in]  */,
 
1986
                                          struct sec_desc_buf **sd_buf /* [out] [ref] */,
 
1987
                                          WERROR *werror)
 
1988
{
 
1989
        struct srvsvc_NetGetFileSecurity r;
 
1990
        NTSTATUS status;
 
1991
 
 
1992
        /* In parameters */
 
1993
        r.in.server_unc = server_unc;
 
1994
        r.in.share = share;
 
1995
        r.in.file = file;
 
1996
        r.in.securityinformation = securityinformation;
 
1997
 
 
1998
        if (DEBUGLEVEL >= 10) {
 
1999
                NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, &r);
 
2000
        }
 
2001
 
 
2002
        status = cli->dispatch(cli,
 
2003
                                mem_ctx,
 
2004
                                &ndr_table_srvsvc,
 
2005
                                NDR_SRVSVC_NETGETFILESECURITY,
 
2006
                                &r);
 
2007
 
 
2008
        if (!NT_STATUS_IS_OK(status)) {
 
2009
                return status;
 
2010
        }
 
2011
 
 
2012
        if (DEBUGLEVEL >= 10) {
 
2013
                NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, &r);
 
2014
        }
 
2015
 
 
2016
        if (NT_STATUS_IS_ERR(status)) {
 
2017
                return status;
 
2018
        }
 
2019
 
 
2020
        /* Return variables */
 
2021
        *sd_buf = *r.out.sd_buf;
 
2022
 
 
2023
        /* Return result */
 
2024
        if (werror) {
 
2025
                *werror = r.out.result;
 
2026
        }
 
2027
 
 
2028
        return werror_to_ntstatus(r.out.result);
 
2029
}
 
2030
 
 
2031
NTSTATUS rpccli_srvsvc_NetSetFileSecurity(struct rpc_pipe_client *cli,
 
2032
                                          TALLOC_CTX *mem_ctx,
 
2033
                                          const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
2034
                                          const char *share /* [in] [unique,charset(UTF16)] */,
 
2035
                                          const char *file /* [in] [charset(UTF16)] */,
 
2036
                                          uint32_t securityinformation /* [in]  */,
 
2037
                                          struct sec_desc_buf *sd_buf /* [in] [ref] */,
 
2038
                                          WERROR *werror)
 
2039
{
 
2040
        struct srvsvc_NetSetFileSecurity r;
 
2041
        NTSTATUS status;
 
2042
 
 
2043
        /* In parameters */
 
2044
        r.in.server_unc = server_unc;
 
2045
        r.in.share = share;
 
2046
        r.in.file = file;
 
2047
        r.in.securityinformation = securityinformation;
 
2048
        r.in.sd_buf = sd_buf;
 
2049
 
 
2050
        if (DEBUGLEVEL >= 10) {
 
2051
                NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, &r);
 
2052
        }
 
2053
 
 
2054
        status = cli->dispatch(cli,
 
2055
                                mem_ctx,
 
2056
                                &ndr_table_srvsvc,
 
2057
                                NDR_SRVSVC_NETSETFILESECURITY,
 
2058
                                &r);
 
2059
 
 
2060
        if (!NT_STATUS_IS_OK(status)) {
 
2061
                return status;
 
2062
        }
 
2063
 
 
2064
        if (DEBUGLEVEL >= 10) {
 
2065
                NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, &r);
 
2066
        }
 
2067
 
 
2068
        if (NT_STATUS_IS_ERR(status)) {
 
2069
                return status;
 
2070
        }
 
2071
 
 
2072
        /* Return variables */
 
2073
 
 
2074
        /* Return result */
 
2075
        if (werror) {
 
2076
                *werror = r.out.result;
 
2077
        }
 
2078
 
 
2079
        return werror_to_ntstatus(r.out.result);
 
2080
}
 
2081
 
 
2082
NTSTATUS rpccli_srvsvc_NetServerTransportAddEx(struct rpc_pipe_client *cli,
 
2083
                                               TALLOC_CTX *mem_ctx,
 
2084
                                               const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
2085
                                               uint32_t level /* [in]  */,
 
2086
                                               union srvsvc_NetTransportInfo info /* [in] [switch_is(level)] */,
 
2087
                                               WERROR *werror)
 
2088
{
 
2089
        struct srvsvc_NetServerTransportAddEx r;
 
2090
        NTSTATUS status;
 
2091
 
 
2092
        /* In parameters */
 
2093
        r.in.server_unc = server_unc;
 
2094
        r.in.level = level;
 
2095
        r.in.info = info;
 
2096
 
 
2097
        if (DEBUGLEVEL >= 10) {
 
2098
                NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, &r);
 
2099
        }
 
2100
 
 
2101
        status = cli->dispatch(cli,
 
2102
                                mem_ctx,
 
2103
                                &ndr_table_srvsvc,
 
2104
                                NDR_SRVSVC_NETSERVERTRANSPORTADDEX,
 
2105
                                &r);
 
2106
 
 
2107
        if (!NT_STATUS_IS_OK(status)) {
 
2108
                return status;
 
2109
        }
 
2110
 
 
2111
        if (DEBUGLEVEL >= 10) {
 
2112
                NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, &r);
 
2113
        }
 
2114
 
 
2115
        if (NT_STATUS_IS_ERR(status)) {
 
2116
                return status;
 
2117
        }
 
2118
 
 
2119
        /* Return variables */
 
2120
 
 
2121
        /* Return result */
 
2122
        if (werror) {
 
2123
                *werror = r.out.result;
 
2124
        }
 
2125
 
 
2126
        return werror_to_ntstatus(r.out.result);
 
2127
}
 
2128
 
 
2129
NTSTATUS rpccli_srvsvc_NetServerSetServiceBitsEx(struct rpc_pipe_client *cli,
 
2130
                                                 TALLOC_CTX *mem_ctx,
 
2131
                                                 const char *server_unc /* [in] [unique,charset(UTF16)] */,
 
2132
                                                 const char *emulated_server_unc /* [in] [unique,charset(UTF16)] */,
 
2133
                                                 const char *transport /* [in] [unique,charset(UTF16)] */,
 
2134
                                                 uint32_t servicebitsofinterest /* [in]  */,
 
2135
                                                 uint32_t servicebits /* [in]  */,
 
2136
                                                 uint32_t updateimmediately /* [in]  */,
 
2137
                                                 WERROR *werror)
 
2138
{
 
2139
        struct srvsvc_NetServerSetServiceBitsEx r;
 
2140
        NTSTATUS status;
 
2141
 
 
2142
        /* In parameters */
 
2143
        r.in.server_unc = server_unc;
 
2144
        r.in.emulated_server_unc = emulated_server_unc;
 
2145
        r.in.transport = transport;
 
2146
        r.in.servicebitsofinterest = servicebitsofinterest;
 
2147
        r.in.servicebits = servicebits;
 
2148
        r.in.updateimmediately = updateimmediately;
 
2149
 
 
2150
        if (DEBUGLEVEL >= 10) {
 
2151
                NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
 
2152
        }
 
2153
 
 
2154
        status = cli->dispatch(cli,
 
2155
                                mem_ctx,
 
2156
                                &ndr_table_srvsvc,
 
2157
                                NDR_SRVSVC_NETSERVERSETSERVICEBITSEX,
 
2158
                                &r);
 
2159
 
 
2160
        if (!NT_STATUS_IS_OK(status)) {
 
2161
                return status;
 
2162
        }
 
2163
 
 
2164
        if (DEBUGLEVEL >= 10) {
 
2165
                NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
 
2166
        }
 
2167
 
 
2168
        if (NT_STATUS_IS_ERR(status)) {
 
2169
                return status;
 
2170
        }
 
2171
 
 
2172
        /* Return variables */
 
2173
 
 
2174
        /* Return result */
 
2175
        if (werror) {
 
2176
                *werror = r.out.result;
 
2177
        }
 
2178
 
 
2179
        return werror_to_ntstatus(r.out.result);
 
2180
}
 
2181
 
 
2182
NTSTATUS rpccli_srvsvc_NETRDFSGETVERSION(struct rpc_pipe_client *cli,
 
2183
                                         TALLOC_CTX *mem_ctx,
 
2184
                                         WERROR *werror)
 
2185
{
 
2186
        struct srvsvc_NETRDFSGETVERSION r;
 
2187
        NTSTATUS status;
 
2188
 
 
2189
        /* In parameters */
 
2190
 
 
2191
        if (DEBUGLEVEL >= 10) {
 
2192
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
 
2193
        }
 
2194
 
 
2195
        status = cli->dispatch(cli,
 
2196
                                mem_ctx,
 
2197
                                &ndr_table_srvsvc,
 
2198
                                NDR_SRVSVC_NETRDFSGETVERSION,
 
2199
                                &r);
 
2200
 
 
2201
        if (!NT_STATUS_IS_OK(status)) {
 
2202
                return status;
 
2203
        }
 
2204
 
 
2205
        if (DEBUGLEVEL >= 10) {
 
2206
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
 
2207
        }
 
2208
 
 
2209
        if (NT_STATUS_IS_ERR(status)) {
 
2210
                return status;
 
2211
        }
 
2212
 
 
2213
        /* Return variables */
 
2214
 
 
2215
        /* Return result */
 
2216
        if (werror) {
 
2217
                *werror = r.out.result;
 
2218
        }
 
2219
 
 
2220
        return werror_to_ntstatus(r.out.result);
 
2221
}
 
2222
 
 
2223
NTSTATUS rpccli_srvsvc_NETRDFSCREATELOCALPARTITION(struct rpc_pipe_client *cli,
 
2224
                                                   TALLOC_CTX *mem_ctx,
 
2225
                                                   WERROR *werror)
 
2226
{
 
2227
        struct srvsvc_NETRDFSCREATELOCALPARTITION r;
 
2228
        NTSTATUS status;
 
2229
 
 
2230
        /* In parameters */
 
2231
 
 
2232
        if (DEBUGLEVEL >= 10) {
 
2233
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
 
2234
        }
 
2235
 
 
2236
        status = cli->dispatch(cli,
 
2237
                                mem_ctx,
 
2238
                                &ndr_table_srvsvc,
 
2239
                                NDR_SRVSVC_NETRDFSCREATELOCALPARTITION,
 
2240
                                &r);
 
2241
 
 
2242
        if (!NT_STATUS_IS_OK(status)) {
 
2243
                return status;
 
2244
        }
 
2245
 
 
2246
        if (DEBUGLEVEL >= 10) {
 
2247
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
 
2248
        }
 
2249
 
 
2250
        if (NT_STATUS_IS_ERR(status)) {
 
2251
                return status;
 
2252
        }
 
2253
 
 
2254
        /* Return variables */
 
2255
 
 
2256
        /* Return result */
 
2257
        if (werror) {
 
2258
                *werror = r.out.result;
 
2259
        }
 
2260
 
 
2261
        return werror_to_ntstatus(r.out.result);
 
2262
}
 
2263
 
 
2264
NTSTATUS rpccli_srvsvc_NETRDFSDELETELOCALPARTITION(struct rpc_pipe_client *cli,
 
2265
                                                   TALLOC_CTX *mem_ctx,
 
2266
                                                   WERROR *werror)
 
2267
{
 
2268
        struct srvsvc_NETRDFSDELETELOCALPARTITION r;
 
2269
        NTSTATUS status;
 
2270
 
 
2271
        /* In parameters */
 
2272
 
 
2273
        if (DEBUGLEVEL >= 10) {
 
2274
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
 
2275
        }
 
2276
 
 
2277
        status = cli->dispatch(cli,
 
2278
                                mem_ctx,
 
2279
                                &ndr_table_srvsvc,
 
2280
                                NDR_SRVSVC_NETRDFSDELETELOCALPARTITION,
 
2281
                                &r);
 
2282
 
 
2283
        if (!NT_STATUS_IS_OK(status)) {
 
2284
                return status;
 
2285
        }
 
2286
 
 
2287
        if (DEBUGLEVEL >= 10) {
 
2288
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
 
2289
        }
 
2290
 
 
2291
        if (NT_STATUS_IS_ERR(status)) {
 
2292
                return status;
 
2293
        }
 
2294
 
 
2295
        /* Return variables */
 
2296
 
 
2297
        /* Return result */
 
2298
        if (werror) {
 
2299
                *werror = r.out.result;
 
2300
        }
 
2301
 
 
2302
        return werror_to_ntstatus(r.out.result);
 
2303
}
 
2304
 
 
2305
NTSTATUS rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct rpc_pipe_client *cli,
 
2306
                                                  TALLOC_CTX *mem_ctx,
 
2307
                                                  WERROR *werror)
 
2308
{
 
2309
        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE r;
 
2310
        NTSTATUS status;
 
2311
 
 
2312
        /* In parameters */
 
2313
 
 
2314
        if (DEBUGLEVEL >= 10) {
 
2315
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
 
2316
        }
 
2317
 
 
2318
        status = cli->dispatch(cli,
 
2319
                                mem_ctx,
 
2320
                                &ndr_table_srvsvc,
 
2321
                                NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE,
 
2322
                                &r);
 
2323
 
 
2324
        if (!NT_STATUS_IS_OK(status)) {
 
2325
                return status;
 
2326
        }
 
2327
 
 
2328
        if (DEBUGLEVEL >= 10) {
 
2329
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
 
2330
        }
 
2331
 
 
2332
        if (NT_STATUS_IS_ERR(status)) {
 
2333
                return status;
 
2334
        }
 
2335
 
 
2336
        /* Return variables */
 
2337
 
 
2338
        /* Return result */
 
2339
        if (werror) {
 
2340
                *werror = r.out.result;
 
2341
        }
 
2342
 
 
2343
        return werror_to_ntstatus(r.out.result);
 
2344
}
 
2345
 
 
2346
NTSTATUS rpccli_srvsvc_NETRDFSSETSERVERINFO(struct rpc_pipe_client *cli,
 
2347
                                            TALLOC_CTX *mem_ctx,
 
2348
                                            WERROR *werror)
 
2349
{
 
2350
        struct srvsvc_NETRDFSSETSERVERINFO r;
 
2351
        NTSTATUS status;
 
2352
 
 
2353
        /* In parameters */
 
2354
 
 
2355
        if (DEBUGLEVEL >= 10) {
 
2356
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
 
2357
        }
 
2358
 
 
2359
        status = cli->dispatch(cli,
 
2360
                                mem_ctx,
 
2361
                                &ndr_table_srvsvc,
 
2362
                                NDR_SRVSVC_NETRDFSSETSERVERINFO,
 
2363
                                &r);
 
2364
 
 
2365
        if (!NT_STATUS_IS_OK(status)) {
 
2366
                return status;
 
2367
        }
 
2368
 
 
2369
        if (DEBUGLEVEL >= 10) {
 
2370
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
 
2371
        }
 
2372
 
 
2373
        if (NT_STATUS_IS_ERR(status)) {
 
2374
                return status;
 
2375
        }
 
2376
 
 
2377
        /* Return variables */
 
2378
 
 
2379
        /* Return result */
 
2380
        if (werror) {
 
2381
                *werror = r.out.result;
 
2382
        }
 
2383
 
 
2384
        return werror_to_ntstatus(r.out.result);
 
2385
}
 
2386
 
 
2387
NTSTATUS rpccli_srvsvc_NETRDFSCREATEEXITPOINT(struct rpc_pipe_client *cli,
 
2388
                                              TALLOC_CTX *mem_ctx,
 
2389
                                              WERROR *werror)
 
2390
{
 
2391
        struct srvsvc_NETRDFSCREATEEXITPOINT r;
 
2392
        NTSTATUS status;
 
2393
 
 
2394
        /* In parameters */
 
2395
 
 
2396
        if (DEBUGLEVEL >= 10) {
 
2397
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
 
2398
        }
 
2399
 
 
2400
        status = cli->dispatch(cli,
 
2401
                                mem_ctx,
 
2402
                                &ndr_table_srvsvc,
 
2403
                                NDR_SRVSVC_NETRDFSCREATEEXITPOINT,
 
2404
                                &r);
 
2405
 
 
2406
        if (!NT_STATUS_IS_OK(status)) {
 
2407
                return status;
 
2408
        }
 
2409
 
 
2410
        if (DEBUGLEVEL >= 10) {
 
2411
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
 
2412
        }
 
2413
 
 
2414
        if (NT_STATUS_IS_ERR(status)) {
 
2415
                return status;
 
2416
        }
 
2417
 
 
2418
        /* Return variables */
 
2419
 
 
2420
        /* Return result */
 
2421
        if (werror) {
 
2422
                *werror = r.out.result;
 
2423
        }
 
2424
 
 
2425
        return werror_to_ntstatus(r.out.result);
 
2426
}
 
2427
 
 
2428
NTSTATUS rpccli_srvsvc_NETRDFSDELETEEXITPOINT(struct rpc_pipe_client *cli,
 
2429
                                              TALLOC_CTX *mem_ctx,
 
2430
                                              WERROR *werror)
 
2431
{
 
2432
        struct srvsvc_NETRDFSDELETEEXITPOINT r;
 
2433
        NTSTATUS status;
 
2434
 
 
2435
        /* In parameters */
 
2436
 
 
2437
        if (DEBUGLEVEL >= 10) {
 
2438
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
 
2439
        }
 
2440
 
 
2441
        status = cli->dispatch(cli,
 
2442
                                mem_ctx,
 
2443
                                &ndr_table_srvsvc,
 
2444
                                NDR_SRVSVC_NETRDFSDELETEEXITPOINT,
 
2445
                                &r);
 
2446
 
 
2447
        if (!NT_STATUS_IS_OK(status)) {
 
2448
                return status;
 
2449
        }
 
2450
 
 
2451
        if (DEBUGLEVEL >= 10) {
 
2452
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
 
2453
        }
 
2454
 
 
2455
        if (NT_STATUS_IS_ERR(status)) {
 
2456
                return status;
 
2457
        }
 
2458
 
 
2459
        /* Return variables */
 
2460
 
 
2461
        /* Return result */
 
2462
        if (werror) {
 
2463
                *werror = r.out.result;
 
2464
        }
 
2465
 
 
2466
        return werror_to_ntstatus(r.out.result);
 
2467
}
 
2468
 
 
2469
NTSTATUS rpccli_srvsvc_NETRDFSMODIFYPREFIX(struct rpc_pipe_client *cli,
 
2470
                                           TALLOC_CTX *mem_ctx,
 
2471
                                           WERROR *werror)
 
2472
{
 
2473
        struct srvsvc_NETRDFSMODIFYPREFIX r;
 
2474
        NTSTATUS status;
 
2475
 
 
2476
        /* In parameters */
 
2477
 
 
2478
        if (DEBUGLEVEL >= 10) {
 
2479
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
 
2480
        }
 
2481
 
 
2482
        status = cli->dispatch(cli,
 
2483
                                mem_ctx,
 
2484
                                &ndr_table_srvsvc,
 
2485
                                NDR_SRVSVC_NETRDFSMODIFYPREFIX,
 
2486
                                &r);
 
2487
 
 
2488
        if (!NT_STATUS_IS_OK(status)) {
 
2489
                return status;
 
2490
        }
 
2491
 
 
2492
        if (DEBUGLEVEL >= 10) {
 
2493
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
 
2494
        }
 
2495
 
 
2496
        if (NT_STATUS_IS_ERR(status)) {
 
2497
                return status;
 
2498
        }
 
2499
 
 
2500
        /* Return variables */
 
2501
 
 
2502
        /* Return result */
 
2503
        if (werror) {
 
2504
                *werror = r.out.result;
 
2505
        }
 
2506
 
 
2507
        return werror_to_ntstatus(r.out.result);
 
2508
}
 
2509
 
 
2510
NTSTATUS rpccli_srvsvc_NETRDFSFIXLOCALVOLUME(struct rpc_pipe_client *cli,
 
2511
                                             TALLOC_CTX *mem_ctx,
 
2512
                                             WERROR *werror)
 
2513
{
 
2514
        struct srvsvc_NETRDFSFIXLOCALVOLUME r;
 
2515
        NTSTATUS status;
 
2516
 
 
2517
        /* In parameters */
 
2518
 
 
2519
        if (DEBUGLEVEL >= 10) {
 
2520
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
 
2521
        }
 
2522
 
 
2523
        status = cli->dispatch(cli,
 
2524
                                mem_ctx,
 
2525
                                &ndr_table_srvsvc,
 
2526
                                NDR_SRVSVC_NETRDFSFIXLOCALVOLUME,
 
2527
                                &r);
 
2528
 
 
2529
        if (!NT_STATUS_IS_OK(status)) {
 
2530
                return status;
 
2531
        }
 
2532
 
 
2533
        if (DEBUGLEVEL >= 10) {
 
2534
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
 
2535
        }
 
2536
 
 
2537
        if (NT_STATUS_IS_ERR(status)) {
 
2538
                return status;
 
2539
        }
 
2540
 
 
2541
        /* Return variables */
 
2542
 
 
2543
        /* Return result */
 
2544
        if (werror) {
 
2545
                *werror = r.out.result;
 
2546
        }
 
2547
 
 
2548
        return werror_to_ntstatus(r.out.result);
 
2549
}
 
2550
 
 
2551
NTSTATUS rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct rpc_pipe_client *cli,
 
2552
                                                    TALLOC_CTX *mem_ctx,
 
2553
                                                    WERROR *werror)
 
2554
{
 
2555
        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO r;
 
2556
        NTSTATUS status;
 
2557
 
 
2558
        /* In parameters */
 
2559
 
 
2560
        if (DEBUGLEVEL >= 10) {
 
2561
                NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
 
2562
        }
 
2563
 
 
2564
        status = cli->dispatch(cli,
 
2565
                                mem_ctx,
 
2566
                                &ndr_table_srvsvc,
 
2567
                                NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO,
 
2568
                                &r);
 
2569
 
 
2570
        if (!NT_STATUS_IS_OK(status)) {
 
2571
                return status;
 
2572
        }
 
2573
 
 
2574
        if (DEBUGLEVEL >= 10) {
 
2575
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
 
2576
        }
 
2577
 
 
2578
        if (NT_STATUS_IS_ERR(status)) {
 
2579
                return status;
 
2580
        }
 
2581
 
 
2582
        /* Return variables */
 
2583
 
 
2584
        /* Return result */
 
2585
        if (werror) {
 
2586
                *werror = r.out.result;
 
2587
        }
 
2588
 
 
2589
        return werror_to_ntstatus(r.out.result);
 
2590
}
 
2591
 
 
2592
NTSTATUS rpccli_srvsvc_NETRSERVERTRANSPORTDELEX(struct rpc_pipe_client *cli,
 
2593
                                                TALLOC_CTX *mem_ctx,
 
2594
                                                WERROR *werror)
 
2595
{
 
2596
        struct srvsvc_NETRSERVERTRANSPORTDELEX r;
 
2597
        NTSTATUS status;
 
2598
 
 
2599
        /* In parameters */
 
2600
 
 
2601
        if (DEBUGLEVEL >= 10) {
 
2602
                NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
 
2603
        }
 
2604
 
 
2605
        status = cli->dispatch(cli,
 
2606
                                mem_ctx,
 
2607
                                &ndr_table_srvsvc,
 
2608
                                NDR_SRVSVC_NETRSERVERTRANSPORTDELEX,
 
2609
                                &r);
 
2610
 
 
2611
        if (!NT_STATUS_IS_OK(status)) {
 
2612
                return status;
 
2613
        }
 
2614
 
 
2615
        if (DEBUGLEVEL >= 10) {
 
2616
                NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
 
2617
        }
 
2618
 
 
2619
        if (NT_STATUS_IS_ERR(status)) {
 
2620
                return status;
 
2621
        }
 
2622
 
 
2623
        /* Return variables */
 
2624
 
 
2625
        /* Return result */
 
2626
        if (werror) {
 
2627
                *werror = r.out.result;
 
2628
        }
 
2629
 
 
2630
        return werror_to_ntstatus(r.out.result);
 
2631
}
 
2632