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