source: branches/samba-3.2.x/source/librpc/gen_ndr/srv_srvsvc.c@ 198

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

Update trunk to 3.2.0pre3
File size: 87.6 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "librpc/gen_ndr/srv_srvsvc.h"
8
9static bool api_srvsvc_NetCharDevEnum(pipes_struct *p)
10{
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct srvsvc_NetCharDevEnum *r;
17
18 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVENUM];
19
20 r = talloc(talloc_tos(), struct srvsvc_NetCharDevEnum);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevEnum, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.level = r->in.level;
49 r->out.ctr = r->in.ctr;
50 r->out.totalentries = talloc_zero(r, uint32_t);
51 if (r->out.totalentries == NULL) {
52 talloc_free(r);
53 return false;
54 }
55
56 r->out.resume_handle = r->in.resume_handle;
57 r->out.result = _srvsvc_NetCharDevEnum(p, r);
58
59 if (p->rng_fault_state) {
60 talloc_free(r);
61 /* Return true here, srv_pipe_hnd.c will take care */
62 return true;
63 }
64
65 if (DEBUGLEVEL >= 10) {
66 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, r);
67 }
68
69 push = ndr_push_init_ctx(r);
70 if (push == NULL) {
71 talloc_free(r);
72 return false;
73 }
74
75 ndr_err = call->ndr_push(push, NDR_OUT, r);
76 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
77 talloc_free(r);
78 return false;
79 }
80
81 blob = ndr_push_blob(push);
82 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
83 talloc_free(r);
84 return false;
85 }
86
87 talloc_free(r);
88
89 return true;
90}
91
92static bool api_srvsvc_NetCharDevGetInfo(pipes_struct *p)
93{
94 const struct ndr_interface_call *call;
95 struct ndr_pull *pull;
96 struct ndr_push *push;
97 enum ndr_err_code ndr_err;
98 DATA_BLOB blob;
99 struct srvsvc_NetCharDevGetInfo *r;
100
101 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVGETINFO];
102
103 r = talloc(talloc_tos(), struct srvsvc_NetCharDevGetInfo);
104 if (r == NULL) {
105 return false;
106 }
107
108 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
109 talloc_free(r);
110 return false;
111 }
112
113 pull = ndr_pull_init_blob(&blob, r);
114 if (pull == NULL) {
115 talloc_free(r);
116 return false;
117 }
118
119 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
120 ndr_err = call->ndr_pull(pull, NDR_IN, r);
121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
122 talloc_free(r);
123 return false;
124 }
125
126 if (DEBUGLEVEL >= 10) {
127 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, r);
128 }
129
130 ZERO_STRUCT(r->out);
131 r->out.info = talloc_zero(r, union srvsvc_NetCharDevInfo);
132 if (r->out.info == NULL) {
133 talloc_free(r);
134 return false;
135 }
136
137 r->out.result = _srvsvc_NetCharDevGetInfo(p, r);
138
139 if (p->rng_fault_state) {
140 talloc_free(r);
141 /* Return true here, srv_pipe_hnd.c will take care */
142 return true;
143 }
144
145 if (DEBUGLEVEL >= 10) {
146 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, r);
147 }
148
149 push = ndr_push_init_ctx(r);
150 if (push == NULL) {
151 talloc_free(r);
152 return false;
153 }
154
155 ndr_err = call->ndr_push(push, NDR_OUT, r);
156 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
157 talloc_free(r);
158 return false;
159 }
160
161 blob = ndr_push_blob(push);
162 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
163 talloc_free(r);
164 return false;
165 }
166
167 talloc_free(r);
168
169 return true;
170}
171
172static bool api_srvsvc_NetCharDevControl(pipes_struct *p)
173{
174 const struct ndr_interface_call *call;
175 struct ndr_pull *pull;
176 struct ndr_push *push;
177 enum ndr_err_code ndr_err;
178 DATA_BLOB blob;
179 struct srvsvc_NetCharDevControl *r;
180
181 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVCONTROL];
182
183 r = talloc(talloc_tos(), struct srvsvc_NetCharDevControl);
184 if (r == NULL) {
185 return false;
186 }
187
188 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
189 talloc_free(r);
190 return false;
191 }
192
193 pull = ndr_pull_init_blob(&blob, r);
194 if (pull == NULL) {
195 talloc_free(r);
196 return false;
197 }
198
199 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
200 ndr_err = call->ndr_pull(pull, NDR_IN, r);
201 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
202 talloc_free(r);
203 return false;
204 }
205
206 if (DEBUGLEVEL >= 10) {
207 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, r);
208 }
209
210 r->out.result = _srvsvc_NetCharDevControl(p, r);
211
212 if (p->rng_fault_state) {
213 talloc_free(r);
214 /* Return true here, srv_pipe_hnd.c will take care */
215 return true;
216 }
217
218 if (DEBUGLEVEL >= 10) {
219 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, r);
220 }
221
222 push = ndr_push_init_ctx(r);
223 if (push == NULL) {
224 talloc_free(r);
225 return false;
226 }
227
228 ndr_err = call->ndr_push(push, NDR_OUT, r);
229 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
230 talloc_free(r);
231 return false;
232 }
233
234 blob = ndr_push_blob(push);
235 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
236 talloc_free(r);
237 return false;
238 }
239
240 talloc_free(r);
241
242 return true;
243}
244
245static bool api_srvsvc_NetCharDevQEnum(pipes_struct *p)
246{
247 const struct ndr_interface_call *call;
248 struct ndr_pull *pull;
249 struct ndr_push *push;
250 enum ndr_err_code ndr_err;
251 DATA_BLOB blob;
252 struct srvsvc_NetCharDevQEnum *r;
253
254 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQENUM];
255
256 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQEnum);
257 if (r == NULL) {
258 return false;
259 }
260
261 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
262 talloc_free(r);
263 return false;
264 }
265
266 pull = ndr_pull_init_blob(&blob, r);
267 if (pull == NULL) {
268 talloc_free(r);
269 return false;
270 }
271
272 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
273 ndr_err = call->ndr_pull(pull, NDR_IN, r);
274 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
275 talloc_free(r);
276 return false;
277 }
278
279 if (DEBUGLEVEL >= 10) {
280 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, r);
281 }
282
283 ZERO_STRUCT(r->out);
284 r->out.level = r->in.level;
285 r->out.ctr = r->in.ctr;
286 r->out.totalentries = talloc_zero(r, uint32_t);
287 if (r->out.totalentries == NULL) {
288 talloc_free(r);
289 return false;
290 }
291
292 r->out.resume_handle = r->in.resume_handle;
293 r->out.result = _srvsvc_NetCharDevQEnum(p, r);
294
295 if (p->rng_fault_state) {
296 talloc_free(r);
297 /* Return true here, srv_pipe_hnd.c will take care */
298 return true;
299 }
300
301 if (DEBUGLEVEL >= 10) {
302 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, r);
303 }
304
305 push = ndr_push_init_ctx(r);
306 if (push == NULL) {
307 talloc_free(r);
308 return false;
309 }
310
311 ndr_err = call->ndr_push(push, NDR_OUT, r);
312 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
313 talloc_free(r);
314 return false;
315 }
316
317 blob = ndr_push_blob(push);
318 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
319 talloc_free(r);
320 return false;
321 }
322
323 talloc_free(r);
324
325 return true;
326}
327
328static bool api_srvsvc_NetCharDevQGetInfo(pipes_struct *p)
329{
330 const struct ndr_interface_call *call;
331 struct ndr_pull *pull;
332 struct ndr_push *push;
333 enum ndr_err_code ndr_err;
334 DATA_BLOB blob;
335 struct srvsvc_NetCharDevQGetInfo *r;
336
337 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQGETINFO];
338
339 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQGetInfo);
340 if (r == NULL) {
341 return false;
342 }
343
344 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
345 talloc_free(r);
346 return false;
347 }
348
349 pull = ndr_pull_init_blob(&blob, r);
350 if (pull == NULL) {
351 talloc_free(r);
352 return false;
353 }
354
355 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
356 ndr_err = call->ndr_pull(pull, NDR_IN, r);
357 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
358 talloc_free(r);
359 return false;
360 }
361
362 if (DEBUGLEVEL >= 10) {
363 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, r);
364 }
365
366 ZERO_STRUCT(r->out);
367 r->out.info = talloc_zero(r, union srvsvc_NetCharDevQInfo);
368 if (r->out.info == NULL) {
369 talloc_free(r);
370 return false;
371 }
372
373 r->out.result = _srvsvc_NetCharDevQGetInfo(p, r);
374
375 if (p->rng_fault_state) {
376 talloc_free(r);
377 /* Return true here, srv_pipe_hnd.c will take care */
378 return true;
379 }
380
381 if (DEBUGLEVEL >= 10) {
382 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, r);
383 }
384
385 push = ndr_push_init_ctx(r);
386 if (push == NULL) {
387 talloc_free(r);
388 return false;
389 }
390
391 ndr_err = call->ndr_push(push, NDR_OUT, r);
392 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
393 talloc_free(r);
394 return false;
395 }
396
397 blob = ndr_push_blob(push);
398 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
399 talloc_free(r);
400 return false;
401 }
402
403 talloc_free(r);
404
405 return true;
406}
407
408static bool api_srvsvc_NetCharDevQSetInfo(pipes_struct *p)
409{
410 const struct ndr_interface_call *call;
411 struct ndr_pull *pull;
412 struct ndr_push *push;
413 enum ndr_err_code ndr_err;
414 DATA_BLOB blob;
415 struct srvsvc_NetCharDevQSetInfo *r;
416
417 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQSETINFO];
418
419 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQSetInfo);
420 if (r == NULL) {
421 return false;
422 }
423
424 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
425 talloc_free(r);
426 return false;
427 }
428
429 pull = ndr_pull_init_blob(&blob, r);
430 if (pull == NULL) {
431 talloc_free(r);
432 return false;
433 }
434
435 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
436 ndr_err = call->ndr_pull(pull, NDR_IN, r);
437 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
438 talloc_free(r);
439 return false;
440 }
441
442 if (DEBUGLEVEL >= 10) {
443 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, r);
444 }
445
446 ZERO_STRUCT(r->out);
447 r->out.parm_error = r->in.parm_error;
448 r->out.result = _srvsvc_NetCharDevQSetInfo(p, r);
449
450 if (p->rng_fault_state) {
451 talloc_free(r);
452 /* Return true here, srv_pipe_hnd.c will take care */
453 return true;
454 }
455
456 if (DEBUGLEVEL >= 10) {
457 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, r);
458 }
459
460 push = ndr_push_init_ctx(r);
461 if (push == NULL) {
462 talloc_free(r);
463 return false;
464 }
465
466 ndr_err = call->ndr_push(push, NDR_OUT, r);
467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
468 talloc_free(r);
469 return false;
470 }
471
472 blob = ndr_push_blob(push);
473 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
474 talloc_free(r);
475 return false;
476 }
477
478 talloc_free(r);
479
480 return true;
481}
482
483static bool api_srvsvc_NetCharDevQPurge(pipes_struct *p)
484{
485 const struct ndr_interface_call *call;
486 struct ndr_pull *pull;
487 struct ndr_push *push;
488 enum ndr_err_code ndr_err;
489 DATA_BLOB blob;
490 struct srvsvc_NetCharDevQPurge *r;
491
492 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGE];
493
494 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurge);
495 if (r == NULL) {
496 return false;
497 }
498
499 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
500 talloc_free(r);
501 return false;
502 }
503
504 pull = ndr_pull_init_blob(&blob, r);
505 if (pull == NULL) {
506 talloc_free(r);
507 return false;
508 }
509
510 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
511 ndr_err = call->ndr_pull(pull, NDR_IN, r);
512 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
513 talloc_free(r);
514 return false;
515 }
516
517 if (DEBUGLEVEL >= 10) {
518 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, r);
519 }
520
521 r->out.result = _srvsvc_NetCharDevQPurge(p, r);
522
523 if (p->rng_fault_state) {
524 talloc_free(r);
525 /* Return true here, srv_pipe_hnd.c will take care */
526 return true;
527 }
528
529 if (DEBUGLEVEL >= 10) {
530 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, r);
531 }
532
533 push = ndr_push_init_ctx(r);
534 if (push == NULL) {
535 talloc_free(r);
536 return false;
537 }
538
539 ndr_err = call->ndr_push(push, NDR_OUT, r);
540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
541 talloc_free(r);
542 return false;
543 }
544
545 blob = ndr_push_blob(push);
546 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
547 talloc_free(r);
548 return false;
549 }
550
551 talloc_free(r);
552
553 return true;
554}
555
556static bool api_srvsvc_NetCharDevQPurgeSelf(pipes_struct *p)
557{
558 const struct ndr_interface_call *call;
559 struct ndr_pull *pull;
560 struct ndr_push *push;
561 enum ndr_err_code ndr_err;
562 DATA_BLOB blob;
563 struct srvsvc_NetCharDevQPurgeSelf *r;
564
565 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGESELF];
566
567 r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurgeSelf);
568 if (r == NULL) {
569 return false;
570 }
571
572 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
573 talloc_free(r);
574 return false;
575 }
576
577 pull = ndr_pull_init_blob(&blob, r);
578 if (pull == NULL) {
579 talloc_free(r);
580 return false;
581 }
582
583 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
584 ndr_err = call->ndr_pull(pull, NDR_IN, r);
585 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
586 talloc_free(r);
587 return false;
588 }
589
590 if (DEBUGLEVEL >= 10) {
591 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
592 }
593
594 r->out.result = _srvsvc_NetCharDevQPurgeSelf(p, r);
595
596 if (p->rng_fault_state) {
597 talloc_free(r);
598 /* Return true here, srv_pipe_hnd.c will take care */
599 return true;
600 }
601
602 if (DEBUGLEVEL >= 10) {
603 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
604 }
605
606 push = ndr_push_init_ctx(r);
607 if (push == NULL) {
608 talloc_free(r);
609 return false;
610 }
611
612 ndr_err = call->ndr_push(push, NDR_OUT, r);
613 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
614 talloc_free(r);
615 return false;
616 }
617
618 blob = ndr_push_blob(push);
619 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
620 talloc_free(r);
621 return false;
622 }
623
624 talloc_free(r);
625
626 return true;
627}
628
629static bool api_srvsvc_NetConnEnum(pipes_struct *p)
630{
631 const struct ndr_interface_call *call;
632 struct ndr_pull *pull;
633 struct ndr_push *push;
634 enum ndr_err_code ndr_err;
635 DATA_BLOB blob;
636 struct srvsvc_NetConnEnum *r;
637
638 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCONNENUM];
639
640 r = talloc(talloc_tos(), struct srvsvc_NetConnEnum);
641 if (r == NULL) {
642 return false;
643 }
644
645 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
646 talloc_free(r);
647 return false;
648 }
649
650 pull = ndr_pull_init_blob(&blob, r);
651 if (pull == NULL) {
652 talloc_free(r);
653 return false;
654 }
655
656 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
657 ndr_err = call->ndr_pull(pull, NDR_IN, r);
658 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
659 talloc_free(r);
660 return false;
661 }
662
663 if (DEBUGLEVEL >= 10) {
664 NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, r);
665 }
666
667 ZERO_STRUCT(r->out);
668 r->out.info_ctr = r->in.info_ctr;
669 r->out.totalentries = talloc_zero(r, uint32_t);
670 if (r->out.totalentries == NULL) {
671 talloc_free(r);
672 return false;
673 }
674
675 r->out.resume_handle = r->in.resume_handle;
676 r->out.result = _srvsvc_NetConnEnum(p, r);
677
678 if (p->rng_fault_state) {
679 talloc_free(r);
680 /* Return true here, srv_pipe_hnd.c will take care */
681 return true;
682 }
683
684 if (DEBUGLEVEL >= 10) {
685 NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, r);
686 }
687
688 push = ndr_push_init_ctx(r);
689 if (push == NULL) {
690 talloc_free(r);
691 return false;
692 }
693
694 ndr_err = call->ndr_push(push, NDR_OUT, r);
695 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
696 talloc_free(r);
697 return false;
698 }
699
700 blob = ndr_push_blob(push);
701 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
702 talloc_free(r);
703 return false;
704 }
705
706 talloc_free(r);
707
708 return true;
709}
710
711static bool api_srvsvc_NetFileEnum(pipes_struct *p)
712{
713 const struct ndr_interface_call *call;
714 struct ndr_pull *pull;
715 struct ndr_push *push;
716 enum ndr_err_code ndr_err;
717 DATA_BLOB blob;
718 struct srvsvc_NetFileEnum *r;
719
720 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEENUM];
721
722 r = talloc(talloc_tos(), struct srvsvc_NetFileEnum);
723 if (r == NULL) {
724 return false;
725 }
726
727 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
728 talloc_free(r);
729 return false;
730 }
731
732 pull = ndr_pull_init_blob(&blob, r);
733 if (pull == NULL) {
734 talloc_free(r);
735 return false;
736 }
737
738 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
739 ndr_err = call->ndr_pull(pull, NDR_IN, r);
740 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
741 talloc_free(r);
742 return false;
743 }
744
745 if (DEBUGLEVEL >= 10) {
746 NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, r);
747 }
748
749 ZERO_STRUCT(r->out);
750 r->out.info_ctr = r->in.info_ctr;
751 r->out.totalentries = talloc_zero(r, uint32_t);
752 if (r->out.totalentries == NULL) {
753 talloc_free(r);
754 return false;
755 }
756
757 r->out.resume_handle = r->in.resume_handle;
758 r->out.result = _srvsvc_NetFileEnum(p, r);
759
760 if (p->rng_fault_state) {
761 talloc_free(r);
762 /* Return true here, srv_pipe_hnd.c will take care */
763 return true;
764 }
765
766 if (DEBUGLEVEL >= 10) {
767 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, r);
768 }
769
770 push = ndr_push_init_ctx(r);
771 if (push == NULL) {
772 talloc_free(r);
773 return false;
774 }
775
776 ndr_err = call->ndr_push(push, NDR_OUT, r);
777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
778 talloc_free(r);
779 return false;
780 }
781
782 blob = ndr_push_blob(push);
783 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
784 talloc_free(r);
785 return false;
786 }
787
788 talloc_free(r);
789
790 return true;
791}
792
793static bool api_srvsvc_NetFileGetInfo(pipes_struct *p)
794{
795 const struct ndr_interface_call *call;
796 struct ndr_pull *pull;
797 struct ndr_push *push;
798 enum ndr_err_code ndr_err;
799 DATA_BLOB blob;
800 struct srvsvc_NetFileGetInfo *r;
801
802 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEGETINFO];
803
804 r = talloc(talloc_tos(), struct srvsvc_NetFileGetInfo);
805 if (r == NULL) {
806 return false;
807 }
808
809 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
810 talloc_free(r);
811 return false;
812 }
813
814 pull = ndr_pull_init_blob(&blob, r);
815 if (pull == NULL) {
816 talloc_free(r);
817 return false;
818 }
819
820 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
821 ndr_err = call->ndr_pull(pull, NDR_IN, r);
822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
823 talloc_free(r);
824 return false;
825 }
826
827 if (DEBUGLEVEL >= 10) {
828 NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, r);
829 }
830
831 ZERO_STRUCT(r->out);
832 r->out.info = talloc_zero(r, union srvsvc_NetFileInfo);
833 if (r->out.info == NULL) {
834 talloc_free(r);
835 return false;
836 }
837
838 r->out.result = _srvsvc_NetFileGetInfo(p, r);
839
840 if (p->rng_fault_state) {
841 talloc_free(r);
842 /* Return true here, srv_pipe_hnd.c will take care */
843 return true;
844 }
845
846 if (DEBUGLEVEL >= 10) {
847 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, r);
848 }
849
850 push = ndr_push_init_ctx(r);
851 if (push == NULL) {
852 talloc_free(r);
853 return false;
854 }
855
856 ndr_err = call->ndr_push(push, NDR_OUT, r);
857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
858 talloc_free(r);
859 return false;
860 }
861
862 blob = ndr_push_blob(push);
863 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
864 talloc_free(r);
865 return false;
866 }
867
868 talloc_free(r);
869
870 return true;
871}
872
873static bool api_srvsvc_NetFileClose(pipes_struct *p)
874{
875 const struct ndr_interface_call *call;
876 struct ndr_pull *pull;
877 struct ndr_push *push;
878 enum ndr_err_code ndr_err;
879 DATA_BLOB blob;
880 struct srvsvc_NetFileClose *r;
881
882 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILECLOSE];
883
884 r = talloc(talloc_tos(), struct srvsvc_NetFileClose);
885 if (r == NULL) {
886 return false;
887 }
888
889 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
890 talloc_free(r);
891 return false;
892 }
893
894 pull = ndr_pull_init_blob(&blob, r);
895 if (pull == NULL) {
896 talloc_free(r);
897 return false;
898 }
899
900 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
901 ndr_err = call->ndr_pull(pull, NDR_IN, r);
902 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
903 talloc_free(r);
904 return false;
905 }
906
907 if (DEBUGLEVEL >= 10) {
908 NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, r);
909 }
910
911 r->out.result = _srvsvc_NetFileClose(p, r);
912
913 if (p->rng_fault_state) {
914 talloc_free(r);
915 /* Return true here, srv_pipe_hnd.c will take care */
916 return true;
917 }
918
919 if (DEBUGLEVEL >= 10) {
920 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, r);
921 }
922
923 push = ndr_push_init_ctx(r);
924 if (push == NULL) {
925 talloc_free(r);
926 return false;
927 }
928
929 ndr_err = call->ndr_push(push, NDR_OUT, r);
930 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
931 talloc_free(r);
932 return false;
933 }
934
935 blob = ndr_push_blob(push);
936 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
937 talloc_free(r);
938 return false;
939 }
940
941 talloc_free(r);
942
943 return true;
944}
945
946static bool api_srvsvc_NetSessEnum(pipes_struct *p)
947{
948 const struct ndr_interface_call *call;
949 struct ndr_pull *pull;
950 struct ndr_push *push;
951 enum ndr_err_code ndr_err;
952 DATA_BLOB blob;
953 struct srvsvc_NetSessEnum *r;
954
955 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSENUM];
956
957 r = talloc(talloc_tos(), struct srvsvc_NetSessEnum);
958 if (r == NULL) {
959 return false;
960 }
961
962 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
963 talloc_free(r);
964 return false;
965 }
966
967 pull = ndr_pull_init_blob(&blob, r);
968 if (pull == NULL) {
969 talloc_free(r);
970 return false;
971 }
972
973 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
974 ndr_err = call->ndr_pull(pull, NDR_IN, r);
975 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
976 talloc_free(r);
977 return false;
978 }
979
980 if (DEBUGLEVEL >= 10) {
981 NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, r);
982 }
983
984 ZERO_STRUCT(r->out);
985 r->out.info_ctr = r->in.info_ctr;
986 r->out.totalentries = talloc_zero(r, uint32_t);
987 if (r->out.totalentries == NULL) {
988 talloc_free(r);
989 return false;
990 }
991
992 r->out.resume_handle = r->in.resume_handle;
993 r->out.result = _srvsvc_NetSessEnum(p, r);
994
995 if (p->rng_fault_state) {
996 talloc_free(r);
997 /* Return true here, srv_pipe_hnd.c will take care */
998 return true;
999 }
1000
1001 if (DEBUGLEVEL >= 10) {
1002 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, r);
1003 }
1004
1005 push = ndr_push_init_ctx(r);
1006 if (push == NULL) {
1007 talloc_free(r);
1008 return false;
1009 }
1010
1011 ndr_err = call->ndr_push(push, NDR_OUT, r);
1012 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1013 talloc_free(r);
1014 return false;
1015 }
1016
1017 blob = ndr_push_blob(push);
1018 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1019 talloc_free(r);
1020 return false;
1021 }
1022
1023 talloc_free(r);
1024
1025 return true;
1026}
1027
1028static bool api_srvsvc_NetSessDel(pipes_struct *p)
1029{
1030 const struct ndr_interface_call *call;
1031 struct ndr_pull *pull;
1032 struct ndr_push *push;
1033 enum ndr_err_code ndr_err;
1034 DATA_BLOB blob;
1035 struct srvsvc_NetSessDel *r;
1036
1037 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSDEL];
1038
1039 r = talloc(talloc_tos(), struct srvsvc_NetSessDel);
1040 if (r == NULL) {
1041 return false;
1042 }
1043
1044 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1045 talloc_free(r);
1046 return false;
1047 }
1048
1049 pull = ndr_pull_init_blob(&blob, r);
1050 if (pull == NULL) {
1051 talloc_free(r);
1052 return false;
1053 }
1054
1055 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1056 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1057 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1058 talloc_free(r);
1059 return false;
1060 }
1061
1062 if (DEBUGLEVEL >= 10) {
1063 NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, r);
1064 }
1065
1066 r->out.result = _srvsvc_NetSessDel(p, r);
1067
1068 if (p->rng_fault_state) {
1069 talloc_free(r);
1070 /* Return true here, srv_pipe_hnd.c will take care */
1071 return true;
1072 }
1073
1074 if (DEBUGLEVEL >= 10) {
1075 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, r);
1076 }
1077
1078 push = ndr_push_init_ctx(r);
1079 if (push == NULL) {
1080 talloc_free(r);
1081 return false;
1082 }
1083
1084 ndr_err = call->ndr_push(push, NDR_OUT, r);
1085 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1086 talloc_free(r);
1087 return false;
1088 }
1089
1090 blob = ndr_push_blob(push);
1091 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1092 talloc_free(r);
1093 return false;
1094 }
1095
1096 talloc_free(r);
1097
1098 return true;
1099}
1100
1101static bool api_srvsvc_NetShareAdd(pipes_struct *p)
1102{
1103 const struct ndr_interface_call *call;
1104 struct ndr_pull *pull;
1105 struct ndr_push *push;
1106 enum ndr_err_code ndr_err;
1107 DATA_BLOB blob;
1108 struct srvsvc_NetShareAdd *r;
1109
1110 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREADD];
1111
1112 r = talloc(talloc_tos(), struct srvsvc_NetShareAdd);
1113 if (r == NULL) {
1114 return false;
1115 }
1116
1117 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1118 talloc_free(r);
1119 return false;
1120 }
1121
1122 pull = ndr_pull_init_blob(&blob, r);
1123 if (pull == NULL) {
1124 talloc_free(r);
1125 return false;
1126 }
1127
1128 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1129 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1131 talloc_free(r);
1132 return false;
1133 }
1134
1135 if (DEBUGLEVEL >= 10) {
1136 NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, r);
1137 }
1138
1139 ZERO_STRUCT(r->out);
1140 r->out.parm_error = r->in.parm_error;
1141 r->out.result = _srvsvc_NetShareAdd(p, r);
1142
1143 if (p->rng_fault_state) {
1144 talloc_free(r);
1145 /* Return true here, srv_pipe_hnd.c will take care */
1146 return true;
1147 }
1148
1149 if (DEBUGLEVEL >= 10) {
1150 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, r);
1151 }
1152
1153 push = ndr_push_init_ctx(r);
1154 if (push == NULL) {
1155 talloc_free(r);
1156 return false;
1157 }
1158
1159 ndr_err = call->ndr_push(push, NDR_OUT, r);
1160 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1161 talloc_free(r);
1162 return false;
1163 }
1164
1165 blob = ndr_push_blob(push);
1166 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1167 talloc_free(r);
1168 return false;
1169 }
1170
1171 talloc_free(r);
1172
1173 return true;
1174}
1175
1176static bool api_srvsvc_NetShareEnumAll(pipes_struct *p)
1177{
1178 const struct ndr_interface_call *call;
1179 struct ndr_pull *pull;
1180 struct ndr_push *push;
1181 enum ndr_err_code ndr_err;
1182 DATA_BLOB blob;
1183 struct srvsvc_NetShareEnumAll *r;
1184
1185 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUMALL];
1186
1187 r = talloc(talloc_tos(), struct srvsvc_NetShareEnumAll);
1188 if (r == NULL) {
1189 return false;
1190 }
1191
1192 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1193 talloc_free(r);
1194 return false;
1195 }
1196
1197 pull = ndr_pull_init_blob(&blob, r);
1198 if (pull == NULL) {
1199 talloc_free(r);
1200 return false;
1201 }
1202
1203 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1204 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1205 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1206 talloc_free(r);
1207 return false;
1208 }
1209
1210 if (DEBUGLEVEL >= 10) {
1211 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, r);
1212 }
1213
1214 ZERO_STRUCT(r->out);
1215 r->out.info_ctr = r->in.info_ctr;
1216 r->out.totalentries = talloc_zero(r, uint32_t);
1217 if (r->out.totalentries == NULL) {
1218 talloc_free(r);
1219 return false;
1220 }
1221
1222 r->out.resume_handle = r->in.resume_handle;
1223 r->out.result = _srvsvc_NetShareEnumAll(p, r);
1224
1225 if (p->rng_fault_state) {
1226 talloc_free(r);
1227 /* Return true here, srv_pipe_hnd.c will take care */
1228 return true;
1229 }
1230
1231 if (DEBUGLEVEL >= 10) {
1232 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, r);
1233 }
1234
1235 push = ndr_push_init_ctx(r);
1236 if (push == NULL) {
1237 talloc_free(r);
1238 return false;
1239 }
1240
1241 ndr_err = call->ndr_push(push, NDR_OUT, r);
1242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1243 talloc_free(r);
1244 return false;
1245 }
1246
1247 blob = ndr_push_blob(push);
1248 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1249 talloc_free(r);
1250 return false;
1251 }
1252
1253 talloc_free(r);
1254
1255 return true;
1256}
1257
1258static bool api_srvsvc_NetShareGetInfo(pipes_struct *p)
1259{
1260 const struct ndr_interface_call *call;
1261 struct ndr_pull *pull;
1262 struct ndr_push *push;
1263 enum ndr_err_code ndr_err;
1264 DATA_BLOB blob;
1265 struct srvsvc_NetShareGetInfo *r;
1266
1267 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREGETINFO];
1268
1269 r = talloc(talloc_tos(), struct srvsvc_NetShareGetInfo);
1270 if (r == NULL) {
1271 return false;
1272 }
1273
1274 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1275 talloc_free(r);
1276 return false;
1277 }
1278
1279 pull = ndr_pull_init_blob(&blob, r);
1280 if (pull == NULL) {
1281 talloc_free(r);
1282 return false;
1283 }
1284
1285 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1286 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1287 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1288 talloc_free(r);
1289 return false;
1290 }
1291
1292 if (DEBUGLEVEL >= 10) {
1293 NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, r);
1294 }
1295
1296 ZERO_STRUCT(r->out);
1297 r->out.info = talloc_zero(r, union srvsvc_NetShareInfo);
1298 if (r->out.info == NULL) {
1299 talloc_free(r);
1300 return false;
1301 }
1302
1303 r->out.result = _srvsvc_NetShareGetInfo(p, r);
1304
1305 if (p->rng_fault_state) {
1306 talloc_free(r);
1307 /* Return true here, srv_pipe_hnd.c will take care */
1308 return true;
1309 }
1310
1311 if (DEBUGLEVEL >= 10) {
1312 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, r);
1313 }
1314
1315 push = ndr_push_init_ctx(r);
1316 if (push == NULL) {
1317 talloc_free(r);
1318 return false;
1319 }
1320
1321 ndr_err = call->ndr_push(push, NDR_OUT, r);
1322 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1323 talloc_free(r);
1324 return false;
1325 }
1326
1327 blob = ndr_push_blob(push);
1328 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1329 talloc_free(r);
1330 return false;
1331 }
1332
1333 talloc_free(r);
1334
1335 return true;
1336}
1337
1338static bool api_srvsvc_NetShareSetInfo(pipes_struct *p)
1339{
1340 const struct ndr_interface_call *call;
1341 struct ndr_pull *pull;
1342 struct ndr_push *push;
1343 enum ndr_err_code ndr_err;
1344 DATA_BLOB blob;
1345 struct srvsvc_NetShareSetInfo *r;
1346
1347 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARESETINFO];
1348
1349 r = talloc(talloc_tos(), struct srvsvc_NetShareSetInfo);
1350 if (r == NULL) {
1351 return false;
1352 }
1353
1354 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1355 talloc_free(r);
1356 return false;
1357 }
1358
1359 pull = ndr_pull_init_blob(&blob, r);
1360 if (pull == NULL) {
1361 talloc_free(r);
1362 return false;
1363 }
1364
1365 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1366 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1367 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1368 talloc_free(r);
1369 return false;
1370 }
1371
1372 if (DEBUGLEVEL >= 10) {
1373 NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, r);
1374 }
1375
1376 ZERO_STRUCT(r->out);
1377 r->out.parm_error = r->in.parm_error;
1378 r->out.result = _srvsvc_NetShareSetInfo(p, r);
1379
1380 if (p->rng_fault_state) {
1381 talloc_free(r);
1382 /* Return true here, srv_pipe_hnd.c will take care */
1383 return true;
1384 }
1385
1386 if (DEBUGLEVEL >= 10) {
1387 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, r);
1388 }
1389
1390 push = ndr_push_init_ctx(r);
1391 if (push == NULL) {
1392 talloc_free(r);
1393 return false;
1394 }
1395
1396 ndr_err = call->ndr_push(push, NDR_OUT, r);
1397 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1398 talloc_free(r);
1399 return false;
1400 }
1401
1402 blob = ndr_push_blob(push);
1403 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1404 talloc_free(r);
1405 return false;
1406 }
1407
1408 talloc_free(r);
1409
1410 return true;
1411}
1412
1413static bool api_srvsvc_NetShareDel(pipes_struct *p)
1414{
1415 const struct ndr_interface_call *call;
1416 struct ndr_pull *pull;
1417 struct ndr_push *push;
1418 enum ndr_err_code ndr_err;
1419 DATA_BLOB blob;
1420 struct srvsvc_NetShareDel *r;
1421
1422 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDEL];
1423
1424 r = talloc(talloc_tos(), struct srvsvc_NetShareDel);
1425 if (r == NULL) {
1426 return false;
1427 }
1428
1429 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1430 talloc_free(r);
1431 return false;
1432 }
1433
1434 pull = ndr_pull_init_blob(&blob, r);
1435 if (pull == NULL) {
1436 talloc_free(r);
1437 return false;
1438 }
1439
1440 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1441 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1442 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1443 talloc_free(r);
1444 return false;
1445 }
1446
1447 if (DEBUGLEVEL >= 10) {
1448 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, r);
1449 }
1450
1451 r->out.result = _srvsvc_NetShareDel(p, r);
1452
1453 if (p->rng_fault_state) {
1454 talloc_free(r);
1455 /* Return true here, srv_pipe_hnd.c will take care */
1456 return true;
1457 }
1458
1459 if (DEBUGLEVEL >= 10) {
1460 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, r);
1461 }
1462
1463 push = ndr_push_init_ctx(r);
1464 if (push == NULL) {
1465 talloc_free(r);
1466 return false;
1467 }
1468
1469 ndr_err = call->ndr_push(push, NDR_OUT, r);
1470 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1471 talloc_free(r);
1472 return false;
1473 }
1474
1475 blob = ndr_push_blob(push);
1476 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1477 talloc_free(r);
1478 return false;
1479 }
1480
1481 talloc_free(r);
1482
1483 return true;
1484}
1485
1486static bool api_srvsvc_NetShareDelSticky(pipes_struct *p)
1487{
1488 const struct ndr_interface_call *call;
1489 struct ndr_pull *pull;
1490 struct ndr_push *push;
1491 enum ndr_err_code ndr_err;
1492 DATA_BLOB blob;
1493 struct srvsvc_NetShareDelSticky *r;
1494
1495 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTICKY];
1496
1497 r = talloc(talloc_tos(), struct srvsvc_NetShareDelSticky);
1498 if (r == NULL) {
1499 return false;
1500 }
1501
1502 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1503 talloc_free(r);
1504 return false;
1505 }
1506
1507 pull = ndr_pull_init_blob(&blob, r);
1508 if (pull == NULL) {
1509 talloc_free(r);
1510 return false;
1511 }
1512
1513 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1514 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1515 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1516 talloc_free(r);
1517 return false;
1518 }
1519
1520 if (DEBUGLEVEL >= 10) {
1521 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, r);
1522 }
1523
1524 r->out.result = _srvsvc_NetShareDelSticky(p, r);
1525
1526 if (p->rng_fault_state) {
1527 talloc_free(r);
1528 /* Return true here, srv_pipe_hnd.c will take care */
1529 return true;
1530 }
1531
1532 if (DEBUGLEVEL >= 10) {
1533 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, r);
1534 }
1535
1536 push = ndr_push_init_ctx(r);
1537 if (push == NULL) {
1538 talloc_free(r);
1539 return false;
1540 }
1541
1542 ndr_err = call->ndr_push(push, NDR_OUT, r);
1543 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1544 talloc_free(r);
1545 return false;
1546 }
1547
1548 blob = ndr_push_blob(push);
1549 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1550 talloc_free(r);
1551 return false;
1552 }
1553
1554 talloc_free(r);
1555
1556 return true;
1557}
1558
1559static bool api_srvsvc_NetShareCheck(pipes_struct *p)
1560{
1561 const struct ndr_interface_call *call;
1562 struct ndr_pull *pull;
1563 struct ndr_push *push;
1564 enum ndr_err_code ndr_err;
1565 DATA_BLOB blob;
1566 struct srvsvc_NetShareCheck *r;
1567
1568 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARECHECK];
1569
1570 r = talloc(talloc_tos(), struct srvsvc_NetShareCheck);
1571 if (r == NULL) {
1572 return false;
1573 }
1574
1575 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1576 talloc_free(r);
1577 return false;
1578 }
1579
1580 pull = ndr_pull_init_blob(&blob, r);
1581 if (pull == NULL) {
1582 talloc_free(r);
1583 return false;
1584 }
1585
1586 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1587 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1588 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1589 talloc_free(r);
1590 return false;
1591 }
1592
1593 if (DEBUGLEVEL >= 10) {
1594 NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, r);
1595 }
1596
1597 ZERO_STRUCT(r->out);
1598 r->out.type = talloc_zero(r, enum srvsvc_ShareType);
1599 if (r->out.type == NULL) {
1600 talloc_free(r);
1601 return false;
1602 }
1603
1604 r->out.result = _srvsvc_NetShareCheck(p, r);
1605
1606 if (p->rng_fault_state) {
1607 talloc_free(r);
1608 /* Return true here, srv_pipe_hnd.c will take care */
1609 return true;
1610 }
1611
1612 if (DEBUGLEVEL >= 10) {
1613 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, r);
1614 }
1615
1616 push = ndr_push_init_ctx(r);
1617 if (push == NULL) {
1618 talloc_free(r);
1619 return false;
1620 }
1621
1622 ndr_err = call->ndr_push(push, NDR_OUT, r);
1623 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1624 talloc_free(r);
1625 return false;
1626 }
1627
1628 blob = ndr_push_blob(push);
1629 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1630 talloc_free(r);
1631 return false;
1632 }
1633
1634 talloc_free(r);
1635
1636 return true;
1637}
1638
1639static bool api_srvsvc_NetSrvGetInfo(pipes_struct *p)
1640{
1641 const struct ndr_interface_call *call;
1642 struct ndr_pull *pull;
1643 struct ndr_push *push;
1644 enum ndr_err_code ndr_err;
1645 DATA_BLOB blob;
1646 struct srvsvc_NetSrvGetInfo *r;
1647
1648 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVGETINFO];
1649
1650 r = talloc(talloc_tos(), struct srvsvc_NetSrvGetInfo);
1651 if (r == NULL) {
1652 return false;
1653 }
1654
1655 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1656 talloc_free(r);
1657 return false;
1658 }
1659
1660 pull = ndr_pull_init_blob(&blob, r);
1661 if (pull == NULL) {
1662 talloc_free(r);
1663 return false;
1664 }
1665
1666 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1667 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1668 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1669 talloc_free(r);
1670 return false;
1671 }
1672
1673 if (DEBUGLEVEL >= 10) {
1674 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, r);
1675 }
1676
1677 ZERO_STRUCT(r->out);
1678 r->out.info = talloc_zero(r, union srvsvc_NetSrvInfo);
1679 if (r->out.info == NULL) {
1680 talloc_free(r);
1681 return false;
1682 }
1683
1684 r->out.result = _srvsvc_NetSrvGetInfo(p, r);
1685
1686 if (p->rng_fault_state) {
1687 talloc_free(r);
1688 /* Return true here, srv_pipe_hnd.c will take care */
1689 return true;
1690 }
1691
1692 if (DEBUGLEVEL >= 10) {
1693 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, r);
1694 }
1695
1696 push = ndr_push_init_ctx(r);
1697 if (push == NULL) {
1698 talloc_free(r);
1699 return false;
1700 }
1701
1702 ndr_err = call->ndr_push(push, NDR_OUT, r);
1703 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1704 talloc_free(r);
1705 return false;
1706 }
1707
1708 blob = ndr_push_blob(push);
1709 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1710 talloc_free(r);
1711 return false;
1712 }
1713
1714 talloc_free(r);
1715
1716 return true;
1717}
1718
1719static bool api_srvsvc_NetSrvSetInfo(pipes_struct *p)
1720{
1721 const struct ndr_interface_call *call;
1722 struct ndr_pull *pull;
1723 struct ndr_push *push;
1724 enum ndr_err_code ndr_err;
1725 DATA_BLOB blob;
1726 struct srvsvc_NetSrvSetInfo *r;
1727
1728 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVSETINFO];
1729
1730 r = talloc(talloc_tos(), struct srvsvc_NetSrvSetInfo);
1731 if (r == NULL) {
1732 return false;
1733 }
1734
1735 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1736 talloc_free(r);
1737 return false;
1738 }
1739
1740 pull = ndr_pull_init_blob(&blob, r);
1741 if (pull == NULL) {
1742 talloc_free(r);
1743 return false;
1744 }
1745
1746 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1747 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1748 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1749 talloc_free(r);
1750 return false;
1751 }
1752
1753 if (DEBUGLEVEL >= 10) {
1754 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, r);
1755 }
1756
1757 ZERO_STRUCT(r->out);
1758 r->out.parm_error = r->in.parm_error;
1759 r->out.result = _srvsvc_NetSrvSetInfo(p, r);
1760
1761 if (p->rng_fault_state) {
1762 talloc_free(r);
1763 /* Return true here, srv_pipe_hnd.c will take care */
1764 return true;
1765 }
1766
1767 if (DEBUGLEVEL >= 10) {
1768 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, r);
1769 }
1770
1771 push = ndr_push_init_ctx(r);
1772 if (push == NULL) {
1773 talloc_free(r);
1774 return false;
1775 }
1776
1777 ndr_err = call->ndr_push(push, NDR_OUT, r);
1778 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1779 talloc_free(r);
1780 return false;
1781 }
1782
1783 blob = ndr_push_blob(push);
1784 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1785 talloc_free(r);
1786 return false;
1787 }
1788
1789 talloc_free(r);
1790
1791 return true;
1792}
1793
1794static bool api_srvsvc_NetDiskEnum(pipes_struct *p)
1795{
1796 const struct ndr_interface_call *call;
1797 struct ndr_pull *pull;
1798 struct ndr_push *push;
1799 enum ndr_err_code ndr_err;
1800 DATA_BLOB blob;
1801 struct srvsvc_NetDiskEnum *r;
1802
1803 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETDISKENUM];
1804
1805 r = talloc(talloc_tos(), struct srvsvc_NetDiskEnum);
1806 if (r == NULL) {
1807 return false;
1808 }
1809
1810 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1811 talloc_free(r);
1812 return false;
1813 }
1814
1815 pull = ndr_pull_init_blob(&blob, r);
1816 if (pull == NULL) {
1817 talloc_free(r);
1818 return false;
1819 }
1820
1821 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1822 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1823 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1824 talloc_free(r);
1825 return false;
1826 }
1827
1828 if (DEBUGLEVEL >= 10) {
1829 NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, r);
1830 }
1831
1832 ZERO_STRUCT(r->out);
1833 r->out.info = r->in.info;
1834 r->out.totalentries = talloc_zero(r, uint32_t);
1835 if (r->out.totalentries == NULL) {
1836 talloc_free(r);
1837 return false;
1838 }
1839
1840 r->out.resume_handle = r->in.resume_handle;
1841 r->out.result = _srvsvc_NetDiskEnum(p, r);
1842
1843 if (p->rng_fault_state) {
1844 talloc_free(r);
1845 /* Return true here, srv_pipe_hnd.c will take care */
1846 return true;
1847 }
1848
1849 if (DEBUGLEVEL >= 10) {
1850 NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, r);
1851 }
1852
1853 push = ndr_push_init_ctx(r);
1854 if (push == NULL) {
1855 talloc_free(r);
1856 return false;
1857 }
1858
1859 ndr_err = call->ndr_push(push, NDR_OUT, r);
1860 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1861 talloc_free(r);
1862 return false;
1863 }
1864
1865 blob = ndr_push_blob(push);
1866 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1867 talloc_free(r);
1868 return false;
1869 }
1870
1871 talloc_free(r);
1872
1873 return true;
1874}
1875
1876static bool api_srvsvc_NetServerStatisticsGet(pipes_struct *p)
1877{
1878 const struct ndr_interface_call *call;
1879 struct ndr_pull *pull;
1880 struct ndr_push *push;
1881 enum ndr_err_code ndr_err;
1882 DATA_BLOB blob;
1883 struct srvsvc_NetServerStatisticsGet *r;
1884
1885 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSTATISTICSGET];
1886
1887 r = talloc(talloc_tos(), struct srvsvc_NetServerStatisticsGet);
1888 if (r == NULL) {
1889 return false;
1890 }
1891
1892 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1893 talloc_free(r);
1894 return false;
1895 }
1896
1897 pull = ndr_pull_init_blob(&blob, r);
1898 if (pull == NULL) {
1899 talloc_free(r);
1900 return false;
1901 }
1902
1903 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1904 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1906 talloc_free(r);
1907 return false;
1908 }
1909
1910 if (DEBUGLEVEL >= 10) {
1911 NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, r);
1912 }
1913
1914 ZERO_STRUCT(r->out);
1915 r->out.stats = talloc_zero(r, struct srvsvc_Statistics);
1916 if (r->out.stats == NULL) {
1917 talloc_free(r);
1918 return false;
1919 }
1920
1921 r->out.result = _srvsvc_NetServerStatisticsGet(p, r);
1922
1923 if (p->rng_fault_state) {
1924 talloc_free(r);
1925 /* Return true here, srv_pipe_hnd.c will take care */
1926 return true;
1927 }
1928
1929 if (DEBUGLEVEL >= 10) {
1930 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, r);
1931 }
1932
1933 push = ndr_push_init_ctx(r);
1934 if (push == NULL) {
1935 talloc_free(r);
1936 return false;
1937 }
1938
1939 ndr_err = call->ndr_push(push, NDR_OUT, r);
1940 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1941 talloc_free(r);
1942 return false;
1943 }
1944
1945 blob = ndr_push_blob(push);
1946 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1947 talloc_free(r);
1948 return false;
1949 }
1950
1951 talloc_free(r);
1952
1953 return true;
1954}
1955
1956static bool api_srvsvc_NetTransportAdd(pipes_struct *p)
1957{
1958 const struct ndr_interface_call *call;
1959 struct ndr_pull *pull;
1960 struct ndr_push *push;
1961 enum ndr_err_code ndr_err;
1962 DATA_BLOB blob;
1963 struct srvsvc_NetTransportAdd *r;
1964
1965 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTADD];
1966
1967 r = talloc(talloc_tos(), struct srvsvc_NetTransportAdd);
1968 if (r == NULL) {
1969 return false;
1970 }
1971
1972 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1973 talloc_free(r);
1974 return false;
1975 }
1976
1977 pull = ndr_pull_init_blob(&blob, r);
1978 if (pull == NULL) {
1979 talloc_free(r);
1980 return false;
1981 }
1982
1983 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1984 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1985 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1986 talloc_free(r);
1987 return false;
1988 }
1989
1990 if (DEBUGLEVEL >= 10) {
1991 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, r);
1992 }
1993
1994 r->out.result = _srvsvc_NetTransportAdd(p, r);
1995
1996 if (p->rng_fault_state) {
1997 talloc_free(r);
1998 /* Return true here, srv_pipe_hnd.c will take care */
1999 return true;
2000 }
2001
2002 if (DEBUGLEVEL >= 10) {
2003 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, r);
2004 }
2005
2006 push = ndr_push_init_ctx(r);
2007 if (push == NULL) {
2008 talloc_free(r);
2009 return false;
2010 }
2011
2012 ndr_err = call->ndr_push(push, NDR_OUT, r);
2013 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2014 talloc_free(r);
2015 return false;
2016 }
2017
2018 blob = ndr_push_blob(push);
2019 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2020 talloc_free(r);
2021 return false;
2022 }
2023
2024 talloc_free(r);
2025
2026 return true;
2027}
2028
2029static bool api_srvsvc_NetTransportEnum(pipes_struct *p)
2030{
2031 const struct ndr_interface_call *call;
2032 struct ndr_pull *pull;
2033 struct ndr_push *push;
2034 enum ndr_err_code ndr_err;
2035 DATA_BLOB blob;
2036 struct srvsvc_NetTransportEnum *r;
2037
2038 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTENUM];
2039
2040 r = talloc(talloc_tos(), struct srvsvc_NetTransportEnum);
2041 if (r == NULL) {
2042 return false;
2043 }
2044
2045 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2046 talloc_free(r);
2047 return false;
2048 }
2049
2050 pull = ndr_pull_init_blob(&blob, r);
2051 if (pull == NULL) {
2052 talloc_free(r);
2053 return false;
2054 }
2055
2056 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2057 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2058 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2059 talloc_free(r);
2060 return false;
2061 }
2062
2063 if (DEBUGLEVEL >= 10) {
2064 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, r);
2065 }
2066
2067 ZERO_STRUCT(r->out);
2068 r->out.level = r->in.level;
2069 r->out.transports = r->in.transports;
2070 r->out.totalentries = talloc_zero(r, uint32_t);
2071 if (r->out.totalentries == NULL) {
2072 talloc_free(r);
2073 return false;
2074 }
2075
2076 r->out.resume_handle = r->in.resume_handle;
2077 r->out.result = _srvsvc_NetTransportEnum(p, r);
2078
2079 if (p->rng_fault_state) {
2080 talloc_free(r);
2081 /* Return true here, srv_pipe_hnd.c will take care */
2082 return true;
2083 }
2084
2085 if (DEBUGLEVEL >= 10) {
2086 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, r);
2087 }
2088
2089 push = ndr_push_init_ctx(r);
2090 if (push == NULL) {
2091 talloc_free(r);
2092 return false;
2093 }
2094
2095 ndr_err = call->ndr_push(push, NDR_OUT, r);
2096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2097 talloc_free(r);
2098 return false;
2099 }
2100
2101 blob = ndr_push_blob(push);
2102 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2103 talloc_free(r);
2104 return false;
2105 }
2106
2107 talloc_free(r);
2108
2109 return true;
2110}
2111
2112static bool api_srvsvc_NetTransportDel(pipes_struct *p)
2113{
2114 const struct ndr_interface_call *call;
2115 struct ndr_pull *pull;
2116 struct ndr_push *push;
2117 enum ndr_err_code ndr_err;
2118 DATA_BLOB blob;
2119 struct srvsvc_NetTransportDel *r;
2120
2121 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTDEL];
2122
2123 r = talloc(talloc_tos(), struct srvsvc_NetTransportDel);
2124 if (r == NULL) {
2125 return false;
2126 }
2127
2128 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2129 talloc_free(r);
2130 return false;
2131 }
2132
2133 pull = ndr_pull_init_blob(&blob, r);
2134 if (pull == NULL) {
2135 talloc_free(r);
2136 return false;
2137 }
2138
2139 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2140 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2142 talloc_free(r);
2143 return false;
2144 }
2145
2146 if (DEBUGLEVEL >= 10) {
2147 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, r);
2148 }
2149
2150 r->out.result = _srvsvc_NetTransportDel(p, r);
2151
2152 if (p->rng_fault_state) {
2153 talloc_free(r);
2154 /* Return true here, srv_pipe_hnd.c will take care */
2155 return true;
2156 }
2157
2158 if (DEBUGLEVEL >= 10) {
2159 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, r);
2160 }
2161
2162 push = ndr_push_init_ctx(r);
2163 if (push == NULL) {
2164 talloc_free(r);
2165 return false;
2166 }
2167
2168 ndr_err = call->ndr_push(push, NDR_OUT, r);
2169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2170 talloc_free(r);
2171 return false;
2172 }
2173
2174 blob = ndr_push_blob(push);
2175 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2176 talloc_free(r);
2177 return false;
2178 }
2179
2180 talloc_free(r);
2181
2182 return true;
2183}
2184
2185static bool api_srvsvc_NetRemoteTOD(pipes_struct *p)
2186{
2187 const struct ndr_interface_call *call;
2188 struct ndr_pull *pull;
2189 struct ndr_push *push;
2190 enum ndr_err_code ndr_err;
2191 DATA_BLOB blob;
2192 struct srvsvc_NetRemoteTOD *r;
2193
2194 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETREMOTETOD];
2195
2196 r = talloc(talloc_tos(), struct srvsvc_NetRemoteTOD);
2197 if (r == NULL) {
2198 return false;
2199 }
2200
2201 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2202 talloc_free(r);
2203 return false;
2204 }
2205
2206 pull = ndr_pull_init_blob(&blob, r);
2207 if (pull == NULL) {
2208 talloc_free(r);
2209 return false;
2210 }
2211
2212 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2213 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2214 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2215 talloc_free(r);
2216 return false;
2217 }
2218
2219 if (DEBUGLEVEL >= 10) {
2220 NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, r);
2221 }
2222
2223 ZERO_STRUCT(r->out);
2224 r->out.info = talloc_zero(r, struct srvsvc_NetRemoteTODInfo *);
2225 if (r->out.info == NULL) {
2226 talloc_free(r);
2227 return false;
2228 }
2229
2230 r->out.result = _srvsvc_NetRemoteTOD(p, r);
2231
2232 if (p->rng_fault_state) {
2233 talloc_free(r);
2234 /* Return true here, srv_pipe_hnd.c will take care */
2235 return true;
2236 }
2237
2238 if (DEBUGLEVEL >= 10) {
2239 NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, r);
2240 }
2241
2242 push = ndr_push_init_ctx(r);
2243 if (push == NULL) {
2244 talloc_free(r);
2245 return false;
2246 }
2247
2248 ndr_err = call->ndr_push(push, NDR_OUT, r);
2249 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2250 talloc_free(r);
2251 return false;
2252 }
2253
2254 blob = ndr_push_blob(push);
2255 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2256 talloc_free(r);
2257 return false;
2258 }
2259
2260 talloc_free(r);
2261
2262 return true;
2263}
2264
2265static bool api_srvsvc_NetSetServiceBits(pipes_struct *p)
2266{
2267 const struct ndr_interface_call *call;
2268 struct ndr_pull *pull;
2269 struct ndr_push *push;
2270 enum ndr_err_code ndr_err;
2271 DATA_BLOB blob;
2272 struct srvsvc_NetSetServiceBits *r;
2273
2274 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETSERVICEBITS];
2275
2276 r = talloc(talloc_tos(), struct srvsvc_NetSetServiceBits);
2277 if (r == NULL) {
2278 return false;
2279 }
2280
2281 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2282 talloc_free(r);
2283 return false;
2284 }
2285
2286 pull = ndr_pull_init_blob(&blob, r);
2287 if (pull == NULL) {
2288 talloc_free(r);
2289 return false;
2290 }
2291
2292 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2293 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2294 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2295 talloc_free(r);
2296 return false;
2297 }
2298
2299 if (DEBUGLEVEL >= 10) {
2300 NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, r);
2301 }
2302
2303 r->out.result = _srvsvc_NetSetServiceBits(p, r);
2304
2305 if (p->rng_fault_state) {
2306 talloc_free(r);
2307 /* Return true here, srv_pipe_hnd.c will take care */
2308 return true;
2309 }
2310
2311 if (DEBUGLEVEL >= 10) {
2312 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, r);
2313 }
2314
2315 push = ndr_push_init_ctx(r);
2316 if (push == NULL) {
2317 talloc_free(r);
2318 return false;
2319 }
2320
2321 ndr_err = call->ndr_push(push, NDR_OUT, r);
2322 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2323 talloc_free(r);
2324 return false;
2325 }
2326
2327 blob = ndr_push_blob(push);
2328 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2329 talloc_free(r);
2330 return false;
2331 }
2332
2333 talloc_free(r);
2334
2335 return true;
2336}
2337
2338static bool api_srvsvc_NetPathType(pipes_struct *p)
2339{
2340 const struct ndr_interface_call *call;
2341 struct ndr_pull *pull;
2342 struct ndr_push *push;
2343 enum ndr_err_code ndr_err;
2344 DATA_BLOB blob;
2345 struct srvsvc_NetPathType *r;
2346
2347 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHTYPE];
2348
2349 r = talloc(talloc_tos(), struct srvsvc_NetPathType);
2350 if (r == NULL) {
2351 return false;
2352 }
2353
2354 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2355 talloc_free(r);
2356 return false;
2357 }
2358
2359 pull = ndr_pull_init_blob(&blob, r);
2360 if (pull == NULL) {
2361 talloc_free(r);
2362 return false;
2363 }
2364
2365 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2366 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2367 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2368 talloc_free(r);
2369 return false;
2370 }
2371
2372 if (DEBUGLEVEL >= 10) {
2373 NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, r);
2374 }
2375
2376 ZERO_STRUCT(r->out);
2377 r->out.pathtype = talloc_zero(r, uint32_t);
2378 if (r->out.pathtype == NULL) {
2379 talloc_free(r);
2380 return false;
2381 }
2382
2383 r->out.result = _srvsvc_NetPathType(p, r);
2384
2385 if (p->rng_fault_state) {
2386 talloc_free(r);
2387 /* Return true here, srv_pipe_hnd.c will take care */
2388 return true;
2389 }
2390
2391 if (DEBUGLEVEL >= 10) {
2392 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, r);
2393 }
2394
2395 push = ndr_push_init_ctx(r);
2396 if (push == NULL) {
2397 talloc_free(r);
2398 return false;
2399 }
2400
2401 ndr_err = call->ndr_push(push, NDR_OUT, r);
2402 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2403 talloc_free(r);
2404 return false;
2405 }
2406
2407 blob = ndr_push_blob(push);
2408 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2409 talloc_free(r);
2410 return false;
2411 }
2412
2413 talloc_free(r);
2414
2415 return true;
2416}
2417
2418static bool api_srvsvc_NetPathCanonicalize(pipes_struct *p)
2419{
2420 const struct ndr_interface_call *call;
2421 struct ndr_pull *pull;
2422 struct ndr_push *push;
2423 enum ndr_err_code ndr_err;
2424 DATA_BLOB blob;
2425 struct srvsvc_NetPathCanonicalize *r;
2426
2427 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCANONICALIZE];
2428
2429 r = talloc(talloc_tos(), struct srvsvc_NetPathCanonicalize);
2430 if (r == NULL) {
2431 return false;
2432 }
2433
2434 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2435 talloc_free(r);
2436 return false;
2437 }
2438
2439 pull = ndr_pull_init_blob(&blob, r);
2440 if (pull == NULL) {
2441 talloc_free(r);
2442 return false;
2443 }
2444
2445 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2446 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2447 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2448 talloc_free(r);
2449 return false;
2450 }
2451
2452 if (DEBUGLEVEL >= 10) {
2453 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, r);
2454 }
2455
2456 ZERO_STRUCT(r->out);
2457 r->out.can_path = talloc_zero_array(r, uint8_t, r->in.maxbuf);
2458 if (r->out.can_path == NULL) {
2459 talloc_free(r);
2460 return false;
2461 }
2462
2463 r->out.pathtype = r->in.pathtype;
2464 r->out.result = _srvsvc_NetPathCanonicalize(p, r);
2465
2466 if (p->rng_fault_state) {
2467 talloc_free(r);
2468 /* Return true here, srv_pipe_hnd.c will take care */
2469 return true;
2470 }
2471
2472 if (DEBUGLEVEL >= 10) {
2473 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, r);
2474 }
2475
2476 push = ndr_push_init_ctx(r);
2477 if (push == NULL) {
2478 talloc_free(r);
2479 return false;
2480 }
2481
2482 ndr_err = call->ndr_push(push, NDR_OUT, r);
2483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2484 talloc_free(r);
2485 return false;
2486 }
2487
2488 blob = ndr_push_blob(push);
2489 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2490 talloc_free(r);
2491 return false;
2492 }
2493
2494 talloc_free(r);
2495
2496 return true;
2497}
2498
2499static bool api_srvsvc_NetPathCompare(pipes_struct *p)
2500{
2501 const struct ndr_interface_call *call;
2502 struct ndr_pull *pull;
2503 struct ndr_push *push;
2504 enum ndr_err_code ndr_err;
2505 DATA_BLOB blob;
2506 struct srvsvc_NetPathCompare *r;
2507
2508 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCOMPARE];
2509
2510 r = talloc(talloc_tos(), struct srvsvc_NetPathCompare);
2511 if (r == NULL) {
2512 return false;
2513 }
2514
2515 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2516 talloc_free(r);
2517 return false;
2518 }
2519
2520 pull = ndr_pull_init_blob(&blob, r);
2521 if (pull == NULL) {
2522 talloc_free(r);
2523 return false;
2524 }
2525
2526 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2527 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2528 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2529 talloc_free(r);
2530 return false;
2531 }
2532
2533 if (DEBUGLEVEL >= 10) {
2534 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, r);
2535 }
2536
2537 r->out.result = _srvsvc_NetPathCompare(p, r);
2538
2539 if (p->rng_fault_state) {
2540 talloc_free(r);
2541 /* Return true here, srv_pipe_hnd.c will take care */
2542 return true;
2543 }
2544
2545 if (DEBUGLEVEL >= 10) {
2546 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, r);
2547 }
2548
2549 push = ndr_push_init_ctx(r);
2550 if (push == NULL) {
2551 talloc_free(r);
2552 return false;
2553 }
2554
2555 ndr_err = call->ndr_push(push, NDR_OUT, r);
2556 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2557 talloc_free(r);
2558 return false;
2559 }
2560
2561 blob = ndr_push_blob(push);
2562 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2563 talloc_free(r);
2564 return false;
2565 }
2566
2567 talloc_free(r);
2568
2569 return true;
2570}
2571
2572static bool api_srvsvc_NetNameValidate(pipes_struct *p)
2573{
2574 const struct ndr_interface_call *call;
2575 struct ndr_pull *pull;
2576 struct ndr_push *push;
2577 enum ndr_err_code ndr_err;
2578 DATA_BLOB blob;
2579 struct srvsvc_NetNameValidate *r;
2580
2581 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETNAMEVALIDATE];
2582
2583 r = talloc(talloc_tos(), struct srvsvc_NetNameValidate);
2584 if (r == NULL) {
2585 return false;
2586 }
2587
2588 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2589 talloc_free(r);
2590 return false;
2591 }
2592
2593 pull = ndr_pull_init_blob(&blob, r);
2594 if (pull == NULL) {
2595 talloc_free(r);
2596 return false;
2597 }
2598
2599 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2600 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2601 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2602 talloc_free(r);
2603 return false;
2604 }
2605
2606 if (DEBUGLEVEL >= 10) {
2607 NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, r);
2608 }
2609
2610 r->out.result = _srvsvc_NetNameValidate(p, r);
2611
2612 if (p->rng_fault_state) {
2613 talloc_free(r);
2614 /* Return true here, srv_pipe_hnd.c will take care */
2615 return true;
2616 }
2617
2618 if (DEBUGLEVEL >= 10) {
2619 NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, r);
2620 }
2621
2622 push = ndr_push_init_ctx(r);
2623 if (push == NULL) {
2624 talloc_free(r);
2625 return false;
2626 }
2627
2628 ndr_err = call->ndr_push(push, NDR_OUT, r);
2629 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2630 talloc_free(r);
2631 return false;
2632 }
2633
2634 blob = ndr_push_blob(push);
2635 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2636 talloc_free(r);
2637 return false;
2638 }
2639
2640 talloc_free(r);
2641
2642 return true;
2643}
2644
2645static bool api_srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p)
2646{
2647 const struct ndr_interface_call *call;
2648 struct ndr_pull *pull;
2649 struct ndr_push *push;
2650 enum ndr_err_code ndr_err;
2651 DATA_BLOB blob;
2652 struct srvsvc_NETRPRNAMECANONICALIZE *r;
2653
2654 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRPRNAMECANONICALIZE];
2655
2656 r = talloc(talloc_tos(), struct srvsvc_NETRPRNAMECANONICALIZE);
2657 if (r == NULL) {
2658 return false;
2659 }
2660
2661 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2662 talloc_free(r);
2663 return false;
2664 }
2665
2666 pull = ndr_pull_init_blob(&blob, r);
2667 if (pull == NULL) {
2668 talloc_free(r);
2669 return false;
2670 }
2671
2672 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2673 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2674 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2675 talloc_free(r);
2676 return false;
2677 }
2678
2679 if (DEBUGLEVEL >= 10) {
2680 NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2681 }
2682
2683 r->out.result = _srvsvc_NETRPRNAMECANONICALIZE(p, r);
2684
2685 if (p->rng_fault_state) {
2686 talloc_free(r);
2687 /* Return true here, srv_pipe_hnd.c will take care */
2688 return true;
2689 }
2690
2691 if (DEBUGLEVEL >= 10) {
2692 NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2693 }
2694
2695 push = ndr_push_init_ctx(r);
2696 if (push == NULL) {
2697 talloc_free(r);
2698 return false;
2699 }
2700
2701 ndr_err = call->ndr_push(push, NDR_OUT, r);
2702 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2703 talloc_free(r);
2704 return false;
2705 }
2706
2707 blob = ndr_push_blob(push);
2708 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2709 talloc_free(r);
2710 return false;
2711 }
2712
2713 talloc_free(r);
2714
2715 return true;
2716}
2717
2718static bool api_srvsvc_NetPRNameCompare(pipes_struct *p)
2719{
2720 const struct ndr_interface_call *call;
2721 struct ndr_pull *pull;
2722 struct ndr_push *push;
2723 enum ndr_err_code ndr_err;
2724 DATA_BLOB blob;
2725 struct srvsvc_NetPRNameCompare *r;
2726
2727 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPRNAMECOMPARE];
2728
2729 r = talloc(talloc_tos(), struct srvsvc_NetPRNameCompare);
2730 if (r == NULL) {
2731 return false;
2732 }
2733
2734 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2735 talloc_free(r);
2736 return false;
2737 }
2738
2739 pull = ndr_pull_init_blob(&blob, r);
2740 if (pull == NULL) {
2741 talloc_free(r);
2742 return false;
2743 }
2744
2745 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2746 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2747 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2748 talloc_free(r);
2749 return false;
2750 }
2751
2752 if (DEBUGLEVEL >= 10) {
2753 NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, r);
2754 }
2755
2756 r->out.result = _srvsvc_NetPRNameCompare(p, r);
2757
2758 if (p->rng_fault_state) {
2759 talloc_free(r);
2760 /* Return true here, srv_pipe_hnd.c will take care */
2761 return true;
2762 }
2763
2764 if (DEBUGLEVEL >= 10) {
2765 NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, r);
2766 }
2767
2768 push = ndr_push_init_ctx(r);
2769 if (push == NULL) {
2770 talloc_free(r);
2771 return false;
2772 }
2773
2774 ndr_err = call->ndr_push(push, NDR_OUT, r);
2775 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2776 talloc_free(r);
2777 return false;
2778 }
2779
2780 blob = ndr_push_blob(push);
2781 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2782 talloc_free(r);
2783 return false;
2784 }
2785
2786 talloc_free(r);
2787
2788 return true;
2789}
2790
2791static bool api_srvsvc_NetShareEnum(pipes_struct *p)
2792{
2793 const struct ndr_interface_call *call;
2794 struct ndr_pull *pull;
2795 struct ndr_push *push;
2796 enum ndr_err_code ndr_err;
2797 DATA_BLOB blob;
2798 struct srvsvc_NetShareEnum *r;
2799
2800 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUM];
2801
2802 r = talloc(talloc_tos(), struct srvsvc_NetShareEnum);
2803 if (r == NULL) {
2804 return false;
2805 }
2806
2807 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2808 talloc_free(r);
2809 return false;
2810 }
2811
2812 pull = ndr_pull_init_blob(&blob, r);
2813 if (pull == NULL) {
2814 talloc_free(r);
2815 return false;
2816 }
2817
2818 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2819 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2820 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2821 talloc_free(r);
2822 return false;
2823 }
2824
2825 if (DEBUGLEVEL >= 10) {
2826 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, r);
2827 }
2828
2829 ZERO_STRUCT(r->out);
2830 r->out.info_ctr = r->in.info_ctr;
2831 r->out.totalentries = talloc_zero(r, uint32_t);
2832 if (r->out.totalentries == NULL) {
2833 talloc_free(r);
2834 return false;
2835 }
2836
2837 r->out.resume_handle = r->in.resume_handle;
2838 r->out.result = _srvsvc_NetShareEnum(p, r);
2839
2840 if (p->rng_fault_state) {
2841 talloc_free(r);
2842 /* Return true here, srv_pipe_hnd.c will take care */
2843 return true;
2844 }
2845
2846 if (DEBUGLEVEL >= 10) {
2847 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, r);
2848 }
2849
2850 push = ndr_push_init_ctx(r);
2851 if (push == NULL) {
2852 talloc_free(r);
2853 return false;
2854 }
2855
2856 ndr_err = call->ndr_push(push, NDR_OUT, r);
2857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2858 talloc_free(r);
2859 return false;
2860 }
2861
2862 blob = ndr_push_blob(push);
2863 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2864 talloc_free(r);
2865 return false;
2866 }
2867
2868 talloc_free(r);
2869
2870 return true;
2871}
2872
2873static bool api_srvsvc_NetShareDelStart(pipes_struct *p)
2874{
2875 const struct ndr_interface_call *call;
2876 struct ndr_pull *pull;
2877 struct ndr_push *push;
2878 enum ndr_err_code ndr_err;
2879 DATA_BLOB blob;
2880 struct srvsvc_NetShareDelStart *r;
2881
2882 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTART];
2883
2884 r = talloc(talloc_tos(), struct srvsvc_NetShareDelStart);
2885 if (r == NULL) {
2886 return false;
2887 }
2888
2889 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2890 talloc_free(r);
2891 return false;
2892 }
2893
2894 pull = ndr_pull_init_blob(&blob, r);
2895 if (pull == NULL) {
2896 talloc_free(r);
2897 return false;
2898 }
2899
2900 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2901 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2902 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2903 talloc_free(r);
2904 return false;
2905 }
2906
2907 if (DEBUGLEVEL >= 10) {
2908 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, r);
2909 }
2910
2911 ZERO_STRUCT(r->out);
2912 r->out.hnd = talloc_zero(r, struct policy_handle);
2913 if (r->out.hnd == NULL) {
2914 talloc_free(r);
2915 return false;
2916 }
2917
2918 r->out.result = _srvsvc_NetShareDelStart(p, r);
2919
2920 if (p->rng_fault_state) {
2921 talloc_free(r);
2922 /* Return true here, srv_pipe_hnd.c will take care */
2923 return true;
2924 }
2925
2926 if (DEBUGLEVEL >= 10) {
2927 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, r);
2928 }
2929
2930 push = ndr_push_init_ctx(r);
2931 if (push == NULL) {
2932 talloc_free(r);
2933 return false;
2934 }
2935
2936 ndr_err = call->ndr_push(push, NDR_OUT, r);
2937 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2938 talloc_free(r);
2939 return false;
2940 }
2941
2942 blob = ndr_push_blob(push);
2943 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2944 talloc_free(r);
2945 return false;
2946 }
2947
2948 talloc_free(r);
2949
2950 return true;
2951}
2952
2953static bool api_srvsvc_NetShareDelCommit(pipes_struct *p)
2954{
2955 const struct ndr_interface_call *call;
2956 struct ndr_pull *pull;
2957 struct ndr_push *push;
2958 enum ndr_err_code ndr_err;
2959 DATA_BLOB blob;
2960 struct srvsvc_NetShareDelCommit *r;
2961
2962 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELCOMMIT];
2963
2964 r = talloc(talloc_tos(), struct srvsvc_NetShareDelCommit);
2965 if (r == NULL) {
2966 return false;
2967 }
2968
2969 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2970 talloc_free(r);
2971 return false;
2972 }
2973
2974 pull = ndr_pull_init_blob(&blob, r);
2975 if (pull == NULL) {
2976 talloc_free(r);
2977 return false;
2978 }
2979
2980 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2981 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2982 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2983 talloc_free(r);
2984 return false;
2985 }
2986
2987 if (DEBUGLEVEL >= 10) {
2988 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, r);
2989 }
2990
2991 ZERO_STRUCT(r->out);
2992 r->out.hnd = r->in.hnd;
2993 r->out.result = _srvsvc_NetShareDelCommit(p, r);
2994
2995 if (p->rng_fault_state) {
2996 talloc_free(r);
2997 /* Return true here, srv_pipe_hnd.c will take care */
2998 return true;
2999 }
3000
3001 if (DEBUGLEVEL >= 10) {
3002 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, r);
3003 }
3004
3005 push = ndr_push_init_ctx(r);
3006 if (push == NULL) {
3007 talloc_free(r);
3008 return false;
3009 }
3010
3011 ndr_err = call->ndr_push(push, NDR_OUT, r);
3012 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3013 talloc_free(r);
3014 return false;
3015 }
3016
3017 blob = ndr_push_blob(push);
3018 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3019 talloc_free(r);
3020 return false;
3021 }
3022
3023 talloc_free(r);
3024
3025 return true;
3026}
3027
3028static bool api_srvsvc_NetGetFileSecurity(pipes_struct *p)
3029{
3030 const struct ndr_interface_call *call;
3031 struct ndr_pull *pull;
3032 struct ndr_push *push;
3033 enum ndr_err_code ndr_err;
3034 DATA_BLOB blob;
3035 struct srvsvc_NetGetFileSecurity *r;
3036
3037 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETGETFILESECURITY];
3038
3039 r = talloc(talloc_tos(), struct srvsvc_NetGetFileSecurity);
3040 if (r == NULL) {
3041 return false;
3042 }
3043
3044 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3045 talloc_free(r);
3046 return false;
3047 }
3048
3049 pull = ndr_pull_init_blob(&blob, r);
3050 if (pull == NULL) {
3051 talloc_free(r);
3052 return false;
3053 }
3054
3055 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3056 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3057 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3058 talloc_free(r);
3059 return false;
3060 }
3061
3062 if (DEBUGLEVEL >= 10) {
3063 NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, r);
3064 }
3065
3066 ZERO_STRUCT(r->out);
3067 r->out.sd_buf = talloc_zero(r, struct sec_desc_buf *);
3068 if (r->out.sd_buf == NULL) {
3069 talloc_free(r);
3070 return false;
3071 }
3072
3073 r->out.result = _srvsvc_NetGetFileSecurity(p, r);
3074
3075 if (p->rng_fault_state) {
3076 talloc_free(r);
3077 /* Return true here, srv_pipe_hnd.c will take care */
3078 return true;
3079 }
3080
3081 if (DEBUGLEVEL >= 10) {
3082 NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, r);
3083 }
3084
3085 push = ndr_push_init_ctx(r);
3086 if (push == NULL) {
3087 talloc_free(r);
3088 return false;
3089 }
3090
3091 ndr_err = call->ndr_push(push, NDR_OUT, r);
3092 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3093 talloc_free(r);
3094 return false;
3095 }
3096
3097 blob = ndr_push_blob(push);
3098 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3099 talloc_free(r);
3100 return false;
3101 }
3102
3103 talloc_free(r);
3104
3105 return true;
3106}
3107
3108static bool api_srvsvc_NetSetFileSecurity(pipes_struct *p)
3109{
3110 const struct ndr_interface_call *call;
3111 struct ndr_pull *pull;
3112 struct ndr_push *push;
3113 enum ndr_err_code ndr_err;
3114 DATA_BLOB blob;
3115 struct srvsvc_NetSetFileSecurity *r;
3116
3117 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETFILESECURITY];
3118
3119 r = talloc(talloc_tos(), struct srvsvc_NetSetFileSecurity);
3120 if (r == NULL) {
3121 return false;
3122 }
3123
3124 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3125 talloc_free(r);
3126 return false;
3127 }
3128
3129 pull = ndr_pull_init_blob(&blob, r);
3130 if (pull == NULL) {
3131 talloc_free(r);
3132 return false;
3133 }
3134
3135 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3136 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3137 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3138 talloc_free(r);
3139 return false;
3140 }
3141
3142 if (DEBUGLEVEL >= 10) {
3143 NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, r);
3144 }
3145
3146 r->out.result = _srvsvc_NetSetFileSecurity(p, r);
3147
3148 if (p->rng_fault_state) {
3149 talloc_free(r);
3150 /* Return true here, srv_pipe_hnd.c will take care */
3151 return true;
3152 }
3153
3154 if (DEBUGLEVEL >= 10) {
3155 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, r);
3156 }
3157
3158 push = ndr_push_init_ctx(r);
3159 if (push == NULL) {
3160 talloc_free(r);
3161 return false;
3162 }
3163
3164 ndr_err = call->ndr_push(push, NDR_OUT, r);
3165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3166 talloc_free(r);
3167 return false;
3168 }
3169
3170 blob = ndr_push_blob(push);
3171 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3172 talloc_free(r);
3173 return false;
3174 }
3175
3176 talloc_free(r);
3177
3178 return true;
3179}
3180
3181static bool api_srvsvc_NetServerTransportAddEx(pipes_struct *p)
3182{
3183 const struct ndr_interface_call *call;
3184 struct ndr_pull *pull;
3185 struct ndr_push *push;
3186 enum ndr_err_code ndr_err;
3187 DATA_BLOB blob;
3188 struct srvsvc_NetServerTransportAddEx *r;
3189
3190 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERTRANSPORTADDEX];
3191
3192 r = talloc(talloc_tos(), struct srvsvc_NetServerTransportAddEx);
3193 if (r == NULL) {
3194 return false;
3195 }
3196
3197 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3198 talloc_free(r);
3199 return false;
3200 }
3201
3202 pull = ndr_pull_init_blob(&blob, r);
3203 if (pull == NULL) {
3204 talloc_free(r);
3205 return false;
3206 }
3207
3208 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3209 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3210 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3211 talloc_free(r);
3212 return false;
3213 }
3214
3215 if (DEBUGLEVEL >= 10) {
3216 NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, r);
3217 }
3218
3219 r->out.result = _srvsvc_NetServerTransportAddEx(p, r);
3220
3221 if (p->rng_fault_state) {
3222 talloc_free(r);
3223 /* Return true here, srv_pipe_hnd.c will take care */
3224 return true;
3225 }
3226
3227 if (DEBUGLEVEL >= 10) {
3228 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, r);
3229 }
3230
3231 push = ndr_push_init_ctx(r);
3232 if (push == NULL) {
3233 talloc_free(r);
3234 return false;
3235 }
3236
3237 ndr_err = call->ndr_push(push, NDR_OUT, r);
3238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3239 talloc_free(r);
3240 return false;
3241 }
3242
3243 blob = ndr_push_blob(push);
3244 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3245 talloc_free(r);
3246 return false;
3247 }
3248
3249 talloc_free(r);
3250
3251 return true;
3252}
3253
3254static bool api_srvsvc_NetServerSetServiceBitsEx(pipes_struct *p)
3255{
3256 const struct ndr_interface_call *call;
3257 struct ndr_pull *pull;
3258 struct ndr_push *push;
3259 enum ndr_err_code ndr_err;
3260 DATA_BLOB blob;
3261 struct srvsvc_NetServerSetServiceBitsEx *r;
3262
3263 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSETSERVICEBITSEX];
3264
3265 r = talloc(talloc_tos(), struct srvsvc_NetServerSetServiceBitsEx);
3266 if (r == NULL) {
3267 return false;
3268 }
3269
3270 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3271 talloc_free(r);
3272 return false;
3273 }
3274
3275 pull = ndr_pull_init_blob(&blob, r);
3276 if (pull == NULL) {
3277 talloc_free(r);
3278 return false;
3279 }
3280
3281 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3282 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3283 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3284 talloc_free(r);
3285 return false;
3286 }
3287
3288 if (DEBUGLEVEL >= 10) {
3289 NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3290 }
3291
3292 r->out.result = _srvsvc_NetServerSetServiceBitsEx(p, r);
3293
3294 if (p->rng_fault_state) {
3295 talloc_free(r);
3296 /* Return true here, srv_pipe_hnd.c will take care */
3297 return true;
3298 }
3299
3300 if (DEBUGLEVEL >= 10) {
3301 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3302 }
3303
3304 push = ndr_push_init_ctx(r);
3305 if (push == NULL) {
3306 talloc_free(r);
3307 return false;
3308 }
3309
3310 ndr_err = call->ndr_push(push, NDR_OUT, r);
3311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3312 talloc_free(r);
3313 return false;
3314 }
3315
3316 blob = ndr_push_blob(push);
3317 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3318 talloc_free(r);
3319 return false;
3320 }
3321
3322 talloc_free(r);
3323
3324 return true;
3325}
3326
3327static bool api_srvsvc_NETRDFSGETVERSION(pipes_struct *p)
3328{
3329 const struct ndr_interface_call *call;
3330 struct ndr_pull *pull;
3331 struct ndr_push *push;
3332 enum ndr_err_code ndr_err;
3333 DATA_BLOB blob;
3334 struct srvsvc_NETRDFSGETVERSION *r;
3335
3336 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSGETVERSION];
3337
3338 r = talloc(talloc_tos(), struct srvsvc_NETRDFSGETVERSION);
3339 if (r == NULL) {
3340 return false;
3341 }
3342
3343 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3344 talloc_free(r);
3345 return false;
3346 }
3347
3348 pull = ndr_pull_init_blob(&blob, r);
3349 if (pull == NULL) {
3350 talloc_free(r);
3351 return false;
3352 }
3353
3354 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3355 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3356 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3357 talloc_free(r);
3358 return false;
3359 }
3360
3361 if (DEBUGLEVEL >= 10) {
3362 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, r);
3363 }
3364
3365 r->out.result = _srvsvc_NETRDFSGETVERSION(p, r);
3366
3367 if (p->rng_fault_state) {
3368 talloc_free(r);
3369 /* Return true here, srv_pipe_hnd.c will take care */
3370 return true;
3371 }
3372
3373 if (DEBUGLEVEL >= 10) {
3374 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, r);
3375 }
3376
3377 push = ndr_push_init_ctx(r);
3378 if (push == NULL) {
3379 talloc_free(r);
3380 return false;
3381 }
3382
3383 ndr_err = call->ndr_push(push, NDR_OUT, r);
3384 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3385 talloc_free(r);
3386 return false;
3387 }
3388
3389 blob = ndr_push_blob(push);
3390 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3391 talloc_free(r);
3392 return false;
3393 }
3394
3395 talloc_free(r);
3396
3397 return true;
3398}
3399
3400static bool api_srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p)
3401{
3402 const struct ndr_interface_call *call;
3403 struct ndr_pull *pull;
3404 struct ndr_push *push;
3405 enum ndr_err_code ndr_err;
3406 DATA_BLOB blob;
3407 struct srvsvc_NETRDFSCREATELOCALPARTITION *r;
3408
3409 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATELOCALPARTITION];
3410
3411 r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATELOCALPARTITION);
3412 if (r == NULL) {
3413 return false;
3414 }
3415
3416 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3417 talloc_free(r);
3418 return false;
3419 }
3420
3421 pull = ndr_pull_init_blob(&blob, r);
3422 if (pull == NULL) {
3423 talloc_free(r);
3424 return false;
3425 }
3426
3427 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3428 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3429 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3430 talloc_free(r);
3431 return false;
3432 }
3433
3434 if (DEBUGLEVEL >= 10) {
3435 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r);
3436 }
3437
3438 r->out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(p, r);
3439
3440 if (p->rng_fault_state) {
3441 talloc_free(r);
3442 /* Return true here, srv_pipe_hnd.c will take care */
3443 return true;
3444 }
3445
3446 if (DEBUGLEVEL >= 10) {
3447 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r);
3448 }
3449
3450 push = ndr_push_init_ctx(r);
3451 if (push == NULL) {
3452 talloc_free(r);
3453 return false;
3454 }
3455
3456 ndr_err = call->ndr_push(push, NDR_OUT, r);
3457 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3458 talloc_free(r);
3459 return false;
3460 }
3461
3462 blob = ndr_push_blob(push);
3463 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3464 talloc_free(r);
3465 return false;
3466 }
3467
3468 talloc_free(r);
3469
3470 return true;
3471}
3472
3473static bool api_srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p)
3474{
3475 const struct ndr_interface_call *call;
3476 struct ndr_pull *pull;
3477 struct ndr_push *push;
3478 enum ndr_err_code ndr_err;
3479 DATA_BLOB blob;
3480 struct srvsvc_NETRDFSDELETELOCALPARTITION *r;
3481
3482 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETELOCALPARTITION];
3483
3484 r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETELOCALPARTITION);
3485 if (r == NULL) {
3486 return false;
3487 }
3488
3489 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3490 talloc_free(r);
3491 return false;
3492 }
3493
3494 pull = ndr_pull_init_blob(&blob, r);
3495 if (pull == NULL) {
3496 talloc_free(r);
3497 return false;
3498 }
3499
3500 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3501 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3502 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3503 talloc_free(r);
3504 return false;
3505 }
3506
3507 if (DEBUGLEVEL >= 10) {
3508 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r);
3509 }
3510
3511 r->out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(p, r);
3512
3513 if (p->rng_fault_state) {
3514 talloc_free(r);
3515 /* Return true here, srv_pipe_hnd.c will take care */
3516 return true;
3517 }
3518
3519 if (DEBUGLEVEL >= 10) {
3520 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r);
3521 }
3522
3523 push = ndr_push_init_ctx(r);
3524 if (push == NULL) {
3525 talloc_free(r);
3526 return false;
3527 }
3528
3529 ndr_err = call->ndr_push(push, NDR_OUT, r);
3530 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3531 talloc_free(r);
3532 return false;
3533 }
3534
3535 blob = ndr_push_blob(push);
3536 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3537 talloc_free(r);
3538 return false;
3539 }
3540
3541 talloc_free(r);
3542
3543 return true;
3544}
3545
3546static bool api_srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p)
3547{
3548 const struct ndr_interface_call *call;
3549 struct ndr_pull *pull;
3550 struct ndr_push *push;
3551 enum ndr_err_code ndr_err;
3552 DATA_BLOB blob;
3553 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r;
3554
3555 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE];
3556
3557 r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETLOCALVOLUMESTATE);
3558 if (r == NULL) {
3559 return false;
3560 }
3561
3562 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3563 talloc_free(r);
3564 return false;
3565 }
3566
3567 pull = ndr_pull_init_blob(&blob, r);
3568 if (pull == NULL) {
3569 talloc_free(r);
3570 return false;
3571 }
3572
3573 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3574 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3575 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3576 talloc_free(r);
3577 return false;
3578 }
3579
3580 if (DEBUGLEVEL >= 10) {
3581 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r);
3582 }
3583
3584 r->out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(p, r);
3585
3586 if (p->rng_fault_state) {
3587 talloc_free(r);
3588 /* Return true here, srv_pipe_hnd.c will take care */
3589 return true;
3590 }
3591
3592 if (DEBUGLEVEL >= 10) {
3593 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r);
3594 }
3595
3596 push = ndr_push_init_ctx(r);
3597 if (push == NULL) {
3598 talloc_free(r);
3599 return false;
3600 }
3601
3602 ndr_err = call->ndr_push(push, NDR_OUT, r);
3603 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3604 talloc_free(r);
3605 return false;
3606 }
3607
3608 blob = ndr_push_blob(push);
3609 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3610 talloc_free(r);
3611 return false;
3612 }
3613
3614 talloc_free(r);
3615
3616 return true;
3617}
3618
3619static bool api_srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p)
3620{
3621 const struct ndr_interface_call *call;
3622 struct ndr_pull *pull;
3623 struct ndr_push *push;
3624 enum ndr_err_code ndr_err;
3625 DATA_BLOB blob;
3626 struct srvsvc_NETRDFSSETSERVERINFO *r;
3627
3628 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETSERVERINFO];
3629
3630 r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETSERVERINFO);
3631 if (r == NULL) {
3632 return false;
3633 }
3634
3635 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3636 talloc_free(r);
3637 return false;
3638 }
3639
3640 pull = ndr_pull_init_blob(&blob, r);
3641 if (pull == NULL) {
3642 talloc_free(r);
3643 return false;
3644 }
3645
3646 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3647 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3648 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3649 talloc_free(r);
3650 return false;
3651 }
3652
3653 if (DEBUGLEVEL >= 10) {
3654 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r);
3655 }
3656
3657 r->out.result = _srvsvc_NETRDFSSETSERVERINFO(p, r);
3658
3659 if (p->rng_fault_state) {
3660 talloc_free(r);
3661 /* Return true here, srv_pipe_hnd.c will take care */
3662 return true;
3663 }
3664
3665 if (DEBUGLEVEL >= 10) {
3666 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r);
3667 }
3668
3669 push = ndr_push_init_ctx(r);
3670 if (push == NULL) {
3671 talloc_free(r);
3672 return false;
3673 }
3674
3675 ndr_err = call->ndr_push(push, NDR_OUT, r);
3676 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3677 talloc_free(r);
3678 return false;
3679 }
3680
3681 blob = ndr_push_blob(push);
3682 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3683 talloc_free(r);
3684 return false;
3685 }
3686
3687 talloc_free(r);
3688
3689 return true;
3690}
3691
3692static bool api_srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p)
3693{
3694 const struct ndr_interface_call *call;
3695 struct ndr_pull *pull;
3696 struct ndr_push *push;
3697 enum ndr_err_code ndr_err;
3698 DATA_BLOB blob;
3699 struct srvsvc_NETRDFSCREATEEXITPOINT *r;
3700
3701 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATEEXITPOINT];
3702
3703 r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATEEXITPOINT);
3704 if (r == NULL) {
3705 return false;
3706 }
3707
3708 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3709 talloc_free(r);
3710 return false;
3711 }
3712
3713 pull = ndr_pull_init_blob(&blob, r);
3714 if (pull == NULL) {
3715 talloc_free(r);
3716 return false;
3717 }
3718
3719 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3720 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3721 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3722 talloc_free(r);
3723 return false;
3724 }
3725
3726 if (DEBUGLEVEL >= 10) {
3727 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r);
3728 }
3729
3730 r->out.result = _srvsvc_NETRDFSCREATEEXITPOINT(p, r);
3731
3732 if (p->rng_fault_state) {
3733 talloc_free(r);
3734 /* Return true here, srv_pipe_hnd.c will take care */
3735 return true;
3736 }
3737
3738 if (DEBUGLEVEL >= 10) {
3739 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r);
3740 }
3741
3742 push = ndr_push_init_ctx(r);
3743 if (push == NULL) {
3744 talloc_free(r);
3745 return false;
3746 }
3747
3748 ndr_err = call->ndr_push(push, NDR_OUT, r);
3749 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3750 talloc_free(r);
3751 return false;
3752 }
3753
3754 blob = ndr_push_blob(push);
3755 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3756 talloc_free(r);
3757 return false;
3758 }
3759
3760 talloc_free(r);
3761
3762 return true;
3763}
3764
3765static bool api_srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p)
3766{
3767 const struct ndr_interface_call *call;
3768 struct ndr_pull *pull;
3769 struct ndr_push *push;
3770 enum ndr_err_code ndr_err;
3771 DATA_BLOB blob;
3772 struct srvsvc_NETRDFSDELETEEXITPOINT *r;
3773
3774 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETEEXITPOINT];
3775
3776 r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETEEXITPOINT);
3777 if (r == NULL) {
3778 return false;
3779 }
3780
3781 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3782 talloc_free(r);
3783 return false;
3784 }
3785
3786 pull = ndr_pull_init_blob(&blob, r);
3787 if (pull == NULL) {
3788 talloc_free(r);
3789 return false;
3790 }
3791
3792 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3793 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3794 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3795 talloc_free(r);
3796 return false;
3797 }
3798
3799 if (DEBUGLEVEL >= 10) {
3800 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r);
3801 }
3802
3803 r->out.result = _srvsvc_NETRDFSDELETEEXITPOINT(p, r);
3804
3805 if (p->rng_fault_state) {
3806 talloc_free(r);
3807 /* Return true here, srv_pipe_hnd.c will take care */
3808 return true;
3809 }
3810
3811 if (DEBUGLEVEL >= 10) {
3812 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r);
3813 }
3814
3815 push = ndr_push_init_ctx(r);
3816 if (push == NULL) {
3817 talloc_free(r);
3818 return false;
3819 }
3820
3821 ndr_err = call->ndr_push(push, NDR_OUT, r);
3822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3823 talloc_free(r);
3824 return false;
3825 }
3826
3827 blob = ndr_push_blob(push);
3828 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3829 talloc_free(r);
3830 return false;
3831 }
3832
3833 talloc_free(r);
3834
3835 return true;
3836}
3837
3838static bool api_srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p)
3839{
3840 const struct ndr_interface_call *call;
3841 struct ndr_pull *pull;
3842 struct ndr_push *push;
3843 enum ndr_err_code ndr_err;
3844 DATA_BLOB blob;
3845 struct srvsvc_NETRDFSMODIFYPREFIX *r;
3846
3847 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMODIFYPREFIX];
3848
3849 r = talloc(talloc_tos(), struct srvsvc_NETRDFSMODIFYPREFIX);
3850 if (r == NULL) {
3851 return false;
3852 }
3853
3854 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3855 talloc_free(r);
3856 return false;
3857 }
3858
3859 pull = ndr_pull_init_blob(&blob, r);
3860 if (pull == NULL) {
3861 talloc_free(r);
3862 return false;
3863 }
3864
3865 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3866 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3867 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3868 talloc_free(r);
3869 return false;
3870 }
3871
3872 if (DEBUGLEVEL >= 10) {
3873 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r);
3874 }
3875
3876 r->out.result = _srvsvc_NETRDFSMODIFYPREFIX(p, r);
3877
3878 if (p->rng_fault_state) {
3879 talloc_free(r);
3880 /* Return true here, srv_pipe_hnd.c will take care */
3881 return true;
3882 }
3883
3884 if (DEBUGLEVEL >= 10) {
3885 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r);
3886 }
3887
3888 push = ndr_push_init_ctx(r);
3889 if (push == NULL) {
3890 talloc_free(r);
3891 return false;
3892 }
3893
3894 ndr_err = call->ndr_push(push, NDR_OUT, r);
3895 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3896 talloc_free(r);
3897 return false;
3898 }
3899
3900 blob = ndr_push_blob(push);
3901 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3902 talloc_free(r);
3903 return false;
3904 }
3905
3906 talloc_free(r);
3907
3908 return true;
3909}
3910
3911static bool api_srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p)
3912{
3913 const struct ndr_interface_call *call;
3914 struct ndr_pull *pull;
3915 struct ndr_push *push;
3916 enum ndr_err_code ndr_err;
3917 DATA_BLOB blob;
3918 struct srvsvc_NETRDFSFIXLOCALVOLUME *r;
3919
3920 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSFIXLOCALVOLUME];
3921
3922 r = talloc(talloc_tos(), struct srvsvc_NETRDFSFIXLOCALVOLUME);
3923 if (r == NULL) {
3924 return false;
3925 }
3926
3927 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3928 talloc_free(r);
3929 return false;
3930 }
3931
3932 pull = ndr_pull_init_blob(&blob, r);
3933 if (pull == NULL) {
3934 talloc_free(r);
3935 return false;
3936 }
3937
3938 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3939 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3940 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3941 talloc_free(r);
3942 return false;
3943 }
3944
3945 if (DEBUGLEVEL >= 10) {
3946 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r);
3947 }
3948
3949 r->out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(p, r);
3950
3951 if (p->rng_fault_state) {
3952 talloc_free(r);
3953 /* Return true here, srv_pipe_hnd.c will take care */
3954 return true;
3955 }
3956
3957 if (DEBUGLEVEL >= 10) {
3958 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r);
3959 }
3960
3961 push = ndr_push_init_ctx(r);
3962 if (push == NULL) {
3963 talloc_free(r);
3964 return false;
3965 }
3966
3967 ndr_err = call->ndr_push(push, NDR_OUT, r);
3968 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3969 talloc_free(r);
3970 return false;
3971 }
3972
3973 blob = ndr_push_blob(push);
3974 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3975 talloc_free(r);
3976 return false;
3977 }
3978
3979 talloc_free(r);
3980
3981 return true;
3982}
3983
3984static bool api_srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p)
3985{
3986 const struct ndr_interface_call *call;
3987 struct ndr_pull *pull;
3988 struct ndr_push *push;
3989 enum ndr_err_code ndr_err;
3990 DATA_BLOB blob;
3991 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r;
3992
3993 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO];
3994
3995 r = talloc(talloc_tos(), struct srvsvc_NETRDFSMANAGERREPORTSITEINFO);
3996 if (r == NULL) {
3997 return false;
3998 }
3999
4000 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4001 talloc_free(r);
4002 return false;
4003 }
4004
4005 pull = ndr_pull_init_blob(&blob, r);
4006 if (pull == NULL) {
4007 talloc_free(r);
4008 return false;
4009 }
4010
4011 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4012 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4013 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4014 talloc_free(r);
4015 return false;
4016 }
4017
4018 if (DEBUGLEVEL >= 10) {
4019 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r);
4020 }
4021
4022 r->out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(p, r);
4023
4024 if (p->rng_fault_state) {
4025 talloc_free(r);
4026 /* Return true here, srv_pipe_hnd.c will take care */
4027 return true;
4028 }
4029
4030 if (DEBUGLEVEL >= 10) {
4031 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r);
4032 }
4033
4034 push = ndr_push_init_ctx(r);
4035 if (push == NULL) {
4036 talloc_free(r);
4037 return false;
4038 }
4039
4040 ndr_err = call->ndr_push(push, NDR_OUT, r);
4041 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4042 talloc_free(r);
4043 return false;
4044 }
4045
4046 blob = ndr_push_blob(push);
4047 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4048 talloc_free(r);
4049 return false;
4050 }
4051
4052 talloc_free(r);
4053
4054 return true;
4055}
4056
4057static bool api_srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p)
4058{
4059 const struct ndr_interface_call *call;
4060 struct ndr_pull *pull;
4061 struct ndr_push *push;
4062 enum ndr_err_code ndr_err;
4063 DATA_BLOB blob;
4064 struct srvsvc_NETRSERVERTRANSPORTDELEX *r;
4065
4066 call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRSERVERTRANSPORTDELEX];
4067
4068 r = talloc(talloc_tos(), struct srvsvc_NETRSERVERTRANSPORTDELEX);
4069 if (r == NULL) {
4070 return false;
4071 }
4072
4073 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4074 talloc_free(r);
4075 return false;
4076 }
4077
4078 pull = ndr_pull_init_blob(&blob, r);
4079 if (pull == NULL) {
4080 talloc_free(r);
4081 return false;
4082 }
4083
4084 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4085 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4086 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4087 talloc_free(r);
4088 return false;
4089 }
4090
4091 if (DEBUGLEVEL >= 10) {
4092 NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r);
4093 }
4094
4095 r->out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(p, r);
4096
4097 if (p->rng_fault_state) {
4098 talloc_free(r);
4099 /* Return true here, srv_pipe_hnd.c will take care */
4100 return true;
4101 }
4102
4103 if (DEBUGLEVEL >= 10) {
4104 NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r);
4105 }
4106
4107 push = ndr_push_init_ctx(r);
4108 if (push == NULL) {
4109 talloc_free(r);
4110 return false;
4111 }
4112
4113 ndr_err = call->ndr_push(push, NDR_OUT, r);
4114 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4115 talloc_free(r);
4116 return false;
4117 }
4118
4119 blob = ndr_push_blob(push);
4120 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4121 talloc_free(r);
4122 return false;
4123 }
4124
4125 talloc_free(r);
4126
4127 return true;
4128}
4129
4130
4131/* Tables */
4132static struct api_struct api_srvsvc_cmds[] =
4133{
4134 {"SRVSVC_NETCHARDEVENUM", NDR_SRVSVC_NETCHARDEVENUM, api_srvsvc_NetCharDevEnum},
4135 {"SRVSVC_NETCHARDEVGETINFO", NDR_SRVSVC_NETCHARDEVGETINFO, api_srvsvc_NetCharDevGetInfo},
4136 {"SRVSVC_NETCHARDEVCONTROL", NDR_SRVSVC_NETCHARDEVCONTROL, api_srvsvc_NetCharDevControl},
4137 {"SRVSVC_NETCHARDEVQENUM", NDR_SRVSVC_NETCHARDEVQENUM, api_srvsvc_NetCharDevQEnum},
4138 {"SRVSVC_NETCHARDEVQGETINFO", NDR_SRVSVC_NETCHARDEVQGETINFO, api_srvsvc_NetCharDevQGetInfo},
4139 {"SRVSVC_NETCHARDEVQSETINFO", NDR_SRVSVC_NETCHARDEVQSETINFO, api_srvsvc_NetCharDevQSetInfo},
4140 {"SRVSVC_NETCHARDEVQPURGE", NDR_SRVSVC_NETCHARDEVQPURGE, api_srvsvc_NetCharDevQPurge},
4141 {"SRVSVC_NETCHARDEVQPURGESELF", NDR_SRVSVC_NETCHARDEVQPURGESELF, api_srvsvc_NetCharDevQPurgeSelf},
4142 {"SRVSVC_NETCONNENUM", NDR_SRVSVC_NETCONNENUM, api_srvsvc_NetConnEnum},
4143 {"SRVSVC_NETFILEENUM", NDR_SRVSVC_NETFILEENUM, api_srvsvc_NetFileEnum},
4144 {"SRVSVC_NETFILEGETINFO", NDR_SRVSVC_NETFILEGETINFO, api_srvsvc_NetFileGetInfo},
4145 {"SRVSVC_NETFILECLOSE", NDR_SRVSVC_NETFILECLOSE, api_srvsvc_NetFileClose},
4146 {"SRVSVC_NETSESSENUM", NDR_SRVSVC_NETSESSENUM, api_srvsvc_NetSessEnum},
4147 {"SRVSVC_NETSESSDEL", NDR_SRVSVC_NETSESSDEL, api_srvsvc_NetSessDel},
4148 {"SRVSVC_NETSHAREADD", NDR_SRVSVC_NETSHAREADD, api_srvsvc_NetShareAdd},
4149 {"SRVSVC_NETSHAREENUMALL", NDR_SRVSVC_NETSHAREENUMALL, api_srvsvc_NetShareEnumAll},
4150 {"SRVSVC_NETSHAREGETINFO", NDR_SRVSVC_NETSHAREGETINFO, api_srvsvc_NetShareGetInfo},
4151 {"SRVSVC_NETSHARESETINFO", NDR_SRVSVC_NETSHARESETINFO, api_srvsvc_NetShareSetInfo},
4152 {"SRVSVC_NETSHAREDEL", NDR_SRVSVC_NETSHAREDEL, api_srvsvc_NetShareDel},
4153 {"SRVSVC_NETSHAREDELSTICKY", NDR_SRVSVC_NETSHAREDELSTICKY, api_srvsvc_NetShareDelSticky},
4154 {"SRVSVC_NETSHARECHECK", NDR_SRVSVC_NETSHARECHECK, api_srvsvc_NetShareCheck},
4155 {"SRVSVC_NETSRVGETINFO", NDR_SRVSVC_NETSRVGETINFO, api_srvsvc_NetSrvGetInfo},
4156 {"SRVSVC_NETSRVSETINFO", NDR_SRVSVC_NETSRVSETINFO, api_srvsvc_NetSrvSetInfo},
4157 {"SRVSVC_NETDISKENUM", NDR_SRVSVC_NETDISKENUM, api_srvsvc_NetDiskEnum},
4158 {"SRVSVC_NETSERVERSTATISTICSGET", NDR_SRVSVC_NETSERVERSTATISTICSGET, api_srvsvc_NetServerStatisticsGet},
4159 {"SRVSVC_NETTRANSPORTADD", NDR_SRVSVC_NETTRANSPORTADD, api_srvsvc_NetTransportAdd},
4160 {"SRVSVC_NETTRANSPORTENUM", NDR_SRVSVC_NETTRANSPORTENUM, api_srvsvc_NetTransportEnum},
4161 {"SRVSVC_NETTRANSPORTDEL", NDR_SRVSVC_NETTRANSPORTDEL, api_srvsvc_NetTransportDel},
4162 {"SRVSVC_NETREMOTETOD", NDR_SRVSVC_NETREMOTETOD, api_srvsvc_NetRemoteTOD},
4163 {"SRVSVC_NETSETSERVICEBITS", NDR_SRVSVC_NETSETSERVICEBITS, api_srvsvc_NetSetServiceBits},
4164 {"SRVSVC_NETPATHTYPE", NDR_SRVSVC_NETPATHTYPE, api_srvsvc_NetPathType},
4165 {"SRVSVC_NETPATHCANONICALIZE", NDR_SRVSVC_NETPATHCANONICALIZE, api_srvsvc_NetPathCanonicalize},
4166 {"SRVSVC_NETPATHCOMPARE", NDR_SRVSVC_NETPATHCOMPARE, api_srvsvc_NetPathCompare},
4167 {"SRVSVC_NETNAMEVALIDATE", NDR_SRVSVC_NETNAMEVALIDATE, api_srvsvc_NetNameValidate},
4168 {"SRVSVC_NETRPRNAMECANONICALIZE", NDR_SRVSVC_NETRPRNAMECANONICALIZE, api_srvsvc_NETRPRNAMECANONICALIZE},
4169 {"SRVSVC_NETPRNAMECOMPARE", NDR_SRVSVC_NETPRNAMECOMPARE, api_srvsvc_NetPRNameCompare},
4170 {"SRVSVC_NETSHAREENUM", NDR_SRVSVC_NETSHAREENUM, api_srvsvc_NetShareEnum},
4171 {"SRVSVC_NETSHAREDELSTART", NDR_SRVSVC_NETSHAREDELSTART, api_srvsvc_NetShareDelStart},
4172 {"SRVSVC_NETSHAREDELCOMMIT", NDR_SRVSVC_NETSHAREDELCOMMIT, api_srvsvc_NetShareDelCommit},
4173 {"SRVSVC_NETGETFILESECURITY", NDR_SRVSVC_NETGETFILESECURITY, api_srvsvc_NetGetFileSecurity},
4174 {"SRVSVC_NETSETFILESECURITY", NDR_SRVSVC_NETSETFILESECURITY, api_srvsvc_NetSetFileSecurity},
4175 {"SRVSVC_NETSERVERTRANSPORTADDEX", NDR_SRVSVC_NETSERVERTRANSPORTADDEX, api_srvsvc_NetServerTransportAddEx},
4176 {"SRVSVC_NETSERVERSETSERVICEBITSEX", NDR_SRVSVC_NETSERVERSETSERVICEBITSEX, api_srvsvc_NetServerSetServiceBitsEx},
4177 {"SRVSVC_NETRDFSGETVERSION", NDR_SRVSVC_NETRDFSGETVERSION, api_srvsvc_NETRDFSGETVERSION},
4178 {"SRVSVC_NETRDFSCREATELOCALPARTITION", NDR_SRVSVC_NETRDFSCREATELOCALPARTITION, api_srvsvc_NETRDFSCREATELOCALPARTITION},
4179 {"SRVSVC_NETRDFSDELETELOCALPARTITION", NDR_SRVSVC_NETRDFSDELETELOCALPARTITION, api_srvsvc_NETRDFSDELETELOCALPARTITION},
4180 {"SRVSVC_NETRDFSSETLOCALVOLUMESTATE", NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE, api_srvsvc_NETRDFSSETLOCALVOLUMESTATE},
4181 {"SRVSVC_NETRDFSSETSERVERINFO", NDR_SRVSVC_NETRDFSSETSERVERINFO, api_srvsvc_NETRDFSSETSERVERINFO},
4182 {"SRVSVC_NETRDFSCREATEEXITPOINT", NDR_SRVSVC_NETRDFSCREATEEXITPOINT, api_srvsvc_NETRDFSCREATEEXITPOINT},
4183 {"SRVSVC_NETRDFSDELETEEXITPOINT", NDR_SRVSVC_NETRDFSDELETEEXITPOINT, api_srvsvc_NETRDFSDELETEEXITPOINT},
4184 {"SRVSVC_NETRDFSMODIFYPREFIX", NDR_SRVSVC_NETRDFSMODIFYPREFIX, api_srvsvc_NETRDFSMODIFYPREFIX},
4185 {"SRVSVC_NETRDFSFIXLOCALVOLUME", NDR_SRVSVC_NETRDFSFIXLOCALVOLUME, api_srvsvc_NETRDFSFIXLOCALVOLUME},
4186 {"SRVSVC_NETRDFSMANAGERREPORTSITEINFO", NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO, api_srvsvc_NETRDFSMANAGERREPORTSITEINFO},
4187 {"SRVSVC_NETRSERVERTRANSPORTDELEX", NDR_SRVSVC_NETRSERVERTRANSPORTDELEX, api_srvsvc_NETRSERVERTRANSPORTDELEX},
4188};
4189
4190void srvsvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
4191{
4192 *fns = api_srvsvc_cmds;
4193 *n_fns = sizeof(api_srvsvc_cmds) / sizeof(struct api_struct);
4194}
4195
4196NTSTATUS rpc_srvsvc_init(void)
4197{
4198 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "srvsvc", "srvsvc", api_srvsvc_cmds, sizeof(api_srvsvc_cmds) / sizeof(struct api_struct));
4199}
Note: See TracBrowser for help on using the repository browser.