source: branches/samba-3.5.x/librpc/gen_ndr/srv_samr.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 134.7 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "../librpc/gen_ndr/srv_samr.h"
8
9static bool api_samr_Connect(pipes_struct *p)
10{
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct samr_Connect *r;
17
18 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT];
19
20 r = talloc(talloc_tos(), struct samr_Connect);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r, NULL);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(samr_Connect, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.connect_handle = talloc_zero(r, struct policy_handle);
49 if (r->out.connect_handle == NULL) {
50 talloc_free(r);
51 return false;
52 }
53
54 r->out.result = _samr_Connect(p, r);
55
56 if (p->rng_fault_state) {
57 talloc_free(r);
58 /* Return true here, srv_pipe_hnd.c will take care */
59 return true;
60 }
61
62 if (DEBUGLEVEL >= 10) {
63 NDR_PRINT_OUT_DEBUG(samr_Connect, r);
64 }
65
66 push = ndr_push_init_ctx(r, NULL);
67 if (push == NULL) {
68 talloc_free(r);
69 return false;
70 }
71
72 ndr_err = call->ndr_push(push, NDR_OUT, r);
73 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
74 talloc_free(r);
75 return false;
76 }
77
78 blob = ndr_push_blob(push);
79 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
80 talloc_free(r);
81 return false;
82 }
83
84 talloc_free(r);
85
86 return true;
87}
88
89static bool api_samr_Close(pipes_struct *p)
90{
91 const struct ndr_interface_call *call;
92 struct ndr_pull *pull;
93 struct ndr_push *push;
94 enum ndr_err_code ndr_err;
95 DATA_BLOB blob;
96 struct samr_Close *r;
97
98 call = &ndr_table_samr.calls[NDR_SAMR_CLOSE];
99
100 r = talloc(talloc_tos(), struct samr_Close);
101 if (r == NULL) {
102 return false;
103 }
104
105 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
106 talloc_free(r);
107 return false;
108 }
109
110 pull = ndr_pull_init_blob(&blob, r, NULL);
111 if (pull == NULL) {
112 talloc_free(r);
113 return false;
114 }
115
116 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
117 ndr_err = call->ndr_pull(pull, NDR_IN, r);
118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
119 talloc_free(r);
120 return false;
121 }
122
123 if (DEBUGLEVEL >= 10) {
124 NDR_PRINT_IN_DEBUG(samr_Close, r);
125 }
126
127 ZERO_STRUCT(r->out);
128 r->out.handle = r->in.handle;
129 r->out.result = _samr_Close(p, r);
130
131 if (p->rng_fault_state) {
132 talloc_free(r);
133 /* Return true here, srv_pipe_hnd.c will take care */
134 return true;
135 }
136
137 if (DEBUGLEVEL >= 10) {
138 NDR_PRINT_OUT_DEBUG(samr_Close, r);
139 }
140
141 push = ndr_push_init_ctx(r, NULL);
142 if (push == NULL) {
143 talloc_free(r);
144 return false;
145 }
146
147 ndr_err = call->ndr_push(push, NDR_OUT, r);
148 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
149 talloc_free(r);
150 return false;
151 }
152
153 blob = ndr_push_blob(push);
154 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
155 talloc_free(r);
156 return false;
157 }
158
159 talloc_free(r);
160
161 return true;
162}
163
164static bool api_samr_SetSecurity(pipes_struct *p)
165{
166 const struct ndr_interface_call *call;
167 struct ndr_pull *pull;
168 struct ndr_push *push;
169 enum ndr_err_code ndr_err;
170 DATA_BLOB blob;
171 struct samr_SetSecurity *r;
172
173 call = &ndr_table_samr.calls[NDR_SAMR_SETSECURITY];
174
175 r = talloc(talloc_tos(), struct samr_SetSecurity);
176 if (r == NULL) {
177 return false;
178 }
179
180 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
181 talloc_free(r);
182 return false;
183 }
184
185 pull = ndr_pull_init_blob(&blob, r, NULL);
186 if (pull == NULL) {
187 talloc_free(r);
188 return false;
189 }
190
191 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
192 ndr_err = call->ndr_pull(pull, NDR_IN, r);
193 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
194 talloc_free(r);
195 return false;
196 }
197
198 if (DEBUGLEVEL >= 10) {
199 NDR_PRINT_IN_DEBUG(samr_SetSecurity, r);
200 }
201
202 r->out.result = _samr_SetSecurity(p, r);
203
204 if (p->rng_fault_state) {
205 talloc_free(r);
206 /* Return true here, srv_pipe_hnd.c will take care */
207 return true;
208 }
209
210 if (DEBUGLEVEL >= 10) {
211 NDR_PRINT_OUT_DEBUG(samr_SetSecurity, r);
212 }
213
214 push = ndr_push_init_ctx(r, NULL);
215 if (push == NULL) {
216 talloc_free(r);
217 return false;
218 }
219
220 ndr_err = call->ndr_push(push, NDR_OUT, r);
221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
222 talloc_free(r);
223 return false;
224 }
225
226 blob = ndr_push_blob(push);
227 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
228 talloc_free(r);
229 return false;
230 }
231
232 talloc_free(r);
233
234 return true;
235}
236
237static bool api_samr_QuerySecurity(pipes_struct *p)
238{
239 const struct ndr_interface_call *call;
240 struct ndr_pull *pull;
241 struct ndr_push *push;
242 enum ndr_err_code ndr_err;
243 DATA_BLOB blob;
244 struct samr_QuerySecurity *r;
245
246 call = &ndr_table_samr.calls[NDR_SAMR_QUERYSECURITY];
247
248 r = talloc(talloc_tos(), struct samr_QuerySecurity);
249 if (r == NULL) {
250 return false;
251 }
252
253 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
254 talloc_free(r);
255 return false;
256 }
257
258 pull = ndr_pull_init_blob(&blob, r, NULL);
259 if (pull == NULL) {
260 talloc_free(r);
261 return false;
262 }
263
264 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
265 ndr_err = call->ndr_pull(pull, NDR_IN, r);
266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
267 talloc_free(r);
268 return false;
269 }
270
271 if (DEBUGLEVEL >= 10) {
272 NDR_PRINT_IN_DEBUG(samr_QuerySecurity, r);
273 }
274
275 ZERO_STRUCT(r->out);
276 r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
277 if (r->out.sdbuf == NULL) {
278 talloc_free(r);
279 return false;
280 }
281
282 r->out.result = _samr_QuerySecurity(p, r);
283
284 if (p->rng_fault_state) {
285 talloc_free(r);
286 /* Return true here, srv_pipe_hnd.c will take care */
287 return true;
288 }
289
290 if (DEBUGLEVEL >= 10) {
291 NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, r);
292 }
293
294 push = ndr_push_init_ctx(r, NULL);
295 if (push == NULL) {
296 talloc_free(r);
297 return false;
298 }
299
300 ndr_err = call->ndr_push(push, NDR_OUT, r);
301 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
302 talloc_free(r);
303 return false;
304 }
305
306 blob = ndr_push_blob(push);
307 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
308 talloc_free(r);
309 return false;
310 }
311
312 talloc_free(r);
313
314 return true;
315}
316
317static bool api_samr_Shutdown(pipes_struct *p)
318{
319 const struct ndr_interface_call *call;
320 struct ndr_pull *pull;
321 struct ndr_push *push;
322 enum ndr_err_code ndr_err;
323 DATA_BLOB blob;
324 struct samr_Shutdown *r;
325
326 call = &ndr_table_samr.calls[NDR_SAMR_SHUTDOWN];
327
328 r = talloc(talloc_tos(), struct samr_Shutdown);
329 if (r == NULL) {
330 return false;
331 }
332
333 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
334 talloc_free(r);
335 return false;
336 }
337
338 pull = ndr_pull_init_blob(&blob, r, NULL);
339 if (pull == NULL) {
340 talloc_free(r);
341 return false;
342 }
343
344 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
345 ndr_err = call->ndr_pull(pull, NDR_IN, r);
346 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
347 talloc_free(r);
348 return false;
349 }
350
351 if (DEBUGLEVEL >= 10) {
352 NDR_PRINT_IN_DEBUG(samr_Shutdown, r);
353 }
354
355 r->out.result = _samr_Shutdown(p, r);
356
357 if (p->rng_fault_state) {
358 talloc_free(r);
359 /* Return true here, srv_pipe_hnd.c will take care */
360 return true;
361 }
362
363 if (DEBUGLEVEL >= 10) {
364 NDR_PRINT_OUT_DEBUG(samr_Shutdown, r);
365 }
366
367 push = ndr_push_init_ctx(r, NULL);
368 if (push == NULL) {
369 talloc_free(r);
370 return false;
371 }
372
373 ndr_err = call->ndr_push(push, NDR_OUT, r);
374 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
375 talloc_free(r);
376 return false;
377 }
378
379 blob = ndr_push_blob(push);
380 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
381 talloc_free(r);
382 return false;
383 }
384
385 talloc_free(r);
386
387 return true;
388}
389
390static bool api_samr_LookupDomain(pipes_struct *p)
391{
392 const struct ndr_interface_call *call;
393 struct ndr_pull *pull;
394 struct ndr_push *push;
395 enum ndr_err_code ndr_err;
396 DATA_BLOB blob;
397 struct samr_LookupDomain *r;
398
399 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPDOMAIN];
400
401 r = talloc(talloc_tos(), struct samr_LookupDomain);
402 if (r == NULL) {
403 return false;
404 }
405
406 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
407 talloc_free(r);
408 return false;
409 }
410
411 pull = ndr_pull_init_blob(&blob, r, NULL);
412 if (pull == NULL) {
413 talloc_free(r);
414 return false;
415 }
416
417 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
418 ndr_err = call->ndr_pull(pull, NDR_IN, r);
419 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
420 talloc_free(r);
421 return false;
422 }
423
424 if (DEBUGLEVEL >= 10) {
425 NDR_PRINT_IN_DEBUG(samr_LookupDomain, r);
426 }
427
428 ZERO_STRUCT(r->out);
429 r->out.sid = talloc_zero(r, struct dom_sid2 *);
430 if (r->out.sid == NULL) {
431 talloc_free(r);
432 return false;
433 }
434
435 r->out.result = _samr_LookupDomain(p, r);
436
437 if (p->rng_fault_state) {
438 talloc_free(r);
439 /* Return true here, srv_pipe_hnd.c will take care */
440 return true;
441 }
442
443 if (DEBUGLEVEL >= 10) {
444 NDR_PRINT_OUT_DEBUG(samr_LookupDomain, r);
445 }
446
447 push = ndr_push_init_ctx(r, NULL);
448 if (push == NULL) {
449 talloc_free(r);
450 return false;
451 }
452
453 ndr_err = call->ndr_push(push, NDR_OUT, r);
454 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
455 talloc_free(r);
456 return false;
457 }
458
459 blob = ndr_push_blob(push);
460 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
461 talloc_free(r);
462 return false;
463 }
464
465 talloc_free(r);
466
467 return true;
468}
469
470static bool api_samr_EnumDomains(pipes_struct *p)
471{
472 const struct ndr_interface_call *call;
473 struct ndr_pull *pull;
474 struct ndr_push *push;
475 enum ndr_err_code ndr_err;
476 DATA_BLOB blob;
477 struct samr_EnumDomains *r;
478
479 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINS];
480
481 r = talloc(talloc_tos(), struct samr_EnumDomains);
482 if (r == NULL) {
483 return false;
484 }
485
486 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
487 talloc_free(r);
488 return false;
489 }
490
491 pull = ndr_pull_init_blob(&blob, r, NULL);
492 if (pull == NULL) {
493 talloc_free(r);
494 return false;
495 }
496
497 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
498 ndr_err = call->ndr_pull(pull, NDR_IN, r);
499 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
500 talloc_free(r);
501 return false;
502 }
503
504 if (DEBUGLEVEL >= 10) {
505 NDR_PRINT_IN_DEBUG(samr_EnumDomains, r);
506 }
507
508 ZERO_STRUCT(r->out);
509 r->out.resume_handle = r->in.resume_handle;
510 r->out.sam = talloc_zero(r, struct samr_SamArray *);
511 if (r->out.sam == NULL) {
512 talloc_free(r);
513 return false;
514 }
515
516 r->out.num_entries = talloc_zero(r, uint32_t);
517 if (r->out.num_entries == NULL) {
518 talloc_free(r);
519 return false;
520 }
521
522 r->out.result = _samr_EnumDomains(p, r);
523
524 if (p->rng_fault_state) {
525 talloc_free(r);
526 /* Return true here, srv_pipe_hnd.c will take care */
527 return true;
528 }
529
530 if (DEBUGLEVEL >= 10) {
531 NDR_PRINT_OUT_DEBUG(samr_EnumDomains, r);
532 }
533
534 push = ndr_push_init_ctx(r, NULL);
535 if (push == NULL) {
536 talloc_free(r);
537 return false;
538 }
539
540 ndr_err = call->ndr_push(push, NDR_OUT, r);
541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
542 talloc_free(r);
543 return false;
544 }
545
546 blob = ndr_push_blob(push);
547 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
548 talloc_free(r);
549 return false;
550 }
551
552 talloc_free(r);
553
554 return true;
555}
556
557static bool api_samr_OpenDomain(pipes_struct *p)
558{
559 const struct ndr_interface_call *call;
560 struct ndr_pull *pull;
561 struct ndr_push *push;
562 enum ndr_err_code ndr_err;
563 DATA_BLOB blob;
564 struct samr_OpenDomain *r;
565
566 call = &ndr_table_samr.calls[NDR_SAMR_OPENDOMAIN];
567
568 r = talloc(talloc_tos(), struct samr_OpenDomain);
569 if (r == NULL) {
570 return false;
571 }
572
573 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
574 talloc_free(r);
575 return false;
576 }
577
578 pull = ndr_pull_init_blob(&blob, r, NULL);
579 if (pull == NULL) {
580 talloc_free(r);
581 return false;
582 }
583
584 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
585 ndr_err = call->ndr_pull(pull, NDR_IN, r);
586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
587 talloc_free(r);
588 return false;
589 }
590
591 if (DEBUGLEVEL >= 10) {
592 NDR_PRINT_IN_DEBUG(samr_OpenDomain, r);
593 }
594
595 ZERO_STRUCT(r->out);
596 r->out.domain_handle = talloc_zero(r, struct policy_handle);
597 if (r->out.domain_handle == NULL) {
598 talloc_free(r);
599 return false;
600 }
601
602 r->out.result = _samr_OpenDomain(p, r);
603
604 if (p->rng_fault_state) {
605 talloc_free(r);
606 /* Return true here, srv_pipe_hnd.c will take care */
607 return true;
608 }
609
610 if (DEBUGLEVEL >= 10) {
611 NDR_PRINT_OUT_DEBUG(samr_OpenDomain, r);
612 }
613
614 push = ndr_push_init_ctx(r, NULL);
615 if (push == NULL) {
616 talloc_free(r);
617 return false;
618 }
619
620 ndr_err = call->ndr_push(push, NDR_OUT, r);
621 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
622 talloc_free(r);
623 return false;
624 }
625
626 blob = ndr_push_blob(push);
627 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
628 talloc_free(r);
629 return false;
630 }
631
632 talloc_free(r);
633
634 return true;
635}
636
637static bool api_samr_QueryDomainInfo(pipes_struct *p)
638{
639 const struct ndr_interface_call *call;
640 struct ndr_pull *pull;
641 struct ndr_push *push;
642 enum ndr_err_code ndr_err;
643 DATA_BLOB blob;
644 struct samr_QueryDomainInfo *r;
645
646 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO];
647
648 r = talloc(talloc_tos(), struct samr_QueryDomainInfo);
649 if (r == NULL) {
650 return false;
651 }
652
653 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
654 talloc_free(r);
655 return false;
656 }
657
658 pull = ndr_pull_init_blob(&blob, r, NULL);
659 if (pull == NULL) {
660 talloc_free(r);
661 return false;
662 }
663
664 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
665 ndr_err = call->ndr_pull(pull, NDR_IN, r);
666 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
667 talloc_free(r);
668 return false;
669 }
670
671 if (DEBUGLEVEL >= 10) {
672 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, r);
673 }
674
675 ZERO_STRUCT(r->out);
676 r->out.info = talloc_zero(r, union samr_DomainInfo *);
677 if (r->out.info == NULL) {
678 talloc_free(r);
679 return false;
680 }
681
682 r->out.result = _samr_QueryDomainInfo(p, r);
683
684 if (p->rng_fault_state) {
685 talloc_free(r);
686 /* Return true here, srv_pipe_hnd.c will take care */
687 return true;
688 }
689
690 if (DEBUGLEVEL >= 10) {
691 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, r);
692 }
693
694 push = ndr_push_init_ctx(r, NULL);
695 if (push == NULL) {
696 talloc_free(r);
697 return false;
698 }
699
700 ndr_err = call->ndr_push(push, NDR_OUT, r);
701 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
702 talloc_free(r);
703 return false;
704 }
705
706 blob = ndr_push_blob(push);
707 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
708 talloc_free(r);
709 return false;
710 }
711
712 talloc_free(r);
713
714 return true;
715}
716
717static bool api_samr_SetDomainInfo(pipes_struct *p)
718{
719 const struct ndr_interface_call *call;
720 struct ndr_pull *pull;
721 struct ndr_push *push;
722 enum ndr_err_code ndr_err;
723 DATA_BLOB blob;
724 struct samr_SetDomainInfo *r;
725
726 call = &ndr_table_samr.calls[NDR_SAMR_SETDOMAININFO];
727
728 r = talloc(talloc_tos(), struct samr_SetDomainInfo);
729 if (r == NULL) {
730 return false;
731 }
732
733 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
734 talloc_free(r);
735 return false;
736 }
737
738 pull = ndr_pull_init_blob(&blob, r, NULL);
739 if (pull == NULL) {
740 talloc_free(r);
741 return false;
742 }
743
744 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
745 ndr_err = call->ndr_pull(pull, NDR_IN, r);
746 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
747 talloc_free(r);
748 return false;
749 }
750
751 if (DEBUGLEVEL >= 10) {
752 NDR_PRINT_IN_DEBUG(samr_SetDomainInfo, r);
753 }
754
755 r->out.result = _samr_SetDomainInfo(p, r);
756
757 if (p->rng_fault_state) {
758 talloc_free(r);
759 /* Return true here, srv_pipe_hnd.c will take care */
760 return true;
761 }
762
763 if (DEBUGLEVEL >= 10) {
764 NDR_PRINT_OUT_DEBUG(samr_SetDomainInfo, r);
765 }
766
767 push = ndr_push_init_ctx(r, NULL);
768 if (push == NULL) {
769 talloc_free(r);
770 return false;
771 }
772
773 ndr_err = call->ndr_push(push, NDR_OUT, r);
774 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
775 talloc_free(r);
776 return false;
777 }
778
779 blob = ndr_push_blob(push);
780 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
781 talloc_free(r);
782 return false;
783 }
784
785 talloc_free(r);
786
787 return true;
788}
789
790static bool api_samr_CreateDomainGroup(pipes_struct *p)
791{
792 const struct ndr_interface_call *call;
793 struct ndr_pull *pull;
794 struct ndr_push *push;
795 enum ndr_err_code ndr_err;
796 DATA_BLOB blob;
797 struct samr_CreateDomainGroup *r;
798
799 call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMAINGROUP];
800
801 r = talloc(talloc_tos(), struct samr_CreateDomainGroup);
802 if (r == NULL) {
803 return false;
804 }
805
806 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
807 talloc_free(r);
808 return false;
809 }
810
811 pull = ndr_pull_init_blob(&blob, r, NULL);
812 if (pull == NULL) {
813 talloc_free(r);
814 return false;
815 }
816
817 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
818 ndr_err = call->ndr_pull(pull, NDR_IN, r);
819 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
820 talloc_free(r);
821 return false;
822 }
823
824 if (DEBUGLEVEL >= 10) {
825 NDR_PRINT_IN_DEBUG(samr_CreateDomainGroup, r);
826 }
827
828 ZERO_STRUCT(r->out);
829 r->out.group_handle = talloc_zero(r, struct policy_handle);
830 if (r->out.group_handle == NULL) {
831 talloc_free(r);
832 return false;
833 }
834
835 r->out.rid = talloc_zero(r, uint32_t);
836 if (r->out.rid == NULL) {
837 talloc_free(r);
838 return false;
839 }
840
841 r->out.result = _samr_CreateDomainGroup(p, r);
842
843 if (p->rng_fault_state) {
844 talloc_free(r);
845 /* Return true here, srv_pipe_hnd.c will take care */
846 return true;
847 }
848
849 if (DEBUGLEVEL >= 10) {
850 NDR_PRINT_OUT_DEBUG(samr_CreateDomainGroup, r);
851 }
852
853 push = ndr_push_init_ctx(r, NULL);
854 if (push == NULL) {
855 talloc_free(r);
856 return false;
857 }
858
859 ndr_err = call->ndr_push(push, NDR_OUT, r);
860 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
861 talloc_free(r);
862 return false;
863 }
864
865 blob = ndr_push_blob(push);
866 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
867 talloc_free(r);
868 return false;
869 }
870
871 talloc_free(r);
872
873 return true;
874}
875
876static bool api_samr_EnumDomainGroups(pipes_struct *p)
877{
878 const struct ndr_interface_call *call;
879 struct ndr_pull *pull;
880 struct ndr_push *push;
881 enum ndr_err_code ndr_err;
882 DATA_BLOB blob;
883 struct samr_EnumDomainGroups *r;
884
885 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINGROUPS];
886
887 r = talloc(talloc_tos(), struct samr_EnumDomainGroups);
888 if (r == NULL) {
889 return false;
890 }
891
892 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
893 talloc_free(r);
894 return false;
895 }
896
897 pull = ndr_pull_init_blob(&blob, r, NULL);
898 if (pull == NULL) {
899 talloc_free(r);
900 return false;
901 }
902
903 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
904 ndr_err = call->ndr_pull(pull, NDR_IN, r);
905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
906 talloc_free(r);
907 return false;
908 }
909
910 if (DEBUGLEVEL >= 10) {
911 NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, r);
912 }
913
914 ZERO_STRUCT(r->out);
915 r->out.resume_handle = r->in.resume_handle;
916 r->out.sam = talloc_zero(r, struct samr_SamArray *);
917 if (r->out.sam == NULL) {
918 talloc_free(r);
919 return false;
920 }
921
922 r->out.num_entries = talloc_zero(r, uint32_t);
923 if (r->out.num_entries == NULL) {
924 talloc_free(r);
925 return false;
926 }
927
928 r->out.result = _samr_EnumDomainGroups(p, r);
929
930 if (p->rng_fault_state) {
931 talloc_free(r);
932 /* Return true here, srv_pipe_hnd.c will take care */
933 return true;
934 }
935
936 if (DEBUGLEVEL >= 10) {
937 NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, r);
938 }
939
940 push = ndr_push_init_ctx(r, NULL);
941 if (push == NULL) {
942 talloc_free(r);
943 return false;
944 }
945
946 ndr_err = call->ndr_push(push, NDR_OUT, r);
947 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
948 talloc_free(r);
949 return false;
950 }
951
952 blob = ndr_push_blob(push);
953 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
954 talloc_free(r);
955 return false;
956 }
957
958 talloc_free(r);
959
960 return true;
961}
962
963static bool api_samr_CreateUser(pipes_struct *p)
964{
965 const struct ndr_interface_call *call;
966 struct ndr_pull *pull;
967 struct ndr_push *push;
968 enum ndr_err_code ndr_err;
969 DATA_BLOB blob;
970 struct samr_CreateUser *r;
971
972 call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER];
973
974 r = talloc(talloc_tos(), struct samr_CreateUser);
975 if (r == NULL) {
976 return false;
977 }
978
979 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
980 talloc_free(r);
981 return false;
982 }
983
984 pull = ndr_pull_init_blob(&blob, r, NULL);
985 if (pull == NULL) {
986 talloc_free(r);
987 return false;
988 }
989
990 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
991 ndr_err = call->ndr_pull(pull, NDR_IN, r);
992 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
993 talloc_free(r);
994 return false;
995 }
996
997 if (DEBUGLEVEL >= 10) {
998 NDR_PRINT_IN_DEBUG(samr_CreateUser, r);
999 }
1000
1001 ZERO_STRUCT(r->out);
1002 r->out.user_handle = talloc_zero(r, struct policy_handle);
1003 if (r->out.user_handle == NULL) {
1004 talloc_free(r);
1005 return false;
1006 }
1007
1008 r->out.rid = talloc_zero(r, uint32_t);
1009 if (r->out.rid == NULL) {
1010 talloc_free(r);
1011 return false;
1012 }
1013
1014 r->out.result = _samr_CreateUser(p, r);
1015
1016 if (p->rng_fault_state) {
1017 talloc_free(r);
1018 /* Return true here, srv_pipe_hnd.c will take care */
1019 return true;
1020 }
1021
1022 if (DEBUGLEVEL >= 10) {
1023 NDR_PRINT_OUT_DEBUG(samr_CreateUser, r);
1024 }
1025
1026 push = ndr_push_init_ctx(r, NULL);
1027 if (push == NULL) {
1028 talloc_free(r);
1029 return false;
1030 }
1031
1032 ndr_err = call->ndr_push(push, NDR_OUT, r);
1033 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1034 talloc_free(r);
1035 return false;
1036 }
1037
1038 blob = ndr_push_blob(push);
1039 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1040 talloc_free(r);
1041 return false;
1042 }
1043
1044 talloc_free(r);
1045
1046 return true;
1047}
1048
1049static bool api_samr_EnumDomainUsers(pipes_struct *p)
1050{
1051 const struct ndr_interface_call *call;
1052 struct ndr_pull *pull;
1053 struct ndr_push *push;
1054 enum ndr_err_code ndr_err;
1055 DATA_BLOB blob;
1056 struct samr_EnumDomainUsers *r;
1057
1058 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINUSERS];
1059
1060 r = talloc(talloc_tos(), struct samr_EnumDomainUsers);
1061 if (r == NULL) {
1062 return false;
1063 }
1064
1065 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1066 talloc_free(r);
1067 return false;
1068 }
1069
1070 pull = ndr_pull_init_blob(&blob, r, NULL);
1071 if (pull == NULL) {
1072 talloc_free(r);
1073 return false;
1074 }
1075
1076 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1077 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1078 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1079 talloc_free(r);
1080 return false;
1081 }
1082
1083 if (DEBUGLEVEL >= 10) {
1084 NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, r);
1085 }
1086
1087 ZERO_STRUCT(r->out);
1088 r->out.resume_handle = r->in.resume_handle;
1089 r->out.sam = talloc_zero(r, struct samr_SamArray *);
1090 if (r->out.sam == NULL) {
1091 talloc_free(r);
1092 return false;
1093 }
1094
1095 r->out.num_entries = talloc_zero(r, uint32_t);
1096 if (r->out.num_entries == NULL) {
1097 talloc_free(r);
1098 return false;
1099 }
1100
1101 r->out.result = _samr_EnumDomainUsers(p, r);
1102
1103 if (p->rng_fault_state) {
1104 talloc_free(r);
1105 /* Return true here, srv_pipe_hnd.c will take care */
1106 return true;
1107 }
1108
1109 if (DEBUGLEVEL >= 10) {
1110 NDR_PRINT_OUT_DEBUG(samr_EnumDomainUsers, r);
1111 }
1112
1113 push = ndr_push_init_ctx(r, NULL);
1114 if (push == NULL) {
1115 talloc_free(r);
1116 return false;
1117 }
1118
1119 ndr_err = call->ndr_push(push, NDR_OUT, r);
1120 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1121 talloc_free(r);
1122 return false;
1123 }
1124
1125 blob = ndr_push_blob(push);
1126 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1127 talloc_free(r);
1128 return false;
1129 }
1130
1131 talloc_free(r);
1132
1133 return true;
1134}
1135
1136static bool api_samr_CreateDomAlias(pipes_struct *p)
1137{
1138 const struct ndr_interface_call *call;
1139 struct ndr_pull *pull;
1140 struct ndr_push *push;
1141 enum ndr_err_code ndr_err;
1142 DATA_BLOB blob;
1143 struct samr_CreateDomAlias *r;
1144
1145 call = &ndr_table_samr.calls[NDR_SAMR_CREATEDOMALIAS];
1146
1147 r = talloc(talloc_tos(), struct samr_CreateDomAlias);
1148 if (r == NULL) {
1149 return false;
1150 }
1151
1152 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1153 talloc_free(r);
1154 return false;
1155 }
1156
1157 pull = ndr_pull_init_blob(&blob, r, NULL);
1158 if (pull == NULL) {
1159 talloc_free(r);
1160 return false;
1161 }
1162
1163 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1164 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1166 talloc_free(r);
1167 return false;
1168 }
1169
1170 if (DEBUGLEVEL >= 10) {
1171 NDR_PRINT_IN_DEBUG(samr_CreateDomAlias, r);
1172 }
1173
1174 ZERO_STRUCT(r->out);
1175 r->out.alias_handle = talloc_zero(r, struct policy_handle);
1176 if (r->out.alias_handle == NULL) {
1177 talloc_free(r);
1178 return false;
1179 }
1180
1181 r->out.rid = talloc_zero(r, uint32_t);
1182 if (r->out.rid == NULL) {
1183 talloc_free(r);
1184 return false;
1185 }
1186
1187 r->out.result = _samr_CreateDomAlias(p, r);
1188
1189 if (p->rng_fault_state) {
1190 talloc_free(r);
1191 /* Return true here, srv_pipe_hnd.c will take care */
1192 return true;
1193 }
1194
1195 if (DEBUGLEVEL >= 10) {
1196 NDR_PRINT_OUT_DEBUG(samr_CreateDomAlias, r);
1197 }
1198
1199 push = ndr_push_init_ctx(r, NULL);
1200 if (push == NULL) {
1201 talloc_free(r);
1202 return false;
1203 }
1204
1205 ndr_err = call->ndr_push(push, NDR_OUT, r);
1206 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1207 talloc_free(r);
1208 return false;
1209 }
1210
1211 blob = ndr_push_blob(push);
1212 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1213 talloc_free(r);
1214 return false;
1215 }
1216
1217 talloc_free(r);
1218
1219 return true;
1220}
1221
1222static bool api_samr_EnumDomainAliases(pipes_struct *p)
1223{
1224 const struct ndr_interface_call *call;
1225 struct ndr_pull *pull;
1226 struct ndr_push *push;
1227 enum ndr_err_code ndr_err;
1228 DATA_BLOB blob;
1229 struct samr_EnumDomainAliases *r;
1230
1231 call = &ndr_table_samr.calls[NDR_SAMR_ENUMDOMAINALIASES];
1232
1233 r = talloc(talloc_tos(), struct samr_EnumDomainAliases);
1234 if (r == NULL) {
1235 return false;
1236 }
1237
1238 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1239 talloc_free(r);
1240 return false;
1241 }
1242
1243 pull = ndr_pull_init_blob(&blob, r, NULL);
1244 if (pull == NULL) {
1245 talloc_free(r);
1246 return false;
1247 }
1248
1249 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1250 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1251 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1252 talloc_free(r);
1253 return false;
1254 }
1255
1256 if (DEBUGLEVEL >= 10) {
1257 NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, r);
1258 }
1259
1260 ZERO_STRUCT(r->out);
1261 r->out.resume_handle = r->in.resume_handle;
1262 r->out.sam = talloc_zero(r, struct samr_SamArray *);
1263 if (r->out.sam == NULL) {
1264 talloc_free(r);
1265 return false;
1266 }
1267
1268 r->out.num_entries = talloc_zero(r, uint32_t);
1269 if (r->out.num_entries == NULL) {
1270 talloc_free(r);
1271 return false;
1272 }
1273
1274 r->out.result = _samr_EnumDomainAliases(p, r);
1275
1276 if (p->rng_fault_state) {
1277 talloc_free(r);
1278 /* Return true here, srv_pipe_hnd.c will take care */
1279 return true;
1280 }
1281
1282 if (DEBUGLEVEL >= 10) {
1283 NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, r);
1284 }
1285
1286 push = ndr_push_init_ctx(r, NULL);
1287 if (push == NULL) {
1288 talloc_free(r);
1289 return false;
1290 }
1291
1292 ndr_err = call->ndr_push(push, NDR_OUT, r);
1293 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1294 talloc_free(r);
1295 return false;
1296 }
1297
1298 blob = ndr_push_blob(push);
1299 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1300 talloc_free(r);
1301 return false;
1302 }
1303
1304 talloc_free(r);
1305
1306 return true;
1307}
1308
1309static bool api_samr_GetAliasMembership(pipes_struct *p)
1310{
1311 const struct ndr_interface_call *call;
1312 struct ndr_pull *pull;
1313 struct ndr_push *push;
1314 enum ndr_err_code ndr_err;
1315 DATA_BLOB blob;
1316 struct samr_GetAliasMembership *r;
1317
1318 call = &ndr_table_samr.calls[NDR_SAMR_GETALIASMEMBERSHIP];
1319
1320 r = talloc(talloc_tos(), struct samr_GetAliasMembership);
1321 if (r == NULL) {
1322 return false;
1323 }
1324
1325 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1326 talloc_free(r);
1327 return false;
1328 }
1329
1330 pull = ndr_pull_init_blob(&blob, r, NULL);
1331 if (pull == NULL) {
1332 talloc_free(r);
1333 return false;
1334 }
1335
1336 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1337 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1338 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1339 talloc_free(r);
1340 return false;
1341 }
1342
1343 if (DEBUGLEVEL >= 10) {
1344 NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, r);
1345 }
1346
1347 ZERO_STRUCT(r->out);
1348 r->out.rids = talloc_zero(r, struct samr_Ids);
1349 if (r->out.rids == NULL) {
1350 talloc_free(r);
1351 return false;
1352 }
1353
1354 r->out.result = _samr_GetAliasMembership(p, r);
1355
1356 if (p->rng_fault_state) {
1357 talloc_free(r);
1358 /* Return true here, srv_pipe_hnd.c will take care */
1359 return true;
1360 }
1361
1362 if (DEBUGLEVEL >= 10) {
1363 NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, r);
1364 }
1365
1366 push = ndr_push_init_ctx(r, NULL);
1367 if (push == NULL) {
1368 talloc_free(r);
1369 return false;
1370 }
1371
1372 ndr_err = call->ndr_push(push, NDR_OUT, r);
1373 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1374 talloc_free(r);
1375 return false;
1376 }
1377
1378 blob = ndr_push_blob(push);
1379 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1380 talloc_free(r);
1381 return false;
1382 }
1383
1384 talloc_free(r);
1385
1386 return true;
1387}
1388
1389static bool api_samr_LookupNames(pipes_struct *p)
1390{
1391 const struct ndr_interface_call *call;
1392 struct ndr_pull *pull;
1393 struct ndr_push *push;
1394 enum ndr_err_code ndr_err;
1395 DATA_BLOB blob;
1396 struct samr_LookupNames *r;
1397
1398 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPNAMES];
1399
1400 r = talloc(talloc_tos(), struct samr_LookupNames);
1401 if (r == NULL) {
1402 return false;
1403 }
1404
1405 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1406 talloc_free(r);
1407 return false;
1408 }
1409
1410 pull = ndr_pull_init_blob(&blob, r, NULL);
1411 if (pull == NULL) {
1412 talloc_free(r);
1413 return false;
1414 }
1415
1416 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1417 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1418 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1419 talloc_free(r);
1420 return false;
1421 }
1422
1423 if (DEBUGLEVEL >= 10) {
1424 NDR_PRINT_IN_DEBUG(samr_LookupNames, r);
1425 }
1426
1427 ZERO_STRUCT(r->out);
1428 r->out.rids = talloc_zero(r, struct samr_Ids);
1429 if (r->out.rids == NULL) {
1430 talloc_free(r);
1431 return false;
1432 }
1433
1434 r->out.types = talloc_zero(r, struct samr_Ids);
1435 if (r->out.types == NULL) {
1436 talloc_free(r);
1437 return false;
1438 }
1439
1440 r->out.result = _samr_LookupNames(p, r);
1441
1442 if (p->rng_fault_state) {
1443 talloc_free(r);
1444 /* Return true here, srv_pipe_hnd.c will take care */
1445 return true;
1446 }
1447
1448 if (DEBUGLEVEL >= 10) {
1449 NDR_PRINT_OUT_DEBUG(samr_LookupNames, r);
1450 }
1451
1452 push = ndr_push_init_ctx(r, NULL);
1453 if (push == NULL) {
1454 talloc_free(r);
1455 return false;
1456 }
1457
1458 ndr_err = call->ndr_push(push, NDR_OUT, r);
1459 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1460 talloc_free(r);
1461 return false;
1462 }
1463
1464 blob = ndr_push_blob(push);
1465 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1466 talloc_free(r);
1467 return false;
1468 }
1469
1470 talloc_free(r);
1471
1472 return true;
1473}
1474
1475static bool api_samr_LookupRids(pipes_struct *p)
1476{
1477 const struct ndr_interface_call *call;
1478 struct ndr_pull *pull;
1479 struct ndr_push *push;
1480 enum ndr_err_code ndr_err;
1481 DATA_BLOB blob;
1482 struct samr_LookupRids *r;
1483
1484 call = &ndr_table_samr.calls[NDR_SAMR_LOOKUPRIDS];
1485
1486 r = talloc(talloc_tos(), struct samr_LookupRids);
1487 if (r == NULL) {
1488 return false;
1489 }
1490
1491 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1492 talloc_free(r);
1493 return false;
1494 }
1495
1496 pull = ndr_pull_init_blob(&blob, r, NULL);
1497 if (pull == NULL) {
1498 talloc_free(r);
1499 return false;
1500 }
1501
1502 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1503 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1504 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1505 talloc_free(r);
1506 return false;
1507 }
1508
1509 if (DEBUGLEVEL >= 10) {
1510 NDR_PRINT_IN_DEBUG(samr_LookupRids, r);
1511 }
1512
1513 ZERO_STRUCT(r->out);
1514 r->out.names = talloc_zero(r, struct lsa_Strings);
1515 if (r->out.names == NULL) {
1516 talloc_free(r);
1517 return false;
1518 }
1519
1520 r->out.types = talloc_zero(r, struct samr_Ids);
1521 if (r->out.types == NULL) {
1522 talloc_free(r);
1523 return false;
1524 }
1525
1526 r->out.result = _samr_LookupRids(p, r);
1527
1528 if (p->rng_fault_state) {
1529 talloc_free(r);
1530 /* Return true here, srv_pipe_hnd.c will take care */
1531 return true;
1532 }
1533
1534 if (DEBUGLEVEL >= 10) {
1535 NDR_PRINT_OUT_DEBUG(samr_LookupRids, r);
1536 }
1537
1538 push = ndr_push_init_ctx(r, NULL);
1539 if (push == NULL) {
1540 talloc_free(r);
1541 return false;
1542 }
1543
1544 ndr_err = call->ndr_push(push, NDR_OUT, r);
1545 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1546 talloc_free(r);
1547 return false;
1548 }
1549
1550 blob = ndr_push_blob(push);
1551 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1552 talloc_free(r);
1553 return false;
1554 }
1555
1556 talloc_free(r);
1557
1558 return true;
1559}
1560
1561static bool api_samr_OpenGroup(pipes_struct *p)
1562{
1563 const struct ndr_interface_call *call;
1564 struct ndr_pull *pull;
1565 struct ndr_push *push;
1566 enum ndr_err_code ndr_err;
1567 DATA_BLOB blob;
1568 struct samr_OpenGroup *r;
1569
1570 call = &ndr_table_samr.calls[NDR_SAMR_OPENGROUP];
1571
1572 r = talloc(talloc_tos(), struct samr_OpenGroup);
1573 if (r == NULL) {
1574 return false;
1575 }
1576
1577 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1578 talloc_free(r);
1579 return false;
1580 }
1581
1582 pull = ndr_pull_init_blob(&blob, r, NULL);
1583 if (pull == NULL) {
1584 talloc_free(r);
1585 return false;
1586 }
1587
1588 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1589 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1590 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1591 talloc_free(r);
1592 return false;
1593 }
1594
1595 if (DEBUGLEVEL >= 10) {
1596 NDR_PRINT_IN_DEBUG(samr_OpenGroup, r);
1597 }
1598
1599 ZERO_STRUCT(r->out);
1600 r->out.group_handle = talloc_zero(r, struct policy_handle);
1601 if (r->out.group_handle == NULL) {
1602 talloc_free(r);
1603 return false;
1604 }
1605
1606 r->out.result = _samr_OpenGroup(p, r);
1607
1608 if (p->rng_fault_state) {
1609 talloc_free(r);
1610 /* Return true here, srv_pipe_hnd.c will take care */
1611 return true;
1612 }
1613
1614 if (DEBUGLEVEL >= 10) {
1615 NDR_PRINT_OUT_DEBUG(samr_OpenGroup, r);
1616 }
1617
1618 push = ndr_push_init_ctx(r, NULL);
1619 if (push == NULL) {
1620 talloc_free(r);
1621 return false;
1622 }
1623
1624 ndr_err = call->ndr_push(push, NDR_OUT, r);
1625 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1626 talloc_free(r);
1627 return false;
1628 }
1629
1630 blob = ndr_push_blob(push);
1631 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1632 talloc_free(r);
1633 return false;
1634 }
1635
1636 talloc_free(r);
1637
1638 return true;
1639}
1640
1641static bool api_samr_QueryGroupInfo(pipes_struct *p)
1642{
1643 const struct ndr_interface_call *call;
1644 struct ndr_pull *pull;
1645 struct ndr_push *push;
1646 enum ndr_err_code ndr_err;
1647 DATA_BLOB blob;
1648 struct samr_QueryGroupInfo *r;
1649
1650 call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPINFO];
1651
1652 r = talloc(talloc_tos(), struct samr_QueryGroupInfo);
1653 if (r == NULL) {
1654 return false;
1655 }
1656
1657 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1658 talloc_free(r);
1659 return false;
1660 }
1661
1662 pull = ndr_pull_init_blob(&blob, r, NULL);
1663 if (pull == NULL) {
1664 talloc_free(r);
1665 return false;
1666 }
1667
1668 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1669 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1670 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1671 talloc_free(r);
1672 return false;
1673 }
1674
1675 if (DEBUGLEVEL >= 10) {
1676 NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, r);
1677 }
1678
1679 ZERO_STRUCT(r->out);
1680 r->out.info = talloc_zero(r, union samr_GroupInfo *);
1681 if (r->out.info == NULL) {
1682 talloc_free(r);
1683 return false;
1684 }
1685
1686 r->out.result = _samr_QueryGroupInfo(p, r);
1687
1688 if (p->rng_fault_state) {
1689 talloc_free(r);
1690 /* Return true here, srv_pipe_hnd.c will take care */
1691 return true;
1692 }
1693
1694 if (DEBUGLEVEL >= 10) {
1695 NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, r);
1696 }
1697
1698 push = ndr_push_init_ctx(r, NULL);
1699 if (push == NULL) {
1700 talloc_free(r);
1701 return false;
1702 }
1703
1704 ndr_err = call->ndr_push(push, NDR_OUT, r);
1705 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1706 talloc_free(r);
1707 return false;
1708 }
1709
1710 blob = ndr_push_blob(push);
1711 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1712 talloc_free(r);
1713 return false;
1714 }
1715
1716 talloc_free(r);
1717
1718 return true;
1719}
1720
1721static bool api_samr_SetGroupInfo(pipes_struct *p)
1722{
1723 const struct ndr_interface_call *call;
1724 struct ndr_pull *pull;
1725 struct ndr_push *push;
1726 enum ndr_err_code ndr_err;
1727 DATA_BLOB blob;
1728 struct samr_SetGroupInfo *r;
1729
1730 call = &ndr_table_samr.calls[NDR_SAMR_SETGROUPINFO];
1731
1732 r = talloc(talloc_tos(), struct samr_SetGroupInfo);
1733 if (r == NULL) {
1734 return false;
1735 }
1736
1737 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1738 talloc_free(r);
1739 return false;
1740 }
1741
1742 pull = ndr_pull_init_blob(&blob, r, NULL);
1743 if (pull == NULL) {
1744 talloc_free(r);
1745 return false;
1746 }
1747
1748 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1749 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1750 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1751 talloc_free(r);
1752 return false;
1753 }
1754
1755 if (DEBUGLEVEL >= 10) {
1756 NDR_PRINT_IN_DEBUG(samr_SetGroupInfo, r);
1757 }
1758
1759 r->out.result = _samr_SetGroupInfo(p, r);
1760
1761 if (p->rng_fault_state) {
1762 talloc_free(r);
1763 /* Return true here, srv_pipe_hnd.c will take care */
1764 return true;
1765 }
1766
1767 if (DEBUGLEVEL >= 10) {
1768 NDR_PRINT_OUT_DEBUG(samr_SetGroupInfo, r);
1769 }
1770
1771 push = ndr_push_init_ctx(r, NULL);
1772 if (push == NULL) {
1773 talloc_free(r);
1774 return false;
1775 }
1776
1777 ndr_err = call->ndr_push(push, NDR_OUT, r);
1778 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1779 talloc_free(r);
1780 return false;
1781 }
1782
1783 blob = ndr_push_blob(push);
1784 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1785 talloc_free(r);
1786 return false;
1787 }
1788
1789 talloc_free(r);
1790
1791 return true;
1792}
1793
1794static bool api_samr_AddGroupMember(pipes_struct *p)
1795{
1796 const struct ndr_interface_call *call;
1797 struct ndr_pull *pull;
1798 struct ndr_push *push;
1799 enum ndr_err_code ndr_err;
1800 DATA_BLOB blob;
1801 struct samr_AddGroupMember *r;
1802
1803 call = &ndr_table_samr.calls[NDR_SAMR_ADDGROUPMEMBER];
1804
1805 r = talloc(talloc_tos(), struct samr_AddGroupMember);
1806 if (r == NULL) {
1807 return false;
1808 }
1809
1810 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1811 talloc_free(r);
1812 return false;
1813 }
1814
1815 pull = ndr_pull_init_blob(&blob, r, NULL);
1816 if (pull == NULL) {
1817 talloc_free(r);
1818 return false;
1819 }
1820
1821 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1822 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1823 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1824 talloc_free(r);
1825 return false;
1826 }
1827
1828 if (DEBUGLEVEL >= 10) {
1829 NDR_PRINT_IN_DEBUG(samr_AddGroupMember, r);
1830 }
1831
1832 r->out.result = _samr_AddGroupMember(p, r);
1833
1834 if (p->rng_fault_state) {
1835 talloc_free(r);
1836 /* Return true here, srv_pipe_hnd.c will take care */
1837 return true;
1838 }
1839
1840 if (DEBUGLEVEL >= 10) {
1841 NDR_PRINT_OUT_DEBUG(samr_AddGroupMember, r);
1842 }
1843
1844 push = ndr_push_init_ctx(r, NULL);
1845 if (push == NULL) {
1846 talloc_free(r);
1847 return false;
1848 }
1849
1850 ndr_err = call->ndr_push(push, NDR_OUT, r);
1851 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1852 talloc_free(r);
1853 return false;
1854 }
1855
1856 blob = ndr_push_blob(push);
1857 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1858 talloc_free(r);
1859 return false;
1860 }
1861
1862 talloc_free(r);
1863
1864 return true;
1865}
1866
1867static bool api_samr_DeleteDomainGroup(pipes_struct *p)
1868{
1869 const struct ndr_interface_call *call;
1870 struct ndr_pull *pull;
1871 struct ndr_push *push;
1872 enum ndr_err_code ndr_err;
1873 DATA_BLOB blob;
1874 struct samr_DeleteDomainGroup *r;
1875
1876 call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMAINGROUP];
1877
1878 r = talloc(talloc_tos(), struct samr_DeleteDomainGroup);
1879 if (r == NULL) {
1880 return false;
1881 }
1882
1883 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1884 talloc_free(r);
1885 return false;
1886 }
1887
1888 pull = ndr_pull_init_blob(&blob, r, NULL);
1889 if (pull == NULL) {
1890 talloc_free(r);
1891 return false;
1892 }
1893
1894 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1895 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1896 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1897 talloc_free(r);
1898 return false;
1899 }
1900
1901 if (DEBUGLEVEL >= 10) {
1902 NDR_PRINT_IN_DEBUG(samr_DeleteDomainGroup, r);
1903 }
1904
1905 ZERO_STRUCT(r->out);
1906 r->out.group_handle = r->in.group_handle;
1907 r->out.result = _samr_DeleteDomainGroup(p, r);
1908
1909 if (p->rng_fault_state) {
1910 talloc_free(r);
1911 /* Return true here, srv_pipe_hnd.c will take care */
1912 return true;
1913 }
1914
1915 if (DEBUGLEVEL >= 10) {
1916 NDR_PRINT_OUT_DEBUG(samr_DeleteDomainGroup, r);
1917 }
1918
1919 push = ndr_push_init_ctx(r, NULL);
1920 if (push == NULL) {
1921 talloc_free(r);
1922 return false;
1923 }
1924
1925 ndr_err = call->ndr_push(push, NDR_OUT, r);
1926 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1927 talloc_free(r);
1928 return false;
1929 }
1930
1931 blob = ndr_push_blob(push);
1932 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1933 talloc_free(r);
1934 return false;
1935 }
1936
1937 talloc_free(r);
1938
1939 return true;
1940}
1941
1942static bool api_samr_DeleteGroupMember(pipes_struct *p)
1943{
1944 const struct ndr_interface_call *call;
1945 struct ndr_pull *pull;
1946 struct ndr_push *push;
1947 enum ndr_err_code ndr_err;
1948 DATA_BLOB blob;
1949 struct samr_DeleteGroupMember *r;
1950
1951 call = &ndr_table_samr.calls[NDR_SAMR_DELETEGROUPMEMBER];
1952
1953 r = talloc(talloc_tos(), struct samr_DeleteGroupMember);
1954 if (r == NULL) {
1955 return false;
1956 }
1957
1958 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1959 talloc_free(r);
1960 return false;
1961 }
1962
1963 pull = ndr_pull_init_blob(&blob, r, NULL);
1964 if (pull == NULL) {
1965 talloc_free(r);
1966 return false;
1967 }
1968
1969 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1970 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1971 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1972 talloc_free(r);
1973 return false;
1974 }
1975
1976 if (DEBUGLEVEL >= 10) {
1977 NDR_PRINT_IN_DEBUG(samr_DeleteGroupMember, r);
1978 }
1979
1980 r->out.result = _samr_DeleteGroupMember(p, r);
1981
1982 if (p->rng_fault_state) {
1983 talloc_free(r);
1984 /* Return true here, srv_pipe_hnd.c will take care */
1985 return true;
1986 }
1987
1988 if (DEBUGLEVEL >= 10) {
1989 NDR_PRINT_OUT_DEBUG(samr_DeleteGroupMember, r);
1990 }
1991
1992 push = ndr_push_init_ctx(r, NULL);
1993 if (push == NULL) {
1994 talloc_free(r);
1995 return false;
1996 }
1997
1998 ndr_err = call->ndr_push(push, NDR_OUT, r);
1999 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2000 talloc_free(r);
2001 return false;
2002 }
2003
2004 blob = ndr_push_blob(push);
2005 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2006 talloc_free(r);
2007 return false;
2008 }
2009
2010 talloc_free(r);
2011
2012 return true;
2013}
2014
2015static bool api_samr_QueryGroupMember(pipes_struct *p)
2016{
2017 const struct ndr_interface_call *call;
2018 struct ndr_pull *pull;
2019 struct ndr_push *push;
2020 enum ndr_err_code ndr_err;
2021 DATA_BLOB blob;
2022 struct samr_QueryGroupMember *r;
2023
2024 call = &ndr_table_samr.calls[NDR_SAMR_QUERYGROUPMEMBER];
2025
2026 r = talloc(talloc_tos(), struct samr_QueryGroupMember);
2027 if (r == NULL) {
2028 return false;
2029 }
2030
2031 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2032 talloc_free(r);
2033 return false;
2034 }
2035
2036 pull = ndr_pull_init_blob(&blob, r, NULL);
2037 if (pull == NULL) {
2038 talloc_free(r);
2039 return false;
2040 }
2041
2042 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2043 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2044 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2045 talloc_free(r);
2046 return false;
2047 }
2048
2049 if (DEBUGLEVEL >= 10) {
2050 NDR_PRINT_IN_DEBUG(samr_QueryGroupMember, r);
2051 }
2052
2053 ZERO_STRUCT(r->out);
2054 r->out.rids = talloc_zero(r, struct samr_RidTypeArray *);
2055 if (r->out.rids == NULL) {
2056 talloc_free(r);
2057 return false;
2058 }
2059
2060 r->out.result = _samr_QueryGroupMember(p, r);
2061
2062 if (p->rng_fault_state) {
2063 talloc_free(r);
2064 /* Return true here, srv_pipe_hnd.c will take care */
2065 return true;
2066 }
2067
2068 if (DEBUGLEVEL >= 10) {
2069 NDR_PRINT_OUT_DEBUG(samr_QueryGroupMember, r);
2070 }
2071
2072 push = ndr_push_init_ctx(r, NULL);
2073 if (push == NULL) {
2074 talloc_free(r);
2075 return false;
2076 }
2077
2078 ndr_err = call->ndr_push(push, NDR_OUT, r);
2079 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2080 talloc_free(r);
2081 return false;
2082 }
2083
2084 blob = ndr_push_blob(push);
2085 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2086 talloc_free(r);
2087 return false;
2088 }
2089
2090 talloc_free(r);
2091
2092 return true;
2093}
2094
2095static bool api_samr_SetMemberAttributesOfGroup(pipes_struct *p)
2096{
2097 const struct ndr_interface_call *call;
2098 struct ndr_pull *pull;
2099 struct ndr_push *push;
2100 enum ndr_err_code ndr_err;
2101 DATA_BLOB blob;
2102 struct samr_SetMemberAttributesOfGroup *r;
2103
2104 call = &ndr_table_samr.calls[NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP];
2105
2106 r = talloc(talloc_tos(), struct samr_SetMemberAttributesOfGroup);
2107 if (r == NULL) {
2108 return false;
2109 }
2110
2111 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2112 talloc_free(r);
2113 return false;
2114 }
2115
2116 pull = ndr_pull_init_blob(&blob, r, NULL);
2117 if (pull == NULL) {
2118 talloc_free(r);
2119 return false;
2120 }
2121
2122 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2123 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2124 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2125 talloc_free(r);
2126 return false;
2127 }
2128
2129 if (DEBUGLEVEL >= 10) {
2130 NDR_PRINT_IN_DEBUG(samr_SetMemberAttributesOfGroup, r);
2131 }
2132
2133 r->out.result = _samr_SetMemberAttributesOfGroup(p, r);
2134
2135 if (p->rng_fault_state) {
2136 talloc_free(r);
2137 /* Return true here, srv_pipe_hnd.c will take care */
2138 return true;
2139 }
2140
2141 if (DEBUGLEVEL >= 10) {
2142 NDR_PRINT_OUT_DEBUG(samr_SetMemberAttributesOfGroup, r);
2143 }
2144
2145 push = ndr_push_init_ctx(r, NULL);
2146 if (push == NULL) {
2147 talloc_free(r);
2148 return false;
2149 }
2150
2151 ndr_err = call->ndr_push(push, NDR_OUT, r);
2152 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2153 talloc_free(r);
2154 return false;
2155 }
2156
2157 blob = ndr_push_blob(push);
2158 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2159 talloc_free(r);
2160 return false;
2161 }
2162
2163 talloc_free(r);
2164
2165 return true;
2166}
2167
2168static bool api_samr_OpenAlias(pipes_struct *p)
2169{
2170 const struct ndr_interface_call *call;
2171 struct ndr_pull *pull;
2172 struct ndr_push *push;
2173 enum ndr_err_code ndr_err;
2174 DATA_BLOB blob;
2175 struct samr_OpenAlias *r;
2176
2177 call = &ndr_table_samr.calls[NDR_SAMR_OPENALIAS];
2178
2179 r = talloc(talloc_tos(), struct samr_OpenAlias);
2180 if (r == NULL) {
2181 return false;
2182 }
2183
2184 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2185 talloc_free(r);
2186 return false;
2187 }
2188
2189 pull = ndr_pull_init_blob(&blob, r, NULL);
2190 if (pull == NULL) {
2191 talloc_free(r);
2192 return false;
2193 }
2194
2195 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2196 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2197 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2198 talloc_free(r);
2199 return false;
2200 }
2201
2202 if (DEBUGLEVEL >= 10) {
2203 NDR_PRINT_IN_DEBUG(samr_OpenAlias, r);
2204 }
2205
2206 ZERO_STRUCT(r->out);
2207 r->out.alias_handle = talloc_zero(r, struct policy_handle);
2208 if (r->out.alias_handle == NULL) {
2209 talloc_free(r);
2210 return false;
2211 }
2212
2213 r->out.result = _samr_OpenAlias(p, r);
2214
2215 if (p->rng_fault_state) {
2216 talloc_free(r);
2217 /* Return true here, srv_pipe_hnd.c will take care */
2218 return true;
2219 }
2220
2221 if (DEBUGLEVEL >= 10) {
2222 NDR_PRINT_OUT_DEBUG(samr_OpenAlias, r);
2223 }
2224
2225 push = ndr_push_init_ctx(r, NULL);
2226 if (push == NULL) {
2227 talloc_free(r);
2228 return false;
2229 }
2230
2231 ndr_err = call->ndr_push(push, NDR_OUT, r);
2232 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2233 talloc_free(r);
2234 return false;
2235 }
2236
2237 blob = ndr_push_blob(push);
2238 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2239 talloc_free(r);
2240 return false;
2241 }
2242
2243 talloc_free(r);
2244
2245 return true;
2246}
2247
2248static bool api_samr_QueryAliasInfo(pipes_struct *p)
2249{
2250 const struct ndr_interface_call *call;
2251 struct ndr_pull *pull;
2252 struct ndr_push *push;
2253 enum ndr_err_code ndr_err;
2254 DATA_BLOB blob;
2255 struct samr_QueryAliasInfo *r;
2256
2257 call = &ndr_table_samr.calls[NDR_SAMR_QUERYALIASINFO];
2258
2259 r = talloc(talloc_tos(), struct samr_QueryAliasInfo);
2260 if (r == NULL) {
2261 return false;
2262 }
2263
2264 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2265 talloc_free(r);
2266 return false;
2267 }
2268
2269 pull = ndr_pull_init_blob(&blob, r, NULL);
2270 if (pull == NULL) {
2271 talloc_free(r);
2272 return false;
2273 }
2274
2275 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2276 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2277 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2278 talloc_free(r);
2279 return false;
2280 }
2281
2282 if (DEBUGLEVEL >= 10) {
2283 NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, r);
2284 }
2285
2286 ZERO_STRUCT(r->out);
2287 r->out.info = talloc_zero(r, union samr_AliasInfo *);
2288 if (r->out.info == NULL) {
2289 talloc_free(r);
2290 return false;
2291 }
2292
2293 r->out.result = _samr_QueryAliasInfo(p, r);
2294
2295 if (p->rng_fault_state) {
2296 talloc_free(r);
2297 /* Return true here, srv_pipe_hnd.c will take care */
2298 return true;
2299 }
2300
2301 if (DEBUGLEVEL >= 10) {
2302 NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, r);
2303 }
2304
2305 push = ndr_push_init_ctx(r, NULL);
2306 if (push == NULL) {
2307 talloc_free(r);
2308 return false;
2309 }
2310
2311 ndr_err = call->ndr_push(push, NDR_OUT, r);
2312 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2313 talloc_free(r);
2314 return false;
2315 }
2316
2317 blob = ndr_push_blob(push);
2318 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2319 talloc_free(r);
2320 return false;
2321 }
2322
2323 talloc_free(r);
2324
2325 return true;
2326}
2327
2328static bool api_samr_SetAliasInfo(pipes_struct *p)
2329{
2330 const struct ndr_interface_call *call;
2331 struct ndr_pull *pull;
2332 struct ndr_push *push;
2333 enum ndr_err_code ndr_err;
2334 DATA_BLOB blob;
2335 struct samr_SetAliasInfo *r;
2336
2337 call = &ndr_table_samr.calls[NDR_SAMR_SETALIASINFO];
2338
2339 r = talloc(talloc_tos(), struct samr_SetAliasInfo);
2340 if (r == NULL) {
2341 return false;
2342 }
2343
2344 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2345 talloc_free(r);
2346 return false;
2347 }
2348
2349 pull = ndr_pull_init_blob(&blob, r, NULL);
2350 if (pull == NULL) {
2351 talloc_free(r);
2352 return false;
2353 }
2354
2355 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2356 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2357 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2358 talloc_free(r);
2359 return false;
2360 }
2361
2362 if (DEBUGLEVEL >= 10) {
2363 NDR_PRINT_IN_DEBUG(samr_SetAliasInfo, r);
2364 }
2365
2366 r->out.result = _samr_SetAliasInfo(p, r);
2367
2368 if (p->rng_fault_state) {
2369 talloc_free(r);
2370 /* Return true here, srv_pipe_hnd.c will take care */
2371 return true;
2372 }
2373
2374 if (DEBUGLEVEL >= 10) {
2375 NDR_PRINT_OUT_DEBUG(samr_SetAliasInfo, r);
2376 }
2377
2378 push = ndr_push_init_ctx(r, NULL);
2379 if (push == NULL) {
2380 talloc_free(r);
2381 return false;
2382 }
2383
2384 ndr_err = call->ndr_push(push, NDR_OUT, r);
2385 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2386 talloc_free(r);
2387 return false;
2388 }
2389
2390 blob = ndr_push_blob(push);
2391 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2392 talloc_free(r);
2393 return false;
2394 }
2395
2396 talloc_free(r);
2397
2398 return true;
2399}
2400
2401static bool api_samr_DeleteDomAlias(pipes_struct *p)
2402{
2403 const struct ndr_interface_call *call;
2404 struct ndr_pull *pull;
2405 struct ndr_push *push;
2406 enum ndr_err_code ndr_err;
2407 DATA_BLOB blob;
2408 struct samr_DeleteDomAlias *r;
2409
2410 call = &ndr_table_samr.calls[NDR_SAMR_DELETEDOMALIAS];
2411
2412 r = talloc(talloc_tos(), struct samr_DeleteDomAlias);
2413 if (r == NULL) {
2414 return false;
2415 }
2416
2417 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2418 talloc_free(r);
2419 return false;
2420 }
2421
2422 pull = ndr_pull_init_blob(&blob, r, NULL);
2423 if (pull == NULL) {
2424 talloc_free(r);
2425 return false;
2426 }
2427
2428 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2429 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2430 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2431 talloc_free(r);
2432 return false;
2433 }
2434
2435 if (DEBUGLEVEL >= 10) {
2436 NDR_PRINT_IN_DEBUG(samr_DeleteDomAlias, r);
2437 }
2438
2439 ZERO_STRUCT(r->out);
2440 r->out.alias_handle = r->in.alias_handle;
2441 r->out.result = _samr_DeleteDomAlias(p, r);
2442
2443 if (p->rng_fault_state) {
2444 talloc_free(r);
2445 /* Return true here, srv_pipe_hnd.c will take care */
2446 return true;
2447 }
2448
2449 if (DEBUGLEVEL >= 10) {
2450 NDR_PRINT_OUT_DEBUG(samr_DeleteDomAlias, r);
2451 }
2452
2453 push = ndr_push_init_ctx(r, NULL);
2454 if (push == NULL) {
2455 talloc_free(r);
2456 return false;
2457 }
2458
2459 ndr_err = call->ndr_push(push, NDR_OUT, r);
2460 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2461 talloc_free(r);
2462 return false;
2463 }
2464
2465 blob = ndr_push_blob(push);
2466 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2467 talloc_free(r);
2468 return false;
2469 }
2470
2471 talloc_free(r);
2472
2473 return true;
2474}
2475
2476static bool api_samr_AddAliasMember(pipes_struct *p)
2477{
2478 const struct ndr_interface_call *call;
2479 struct ndr_pull *pull;
2480 struct ndr_push *push;
2481 enum ndr_err_code ndr_err;
2482 DATA_BLOB blob;
2483 struct samr_AddAliasMember *r;
2484
2485 call = &ndr_table_samr.calls[NDR_SAMR_ADDALIASMEMBER];
2486
2487 r = talloc(talloc_tos(), struct samr_AddAliasMember);
2488 if (r == NULL) {
2489 return false;
2490 }
2491
2492 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2493 talloc_free(r);
2494 return false;
2495 }
2496
2497 pull = ndr_pull_init_blob(&blob, r, NULL);
2498 if (pull == NULL) {
2499 talloc_free(r);
2500 return false;
2501 }
2502
2503 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2504 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2505 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2506 talloc_free(r);
2507 return false;
2508 }
2509
2510 if (DEBUGLEVEL >= 10) {
2511 NDR_PRINT_IN_DEBUG(samr_AddAliasMember, r);
2512 }
2513
2514 r->out.result = _samr_AddAliasMember(p, r);
2515
2516 if (p->rng_fault_state) {
2517 talloc_free(r);
2518 /* Return true here, srv_pipe_hnd.c will take care */
2519 return true;
2520 }
2521
2522 if (DEBUGLEVEL >= 10) {
2523 NDR_PRINT_OUT_DEBUG(samr_AddAliasMember, r);
2524 }
2525
2526 push = ndr_push_init_ctx(r, NULL);
2527 if (push == NULL) {
2528 talloc_free(r);
2529 return false;
2530 }
2531
2532 ndr_err = call->ndr_push(push, NDR_OUT, r);
2533 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2534 talloc_free(r);
2535 return false;
2536 }
2537
2538 blob = ndr_push_blob(push);
2539 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2540 talloc_free(r);
2541 return false;
2542 }
2543
2544 talloc_free(r);
2545
2546 return true;
2547}
2548
2549static bool api_samr_DeleteAliasMember(pipes_struct *p)
2550{
2551 const struct ndr_interface_call *call;
2552 struct ndr_pull *pull;
2553 struct ndr_push *push;
2554 enum ndr_err_code ndr_err;
2555 DATA_BLOB blob;
2556 struct samr_DeleteAliasMember *r;
2557
2558 call = &ndr_table_samr.calls[NDR_SAMR_DELETEALIASMEMBER];
2559
2560 r = talloc(talloc_tos(), struct samr_DeleteAliasMember);
2561 if (r == NULL) {
2562 return false;
2563 }
2564
2565 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2566 talloc_free(r);
2567 return false;
2568 }
2569
2570 pull = ndr_pull_init_blob(&blob, r, NULL);
2571 if (pull == NULL) {
2572 talloc_free(r);
2573 return false;
2574 }
2575
2576 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2577 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2578 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2579 talloc_free(r);
2580 return false;
2581 }
2582
2583 if (DEBUGLEVEL >= 10) {
2584 NDR_PRINT_IN_DEBUG(samr_DeleteAliasMember, r);
2585 }
2586
2587 r->out.result = _samr_DeleteAliasMember(p, r);
2588
2589 if (p->rng_fault_state) {
2590 talloc_free(r);
2591 /* Return true here, srv_pipe_hnd.c will take care */
2592 return true;
2593 }
2594
2595 if (DEBUGLEVEL >= 10) {
2596 NDR_PRINT_OUT_DEBUG(samr_DeleteAliasMember, r);
2597 }
2598
2599 push = ndr_push_init_ctx(r, NULL);
2600 if (push == NULL) {
2601 talloc_free(r);
2602 return false;
2603 }
2604
2605 ndr_err = call->ndr_push(push, NDR_OUT, r);
2606 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2607 talloc_free(r);
2608 return false;
2609 }
2610
2611 blob = ndr_push_blob(push);
2612 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2613 talloc_free(r);
2614 return false;
2615 }
2616
2617 talloc_free(r);
2618
2619 return true;
2620}
2621
2622static bool api_samr_GetMembersInAlias(pipes_struct *p)
2623{
2624 const struct ndr_interface_call *call;
2625 struct ndr_pull *pull;
2626 struct ndr_push *push;
2627 enum ndr_err_code ndr_err;
2628 DATA_BLOB blob;
2629 struct samr_GetMembersInAlias *r;
2630
2631 call = &ndr_table_samr.calls[NDR_SAMR_GETMEMBERSINALIAS];
2632
2633 r = talloc(talloc_tos(), struct samr_GetMembersInAlias);
2634 if (r == NULL) {
2635 return false;
2636 }
2637
2638 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2639 talloc_free(r);
2640 return false;
2641 }
2642
2643 pull = ndr_pull_init_blob(&blob, r, NULL);
2644 if (pull == NULL) {
2645 talloc_free(r);
2646 return false;
2647 }
2648
2649 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2650 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2651 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2652 talloc_free(r);
2653 return false;
2654 }
2655
2656 if (DEBUGLEVEL >= 10) {
2657 NDR_PRINT_IN_DEBUG(samr_GetMembersInAlias, r);
2658 }
2659
2660 ZERO_STRUCT(r->out);
2661 r->out.sids = talloc_zero(r, struct lsa_SidArray);
2662 if (r->out.sids == NULL) {
2663 talloc_free(r);
2664 return false;
2665 }
2666
2667 r->out.result = _samr_GetMembersInAlias(p, r);
2668
2669 if (p->rng_fault_state) {
2670 talloc_free(r);
2671 /* Return true here, srv_pipe_hnd.c will take care */
2672 return true;
2673 }
2674
2675 if (DEBUGLEVEL >= 10) {
2676 NDR_PRINT_OUT_DEBUG(samr_GetMembersInAlias, r);
2677 }
2678
2679 push = ndr_push_init_ctx(r, NULL);
2680 if (push == NULL) {
2681 talloc_free(r);
2682 return false;
2683 }
2684
2685 ndr_err = call->ndr_push(push, NDR_OUT, r);
2686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2687 talloc_free(r);
2688 return false;
2689 }
2690
2691 blob = ndr_push_blob(push);
2692 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2693 talloc_free(r);
2694 return false;
2695 }
2696
2697 talloc_free(r);
2698
2699 return true;
2700}
2701
2702static bool api_samr_OpenUser(pipes_struct *p)
2703{
2704 const struct ndr_interface_call *call;
2705 struct ndr_pull *pull;
2706 struct ndr_push *push;
2707 enum ndr_err_code ndr_err;
2708 DATA_BLOB blob;
2709 struct samr_OpenUser *r;
2710
2711 call = &ndr_table_samr.calls[NDR_SAMR_OPENUSER];
2712
2713 r = talloc(talloc_tos(), struct samr_OpenUser);
2714 if (r == NULL) {
2715 return false;
2716 }
2717
2718 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2719 talloc_free(r);
2720 return false;
2721 }
2722
2723 pull = ndr_pull_init_blob(&blob, r, NULL);
2724 if (pull == NULL) {
2725 talloc_free(r);
2726 return false;
2727 }
2728
2729 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2730 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2732 talloc_free(r);
2733 return false;
2734 }
2735
2736 if (DEBUGLEVEL >= 10) {
2737 NDR_PRINT_IN_DEBUG(samr_OpenUser, r);
2738 }
2739
2740 ZERO_STRUCT(r->out);
2741 r->out.user_handle = talloc_zero(r, struct policy_handle);
2742 if (r->out.user_handle == NULL) {
2743 talloc_free(r);
2744 return false;
2745 }
2746
2747 r->out.result = _samr_OpenUser(p, r);
2748
2749 if (p->rng_fault_state) {
2750 talloc_free(r);
2751 /* Return true here, srv_pipe_hnd.c will take care */
2752 return true;
2753 }
2754
2755 if (DEBUGLEVEL >= 10) {
2756 NDR_PRINT_OUT_DEBUG(samr_OpenUser, r);
2757 }
2758
2759 push = ndr_push_init_ctx(r, NULL);
2760 if (push == NULL) {
2761 talloc_free(r);
2762 return false;
2763 }
2764
2765 ndr_err = call->ndr_push(push, NDR_OUT, r);
2766 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2767 talloc_free(r);
2768 return false;
2769 }
2770
2771 blob = ndr_push_blob(push);
2772 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2773 talloc_free(r);
2774 return false;
2775 }
2776
2777 talloc_free(r);
2778
2779 return true;
2780}
2781
2782static bool api_samr_DeleteUser(pipes_struct *p)
2783{
2784 const struct ndr_interface_call *call;
2785 struct ndr_pull *pull;
2786 struct ndr_push *push;
2787 enum ndr_err_code ndr_err;
2788 DATA_BLOB blob;
2789 struct samr_DeleteUser *r;
2790
2791 call = &ndr_table_samr.calls[NDR_SAMR_DELETEUSER];
2792
2793 r = talloc(talloc_tos(), struct samr_DeleteUser);
2794 if (r == NULL) {
2795 return false;
2796 }
2797
2798 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2799 talloc_free(r);
2800 return false;
2801 }
2802
2803 pull = ndr_pull_init_blob(&blob, r, NULL);
2804 if (pull == NULL) {
2805 talloc_free(r);
2806 return false;
2807 }
2808
2809 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2810 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2811 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2812 talloc_free(r);
2813 return false;
2814 }
2815
2816 if (DEBUGLEVEL >= 10) {
2817 NDR_PRINT_IN_DEBUG(samr_DeleteUser, r);
2818 }
2819
2820 ZERO_STRUCT(r->out);
2821 r->out.user_handle = r->in.user_handle;
2822 r->out.result = _samr_DeleteUser(p, r);
2823
2824 if (p->rng_fault_state) {
2825 talloc_free(r);
2826 /* Return true here, srv_pipe_hnd.c will take care */
2827 return true;
2828 }
2829
2830 if (DEBUGLEVEL >= 10) {
2831 NDR_PRINT_OUT_DEBUG(samr_DeleteUser, r);
2832 }
2833
2834 push = ndr_push_init_ctx(r, NULL);
2835 if (push == NULL) {
2836 talloc_free(r);
2837 return false;
2838 }
2839
2840 ndr_err = call->ndr_push(push, NDR_OUT, r);
2841 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2842 talloc_free(r);
2843 return false;
2844 }
2845
2846 blob = ndr_push_blob(push);
2847 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2848 talloc_free(r);
2849 return false;
2850 }
2851
2852 talloc_free(r);
2853
2854 return true;
2855}
2856
2857static bool api_samr_QueryUserInfo(pipes_struct *p)
2858{
2859 const struct ndr_interface_call *call;
2860 struct ndr_pull *pull;
2861 struct ndr_push *push;
2862 enum ndr_err_code ndr_err;
2863 DATA_BLOB blob;
2864 struct samr_QueryUserInfo *r;
2865
2866 call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO];
2867
2868 r = talloc(talloc_tos(), struct samr_QueryUserInfo);
2869 if (r == NULL) {
2870 return false;
2871 }
2872
2873 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2874 talloc_free(r);
2875 return false;
2876 }
2877
2878 pull = ndr_pull_init_blob(&blob, r, NULL);
2879 if (pull == NULL) {
2880 talloc_free(r);
2881 return false;
2882 }
2883
2884 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2885 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2886 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2887 talloc_free(r);
2888 return false;
2889 }
2890
2891 if (DEBUGLEVEL >= 10) {
2892 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, r);
2893 }
2894
2895 ZERO_STRUCT(r->out);
2896 r->out.info = talloc_zero(r, union samr_UserInfo *);
2897 if (r->out.info == NULL) {
2898 talloc_free(r);
2899 return false;
2900 }
2901
2902 r->out.result = _samr_QueryUserInfo(p, r);
2903
2904 if (p->rng_fault_state) {
2905 talloc_free(r);
2906 /* Return true here, srv_pipe_hnd.c will take care */
2907 return true;
2908 }
2909
2910 if (DEBUGLEVEL >= 10) {
2911 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, r);
2912 }
2913
2914 push = ndr_push_init_ctx(r, NULL);
2915 if (push == NULL) {
2916 talloc_free(r);
2917 return false;
2918 }
2919
2920 ndr_err = call->ndr_push(push, NDR_OUT, r);
2921 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2922 talloc_free(r);
2923 return false;
2924 }
2925
2926 blob = ndr_push_blob(push);
2927 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2928 talloc_free(r);
2929 return false;
2930 }
2931
2932 talloc_free(r);
2933
2934 return true;
2935}
2936
2937static bool api_samr_SetUserInfo(pipes_struct *p)
2938{
2939 const struct ndr_interface_call *call;
2940 struct ndr_pull *pull;
2941 struct ndr_push *push;
2942 enum ndr_err_code ndr_err;
2943 DATA_BLOB blob;
2944 struct samr_SetUserInfo *r;
2945
2946 call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO];
2947
2948 r = talloc(talloc_tos(), struct samr_SetUserInfo);
2949 if (r == NULL) {
2950 return false;
2951 }
2952
2953 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2954 talloc_free(r);
2955 return false;
2956 }
2957
2958 pull = ndr_pull_init_blob(&blob, r, NULL);
2959 if (pull == NULL) {
2960 talloc_free(r);
2961 return false;
2962 }
2963
2964 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2965 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2966 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2967 talloc_free(r);
2968 return false;
2969 }
2970
2971 if (DEBUGLEVEL >= 10) {
2972 NDR_PRINT_IN_DEBUG(samr_SetUserInfo, r);
2973 }
2974
2975 r->out.result = _samr_SetUserInfo(p, r);
2976
2977 if (p->rng_fault_state) {
2978 talloc_free(r);
2979 /* Return true here, srv_pipe_hnd.c will take care */
2980 return true;
2981 }
2982
2983 if (DEBUGLEVEL >= 10) {
2984 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo, r);
2985 }
2986
2987 push = ndr_push_init_ctx(r, NULL);
2988 if (push == NULL) {
2989 talloc_free(r);
2990 return false;
2991 }
2992
2993 ndr_err = call->ndr_push(push, NDR_OUT, r);
2994 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2995 talloc_free(r);
2996 return false;
2997 }
2998
2999 blob = ndr_push_blob(push);
3000 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3001 talloc_free(r);
3002 return false;
3003 }
3004
3005 talloc_free(r);
3006
3007 return true;
3008}
3009
3010static bool api_samr_ChangePasswordUser(pipes_struct *p)
3011{
3012 const struct ndr_interface_call *call;
3013 struct ndr_pull *pull;
3014 struct ndr_push *push;
3015 enum ndr_err_code ndr_err;
3016 DATA_BLOB blob;
3017 struct samr_ChangePasswordUser *r;
3018
3019 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER];
3020
3021 r = talloc(talloc_tos(), struct samr_ChangePasswordUser);
3022 if (r == NULL) {
3023 return false;
3024 }
3025
3026 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3027 talloc_free(r);
3028 return false;
3029 }
3030
3031 pull = ndr_pull_init_blob(&blob, r, NULL);
3032 if (pull == NULL) {
3033 talloc_free(r);
3034 return false;
3035 }
3036
3037 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3038 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3039 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3040 talloc_free(r);
3041 return false;
3042 }
3043
3044 if (DEBUGLEVEL >= 10) {
3045 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser, r);
3046 }
3047
3048 r->out.result = _samr_ChangePasswordUser(p, r);
3049
3050 if (p->rng_fault_state) {
3051 talloc_free(r);
3052 /* Return true here, srv_pipe_hnd.c will take care */
3053 return true;
3054 }
3055
3056 if (DEBUGLEVEL >= 10) {
3057 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser, r);
3058 }
3059
3060 push = ndr_push_init_ctx(r, NULL);
3061 if (push == NULL) {
3062 talloc_free(r);
3063 return false;
3064 }
3065
3066 ndr_err = call->ndr_push(push, NDR_OUT, r);
3067 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3068 talloc_free(r);
3069 return false;
3070 }
3071
3072 blob = ndr_push_blob(push);
3073 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3074 talloc_free(r);
3075 return false;
3076 }
3077
3078 talloc_free(r);
3079
3080 return true;
3081}
3082
3083static bool api_samr_GetGroupsForUser(pipes_struct *p)
3084{
3085 const struct ndr_interface_call *call;
3086 struct ndr_pull *pull;
3087 struct ndr_push *push;
3088 enum ndr_err_code ndr_err;
3089 DATA_BLOB blob;
3090 struct samr_GetGroupsForUser *r;
3091
3092 call = &ndr_table_samr.calls[NDR_SAMR_GETGROUPSFORUSER];
3093
3094 r = talloc(talloc_tos(), struct samr_GetGroupsForUser);
3095 if (r == NULL) {
3096 return false;
3097 }
3098
3099 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3100 talloc_free(r);
3101 return false;
3102 }
3103
3104 pull = ndr_pull_init_blob(&blob, r, NULL);
3105 if (pull == NULL) {
3106 talloc_free(r);
3107 return false;
3108 }
3109
3110 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3111 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3112 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3113 talloc_free(r);
3114 return false;
3115 }
3116
3117 if (DEBUGLEVEL >= 10) {
3118 NDR_PRINT_IN_DEBUG(samr_GetGroupsForUser, r);
3119 }
3120
3121 ZERO_STRUCT(r->out);
3122 r->out.rids = talloc_zero(r, struct samr_RidWithAttributeArray *);
3123 if (r->out.rids == NULL) {
3124 talloc_free(r);
3125 return false;
3126 }
3127
3128 r->out.result = _samr_GetGroupsForUser(p, r);
3129
3130 if (p->rng_fault_state) {
3131 talloc_free(r);
3132 /* Return true here, srv_pipe_hnd.c will take care */
3133 return true;
3134 }
3135
3136 if (DEBUGLEVEL >= 10) {
3137 NDR_PRINT_OUT_DEBUG(samr_GetGroupsForUser, r);
3138 }
3139
3140 push = ndr_push_init_ctx(r, NULL);
3141 if (push == NULL) {
3142 talloc_free(r);
3143 return false;
3144 }
3145
3146 ndr_err = call->ndr_push(push, NDR_OUT, r);
3147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3148 talloc_free(r);
3149 return false;
3150 }
3151
3152 blob = ndr_push_blob(push);
3153 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3154 talloc_free(r);
3155 return false;
3156 }
3157
3158 talloc_free(r);
3159
3160 return true;
3161}
3162
3163static bool api_samr_QueryDisplayInfo(pipes_struct *p)
3164{
3165 const struct ndr_interface_call *call;
3166 struct ndr_pull *pull;
3167 struct ndr_push *push;
3168 enum ndr_err_code ndr_err;
3169 DATA_BLOB blob;
3170 struct samr_QueryDisplayInfo *r;
3171
3172 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO];
3173
3174 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo);
3175 if (r == NULL) {
3176 return false;
3177 }
3178
3179 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3180 talloc_free(r);
3181 return false;
3182 }
3183
3184 pull = ndr_pull_init_blob(&blob, r, NULL);
3185 if (pull == NULL) {
3186 talloc_free(r);
3187 return false;
3188 }
3189
3190 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3191 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3192 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3193 talloc_free(r);
3194 return false;
3195 }
3196
3197 if (DEBUGLEVEL >= 10) {
3198 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo, r);
3199 }
3200
3201 ZERO_STRUCT(r->out);
3202 r->out.total_size = talloc_zero(r, uint32_t);
3203 if (r->out.total_size == NULL) {
3204 talloc_free(r);
3205 return false;
3206 }
3207
3208 r->out.returned_size = talloc_zero(r, uint32_t);
3209 if (r->out.returned_size == NULL) {
3210 talloc_free(r);
3211 return false;
3212 }
3213
3214 r->out.info = talloc_zero(r, union samr_DispInfo);
3215 if (r->out.info == NULL) {
3216 talloc_free(r);
3217 return false;
3218 }
3219
3220 r->out.result = _samr_QueryDisplayInfo(p, r);
3221
3222 if (p->rng_fault_state) {
3223 talloc_free(r);
3224 /* Return true here, srv_pipe_hnd.c will take care */
3225 return true;
3226 }
3227
3228 if (DEBUGLEVEL >= 10) {
3229 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo, r);
3230 }
3231
3232 push = ndr_push_init_ctx(r, NULL);
3233 if (push == NULL) {
3234 talloc_free(r);
3235 return false;
3236 }
3237
3238 ndr_err = call->ndr_push(push, NDR_OUT, r);
3239 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3240 talloc_free(r);
3241 return false;
3242 }
3243
3244 blob = ndr_push_blob(push);
3245 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3246 talloc_free(r);
3247 return false;
3248 }
3249
3250 talloc_free(r);
3251
3252 return true;
3253}
3254
3255static bool api_samr_GetDisplayEnumerationIndex(pipes_struct *p)
3256{
3257 const struct ndr_interface_call *call;
3258 struct ndr_pull *pull;
3259 struct ndr_push *push;
3260 enum ndr_err_code ndr_err;
3261 DATA_BLOB blob;
3262 struct samr_GetDisplayEnumerationIndex *r;
3263
3264 call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX];
3265
3266 r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex);
3267 if (r == NULL) {
3268 return false;
3269 }
3270
3271 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3272 talloc_free(r);
3273 return false;
3274 }
3275
3276 pull = ndr_pull_init_blob(&blob, r, NULL);
3277 if (pull == NULL) {
3278 talloc_free(r);
3279 return false;
3280 }
3281
3282 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3283 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3284 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3285 talloc_free(r);
3286 return false;
3287 }
3288
3289 if (DEBUGLEVEL >= 10) {
3290 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex, r);
3291 }
3292
3293 ZERO_STRUCT(r->out);
3294 r->out.idx = talloc_zero(r, uint32_t);
3295 if (r->out.idx == NULL) {
3296 talloc_free(r);
3297 return false;
3298 }
3299
3300 r->out.result = _samr_GetDisplayEnumerationIndex(p, r);
3301
3302 if (p->rng_fault_state) {
3303 talloc_free(r);
3304 /* Return true here, srv_pipe_hnd.c will take care */
3305 return true;
3306 }
3307
3308 if (DEBUGLEVEL >= 10) {
3309 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex, r);
3310 }
3311
3312 push = ndr_push_init_ctx(r, NULL);
3313 if (push == NULL) {
3314 talloc_free(r);
3315 return false;
3316 }
3317
3318 ndr_err = call->ndr_push(push, NDR_OUT, r);
3319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3320 talloc_free(r);
3321 return false;
3322 }
3323
3324 blob = ndr_push_blob(push);
3325 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3326 talloc_free(r);
3327 return false;
3328 }
3329
3330 talloc_free(r);
3331
3332 return true;
3333}
3334
3335static bool api_samr_TestPrivateFunctionsDomain(pipes_struct *p)
3336{
3337 const struct ndr_interface_call *call;
3338 struct ndr_pull *pull;
3339 struct ndr_push *push;
3340 enum ndr_err_code ndr_err;
3341 DATA_BLOB blob;
3342 struct samr_TestPrivateFunctionsDomain *r;
3343
3344 call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN];
3345
3346 r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsDomain);
3347 if (r == NULL) {
3348 return false;
3349 }
3350
3351 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3352 talloc_free(r);
3353 return false;
3354 }
3355
3356 pull = ndr_pull_init_blob(&blob, r, NULL);
3357 if (pull == NULL) {
3358 talloc_free(r);
3359 return false;
3360 }
3361
3362 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3363 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3365 talloc_free(r);
3366 return false;
3367 }
3368
3369 if (DEBUGLEVEL >= 10) {
3370 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsDomain, r);
3371 }
3372
3373 r->out.result = _samr_TestPrivateFunctionsDomain(p, r);
3374
3375 if (p->rng_fault_state) {
3376 talloc_free(r);
3377 /* Return true here, srv_pipe_hnd.c will take care */
3378 return true;
3379 }
3380
3381 if (DEBUGLEVEL >= 10) {
3382 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsDomain, r);
3383 }
3384
3385 push = ndr_push_init_ctx(r, NULL);
3386 if (push == NULL) {
3387 talloc_free(r);
3388 return false;
3389 }
3390
3391 ndr_err = call->ndr_push(push, NDR_OUT, r);
3392 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3393 talloc_free(r);
3394 return false;
3395 }
3396
3397 blob = ndr_push_blob(push);
3398 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3399 talloc_free(r);
3400 return false;
3401 }
3402
3403 talloc_free(r);
3404
3405 return true;
3406}
3407
3408static bool api_samr_TestPrivateFunctionsUser(pipes_struct *p)
3409{
3410 const struct ndr_interface_call *call;
3411 struct ndr_pull *pull;
3412 struct ndr_push *push;
3413 enum ndr_err_code ndr_err;
3414 DATA_BLOB blob;
3415 struct samr_TestPrivateFunctionsUser *r;
3416
3417 call = &ndr_table_samr.calls[NDR_SAMR_TESTPRIVATEFUNCTIONSUSER];
3418
3419 r = talloc(talloc_tos(), struct samr_TestPrivateFunctionsUser);
3420 if (r == NULL) {
3421 return false;
3422 }
3423
3424 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3425 talloc_free(r);
3426 return false;
3427 }
3428
3429 pull = ndr_pull_init_blob(&blob, r, NULL);
3430 if (pull == NULL) {
3431 talloc_free(r);
3432 return false;
3433 }
3434
3435 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3436 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3437 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3438 talloc_free(r);
3439 return false;
3440 }
3441
3442 if (DEBUGLEVEL >= 10) {
3443 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsUser, r);
3444 }
3445
3446 r->out.result = _samr_TestPrivateFunctionsUser(p, r);
3447
3448 if (p->rng_fault_state) {
3449 talloc_free(r);
3450 /* Return true here, srv_pipe_hnd.c will take care */
3451 return true;
3452 }
3453
3454 if (DEBUGLEVEL >= 10) {
3455 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsUser, r);
3456 }
3457
3458 push = ndr_push_init_ctx(r, NULL);
3459 if (push == NULL) {
3460 talloc_free(r);
3461 return false;
3462 }
3463
3464 ndr_err = call->ndr_push(push, NDR_OUT, r);
3465 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3466 talloc_free(r);
3467 return false;
3468 }
3469
3470 blob = ndr_push_blob(push);
3471 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3472 talloc_free(r);
3473 return false;
3474 }
3475
3476 talloc_free(r);
3477
3478 return true;
3479}
3480
3481static bool api_samr_GetUserPwInfo(pipes_struct *p)
3482{
3483 const struct ndr_interface_call *call;
3484 struct ndr_pull *pull;
3485 struct ndr_push *push;
3486 enum ndr_err_code ndr_err;
3487 DATA_BLOB blob;
3488 struct samr_GetUserPwInfo *r;
3489
3490 call = &ndr_table_samr.calls[NDR_SAMR_GETUSERPWINFO];
3491
3492 r = talloc(talloc_tos(), struct samr_GetUserPwInfo);
3493 if (r == NULL) {
3494 return false;
3495 }
3496
3497 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3498 talloc_free(r);
3499 return false;
3500 }
3501
3502 pull = ndr_pull_init_blob(&blob, r, NULL);
3503 if (pull == NULL) {
3504 talloc_free(r);
3505 return false;
3506 }
3507
3508 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3509 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3510 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3511 talloc_free(r);
3512 return false;
3513 }
3514
3515 if (DEBUGLEVEL >= 10) {
3516 NDR_PRINT_IN_DEBUG(samr_GetUserPwInfo, r);
3517 }
3518
3519 ZERO_STRUCT(r->out);
3520 r->out.info = talloc_zero(r, struct samr_PwInfo);
3521 if (r->out.info == NULL) {
3522 talloc_free(r);
3523 return false;
3524 }
3525
3526 r->out.result = _samr_GetUserPwInfo(p, r);
3527
3528 if (p->rng_fault_state) {
3529 talloc_free(r);
3530 /* Return true here, srv_pipe_hnd.c will take care */
3531 return true;
3532 }
3533
3534 if (DEBUGLEVEL >= 10) {
3535 NDR_PRINT_OUT_DEBUG(samr_GetUserPwInfo, r);
3536 }
3537
3538 push = ndr_push_init_ctx(r, NULL);
3539 if (push == NULL) {
3540 talloc_free(r);
3541 return false;
3542 }
3543
3544 ndr_err = call->ndr_push(push, NDR_OUT, r);
3545 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3546 talloc_free(r);
3547 return false;
3548 }
3549
3550 blob = ndr_push_blob(push);
3551 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3552 talloc_free(r);
3553 return false;
3554 }
3555
3556 talloc_free(r);
3557
3558 return true;
3559}
3560
3561static bool api_samr_RemoveMemberFromForeignDomain(pipes_struct *p)
3562{
3563 const struct ndr_interface_call *call;
3564 struct ndr_pull *pull;
3565 struct ndr_push *push;
3566 enum ndr_err_code ndr_err;
3567 DATA_BLOB blob;
3568 struct samr_RemoveMemberFromForeignDomain *r;
3569
3570 call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN];
3571
3572 r = talloc(talloc_tos(), struct samr_RemoveMemberFromForeignDomain);
3573 if (r == NULL) {
3574 return false;
3575 }
3576
3577 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3578 talloc_free(r);
3579 return false;
3580 }
3581
3582 pull = ndr_pull_init_blob(&blob, r, NULL);
3583 if (pull == NULL) {
3584 talloc_free(r);
3585 return false;
3586 }
3587
3588 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3589 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3590 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3591 talloc_free(r);
3592 return false;
3593 }
3594
3595 if (DEBUGLEVEL >= 10) {
3596 NDR_PRINT_IN_DEBUG(samr_RemoveMemberFromForeignDomain, r);
3597 }
3598
3599 r->out.result = _samr_RemoveMemberFromForeignDomain(p, r);
3600
3601 if (p->rng_fault_state) {
3602 talloc_free(r);
3603 /* Return true here, srv_pipe_hnd.c will take care */
3604 return true;
3605 }
3606
3607 if (DEBUGLEVEL >= 10) {
3608 NDR_PRINT_OUT_DEBUG(samr_RemoveMemberFromForeignDomain, r);
3609 }
3610
3611 push = ndr_push_init_ctx(r, NULL);
3612 if (push == NULL) {
3613 talloc_free(r);
3614 return false;
3615 }
3616
3617 ndr_err = call->ndr_push(push, NDR_OUT, r);
3618 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3619 talloc_free(r);
3620 return false;
3621 }
3622
3623 blob = ndr_push_blob(push);
3624 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3625 talloc_free(r);
3626 return false;
3627 }
3628
3629 talloc_free(r);
3630
3631 return true;
3632}
3633
3634static bool api_samr_QueryDomainInfo2(pipes_struct *p)
3635{
3636 const struct ndr_interface_call *call;
3637 struct ndr_pull *pull;
3638 struct ndr_push *push;
3639 enum ndr_err_code ndr_err;
3640 DATA_BLOB blob;
3641 struct samr_QueryDomainInfo2 *r;
3642
3643 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDOMAININFO2];
3644
3645 r = talloc(talloc_tos(), struct samr_QueryDomainInfo2);
3646 if (r == NULL) {
3647 return false;
3648 }
3649
3650 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3651 talloc_free(r);
3652 return false;
3653 }
3654
3655 pull = ndr_pull_init_blob(&blob, r, NULL);
3656 if (pull == NULL) {
3657 talloc_free(r);
3658 return false;
3659 }
3660
3661 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3662 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3663 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3664 talloc_free(r);
3665 return false;
3666 }
3667
3668 if (DEBUGLEVEL >= 10) {
3669 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo2, r);
3670 }
3671
3672 ZERO_STRUCT(r->out);
3673 r->out.info = talloc_zero(r, union samr_DomainInfo *);
3674 if (r->out.info == NULL) {
3675 talloc_free(r);
3676 return false;
3677 }
3678
3679 r->out.result = _samr_QueryDomainInfo2(p, r);
3680
3681 if (p->rng_fault_state) {
3682 talloc_free(r);
3683 /* Return true here, srv_pipe_hnd.c will take care */
3684 return true;
3685 }
3686
3687 if (DEBUGLEVEL >= 10) {
3688 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo2, r);
3689 }
3690
3691 push = ndr_push_init_ctx(r, NULL);
3692 if (push == NULL) {
3693 talloc_free(r);
3694 return false;
3695 }
3696
3697 ndr_err = call->ndr_push(push, NDR_OUT, r);
3698 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3699 talloc_free(r);
3700 return false;
3701 }
3702
3703 blob = ndr_push_blob(push);
3704 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3705 talloc_free(r);
3706 return false;
3707 }
3708
3709 talloc_free(r);
3710
3711 return true;
3712}
3713
3714static bool api_samr_QueryUserInfo2(pipes_struct *p)
3715{
3716 const struct ndr_interface_call *call;
3717 struct ndr_pull *pull;
3718 struct ndr_push *push;
3719 enum ndr_err_code ndr_err;
3720 DATA_BLOB blob;
3721 struct samr_QueryUserInfo2 *r;
3722
3723 call = &ndr_table_samr.calls[NDR_SAMR_QUERYUSERINFO2];
3724
3725 r = talloc(talloc_tos(), struct samr_QueryUserInfo2);
3726 if (r == NULL) {
3727 return false;
3728 }
3729
3730 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3731 talloc_free(r);
3732 return false;
3733 }
3734
3735 pull = ndr_pull_init_blob(&blob, r, NULL);
3736 if (pull == NULL) {
3737 talloc_free(r);
3738 return false;
3739 }
3740
3741 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3742 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3743 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3744 talloc_free(r);
3745 return false;
3746 }
3747
3748 if (DEBUGLEVEL >= 10) {
3749 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo2, r);
3750 }
3751
3752 ZERO_STRUCT(r->out);
3753 r->out.info = talloc_zero(r, union samr_UserInfo *);
3754 if (r->out.info == NULL) {
3755 talloc_free(r);
3756 return false;
3757 }
3758
3759 r->out.result = _samr_QueryUserInfo2(p, r);
3760
3761 if (p->rng_fault_state) {
3762 talloc_free(r);
3763 /* Return true here, srv_pipe_hnd.c will take care */
3764 return true;
3765 }
3766
3767 if (DEBUGLEVEL >= 10) {
3768 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo2, r);
3769 }
3770
3771 push = ndr_push_init_ctx(r, NULL);
3772 if (push == NULL) {
3773 talloc_free(r);
3774 return false;
3775 }
3776
3777 ndr_err = call->ndr_push(push, NDR_OUT, r);
3778 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3779 talloc_free(r);
3780 return false;
3781 }
3782
3783 blob = ndr_push_blob(push);
3784 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3785 talloc_free(r);
3786 return false;
3787 }
3788
3789 talloc_free(r);
3790
3791 return true;
3792}
3793
3794static bool api_samr_QueryDisplayInfo2(pipes_struct *p)
3795{
3796 const struct ndr_interface_call *call;
3797 struct ndr_pull *pull;
3798 struct ndr_push *push;
3799 enum ndr_err_code ndr_err;
3800 DATA_BLOB blob;
3801 struct samr_QueryDisplayInfo2 *r;
3802
3803 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO2];
3804
3805 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo2);
3806 if (r == NULL) {
3807 return false;
3808 }
3809
3810 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3811 talloc_free(r);
3812 return false;
3813 }
3814
3815 pull = ndr_pull_init_blob(&blob, r, NULL);
3816 if (pull == NULL) {
3817 talloc_free(r);
3818 return false;
3819 }
3820
3821 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3822 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3823 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3824 talloc_free(r);
3825 return false;
3826 }
3827
3828 if (DEBUGLEVEL >= 10) {
3829 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo2, r);
3830 }
3831
3832 ZERO_STRUCT(r->out);
3833 r->out.total_size = talloc_zero(r, uint32_t);
3834 if (r->out.total_size == NULL) {
3835 talloc_free(r);
3836 return false;
3837 }
3838
3839 r->out.returned_size = talloc_zero(r, uint32_t);
3840 if (r->out.returned_size == NULL) {
3841 talloc_free(r);
3842 return false;
3843 }
3844
3845 r->out.info = talloc_zero(r, union samr_DispInfo);
3846 if (r->out.info == NULL) {
3847 talloc_free(r);
3848 return false;
3849 }
3850
3851 r->out.result = _samr_QueryDisplayInfo2(p, r);
3852
3853 if (p->rng_fault_state) {
3854 talloc_free(r);
3855 /* Return true here, srv_pipe_hnd.c will take care */
3856 return true;
3857 }
3858
3859 if (DEBUGLEVEL >= 10) {
3860 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo2, r);
3861 }
3862
3863 push = ndr_push_init_ctx(r, NULL);
3864 if (push == NULL) {
3865 talloc_free(r);
3866 return false;
3867 }
3868
3869 ndr_err = call->ndr_push(push, NDR_OUT, r);
3870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3871 talloc_free(r);
3872 return false;
3873 }
3874
3875 blob = ndr_push_blob(push);
3876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3877 talloc_free(r);
3878 return false;
3879 }
3880
3881 talloc_free(r);
3882
3883 return true;
3884}
3885
3886static bool api_samr_GetDisplayEnumerationIndex2(pipes_struct *p)
3887{
3888 const struct ndr_interface_call *call;
3889 struct ndr_pull *pull;
3890 struct ndr_push *push;
3891 enum ndr_err_code ndr_err;
3892 DATA_BLOB blob;
3893 struct samr_GetDisplayEnumerationIndex2 *r;
3894
3895 call = &ndr_table_samr.calls[NDR_SAMR_GETDISPLAYENUMERATIONINDEX2];
3896
3897 r = talloc(talloc_tos(), struct samr_GetDisplayEnumerationIndex2);
3898 if (r == NULL) {
3899 return false;
3900 }
3901
3902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3903 talloc_free(r);
3904 return false;
3905 }
3906
3907 pull = ndr_pull_init_blob(&blob, r, NULL);
3908 if (pull == NULL) {
3909 talloc_free(r);
3910 return false;
3911 }
3912
3913 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3914 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3916 talloc_free(r);
3917 return false;
3918 }
3919
3920 if (DEBUGLEVEL >= 10) {
3921 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex2, r);
3922 }
3923
3924 ZERO_STRUCT(r->out);
3925 r->out.idx = talloc_zero(r, uint32_t);
3926 if (r->out.idx == NULL) {
3927 talloc_free(r);
3928 return false;
3929 }
3930
3931 r->out.result = _samr_GetDisplayEnumerationIndex2(p, r);
3932
3933 if (p->rng_fault_state) {
3934 talloc_free(r);
3935 /* Return true here, srv_pipe_hnd.c will take care */
3936 return true;
3937 }
3938
3939 if (DEBUGLEVEL >= 10) {
3940 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex2, r);
3941 }
3942
3943 push = ndr_push_init_ctx(r, NULL);
3944 if (push == NULL) {
3945 talloc_free(r);
3946 return false;
3947 }
3948
3949 ndr_err = call->ndr_push(push, NDR_OUT, r);
3950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3951 talloc_free(r);
3952 return false;
3953 }
3954
3955 blob = ndr_push_blob(push);
3956 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3957 talloc_free(r);
3958 return false;
3959 }
3960
3961 talloc_free(r);
3962
3963 return true;
3964}
3965
3966static bool api_samr_CreateUser2(pipes_struct *p)
3967{
3968 const struct ndr_interface_call *call;
3969 struct ndr_pull *pull;
3970 struct ndr_push *push;
3971 enum ndr_err_code ndr_err;
3972 DATA_BLOB blob;
3973 struct samr_CreateUser2 *r;
3974
3975 call = &ndr_table_samr.calls[NDR_SAMR_CREATEUSER2];
3976
3977 r = talloc(talloc_tos(), struct samr_CreateUser2);
3978 if (r == NULL) {
3979 return false;
3980 }
3981
3982 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3983 talloc_free(r);
3984 return false;
3985 }
3986
3987 pull = ndr_pull_init_blob(&blob, r, NULL);
3988 if (pull == NULL) {
3989 talloc_free(r);
3990 return false;
3991 }
3992
3993 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3994 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3995 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3996 talloc_free(r);
3997 return false;
3998 }
3999
4000 if (DEBUGLEVEL >= 10) {
4001 NDR_PRINT_IN_DEBUG(samr_CreateUser2, r);
4002 }
4003
4004 ZERO_STRUCT(r->out);
4005 r->out.user_handle = talloc_zero(r, struct policy_handle);
4006 if (r->out.user_handle == NULL) {
4007 talloc_free(r);
4008 return false;
4009 }
4010
4011 r->out.access_granted = talloc_zero(r, uint32_t);
4012 if (r->out.access_granted == NULL) {
4013 talloc_free(r);
4014 return false;
4015 }
4016
4017 r->out.rid = talloc_zero(r, uint32_t);
4018 if (r->out.rid == NULL) {
4019 talloc_free(r);
4020 return false;
4021 }
4022
4023 r->out.result = _samr_CreateUser2(p, r);
4024
4025 if (p->rng_fault_state) {
4026 talloc_free(r);
4027 /* Return true here, srv_pipe_hnd.c will take care */
4028 return true;
4029 }
4030
4031 if (DEBUGLEVEL >= 10) {
4032 NDR_PRINT_OUT_DEBUG(samr_CreateUser2, r);
4033 }
4034
4035 push = ndr_push_init_ctx(r, NULL);
4036 if (push == NULL) {
4037 talloc_free(r);
4038 return false;
4039 }
4040
4041 ndr_err = call->ndr_push(push, NDR_OUT, r);
4042 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4043 talloc_free(r);
4044 return false;
4045 }
4046
4047 blob = ndr_push_blob(push);
4048 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4049 talloc_free(r);
4050 return false;
4051 }
4052
4053 talloc_free(r);
4054
4055 return true;
4056}
4057
4058static bool api_samr_QueryDisplayInfo3(pipes_struct *p)
4059{
4060 const struct ndr_interface_call *call;
4061 struct ndr_pull *pull;
4062 struct ndr_push *push;
4063 enum ndr_err_code ndr_err;
4064 DATA_BLOB blob;
4065 struct samr_QueryDisplayInfo3 *r;
4066
4067 call = &ndr_table_samr.calls[NDR_SAMR_QUERYDISPLAYINFO3];
4068
4069 r = talloc(talloc_tos(), struct samr_QueryDisplayInfo3);
4070 if (r == NULL) {
4071 return false;
4072 }
4073
4074 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4075 talloc_free(r);
4076 return false;
4077 }
4078
4079 pull = ndr_pull_init_blob(&blob, r, NULL);
4080 if (pull == NULL) {
4081 talloc_free(r);
4082 return false;
4083 }
4084
4085 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4086 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4087 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4088 talloc_free(r);
4089 return false;
4090 }
4091
4092 if (DEBUGLEVEL >= 10) {
4093 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo3, r);
4094 }
4095
4096 ZERO_STRUCT(r->out);
4097 r->out.total_size = talloc_zero(r, uint32_t);
4098 if (r->out.total_size == NULL) {
4099 talloc_free(r);
4100 return false;
4101 }
4102
4103 r->out.returned_size = talloc_zero(r, uint32_t);
4104 if (r->out.returned_size == NULL) {
4105 talloc_free(r);
4106 return false;
4107 }
4108
4109 r->out.info = talloc_zero(r, union samr_DispInfo);
4110 if (r->out.info == NULL) {
4111 talloc_free(r);
4112 return false;
4113 }
4114
4115 r->out.result = _samr_QueryDisplayInfo3(p, r);
4116
4117 if (p->rng_fault_state) {
4118 talloc_free(r);
4119 /* Return true here, srv_pipe_hnd.c will take care */
4120 return true;
4121 }
4122
4123 if (DEBUGLEVEL >= 10) {
4124 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo3, r);
4125 }
4126
4127 push = ndr_push_init_ctx(r, NULL);
4128 if (push == NULL) {
4129 talloc_free(r);
4130 return false;
4131 }
4132
4133 ndr_err = call->ndr_push(push, NDR_OUT, r);
4134 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4135 talloc_free(r);
4136 return false;
4137 }
4138
4139 blob = ndr_push_blob(push);
4140 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4141 talloc_free(r);
4142 return false;
4143 }
4144
4145 talloc_free(r);
4146
4147 return true;
4148}
4149
4150static bool api_samr_AddMultipleMembersToAlias(pipes_struct *p)
4151{
4152 const struct ndr_interface_call *call;
4153 struct ndr_pull *pull;
4154 struct ndr_push *push;
4155 enum ndr_err_code ndr_err;
4156 DATA_BLOB blob;
4157 struct samr_AddMultipleMembersToAlias *r;
4158
4159 call = &ndr_table_samr.calls[NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS];
4160
4161 r = talloc(talloc_tos(), struct samr_AddMultipleMembersToAlias);
4162 if (r == NULL) {
4163 return false;
4164 }
4165
4166 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4167 talloc_free(r);
4168 return false;
4169 }
4170
4171 pull = ndr_pull_init_blob(&blob, r, NULL);
4172 if (pull == NULL) {
4173 talloc_free(r);
4174 return false;
4175 }
4176
4177 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4178 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4179 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4180 talloc_free(r);
4181 return false;
4182 }
4183
4184 if (DEBUGLEVEL >= 10) {
4185 NDR_PRINT_IN_DEBUG(samr_AddMultipleMembersToAlias, r);
4186 }
4187
4188 r->out.result = _samr_AddMultipleMembersToAlias(p, r);
4189
4190 if (p->rng_fault_state) {
4191 talloc_free(r);
4192 /* Return true here, srv_pipe_hnd.c will take care */
4193 return true;
4194 }
4195
4196 if (DEBUGLEVEL >= 10) {
4197 NDR_PRINT_OUT_DEBUG(samr_AddMultipleMembersToAlias, r);
4198 }
4199
4200 push = ndr_push_init_ctx(r, NULL);
4201 if (push == NULL) {
4202 talloc_free(r);
4203 return false;
4204 }
4205
4206 ndr_err = call->ndr_push(push, NDR_OUT, r);
4207 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4208 talloc_free(r);
4209 return false;
4210 }
4211
4212 blob = ndr_push_blob(push);
4213 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4214 talloc_free(r);
4215 return false;
4216 }
4217
4218 talloc_free(r);
4219
4220 return true;
4221}
4222
4223static bool api_samr_RemoveMultipleMembersFromAlias(pipes_struct *p)
4224{
4225 const struct ndr_interface_call *call;
4226 struct ndr_pull *pull;
4227 struct ndr_push *push;
4228 enum ndr_err_code ndr_err;
4229 DATA_BLOB blob;
4230 struct samr_RemoveMultipleMembersFromAlias *r;
4231
4232 call = &ndr_table_samr.calls[NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS];
4233
4234 r = talloc(talloc_tos(), struct samr_RemoveMultipleMembersFromAlias);
4235 if (r == NULL) {
4236 return false;
4237 }
4238
4239 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4240 talloc_free(r);
4241 return false;
4242 }
4243
4244 pull = ndr_pull_init_blob(&blob, r, NULL);
4245 if (pull == NULL) {
4246 talloc_free(r);
4247 return false;
4248 }
4249
4250 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4251 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4252 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4253 talloc_free(r);
4254 return false;
4255 }
4256
4257 if (DEBUGLEVEL >= 10) {
4258 NDR_PRINT_IN_DEBUG(samr_RemoveMultipleMembersFromAlias, r);
4259 }
4260
4261 r->out.result = _samr_RemoveMultipleMembersFromAlias(p, r);
4262
4263 if (p->rng_fault_state) {
4264 talloc_free(r);
4265 /* Return true here, srv_pipe_hnd.c will take care */
4266 return true;
4267 }
4268
4269 if (DEBUGLEVEL >= 10) {
4270 NDR_PRINT_OUT_DEBUG(samr_RemoveMultipleMembersFromAlias, r);
4271 }
4272
4273 push = ndr_push_init_ctx(r, NULL);
4274 if (push == NULL) {
4275 talloc_free(r);
4276 return false;
4277 }
4278
4279 ndr_err = call->ndr_push(push, NDR_OUT, r);
4280 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4281 talloc_free(r);
4282 return false;
4283 }
4284
4285 blob = ndr_push_blob(push);
4286 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4287 talloc_free(r);
4288 return false;
4289 }
4290
4291 talloc_free(r);
4292
4293 return true;
4294}
4295
4296static bool api_samr_OemChangePasswordUser2(pipes_struct *p)
4297{
4298 const struct ndr_interface_call *call;
4299 struct ndr_pull *pull;
4300 struct ndr_push *push;
4301 enum ndr_err_code ndr_err;
4302 DATA_BLOB blob;
4303 struct samr_OemChangePasswordUser2 *r;
4304
4305 call = &ndr_table_samr.calls[NDR_SAMR_OEMCHANGEPASSWORDUSER2];
4306
4307 r = talloc(talloc_tos(), struct samr_OemChangePasswordUser2);
4308 if (r == NULL) {
4309 return false;
4310 }
4311
4312 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4313 talloc_free(r);
4314 return false;
4315 }
4316
4317 pull = ndr_pull_init_blob(&blob, r, NULL);
4318 if (pull == NULL) {
4319 talloc_free(r);
4320 return false;
4321 }
4322
4323 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4324 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4325 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4326 talloc_free(r);
4327 return false;
4328 }
4329
4330 if (DEBUGLEVEL >= 10) {
4331 NDR_PRINT_IN_DEBUG(samr_OemChangePasswordUser2, r);
4332 }
4333
4334 r->out.result = _samr_OemChangePasswordUser2(p, r);
4335
4336 if (p->rng_fault_state) {
4337 talloc_free(r);
4338 /* Return true here, srv_pipe_hnd.c will take care */
4339 return true;
4340 }
4341
4342 if (DEBUGLEVEL >= 10) {
4343 NDR_PRINT_OUT_DEBUG(samr_OemChangePasswordUser2, r);
4344 }
4345
4346 push = ndr_push_init_ctx(r, NULL);
4347 if (push == NULL) {
4348 talloc_free(r);
4349 return false;
4350 }
4351
4352 ndr_err = call->ndr_push(push, NDR_OUT, r);
4353 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4354 talloc_free(r);
4355 return false;
4356 }
4357
4358 blob = ndr_push_blob(push);
4359 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4360 talloc_free(r);
4361 return false;
4362 }
4363
4364 talloc_free(r);
4365
4366 return true;
4367}
4368
4369static bool api_samr_ChangePasswordUser2(pipes_struct *p)
4370{
4371 const struct ndr_interface_call *call;
4372 struct ndr_pull *pull;
4373 struct ndr_push *push;
4374 enum ndr_err_code ndr_err;
4375 DATA_BLOB blob;
4376 struct samr_ChangePasswordUser2 *r;
4377
4378 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER2];
4379
4380 r = talloc(talloc_tos(), struct samr_ChangePasswordUser2);
4381 if (r == NULL) {
4382 return false;
4383 }
4384
4385 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4386 talloc_free(r);
4387 return false;
4388 }
4389
4390 pull = ndr_pull_init_blob(&blob, r, NULL);
4391 if (pull == NULL) {
4392 talloc_free(r);
4393 return false;
4394 }
4395
4396 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4397 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4398 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4399 talloc_free(r);
4400 return false;
4401 }
4402
4403 if (DEBUGLEVEL >= 10) {
4404 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser2, r);
4405 }
4406
4407 r->out.result = _samr_ChangePasswordUser2(p, r);
4408
4409 if (p->rng_fault_state) {
4410 talloc_free(r);
4411 /* Return true here, srv_pipe_hnd.c will take care */
4412 return true;
4413 }
4414
4415 if (DEBUGLEVEL >= 10) {
4416 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser2, r);
4417 }
4418
4419 push = ndr_push_init_ctx(r, NULL);
4420 if (push == NULL) {
4421 talloc_free(r);
4422 return false;
4423 }
4424
4425 ndr_err = call->ndr_push(push, NDR_OUT, r);
4426 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4427 talloc_free(r);
4428 return false;
4429 }
4430
4431 blob = ndr_push_blob(push);
4432 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4433 talloc_free(r);
4434 return false;
4435 }
4436
4437 talloc_free(r);
4438
4439 return true;
4440}
4441
4442static bool api_samr_GetDomPwInfo(pipes_struct *p)
4443{
4444 const struct ndr_interface_call *call;
4445 struct ndr_pull *pull;
4446 struct ndr_push *push;
4447 enum ndr_err_code ndr_err;
4448 DATA_BLOB blob;
4449 struct samr_GetDomPwInfo *r;
4450
4451 call = &ndr_table_samr.calls[NDR_SAMR_GETDOMPWINFO];
4452
4453 r = talloc(talloc_tos(), struct samr_GetDomPwInfo);
4454 if (r == NULL) {
4455 return false;
4456 }
4457
4458 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4459 talloc_free(r);
4460 return false;
4461 }
4462
4463 pull = ndr_pull_init_blob(&blob, r, NULL);
4464 if (pull == NULL) {
4465 talloc_free(r);
4466 return false;
4467 }
4468
4469 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4470 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4471 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4472 talloc_free(r);
4473 return false;
4474 }
4475
4476 if (DEBUGLEVEL >= 10) {
4477 NDR_PRINT_IN_DEBUG(samr_GetDomPwInfo, r);
4478 }
4479
4480 ZERO_STRUCT(r->out);
4481 r->out.info = talloc_zero(r, struct samr_PwInfo);
4482 if (r->out.info == NULL) {
4483 talloc_free(r);
4484 return false;
4485 }
4486
4487 r->out.result = _samr_GetDomPwInfo(p, r);
4488
4489 if (p->rng_fault_state) {
4490 talloc_free(r);
4491 /* Return true here, srv_pipe_hnd.c will take care */
4492 return true;
4493 }
4494
4495 if (DEBUGLEVEL >= 10) {
4496 NDR_PRINT_OUT_DEBUG(samr_GetDomPwInfo, r);
4497 }
4498
4499 push = ndr_push_init_ctx(r, NULL);
4500 if (push == NULL) {
4501 talloc_free(r);
4502 return false;
4503 }
4504
4505 ndr_err = call->ndr_push(push, NDR_OUT, r);
4506 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4507 talloc_free(r);
4508 return false;
4509 }
4510
4511 blob = ndr_push_blob(push);
4512 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4513 talloc_free(r);
4514 return false;
4515 }
4516
4517 talloc_free(r);
4518
4519 return true;
4520}
4521
4522static bool api_samr_Connect2(pipes_struct *p)
4523{
4524 const struct ndr_interface_call *call;
4525 struct ndr_pull *pull;
4526 struct ndr_push *push;
4527 enum ndr_err_code ndr_err;
4528 DATA_BLOB blob;
4529 struct samr_Connect2 *r;
4530
4531 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT2];
4532
4533 r = talloc(talloc_tos(), struct samr_Connect2);
4534 if (r == NULL) {
4535 return false;
4536 }
4537
4538 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4539 talloc_free(r);
4540 return false;
4541 }
4542
4543 pull = ndr_pull_init_blob(&blob, r, NULL);
4544 if (pull == NULL) {
4545 talloc_free(r);
4546 return false;
4547 }
4548
4549 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4550 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4551 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4552 talloc_free(r);
4553 return false;
4554 }
4555
4556 if (DEBUGLEVEL >= 10) {
4557 NDR_PRINT_IN_DEBUG(samr_Connect2, r);
4558 }
4559
4560 ZERO_STRUCT(r->out);
4561 r->out.connect_handle = talloc_zero(r, struct policy_handle);
4562 if (r->out.connect_handle == NULL) {
4563 talloc_free(r);
4564 return false;
4565 }
4566
4567 r->out.result = _samr_Connect2(p, r);
4568
4569 if (p->rng_fault_state) {
4570 talloc_free(r);
4571 /* Return true here, srv_pipe_hnd.c will take care */
4572 return true;
4573 }
4574
4575 if (DEBUGLEVEL >= 10) {
4576 NDR_PRINT_OUT_DEBUG(samr_Connect2, r);
4577 }
4578
4579 push = ndr_push_init_ctx(r, NULL);
4580 if (push == NULL) {
4581 talloc_free(r);
4582 return false;
4583 }
4584
4585 ndr_err = call->ndr_push(push, NDR_OUT, r);
4586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4587 talloc_free(r);
4588 return false;
4589 }
4590
4591 blob = ndr_push_blob(push);
4592 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4593 talloc_free(r);
4594 return false;
4595 }
4596
4597 talloc_free(r);
4598
4599 return true;
4600}
4601
4602static bool api_samr_SetUserInfo2(pipes_struct *p)
4603{
4604 const struct ndr_interface_call *call;
4605 struct ndr_pull *pull;
4606 struct ndr_push *push;
4607 enum ndr_err_code ndr_err;
4608 DATA_BLOB blob;
4609 struct samr_SetUserInfo2 *r;
4610
4611 call = &ndr_table_samr.calls[NDR_SAMR_SETUSERINFO2];
4612
4613 r = talloc(talloc_tos(), struct samr_SetUserInfo2);
4614 if (r == NULL) {
4615 return false;
4616 }
4617
4618 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4619 talloc_free(r);
4620 return false;
4621 }
4622
4623 pull = ndr_pull_init_blob(&blob, r, NULL);
4624 if (pull == NULL) {
4625 talloc_free(r);
4626 return false;
4627 }
4628
4629 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4630 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4631 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4632 talloc_free(r);
4633 return false;
4634 }
4635
4636 if (DEBUGLEVEL >= 10) {
4637 NDR_PRINT_IN_DEBUG(samr_SetUserInfo2, r);
4638 }
4639
4640 r->out.result = _samr_SetUserInfo2(p, r);
4641
4642 if (p->rng_fault_state) {
4643 talloc_free(r);
4644 /* Return true here, srv_pipe_hnd.c will take care */
4645 return true;
4646 }
4647
4648 if (DEBUGLEVEL >= 10) {
4649 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo2, r);
4650 }
4651
4652 push = ndr_push_init_ctx(r, NULL);
4653 if (push == NULL) {
4654 talloc_free(r);
4655 return false;
4656 }
4657
4658 ndr_err = call->ndr_push(push, NDR_OUT, r);
4659 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4660 talloc_free(r);
4661 return false;
4662 }
4663
4664 blob = ndr_push_blob(push);
4665 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4666 talloc_free(r);
4667 return false;
4668 }
4669
4670 talloc_free(r);
4671
4672 return true;
4673}
4674
4675static bool api_samr_SetBootKeyInformation(pipes_struct *p)
4676{
4677 const struct ndr_interface_call *call;
4678 struct ndr_pull *pull;
4679 struct ndr_push *push;
4680 enum ndr_err_code ndr_err;
4681 DATA_BLOB blob;
4682 struct samr_SetBootKeyInformation *r;
4683
4684 call = &ndr_table_samr.calls[NDR_SAMR_SETBOOTKEYINFORMATION];
4685
4686 r = talloc(talloc_tos(), struct samr_SetBootKeyInformation);
4687 if (r == NULL) {
4688 return false;
4689 }
4690
4691 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4692 talloc_free(r);
4693 return false;
4694 }
4695
4696 pull = ndr_pull_init_blob(&blob, r, NULL);
4697 if (pull == NULL) {
4698 talloc_free(r);
4699 return false;
4700 }
4701
4702 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4703 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4704 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4705 talloc_free(r);
4706 return false;
4707 }
4708
4709 if (DEBUGLEVEL >= 10) {
4710 NDR_PRINT_IN_DEBUG(samr_SetBootKeyInformation, r);
4711 }
4712
4713 r->out.result = _samr_SetBootKeyInformation(p, r);
4714
4715 if (p->rng_fault_state) {
4716 talloc_free(r);
4717 /* Return true here, srv_pipe_hnd.c will take care */
4718 return true;
4719 }
4720
4721 if (DEBUGLEVEL >= 10) {
4722 NDR_PRINT_OUT_DEBUG(samr_SetBootKeyInformation, r);
4723 }
4724
4725 push = ndr_push_init_ctx(r, NULL);
4726 if (push == NULL) {
4727 talloc_free(r);
4728 return false;
4729 }
4730
4731 ndr_err = call->ndr_push(push, NDR_OUT, r);
4732 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4733 talloc_free(r);
4734 return false;
4735 }
4736
4737 blob = ndr_push_blob(push);
4738 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4739 talloc_free(r);
4740 return false;
4741 }
4742
4743 talloc_free(r);
4744
4745 return true;
4746}
4747
4748static bool api_samr_GetBootKeyInformation(pipes_struct *p)
4749{
4750 const struct ndr_interface_call *call;
4751 struct ndr_pull *pull;
4752 struct ndr_push *push;
4753 enum ndr_err_code ndr_err;
4754 DATA_BLOB blob;
4755 struct samr_GetBootKeyInformation *r;
4756
4757 call = &ndr_table_samr.calls[NDR_SAMR_GETBOOTKEYINFORMATION];
4758
4759 r = talloc(talloc_tos(), struct samr_GetBootKeyInformation);
4760 if (r == NULL) {
4761 return false;
4762 }
4763
4764 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4765 talloc_free(r);
4766 return false;
4767 }
4768
4769 pull = ndr_pull_init_blob(&blob, r, NULL);
4770 if (pull == NULL) {
4771 talloc_free(r);
4772 return false;
4773 }
4774
4775 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4776 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4778 talloc_free(r);
4779 return false;
4780 }
4781
4782 if (DEBUGLEVEL >= 10) {
4783 NDR_PRINT_IN_DEBUG(samr_GetBootKeyInformation, r);
4784 }
4785
4786 ZERO_STRUCT(r->out);
4787 r->out.unknown = talloc_zero(r, uint32_t);
4788 if (r->out.unknown == NULL) {
4789 talloc_free(r);
4790 return false;
4791 }
4792
4793 r->out.result = _samr_GetBootKeyInformation(p, r);
4794
4795 if (p->rng_fault_state) {
4796 talloc_free(r);
4797 /* Return true here, srv_pipe_hnd.c will take care */
4798 return true;
4799 }
4800
4801 if (DEBUGLEVEL >= 10) {
4802 NDR_PRINT_OUT_DEBUG(samr_GetBootKeyInformation, r);
4803 }
4804
4805 push = ndr_push_init_ctx(r, NULL);
4806 if (push == NULL) {
4807 talloc_free(r);
4808 return false;
4809 }
4810
4811 ndr_err = call->ndr_push(push, NDR_OUT, r);
4812 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4813 talloc_free(r);
4814 return false;
4815 }
4816
4817 blob = ndr_push_blob(push);
4818 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4819 talloc_free(r);
4820 return false;
4821 }
4822
4823 talloc_free(r);
4824
4825 return true;
4826}
4827
4828static bool api_samr_Connect3(pipes_struct *p)
4829{
4830 const struct ndr_interface_call *call;
4831 struct ndr_pull *pull;
4832 struct ndr_push *push;
4833 enum ndr_err_code ndr_err;
4834 DATA_BLOB blob;
4835 struct samr_Connect3 *r;
4836
4837 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT3];
4838
4839 r = talloc(talloc_tos(), struct samr_Connect3);
4840 if (r == NULL) {
4841 return false;
4842 }
4843
4844 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4845 talloc_free(r);
4846 return false;
4847 }
4848
4849 pull = ndr_pull_init_blob(&blob, r, NULL);
4850 if (pull == NULL) {
4851 talloc_free(r);
4852 return false;
4853 }
4854
4855 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4856 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4858 talloc_free(r);
4859 return false;
4860 }
4861
4862 if (DEBUGLEVEL >= 10) {
4863 NDR_PRINT_IN_DEBUG(samr_Connect3, r);
4864 }
4865
4866 ZERO_STRUCT(r->out);
4867 r->out.connect_handle = talloc_zero(r, struct policy_handle);
4868 if (r->out.connect_handle == NULL) {
4869 talloc_free(r);
4870 return false;
4871 }
4872
4873 r->out.result = _samr_Connect3(p, r);
4874
4875 if (p->rng_fault_state) {
4876 talloc_free(r);
4877 /* Return true here, srv_pipe_hnd.c will take care */
4878 return true;
4879 }
4880
4881 if (DEBUGLEVEL >= 10) {
4882 NDR_PRINT_OUT_DEBUG(samr_Connect3, r);
4883 }
4884
4885 push = ndr_push_init_ctx(r, NULL);
4886 if (push == NULL) {
4887 talloc_free(r);
4888 return false;
4889 }
4890
4891 ndr_err = call->ndr_push(push, NDR_OUT, r);
4892 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4893 talloc_free(r);
4894 return false;
4895 }
4896
4897 blob = ndr_push_blob(push);
4898 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4899 talloc_free(r);
4900 return false;
4901 }
4902
4903 talloc_free(r);
4904
4905 return true;
4906}
4907
4908static bool api_samr_Connect4(pipes_struct *p)
4909{
4910 const struct ndr_interface_call *call;
4911 struct ndr_pull *pull;
4912 struct ndr_push *push;
4913 enum ndr_err_code ndr_err;
4914 DATA_BLOB blob;
4915 struct samr_Connect4 *r;
4916
4917 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT4];
4918
4919 r = talloc(talloc_tos(), struct samr_Connect4);
4920 if (r == NULL) {
4921 return false;
4922 }
4923
4924 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4925 talloc_free(r);
4926 return false;
4927 }
4928
4929 pull = ndr_pull_init_blob(&blob, r, NULL);
4930 if (pull == NULL) {
4931 talloc_free(r);
4932 return false;
4933 }
4934
4935 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4936 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4937 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4938 talloc_free(r);
4939 return false;
4940 }
4941
4942 if (DEBUGLEVEL >= 10) {
4943 NDR_PRINT_IN_DEBUG(samr_Connect4, r);
4944 }
4945
4946 ZERO_STRUCT(r->out);
4947 r->out.connect_handle = talloc_zero(r, struct policy_handle);
4948 if (r->out.connect_handle == NULL) {
4949 talloc_free(r);
4950 return false;
4951 }
4952
4953 r->out.result = _samr_Connect4(p, r);
4954
4955 if (p->rng_fault_state) {
4956 talloc_free(r);
4957 /* Return true here, srv_pipe_hnd.c will take care */
4958 return true;
4959 }
4960
4961 if (DEBUGLEVEL >= 10) {
4962 NDR_PRINT_OUT_DEBUG(samr_Connect4, r);
4963 }
4964
4965 push = ndr_push_init_ctx(r, NULL);
4966 if (push == NULL) {
4967 talloc_free(r);
4968 return false;
4969 }
4970
4971 ndr_err = call->ndr_push(push, NDR_OUT, r);
4972 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4973 talloc_free(r);
4974 return false;
4975 }
4976
4977 blob = ndr_push_blob(push);
4978 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4979 talloc_free(r);
4980 return false;
4981 }
4982
4983 talloc_free(r);
4984
4985 return true;
4986}
4987
4988static bool api_samr_ChangePasswordUser3(pipes_struct *p)
4989{
4990 const struct ndr_interface_call *call;
4991 struct ndr_pull *pull;
4992 struct ndr_push *push;
4993 enum ndr_err_code ndr_err;
4994 DATA_BLOB blob;
4995 struct samr_ChangePasswordUser3 *r;
4996
4997 call = &ndr_table_samr.calls[NDR_SAMR_CHANGEPASSWORDUSER3];
4998
4999 r = talloc(talloc_tos(), struct samr_ChangePasswordUser3);
5000 if (r == NULL) {
5001 return false;
5002 }
5003
5004 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5005 talloc_free(r);
5006 return false;
5007 }
5008
5009 pull = ndr_pull_init_blob(&blob, r, NULL);
5010 if (pull == NULL) {
5011 talloc_free(r);
5012 return false;
5013 }
5014
5015 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5016 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5017 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5018 talloc_free(r);
5019 return false;
5020 }
5021
5022 if (DEBUGLEVEL >= 10) {
5023 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser3, r);
5024 }
5025
5026 ZERO_STRUCT(r->out);
5027 r->out.dominfo = talloc_zero(r, struct samr_DomInfo1 *);
5028 if (r->out.dominfo == NULL) {
5029 talloc_free(r);
5030 return false;
5031 }
5032
5033 r->out.reject = talloc_zero(r, struct samr_ChangeReject *);
5034 if (r->out.reject == NULL) {
5035 talloc_free(r);
5036 return false;
5037 }
5038
5039 r->out.result = _samr_ChangePasswordUser3(p, r);
5040
5041 if (p->rng_fault_state) {
5042 talloc_free(r);
5043 /* Return true here, srv_pipe_hnd.c will take care */
5044 return true;
5045 }
5046
5047 if (DEBUGLEVEL >= 10) {
5048 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser3, r);
5049 }
5050
5051 push = ndr_push_init_ctx(r, NULL);
5052 if (push == NULL) {
5053 talloc_free(r);
5054 return false;
5055 }
5056
5057 ndr_err = call->ndr_push(push, NDR_OUT, r);
5058 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5059 talloc_free(r);
5060 return false;
5061 }
5062
5063 blob = ndr_push_blob(push);
5064 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5065 talloc_free(r);
5066 return false;
5067 }
5068
5069 talloc_free(r);
5070
5071 return true;
5072}
5073
5074static bool api_samr_Connect5(pipes_struct *p)
5075{
5076 const struct ndr_interface_call *call;
5077 struct ndr_pull *pull;
5078 struct ndr_push *push;
5079 enum ndr_err_code ndr_err;
5080 DATA_BLOB blob;
5081 struct samr_Connect5 *r;
5082
5083 call = &ndr_table_samr.calls[NDR_SAMR_CONNECT5];
5084
5085 r = talloc(talloc_tos(), struct samr_Connect5);
5086 if (r == NULL) {
5087 return false;
5088 }
5089
5090 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5091 talloc_free(r);
5092 return false;
5093 }
5094
5095 pull = ndr_pull_init_blob(&blob, r, NULL);
5096 if (pull == NULL) {
5097 talloc_free(r);
5098 return false;
5099 }
5100
5101 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5102 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5103 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5104 talloc_free(r);
5105 return false;
5106 }
5107
5108 if (DEBUGLEVEL >= 10) {
5109 NDR_PRINT_IN_DEBUG(samr_Connect5, r);
5110 }
5111
5112 ZERO_STRUCT(r->out);
5113 r->out.level_out = talloc_zero(r, uint32_t);
5114 if (r->out.level_out == NULL) {
5115 talloc_free(r);
5116 return false;
5117 }
5118
5119 r->out.info_out = talloc_zero(r, union samr_ConnectInfo);
5120 if (r->out.info_out == NULL) {
5121 talloc_free(r);
5122 return false;
5123 }
5124
5125 r->out.connect_handle = talloc_zero(r, struct policy_handle);
5126 if (r->out.connect_handle == NULL) {
5127 talloc_free(r);
5128 return false;
5129 }
5130
5131 r->out.result = _samr_Connect5(p, r);
5132
5133 if (p->rng_fault_state) {
5134 talloc_free(r);
5135 /* Return true here, srv_pipe_hnd.c will take care */
5136 return true;
5137 }
5138
5139 if (DEBUGLEVEL >= 10) {
5140 NDR_PRINT_OUT_DEBUG(samr_Connect5, r);
5141 }
5142
5143 push = ndr_push_init_ctx(r, NULL);
5144 if (push == NULL) {
5145 talloc_free(r);
5146 return false;
5147 }
5148
5149 ndr_err = call->ndr_push(push, NDR_OUT, r);
5150 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5151 talloc_free(r);
5152 return false;
5153 }
5154
5155 blob = ndr_push_blob(push);
5156 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5157 talloc_free(r);
5158 return false;
5159 }
5160
5161 talloc_free(r);
5162
5163 return true;
5164}
5165
5166static bool api_samr_RidToSid(pipes_struct *p)
5167{
5168 const struct ndr_interface_call *call;
5169 struct ndr_pull *pull;
5170 struct ndr_push *push;
5171 enum ndr_err_code ndr_err;
5172 DATA_BLOB blob;
5173 struct samr_RidToSid *r;
5174
5175 call = &ndr_table_samr.calls[NDR_SAMR_RIDTOSID];
5176
5177 r = talloc(talloc_tos(), struct samr_RidToSid);
5178 if (r == NULL) {
5179 return false;
5180 }
5181
5182 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5183 talloc_free(r);
5184 return false;
5185 }
5186
5187 pull = ndr_pull_init_blob(&blob, r, NULL);
5188 if (pull == NULL) {
5189 talloc_free(r);
5190 return false;
5191 }
5192
5193 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5194 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5195 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5196 talloc_free(r);
5197 return false;
5198 }
5199
5200 if (DEBUGLEVEL >= 10) {
5201 NDR_PRINT_IN_DEBUG(samr_RidToSid, r);
5202 }
5203
5204 ZERO_STRUCT(r->out);
5205 r->out.sid = talloc_zero(r, struct dom_sid2 *);
5206 if (r->out.sid == NULL) {
5207 talloc_free(r);
5208 return false;
5209 }
5210
5211 r->out.result = _samr_RidToSid(p, r);
5212
5213 if (p->rng_fault_state) {
5214 talloc_free(r);
5215 /* Return true here, srv_pipe_hnd.c will take care */
5216 return true;
5217 }
5218
5219 if (DEBUGLEVEL >= 10) {
5220 NDR_PRINT_OUT_DEBUG(samr_RidToSid, r);
5221 }
5222
5223 push = ndr_push_init_ctx(r, NULL);
5224 if (push == NULL) {
5225 talloc_free(r);
5226 return false;
5227 }
5228
5229 ndr_err = call->ndr_push(push, NDR_OUT, r);
5230 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5231 talloc_free(r);
5232 return false;
5233 }
5234
5235 blob = ndr_push_blob(push);
5236 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5237 talloc_free(r);
5238 return false;
5239 }
5240
5241 talloc_free(r);
5242
5243 return true;
5244}
5245
5246static bool api_samr_SetDsrmPassword(pipes_struct *p)
5247{
5248 const struct ndr_interface_call *call;
5249 struct ndr_pull *pull;
5250 struct ndr_push *push;
5251 enum ndr_err_code ndr_err;
5252 DATA_BLOB blob;
5253 struct samr_SetDsrmPassword *r;
5254
5255 call = &ndr_table_samr.calls[NDR_SAMR_SETDSRMPASSWORD];
5256
5257 r = talloc(talloc_tos(), struct samr_SetDsrmPassword);
5258 if (r == NULL) {
5259 return false;
5260 }
5261
5262 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5263 talloc_free(r);
5264 return false;
5265 }
5266
5267 pull = ndr_pull_init_blob(&blob, r, NULL);
5268 if (pull == NULL) {
5269 talloc_free(r);
5270 return false;
5271 }
5272
5273 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5274 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5275 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5276 talloc_free(r);
5277 return false;
5278 }
5279
5280 if (DEBUGLEVEL >= 10) {
5281 NDR_PRINT_IN_DEBUG(samr_SetDsrmPassword, r);
5282 }
5283
5284 r->out.result = _samr_SetDsrmPassword(p, r);
5285
5286 if (p->rng_fault_state) {
5287 talloc_free(r);
5288 /* Return true here, srv_pipe_hnd.c will take care */
5289 return true;
5290 }
5291
5292 if (DEBUGLEVEL >= 10) {
5293 NDR_PRINT_OUT_DEBUG(samr_SetDsrmPassword, r);
5294 }
5295
5296 push = ndr_push_init_ctx(r, NULL);
5297 if (push == NULL) {
5298 talloc_free(r);
5299 return false;
5300 }
5301
5302 ndr_err = call->ndr_push(push, NDR_OUT, r);
5303 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5304 talloc_free(r);
5305 return false;
5306 }
5307
5308 blob = ndr_push_blob(push);
5309 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5310 talloc_free(r);
5311 return false;
5312 }
5313
5314 talloc_free(r);
5315
5316 return true;
5317}
5318
5319static bool api_samr_ValidatePassword(pipes_struct *p)
5320{
5321 const struct ndr_interface_call *call;
5322 struct ndr_pull *pull;
5323 struct ndr_push *push;
5324 enum ndr_err_code ndr_err;
5325 DATA_BLOB blob;
5326 struct samr_ValidatePassword *r;
5327
5328 call = &ndr_table_samr.calls[NDR_SAMR_VALIDATEPASSWORD];
5329
5330 r = talloc(talloc_tos(), struct samr_ValidatePassword);
5331 if (r == NULL) {
5332 return false;
5333 }
5334
5335 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5336 talloc_free(r);
5337 return false;
5338 }
5339
5340 pull = ndr_pull_init_blob(&blob, r, NULL);
5341 if (pull == NULL) {
5342 talloc_free(r);
5343 return false;
5344 }
5345
5346 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5347 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5348 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5349 talloc_free(r);
5350 return false;
5351 }
5352
5353 if (DEBUGLEVEL >= 10) {
5354 NDR_PRINT_IN_DEBUG(samr_ValidatePassword, r);
5355 }
5356
5357 ZERO_STRUCT(r->out);
5358 r->out.rep = talloc_zero(r, union samr_ValidatePasswordRep *);
5359 if (r->out.rep == NULL) {
5360 talloc_free(r);
5361 return false;
5362 }
5363
5364 r->out.result = _samr_ValidatePassword(p, r);
5365
5366 if (p->rng_fault_state) {
5367 talloc_free(r);
5368 /* Return true here, srv_pipe_hnd.c will take care */
5369 return true;
5370 }
5371
5372 if (DEBUGLEVEL >= 10) {
5373 NDR_PRINT_OUT_DEBUG(samr_ValidatePassword, r);
5374 }
5375
5376 push = ndr_push_init_ctx(r, NULL);
5377 if (push == NULL) {
5378 talloc_free(r);
5379 return false;
5380 }
5381
5382 ndr_err = call->ndr_push(push, NDR_OUT, r);
5383 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5384 talloc_free(r);
5385 return false;
5386 }
5387
5388 blob = ndr_push_blob(push);
5389 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5390 talloc_free(r);
5391 return false;
5392 }
5393
5394 talloc_free(r);
5395
5396 return true;
5397}
5398
5399
5400/* Tables */
5401static struct api_struct api_samr_cmds[] =
5402{
5403 {"SAMR_CONNECT", NDR_SAMR_CONNECT, api_samr_Connect},
5404 {"SAMR_CLOSE", NDR_SAMR_CLOSE, api_samr_Close},
5405 {"SAMR_SETSECURITY", NDR_SAMR_SETSECURITY, api_samr_SetSecurity},
5406 {"SAMR_QUERYSECURITY", NDR_SAMR_QUERYSECURITY, api_samr_QuerySecurity},
5407 {"SAMR_SHUTDOWN", NDR_SAMR_SHUTDOWN, api_samr_Shutdown},
5408 {"SAMR_LOOKUPDOMAIN", NDR_SAMR_LOOKUPDOMAIN, api_samr_LookupDomain},
5409 {"SAMR_ENUMDOMAINS", NDR_SAMR_ENUMDOMAINS, api_samr_EnumDomains},
5410 {"SAMR_OPENDOMAIN", NDR_SAMR_OPENDOMAIN, api_samr_OpenDomain},
5411 {"SAMR_QUERYDOMAININFO", NDR_SAMR_QUERYDOMAININFO, api_samr_QueryDomainInfo},
5412 {"SAMR_SETDOMAININFO", NDR_SAMR_SETDOMAININFO, api_samr_SetDomainInfo},
5413 {"SAMR_CREATEDOMAINGROUP", NDR_SAMR_CREATEDOMAINGROUP, api_samr_CreateDomainGroup},
5414 {"SAMR_ENUMDOMAINGROUPS", NDR_SAMR_ENUMDOMAINGROUPS, api_samr_EnumDomainGroups},
5415 {"SAMR_CREATEUSER", NDR_SAMR_CREATEUSER, api_samr_CreateUser},
5416 {"SAMR_ENUMDOMAINUSERS", NDR_SAMR_ENUMDOMAINUSERS, api_samr_EnumDomainUsers},
5417 {"SAMR_CREATEDOMALIAS", NDR_SAMR_CREATEDOMALIAS, api_samr_CreateDomAlias},
5418 {"SAMR_ENUMDOMAINALIASES", NDR_SAMR_ENUMDOMAINALIASES, api_samr_EnumDomainAliases},
5419 {"SAMR_GETALIASMEMBERSHIP", NDR_SAMR_GETALIASMEMBERSHIP, api_samr_GetAliasMembership},
5420 {"SAMR_LOOKUPNAMES", NDR_SAMR_LOOKUPNAMES, api_samr_LookupNames},
5421 {"SAMR_LOOKUPRIDS", NDR_SAMR_LOOKUPRIDS, api_samr_LookupRids},
5422 {"SAMR_OPENGROUP", NDR_SAMR_OPENGROUP, api_samr_OpenGroup},
5423 {"SAMR_QUERYGROUPINFO", NDR_SAMR_QUERYGROUPINFO, api_samr_QueryGroupInfo},
5424 {"SAMR_SETGROUPINFO", NDR_SAMR_SETGROUPINFO, api_samr_SetGroupInfo},
5425 {"SAMR_ADDGROUPMEMBER", NDR_SAMR_ADDGROUPMEMBER, api_samr_AddGroupMember},
5426 {"SAMR_DELETEDOMAINGROUP", NDR_SAMR_DELETEDOMAINGROUP, api_samr_DeleteDomainGroup},
5427 {"SAMR_DELETEGROUPMEMBER", NDR_SAMR_DELETEGROUPMEMBER, api_samr_DeleteGroupMember},
5428 {"SAMR_QUERYGROUPMEMBER", NDR_SAMR_QUERYGROUPMEMBER, api_samr_QueryGroupMember},
5429 {"SAMR_SETMEMBERATTRIBUTESOFGROUP", NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP, api_samr_SetMemberAttributesOfGroup},
5430 {"SAMR_OPENALIAS", NDR_SAMR_OPENALIAS, api_samr_OpenAlias},
5431 {"SAMR_QUERYALIASINFO", NDR_SAMR_QUERYALIASINFO, api_samr_QueryAliasInfo},
5432 {"SAMR_SETALIASINFO", NDR_SAMR_SETALIASINFO, api_samr_SetAliasInfo},
5433 {"SAMR_DELETEDOMALIAS", NDR_SAMR_DELETEDOMALIAS, api_samr_DeleteDomAlias},
5434 {"SAMR_ADDALIASMEMBER", NDR_SAMR_ADDALIASMEMBER, api_samr_AddAliasMember},
5435 {"SAMR_DELETEALIASMEMBER", NDR_SAMR_DELETEALIASMEMBER, api_samr_DeleteAliasMember},
5436 {"SAMR_GETMEMBERSINALIAS", NDR_SAMR_GETMEMBERSINALIAS, api_samr_GetMembersInAlias},
5437 {"SAMR_OPENUSER", NDR_SAMR_OPENUSER, api_samr_OpenUser},
5438 {"SAMR_DELETEUSER", NDR_SAMR_DELETEUSER, api_samr_DeleteUser},
5439 {"SAMR_QUERYUSERINFO", NDR_SAMR_QUERYUSERINFO, api_samr_QueryUserInfo},
5440 {"SAMR_SETUSERINFO", NDR_SAMR_SETUSERINFO, api_samr_SetUserInfo},
5441 {"SAMR_CHANGEPASSWORDUSER", NDR_SAMR_CHANGEPASSWORDUSER, api_samr_ChangePasswordUser},
5442 {"SAMR_GETGROUPSFORUSER", NDR_SAMR_GETGROUPSFORUSER, api_samr_GetGroupsForUser},
5443 {"SAMR_QUERYDISPLAYINFO", NDR_SAMR_QUERYDISPLAYINFO, api_samr_QueryDisplayInfo},
5444 {"SAMR_GETDISPLAYENUMERATIONINDEX", NDR_SAMR_GETDISPLAYENUMERATIONINDEX, api_samr_GetDisplayEnumerationIndex},
5445 {"SAMR_TESTPRIVATEFUNCTIONSDOMAIN", NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN, api_samr_TestPrivateFunctionsDomain},
5446 {"SAMR_TESTPRIVATEFUNCTIONSUSER", NDR_SAMR_TESTPRIVATEFUNCTIONSUSER, api_samr_TestPrivateFunctionsUser},
5447 {"SAMR_GETUSERPWINFO", NDR_SAMR_GETUSERPWINFO, api_samr_GetUserPwInfo},
5448 {"SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN", NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN, api_samr_RemoveMemberFromForeignDomain},
5449 {"SAMR_QUERYDOMAININFO2", NDR_SAMR_QUERYDOMAININFO2, api_samr_QueryDomainInfo2},
5450 {"SAMR_QUERYUSERINFO2", NDR_SAMR_QUERYUSERINFO2, api_samr_QueryUserInfo2},
5451 {"SAMR_QUERYDISPLAYINFO2", NDR_SAMR_QUERYDISPLAYINFO2, api_samr_QueryDisplayInfo2},
5452 {"SAMR_GETDISPLAYENUMERATIONINDEX2", NDR_SAMR_GETDISPLAYENUMERATIONINDEX2, api_samr_GetDisplayEnumerationIndex2},
5453 {"SAMR_CREATEUSER2", NDR_SAMR_CREATEUSER2, api_samr_CreateUser2},
5454 {"SAMR_QUERYDISPLAYINFO3", NDR_SAMR_QUERYDISPLAYINFO3, api_samr_QueryDisplayInfo3},
5455 {"SAMR_ADDMULTIPLEMEMBERSTOALIAS", NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS, api_samr_AddMultipleMembersToAlias},
5456 {"SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS", NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS, api_samr_RemoveMultipleMembersFromAlias},
5457 {"SAMR_OEMCHANGEPASSWORDUSER2", NDR_SAMR_OEMCHANGEPASSWORDUSER2, api_samr_OemChangePasswordUser2},
5458 {"SAMR_CHANGEPASSWORDUSER2", NDR_SAMR_CHANGEPASSWORDUSER2, api_samr_ChangePasswordUser2},
5459 {"SAMR_GETDOMPWINFO", NDR_SAMR_GETDOMPWINFO, api_samr_GetDomPwInfo},
5460 {"SAMR_CONNECT2", NDR_SAMR_CONNECT2, api_samr_Connect2},
5461 {"SAMR_SETUSERINFO2", NDR_SAMR_SETUSERINFO2, api_samr_SetUserInfo2},
5462 {"SAMR_SETBOOTKEYINFORMATION", NDR_SAMR_SETBOOTKEYINFORMATION, api_samr_SetBootKeyInformation},
5463 {"SAMR_GETBOOTKEYINFORMATION", NDR_SAMR_GETBOOTKEYINFORMATION, api_samr_GetBootKeyInformation},
5464 {"SAMR_CONNECT3", NDR_SAMR_CONNECT3, api_samr_Connect3},
5465 {"SAMR_CONNECT4", NDR_SAMR_CONNECT4, api_samr_Connect4},
5466 {"SAMR_CHANGEPASSWORDUSER3", NDR_SAMR_CHANGEPASSWORDUSER3, api_samr_ChangePasswordUser3},
5467 {"SAMR_CONNECT5", NDR_SAMR_CONNECT5, api_samr_Connect5},
5468 {"SAMR_RIDTOSID", NDR_SAMR_RIDTOSID, api_samr_RidToSid},
5469 {"SAMR_SETDSRMPASSWORD", NDR_SAMR_SETDSRMPASSWORD, api_samr_SetDsrmPassword},
5470 {"SAMR_VALIDATEPASSWORD", NDR_SAMR_VALIDATEPASSWORD, api_samr_ValidatePassword},
5471};
5472
5473void samr_get_pipe_fns(struct api_struct **fns, int *n_fns)
5474{
5475 *fns = api_samr_cmds;
5476 *n_fns = sizeof(api_samr_cmds) / sizeof(struct api_struct);
5477}
5478
5479NTSTATUS rpc_samr_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
5480{
5481 if (cli->pipes_struct == NULL) {
5482 return NT_STATUS_INVALID_PARAMETER;
5483 }
5484
5485 switch (opnum)
5486 {
5487 case NDR_SAMR_CONNECT: {
5488 struct samr_Connect *r = (struct samr_Connect *)_r;
5489 ZERO_STRUCT(r->out);
5490 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
5491 if (r->out.connect_handle == NULL) {
5492 return NT_STATUS_NO_MEMORY;
5493 }
5494
5495 r->out.result = _samr_Connect(cli->pipes_struct, r);
5496 return NT_STATUS_OK;
5497 }
5498
5499 case NDR_SAMR_CLOSE: {
5500 struct samr_Close *r = (struct samr_Close *)_r;
5501 ZERO_STRUCT(r->out);
5502 r->out.handle = r->in.handle;
5503 r->out.result = _samr_Close(cli->pipes_struct, r);
5504 return NT_STATUS_OK;
5505 }
5506
5507 case NDR_SAMR_SETSECURITY: {
5508 struct samr_SetSecurity *r = (struct samr_SetSecurity *)_r;
5509 r->out.result = _samr_SetSecurity(cli->pipes_struct, r);
5510 return NT_STATUS_OK;
5511 }
5512
5513 case NDR_SAMR_QUERYSECURITY: {
5514 struct samr_QuerySecurity *r = (struct samr_QuerySecurity *)_r;
5515 ZERO_STRUCT(r->out);
5516 r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
5517 if (r->out.sdbuf == NULL) {
5518 return NT_STATUS_NO_MEMORY;
5519 }
5520
5521 r->out.result = _samr_QuerySecurity(cli->pipes_struct, r);
5522 return NT_STATUS_OK;
5523 }
5524
5525 case NDR_SAMR_SHUTDOWN: {
5526 struct samr_Shutdown *r = (struct samr_Shutdown *)_r;
5527 r->out.result = _samr_Shutdown(cli->pipes_struct, r);
5528 return NT_STATUS_OK;
5529 }
5530
5531 case NDR_SAMR_LOOKUPDOMAIN: {
5532 struct samr_LookupDomain *r = (struct samr_LookupDomain *)_r;
5533 ZERO_STRUCT(r->out);
5534 r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *);
5535 if (r->out.sid == NULL) {
5536 return NT_STATUS_NO_MEMORY;
5537 }
5538
5539 r->out.result = _samr_LookupDomain(cli->pipes_struct, r);
5540 return NT_STATUS_OK;
5541 }
5542
5543 case NDR_SAMR_ENUMDOMAINS: {
5544 struct samr_EnumDomains *r = (struct samr_EnumDomains *)_r;
5545 ZERO_STRUCT(r->out);
5546 r->out.resume_handle = r->in.resume_handle;
5547 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5548 if (r->out.sam == NULL) {
5549 return NT_STATUS_NO_MEMORY;
5550 }
5551
5552 r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5553 if (r->out.num_entries == NULL) {
5554 return NT_STATUS_NO_MEMORY;
5555 }
5556
5557 r->out.result = _samr_EnumDomains(cli->pipes_struct, r);
5558 return NT_STATUS_OK;
5559 }
5560
5561 case NDR_SAMR_OPENDOMAIN: {
5562 struct samr_OpenDomain *r = (struct samr_OpenDomain *)_r;
5563 ZERO_STRUCT(r->out);
5564 r->out.domain_handle = talloc_zero(mem_ctx, struct policy_handle);
5565 if (r->out.domain_handle == NULL) {
5566 return NT_STATUS_NO_MEMORY;
5567 }
5568
5569 r->out.result = _samr_OpenDomain(cli->pipes_struct, r);
5570 return NT_STATUS_OK;
5571 }
5572
5573 case NDR_SAMR_QUERYDOMAININFO: {
5574 struct samr_QueryDomainInfo *r = (struct samr_QueryDomainInfo *)_r;
5575 ZERO_STRUCT(r->out);
5576 r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *);
5577 if (r->out.info == NULL) {
5578 return NT_STATUS_NO_MEMORY;
5579 }
5580
5581 r->out.result = _samr_QueryDomainInfo(cli->pipes_struct, r);
5582 return NT_STATUS_OK;
5583 }
5584
5585 case NDR_SAMR_SETDOMAININFO: {
5586 struct samr_SetDomainInfo *r = (struct samr_SetDomainInfo *)_r;
5587 r->out.result = _samr_SetDomainInfo(cli->pipes_struct, r);
5588 return NT_STATUS_OK;
5589 }
5590
5591 case NDR_SAMR_CREATEDOMAINGROUP: {
5592 struct samr_CreateDomainGroup *r = (struct samr_CreateDomainGroup *)_r;
5593 ZERO_STRUCT(r->out);
5594 r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle);
5595 if (r->out.group_handle == NULL) {
5596 return NT_STATUS_NO_MEMORY;
5597 }
5598
5599 r->out.rid = talloc_zero(mem_ctx, uint32_t);
5600 if (r->out.rid == NULL) {
5601 return NT_STATUS_NO_MEMORY;
5602 }
5603
5604 r->out.result = _samr_CreateDomainGroup(cli->pipes_struct, r);
5605 return NT_STATUS_OK;
5606 }
5607
5608 case NDR_SAMR_ENUMDOMAINGROUPS: {
5609 struct samr_EnumDomainGroups *r = (struct samr_EnumDomainGroups *)_r;
5610 ZERO_STRUCT(r->out);
5611 r->out.resume_handle = r->in.resume_handle;
5612 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5613 if (r->out.sam == NULL) {
5614 return NT_STATUS_NO_MEMORY;
5615 }
5616
5617 r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5618 if (r->out.num_entries == NULL) {
5619 return NT_STATUS_NO_MEMORY;
5620 }
5621
5622 r->out.result = _samr_EnumDomainGroups(cli->pipes_struct, r);
5623 return NT_STATUS_OK;
5624 }
5625
5626 case NDR_SAMR_CREATEUSER: {
5627 struct samr_CreateUser *r = (struct samr_CreateUser *)_r;
5628 ZERO_STRUCT(r->out);
5629 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
5630 if (r->out.user_handle == NULL) {
5631 return NT_STATUS_NO_MEMORY;
5632 }
5633
5634 r->out.rid = talloc_zero(mem_ctx, uint32_t);
5635 if (r->out.rid == NULL) {
5636 return NT_STATUS_NO_MEMORY;
5637 }
5638
5639 r->out.result = _samr_CreateUser(cli->pipes_struct, r);
5640 return NT_STATUS_OK;
5641 }
5642
5643 case NDR_SAMR_ENUMDOMAINUSERS: {
5644 struct samr_EnumDomainUsers *r = (struct samr_EnumDomainUsers *)_r;
5645 ZERO_STRUCT(r->out);
5646 r->out.resume_handle = r->in.resume_handle;
5647 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5648 if (r->out.sam == NULL) {
5649 return NT_STATUS_NO_MEMORY;
5650 }
5651
5652 r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5653 if (r->out.num_entries == NULL) {
5654 return NT_STATUS_NO_MEMORY;
5655 }
5656
5657 r->out.result = _samr_EnumDomainUsers(cli->pipes_struct, r);
5658 return NT_STATUS_OK;
5659 }
5660
5661 case NDR_SAMR_CREATEDOMALIAS: {
5662 struct samr_CreateDomAlias *r = (struct samr_CreateDomAlias *)_r;
5663 ZERO_STRUCT(r->out);
5664 r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle);
5665 if (r->out.alias_handle == NULL) {
5666 return NT_STATUS_NO_MEMORY;
5667 }
5668
5669 r->out.rid = talloc_zero(mem_ctx, uint32_t);
5670 if (r->out.rid == NULL) {
5671 return NT_STATUS_NO_MEMORY;
5672 }
5673
5674 r->out.result = _samr_CreateDomAlias(cli->pipes_struct, r);
5675 return NT_STATUS_OK;
5676 }
5677
5678 case NDR_SAMR_ENUMDOMAINALIASES: {
5679 struct samr_EnumDomainAliases *r = (struct samr_EnumDomainAliases *)_r;
5680 ZERO_STRUCT(r->out);
5681 r->out.resume_handle = r->in.resume_handle;
5682 r->out.sam = talloc_zero(mem_ctx, struct samr_SamArray *);
5683 if (r->out.sam == NULL) {
5684 return NT_STATUS_NO_MEMORY;
5685 }
5686
5687 r->out.num_entries = talloc_zero(mem_ctx, uint32_t);
5688 if (r->out.num_entries == NULL) {
5689 return NT_STATUS_NO_MEMORY;
5690 }
5691
5692 r->out.result = _samr_EnumDomainAliases(cli->pipes_struct, r);
5693 return NT_STATUS_OK;
5694 }
5695
5696 case NDR_SAMR_GETALIASMEMBERSHIP: {
5697 struct samr_GetAliasMembership *r = (struct samr_GetAliasMembership *)_r;
5698 ZERO_STRUCT(r->out);
5699 r->out.rids = talloc_zero(mem_ctx, struct samr_Ids);
5700 if (r->out.rids == NULL) {
5701 return NT_STATUS_NO_MEMORY;
5702 }
5703
5704 r->out.result = _samr_GetAliasMembership(cli->pipes_struct, r);
5705 return NT_STATUS_OK;
5706 }
5707
5708 case NDR_SAMR_LOOKUPNAMES: {
5709 struct samr_LookupNames *r = (struct samr_LookupNames *)_r;
5710 ZERO_STRUCT(r->out);
5711 r->out.rids = talloc_zero(mem_ctx, struct samr_Ids);
5712 if (r->out.rids == NULL) {
5713 return NT_STATUS_NO_MEMORY;
5714 }
5715
5716 r->out.types = talloc_zero(mem_ctx, struct samr_Ids);
5717 if (r->out.types == NULL) {
5718 return NT_STATUS_NO_MEMORY;
5719 }
5720
5721 r->out.result = _samr_LookupNames(cli->pipes_struct, r);
5722 return NT_STATUS_OK;
5723 }
5724
5725 case NDR_SAMR_LOOKUPRIDS: {
5726 struct samr_LookupRids *r = (struct samr_LookupRids *)_r;
5727 ZERO_STRUCT(r->out);
5728 r->out.names = talloc_zero(mem_ctx, struct lsa_Strings);
5729 if (r->out.names == NULL) {
5730 return NT_STATUS_NO_MEMORY;
5731 }
5732
5733 r->out.types = talloc_zero(mem_ctx, struct samr_Ids);
5734 if (r->out.types == NULL) {
5735 return NT_STATUS_NO_MEMORY;
5736 }
5737
5738 r->out.result = _samr_LookupRids(cli->pipes_struct, r);
5739 return NT_STATUS_OK;
5740 }
5741
5742 case NDR_SAMR_OPENGROUP: {
5743 struct samr_OpenGroup *r = (struct samr_OpenGroup *)_r;
5744 ZERO_STRUCT(r->out);
5745 r->out.group_handle = talloc_zero(mem_ctx, struct policy_handle);
5746 if (r->out.group_handle == NULL) {
5747 return NT_STATUS_NO_MEMORY;
5748 }
5749
5750 r->out.result = _samr_OpenGroup(cli->pipes_struct, r);
5751 return NT_STATUS_OK;
5752 }
5753
5754 case NDR_SAMR_QUERYGROUPINFO: {
5755 struct samr_QueryGroupInfo *r = (struct samr_QueryGroupInfo *)_r;
5756 ZERO_STRUCT(r->out);
5757 r->out.info = talloc_zero(mem_ctx, union samr_GroupInfo *);
5758 if (r->out.info == NULL) {
5759 return NT_STATUS_NO_MEMORY;
5760 }
5761
5762 r->out.result = _samr_QueryGroupInfo(cli->pipes_struct, r);
5763 return NT_STATUS_OK;
5764 }
5765
5766 case NDR_SAMR_SETGROUPINFO: {
5767 struct samr_SetGroupInfo *r = (struct samr_SetGroupInfo *)_r;
5768 r->out.result = _samr_SetGroupInfo(cli->pipes_struct, r);
5769 return NT_STATUS_OK;
5770 }
5771
5772 case NDR_SAMR_ADDGROUPMEMBER: {
5773 struct samr_AddGroupMember *r = (struct samr_AddGroupMember *)_r;
5774 r->out.result = _samr_AddGroupMember(cli->pipes_struct, r);
5775 return NT_STATUS_OK;
5776 }
5777
5778 case NDR_SAMR_DELETEDOMAINGROUP: {
5779 struct samr_DeleteDomainGroup *r = (struct samr_DeleteDomainGroup *)_r;
5780 ZERO_STRUCT(r->out);
5781 r->out.group_handle = r->in.group_handle;
5782 r->out.result = _samr_DeleteDomainGroup(cli->pipes_struct, r);
5783 return NT_STATUS_OK;
5784 }
5785
5786 case NDR_SAMR_DELETEGROUPMEMBER: {
5787 struct samr_DeleteGroupMember *r = (struct samr_DeleteGroupMember *)_r;
5788 r->out.result = _samr_DeleteGroupMember(cli->pipes_struct, r);
5789 return NT_STATUS_OK;
5790 }
5791
5792 case NDR_SAMR_QUERYGROUPMEMBER: {
5793 struct samr_QueryGroupMember *r = (struct samr_QueryGroupMember *)_r;
5794 ZERO_STRUCT(r->out);
5795 r->out.rids = talloc_zero(mem_ctx, struct samr_RidTypeArray *);
5796 if (r->out.rids == NULL) {
5797 return NT_STATUS_NO_MEMORY;
5798 }
5799
5800 r->out.result = _samr_QueryGroupMember(cli->pipes_struct, r);
5801 return NT_STATUS_OK;
5802 }
5803
5804 case NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP: {
5805 struct samr_SetMemberAttributesOfGroup *r = (struct samr_SetMemberAttributesOfGroup *)_r;
5806 r->out.result = _samr_SetMemberAttributesOfGroup(cli->pipes_struct, r);
5807 return NT_STATUS_OK;
5808 }
5809
5810 case NDR_SAMR_OPENALIAS: {
5811 struct samr_OpenAlias *r = (struct samr_OpenAlias *)_r;
5812 ZERO_STRUCT(r->out);
5813 r->out.alias_handle = talloc_zero(mem_ctx, struct policy_handle);
5814 if (r->out.alias_handle == NULL) {
5815 return NT_STATUS_NO_MEMORY;
5816 }
5817
5818 r->out.result = _samr_OpenAlias(cli->pipes_struct, r);
5819 return NT_STATUS_OK;
5820 }
5821
5822 case NDR_SAMR_QUERYALIASINFO: {
5823 struct samr_QueryAliasInfo *r = (struct samr_QueryAliasInfo *)_r;
5824 ZERO_STRUCT(r->out);
5825 r->out.info = talloc_zero(mem_ctx, union samr_AliasInfo *);
5826 if (r->out.info == NULL) {
5827 return NT_STATUS_NO_MEMORY;
5828 }
5829
5830 r->out.result = _samr_QueryAliasInfo(cli->pipes_struct, r);
5831 return NT_STATUS_OK;
5832 }
5833
5834 case NDR_SAMR_SETALIASINFO: {
5835 struct samr_SetAliasInfo *r = (struct samr_SetAliasInfo *)_r;
5836 r->out.result = _samr_SetAliasInfo(cli->pipes_struct, r);
5837 return NT_STATUS_OK;
5838 }
5839
5840 case NDR_SAMR_DELETEDOMALIAS: {
5841 struct samr_DeleteDomAlias *r = (struct samr_DeleteDomAlias *)_r;
5842 ZERO_STRUCT(r->out);
5843 r->out.alias_handle = r->in.alias_handle;
5844 r->out.result = _samr_DeleteDomAlias(cli->pipes_struct, r);
5845 return NT_STATUS_OK;
5846 }
5847
5848 case NDR_SAMR_ADDALIASMEMBER: {
5849 struct samr_AddAliasMember *r = (struct samr_AddAliasMember *)_r;
5850 r->out.result = _samr_AddAliasMember(cli->pipes_struct, r);
5851 return NT_STATUS_OK;
5852 }
5853
5854 case NDR_SAMR_DELETEALIASMEMBER: {
5855 struct samr_DeleteAliasMember *r = (struct samr_DeleteAliasMember *)_r;
5856 r->out.result = _samr_DeleteAliasMember(cli->pipes_struct, r);
5857 return NT_STATUS_OK;
5858 }
5859
5860 case NDR_SAMR_GETMEMBERSINALIAS: {
5861 struct samr_GetMembersInAlias *r = (struct samr_GetMembersInAlias *)_r;
5862 ZERO_STRUCT(r->out);
5863 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
5864 if (r->out.sids == NULL) {
5865 return NT_STATUS_NO_MEMORY;
5866 }
5867
5868 r->out.result = _samr_GetMembersInAlias(cli->pipes_struct, r);
5869 return NT_STATUS_OK;
5870 }
5871
5872 case NDR_SAMR_OPENUSER: {
5873 struct samr_OpenUser *r = (struct samr_OpenUser *)_r;
5874 ZERO_STRUCT(r->out);
5875 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
5876 if (r->out.user_handle == NULL) {
5877 return NT_STATUS_NO_MEMORY;
5878 }
5879
5880 r->out.result = _samr_OpenUser(cli->pipes_struct, r);
5881 return NT_STATUS_OK;
5882 }
5883
5884 case NDR_SAMR_DELETEUSER: {
5885 struct samr_DeleteUser *r = (struct samr_DeleteUser *)_r;
5886 ZERO_STRUCT(r->out);
5887 r->out.user_handle = r->in.user_handle;
5888 r->out.result = _samr_DeleteUser(cli->pipes_struct, r);
5889 return NT_STATUS_OK;
5890 }
5891
5892 case NDR_SAMR_QUERYUSERINFO: {
5893 struct samr_QueryUserInfo *r = (struct samr_QueryUserInfo *)_r;
5894 ZERO_STRUCT(r->out);
5895 r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *);
5896 if (r->out.info == NULL) {
5897 return NT_STATUS_NO_MEMORY;
5898 }
5899
5900 r->out.result = _samr_QueryUserInfo(cli->pipes_struct, r);
5901 return NT_STATUS_OK;
5902 }
5903
5904 case NDR_SAMR_SETUSERINFO: {
5905 struct samr_SetUserInfo *r = (struct samr_SetUserInfo *)_r;
5906 r->out.result = _samr_SetUserInfo(cli->pipes_struct, r);
5907 return NT_STATUS_OK;
5908 }
5909
5910 case NDR_SAMR_CHANGEPASSWORDUSER: {
5911 struct samr_ChangePasswordUser *r = (struct samr_ChangePasswordUser *)_r;
5912 r->out.result = _samr_ChangePasswordUser(cli->pipes_struct, r);
5913 return NT_STATUS_OK;
5914 }
5915
5916 case NDR_SAMR_GETGROUPSFORUSER: {
5917 struct samr_GetGroupsForUser *r = (struct samr_GetGroupsForUser *)_r;
5918 ZERO_STRUCT(r->out);
5919 r->out.rids = talloc_zero(mem_ctx, struct samr_RidWithAttributeArray *);
5920 if (r->out.rids == NULL) {
5921 return NT_STATUS_NO_MEMORY;
5922 }
5923
5924 r->out.result = _samr_GetGroupsForUser(cli->pipes_struct, r);
5925 return NT_STATUS_OK;
5926 }
5927
5928 case NDR_SAMR_QUERYDISPLAYINFO: {
5929 struct samr_QueryDisplayInfo *r = (struct samr_QueryDisplayInfo *)_r;
5930 ZERO_STRUCT(r->out);
5931 r->out.total_size = talloc_zero(mem_ctx, uint32_t);
5932 if (r->out.total_size == NULL) {
5933 return NT_STATUS_NO_MEMORY;
5934 }
5935
5936 r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
5937 if (r->out.returned_size == NULL) {
5938 return NT_STATUS_NO_MEMORY;
5939 }
5940
5941 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
5942 if (r->out.info == NULL) {
5943 return NT_STATUS_NO_MEMORY;
5944 }
5945
5946 r->out.result = _samr_QueryDisplayInfo(cli->pipes_struct, r);
5947 return NT_STATUS_OK;
5948 }
5949
5950 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX: {
5951 struct samr_GetDisplayEnumerationIndex *r = (struct samr_GetDisplayEnumerationIndex *)_r;
5952 ZERO_STRUCT(r->out);
5953 r->out.idx = talloc_zero(mem_ctx, uint32_t);
5954 if (r->out.idx == NULL) {
5955 return NT_STATUS_NO_MEMORY;
5956 }
5957
5958 r->out.result = _samr_GetDisplayEnumerationIndex(cli->pipes_struct, r);
5959 return NT_STATUS_OK;
5960 }
5961
5962 case NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN: {
5963 struct samr_TestPrivateFunctionsDomain *r = (struct samr_TestPrivateFunctionsDomain *)_r;
5964 r->out.result = _samr_TestPrivateFunctionsDomain(cli->pipes_struct, r);
5965 return NT_STATUS_OK;
5966 }
5967
5968 case NDR_SAMR_TESTPRIVATEFUNCTIONSUSER: {
5969 struct samr_TestPrivateFunctionsUser *r = (struct samr_TestPrivateFunctionsUser *)_r;
5970 r->out.result = _samr_TestPrivateFunctionsUser(cli->pipes_struct, r);
5971 return NT_STATUS_OK;
5972 }
5973
5974 case NDR_SAMR_GETUSERPWINFO: {
5975 struct samr_GetUserPwInfo *r = (struct samr_GetUserPwInfo *)_r;
5976 ZERO_STRUCT(r->out);
5977 r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo);
5978 if (r->out.info == NULL) {
5979 return NT_STATUS_NO_MEMORY;
5980 }
5981
5982 r->out.result = _samr_GetUserPwInfo(cli->pipes_struct, r);
5983 return NT_STATUS_OK;
5984 }
5985
5986 case NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN: {
5987 struct samr_RemoveMemberFromForeignDomain *r = (struct samr_RemoveMemberFromForeignDomain *)_r;
5988 r->out.result = _samr_RemoveMemberFromForeignDomain(cli->pipes_struct, r);
5989 return NT_STATUS_OK;
5990 }
5991
5992 case NDR_SAMR_QUERYDOMAININFO2: {
5993 struct samr_QueryDomainInfo2 *r = (struct samr_QueryDomainInfo2 *)_r;
5994 ZERO_STRUCT(r->out);
5995 r->out.info = talloc_zero(mem_ctx, union samr_DomainInfo *);
5996 if (r->out.info == NULL) {
5997 return NT_STATUS_NO_MEMORY;
5998 }
5999
6000 r->out.result = _samr_QueryDomainInfo2(cli->pipes_struct, r);
6001 return NT_STATUS_OK;
6002 }
6003
6004 case NDR_SAMR_QUERYUSERINFO2: {
6005 struct samr_QueryUserInfo2 *r = (struct samr_QueryUserInfo2 *)_r;
6006 ZERO_STRUCT(r->out);
6007 r->out.info = talloc_zero(mem_ctx, union samr_UserInfo *);
6008 if (r->out.info == NULL) {
6009 return NT_STATUS_NO_MEMORY;
6010 }
6011
6012 r->out.result = _samr_QueryUserInfo2(cli->pipes_struct, r);
6013 return NT_STATUS_OK;
6014 }
6015
6016 case NDR_SAMR_QUERYDISPLAYINFO2: {
6017 struct samr_QueryDisplayInfo2 *r = (struct samr_QueryDisplayInfo2 *)_r;
6018 ZERO_STRUCT(r->out);
6019 r->out.total_size = talloc_zero(mem_ctx, uint32_t);
6020 if (r->out.total_size == NULL) {
6021 return NT_STATUS_NO_MEMORY;
6022 }
6023
6024 r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
6025 if (r->out.returned_size == NULL) {
6026 return NT_STATUS_NO_MEMORY;
6027 }
6028
6029 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
6030 if (r->out.info == NULL) {
6031 return NT_STATUS_NO_MEMORY;
6032 }
6033
6034 r->out.result = _samr_QueryDisplayInfo2(cli->pipes_struct, r);
6035 return NT_STATUS_OK;
6036 }
6037
6038 case NDR_SAMR_GETDISPLAYENUMERATIONINDEX2: {
6039 struct samr_GetDisplayEnumerationIndex2 *r = (struct samr_GetDisplayEnumerationIndex2 *)_r;
6040 ZERO_STRUCT(r->out);
6041 r->out.idx = talloc_zero(mem_ctx, uint32_t);
6042 if (r->out.idx == NULL) {
6043 return NT_STATUS_NO_MEMORY;
6044 }
6045
6046 r->out.result = _samr_GetDisplayEnumerationIndex2(cli->pipes_struct, r);
6047 return NT_STATUS_OK;
6048 }
6049
6050 case NDR_SAMR_CREATEUSER2: {
6051 struct samr_CreateUser2 *r = (struct samr_CreateUser2 *)_r;
6052 ZERO_STRUCT(r->out);
6053 r->out.user_handle = talloc_zero(mem_ctx, struct policy_handle);
6054 if (r->out.user_handle == NULL) {
6055 return NT_STATUS_NO_MEMORY;
6056 }
6057
6058 r->out.access_granted = talloc_zero(mem_ctx, uint32_t);
6059 if (r->out.access_granted == NULL) {
6060 return NT_STATUS_NO_MEMORY;
6061 }
6062
6063 r->out.rid = talloc_zero(mem_ctx, uint32_t);
6064 if (r->out.rid == NULL) {
6065 return NT_STATUS_NO_MEMORY;
6066 }
6067
6068 r->out.result = _samr_CreateUser2(cli->pipes_struct, r);
6069 return NT_STATUS_OK;
6070 }
6071
6072 case NDR_SAMR_QUERYDISPLAYINFO3: {
6073 struct samr_QueryDisplayInfo3 *r = (struct samr_QueryDisplayInfo3 *)_r;
6074 ZERO_STRUCT(r->out);
6075 r->out.total_size = talloc_zero(mem_ctx, uint32_t);
6076 if (r->out.total_size == NULL) {
6077 return NT_STATUS_NO_MEMORY;
6078 }
6079
6080 r->out.returned_size = talloc_zero(mem_ctx, uint32_t);
6081 if (r->out.returned_size == NULL) {
6082 return NT_STATUS_NO_MEMORY;
6083 }
6084
6085 r->out.info = talloc_zero(mem_ctx, union samr_DispInfo);
6086 if (r->out.info == NULL) {
6087 return NT_STATUS_NO_MEMORY;
6088 }
6089
6090 r->out.result = _samr_QueryDisplayInfo3(cli->pipes_struct, r);
6091 return NT_STATUS_OK;
6092 }
6093
6094 case NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS: {
6095 struct samr_AddMultipleMembersToAlias *r = (struct samr_AddMultipleMembersToAlias *)_r;
6096 r->out.result = _samr_AddMultipleMembersToAlias(cli->pipes_struct, r);
6097 return NT_STATUS_OK;
6098 }
6099
6100 case NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS: {
6101 struct samr_RemoveMultipleMembersFromAlias *r = (struct samr_RemoveMultipleMembersFromAlias *)_r;
6102 r->out.result = _samr_RemoveMultipleMembersFromAlias(cli->pipes_struct, r);
6103 return NT_STATUS_OK;
6104 }
6105
6106 case NDR_SAMR_OEMCHANGEPASSWORDUSER2: {
6107 struct samr_OemChangePasswordUser2 *r = (struct samr_OemChangePasswordUser2 *)_r;
6108 r->out.result = _samr_OemChangePasswordUser2(cli->pipes_struct, r);
6109 return NT_STATUS_OK;
6110 }
6111
6112 case NDR_SAMR_CHANGEPASSWORDUSER2: {
6113 struct samr_ChangePasswordUser2 *r = (struct samr_ChangePasswordUser2 *)_r;
6114 r->out.result = _samr_ChangePasswordUser2(cli->pipes_struct, r);
6115 return NT_STATUS_OK;
6116 }
6117
6118 case NDR_SAMR_GETDOMPWINFO: {
6119 struct samr_GetDomPwInfo *r = (struct samr_GetDomPwInfo *)_r;
6120 ZERO_STRUCT(r->out);
6121 r->out.info = talloc_zero(mem_ctx, struct samr_PwInfo);
6122 if (r->out.info == NULL) {
6123 return NT_STATUS_NO_MEMORY;
6124 }
6125
6126 r->out.result = _samr_GetDomPwInfo(cli->pipes_struct, r);
6127 return NT_STATUS_OK;
6128 }
6129
6130 case NDR_SAMR_CONNECT2: {
6131 struct samr_Connect2 *r = (struct samr_Connect2 *)_r;
6132 ZERO_STRUCT(r->out);
6133 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6134 if (r->out.connect_handle == NULL) {
6135 return NT_STATUS_NO_MEMORY;
6136 }
6137
6138 r->out.result = _samr_Connect2(cli->pipes_struct, r);
6139 return NT_STATUS_OK;
6140 }
6141
6142 case NDR_SAMR_SETUSERINFO2: {
6143 struct samr_SetUserInfo2 *r = (struct samr_SetUserInfo2 *)_r;
6144 r->out.result = _samr_SetUserInfo2(cli->pipes_struct, r);
6145 return NT_STATUS_OK;
6146 }
6147
6148 case NDR_SAMR_SETBOOTKEYINFORMATION: {
6149 struct samr_SetBootKeyInformation *r = (struct samr_SetBootKeyInformation *)_r;
6150 r->out.result = _samr_SetBootKeyInformation(cli->pipes_struct, r);
6151 return NT_STATUS_OK;
6152 }
6153
6154 case NDR_SAMR_GETBOOTKEYINFORMATION: {
6155 struct samr_GetBootKeyInformation *r = (struct samr_GetBootKeyInformation *)_r;
6156 ZERO_STRUCT(r->out);
6157 r->out.unknown = talloc_zero(mem_ctx, uint32_t);
6158 if (r->out.unknown == NULL) {
6159 return NT_STATUS_NO_MEMORY;
6160 }
6161
6162 r->out.result = _samr_GetBootKeyInformation(cli->pipes_struct, r);
6163 return NT_STATUS_OK;
6164 }
6165
6166 case NDR_SAMR_CONNECT3: {
6167 struct samr_Connect3 *r = (struct samr_Connect3 *)_r;
6168 ZERO_STRUCT(r->out);
6169 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6170 if (r->out.connect_handle == NULL) {
6171 return NT_STATUS_NO_MEMORY;
6172 }
6173
6174 r->out.result = _samr_Connect3(cli->pipes_struct, r);
6175 return NT_STATUS_OK;
6176 }
6177
6178 case NDR_SAMR_CONNECT4: {
6179 struct samr_Connect4 *r = (struct samr_Connect4 *)_r;
6180 ZERO_STRUCT(r->out);
6181 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6182 if (r->out.connect_handle == NULL) {
6183 return NT_STATUS_NO_MEMORY;
6184 }
6185
6186 r->out.result = _samr_Connect4(cli->pipes_struct, r);
6187 return NT_STATUS_OK;
6188 }
6189
6190 case NDR_SAMR_CHANGEPASSWORDUSER3: {
6191 struct samr_ChangePasswordUser3 *r = (struct samr_ChangePasswordUser3 *)_r;
6192 ZERO_STRUCT(r->out);
6193 r->out.dominfo = talloc_zero(mem_ctx, struct samr_DomInfo1 *);
6194 if (r->out.dominfo == NULL) {
6195 return NT_STATUS_NO_MEMORY;
6196 }
6197
6198 r->out.reject = talloc_zero(mem_ctx, struct samr_ChangeReject *);
6199 if (r->out.reject == NULL) {
6200 return NT_STATUS_NO_MEMORY;
6201 }
6202
6203 r->out.result = _samr_ChangePasswordUser3(cli->pipes_struct, r);
6204 return NT_STATUS_OK;
6205 }
6206
6207 case NDR_SAMR_CONNECT5: {
6208 struct samr_Connect5 *r = (struct samr_Connect5 *)_r;
6209 ZERO_STRUCT(r->out);
6210 r->out.level_out = talloc_zero(mem_ctx, uint32_t);
6211 if (r->out.level_out == NULL) {
6212 return NT_STATUS_NO_MEMORY;
6213 }
6214
6215 r->out.info_out = talloc_zero(mem_ctx, union samr_ConnectInfo);
6216 if (r->out.info_out == NULL) {
6217 return NT_STATUS_NO_MEMORY;
6218 }
6219
6220 r->out.connect_handle = talloc_zero(mem_ctx, struct policy_handle);
6221 if (r->out.connect_handle == NULL) {
6222 return NT_STATUS_NO_MEMORY;
6223 }
6224
6225 r->out.result = _samr_Connect5(cli->pipes_struct, r);
6226 return NT_STATUS_OK;
6227 }
6228
6229 case NDR_SAMR_RIDTOSID: {
6230 struct samr_RidToSid *r = (struct samr_RidToSid *)_r;
6231 ZERO_STRUCT(r->out);
6232 r->out.sid = talloc_zero(mem_ctx, struct dom_sid2 *);
6233 if (r->out.sid == NULL) {
6234 return NT_STATUS_NO_MEMORY;
6235 }
6236
6237 r->out.result = _samr_RidToSid(cli->pipes_struct, r);
6238 return NT_STATUS_OK;
6239 }
6240
6241 case NDR_SAMR_SETDSRMPASSWORD: {
6242 struct samr_SetDsrmPassword *r = (struct samr_SetDsrmPassword *)_r;
6243 r->out.result = _samr_SetDsrmPassword(cli->pipes_struct, r);
6244 return NT_STATUS_OK;
6245 }
6246
6247 case NDR_SAMR_VALIDATEPASSWORD: {
6248 struct samr_ValidatePassword *r = (struct samr_ValidatePassword *)_r;
6249 ZERO_STRUCT(r->out);
6250 r->out.rep = talloc_zero(mem_ctx, union samr_ValidatePasswordRep *);
6251 if (r->out.rep == NULL) {
6252 return NT_STATUS_NO_MEMORY;
6253 }
6254
6255 r->out.result = _samr_ValidatePassword(cli->pipes_struct, r);
6256 return NT_STATUS_OK;
6257 }
6258
6259 default:
6260 return NT_STATUS_NOT_IMPLEMENTED;
6261 }
6262}
6263
6264NTSTATUS rpc_samr_init(void)
6265{
6266 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "samr", "samr", &ndr_table_samr, api_samr_cmds, sizeof(api_samr_cmds) / sizeof(struct api_struct));
6267}
Note: See TracBrowser for help on using the repository browser.