Add new script for building IDL files in librpc/idl, generating both
[sfrench/samba-autobuild/.git] / librpc / gen_ndr / srv_srvsvc.c
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, NULL);
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.info_ctr = r->in.info_ctr;
49         r->out.resume_handle = r->in.resume_handle;
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.result = _srvsvc_NetCharDevEnum(p, r);
57
58         if (p->rng_fault_state) {
59                 talloc_free(r);
60                 /* Return true here, srv_pipe_hnd.c will take care */
61                 return true;
62         }
63
64         if (DEBUGLEVEL >= 10) {
65                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, r);
66         }
67
68         push = ndr_push_init_ctx(r, NULL);
69         if (push == NULL) {
70                 talloc_free(r);
71                 return false;
72         }
73
74         ndr_err = call->ndr_push(push, NDR_OUT, r);
75         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
76                 talloc_free(r);
77                 return false;
78         }
79
80         blob = ndr_push_blob(push);
81         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
82                 talloc_free(r);
83                 return false;
84         }
85
86         talloc_free(r);
87
88         return true;
89 }
90
91 static bool api_srvsvc_NetCharDevGetInfo(pipes_struct *p)
92 {
93         const struct ndr_interface_call *call;
94         struct ndr_pull *pull;
95         struct ndr_push *push;
96         enum ndr_err_code ndr_err;
97         DATA_BLOB blob;
98         struct srvsvc_NetCharDevGetInfo *r;
99
100         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVGETINFO];
101
102         r = talloc(talloc_tos(), struct srvsvc_NetCharDevGetInfo);
103         if (r == NULL) {
104                 return false;
105         }
106
107         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
108                 talloc_free(r);
109                 return false;
110         }
111
112         pull = ndr_pull_init_blob(&blob, r, NULL);
113         if (pull == NULL) {
114                 talloc_free(r);
115                 return false;
116         }
117
118         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
119         ndr_err = call->ndr_pull(pull, NDR_IN, r);
120         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
121                 talloc_free(r);
122                 return false;
123         }
124
125         if (DEBUGLEVEL >= 10) {
126                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, r);
127         }
128
129         ZERO_STRUCT(r->out);
130         r->out.info = talloc_zero(r, union srvsvc_NetCharDevInfo);
131         if (r->out.info == NULL) {
132                 talloc_free(r);
133                 return false;
134         }
135
136         r->out.result = _srvsvc_NetCharDevGetInfo(p, r);
137
138         if (p->rng_fault_state) {
139                 talloc_free(r);
140                 /* Return true here, srv_pipe_hnd.c will take care */
141                 return true;
142         }
143
144         if (DEBUGLEVEL >= 10) {
145                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, r);
146         }
147
148         push = ndr_push_init_ctx(r, NULL);
149         if (push == NULL) {
150                 talloc_free(r);
151                 return false;
152         }
153
154         ndr_err = call->ndr_push(push, NDR_OUT, r);
155         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
156                 talloc_free(r);
157                 return false;
158         }
159
160         blob = ndr_push_blob(push);
161         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
162                 talloc_free(r);
163                 return false;
164         }
165
166         talloc_free(r);
167
168         return true;
169 }
170
171 static bool api_srvsvc_NetCharDevControl(pipes_struct *p)
172 {
173         const struct ndr_interface_call *call;
174         struct ndr_pull *pull;
175         struct ndr_push *push;
176         enum ndr_err_code ndr_err;
177         DATA_BLOB blob;
178         struct srvsvc_NetCharDevControl *r;
179
180         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVCONTROL];
181
182         r = talloc(talloc_tos(), struct srvsvc_NetCharDevControl);
183         if (r == NULL) {
184                 return false;
185         }
186
187         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
188                 talloc_free(r);
189                 return false;
190         }
191
192         pull = ndr_pull_init_blob(&blob, r, NULL);
193         if (pull == NULL) {
194                 talloc_free(r);
195                 return false;
196         }
197
198         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
199         ndr_err = call->ndr_pull(pull, NDR_IN, r);
200         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
201                 talloc_free(r);
202                 return false;
203         }
204
205         if (DEBUGLEVEL >= 10) {
206                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, r);
207         }
208
209         r->out.result = _srvsvc_NetCharDevControl(p, r);
210
211         if (p->rng_fault_state) {
212                 talloc_free(r);
213                 /* Return true here, srv_pipe_hnd.c will take care */
214                 return true;
215         }
216
217         if (DEBUGLEVEL >= 10) {
218                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, r);
219         }
220
221         push = ndr_push_init_ctx(r, NULL);
222         if (push == NULL) {
223                 talloc_free(r);
224                 return false;
225         }
226
227         ndr_err = call->ndr_push(push, NDR_OUT, r);
228         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
229                 talloc_free(r);
230                 return false;
231         }
232
233         blob = ndr_push_blob(push);
234         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
235                 talloc_free(r);
236                 return false;
237         }
238
239         talloc_free(r);
240
241         return true;
242 }
243
244 static bool api_srvsvc_NetCharDevQEnum(pipes_struct *p)
245 {
246         const struct ndr_interface_call *call;
247         struct ndr_pull *pull;
248         struct ndr_push *push;
249         enum ndr_err_code ndr_err;
250         DATA_BLOB blob;
251         struct srvsvc_NetCharDevQEnum *r;
252
253         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQENUM];
254
255         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQEnum);
256         if (r == NULL) {
257                 return false;
258         }
259
260         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
261                 talloc_free(r);
262                 return false;
263         }
264
265         pull = ndr_pull_init_blob(&blob, r, NULL);
266         if (pull == NULL) {
267                 talloc_free(r);
268                 return false;
269         }
270
271         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
272         ndr_err = call->ndr_pull(pull, NDR_IN, r);
273         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
274                 talloc_free(r);
275                 return false;
276         }
277
278         if (DEBUGLEVEL >= 10) {
279                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, r);
280         }
281
282         ZERO_STRUCT(r->out);
283         r->out.info_ctr = r->in.info_ctr;
284         r->out.resume_handle = r->in.resume_handle;
285         r->out.totalentries = talloc_zero(r, uint32_t);
286         if (r->out.totalentries == NULL) {
287                 talloc_free(r);
288                 return false;
289         }
290
291         r->out.result = _srvsvc_NetCharDevQEnum(p, r);
292
293         if (p->rng_fault_state) {
294                 talloc_free(r);
295                 /* Return true here, srv_pipe_hnd.c will take care */
296                 return true;
297         }
298
299         if (DEBUGLEVEL >= 10) {
300                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, r);
301         }
302
303         push = ndr_push_init_ctx(r, NULL);
304         if (push == NULL) {
305                 talloc_free(r);
306                 return false;
307         }
308
309         ndr_err = call->ndr_push(push, NDR_OUT, r);
310         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
311                 talloc_free(r);
312                 return false;
313         }
314
315         blob = ndr_push_blob(push);
316         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
317                 talloc_free(r);
318                 return false;
319         }
320
321         talloc_free(r);
322
323         return true;
324 }
325
326 static bool api_srvsvc_NetCharDevQGetInfo(pipes_struct *p)
327 {
328         const struct ndr_interface_call *call;
329         struct ndr_pull *pull;
330         struct ndr_push *push;
331         enum ndr_err_code ndr_err;
332         DATA_BLOB blob;
333         struct srvsvc_NetCharDevQGetInfo *r;
334
335         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQGETINFO];
336
337         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQGetInfo);
338         if (r == NULL) {
339                 return false;
340         }
341
342         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
343                 talloc_free(r);
344                 return false;
345         }
346
347         pull = ndr_pull_init_blob(&blob, r, NULL);
348         if (pull == NULL) {
349                 talloc_free(r);
350                 return false;
351         }
352
353         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
354         ndr_err = call->ndr_pull(pull, NDR_IN, r);
355         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
356                 talloc_free(r);
357                 return false;
358         }
359
360         if (DEBUGLEVEL >= 10) {
361                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, r);
362         }
363
364         ZERO_STRUCT(r->out);
365         r->out.info = talloc_zero(r, union srvsvc_NetCharDevQInfo);
366         if (r->out.info == NULL) {
367                 talloc_free(r);
368                 return false;
369         }
370
371         r->out.result = _srvsvc_NetCharDevQGetInfo(p, r);
372
373         if (p->rng_fault_state) {
374                 talloc_free(r);
375                 /* Return true here, srv_pipe_hnd.c will take care */
376                 return true;
377         }
378
379         if (DEBUGLEVEL >= 10) {
380                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, r);
381         }
382
383         push = ndr_push_init_ctx(r, NULL);
384         if (push == NULL) {
385                 talloc_free(r);
386                 return false;
387         }
388
389         ndr_err = call->ndr_push(push, NDR_OUT, r);
390         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
391                 talloc_free(r);
392                 return false;
393         }
394
395         blob = ndr_push_blob(push);
396         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
397                 talloc_free(r);
398                 return false;
399         }
400
401         talloc_free(r);
402
403         return true;
404 }
405
406 static bool api_srvsvc_NetCharDevQSetInfo(pipes_struct *p)
407 {
408         const struct ndr_interface_call *call;
409         struct ndr_pull *pull;
410         struct ndr_push *push;
411         enum ndr_err_code ndr_err;
412         DATA_BLOB blob;
413         struct srvsvc_NetCharDevQSetInfo *r;
414
415         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQSETINFO];
416
417         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQSetInfo);
418         if (r == NULL) {
419                 return false;
420         }
421
422         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
423                 talloc_free(r);
424                 return false;
425         }
426
427         pull = ndr_pull_init_blob(&blob, r, NULL);
428         if (pull == NULL) {
429                 talloc_free(r);
430                 return false;
431         }
432
433         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
434         ndr_err = call->ndr_pull(pull, NDR_IN, r);
435         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
436                 talloc_free(r);
437                 return false;
438         }
439
440         if (DEBUGLEVEL >= 10) {
441                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, r);
442         }
443
444         ZERO_STRUCT(r->out);
445         r->out.parm_error = r->in.parm_error;
446         r->out.result = _srvsvc_NetCharDevQSetInfo(p, r);
447
448         if (p->rng_fault_state) {
449                 talloc_free(r);
450                 /* Return true here, srv_pipe_hnd.c will take care */
451                 return true;
452         }
453
454         if (DEBUGLEVEL >= 10) {
455                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, r);
456         }
457
458         push = ndr_push_init_ctx(r, NULL);
459         if (push == NULL) {
460                 talloc_free(r);
461                 return false;
462         }
463
464         ndr_err = call->ndr_push(push, NDR_OUT, r);
465         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
466                 talloc_free(r);
467                 return false;
468         }
469
470         blob = ndr_push_blob(push);
471         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
472                 talloc_free(r);
473                 return false;
474         }
475
476         talloc_free(r);
477
478         return true;
479 }
480
481 static bool api_srvsvc_NetCharDevQPurge(pipes_struct *p)
482 {
483         const struct ndr_interface_call *call;
484         struct ndr_pull *pull;
485         struct ndr_push *push;
486         enum ndr_err_code ndr_err;
487         DATA_BLOB blob;
488         struct srvsvc_NetCharDevQPurge *r;
489
490         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGE];
491
492         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurge);
493         if (r == NULL) {
494                 return false;
495         }
496
497         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
498                 talloc_free(r);
499                 return false;
500         }
501
502         pull = ndr_pull_init_blob(&blob, r, NULL);
503         if (pull == NULL) {
504                 talloc_free(r);
505                 return false;
506         }
507
508         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
509         ndr_err = call->ndr_pull(pull, NDR_IN, r);
510         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
511                 talloc_free(r);
512                 return false;
513         }
514
515         if (DEBUGLEVEL >= 10) {
516                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, r);
517         }
518
519         r->out.result = _srvsvc_NetCharDevQPurge(p, r);
520
521         if (p->rng_fault_state) {
522                 talloc_free(r);
523                 /* Return true here, srv_pipe_hnd.c will take care */
524                 return true;
525         }
526
527         if (DEBUGLEVEL >= 10) {
528                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, r);
529         }
530
531         push = ndr_push_init_ctx(r, NULL);
532         if (push == NULL) {
533                 talloc_free(r);
534                 return false;
535         }
536
537         ndr_err = call->ndr_push(push, NDR_OUT, r);
538         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
539                 talloc_free(r);
540                 return false;
541         }
542
543         blob = ndr_push_blob(push);
544         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
545                 talloc_free(r);
546                 return false;
547         }
548
549         talloc_free(r);
550
551         return true;
552 }
553
554 static bool api_srvsvc_NetCharDevQPurgeSelf(pipes_struct *p)
555 {
556         const struct ndr_interface_call *call;
557         struct ndr_pull *pull;
558         struct ndr_push *push;
559         enum ndr_err_code ndr_err;
560         DATA_BLOB blob;
561         struct srvsvc_NetCharDevQPurgeSelf *r;
562
563         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGESELF];
564
565         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurgeSelf);
566         if (r == NULL) {
567                 return false;
568         }
569
570         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
571                 talloc_free(r);
572                 return false;
573         }
574
575         pull = ndr_pull_init_blob(&blob, r, NULL);
576         if (pull == NULL) {
577                 talloc_free(r);
578                 return false;
579         }
580
581         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
582         ndr_err = call->ndr_pull(pull, NDR_IN, r);
583         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
584                 talloc_free(r);
585                 return false;
586         }
587
588         if (DEBUGLEVEL >= 10) {
589                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
590         }
591
592         r->out.result = _srvsvc_NetCharDevQPurgeSelf(p, r);
593
594         if (p->rng_fault_state) {
595                 talloc_free(r);
596                 /* Return true here, srv_pipe_hnd.c will take care */
597                 return true;
598         }
599
600         if (DEBUGLEVEL >= 10) {
601                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
602         }
603
604         push = ndr_push_init_ctx(r, NULL);
605         if (push == NULL) {
606                 talloc_free(r);
607                 return false;
608         }
609
610         ndr_err = call->ndr_push(push, NDR_OUT, r);
611         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
612                 talloc_free(r);
613                 return false;
614         }
615
616         blob = ndr_push_blob(push);
617         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
618                 talloc_free(r);
619                 return false;
620         }
621
622         talloc_free(r);
623
624         return true;
625 }
626
627 static bool api_srvsvc_NetConnEnum(pipes_struct *p)
628 {
629         const struct ndr_interface_call *call;
630         struct ndr_pull *pull;
631         struct ndr_push *push;
632         enum ndr_err_code ndr_err;
633         DATA_BLOB blob;
634         struct srvsvc_NetConnEnum *r;
635
636         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCONNENUM];
637
638         r = talloc(talloc_tos(), struct srvsvc_NetConnEnum);
639         if (r == NULL) {
640                 return false;
641         }
642
643         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
644                 talloc_free(r);
645                 return false;
646         }
647
648         pull = ndr_pull_init_blob(&blob, r, NULL);
649         if (pull == NULL) {
650                 talloc_free(r);
651                 return false;
652         }
653
654         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
655         ndr_err = call->ndr_pull(pull, NDR_IN, r);
656         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
657                 talloc_free(r);
658                 return false;
659         }
660
661         if (DEBUGLEVEL >= 10) {
662                 NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, r);
663         }
664
665         ZERO_STRUCT(r->out);
666         r->out.info_ctr = r->in.info_ctr;
667         r->out.resume_handle = r->in.resume_handle;
668         r->out.totalentries = talloc_zero(r, uint32_t);
669         if (r->out.totalentries == NULL) {
670                 talloc_free(r);
671                 return false;
672         }
673
674         r->out.result = _srvsvc_NetConnEnum(p, r);
675
676         if (p->rng_fault_state) {
677                 talloc_free(r);
678                 /* Return true here, srv_pipe_hnd.c will take care */
679                 return true;
680         }
681
682         if (DEBUGLEVEL >= 10) {
683                 NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, r);
684         }
685
686         push = ndr_push_init_ctx(r, NULL);
687         if (push == NULL) {
688                 talloc_free(r);
689                 return false;
690         }
691
692         ndr_err = call->ndr_push(push, NDR_OUT, r);
693         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
694                 talloc_free(r);
695                 return false;
696         }
697
698         blob = ndr_push_blob(push);
699         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
700                 talloc_free(r);
701                 return false;
702         }
703
704         talloc_free(r);
705
706         return true;
707 }
708
709 static bool api_srvsvc_NetFileEnum(pipes_struct *p)
710 {
711         const struct ndr_interface_call *call;
712         struct ndr_pull *pull;
713         struct ndr_push *push;
714         enum ndr_err_code ndr_err;
715         DATA_BLOB blob;
716         struct srvsvc_NetFileEnum *r;
717
718         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEENUM];
719
720         r = talloc(talloc_tos(), struct srvsvc_NetFileEnum);
721         if (r == NULL) {
722                 return false;
723         }
724
725         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
726                 talloc_free(r);
727                 return false;
728         }
729
730         pull = ndr_pull_init_blob(&blob, r, NULL);
731         if (pull == NULL) {
732                 talloc_free(r);
733                 return false;
734         }
735
736         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
737         ndr_err = call->ndr_pull(pull, NDR_IN, r);
738         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
739                 talloc_free(r);
740                 return false;
741         }
742
743         if (DEBUGLEVEL >= 10) {
744                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, r);
745         }
746
747         ZERO_STRUCT(r->out);
748         r->out.info_ctr = r->in.info_ctr;
749         r->out.resume_handle = r->in.resume_handle;
750         r->out.totalentries = talloc_zero(r, uint32_t);
751         if (r->out.totalentries == NULL) {
752                 talloc_free(r);
753                 return false;
754         }
755
756         r->out.result = _srvsvc_NetFileEnum(p, r);
757
758         if (p->rng_fault_state) {
759                 talloc_free(r);
760                 /* Return true here, srv_pipe_hnd.c will take care */
761                 return true;
762         }
763
764         if (DEBUGLEVEL >= 10) {
765                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, r);
766         }
767
768         push = ndr_push_init_ctx(r, NULL);
769         if (push == NULL) {
770                 talloc_free(r);
771                 return false;
772         }
773
774         ndr_err = call->ndr_push(push, NDR_OUT, r);
775         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
776                 talloc_free(r);
777                 return false;
778         }
779
780         blob = ndr_push_blob(push);
781         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
782                 talloc_free(r);
783                 return false;
784         }
785
786         talloc_free(r);
787
788         return true;
789 }
790
791 static bool api_srvsvc_NetFileGetInfo(pipes_struct *p)
792 {
793         const struct ndr_interface_call *call;
794         struct ndr_pull *pull;
795         struct ndr_push *push;
796         enum ndr_err_code ndr_err;
797         DATA_BLOB blob;
798         struct srvsvc_NetFileGetInfo *r;
799
800         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEGETINFO];
801
802         r = talloc(talloc_tos(), struct srvsvc_NetFileGetInfo);
803         if (r == NULL) {
804                 return false;
805         }
806
807         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
808                 talloc_free(r);
809                 return false;
810         }
811
812         pull = ndr_pull_init_blob(&blob, r, NULL);
813         if (pull == NULL) {
814                 talloc_free(r);
815                 return false;
816         }
817
818         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
819         ndr_err = call->ndr_pull(pull, NDR_IN, r);
820         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
821                 talloc_free(r);
822                 return false;
823         }
824
825         if (DEBUGLEVEL >= 10) {
826                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, r);
827         }
828
829         ZERO_STRUCT(r->out);
830         r->out.info = talloc_zero(r, union srvsvc_NetFileInfo);
831         if (r->out.info == NULL) {
832                 talloc_free(r);
833                 return false;
834         }
835
836         r->out.result = _srvsvc_NetFileGetInfo(p, r);
837
838         if (p->rng_fault_state) {
839                 talloc_free(r);
840                 /* Return true here, srv_pipe_hnd.c will take care */
841                 return true;
842         }
843
844         if (DEBUGLEVEL >= 10) {
845                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, r);
846         }
847
848         push = ndr_push_init_ctx(r, NULL);
849         if (push == NULL) {
850                 talloc_free(r);
851                 return false;
852         }
853
854         ndr_err = call->ndr_push(push, NDR_OUT, r);
855         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
856                 talloc_free(r);
857                 return false;
858         }
859
860         blob = ndr_push_blob(push);
861         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
862                 talloc_free(r);
863                 return false;
864         }
865
866         talloc_free(r);
867
868         return true;
869 }
870
871 static bool api_srvsvc_NetFileClose(pipes_struct *p)
872 {
873         const struct ndr_interface_call *call;
874         struct ndr_pull *pull;
875         struct ndr_push *push;
876         enum ndr_err_code ndr_err;
877         DATA_BLOB blob;
878         struct srvsvc_NetFileClose *r;
879
880         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILECLOSE];
881
882         r = talloc(talloc_tos(), struct srvsvc_NetFileClose);
883         if (r == NULL) {
884                 return false;
885         }
886
887         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
888                 talloc_free(r);
889                 return false;
890         }
891
892         pull = ndr_pull_init_blob(&blob, r, NULL);
893         if (pull == NULL) {
894                 talloc_free(r);
895                 return false;
896         }
897
898         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
899         ndr_err = call->ndr_pull(pull, NDR_IN, r);
900         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
901                 talloc_free(r);
902                 return false;
903         }
904
905         if (DEBUGLEVEL >= 10) {
906                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, r);
907         }
908
909         r->out.result = _srvsvc_NetFileClose(p, r);
910
911         if (p->rng_fault_state) {
912                 talloc_free(r);
913                 /* Return true here, srv_pipe_hnd.c will take care */
914                 return true;
915         }
916
917         if (DEBUGLEVEL >= 10) {
918                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, r);
919         }
920
921         push = ndr_push_init_ctx(r, NULL);
922         if (push == NULL) {
923                 talloc_free(r);
924                 return false;
925         }
926
927         ndr_err = call->ndr_push(push, NDR_OUT, r);
928         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
929                 talloc_free(r);
930                 return false;
931         }
932
933         blob = ndr_push_blob(push);
934         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
935                 talloc_free(r);
936                 return false;
937         }
938
939         talloc_free(r);
940
941         return true;
942 }
943
944 static bool api_srvsvc_NetSessEnum(pipes_struct *p)
945 {
946         const struct ndr_interface_call *call;
947         struct ndr_pull *pull;
948         struct ndr_push *push;
949         enum ndr_err_code ndr_err;
950         DATA_BLOB blob;
951         struct srvsvc_NetSessEnum *r;
952
953         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSENUM];
954
955         r = talloc(talloc_tos(), struct srvsvc_NetSessEnum);
956         if (r == NULL) {
957                 return false;
958         }
959
960         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
961                 talloc_free(r);
962                 return false;
963         }
964
965         pull = ndr_pull_init_blob(&blob, r, NULL);
966         if (pull == NULL) {
967                 talloc_free(r);
968                 return false;
969         }
970
971         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
972         ndr_err = call->ndr_pull(pull, NDR_IN, r);
973         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
974                 talloc_free(r);
975                 return false;
976         }
977
978         if (DEBUGLEVEL >= 10) {
979                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, r);
980         }
981
982         ZERO_STRUCT(r->out);
983         r->out.info_ctr = r->in.info_ctr;
984         r->out.resume_handle = r->in.resume_handle;
985         r->out.totalentries = talloc_zero(r, uint32_t);
986         if (r->out.totalentries == NULL) {
987                 talloc_free(r);
988                 return false;
989         }
990
991         r->out.result = _srvsvc_NetSessEnum(p, r);
992
993         if (p->rng_fault_state) {
994                 talloc_free(r);
995                 /* Return true here, srv_pipe_hnd.c will take care */
996                 return true;
997         }
998
999         if (DEBUGLEVEL >= 10) {
1000                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, r);
1001         }
1002
1003         push = ndr_push_init_ctx(r, NULL);
1004         if (push == NULL) {
1005                 talloc_free(r);
1006                 return false;
1007         }
1008
1009         ndr_err = call->ndr_push(push, NDR_OUT, r);
1010         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1011                 talloc_free(r);
1012                 return false;
1013         }
1014
1015         blob = ndr_push_blob(push);
1016         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1017                 talloc_free(r);
1018                 return false;
1019         }
1020
1021         talloc_free(r);
1022
1023         return true;
1024 }
1025
1026 static bool api_srvsvc_NetSessDel(pipes_struct *p)
1027 {
1028         const struct ndr_interface_call *call;
1029         struct ndr_pull *pull;
1030         struct ndr_push *push;
1031         enum ndr_err_code ndr_err;
1032         DATA_BLOB blob;
1033         struct srvsvc_NetSessDel *r;
1034
1035         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSDEL];
1036
1037         r = talloc(talloc_tos(), struct srvsvc_NetSessDel);
1038         if (r == NULL) {
1039                 return false;
1040         }
1041
1042         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1043                 talloc_free(r);
1044                 return false;
1045         }
1046
1047         pull = ndr_pull_init_blob(&blob, r, NULL);
1048         if (pull == NULL) {
1049                 talloc_free(r);
1050                 return false;
1051         }
1052
1053         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1054         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1055         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1056                 talloc_free(r);
1057                 return false;
1058         }
1059
1060         if (DEBUGLEVEL >= 10) {
1061                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, r);
1062         }
1063
1064         r->out.result = _srvsvc_NetSessDel(p, r);
1065
1066         if (p->rng_fault_state) {
1067                 talloc_free(r);
1068                 /* Return true here, srv_pipe_hnd.c will take care */
1069                 return true;
1070         }
1071
1072         if (DEBUGLEVEL >= 10) {
1073                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, r);
1074         }
1075
1076         push = ndr_push_init_ctx(r, NULL);
1077         if (push == NULL) {
1078                 talloc_free(r);
1079                 return false;
1080         }
1081
1082         ndr_err = call->ndr_push(push, NDR_OUT, r);
1083         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1084                 talloc_free(r);
1085                 return false;
1086         }
1087
1088         blob = ndr_push_blob(push);
1089         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1090                 talloc_free(r);
1091                 return false;
1092         }
1093
1094         talloc_free(r);
1095
1096         return true;
1097 }
1098
1099 static bool api_srvsvc_NetShareAdd(pipes_struct *p)
1100 {
1101         const struct ndr_interface_call *call;
1102         struct ndr_pull *pull;
1103         struct ndr_push *push;
1104         enum ndr_err_code ndr_err;
1105         DATA_BLOB blob;
1106         struct srvsvc_NetShareAdd *r;
1107
1108         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREADD];
1109
1110         r = talloc(talloc_tos(), struct srvsvc_NetShareAdd);
1111         if (r == NULL) {
1112                 return false;
1113         }
1114
1115         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1116                 talloc_free(r);
1117                 return false;
1118         }
1119
1120         pull = ndr_pull_init_blob(&blob, r, NULL);
1121         if (pull == NULL) {
1122                 talloc_free(r);
1123                 return false;
1124         }
1125
1126         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1127         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1128         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1129                 talloc_free(r);
1130                 return false;
1131         }
1132
1133         if (DEBUGLEVEL >= 10) {
1134                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, r);
1135         }
1136
1137         ZERO_STRUCT(r->out);
1138         r->out.parm_error = r->in.parm_error;
1139         r->out.result = _srvsvc_NetShareAdd(p, r);
1140
1141         if (p->rng_fault_state) {
1142                 talloc_free(r);
1143                 /* Return true here, srv_pipe_hnd.c will take care */
1144                 return true;
1145         }
1146
1147         if (DEBUGLEVEL >= 10) {
1148                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, r);
1149         }
1150
1151         push = ndr_push_init_ctx(r, NULL);
1152         if (push == NULL) {
1153                 talloc_free(r);
1154                 return false;
1155         }
1156
1157         ndr_err = call->ndr_push(push, NDR_OUT, r);
1158         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1159                 talloc_free(r);
1160                 return false;
1161         }
1162
1163         blob = ndr_push_blob(push);
1164         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1165                 talloc_free(r);
1166                 return false;
1167         }
1168
1169         talloc_free(r);
1170
1171         return true;
1172 }
1173
1174 static bool api_srvsvc_NetShareEnumAll(pipes_struct *p)
1175 {
1176         const struct ndr_interface_call *call;
1177         struct ndr_pull *pull;
1178         struct ndr_push *push;
1179         enum ndr_err_code ndr_err;
1180         DATA_BLOB blob;
1181         struct srvsvc_NetShareEnumAll *r;
1182
1183         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUMALL];
1184
1185         r = talloc(talloc_tos(), struct srvsvc_NetShareEnumAll);
1186         if (r == NULL) {
1187                 return false;
1188         }
1189
1190         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1191                 talloc_free(r);
1192                 return false;
1193         }
1194
1195         pull = ndr_pull_init_blob(&blob, r, NULL);
1196         if (pull == NULL) {
1197                 talloc_free(r);
1198                 return false;
1199         }
1200
1201         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1202         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1203         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1204                 talloc_free(r);
1205                 return false;
1206         }
1207
1208         if (DEBUGLEVEL >= 10) {
1209                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, r);
1210         }
1211
1212         ZERO_STRUCT(r->out);
1213         r->out.info_ctr = r->in.info_ctr;
1214         r->out.resume_handle = r->in.resume_handle;
1215         r->out.totalentries = talloc_zero(r, uint32_t);
1216         if (r->out.totalentries == NULL) {
1217                 talloc_free(r);
1218                 return false;
1219         }
1220
1221         r->out.result = _srvsvc_NetShareEnumAll(p, r);
1222
1223         if (p->rng_fault_state) {
1224                 talloc_free(r);
1225                 /* Return true here, srv_pipe_hnd.c will take care */
1226                 return true;
1227         }
1228
1229         if (DEBUGLEVEL >= 10) {
1230                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, r);
1231         }
1232
1233         push = ndr_push_init_ctx(r, NULL);
1234         if (push == NULL) {
1235                 talloc_free(r);
1236                 return false;
1237         }
1238
1239         ndr_err = call->ndr_push(push, NDR_OUT, r);
1240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1241                 talloc_free(r);
1242                 return false;
1243         }
1244
1245         blob = ndr_push_blob(push);
1246         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1247                 talloc_free(r);
1248                 return false;
1249         }
1250
1251         talloc_free(r);
1252
1253         return true;
1254 }
1255
1256 static bool api_srvsvc_NetShareGetInfo(pipes_struct *p)
1257 {
1258         const struct ndr_interface_call *call;
1259         struct ndr_pull *pull;
1260         struct ndr_push *push;
1261         enum ndr_err_code ndr_err;
1262         DATA_BLOB blob;
1263         struct srvsvc_NetShareGetInfo *r;
1264
1265         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREGETINFO];
1266
1267         r = talloc(talloc_tos(), struct srvsvc_NetShareGetInfo);
1268         if (r == NULL) {
1269                 return false;
1270         }
1271
1272         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1273                 talloc_free(r);
1274                 return false;
1275         }
1276
1277         pull = ndr_pull_init_blob(&blob, r, NULL);
1278         if (pull == NULL) {
1279                 talloc_free(r);
1280                 return false;
1281         }
1282
1283         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1284         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1286                 talloc_free(r);
1287                 return false;
1288         }
1289
1290         if (DEBUGLEVEL >= 10) {
1291                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, r);
1292         }
1293
1294         ZERO_STRUCT(r->out);
1295         r->out.info = talloc_zero(r, union srvsvc_NetShareInfo);
1296         if (r->out.info == NULL) {
1297                 talloc_free(r);
1298                 return false;
1299         }
1300
1301         r->out.result = _srvsvc_NetShareGetInfo(p, r);
1302
1303         if (p->rng_fault_state) {
1304                 talloc_free(r);
1305                 /* Return true here, srv_pipe_hnd.c will take care */
1306                 return true;
1307         }
1308
1309         if (DEBUGLEVEL >= 10) {
1310                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, r);
1311         }
1312
1313         push = ndr_push_init_ctx(r, NULL);
1314         if (push == NULL) {
1315                 talloc_free(r);
1316                 return false;
1317         }
1318
1319         ndr_err = call->ndr_push(push, NDR_OUT, r);
1320         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1321                 talloc_free(r);
1322                 return false;
1323         }
1324
1325         blob = ndr_push_blob(push);
1326         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1327                 talloc_free(r);
1328                 return false;
1329         }
1330
1331         talloc_free(r);
1332
1333         return true;
1334 }
1335
1336 static bool api_srvsvc_NetShareSetInfo(pipes_struct *p)
1337 {
1338         const struct ndr_interface_call *call;
1339         struct ndr_pull *pull;
1340         struct ndr_push *push;
1341         enum ndr_err_code ndr_err;
1342         DATA_BLOB blob;
1343         struct srvsvc_NetShareSetInfo *r;
1344
1345         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARESETINFO];
1346
1347         r = talloc(talloc_tos(), struct srvsvc_NetShareSetInfo);
1348         if (r == NULL) {
1349                 return false;
1350         }
1351
1352         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1353                 talloc_free(r);
1354                 return false;
1355         }
1356
1357         pull = ndr_pull_init_blob(&blob, r, NULL);
1358         if (pull == NULL) {
1359                 talloc_free(r);
1360                 return false;
1361         }
1362
1363         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1364         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1366                 talloc_free(r);
1367                 return false;
1368         }
1369
1370         if (DEBUGLEVEL >= 10) {
1371                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, r);
1372         }
1373
1374         ZERO_STRUCT(r->out);
1375         r->out.parm_error = r->in.parm_error;
1376         r->out.result = _srvsvc_NetShareSetInfo(p, r);
1377
1378         if (p->rng_fault_state) {
1379                 talloc_free(r);
1380                 /* Return true here, srv_pipe_hnd.c will take care */
1381                 return true;
1382         }
1383
1384         if (DEBUGLEVEL >= 10) {
1385                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, r);
1386         }
1387
1388         push = ndr_push_init_ctx(r, NULL);
1389         if (push == NULL) {
1390                 talloc_free(r);
1391                 return false;
1392         }
1393
1394         ndr_err = call->ndr_push(push, NDR_OUT, r);
1395         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1396                 talloc_free(r);
1397                 return false;
1398         }
1399
1400         blob = ndr_push_blob(push);
1401         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1402                 talloc_free(r);
1403                 return false;
1404         }
1405
1406         talloc_free(r);
1407
1408         return true;
1409 }
1410
1411 static bool api_srvsvc_NetShareDel(pipes_struct *p)
1412 {
1413         const struct ndr_interface_call *call;
1414         struct ndr_pull *pull;
1415         struct ndr_push *push;
1416         enum ndr_err_code ndr_err;
1417         DATA_BLOB blob;
1418         struct srvsvc_NetShareDel *r;
1419
1420         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDEL];
1421
1422         r = talloc(talloc_tos(), struct srvsvc_NetShareDel);
1423         if (r == NULL) {
1424                 return false;
1425         }
1426
1427         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1428                 talloc_free(r);
1429                 return false;
1430         }
1431
1432         pull = ndr_pull_init_blob(&blob, r, NULL);
1433         if (pull == NULL) {
1434                 talloc_free(r);
1435                 return false;
1436         }
1437
1438         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1439         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1440         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1441                 talloc_free(r);
1442                 return false;
1443         }
1444
1445         if (DEBUGLEVEL >= 10) {
1446                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, r);
1447         }
1448
1449         r->out.result = _srvsvc_NetShareDel(p, r);
1450
1451         if (p->rng_fault_state) {
1452                 talloc_free(r);
1453                 /* Return true here, srv_pipe_hnd.c will take care */
1454                 return true;
1455         }
1456
1457         if (DEBUGLEVEL >= 10) {
1458                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, r);
1459         }
1460
1461         push = ndr_push_init_ctx(r, NULL);
1462         if (push == NULL) {
1463                 talloc_free(r);
1464                 return false;
1465         }
1466
1467         ndr_err = call->ndr_push(push, NDR_OUT, r);
1468         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1469                 talloc_free(r);
1470                 return false;
1471         }
1472
1473         blob = ndr_push_blob(push);
1474         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1475                 talloc_free(r);
1476                 return false;
1477         }
1478
1479         talloc_free(r);
1480
1481         return true;
1482 }
1483
1484 static bool api_srvsvc_NetShareDelSticky(pipes_struct *p)
1485 {
1486         const struct ndr_interface_call *call;
1487         struct ndr_pull *pull;
1488         struct ndr_push *push;
1489         enum ndr_err_code ndr_err;
1490         DATA_BLOB blob;
1491         struct srvsvc_NetShareDelSticky *r;
1492
1493         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTICKY];
1494
1495         r = talloc(talloc_tos(), struct srvsvc_NetShareDelSticky);
1496         if (r == NULL) {
1497                 return false;
1498         }
1499
1500         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1501                 talloc_free(r);
1502                 return false;
1503         }
1504
1505         pull = ndr_pull_init_blob(&blob, r, NULL);
1506         if (pull == NULL) {
1507                 talloc_free(r);
1508                 return false;
1509         }
1510
1511         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1512         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1513         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1514                 talloc_free(r);
1515                 return false;
1516         }
1517
1518         if (DEBUGLEVEL >= 10) {
1519                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, r);
1520         }
1521
1522         r->out.result = _srvsvc_NetShareDelSticky(p, r);
1523
1524         if (p->rng_fault_state) {
1525                 talloc_free(r);
1526                 /* Return true here, srv_pipe_hnd.c will take care */
1527                 return true;
1528         }
1529
1530         if (DEBUGLEVEL >= 10) {
1531                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, r);
1532         }
1533
1534         push = ndr_push_init_ctx(r, NULL);
1535         if (push == NULL) {
1536                 talloc_free(r);
1537                 return false;
1538         }
1539
1540         ndr_err = call->ndr_push(push, NDR_OUT, r);
1541         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1542                 talloc_free(r);
1543                 return false;
1544         }
1545
1546         blob = ndr_push_blob(push);
1547         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1548                 talloc_free(r);
1549                 return false;
1550         }
1551
1552         talloc_free(r);
1553
1554         return true;
1555 }
1556
1557 static bool api_srvsvc_NetShareCheck(pipes_struct *p)
1558 {
1559         const struct ndr_interface_call *call;
1560         struct ndr_pull *pull;
1561         struct ndr_push *push;
1562         enum ndr_err_code ndr_err;
1563         DATA_BLOB blob;
1564         struct srvsvc_NetShareCheck *r;
1565
1566         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARECHECK];
1567
1568         r = talloc(talloc_tos(), struct srvsvc_NetShareCheck);
1569         if (r == NULL) {
1570                 return false;
1571         }
1572
1573         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1574                 talloc_free(r);
1575                 return false;
1576         }
1577
1578         pull = ndr_pull_init_blob(&blob, r, NULL);
1579         if (pull == NULL) {
1580                 talloc_free(r);
1581                 return false;
1582         }
1583
1584         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1585         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1586         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1587                 talloc_free(r);
1588                 return false;
1589         }
1590
1591         if (DEBUGLEVEL >= 10) {
1592                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, r);
1593         }
1594
1595         ZERO_STRUCT(r->out);
1596         r->out.type = talloc_zero(r, enum srvsvc_ShareType);
1597         if (r->out.type == NULL) {
1598                 talloc_free(r);
1599                 return false;
1600         }
1601
1602         r->out.result = _srvsvc_NetShareCheck(p, r);
1603
1604         if (p->rng_fault_state) {
1605                 talloc_free(r);
1606                 /* Return true here, srv_pipe_hnd.c will take care */
1607                 return true;
1608         }
1609
1610         if (DEBUGLEVEL >= 10) {
1611                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, r);
1612         }
1613
1614         push = ndr_push_init_ctx(r, NULL);
1615         if (push == NULL) {
1616                 talloc_free(r);
1617                 return false;
1618         }
1619
1620         ndr_err = call->ndr_push(push, NDR_OUT, r);
1621         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1622                 talloc_free(r);
1623                 return false;
1624         }
1625
1626         blob = ndr_push_blob(push);
1627         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1628                 talloc_free(r);
1629                 return false;
1630         }
1631
1632         talloc_free(r);
1633
1634         return true;
1635 }
1636
1637 static bool api_srvsvc_NetSrvGetInfo(pipes_struct *p)
1638 {
1639         const struct ndr_interface_call *call;
1640         struct ndr_pull *pull;
1641         struct ndr_push *push;
1642         enum ndr_err_code ndr_err;
1643         DATA_BLOB blob;
1644         struct srvsvc_NetSrvGetInfo *r;
1645
1646         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVGETINFO];
1647
1648         r = talloc(talloc_tos(), struct srvsvc_NetSrvGetInfo);
1649         if (r == NULL) {
1650                 return false;
1651         }
1652
1653         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1654                 talloc_free(r);
1655                 return false;
1656         }
1657
1658         pull = ndr_pull_init_blob(&blob, r, NULL);
1659         if (pull == NULL) {
1660                 talloc_free(r);
1661                 return false;
1662         }
1663
1664         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1665         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1666         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1667                 talloc_free(r);
1668                 return false;
1669         }
1670
1671         if (DEBUGLEVEL >= 10) {
1672                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, r);
1673         }
1674
1675         ZERO_STRUCT(r->out);
1676         r->out.info = talloc_zero(r, union srvsvc_NetSrvInfo);
1677         if (r->out.info == NULL) {
1678                 talloc_free(r);
1679                 return false;
1680         }
1681
1682         r->out.result = _srvsvc_NetSrvGetInfo(p, r);
1683
1684         if (p->rng_fault_state) {
1685                 talloc_free(r);
1686                 /* Return true here, srv_pipe_hnd.c will take care */
1687                 return true;
1688         }
1689
1690         if (DEBUGLEVEL >= 10) {
1691                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, r);
1692         }
1693
1694         push = ndr_push_init_ctx(r, NULL);
1695         if (push == NULL) {
1696                 talloc_free(r);
1697                 return false;
1698         }
1699
1700         ndr_err = call->ndr_push(push, NDR_OUT, r);
1701         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1702                 talloc_free(r);
1703                 return false;
1704         }
1705
1706         blob = ndr_push_blob(push);
1707         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1708                 talloc_free(r);
1709                 return false;
1710         }
1711
1712         talloc_free(r);
1713
1714         return true;
1715 }
1716
1717 static bool api_srvsvc_NetSrvSetInfo(pipes_struct *p)
1718 {
1719         const struct ndr_interface_call *call;
1720         struct ndr_pull *pull;
1721         struct ndr_push *push;
1722         enum ndr_err_code ndr_err;
1723         DATA_BLOB blob;
1724         struct srvsvc_NetSrvSetInfo *r;
1725
1726         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVSETINFO];
1727
1728         r = talloc(talloc_tos(), struct srvsvc_NetSrvSetInfo);
1729         if (r == NULL) {
1730                 return false;
1731         }
1732
1733         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1734                 talloc_free(r);
1735                 return false;
1736         }
1737
1738         pull = ndr_pull_init_blob(&blob, r, NULL);
1739         if (pull == NULL) {
1740                 talloc_free(r);
1741                 return false;
1742         }
1743
1744         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1745         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1746         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1747                 talloc_free(r);
1748                 return false;
1749         }
1750
1751         if (DEBUGLEVEL >= 10) {
1752                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, r);
1753         }
1754
1755         ZERO_STRUCT(r->out);
1756         r->out.parm_error = r->in.parm_error;
1757         r->out.result = _srvsvc_NetSrvSetInfo(p, r);
1758
1759         if (p->rng_fault_state) {
1760                 talloc_free(r);
1761                 /* Return true here, srv_pipe_hnd.c will take care */
1762                 return true;
1763         }
1764
1765         if (DEBUGLEVEL >= 10) {
1766                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, r);
1767         }
1768
1769         push = ndr_push_init_ctx(r, NULL);
1770         if (push == NULL) {
1771                 talloc_free(r);
1772                 return false;
1773         }
1774
1775         ndr_err = call->ndr_push(push, NDR_OUT, r);
1776         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1777                 talloc_free(r);
1778                 return false;
1779         }
1780
1781         blob = ndr_push_blob(push);
1782         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1783                 talloc_free(r);
1784                 return false;
1785         }
1786
1787         talloc_free(r);
1788
1789         return true;
1790 }
1791
1792 static bool api_srvsvc_NetDiskEnum(pipes_struct *p)
1793 {
1794         const struct ndr_interface_call *call;
1795         struct ndr_pull *pull;
1796         struct ndr_push *push;
1797         enum ndr_err_code ndr_err;
1798         DATA_BLOB blob;
1799         struct srvsvc_NetDiskEnum *r;
1800
1801         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETDISKENUM];
1802
1803         r = talloc(talloc_tos(), struct srvsvc_NetDiskEnum);
1804         if (r == NULL) {
1805                 return false;
1806         }
1807
1808         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1809                 talloc_free(r);
1810                 return false;
1811         }
1812
1813         pull = ndr_pull_init_blob(&blob, r, NULL);
1814         if (pull == NULL) {
1815                 talloc_free(r);
1816                 return false;
1817         }
1818
1819         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1820         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1821         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1822                 talloc_free(r);
1823                 return false;
1824         }
1825
1826         if (DEBUGLEVEL >= 10) {
1827                 NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, r);
1828         }
1829
1830         ZERO_STRUCT(r->out);
1831         r->out.info = r->in.info;
1832         r->out.resume_handle = r->in.resume_handle;
1833         r->out.totalentries = talloc_zero(r, uint32_t);
1834         if (r->out.totalentries == NULL) {
1835                 talloc_free(r);
1836                 return false;
1837         }
1838
1839         r->out.result = _srvsvc_NetDiskEnum(p, r);
1840
1841         if (p->rng_fault_state) {
1842                 talloc_free(r);
1843                 /* Return true here, srv_pipe_hnd.c will take care */
1844                 return true;
1845         }
1846
1847         if (DEBUGLEVEL >= 10) {
1848                 NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, r);
1849         }
1850
1851         push = ndr_push_init_ctx(r, NULL);
1852         if (push == NULL) {
1853                 talloc_free(r);
1854                 return false;
1855         }
1856
1857         ndr_err = call->ndr_push(push, NDR_OUT, r);
1858         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1859                 talloc_free(r);
1860                 return false;
1861         }
1862
1863         blob = ndr_push_blob(push);
1864         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1865                 talloc_free(r);
1866                 return false;
1867         }
1868
1869         talloc_free(r);
1870
1871         return true;
1872 }
1873
1874 static bool api_srvsvc_NetServerStatisticsGet(pipes_struct *p)
1875 {
1876         const struct ndr_interface_call *call;
1877         struct ndr_pull *pull;
1878         struct ndr_push *push;
1879         enum ndr_err_code ndr_err;
1880         DATA_BLOB blob;
1881         struct srvsvc_NetServerStatisticsGet *r;
1882
1883         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSTATISTICSGET];
1884
1885         r = talloc(talloc_tos(), struct srvsvc_NetServerStatisticsGet);
1886         if (r == NULL) {
1887                 return false;
1888         }
1889
1890         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1891                 talloc_free(r);
1892                 return false;
1893         }
1894
1895         pull = ndr_pull_init_blob(&blob, r, NULL);
1896         if (pull == NULL) {
1897                 talloc_free(r);
1898                 return false;
1899         }
1900
1901         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1902         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1903         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1904                 talloc_free(r);
1905                 return false;
1906         }
1907
1908         if (DEBUGLEVEL >= 10) {
1909                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, r);
1910         }
1911
1912         ZERO_STRUCT(r->out);
1913         r->out.stats = talloc_zero(r, struct srvsvc_Statistics *);
1914         if (r->out.stats == NULL) {
1915                 talloc_free(r);
1916                 return false;
1917         }
1918
1919         r->out.result = _srvsvc_NetServerStatisticsGet(p, r);
1920
1921         if (p->rng_fault_state) {
1922                 talloc_free(r);
1923                 /* Return true here, srv_pipe_hnd.c will take care */
1924                 return true;
1925         }
1926
1927         if (DEBUGLEVEL >= 10) {
1928                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, r);
1929         }
1930
1931         push = ndr_push_init_ctx(r, NULL);
1932         if (push == NULL) {
1933                 talloc_free(r);
1934                 return false;
1935         }
1936
1937         ndr_err = call->ndr_push(push, NDR_OUT, r);
1938         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1939                 talloc_free(r);
1940                 return false;
1941         }
1942
1943         blob = ndr_push_blob(push);
1944         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1945                 talloc_free(r);
1946                 return false;
1947         }
1948
1949         talloc_free(r);
1950
1951         return true;
1952 }
1953
1954 static bool api_srvsvc_NetTransportAdd(pipes_struct *p)
1955 {
1956         const struct ndr_interface_call *call;
1957         struct ndr_pull *pull;
1958         struct ndr_push *push;
1959         enum ndr_err_code ndr_err;
1960         DATA_BLOB blob;
1961         struct srvsvc_NetTransportAdd *r;
1962
1963         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTADD];
1964
1965         r = talloc(talloc_tos(), struct srvsvc_NetTransportAdd);
1966         if (r == NULL) {
1967                 return false;
1968         }
1969
1970         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1971                 talloc_free(r);
1972                 return false;
1973         }
1974
1975         pull = ndr_pull_init_blob(&blob, r, NULL);
1976         if (pull == NULL) {
1977                 talloc_free(r);
1978                 return false;
1979         }
1980
1981         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1982         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1983         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1984                 talloc_free(r);
1985                 return false;
1986         }
1987
1988         if (DEBUGLEVEL >= 10) {
1989                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, r);
1990         }
1991
1992         r->out.result = _srvsvc_NetTransportAdd(p, r);
1993
1994         if (p->rng_fault_state) {
1995                 talloc_free(r);
1996                 /* Return true here, srv_pipe_hnd.c will take care */
1997                 return true;
1998         }
1999
2000         if (DEBUGLEVEL >= 10) {
2001                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, r);
2002         }
2003
2004         push = ndr_push_init_ctx(r, NULL);
2005         if (push == NULL) {
2006                 talloc_free(r);
2007                 return false;
2008         }
2009
2010         ndr_err = call->ndr_push(push, NDR_OUT, r);
2011         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2012                 talloc_free(r);
2013                 return false;
2014         }
2015
2016         blob = ndr_push_blob(push);
2017         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2018                 talloc_free(r);
2019                 return false;
2020         }
2021
2022         talloc_free(r);
2023
2024         return true;
2025 }
2026
2027 static bool api_srvsvc_NetTransportEnum(pipes_struct *p)
2028 {
2029         const struct ndr_interface_call *call;
2030         struct ndr_pull *pull;
2031         struct ndr_push *push;
2032         enum ndr_err_code ndr_err;
2033         DATA_BLOB blob;
2034         struct srvsvc_NetTransportEnum *r;
2035
2036         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTENUM];
2037
2038         r = talloc(talloc_tos(), struct srvsvc_NetTransportEnum);
2039         if (r == NULL) {
2040                 return false;
2041         }
2042
2043         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2044                 talloc_free(r);
2045                 return false;
2046         }
2047
2048         pull = ndr_pull_init_blob(&blob, r, NULL);
2049         if (pull == NULL) {
2050                 talloc_free(r);
2051                 return false;
2052         }
2053
2054         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2055         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2056         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2057                 talloc_free(r);
2058                 return false;
2059         }
2060
2061         if (DEBUGLEVEL >= 10) {
2062                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, r);
2063         }
2064
2065         ZERO_STRUCT(r->out);
2066         r->out.transports = r->in.transports;
2067         r->out.resume_handle = r->in.resume_handle;
2068         r->out.totalentries = talloc_zero(r, uint32_t);
2069         if (r->out.totalentries == NULL) {
2070                 talloc_free(r);
2071                 return false;
2072         }
2073
2074         r->out.result = _srvsvc_NetTransportEnum(p, r);
2075
2076         if (p->rng_fault_state) {
2077                 talloc_free(r);
2078                 /* Return true here, srv_pipe_hnd.c will take care */
2079                 return true;
2080         }
2081
2082         if (DEBUGLEVEL >= 10) {
2083                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, r);
2084         }
2085
2086         push = ndr_push_init_ctx(r, NULL);
2087         if (push == NULL) {
2088                 talloc_free(r);
2089                 return false;
2090         }
2091
2092         ndr_err = call->ndr_push(push, NDR_OUT, r);
2093         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2094                 talloc_free(r);
2095                 return false;
2096         }
2097
2098         blob = ndr_push_blob(push);
2099         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2100                 talloc_free(r);
2101                 return false;
2102         }
2103
2104         talloc_free(r);
2105
2106         return true;
2107 }
2108
2109 static bool api_srvsvc_NetTransportDel(pipes_struct *p)
2110 {
2111         const struct ndr_interface_call *call;
2112         struct ndr_pull *pull;
2113         struct ndr_push *push;
2114         enum ndr_err_code ndr_err;
2115         DATA_BLOB blob;
2116         struct srvsvc_NetTransportDel *r;
2117
2118         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTDEL];
2119
2120         r = talloc(talloc_tos(), struct srvsvc_NetTransportDel);
2121         if (r == NULL) {
2122                 return false;
2123         }
2124
2125         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2126                 talloc_free(r);
2127                 return false;
2128         }
2129
2130         pull = ndr_pull_init_blob(&blob, r, NULL);
2131         if (pull == NULL) {
2132                 talloc_free(r);
2133                 return false;
2134         }
2135
2136         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2137         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2138         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2139                 talloc_free(r);
2140                 return false;
2141         }
2142
2143         if (DEBUGLEVEL >= 10) {
2144                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, r);
2145         }
2146
2147         r->out.result = _srvsvc_NetTransportDel(p, r);
2148
2149         if (p->rng_fault_state) {
2150                 talloc_free(r);
2151                 /* Return true here, srv_pipe_hnd.c will take care */
2152                 return true;
2153         }
2154
2155         if (DEBUGLEVEL >= 10) {
2156                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, r);
2157         }
2158
2159         push = ndr_push_init_ctx(r, NULL);
2160         if (push == NULL) {
2161                 talloc_free(r);
2162                 return false;
2163         }
2164
2165         ndr_err = call->ndr_push(push, NDR_OUT, r);
2166         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2167                 talloc_free(r);
2168                 return false;
2169         }
2170
2171         blob = ndr_push_blob(push);
2172         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2173                 talloc_free(r);
2174                 return false;
2175         }
2176
2177         talloc_free(r);
2178
2179         return true;
2180 }
2181
2182 static bool api_srvsvc_NetRemoteTOD(pipes_struct *p)
2183 {
2184         const struct ndr_interface_call *call;
2185         struct ndr_pull *pull;
2186         struct ndr_push *push;
2187         enum ndr_err_code ndr_err;
2188         DATA_BLOB blob;
2189         struct srvsvc_NetRemoteTOD *r;
2190
2191         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETREMOTETOD];
2192
2193         r = talloc(talloc_tos(), struct srvsvc_NetRemoteTOD);
2194         if (r == NULL) {
2195                 return false;
2196         }
2197
2198         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2199                 talloc_free(r);
2200                 return false;
2201         }
2202
2203         pull = ndr_pull_init_blob(&blob, r, NULL);
2204         if (pull == NULL) {
2205                 talloc_free(r);
2206                 return false;
2207         }
2208
2209         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2210         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2211         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2212                 talloc_free(r);
2213                 return false;
2214         }
2215
2216         if (DEBUGLEVEL >= 10) {
2217                 NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, r);
2218         }
2219
2220         ZERO_STRUCT(r->out);
2221         r->out.info = talloc_zero(r, struct srvsvc_NetRemoteTODInfo *);
2222         if (r->out.info == NULL) {
2223                 talloc_free(r);
2224                 return false;
2225         }
2226
2227         r->out.result = _srvsvc_NetRemoteTOD(p, r);
2228
2229         if (p->rng_fault_state) {
2230                 talloc_free(r);
2231                 /* Return true here, srv_pipe_hnd.c will take care */
2232                 return true;
2233         }
2234
2235         if (DEBUGLEVEL >= 10) {
2236                 NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, r);
2237         }
2238
2239         push = ndr_push_init_ctx(r, NULL);
2240         if (push == NULL) {
2241                 talloc_free(r);
2242                 return false;
2243         }
2244
2245         ndr_err = call->ndr_push(push, NDR_OUT, r);
2246         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2247                 talloc_free(r);
2248                 return false;
2249         }
2250
2251         blob = ndr_push_blob(push);
2252         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2253                 talloc_free(r);
2254                 return false;
2255         }
2256
2257         talloc_free(r);
2258
2259         return true;
2260 }
2261
2262 static bool api_srvsvc_NetSetServiceBits(pipes_struct *p)
2263 {
2264         const struct ndr_interface_call *call;
2265         struct ndr_pull *pull;
2266         struct ndr_push *push;
2267         enum ndr_err_code ndr_err;
2268         DATA_BLOB blob;
2269         struct srvsvc_NetSetServiceBits *r;
2270
2271         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETSERVICEBITS];
2272
2273         r = talloc(talloc_tos(), struct srvsvc_NetSetServiceBits);
2274         if (r == NULL) {
2275                 return false;
2276         }
2277
2278         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2279                 talloc_free(r);
2280                 return false;
2281         }
2282
2283         pull = ndr_pull_init_blob(&blob, r, NULL);
2284         if (pull == NULL) {
2285                 talloc_free(r);
2286                 return false;
2287         }
2288
2289         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2290         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2291         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2292                 talloc_free(r);
2293                 return false;
2294         }
2295
2296         if (DEBUGLEVEL >= 10) {
2297                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, r);
2298         }
2299
2300         r->out.result = _srvsvc_NetSetServiceBits(p, r);
2301
2302         if (p->rng_fault_state) {
2303                 talloc_free(r);
2304                 /* Return true here, srv_pipe_hnd.c will take care */
2305                 return true;
2306         }
2307
2308         if (DEBUGLEVEL >= 10) {
2309                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, r);
2310         }
2311
2312         push = ndr_push_init_ctx(r, NULL);
2313         if (push == NULL) {
2314                 talloc_free(r);
2315                 return false;
2316         }
2317
2318         ndr_err = call->ndr_push(push, NDR_OUT, r);
2319         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2320                 talloc_free(r);
2321                 return false;
2322         }
2323
2324         blob = ndr_push_blob(push);
2325         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2326                 talloc_free(r);
2327                 return false;
2328         }
2329
2330         talloc_free(r);
2331
2332         return true;
2333 }
2334
2335 static bool api_srvsvc_NetPathType(pipes_struct *p)
2336 {
2337         const struct ndr_interface_call *call;
2338         struct ndr_pull *pull;
2339         struct ndr_push *push;
2340         enum ndr_err_code ndr_err;
2341         DATA_BLOB blob;
2342         struct srvsvc_NetPathType *r;
2343
2344         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHTYPE];
2345
2346         r = talloc(talloc_tos(), struct srvsvc_NetPathType);
2347         if (r == NULL) {
2348                 return false;
2349         }
2350
2351         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2352                 talloc_free(r);
2353                 return false;
2354         }
2355
2356         pull = ndr_pull_init_blob(&blob, r, NULL);
2357         if (pull == NULL) {
2358                 talloc_free(r);
2359                 return false;
2360         }
2361
2362         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2363         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2364         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2365                 talloc_free(r);
2366                 return false;
2367         }
2368
2369         if (DEBUGLEVEL >= 10) {
2370                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, r);
2371         }
2372
2373         ZERO_STRUCT(r->out);
2374         r->out.pathtype = talloc_zero(r, uint32_t);
2375         if (r->out.pathtype == NULL) {
2376                 talloc_free(r);
2377                 return false;
2378         }
2379
2380         r->out.result = _srvsvc_NetPathType(p, r);
2381
2382         if (p->rng_fault_state) {
2383                 talloc_free(r);
2384                 /* Return true here, srv_pipe_hnd.c will take care */
2385                 return true;
2386         }
2387
2388         if (DEBUGLEVEL >= 10) {
2389                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, r);
2390         }
2391
2392         push = ndr_push_init_ctx(r, NULL);
2393         if (push == NULL) {
2394                 talloc_free(r);
2395                 return false;
2396         }
2397
2398         ndr_err = call->ndr_push(push, NDR_OUT, r);
2399         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2400                 talloc_free(r);
2401                 return false;
2402         }
2403
2404         blob = ndr_push_blob(push);
2405         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2406                 talloc_free(r);
2407                 return false;
2408         }
2409
2410         talloc_free(r);
2411
2412         return true;
2413 }
2414
2415 static bool api_srvsvc_NetPathCanonicalize(pipes_struct *p)
2416 {
2417         const struct ndr_interface_call *call;
2418         struct ndr_pull *pull;
2419         struct ndr_push *push;
2420         enum ndr_err_code ndr_err;
2421         DATA_BLOB blob;
2422         struct srvsvc_NetPathCanonicalize *r;
2423
2424         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCANONICALIZE];
2425
2426         r = talloc(talloc_tos(), struct srvsvc_NetPathCanonicalize);
2427         if (r == NULL) {
2428                 return false;
2429         }
2430
2431         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2432                 talloc_free(r);
2433                 return false;
2434         }
2435
2436         pull = ndr_pull_init_blob(&blob, r, NULL);
2437         if (pull == NULL) {
2438                 talloc_free(r);
2439                 return false;
2440         }
2441
2442         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2443         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2444         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2445                 talloc_free(r);
2446                 return false;
2447         }
2448
2449         if (DEBUGLEVEL >= 10) {
2450                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, r);
2451         }
2452
2453         ZERO_STRUCT(r->out);
2454         r->out.pathtype = r->in.pathtype;
2455         r->out.can_path = talloc_zero_array(r, uint8_t, r->in.maxbuf);
2456         if (r->out.can_path == NULL) {
2457                 talloc_free(r);
2458                 return false;
2459         }
2460
2461         r->out.result = _srvsvc_NetPathCanonicalize(p, r);
2462
2463         if (p->rng_fault_state) {
2464                 talloc_free(r);
2465                 /* Return true here, srv_pipe_hnd.c will take care */
2466                 return true;
2467         }
2468
2469         if (DEBUGLEVEL >= 10) {
2470                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, r);
2471         }
2472
2473         push = ndr_push_init_ctx(r, NULL);
2474         if (push == NULL) {
2475                 talloc_free(r);
2476                 return false;
2477         }
2478
2479         ndr_err = call->ndr_push(push, NDR_OUT, r);
2480         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2481                 talloc_free(r);
2482                 return false;
2483         }
2484
2485         blob = ndr_push_blob(push);
2486         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2487                 talloc_free(r);
2488                 return false;
2489         }
2490
2491         talloc_free(r);
2492
2493         return true;
2494 }
2495
2496 static bool api_srvsvc_NetPathCompare(pipes_struct *p)
2497 {
2498         const struct ndr_interface_call *call;
2499         struct ndr_pull *pull;
2500         struct ndr_push *push;
2501         enum ndr_err_code ndr_err;
2502         DATA_BLOB blob;
2503         struct srvsvc_NetPathCompare *r;
2504
2505         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCOMPARE];
2506
2507         r = talloc(talloc_tos(), struct srvsvc_NetPathCompare);
2508         if (r == NULL) {
2509                 return false;
2510         }
2511
2512         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2513                 talloc_free(r);
2514                 return false;
2515         }
2516
2517         pull = ndr_pull_init_blob(&blob, r, NULL);
2518         if (pull == NULL) {
2519                 talloc_free(r);
2520                 return false;
2521         }
2522
2523         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2524         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2525         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2526                 talloc_free(r);
2527                 return false;
2528         }
2529
2530         if (DEBUGLEVEL >= 10) {
2531                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, r);
2532         }
2533
2534         r->out.result = _srvsvc_NetPathCompare(p, r);
2535
2536         if (p->rng_fault_state) {
2537                 talloc_free(r);
2538                 /* Return true here, srv_pipe_hnd.c will take care */
2539                 return true;
2540         }
2541
2542         if (DEBUGLEVEL >= 10) {
2543                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, r);
2544         }
2545
2546         push = ndr_push_init_ctx(r, NULL);
2547         if (push == NULL) {
2548                 talloc_free(r);
2549                 return false;
2550         }
2551
2552         ndr_err = call->ndr_push(push, NDR_OUT, r);
2553         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2554                 talloc_free(r);
2555                 return false;
2556         }
2557
2558         blob = ndr_push_blob(push);
2559         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2560                 talloc_free(r);
2561                 return false;
2562         }
2563
2564         talloc_free(r);
2565
2566         return true;
2567 }
2568
2569 static bool api_srvsvc_NetNameValidate(pipes_struct *p)
2570 {
2571         const struct ndr_interface_call *call;
2572         struct ndr_pull *pull;
2573         struct ndr_push *push;
2574         enum ndr_err_code ndr_err;
2575         DATA_BLOB blob;
2576         struct srvsvc_NetNameValidate *r;
2577
2578         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETNAMEVALIDATE];
2579
2580         r = talloc(talloc_tos(), struct srvsvc_NetNameValidate);
2581         if (r == NULL) {
2582                 return false;
2583         }
2584
2585         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2586                 talloc_free(r);
2587                 return false;
2588         }
2589
2590         pull = ndr_pull_init_blob(&blob, r, NULL);
2591         if (pull == NULL) {
2592                 talloc_free(r);
2593                 return false;
2594         }
2595
2596         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2597         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2598         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2599                 talloc_free(r);
2600                 return false;
2601         }
2602
2603         if (DEBUGLEVEL >= 10) {
2604                 NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, r);
2605         }
2606
2607         r->out.result = _srvsvc_NetNameValidate(p, r);
2608
2609         if (p->rng_fault_state) {
2610                 talloc_free(r);
2611                 /* Return true here, srv_pipe_hnd.c will take care */
2612                 return true;
2613         }
2614
2615         if (DEBUGLEVEL >= 10) {
2616                 NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, r);
2617         }
2618
2619         push = ndr_push_init_ctx(r, NULL);
2620         if (push == NULL) {
2621                 talloc_free(r);
2622                 return false;
2623         }
2624
2625         ndr_err = call->ndr_push(push, NDR_OUT, r);
2626         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2627                 talloc_free(r);
2628                 return false;
2629         }
2630
2631         blob = ndr_push_blob(push);
2632         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2633                 talloc_free(r);
2634                 return false;
2635         }
2636
2637         talloc_free(r);
2638
2639         return true;
2640 }
2641
2642 static bool api_srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p)
2643 {
2644         const struct ndr_interface_call *call;
2645         struct ndr_pull *pull;
2646         struct ndr_push *push;
2647         enum ndr_err_code ndr_err;
2648         DATA_BLOB blob;
2649         struct srvsvc_NETRPRNAMECANONICALIZE *r;
2650
2651         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRPRNAMECANONICALIZE];
2652
2653         r = talloc(talloc_tos(), struct srvsvc_NETRPRNAMECANONICALIZE);
2654         if (r == NULL) {
2655                 return false;
2656         }
2657
2658         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2659                 talloc_free(r);
2660                 return false;
2661         }
2662
2663         pull = ndr_pull_init_blob(&blob, r, NULL);
2664         if (pull == NULL) {
2665                 talloc_free(r);
2666                 return false;
2667         }
2668
2669         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2670         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2671         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2672                 talloc_free(r);
2673                 return false;
2674         }
2675
2676         if (DEBUGLEVEL >= 10) {
2677                 NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2678         }
2679
2680         r->out.result = _srvsvc_NETRPRNAMECANONICALIZE(p, r);
2681
2682         if (p->rng_fault_state) {
2683                 talloc_free(r);
2684                 /* Return true here, srv_pipe_hnd.c will take care */
2685                 return true;
2686         }
2687
2688         if (DEBUGLEVEL >= 10) {
2689                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2690         }
2691
2692         push = ndr_push_init_ctx(r, NULL);
2693         if (push == NULL) {
2694                 talloc_free(r);
2695                 return false;
2696         }
2697
2698         ndr_err = call->ndr_push(push, NDR_OUT, r);
2699         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2700                 talloc_free(r);
2701                 return false;
2702         }
2703
2704         blob = ndr_push_blob(push);
2705         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2706                 talloc_free(r);
2707                 return false;
2708         }
2709
2710         talloc_free(r);
2711
2712         return true;
2713 }
2714
2715 static bool api_srvsvc_NetPRNameCompare(pipes_struct *p)
2716 {
2717         const struct ndr_interface_call *call;
2718         struct ndr_pull *pull;
2719         struct ndr_push *push;
2720         enum ndr_err_code ndr_err;
2721         DATA_BLOB blob;
2722         struct srvsvc_NetPRNameCompare *r;
2723
2724         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPRNAMECOMPARE];
2725
2726         r = talloc(talloc_tos(), struct srvsvc_NetPRNameCompare);
2727         if (r == NULL) {
2728                 return false;
2729         }
2730
2731         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2732                 talloc_free(r);
2733                 return false;
2734         }
2735
2736         pull = ndr_pull_init_blob(&blob, r, NULL);
2737         if (pull == NULL) {
2738                 talloc_free(r);
2739                 return false;
2740         }
2741
2742         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2743         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2744         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2745                 talloc_free(r);
2746                 return false;
2747         }
2748
2749         if (DEBUGLEVEL >= 10) {
2750                 NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, r);
2751         }
2752
2753         r->out.result = _srvsvc_NetPRNameCompare(p, r);
2754
2755         if (p->rng_fault_state) {
2756                 talloc_free(r);
2757                 /* Return true here, srv_pipe_hnd.c will take care */
2758                 return true;
2759         }
2760
2761         if (DEBUGLEVEL >= 10) {
2762                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, r);
2763         }
2764
2765         push = ndr_push_init_ctx(r, NULL);
2766         if (push == NULL) {
2767                 talloc_free(r);
2768                 return false;
2769         }
2770
2771         ndr_err = call->ndr_push(push, NDR_OUT, r);
2772         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2773                 talloc_free(r);
2774                 return false;
2775         }
2776
2777         blob = ndr_push_blob(push);
2778         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2779                 talloc_free(r);
2780                 return false;
2781         }
2782
2783         talloc_free(r);
2784
2785         return true;
2786 }
2787
2788 static bool api_srvsvc_NetShareEnum(pipes_struct *p)
2789 {
2790         const struct ndr_interface_call *call;
2791         struct ndr_pull *pull;
2792         struct ndr_push *push;
2793         enum ndr_err_code ndr_err;
2794         DATA_BLOB blob;
2795         struct srvsvc_NetShareEnum *r;
2796
2797         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUM];
2798
2799         r = talloc(talloc_tos(), struct srvsvc_NetShareEnum);
2800         if (r == NULL) {
2801                 return false;
2802         }
2803
2804         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2805                 talloc_free(r);
2806                 return false;
2807         }
2808
2809         pull = ndr_pull_init_blob(&blob, r, NULL);
2810         if (pull == NULL) {
2811                 talloc_free(r);
2812                 return false;
2813         }
2814
2815         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2816         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2817         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2818                 talloc_free(r);
2819                 return false;
2820         }
2821
2822         if (DEBUGLEVEL >= 10) {
2823                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, r);
2824         }
2825
2826         ZERO_STRUCT(r->out);
2827         r->out.info_ctr = r->in.info_ctr;
2828         r->out.resume_handle = r->in.resume_handle;
2829         r->out.totalentries = talloc_zero(r, uint32_t);
2830         if (r->out.totalentries == NULL) {
2831                 talloc_free(r);
2832                 return false;
2833         }
2834
2835         r->out.result = _srvsvc_NetShareEnum(p, r);
2836
2837         if (p->rng_fault_state) {
2838                 talloc_free(r);
2839                 /* Return true here, srv_pipe_hnd.c will take care */
2840                 return true;
2841         }
2842
2843         if (DEBUGLEVEL >= 10) {
2844                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, r);
2845         }
2846
2847         push = ndr_push_init_ctx(r, NULL);
2848         if (push == NULL) {
2849                 talloc_free(r);
2850                 return false;
2851         }
2852
2853         ndr_err = call->ndr_push(push, NDR_OUT, r);
2854         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2855                 talloc_free(r);
2856                 return false;
2857         }
2858
2859         blob = ndr_push_blob(push);
2860         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2861                 talloc_free(r);
2862                 return false;
2863         }
2864
2865         talloc_free(r);
2866
2867         return true;
2868 }
2869
2870 static bool api_srvsvc_NetShareDelStart(pipes_struct *p)
2871 {
2872         const struct ndr_interface_call *call;
2873         struct ndr_pull *pull;
2874         struct ndr_push *push;
2875         enum ndr_err_code ndr_err;
2876         DATA_BLOB blob;
2877         struct srvsvc_NetShareDelStart *r;
2878
2879         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTART];
2880
2881         r = talloc(talloc_tos(), struct srvsvc_NetShareDelStart);
2882         if (r == NULL) {
2883                 return false;
2884         }
2885
2886         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2887                 talloc_free(r);
2888                 return false;
2889         }
2890
2891         pull = ndr_pull_init_blob(&blob, r, NULL);
2892         if (pull == NULL) {
2893                 talloc_free(r);
2894                 return false;
2895         }
2896
2897         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2898         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2899         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2900                 talloc_free(r);
2901                 return false;
2902         }
2903
2904         if (DEBUGLEVEL >= 10) {
2905                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, r);
2906         }
2907
2908         ZERO_STRUCT(r->out);
2909         r->out.hnd = talloc_zero(r, struct policy_handle);
2910         if (r->out.hnd == NULL) {
2911                 talloc_free(r);
2912                 return false;
2913         }
2914
2915         r->out.result = _srvsvc_NetShareDelStart(p, r);
2916
2917         if (p->rng_fault_state) {
2918                 talloc_free(r);
2919                 /* Return true here, srv_pipe_hnd.c will take care */
2920                 return true;
2921         }
2922
2923         if (DEBUGLEVEL >= 10) {
2924                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, r);
2925         }
2926
2927         push = ndr_push_init_ctx(r, NULL);
2928         if (push == NULL) {
2929                 talloc_free(r);
2930                 return false;
2931         }
2932
2933         ndr_err = call->ndr_push(push, NDR_OUT, r);
2934         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2935                 talloc_free(r);
2936                 return false;
2937         }
2938
2939         blob = ndr_push_blob(push);
2940         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2941                 talloc_free(r);
2942                 return false;
2943         }
2944
2945         talloc_free(r);
2946
2947         return true;
2948 }
2949
2950 static bool api_srvsvc_NetShareDelCommit(pipes_struct *p)
2951 {
2952         const struct ndr_interface_call *call;
2953         struct ndr_pull *pull;
2954         struct ndr_push *push;
2955         enum ndr_err_code ndr_err;
2956         DATA_BLOB blob;
2957         struct srvsvc_NetShareDelCommit *r;
2958
2959         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELCOMMIT];
2960
2961         r = talloc(talloc_tos(), struct srvsvc_NetShareDelCommit);
2962         if (r == NULL) {
2963                 return false;
2964         }
2965
2966         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2967                 talloc_free(r);
2968                 return false;
2969         }
2970
2971         pull = ndr_pull_init_blob(&blob, r, NULL);
2972         if (pull == NULL) {
2973                 talloc_free(r);
2974                 return false;
2975         }
2976
2977         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2978         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2979         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2980                 talloc_free(r);
2981                 return false;
2982         }
2983
2984         if (DEBUGLEVEL >= 10) {
2985                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, r);
2986         }
2987
2988         ZERO_STRUCT(r->out);
2989         r->out.hnd = r->in.hnd;
2990         r->out.result = _srvsvc_NetShareDelCommit(p, r);
2991
2992         if (p->rng_fault_state) {
2993                 talloc_free(r);
2994                 /* Return true here, srv_pipe_hnd.c will take care */
2995                 return true;
2996         }
2997
2998         if (DEBUGLEVEL >= 10) {
2999                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, r);
3000         }
3001
3002         push = ndr_push_init_ctx(r, NULL);
3003         if (push == NULL) {
3004                 talloc_free(r);
3005                 return false;
3006         }
3007
3008         ndr_err = call->ndr_push(push, NDR_OUT, r);
3009         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3010                 talloc_free(r);
3011                 return false;
3012         }
3013
3014         blob = ndr_push_blob(push);
3015         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3016                 talloc_free(r);
3017                 return false;
3018         }
3019
3020         talloc_free(r);
3021
3022         return true;
3023 }
3024
3025 static bool api_srvsvc_NetGetFileSecurity(pipes_struct *p)
3026 {
3027         const struct ndr_interface_call *call;
3028         struct ndr_pull *pull;
3029         struct ndr_push *push;
3030         enum ndr_err_code ndr_err;
3031         DATA_BLOB blob;
3032         struct srvsvc_NetGetFileSecurity *r;
3033
3034         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETGETFILESECURITY];
3035
3036         r = talloc(talloc_tos(), struct srvsvc_NetGetFileSecurity);
3037         if (r == NULL) {
3038                 return false;
3039         }
3040
3041         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3042                 talloc_free(r);
3043                 return false;
3044         }
3045
3046         pull = ndr_pull_init_blob(&blob, r, NULL);
3047         if (pull == NULL) {
3048                 talloc_free(r);
3049                 return false;
3050         }
3051
3052         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3053         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3054         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3055                 talloc_free(r);
3056                 return false;
3057         }
3058
3059         if (DEBUGLEVEL >= 10) {
3060                 NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, r);
3061         }
3062
3063         ZERO_STRUCT(r->out);
3064         r->out.sd_buf = talloc_zero(r, struct sec_desc_buf *);
3065         if (r->out.sd_buf == NULL) {
3066                 talloc_free(r);
3067                 return false;
3068         }
3069
3070         r->out.result = _srvsvc_NetGetFileSecurity(p, r);
3071
3072         if (p->rng_fault_state) {
3073                 talloc_free(r);
3074                 /* Return true here, srv_pipe_hnd.c will take care */
3075                 return true;
3076         }
3077
3078         if (DEBUGLEVEL >= 10) {
3079                 NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, r);
3080         }
3081
3082         push = ndr_push_init_ctx(r, NULL);
3083         if (push == NULL) {
3084                 talloc_free(r);
3085                 return false;
3086         }
3087
3088         ndr_err = call->ndr_push(push, NDR_OUT, r);
3089         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3090                 talloc_free(r);
3091                 return false;
3092         }
3093
3094         blob = ndr_push_blob(push);
3095         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3096                 talloc_free(r);
3097                 return false;
3098         }
3099
3100         talloc_free(r);
3101
3102         return true;
3103 }
3104
3105 static bool api_srvsvc_NetSetFileSecurity(pipes_struct *p)
3106 {
3107         const struct ndr_interface_call *call;
3108         struct ndr_pull *pull;
3109         struct ndr_push *push;
3110         enum ndr_err_code ndr_err;
3111         DATA_BLOB blob;
3112         struct srvsvc_NetSetFileSecurity *r;
3113
3114         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETFILESECURITY];
3115
3116         r = talloc(talloc_tos(), struct srvsvc_NetSetFileSecurity);
3117         if (r == NULL) {
3118                 return false;
3119         }
3120
3121         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3122                 talloc_free(r);
3123                 return false;
3124         }
3125
3126         pull = ndr_pull_init_blob(&blob, r, NULL);
3127         if (pull == NULL) {
3128                 talloc_free(r);
3129                 return false;
3130         }
3131
3132         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3133         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3134         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3135                 talloc_free(r);
3136                 return false;
3137         }
3138
3139         if (DEBUGLEVEL >= 10) {
3140                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, r);
3141         }
3142
3143         r->out.result = _srvsvc_NetSetFileSecurity(p, r);
3144
3145         if (p->rng_fault_state) {
3146                 talloc_free(r);
3147                 /* Return true here, srv_pipe_hnd.c will take care */
3148                 return true;
3149         }
3150
3151         if (DEBUGLEVEL >= 10) {
3152                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, r);
3153         }
3154
3155         push = ndr_push_init_ctx(r, NULL);
3156         if (push == NULL) {
3157                 talloc_free(r);
3158                 return false;
3159         }
3160
3161         ndr_err = call->ndr_push(push, NDR_OUT, r);
3162         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3163                 talloc_free(r);
3164                 return false;
3165         }
3166
3167         blob = ndr_push_blob(push);
3168         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3169                 talloc_free(r);
3170                 return false;
3171         }
3172
3173         talloc_free(r);
3174
3175         return true;
3176 }
3177
3178 static bool api_srvsvc_NetServerTransportAddEx(pipes_struct *p)
3179 {
3180         const struct ndr_interface_call *call;
3181         struct ndr_pull *pull;
3182         struct ndr_push *push;
3183         enum ndr_err_code ndr_err;
3184         DATA_BLOB blob;
3185         struct srvsvc_NetServerTransportAddEx *r;
3186
3187         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERTRANSPORTADDEX];
3188
3189         r = talloc(talloc_tos(), struct srvsvc_NetServerTransportAddEx);
3190         if (r == NULL) {
3191                 return false;
3192         }
3193
3194         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3195                 talloc_free(r);
3196                 return false;
3197         }
3198
3199         pull = ndr_pull_init_blob(&blob, r, NULL);
3200         if (pull == NULL) {
3201                 talloc_free(r);
3202                 return false;
3203         }
3204
3205         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3206         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3207         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3208                 talloc_free(r);
3209                 return false;
3210         }
3211
3212         if (DEBUGLEVEL >= 10) {
3213                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, r);
3214         }
3215
3216         r->out.result = _srvsvc_NetServerTransportAddEx(p, r);
3217
3218         if (p->rng_fault_state) {
3219                 talloc_free(r);
3220                 /* Return true here, srv_pipe_hnd.c will take care */
3221                 return true;
3222         }
3223
3224         if (DEBUGLEVEL >= 10) {
3225                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, r);
3226         }
3227
3228         push = ndr_push_init_ctx(r, NULL);
3229         if (push == NULL) {
3230                 talloc_free(r);
3231                 return false;
3232         }
3233
3234         ndr_err = call->ndr_push(push, NDR_OUT, r);
3235         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3236                 talloc_free(r);
3237                 return false;
3238         }
3239
3240         blob = ndr_push_blob(push);
3241         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3242                 talloc_free(r);
3243                 return false;
3244         }
3245
3246         talloc_free(r);
3247
3248         return true;
3249 }
3250
3251 static bool api_srvsvc_NetServerSetServiceBitsEx(pipes_struct *p)
3252 {
3253         const struct ndr_interface_call *call;
3254         struct ndr_pull *pull;
3255         struct ndr_push *push;
3256         enum ndr_err_code ndr_err;
3257         DATA_BLOB blob;
3258         struct srvsvc_NetServerSetServiceBitsEx *r;
3259
3260         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSETSERVICEBITSEX];
3261
3262         r = talloc(talloc_tos(), struct srvsvc_NetServerSetServiceBitsEx);
3263         if (r == NULL) {
3264                 return false;
3265         }
3266
3267         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3268                 talloc_free(r);
3269                 return false;
3270         }
3271
3272         pull = ndr_pull_init_blob(&blob, r, NULL);
3273         if (pull == NULL) {
3274                 talloc_free(r);
3275                 return false;
3276         }
3277
3278         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3279         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3280         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3281                 talloc_free(r);
3282                 return false;
3283         }
3284
3285         if (DEBUGLEVEL >= 10) {
3286                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3287         }
3288
3289         r->out.result = _srvsvc_NetServerSetServiceBitsEx(p, r);
3290
3291         if (p->rng_fault_state) {
3292                 talloc_free(r);
3293                 /* Return true here, srv_pipe_hnd.c will take care */
3294                 return true;
3295         }
3296
3297         if (DEBUGLEVEL >= 10) {
3298                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3299         }
3300
3301         push = ndr_push_init_ctx(r, NULL);
3302         if (push == NULL) {
3303                 talloc_free(r);
3304                 return false;
3305         }
3306
3307         ndr_err = call->ndr_push(push, NDR_OUT, r);