2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/srv_lsa.h"
9 static bool api_lsa_Close(pipes_struct *p)
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
18 call = &p->interface->calls[NDR_LSA_CLOSE];
20 r = talloc(talloc_tos(), struct lsa_Close);
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
30 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(lsa_Close, r);
48 r->out.handle = r->in.handle;
49 r->out.result = _lsa_Close(p, r);
51 if (p->rng_fault_state) {
53 /* Return true here, srv_pipe_hnd.c will take care */
57 if (DEBUGLEVEL >= 10) {
58 NDR_PRINT_OUT_DEBUG(lsa_Close, r);
61 push = ndr_push_init_ctx(r, NULL);
67 ndr_err = call->ndr_push(push, NDR_OUT, r);
68 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
73 blob = ndr_push_blob(push);
74 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
84 static bool api_lsa_Delete(pipes_struct *p)
86 const struct ndr_interface_call *call;
87 struct ndr_pull *pull;
88 struct ndr_push *push;
89 enum ndr_err_code ndr_err;
93 call = &p->interface->calls[NDR_LSA_DELETE];
95 r = talloc(talloc_tos(), struct lsa_Delete);
100 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
105 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
118 if (DEBUGLEVEL >= 10) {
119 NDR_PRINT_IN_DEBUG(lsa_Delete, r);
122 r->out.result = _lsa_Delete(p, r);
124 if (p->rng_fault_state) {
126 /* Return true here, srv_pipe_hnd.c will take care */
130 if (DEBUGLEVEL >= 10) {
131 NDR_PRINT_OUT_DEBUG(lsa_Delete, r);
134 push = ndr_push_init_ctx(r, NULL);
140 ndr_err = call->ndr_push(push, NDR_OUT, r);
141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
146 blob = ndr_push_blob(push);
147 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
157 static bool api_lsa_EnumPrivs(pipes_struct *p)
159 const struct ndr_interface_call *call;
160 struct ndr_pull *pull;
161 struct ndr_push *push;
162 enum ndr_err_code ndr_err;
164 struct lsa_EnumPrivs *r;
166 call = &p->interface->calls[NDR_LSA_ENUMPRIVS];
168 r = talloc(talloc_tos(), struct lsa_EnumPrivs);
173 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
178 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
191 if (DEBUGLEVEL >= 10) {
192 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);
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) {
203 r->out.result = _lsa_EnumPrivs(p, r);
205 if (p->rng_fault_state) {
207 /* Return true here, srv_pipe_hnd.c will take care */
211 if (DEBUGLEVEL >= 10) {
212 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);
215 push = ndr_push_init_ctx(r, NULL);
221 ndr_err = call->ndr_push(push, NDR_OUT, r);
222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
227 blob = ndr_push_blob(push);
228 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
238 static bool api_lsa_QuerySecurity(pipes_struct *p)
240 const struct ndr_interface_call *call;
241 struct ndr_pull *pull;
242 struct ndr_push *push;
243 enum ndr_err_code ndr_err;
245 struct lsa_QuerySecurity *r;
247 call = &p->interface->calls[NDR_LSA_QUERYSECURITY];
249 r = talloc(talloc_tos(), struct lsa_QuerySecurity);
254 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
259 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
272 if (DEBUGLEVEL >= 10) {
273 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, r);
277 r->out.sdbuf = talloc_zero(r, struct sec_desc_buf *);
278 if (r->out.sdbuf == NULL) {
283 r->out.result = _lsa_QuerySecurity(p, r);
285 if (p->rng_fault_state) {
287 /* Return true here, srv_pipe_hnd.c will take care */
291 if (DEBUGLEVEL >= 10) {
292 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, r);
295 push = ndr_push_init_ctx(r, NULL);
301 ndr_err = call->ndr_push(push, NDR_OUT, r);
302 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
307 blob = ndr_push_blob(push);
308 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
318 static bool api_lsa_SetSecObj(pipes_struct *p)
320 const struct ndr_interface_call *call;
321 struct ndr_pull *pull;
322 struct ndr_push *push;
323 enum ndr_err_code ndr_err;
325 struct lsa_SetSecObj *r;
327 call = &p->interface->calls[NDR_LSA_SETSECOBJ];
329 r = talloc(talloc_tos(), struct lsa_SetSecObj);
334 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
339 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
352 if (DEBUGLEVEL >= 10) {
353 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);
356 r->out.result = _lsa_SetSecObj(p, r);
358 if (p->rng_fault_state) {
360 /* Return true here, srv_pipe_hnd.c will take care */
364 if (DEBUGLEVEL >= 10) {
365 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);
368 push = ndr_push_init_ctx(r, NULL);
374 ndr_err = call->ndr_push(push, NDR_OUT, r);
375 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
380 blob = ndr_push_blob(push);
381 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
391 static bool api_lsa_ChangePassword(pipes_struct *p)
393 const struct ndr_interface_call *call;
394 struct ndr_pull *pull;
395 struct ndr_push *push;
396 enum ndr_err_code ndr_err;
398 struct lsa_ChangePassword *r;
400 call = &p->interface->calls[NDR_LSA_CHANGEPASSWORD];
402 r = talloc(talloc_tos(), struct lsa_ChangePassword);
407 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
412 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
425 if (DEBUGLEVEL >= 10) {
426 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);
429 r->out.result = _lsa_ChangePassword(p, r);
431 if (p->rng_fault_state) {
433 /* Return true here, srv_pipe_hnd.c will take care */
437 if (DEBUGLEVEL >= 10) {
438 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);
441 push = ndr_push_init_ctx(r, NULL);
447 ndr_err = call->ndr_push(push, NDR_OUT, r);
448 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
453 blob = ndr_push_blob(push);
454 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
464 static bool api_lsa_OpenPolicy(pipes_struct *p)
466 const struct ndr_interface_call *call;
467 struct ndr_pull *pull;
468 struct ndr_push *push;
469 enum ndr_err_code ndr_err;
471 struct lsa_OpenPolicy *r;
473 call = &p->interface->calls[NDR_LSA_OPENPOLICY];
475 r = talloc(talloc_tos(), struct lsa_OpenPolicy);
480 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
485 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
498 if (DEBUGLEVEL >= 10) {
499 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);
503 r->out.handle = talloc_zero(r, struct policy_handle);
504 if (r->out.handle == NULL) {
509 r->out.result = _lsa_OpenPolicy(p, r);
511 if (p->rng_fault_state) {
513 /* Return true here, srv_pipe_hnd.c will take care */
517 if (DEBUGLEVEL >= 10) {
518 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);
521 push = ndr_push_init_ctx(r, NULL);
527 ndr_err = call->ndr_push(push, NDR_OUT, r);
528 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
533 blob = ndr_push_blob(push);
534 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
544 static bool api_lsa_QueryInfoPolicy(pipes_struct *p)
546 const struct ndr_interface_call *call;
547 struct ndr_pull *pull;
548 struct ndr_push *push;
549 enum ndr_err_code ndr_err;
551 struct lsa_QueryInfoPolicy *r;
553 call = &p->interface->calls[NDR_LSA_QUERYINFOPOLICY];
555 r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy);
560 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
565 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
578 if (DEBUGLEVEL >= 10) {
579 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);
583 r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
584 if (r->out.info == NULL) {
589 r->out.result = _lsa_QueryInfoPolicy(p, r);
591 if (p->rng_fault_state) {
593 /* Return true here, srv_pipe_hnd.c will take care */
597 if (DEBUGLEVEL >= 10) {
598 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);
601 push = ndr_push_init_ctx(r, NULL);
607 ndr_err = call->ndr_push(push, NDR_OUT, r);
608 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
613 blob = ndr_push_blob(push);
614 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
624 static bool api_lsa_SetInfoPolicy(pipes_struct *p)
626 const struct ndr_interface_call *call;
627 struct ndr_pull *pull;
628 struct ndr_push *push;
629 enum ndr_err_code ndr_err;
631 struct lsa_SetInfoPolicy *r;
633 call = &p->interface->calls[NDR_LSA_SETINFOPOLICY];
635 r = talloc(talloc_tos(), struct lsa_SetInfoPolicy);
640 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
645 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
658 if (DEBUGLEVEL >= 10) {
659 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);
662 r->out.result = _lsa_SetInfoPolicy(p, r);
664 if (p->rng_fault_state) {
666 /* Return true here, srv_pipe_hnd.c will take care */
670 if (DEBUGLEVEL >= 10) {
671 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);
674 push = ndr_push_init_ctx(r, NULL);
680 ndr_err = call->ndr_push(push, NDR_OUT, r);
681 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
686 blob = ndr_push_blob(push);
687 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
697 static bool api_lsa_ClearAuditLog(pipes_struct *p)
699 const struct ndr_interface_call *call;
700 struct ndr_pull *pull;
701 struct ndr_push *push;
702 enum ndr_err_code ndr_err;
704 struct lsa_ClearAuditLog *r;
706 call = &p->interface->calls[NDR_LSA_CLEARAUDITLOG];
708 r = talloc(talloc_tos(), struct lsa_ClearAuditLog);
713 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
718 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
731 if (DEBUGLEVEL >= 10) {
732 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);
735 r->out.result = _lsa_ClearAuditLog(p, r);
737 if (p->rng_fault_state) {
739 /* Return true here, srv_pipe_hnd.c will take care */
743 if (DEBUGLEVEL >= 10) {
744 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);
747 push = ndr_push_init_ctx(r, NULL);
753 ndr_err = call->ndr_push(push, NDR_OUT, r);
754 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
759 blob = ndr_push_blob(push);
760 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
770 static bool api_lsa_CreateAccount(pipes_struct *p)
772 const struct ndr_interface_call *call;
773 struct ndr_pull *pull;
774 struct ndr_push *push;
775 enum ndr_err_code ndr_err;
777 struct lsa_CreateAccount *r;
779 call = &p->interface->calls[NDR_LSA_CREATEACCOUNT];
781 r = talloc(talloc_tos(), struct lsa_CreateAccount);
786 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
791 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
804 if (DEBUGLEVEL >= 10) {
805 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);
809 r->out.acct_handle = talloc_zero(r, struct policy_handle);
810 if (r->out.acct_handle == NULL) {
815 r->out.result = _lsa_CreateAccount(p, r);
817 if (p->rng_fault_state) {
819 /* Return true here, srv_pipe_hnd.c will take care */
823 if (DEBUGLEVEL >= 10) {
824 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);
827 push = ndr_push_init_ctx(r, NULL);
833 ndr_err = call->ndr_push(push, NDR_OUT, r);
834 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
839 blob = ndr_push_blob(push);
840 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
850 static bool api_lsa_EnumAccounts(pipes_struct *p)
852 const struct ndr_interface_call *call;
853 struct ndr_pull *pull;
854 struct ndr_push *push;
855 enum ndr_err_code ndr_err;
857 struct lsa_EnumAccounts *r;
859 call = &p->interface->calls[NDR_LSA_ENUMACCOUNTS];
861 r = talloc(talloc_tos(), struct lsa_EnumAccounts);
866 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
871 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
884 if (DEBUGLEVEL >= 10) {
885 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);
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) {
896 r->out.result = _lsa_EnumAccounts(p, r);
898 if (p->rng_fault_state) {
900 /* Return true here, srv_pipe_hnd.c will take care */
904 if (DEBUGLEVEL >= 10) {
905 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);
908 push = ndr_push_init_ctx(r, NULL);
914 ndr_err = call->ndr_push(push, NDR_OUT, r);
915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
920 blob = ndr_push_blob(push);
921 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
931 static bool api_lsa_CreateTrustedDomain(pipes_struct *p)
933 const struct ndr_interface_call *call;
934 struct ndr_pull *pull;
935 struct ndr_push *push;
936 enum ndr_err_code ndr_err;
938 struct lsa_CreateTrustedDomain *r;
940 call = &p->interface->calls[NDR_LSA_CREATETRUSTEDDOMAIN];
942 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomain);
947 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
952 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
965 if (DEBUGLEVEL >= 10) {
966 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, r);
970 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
971 if (r->out.trustdom_handle == NULL) {
976 r->out.result = _lsa_CreateTrustedDomain(p, r);
978 if (p->rng_fault_state) {
980 /* Return true here, srv_pipe_hnd.c will take care */
984 if (DEBUGLEVEL >= 10) {
985 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, r);
988 push = ndr_push_init_ctx(r, NULL);
994 ndr_err = call->ndr_push(push, NDR_OUT, r);
995 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1000 blob = ndr_push_blob(push);
1001 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1011 static bool api_lsa_EnumTrustDom(pipes_struct *p)
1013 const struct ndr_interface_call *call;
1014 struct ndr_pull *pull;
1015 struct ndr_push *push;
1016 enum ndr_err_code ndr_err;
1018 struct lsa_EnumTrustDom *r;
1020 call = &p->interface->calls[NDR_LSA_ENUMTRUSTDOM];
1022 r = talloc(talloc_tos(), struct lsa_EnumTrustDom);
1027 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1032 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1045 if (DEBUGLEVEL >= 10) {
1046 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);
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) {
1057 r->out.result = _lsa_EnumTrustDom(p, r);
1059 if (p->rng_fault_state) {
1061 /* Return true here, srv_pipe_hnd.c will take care */
1065 if (DEBUGLEVEL >= 10) {
1066 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);
1069 push = ndr_push_init_ctx(r, NULL);
1075 ndr_err = call->ndr_push(push, NDR_OUT, r);
1076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1081 blob = ndr_push_blob(push);
1082 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1092 static bool api_lsa_LookupNames(pipes_struct *p)
1094 const struct ndr_interface_call *call;
1095 struct ndr_pull *pull;
1096 struct ndr_push *push;
1097 enum ndr_err_code ndr_err;
1099 struct lsa_LookupNames *r;
1101 call = &p->interface->calls[NDR_LSA_LOOKUPNAMES];
1103 r = talloc(talloc_tos(), struct lsa_LookupNames);
1108 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1113 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1126 if (DEBUGLEVEL >= 10) {
1127 NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);
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) {
1139 r->out.result = _lsa_LookupNames(p, r);
1141 if (p->rng_fault_state) {
1143 /* Return true here, srv_pipe_hnd.c will take care */
1147 if (DEBUGLEVEL >= 10) {
1148 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);
1151 push = ndr_push_init_ctx(r, NULL);
1157 ndr_err = call->ndr_push(push, NDR_OUT, r);
1158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1163 blob = ndr_push_blob(push);
1164 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1174 static bool api_lsa_LookupSids(pipes_struct *p)
1176 const struct ndr_interface_call *call;
1177 struct ndr_pull *pull;
1178 struct ndr_push *push;
1179 enum ndr_err_code ndr_err;
1181 struct lsa_LookupSids *r;
1183 call = &p->interface->calls[NDR_LSA_LOOKUPSIDS];
1185 r = talloc(talloc_tos(), struct lsa_LookupSids);
1190 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1195 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1208 if (DEBUGLEVEL >= 10) {
1209 NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);
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) {
1221 r->out.result = _lsa_LookupSids(p, r);
1223 if (p->rng_fault_state) {
1225 /* Return true here, srv_pipe_hnd.c will take care */
1229 if (DEBUGLEVEL >= 10) {
1230 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);
1233 push = ndr_push_init_ctx(r, NULL);
1239 ndr_err = call->ndr_push(push, NDR_OUT, r);
1240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1245 blob = ndr_push_blob(push);
1246 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1256 static bool api_lsa_CreateSecret(pipes_struct *p)
1258 const struct ndr_interface_call *call;
1259 struct ndr_pull *pull;
1260 struct ndr_push *push;
1261 enum ndr_err_code ndr_err;
1263 struct lsa_CreateSecret *r;
1265 call = &p->interface->calls[NDR_LSA_CREATESECRET];
1267 r = talloc(talloc_tos(), struct lsa_CreateSecret);
1272 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1277 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1290 if (DEBUGLEVEL >= 10) {
1291 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, r);
1294 ZERO_STRUCT(r->out);
1295 r->out.sec_handle = talloc_zero(r, struct policy_handle);
1296 if (r->out.sec_handle == NULL) {
1301 r->out.result = _lsa_CreateSecret(p, r);
1303 if (p->rng_fault_state) {
1305 /* Return true here, srv_pipe_hnd.c will take care */
1309 if (DEBUGLEVEL >= 10) {
1310 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, r);
1313 push = ndr_push_init_ctx(r, NULL);
1319 ndr_err = call->ndr_push(push, NDR_OUT, r);
1320 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1325 blob = ndr_push_blob(push);
1326 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1336 static bool api_lsa_OpenAccount(pipes_struct *p)
1338 const struct ndr_interface_call *call;
1339 struct ndr_pull *pull;
1340 struct ndr_push *push;
1341 enum ndr_err_code ndr_err;
1343 struct lsa_OpenAccount *r;
1345 call = &p->interface->calls[NDR_LSA_OPENACCOUNT];
1347 r = talloc(talloc_tos(), struct lsa_OpenAccount);
1352 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1357 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1370 if (DEBUGLEVEL >= 10) {
1371 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);
1374 ZERO_STRUCT(r->out);
1375 r->out.acct_handle = talloc_zero(r, struct policy_handle);
1376 if (r->out.acct_handle == NULL) {
1381 r->out.result = _lsa_OpenAccount(p, r);
1383 if (p->rng_fault_state) {
1385 /* Return true here, srv_pipe_hnd.c will take care */
1389 if (DEBUGLEVEL >= 10) {
1390 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);
1393 push = ndr_push_init_ctx(r, NULL);
1399 ndr_err = call->ndr_push(push, NDR_OUT, r);
1400 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1405 blob = ndr_push_blob(push);
1406 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1416 static bool api_lsa_EnumPrivsAccount(pipes_struct *p)
1418 const struct ndr_interface_call *call;
1419 struct ndr_pull *pull;
1420 struct ndr_push *push;
1421 enum ndr_err_code ndr_err;
1423 struct lsa_EnumPrivsAccount *r;
1425 call = &p->interface->calls[NDR_LSA_ENUMPRIVSACCOUNT];
1427 r = talloc(talloc_tos(), struct lsa_EnumPrivsAccount);
1432 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1437 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1450 if (DEBUGLEVEL >= 10) {
1451 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);
1454 ZERO_STRUCT(r->out);
1455 r->out.privs = talloc_zero(r, struct lsa_PrivilegeSet *);
1456 if (r->out.privs == NULL) {
1461 r->out.result = _lsa_EnumPrivsAccount(p, r);
1463 if (p->rng_fault_state) {
1465 /* Return true here, srv_pipe_hnd.c will take care */
1469 if (DEBUGLEVEL >= 10) {
1470 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);
1473 push = ndr_push_init_ctx(r, NULL);
1479 ndr_err = call->ndr_push(push, NDR_OUT, r);
1480 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1485 blob = ndr_push_blob(push);
1486 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1496 static bool api_lsa_AddPrivilegesToAccount(pipes_struct *p)
1498 const struct ndr_interface_call *call;
1499 struct ndr_pull *pull;
1500 struct ndr_push *push;
1501 enum ndr_err_code ndr_err;
1503 struct lsa_AddPrivilegesToAccount *r;
1505 call = &p->interface->calls[NDR_LSA_ADDPRIVILEGESTOACCOUNT];
1507 r = talloc(talloc_tos(), struct lsa_AddPrivilegesToAccount);
1512 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1517 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1530 if (DEBUGLEVEL >= 10) {
1531 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, r);
1534 r->out.result = _lsa_AddPrivilegesToAccount(p, r);
1536 if (p->rng_fault_state) {
1538 /* Return true here, srv_pipe_hnd.c will take care */
1542 if (DEBUGLEVEL >= 10) {
1543 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, r);
1546 push = ndr_push_init_ctx(r, NULL);
1552 ndr_err = call->ndr_push(push, NDR_OUT, r);
1553 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1558 blob = ndr_push_blob(push);
1559 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1569 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct *p)
1571 const struct ndr_interface_call *call;
1572 struct ndr_pull *pull;
1573 struct ndr_push *push;
1574 enum ndr_err_code ndr_err;
1576 struct lsa_RemovePrivilegesFromAccount *r;
1578 call = &p->interface->calls[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT];
1580 r = talloc(talloc_tos(), struct lsa_RemovePrivilegesFromAccount);
1585 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1590 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1603 if (DEBUGLEVEL >= 10) {
1604 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1607 r->out.result = _lsa_RemovePrivilegesFromAccount(p, r);
1609 if (p->rng_fault_state) {
1611 /* Return true here, srv_pipe_hnd.c will take care */
1615 if (DEBUGLEVEL >= 10) {
1616 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1619 push = ndr_push_init_ctx(r, NULL);
1625 ndr_err = call->ndr_push(push, NDR_OUT, r);
1626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1631 blob = ndr_push_blob(push);
1632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1642 static bool api_lsa_GetQuotasForAccount(pipes_struct *p)
1644 const struct ndr_interface_call *call;
1645 struct ndr_pull *pull;
1646 struct ndr_push *push;
1647 enum ndr_err_code ndr_err;
1649 struct lsa_GetQuotasForAccount *r;
1651 call = &p->interface->calls[NDR_LSA_GETQUOTASFORACCOUNT];
1653 r = talloc(talloc_tos(), struct lsa_GetQuotasForAccount);
1658 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1663 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1676 if (DEBUGLEVEL >= 10) {
1677 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, r);
1680 r->out.result = _lsa_GetQuotasForAccount(p, r);
1682 if (p->rng_fault_state) {
1684 /* Return true here, srv_pipe_hnd.c will take care */
1688 if (DEBUGLEVEL >= 10) {
1689 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, r);
1692 push = ndr_push_init_ctx(r, NULL);
1698 ndr_err = call->ndr_push(push, NDR_OUT, r);
1699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1704 blob = ndr_push_blob(push);
1705 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1715 static bool api_lsa_SetQuotasForAccount(pipes_struct *p)
1717 const struct ndr_interface_call *call;
1718 struct ndr_pull *pull;
1719 struct ndr_push *push;
1720 enum ndr_err_code ndr_err;
1722 struct lsa_SetQuotasForAccount *r;
1724 call = &p->interface->calls[NDR_LSA_SETQUOTASFORACCOUNT];
1726 r = talloc(talloc_tos(), struct lsa_SetQuotasForAccount);
1731 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1736 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1749 if (DEBUGLEVEL >= 10) {
1750 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, r);
1753 r->out.result = _lsa_SetQuotasForAccount(p, r);
1755 if (p->rng_fault_state) {
1757 /* Return true here, srv_pipe_hnd.c will take care */
1761 if (DEBUGLEVEL >= 10) {
1762 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, r);
1765 push = ndr_push_init_ctx(r, NULL);
1771 ndr_err = call->ndr_push(push, NDR_OUT, r);
1772 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1777 blob = ndr_push_blob(push);
1778 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1788 static bool api_lsa_GetSystemAccessAccount(pipes_struct *p)
1790 const struct ndr_interface_call *call;
1791 struct ndr_pull *pull;
1792 struct ndr_push *push;
1793 enum ndr_err_code ndr_err;
1795 struct lsa_GetSystemAccessAccount *r;
1797 call = &p->interface->calls[NDR_LSA_GETSYSTEMACCESSACCOUNT];
1799 r = talloc(talloc_tos(), struct lsa_GetSystemAccessAccount);
1804 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1809 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1822 if (DEBUGLEVEL >= 10) {
1823 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, r);
1826 ZERO_STRUCT(r->out);
1827 r->out.access_mask = talloc_zero(r, uint32_t);
1828 if (r->out.access_mask == NULL) {
1833 r->out.result = _lsa_GetSystemAccessAccount(p, r);
1835 if (p->rng_fault_state) {
1837 /* Return true here, srv_pipe_hnd.c will take care */
1841 if (DEBUGLEVEL >= 10) {
1842 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1845 push = ndr_push_init_ctx(r, NULL);
1851 ndr_err = call->ndr_push(push, NDR_OUT, r);
1852 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1857 blob = ndr_push_blob(push);
1858 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1868 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
1870 const struct ndr_interface_call *call;
1871 struct ndr_pull *pull;
1872 struct ndr_push *push;
1873 enum ndr_err_code ndr_err;
1875 struct lsa_SetSystemAccessAccount *r;
1877 call = &p->interface->calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1879 r = talloc(talloc_tos(), struct lsa_SetSystemAccessAccount);
1884 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1889 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1902 if (DEBUGLEVEL >= 10) {
1903 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1906 r->out.result = _lsa_SetSystemAccessAccount(p, r);
1908 if (p->rng_fault_state) {
1910 /* Return true here, srv_pipe_hnd.c will take care */
1914 if (DEBUGLEVEL >= 10) {
1915 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1918 push = ndr_push_init_ctx(r, NULL);
1924 ndr_err = call->ndr_push(push, NDR_OUT, r);
1925 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1930 blob = ndr_push_blob(push);
1931 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1941 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
1943 const struct ndr_interface_call *call;
1944 struct ndr_pull *pull;
1945 struct ndr_push *push;
1946 enum ndr_err_code ndr_err;
1948 struct lsa_OpenTrustedDomain *r;
1950 call = &p->interface->calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1952 r = talloc(talloc_tos(), struct lsa_OpenTrustedDomain);
1957 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1962 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
1975 if (DEBUGLEVEL >= 10) {
1976 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1979 ZERO_STRUCT(r->out);
1980 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1981 if (r->out.trustdom_handle == NULL) {
1986 r->out.result = _lsa_OpenTrustedDomain(p, r);
1988 if (p->rng_fault_state) {
1990 /* Return true here, srv_pipe_hnd.c will take care */
1994 if (DEBUGLEVEL >= 10) {
1995 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1998 push = ndr_push_init_ctx(r, NULL);
2004 ndr_err = call->ndr_push(push, NDR_OUT, r);
2005 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2010 blob = ndr_push_blob(push);
2011 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2021 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
2023 const struct ndr_interface_call *call;
2024 struct ndr_pull *pull;
2025 struct ndr_push *push;
2026 enum ndr_err_code ndr_err;
2028 struct lsa_QueryTrustedDomainInfo *r;
2030 call = &p->interface->calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
2032 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfo);
2037 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2042 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2055 if (DEBUGLEVEL >= 10) {
2056 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
2059 ZERO_STRUCT(r->out);
2060 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
2061 if (r->out.info == NULL) {
2066 r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2068 if (p->rng_fault_state) {
2070 /* Return true here, srv_pipe_hnd.c will take care */
2074 if (DEBUGLEVEL >= 10) {
2075 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2078 push = ndr_push_init_ctx(r, NULL);
2084 ndr_err = call->ndr_push(push, NDR_OUT, r);
2085 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2090 blob = ndr_push_blob(push);
2091 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2101 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
2103 const struct ndr_interface_call *call;
2104 struct ndr_pull *pull;
2105 struct ndr_push *push;
2106 enum ndr_err_code ndr_err;
2108 struct lsa_SetInformationTrustedDomain *r;
2110 call = &p->interface->calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2112 r = talloc(talloc_tos(), struct lsa_SetInformationTrustedDomain);
2117 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2122 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2135 if (DEBUGLEVEL >= 10) {
2136 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2139 r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2141 if (p->rng_fault_state) {
2143 /* Return true here, srv_pipe_hnd.c will take care */
2147 if (DEBUGLEVEL >= 10) {
2148 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2151 push = ndr_push_init_ctx(r, NULL);
2157 ndr_err = call->ndr_push(push, NDR_OUT, r);
2158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2163 blob = ndr_push_blob(push);
2164 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2174 static bool api_lsa_OpenSecret(pipes_struct *p)
2176 const struct ndr_interface_call *call;
2177 struct ndr_pull *pull;
2178 struct ndr_push *push;
2179 enum ndr_err_code ndr_err;
2181 struct lsa_OpenSecret *r;
2183 call = &p->interface->calls[NDR_LSA_OPENSECRET];
2185 r = talloc(talloc_tos(), struct lsa_OpenSecret);
2190 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2195 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2208 if (DEBUGLEVEL >= 10) {
2209 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2212 ZERO_STRUCT(r->out);
2213 r->out.sec_handle = talloc_zero(r, struct policy_handle);
2214 if (r->out.sec_handle == NULL) {
2219 r->out.result = _lsa_OpenSecret(p, r);
2221 if (p->rng_fault_state) {
2223 /* Return true here, srv_pipe_hnd.c will take care */
2227 if (DEBUGLEVEL >= 10) {
2228 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2231 push = ndr_push_init_ctx(r, NULL);
2237 ndr_err = call->ndr_push(push, NDR_OUT, r);
2238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2243 blob = ndr_push_blob(push);
2244 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2254 static bool api_lsa_SetSecret(pipes_struct *p)
2256 const struct ndr_interface_call *call;
2257 struct ndr_pull *pull;
2258 struct ndr_push *push;
2259 enum ndr_err_code ndr_err;
2261 struct lsa_SetSecret *r;
2263 call = &p->interface->calls[NDR_LSA_SETSECRET];
2265 r = talloc(talloc_tos(), struct lsa_SetSecret);
2270 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2275 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2288 if (DEBUGLEVEL >= 10) {
2289 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2292 r->out.result = _lsa_SetSecret(p, r);
2294 if (p->rng_fault_state) {
2296 /* Return true here, srv_pipe_hnd.c will take care */
2300 if (DEBUGLEVEL >= 10) {
2301 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2304 push = ndr_push_init_ctx(r, NULL);
2310 ndr_err = call->ndr_push(push, NDR_OUT, r);
2311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2316 blob = ndr_push_blob(push);
2317 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2327 static bool api_lsa_QuerySecret(pipes_struct *p)
2329 const struct ndr_interface_call *call;
2330 struct ndr_pull *pull;
2331 struct ndr_push *push;
2332 enum ndr_err_code ndr_err;
2334 struct lsa_QuerySecret *r;
2336 call = &p->interface->calls[NDR_LSA_QUERYSECRET];
2338 r = talloc(talloc_tos(), struct lsa_QuerySecret);
2343 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2348 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2361 if (DEBUGLEVEL >= 10) {
2362 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
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);
2372 if (p->rng_fault_state) {
2374 /* Return true here, srv_pipe_hnd.c will take care */
2378 if (DEBUGLEVEL >= 10) {
2379 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2382 push = ndr_push_init_ctx(r, NULL);
2388 ndr_err = call->ndr_push(push, NDR_OUT, r);
2389 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2394 blob = ndr_push_blob(push);
2395 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2405 static bool api_lsa_LookupPrivValue(pipes_struct *p)
2407 const struct ndr_interface_call *call;
2408 struct ndr_pull *pull;
2409 struct ndr_push *push;
2410 enum ndr_err_code ndr_err;
2412 struct lsa_LookupPrivValue *r;
2414 call = &p->interface->calls[NDR_LSA_LOOKUPPRIVVALUE];
2416 r = talloc(talloc_tos(), struct lsa_LookupPrivValue);
2421 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2426 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2439 if (DEBUGLEVEL >= 10) {
2440 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2443 ZERO_STRUCT(r->out);
2444 r->out.luid = talloc_zero(r, struct lsa_LUID);
2445 if (r->out.luid == NULL) {
2450 r->out.result = _lsa_LookupPrivValue(p, r);
2452 if (p->rng_fault_state) {
2454 /* Return true here, srv_pipe_hnd.c will take care */
2458 if (DEBUGLEVEL >= 10) {
2459 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2462 push = ndr_push_init_ctx(r, NULL);
2468 ndr_err = call->ndr_push(push, NDR_OUT, r);
2469 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2474 blob = ndr_push_blob(push);
2475 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2485 static bool api_lsa_LookupPrivName(pipes_struct *p)
2487 const struct ndr_interface_call *call;
2488 struct ndr_pull *pull;
2489 struct ndr_push *push;
2490 enum ndr_err_code ndr_err;
2492 struct lsa_LookupPrivName *r;
2494 call = &p->interface->calls[NDR_LSA_LOOKUPPRIVNAME];
2496 r = talloc(talloc_tos(), struct lsa_LookupPrivName);
2501 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2506 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2519 if (DEBUGLEVEL >= 10) {
2520 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2523 ZERO_STRUCT(r->out);
2524 r->out.name = talloc_zero(r, struct lsa_StringLarge *);
2525 if (r->out.name == NULL) {
2530 r->out.result = _lsa_LookupPrivName(p, r);
2532 if (p->rng_fault_state) {
2534 /* Return true here, srv_pipe_hnd.c will take care */
2538 if (DEBUGLEVEL >= 10) {
2539 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2542 push = ndr_push_init_ctx(r, NULL);
2548 ndr_err = call->ndr_push(push, NDR_OUT, r);
2549 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2554 blob = ndr_push_blob(push);
2555 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2565 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
2567 const struct ndr_interface_call *call;
2568 struct ndr_pull *pull;
2569 struct ndr_push *push;
2570 enum ndr_err_code ndr_err;
2572 struct lsa_LookupPrivDisplayName *r;
2574 call = &p->interface->calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2576 r = talloc(talloc_tos(), struct lsa_LookupPrivDisplayName);
2581 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2586 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2599 if (DEBUGLEVEL >= 10) {
2600 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2603 ZERO_STRUCT(r->out);
2604 r->out.disp_name = talloc_zero(r, struct lsa_StringLarge *);
2605 if (r->out.disp_name == NULL) {
2610 r->out.returned_language_id = talloc_zero(r, uint16_t);
2611 if (r->out.returned_language_id == NULL) {
2616 r->out.result = _lsa_LookupPrivDisplayName(p, r);
2618 if (p->rng_fault_state) {
2620 /* Return true here, srv_pipe_hnd.c will take care */
2624 if (DEBUGLEVEL >= 10) {
2625 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2628 push = ndr_push_init_ctx(r, NULL);
2634 ndr_err = call->ndr_push(push, NDR_OUT, r);
2635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2640 blob = ndr_push_blob(push);
2641 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2651 static bool api_lsa_DeleteObject(pipes_struct *p)
2653 const struct ndr_interface_call *call;
2654 struct ndr_pull *pull;
2655 struct ndr_push *push;
2656 enum ndr_err_code ndr_err;
2658 struct lsa_DeleteObject *r;
2660 call = &p->interface->calls[NDR_LSA_DELETEOBJECT];
2662 r = talloc(talloc_tos(), struct lsa_DeleteObject);
2667 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2672 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2685 if (DEBUGLEVEL >= 10) {
2686 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2689 ZERO_STRUCT(r->out);
2690 r->out.handle = r->in.handle;
2691 r->out.result = _lsa_DeleteObject(p, r);
2693 if (p->rng_fault_state) {
2695 /* Return true here, srv_pipe_hnd.c will take care */
2699 if (DEBUGLEVEL >= 10) {
2700 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2703 push = ndr_push_init_ctx(r, NULL);
2709 ndr_err = call->ndr_push(push, NDR_OUT, r);
2710 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2715 blob = ndr_push_blob(push);
2716 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2726 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
2728 const struct ndr_interface_call *call;
2729 struct ndr_pull *pull;
2730 struct ndr_push *push;
2731 enum ndr_err_code ndr_err;
2733 struct lsa_EnumAccountsWithUserRight *r;
2735 call = &p->interface->calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2737 r = talloc(talloc_tos(), struct lsa_EnumAccountsWithUserRight);
2742 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2747 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2760 if (DEBUGLEVEL >= 10) {
2761 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2764 ZERO_STRUCT(r->out);
2765 r->out.sids = talloc_zero(r, struct lsa_SidArray);
2766 if (r->out.sids == NULL) {
2771 r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2773 if (p->rng_fault_state) {
2775 /* Return true here, srv_pipe_hnd.c will take care */
2779 if (DEBUGLEVEL >= 10) {
2780 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2783 push = ndr_push_init_ctx(r, NULL);
2789 ndr_err = call->ndr_push(push, NDR_OUT, r);
2790 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2795 blob = ndr_push_blob(push);
2796 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2806 static bool api_lsa_EnumAccountRights(pipes_struct *p)
2808 const struct ndr_interface_call *call;
2809 struct ndr_pull *pull;
2810 struct ndr_push *push;
2811 enum ndr_err_code ndr_err;
2813 struct lsa_EnumAccountRights *r;
2815 call = &p->interface->calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2817 r = talloc(talloc_tos(), struct lsa_EnumAccountRights);
2822 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2827 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2840 if (DEBUGLEVEL >= 10) {
2841 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2844 ZERO_STRUCT(r->out);
2845 r->out.rights = talloc_zero(r, struct lsa_RightSet);
2846 if (r->out.rights == NULL) {
2851 r->out.result = _lsa_EnumAccountRights(p, r);
2853 if (p->rng_fault_state) {
2855 /* Return true here, srv_pipe_hnd.c will take care */
2859 if (DEBUGLEVEL >= 10) {
2860 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2863 push = ndr_push_init_ctx(r, NULL);
2869 ndr_err = call->ndr_push(push, NDR_OUT, r);
2870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2875 blob = ndr_push_blob(push);
2876 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2886 static bool api_lsa_AddAccountRights(pipes_struct *p)
2888 const struct ndr_interface_call *call;
2889 struct ndr_pull *pull;
2890 struct ndr_push *push;
2891 enum ndr_err_code ndr_err;
2893 struct lsa_AddAccountRights *r;
2895 call = &p->interface->calls[NDR_LSA_ADDACCOUNTRIGHTS];
2897 r = talloc(talloc_tos(), struct lsa_AddAccountRights);
2902 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2907 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2920 if (DEBUGLEVEL >= 10) {
2921 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2924 r->out.result = _lsa_AddAccountRights(p, r);
2926 if (p->rng_fault_state) {
2928 /* Return true here, srv_pipe_hnd.c will take care */
2932 if (DEBUGLEVEL >= 10) {
2933 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2936 push = ndr_push_init_ctx(r, NULL);
2942 ndr_err = call->ndr_push(push, NDR_OUT, r);
2943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2948 blob = ndr_push_blob(push);
2949 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2959 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
2961 const struct ndr_interface_call *call;
2962 struct ndr_pull *pull;
2963 struct ndr_push *push;
2964 enum ndr_err_code ndr_err;
2966 struct lsa_RemoveAccountRights *r;
2968 call = &p->interface->calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2970 r = talloc(talloc_tos(), struct lsa_RemoveAccountRights);
2975 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2980 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
2993 if (DEBUGLEVEL >= 10) {
2994 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2997 r->out.result = _lsa_RemoveAccountRights(p, r);
2999 if (p->rng_fault_state) {
3001 /* Return true here, srv_pipe_hnd.c will take care */
3005 if (DEBUGLEVEL >= 10) {
3006 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
3009 push = ndr_push_init_ctx(r, NULL);
3015 ndr_err = call->ndr_push(push, NDR_OUT, r);
3016 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3021 blob = ndr_push_blob(push);
3022 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3032 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
3034 const struct ndr_interface_call *call;
3035 struct ndr_pull *pull;
3036 struct ndr_push *push;
3037 enum ndr_err_code ndr_err;
3039 struct lsa_QueryTrustedDomainInfoBySid *r;
3041 call = &p->interface->calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
3043 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoBySid);
3048 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3053 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3066 if (DEBUGLEVEL >= 10) {
3067 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3070 ZERO_STRUCT(r->out);
3071 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3072 if (r->out.info == NULL) {
3077 r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
3079 if (p->rng_fault_state) {
3081 /* Return true here, srv_pipe_hnd.c will take care */
3085 if (DEBUGLEVEL >= 10) {
3086 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
3089 push = ndr_push_init_ctx(r, NULL);
3095 ndr_err = call->ndr_push(push, NDR_OUT, r);
3096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3101 blob = ndr_push_blob(push);
3102 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3112 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
3114 const struct ndr_interface_call *call;
3115 struct ndr_pull *pull;
3116 struct ndr_push *push;
3117 enum ndr_err_code ndr_err;
3119 struct lsa_SetTrustedDomainInfo *r;
3121 call = &p->interface->calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3123 r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfo);
3128 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3133 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3146 if (DEBUGLEVEL >= 10) {
3147 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3150 r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3152 if (p->rng_fault_state) {
3154 /* Return true here, srv_pipe_hnd.c will take care */
3158 if (DEBUGLEVEL >= 10) {
3159 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3162 push = ndr_push_init_ctx(r, NULL);
3168 ndr_err = call->ndr_push(push, NDR_OUT, r);
3169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3174 blob = ndr_push_blob(push);
3175 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3185 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
3187 const struct ndr_interface_call *call;
3188 struct ndr_pull *pull;
3189 struct ndr_push *push;
3190 enum ndr_err_code ndr_err;
3192 struct lsa_DeleteTrustedDomain *r;
3194 call = &p->interface->calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3196 r = talloc(talloc_tos(), struct lsa_DeleteTrustedDomain);
3201 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3206 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3219 if (DEBUGLEVEL >= 10) {
3220 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3223 r->out.result = _lsa_DeleteTrustedDomain(p, r);
3225 if (p->rng_fault_state) {
3227 /* Return true here, srv_pipe_hnd.c will take care */
3231 if (DEBUGLEVEL >= 10) {
3232 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3235 push = ndr_push_init_ctx(r, NULL);
3241 ndr_err = call->ndr_push(push, NDR_OUT, r);
3242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3247 blob = ndr_push_blob(push);
3248 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3258 static bool api_lsa_StorePrivateData(pipes_struct *p)
3260 const struct ndr_interface_call *call;
3261 struct ndr_pull *pull;
3262 struct ndr_push *push;
3263 enum ndr_err_code ndr_err;
3265 struct lsa_StorePrivateData *r;
3267 call = &p->interface->calls[NDR_LSA_STOREPRIVATEDATA];
3269 r = talloc(talloc_tos(), struct lsa_StorePrivateData);
3274 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3279 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3292 if (DEBUGLEVEL >= 10) {
3293 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3296 r->out.result = _lsa_StorePrivateData(p, r);
3298 if (p->rng_fault_state) {
3300 /* Return true here, srv_pipe_hnd.c will take care */
3304 if (DEBUGLEVEL >= 10) {
3305 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3308 push = ndr_push_init_ctx(r, NULL);
3314 ndr_err = call->ndr_push(push, NDR_OUT, r);
3315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3320 blob = ndr_push_blob(push);
3321 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3331 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
3333 const struct ndr_interface_call *call;
3334 struct ndr_pull *pull;
3335 struct ndr_push *push;
3336 enum ndr_err_code ndr_err;
3338 struct lsa_RetrievePrivateData *r;
3340 call = &p->interface->calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3342 r = talloc(talloc_tos(), struct lsa_RetrievePrivateData);
3347 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3352 pull = ndr_pull_init_blob(&blob, r, NULL);
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)) {
3365 if (DEBUGLEVEL >= 10) {
3366 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3369 ZERO_STRUCT(r->out);
3370 r->out.val = r->in.val;
3371 r->out.result = _lsa_RetrievePrivateData(p, r);
3373 if (p->rng_fault_state) {
3375 /* Return true here, srv_pipe_hnd.c will take care */
3379 if (DEBUGLEVEL >= 10) {
3380 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3383 push = ndr_push_init_ctx(r, NULL);
3389 ndr_err = call->ndr_push(push, NDR_OUT, r);
3390 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3395 blob = ndr_push_blob(push);
3396 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3406 static bool api_lsa_OpenPolicy2(pipes_struct *p)
3408 const struct ndr_interface_call *call;
3409 struct ndr_pull *pull;
3410 struct ndr_push *push;
3411 enum ndr_err_code ndr_err;
3413 struct lsa_OpenPolicy2 *r;
3415 call = &p->interface->calls[NDR_LSA_OPENPOLICY2];
3417 r = talloc(talloc_tos(), struct lsa_OpenPolicy2);
3422 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3427 pull = ndr_pull_init_blob(&blob, r, NULL);
3433 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3434 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3435 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3440 if (DEBUGLEVEL >= 10) {
3441 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3444 ZERO_STRUCT(r->out);
3445 r->out.handle = talloc_zero(r, struct policy_handle);
3446 if (r->out.handle == NULL) {
3451 r->out.result = _lsa_OpenPolicy2(p, r);
3453 if (p->rng_fault_state) {
3455 /* Return true here, srv_pipe_hnd.c will take care */
3459 if (DEBUGLEVEL >= 10) {
3460 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3463 push = ndr_push_init_ctx(r, NULL);
3469 ndr_err = call->ndr_push(push, NDR_OUT, r);
3470 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3475 blob = ndr_push_blob(push);
3476 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3486 static bool api_lsa_GetUserName(pipes_struct *p)
3488 const struct ndr_interface_call *call;
3489 struct ndr_pull *pull;
3490 struct ndr_push *push;
3491 enum ndr_err_code ndr_err;
3493 struct lsa_GetUserName *r;
3495 call = &p->interface->calls[NDR_LSA_GETUSERNAME];
3497 r = talloc(talloc_tos(), struct lsa_GetUserName);
3502 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3507 pull = ndr_pull_init_blob(&blob, r, NULL);
3513 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3514 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3515 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3520 if (DEBUGLEVEL >= 10) {
3521 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3524 ZERO_STRUCT(r->out);
3525 r->out.account_name = r->in.account_name;
3526 r->out.authority_name = r->in.authority_name;
3527 r->out.result = _lsa_GetUserName(p, r);
3529 if (p->rng_fault_state) {
3531 /* Return true here, srv_pipe_hnd.c will take care */
3535 if (DEBUGLEVEL >= 10) {
3536 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3539 push = ndr_push_init_ctx(r, NULL);
3545 ndr_err = call->ndr_push(push, NDR_OUT, r);
3546 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3551 blob = ndr_push_blob(push);
3552 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3562 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
3564 const struct ndr_interface_call *call;
3565 struct ndr_pull *pull;
3566 struct ndr_push *push;
3567 enum ndr_err_code ndr_err;
3569 struct lsa_QueryInfoPolicy2 *r;
3571 call = &p->interface->calls[NDR_LSA_QUERYINFOPOLICY2];
3573 r = talloc(talloc_tos(), struct lsa_QueryInfoPolicy2);
3578 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3583 pull = ndr_pull_init_blob(&blob, r, NULL);
3589 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3590 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3591 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3596 if (DEBUGLEVEL >= 10) {
3597 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3600 ZERO_STRUCT(r->out);
3601 r->out.info = talloc_zero(r, union lsa_PolicyInformation *);
3602 if (r->out.info == NULL) {
3607 r->out.result = _lsa_QueryInfoPolicy2(p, r);
3609 if (p->rng_fault_state) {
3611 /* Return true here, srv_pipe_hnd.c will take care */
3615 if (DEBUGLEVEL >= 10) {
3616 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3619 push = ndr_push_init_ctx(r, NULL);
3625 ndr_err = call->ndr_push(push, NDR_OUT, r);
3626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3631 blob = ndr_push_blob(push);
3632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3642 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
3644 const struct ndr_interface_call *call;
3645 struct ndr_pull *pull;
3646 struct ndr_push *push;
3647 enum ndr_err_code ndr_err;
3649 struct lsa_SetInfoPolicy2 *r;
3651 call = &p->interface->calls[NDR_LSA_SETINFOPOLICY2];
3653 r = talloc(talloc_tos(), struct lsa_SetInfoPolicy2);
3658 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3663 pull = ndr_pull_init_blob(&blob, r, NULL);
3669 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3670 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3671 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3676 if (DEBUGLEVEL >= 10) {
3677 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3680 r->out.result = _lsa_SetInfoPolicy2(p, r);
3682 if (p->rng_fault_state) {
3684 /* Return true here, srv_pipe_hnd.c will take care */
3688 if (DEBUGLEVEL >= 10) {
3689 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3692 push = ndr_push_init_ctx(r, NULL);
3698 ndr_err = call->ndr_push(push, NDR_OUT, r);
3699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3704 blob = ndr_push_blob(push);
3705 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3715 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
3717 const struct ndr_interface_call *call;
3718 struct ndr_pull *pull;
3719 struct ndr_push *push;
3720 enum ndr_err_code ndr_err;
3722 struct lsa_QueryTrustedDomainInfoByName *r;
3724 call = &p->interface->calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3726 r = talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoByName);
3731 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3736 pull = ndr_pull_init_blob(&blob, r, NULL);
3742 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3743 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3744 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3749 if (DEBUGLEVEL >= 10) {
3750 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3753 ZERO_STRUCT(r->out);
3754 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo *);
3755 if (r->out.info == NULL) {
3760 r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3762 if (p->rng_fault_state) {
3764 /* Return true here, srv_pipe_hnd.c will take care */
3768 if (DEBUGLEVEL >= 10) {
3769 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3772 push = ndr_push_init_ctx(r, NULL);
3778 ndr_err = call->ndr_push(push, NDR_OUT, r);
3779 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3784 blob = ndr_push_blob(push);
3785 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3795 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
3797 const struct ndr_interface_call *call;
3798 struct ndr_pull *pull;
3799 struct ndr_push *push;
3800 enum ndr_err_code ndr_err;
3802 struct lsa_SetTrustedDomainInfoByName *r;
3804 call = &p->interface->calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3806 r = talloc(talloc_tos(), struct lsa_SetTrustedDomainInfoByName);
3811 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3816 pull = ndr_pull_init_blob(&blob, r, NULL);
3822 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3823 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3824 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3829 if (DEBUGLEVEL >= 10) {
3830 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3833 r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3835 if (p->rng_fault_state) {
3837 /* Return true here, srv_pipe_hnd.c will take care */
3841 if (DEBUGLEVEL >= 10) {
3842 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3845 push = ndr_push_init_ctx(r, NULL);
3851 ndr_err = call->ndr_push(push, NDR_OUT, r);
3852 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3857 blob = ndr_push_blob(push);
3858 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3868 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
3870 const struct ndr_interface_call *call;
3871 struct ndr_pull *pull;
3872 struct ndr_push *push;
3873 enum ndr_err_code ndr_err;
3875 struct lsa_EnumTrustedDomainsEx *r;
3877 call = &p->interface->calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3879 r = talloc(talloc_tos(), struct lsa_EnumTrustedDomainsEx);
3884 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3889 pull = ndr_pull_init_blob(&blob, r, NULL);
3895 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3896 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3897 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3902 if (DEBUGLEVEL >= 10) {
3903 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3906 ZERO_STRUCT(r->out);
3907 r->out.resume_handle = r->in.resume_handle;
3908 r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3909 if (r->out.domains == NULL) {
3914 r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3916 if (p->rng_fault_state) {
3918 /* Return true here, srv_pipe_hnd.c will take care */
3922 if (DEBUGLEVEL >= 10) {
3923 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3926 push = ndr_push_init_ctx(r, NULL);
3932 ndr_err = call->ndr_push(push, NDR_OUT, r);
3933 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3938 blob = ndr_push_blob(push);
3939 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3949 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
3951 const struct ndr_interface_call *call;
3952 struct ndr_pull *pull;
3953 struct ndr_push *push;
3954 enum ndr_err_code ndr_err;
3956 struct lsa_CreateTrustedDomainEx *r;
3958 call = &p->interface->calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3960 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx);
3965 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3970 pull = ndr_pull_init_blob(&blob, r, NULL);
3976 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3977 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3978 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3983 if (DEBUGLEVEL >= 10) {
3984 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3987 ZERO_STRUCT(r->out);
3988 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
3989 if (r->out.trustdom_handle == NULL) {
3994 r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3996 if (p->rng_fault_state) {
3998 /* Return true here, srv_pipe_hnd.c will take care */
4002 if (DEBUGLEVEL >= 10) {
4003 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
4006 push = ndr_push_init_ctx(r, NULL);
4012 ndr_err = call->ndr_push(push, NDR_OUT, r);
4013 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4018 blob = ndr_push_blob(push);
4019 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4029 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
4031 const struct ndr_interface_call *call;
4032 struct ndr_pull *pull;
4033 struct ndr_push *push;
4034 enum ndr_err_code ndr_err;
4036 struct lsa_CloseTrustedDomainEx *r;
4038 call = &p->interface->calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
4040 r = talloc(talloc_tos(), struct lsa_CloseTrustedDomainEx);
4045 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4050 pull = ndr_pull_init_blob(&blob, r, NULL);
4056 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4057 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4058 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4063 if (DEBUGLEVEL >= 10) {
4064 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
4067 ZERO_STRUCT(r->out);
4068 r->out.handle = r->in.handle;
4069 r->out.result = _lsa_CloseTrustedDomainEx(p, r);
4071 if (p->rng_fault_state) {
4073 /* Return true here, srv_pipe_hnd.c will take care */
4077 if (DEBUGLEVEL >= 10) {
4078 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
4081 push = ndr_push_init_ctx(r, NULL);
4087 ndr_err = call->ndr_push(push, NDR_OUT, r);
4088 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4093 blob = ndr_push_blob(push);
4094 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4104 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
4106 const struct ndr_interface_call *call;
4107 struct ndr_pull *pull;
4108 struct ndr_push *push;
4109 enum ndr_err_code ndr_err;
4111 struct lsa_QueryDomainInformationPolicy *r;
4113 call = &p->interface->calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
4115 r = talloc(talloc_tos(), struct lsa_QueryDomainInformationPolicy);
4120 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4125 pull = ndr_pull_init_blob(&blob, r, NULL);
4131 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4132 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4133 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4138 if (DEBUGLEVEL >= 10) {
4139 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4142 ZERO_STRUCT(r->out);
4143 r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy *);
4144 if (r->out.info == NULL) {
4149 r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4151 if (p->rng_fault_state) {
4153 /* Return true here, srv_pipe_hnd.c will take care */
4157 if (DEBUGLEVEL >= 10) {
4158 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4161 push = ndr_push_init_ctx(r, NULL);
4167 ndr_err = call->ndr_push(push, NDR_OUT, r);
4168 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4173 blob = ndr_push_blob(push);
4174 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4184 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
4186 const struct ndr_interface_call *call;
4187 struct ndr_pull *pull;
4188 struct ndr_push *push;
4189 enum ndr_err_code ndr_err;
4191 struct lsa_SetDomainInformationPolicy *r;
4193 call = &p->interface->calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4195 r = talloc(talloc_tos(), struct lsa_SetDomainInformationPolicy);
4200 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4205 pull = ndr_pull_init_blob(&blob, r, NULL);
4211 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4212 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4213 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4218 if (DEBUGLEVEL >= 10) {
4219 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4222 r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4224 if (p->rng_fault_state) {
4226 /* Return true here, srv_pipe_hnd.c will take care */
4230 if (DEBUGLEVEL >= 10) {
4231 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4234 push = ndr_push_init_ctx(r, NULL);
4240 ndr_err = call->ndr_push(push, NDR_OUT, r);
4241 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4246 blob = ndr_push_blob(push);
4247 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4257 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
4259 const struct ndr_interface_call *call;
4260 struct ndr_pull *pull;
4261 struct ndr_push *push;
4262 enum ndr_err_code ndr_err;
4264 struct lsa_OpenTrustedDomainByName *r;
4266 call = &p->interface->calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4268 r = talloc(talloc_tos(), struct lsa_OpenTrustedDomainByName);
4273 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4278 pull = ndr_pull_init_blob(&blob, r, NULL);
4284 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4285 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4286 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4291 if (DEBUGLEVEL >= 10) {
4292 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4295 ZERO_STRUCT(r->out);
4296 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4297 if (r->out.trustdom_handle == NULL) {
4302 r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4304 if (p->rng_fault_state) {
4306 /* Return true here, srv_pipe_hnd.c will take care */
4310 if (DEBUGLEVEL >= 10) {
4311 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4314 push = ndr_push_init_ctx(r, NULL);
4320 ndr_err = call->ndr_push(push, NDR_OUT, r);
4321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4326 blob = ndr_push_blob(push);
4327 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4337 static bool api_lsa_TestCall(pipes_struct *p)
4339 const struct ndr_interface_call *call;
4340 struct ndr_pull *pull;
4341 struct ndr_push *push;
4342 enum ndr_err_code ndr_err;
4344 struct lsa_TestCall *r;
4346 call = &p->interface->calls[NDR_LSA_TESTCALL];
4348 r = talloc(talloc_tos(), struct lsa_TestCall);
4353 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4358 pull = ndr_pull_init_blob(&blob, r, NULL);
4364 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4365 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4366 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4371 if (DEBUGLEVEL >= 10) {
4372 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4375 r->out.result = _lsa_TestCall(p, r);
4377 if (p->rng_fault_state) {
4379 /* Return true here, srv_pipe_hnd.c will take care */
4383 if (DEBUGLEVEL >= 10) {
4384 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4387 push = ndr_push_init_ctx(r, NULL);
4393 ndr_err = call->ndr_push(push, NDR_OUT, r);
4394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4399 blob = ndr_push_blob(push);
4400 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4410 static bool api_lsa_LookupSids2(pipes_struct *p)
4412 const struct ndr_interface_call *call;
4413 struct ndr_pull *pull;
4414 struct ndr_push *push;
4415 enum ndr_err_code ndr_err;
4417 struct lsa_LookupSids2 *r;
4419 call = &p->interface->calls[NDR_LSA_LOOKUPSIDS2];
4421 r = talloc(talloc_tos(), struct lsa_LookupSids2);
4426 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4431 pull = ndr_pull_init_blob(&blob, r, NULL);
4437 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4438 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4439 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4444 if (DEBUGLEVEL >= 10) {
4445 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4448 ZERO_STRUCT(r->out);
4449 r->out.names = r->in.names;
4450 r->out.count = r->in.count;
4451 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4452 if (r->out.domains == NULL) {
4457 r->out.result = _lsa_LookupSids2(p, r);
4459 if (p->rng_fault_state) {
4461 /* Return true here, srv_pipe_hnd.c will take care */
4465 if (DEBUGLEVEL >= 10) {
4466 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4469 push = ndr_push_init_ctx(r, NULL);
4475 ndr_err = call->ndr_push(push, NDR_OUT, r);
4476 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4481 blob = ndr_push_blob(push);
4482 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4492 static bool api_lsa_LookupNames2(pipes_struct *p)
4494 const struct ndr_interface_call *call;
4495 struct ndr_pull *pull;
4496 struct ndr_push *push;
4497 enum ndr_err_code ndr_err;
4499 struct lsa_LookupNames2 *r;
4501 call = &p->interface->calls[NDR_LSA_LOOKUPNAMES2];
4503 r = talloc(talloc_tos(), struct lsa_LookupNames2);
4508 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4513 pull = ndr_pull_init_blob(&blob, r, NULL);
4519 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4520 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4521 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4526 if (DEBUGLEVEL >= 10) {
4527 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4530 ZERO_STRUCT(r->out);
4531 r->out.sids = r->in.sids;
4532 r->out.count = r->in.count;
4533 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
4534 if (r->out.domains == NULL) {
4539 r->out.result = _lsa_LookupNames2(p, r);
4541 if (p->rng_fault_state) {
4543 /* Return true here, srv_pipe_hnd.c will take care */
4547 if (DEBUGLEVEL >= 10) {
4548 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4551 push = ndr_push_init_ctx(r, NULL);
4557 ndr_err = call->ndr_push(push, NDR_OUT, r);
4558 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4563 blob = ndr_push_blob(push);
4564 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4574 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
4576 const struct ndr_interface_call *call;
4577 struct ndr_pull *pull;
4578 struct ndr_push *push;
4579 enum ndr_err_code ndr_err;
4581 struct lsa_CreateTrustedDomainEx2 *r;
4583 call = &p->interface->calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4585 r = talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx2);
4590 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4595 pull = ndr_pull_init_blob(&blob, r, NULL);
4601 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4602 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4603 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4608 if (DEBUGLEVEL >= 10) {
4609 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4612 ZERO_STRUCT(r->out);
4613 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4614 if (r->out.trustdom_handle == NULL) {
4619 r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4621 if (p->rng_fault_state) {
4623 /* Return true here, srv_pipe_hnd.c will take care */
4627 if (DEBUGLEVEL >= 10) {
4628 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4631 push = ndr_push_init_ctx(r, NULL);
4637 ndr_err = call->ndr_push(push, NDR_OUT, r);
4638 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4643 blob = ndr_push_blob(push);
4644 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4654 static bool api_lsa_CREDRWRITE(pipes_struct *p)
4656 const struct ndr_interface_call *call;
4657 struct ndr_pull *pull;
4658 struct ndr_push *push;
4659 enum ndr_err_code ndr_err;
4661 struct lsa_CREDRWRITE *r;
4663 call = &p->interface->calls[NDR_LSA_CREDRWRITE];
4665 r = talloc(talloc_tos(), struct lsa_CREDRWRITE);
4670 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4675 pull = ndr_pull_init_blob(&blob, r, NULL);
4681 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4682 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4683 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4688 if (DEBUGLEVEL >= 10) {
4689 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4692 r->out.result = _lsa_CREDRWRITE(p, r);
4694 if (p->rng_fault_state) {
4696 /* Return true here, srv_pipe_hnd.c will take care */
4700 if (DEBUGLEVEL >= 10) {
4701 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4704 push = ndr_push_init_ctx(r, NULL);
4710 ndr_err = call->ndr_push(push, NDR_OUT, r);
4711 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4716 blob = ndr_push_blob(push);
4717 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4727 static bool api_lsa_CREDRREAD(pipes_struct *p)
4729 const struct ndr_interface_call *call;
4730 struct ndr_pull *pull;
4731 struct ndr_push *push;
4732 enum ndr_err_code ndr_err;
4734 struct lsa_CREDRREAD *r;
4736 call = &p->interface->calls[NDR_LSA_CREDRREAD];
4738 r = talloc(talloc_tos(), struct lsa_CREDRREAD);
4743 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4748 pull = ndr_pull_init_blob(&blob, r, NULL);
4754 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4755 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4756 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4761 if (DEBUGLEVEL >= 10) {
4762 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4765 r->out.result = _lsa_CREDRREAD(p, r);
4767 if (p->rng_fault_state) {
4769 /* Return true here, srv_pipe_hnd.c will take care */
4773 if (DEBUGLEVEL >= 10) {
4774 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4777 push = ndr_push_init_ctx(r, NULL);
4783 ndr_err = call->ndr_push(push, NDR_OUT, r);
4784 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4789 blob = ndr_push_blob(push);
4790 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4800 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
4802 const struct ndr_interface_call *call;
4803 struct ndr_pull *pull;
4804 struct ndr_push *push;
4805 enum ndr_err_code ndr_err;
4807 struct lsa_CREDRENUMERATE *r;
4809 call = &p->interface->calls[NDR_LSA_CREDRENUMERATE];
4811 r = talloc(talloc_tos(), struct lsa_CREDRENUMERATE);
4816 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4821 pull = ndr_pull_init_blob(&blob, r, NULL);
4827 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4828 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4829 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4834 if (DEBUGLEVEL >= 10) {
4835 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4838 r->out.result = _lsa_CREDRENUMERATE(p, r);
4840 if (p->rng_fault_state) {
4842 /* Return true here, srv_pipe_hnd.c will take care */
4846 if (DEBUGLEVEL >= 10) {
4847 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4850 push = ndr_push_init_ctx(r, NULL);
4856 ndr_err = call->ndr_push(push, NDR_OUT, r);
4857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4862 blob = ndr_push_blob(push);
4863 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4873 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
4875 const struct ndr_interface_call *call;
4876 struct ndr_pull *pull;
4877 struct ndr_push *push;
4878 enum ndr_err_code ndr_err;
4880 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4882 call = &p->interface->calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4884 r = talloc(talloc_tos(), struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4889 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4894 pull = ndr_pull_init_blob(&blob, r, NULL);
4900 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4901 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4902 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4907 if (DEBUGLEVEL >= 10) {
4908 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4911 r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4913 if (p->rng_fault_state) {
4915 /* Return true here, srv_pipe_hnd.c will take care */
4919 if (DEBUGLEVEL >= 10) {
4920 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4923 push = ndr_push_init_ctx(r, NULL);
4929 ndr_err = call->ndr_push(push, NDR_OUT, r);
4930 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4935 blob = ndr_push_blob(push);
4936 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4946 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
4948 const struct ndr_interface_call *call;
4949 struct ndr_pull *pull;
4950 struct ndr_push *push;
4951 enum ndr_err_code ndr_err;
4953 struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4955 call = &p->interface->calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4957 r = talloc(talloc_tos(), struct lsa_CREDRREADDOMAINCREDENTIALS);
4962 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4967 pull = ndr_pull_init_blob(&blob, r, NULL);
4973 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4974 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4975 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4980 if (DEBUGLEVEL >= 10) {
4981 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4984 r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4986 if (p->rng_fault_state) {
4988 /* Return true here, srv_pipe_hnd.c will take care */
4992 if (DEBUGLEVEL >= 10) {
4993 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4996 push = ndr_push_init_ctx(r, NULL);
5002 ndr_err = call->ndr_push(push, NDR_OUT, r);
5003 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5008 blob = ndr_push_blob(push);
5009 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5019 static bool api_lsa_CREDRDELETE(pipes_struct *p)
5021 const struct ndr_interface_call *call;
5022 struct ndr_pull *pull;
5023 struct ndr_push *push;
5024 enum ndr_err_code ndr_err;
5026 struct lsa_CREDRDELETE *r;
5028 call = &p->interface->calls[NDR_LSA_CREDRDELETE];
5030 r = talloc(talloc_tos(), struct lsa_CREDRDELETE);
5035 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5040 pull = ndr_pull_init_blob(&blob, r, NULL);
5046 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5047 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5048 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5053 if (DEBUGLEVEL >= 10) {
5054 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
5057 r->out.result = _lsa_CREDRDELETE(p, r);
5059 if (p->rng_fault_state) {
5061 /* Return true here, srv_pipe_hnd.c will take care */
5065 if (DEBUGLEVEL >= 10) {
5066 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
5069 push = ndr_push_init_ctx(r, NULL);
5075 ndr_err = call->ndr_push(push, NDR_OUT, r);
5076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5081 blob = ndr_push_blob(push);
5082 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5092 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
5094 const struct ndr_interface_call *call;
5095 struct ndr_pull *pull;
5096 struct ndr_push *push;
5097 enum ndr_err_code ndr_err;
5099 struct lsa_CREDRGETTARGETINFO *r;
5101 call = &p->interface->calls[NDR_LSA_CREDRGETTARGETINFO];
5103 r = talloc(talloc_tos(), struct lsa_CREDRGETTARGETINFO);
5108 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5113 pull = ndr_pull_init_blob(&blob, r, NULL);
5119 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5120 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5126 if (DEBUGLEVEL >= 10) {
5127 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
5130 r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
5132 if (p->rng_fault_state) {
5134 /* Return true here, srv_pipe_hnd.c will take care */
5138 if (DEBUGLEVEL >= 10) {
5139 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
5142 push = ndr_push_init_ctx(r, NULL);
5148 ndr_err = call->ndr_push(push, NDR_OUT, r);
5149 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5154 blob = ndr_push_blob(push);
5155 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5165 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
5167 const struct ndr_interface_call *call;
5168 struct ndr_pull *pull;
5169 struct ndr_push *push;
5170 enum ndr_err_code ndr_err;
5172 struct lsa_CREDRPROFILELOADED *r;
5174 call = &p->interface->calls[NDR_LSA_CREDRPROFILELOADED];
5176 r = talloc(talloc_tos(), struct lsa_CREDRPROFILELOADED);
5181 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5186 pull = ndr_pull_init_blob(&blob, r, NULL);
5192 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5193 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5194 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5199 if (DEBUGLEVEL >= 10) {
5200 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5203 r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5205 if (p->rng_fault_state) {
5207 /* Return true here, srv_pipe_hnd.c will take care */
5211 if (DEBUGLEVEL >= 10) {
5212 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5215 push = ndr_push_init_ctx(r, NULL);
5221 ndr_err = call->ndr_push(push, NDR_OUT, r);
5222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5227 blob = ndr_push_blob(push);
5228 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5238 static bool api_lsa_LookupNames3(pipes_struct *p)
5240 const struct ndr_interface_call *call;
5241 struct ndr_pull *pull;
5242 struct ndr_push *push;
5243 enum ndr_err_code ndr_err;
5245 struct lsa_LookupNames3 *r;
5247 call = &p->interface->calls[NDR_LSA_LOOKUPNAMES3];
5249 r = talloc(talloc_tos(), struct lsa_LookupNames3);
5254 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5259 pull = ndr_pull_init_blob(&blob, r, NULL);
5265 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5266 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5267 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5272 if (DEBUGLEVEL >= 10) {
5273 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5276 ZERO_STRUCT(r->out);
5277 r->out.sids = r->in.sids;
5278 r->out.count = r->in.count;
5279 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5280 if (r->out.domains == NULL) {
5285 r->out.result = _lsa_LookupNames3(p, r);
5287 if (p->rng_fault_state) {
5289 /* Return true here, srv_pipe_hnd.c will take care */
5293 if (DEBUGLEVEL >= 10) {
5294 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5297 push = ndr_push_init_ctx(r, NULL);
5303 ndr_err = call->ndr_push(push, NDR_OUT, r);
5304 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5309 blob = ndr_push_blob(push);
5310 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5320 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
5322 const struct ndr_interface_call *call;
5323 struct ndr_pull *pull;
5324 struct ndr_push *push;
5325 enum ndr_err_code ndr_err;
5327 struct lsa_CREDRGETSESSIONTYPES *r;
5329 call = &p->interface->calls[NDR_LSA_CREDRGETSESSIONTYPES];
5331 r = talloc(talloc_tos(), struct lsa_CREDRGETSESSIONTYPES);
5336 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5341 pull = ndr_pull_init_blob(&blob, r, NULL);
5347 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5348 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5349 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5354 if (DEBUGLEVEL >= 10) {
5355 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5358 r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5360 if (p->rng_fault_state) {
5362 /* Return true here, srv_pipe_hnd.c will take care */
5366 if (DEBUGLEVEL >= 10) {
5367 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5370 push = ndr_push_init_ctx(r, NULL);
5376 ndr_err = call->ndr_push(push, NDR_OUT, r);
5377 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5382 blob = ndr_push_blob(push);
5383 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5393 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
5395 const struct ndr_interface_call *call;
5396 struct ndr_pull *pull;
5397 struct ndr_push *push;
5398 enum ndr_err_code ndr_err;
5400 struct lsa_LSARREGISTERAUDITEVENT *r;
5402 call = &p->interface->calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5404 r = talloc(talloc_tos(), struct lsa_LSARREGISTERAUDITEVENT);
5409 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5414 pull = ndr_pull_init_blob(&blob, r, NULL);
5420 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5421 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5422 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5427 if (DEBUGLEVEL >= 10) {
5428 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5431 r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5433 if (p->rng_fault_state) {
5435 /* Return true here, srv_pipe_hnd.c will take care */
5439 if (DEBUGLEVEL >= 10) {
5440 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5443 push = ndr_push_init_ctx(r, NULL);
5449 ndr_err = call->ndr_push(push, NDR_OUT, r);
5450 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5455 blob = ndr_push_blob(push);
5456 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5466 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
5468 const struct ndr_interface_call *call;
5469 struct ndr_pull *pull;
5470 struct ndr_push *push;
5471 enum ndr_err_code ndr_err;
5473 struct lsa_LSARGENAUDITEVENT *r;
5475 call = &p->interface->calls[NDR_LSA_LSARGENAUDITEVENT];
5477 r = talloc(talloc_tos(), struct lsa_LSARGENAUDITEVENT);
5482 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5487 pull = ndr_pull_init_blob(&blob, r, NULL);
5493 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5494 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5495 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5500 if (DEBUGLEVEL >= 10) {
5501 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5504 r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5506 if (p->rng_fault_state) {
5508 /* Return true here, srv_pipe_hnd.c will take care */
5512 if (DEBUGLEVEL >= 10) {
5513 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5516 push = ndr_push_init_ctx(r, NULL);
5522 ndr_err = call->ndr_push(push, NDR_OUT, r);
5523 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5528 blob = ndr_push_blob(push);
5529 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5539 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
5541 const struct ndr_interface_call *call;
5542 struct ndr_pull *pull;
5543 struct ndr_push *push;
5544 enum ndr_err_code ndr_err;
5546 struct lsa_LSARUNREGISTERAUDITEVENT *r;
5548 call = &p->interface->calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5550 r = talloc(talloc_tos(), struct lsa_LSARUNREGISTERAUDITEVENT);
5555 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5560 pull = ndr_pull_init_blob(&blob, r, NULL);
5566 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5567 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5568 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5573 if (DEBUGLEVEL >= 10) {
5574 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5577 r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5579 if (p->rng_fault_state) {
5581 /* Return true here, srv_pipe_hnd.c will take care */
5585 if (DEBUGLEVEL >= 10) {
5586 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5589 push = ndr_push_init_ctx(r, NULL);
5595 ndr_err = call->ndr_push(push, NDR_OUT, r);
5596 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5601 blob = ndr_push_blob(push);
5602 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5612 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct *p)
5614 const struct ndr_interface_call *call;
5615 struct ndr_pull *pull;
5616 struct ndr_push *push;
5617 enum ndr_err_code ndr_err;
5619 struct lsa_lsaRQueryForestTrustInformation *r;
5621 call = &p->interface->calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5623 r = talloc(talloc_tos(), struct lsa_lsaRQueryForestTrustInformation);
5628 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5633 pull = ndr_pull_init_blob(&blob, r, NULL);
5639 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5640 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5641 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5646 if (DEBUGLEVEL >= 10) {
5647 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5650 ZERO_STRUCT(r->out);
5651 r->out.forest_trust_info = talloc_zero(r, struct lsa_ForestTrustInformation *);
5652 if (r->out.forest_trust_info == NULL) {
5657 r->out.result = _lsa_lsaRQueryForestTrustInformation(p, r);
5659 if (p->rng_fault_state) {
5661 /* Return true here, srv_pipe_hnd.c will take care */
5665 if (DEBUGLEVEL >= 10) {
5666 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation, r);
5669 push = ndr_push_init_ctx(r, NULL);
5675 ndr_err = call->ndr_push(push, NDR_OUT, r);
5676 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5681 blob = ndr_push_blob(push);
5682 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5692 static bool api_lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
5694 const struct ndr_interface_call *call;
5695 struct ndr_pull *pull;
5696 struct ndr_push *push;
5697 enum ndr_err_code ndr_err;
5699 struct lsa_LSARSETFORESTTRUSTINFORMATION *r;
5701 call = &p->interface->calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5703 r = talloc(talloc_tos(), struct lsa_LSARSETFORESTTRUSTINFORMATION);
5708 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5713 pull = ndr_pull_init_blob(&blob, r, NULL);
5719 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5720 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5721 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5726 if (DEBUGLEVEL >= 10) {
5727 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5730 r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, r);
5732 if (p->rng_fault_state) {
5734 /* Return true here, srv_pipe_hnd.c will take care */
5738 if (DEBUGLEVEL >= 10) {
5739 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5742 push = ndr_push_init_ctx(r, NULL);
5748 ndr_err = call->ndr_push(push, NDR_OUT, r);
5749 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5754 blob = ndr_push_blob(push);
5755 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5765 static bool api_lsa_CREDRRENAME(pipes_struct *p)
5767 const struct ndr_interface_call *call;
5768 struct ndr_pull *pull;
5769 struct ndr_push *push;
5770 enum ndr_err_code ndr_err;
5772 struct lsa_CREDRRENAME *r;
5774 call = &p->interface->calls[NDR_LSA_CREDRRENAME];
5776 r = talloc(talloc_tos(), struct lsa_CREDRRENAME);
5781 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5786 pull = ndr_pull_init_blob(&blob, r, NULL);
5792 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5793 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5794 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5799 if (DEBUGLEVEL >= 10) {
5800 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5803 r->out.result = _lsa_CREDRRENAME(p, r);
5805 if (p->rng_fault_state) {
5807 /* Return true here, srv_pipe_hnd.c will take care */
5811 if (DEBUGLEVEL >= 10) {
5812 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5815 push = ndr_push_init_ctx(r, NULL);
5821 ndr_err = call->ndr_push(push, NDR_OUT, r);
5822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5827 blob = ndr_push_blob(push);
5828 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5838 static bool api_lsa_LookupSids3(pipes_struct *p)
5840 const struct ndr_interface_call *call;
5841 struct ndr_pull *pull;
5842 struct ndr_push *push;
5843 enum ndr_err_code ndr_err;
5845 struct lsa_LookupSids3 *r;
5847 call = &p->interface->calls[NDR_LSA_LOOKUPSIDS3];
5849 r = talloc(talloc_tos(), struct lsa_LookupSids3);
5854 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5859 pull = ndr_pull_init_blob(&blob, r, NULL);
5865 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5866 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5867 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5872 if (DEBUGLEVEL >= 10) {
5873 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5876 ZERO_STRUCT(r->out);
5877 r->out.names = r->in.names;
5878 r->out.count = r->in.count;
5879 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5880 if (r->out.domains == NULL) {
5885 r->out.result = _lsa_LookupSids3(p, r);
5887 if (p->rng_fault_state) {
5889 /* Return true here, srv_pipe_hnd.c will take care */
5893 if (DEBUGLEVEL >= 10) {
5894 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5897 push = ndr_push_init_ctx(r, NULL);
5903 ndr_err = call->ndr_push(push, NDR_OUT, r);
5904 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5909 blob = ndr_push_blob(push);
5910 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
5920 static bool api_lsa_LookupNames4(pipes_struct *p)
5922 const struct ndr_interface_call *call;
5923 struct ndr_pull *pull;
5924 struct ndr_push *push;
5925 enum ndr_err_code ndr_err;
5927 struct lsa_LookupNames4 *r;
5929 call = &p->interface->calls[NDR_LSA_LOOKUPNAMES4];
5931 r = talloc(talloc_tos(), struct lsa_LookupNames4);
5936 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5941 pull = ndr_pull_init_blob(&blob, r, NULL);
5947 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5948 ndr_err = call->ndr_pull(pull, NDR_IN, r);
5949 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5954 if (DEBUGLEVEL >= 10) {
5955 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5958 ZERO_STRUCT(r->out);
5959 r->out.sids = r->in.sids;
5960 r->out.count = r->in.count;
5961 r->out.domains = talloc_zero(r, struct lsa_RefDomainList *);
5962 if (r->out.domains == NULL) {
5967 r->out.result = _lsa_LookupNames4(p, r);
5969 if (p->rng_fault_state) {
5971 /* Return true here, srv_pipe_hnd.c will take care */
5975 if (DEBUGLEVEL >= 10) {
5976 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5979 push = ndr_push_init_ctx(r, NULL);
5985 ndr_err = call->ndr_push(push, NDR_OUT, r);
5986 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
5991 blob = ndr_push_blob(push);
5992 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6002 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
6004 const struct ndr_interface_call *call;
6005 struct ndr_pull *pull;
6006 struct ndr_push *push;
6007 enum ndr_err_code ndr_err;
6009 struct lsa_LSAROPENPOLICYSCE *r;
6011 call = &p->interface->calls[NDR_LSA_LSAROPENPOLICYSCE];
6013 r = talloc(talloc_tos(), struct lsa_LSAROPENPOLICYSCE);
6018 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6023 pull = ndr_pull_init_blob(&blob, r, NULL);
6029 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6030 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6031 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6036 if (DEBUGLEVEL >= 10) {
6037 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6040 r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
6042 if (p->rng_fault_state) {
6044 /* Return true here, srv_pipe_hnd.c will take care */
6048 if (DEBUGLEVEL >= 10) {
6049 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
6052 push = ndr_push_init_ctx(r, NULL);
6058 ndr_err = call->ndr_push(push, NDR_OUT, r);
6059 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6064 blob = ndr_push_blob(push);
6065 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6075 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6077 const struct ndr_interface_call *call;
6078 struct ndr_pull *pull;
6079 struct ndr_push *push;
6080 enum ndr_err_code ndr_err;
6082 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
6084 call = &p->interface->calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
6086 r = talloc(talloc_tos(), struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
6091 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6096 pull = ndr_pull_init_blob(&blob, r, NULL);
6102 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6103 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6104 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6109 if (DEBUGLEVEL >= 10) {
6110 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6113 r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
6115 if (p->rng_fault_state) {
6117 /* Return true here, srv_pipe_hnd.c will take care */
6121 if (DEBUGLEVEL >= 10) {
6122 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
6125 push = ndr_push_init_ctx(r, NULL);
6131 ndr_err = call->ndr_push(push, NDR_OUT, r);
6132 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6137 blob = ndr_push_blob(push);
6138 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6148 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
6150 const struct ndr_interface_call *call;
6151 struct ndr_pull *pull;
6152 struct ndr_push *push;
6153 enum ndr_err_code ndr_err;
6155 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
6157 call = &p->interface->calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
6159 r = talloc(talloc_tos(), struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
6164 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6169 pull = ndr_pull_init_blob(&blob, r, NULL);
6175 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6176 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6177 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6182 if (DEBUGLEVEL >= 10) {
6183 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6186 r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
6188 if (p->rng_fault_state) {
6190 /* Return true here, srv_pipe_hnd.c will take care */
6194 if (DEBUGLEVEL >= 10) {
6195 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
6198 push = ndr_push_init_ctx(r, NULL);
6204 ndr_err = call->ndr_push(push, NDR_OUT, r);
6205 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6210 blob = ndr_push_blob(push);
6211 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6221 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
6223 const struct ndr_interface_call *call;
6224 struct ndr_pull *pull;
6225 struct ndr_push *push;
6226 enum ndr_err_code ndr_err;
6228 struct lsa_LSARADTREPORTSECURITYEVENT *r;
6230 call = &p->interface->calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6232 r = talloc(talloc_tos(), struct lsa_LSARADTREPORTSECURITYEVENT);
6237 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6242 pull = ndr_pull_init_blob(&blob, r, NULL);
6248 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6249 ndr_err = call->ndr_pull(pull, NDR_IN, r);
6250 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6255 if (DEBUGLEVEL >= 10) {
6256 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6259 r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6261 if (p->rng_fault_state) {
6263 /* Return true here, srv_pipe_hnd.c will take care */
6267 if (DEBUGLEVEL >= 10) {
6268 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6271 push = ndr_push_init_ctx(r, NULL);
6277 ndr_err = call->ndr_push(push, NDR_OUT, r);
6278 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
6283 blob = ndr_push_blob(push);
6284 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
6296 static struct api_struct api_lsarpc_cmds[] =
6298 {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6299 {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6300 {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6301 {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6302 {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6303 {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6304 {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6305 {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6306 {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6307 {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6308 {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6309 {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6310 {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6311 {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6312 {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6313 {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6314 {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6315 {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6316 {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6317 {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6318 {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6319 {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6320 {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6321 {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6322 {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6323 {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6324 {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6325 {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6326 {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6327 {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6328 {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6329 {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6330 {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6331 {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6332 {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6333 {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6334 {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6335 {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6336 {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6337 {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6338 {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6339 {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6340 {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6341 {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6342 {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6343 {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6344 {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6345 {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6346 {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6347 {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6348 {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6349 {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6350 {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6351 {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6352 {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6353 {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6354 {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6355 {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6356 {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6357 {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6358 {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6359 {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6360 {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6361 {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6362 {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6363 {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6364 {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6365 {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6366 {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6367 {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6368 {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6369 {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6370 {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6371 {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_lsaRQueryForestTrustInformation},
6372 {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_LSARSETFORESTTRUSTINFORMATION},
6373 {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6374 {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6375 {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6376 {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6377 {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6378 {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6379 {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6382 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
6384 *fns = api_lsarpc_cmds;
6385 *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6388 NTSTATUS rpc_lsarpc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *interface, uint32_t interface_version, uint32_t opnum, void *_r)
6390 if (cli->pipes_struct == NULL) {
6391 return NT_STATUS_INVALID_PARAMETER;
6396 case NDR_LSA_CLOSE: {
6397 struct lsa_Close *r = (struct lsa_Close *)_r;
6398 ZERO_STRUCT(r->out);
6399 r->out.handle = r->in.handle;
6400 r->out.result = _lsa_Close(cli->pipes_struct, r);
6401 return NT_STATUS_OK;
6404 case NDR_LSA_DELETE: {
6405 struct lsa_Delete *r = (struct lsa_Delete *)_r;
6406 r->out.result = _lsa_Delete(cli->pipes_struct, r);
6407 return NT_STATUS_OK;
6410 case NDR_LSA_ENUMPRIVS: {
6411 struct lsa_EnumPrivs *r = (struct lsa_EnumPrivs *)_r;
6412 ZERO_STRUCT(r->out);
6413 r->out.resume_handle = r->in.resume_handle;
6414 r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivArray);
6415 if (r->out.privs == NULL) {
6416 return NT_STATUS_NO_MEMORY;
6419 r->out.result = _lsa_EnumPrivs(cli->pipes_struct, r);
6420 return NT_STATUS_OK;
6423 case NDR_LSA_QUERYSECURITY: {
6424 struct lsa_QuerySecurity *r = (struct lsa_QuerySecurity *)_r;
6425 ZERO_STRUCT(r->out);
6426 r->out.sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf *);
6427 if (r->out.sdbuf == NULL) {
6428 return NT_STATUS_NO_MEMORY;
6431 r->out.result = _lsa_QuerySecurity(cli->pipes_struct, r);
6432 return NT_STATUS_OK;
6435 case NDR_LSA_SETSECOBJ: {
6436 struct lsa_SetSecObj *r = (struct lsa_SetSecObj *)_r;
6437 r->out.result = _lsa_SetSecObj(cli->pipes_struct, r);
6438 return NT_STATUS_OK;
6441 case NDR_LSA_CHANGEPASSWORD: {
6442 struct lsa_ChangePassword *r = (struct lsa_ChangePassword *)_r;
6443 r->out.result = _lsa_ChangePassword(cli->pipes_struct, r);
6444 return NT_STATUS_OK;
6447 case NDR_LSA_OPENPOLICY: {
6448 struct lsa_OpenPolicy *r = (struct lsa_OpenPolicy *)_r;
6449 ZERO_STRUCT(r->out);
6450 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6451 if (r->out.handle == NULL) {
6452 return NT_STATUS_NO_MEMORY;
6455 r->out.result = _lsa_OpenPolicy(cli->pipes_struct, r);
6456 return NT_STATUS_OK;
6459 case NDR_LSA_QUERYINFOPOLICY: {
6460 struct lsa_QueryInfoPolicy *r = (struct lsa_QueryInfoPolicy *)_r;
6461 ZERO_STRUCT(r->out);
6462 r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6463 if (r->out.info == NULL) {
6464 return NT_STATUS_NO_MEMORY;
6467 r->out.result = _lsa_QueryInfoPolicy(cli->pipes_struct, r);
6468 return NT_STATUS_OK;
6471 case NDR_LSA_SETINFOPOLICY: {
6472 struct lsa_SetInfoPolicy *r = (struct lsa_SetInfoPolicy *)_r;
6473 r->out.result = _lsa_SetInfoPolicy(cli->pipes_struct, r);
6474 return NT_STATUS_OK;
6477 case NDR_LSA_CLEARAUDITLOG: {
6478 struct lsa_ClearAuditLog *r = (struct lsa_ClearAuditLog *)_r;
6479 r->out.result = _lsa_ClearAuditLog(cli->pipes_struct, r);
6480 return NT_STATUS_OK;
6483 case NDR_LSA_CREATEACCOUNT: {
6484 struct lsa_CreateAccount *r = (struct lsa_CreateAccount *)_r;
6485 ZERO_STRUCT(r->out);
6486 r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6487 if (r->out.acct_handle == NULL) {
6488 return NT_STATUS_NO_MEMORY;
6491 r->out.result = _lsa_CreateAccount(cli->pipes_struct, r);
6492 return NT_STATUS_OK;
6495 case NDR_LSA_ENUMACCOUNTS: {
6496 struct lsa_EnumAccounts *r = (struct lsa_EnumAccounts *)_r;
6497 ZERO_STRUCT(r->out);
6498 r->out.resume_handle = r->in.resume_handle;
6499 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6500 if (r->out.sids == NULL) {
6501 return NT_STATUS_NO_MEMORY;
6504 r->out.result = _lsa_EnumAccounts(cli->pipes_struct, r);
6505 return NT_STATUS_OK;
6508 case NDR_LSA_CREATETRUSTEDDOMAIN: {
6509 struct lsa_CreateTrustedDomain *r = (struct lsa_CreateTrustedDomain *)_r;
6510 ZERO_STRUCT(r->out);
6511 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6512 if (r->out.trustdom_handle == NULL) {
6513 return NT_STATUS_NO_MEMORY;
6516 r->out.result = _lsa_CreateTrustedDomain(cli->pipes_struct, r);
6517 return NT_STATUS_OK;
6520 case NDR_LSA_ENUMTRUSTDOM: {
6521 struct lsa_EnumTrustDom *r = (struct lsa_EnumTrustDom *)_r;
6522 ZERO_STRUCT(r->out);
6523 r->out.resume_handle = r->in.resume_handle;
6524 r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainList);
6525 if (r->out.domains == NULL) {
6526 return NT_STATUS_NO_MEMORY;
6529 r->out.result = _lsa_EnumTrustDom(cli->pipes_struct, r);
6530 return NT_STATUS_OK;
6533 case NDR_LSA_LOOKUPNAMES: {
6534 struct lsa_LookupNames *r = (struct lsa_LookupNames *)_r;
6535 ZERO_STRUCT(r->out);
6536 r->out.sids = r->in.sids;
6537 r->out.count = r->in.count;
6538 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6539 if (r->out.domains == NULL) {
6540 return NT_STATUS_NO_MEMORY;
6543 r->out.result = _lsa_LookupNames(cli->pipes_struct, r);
6544 return NT_STATUS_OK;
6547 case NDR_LSA_LOOKUPSIDS: {
6548 struct lsa_LookupSids *r = (struct lsa_LookupSids *)_r;
6549 ZERO_STRUCT(r->out);
6550 r->out.names = r->in.names;
6551 r->out.count = r->in.count;
6552 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6553 if (r->out.domains == NULL) {
6554 return NT_STATUS_NO_MEMORY;
6557 r->out.result = _lsa_LookupSids(cli->pipes_struct, r);
6558 return NT_STATUS_OK;
6561 case NDR_LSA_CREATESECRET: {
6562 struct lsa_CreateSecret *r = (struct lsa_CreateSecret *)_r;
6563 ZERO_STRUCT(r->out);
6564 r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6565 if (r->out.sec_handle == NULL) {
6566 return NT_STATUS_NO_MEMORY;
6569 r->out.result = _lsa_CreateSecret(cli->pipes_struct, r);
6570 return NT_STATUS_OK;
6573 case NDR_LSA_OPENACCOUNT: {
6574 struct lsa_OpenAccount *r = (struct lsa_OpenAccount *)_r;
6575 ZERO_STRUCT(r->out);
6576 r->out.acct_handle = talloc_zero(mem_ctx, struct policy_handle);
6577 if (r->out.acct_handle == NULL) {
6578 return NT_STATUS_NO_MEMORY;
6581 r->out.result = _lsa_OpenAccount(cli->pipes_struct, r);
6582 return NT_STATUS_OK;
6585 case NDR_LSA_ENUMPRIVSACCOUNT: {
6586 struct lsa_EnumPrivsAccount *r = (struct lsa_EnumPrivsAccount *)_r;
6587 ZERO_STRUCT(r->out);
6588 r->out.privs = talloc_zero(mem_ctx, struct lsa_PrivilegeSet *);
6589 if (r->out.privs == NULL) {
6590 return NT_STATUS_NO_MEMORY;
6593 r->out.result = _lsa_EnumPrivsAccount(cli->pipes_struct, r);
6594 return NT_STATUS_OK;
6597 case NDR_LSA_ADDPRIVILEGESTOACCOUNT: {
6598 struct lsa_AddPrivilegesToAccount *r = (struct lsa_AddPrivilegesToAccount *)_r;
6599 r->out.result = _lsa_AddPrivilegesToAccount(cli->pipes_struct, r);
6600 return NT_STATUS_OK;
6603 case NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT: {
6604 struct lsa_RemovePrivilegesFromAccount *r = (struct lsa_RemovePrivilegesFromAccount *)_r;
6605 r->out.result = _lsa_RemovePrivilegesFromAccount(cli->pipes_struct, r);
6606 return NT_STATUS_OK;
6609 case NDR_LSA_GETQUOTASFORACCOUNT: {
6610 struct lsa_GetQuotasForAccount *r = (struct lsa_GetQuotasForAccount *)_r;
6611 r->out.result = _lsa_GetQuotasForAccount(cli->pipes_struct, r);
6612 return NT_STATUS_OK;
6615 case NDR_LSA_SETQUOTASFORACCOUNT: {
6616 struct lsa_SetQuotasForAccount *r = (struct lsa_SetQuotasForAccount *)_r;
6617 r->out.result = _lsa_SetQuotasForAccount(cli->pipes_struct, r);
6618 return NT_STATUS_OK;
6621 case NDR_LSA_GETSYSTEMACCESSACCOUNT: {
6622 struct lsa_GetSystemAccessAccount *r = (struct lsa_GetSystemAccessAccount *)_r;
6623 ZERO_STRUCT(r->out);
6624 r->out.access_mask = talloc_zero(mem_ctx, uint32_t);
6625 if (r->out.access_mask == NULL) {
6626 return NT_STATUS_NO_MEMORY;
6629 r->out.result = _lsa_GetSystemAccessAccount(cli->pipes_struct, r);
6630 return NT_STATUS_OK;
6633 case NDR_LSA_SETSYSTEMACCESSACCOUNT: {
6634 struct lsa_SetSystemAccessAccount *r = (struct lsa_SetSystemAccessAccount *)_r;
6635 r->out.result = _lsa_SetSystemAccessAccount(cli->pipes_struct, r);
6636 return NT_STATUS_OK;
6639 case NDR_LSA_OPENTRUSTEDDOMAIN: {
6640 struct lsa_OpenTrustedDomain *r = (struct lsa_OpenTrustedDomain *)_r;
6641 ZERO_STRUCT(r->out);
6642 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6643 if (r->out.trustdom_handle == NULL) {
6644 return NT_STATUS_NO_MEMORY;
6647 r->out.result = _lsa_OpenTrustedDomain(cli->pipes_struct, r);
6648 return NT_STATUS_OK;
6651 case NDR_LSA_QUERYTRUSTEDDOMAININFO: {
6652 struct lsa_QueryTrustedDomainInfo *r = (struct lsa_QueryTrustedDomainInfo *)_r;
6653 ZERO_STRUCT(r->out);
6654 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6655 if (r->out.info == NULL) {
6656 return NT_STATUS_NO_MEMORY;
6659 r->out.result = _lsa_QueryTrustedDomainInfo(cli->pipes_struct, r);
6660 return NT_STATUS_OK;
6663 case NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN: {
6664 struct lsa_SetInformationTrustedDomain *r = (struct lsa_SetInformationTrustedDomain *)_r;
6665 r->out.result = _lsa_SetInformationTrustedDomain(cli->pipes_struct, r);
6666 return NT_STATUS_OK;
6669 case NDR_LSA_OPENSECRET: {
6670 struct lsa_OpenSecret *r = (struct lsa_OpenSecret *)_r;
6671 ZERO_STRUCT(r->out);
6672 r->out.sec_handle = talloc_zero(mem_ctx, struct policy_handle);
6673 if (r->out.sec_handle == NULL) {
6674 return NT_STATUS_NO_MEMORY;
6677 r->out.result = _lsa_OpenSecret(cli->pipes_struct, r);
6678 return NT_STATUS_OK;
6681 case NDR_LSA_SETSECRET: {
6682 struct lsa_SetSecret *r = (struct lsa_SetSecret *)_r;
6683 r->out.result = _lsa_SetSecret(cli->pipes_struct, r);
6684 return NT_STATUS_OK;
6687 case NDR_LSA_QUERYSECRET: {
6688 struct lsa_QuerySecret *r = (struct lsa_QuerySecret *)_r;
6689 ZERO_STRUCT(r->out);
6690 r->out.new_val = r->in.new_val;
6691 r->out.new_mtime = r->in.new_mtime;
6692 r->out.old_val = r->in.old_val;
6693 r->out.old_mtime = r->in.old_mtime;
6694 r->out.result = _lsa_QuerySecret(cli->pipes_struct, r);
6695 return NT_STATUS_OK;
6698 case NDR_LSA_LOOKUPPRIVVALUE: {
6699 struct lsa_LookupPrivValue *r = (struct lsa_LookupPrivValue *)_r;
6700 ZERO_STRUCT(r->out);
6701 r->out.luid = talloc_zero(mem_ctx, struct lsa_LUID);
6702 if (r->out.luid == NULL) {
6703 return NT_STATUS_NO_MEMORY;
6706 r->out.result = _lsa_LookupPrivValue(cli->pipes_struct, r);
6707 return NT_STATUS_OK;
6710 case NDR_LSA_LOOKUPPRIVNAME: {
6711 struct lsa_LookupPrivName *r = (struct lsa_LookupPrivName *)_r;
6712 ZERO_STRUCT(r->out);
6713 r->out.name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6714 if (r->out.name == NULL) {
6715 return NT_STATUS_NO_MEMORY;
6718 r->out.result = _lsa_LookupPrivName(cli->pipes_struct, r);
6719 return NT_STATUS_OK;
6722 case NDR_LSA_LOOKUPPRIVDISPLAYNAME: {
6723 struct lsa_LookupPrivDisplayName *r = (struct lsa_LookupPrivDisplayName *)_r;
6724 ZERO_STRUCT(r->out);
6725 r->out.disp_name = talloc_zero(mem_ctx, struct lsa_StringLarge *);
6726 if (r->out.disp_name == NULL) {
6727 return NT_STATUS_NO_MEMORY;
6730 r->out.returned_language_id = talloc_zero(mem_ctx, uint16_t);
6731 if (r->out.returned_language_id == NULL) {
6732 return NT_STATUS_NO_MEMORY;
6735 r->out.result = _lsa_LookupPrivDisplayName(cli->pipes_struct, r);
6736 return NT_STATUS_OK;
6739 case NDR_LSA_DELETEOBJECT: {
6740 struct lsa_DeleteObject *r = (struct lsa_DeleteObject *)_r;
6741 ZERO_STRUCT(r->out);
6742 r->out.handle = r->in.handle;
6743 r->out.result = _lsa_DeleteObject(cli->pipes_struct, r);
6744 return NT_STATUS_OK;
6747 case NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT: {
6748 struct lsa_EnumAccountsWithUserRight *r = (struct lsa_EnumAccountsWithUserRight *)_r;
6749 ZERO_STRUCT(r->out);
6750 r->out.sids = talloc_zero(mem_ctx, struct lsa_SidArray);
6751 if (r->out.sids == NULL) {
6752 return NT_STATUS_NO_MEMORY;
6755 r->out.result = _lsa_EnumAccountsWithUserRight(cli->pipes_struct, r);
6756 return NT_STATUS_OK;
6759 case NDR_LSA_ENUMACCOUNTRIGHTS: {
6760 struct lsa_EnumAccountRights *r = (struct lsa_EnumAccountRights *)_r;
6761 ZERO_STRUCT(r->out);
6762 r->out.rights = talloc_zero(mem_ctx, struct lsa_RightSet);
6763 if (r->out.rights == NULL) {
6764 return NT_STATUS_NO_MEMORY;
6767 r->out.result = _lsa_EnumAccountRights(cli->pipes_struct, r);
6768 return NT_STATUS_OK;
6771 case NDR_LSA_ADDACCOUNTRIGHTS: {
6772 struct lsa_AddAccountRights *r = (struct lsa_AddAccountRights *)_r;
6773 r->out.result = _lsa_AddAccountRights(cli->pipes_struct, r);
6774 return NT_STATUS_OK;
6777 case NDR_LSA_REMOVEACCOUNTRIGHTS: {
6778 struct lsa_RemoveAccountRights *r = (struct lsa_RemoveAccountRights *)_r;
6779 r->out.result = _lsa_RemoveAccountRights(cli->pipes_struct, r);
6780 return NT_STATUS_OK;
6783 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID: {
6784 struct lsa_QueryTrustedDomainInfoBySid *r = (struct lsa_QueryTrustedDomainInfoBySid *)_r;
6785 ZERO_STRUCT(r->out);
6786 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6787 if (r->out.info == NULL) {
6788 return NT_STATUS_NO_MEMORY;
6791 r->out.result = _lsa_QueryTrustedDomainInfoBySid(cli->pipes_struct, r);
6792 return NT_STATUS_OK;
6795 case NDR_LSA_SETTRUSTEDDOMAININFO: {
6796 struct lsa_SetTrustedDomainInfo *r = (struct lsa_SetTrustedDomainInfo *)_r;
6797 r->out.result = _lsa_SetTrustedDomainInfo(cli->pipes_struct, r);
6798 return NT_STATUS_OK;
6801 case NDR_LSA_DELETETRUSTEDDOMAIN: {
6802 struct lsa_DeleteTrustedDomain *r = (struct lsa_DeleteTrustedDomain *)_r;
6803 r->out.result = _lsa_DeleteTrustedDomain(cli->pipes_struct, r);
6804 return NT_STATUS_OK;
6807 case NDR_LSA_STOREPRIVATEDATA: {
6808 struct lsa_StorePrivateData *r = (struct lsa_StorePrivateData *)_r;
6809 r->out.result = _lsa_StorePrivateData(cli->pipes_struct, r);
6810 return NT_STATUS_OK;
6813 case NDR_LSA_RETRIEVEPRIVATEDATA: {
6814 struct lsa_RetrievePrivateData *r = (struct lsa_RetrievePrivateData *)_r;
6815 ZERO_STRUCT(r->out);
6816 r->out.val = r->in.val;
6817 r->out.result = _lsa_RetrievePrivateData(cli->pipes_struct, r);
6818 return NT_STATUS_OK;
6821 case NDR_LSA_OPENPOLICY2: {
6822 struct lsa_OpenPolicy2 *r = (struct lsa_OpenPolicy2 *)_r;
6823 ZERO_STRUCT(r->out);
6824 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
6825 if (r->out.handle == NULL) {
6826 return NT_STATUS_NO_MEMORY;
6829 r->out.result = _lsa_OpenPolicy2(cli->pipes_struct, r);
6830 return NT_STATUS_OK;
6833 case NDR_LSA_GETUSERNAME: {
6834 struct lsa_GetUserName *r = (struct lsa_GetUserName *)_r;
6835 ZERO_STRUCT(r->out);
6836 r->out.account_name = r->in.account_name;
6837 r->out.authority_name = r->in.authority_name;
6838 r->out.result = _lsa_GetUserName(cli->pipes_struct, r);
6839 return NT_STATUS_OK;
6842 case NDR_LSA_QUERYINFOPOLICY2: {
6843 struct lsa_QueryInfoPolicy2 *r = (struct lsa_QueryInfoPolicy2 *)_r;
6844 ZERO_STRUCT(r->out);
6845 r->out.info = talloc_zero(mem_ctx, union lsa_PolicyInformation *);
6846 if (r->out.info == NULL) {
6847 return NT_STATUS_NO_MEMORY;
6850 r->out.result = _lsa_QueryInfoPolicy2(cli->pipes_struct, r);
6851 return NT_STATUS_OK;
6854 case NDR_LSA_SETINFOPOLICY2: {
6855 struct lsa_SetInfoPolicy2 *r = (struct lsa_SetInfoPolicy2 *)_r;
6856 r->out.result = _lsa_SetInfoPolicy2(cli->pipes_struct, r);
6857 return NT_STATUS_OK;
6860 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME: {
6861 struct lsa_QueryTrustedDomainInfoByName *r = (struct lsa_QueryTrustedDomainInfoByName *)_r;
6862 ZERO_STRUCT(r->out);
6863 r->out.info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo *);
6864 if (r->out.info == NULL) {
6865 return NT_STATUS_NO_MEMORY;
6868 r->out.result = _lsa_QueryTrustedDomainInfoByName(cli->pipes_struct, r);
6869 return NT_STATUS_OK;
6872 case NDR_LSA_SETTRUSTEDDOMAININFOBYNAME: {
6873 struct lsa_SetTrustedDomainInfoByName *r = (struct lsa_SetTrustedDomainInfoByName *)_r;
6874 r->out.result = _lsa_SetTrustedDomainInfoByName(cli->pipes_struct, r);
6875 return NT_STATUS_OK;
6878 case NDR_LSA_ENUMTRUSTEDDOMAINSEX: {
6879 struct lsa_EnumTrustedDomainsEx *r = (struct lsa_EnumTrustedDomainsEx *)_r;
6880 ZERO_STRUCT(r->out);
6881 r->out.resume_handle = r->in.resume_handle;
6882 r->out.domains = talloc_zero(mem_ctx, struct lsa_DomainListEx);
6883 if (r->out.domains == NULL) {
6884 return NT_STATUS_NO_MEMORY;
6887 r->out.result = _lsa_EnumTrustedDomainsEx(cli->pipes_struct, r);
6888 return NT_STATUS_OK;
6891 case NDR_LSA_CREATETRUSTEDDOMAINEX: {
6892 struct lsa_CreateTrustedDomainEx *r = (struct lsa_CreateTrustedDomainEx *)_r;
6893 ZERO_STRUCT(r->out);
6894 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6895 if (r->out.trustdom_handle == NULL) {
6896 return NT_STATUS_NO_MEMORY;
6899 r->out.result = _lsa_CreateTrustedDomainEx(cli->pipes_struct, r);
6900 return NT_STATUS_OK;
6903 case NDR_LSA_CLOSETRUSTEDDOMAINEX: {
6904 struct lsa_CloseTrustedDomainEx *r = (struct lsa_CloseTrustedDomainEx *)_r;
6905 ZERO_STRUCT(r->out);
6906 r->out.handle = r->in.handle;
6907 r->out.result = _lsa_CloseTrustedDomainEx(cli->pipes_struct, r);
6908 return NT_STATUS_OK;
6911 case NDR_LSA_QUERYDOMAININFORMATIONPOLICY: {
6912 struct lsa_QueryDomainInformationPolicy *r = (struct lsa_QueryDomainInformationPolicy *)_r;
6913 ZERO_STRUCT(r->out);
6914 r->out.info = talloc_zero(mem_ctx, union lsa_DomainInformationPolicy *);
6915 if (r->out.info == NULL) {
6916 return NT_STATUS_NO_MEMORY;
6919 r->out.result = _lsa_QueryDomainInformationPolicy(cli->pipes_struct, r);
6920 return NT_STATUS_OK;
6923 case NDR_LSA_SETDOMAININFORMATIONPOLICY: {
6924 struct lsa_SetDomainInformationPolicy *r = (struct lsa_SetDomainInformationPolicy *)_r;
6925 r->out.result = _lsa_SetDomainInformationPolicy(cli->pipes_struct, r);
6926 return NT_STATUS_OK;
6929 case NDR_LSA_OPENTRUSTEDDOMAINBYNAME: {
6930 struct lsa_OpenTrustedDomainByName *r = (struct lsa_OpenTrustedDomainByName *)_r;
6931 ZERO_STRUCT(r->out);
6932 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6933 if (r->out.trustdom_handle == NULL) {
6934 return NT_STATUS_NO_MEMORY;
6937 r->out.result = _lsa_OpenTrustedDomainByName(cli->pipes_struct, r);
6938 return NT_STATUS_OK;
6941 case NDR_LSA_TESTCALL: {
6942 struct lsa_TestCall *r = (struct lsa_TestCall *)_r;
6943 r->out.result = _lsa_TestCall(cli->pipes_struct, r);
6944 return NT_STATUS_OK;
6947 case NDR_LSA_LOOKUPSIDS2: {
6948 struct lsa_LookupSids2 *r = (struct lsa_LookupSids2 *)_r;
6949 ZERO_STRUCT(r->out);
6950 r->out.names = r->in.names;
6951 r->out.count = r->in.count;
6952 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6953 if (r->out.domains == NULL) {
6954 return NT_STATUS_NO_MEMORY;
6957 r->out.result = _lsa_LookupSids2(cli->pipes_struct, r);
6958 return NT_STATUS_OK;
6961 case NDR_LSA_LOOKUPNAMES2: {
6962 struct lsa_LookupNames2 *r = (struct lsa_LookupNames2 *)_r;
6963 ZERO_STRUCT(r->out);
6964 r->out.sids = r->in.sids;
6965 r->out.count = r->in.count;
6966 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
6967 if (r->out.domains == NULL) {
6968 return NT_STATUS_NO_MEMORY;
6971 r->out.result = _lsa_LookupNames2(cli->pipes_struct, r);
6972 return NT_STATUS_OK;
6975 case NDR_LSA_CREATETRUSTEDDOMAINEX2: {
6976 struct lsa_CreateTrustedDomainEx2 *r = (struct lsa_CreateTrustedDomainEx2 *)_r;
6977 ZERO_STRUCT(r->out);
6978 r->out.trustdom_handle = talloc_zero(mem_ctx, struct policy_handle);
6979 if (r->out.trustdom_handle == NULL) {
6980 return NT_STATUS_NO_MEMORY;
6983 r->out.result = _lsa_CreateTrustedDomainEx2(cli->pipes_struct, r);
6984 return NT_STATUS_OK;
6987 case NDR_LSA_CREDRWRITE: {
6988 struct lsa_CREDRWRITE *r = (struct lsa_CREDRWRITE *)_r;
6989 r->out.result = _lsa_CREDRWRITE(cli->pipes_struct, r);
6990 return NT_STATUS_OK;
6993 case NDR_LSA_CREDRREAD: {
6994 struct lsa_CREDRREAD *r = (struct lsa_CREDRREAD *)_r;
6995 r->out.result = _lsa_CREDRREAD(cli->pipes_struct, r);
6996 return NT_STATUS_OK;
6999 case NDR_LSA_CREDRENUMERATE: {
7000 struct lsa_CREDRENUMERATE *r = (struct lsa_CREDRENUMERATE *)_r;
7001 r->out.result = _lsa_CREDRENUMERATE(cli->pipes_struct, r);
7002 return NT_STATUS_OK;
7005 case NDR_LSA_CREDRWRITEDOMAINCREDENTIALS: {
7006 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r = (struct lsa_CREDRWRITEDOMAINCREDENTIALS *)_r;
7007 r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(cli->pipes_struct, r);
7008 return NT_STATUS_OK;
7011 case NDR_LSA_CREDRREADDOMAINCREDENTIALS: {
7012 struct lsa_CREDRREADDOMAINCREDENTIALS *r = (struct lsa_CREDRREADDOMAINCREDENTIALS *)_r;
7013 r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(cli->pipes_struct, r);
7014 return NT_STATUS_OK;
7017 case NDR_LSA_CREDRDELETE: {
7018 struct lsa_CREDRDELETE *r = (struct lsa_CREDRDELETE *)_r;
7019 r->out.result = _lsa_CREDRDELETE(cli->pipes_struct, r);
7020 return NT_STATUS_OK;
7023 case NDR_LSA_CREDRGETTARGETINFO: {
7024 struct lsa_CREDRGETTARGETINFO *r = (struct lsa_CREDRGETTARGETINFO *)_r;
7025 r->out.result = _lsa_CREDRGETTARGETINFO(cli->pipes_struct, r);
7026 return NT_STATUS_OK;
7029 case NDR_LSA_CREDRPROFILELOADED: {
7030 struct lsa_CREDRPROFILELOADED *r = (struct lsa_CREDRPROFILELOADED *)_r;
7031 r->out.result = _lsa_CREDRPROFILELOADED(cli->pipes_struct, r);
7032 return NT_STATUS_OK;
7035 case NDR_LSA_LOOKUPNAMES3: {
7036 struct lsa_LookupNames3 *r = (struct lsa_LookupNames3 *)_r;
7037 ZERO_STRUCT(r->out);
7038 r->out.sids = r->in.sids;
7039 r->out.count = r->in.count;
7040 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7041 if (r->out.domains == NULL) {
7042 return NT_STATUS_NO_MEMORY;
7045 r->out.result = _lsa_LookupNames3(cli->pipes_struct, r);
7046 return NT_STATUS_OK;
7049 case NDR_LSA_CREDRGETSESSIONTYPES: {
7050 struct lsa_CREDRGETSESSIONTYPES *r = (struct lsa_CREDRGETSESSIONTYPES *)_r;
7051 r->out.result = _lsa_CREDRGETSESSIONTYPES(cli->pipes_struct, r);
7052 return NT_STATUS_OK;
7055 case NDR_LSA_LSARREGISTERAUDITEVENT: {
7056 struct lsa_LSARREGISTERAUDITEVENT *r = (struct lsa_LSARREGISTERAUDITEVENT *)_r;
7057 r->out.result = _lsa_LSARREGISTERAUDITEVENT(cli->pipes_struct, r);
7058 return NT_STATUS_OK;
7061 case NDR_LSA_LSARGENAUDITEVENT: {
7062 struct lsa_LSARGENAUDITEVENT *r = (struct lsa_LSARGENAUDITEVENT *)_r;
7063 r->out.result = _lsa_LSARGENAUDITEVENT(cli->pipes_struct, r);
7064 return NT_STATUS_OK;
7067 case NDR_LSA_LSARUNREGISTERAUDITEVENT: {
7068 struct lsa_LSARUNREGISTERAUDITEVENT *r = (struct lsa_LSARUNREGISTERAUDITEVENT *)_r;
7069 r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(cli->pipes_struct, r);
7070 return NT_STATUS_OK;
7073 case NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION: {
7074 struct lsa_lsaRQueryForestTrustInformation *r = (struct lsa_lsaRQueryForestTrustInformation *)_r;
7075 ZERO_STRUCT(r->out);
7076 r->out.forest_trust_info = talloc_zero(mem_ctx, struct lsa_ForestTrustInformation *);
7077 if (r->out.forest_trust_info == NULL) {
7078 return NT_STATUS_NO_MEMORY;
7081 r->out.result = _lsa_lsaRQueryForestTrustInformation(cli->pipes_struct, r);
7082 return NT_STATUS_OK;
7085 case NDR_LSA_LSARSETFORESTTRUSTINFORMATION: {
7086 struct lsa_LSARSETFORESTTRUSTINFORMATION *r = (struct lsa_LSARSETFORESTTRUSTINFORMATION *)_r;
7087 r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(cli->pipes_struct, r);
7088 return NT_STATUS_OK;
7091 case NDR_LSA_CREDRRENAME: {
7092 struct lsa_CREDRRENAME *r = (struct lsa_CREDRRENAME *)_r;
7093 r->out.result = _lsa_CREDRRENAME(cli->pipes_struct, r);
7094 return NT_STATUS_OK;
7097 case NDR_LSA_LOOKUPSIDS3: {
7098 struct lsa_LookupSids3 *r = (struct lsa_LookupSids3 *)_r;
7099 ZERO_STRUCT(r->out);
7100 r->out.names = r->in.names;
7101 r->out.count = r->in.count;
7102 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7103 if (r->out.domains == NULL) {
7104 return NT_STATUS_NO_MEMORY;
7107 r->out.result = _lsa_LookupSids3(cli->pipes_struct, r);
7108 return NT_STATUS_OK;
7111 case NDR_LSA_LOOKUPNAMES4: {
7112 struct lsa_LookupNames4 *r = (struct lsa_LookupNames4 *)_r;
7113 ZERO_STRUCT(r->out);
7114 r->out.sids = r->in.sids;
7115 r->out.count = r->in.count;
7116 r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList *);
7117 if (r->out.domains == NULL) {
7118 return NT_STATUS_NO_MEMORY;
7121 r->out.result = _lsa_LookupNames4(cli->pipes_struct, r);
7122 return NT_STATUS_OK;
7125 case NDR_LSA_LSAROPENPOLICYSCE: {
7126 struct lsa_LSAROPENPOLICYSCE *r = (struct lsa_LSAROPENPOLICYSCE *)_r;
7127 r->out.result = _lsa_LSAROPENPOLICYSCE(cli->pipes_struct, r);
7128 return NT_STATUS_OK;
7131 case NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE: {
7132 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *)_r;
7133 r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7134 return NT_STATUS_OK;
7137 case NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE: {
7138 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r = (struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *)_r;
7139 r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(cli->pipes_struct, r);
7140 return NT_STATUS_OK;
7143 case NDR_LSA_LSARADTREPORTSECURITYEVENT: {
7144 struct lsa_LSARADTREPORTSECURITYEVENT *r = (struct lsa_LSARADTREPORTSECURITYEVENT *)_r;
7145 r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(cli->pipes_struct, r);
7146 return NT_STATUS_OK;
7150 return NT_STATUS_NOT_IMPLEMENTED;
7154 NTSTATUS rpc_lsarpc_init(void)
7156 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", &ndr_table_lsarpc, api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));