/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- api_lsa_Close
- api_lsa_Delete
- api_lsa_EnumPrivs
- api_lsa_QuerySecurity
- api_lsa_SetSecObj
- api_lsa_ChangePassword
- api_lsa_OpenPolicy
- api_lsa_QueryInfoPolicy
- api_lsa_SetInfoPolicy
- api_lsa_ClearAuditLog
- api_lsa_CreateAccount
- api_lsa_EnumAccounts
- api_lsa_CreateTrustedDomain
- api_lsa_EnumTrustDom
- api_lsa_LookupNames
- api_lsa_LookupSids
- api_lsa_CreateSecret
- api_lsa_OpenAccount
- api_lsa_EnumPrivsAccount
- api_lsa_AddPrivilegesToAccount
- api_lsa_RemovePrivilegesFromAccount
- api_lsa_GetQuotasForAccount
- api_lsa_SetQuotasForAccount
- api_lsa_GetSystemAccessAccount
- api_lsa_SetSystemAccessAccount
- api_lsa_OpenTrustedDomain
- api_lsa_QueryTrustedDomainInfo
- api_lsa_SetInformationTrustedDomain
- api_lsa_OpenSecret
- api_lsa_SetSecret
- api_lsa_QuerySecret
- api_lsa_LookupPrivValue
- api_lsa_LookupPrivName
- api_lsa_LookupPrivDisplayName
- api_lsa_DeleteObject
- api_lsa_EnumAccountsWithUserRight
- api_lsa_EnumAccountRights
- api_lsa_AddAccountRights
- api_lsa_RemoveAccountRights
- api_lsa_QueryTrustedDomainInfoBySid
- api_lsa_SetTrustedDomainInfo
- api_lsa_DeleteTrustedDomain
- api_lsa_StorePrivateData
- api_lsa_RetrievePrivateData
- api_lsa_OpenPolicy2
- api_lsa_GetUserName
- api_lsa_QueryInfoPolicy2
- api_lsa_SetInfoPolicy2
- api_lsa_QueryTrustedDomainInfoByName
- api_lsa_SetTrustedDomainInfoByName
- api_lsa_EnumTrustedDomainsEx
- api_lsa_CreateTrustedDomainEx
- api_lsa_CloseTrustedDomainEx
- api_lsa_QueryDomainInformationPolicy
- api_lsa_SetDomainInformationPolicy
- api_lsa_OpenTrustedDomainByName
- api_lsa_TestCall
- api_lsa_LookupSids2
- api_lsa_LookupNames2
- api_lsa_CreateTrustedDomainEx2
- api_lsa_CREDRWRITE
- api_lsa_CREDRREAD
- api_lsa_CREDRENUMERATE
- api_lsa_CREDRWRITEDOMAINCREDENTIALS
- api_lsa_CREDRREADDOMAINCREDENTIALS
- api_lsa_CREDRDELETE
- api_lsa_CREDRGETTARGETINFO
- api_lsa_CREDRPROFILELOADED
- api_lsa_LookupNames3
- api_lsa_CREDRGETSESSIONTYPES
- api_lsa_LSARREGISTERAUDITEVENT
- api_lsa_LSARGENAUDITEVENT
- api_lsa_LSARUNREGISTERAUDITEVENT
- api_lsa_lsaRQueryForestTrustInformation
- api_lsa_LSARSETFORESTTRUSTINFORMATION
- api_lsa_CREDRRENAME
- api_lsa_LookupSids3
- api_lsa_LookupNames4
- api_lsa_LSAROPENPOLICYSCE
- api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE
- api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
- api_lsa_LSARADTREPORTSECURITYEVENT
- lsarpc_get_pipe_fns
- rpc_lsarpc_dispatch
- rpc_lsarpc_init
1 /*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/srv_lsa.h"
8
9 static bool api_lsa_Close(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
10 {
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct lsa_Close *r;
17
18 call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSE];
19
20 r = talloc(talloc_tos(), struct lsa_Close);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r, NULL);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(lsa_Close, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.handle = r->in.handle;
49 r->out.result = _lsa_Close(p, r);
50
51 if (p->rng_fault_state) {
52 talloc_free(r);
53 /* Return true here, srv_pipe_hnd.c will take care */
54 return true;
55 }
56
57 if (DEBUGLEVEL >= 10) {
58 NDR_PRINT_OUT_DEBUG(lsa_Close, r);
59 }
60
61 push = ndr_push_init_ctx(r, NULL);
62 if (push == NULL) {
63 talloc_free(r);
64 return false;
65 }
66
67 ndr_err = call->ndr_push(push, NDR_OUT, r);
68 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
69 talloc_free(r);
70 return false;
71 }
72
73 blob = ndr_push_blob(push);
74 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
75 talloc_free(r);
76 return false;
77 }
78
79 talloc_free(r);
80
81 return true;
82 }
83
84 static bool api_lsa_Delete(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
85 {
86 const struct ndr_interface_call *call;
87 struct ndr_pull *pull;
88 struct ndr_push *push;
89 enum ndr_err_code ndr_err;
90 DATA_BLOB blob;
91 struct lsa_Delete *r;
92
93 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETE];
94
95 r = talloc(talloc_tos(), struct lsa_Delete);
96 if (r == NULL) {
97 return false;
98 }
99
100 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
101 talloc_free(r);
102 return false;
103 }
104
105 pull = ndr_pull_init_blob(&blob, r, NULL);
106 if (pull == NULL) {
107 talloc_free(r);
108 return false;
109 }
110
111 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
112 ndr_err = call->ndr_pull(pull, NDR_IN, r);
113 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
114 talloc_free(r);
115 return false;
116 }
117
118 if (DEBUGLEVEL >= 10) {
119 NDR_PRINT_IN_DEBUG(lsa_Delete, r);
120 }
121
122 r->out.result = _lsa_Delete(p, r);
123
124 if (p->rng_fault_state) {
125 talloc_free(r);
126 /* Return true here, srv_pipe_hnd.c will take care */
127 return true;
128 }
129
130 if (DEBUGLEVEL >= 10) {
131 NDR_PRINT_OUT_DEBUG(lsa_Delete, r);
132 }
133
134 push = ndr_push_init_ctx(r, NULL);
135 if (push == NULL) {
136 talloc_free(r);
137 return false;
138 }
139
140 ndr_err = call->ndr_push(push, NDR_OUT, r);
141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
142 talloc_free(r);
143 return false;
144 }
145
146 blob = ndr_push_blob(push);
147 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
148 talloc_free(r);
149 return false;
150 }
151
152 talloc_free(r);
153
154 return true;
155 }
156
157 static bool api_lsa_EnumPrivs(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
158 {
159 const struct ndr_interface_call *call;
160 struct ndr_pull *pull;
161 struct ndr_push *push;
162 enum ndr_err_code ndr_err;
163 DATA_BLOB blob;
164 struct lsa_EnumPrivs *r;
165
166 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVS];
167
168 r = talloc(talloc_tos(), struct lsa_EnumPrivs);
169 if (r == NULL) {
170 return false;
171 }
172
173 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
174 talloc_free(r);
175 return false;
176 }
177
178 pull = ndr_pull_init_blob(&blob, r, NULL);
179 if (pull == NULL) {
180 talloc_free(r);
181 return false;
182 }
183
184 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
185 ndr_err = call->ndr_pull(pull, NDR_IN, r);
186 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
187 talloc_free(r);
188 return false;
189 }
190
191 if (DEBUGLEVEL >= 10) {
192 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);
193 }
194
195 ZERO_STRUCT(r->out);
196 r->out.resume_handle = r->in.resume_handle;
197 r->out.privs = talloc_zero(r, struct lsa_PrivArray);
198 if (r->out.privs == NULL) {
199 talloc_free(r);
200 return false;
201 }
202
203 r->out.result = _lsa_EnumPrivs(p, r);
204
205 if (p->rng_fault_state) {
206 talloc_free(r);
207 /* Return true here, srv_pipe_hnd.c will take care */
208 return true;
209 }
210
211 if (DEBUGLEVEL >= 10) {
212 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);
213 }
214
215 push = ndr_push_init_ctx(r, NULL);
216 if (push == NULL) {
217 talloc_free(r);
218 return false;
219 }
220
221 ndr_err = call->ndr_push(push, NDR_OUT, r);
222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
223 talloc_free(r);
224 return false;
225 }
226
227 blob = ndr_push_blob(push);
228 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
229 talloc_free(r);
230 return false;
231 }
232
233 talloc_free(r);
234
235 return true;
236 }
237
238 static bool api_lsa_QuerySecurity(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
239 {
240 const struct ndr_interface_call *call;
241 struct ndr_pull *pull;
242 struct ndr_push *push;
243 enum ndr_err_code ndr_err;
244 DATA_BLOB blob;
245 struct lsa_QuerySecurity *r;
246
247 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECURITY];
248
249 r = talloc(talloc_tos(), struct lsa_QuerySecurity);
250 if (r == NULL) {
251 return false;
252 }
253
254 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
255 talloc_free(r);
256 return false;
257 }
258
259 pull = ndr_pull_init_blob(&blob, r, NULL);
260 if (pull == NULL) {
261 talloc_free(r);
262 return false;
263 }
264
265 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
266 ndr_err = call->ndr_pull(pull, NDR_IN, r);
267 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
268 talloc_free(r);
269 return false;
270 }
271
272 if (DEBUGLEVEL >= 10) {
273 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, r);
274 }
275
276 ZERO_STRUCT(r->out);
277 r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
278 if (r->out.sdbuf == NULL) {
279 talloc_free(r);
280 return false;
281 }
282
283 r->out.result = _lsa_QuerySecurity(p, r);
284
285 if (p->rng_fault_state) {
286 talloc_free(r);
287 /* Return true here, srv_pipe_hnd.c will take care */
288 return true;
289 }
290
291 if (DEBUGLEVEL >= 10) {
292 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, r);
293 }
294
295 push = ndr_push_init_ctx(r, NULL);
296 if (push == NULL) {
297 talloc_free(r);
298 return false;
299 }
300
301 ndr_err = call->ndr_push(push, NDR_OUT, r);
302 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
303 talloc_free(r);
304 return false;
305 }
306
307 blob = ndr_push_blob(push);
308 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
309 talloc_free(r);
310 return false;
311 }
312
313 talloc_free(r);
314
315 return true;
316 }
317
318 static bool api_lsa_SetSecObj(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
319 {
320 const struct ndr_interface_call *call;
321 struct ndr_pull *pull;
322 struct ndr_push *push;
323 enum ndr_err_code ndr_err;
324 DATA_BLOB blob;
325 struct lsa_SetSecObj *r;
326
327 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECOBJ];
328
329 r = talloc(talloc_tos(), struct lsa_SetSecObj);
330 if (r == NULL) {
331 return false;
332 }
333
334 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
335 talloc_free(r);
336 return false;
337 }
338
339 pull = ndr_pull_init_blob(&blob, r, NULL);
340 if (pull == NULL) {
341 talloc_free(r);
342 return false;
343 }
344
345 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
346 ndr_err = call->ndr_pull(pull, NDR_IN, r);
347 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
348 talloc_free(r);
349 return false;
350 }
351
352 if (DEBUGLEVEL >= 10) {
353 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);
354 }
355
356 r->out.result = _lsa_SetSecObj(p, r);
357
358 if (p->rng_fault_state) {
359 talloc_free(r);
360 /* Return true here, srv_pipe_hnd.c will take care */
361 return true;
362 }
363
364 if (DEBUGLEVEL >= 10) {
365 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);
366 }
367
368 push = ndr_push_init_ctx(r, NULL);
369 if (push == NULL) {
370 talloc_free(r);
371 return false;
372 }
373
374 ndr_err = call->ndr_push(push, NDR_OUT, r);
375 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
376 talloc_free(r);
377 return false;
378 }
379
380 blob = ndr_push_blob(push);
381 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
382 talloc_free(r);
383 return false;
384 }
385
386 talloc_free(r);
387
388 return true;
389 }
390
391 static bool api_lsa_ChangePassword(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
392 {
393 const struct ndr_interface_call *call;
394 struct ndr_pull *pull;
395 struct ndr_push *push;
396 enum ndr_err_code ndr_err;
397 DATA_BLOB blob;
398 struct lsa_ChangePassword *r;
399
400 call = &ndr_table_lsarpc.calls[NDR_LSA_CHANGEPASSWORD];
401
402 r = talloc(talloc_tos(), struct lsa_ChangePassword);
403 if (r == NULL) {
404 return false;
405 }
406
407 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
408 talloc_free(r);
409 return false;
410 }
411
412 pull = ndr_pull_init_blob(&blob, r, NULL);
413 if (pull == NULL) {
414 talloc_free(r);
415 return false;
416 }
417
418 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
419 ndr_err = call->ndr_pull(pull, NDR_IN, r);
420 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
421 talloc_free(r);
422 return false;
423 }
424
425 if (DEBUGLEVEL >= 10) {
426 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);
427 }
428
429 r->out.result = _lsa_ChangePassword(p, r);
430
431 if (p->rng_fault_state) {
432 talloc_free(r);
433 /* Return true here, srv_pipe_hnd.c will take care */
434 return true;
435 }
436
437 if (DEBUGLEVEL >= 10) {
438 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);
439 }
440
441 push = ndr_push_init_ctx(r, NULL);
442 if (push == NULL) {
443 talloc_free(r);
444 return false;
445 }
446
447 ndr_err = call->ndr_push(push, NDR_OUT, r);
448 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
449 talloc_free(r);
450 return false;
451 }
452
453 blob = ndr_push_blob(push);
454 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
455 talloc_free(r);
456 return false;
457 }
458
459 talloc_free(r);
460
461 return true;
462 }
463
464 static bool api_lsa_OpenPolicy(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
465 {
466 const struct ndr_interface_call *call;
467 struct ndr_pull *pull;
468 struct ndr_push *push;
469 enum ndr_err_code ndr_err;
470 DATA_BLOB blob;
471 struct lsa_OpenPolicy *r;
472
473 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY];
474
475 r = talloc(talloc_tos(), struct lsa_OpenPolicy);
476 if (r == NULL) {
477 return false;
478 }
479
480 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
481 talloc_free(r);
482 return false;
483 }
484
485 pull = ndr_pull_init_blob(&blob, r, NULL);
486 if (pull == NULL) {
487 talloc_free(r);
488 return false;
489 }
490
491 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
492 ndr_err = call->ndr_pull(pull, NDR_IN, r);
493 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
494 talloc_free(r);
495 return false;
496 }
497
498 if (DEBUGLEVEL >= 10) {
499 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);
500 }
501
502 ZERO_STRUCT(r->out);
503 r->out.handle = talloc_zero(r, struct policy_handle);
504 if (r->out.handle == NULL) {
505 talloc_free(r);
506 return false;
507 }
508
509 r->out.result = _lsa_OpenPolicy(p, r);
510
511 if (p->rng_fault_state) {
512 talloc_free(r);
513 /* Return true here, srv_pipe_hnd.c will take care */
514 return true;
515 }
516
517 if (DEBUGLEVEL >= 10) {
518 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);
519 }
520
521 push = ndr_push_init_ctx(r, NULL);
522 if (push == NULL) {
523 talloc_free(r);
524 return false;
525 }
526
527 ndr_err = call->ndr_push(push, NDR_OUT, r);
528 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
529 talloc_free(r);
530 return false;
531 }
532
533 blob = ndr_push_blob(push);
534 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
535 talloc_free(r);
536 return false;
537 }
538
539 talloc_free(r);
540
541 return true;
542 }
543
544 static bool api_lsa_QueryInfoPolicy(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
545 {
546 const struct ndr_interface_call *call;
547 struct ndr_pull *pull;
548 struct ndr_push *push;
549 enum ndr_err_code ndr_err;
550 DATA_BLOB blob;
551 struct lsa_QueryInfoPolicy *r;
552
553 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY];
554
555 r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy);
556 if (r == NULL) {
557 return false;
558 }
559
560 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
561 talloc_free(r);
562 return false;
563 }
564
565 pull = ndr_pull_init_blob(&blob, r, NULL);
566 if (pull == NULL) {
567 talloc_free(r);
568 return false;
569 }
570
571 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
572 ndr_err = call->ndr_pull(pull, NDR_IN, r);
573 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
574 talloc_free(r);
575 return false;
576 }
577
578 if (DEBUGLEVEL >= 10) {
579 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);
580 }
581
582 ZERO_STRUCT(r->out);
583 r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
584 if (r->out.info == NULL) {
585 talloc_free(r);
586 return false;
587 }
588
589 r->out.result = _lsa_QueryInfoPolicy(p, r);
590
591 if (p->rng_fault_state) {
592 talloc_free(r);
593 /* Return true here, srv_pipe_hnd.c will take care */
594 return true;
595 }
596
597 if (DEBUGLEVEL >= 10) {
598 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);
599 }
600
601 push = ndr_push_init_ctx(r, NULL);
602 if (push == NULL) {
603 talloc_free(r);
604 return false;
605 }
606
607 ndr_err = call->ndr_push(push, NDR_OUT, r);
608 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
609 talloc_free(r);
610 return false;
611 }
612
613 blob = ndr_push_blob(push);
614 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
615 talloc_free(r);
616 return false;
617 }
618
619 talloc_free(r);
620
621 return true;
622 }
623
624 static bool api_lsa_SetInfoPolicy(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
625 {
626 const struct ndr_interface_call *call;
627 struct ndr_pull *pull;
628 struct ndr_push *push;
629 enum ndr_err_code ndr_err;
630 DATA_BLOB blob;
631 struct lsa_SetInfoPolicy *r;
632
633 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY];
634
635 r = talloc(talloc_tos(), struct lsa_SetInfoPolicy);
636 if (r == NULL) {
637 return false;
638 }
639
640 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
641 talloc_free(r);
642 return false;
643 }
644
645 pull = ndr_pull_init_blob(&blob, r, NULL);
646 if (pull == NULL) {
647 talloc_free(r);
648 return false;
649 }
650
651 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
652 ndr_err = call->ndr_pull(pull, NDR_IN, r);
653 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
654 talloc_free(r);
655 return false;
656 }
657
658 if (DEBUGLEVEL >= 10) {
659 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);
660 }
661
662 r->out.result = _lsa_SetInfoPolicy(p, r);
663
664 if (p->rng_fault_state) {
665 talloc_free(r);
666 /* Return true here, srv_pipe_hnd.c will take care */
667 return true;
668 }
669
670 if (DEBUGLEVEL >= 10) {
671 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);
672 }
673
674 push = ndr_push_init_ctx(r, NULL);
675 if (push == NULL) {
676 talloc_free(r);
677 return false;
678 }
679
680 ndr_err = call->ndr_push(push, NDR_OUT, r);
681 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
682 talloc_free(r);
683 return false;
684 }
685
686 blob = ndr_push_blob(push);
687 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
688 talloc_free(r);
689 return false;
690 }
691
692 talloc_free(r);
693
694 return true;
695 }
696
697 static bool api_lsa_ClearAuditLog(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
698 {
699 const struct ndr_interface_call *call;
700 struct ndr_pull *pull;
701 struct ndr_push *push;
702 enum ndr_err_code ndr_err;
703 DATA_BLOB blob;
704 struct lsa_ClearAuditLog *r;
705
706 call = &ndr_table_lsarpc.calls[NDR_LSA_CLEARAUDITLOG];
707
708 r = talloc(talloc_tos(), struct lsa_ClearAuditLog);
709 if (r == NULL) {
710 return false;
711 }
712
713 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
714 talloc_free(r);
715 return false;
716 }
717
718 pull = ndr_pull_init_blob(&blob, r, NULL);
719 if (pull == NULL) {
720 talloc_free(r);
721 return false;
722 }
723
724 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
725 ndr_err = call->ndr_pull(pull, NDR_IN, r);
726 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
727 talloc_free(r);
728 return false;
729 }
730
731 if (DEBUGLEVEL >= 10) {
732 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);
733 }
734
735 r->out.result = _lsa_ClearAuditLog(p, r);
736
737 if (p->rng_fault_state) {
738 talloc_free(r);
739 /* Return true here, srv_pipe_hnd.c will take care */
740 return true;
741 }
742
743 if (DEBUGLEVEL >= 10) {
744 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);
745 }
746
747 push = ndr_push_init_ctx(r, NULL);
748 if (push == NULL) {
749 talloc_free(r);
750 return false;
751 }
752
753 ndr_err = call->ndr_push(push, NDR_OUT, r);
754 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
755 talloc_free(r);
756 return false;
757 }
758
759 blob = ndr_push_blob(push);
760 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
761 talloc_free(r);
762 return false;
763 }
764
765 talloc_free(r);
766
767 return true;
768 }
769
770 static bool api_lsa_CreateAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
771 {
772 const struct ndr_interface_call *call;
773 struct ndr_pull *pull;
774 struct ndr_push *push;
775 enum ndr_err_code ndr_err;
776 DATA_BLOB blob;
777 struct lsa_CreateAccount *r;
778
779 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATEACCOUNT];
780
781 r = talloc(talloc_tos(), struct lsa_CreateAccount);
782 if (r == NULL) {
783 return false;
784 }
785
786 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
787 talloc_free(r);
788 return false;
789 }
790
791 pull = ndr_pull_init_blob(&blob, r, NULL);
792 if (pull == NULL) {
793 talloc_free(r);
794 return false;
795 }
796
797 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
798 ndr_err = call->ndr_pull(pull, NDR_IN, r);
799 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
800 talloc_free(r);
801 return false;
802 }
803
804 if (DEBUGLEVEL >= 10) {
805 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);
806 }
807
808 ZERO_STRUCT(r->out);
809 r->out.acct_handle = talloc_zero(r, struct policy_handle);
810 if (r->out.acct_handle == NULL) {
811 talloc_free(r);
812 return false;
813 }
814
815 r->out.result = _lsa_CreateAccount(p, r);
816
817 if (p->rng_fault_state) {
818 talloc_free(r);
819 /* Return true here, srv_pipe_hnd.c will take care */
820 return true;
821 }
822
823 if (DEBUGLEVEL >= 10) {
824 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);
825 }
826
827 push = ndr_push_init_ctx(r, NULL);
828 if (push == NULL) {
829 talloc_free(r);
830 return false;
831 }
832
833 ndr_err = call->ndr_push(push, NDR_OUT, r);
834 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
835 talloc_free(r);
836 return false;
837 }
838
839 blob = ndr_push_blob(push);
840 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
841 talloc_free(r);
842 return false;
843 }
844
845 talloc_free(r);
846
847 return true;
848 }
849
850 static bool api_lsa_EnumAccounts(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
851 {
852 const struct ndr_interface_call *call;
853 struct ndr_pull *pull;
854 struct ndr_push *push;
855 enum ndr_err_code ndr_err;
856 DATA_BLOB blob;
857 struct lsa_EnumAccounts *r;
858
859 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTS];
860
861 r = talloc(talloc_tos(), struct lsa_EnumAccounts);
862 if (r == NULL) {
863 return false;
864 }
865
866 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
867 talloc_free(r);
868 return false;
869 }
870
871 pull = ndr_pull_init_blob(&blob, r, NULL);
872 if (pull == NULL) {
873 talloc_free(r);
874 return false;
875 }
876
877 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
878 ndr_err = call->ndr_pull(pull, NDR_IN, r);
879 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
880 talloc_free(r);
881 return false;
882 }
883
884 if (DEBUGLEVEL >= 10) {
885 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);
886 }
887
888 ZERO_STRUCT(r->out);
889 r->out.resume_handle = r->in.resume_handle;
890 r->out.sids = talloc_zero(r, struct lsa_SidArray);
891 if (r->out.sids == NULL) {
892 talloc_free(r);
893 return false;
894 }
895
896 r->out.result = _lsa_EnumAccounts(p, r);
897
898 if (p->rng_fault_state) {
899 talloc_free(r);
900 /* Return true here, srv_pipe_hnd.c will take care */
901 return true;
902 }
903
904 if (DEBUGLEVEL >= 10) {
905 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);
906 }
907
908 push = ndr_push_init_ctx(r, NULL);
909 if (push == NULL) {
910 talloc_free(r);
911 return false;
912 }
913
914 ndr_err = call->ndr_push(push, NDR_OUT, r);
915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
916 talloc_free(r);
917 return false;
918 }
919
920 blob = ndr_push_blob(push);
921 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
922 talloc_free(r);
923 return false;
924 }
925
926 talloc_free(r);
927
928 return true;
929 }
930
931 static bool api_lsa_CreateTrustedDomain(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
932 {
933 const struct ndr_interface_call *call;
934 struct ndr_pull *pull;
935 struct ndr_push *push;
936 enum ndr_err_code ndr_err;
937 DATA_BLOB blob;
938 struct lsa_CreateTrustedDomain *r;
939
940 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAIN];
941
942 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomain);
943 if (r == NULL) {
944 return false;
945 }
946
947 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
948 talloc_free(r);
949 return false;
950 }
951
952 pull = ndr_pull_init_blob(&blob, r, NULL);
953 if (pull == NULL) {
954 talloc_free(r);
955 return false;
956 }
957
958 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
959 ndr_err = call->ndr_pull(pull, NDR_IN, r);
960 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
961 talloc_free(r);
962 return false;
963 }
964
965 if (DEBUGLEVEL >= 10) {
966 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, r);
967 }
968
969 ZERO_STRUCT(r->out);
970 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
971 if (r->out.trustdom_handle == NULL) {
972 talloc_free(r);
973 return false;
974 }
975
976 r->out.result = _lsa_CreateTrustedDomain(p, r);
977
978 if (p->rng_fault_state) {
979 talloc_free(r);
980 /* Return true here, srv_pipe_hnd.c will take care */
981 return true;
982 }
983
984 if (DEBUGLEVEL >= 10) {
985 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, r);
986 }
987
988 push = ndr_push_init_ctx(r, NULL);
989 if (push == NULL) {
990 talloc_free(r);
991 return false;
992 }
993
994 ndr_err = call->ndr_push(push, NDR_OUT, r);
995 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
996 talloc_free(r);
997 return false;
998 }
999
1000 blob = ndr_push_blob(push);
1001 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1002 talloc_free(r);
1003 return false;
1004 }
1005
1006 talloc_free(r);
1007
1008 return true;
1009 }
1010
1011 static bool api_lsa_EnumTrustDom(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1012 {
1013 const struct ndr_interface_call *call;
1014 struct ndr_pull *pull;
1015 struct ndr_push *push;
1016 enum ndr_err_code ndr_err;
1017 DATA_BLOB blob;
1018 struct lsa_EnumTrustDom *r;
1019
1020 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTDOM];
1021
1022 r = talloc(talloc_tos(), struct lsa_EnumTrustDom);
1023 if (r == NULL) {
1024 return false;
1025 }
1026
1027 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1028 talloc_free(r);
1029 return false;
1030 }
1031
1032 pull = ndr_pull_init_blob(&blob, r, NULL);
1033 if (pull == NULL) {
1034 talloc_free(r);
1035 return false;
1036 }
1037
1038 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1039 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1040 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1041 talloc_free(r);
1042 return false;
1043 }
1044
1045 if (DEBUGLEVEL >= 10) {
1046 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);
1047 }
1048
1049 ZERO_STRUCT(r->out);
1050 r->out.resume_handle = r->in.resume_handle;
1051 r->out.domains = talloc_zero(r, struct lsa_DomainList);
1052 if (r->out.domains == NULL) {
1053 talloc_free(r);
1054 return false;
1055 }
1056
1057 r->out.result = _lsa_EnumTrustDom(p, r);
1058
1059 if (p->rng_fault_state) {
1060 talloc_free(r);
1061 /* Return true here, srv_pipe_hnd.c will take care */
1062 return true;
1063 }
1064
1065 if (DEBUGLEVEL >= 10) {
1066 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);
1067 }
1068
1069 push = ndr_push_init_ctx(r, NULL);
1070 if (push == NULL) {
1071 talloc_free(r);
1072 return false;
1073 }
1074
1075 ndr_err = call->ndr_push(push, NDR_OUT, r);
1076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1077 talloc_free(r);
1078 return false;
1079 }
1080
1081 blob = ndr_push_blob(push);
1082 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1083 talloc_free(r);
1084 return false;
1085 }
1086
1087 talloc_free(r);
1088
1089 return true;
1090 }
1091
1092 static bool api_lsa_LookupNames(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1093 {
1094 const struct ndr_interface_call *call;
1095 struct ndr_pull *pull;
1096 struct ndr_push *push;
1097 enum ndr_err_code ndr_err;
1098 DATA_BLOB blob;
1099 struct lsa_LookupNames *r;
1100
1101 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES];
1102
1103 r = talloc(talloc_tos(), struct lsa_LookupNames);
1104 if (r == NULL) {
1105 return false;
1106 }
1107
1108 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1109 talloc_free(r);
1110 return false;
1111 }
1112
1113 pull = ndr_pull_init_blob(&blob, r, NULL);
1114 if (pull == NULL) {
1115 talloc_free(r);
1116 return false;
1117 }
1118
1119 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1120 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1122 talloc_free(r);
1123 return false;
1124 }
1125
1126 if (DEBUGLEVEL >= 10) {
1127 NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);
1128 }
1129
1130 ZERO_STRUCT(r->out);
1131 r->out.sids = r->in.sids;
1132 r->out.count = r->in.count;
1133 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1134 if (r->out.domains == NULL) {
1135 talloc_free(r);
1136 return false;
1137 }
1138
1139 r->out.result = _lsa_LookupNames(p, r);
1140
1141 if (p->rng_fault_state) {
1142 talloc_free(r);
1143 /* Return true here, srv_pipe_hnd.c will take care */
1144 return true;
1145 }
1146
1147 if (DEBUGLEVEL >= 10) {
1148 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);
1149 }
1150
1151 push = ndr_push_init_ctx(r, NULL);
1152 if (push == NULL) {
1153 talloc_free(r);
1154 return false;
1155 }
1156
1157 ndr_err = call->ndr_push(push, NDR_OUT, r);
1158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1159 talloc_free(r);
1160 return false;
1161 }
1162
1163 blob = ndr_push_blob(push);
1164 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1165 talloc_free(r);
1166 return false;
1167 }
1168
1169 talloc_free(r);
1170
1171 return true;
1172 }
1173
1174 static bool api_lsa_LookupSids(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1175 {
1176 const struct ndr_interface_call *call;
1177 struct ndr_pull *pull;
1178 struct ndr_push *push;
1179 enum ndr_err_code ndr_err;
1180 DATA_BLOB blob;
1181 struct lsa_LookupSids *r;
1182
1183 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS];
1184
1185 r = talloc(talloc_tos(), struct lsa_LookupSids);
1186 if (r == NULL) {
1187 return false;
1188 }
1189
1190 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1191 talloc_free(r);
1192 return false;
1193 }
1194
1195 pull = ndr_pull_init_blob(&blob, r, NULL);
1196 if (pull == NULL) {
1197 talloc_free(r);
1198 return false;
1199 }
1200
1201 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1202 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1204 talloc_free(r);
1205 return false;
1206 }
1207
1208 if (DEBUGLEVEL >= 10) {
1209 NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);
1210 }
1211
1212 ZERO_STRUCT(r->out);
1213 r->out.names = r->in.names;
1214 r->out.count = r->in.count;
1215 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
1216 if (r->out.domains == NULL) {
1217 talloc_free(r);
1218 return false;
1219 }
1220
1221 r->out.result = _lsa_LookupSids(p, r);
1222
1223 if (p->rng_fault_state) {
1224 talloc_free(r);
1225 /* Return true here, srv_pipe_hnd.c will take care */
1226 return true;
1227 }
1228
1229 if (DEBUGLEVEL >= 10) {
1230 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);
1231 }
1232
1233 push = ndr_push_init_ctx(r, NULL);
1234 if (push == NULL) {
1235 talloc_free(r);
1236 return false;
1237 }
1238
1239 ndr_err = call->ndr_push(push, NDR_OUT, r);
1240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1241 talloc_free(r);
1242 return false;
1243 }
1244
1245 blob = ndr_push_blob(push);
1246 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1247 talloc_free(r);
1248 return false;
1249 }
1250
1251 talloc_free(r);
1252
1253 return true;
1254 }
1255
1256 static bool api_lsa_CreateSecret(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1257 {
1258 const struct ndr_interface_call *call;
1259 struct ndr_pull *pull;
1260 struct ndr_push *push;
1261 enum ndr_err_code ndr_err;
1262 DATA_BLOB blob;
1263 struct lsa_CreateSecret *r;
1264
1265 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATESECRET];
1266
1267 r = talloc(talloc_tos(), struct lsa_CreateSecret);
1268 if (r == NULL) {
1269 return false;
1270 }
1271
1272 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1273 talloc_free(r);
1274 return false;
1275 }
1276
1277 pull = ndr_pull_init_blob(&blob, r, NULL);
1278 if (pull == NULL) {
1279 talloc_free(r);
1280 return false;
1281 }
1282
1283 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1284 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1286 talloc_free(r);
1287 return false;
1288 }
1289
1290 if (DEBUGLEVEL >= 10) {
1291 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, r);
1292 }
1293
1294 ZERO_STRUCT(r->out);
1295 r->out.sec_handle = talloc_zero(r, struct policy_handle);
1296 if (r->out.sec_handle == NULL) {
1297 talloc_free(r);
1298 return false;
1299 }
1300
1301 r->out.result = _lsa_CreateSecret(p, r);
1302
1303 if (p->rng_fault_state) {
1304 talloc_free(r);
1305 /* Return true here, srv_pipe_hnd.c will take care */
1306 return true;
1307 }
1308
1309 if (DEBUGLEVEL >= 10) {
1310 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, r);
1311 }
1312
1313 push = ndr_push_init_ctx(r, NULL);
1314 if (push == NULL) {
1315 talloc_free(r);
1316 return false;
1317 }
1318
1319 ndr_err = call->ndr_push(push, NDR_OUT, r);
1320 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1321 talloc_free(r);
1322 return false;
1323 }
1324
1325 blob = ndr_push_blob(push);
1326 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1327 talloc_free(r);
1328 return false;
1329 }
1330
1331 talloc_free(r);
1332
1333 return true;
1334 }
1335
1336 static bool api_lsa_OpenAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1337 {
1338 const struct ndr_interface_call *call;
1339 struct ndr_pull *pull;
1340 struct ndr_push *push;
1341 enum ndr_err_code ndr_err;
1342 DATA_BLOB blob;
1343 struct lsa_OpenAccount *r;
1344
1345 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENACCOUNT];
1346
1347 r = talloc(talloc_tos(), struct lsa_OpenAccount);
1348 if (r == NULL) {
1349 return false;
1350 }
1351
1352 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1353 talloc_free(r);
1354 return false;
1355 }
1356
1357 pull = ndr_pull_init_blob(&blob, r, NULL);
1358 if (pull == NULL) {
1359 talloc_free(r);
1360 return false;
1361 }
1362
1363 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1364 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1366 talloc_free(r);
1367 return false;
1368 }
1369
1370 if (DEBUGLEVEL >= 10) {
1371 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);
1372 }
1373
1374 ZERO_STRUCT(r->out);
1375 r->out.acct_handle = talloc_zero(r, struct policy_handle);
1376 if (r->out.acct_handle == NULL) {
1377 talloc_free(r);
1378 return false;
1379 }
1380
1381 r->out.result = _lsa_OpenAccount(p, r);
1382
1383 if (p->rng_fault_state) {
1384 talloc_free(r);
1385 /* Return true here, srv_pipe_hnd.c will take care */
1386 return true;
1387 }
1388
1389 if (DEBUGLEVEL >= 10) {
1390 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);
1391 }
1392
1393 push = ndr_push_init_ctx(r, NULL);
1394 if (push == NULL) {
1395 talloc_free(r);
1396 return false;
1397 }
1398
1399 ndr_err = call->ndr_push(push, NDR_OUT, r);
1400 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1401 talloc_free(r);
1402 return false;
1403 }
1404
1405 blob = ndr_push_blob(push);
1406 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1407 talloc_free(r);
1408 return false;
1409 }
1410
1411 talloc_free(r);
1412
1413 return true;
1414 }
1415
1416 static bool api_lsa_EnumPrivsAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1417 {
1418 const struct ndr_interface_call *call;
1419 struct ndr_pull *pull;
1420 struct ndr_push *push;
1421 enum ndr_err_code ndr_err;
1422 DATA_BLOB blob;
1423 struct lsa_EnumPrivsAccount *r;
1424
1425 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVSACCOUNT];
1426
1427 r = talloc(talloc_tos(), struct lsa_EnumPrivsAccount);
1428 if (r == NULL) {
1429 return false;
1430 }
1431
1432 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1433 talloc_free(r);
1434 return false;
1435 }
1436
1437 pull = ndr_pull_init_blob(&blob, r, NULL);
1438 if (pull == NULL) {
1439 talloc_free(r);
1440 return false;
1441 }
1442
1443 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1444 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1445 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1446 talloc_free(r);
1447 return false;
1448 }
1449
1450 if (DEBUGLEVEL >= 10) {
1451 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);
1452 }
1453
1454 ZERO_STRUCT(r->out);
1455 r->out.privs = talloc_zero(r, struct lsa_PrivilegeSet *);
1456 if (r->out.privs == NULL) {
1457 talloc_free(r);
1458 return false;
1459 }
1460
1461 r->out.result = _lsa_EnumPrivsAccount(p, r);
1462
1463 if (p->rng_fault_state) {
1464 talloc_free(r);
1465 /* Return true here, srv_pipe_hnd.c will take care */
1466 return true;
1467 }
1468
1469 if (DEBUGLEVEL >= 10) {
1470 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);
1471 }
1472
1473 push = ndr_push_init_ctx(r, NULL);
1474 if (push == NULL) {
1475 talloc_free(r);
1476 return false;
1477 }
1478
1479 ndr_err = call->ndr_push(push, NDR_OUT, r);
1480 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1481 talloc_free(r);
1482 return false;
1483 }
1484
1485 blob = ndr_push_blob(push);
1486 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1487 talloc_free(r);
1488 return false;
1489 }
1490
1491 talloc_free(r);
1492
1493 return true;
1494 }
1495
1496 static bool api_lsa_AddPrivilegesToAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1497 {
1498 const struct ndr_interface_call *call;
1499 struct ndr_pull *pull;
1500 struct ndr_push *push;
1501 enum ndr_err_code ndr_err;
1502 DATA_BLOB blob;
1503 struct lsa_AddPrivilegesToAccount *r;
1504
1505 call = &ndr_table_lsarpc.calls[NDR_LSA_ADDPRIVILEGESTOACCOUNT];
1506
1507 r = talloc(talloc_tos(), struct lsa_AddPrivilegesToAccount);
1508 if (r == NULL) {
1509 return false;
1510 }
1511
1512 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1513 talloc_free(r);
1514 return false;
1515 }
1516
1517 pull = ndr_pull_init_blob(&blob, r, NULL);
1518 if (pull == NULL) {
1519 talloc_free(r);
1520 return false;
1521 }
1522
1523 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1524 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1525 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1526 talloc_free(r);
1527 return false;
1528 }
1529
1530 if (DEBUGLEVEL >= 10) {
1531 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, r);
1532 }
1533
1534 r->out.result = _lsa_AddPrivilegesToAccount(p, r);
1535
1536 if (p->rng_fault_state) {
1537 talloc_free(r);
1538 /* Return true here, srv_pipe_hnd.c will take care */
1539 return true;
1540 }
1541
1542 if (DEBUGLEVEL >= 10) {
1543 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, r);
1544 }
1545
1546 push = ndr_push_init_ctx(r, NULL);
1547 if (push == NULL) {
1548 talloc_free(r);
1549 return false;
1550 }
1551
1552 ndr_err = call->ndr_push(push, NDR_OUT, r);
1553 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1554 talloc_free(r);
1555 return false;
1556 }
1557
1558 blob = ndr_push_blob(push);
1559 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1560 talloc_free(r);
1561 return false;
1562 }
1563
1564 talloc_free(r);
1565
1566 return true;
1567 }
1568
1569 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1570 {
1571 const struct ndr_interface_call *call;
1572 struct ndr_pull *pull;
1573 struct ndr_push *push;
1574 enum ndr_err_code ndr_err;
1575 DATA_BLOB blob;
1576 struct lsa_RemovePrivilegesFromAccount *r;
1577
1578 call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT];
1579
1580 r = talloc(talloc_tos(), struct lsa_RemovePrivilegesFromAccount);
1581 if (r == NULL) {
1582 return false;
1583 }
1584
1585 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1586 talloc_free(r);
1587 return false;
1588 }
1589
1590 pull = ndr_pull_init_blob(&blob, r, NULL);
1591 if (pull == NULL) {
1592 talloc_free(r);
1593 return false;
1594 }
1595
1596 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1597 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1598 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1599 talloc_free(r);
1600 return false;
1601 }
1602
1603 if (DEBUGLEVEL >= 10) {
1604 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1605 }
1606
1607 r->out.result = _lsa_RemovePrivilegesFromAccount(p, r);
1608
1609 if (p->rng_fault_state) {
1610 talloc_free(r);
1611 /* Return true here, srv_pipe_hnd.c will take care */
1612 return true;
1613 }
1614
1615 if (DEBUGLEVEL >= 10) {
1616 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1617 }
1618
1619 push = ndr_push_init_ctx(r, NULL);
1620 if (push == NULL) {
1621 talloc_free(r);
1622 return false;
1623 }
1624
1625 ndr_err = call->ndr_push(push, NDR_OUT, r);
1626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1627 talloc_free(r);
1628 return false;
1629 }
1630
1631 blob = ndr_push_blob(push);
1632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1633 talloc_free(r);
1634 return false;
1635 }
1636
1637 talloc_free(r);
1638
1639 return true;
1640 }
1641
1642 static bool api_lsa_GetQuotasForAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1643 {
1644 const struct ndr_interface_call *call;
1645 struct ndr_pull *pull;
1646 struct ndr_push *push;
1647 enum ndr_err_code ndr_err;
1648 DATA_BLOB blob;
1649 struct lsa_GetQuotasForAccount *r;
1650
1651 call = &ndr_table_lsarpc.calls[NDR_LSA_GETQUOTASFORACCOUNT];
1652
1653 r = talloc(talloc_tos(), struct lsa_GetQuotasForAccount);
1654 if (r == NULL) {
1655 return false;
1656 }
1657
1658 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1659 talloc_free(r);
1660 return false;
1661 }
1662
1663 pull = ndr_pull_init_blob(&blob, r, NULL);
1664 if (pull == NULL) {
1665 talloc_free(r);
1666 return false;
1667 }
1668
1669 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1670 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1671 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1672 talloc_free(r);
1673 return false;
1674 }
1675
1676 if (DEBUGLEVEL >= 10) {
1677 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, r);
1678 }
1679
1680 r->out.result = _lsa_GetQuotasForAccount(p, r);
1681
1682 if (p->rng_fault_state) {
1683 talloc_free(r);
1684 /* Return true here, srv_pipe_hnd.c will take care */
1685 return true;
1686 }
1687
1688 if (DEBUGLEVEL >= 10) {
1689 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, r);
1690 }
1691
1692 push = ndr_push_init_ctx(r, NULL);
1693 if (push == NULL) {
1694 talloc_free(r);
1695 return false;
1696 }
1697
1698 ndr_err = call->ndr_push(push, NDR_OUT, r);
1699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1700 talloc_free(r);
1701 return false;
1702 }
1703
1704 blob = ndr_push_blob(push);
1705 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1706 talloc_free(r);
1707 return false;
1708 }
1709
1710 talloc_free(r);
1711
1712 return true;
1713 }
1714
1715 static bool api_lsa_SetQuotasForAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1716 {
1717 const struct ndr_interface_call *call;
1718 struct ndr_pull *pull;
1719 struct ndr_push *push;
1720 enum ndr_err_code ndr_err;
1721 DATA_BLOB blob;
1722 struct lsa_SetQuotasForAccount *r;
1723
1724 call = &ndr_table_lsarpc.calls[NDR_LSA_SETQUOTASFORACCOUNT];
1725
1726 r = talloc(talloc_tos(), struct lsa_SetQuotasForAccount);
1727 if (r == NULL) {
1728 return false;
1729 }
1730
1731 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1732 talloc_free(r);
1733 return false;
1734 }
1735
1736 pull = ndr_pull_init_blob(&blob, r, NULL);
1737 if (pull == NULL) {
1738 talloc_free(r);
1739 return false;
1740 }
1741
1742 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1743 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1744 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1745 talloc_free(r);
1746 return false;
1747 }
1748
1749 if (DEBUGLEVEL >= 10) {
1750 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, r);
1751 }
1752
1753 r->out.result = _lsa_SetQuotasForAccount(p, r);
1754
1755 if (p->rng_fault_state) {
1756 talloc_free(r);
1757 /* Return true here, srv_pipe_hnd.c will take care */
1758 return true;
1759 }
1760
1761 if (DEBUGLEVEL >= 10) {
1762 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, r);
1763 }
1764
1765 push = ndr_push_init_ctx(r, NULL);
1766 if (push == NULL) {
1767 talloc_free(r);
1768 return false;
1769 }
1770
1771 ndr_err = call->ndr_push(push, NDR_OUT, r);
1772 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1773 talloc_free(r);
1774 return false;
1775 }
1776
1777 blob = ndr_push_blob(push);
1778 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1779 talloc_free(r);
1780 return false;
1781 }
1782
1783 talloc_free(r);
1784
1785 return true;
1786 }
1787
1788 static bool api_lsa_GetSystemAccessAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1789 {
1790 const struct ndr_interface_call *call;
1791 struct ndr_pull *pull;
1792 struct ndr_push *push;
1793 enum ndr_err_code ndr_err;
1794 DATA_BLOB blob;
1795 struct lsa_GetSystemAccessAccount *r;
1796
1797 call = &ndr_table_lsarpc.calls[NDR_LSA_GETSYSTEMACCESSACCOUNT];
1798
1799 r = talloc(talloc_tos(), struct lsa_GetSystemAccessAccount);
1800 if (r == NULL) {
1801 return false;
1802 }
1803
1804 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1805 talloc_free(r);
1806 return false;
1807 }
1808
1809 pull = ndr_pull_init_blob(&blob, r, NULL);
1810 if (pull == NULL) {
1811 talloc_free(r);
1812 return false;
1813 }
1814
1815 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1816 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1817 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1818 talloc_free(r);
1819 return false;
1820 }
1821
1822 if (DEBUGLEVEL >= 10) {
1823 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, r);
1824 }
1825
1826 ZERO_STRUCT(r->out);
1827 r->out.access_mask = talloc_zero(r, uint32_t);
1828 if (r->out.access_mask == NULL) {
1829 talloc_free(r);
1830 return false;
1831 }
1832
1833 r->out.result = _lsa_GetSystemAccessAccount(p, r);
1834
1835 if (p->rng_fault_state) {
1836 talloc_free(r);
1837 /* Return true here, srv_pipe_hnd.c will take care */
1838 return true;
1839 }
1840
1841 if (DEBUGLEVEL >= 10) {
1842 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1843 }
1844
1845 push = ndr_push_init_ctx(r, NULL);
1846 if (push == NULL) {
1847 talloc_free(r);
1848 return false;
1849 }
1850
1851 ndr_err = call->ndr_push(push, NDR_OUT, r);
1852 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1853 talloc_free(r);
1854 return false;
1855 }
1856
1857 blob = ndr_push_blob(push);
1858 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1859 talloc_free(r);
1860 return false;
1861 }
1862
1863 talloc_free(r);
1864
1865 return true;
1866 }
1867
1868 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1869 {
1870 const struct ndr_interface_call *call;
1871 struct ndr_pull *pull;
1872 struct ndr_push *push;
1873 enum ndr_err_code ndr_err;
1874 DATA_BLOB blob;
1875 struct lsa_SetSystemAccessAccount *r;
1876
1877 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1878
1879 r = talloc(talloc_tos(), struct lsa_SetSystemAccessAccount);
1880 if (r == NULL) {
1881 return false;
1882 }
1883
1884 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1885 talloc_free(r);
1886 return false;
1887 }
1888
1889 pull = ndr_pull_init_blob(&blob, r, NULL);
1890 if (pull == NULL) {
1891 talloc_free(r);
1892 return false;
1893 }
1894
1895 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1896 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1897 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1898 talloc_free(r);
1899 return false;
1900 }
1901
1902 if (DEBUGLEVEL >= 10) {
1903 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1904 }
1905
1906 r->out.result = _lsa_SetSystemAccessAccount(p, r);
1907
1908 if (p->rng_fault_state) {
1909 talloc_free(r);
1910 /* Return true here, srv_pipe_hnd.c will take care */
1911 return true;
1912 }
1913
1914 if (DEBUGLEVEL >= 10) {
1915 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1916 }
1917
1918 push = ndr_push_init_ctx(r, NULL);
1919 if (push == NULL) {
1920 talloc_free(r);
1921 return false;
1922 }
1923
1924 ndr_err = call->ndr_push(push, NDR_OUT, r);
1925 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1926 talloc_free(r);
1927 return false;
1928 }
1929
1930 blob = ndr_push_blob(push);
1931 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1932 talloc_free(r);
1933 return false;
1934 }
1935
1936 talloc_free(r);
1937
1938 return true;
1939 }
1940
1941 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
1942 {
1943 const struct ndr_interface_call *call;
1944 struct ndr_pull *pull;
1945 struct ndr_push *push;
1946 enum ndr_err_code ndr_err;
1947 DATA_BLOB blob;
1948 struct lsa_OpenTrustedDomain *r;
1949
1950 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1951
1952 r = talloc(talloc_tos(), struct lsa_OpenTrustedDomain);
1953 if (r == NULL) {
1954 return false;
1955 }
1956
1957 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1958 talloc_free(r);
1959 return false;
1960 }
1961
1962 pull = ndr_pull_init_blob(&blob, r, NULL);
1963 if (pull == NULL) {
1964 talloc_free(r);
1965 return false;
1966 }
1967
1968 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1969 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1970 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1971 talloc_free(r);
1972 return false;
1973 }
1974
1975 if (DEBUGLEVEL >= 10) {
1976 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1977 }
1978
1979 ZERO_STRUCT(r->out);
1980 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1981 if (r->out.trustdom_handle == NULL) {
1982 talloc_free(r);
1983 return false;
1984 }
1985
1986 r->out.result = _lsa_OpenTrustedDomain(p, r);
1987
1988 if (p->rng_fault_state) {
1989 talloc_free(r);
1990 /* Return true here, srv_pipe_hnd.c will take care */
1991 return true;
1992 }
1993
1994 if (DEBUGLEVEL >= 10) {
1995 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1996 }
1997
1998 push = ndr_push_init_ctx(r, NULL);
1999 if (push == NULL) {
2000 talloc_free(r);
2001 return false;
2002 }
2003
2004 ndr_err = call->ndr_push(push, NDR_OUT, r);
2005 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2006 talloc_free(r);
2007 return false;
2008 }
2009
2010 blob = ndr_push_blob(push);
2011 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2012 talloc_free(r);
2013 return false;
2014 }
2015
2016 talloc_free(r);
2017
2018 return true;
2019 }
2020
2021 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2022 {
2023 const struct ndr_interface_call *call;
2024 struct ndr_pull *pull;
2025 struct ndr_push *push;
2026 enum ndr_err_code ndr_err;
2027 DATA_BLOB blob;
2028 struct lsa_QueryTrustedDomainInfo *r;
2029
2030 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
2031
2032 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfo);
2033 if (r == NULL) {
2034 return false;
2035 }
2036
2037 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2038 talloc_free(r);
2039 return false;
2040 }
2041
2042 pull = ndr_pull_init_blob(&blob, r, NULL);
2043 if (pull == NULL) {
2044 talloc_free(r);
2045 return false;
2046 }
2047
2048 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2049 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2050 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2051 talloc_free(r);
2052 return false;
2053 }
2054
2055 if (DEBUGLEVEL >= 10) {
2056 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
2057 }
2058
2059 ZERO_STRUCT(r->out);
2060 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
2061 if (r->out.info == NULL) {
2062 talloc_free(r);
2063 return false;
2064 }
2065
2066 r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2067
2068 if (p->rng_fault_state) {
2069 talloc_free(r);
2070 /* Return true here, srv_pipe_hnd.c will take care */
2071 return true;
2072 }
2073
2074 if (DEBUGLEVEL >= 10) {
2075 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2076 }
2077
2078 push = ndr_push_init_ctx(r, NULL);
2079 if (push == NULL) {
2080 talloc_free(r);
2081 return false;
2082 }
2083
2084 ndr_err = call->ndr_push(push, NDR_OUT, r);
2085 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2086 talloc_free(r);
2087 return false;
2088 }
2089
2090 blob = ndr_push_blob(push);
2091 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2092 talloc_free(r);
2093 return false;
2094 }
2095
2096 talloc_free(r);
2097
2098 return true;
2099 }
2100
2101 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2102 {
2103 const struct ndr_interface_call *call;
2104 struct ndr_pull *pull;
2105 struct ndr_push *push;
2106 enum ndr_err_code ndr_err;
2107 DATA_BLOB blob;
2108 struct lsa_SetInformationTrustedDomain *r;
2109
2110 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2111
2112 r = talloc(talloc_tos(), struct lsa_SetInformationTrustedDomain);
2113 if (r == NULL) {
2114 return false;
2115 }
2116
2117 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2118 talloc_free(r);
2119 return false;
2120 }
2121
2122 pull = ndr_pull_init_blob(&blob, r, NULL);
2123 if (pull == NULL) {
2124 talloc_free(r);
2125 return false;
2126 }
2127
2128 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2129 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2131 talloc_free(r);
2132 return false;
2133 }
2134
2135 if (DEBUGLEVEL >= 10) {
2136 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2137 }
2138
2139 r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2140
2141 if (p->rng_fault_state) {
2142 talloc_free(r);
2143 /* Return true here, srv_pipe_hnd.c will take care */
2144 return true;
2145 }
2146
2147 if (DEBUGLEVEL >= 10) {
2148 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2149 }
2150
2151 push = ndr_push_init_ctx(r, NULL);
2152 if (push == NULL) {
2153 talloc_free(r);
2154 return false;
2155 }
2156
2157 ndr_err = call->ndr_push(push, NDR_OUT, r);
2158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2159 talloc_free(r);
2160 return false;
2161 }
2162
2163 blob = ndr_push_blob(push);
2164 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2165 talloc_free(r);
2166 return false;
2167 }
2168
2169 talloc_free(r);
2170
2171 return true;
2172 }
2173
2174 static bool api_lsa_OpenSecret(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2175 {
2176 const struct ndr_interface_call *call;
2177 struct ndr_pull *pull;
2178 struct ndr_push *push;
2179 enum ndr_err_code ndr_err;
2180 DATA_BLOB blob;
2181 struct lsa_OpenSecret *r;
2182
2183 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENSECRET];
2184
2185 r = talloc(talloc_tos(), struct lsa_OpenSecret);
2186 if (r == NULL) {
2187 return false;
2188 }
2189
2190 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2191 talloc_free(r);
2192 return false;
2193 }
2194
2195 pull = ndr_pull_init_blob(&blob, r, NULL);
2196 if (pull == NULL) {
2197 talloc_free(r);
2198 return false;
2199 }
2200
2201 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2202 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2204 talloc_free(r);
2205 return false;
2206 }
2207
2208 if (DEBUGLEVEL >= 10) {
2209 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2210 }
2211
2212 ZERO_STRUCT(r->out);
2213 r->out.sec_handle = talloc_zero(r, struct policy_handle);
2214 if (r->out.sec_handle == NULL) {
2215 talloc_free(r);
2216 return false;
2217 }
2218
2219 r->out.result = _lsa_OpenSecret(p, r);
2220
2221 if (p->rng_fault_state) {
2222 talloc_free(r);
2223 /* Return true here, srv_pipe_hnd.c will take care */
2224 return true;
2225 }
2226
2227 if (DEBUGLEVEL >= 10) {
2228 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2229 }
2230
2231 push = ndr_push_init_ctx(r, NULL);
2232 if (push == NULL) {
2233 talloc_free(r);
2234 return false;
2235 }
2236
2237 ndr_err = call->ndr_push(push, NDR_OUT, r);
2238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2239 talloc_free(r);
2240 return false;
2241 }
2242
2243 blob = ndr_push_blob(push);
2244 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2245 talloc_free(r);
2246 return false;
2247 }
2248
2249 talloc_free(r);
2250
2251 return true;
2252 }
2253
2254 static bool api_lsa_SetSecret(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2255 {
2256 const struct ndr_interface_call *call;
2257 struct ndr_pull *pull;
2258 struct ndr_push *push;
2259 enum ndr_err_code ndr_err;
2260 DATA_BLOB blob;
2261 struct lsa_SetSecret *r;
2262
2263 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECRET];
2264
2265 r = talloc(talloc_tos(), struct lsa_SetSecret);
2266 if (r == NULL) {
2267 return false;
2268 }
2269
2270 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2271 talloc_free(r);
2272 return false;
2273 }
2274
2275 pull = ndr_pull_init_blob(&blob, r, NULL);
2276 if (pull == NULL) {
2277 talloc_free(r);
2278 return false;
2279 }
2280
2281 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2282 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2283 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2284 talloc_free(r);
2285 return false;
2286 }
2287
2288 if (DEBUGLEVEL >= 10) {
2289 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2290 }
2291
2292 r->out.result = _lsa_SetSecret(p, r);
2293
2294 if (p->rng_fault_state) {
2295 talloc_free(r);
2296 /* Return true here, srv_pipe_hnd.c will take care */
2297 return true;
2298 }
2299
2300 if (DEBUGLEVEL >= 10) {
2301 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2302 }
2303
2304 push = ndr_push_init_ctx(r, NULL);
2305 if (push == NULL) {
2306 talloc_free(r);
2307 return false;
2308 }
2309
2310 ndr_err = call->ndr_push(push, NDR_OUT, r);
2311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2312 talloc_free(r);
2313 return false;
2314 }
2315
2316 blob = ndr_push_blob(push);
2317 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2318 talloc_free(r);
2319 return false;
2320 }
2321
2322 talloc_free(r);
2323
2324 return true;
2325 }
2326
2327 static bool api_lsa_QuerySecret(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2328 {
2329 const struct ndr_interface_call *call;
2330 struct ndr_pull *pull;
2331 struct ndr_push *push;
2332 enum ndr_err_code ndr_err;
2333 DATA_BLOB blob;
2334 struct lsa_QuerySecret *r;
2335
2336 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECRET];
2337
2338 r = talloc(talloc_tos(), struct lsa_QuerySecret);
2339 if (r == NULL) {
2340 return false;
2341 }
2342
2343 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2344 talloc_free(r);
2345 return false;
2346 }
2347
2348 pull = ndr_pull_init_blob(&blob, r, NULL);
2349 if (pull == NULL) {
2350 talloc_free(r);
2351 return false;
2352 }
2353
2354 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2355 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2356 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2357 talloc_free(r);
2358 return false;
2359 }
2360
2361 if (DEBUGLEVEL >= 10) {
2362 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
2363 }
2364
2365 ZERO_STRUCT(r->out);
2366 r->out.new_val = r->in.new_val;
2367 r->out.new_mtime = r->in.new_mtime;
2368 r->out.old_val = r->in.old_val;
2369 r->out.old_mtime = r->in.old_mtime;
2370 r->out.result = _lsa_QuerySecret(p, r);
2371
2372 if (p->rng_fault_state) {
2373 talloc_free(r);
2374 /* Return true here, srv_pipe_hnd.c will take care */
2375 return true;
2376 }
2377
2378 if (DEBUGLEVEL >= 10) {
2379 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2380 }
2381
2382 push = ndr_push_init_ctx(r, NULL);
2383 if (push == NULL) {
2384 talloc_free(r);
2385 return false;
2386 }
2387
2388 ndr_err = call->ndr_push(push, NDR_OUT, r);
2389 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2390 talloc_free(r);
2391 return false;
2392 }
2393
2394 blob = ndr_push_blob(push);
2395 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2396 talloc_free(r);
2397 return false;
2398 }
2399
2400 talloc_free(r);
2401
2402 return true;
2403 }
2404
2405 static bool api_lsa_LookupPrivValue(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2406 {
2407 const struct ndr_interface_call *call;
2408 struct ndr_pull *pull;
2409 struct ndr_push *push;
2410 enum ndr_err_code ndr_err;
2411 DATA_BLOB blob;
2412 struct lsa_LookupPrivValue *r;
2413
2414 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVVALUE];
2415
2416 r = talloc(talloc_tos(), struct lsa_LookupPrivValue);
2417 if (r == NULL) {
2418 return false;
2419 }
2420
2421 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2422 talloc_free(r);
2423 return false;
2424 }
2425
2426 pull = ndr_pull_init_blob(&blob, r, NULL);
2427 if (pull == NULL) {
2428 talloc_free(r);
2429 return false;
2430 }
2431
2432 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2433 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2434 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2435 talloc_free(r);
2436 return false;
2437 }
2438
2439 if (DEBUGLEVEL >= 10) {
2440 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2441 }
2442
2443 ZERO_STRUCT(r->out);
2444 r->out.luid = talloc_zero(r, struct lsa_LUID);
2445 if (r->out.luid == NULL) {
2446 talloc_free(r);
2447 return false;
2448 }
2449
2450 r->out.result = _lsa_LookupPrivValue(p, r);
2451
2452 if (p->rng_fault_state) {
2453 talloc_free(r);
2454 /* Return true here, srv_pipe_hnd.c will take care */
2455 return true;
2456 }
2457
2458 if (DEBUGLEVEL >= 10) {
2459 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2460 }
2461
2462 push = ndr_push_init_ctx(r, NULL);
2463 if (push == NULL) {
2464 talloc_free(r);
2465 return false;
2466 }
2467
2468 ndr_err = call->ndr_push(push, NDR_OUT, r);
2469 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2470 talloc_free(r);
2471 return false;
2472 }
2473
2474 blob = ndr_push_blob(push);
2475 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2476 talloc_free(r);
2477 return false;
2478 }
2479
2480 talloc_free(r);
2481
2482 return true;
2483 }
2484
2485 static bool api_lsa_LookupPrivName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2486 {
2487 const struct ndr_interface_call *call;
2488 struct ndr_pull *pull;
2489 struct ndr_push *push;
2490 enum ndr_err_code ndr_err;
2491 DATA_BLOB blob;
2492 struct lsa_LookupPrivName *r;
2493
2494 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVNAME];
2495
2496 r = talloc(talloc_tos(), struct lsa_LookupPrivName);
2497 if (r == NULL) {
2498 return false;
2499 }
2500
2501 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2502 talloc_free(r);
2503 return false;
2504 }
2505
2506 pull = ndr_pull_init_blob(&blob, r, NULL);
2507 if (pull == NULL) {
2508 talloc_free(r);
2509 return false;
2510 }
2511
2512 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2513 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2514 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2515 talloc_free(r);
2516 return false;
2517 }
2518
2519 if (DEBUGLEVEL >= 10) {
2520 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2521 }
2522
2523 ZERO_STRUCT(r->out);
2524 r->out.name = talloc_zero(r, struct lsa_StringLarge *);
2525 if (r->out.name == NULL) {
2526 talloc_free(r);
2527 return false;
2528 }
2529
2530 r->out.result = _lsa_LookupPrivName(p, r);
2531
2532 if (p->rng_fault_state) {
2533 talloc_free(r);
2534 /* Return true here, srv_pipe_hnd.c will take care */
2535 return true;
2536 }
2537
2538 if (DEBUGLEVEL >= 10) {
2539 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2540 }
2541
2542 push = ndr_push_init_ctx(r, NULL);
2543 if (push == NULL) {
2544 talloc_free(r);
2545 return false;
2546 }
2547
2548 ndr_err = call->ndr_push(push, NDR_OUT, r);
2549 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2550 talloc_free(r);
2551 return false;
2552 }
2553
2554 blob = ndr_push_blob(push);
2555 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2556 talloc_free(r);
2557 return false;
2558 }
2559
2560 talloc_free(r);
2561
2562 return true;
2563 }
2564
2565 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2566 {
2567 const struct ndr_interface_call *call;
2568 struct ndr_pull *pull;
2569 struct ndr_push *push;
2570 enum ndr_err_code ndr_err;
2571 DATA_BLOB blob;
2572 struct lsa_LookupPrivDisplayName *r;
2573
2574 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2575
2576 r = talloc(talloc_tos(), struct lsa_LookupPrivDisplayName);
2577 if (r == NULL) {
2578 return false;
2579 }
2580
2581 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2582 talloc_free(r);
2583 return false;
2584 }
2585
2586 pull = ndr_pull_init_blob(&blob, r, NULL);
2587 if (pull == NULL) {
2588 talloc_free(r);
2589 return false;
2590 }
2591
2592 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2593 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2594 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2595 talloc_free(r);
2596 return false;
2597 }
2598
2599 if (DEBUGLEVEL >= 10) {
2600 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2601 }
2602
2603 ZERO_STRUCT(r->out);
2604 r->out.disp_name = talloc_zero(r, struct lsa_StringLarge *);
2605 if (r->out.disp_name == NULL) {
2606 talloc_free(r);
2607 return false;
2608 }
2609
2610 r->out.returned_language_id = talloc_zero(r, uint16_t);
2611 if (r->out.returned_language_id == NULL) {
2612 talloc_free(r);
2613 return false;
2614 }
2615
2616 r->out.result = _lsa_LookupPrivDisplayName(p, r);
2617
2618 if (p->rng_fault_state) {
2619 talloc_free(r);
2620 /* Return true here, srv_pipe_hnd.c will take care */
2621 return true;
2622 }
2623
2624 if (DEBUGLEVEL >= 10) {
2625 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2626 }
2627
2628 push = ndr_push_init_ctx(r, NULL);
2629 if (push == NULL) {
2630 talloc_free(r);
2631 return false;
2632 }
2633
2634 ndr_err = call->ndr_push(push, NDR_OUT, r);
2635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2636 talloc_free(r);
2637 return false;
2638 }
2639
2640 blob = ndr_push_blob(push);
2641 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2642 talloc_free(r);
2643 return false;
2644 }
2645
2646 talloc_free(r);
2647
2648 return true;
2649 }
2650
2651 static bool api_lsa_DeleteObject(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2652 {
2653 const struct ndr_interface_call *call;
2654 struct ndr_pull *pull;
2655 struct ndr_push *push;
2656 enum ndr_err_code ndr_err;
2657 DATA_BLOB blob;
2658 struct lsa_DeleteObject *r;
2659
2660 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETEOBJECT];
2661
2662 r = talloc(talloc_tos(), struct lsa_DeleteObject);
2663 if (r == NULL) {
2664 return false;
2665 }
2666
2667 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2668 talloc_free(r);
2669 return false;
2670 }
2671
2672 pull = ndr_pull_init_blob(&blob, r, NULL);
2673 if (pull == NULL) {
2674 talloc_free(r);
2675 return false;
2676 }
2677
2678 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2679 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2680 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2681 talloc_free(r);
2682 return false;
2683 }
2684
2685 if (DEBUGLEVEL >= 10) {
2686 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2687 }
2688
2689 ZERO_STRUCT(r->out);
2690 r->out.handle = r->in.handle;
2691 r->out.result = _lsa_DeleteObject(p, r);
2692
2693 if (p->rng_fault_state) {
2694 talloc_free(r);
2695 /* Return true here, srv_pipe_hnd.c will take care */
2696 return true;
2697 }
2698
2699 if (DEBUGLEVEL >= 10) {
2700 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2701 }
2702
2703 push = ndr_push_init_ctx(r, NULL);
2704 if (push == NULL) {
2705 talloc_free(r);
2706 return false;
2707 }
2708
2709 ndr_err = call->ndr_push(push, NDR_OUT, r);
2710 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2711 talloc_free(r);
2712 return false;
2713 }
2714
2715 blob = ndr_push_blob(push);
2716 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2717 talloc_free(r);
2718 return false;
2719 }
2720
2721 talloc_free(r);
2722
2723 return true;
2724 }
2725
2726 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2727 {
2728 const struct ndr_interface_call *call;
2729 struct ndr_pull *pull;
2730 struct ndr_push *push;
2731 enum ndr_err_code ndr_err;
2732 DATA_BLOB blob;
2733 struct lsa_EnumAccountsWithUserRight *r;
2734
2735 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2736
2737 r = talloc(talloc_tos(), struct lsa_EnumAccountsWithUserRight);
2738 if (r == NULL) {
2739 return false;
2740 }
2741
2742 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2743 talloc_free(r);
2744 return false;
2745 }
2746
2747 pull = ndr_pull_init_blob(&blob, r, NULL);
2748 if (pull == NULL) {
2749 talloc_free(r);
2750 return false;
2751 }
2752
2753 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2754 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2755 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2756 talloc_free(r);
2757 return false;
2758 }
2759
2760 if (DEBUGLEVEL >= 10) {
2761 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2762 }
2763
2764 ZERO_STRUCT(r->out);
2765 r->out.sids = talloc_zero(r, struct lsa_SidArray);
2766 if (r->out.sids == NULL) {
2767 talloc_free(r);
2768 return false;
2769 }
2770
2771 r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2772
2773 if (p->rng_fault_state) {
2774 talloc_free(r);
2775 /* Return true here, srv_pipe_hnd.c will take care */
2776 return true;
2777 }
2778
2779 if (DEBUGLEVEL >= 10) {
2780 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2781 }
2782
2783 push = ndr_push_init_ctx(r, NULL);
2784 if (push == NULL) {
2785 talloc_free(r);
2786 return false;
2787 }
2788
2789 ndr_err = call->ndr_push(push, NDR_OUT, r);
2790 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2791 talloc_free(r);
2792 return false;
2793 }
2794
2795 blob = ndr_push_blob(push);
2796 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2797 talloc_free(r);
2798 return false;
2799 }
2800
2801 talloc_free(r);
2802
2803 return true;
2804 }
2805
2806 static bool api_lsa_EnumAccountRights(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2807 {
2808 const struct ndr_interface_call *call;
2809 struct ndr_pull *pull;
2810 struct ndr_push *push;
2811 enum ndr_err_code ndr_err;
2812 DATA_BLOB blob;
2813 struct lsa_EnumAccountRights *r;
2814
2815 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2816
2817 r = talloc(talloc_tos(), struct lsa_EnumAccountRights);
2818 if (r == NULL) {
2819 return false;
2820 }
2821
2822 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2823 talloc_free(r);
2824 return false;
2825 }
2826
2827 pull = ndr_pull_init_blob(&blob, r, NULL);
2828 if (pull == NULL) {
2829 talloc_free(r);
2830 return false;
2831 }
2832
2833 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2834 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2835 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2836 talloc_free(r);
2837 return false;
2838 }
2839
2840 if (DEBUGLEVEL >= 10) {
2841 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2842 }
2843
2844 ZERO_STRUCT(r->out);
2845 r->out.rights = talloc_zero(r, struct lsa_RightSet);
2846 if (r->out.rights == NULL) {
2847 talloc_free(r);
2848 return false;
2849 }
2850
2851 r->out.result = _lsa_EnumAccountRights(p, r);
2852
2853 if (p->rng_fault_state) {
2854 talloc_free(r);
2855 /* Return true here, srv_pipe_hnd.c will take care */
2856 return true;
2857 }
2858
2859 if (DEBUGLEVEL >= 10) {
2860 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2861 }
2862
2863 push = ndr_push_init_ctx(r, NULL);
2864 if (push == NULL) {
2865 talloc_free(r);
2866 return false;
2867 }
2868
2869 ndr_err = call->ndr_push(push, NDR_OUT, r);
2870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2871 talloc_free(r);
2872 return false;
2873 }
2874
2875 blob = ndr_push_blob(push);
2876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2877 talloc_free(r);
2878 return false;
2879 }
2880
2881 talloc_free(r);
2882
2883 return true;
2884 }
2885
2886 static bool api_lsa_AddAccountRights(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2887 {
2888 const struct ndr_interface_call *call;
2889 struct ndr_pull *pull;
2890 struct ndr_push *push;
2891 enum ndr_err_code ndr_err;
2892 DATA_BLOB blob;
2893 struct lsa_AddAccountRights *r;
2894
2895 call = &ndr_table_lsarpc.calls[NDR_LSA_ADDACCOUNTRIGHTS];
2896
2897 r = talloc(talloc_tos(), struct lsa_AddAccountRights);
2898 if (r == NULL) {
2899 return false;
2900 }
2901
2902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2903 talloc_free(r);
2904 return false;
2905 }
2906
2907 pull = ndr_pull_init_blob(&blob, r, NULL);
2908 if (pull == NULL) {
2909 talloc_free(r);
2910 return false;
2911 }
2912
2913 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2914 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2916 talloc_free(r);
2917 return false;
2918 }
2919
2920 if (DEBUGLEVEL >= 10) {
2921 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2922 }
2923
2924 r->out.result = _lsa_AddAccountRights(p, r);
2925
2926 if (p->rng_fault_state) {
2927 talloc_free(r);
2928 /* Return true here, srv_pipe_hnd.c will take care */
2929 return true;
2930 }
2931
2932 if (DEBUGLEVEL >= 10) {
2933 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2934 }
2935
2936 push = ndr_push_init_ctx(r, NULL);
2937 if (push == NULL) {
2938 talloc_free(r);
2939 return false;
2940 }
2941
2942 ndr_err = call->ndr_push(push, NDR_OUT, r);
2943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2944 talloc_free(r);
2945 return false;
2946 }
2947
2948 blob = ndr_push_blob(push);
2949 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2950 talloc_free(r);
2951 return false;
2952 }
2953
2954 talloc_free(r);
2955
2956 return true;
2957 }
2958
2959 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
2960 {
2961 const struct ndr_interface_call *call;
2962 struct ndr_pull *pull;
2963 struct ndr_push *push;
2964 enum ndr_err_code ndr_err;
2965 DATA_BLOB blob;
2966 struct lsa_RemoveAccountRights *r;
2967
2968 call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2969
2970 r = talloc(talloc_tos(), struct lsa_RemoveAccountRights);
2971 if (r == NULL) {
2972 return false;
2973 }
2974
2975 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2976 talloc_free(r);
2977 return false;
2978 }
2979
2980 pull = ndr_pull_init_blob(&blob, r, NULL);
2981 if (pull == NULL) {
2982 talloc_free(r);
2983 return false;
2984 }
2985
2986 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2987 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2988 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2989 talloc_free(r);
2990 return false;
2991 }
2992
2993 if (DEBUGLEVEL >= 10) {
2994 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2995 }
2996
2997 r->out.result = _lsa_RemoveAccountRights(p, r);
2998
2999 if (p->rng_fault_state) {
3000 talloc_free(r);
3001 /* Return true here, srv_pipe_hnd.c will take care */
3002 return true;
3003 }
3004
3005 if (DEBUGLEVEL >= 10) {
3006 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
3007 }
3008
3009 push = ndr_push_init_ctx(r, NULL);
3010 if (push == NULL) {
3011 talloc_free(r);
3012 return false;
3013 }
3014
3015 ndr_err = call->ndr_push(push, NDR_OUT, r);
3016 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3017 talloc_free(r);
3018 return false;
3019 }
3020
3021 blob = ndr_push_blob(push);
3022 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3023 talloc_free(r);
3024 return false;
3025 }
3026
3027 talloc_free(r);
3028
3029 return true;
3030 }
3031
3032 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3033 {
3034 const struct ndr_interface_call *call;
3035 struct ndr_pull *pull;
3036 struct ndr_push *push;
3037 enum ndr_err_code ndr_err;
3038 DATA_BLOB blob;
3039 struct lsa_QueryTrustedDomainInfoBySid *r;
3040
3041 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
3042
3043 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoBySid);
3044 if (r == NULL) {
3045 return false;
3046 }
3047
3048 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3049 talloc_free(r);
3050 return false;
3051 }
3052
3053 pull = ndr_pull_init_blob(&blob, r, NULL);
3054 if (pull == NULL) {
3055 talloc_free(r);
3056 return false;
3057 }
3058
3059 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3060 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3061 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3062 talloc_free(r);
3063 return false;
3064 }
3065
3066 if (DEBUGLEVEL >= 10) {
3067 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3068 }
3069
3070 ZERO_STRUCT(r->out);
3071 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3072 if (r->out.info == NULL) {
3073 talloc_free(r);
3074 return false;
3075 }
3076
3077 r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
3078
3079 if (p->rng_fault_state) {
3080 talloc_free(r);
3081 /* Return true here, srv_pipe_hnd.c will take care */
3082 return true;
3083 }
3084
3085 if (DEBUGLEVEL >= 10) {
3086 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3087 }
3088
3089 push = ndr_push_init_ctx(r, NULL);
3090 if (push == NULL) {
3091 talloc_free(r);
3092 return false;
3093 }
3094
3095 ndr_err = call->ndr_push(push, NDR_OUT, r);
3096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3097 talloc_free(r);
3098 return false;
3099 }
3100
3101 blob = ndr_push_blob(push);
3102 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3103 talloc_free(r);
3104 return false;
3105 }
3106
3107 talloc_free(r);
3108
3109 return true;
3110 }
3111
3112 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3113 {
3114 const struct ndr_interface_call *call;
3115 struct ndr_pull *pull;
3116 struct ndr_push *push;
3117 enum ndr_err_code ndr_err;
3118 DATA_BLOB blob;
3119 struct lsa_SetTrustedDomainInfo *r;
3120
3121 call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3122
3123 r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfo);
3124 if (r == NULL) {
3125 return false;
3126 }
3127
3128 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3129 talloc_free(r);
3130 return false;
3131 }
3132
3133 pull = ndr_pull_init_blob(&blob, r, NULL);
3134 if (pull == NULL) {
3135 talloc_free(r);
3136 return false;
3137 }
3138
3139 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3140 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3142 talloc_free(r);
3143 return false;
3144 }
3145
3146 if (DEBUGLEVEL >= 10) {
3147 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3148 }
3149
3150 r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3151
3152 if (p->rng_fault_state) {
3153 talloc_free(r);
3154 /* Return true here, srv_pipe_hnd.c will take care */
3155 return true;
3156 }
3157
3158 if (DEBUGLEVEL >= 10) {
3159 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3160 }
3161
3162 push = ndr_push_init_ctx(r, NULL);
3163 if (push == NULL) {
3164 talloc_free(r);
3165 return false;
3166 }
3167
3168 ndr_err = call->ndr_push(push, NDR_OUT, r);
3169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3170 talloc_free(r);
3171 return false;
3172 }
3173
3174 blob = ndr_push_blob(push);
3175 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3176 talloc_free(r);
3177 return false;
3178 }
3179
3180 talloc_free(r);
3181
3182 return true;
3183 }
3184
3185 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3186 {
3187 const struct ndr_interface_call *call;
3188 struct ndr_pull *pull;
3189 struct ndr_push *push;
3190 enum ndr_err_code ndr_err;
3191 DATA_BLOB blob;
3192 struct lsa_DeleteTrustedDomain *r;
3193
3194 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3195
3196 r = talloc(talloc_tos(), struct lsa_DeleteTrustedDomain);
3197 if (r == NULL) {
3198 return false;
3199 }
3200
3201 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3202 talloc_free(r);
3203 return false;
3204 }
3205
3206 pull = ndr_pull_init_blob(&blob, r, NULL);
3207 if (pull == NULL) {
3208 talloc_free(r);
3209 return false;
3210 }
3211
3212 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3213 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3214 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3215 talloc_free(r);
3216 return false;
3217 }
3218
3219 if (DEBUGLEVEL >= 10) {
3220 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3221 }
3222
3223 r->out.result = _lsa_DeleteTrustedDomain(p, r);
3224
3225 if (p->rng_fault_state) {
3226 talloc_free(r);
3227 /* Return true here, srv_pipe_hnd.c will take care */
3228 return true;
3229 }
3230
3231 if (DEBUGLEVEL >= 10) {
3232 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3233 }
3234
3235 push = ndr_push_init_ctx(r, NULL);
3236 if (push == NULL) {
3237 talloc_free(r);
3238 return false;
3239 }
3240
3241 ndr_err = call->ndr_push(push, NDR_OUT, r);
3242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3243 talloc_free(r);
3244 return false;
3245 }
3246
3247 blob = ndr_push_blob(push);
3248 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3249 talloc_free(r);
3250 return false;
3251 }
3252
3253 talloc_free(r);
3254
3255 return true;
3256 }
3257
3258 static bool api_lsa_StorePrivateData(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3259 {
3260 const struct ndr_interface_call *call;
3261 struct ndr_pull *pull;
3262 struct ndr_push *push;
3263 enum ndr_err_code ndr_err;
3264 DATA_BLOB blob;
3265 struct lsa_StorePrivateData *r;
3266
3267 call = &ndr_table_lsarpc.calls[NDR_LSA_STOREPRIVATEDATA];
3268
3269 r = talloc(talloc_tos(), struct lsa_StorePrivateData);
3270 if (r == NULL) {
3271 return false;
3272 }
3273
3274 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3275 talloc_free(r);
3276 return false;
3277 }
3278
3279 pull = ndr_pull_init_blob(&blob, r, NULL);
3280 if (pull == NULL) {
3281 talloc_free(r);
3282 return false;
3283 }
3284
3285 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3286 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3287 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3288 talloc_free(r);
3289 return false;
3290 }
3291
3292 if (DEBUGLEVEL >= 10) {
3293 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3294 }
3295
3296 r->out.result = _lsa_StorePrivateData(p, r);
3297
3298 if (p->rng_fault_state) {
3299 talloc_free(r);
3300 /* Return true here, srv_pipe_hnd.c will take care */
3301 return true;
3302 }
3303
3304 if (DEBUGLEVEL >= 10) {
3305 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3306 }
3307
3308 push = ndr_push_init_ctx(r, NULL);
3309 if (push == NULL) {
3310 talloc_free(r);
3311 return false;
3312 }
3313
3314 ndr_err = call->ndr_push(push, NDR_OUT, r);
3315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3316 talloc_free(r);
3317 return false;
3318 }
3319
3320 blob = ndr_push_blob(push);
3321 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3322 talloc_free(r);
3323 return false;
3324 }
3325
3326 talloc_free(r);
3327
3328 return true;
3329 }
3330
3331 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3332 {
3333 const struct ndr_interface_call *call;
3334 struct ndr_pull *pull;
3335 struct ndr_push *push;
3336 enum ndr_err_code ndr_err;
3337 DATA_BLOB blob;
3338 struct lsa_RetrievePrivateData *r;
3339
3340 call = &ndr_table_lsarpc.calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3341
3342 r = talloc(talloc_tos(), struct lsa_RetrievePrivateData);
3343 if (r == NULL) {
3344 return false;
3345 }
3346
3347 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3348 talloc_free(r);
3349 return false;
3350 }
3351
3352 pull = ndr_pull_init_blob(&blob, r, NULL);
3353 if (pull == NULL) {
3354 talloc_free(r);
3355 return false;
3356 }
3357
3358 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3359 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3360 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3361 talloc_free(r);
3362 return false;
3363 }
3364
3365 if (DEBUGLEVEL >= 10) {
3366 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3367 }
3368
3369 r->out.result = _lsa_RetrievePrivateData(p, r);
3370
3371 if (p->rng_fault_state) {
3372 talloc_free(r);
3373 /* Return true here, srv_pipe_hnd.c will take care */
3374 return true;
3375 }
3376
3377 if (DEBUGLEVEL >= 10) {
3378 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3379 }
3380
3381 push = ndr_push_init_ctx(r, NULL);
3382 if (push == NULL) {
3383 talloc_free(r);
3384 return false;
3385 }
3386
3387 ndr_err = call->ndr_push(push, NDR_OUT, r);
3388 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3389 talloc_free(r);
3390 return false;
3391 }
3392
3393 blob = ndr_push_blob(push);
3394 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3395 talloc_free(r);
3396 return false;
3397 }
3398
3399 talloc_free(r);
3400
3401 return true;
3402 }
3403
3404 static bool api_lsa_OpenPolicy2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3405 {
3406 const struct ndr_interface_call *call;
3407 struct ndr_pull *pull;
3408 struct ndr_push *push;
3409 enum ndr_err_code ndr_err;
3410 DATA_BLOB blob;
3411 struct lsa_OpenPolicy2 *r;
3412
3413 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY2];
3414
3415 r = talloc(talloc_tos(), struct lsa_OpenPolicy2);
3416 if (r == NULL) {
3417 return false;
3418 }
3419
3420 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3421 talloc_free(r);
3422 return false;
3423 }
3424
3425 pull = ndr_pull_init_blob(&blob, r, NULL);
3426 if (pull == NULL) {
3427 talloc_free(r);
3428 return false;
3429 }
3430
3431 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3432 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3433 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3434 talloc_free(r);
3435 return false;
3436 }
3437
3438 if (DEBUGLEVEL >= 10) {
3439 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3440 }
3441
3442 ZERO_STRUCT(r->out);
3443 r->out.handle = talloc_zero(r, struct policy_handle);
3444 if (r->out.handle == NULL) {
3445 talloc_free(r);
3446 return false;
3447 }
3448
3449 r->out.result = _lsa_OpenPolicy2(p, r);
3450
3451 if (p->rng_fault_state) {
3452 talloc_free(r);
3453 /* Return true here, srv_pipe_hnd.c will take care */
3454 return true;
3455 }
3456
3457 if (DEBUGLEVEL >= 10) {
3458 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3459 }
3460
3461 push = ndr_push_init_ctx(r, NULL);
3462 if (push == NULL) {
3463 talloc_free(r);
3464 return false;
3465 }
3466
3467 ndr_err = call->ndr_push(push, NDR_OUT, r);
3468 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3469 talloc_free(r);
3470 return false;
3471 }
3472
3473 blob = ndr_push_blob(push);
3474 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3475 talloc_free(r);
3476 return false;
3477 }
3478
3479 talloc_free(r);
3480
3481 return true;
3482 }
3483
3484 static bool api_lsa_GetUserName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3485 {
3486 const struct ndr_interface_call *call;
3487 struct ndr_pull *pull;
3488 struct ndr_push *push;
3489 enum ndr_err_code ndr_err;
3490 DATA_BLOB blob;
3491 struct lsa_GetUserName *r;
3492
3493 call = &ndr_table_lsarpc.calls[NDR_LSA_GETUSERNAME];
3494
3495 r = talloc(talloc_tos(), struct lsa_GetUserName);
3496 if (r == NULL) {
3497 return false;
3498 }
3499
3500 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3501 talloc_free(r);
3502 return false;
3503 }
3504
3505 pull = ndr_pull_init_blob(&blob, r, NULL);
3506 if (pull == NULL) {
3507 talloc_free(r);
3508 return false;
3509 }
3510
3511 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3512 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3514 talloc_free(r);
3515 return false;
3516 }
3517
3518 if (DEBUGLEVEL >= 10) {
3519 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3520 }
3521
3522 ZERO_STRUCT(r->out);
3523 r->out.account_name = r->in.account_name;
3524 r->out.authority_name = r->in.authority_name;
3525 r->out.result = _lsa_GetUserName(p, r);
3526
3527 if (p->rng_fault_state) {
3528 talloc_free(r);
3529 /* Return true here, srv_pipe_hnd.c will take care */
3530 return true;
3531 }
3532
3533 if (DEBUGLEVEL >= 10) {
3534 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3535 }
3536
3537 push = ndr_push_init_ctx(r, NULL);
3538 if (push == NULL) {
3539 talloc_free(r);
3540 return false;
3541 }
3542
3543 ndr_err = call->ndr_push(push, NDR_OUT, r);
3544 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3545 talloc_free(r);
3546 return false;
3547 }
3548
3549 blob = ndr_push_blob(push);
3550 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3551 talloc_free(r);
3552 return false;
3553 }
3554
3555 talloc_free(r);
3556
3557 return true;
3558 }
3559
3560 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3561 {
3562 const struct ndr_interface_call *call;
3563 struct ndr_pull *pull;
3564 struct ndr_push *push;
3565 enum ndr_err_code ndr_err;
3566 DATA_BLOB blob;
3567 struct lsa_QueryInfoPolicy2 *r;
3568
3569 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY2];
3570
3571 r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy2);
3572 if (r == NULL) {
3573 return false;
3574 }
3575
3576 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3577 talloc_free(r);
3578 return false;
3579 }
3580
3581 pull = ndr_pull_init_blob(&blob, r, NULL);
3582 if (pull == NULL) {
3583 talloc_free(r);
3584 return false;
3585 }
3586
3587 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3588 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3589 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3590 talloc_free(r);
3591 return false;
3592 }
3593
3594 if (DEBUGLEVEL >= 10) {
3595 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3596 }
3597
3598 ZERO_STRUCT(r->out);
3599 r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
3600 if (r->out.info == NULL) {
3601 talloc_free(r);
3602 return false;
3603 }
3604
3605 r->out.result = _lsa_QueryInfoPolicy2(p, r);
3606
3607 if (p->rng_fault_state) {
3608 talloc_free(r);
3609 /* Return true here, srv_pipe_hnd.c will take care */
3610 return true;
3611 }
3612
3613 if (DEBUGLEVEL >= 10) {
3614 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3615 }
3616
3617 push = ndr_push_init_ctx(r, NULL);
3618 if (push == NULL) {
3619 talloc_free(r);
3620 return false;
3621 }
3622
3623 ndr_err = call->ndr_push(push, NDR_OUT, r);
3624 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3625 talloc_free(r);
3626 return false;
3627 }
3628
3629 blob = ndr_push_blob(push);
3630 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3631 talloc_free(r);
3632 return false;
3633 }
3634
3635 talloc_free(r);
3636
3637 return true;
3638 }
3639
3640 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3641 {
3642 const struct ndr_interface_call *call;
3643 struct ndr_pull *pull;
3644 struct ndr_push *push;
3645 enum ndr_err_code ndr_err;
3646 DATA_BLOB blob;
3647 struct lsa_SetInfoPolicy2 *r;
3648
3649 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY2];
3650
3651 r = talloc(talloc_tos(), struct lsa_SetInfoPolicy2);
3652 if (r == NULL) {
3653 return false;
3654 }
3655
3656 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3657 talloc_free(r);
3658 return false;
3659 }
3660
3661 pull = ndr_pull_init_blob(&blob, r, NULL);
3662 if (pull == NULL) {
3663 talloc_free(r);
3664 return false;
3665 }
3666
3667 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3668 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3669 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3670 talloc_free(r);
3671 return false;
3672 }
3673
3674 if (DEBUGLEVEL >= 10) {
3675 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3676 }
3677
3678 r->out.result = _lsa_SetInfoPolicy2(p, r);
3679
3680 if (p->rng_fault_state) {
3681 talloc_free(r);
3682 /* Return true here, srv_pipe_hnd.c will take care */
3683 return true;
3684 }
3685
3686 if (DEBUGLEVEL >= 10) {
3687 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3688 }
3689
3690 push = ndr_push_init_ctx(r, NULL);
3691 if (push == NULL) {
3692 talloc_free(r);
3693 return false;
3694 }
3695
3696 ndr_err = call->ndr_push(push, NDR_OUT, r);
3697 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3698 talloc_free(r);
3699 return false;
3700 }
3701
3702 blob = ndr_push_blob(push);
3703 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3704 talloc_free(r);
3705 return false;
3706 }
3707
3708 talloc_free(r);
3709
3710 return true;
3711 }
3712
3713 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3714 {
3715 const struct ndr_interface_call *call;
3716 struct ndr_pull *pull;
3717 struct ndr_push *push;
3718 enum ndr_err_code ndr_err;
3719 DATA_BLOB blob;
3720 struct lsa_QueryTrustedDomainInfoByName *r;
3721
3722 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3723
3724 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoByName);
3725 if (r == NULL) {
3726 return false;
3727 }
3728
3729 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3730 talloc_free(r);
3731 return false;
3732 }
3733
3734 pull = ndr_pull_init_blob(&blob, r, NULL);
3735 if (pull == NULL) {
3736 talloc_free(r);
3737 return false;
3738 }
3739
3740 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3741 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3742 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3743 talloc_free(r);
3744 return false;
3745 }
3746
3747 if (DEBUGLEVEL >= 10) {
3748 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3749 }
3750
3751 ZERO_STRUCT(r->out);
3752 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3753 if (r->out.info == NULL) {
3754 talloc_free(r);
3755 return false;
3756 }
3757
3758 r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3759
3760 if (p->rng_fault_state) {
3761 talloc_free(r);
3762 /* Return true here, srv_pipe_hnd.c will take care */
3763 return true;
3764 }
3765
3766 if (DEBUGLEVEL >= 10) {
3767 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3768 }
3769
3770 push = ndr_push_init_ctx(r, NULL);
3771 if (push == NULL) {
3772 talloc_free(r);
3773 return false;
3774 }
3775
3776 ndr_err = call->ndr_push(push, NDR_OUT, r);
3777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3778 talloc_free(r);
3779 return false;
3780 }
3781
3782 blob = ndr_push_blob(push);
3783 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3784 talloc_free(r);
3785 return false;
3786 }
3787
3788 talloc_free(r);
3789
3790 return true;
3791 }
3792
3793 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3794 {
3795 const struct ndr_interface_call *call;
3796 struct ndr_pull *pull;
3797 struct ndr_push *push;
3798 enum ndr_err_code ndr_err;
3799 DATA_BLOB blob;
3800 struct lsa_SetTrustedDomainInfoByName *r;
3801
3802 call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3803
3804 r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfoByName);
3805 if (r == NULL) {
3806 return false;
3807 }
3808
3809 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3810 talloc_free(r);
3811 return false;
3812 }
3813
3814 pull = ndr_pull_init_blob(&blob, r, NULL);
3815 if (pull == NULL) {
3816 talloc_free(r);
3817 return false;
3818 }
3819
3820 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3821 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3823 talloc_free(r);
3824 return false;
3825 }
3826
3827 if (DEBUGLEVEL >= 10) {
3828 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3829 }
3830
3831 r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3832
3833 if (p->rng_fault_state) {
3834 talloc_free(r);
3835 /* Return true here, srv_pipe_hnd.c will take care */
3836 return true;
3837 }
3838
3839 if (DEBUGLEVEL >= 10) {
3840 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3841 }
3842
3843 push = ndr_push_init_ctx(r, NULL);
3844 if (push == NULL) {
3845 talloc_free(r);
3846 return false;
3847 }
3848
3849 ndr_err = call->ndr_push(push, NDR_OUT, r);
3850 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3851 talloc_free(r);
3852 return false;
3853 }
3854
3855 blob = ndr_push_blob(push);
3856 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3857 talloc_free(r);
3858 return false;
3859 }
3860
3861 talloc_free(r);
3862
3863 return true;
3864 }
3865
3866 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3867 {
3868 const struct ndr_interface_call *call;
3869 struct ndr_pull *pull;
3870 struct ndr_push *push;
3871 enum ndr_err_code ndr_err;
3872 DATA_BLOB blob;
3873 struct lsa_EnumTrustedDomainsEx *r;
3874
3875 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3876
3877 r = talloc(talloc_tos(), struct lsa_EnumTrustedDomainsEx);
3878 if (r == NULL) {
3879 return false;
3880 }
3881
3882 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3883 talloc_free(r);
3884 return false;
3885 }
3886
3887 pull = ndr_pull_init_blob(&blob, r, NULL);
3888 if (pull == NULL) {
3889 talloc_free(r);
3890 return false;
3891 }
3892
3893 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3894 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3895 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3896 talloc_free(r);
3897 return false;
3898 }
3899
3900 if (DEBUGLEVEL >= 10) {
3901 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3902 }
3903
3904 ZERO_STRUCT(r->out);
3905 r->out.resume_handle = r->in.resume_handle;
3906 r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3907 if (r->out.domains == NULL) {
3908 talloc_free(r);
3909 return false;
3910 }
3911
3912 r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3913
3914 if (p->rng_fault_state) {
3915 talloc_free(r);
3916 /* Return true here, srv_pipe_hnd.c will take care */
3917 return true;
3918 }
3919
3920 if (DEBUGLEVEL >= 10) {
3921 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3922 }
3923
3924 push = ndr_push_init_ctx(r, NULL);
3925 if (push == NULL) {
3926 talloc_free(r);
3927 return false;
3928 }
3929
3930 ndr_err = call->ndr_push(push, NDR_OUT, r);
3931 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3932 talloc_free(r);
3933 return false;
3934 }
3935
3936 blob = ndr_push_blob(push);
3937 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3938 talloc_free(r);
3939 return false;
3940 }
3941
3942 talloc_free(r);
3943
3944 return true;
3945 }
3946
3947 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
3948 {
3949 const struct ndr_interface_call *call;
3950 struct ndr_pull *pull;
3951 struct ndr_push *push;
3952 enum ndr_err_code ndr_err;
3953 DATA_BLOB blob;
3954 struct lsa_CreateTrustedDomainEx *r;
3955
3956 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3957
3958 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx);
3959 if (r == NULL) {
3960 return false;
3961 }
3962
3963 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3964 talloc_free(r);
3965 return false;
3966 }
3967
3968 pull = ndr_pull_init_blob(&blob, r, NULL);
3969 if (pull == NULL) {
3970 talloc_free(r);
3971 return false;
3972 }
3973
3974 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3975 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3976 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3977 talloc_free(r);
3978 return false;
3979 }
3980
3981 if (DEBUGLEVEL >= 10) {
3982 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3983 }
3984
3985 ZERO_STRUCT(r->out);
3986 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
3987 if (r->out.trustdom_handle == NULL) {
3988 talloc_free(r);
3989 return false;
3990 }
3991
3992 r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3993
3994 if (p->rng_fault_state) {
3995 talloc_free(r);
3996 /* Return true here, srv_pipe_hnd.c will take care */
3997 return true;
3998 }
3999
4000 if (DEBUGLEVEL >= 10) {
4001 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
4002 }
4003
4004 push = ndr_push_init_ctx(r, NULL);
4005 if (push == NULL) {
4006 talloc_free(r);
4007 return false;
4008 }
4009
4010 ndr_err = call->ndr_push(push, NDR_OUT, r);
4011 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4012 talloc_free(r);
4013 return false;
4014 }
4015
4016 blob = ndr_push_blob(push);
4017 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4018 talloc_free(r);
4019 return false;
4020 }
4021
4022 talloc_free(r);
4023
4024 return true;
4025 }
4026
4027 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4028 {
4029 const struct ndr_interface_call *call;
4030 struct ndr_pull *pull;
4031 struct ndr_push *push;
4032 enum ndr_err_code ndr_err;
4033 DATA_BLOB blob;
4034 struct lsa_CloseTrustedDomainEx *r;
4035
4036 call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
4037
4038 r = talloc(talloc_tos(), struct lsa_CloseTrustedDomainEx);
4039 if (r == NULL) {
4040 return false;
4041 }
4042
4043 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4044 talloc_free(r);
4045 return false;
4046 }
4047
4048 pull = ndr_pull_init_blob(&blob, r, NULL);
4049 if (pull == NULL) {
4050 talloc_free(r);
4051 return false;
4052 }
4053
4054 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4055 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4056 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4057 talloc_free(r);
4058 return false;
4059 }
4060
4061 if (DEBUGLEVEL >= 10) {
4062 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
4063 }
4064
4065 ZERO_STRUCT(r->out);
4066 r->out.handle = r->in.handle;
4067 r->out.result = _lsa_CloseTrustedDomainEx(p, r);
4068
4069 if (p->rng_fault_state) {
4070 talloc_free(r);
4071 /* Return true here, srv_pipe_hnd.c will take care */
4072 return true;
4073 }
4074
4075 if (DEBUGLEVEL >= 10) {
4076 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
4077 }
4078
4079 push = ndr_push_init_ctx(r, NULL);
4080 if (push == NULL) {
4081 talloc_free(r);
4082 return false;
4083 }
4084
4085 ndr_err = call->ndr_push(push, NDR_OUT, r);
4086 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4087 talloc_free(r);
4088 return false;
4089 }
4090
4091 blob = ndr_push_blob(push);
4092 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4093 talloc_free(r);
4094 return false;
4095 }
4096
4097 talloc_free(r);
4098
4099 return true;
4100 }
4101
4102 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4103 {
4104 const struct ndr_interface_call *call;
4105 struct ndr_pull *pull;
4106 struct ndr_push *push;
4107 enum ndr_err_code ndr_err;
4108 DATA_BLOB blob;
4109 struct lsa_QueryDomainInformationPolicy *r;
4110
4111 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
4112
4113 r = talloc(talloc_tos(), struct lsa_QueryDomainInformationPolicy);
4114 if (r == NULL) {
4115 return false;
4116 }
4117
4118 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4119 talloc_free(r);
4120 return false;
4121 }
4122
4123 pull = ndr_pull_init_blob(&blob, r, NULL);
4124 if (pull == NULL) {
4125 talloc_free(r);
4126 return false;
4127 }
4128
4129 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4130 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4131 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4132 talloc_free(r);
4133 return false;
4134 }
4135
4136 if (DEBUGLEVEL >= 10) {
4137 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4138 }
4139
4140 ZERO_STRUCT(r->out);
4141 r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy *);
4142 if (r->out.info == NULL) {
4143 talloc_free(r);
4144 return false;
4145 }
4146
4147 r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4148
4149 if (p->rng_fault_state) {
4150 talloc_free(r);
4151 /* Return true here, srv_pipe_hnd.c will take care */
4152 return true;
4153 }
4154
4155 if (DEBUGLEVEL >= 10) {
4156 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4157 }
4158
4159 push = ndr_push_init_ctx(r, NULL);
4160 if (push == NULL) {
4161 talloc_free(r);
4162 return false;
4163 }
4164
4165 ndr_err = call->ndr_push(push, NDR_OUT, r);
4166 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4167 talloc_free(r);
4168 return false;
4169 }
4170
4171 blob = ndr_push_blob(push);
4172 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4173 talloc_free(r);
4174 return false;
4175 }
4176
4177 talloc_free(r);
4178
4179 return true;
4180 }
4181
4182 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4183 {
4184 const struct ndr_interface_call *call;
4185 struct ndr_pull *pull;
4186 struct ndr_push *push;
4187 enum ndr_err_code ndr_err;
4188 DATA_BLOB blob;
4189 struct lsa_SetDomainInformationPolicy *r;
4190
4191 call = &ndr_table_lsarpc.calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4192
4193 r = talloc(talloc_tos(), struct lsa_SetDomainInformationPolicy);
4194 if (r == NULL) {
4195 return false;
4196 }
4197
4198 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4199 talloc_free(r);
4200 return false;
4201 }
4202
4203 pull = ndr_pull_init_blob(&blob, r, NULL);
4204 if (pull == NULL) {
4205 talloc_free(r);
4206 return false;
4207 }
4208
4209 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4210 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4211 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4212 talloc_free(r);
4213 return false;
4214 }
4215
4216 if (DEBUGLEVEL >= 10) {
4217 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4218 }
4219
4220 r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4221
4222 if (p->rng_fault_state) {
4223 talloc_free(r);
4224 /* Return true here, srv_pipe_hnd.c will take care */
4225 return true;
4226 }
4227
4228 if (DEBUGLEVEL >= 10) {
4229 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4230 }
4231
4232 push = ndr_push_init_ctx(r, NULL);
4233 if (push == NULL) {
4234 talloc_free(r);
4235 return false;
4236 }
4237
4238 ndr_err = call->ndr_push(push, NDR_OUT, r);
4239 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4240 talloc_free(r);
4241 return false;
4242 }
4243
4244 blob = ndr_push_blob(push);
4245 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4246 talloc_free(r);
4247 return false;
4248 }
4249
4250 talloc_free(r);
4251
4252 return true;
4253 }
4254
4255 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4256 {
4257 const struct ndr_interface_call *call;
4258 struct ndr_pull *pull;
4259 struct ndr_push *push;
4260 enum ndr_err_code ndr_err;
4261 DATA_BLOB blob;
4262 struct lsa_OpenTrustedDomainByName *r;
4263
4264 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4265
4266 r = talloc(talloc_tos(), struct lsa_OpenTrustedDomainByName);
4267 if (r == NULL) {
4268 return false;
4269 }
4270
4271 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4272 talloc_free(r);
4273 return false;
4274 }
4275
4276 pull = ndr_pull_init_blob(&blob, r, NULL);
4277 if (pull == NULL) {
4278 talloc_free(r);
4279 return false;
4280 }
4281
4282 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4283 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4284 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4285 talloc_free(r);
4286 return false;
4287 }
4288
4289 if (DEBUGLEVEL >= 10) {
4290 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4291 }
4292
4293 ZERO_STRUCT(r->out);
4294 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4295 if (r->out.trustdom_handle == NULL) {
4296 talloc_free(r);
4297 return false;
4298 }
4299
4300 r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4301
4302 if (p->rng_fault_state) {
4303 talloc_free(r);
4304 /* Return true here, srv_pipe_hnd.c will take care */
4305 return true;
4306 }
4307
4308 if (DEBUGLEVEL >= 10) {
4309 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4310 }
4311
4312 push = ndr_push_init_ctx(r, NULL);
4313 if (push == NULL) {
4314 talloc_free(r);
4315 return false;
4316 }
4317
4318 ndr_err = call->ndr_push(push, NDR_OUT, r);
4319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4320 talloc_free(r);
4321 return false;
4322 }
4323
4324 blob = ndr_push_blob(push);
4325 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4326 talloc_free(r);
4327 return false;
4328 }
4329
4330 talloc_free(r);
4331
4332 return true;
4333 }
4334
4335 static bool api_lsa_TestCall(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4336 {
4337 const struct ndr_interface_call *call;
4338 struct ndr_pull *pull;
4339 struct ndr_push *push;
4340 enum ndr_err_code ndr_err;
4341 DATA_BLOB blob;
4342 struct lsa_TestCall *r;
4343
4344 call = &ndr_table_lsarpc.calls[NDR_LSA_TESTCALL];
4345
4346 r = talloc(talloc_tos(), struct lsa_TestCall);
4347 if (r == NULL) {
4348 return false;
4349 }
4350
4351 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4352 talloc_free(r);
4353 return false;
4354 }
4355
4356 pull = ndr_pull_init_blob(&blob, r, NULL);
4357 if (pull == NULL) {
4358 talloc_free(r);
4359 return false;
4360 }
4361
4362 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4363 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4365 talloc_free(r);
4366 return false;
4367 }
4368
4369 if (DEBUGLEVEL >= 10) {
4370 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4371 }
4372
4373 r->out.result = _lsa_TestCall(p, r);
4374
4375 if (p->rng_fault_state) {
4376 talloc_free(r);
4377 /* Return true here, srv_pipe_hnd.c will take care */
4378 return true;
4379 }
4380
4381 if (DEBUGLEVEL >= 10) {
4382 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4383 }
4384
4385 push = ndr_push_init_ctx(r, NULL);
4386 if (push == NULL) {
4387 talloc_free(r);
4388 return false;
4389 }
4390
4391 ndr_err = call->ndr_push(push, NDR_OUT, r);
4392 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4393 talloc_free(r);
4394 return false;
4395 }
4396
4397 blob = ndr_push_blob(push);
4398 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4399 talloc_free(r);
4400 return false;
4401 }
4402
4403 talloc_free(r);
4404
4405 return true;
4406 }
4407
4408 static bool api_lsa_LookupSids2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4409 {
4410 const struct ndr_interface_call *call;
4411 struct ndr_pull *pull;
4412 struct ndr_push *push;
4413 enum ndr_err_code ndr_err;
4414 DATA_BLOB blob;
4415 struct lsa_LookupSids2 *r;
4416
4417 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS2];
4418
4419 r = talloc(talloc_tos(), struct lsa_LookupSids2);
4420 if (r == NULL) {
4421 return false;
4422 }
4423
4424 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4425 talloc_free(r);
4426 return false;
4427 }
4428
4429 pull = ndr_pull_init_blob(&blob, r, NULL);
4430 if (pull == NULL) {
4431 talloc_free(r);
4432 return false;
4433 }
4434
4435 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4436 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4437 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4438 talloc_free(r);
4439 return false;
4440 }
4441
4442 if (DEBUGLEVEL >= 10) {
4443 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4444 }
4445
4446 ZERO_STRUCT(r->out);
4447 r->out.names = r->in.names;
4448 r->out.count = r->in.count;
4449 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4450 if (r->out.domains == NULL) {
4451 talloc_free(r);
4452 return false;
4453 }
4454
4455 r->out.result = _lsa_LookupSids2(p, r);
4456
4457 if (p->rng_fault_state) {
4458 talloc_free(r);
4459 /* Return true here, srv_pipe_hnd.c will take care */
4460 return true;
4461 }
4462
4463 if (DEBUGLEVEL >= 10) {
4464 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4465 }
4466
4467 push = ndr_push_init_ctx(r, NULL);
4468 if (push == NULL) {
4469 talloc_free(r);
4470 return false;
4471 }
4472
4473 ndr_err = call->ndr_push(push, NDR_OUT, r);
4474 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4475 talloc_free(r);
4476 return false;
4477 }
4478
4479 blob = ndr_push_blob(push);
4480 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4481 talloc_free(r);
4482 return false;
4483 }
4484
4485 talloc_free(r);
4486
4487 return true;
4488 }
4489
4490 static bool api_lsa_LookupNames2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4491 {
4492 const struct ndr_interface_call *call;
4493 struct ndr_pull *pull;
4494 struct ndr_push *push;
4495 enum ndr_err_code ndr_err;
4496 DATA_BLOB blob;
4497 struct lsa_LookupNames2 *r;
4498
4499 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES2];
4500
4501 r = talloc(talloc_tos(), struct lsa_LookupNames2);
4502 if (r == NULL) {
4503 return false;
4504 }
4505
4506 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4507 talloc_free(r);
4508 return false;
4509 }
4510
4511 pull = ndr_pull_init_blob(&blob, r, NULL);
4512 if (pull == NULL) {
4513 talloc_free(r);
4514 return false;
4515 }
4516
4517 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4518 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4519 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4520 talloc_free(r);
4521 return false;
4522 }
4523
4524 if (DEBUGLEVEL >= 10) {
4525 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4526 }
4527
4528 ZERO_STRUCT(r->out);
4529 r->out.sids = r->in.sids;
4530 r->out.count = r->in.count;
4531 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4532 if (r->out.domains == NULL) {
4533 talloc_free(r);
4534 return false;
4535 }
4536
4537 r->out.result = _lsa_LookupNames2(p, r);
4538
4539 if (p->rng_fault_state) {
4540 talloc_free(r);
4541 /* Return true here, srv_pipe_hnd.c will take care */
4542 return true;
4543 }
4544
4545 if (DEBUGLEVEL >= 10) {
4546 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4547 }
4548
4549 push = ndr_push_init_ctx(r, NULL);
4550 if (push == NULL) {
4551 talloc_free(r);
4552 return false;
4553 }
4554
4555 ndr_err = call->ndr_push(push, NDR_OUT, r);
4556 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4557 talloc_free(r);
4558 return false;
4559 }
4560
4561 blob = ndr_push_blob(push);
4562 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4563 talloc_free(r);
4564 return false;
4565 }
4566
4567 talloc_free(r);
4568
4569 return true;
4570 }
4571
4572 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4573 {
4574 const struct ndr_interface_call *call;
4575 struct ndr_pull *pull;
4576 struct ndr_push *push;
4577 enum ndr_err_code ndr_err;
4578 DATA_BLOB blob;
4579 struct lsa_CreateTrustedDomainEx2 *r;
4580
4581 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4582
4583 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx2);
4584 if (r == NULL) {
4585 return false;
4586 }
4587
4588 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4589 talloc_free(r);
4590 return false;
4591 }
4592
4593 pull = ndr_pull_init_blob(&blob, r, NULL);
4594 if (pull == NULL) {
4595 talloc_free(r);
4596 return false;
4597 }
4598
4599 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4600 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4601 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4602 talloc_free(r);
4603 return false;
4604 }
4605
4606 if (DEBUGLEVEL >= 10) {
4607 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4608 }
4609
4610 ZERO_STRUCT(r->out);
4611 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4612 if (r->out.trustdom_handle == NULL) {
4613 talloc_free(r);
4614 return false;
4615 }
4616
4617 r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4618
4619 if (p->rng_fault_state) {
4620 talloc_free(r);
4621 /* Return true here, srv_pipe_hnd.c will take care */
4622 return true;
4623 }
4624
4625 if (DEBUGLEVEL >= 10) {
4626 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4627 }
4628
4629 push = ndr_push_init_ctx(r, NULL);
4630 if (push == NULL) {
4631 talloc_free(r);
4632 return false;
4633 }
4634
4635 ndr_err = call->ndr_push(push, NDR_OUT, r);
4636 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4637 talloc_free(r);
4638 return false;
4639 }
4640
4641 blob = ndr_push_blob(push);
4642 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4643 talloc_free(r);
4644 return false;
4645 }
4646
4647 talloc_free(r);
4648
4649 return true;
4650 }
4651
4652 static bool api_lsa_CREDRWRITE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4653 {
4654 const struct ndr_interface_call *call;
4655 struct ndr_pull *pull;
4656 struct ndr_push *push;
4657 enum ndr_err_code ndr_err;
4658 DATA_BLOB blob;
4659 struct lsa_CREDRWRITE *r;
4660
4661 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITE];
4662
4663 r = talloc(talloc_tos(), struct lsa_CREDRWRITE);
4664 if (r == NULL) {
4665 return false;
4666 }
4667
4668 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4669 talloc_free(r);
4670 return false;
4671 }
4672
4673 pull = ndr_pull_init_blob(&blob, r, NULL);
4674 if (pull == NULL) {
4675 talloc_free(r);
4676 return false;
4677 }
4678
4679 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4680 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4681 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4682 talloc_free(r);
4683 return false;
4684 }
4685
4686 if (DEBUGLEVEL >= 10) {
4687 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4688 }
4689
4690 r->out.result = _lsa_CREDRWRITE(p, r);
4691
4692 if (p->rng_fault_state) {
4693 talloc_free(r);
4694 /* Return true here, srv_pipe_hnd.c will take care */
4695 return true;
4696 }
4697
4698 if (DEBUGLEVEL >= 10) {
4699 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4700 }
4701
4702 push = ndr_push_init_ctx(r, NULL);
4703 if (push == NULL) {
4704 talloc_free(r);
4705 return false;
4706 }
4707
4708 ndr_err = call->ndr_push(push, NDR_OUT, r);
4709 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4710 talloc_free(r);
4711 return false;
4712 }
4713
4714 blob = ndr_push_blob(push);
4715 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4716 talloc_free(r);
4717 return false;
4718 }
4719
4720 talloc_free(r);
4721
4722 return true;
4723 }
4724
4725 static bool api_lsa_CREDRREAD(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4726 {
4727 const struct ndr_interface_call *call;
4728 struct ndr_pull *pull;
4729 struct ndr_push *push;
4730 enum ndr_err_code ndr_err;
4731 DATA_BLOB blob;
4732 struct lsa_CREDRREAD *r;
4733
4734 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREAD];
4735
4736 r = talloc(talloc_tos(), struct lsa_CREDRREAD);
4737 if (r == NULL) {
4738 return false;
4739 }
4740
4741 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4742 talloc_free(r);
4743 return false;
4744 }
4745
4746 pull = ndr_pull_init_blob(&blob, r, NULL);
4747 if (pull == NULL) {
4748 talloc_free(r);
4749 return false;
4750 }
4751
4752 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4753 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4754 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4755 talloc_free(r);
4756 return false;
4757 }
4758
4759 if (DEBUGLEVEL >= 10) {
4760 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4761 }
4762
4763 r->out.result = _lsa_CREDRREAD(p, r);
4764
4765 if (p->rng_fault_state) {
4766 talloc_free(r);
4767 /* Return true here, srv_pipe_hnd.c will take care */
4768 return true;
4769 }
4770
4771 if (DEBUGLEVEL >= 10) {
4772 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4773 }
4774
4775 push = ndr_push_init_ctx(r, NULL);
4776 if (push == NULL) {
4777 talloc_free(r);
4778 return false;
4779 }
4780
4781 ndr_err = call->ndr_push(push, NDR_OUT, r);
4782 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4783 talloc_free(r);
4784 return false;
4785 }
4786
4787 blob = ndr_push_blob(push);
4788 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4789 talloc_free(r);
4790 return false;
4791 }
4792
4793 talloc_free(r);
4794
4795 return true;
4796 }
4797
4798 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4799 {
4800 const struct ndr_interface_call *call;
4801 struct ndr_pull *pull;
4802 struct ndr_push *push;
4803 enum ndr_err_code ndr_err;
4804 DATA_BLOB blob;
4805 struct lsa_CREDRENUMERATE *r;
4806
4807 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRENUMERATE];
4808
4809 r = talloc(talloc_tos(), struct lsa_CREDRENUMERATE);
4810 if (r == NULL) {
4811 return false;
4812 }
4813
4814 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4815 talloc_free(r);
4816 return false;
4817 }
4818
4819 pull = ndr_pull_init_blob(&blob, r, NULL);
4820 if (pull == NULL) {
4821 talloc_free(r);
4822 return false;
4823 }
4824
4825 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4826 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4827 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4828 talloc_free(r);
4829 return false;
4830 }
4831
4832 if (DEBUGLEVEL >= 10) {
4833 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4834 }
4835
4836 r->out.result = _lsa_CREDRENUMERATE(p, r);
4837
4838 if (p->rng_fault_state) {
4839 talloc_free(r);
4840 /* Return true here, srv_pipe_hnd.c will take care */
4841 return true;
4842 }
4843
4844 if (DEBUGLEVEL >= 10) {
4845 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4846 }
4847
4848 push = ndr_push_init_ctx(r, NULL);
4849 if (push == NULL) {
4850 talloc_free(r);
4851 return false;
4852 }
4853
4854 ndr_err = call->ndr_push(push, NDR_OUT, r);
4855 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4856 talloc_free(r);
4857 return false;
4858 }
4859
4860 blob = ndr_push_blob(push);
4861 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4862 talloc_free(r);
4863 return false;
4864 }
4865
4866 talloc_free(r);
4867
4868 return true;
4869 }
4870
4871 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4872 {
4873 const struct ndr_interface_call *call;
4874 struct ndr_pull *pull;
4875 struct ndr_push *push;
4876 enum ndr_err_code ndr_err;
4877 DATA_BLOB blob;
4878 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4879
4880 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4881
4882 r = talloc(talloc_tos(), struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4883 if (r == NULL) {
4884 return false;
4885 }
4886
4887 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4888 talloc_free(r);
4889 return false;
4890 }
4891
4892 pull = ndr_pull_init_blob(&blob, r, NULL);
4893 if (pull == NULL) {
4894 talloc_free(r);
4895 return false;
4896 }
4897
4898 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4899 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4900 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4901 talloc_free(r);
4902 return false;
4903 }
4904
4905 if (DEBUGLEVEL >= 10) {
4906 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4907 }
4908
4909 r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4910
4911 if (p->rng_fault_state) {
4912 talloc_free(r);
4913 /* Return true here, srv_pipe_hnd.c will take care */
4914 return true;
4915 }
4916
4917 if (DEBUGLEVEL >= 10) {
4918 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4919 }
4920
4921 push = ndr_push_init_ctx(r, NULL);
4922 if (push == NULL) {
4923 talloc_free(r);
4924 return false;
4925 }
4926
4927 ndr_err = call->ndr_push(push, NDR_OUT, r);
4928 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4929 talloc_free(r);
4930 return false;
4931 }
4932
4933 blob = ndr_push_blob(push);
4934 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4935 talloc_free(r);
4936 return false;
4937 }
4938
4939 talloc_free(r);
4940
4941 return true;
4942 }
4943
4944 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
4945 {
4946 const struct ndr_interface_call *call;
4947 struct ndr_pull *pull;
4948 struct ndr_push *push;
4949 enum ndr_err_code ndr_err;
4950 DATA_BLOB blob;
4951 struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4952
4953 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4954
4955 r = talloc(talloc_tos(), struct lsa_CREDRREADDOMAINCREDENTIALS);
4956 if (r == NULL) {
4957 return false;
4958 }
4959
4960 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4961 talloc_free(r);
4962 return false;
4963 }
4964
4965 pull = ndr_pull_init_blob(&blob, r, NULL);
4966 if (pull == NULL) {
4967 talloc_free(r);
4968 return false;
4969 }
4970
4971 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4972 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4973 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4974 talloc_free(r);
4975 return false;
4976 }
4977
4978 if (DEBUGLEVEL >= 10) {
4979 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4980 }
4981
4982 r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4983
4984 if (p->rng_fault_state) {
4985 talloc_free(r);
4986 /* Return true here, srv_pipe_hnd.c will take care */
4987 return true;
4988 }
4989
4990 if (DEBUGLEVEL >= 10) {
4991 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4992 }
4993
4994 push = ndr_push_init_ctx(r, NULL);
4995 if (push == NULL) {
4996 talloc_free(r);
4997 return false;
4998 }
4999
5000 ndr_err = call->ndr_push(push, NDR_OUT, r);
5001 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5002 talloc_free(r);
5003 return false;
5004 }
5005
5006 blob = ndr_push_blob(push);
5007 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5008 talloc_free(r);
5009 return false;
5010 }
5011
5012 talloc_free(r);
5013
5014 return true;
5015 }
5016
5017 static bool api_lsa_CREDRDELETE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5018 {
5019 const struct ndr_interface_call *call;
5020 struct ndr_pull *pull;
5021 struct ndr_push *push;
5022 enum ndr_err_code ndr_err;
5023 DATA_BLOB blob;
5024 struct lsa_CREDRDELETE *r;
5025
5026 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRDELETE];
5027
5028 r = talloc(talloc_tos(), struct lsa_CREDRDELETE);
5029 if (r == NULL) {
5030 return false;
5031 }
5032
5033 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5034 talloc_free(r);
5035 return false;
5036 }
5037
5038 pull = ndr_pull_init_blob(&blob, r, NULL);
5039 if (pull == NULL) {
5040 talloc_free(r);
5041 return false;
5042 }
5043
5044 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5045 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5046 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5047 talloc_free(r);
5048 return false;
5049 }
5050
5051 if (DEBUGLEVEL >= 10) {
5052 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
5053 }
5054
5055 r->out.result = _lsa_CREDRDELETE(p, r);
5056
5057 if (p->rng_fault_state) {
5058 talloc_free(r);
5059 /* Return true here, srv_pipe_hnd.c will take care */
5060 return true;
5061 }
5062
5063 if (DEBUGLEVEL >= 10) {
5064 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
5065 }
5066
5067 push = ndr_push_init_ctx(r, NULL);
5068 if (push == NULL) {
5069 talloc_free(r);
5070 return false;
5071 }
5072
5073 ndr_err = call->ndr_push(push, NDR_OUT, r);
5074 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5075 talloc_free(r);
5076 return false;
5077 }
5078
5079 blob = ndr_push_blob(push);
5080 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5081 talloc_free(r);
5082 return false;
5083 }
5084
5085 talloc_free(r);
5086
5087 return true;
5088 }
5089
5090 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5091 {
5092 const struct ndr_interface_call *call;
5093 struct ndr_pull *pull;
5094 struct ndr_push *push;
5095 enum ndr_err_code ndr_err;
5096 DATA_BLOB blob;
5097 struct lsa_CREDRGETTARGETINFO *r;
5098
5099 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETTARGETINFO];
5100
5101 r = talloc(talloc_tos(), struct lsa_CREDRGETTARGETINFO);
5102 if (r == NULL) {
5103 return false;
5104 }
5105
5106 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5107 talloc_free(r);
5108 return false;
5109 }
5110
5111 pull = ndr_pull_init_blob(&blob, r, NULL);
5112 if (pull == NULL) {
5113 talloc_free(r);
5114 return false;
5115 }
5116
5117 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5118 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5119 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5120 talloc_free(r);
5121 return false;
5122 }
5123
5124 if (DEBUGLEVEL >= 10) {
5125 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
5126 }
5127
5128 r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
5129
5130 if (p->rng_fault_state) {
5131 talloc_free(r);
5132 /* Return true here, srv_pipe_hnd.c will take care */
5133 return true;
5134 }
5135
5136 if (DEBUGLEVEL >= 10) {
5137 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
5138 }
5139
5140 push = ndr_push_init_ctx(r, NULL);
5141 if (push == NULL) {
5142 talloc_free(r);
5143 return false;
5144 }
5145
5146 ndr_err = call->ndr_push(push, NDR_OUT, r);
5147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5148 talloc_free(r);
5149 return false;
5150 }
5151
5152 blob = ndr_push_blob(push);
5153 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5154 talloc_free(r);
5155 return false;
5156 }
5157
5158 talloc_free(r);
5159
5160 return true;
5161 }
5162
5163 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5164 {
5165 const struct ndr_interface_call *call;
5166 struct ndr_pull *pull;
5167 struct ndr_push *push;
5168 enum ndr_err_code ndr_err;
5169 DATA_BLOB blob;
5170 struct lsa_CREDRPROFILELOADED *r;
5171
5172 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRPROFILELOADED];
5173
5174 r = talloc(talloc_tos(), struct lsa_CREDRPROFILELOADED);
5175 if (r == NULL) {
5176 return false;
5177 }
5178
5179 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5180 talloc_free(r);
5181 return false;
5182 }
5183
5184 pull = ndr_pull_init_blob(&blob, r, NULL);
5185 if (pull == NULL) {
5186 talloc_free(r);
5187 return false;
5188 }
5189
5190 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5191 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5192 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5193 talloc_free(r);
5194 return false;
5195 }
5196
5197 if (DEBUGLEVEL >= 10) {
5198 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5199 }
5200
5201 r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5202
5203 if (p->rng_fault_state) {
5204 talloc_free(r);
5205 /* Return true here, srv_pipe_hnd.c will take care */
5206 return true;
5207 }
5208
5209 if (DEBUGLEVEL >= 10) {
5210 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5211 }
5212
5213 push = ndr_push_init_ctx(r, NULL);
5214 if (push == NULL) {
5215 talloc_free(r);
5216 return false;
5217 }
5218
5219 ndr_err = call->ndr_push(push, NDR_OUT, r);
5220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5221 talloc_free(r);
5222 return false;
5223 }
5224
5225 blob = ndr_push_blob(push);
5226 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5227 talloc_free(r);
5228 return false;
5229 }
5230
5231 talloc_free(r);
5232
5233 return true;
5234 }
5235
5236 static bool api_lsa_LookupNames3(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5237 {
5238 const struct ndr_interface_call *call;
5239 struct ndr_pull *pull;
5240 struct ndr_push *push;
5241 enum ndr_err_code ndr_err;
5242 DATA_BLOB blob;
5243 struct lsa_LookupNames3 *r;
5244
5245 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES3];
5246
5247 r = talloc(talloc_tos(), struct lsa_LookupNames3);
5248 if (r == NULL) {
5249 return false;
5250 }
5251
5252 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5253 talloc_free(r);
5254 return false;
5255 }
5256
5257 pull = ndr_pull_init_blob(&blob, r, NULL);
5258 if (pull == NULL) {
5259 talloc_free(r);
5260 return false;
5261 }
5262
5263 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5264 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5265 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5266 talloc_free(r);
5267 return false;
5268 }
5269
5270 if (DEBUGLEVEL >= 10) {
5271 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5272 }
5273
5274 ZERO_STRUCT(r->out);
5275 r->out.sids = r->in.sids;
5276 r->out.count = r->in.count;
5277 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5278 if (r->out.domains == NULL) {
5279 talloc_free(r);
5280 return false;
5281 }
5282
5283 r->out.result = _lsa_LookupNames3(p, r);
5284
5285 if (p->rng_fault_state) {
5286 talloc_free(r);
5287 /* Return true here, srv_pipe_hnd.c will take care */
5288 return true;
5289 }
5290
5291 if (DEBUGLEVEL >= 10) {
5292 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5293 }
5294
5295 push = ndr_push_init_ctx(r, NULL);
5296 if (push == NULL) {
5297 talloc_free(r);
5298 return false;
5299 }
5300
5301 ndr_err = call->ndr_push(push, NDR_OUT, r);
5302 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5303 talloc_free(r);
5304 return false;
5305 }
5306
5307 blob = ndr_push_blob(push);
5308 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5309 talloc_free(r);
5310 return false;
5311 }
5312
5313 talloc_free(r);
5314
5315 return true;
5316 }
5317
5318 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5319 {
5320 const struct ndr_interface_call *call;
5321 struct ndr_pull *pull;
5322 struct ndr_push *push;
5323 enum ndr_err_code ndr_err;
5324 DATA_BLOB blob;
5325 struct lsa_CREDRGETSESSIONTYPES *r;
5326
5327 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETSESSIONTYPES];
5328
5329 r = talloc(talloc_tos(), struct lsa_CREDRGETSESSIONTYPES);
5330 if (r == NULL) {
5331 return false;
5332 }
5333
5334 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5335 talloc_free(r);
5336 return false;
5337 }
5338
5339 pull = ndr_pull_init_blob(&blob, r, NULL);
5340 if (pull == NULL) {
5341 talloc_free(r);
5342 return false;
5343 }
5344
5345 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5346 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5347 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5348 talloc_free(r);
5349 return false;
5350 }
5351
5352 if (DEBUGLEVEL >= 10) {
5353 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5354 }
5355
5356 r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5357
5358 if (p->rng_fault_state) {
5359 talloc_free(r);
5360 /* Return true here, srv_pipe_hnd.c will take care */
5361 return true;
5362 }
5363
5364 if (DEBUGLEVEL >= 10) {
5365 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5366 }
5367
5368 push = ndr_push_init_ctx(r, NULL);
5369 if (push == NULL) {
5370 talloc_free(r);
5371 return false;
5372 }
5373
5374 ndr_err = call->ndr_push(push, NDR_OUT, r);
5375 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5376 talloc_free(r);
5377 return false;
5378 }
5379
5380 blob = ndr_push_blob(push);
5381 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5382 talloc_free(r);
5383 return false;
5384 }
5385
5386 talloc_free(r);
5387
5388 return true;
5389 }
5390
5391 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5392 {
5393 const struct ndr_interface_call *call;
5394 struct ndr_pull *pull;
5395 struct ndr_push *push;
5396 enum ndr_err_code ndr_err;
5397 DATA_BLOB blob;
5398 struct lsa_LSARREGISTERAUDITEVENT *r;
5399
5400 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5401
5402 r = talloc(talloc_tos(), struct lsa_LSARREGISTERAUDITEVENT);
5403 if (r == NULL) {
5404 return false;
5405 }
5406
5407 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5408 talloc_free(r);
5409 return false;
5410 }
5411
5412 pull = ndr_pull_init_blob(&blob, r, NULL);
5413 if (pull == NULL) {
5414 talloc_free(r);
5415 return false;
5416 }
5417
5418 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5419 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5420 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5421 talloc_free(r);
5422 return false;
5423 }
5424
5425 if (DEBUGLEVEL >= 10) {
5426 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5427 }
5428
5429 r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5430
5431 if (p->rng_fault_state) {
5432 talloc_free(r);
5433 /* Return true here, srv_pipe_hnd.c will take care */
5434 return true;
5435 }
5436
5437 if (DEBUGLEVEL >= 10) {
5438 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5439 }
5440
5441 push = ndr_push_init_ctx(r, NULL);
5442 if (push == NULL) {
5443 talloc_free(r);
5444 return false;
5445 }
5446
5447 ndr_err = call->ndr_push(push, NDR_OUT, r);
5448 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5449 talloc_free(r);
5450 return false;
5451 }
5452
5453 blob = ndr_push_blob(push);
5454 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5455 talloc_free(r);
5456 return false;
5457 }
5458
5459 talloc_free(r);
5460
5461 return true;
5462 }
5463
5464 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5465 {
5466 const struct ndr_interface_call *call;
5467 struct ndr_pull *pull;
5468 struct ndr_push *push;
5469 enum ndr_err_code ndr_err;
5470 DATA_BLOB blob;
5471 struct lsa_LSARGENAUDITEVENT *r;
5472
5473 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARGENAUDITEVENT];
5474
5475 r = talloc(talloc_tos(), struct lsa_LSARGENAUDITEVENT);
5476 if (r == NULL) {
5477 return false;
5478 }
5479
5480 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5481 talloc_free(r);
5482 return false;
5483 }
5484
5485 pull = ndr_pull_init_blob(&blob, r, NULL);
5486 if (pull == NULL) {
5487 talloc_free(r);
5488 return false;
5489 }
5490
5491 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5492 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5493 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5494 talloc_free(r);
5495 return false;
5496 }
5497
5498 if (DEBUGLEVEL >= 10) {
5499 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5500 }
5501
5502 r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5503
5504 if (p->rng_fault_state) {
5505 talloc_free(r);
5506 /* Return true here, srv_pipe_hnd.c will take care */
5507 return true;
5508 }
5509
5510 if (DEBUGLEVEL >= 10) {
5511 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5512 }
5513
5514 push = ndr_push_init_ctx(r, NULL);
5515 if (push == NULL) {
5516 talloc_free(r);
5517 return false;
5518 }
5519
5520 ndr_err = call->ndr_push(push, NDR_OUT, r);
5521 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5522 talloc_free(r);
5523 return false;
5524 }
5525
5526 blob = ndr_push_blob(push);
5527 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5528 talloc_free(r);
5529 return false;
5530 }
5531
5532 talloc_free(r);
5533
5534 return true;
5535 }
5536
5537 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5538 {
5539 const struct ndr_interface_call *call;
5540 struct ndr_pull *pull;
5541 struct ndr_push *push;
5542 enum ndr_err_code ndr_err;
5543 DATA_BLOB blob;
5544 struct lsa_LSARUNREGISTERAUDITEVENT *r;
5545
5546 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5547
5548 r = talloc(talloc_tos(), struct lsa_LSARUNREGISTERAUDITEVENT);
5549 if (r == NULL) {
5550 return false;
5551 }
5552
5553 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5554 talloc_free(r);
5555 return false;
5556 }
5557
5558 pull = ndr_pull_init_blob(&blob, r, NULL);
5559 if (pull == NULL) {
5560 talloc_free(r);
5561 return false;
5562 }
5563
5564 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5565 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5566 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5567 talloc_free(r);
5568 return false;
5569 }
5570
5571 if (DEBUGLEVEL >= 10) {
5572 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5573 }
5574
5575 r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5576
5577 if (p->rng_fault_state) {
5578 talloc_free(r);
5579 /* Return true here, srv_pipe_hnd.c will take care */
5580 return true;
5581 }
5582
5583 if (DEBUGLEVEL >= 10) {
5584 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5585 }
5586
5587 push = ndr_push_init_ctx(r, NULL);
5588 if (push == NULL) {
5589 talloc_free(r);
5590 return false;
5591 }
5592
5593 ndr_err = call->ndr_push(push, NDR_OUT, r);
5594 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5595 talloc_free(r);
5596 return false;
5597 }
5598
5599 blob = ndr_push_blob(push);
5600 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5601 talloc_free(r);
5602 return false;
5603 }
5604
5605 talloc_free(r);
5606
5607 return true;
5608 }
5609
5610 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5611 {
5612 const struct ndr_interface_call *call;
5613 struct ndr_pull *pull;
5614 struct ndr_push *push;
5615 enum ndr_err_code ndr_err;
5616 DATA_BLOB blob;
5617 struct lsa_lsaRQueryForestTrustInformation *r;
5618
5619 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5620
5621 r = talloc(talloc_tos(), struct lsa_lsaRQueryForestTrustInformation);
5622 if (r == NULL) {
5623 return false;
5624 }
5625
5626 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5627 talloc_free(r);
5628 return false;
5629 }
5630
5631 pull = ndr_pull_init_blob(&blob, r, NULL);
5632 if (pull == NULL) {
5633 talloc_free(r);
5634 return false;
5635 }
5636
5637 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5638 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5639 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5640 talloc_free(r);
5641 return false;
5642 }
5643
5644 if (DEBUGLEVEL >= 10) {
5645 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5646 }
5647
5648 ZERO_STRUCT(r->out);
5649 r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
5650 if (r->out.forest_trust_info == NULL) {
5651 talloc_free(r);
5652 return false;
5653 }
5654
5655 r->out.result = _lsa_lsaRQueryForestTrustInformation(p, r);
5656
5657 if (p->rng_fault_state) {
5658 talloc_free(r);
5659 /* Return true here, srv_pipe_hnd.c will take care */
5660 return true;
5661 }
5662
5663 if (DEBUGLEVEL >= 10) {
5664 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5665 }
5666
5667 push = ndr_push_init_ctx(r, NULL);
5668 if (push == NULL) {
5669 talloc_free(r);
5670 return false;
5671 }
5672
5673 ndr_err = call->ndr_push(push, NDR_OUT, r);
5674 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5675 talloc_free(r);
5676 return false;
5677 }
5678
5679 blob = ndr_push_blob(push);
5680 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5681 talloc_free(r);
5682 return false;
5683 }
5684
5685 talloc_free(r);
5686
5687 return true;
5688 }
5689
5690 static bool api_lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5691 {
5692 const struct ndr_interface_call *call;
5693 struct ndr_pull *pull;
5694 struct ndr_push *push;
5695 enum ndr_err_code ndr_err;
5696 DATA_BLOB blob;
5697 struct lsa_LSARSETFORESTTRUSTINFORMATION *r;
5698
5699 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5700
5701 r = talloc(talloc_tos(), struct lsa_LSARSETFORESTTRUSTINFORMATION);
5702 if (r == NULL) {
5703 return false;
5704 }
5705
5706 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5707 talloc_free(r);
5708 return false;
5709 }
5710
5711 pull = ndr_pull_init_blob(&blob, r, NULL);
5712 if (pull == NULL) {
5713 talloc_free(r);
5714 return false;
5715 }
5716
5717 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5718 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5719 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5720 talloc_free(r);
5721 return false;
5722 }
5723
5724 if (DEBUGLEVEL >= 10) {
5725 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5726 }
5727
5728 r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, r);
5729
5730 if (p->rng_fault_state) {
5731 talloc_free(r);
5732 /* Return true here, srv_pipe_hnd.c will take care */
5733 return true;
5734 }
5735
5736 if (DEBUGLEVEL >= 10) {
5737 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5738 }
5739
5740 push = ndr_push_init_ctx(r, NULL);
5741 if (push == NULL) {
5742 talloc_free(r);
5743 return false;
5744 }
5745
5746 ndr_err = call->ndr_push(push, NDR_OUT, r);
5747 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5748 talloc_free(r);
5749 return false;
5750 }
5751
5752 blob = ndr_push_blob(push);
5753 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5754 talloc_free(r);
5755 return false;
5756 }
5757
5758 talloc_free(r);
5759
5760 return true;
5761 }
5762
5763 static bool api_lsa_CREDRRENAME(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5764 {
5765 const struct ndr_interface_call *call;
5766 struct ndr_pull *pull;
5767 struct ndr_push *push;
5768 enum ndr_err_code ndr_err;
5769 DATA_BLOB blob;
5770 struct lsa_CREDRRENAME *r;
5771
5772 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRRENAME];
5773
5774 r = talloc(talloc_tos(), struct lsa_CREDRRENAME);
5775 if (r == NULL) {
5776 return false;
5777 }
5778
5779 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5780 talloc_free(r);
5781 return false;
5782 }
5783
5784 pull = ndr_pull_init_blob(&blob, r, NULL);
5785 if (pull == NULL) {
5786 talloc_free(r);
5787 return false;
5788 }
5789
5790 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5791 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5792 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5793 talloc_free(r);
5794 return false;
5795 }
5796
5797 if (DEBUGLEVEL >= 10) {
5798 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5799 }
5800
5801 r->out.result = _lsa_CREDRRENAME(p, r);
5802
5803 if (p->rng_fault_state) {
5804 talloc_free(r);
5805 /* Return true here, srv_pipe_hnd.c will take care */
5806 return true;
5807 }
5808
5809 if (DEBUGLEVEL >= 10) {
5810 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5811 }
5812
5813 push = ndr_push_init_ctx(r, NULL);
5814 if (push == NULL) {
5815 talloc_free(r);
5816 return false;
5817 }
5818
5819 ndr_err = call->ndr_push(push, NDR_OUT, r);
5820 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5821 talloc_free(r);
5822 return false;
5823 }
5824
5825 blob = ndr_push_blob(push);
5826 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5827 talloc_free(r);
5828 return false;
5829 }
5830
5831 talloc_free(r);
5832
5833 return true;
5834 }
5835
5836 static bool api_lsa_LookupSids3(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5837 {
5838 const struct ndr_interface_call *call;
5839 struct ndr_pull *pull;
5840 struct ndr_push *push;
5841 enum ndr_err_code ndr_err;
5842 DATA_BLOB blob;
5843 struct lsa_LookupSids3 *r;
5844
5845 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS3];
5846
5847 r = talloc(talloc_tos(), struct lsa_LookupSids3);
5848 if (r == NULL) {
5849 return false;
5850 }
5851
5852 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5853 talloc_free(r);
5854 return false;
5855 }
5856
5857 pull = ndr_pull_init_blob(&blob, r, NULL);
5858 if (pull == NULL) {
5859 talloc_free(r);
5860 return false;
5861 }
5862
5863 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5864 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5865 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5866 talloc_free(r);
5867 return false;
5868 }
5869
5870 if (DEBUGLEVEL >= 10) {
5871 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5872 }
5873
5874 ZERO_STRUCT(r->out);
5875 r->out.names = r->in.names;
5876 r->out.count = r->in.count;
5877 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5878 if (r->out.domains == NULL) {
5879 talloc_free(r);
5880 return false;
5881 }
5882
5883 r->out.result = _lsa_LookupSids3(p, r);
5884
5885 if (p->rng_fault_state) {
5886 talloc_free(r);
5887 /* Return true here, srv_pipe_hnd.c will take care */
5888 return true;
5889 }
5890
5891 if (DEBUGLEVEL >= 10) {
5892 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5893 }
5894
5895 push = ndr_push_init_ctx(r, NULL);
5896 if (push == NULL) {
5897 talloc_free(r);
5898 return false;
5899 }
5900
5901 ndr_err = call->ndr_push(push, NDR_OUT, r);
5902 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5903 talloc_free(r);
5904 return false;
5905 }
5906
5907 blob = ndr_push_blob(push);
5908 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5909 talloc_free(r);
5910 return false;
5911 }
5912
5913 talloc_free(r);
5914
5915 return true;
5916 }
5917
5918 static bool api_lsa_LookupNames4(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
5919 {
5920 const struct ndr_interface_call *call;
5921 struct ndr_pull *pull;
5922 struct ndr_push *push;
5923 enum ndr_err_code ndr_err;
5924 DATA_BLOB blob;
5925 struct lsa_LookupNames4 *r;
5926
5927 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES4];
5928
5929 r = talloc(talloc_tos(), struct lsa_LookupNames4);
5930 if (r == NULL) {
5931 return false;
5932 }
5933
5934 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5935 talloc_free(r);
5936 return false;
5937 }
5938
5939 pull = ndr_pull_init_blob(&blob, r, NULL);
5940 if (pull == NULL) {
5941 talloc_free(r);
5942 return false;
5943 }
5944
5945 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5946 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5947 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5948 talloc_free(r);
5949 return false;
5950 }
5951
5952 if (DEBUGLEVEL >= 10) {
5953 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5954 }
5955
5956 ZERO_STRUCT(r->out);
5957 r->out.sids = r->in.sids;
5958 r->out.count = r->in.count;
5959 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5960 if (r->out.domains == NULL) {
5961 talloc_free(r);
5962 return false;
5963 }
5964
5965 r->out.result = _lsa_LookupNames4(p, r);
5966
5967 if (p->rng_fault_state) {
5968 talloc_free(r);
5969 /* Return true here, srv_pipe_hnd.c will take care */
5970 return true;
5971 }
5972
5973 if (DEBUGLEVEL >= 10) {
5974 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5975 }
5976
5977 push = ndr_push_init_ctx(r, NULL);
5978 if (push == NULL) {
5979 talloc_free(r);
5980 return false;
5981 }
5982
5983 ndr_err = call->ndr_push(push, NDR_OUT, r);
5984 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5985 talloc_free(r);
5986 return false;
5987 }
5988
5989 blob = ndr_push_blob(push);
5990 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5991 talloc_free(r);
5992 return false;
5993 }
5994
5995 talloc_free(r);
5996
5997 return true;
5998 }
5999
6000 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
6001 {
6002 const struct ndr_interface_call *call;
6003 struct ndr_pull *pull;
6004 struct ndr_push *push;
6005 enum ndr_err_code ndr_err;
6006 DATA_BLOB blob;
6007 struct lsa_LSAROPENPOLICYSCE *r;
6008
6009 call = &ndr_table_lsarpc.calls[NDR_LSA_LSAROPENPOLICYSCE];
6010
6011 r = talloc(talloc_tos(), struct lsa_LSAROPENPOLICYSCE);
6012 if (r == NULL) {
6013 return false;
6014 }
6015
6016 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6017 talloc_free(r);
6018 return false;
6019 }
6020
6021 pull = ndr_pull_init_blob(&blob, r, NULL);
6022 if (pull == NULL) {
6023 talloc_free(r);
6024 return false;
6025 }
6026
6027 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6028 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6029 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6030 talloc_free(r);
6031 return false;
6032 }
6033
6034 if (DEBUGLEVEL >= 10) {
6035 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6036 }
6037
6038 r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
6039
6040 if (p->rng_fault_state) {
6041 talloc_free(r);
6042 /* Return true here, srv_pipe_hnd.c will take care */
6043 return true;
6044 }
6045
6046 if (DEBUGLEVEL >= 10) {
6047 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6048 }
6049
6050 push = ndr_push_init_ctx(r, NULL);
6051 if (push == NULL) {
6052 talloc_free(r);
6053 return false;
6054 }
6055
6056 ndr_err = call->ndr_push(push, NDR_OUT, r);
6057 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6058 talloc_free(r);
6059 return false;
6060 }
6061
6062 blob = ndr_push_blob(push);
6063 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6064 talloc_free(r);
6065 return false;
6066 }
6067
6068 talloc_free(r);
6069
6070 return true;
6071 }
6072
6073 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
6074 {
6075 const struct ndr_interface_call *call;
6076 struct ndr_pull *pull;
6077 struct ndr_push *push;
6078 enum ndr_err_code ndr_err;
6079 DATA_BLOB blob;
6080 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
6081
6082 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
6083
6084 r = talloc(talloc_tos(), struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
6085 if (r == NULL) {
6086 return false;
6087 }
6088
6089 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6090 talloc_free(r);
6091 return false;
6092 }
6093
6094 pull = ndr_pull_init_blob(&blob, r, NULL);
6095 if (pull == NULL) {
6096 talloc_free(r);
6097 return false;
6098 }
6099
6100 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6101 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6102 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6103 talloc_free(r);
6104 return false;
6105 }
6106
6107 if (DEBUGLEVEL >= 10) {
6108 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6109 }
6110
6111 r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
6112
6113 if (p->rng_fault_state) {
6114 talloc_free(r);
6115 /* Return true here, srv_pipe_hnd.c will take care */
6116 return true;
6117 }
6118
6119 if (DEBUGLEVEL >= 10) {
6120 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6121 }
6122
6123 push = ndr_push_init_ctx(r, NULL);
6124 if (push == NULL) {
6125 talloc_free(r);
6126 return false;
6127 }
6128
6129 ndr_err = call->ndr_push(push, NDR_OUT, r);
6130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6131 talloc_free(r);
6132 return false;
6133 }
6134
6135 blob = ndr_push_blob(push);
6136 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6137 talloc_free(r);
6138 return false;
6139 }
6140
6141 talloc_free(r);
6142
6143 return true;
6144 }
6145
6146 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
6147 {
6148 const struct ndr_interface_call *call;
6149 struct ndr_pull *pull;
6150 struct ndr_push *push;
6151 enum ndr_err_code ndr_err;
6152 DATA_BLOB blob;
6153 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
6154
6155 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
6156
6157 r = talloc(talloc_tos(), struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
6158 if (r == NULL) {
6159 return false;
6160 }
6161
6162 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6163 talloc_free(r);
6164 return false;
6165 }
6166
6167 pull = ndr_pull_init_blob(&blob, r, NULL);
6168 if (pull == NULL) {
6169 talloc_free(r);
6170 return false;
6171 }
6172
6173 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6174 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6175 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6176 talloc_free(r);
6177 return false;
6178 }
6179
6180 if (DEBUGLEVEL >= 10) {
6181 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6182 }
6183
6184 r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
6185
6186 if (p->rng_fault_state) {
6187 talloc_free(r);
6188 /* Return true here, srv_pipe_hnd.c will take care */
6189 return true;
6190 }
6191
6192 if (DEBUGLEVEL >= 10) {
6193 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6194 }
6195
6196 push = ndr_push_init_ctx(r, NULL);
6197 if (push == NULL) {
6198 talloc_free(r);
6199 return false;
6200 }
6201
6202 ndr_err = call->ndr_push(push, NDR_OUT, r);
6203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6204 talloc_free(r);
6205 return false;
6206 }
6207
6208 blob = ndr_push_blob(push);
6209 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6210 talloc_free(r);
6211 return false;
6212 }
6213
6214 talloc_free(r);
6215
6216 return true;
6217 }
6218
6219 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
/* [<][>][^][v][top][bottom][index][help] */
6220 {
6221 const struct ndr_interface_call *call;
6222 struct ndr_pull *pull;
6223 struct ndr_push *push;
6224 enum ndr_err_code ndr_err;
6225 DATA_BLOB blob;
6226 struct lsa_LSARADTREPORTSECURITYEVENT *r;
6227
6228 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6229
6230 r = talloc(talloc_tos(), struct lsa_LSARADTREPORTSECURITYEVENT);
6231 if (r == NULL) {
6232 return false;
6233 }
6234
6235 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6236 talloc_free(r);
6237 return false;
6238 }
6239
6240 pull = ndr_pull_init_blob(&blob, r, NULL);
6241 if (pull == NULL) {
6242 talloc_free(r);
6243 return false;
6244 }
6245
6246 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6247 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6249 talloc_free(r);
6250 return false;
6251 }
6252
6253 if (DEBUGLEVEL >= 10) {
6254 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6255 }
6256
6257 r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6258
6259 if (p->rng_fault_state) {
6260 talloc_free(r);
6261 /* Return true here, srv_pipe_hnd.c will take care */
6262 return true;
6263 }
6264
6265 if (DEBUGLEVEL >= 10) {
6266 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6267 }
6268
6269 push = ndr_push_init_ctx(r, NULL);
6270 if (push == NULL) {
6271 talloc_free(r);
6272 return false;
6273 }
6274
6275 ndr_err = call->ndr_push(push, NDR_OUT, r);
6276 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6277 talloc_free(r);
6278 return false;
6279 }
6280
6281 blob = ndr_push_blob(push);
6282 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6283 talloc_free(r);
6284 return false;
6285 }
6286
6287 talloc_free(r);
6288
6289 return true;
6290 }
6291
6292
6293 /* Tables */
6294 static struct api_struct api_lsarpc_cmds[] =
6295 {
6296 {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6297 {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6298 {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6299 {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6300 {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6301 {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6302 {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6303 {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6304 {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6305 {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6306 {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6307 {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6308 {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6309 {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6310 {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6311 {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6312 {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6313 {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6314 {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6315 {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6316 {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6317 {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6318 {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6319 {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6320 {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6321 {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6322 {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6323 {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6324 {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6325 {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6326 {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6327 {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6328 {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6329 {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6330 {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6331 {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6332 {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6333 {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6334 {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6335 {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6336 {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6337 {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6338 {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6339 {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6340 {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6341 {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6342 {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6343 {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6344 {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6345 {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6346 {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6347 {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6348 {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6349 {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6350 {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6351 {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6352 {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6353 {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6354 {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6355 {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6356 {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6357 {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6358 {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6359 {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6360 {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6361 {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6362 {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6363 {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6364 {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6365 {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6366 {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6367 {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6368 {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6369 {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_lsaRQueryForestTrustInformation},
6370 {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_LSARSETFORESTTRUSTINFORMATION},
6371 {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6372 {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6373 {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6374 {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6375 {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6376 {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6377 {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6378 };
6379
6380 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
/* [<][>][^][v][top][bottom][index][help] */
6381 {
6382 *fns = api_lsarpc_cmds;
6383 *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6384 }
6385
6386 NTSTATUS rpc_lsarpc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
/* [<][>][^][v][top][bottom][index][help] */
6387 {
6388 if (cli->pipes_struct == NULL) {
6389 return NT_STATUS_INVALID_PARAMETER;
6390 }
6391
6392 switch (opnum)
6393 {
6394 case NDR_LSA_CLOSE: {
6395 struct lsa_Close *r = (struct lsa_Close *)_r;
6396 ZERO_STRUCT(r->out);
6397 r->out.handle = r->in.handle;
6398 r->out.result = _lsa_Close(cli->pipes_struct, r);
6399 return NT_STATUS_OK;
6400 }
6401
6402 case NDR_LSA_DELETE: {
6403 struct lsa_Delete *r = (struct lsa_Delete *)_r;
6404 r->out.result = _lsa_Delete(cli->pipes_struct, r);
6405 return NT_STATUS_OK;
6406 }
6407
6408 case NDR_LSA_ENUMPRIVS: {
6409 struct lsa_EnumPrivs *r = (struct lsa_EnumPrivs *)_r;
6410 ZERO_STRUCT(r->out);
6411 r->out.resume_handle = r->in.resume_handle;
6412 r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivArray);
6413 if (r->out.privs == NULL) {
6414 return NT_STATUS_NO_MEMORY;
6415 }
6416
6417 r->out.result = _lsa_EnumPrivs(cli->pipes_struct, r);
6418 return NT_STATUS_OK;
6419 }
6420
6421 case NDR_LSA_QUERYSECURITY: {
6422 struct lsa_QuerySecurity *r = (struct lsa_QuerySecurity *)_r;
6423 ZERO_STRUCT(r->out);
6424 r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
6425 if (r->out.sdbuf == NULL) {
6426 return NT_STATUS_NO_MEMORY;
6427 }
6428
6429 r->out.result = _lsa_QuerySecurity(cli->pipes_struct, r);
6430 return NT_STATUS_OK;
6431 }
6432
6433 case NDR_LSA_SETSECOBJ: {
6434 struct lsa_SetSecObj *r = (struct lsa_SetSecObj *)_r;
6435 r->out.result = _lsa_SetSecObj(cli->pipes_struct, r);
6436 return NT_STATUS_OK;
6437 }
6438
6439 case NDR_LSA_CHANGEPASSWORD: {
6440 struct lsa_ChangePassword *r = (struct lsa_ChangePassword *)_r;
6441 r->out.result = _lsa_ChangePassword(cli->pipes_struct, r);
6442 return NT_STATUS_OK;
6443 }
6444
6445 case NDR_LSA_OPENPOLICY: {
6446 struct lsa_OpenPolicy *r = (struct lsa_OpenPolicy *)_r;
6447 ZERO_STRUCT(r->out);
6448 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6449 if (r->out.handle == NULL) {
6450 return NT_STATUS_NO_MEMORY;
6451 }
6452
6453 r->out.result = _lsa_OpenPolicy(cli->pipes_struct, r);
6454 return NT_STATUS_OK;
6455 }
6456
6457 case NDR_LSA_QUERYINFOPOLICY: {
6458 struct lsa_QueryInfoPolicy *r = (struct lsa_QueryInfoPolicy *)_r;
6459 ZERO_STRUCT(r->out);
6460 r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6461 if (r->out.info == NULL) {
6462 return NT_STATUS_NO_MEMORY;
6463 }
6464
6465 r->out.result = _lsa_QueryInfoPolicy(cli->pipes_struct, r);
6466 return NT_STATUS_OK;
6467 }
6468
6469 case NDR_LSA_SETINFOPOLICY: {
6470 struct lsa_SetInfoPolicy *r = (struct lsa_SetInfoPolicy *)_r;
6471 r->out.result = _lsa_SetInfoPolicy(cli->pipes_struct, r);
6472 return NT_STATUS_OK;
6473 }
6474
6475 case NDR_LSA_CLEARAUDITLOG: {
6476 struct lsa_ClearAuditLog *r = (struct lsa_ClearAuditLog *)_r;
6477 r->out.result = _lsa_ClearAuditLog(cli->pipes_struct, r);
6478 return NT_STATUS_OK;
6479 }
6480
6481 case NDR_LSA_CREATEACCOUNT: {
6482 struct lsa_CreateAccount *r = (struct lsa_CreateAccount *)_r;
6483 ZERO_STRUCT(r->out);
6484 r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6485 if (r->out.acct_handle == NULL) {
6486 return NT_STATUS_NO_MEMORY;
6487 }
6488
6489 r->out.result = _lsa_CreateAccount(cli->pipes_struct, r);
6490 return NT_STATUS_OK;
6491 }
6492
6493 case NDR_LSA_ENUMACCOUNTS: {
6494 struct lsa_EnumAccounts *r = (struct lsa_EnumAccounts *)_r;
6495 ZERO_STRUCT(r->out);
6496 r->out.resume_handle = r->in.resume_handle;
6497 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6498 if (r->out.sids == NULL) {
6499 return NT_STATUS_NO_MEMORY;
6500 }
6501
6502 r->out.result = _lsa_EnumAccounts(cli->pipes_struct, r);
6503 return NT_STATUS_OK;
6504 }
6505
6506 case NDR_LSA_CREATETRUSTEDDOMAIN: {
6507 struct lsa_CreateTrustedDomain *r = (struct lsa_CreateTrustedDomain *)_r;
6508 ZERO_STRUCT(r->out);
6509 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6510 if (r->out.trustdom_handle == NULL) {
6511 return NT_STATUS_NO_MEMORY;
6512 }
6513
6514 r->out.result = _lsa_CreateTrustedDomain(cli->pipes_struct, r);
6515 return NT_STATUS_OK;
6516 }
6517
6518 case NDR_LSA_ENUMTRUSTDOM: {
6519 struct lsa_EnumTrustDom *r = (struct lsa_EnumTrustDom *)_r;
6520 ZERO_STRUCT(r->out);
6521 r->out.resume_handle = r->in.resume_handle;
6522 r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainList);
6523 if (r->out.domains == NULL) {
6524 return NT_STATUS_NO_MEMORY;
6525 }
6526
6527 r->out.result = _lsa_EnumTrustDom(cli->pipes_struct, r);
6528 return NT_STATUS_OK;
6529 }
6530
6531 case NDR_LSA_LOOKUPNAMES: {
6532 struct lsa_LookupNames *r = (struct lsa_LookupNames *)_r;
6533 ZERO_STRUCT(r->out);
6534 r->out.sids = r->in.sids;
6535 r->out.count = r->in.count;
6536 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6537 if (r->out.domains == NULL) {
6538 return NT_STATUS_NO_MEMORY;
6539 }
6540
6541 r->out.result = _lsa_LookupNames(cli->pipes_struct, r);
6542 return NT_STATUS_OK;
6543 }
6544
6545 case NDR_LSA_LOOKUPSIDS: {
6546 struct lsa_LookupSids *r = (struct lsa_LookupSids *)_r;
6547 ZERO_STRUCT(r->out);
6548 r->out.names = r->in.names;
6549 r->out.count = r->in.count;
6550 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6551 if (r->out.domains == NULL) {
6552 return NT_STATUS_NO_MEMORY;
6553 }
6554
6555 r->out.result = _lsa_LookupSids(cli->pipes_struct, r);
6556 return NT_STATUS_OK;
6557 }
6558
6559 case NDR_LSA_CREATESECRET: {
6560 struct lsa_CreateSecret *r = (struct lsa_CreateSecret *)_r;
6561 ZERO_STRUCT(r->out);
6562 r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6563 if (r->out.sec_handle == NULL) {
6564 return NT_STATUS_NO_MEMORY;
6565 }
6566
6567 r->out.result = _lsa_CreateSecret(cli->pipes_struct, r);
6568 return NT_STATUS_OK;
6569 }
6570
6571 case NDR_LSA_OPENACCOUNT: {
6572 struct lsa_OpenAccount *r = (struct lsa_OpenAccount *)_r;
6573 ZERO_STRUCT(r->out);
6574 r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6575 if (r->out.acct_handle == NULL) {
6576 return NT_STATUS_NO_MEMORY;
6577 }
6578
6579 r->out.result = _lsa_OpenAccount(cli->pipes_struct, r);
6580 return NT_STATUS_OK;
6581 }
6582
6583 case NDR_LSA_ENUMPRIVSACCOUNT: {
6584 struct lsa_EnumPrivsAccount *r = (struct lsa_EnumPrivsAccount *)_r;
6585 ZERO_STRUCT(r->out);
6586 r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivilegeSet *);
6587 if (r->out.privs == NULL) {
6588 return NT_STATUS_NO_MEMORY;
6589 }
6590
6591 r->out.result = _lsa_EnumPrivsAccount(cli->pipes_struct, r);
6592 return NT_STATUS_OK;
6593 }
6594
6595 case NDR_LSA_ADDPRIVILEGESTOACCOUNT: {
6596 struct lsa_AddPrivilegesToAccount *r = (struct lsa_AddPrivilegesToAccount *)_r;
6597 r->out.result = _lsa_AddPrivilegesToAccount(cli->pipes_struct, r);
6598 return NT_STATUS_OK;
6599 }
6600
6601 case NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT: {
6602 struct lsa_RemovePrivilegesFromAccount *r = (struct lsa_RemovePrivilegesFromAccount *)_r;
6603 r->out.result = _lsa_RemovePrivilegesFromAccount(cli->pipes_struct, r);
6604 return NT_STATUS_OK;
6605 }
6606
6607 case NDR_LSA_GETQUOTASFORACCOUNT: {
6608 struct lsa_GetQuotasForAccount *r = (struct lsa_GetQuotasForAccount *)_r;
6609 r->out.result = _lsa_GetQuotasForAccount(cli->pipes_struct, r);
6610 return NT_STATUS_OK;
6611 }
6612
6613 case NDR_LSA_SETQUOTASFORACCOUNT: {
6614 struct lsa_SetQuotasForAccount *r = (struct lsa_SetQuotasForAccount *)_r;
6615 r->out.result = _lsa_SetQuotasForAccount(cli->pipes_struct, r);
6616 return NT_STATUS_OK;
6617 }
6618
6619 case NDR_LSA_GETSYSTEMACCESSACCOUNT: {
6620 struct lsa_GetSystemAccessAccount *r = (struct lsa_GetSystemAccessAccount *)_r;
6621 ZERO_STRUCT(r->out);
6622 r->out.access_mask = talloc_zero(mem_ctx, uint32_t);
6623 if (r->out.access_mask == NULL) {
6624 return NT_STATUS_NO_MEMORY;
6625 }
6626
6627 r->out.result = _lsa_GetSystemAccessAccount(cli->pipes_struct, r);
6628 return NT_STATUS_OK;
6629 }
6630
6631 case NDR_LSA_SETSYSTEMACCESSACCOUNT: {
6632 struct lsa_SetSystemAccessAccount *r = (struct lsa_SetSystemAccessAccount *)_r;
6633 r->out.result = _lsa_SetSystemAccessAccount(cli->pipes_struct, r);
6634 return NT_STATUS_OK;
6635 }
6636
6637 case NDR_LSA_OPENTRUSTEDDOMAIN: {
6638 struct lsa_OpenTrustedDomain *r = (struct lsa_OpenTrustedDomain *)_r;
6639 ZERO_STRUCT(r->out);
6640 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6641 if (r->out.trustdom_handle == NULL) {
6642 return NT_STATUS_NO_MEMORY;
6643 }
6644
6645 r->out.result = _lsa_OpenTrustedDomain(cli->pipes_struct, r);
6646 return NT_STATUS_OK;
6647 }
6648
6649 case NDR_LSA_QUERYTRUSTEDDOMAININFO: {
6650 struct lsa_QueryTrustedDomainInfo *r = (struct lsa_QueryTrustedDomainInfo *)_r;
6651 ZERO_STRUCT(r->out);
6652 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6653 if (r->out.info == NULL) {
6654 return NT_STATUS_NO_MEMORY;
6655 }
6656
6657 r->out.result = _lsa_QueryTrustedDomainInfo(cli->pipes_struct, r);
6658 return NT_STATUS_OK;
6659 }
6660
6661 case NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN: {
6662 struct lsa_SetInformationTrustedDomain *r = (struct lsa_SetInformationTrustedDomain *)_r;
6663 r->out.result = _lsa_SetInformationTrustedDomain(cli->pipes_struct, r);
6664 return NT_STATUS_OK;
6665 }
6666
6667 case NDR_LSA_OPENSECRET: {
6668 struct lsa_OpenSecret *r = (struct lsa_OpenSecret *)_r;
6669 ZERO_STRUCT(r->out);
6670 r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6671 if (r->out.sec_handle == NULL) {
6672 return NT_STATUS_NO_MEMORY;
6673 }
6674
6675 r->out.result = _lsa_OpenSecret(cli->pipes_struct, r);
6676 return NT_STATUS_OK;
6677 }
6678
6679 case NDR_LSA_SETSECRET: {
6680 struct lsa_SetSecret *r = (struct lsa_SetSecret *)_r;
6681 r->out.result = _lsa_SetSecret(cli->pipes_struct, r);
6682 return NT_STATUS_OK;
6683 }
6684
6685 case NDR_LSA_QUERYSECRET: {
6686 struct lsa_QuerySecret *r = (struct lsa_QuerySecret *)_r;
6687 ZERO_STRUCT(r->out);
6688 r->out.new_val = r->in.new_val;
6689 r->out.new_mtime = r->in.new_mtime;
6690 r->out.old_val = r->in.old_val;
6691 r->out.old_mtime = r->in.old_mtime;
6692 r->out.result = _lsa_QuerySecret(cli->pipes_struct, r);
6693 return NT_STATUS_OK;
6694 }
6695
6696 case NDR_LSA_LOOKUPPRIVVALUE: {
6697 struct lsa_LookupPrivValue *r = (struct lsa_LookupPrivValue *)_r;
6698 ZERO_STRUCT(r->out);
6699 r->out.luid = talloc_zero(mem_ctx, struct lsa_LUID);
6700 if (r->out.luid == NULL) {
6701 return NT_STATUS_NO_MEMORY;
6702 }
6703
6704 r->out.result = _lsa_LookupPrivValue(cli->pipes_struct, r);
6705 return NT_STATUS_OK;
6706 }
6707
6708 case NDR_LSA_LOOKUPPRIVNAME: {
6709 struct lsa_LookupPrivName *r = (struct lsa_LookupPrivName *)_r;
6710 ZERO_STRUCT(r->out);
6711 r->out.name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6712 if (r->out.name == NULL) {
6713 return NT_STATUS_NO_MEMORY;
6714 }
6715
6716 r->out.result = _lsa_LookupPrivName(cli->pipes_struct, r);
6717 return NT_STATUS_OK;
6718 }
6719
6720 case NDR_LSA_LOOKUPPRIVDISPLAYNAME: {
6721 struct lsa_LookupPrivDisplayName *r = (struct lsa_LookupPrivDisplayName *)_r;
6722 ZERO_STRUCT(r->out);
6723 r->out.disp_name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6724 if (r->out.disp_name == NULL) {
6725 return NT_STATUS_NO_MEMORY;
6726 }
6727
6728 r->out.returned_language_id = talloc_zero(mem_ctx, uint16_t);
6729 if (r->out.returned_language_id == NULL) {
6730 return NT_STATUS_NO_MEMORY;
6731 }
6732
6733 r->out.result = _lsa_LookupPrivDisplayName(cli->pipes_struct, r);
6734 return NT_STATUS_OK;
6735 }
6736
6737 case NDR_LSA_DELETEOBJECT: {
6738 struct lsa_DeleteObject *r = (struct lsa_DeleteObject *)_r;
6739 ZERO_STRUCT(r->out);
6740 r->out.handle = r->in.handle;
6741 r->out.result = _lsa_DeleteObject(cli->pipes_struct, r);
6742 return NT_STATUS_OK;
6743 }
6744
6745 case NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT: {
6746 struct lsa_EnumAccountsWithUserRight *r = (struct lsa_EnumAccountsWithUserRight *)_r;
6747 ZERO_STRUCT(r->out);
6748 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6749 if (r->out.sids == NULL) {
6750 return NT_STATUS_NO_MEMORY;
6751 }
6752
6753 r->out.result = _lsa_EnumAccountsWithUserRight(cli->pipes_struct, r);
6754 return NT_STATUS_OK;
6755 }
6756
6757 case NDR_LSA_ENUMACCOUNTRIGHTS: {
6758 struct lsa_EnumAccountRights *r = (struct lsa_EnumAccountRights *)_r;
6759 ZERO_STRUCT(r->out);
6760 r->out.rights = talloc_zero(mem_ctx, struct lsa_RightSet);
6761 if (r->out.rights == NULL) {
6762 return NT_STATUS_NO_MEMORY;
6763 }
6764
6765 r->out.result = _lsa_EnumAccountRights(cli->pipes_struct, r);
6766 return NT_STATUS_OK;
6767 }
6768
6769 case NDR_LSA_ADDACCOUNTRIGHTS: {
6770 struct lsa_AddAccountRights *r = (struct lsa_AddAccountRights *)_r;
6771 r->out.result = _lsa_AddAccountRights(cli->pipes_struct, r);
6772 return NT_STATUS_OK;
6773 }
6774
6775 case NDR_LSA_REMOVEACCOUNTRIGHTS: {
6776 struct lsa_RemoveAccountRights *r = (struct lsa_RemoveAccountRights *)_r;
6777 r->out.result = _lsa_RemoveAccountRights(cli->pipes_struct, r);
6778 return NT_STATUS_OK;
6779 }
6780
6781 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID: {
6782 struct lsa_QueryTrustedDomainInfoBySid *r = (struct lsa_QueryTrustedDomainInfoBySid *)_r;
6783 ZERO_STRUCT(r->out);
6784 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6785 if (r->out.info == NULL) {
6786 return NT_STATUS_NO_MEMORY;
6787 }
6788
6789 r->out.result = _lsa_QueryTrustedDomainInfoBySid(cli->pipes_struct, r);
6790 return NT_STATUS_OK;
6791 }
6792
6793 case NDR_LSA_SETTRUSTEDDOMAININFO: {
6794 struct lsa_SetTrustedDomainInfo *r = (struct lsa_SetTrustedDomainInfo *)_r;
6795 r->out.result = _lsa_SetTrustedDomainInfo(cli->pipes_struct, r);
6796 return NT_STATUS_OK;
6797 }
6798
6799 case NDR_LSA_DELETETRUSTEDDOMAIN: {
6800 struct lsa_DeleteTrustedDomain *r = (struct lsa_DeleteTrustedDomain *)_r;
6801 r->out.result = _lsa_DeleteTrustedDomain(cli->pipes_struct, r);
6802 return NT_STATUS_OK;
6803 }
6804
6805 case NDR_LSA_STOREPRIVATEDATA: {
6806 struct lsa_StorePrivateData *r = (struct lsa_StorePrivateData *)_r;
6807 r->out.result = _lsa_StorePrivateData(cli->pipes_struct, r);
6808 return NT_STATUS_OK;
6809 }
6810
6811 case NDR_LSA_RETRIEVEPRIVATEDATA: {
6812 struct lsa_RetrievePrivateData *r = (struct lsa_RetrievePrivateData *)_r;
6813 r->out.result = _lsa_RetrievePrivateData(cli->pipes_struct, r);
6814 return NT_STATUS_OK;
6815 }
6816
6817 case NDR_LSA_OPENPOLICY2: {
6818 struct lsa_OpenPolicy2 *r = (struct lsa_OpenPolicy2 *)_r;
6819 ZERO_STRUCT(r->out);
6820 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6821 if (r->out.handle == NULL) {
6822 return NT_STATUS_NO_MEMORY;
6823 }
6824
6825 r->out.result = _lsa_OpenPolicy2(cli->pipes_struct, r);
6826 return NT_STATUS_OK;
6827 }
6828
6829 case NDR_LSA_GETUSERNAME: {
6830 struct lsa_GetUserName *r = (struct lsa_GetUserName *)_r;
6831 ZERO_STRUCT(r->out);
6832 r->out.account_name = r->in.account_name;
6833 r->out.authority_name = r->in.authority_name;
6834 r->out.result = _lsa_GetUserName(cli->pipes_struct, r);
6835 return NT_STATUS_OK;
6836 }
6837
6838 case NDR_LSA_QUERYINFOPOLICY2: {
6839 struct lsa_QueryInfoPolicy2 *r = (struct lsa_QueryInfoPolicy2 *)_r;
6840 ZERO_STRUCT(r->out);
6841 r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6842 if (r->out.info == NULL) {
6843 return NT_STATUS_NO_MEMORY;
6844 }
6845
6846 r->out.result = _lsa_QueryInfoPolicy2(cli->pipes_struct, r);
6847 return NT_STATUS_OK;
6848 }
6849
6850 case NDR_LSA_SETINFOPOLICY2: {
6851 struct lsa_SetInfoPolicy2 *r = (struct lsa_SetInfoPolicy2 *)_r;
6852 r->out.result = _lsa_SetInfoPolicy2(cli->pipes_struct, r);
6853 return NT_STATUS_OK;
6854 }
6855
6856 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME: {
6857 struct lsa_QueryTrustedDomainInfoByName *r = (struct lsa_QueryTrustedDomainInfoByName *)_r;
6858 ZERO_STRUCT(r->out);
6859 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6860 if (r->out.info == NULL) {
6861 return NT_STATUS_NO_MEMORY;
6862 }
6863
6864 r->out.result = _lsa_QueryTrustedDomainInfoByName(cli->pipes_struct, r);
6865 return NT_STATUS_OK;
6866 }
6867
6868 case NDR_LSA_SETTRUSTEDDOMAININFOBYNAME: {
6869 struct lsa_SetTrustedDomainInfoByName *r = (struct lsa_SetTrustedDomainInfoByName *)_r;
6870 r->out.result = _lsa_SetTrustedDomainInfoByName(cli->pipes_struct, r);
6871 return NT_STATUS_OK;
6872 }
6873
6874 case NDR_LSA_ENUMTRUSTEDDOMAINSEX: {
6875 struct lsa_EnumTrustedDomainsEx *r = (struct lsa_EnumTrustedDomainsEx *)_r;
6876 ZERO_STRUCT(r->out);
6877 r->out.resume_handle = r->in.resume_handle;
6878 r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainListEx);
6879 if (r->out.domains == NULL) {
6880 return NT_STATUS_NO_MEMORY;
6881 }
6882
6883 r->out.result = _lsa_EnumTrustedDomainsEx(cli->pipes_struct, r);
6884 return NT_STATUS_OK;
6885 }
6886
6887 case NDR_LSA_CREATETRUSTEDDOMAINEX: {
6888 struct lsa_CreateTrustedDomainEx *r = (struct lsa_CreateTrustedDomainEx *)_r;
6889 ZERO_STRUCT(r->out);
6890 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6891 if (r->out.trustdom_handle == NULL) {
6892 return NT_STATUS_NO_MEMORY;
6893 }
6894
6895 r->out.result = _lsa_CreateTrustedDomainEx(cli->pipes_struct, r);
6896 return NT_STATUS_OK;
6897 }
6898
6899 case NDR_LSA_CLOSETRUSTEDDOMAINEX: {
6900 struct lsa_CloseTrustedDomainEx *r = (struct lsa_CloseTrustedDomainEx *)_r;
6901 ZERO_STRUCT(r->out);
6902 r->out.handle = r->in.handle;
6903 r->out.result = _lsa_CloseTrustedDomainEx(cli->pipes_struct, r);
6904 return NT_STATUS_OK;
6905 }
6906
6907 case NDR_LSA_QUERYDOMAININFORMATIONPOLICY: {
6908 struct lsa_QueryDomainInformationPolicy *r = (struct lsa_QueryDomainInformationPolicy *)_r;
6909 ZERO_STRUCT(r->out);
6910 r->out.info = talloc_zero(mem_ctx, union lsa_DomainInformationPolicy *);
6911 if (r->out.info == NULL) {
6912 return NT_STATUS_NO_MEMORY;
6913 }
6914
6915 r->out.result = _lsa_QueryDomainInformationPolicy(cli->pipes_struct, r);
6916 return NT_STATUS_OK;
6917 }
6918
6919 case NDR_LSA_SETDOMAININFORMATIONPOLICY: {
6920 struct lsa_SetDomainInformationPolicy *r = (struct lsa_SetDomainInformationPolicy *)_r;
6921 r->out.result = _lsa_SetDomainInformationPolicy(cli->pipes_struct, r);
6922 return NT_STATUS_OK;
6923 }
6924
6925 case NDR_LSA_OPENTRUSTEDDOMAINBYNAME: {
6926 struct lsa_OpenTrustedDomainByName *r = (struct lsa_OpenTrustedDomainByName *)_r;
6927 ZERO_STRUCT(r->out);
6928 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6929 if (r->out.trustdom_handle == NULL) {
6930 return NT_STATUS_NO_MEMORY;
6931 }
6932
6933 r->out.result = _lsa_OpenTrustedDomainByName(cli->pipes_struct, r);
6934 return NT_STATUS_OK;
6935 }
6936
6937 case NDR_LSA_TESTCALL: {
6938 struct lsa_TestCall *r = (struct lsa_TestCall *)_r;
6939 r->out.result = _lsa_TestCall(cli->pipes_struct, r);
6940 return NT_STATUS_OK;
6941 }
6942
6943 case NDR_LSA_LOOKUPSIDS2: {
6944 struct lsa_LookupSids2 *r = (struct lsa_LookupSids2 *)_r;
6945 ZERO_STRUCT(r->out);
6946 r->out.names = r->in.names;
6947 r->out.count = r->in.count;
6948 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6949 if (r->out.domains == NULL) {
6950 return NT_STATUS_NO_MEMORY;
6951 }
6952
6953 r->out.result = _lsa_LookupSids2(cli->pipes_struct, r);
6954 return NT_STATUS_OK;
6955 }
6956
6957 case NDR_LSA_LOOKUPNAMES2: {
6958 struct lsa_LookupNames2 *r = (struct lsa_LookupNames2 *)_r;
6959 ZERO_STRUCT(r->out);
6960 r->out.sids = r->in.sids;
6961 r->out.count = r->in.count;
6962 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6963 if (r->out.domains == NULL) {
6964 return NT_STATUS_NO_MEMORY;
6965 }
6966
6967 r->out.result = _lsa_LookupNames2(cli->pipes_struct, r);
6968 return NT_STATUS_OK;
6969 }
6970
6971 case NDR_LSA_CREATETRUSTEDDOMAINEX2: {
6972 struct lsa_CreateTrustedDomainEx2 *r = (struct lsa_CreateTrustedDomainEx2 *)_r;
6973 ZERO_STRUCT(r->out);
6974 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6975 if (r->out.trustdom_handle == NULL) {
6976 return NT_STATUS_NO_MEMORY;
6977 }
6978
6979 r->out.result = _lsa_CreateTrustedDomainEx2(cli->pipes_struct, r);
6980 return NT_STATUS_OK;
6981 }
6982
6983 case NDR_LSA_CREDRWRITE: {
6984 struct lsa_CREDRWRITE *r = (struct lsa_CREDRWRITE *)_r;
6985 r->out.result = _lsa_CREDRWRITE(cli->pipes_struct, r);
6986 return NT_STATUS_OK;
6987 }
6988
6989 case NDR_LSA_CREDRREAD: {
6990 struct lsa_CREDRREAD *r = (struct lsa_CREDRREAD *)_r;
6991 r->out.result = _lsa_CREDRREAD(cli->pipes_struct, r);
6992 return NT_STATUS_OK;
6993 }
6994
6995 case NDR_LSA_CREDRENUMERATE: {
6996 struct lsa_CREDRENUMERATE *r = (struct lsa_CREDRENUMERATE *)_r;
6997 r->out.result = _lsa_CREDRENUMERATE(cli->pipes_struct, r);
6998 return NT_STATUS_OK;
6999 }
7000
7001 case NDR_LSA_CREDRWRITEDOMAINCREDENTIALS: {
7002 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r = (struct lsa_CREDRWRITEDOMAINCREDENTIALS *)_r;
7003 r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(cli->pipes_struct, r);
7004 return NT_STATUS_OK;
7005 }
7006
7007 case NDR_LSA_CREDRREADDOMAINCREDENTIALS: {
7008 struct lsa_CREDRREADDOMAINCREDENTIALS *r = (struct lsa_CREDRREADDOMAINCREDENTIALS *)_r;
7009 r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(cli->pipes_struct, r);
7010 return NT_STATUS_OK;
7011 }
7012
7013 case NDR_LSA_CREDRDELETE: {
7014 struct lsa_CREDRDELETE *r = (struct lsa_CREDRDELETE *)_r;
7015 r->out.result = _lsa_CREDRDELETE(cli->pipes_struct, r);
7016 return NT_STATUS_OK;
7017 }
7018
7019 case NDR_LSA_CREDRGETTARGETINFO: {
7020 struct lsa_CREDRGETTARGETINFO *r = (struct lsa_CREDRGETTARGETINFO *)_r;
7021 r->out.result = _lsa_CREDRGETTARGETINFO(cli->pipes_struct, r);
7022 return NT_STATUS_OK;
7023 }
7024
7025 case NDR_LSA_CREDRPROFILELOADED: {
7026 struct lsa_CREDRPROFILELOADED *r = (struct lsa_CREDRPROFILELOADED *)_r;
7027 r->out.result = _lsa_CREDRPROFILELOADED(cli->pipes_struct, r);
7028 return NT_STATUS_OK;
7029 }
7030
7031 case NDR_LSA_LOOKUPNAMES3: {
7032 struct lsa_LookupNames3 *r = (struct lsa_LookupNames3 *)_r;
7033 ZERO_STRUCT(r->out);
7034 r->out.sids = r->in.sids;
7035 r->out.count = r->in.count;
7036 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7037 if (r->out.domains == NULL) {
7038 return NT_STATUS_NO_MEMORY;
7039 }
7040
7041 r->out.result = _lsa_LookupNames3(cli->pipes_struct, r);
7042 return NT_STATUS_OK;
7043 }
7044
7045 case NDR_LSA_CREDRGETSESSIONTYPES: {
7046 struct lsa_CREDRGETSESSIONTYPES *r = (struct lsa_CREDRGETSESSIONTYPES *)_r;
7047 r->out.result = _lsa_CREDRGETSESSIONTYPES(cli->pipes_struct, r);
7048 return NT_STATUS_OK;
7049 }
7050
7051 case NDR_LSA_LSARREGISTERAUDITEVENT: {
7052 struct lsa_LSARREGISTERAUDITEVENT *r = (struct lsa_LSARREGISTERAUDITEVENT *)_r;
7053 r->out.result = _lsa_LSARREGISTERAUDITEVENT(cli->pipes_struct, r);
7054 return NT_STATUS_OK;
7055 }
7056
7057 case NDR_LSA_LSARGENAUDITEVENT: {
7058 struct lsa_LSARGENAUDITEVENT *r = (struct lsa_LSARGENAUDITEVENT *)_r;
7059 r->out.result = _lsa_LSARGENAUDITEVENT(cli->pipes_struct, r);
7060 return NT_STATUS_OK;
7061 }
7062
7063 case NDR_LSA_LSARUNREGISTERAUDITEVENT: {
7064 struct lsa_LSARUNREGISTERAUDITEVENT *r = (struct lsa_LSARUNREGISTERAUDITEVENT *)_r;
7065 r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(cli->pipes_struct, r);
7066 return NT_STATUS_OK;
7067 }
7068
7069 case NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION: {
7070 struct lsa_lsaRQueryForestTrustInformation *r = (struct lsa_lsaRQueryForestTrustInformation *)_r;
7071 ZERO_STRUCT(r->out);
7072 r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
7073 if (r->out.forest_trust_info == NULL) {
7074 return NT_STATUS_NO_MEMORY;
7075 }
7076
7077 r->out.result = _lsa_lsaRQueryForestTrustInformation(cli->pipes_struct, r);
7078 return NT_STATUS_OK;
7079 }
7080
7081 case NDR_LSA_LSARSETFORESTTRUSTINFORMATION: {
7082 struct lsa_LSARSETFORESTTRUSTINFORMATION *r = (struct lsa_LSARSETFORESTTRUSTINFORMATION *)_r;
7083 r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(cli->pipes_struct, r);
7084 return NT_STATUS_OK;
7085 }
7086
7087 case NDR_LSA_CREDRRENAME: {
7088 struct lsa_CREDRRENAME *r = (struct lsa_CREDRRENAME *)_r;
7089 r->out.result = _lsa_CREDRRENAME(cli->pipes_struct, r);
7090 return NT_STATUS_OK;
7091 }
7092
7093 case NDR_LSA_LOOKUPSIDS3: {
7094 struct lsa_LookupSids3 *r = (struct lsa_LookupSids3 *)_r;
7095 ZERO_STRUCT(r->out);
7096 r->out.names = r->in.names;
7097 r->out.count = r->in.count;
7098 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7099 if (r->out.domains == NULL) {
7100 return NT_STATUS_NO_MEMORY;
7101 }
7102
7103 r->out.result = _lsa_LookupSids3(cli->pipes_struct, r);
7104 return NT_STATUS_OK;
7105 }
7106
7107 case NDR_LSA_LOOKUPNAMES4: {
7108 struct lsa_LookupNames4 *r = (struct lsa_LookupNames4 *)_r;
7109 ZERO_STRUCT(r->out);
7110 r->out.sids = r->in.sids;
7111 r->out.count = r->in.count;
7112 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7113 if (r->out.domains == NULL) {
7114 return NT_STATUS_NO_MEMORY;
7115 }
7116
7117 r->out.result = _lsa_LookupNames4(cli->pipes_struct, r);
7118 return NT_STATUS_OK;
7119 }
7120
7121 case NDR_LSA_LSAROPENPOLICYSCE: {
7122 struct lsa_LSAROPENPOLICYSCE *r = (struct lsa_LSAROPENPOLICYSCE *)_r;
7123 r->out.result = _lsa_LSAROPENPOLICYSCE(cli->pipes_struct, r);
7124 return NT_STATUS_OK;
7125 }
7126
7127 case NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE: {
7128 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *)_r;
7129 r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7130 return NT_STATUS_OK;
7131 }
7132
7133 case NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE: {
7134 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *)_r;
7135 r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7136 return NT_STATUS_OK;
7137 }
7138
7139 case NDR_LSA_LSARADTREPORTSECURITYEVENT: {
7140 struct lsa_LSARADTREPORTSECURITYEVENT *r = (struct lsa_LSARADTREPORTSECURITYEVENT *)_r;
7141 r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(cli->pipes_struct, r);
7142 return NT_STATUS_OK;
7143 }
7144
7145 default:
7146 return NT_STATUS_NOT_IMPLEMENTED;
7147 }
7148 }
7149
7150 NTSTATUS rpc_lsarpc_init(void)
/* [<][>][^][v][top][bottom][index][help] */
7151 {
7152 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", &ndr_table_lsarpc, api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));
7153 }