source: branches/samba-3.2.x/source/librpc/gen_ndr/cli_srvsvc.c@ 553

Last change on this file since 553 was 133, checked in by Paul Smedley, 18 years ago

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