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