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