Merge branch 'master' of ssh://git.samba.org/data/git/samba
[ira/wip.git] / 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