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