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;
18 call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSE];
20 r = talloc(NULL, struct lsa_Close);
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
30 pull = ndr_pull_init_blob(&blob, r);
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 status = call->ndr_pull(pull, NDR_IN, r);
38 if (NT_STATUS_IS_ERR(status)) {
44 NDR_PRINT_IN_DEBUG(lsa_Close, r);
47 r->out.handle = r->in.handle;
48 r->out.result = _lsa_Close(p, r);
50 if (p->rng_fault_state) {
52 /* Return True here, srv_pipe_hnd.c will take care */
57 NDR_PRINT_OUT_DEBUG(lsa_Close, r);
59 push = ndr_push_init_ctx(r);
65 status = call->ndr_push(push, NDR_OUT, r);
66 if (NT_STATUS_IS_ERR(status)) {
71 blob = ndr_push_blob(push);
72 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
82 static bool api_lsa_Delete(pipes_struct *p)
84 const struct ndr_interface_call *call;
85 struct ndr_pull *pull;
86 struct ndr_push *push;
91 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETE];
93 r = talloc(NULL, struct lsa_Delete);
98 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
103 pull = ndr_pull_init_blob(&blob, r);
109 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
110 status = call->ndr_pull(pull, NDR_IN, r);
111 if (NT_STATUS_IS_ERR(status)) {
116 if (DEBUGLEVEL >= 10)
117 NDR_PRINT_IN_DEBUG(lsa_Delete, r);
119 r->out.result = _lsa_Delete(p, r);
121 if (p->rng_fault_state) {
123 /* Return True here, srv_pipe_hnd.c will take care */
127 if (DEBUGLEVEL >= 10)
128 NDR_PRINT_OUT_DEBUG(lsa_Delete, r);
130 push = ndr_push_init_ctx(r);
136 status = call->ndr_push(push, NDR_OUT, r);
137 if (NT_STATUS_IS_ERR(status)) {
142 blob = ndr_push_blob(push);
143 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
153 static bool api_lsa_EnumPrivs(pipes_struct *p)
155 const struct ndr_interface_call *call;
156 struct ndr_pull *pull;
157 struct ndr_push *push;
160 struct lsa_EnumPrivs *r;
162 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVS];
164 r = talloc(NULL, struct lsa_EnumPrivs);
169 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
174 pull = ndr_pull_init_blob(&blob, r);
180 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
181 status = call->ndr_pull(pull, NDR_IN, r);
182 if (NT_STATUS_IS_ERR(status)) {
187 if (DEBUGLEVEL >= 10)
188 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, r);
191 r->out.resume_handle = r->in.resume_handle;
192 r->out.privs = talloc_zero(r, struct lsa_PrivArray);
193 if (r->out.privs == NULL) {
198 r->out.result = _lsa_EnumPrivs(p, r);
200 if (p->rng_fault_state) {
202 /* Return True here, srv_pipe_hnd.c will take care */
206 if (DEBUGLEVEL >= 10)
207 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, r);
209 push = ndr_push_init_ctx(r);
215 status = call->ndr_push(push, NDR_OUT, r);
216 if (NT_STATUS_IS_ERR(status)) {
221 blob = ndr_push_blob(push);
222 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
232 static bool api_lsa_QuerySecurity(pipes_struct *p)
234 const struct ndr_interface_call *call;
235 struct ndr_pull *pull;
236 struct ndr_push *push;
239 struct lsa_QuerySecurity *r;
241 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECURITY];
243 r = talloc(NULL, struct lsa_QuerySecurity);
248 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
253 pull = ndr_pull_init_blob(&blob, r);
259 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
260 status = call->ndr_pull(pull, NDR_IN, r);
261 if (NT_STATUS_IS_ERR(status)) {
266 if (DEBUGLEVEL >= 10)
267 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, r);
270 r->out.sdbuf = talloc_zero(r, struct sec_desc_buf);
271 if (r->out.sdbuf == NULL) {
276 r->out.result = _lsa_QuerySecurity(p, r);
278 if (p->rng_fault_state) {
280 /* Return True here, srv_pipe_hnd.c will take care */
284 if (DEBUGLEVEL >= 10)
285 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, r);
287 push = ndr_push_init_ctx(r);
293 status = call->ndr_push(push, NDR_OUT, r);
294 if (NT_STATUS_IS_ERR(status)) {
299 blob = ndr_push_blob(push);
300 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
310 static bool api_lsa_SetSecObj(pipes_struct *p)
312 const struct ndr_interface_call *call;
313 struct ndr_pull *pull;
314 struct ndr_push *push;
317 struct lsa_SetSecObj *r;
319 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECOBJ];
321 r = talloc(NULL, struct lsa_SetSecObj);
326 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
331 pull = ndr_pull_init_blob(&blob, r);
337 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
338 status = call->ndr_pull(pull, NDR_IN, r);
339 if (NT_STATUS_IS_ERR(status)) {
344 if (DEBUGLEVEL >= 10)
345 NDR_PRINT_IN_DEBUG(lsa_SetSecObj, r);
347 r->out.result = _lsa_SetSecObj(p, r);
349 if (p->rng_fault_state) {
351 /* Return True here, srv_pipe_hnd.c will take care */
355 if (DEBUGLEVEL >= 10)
356 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, r);
358 push = ndr_push_init_ctx(r);
364 status = call->ndr_push(push, NDR_OUT, r);
365 if (NT_STATUS_IS_ERR(status)) {
370 blob = ndr_push_blob(push);
371 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
381 static bool api_lsa_ChangePassword(pipes_struct *p)
383 const struct ndr_interface_call *call;
384 struct ndr_pull *pull;
385 struct ndr_push *push;
388 struct lsa_ChangePassword *r;
390 call = &ndr_table_lsarpc.calls[NDR_LSA_CHANGEPASSWORD];
392 r = talloc(NULL, struct lsa_ChangePassword);
397 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
402 pull = ndr_pull_init_blob(&blob, r);
408 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
409 status = call->ndr_pull(pull, NDR_IN, r);
410 if (NT_STATUS_IS_ERR(status)) {
415 if (DEBUGLEVEL >= 10)
416 NDR_PRINT_IN_DEBUG(lsa_ChangePassword, r);
418 r->out.result = _lsa_ChangePassword(p, r);
420 if (p->rng_fault_state) {
422 /* Return True here, srv_pipe_hnd.c will take care */
426 if (DEBUGLEVEL >= 10)
427 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, r);
429 push = ndr_push_init_ctx(r);
435 status = call->ndr_push(push, NDR_OUT, r);
436 if (NT_STATUS_IS_ERR(status)) {
441 blob = ndr_push_blob(push);
442 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
452 static bool api_lsa_OpenPolicy(pipes_struct *p)
454 const struct ndr_interface_call *call;
455 struct ndr_pull *pull;
456 struct ndr_push *push;
459 struct lsa_OpenPolicy *r;
461 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY];
463 r = talloc(NULL, struct lsa_OpenPolicy);
468 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
473 pull = ndr_pull_init_blob(&blob, r);
479 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
480 status = call->ndr_pull(pull, NDR_IN, r);
481 if (NT_STATUS_IS_ERR(status)) {
486 if (DEBUGLEVEL >= 10)
487 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, r);
490 r->out.handle = talloc_zero(r, struct policy_handle);
491 if (r->out.handle == NULL) {
496 r->out.result = _lsa_OpenPolicy(p, r);
498 if (p->rng_fault_state) {
500 /* Return True here, srv_pipe_hnd.c will take care */
504 if (DEBUGLEVEL >= 10)
505 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, r);
507 push = ndr_push_init_ctx(r);
513 status = call->ndr_push(push, NDR_OUT, r);
514 if (NT_STATUS_IS_ERR(status)) {
519 blob = ndr_push_blob(push);
520 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
530 static bool api_lsa_QueryInfoPolicy(pipes_struct *p)
532 const struct ndr_interface_call *call;
533 struct ndr_pull *pull;
534 struct ndr_push *push;
537 struct lsa_QueryInfoPolicy *r;
539 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY];
541 r = talloc(NULL, struct lsa_QueryInfoPolicy);
546 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
551 pull = ndr_pull_init_blob(&blob, r);
557 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
558 status = call->ndr_pull(pull, NDR_IN, r);
559 if (NT_STATUS_IS_ERR(status)) {
564 if (DEBUGLEVEL >= 10)
565 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy, r);
568 r->out.info = talloc_zero(r, union lsa_PolicyInformation);
569 if (r->out.info == NULL) {
574 r->out.result = _lsa_QueryInfoPolicy(p, r);
576 if (p->rng_fault_state) {
578 /* Return True here, srv_pipe_hnd.c will take care */
582 if (DEBUGLEVEL >= 10)
583 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, r);
585 push = ndr_push_init_ctx(r);
591 status = call->ndr_push(push, NDR_OUT, r);
592 if (NT_STATUS_IS_ERR(status)) {
597 blob = ndr_push_blob(push);
598 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
608 static bool api_lsa_SetInfoPolicy(pipes_struct *p)
610 const struct ndr_interface_call *call;
611 struct ndr_pull *pull;
612 struct ndr_push *push;
615 struct lsa_SetInfoPolicy *r;
617 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY];
619 r = talloc(NULL, struct lsa_SetInfoPolicy);
624 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
629 pull = ndr_pull_init_blob(&blob, r);
635 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
636 status = call->ndr_pull(pull, NDR_IN, r);
637 if (NT_STATUS_IS_ERR(status)) {
642 if (DEBUGLEVEL >= 10)
643 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, r);
645 r->out.result = _lsa_SetInfoPolicy(p, r);
647 if (p->rng_fault_state) {
649 /* Return True here, srv_pipe_hnd.c will take care */
653 if (DEBUGLEVEL >= 10)
654 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, r);
656 push = ndr_push_init_ctx(r);
662 status = call->ndr_push(push, NDR_OUT, r);
663 if (NT_STATUS_IS_ERR(status)) {
668 blob = ndr_push_blob(push);
669 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
679 static bool api_lsa_ClearAuditLog(pipes_struct *p)
681 const struct ndr_interface_call *call;
682 struct ndr_pull *pull;
683 struct ndr_push *push;
686 struct lsa_ClearAuditLog *r;
688 call = &ndr_table_lsarpc.calls[NDR_LSA_CLEARAUDITLOG];
690 r = talloc(NULL, struct lsa_ClearAuditLog);
695 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
700 pull = ndr_pull_init_blob(&blob, r);
706 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
707 status = call->ndr_pull(pull, NDR_IN, r);
708 if (NT_STATUS_IS_ERR(status)) {
713 if (DEBUGLEVEL >= 10)
714 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, r);
716 r->out.result = _lsa_ClearAuditLog(p, r);
718 if (p->rng_fault_state) {
720 /* Return True here, srv_pipe_hnd.c will take care */
724 if (DEBUGLEVEL >= 10)
725 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, r);
727 push = ndr_push_init_ctx(r);
733 status = call->ndr_push(push, NDR_OUT, r);
734 if (NT_STATUS_IS_ERR(status)) {
739 blob = ndr_push_blob(push);
740 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
750 static bool api_lsa_CreateAccount(pipes_struct *p)
752 const struct ndr_interface_call *call;
753 struct ndr_pull *pull;
754 struct ndr_push *push;
757 struct lsa_CreateAccount *r;
759 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATEACCOUNT];
761 r = talloc(NULL, struct lsa_CreateAccount);
766 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
771 pull = ndr_pull_init_blob(&blob, r);
777 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
778 status = call->ndr_pull(pull, NDR_IN, r);
779 if (NT_STATUS_IS_ERR(status)) {
784 if (DEBUGLEVEL >= 10)
785 NDR_PRINT_IN_DEBUG(lsa_CreateAccount, r);
788 r->out.acct_handle = talloc_zero(r, struct policy_handle);
789 if (r->out.acct_handle == NULL) {
794 r->out.result = _lsa_CreateAccount(p, r);
796 if (p->rng_fault_state) {
798 /* Return True here, srv_pipe_hnd.c will take care */
802 if (DEBUGLEVEL >= 10)
803 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, r);
805 push = ndr_push_init_ctx(r);
811 status = call->ndr_push(push, NDR_OUT, r);
812 if (NT_STATUS_IS_ERR(status)) {
817 blob = ndr_push_blob(push);
818 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
828 static bool api_lsa_EnumAccounts(pipes_struct *p)
830 const struct ndr_interface_call *call;
831 struct ndr_pull *pull;
832 struct ndr_push *push;
835 struct lsa_EnumAccounts *r;
837 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTS];
839 r = talloc(NULL, struct lsa_EnumAccounts);
844 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
849 pull = ndr_pull_init_blob(&blob, r);
855 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
856 status = call->ndr_pull(pull, NDR_IN, r);
857 if (NT_STATUS_IS_ERR(status)) {
862 if (DEBUGLEVEL >= 10)
863 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, r);
866 r->out.resume_handle = r->in.resume_handle;
867 r->out.sids = talloc_zero(r, struct lsa_SidArray);
868 if (r->out.sids == NULL) {
873 r->out.result = _lsa_EnumAccounts(p, r);
875 if (p->rng_fault_state) {
877 /* Return True here, srv_pipe_hnd.c will take care */
881 if (DEBUGLEVEL >= 10)
882 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, r);
884 push = ndr_push_init_ctx(r);
890 status = call->ndr_push(push, NDR_OUT, r);
891 if (NT_STATUS_IS_ERR(status)) {
896 blob = ndr_push_blob(push);
897 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
907 static bool api_lsa_CreateTrustedDomain(pipes_struct *p)
909 const struct ndr_interface_call *call;
910 struct ndr_pull *pull;
911 struct ndr_push *push;
914 struct lsa_CreateTrustedDomain *r;
916 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAIN];
918 r = talloc(NULL, struct lsa_CreateTrustedDomain);
923 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
928 pull = ndr_pull_init_blob(&blob, r);
934 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
935 status = call->ndr_pull(pull, NDR_IN, r);
936 if (NT_STATUS_IS_ERR(status)) {
941 if (DEBUGLEVEL >= 10)
942 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, r);
945 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
946 if (r->out.trustdom_handle == NULL) {
951 r->out.result = _lsa_CreateTrustedDomain(p, r);
953 if (p->rng_fault_state) {
955 /* Return True here, srv_pipe_hnd.c will take care */
959 if (DEBUGLEVEL >= 10)
960 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, r);
962 push = ndr_push_init_ctx(r);
968 status = call->ndr_push(push, NDR_OUT, r);
969 if (NT_STATUS_IS_ERR(status)) {
974 blob = ndr_push_blob(push);
975 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
985 static bool api_lsa_EnumTrustDom(pipes_struct *p)
987 const struct ndr_interface_call *call;
988 struct ndr_pull *pull;
989 struct ndr_push *push;
992 struct lsa_EnumTrustDom *r;
994 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTDOM];
996 r = talloc(NULL, struct lsa_EnumTrustDom);
1001 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1006 pull = ndr_pull_init_blob(&blob, r);
1012 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1013 status = call->ndr_pull(pull, NDR_IN, r);
1014 if (NT_STATUS_IS_ERR(status)) {
1019 if (DEBUGLEVEL >= 10)
1020 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, r);
1022 ZERO_STRUCT(r->out);
1023 r->out.resume_handle = r->in.resume_handle;
1024 r->out.domains = talloc_zero(r, struct lsa_DomainList);
1025 if (r->out.domains == NULL) {
1030 r->out.result = _lsa_EnumTrustDom(p, r);
1032 if (p->rng_fault_state) {
1034 /* Return True here, srv_pipe_hnd.c will take care */
1038 if (DEBUGLEVEL >= 10)
1039 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, r);
1041 push = ndr_push_init_ctx(r);
1047 status = call->ndr_push(push, NDR_OUT, r);
1048 if (NT_STATUS_IS_ERR(status)) {
1053 blob = ndr_push_blob(push);
1054 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1064 static bool api_lsa_LookupNames(pipes_struct *p)
1066 const struct ndr_interface_call *call;
1067 struct ndr_pull *pull;
1068 struct ndr_push *push;
1071 struct lsa_LookupNames *r;
1073 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES];
1075 r = talloc(NULL, struct lsa_LookupNames);
1080 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1085 pull = ndr_pull_init_blob(&blob, r);
1091 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1092 status = call->ndr_pull(pull, NDR_IN, r);
1093 if (NT_STATUS_IS_ERR(status)) {
1098 if (DEBUGLEVEL >= 10)
1099 NDR_PRINT_IN_DEBUG(lsa_LookupNames, r);
1101 ZERO_STRUCT(r->out);
1102 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
1103 if (r->out.domains == NULL) {
1108 r->out.sids = r->in.sids;
1109 r->out.count = r->in.count;
1110 r->out.result = _lsa_LookupNames(p, r);
1112 if (p->rng_fault_state) {
1114 /* Return True here, srv_pipe_hnd.c will take care */
1118 if (DEBUGLEVEL >= 10)
1119 NDR_PRINT_OUT_DEBUG(lsa_LookupNames, r);
1121 push = ndr_push_init_ctx(r);
1127 status = call->ndr_push(push, NDR_OUT, r);
1128 if (NT_STATUS_IS_ERR(status)) {
1133 blob = ndr_push_blob(push);
1134 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1144 static bool api_lsa_LookupSids(pipes_struct *p)
1146 const struct ndr_interface_call *call;
1147 struct ndr_pull *pull;
1148 struct ndr_push *push;
1151 struct lsa_LookupSids *r;
1153 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS];
1155 r = talloc(NULL, struct lsa_LookupSids);
1160 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1165 pull = ndr_pull_init_blob(&blob, r);
1171 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1172 status = call->ndr_pull(pull, NDR_IN, r);
1173 if (NT_STATUS_IS_ERR(status)) {
1178 if (DEBUGLEVEL >= 10)
1179 NDR_PRINT_IN_DEBUG(lsa_LookupSids, r);
1181 ZERO_STRUCT(r->out);
1182 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
1183 if (r->out.domains == NULL) {
1188 r->out.names = r->in.names;
1189 r->out.count = r->in.count;
1190 r->out.result = _lsa_LookupSids(p, r);
1192 if (p->rng_fault_state) {
1194 /* Return True here, srv_pipe_hnd.c will take care */
1198 if (DEBUGLEVEL >= 10)
1199 NDR_PRINT_OUT_DEBUG(lsa_LookupSids, r);
1201 push = ndr_push_init_ctx(r);
1207 status = call->ndr_push(push, NDR_OUT, r);
1208 if (NT_STATUS_IS_ERR(status)) {
1213 blob = ndr_push_blob(push);
1214 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1224 static bool api_lsa_CreateSecret(pipes_struct *p)
1226 const struct ndr_interface_call *call;
1227 struct ndr_pull *pull;
1228 struct ndr_push *push;
1231 struct lsa_CreateSecret *r;
1233 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATESECRET];
1235 r = talloc(NULL, struct lsa_CreateSecret);
1240 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1245 pull = ndr_pull_init_blob(&blob, r);
1251 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1252 status = call->ndr_pull(pull, NDR_IN, r);
1253 if (NT_STATUS_IS_ERR(status)) {
1258 if (DEBUGLEVEL >= 10)
1259 NDR_PRINT_IN_DEBUG(lsa_CreateSecret, r);
1261 ZERO_STRUCT(r->out);
1262 r->out.sec_handle = talloc_zero(r, struct policy_handle);
1263 if (r->out.sec_handle == NULL) {
1268 r->out.result = _lsa_CreateSecret(p, r);
1270 if (p->rng_fault_state) {
1272 /* Return True here, srv_pipe_hnd.c will take care */
1276 if (DEBUGLEVEL >= 10)
1277 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, r);
1279 push = ndr_push_init_ctx(r);
1285 status = call->ndr_push(push, NDR_OUT, r);
1286 if (NT_STATUS_IS_ERR(status)) {
1291 blob = ndr_push_blob(push);
1292 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1302 static bool api_lsa_OpenAccount(pipes_struct *p)
1304 const struct ndr_interface_call *call;
1305 struct ndr_pull *pull;
1306 struct ndr_push *push;
1309 struct lsa_OpenAccount *r;
1311 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENACCOUNT];
1313 r = talloc(NULL, struct lsa_OpenAccount);
1318 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1323 pull = ndr_pull_init_blob(&blob, r);
1329 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1330 status = call->ndr_pull(pull, NDR_IN, r);
1331 if (NT_STATUS_IS_ERR(status)) {
1336 if (DEBUGLEVEL >= 10)
1337 NDR_PRINT_IN_DEBUG(lsa_OpenAccount, r);
1339 ZERO_STRUCT(r->out);
1340 r->out.acct_handle = talloc_zero(r, struct policy_handle);
1341 if (r->out.acct_handle == NULL) {
1346 r->out.result = _lsa_OpenAccount(p, r);
1348 if (p->rng_fault_state) {
1350 /* Return True here, srv_pipe_hnd.c will take care */
1354 if (DEBUGLEVEL >= 10)
1355 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, r);
1357 push = ndr_push_init_ctx(r);
1363 status = call->ndr_push(push, NDR_OUT, r);
1364 if (NT_STATUS_IS_ERR(status)) {
1369 blob = ndr_push_blob(push);
1370 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1380 static bool api_lsa_EnumPrivsAccount(pipes_struct *p)
1382 const struct ndr_interface_call *call;
1383 struct ndr_pull *pull;
1384 struct ndr_push *push;
1387 struct lsa_EnumPrivsAccount *r;
1389 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMPRIVSACCOUNT];
1391 r = talloc(NULL, struct lsa_EnumPrivsAccount);
1396 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1401 pull = ndr_pull_init_blob(&blob, r);
1407 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1408 status = call->ndr_pull(pull, NDR_IN, r);
1409 if (NT_STATUS_IS_ERR(status)) {
1414 if (DEBUGLEVEL >= 10)
1415 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, r);
1417 ZERO_STRUCT(r->out);
1418 r->out.privs = talloc_zero(r, struct lsa_PrivilegeSet);
1419 if (r->out.privs == NULL) {
1424 r->out.result = _lsa_EnumPrivsAccount(p, r);
1426 if (p->rng_fault_state) {
1428 /* Return True here, srv_pipe_hnd.c will take care */
1432 if (DEBUGLEVEL >= 10)
1433 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, r);
1435 push = ndr_push_init_ctx(r);
1441 status = call->ndr_push(push, NDR_OUT, r);
1442 if (NT_STATUS_IS_ERR(status)) {
1447 blob = ndr_push_blob(push);
1448 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1458 static bool api_lsa_AddPrivilegesToAccount(pipes_struct *p)
1460 const struct ndr_interface_call *call;
1461 struct ndr_pull *pull;
1462 struct ndr_push *push;
1465 struct lsa_AddPrivilegesToAccount *r;
1467 call = &ndr_table_lsarpc.calls[NDR_LSA_ADDPRIVILEGESTOACCOUNT];
1469 r = talloc(NULL, struct lsa_AddPrivilegesToAccount);
1474 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1479 pull = ndr_pull_init_blob(&blob, r);
1485 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1486 status = call->ndr_pull(pull, NDR_IN, r);
1487 if (NT_STATUS_IS_ERR(status)) {
1492 if (DEBUGLEVEL >= 10)
1493 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, r);
1495 r->out.result = _lsa_AddPrivilegesToAccount(p, r);
1497 if (p->rng_fault_state) {
1499 /* Return True here, srv_pipe_hnd.c will take care */
1503 if (DEBUGLEVEL >= 10)
1504 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, r);
1506 push = ndr_push_init_ctx(r);
1512 status = call->ndr_push(push, NDR_OUT, r);
1513 if (NT_STATUS_IS_ERR(status)) {
1518 blob = ndr_push_blob(push);
1519 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1529 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct *p)
1531 const struct ndr_interface_call *call;
1532 struct ndr_pull *pull;
1533 struct ndr_push *push;
1536 struct lsa_RemovePrivilegesFromAccount *r;
1538 call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT];
1540 r = talloc(NULL, struct lsa_RemovePrivilegesFromAccount);
1545 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1550 pull = ndr_pull_init_blob(&blob, r);
1556 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1557 status = call->ndr_pull(pull, NDR_IN, r);
1558 if (NT_STATUS_IS_ERR(status)) {
1563 if (DEBUGLEVEL >= 10)
1564 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1566 r->out.result = _lsa_RemovePrivilegesFromAccount(p, r);
1568 if (p->rng_fault_state) {
1570 /* Return True here, srv_pipe_hnd.c will take care */
1574 if (DEBUGLEVEL >= 10)
1575 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, r);
1577 push = ndr_push_init_ctx(r);
1583 status = call->ndr_push(push, NDR_OUT, r);
1584 if (NT_STATUS_IS_ERR(status)) {
1589 blob = ndr_push_blob(push);
1590 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1600 static bool api_lsa_GetQuotasForAccount(pipes_struct *p)
1602 const struct ndr_interface_call *call;
1603 struct ndr_pull *pull;
1604 struct ndr_push *push;
1607 struct lsa_GetQuotasForAccount *r;
1609 call = &ndr_table_lsarpc.calls[NDR_LSA_GETQUOTASFORACCOUNT];
1611 r = talloc(NULL, struct lsa_GetQuotasForAccount);
1616 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1621 pull = ndr_pull_init_blob(&blob, r);
1627 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1628 status = call->ndr_pull(pull, NDR_IN, r);
1629 if (NT_STATUS_IS_ERR(status)) {
1634 if (DEBUGLEVEL >= 10)
1635 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, r);
1637 r->out.result = _lsa_GetQuotasForAccount(p, r);
1639 if (p->rng_fault_state) {
1641 /* Return True here, srv_pipe_hnd.c will take care */
1645 if (DEBUGLEVEL >= 10)
1646 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, r);
1648 push = ndr_push_init_ctx(r);
1654 status = call->ndr_push(push, NDR_OUT, r);
1655 if (NT_STATUS_IS_ERR(status)) {
1660 blob = ndr_push_blob(push);
1661 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1671 static bool api_lsa_SetQuotasForAccount(pipes_struct *p)
1673 const struct ndr_interface_call *call;
1674 struct ndr_pull *pull;
1675 struct ndr_push *push;
1678 struct lsa_SetQuotasForAccount *r;
1680 call = &ndr_table_lsarpc.calls[NDR_LSA_SETQUOTASFORACCOUNT];
1682 r = talloc(NULL, struct lsa_SetQuotasForAccount);
1687 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1692 pull = ndr_pull_init_blob(&blob, r);
1698 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1699 status = call->ndr_pull(pull, NDR_IN, r);
1700 if (NT_STATUS_IS_ERR(status)) {
1705 if (DEBUGLEVEL >= 10)
1706 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, r);
1708 r->out.result = _lsa_SetQuotasForAccount(p, r);
1710 if (p->rng_fault_state) {
1712 /* Return True here, srv_pipe_hnd.c will take care */
1716 if (DEBUGLEVEL >= 10)
1717 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, r);
1719 push = ndr_push_init_ctx(r);
1725 status = call->ndr_push(push, NDR_OUT, r);
1726 if (NT_STATUS_IS_ERR(status)) {
1731 blob = ndr_push_blob(push);
1732 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1742 static bool api_lsa_GetSystemAccessAccount(pipes_struct *p)
1744 const struct ndr_interface_call *call;
1745 struct ndr_pull *pull;
1746 struct ndr_push *push;
1749 struct lsa_GetSystemAccessAccount *r;
1751 call = &ndr_table_lsarpc.calls[NDR_LSA_GETSYSTEMACCESSACCOUNT];
1753 r = talloc(NULL, struct lsa_GetSystemAccessAccount);
1758 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1763 pull = ndr_pull_init_blob(&blob, r);
1769 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1770 status = call->ndr_pull(pull, NDR_IN, r);
1771 if (NT_STATUS_IS_ERR(status)) {
1776 if (DEBUGLEVEL >= 10)
1777 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, r);
1779 r->out.result = _lsa_GetSystemAccessAccount(p, r);
1781 if (p->rng_fault_state) {
1783 /* Return True here, srv_pipe_hnd.c will take care */
1787 if (DEBUGLEVEL >= 10)
1788 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, r);
1790 push = ndr_push_init_ctx(r);
1796 status = call->ndr_push(push, NDR_OUT, r);
1797 if (NT_STATUS_IS_ERR(status)) {
1802 blob = ndr_push_blob(push);
1803 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1813 static bool api_lsa_SetSystemAccessAccount(pipes_struct *p)
1815 const struct ndr_interface_call *call;
1816 struct ndr_pull *pull;
1817 struct ndr_push *push;
1820 struct lsa_SetSystemAccessAccount *r;
1822 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSYSTEMACCESSACCOUNT];
1824 r = talloc(NULL, struct lsa_SetSystemAccessAccount);
1829 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1834 pull = ndr_pull_init_blob(&blob, r);
1840 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1841 status = call->ndr_pull(pull, NDR_IN, r);
1842 if (NT_STATUS_IS_ERR(status)) {
1847 if (DEBUGLEVEL >= 10)
1848 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, r);
1850 r->out.result = _lsa_SetSystemAccessAccount(p, r);
1852 if (p->rng_fault_state) {
1854 /* Return True here, srv_pipe_hnd.c will take care */
1858 if (DEBUGLEVEL >= 10)
1859 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, r);
1861 push = ndr_push_init_ctx(r);
1867 status = call->ndr_push(push, NDR_OUT, r);
1868 if (NT_STATUS_IS_ERR(status)) {
1873 blob = ndr_push_blob(push);
1874 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1884 static bool api_lsa_OpenTrustedDomain(pipes_struct *p)
1886 const struct ndr_interface_call *call;
1887 struct ndr_pull *pull;
1888 struct ndr_push *push;
1891 struct lsa_OpenTrustedDomain *r;
1893 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAIN];
1895 r = talloc(NULL, struct lsa_OpenTrustedDomain);
1900 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1905 pull = ndr_pull_init_blob(&blob, r);
1911 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1912 status = call->ndr_pull(pull, NDR_IN, r);
1913 if (NT_STATUS_IS_ERR(status)) {
1918 if (DEBUGLEVEL >= 10)
1919 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, r);
1921 ZERO_STRUCT(r->out);
1922 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
1923 if (r->out.trustdom_handle == NULL) {
1928 r->out.result = _lsa_OpenTrustedDomain(p, r);
1930 if (p->rng_fault_state) {
1932 /* Return True here, srv_pipe_hnd.c will take care */
1936 if (DEBUGLEVEL >= 10)
1937 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, r);
1939 push = ndr_push_init_ctx(r);
1945 status = call->ndr_push(push, NDR_OUT, r);
1946 if (NT_STATUS_IS_ERR(status)) {
1951 blob = ndr_push_blob(push);
1952 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1962 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct *p)
1964 const struct ndr_interface_call *call;
1965 struct ndr_pull *pull;
1966 struct ndr_push *push;
1969 struct lsa_QueryTrustedDomainInfo *r;
1971 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFO];
1973 r = talloc(NULL, struct lsa_QueryTrustedDomainInfo);
1978 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1983 pull = ndr_pull_init_blob(&blob, r);
1989 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1990 status = call->ndr_pull(pull, NDR_IN, r);
1991 if (NT_STATUS_IS_ERR(status)) {
1996 if (DEBUGLEVEL >= 10)
1997 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo, r);
1999 ZERO_STRUCT(r->out);
2000 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
2001 if (r->out.info == NULL) {
2006 r->out.result = _lsa_QueryTrustedDomainInfo(p, r);
2008 if (p->rng_fault_state) {
2010 /* Return True here, srv_pipe_hnd.c will take care */
2014 if (DEBUGLEVEL >= 10)
2015 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, r);
2017 push = ndr_push_init_ctx(r);
2023 status = call->ndr_push(push, NDR_OUT, r);
2024 if (NT_STATUS_IS_ERR(status)) {
2029 blob = ndr_push_blob(push);
2030 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2040 static bool api_lsa_SetInformationTrustedDomain(pipes_struct *p)
2042 const struct ndr_interface_call *call;
2043 struct ndr_pull *pull;
2044 struct ndr_push *push;
2047 struct lsa_SetInformationTrustedDomain *r;
2049 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN];
2051 r = talloc(NULL, struct lsa_SetInformationTrustedDomain);
2056 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2061 pull = ndr_pull_init_blob(&blob, r);
2067 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2068 status = call->ndr_pull(pull, NDR_IN, r);
2069 if (NT_STATUS_IS_ERR(status)) {
2074 if (DEBUGLEVEL >= 10)
2075 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, r);
2077 r->out.result = _lsa_SetInformationTrustedDomain(p, r);
2079 if (p->rng_fault_state) {
2081 /* Return True here, srv_pipe_hnd.c will take care */
2085 if (DEBUGLEVEL >= 10)
2086 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, r);
2088 push = ndr_push_init_ctx(r);
2094 status = call->ndr_push(push, NDR_OUT, r);
2095 if (NT_STATUS_IS_ERR(status)) {
2100 blob = ndr_push_blob(push);
2101 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2111 static bool api_lsa_OpenSecret(pipes_struct *p)
2113 const struct ndr_interface_call *call;
2114 struct ndr_pull *pull;
2115 struct ndr_push *push;
2118 struct lsa_OpenSecret *r;
2120 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENSECRET];
2122 r = talloc(NULL, struct lsa_OpenSecret);
2127 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2132 pull = ndr_pull_init_blob(&blob, r);
2138 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2139 status = call->ndr_pull(pull, NDR_IN, r);
2140 if (NT_STATUS_IS_ERR(status)) {
2145 if (DEBUGLEVEL >= 10)
2146 NDR_PRINT_IN_DEBUG(lsa_OpenSecret, r);
2148 ZERO_STRUCT(r->out);
2149 r->out.sec_handle = talloc_zero(r, struct policy_handle);
2150 if (r->out.sec_handle == NULL) {
2155 r->out.result = _lsa_OpenSecret(p, r);
2157 if (p->rng_fault_state) {
2159 /* Return True here, srv_pipe_hnd.c will take care */
2163 if (DEBUGLEVEL >= 10)
2164 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, r);
2166 push = ndr_push_init_ctx(r);
2172 status = call->ndr_push(push, NDR_OUT, r);
2173 if (NT_STATUS_IS_ERR(status)) {
2178 blob = ndr_push_blob(push);
2179 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2189 static bool api_lsa_SetSecret(pipes_struct *p)
2191 const struct ndr_interface_call *call;
2192 struct ndr_pull *pull;
2193 struct ndr_push *push;
2196 struct lsa_SetSecret *r;
2198 call = &ndr_table_lsarpc.calls[NDR_LSA_SETSECRET];
2200 r = talloc(NULL, struct lsa_SetSecret);
2205 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2210 pull = ndr_pull_init_blob(&blob, r);
2216 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2217 status = call->ndr_pull(pull, NDR_IN, r);
2218 if (NT_STATUS_IS_ERR(status)) {
2223 if (DEBUGLEVEL >= 10)
2224 NDR_PRINT_IN_DEBUG(lsa_SetSecret, r);
2226 r->out.result = _lsa_SetSecret(p, r);
2228 if (p->rng_fault_state) {
2230 /* Return True here, srv_pipe_hnd.c will take care */
2234 if (DEBUGLEVEL >= 10)
2235 NDR_PRINT_OUT_DEBUG(lsa_SetSecret, r);
2237 push = ndr_push_init_ctx(r);
2243 status = call->ndr_push(push, NDR_OUT, r);
2244 if (NT_STATUS_IS_ERR(status)) {
2249 blob = ndr_push_blob(push);
2250 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2260 static bool api_lsa_QuerySecret(pipes_struct *p)
2262 const struct ndr_interface_call *call;
2263 struct ndr_pull *pull;
2264 struct ndr_push *push;
2267 struct lsa_QuerySecret *r;
2269 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYSECRET];
2271 r = talloc(NULL, struct lsa_QuerySecret);
2276 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2281 pull = ndr_pull_init_blob(&blob, r);
2287 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2288 status = call->ndr_pull(pull, NDR_IN, r);
2289 if (NT_STATUS_IS_ERR(status)) {
2294 if (DEBUGLEVEL >= 10)
2295 NDR_PRINT_IN_DEBUG(lsa_QuerySecret, r);
2297 ZERO_STRUCT(r->out);
2298 r->out.new_val = r->in.new_val;
2299 r->out.new_mtime = r->in.new_mtime;
2300 r->out.old_val = r->in.old_val;
2301 r->out.old_mtime = r->in.old_mtime;
2302 r->out.result = _lsa_QuerySecret(p, r);
2304 if (p->rng_fault_state) {
2306 /* Return True here, srv_pipe_hnd.c will take care */
2310 if (DEBUGLEVEL >= 10)
2311 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, r);
2313 push = ndr_push_init_ctx(r);
2319 status = call->ndr_push(push, NDR_OUT, r);
2320 if (NT_STATUS_IS_ERR(status)) {
2325 blob = ndr_push_blob(push);
2326 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2336 static bool api_lsa_LookupPrivValue(pipes_struct *p)
2338 const struct ndr_interface_call *call;
2339 struct ndr_pull *pull;
2340 struct ndr_push *push;
2343 struct lsa_LookupPrivValue *r;
2345 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVVALUE];
2347 r = talloc(NULL, struct lsa_LookupPrivValue);
2352 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2357 pull = ndr_pull_init_blob(&blob, r);
2363 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2364 status = call->ndr_pull(pull, NDR_IN, r);
2365 if (NT_STATUS_IS_ERR(status)) {
2370 if (DEBUGLEVEL >= 10)
2371 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, r);
2373 ZERO_STRUCT(r->out);
2374 r->out.luid = talloc_zero(r, struct lsa_LUID);
2375 if (r->out.luid == NULL) {
2380 r->out.result = _lsa_LookupPrivValue(p, r);
2382 if (p->rng_fault_state) {
2384 /* Return True here, srv_pipe_hnd.c will take care */
2388 if (DEBUGLEVEL >= 10)
2389 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, r);
2391 push = ndr_push_init_ctx(r);
2397 status = call->ndr_push(push, NDR_OUT, r);
2398 if (NT_STATUS_IS_ERR(status)) {
2403 blob = ndr_push_blob(push);
2404 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2414 static bool api_lsa_LookupPrivName(pipes_struct *p)
2416 const struct ndr_interface_call *call;
2417 struct ndr_pull *pull;
2418 struct ndr_push *push;
2421 struct lsa_LookupPrivName *r;
2423 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVNAME];
2425 r = talloc(NULL, struct lsa_LookupPrivName);
2430 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2435 pull = ndr_pull_init_blob(&blob, r);
2441 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2442 status = call->ndr_pull(pull, NDR_IN, r);
2443 if (NT_STATUS_IS_ERR(status)) {
2448 if (DEBUGLEVEL >= 10)
2449 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, r);
2451 ZERO_STRUCT(r->out);
2452 r->out.name = talloc_zero(r, struct lsa_StringLarge);
2453 if (r->out.name == NULL) {
2458 r->out.result = _lsa_LookupPrivName(p, r);
2460 if (p->rng_fault_state) {
2462 /* Return True here, srv_pipe_hnd.c will take care */
2466 if (DEBUGLEVEL >= 10)
2467 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, r);
2469 push = ndr_push_init_ctx(r);
2475 status = call->ndr_push(push, NDR_OUT, r);
2476 if (NT_STATUS_IS_ERR(status)) {
2481 blob = ndr_push_blob(push);
2482 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2492 static bool api_lsa_LookupPrivDisplayName(pipes_struct *p)
2494 const struct ndr_interface_call *call;
2495 struct ndr_pull *pull;
2496 struct ndr_push *push;
2499 struct lsa_LookupPrivDisplayName *r;
2501 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPPRIVDISPLAYNAME];
2503 r = talloc(NULL, struct lsa_LookupPrivDisplayName);
2508 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2513 pull = ndr_pull_init_blob(&blob, r);
2519 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2520 status = call->ndr_pull(pull, NDR_IN, r);
2521 if (NT_STATUS_IS_ERR(status)) {
2526 if (DEBUGLEVEL >= 10)
2527 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, r);
2529 ZERO_STRUCT(r->out);
2530 r->out.disp_name = talloc_zero(r, struct lsa_StringLarge);
2531 if (r->out.disp_name == NULL) {
2536 r->out.language_id = r->in.language_id;
2537 r->out.result = _lsa_LookupPrivDisplayName(p, r);
2539 if (p->rng_fault_state) {
2541 /* Return True here, srv_pipe_hnd.c will take care */
2545 if (DEBUGLEVEL >= 10)
2546 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, r);
2548 push = ndr_push_init_ctx(r);
2554 status = call->ndr_push(push, NDR_OUT, r);
2555 if (NT_STATUS_IS_ERR(status)) {
2560 blob = ndr_push_blob(push);
2561 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2571 static bool api_lsa_DeleteObject(pipes_struct *p)
2573 const struct ndr_interface_call *call;
2574 struct ndr_pull *pull;
2575 struct ndr_push *push;
2578 struct lsa_DeleteObject *r;
2580 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETEOBJECT];
2582 r = talloc(NULL, struct lsa_DeleteObject);
2587 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2592 pull = ndr_pull_init_blob(&blob, r);
2598 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2599 status = call->ndr_pull(pull, NDR_IN, r);
2600 if (NT_STATUS_IS_ERR(status)) {
2605 if (DEBUGLEVEL >= 10)
2606 NDR_PRINT_IN_DEBUG(lsa_DeleteObject, r);
2608 r->out.result = _lsa_DeleteObject(p, r);
2610 if (p->rng_fault_state) {
2612 /* Return True here, srv_pipe_hnd.c will take care */
2616 if (DEBUGLEVEL >= 10)
2617 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, r);
2619 push = ndr_push_init_ctx(r);
2625 status = call->ndr_push(push, NDR_OUT, r);
2626 if (NT_STATUS_IS_ERR(status)) {
2631 blob = ndr_push_blob(push);
2632 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2642 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct *p)
2644 const struct ndr_interface_call *call;
2645 struct ndr_pull *pull;
2646 struct ndr_push *push;
2649 struct lsa_EnumAccountsWithUserRight *r;
2651 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT];
2653 r = talloc(NULL, struct lsa_EnumAccountsWithUserRight);
2658 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2663 pull = ndr_pull_init_blob(&blob, r);
2669 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2670 status = call->ndr_pull(pull, NDR_IN, r);
2671 if (NT_STATUS_IS_ERR(status)) {
2676 if (DEBUGLEVEL >= 10)
2677 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, r);
2679 ZERO_STRUCT(r->out);
2680 r->out.sids = talloc_zero(r, struct lsa_SidArray);
2681 if (r->out.sids == NULL) {
2686 r->out.result = _lsa_EnumAccountsWithUserRight(p, r);
2688 if (p->rng_fault_state) {
2690 /* Return True here, srv_pipe_hnd.c will take care */
2694 if (DEBUGLEVEL >= 10)
2695 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, r);
2697 push = ndr_push_init_ctx(r);
2703 status = call->ndr_push(push, NDR_OUT, r);
2704 if (NT_STATUS_IS_ERR(status)) {
2709 blob = ndr_push_blob(push);
2710 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2720 static bool api_lsa_EnumAccountRights(pipes_struct *p)
2722 const struct ndr_interface_call *call;
2723 struct ndr_pull *pull;
2724 struct ndr_push *push;
2727 struct lsa_EnumAccountRights *r;
2729 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMACCOUNTRIGHTS];
2731 r = talloc(NULL, struct lsa_EnumAccountRights);
2736 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2741 pull = ndr_pull_init_blob(&blob, r);
2747 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2748 status = call->ndr_pull(pull, NDR_IN, r);
2749 if (NT_STATUS_IS_ERR(status)) {
2754 if (DEBUGLEVEL >= 10)
2755 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, r);
2757 ZERO_STRUCT(r->out);
2758 r->out.rights = talloc_zero(r, struct lsa_RightSet);
2759 if (r->out.rights == NULL) {
2764 r->out.result = _lsa_EnumAccountRights(p, r);
2766 if (p->rng_fault_state) {
2768 /* Return True here, srv_pipe_hnd.c will take care */
2772 if (DEBUGLEVEL >= 10)
2773 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, r);
2775 push = ndr_push_init_ctx(r);
2781 status = call->ndr_push(push, NDR_OUT, r);
2782 if (NT_STATUS_IS_ERR(status)) {
2787 blob = ndr_push_blob(push);
2788 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2798 static bool api_lsa_AddAccountRights(pipes_struct *p)
2800 const struct ndr_interface_call *call;
2801 struct ndr_pull *pull;
2802 struct ndr_push *push;
2805 struct lsa_AddAccountRights *r;
2807 call = &ndr_table_lsarpc.calls[NDR_LSA_ADDACCOUNTRIGHTS];
2809 r = talloc(NULL, struct lsa_AddAccountRights);
2814 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2819 pull = ndr_pull_init_blob(&blob, r);
2825 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2826 status = call->ndr_pull(pull, NDR_IN, r);
2827 if (NT_STATUS_IS_ERR(status)) {
2832 if (DEBUGLEVEL >= 10)
2833 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, r);
2835 r->out.result = _lsa_AddAccountRights(p, r);
2837 if (p->rng_fault_state) {
2839 /* Return True here, srv_pipe_hnd.c will take care */
2843 if (DEBUGLEVEL >= 10)
2844 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, r);
2846 push = ndr_push_init_ctx(r);
2852 status = call->ndr_push(push, NDR_OUT, r);
2853 if (NT_STATUS_IS_ERR(status)) {
2858 blob = ndr_push_blob(push);
2859 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2869 static bool api_lsa_RemoveAccountRights(pipes_struct *p)
2871 const struct ndr_interface_call *call;
2872 struct ndr_pull *pull;
2873 struct ndr_push *push;
2876 struct lsa_RemoveAccountRights *r;
2878 call = &ndr_table_lsarpc.calls[NDR_LSA_REMOVEACCOUNTRIGHTS];
2880 r = talloc(NULL, struct lsa_RemoveAccountRights);
2885 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2890 pull = ndr_pull_init_blob(&blob, r);
2896 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2897 status = call->ndr_pull(pull, NDR_IN, r);
2898 if (NT_STATUS_IS_ERR(status)) {
2903 if (DEBUGLEVEL >= 10)
2904 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, r);
2906 r->out.result = _lsa_RemoveAccountRights(p, r);
2908 if (p->rng_fault_state) {
2910 /* Return True here, srv_pipe_hnd.c will take care */
2914 if (DEBUGLEVEL >= 10)
2915 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, r);
2917 push = ndr_push_init_ctx(r);
2923 status = call->ndr_push(push, NDR_OUT, r);
2924 if (NT_STATUS_IS_ERR(status)) {
2929 blob = ndr_push_blob(push);
2930 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2940 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct *p)
2942 const struct ndr_interface_call *call;
2943 struct ndr_pull *pull;
2944 struct ndr_push *push;
2947 struct lsa_QueryTrustedDomainInfoBySid *r;
2949 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID];
2951 r = talloc(NULL, struct lsa_QueryTrustedDomainInfoBySid);
2956 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2961 pull = ndr_pull_init_blob(&blob, r);
2967 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2968 status = call->ndr_pull(pull, NDR_IN, r);
2969 if (NT_STATUS_IS_ERR(status)) {
2974 if (DEBUGLEVEL >= 10)
2975 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
2977 ZERO_STRUCT(r->out);
2978 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
2979 if (r->out.info == NULL) {
2984 r->out.result = _lsa_QueryTrustedDomainInfoBySid(p, r);
2986 if (p->rng_fault_state) {
2988 /* Return True here, srv_pipe_hnd.c will take care */
2992 if (DEBUGLEVEL >= 10)
2993 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, r);
2995 push = ndr_push_init_ctx(r);
3001 status = call->ndr_push(push, NDR_OUT, r);
3002 if (NT_STATUS_IS_ERR(status)) {
3007 blob = ndr_push_blob(push);
3008 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3018 static bool api_lsa_SetTrustedDomainInfo(pipes_struct *p)
3020 const struct ndr_interface_call *call;
3021 struct ndr_pull *pull;
3022 struct ndr_push *push;
3025 struct lsa_SetTrustedDomainInfo *r;
3027 call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFO];
3029 r = talloc(NULL, struct lsa_SetTrustedDomainInfo);
3034 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3039 pull = ndr_pull_init_blob(&blob, r);
3045 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3046 status = call->ndr_pull(pull, NDR_IN, r);
3047 if (NT_STATUS_IS_ERR(status)) {
3052 if (DEBUGLEVEL >= 10)
3053 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, r);
3055 r->out.result = _lsa_SetTrustedDomainInfo(p, r);
3057 if (p->rng_fault_state) {
3059 /* Return True here, srv_pipe_hnd.c will take care */
3063 if (DEBUGLEVEL >= 10)
3064 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, r);
3066 push = ndr_push_init_ctx(r);
3072 status = call->ndr_push(push, NDR_OUT, r);
3073 if (NT_STATUS_IS_ERR(status)) {
3078 blob = ndr_push_blob(push);
3079 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3089 static bool api_lsa_DeleteTrustedDomain(pipes_struct *p)
3091 const struct ndr_interface_call *call;
3092 struct ndr_pull *pull;
3093 struct ndr_push *push;
3096 struct lsa_DeleteTrustedDomain *r;
3098 call = &ndr_table_lsarpc.calls[NDR_LSA_DELETETRUSTEDDOMAIN];
3100 r = talloc(NULL, struct lsa_DeleteTrustedDomain);
3105 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3110 pull = ndr_pull_init_blob(&blob, r);
3116 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3117 status = call->ndr_pull(pull, NDR_IN, r);
3118 if (NT_STATUS_IS_ERR(status)) {
3123 if (DEBUGLEVEL >= 10)
3124 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, r);
3126 r->out.result = _lsa_DeleteTrustedDomain(p, r);
3128 if (p->rng_fault_state) {
3130 /* Return True here, srv_pipe_hnd.c will take care */
3134 if (DEBUGLEVEL >= 10)
3135 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, r);
3137 push = ndr_push_init_ctx(r);
3143 status = call->ndr_push(push, NDR_OUT, r);
3144 if (NT_STATUS_IS_ERR(status)) {
3149 blob = ndr_push_blob(push);
3150 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3160 static bool api_lsa_StorePrivateData(pipes_struct *p)
3162 const struct ndr_interface_call *call;
3163 struct ndr_pull *pull;
3164 struct ndr_push *push;
3167 struct lsa_StorePrivateData *r;
3169 call = &ndr_table_lsarpc.calls[NDR_LSA_STOREPRIVATEDATA];
3171 r = talloc(NULL, struct lsa_StorePrivateData);
3176 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3181 pull = ndr_pull_init_blob(&blob, r);
3187 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3188 status = call->ndr_pull(pull, NDR_IN, r);
3189 if (NT_STATUS_IS_ERR(status)) {
3194 if (DEBUGLEVEL >= 10)
3195 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, r);
3197 r->out.result = _lsa_StorePrivateData(p, r);
3199 if (p->rng_fault_state) {
3201 /* Return True here, srv_pipe_hnd.c will take care */
3205 if (DEBUGLEVEL >= 10)
3206 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, r);
3208 push = ndr_push_init_ctx(r);
3214 status = call->ndr_push(push, NDR_OUT, r);
3215 if (NT_STATUS_IS_ERR(status)) {
3220 blob = ndr_push_blob(push);
3221 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3231 static bool api_lsa_RetrievePrivateData(pipes_struct *p)
3233 const struct ndr_interface_call *call;
3234 struct ndr_pull *pull;
3235 struct ndr_push *push;
3238 struct lsa_RetrievePrivateData *r;
3240 call = &ndr_table_lsarpc.calls[NDR_LSA_RETRIEVEPRIVATEDATA];
3242 r = talloc(NULL, struct lsa_RetrievePrivateData);
3247 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3252 pull = ndr_pull_init_blob(&blob, r);
3258 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3259 status = call->ndr_pull(pull, NDR_IN, r);
3260 if (NT_STATUS_IS_ERR(status)) {
3265 if (DEBUGLEVEL >= 10)
3266 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, r);
3268 r->out.result = _lsa_RetrievePrivateData(p, r);
3270 if (p->rng_fault_state) {
3272 /* Return True here, srv_pipe_hnd.c will take care */
3276 if (DEBUGLEVEL >= 10)
3277 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, r);
3279 push = ndr_push_init_ctx(r);
3285 status = call->ndr_push(push, NDR_OUT, r);
3286 if (NT_STATUS_IS_ERR(status)) {
3291 blob = ndr_push_blob(push);
3292 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3302 static bool api_lsa_OpenPolicy2(pipes_struct *p)
3304 const struct ndr_interface_call *call;
3305 struct ndr_pull *pull;
3306 struct ndr_push *push;
3309 struct lsa_OpenPolicy2 *r;
3311 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENPOLICY2];
3313 r = talloc(NULL, struct lsa_OpenPolicy2);
3318 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3323 pull = ndr_pull_init_blob(&blob, r);
3329 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3330 status = call->ndr_pull(pull, NDR_IN, r);
3331 if (NT_STATUS_IS_ERR(status)) {
3336 if (DEBUGLEVEL >= 10)
3337 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, r);
3339 ZERO_STRUCT(r->out);
3340 r->out.handle = talloc_zero(r, struct policy_handle);
3341 if (r->out.handle == NULL) {
3346 r->out.result = _lsa_OpenPolicy2(p, r);
3348 if (p->rng_fault_state) {
3350 /* Return True here, srv_pipe_hnd.c will take care */
3354 if (DEBUGLEVEL >= 10)
3355 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, r);
3357 push = ndr_push_init_ctx(r);
3363 status = call->ndr_push(push, NDR_OUT, r);
3364 if (NT_STATUS_IS_ERR(status)) {
3369 blob = ndr_push_blob(push);
3370 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3380 static bool api_lsa_GetUserName(pipes_struct *p)
3382 const struct ndr_interface_call *call;
3383 struct ndr_pull *pull;
3384 struct ndr_push *push;
3387 struct lsa_GetUserName *r;
3389 call = &ndr_table_lsarpc.calls[NDR_LSA_GETUSERNAME];
3391 r = talloc(NULL, struct lsa_GetUserName);
3396 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3401 pull = ndr_pull_init_blob(&blob, r);
3407 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3408 status = call->ndr_pull(pull, NDR_IN, r);
3409 if (NT_STATUS_IS_ERR(status)) {
3414 if (DEBUGLEVEL >= 10)
3415 NDR_PRINT_IN_DEBUG(lsa_GetUserName, r);
3417 ZERO_STRUCT(r->out);
3418 r->out.account_name = r->in.account_name;
3419 r->out.authority_name = r->in.authority_name;
3420 r->out.result = _lsa_GetUserName(p, r);
3422 if (p->rng_fault_state) {
3424 /* Return True here, srv_pipe_hnd.c will take care */
3428 if (DEBUGLEVEL >= 10)
3429 NDR_PRINT_OUT_DEBUG(lsa_GetUserName, r);
3431 push = ndr_push_init_ctx(r);
3437 status = call->ndr_push(push, NDR_OUT, r);
3438 if (NT_STATUS_IS_ERR(status)) {
3443 blob = ndr_push_blob(push);
3444 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3454 static bool api_lsa_QueryInfoPolicy2(pipes_struct *p)
3456 const struct ndr_interface_call *call;
3457 struct ndr_pull *pull;
3458 struct ndr_push *push;
3461 struct lsa_QueryInfoPolicy2 *r;
3463 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYINFOPOLICY2];
3465 r = talloc(NULL, struct lsa_QueryInfoPolicy2);
3470 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3475 pull = ndr_pull_init_blob(&blob, r);
3481 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3482 status = call->ndr_pull(pull, NDR_IN, r);
3483 if (NT_STATUS_IS_ERR(status)) {
3488 if (DEBUGLEVEL >= 10)
3489 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2, r);
3491 ZERO_STRUCT(r->out);
3492 r->out.info = talloc_zero(r, union lsa_PolicyInformation);
3493 if (r->out.info == NULL) {
3498 r->out.result = _lsa_QueryInfoPolicy2(p, r);
3500 if (p->rng_fault_state) {
3502 /* Return True here, srv_pipe_hnd.c will take care */
3506 if (DEBUGLEVEL >= 10)
3507 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, r);
3509 push = ndr_push_init_ctx(r);
3515 status = call->ndr_push(push, NDR_OUT, r);
3516 if (NT_STATUS_IS_ERR(status)) {
3521 blob = ndr_push_blob(push);
3522 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3532 static bool api_lsa_SetInfoPolicy2(pipes_struct *p)
3534 const struct ndr_interface_call *call;
3535 struct ndr_pull *pull;
3536 struct ndr_push *push;
3539 struct lsa_SetInfoPolicy2 *r;
3541 call = &ndr_table_lsarpc.calls[NDR_LSA_SETINFOPOLICY2];
3543 r = talloc(NULL, struct lsa_SetInfoPolicy2);
3548 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3553 pull = ndr_pull_init_blob(&blob, r);
3559 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3560 status = call->ndr_pull(pull, NDR_IN, r);
3561 if (NT_STATUS_IS_ERR(status)) {
3566 if (DEBUGLEVEL >= 10)
3567 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, r);
3569 r->out.result = _lsa_SetInfoPolicy2(p, r);
3571 if (p->rng_fault_state) {
3573 /* Return True here, srv_pipe_hnd.c will take care */
3577 if (DEBUGLEVEL >= 10)
3578 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, r);
3580 push = ndr_push_init_ctx(r);
3586 status = call->ndr_push(push, NDR_OUT, r);
3587 if (NT_STATUS_IS_ERR(status)) {
3592 blob = ndr_push_blob(push);
3593 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3603 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct *p)
3605 const struct ndr_interface_call *call;
3606 struct ndr_pull *pull;
3607 struct ndr_push *push;
3610 struct lsa_QueryTrustedDomainInfoByName *r;
3612 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME];
3614 r = talloc(NULL, struct lsa_QueryTrustedDomainInfoByName);
3619 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3624 pull = ndr_pull_init_blob(&blob, r);
3630 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3631 status = call->ndr_pull(pull, NDR_IN, r);
3632 if (NT_STATUS_IS_ERR(status)) {
3637 if (DEBUGLEVEL >= 10)
3638 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3640 ZERO_STRUCT(r->out);
3641 r->out.info = talloc_zero(r, union lsa_TrustedDomainInfo);
3642 if (r->out.info == NULL) {
3647 r->out.result = _lsa_QueryTrustedDomainInfoByName(p, r);
3649 if (p->rng_fault_state) {
3651 /* Return True here, srv_pipe_hnd.c will take care */
3655 if (DEBUGLEVEL >= 10)
3656 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, r);
3658 push = ndr_push_init_ctx(r);
3664 status = call->ndr_push(push, NDR_OUT, r);
3665 if (NT_STATUS_IS_ERR(status)) {
3670 blob = ndr_push_blob(push);
3671 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3681 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct *p)
3683 const struct ndr_interface_call *call;
3684 struct ndr_pull *pull;
3685 struct ndr_push *push;
3688 struct lsa_SetTrustedDomainInfoByName *r;
3690 call = &ndr_table_lsarpc.calls[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME];
3692 r = talloc(NULL, struct lsa_SetTrustedDomainInfoByName);
3697 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3702 pull = ndr_pull_init_blob(&blob, r);
3708 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3709 status = call->ndr_pull(pull, NDR_IN, r);
3710 if (NT_STATUS_IS_ERR(status)) {
3715 if (DEBUGLEVEL >= 10)
3716 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3718 r->out.result = _lsa_SetTrustedDomainInfoByName(p, r);
3720 if (p->rng_fault_state) {
3722 /* Return True here, srv_pipe_hnd.c will take care */
3726 if (DEBUGLEVEL >= 10)
3727 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, r);
3729 push = ndr_push_init_ctx(r);
3735 status = call->ndr_push(push, NDR_OUT, r);
3736 if (NT_STATUS_IS_ERR(status)) {
3741 blob = ndr_push_blob(push);
3742 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3752 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct *p)
3754 const struct ndr_interface_call *call;
3755 struct ndr_pull *pull;
3756 struct ndr_push *push;
3759 struct lsa_EnumTrustedDomainsEx *r;
3761 call = &ndr_table_lsarpc.calls[NDR_LSA_ENUMTRUSTEDDOMAINSEX];
3763 r = talloc(NULL, struct lsa_EnumTrustedDomainsEx);
3768 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3773 pull = ndr_pull_init_blob(&blob, r);
3779 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3780 status = call->ndr_pull(pull, NDR_IN, r);
3781 if (NT_STATUS_IS_ERR(status)) {
3786 if (DEBUGLEVEL >= 10)
3787 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, r);
3789 ZERO_STRUCT(r->out);
3790 r->out.resume_handle = r->in.resume_handle;
3791 r->out.domains = talloc_zero(r, struct lsa_DomainListEx);
3792 if (r->out.domains == NULL) {
3797 r->out.result = _lsa_EnumTrustedDomainsEx(p, r);
3799 if (p->rng_fault_state) {
3801 /* Return True here, srv_pipe_hnd.c will take care */
3805 if (DEBUGLEVEL >= 10)
3806 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, r);
3808 push = ndr_push_init_ctx(r);
3814 status = call->ndr_push(push, NDR_OUT, r);
3815 if (NT_STATUS_IS_ERR(status)) {
3820 blob = ndr_push_blob(push);
3821 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3831 static bool api_lsa_CreateTrustedDomainEx(pipes_struct *p)
3833 const struct ndr_interface_call *call;
3834 struct ndr_pull *pull;
3835 struct ndr_push *push;
3838 struct lsa_CreateTrustedDomainEx *r;
3840 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX];
3842 r = talloc(NULL, struct lsa_CreateTrustedDomainEx);
3847 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3852 pull = ndr_pull_init_blob(&blob, r);
3858 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3859 status = call->ndr_pull(pull, NDR_IN, r);
3860 if (NT_STATUS_IS_ERR(status)) {
3865 if (DEBUGLEVEL >= 10)
3866 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, r);
3868 r->out.result = _lsa_CreateTrustedDomainEx(p, r);
3870 if (p->rng_fault_state) {
3872 /* Return True here, srv_pipe_hnd.c will take care */
3876 if (DEBUGLEVEL >= 10)
3877 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, r);
3879 push = ndr_push_init_ctx(r);
3885 status = call->ndr_push(push, NDR_OUT, r);
3886 if (NT_STATUS_IS_ERR(status)) {
3891 blob = ndr_push_blob(push);
3892 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3902 static bool api_lsa_CloseTrustedDomainEx(pipes_struct *p)
3904 const struct ndr_interface_call *call;
3905 struct ndr_pull *pull;
3906 struct ndr_push *push;
3909 struct lsa_CloseTrustedDomainEx *r;
3911 call = &ndr_table_lsarpc.calls[NDR_LSA_CLOSETRUSTEDDOMAINEX];
3913 r = talloc(NULL, struct lsa_CloseTrustedDomainEx);
3918 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3923 pull = ndr_pull_init_blob(&blob, r);
3929 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3930 status = call->ndr_pull(pull, NDR_IN, r);
3931 if (NT_STATUS_IS_ERR(status)) {
3936 if (DEBUGLEVEL >= 10)
3937 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, r);
3939 ZERO_STRUCT(r->out);
3940 r->out.handle = r->in.handle;
3941 r->out.result = _lsa_CloseTrustedDomainEx(p, r);
3943 if (p->rng_fault_state) {
3945 /* Return True here, srv_pipe_hnd.c will take care */
3949 if (DEBUGLEVEL >= 10)
3950 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, r);
3952 push = ndr_push_init_ctx(r);
3958 status = call->ndr_push(push, NDR_OUT, r);
3959 if (NT_STATUS_IS_ERR(status)) {
3964 blob = ndr_push_blob(push);
3965 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
3975 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct *p)
3977 const struct ndr_interface_call *call;
3978 struct ndr_pull *pull;
3979 struct ndr_push *push;
3982 struct lsa_QueryDomainInformationPolicy *r;
3984 call = &ndr_table_lsarpc.calls[NDR_LSA_QUERYDOMAININFORMATIONPOLICY];
3986 r = talloc(NULL, struct lsa_QueryDomainInformationPolicy);
3991 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3996 pull = ndr_pull_init_blob(&blob, r);
4002 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4003 status = call->ndr_pull(pull, NDR_IN, r);
4004 if (NT_STATUS_IS_ERR(status)) {
4009 if (DEBUGLEVEL >= 10)
4010 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy, r);
4012 ZERO_STRUCT(r->out);
4013 r->out.info = talloc_zero(r, union lsa_DomainInformationPolicy);
4014 if (r->out.info == NULL) {
4019 r->out.result = _lsa_QueryDomainInformationPolicy(p, r);
4021 if (p->rng_fault_state) {
4023 /* Return True here, srv_pipe_hnd.c will take care */
4027 if (DEBUGLEVEL >= 10)
4028 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, r);
4030 push = ndr_push_init_ctx(r);
4036 status = call->ndr_push(push, NDR_OUT, r);
4037 if (NT_STATUS_IS_ERR(status)) {
4042 blob = ndr_push_blob(push);
4043 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4053 static bool api_lsa_SetDomainInformationPolicy(pipes_struct *p)
4055 const struct ndr_interface_call *call;
4056 struct ndr_pull *pull;
4057 struct ndr_push *push;
4060 struct lsa_SetDomainInformationPolicy *r;
4062 call = &ndr_table_lsarpc.calls[NDR_LSA_SETDOMAININFORMATIONPOLICY];
4064 r = talloc(NULL, struct lsa_SetDomainInformationPolicy);
4069 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4074 pull = ndr_pull_init_blob(&blob, r);
4080 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4081 status = call->ndr_pull(pull, NDR_IN, r);
4082 if (NT_STATUS_IS_ERR(status)) {
4087 if (DEBUGLEVEL >= 10)
4088 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, r);
4090 r->out.result = _lsa_SetDomainInformationPolicy(p, r);
4092 if (p->rng_fault_state) {
4094 /* Return True here, srv_pipe_hnd.c will take care */
4098 if (DEBUGLEVEL >= 10)
4099 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, r);
4101 push = ndr_push_init_ctx(r);
4107 status = call->ndr_push(push, NDR_OUT, r);
4108 if (NT_STATUS_IS_ERR(status)) {
4113 blob = ndr_push_blob(push);
4114 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4124 static bool api_lsa_OpenTrustedDomainByName(pipes_struct *p)
4126 const struct ndr_interface_call *call;
4127 struct ndr_pull *pull;
4128 struct ndr_push *push;
4131 struct lsa_OpenTrustedDomainByName *r;
4133 call = &ndr_table_lsarpc.calls[NDR_LSA_OPENTRUSTEDDOMAINBYNAME];
4135 r = talloc(NULL, struct lsa_OpenTrustedDomainByName);
4140 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4145 pull = ndr_pull_init_blob(&blob, r);
4151 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4152 status = call->ndr_pull(pull, NDR_IN, r);
4153 if (NT_STATUS_IS_ERR(status)) {
4158 if (DEBUGLEVEL >= 10)
4159 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, r);
4161 ZERO_STRUCT(r->out);
4162 r->out.trustdom_handle = talloc_zero(r, struct policy_handle);
4163 if (r->out.trustdom_handle == NULL) {
4168 r->out.result = _lsa_OpenTrustedDomainByName(p, r);
4170 if (p->rng_fault_state) {
4172 /* Return True here, srv_pipe_hnd.c will take care */
4176 if (DEBUGLEVEL >= 10)
4177 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, r);
4179 push = ndr_push_init_ctx(r);
4185 status = call->ndr_push(push, NDR_OUT, r);
4186 if (NT_STATUS_IS_ERR(status)) {
4191 blob = ndr_push_blob(push);
4192 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4202 static bool api_lsa_TestCall(pipes_struct *p)
4204 const struct ndr_interface_call *call;
4205 struct ndr_pull *pull;
4206 struct ndr_push *push;
4209 struct lsa_TestCall *r;
4211 call = &ndr_table_lsarpc.calls[NDR_LSA_TESTCALL];
4213 r = talloc(NULL, struct lsa_TestCall);
4218 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4223 pull = ndr_pull_init_blob(&blob, r);
4229 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4230 status = call->ndr_pull(pull, NDR_IN, r);
4231 if (NT_STATUS_IS_ERR(status)) {
4236 if (DEBUGLEVEL >= 10)
4237 NDR_PRINT_IN_DEBUG(lsa_TestCall, r);
4239 r->out.result = _lsa_TestCall(p, r);
4241 if (p->rng_fault_state) {
4243 /* Return True here, srv_pipe_hnd.c will take care */
4247 if (DEBUGLEVEL >= 10)
4248 NDR_PRINT_OUT_DEBUG(lsa_TestCall, r);
4250 push = ndr_push_init_ctx(r);
4256 status = call->ndr_push(push, NDR_OUT, r);
4257 if (NT_STATUS_IS_ERR(status)) {
4262 blob = ndr_push_blob(push);
4263 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4273 static bool api_lsa_LookupSids2(pipes_struct *p)
4275 const struct ndr_interface_call *call;
4276 struct ndr_pull *pull;
4277 struct ndr_push *push;
4280 struct lsa_LookupSids2 *r;
4282 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS2];
4284 r = talloc(NULL, struct lsa_LookupSids2);
4289 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4294 pull = ndr_pull_init_blob(&blob, r);
4300 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4301 status = call->ndr_pull(pull, NDR_IN, r);
4302 if (NT_STATUS_IS_ERR(status)) {
4307 if (DEBUGLEVEL >= 10)
4308 NDR_PRINT_IN_DEBUG(lsa_LookupSids2, r);
4310 ZERO_STRUCT(r->out);
4311 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
4312 if (r->out.domains == NULL) {
4317 r->out.names = r->in.names;
4318 r->out.count = r->in.count;
4319 r->out.result = _lsa_LookupSids2(p, r);
4321 if (p->rng_fault_state) {
4323 /* Return True here, srv_pipe_hnd.c will take care */
4327 if (DEBUGLEVEL >= 10)
4328 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, r);
4330 push = ndr_push_init_ctx(r);
4336 status = call->ndr_push(push, NDR_OUT, r);
4337 if (NT_STATUS_IS_ERR(status)) {
4342 blob = ndr_push_blob(push);
4343 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4353 static bool api_lsa_LookupNames2(pipes_struct *p)
4355 const struct ndr_interface_call *call;
4356 struct ndr_pull *pull;
4357 struct ndr_push *push;
4360 struct lsa_LookupNames2 *r;
4362 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES2];
4364 r = talloc(NULL, struct lsa_LookupNames2);
4369 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4374 pull = ndr_pull_init_blob(&blob, r);
4380 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4381 status = call->ndr_pull(pull, NDR_IN, r);
4382 if (NT_STATUS_IS_ERR(status)) {
4387 if (DEBUGLEVEL >= 10)
4388 NDR_PRINT_IN_DEBUG(lsa_LookupNames2, r);
4390 ZERO_STRUCT(r->out);
4391 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
4392 if (r->out.domains == NULL) {
4397 r->out.sids = r->in.sids;
4398 r->out.count = r->in.count;
4399 r->out.result = _lsa_LookupNames2(p, r);
4401 if (p->rng_fault_state) {
4403 /* Return True here, srv_pipe_hnd.c will take care */
4407 if (DEBUGLEVEL >= 10)
4408 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, r);
4410 push = ndr_push_init_ctx(r);
4416 status = call->ndr_push(push, NDR_OUT, r);
4417 if (NT_STATUS_IS_ERR(status)) {
4422 blob = ndr_push_blob(push);
4423 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4433 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct *p)
4435 const struct ndr_interface_call *call;
4436 struct ndr_pull *pull;
4437 struct ndr_push *push;
4440 struct lsa_CreateTrustedDomainEx2 *r;
4442 call = &ndr_table_lsarpc.calls[NDR_LSA_CREATETRUSTEDDOMAINEX2];
4444 r = talloc(NULL, struct lsa_CreateTrustedDomainEx2);
4449 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4454 pull = ndr_pull_init_blob(&blob, r);
4460 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4461 status = call->ndr_pull(pull, NDR_IN, r);
4462 if (NT_STATUS_IS_ERR(status)) {
4467 if (DEBUGLEVEL >= 10)
4468 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, r);
4470 r->out.result = _lsa_CreateTrustedDomainEx2(p, r);
4472 if (p->rng_fault_state) {
4474 /* Return True here, srv_pipe_hnd.c will take care */
4478 if (DEBUGLEVEL >= 10)
4479 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, r);
4481 push = ndr_push_init_ctx(r);
4487 status = call->ndr_push(push, NDR_OUT, r);
4488 if (NT_STATUS_IS_ERR(status)) {
4493 blob = ndr_push_blob(push);
4494 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4504 static bool api_lsa_CREDRWRITE(pipes_struct *p)
4506 const struct ndr_interface_call *call;
4507 struct ndr_pull *pull;
4508 struct ndr_push *push;
4511 struct lsa_CREDRWRITE *r;
4513 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITE];
4515 r = talloc(NULL, struct lsa_CREDRWRITE);
4520 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4525 pull = ndr_pull_init_blob(&blob, r);
4531 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4532 status = call->ndr_pull(pull, NDR_IN, r);
4533 if (NT_STATUS_IS_ERR(status)) {
4538 if (DEBUGLEVEL >= 10)
4539 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, r);
4541 r->out.result = _lsa_CREDRWRITE(p, r);
4543 if (p->rng_fault_state) {
4545 /* Return True here, srv_pipe_hnd.c will take care */
4549 if (DEBUGLEVEL >= 10)
4550 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, r);
4552 push = ndr_push_init_ctx(r);
4558 status = call->ndr_push(push, NDR_OUT, r);
4559 if (NT_STATUS_IS_ERR(status)) {
4564 blob = ndr_push_blob(push);
4565 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4575 static bool api_lsa_CREDRREAD(pipes_struct *p)
4577 const struct ndr_interface_call *call;
4578 struct ndr_pull *pull;
4579 struct ndr_push *push;
4582 struct lsa_CREDRREAD *r;
4584 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREAD];
4586 r = talloc(NULL, struct lsa_CREDRREAD);
4591 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4596 pull = ndr_pull_init_blob(&blob, r);
4602 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4603 status = call->ndr_pull(pull, NDR_IN, r);
4604 if (NT_STATUS_IS_ERR(status)) {
4609 if (DEBUGLEVEL >= 10)
4610 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, r);
4612 r->out.result = _lsa_CREDRREAD(p, r);
4614 if (p->rng_fault_state) {
4616 /* Return True here, srv_pipe_hnd.c will take care */
4620 if (DEBUGLEVEL >= 10)
4621 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, r);
4623 push = ndr_push_init_ctx(r);
4629 status = call->ndr_push(push, NDR_OUT, r);
4630 if (NT_STATUS_IS_ERR(status)) {
4635 blob = ndr_push_blob(push);
4636 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4646 static bool api_lsa_CREDRENUMERATE(pipes_struct *p)
4648 const struct ndr_interface_call *call;
4649 struct ndr_pull *pull;
4650 struct ndr_push *push;
4653 struct lsa_CREDRENUMERATE *r;
4655 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRENUMERATE];
4657 r = talloc(NULL, struct lsa_CREDRENUMERATE);
4662 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4667 pull = ndr_pull_init_blob(&blob, r);
4673 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4674 status = call->ndr_pull(pull, NDR_IN, r);
4675 if (NT_STATUS_IS_ERR(status)) {
4680 if (DEBUGLEVEL >= 10)
4681 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, r);
4683 r->out.result = _lsa_CREDRENUMERATE(p, r);
4685 if (p->rng_fault_state) {
4687 /* Return True here, srv_pipe_hnd.c will take care */
4691 if (DEBUGLEVEL >= 10)
4692 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, r);
4694 push = ndr_push_init_ctx(r);
4700 status = call->ndr_push(push, NDR_OUT, r);
4701 if (NT_STATUS_IS_ERR(status)) {
4706 blob = ndr_push_blob(push);
4707 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4717 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
4719 const struct ndr_interface_call *call;
4720 struct ndr_pull *pull;
4721 struct ndr_push *push;
4724 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r;
4726 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS];
4728 r = talloc(NULL, struct lsa_CREDRWRITEDOMAINCREDENTIALS);
4733 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4738 pull = ndr_pull_init_blob(&blob, r);
4744 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4745 status = call->ndr_pull(pull, NDR_IN, r);
4746 if (NT_STATUS_IS_ERR(status)) {
4751 if (DEBUGLEVEL >= 10)
4752 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4754 r->out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, r);
4756 if (p->rng_fault_state) {
4758 /* Return True here, srv_pipe_hnd.c will take care */
4762 if (DEBUGLEVEL >= 10)
4763 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, r);
4765 push = ndr_push_init_ctx(r);
4771 status = call->ndr_push(push, NDR_OUT, r);
4772 if (NT_STATUS_IS_ERR(status)) {
4777 blob = ndr_push_blob(push);
4778 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4788 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
4790 const struct ndr_interface_call *call;
4791 struct ndr_pull *pull;
4792 struct ndr_push *push;
4795 struct lsa_CREDRREADDOMAINCREDENTIALS *r;
4797 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRREADDOMAINCREDENTIALS];
4799 r = talloc(NULL, struct lsa_CREDRREADDOMAINCREDENTIALS);
4804 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4809 pull = ndr_pull_init_blob(&blob, r);
4815 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4816 status = call->ndr_pull(pull, NDR_IN, r);
4817 if (NT_STATUS_IS_ERR(status)) {
4822 if (DEBUGLEVEL >= 10)
4823 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4825 r->out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, r);
4827 if (p->rng_fault_state) {
4829 /* Return True here, srv_pipe_hnd.c will take care */
4833 if (DEBUGLEVEL >= 10)
4834 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, r);
4836 push = ndr_push_init_ctx(r);
4842 status = call->ndr_push(push, NDR_OUT, r);
4843 if (NT_STATUS_IS_ERR(status)) {
4848 blob = ndr_push_blob(push);
4849 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4859 static bool api_lsa_CREDRDELETE(pipes_struct *p)
4861 const struct ndr_interface_call *call;
4862 struct ndr_pull *pull;
4863 struct ndr_push *push;
4866 struct lsa_CREDRDELETE *r;
4868 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRDELETE];
4870 r = talloc(NULL, struct lsa_CREDRDELETE);
4875 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4880 pull = ndr_pull_init_blob(&blob, r);
4886 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4887 status = call->ndr_pull(pull, NDR_IN, r);
4888 if (NT_STATUS_IS_ERR(status)) {
4893 if (DEBUGLEVEL >= 10)
4894 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, r);
4896 r->out.result = _lsa_CREDRDELETE(p, r);
4898 if (p->rng_fault_state) {
4900 /* Return True here, srv_pipe_hnd.c will take care */
4904 if (DEBUGLEVEL >= 10)
4905 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, r);
4907 push = ndr_push_init_ctx(r);
4913 status = call->ndr_push(push, NDR_OUT, r);
4914 if (NT_STATUS_IS_ERR(status)) {
4919 blob = ndr_push_blob(push);
4920 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
4930 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct *p)
4932 const struct ndr_interface_call *call;
4933 struct ndr_pull *pull;
4934 struct ndr_push *push;
4937 struct lsa_CREDRGETTARGETINFO *r;
4939 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETTARGETINFO];
4941 r = talloc(NULL, struct lsa_CREDRGETTARGETINFO);
4946 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4951 pull = ndr_pull_init_blob(&blob, r);
4957 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4958 status = call->ndr_pull(pull, NDR_IN, r);
4959 if (NT_STATUS_IS_ERR(status)) {
4964 if (DEBUGLEVEL >= 10)
4965 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, r);
4967 r->out.result = _lsa_CREDRGETTARGETINFO(p, r);
4969 if (p->rng_fault_state) {
4971 /* Return True here, srv_pipe_hnd.c will take care */
4975 if (DEBUGLEVEL >= 10)
4976 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, r);
4978 push = ndr_push_init_ctx(r);
4984 status = call->ndr_push(push, NDR_OUT, r);
4985 if (NT_STATUS_IS_ERR(status)) {
4990 blob = ndr_push_blob(push);
4991 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5001 static bool api_lsa_CREDRPROFILELOADED(pipes_struct *p)
5003 const struct ndr_interface_call *call;
5004 struct ndr_pull *pull;
5005 struct ndr_push *push;
5008 struct lsa_CREDRPROFILELOADED *r;
5010 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRPROFILELOADED];
5012 r = talloc(NULL, struct lsa_CREDRPROFILELOADED);
5017 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5022 pull = ndr_pull_init_blob(&blob, r);
5028 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5029 status = call->ndr_pull(pull, NDR_IN, r);
5030 if (NT_STATUS_IS_ERR(status)) {
5035 if (DEBUGLEVEL >= 10)
5036 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, r);
5038 r->out.result = _lsa_CREDRPROFILELOADED(p, r);
5040 if (p->rng_fault_state) {
5042 /* Return True here, srv_pipe_hnd.c will take care */
5046 if (DEBUGLEVEL >= 10)
5047 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, r);
5049 push = ndr_push_init_ctx(r);
5055 status = call->ndr_push(push, NDR_OUT, r);
5056 if (NT_STATUS_IS_ERR(status)) {
5061 blob = ndr_push_blob(push);
5062 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5072 static bool api_lsa_LookupNames3(pipes_struct *p)
5074 const struct ndr_interface_call *call;
5075 struct ndr_pull *pull;
5076 struct ndr_push *push;
5079 struct lsa_LookupNames3 *r;
5081 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES3];
5083 r = talloc(NULL, struct lsa_LookupNames3);
5088 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5093 pull = ndr_pull_init_blob(&blob, r);
5099 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5100 status = call->ndr_pull(pull, NDR_IN, r);
5101 if (NT_STATUS_IS_ERR(status)) {
5106 if (DEBUGLEVEL >= 10)
5107 NDR_PRINT_IN_DEBUG(lsa_LookupNames3, r);
5109 ZERO_STRUCT(r->out);
5110 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5111 if (r->out.domains == NULL) {
5116 r->out.sids = r->in.sids;
5117 r->out.count = r->in.count;
5118 r->out.result = _lsa_LookupNames3(p, r);
5120 if (p->rng_fault_state) {
5122 /* Return True here, srv_pipe_hnd.c will take care */
5126 if (DEBUGLEVEL >= 10)
5127 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, r);
5129 push = ndr_push_init_ctx(r);
5135 status = call->ndr_push(push, NDR_OUT, r);
5136 if (NT_STATUS_IS_ERR(status)) {
5141 blob = ndr_push_blob(push);
5142 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5152 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
5154 const struct ndr_interface_call *call;
5155 struct ndr_pull *pull;
5156 struct ndr_push *push;
5159 struct lsa_CREDRGETSESSIONTYPES *r;
5161 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRGETSESSIONTYPES];
5163 r = talloc(NULL, struct lsa_CREDRGETSESSIONTYPES);
5168 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5173 pull = ndr_pull_init_blob(&blob, r);
5179 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5180 status = call->ndr_pull(pull, NDR_IN, r);
5181 if (NT_STATUS_IS_ERR(status)) {
5186 if (DEBUGLEVEL >= 10)
5187 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5189 r->out.result = _lsa_CREDRGETSESSIONTYPES(p, r);
5191 if (p->rng_fault_state) {
5193 /* Return True here, srv_pipe_hnd.c will take care */
5197 if (DEBUGLEVEL >= 10)
5198 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, r);
5200 push = ndr_push_init_ctx(r);
5206 status = call->ndr_push(push, NDR_OUT, r);
5207 if (NT_STATUS_IS_ERR(status)) {
5212 blob = ndr_push_blob(push);
5213 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5223 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
5225 const struct ndr_interface_call *call;
5226 struct ndr_pull *pull;
5227 struct ndr_push *push;
5230 struct lsa_LSARREGISTERAUDITEVENT *r;
5232 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARREGISTERAUDITEVENT];
5234 r = talloc(NULL, struct lsa_LSARREGISTERAUDITEVENT);
5239 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5244 pull = ndr_pull_init_blob(&blob, r);
5250 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5251 status = call->ndr_pull(pull, NDR_IN, r);
5252 if (NT_STATUS_IS_ERR(status)) {
5257 if (DEBUGLEVEL >= 10)
5258 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5260 r->out.result = _lsa_LSARREGISTERAUDITEVENT(p, r);
5262 if (p->rng_fault_state) {
5264 /* Return True here, srv_pipe_hnd.c will take care */
5268 if (DEBUGLEVEL >= 10)
5269 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, r);
5271 push = ndr_push_init_ctx(r);
5277 status = call->ndr_push(push, NDR_OUT, r);
5278 if (NT_STATUS_IS_ERR(status)) {
5283 blob = ndr_push_blob(push);
5284 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5294 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct *p)
5296 const struct ndr_interface_call *call;
5297 struct ndr_pull *pull;
5298 struct ndr_push *push;
5301 struct lsa_LSARGENAUDITEVENT *r;
5303 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARGENAUDITEVENT];
5305 r = talloc(NULL, struct lsa_LSARGENAUDITEVENT);
5310 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5315 pull = ndr_pull_init_blob(&blob, r);
5321 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5322 status = call->ndr_pull(pull, NDR_IN, r);
5323 if (NT_STATUS_IS_ERR(status)) {
5328 if (DEBUGLEVEL >= 10)
5329 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, r);
5331 r->out.result = _lsa_LSARGENAUDITEVENT(p, r);
5333 if (p->rng_fault_state) {
5335 /* Return True here, srv_pipe_hnd.c will take care */
5339 if (DEBUGLEVEL >= 10)
5340 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, r);
5342 push = ndr_push_init_ctx(r);
5348 status = call->ndr_push(push, NDR_OUT, r);
5349 if (NT_STATUS_IS_ERR(status)) {
5354 blob = ndr_push_blob(push);
5355 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5365 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
5367 const struct ndr_interface_call *call;
5368 struct ndr_pull *pull;
5369 struct ndr_push *push;
5372 struct lsa_LSARUNREGISTERAUDITEVENT *r;
5374 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARUNREGISTERAUDITEVENT];
5376 r = talloc(NULL, struct lsa_LSARUNREGISTERAUDITEVENT);
5381 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5386 pull = ndr_pull_init_blob(&blob, r);
5392 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5393 status = call->ndr_pull(pull, NDR_IN, r);
5394 if (NT_STATUS_IS_ERR(status)) {
5399 if (DEBUGLEVEL >= 10)
5400 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5402 r->out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, r);
5404 if (p->rng_fault_state) {
5406 /* Return True here, srv_pipe_hnd.c will take care */
5410 if (DEBUGLEVEL >= 10)
5411 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, r);
5413 push = ndr_push_init_ctx(r);
5419 status = call->ndr_push(push, NDR_OUT, r);
5420 if (NT_STATUS_IS_ERR(status)) {
5425 blob = ndr_push_blob(push);
5426 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5436 static bool api_lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p)
5438 const struct ndr_interface_call *call;
5439 struct ndr_pull *pull;
5440 struct ndr_push *push;
5443 struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r;
5445 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION];
5447 r = talloc(NULL, struct lsa_LSARQUERYFORESTTRUSTINFORMATION);
5452 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5457 pull = ndr_pull_init_blob(&blob, r);
5463 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5464 status = call->ndr_pull(pull, NDR_IN, r);
5465 if (NT_STATUS_IS_ERR(status)) {
5470 if (DEBUGLEVEL >= 10)
5471 NDR_PRINT_IN_DEBUG(lsa_LSARQUERYFORESTTRUSTINFORMATION, r);
5473 r->out.result = _lsa_LSARQUERYFORESTTRUSTINFORMATION(p, r);
5475 if (p->rng_fault_state) {
5477 /* Return True here, srv_pipe_hnd.c will take care */
5481 if (DEBUGLEVEL >= 10)
5482 NDR_PRINT_OUT_DEBUG(lsa_LSARQUERYFORESTTRUSTINFORMATION, r);
5484 push = ndr_push_init_ctx(r);
5490 status = call->ndr_push(push, NDR_OUT, r);
5491 if (NT_STATUS_IS_ERR(status)) {
5496 blob = ndr_push_blob(push);
5497 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5507 static bool api_lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
5509 const struct ndr_interface_call *call;
5510 struct ndr_pull *pull;
5511 struct ndr_push *push;
5514 struct lsa_LSARSETFORESTTRUSTINFORMATION *r;
5516 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARSETFORESTTRUSTINFORMATION];
5518 r = talloc(NULL, struct lsa_LSARSETFORESTTRUSTINFORMATION);
5523 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5528 pull = ndr_pull_init_blob(&blob, r);
5534 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5535 status = call->ndr_pull(pull, NDR_IN, r);
5536 if (NT_STATUS_IS_ERR(status)) {
5541 if (DEBUGLEVEL >= 10)
5542 NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5544 r->out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, r);
5546 if (p->rng_fault_state) {
5548 /* Return True here, srv_pipe_hnd.c will take care */
5552 if (DEBUGLEVEL >= 10)
5553 NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, r);
5555 push = ndr_push_init_ctx(r);
5561 status = call->ndr_push(push, NDR_OUT, r);
5562 if (NT_STATUS_IS_ERR(status)) {
5567 blob = ndr_push_blob(push);
5568 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5578 static bool api_lsa_CREDRRENAME(pipes_struct *p)
5580 const struct ndr_interface_call *call;
5581 struct ndr_pull *pull;
5582 struct ndr_push *push;
5585 struct lsa_CREDRRENAME *r;
5587 call = &ndr_table_lsarpc.calls[NDR_LSA_CREDRRENAME];
5589 r = talloc(NULL, struct lsa_CREDRRENAME);
5594 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5599 pull = ndr_pull_init_blob(&blob, r);
5605 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5606 status = call->ndr_pull(pull, NDR_IN, r);
5607 if (NT_STATUS_IS_ERR(status)) {
5612 if (DEBUGLEVEL >= 10)
5613 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, r);
5615 r->out.result = _lsa_CREDRRENAME(p, r);
5617 if (p->rng_fault_state) {
5619 /* Return True here, srv_pipe_hnd.c will take care */
5623 if (DEBUGLEVEL >= 10)
5624 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, r);
5626 push = ndr_push_init_ctx(r);
5632 status = call->ndr_push(push, NDR_OUT, r);
5633 if (NT_STATUS_IS_ERR(status)) {
5638 blob = ndr_push_blob(push);
5639 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5649 static bool api_lsa_LookupSids3(pipes_struct *p)
5651 const struct ndr_interface_call *call;
5652 struct ndr_pull *pull;
5653 struct ndr_push *push;
5656 struct lsa_LookupSids3 *r;
5658 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPSIDS3];
5660 r = talloc(NULL, struct lsa_LookupSids3);
5665 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5670 pull = ndr_pull_init_blob(&blob, r);
5676 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5677 status = call->ndr_pull(pull, NDR_IN, r);
5678 if (NT_STATUS_IS_ERR(status)) {
5683 if (DEBUGLEVEL >= 10)
5684 NDR_PRINT_IN_DEBUG(lsa_LookupSids3, r);
5686 ZERO_STRUCT(r->out);
5687 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5688 if (r->out.domains == NULL) {
5693 r->out.names = r->in.names;
5694 r->out.count = r->in.count;
5695 r->out.result = _lsa_LookupSids3(p, r);
5697 if (p->rng_fault_state) {
5699 /* Return True here, srv_pipe_hnd.c will take care */
5703 if (DEBUGLEVEL >= 10)
5704 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, r);
5706 push = ndr_push_init_ctx(r);
5712 status = call->ndr_push(push, NDR_OUT, r);
5713 if (NT_STATUS_IS_ERR(status)) {
5718 blob = ndr_push_blob(push);
5719 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5729 static bool api_lsa_LookupNames4(pipes_struct *p)
5731 const struct ndr_interface_call *call;
5732 struct ndr_pull *pull;
5733 struct ndr_push *push;
5736 struct lsa_LookupNames4 *r;
5738 call = &ndr_table_lsarpc.calls[NDR_LSA_LOOKUPNAMES4];
5740 r = talloc(NULL, struct lsa_LookupNames4);
5745 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5750 pull = ndr_pull_init_blob(&blob, r);
5756 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5757 status = call->ndr_pull(pull, NDR_IN, r);
5758 if (NT_STATUS_IS_ERR(status)) {
5763 if (DEBUGLEVEL >= 10)
5764 NDR_PRINT_IN_DEBUG(lsa_LookupNames4, r);
5766 ZERO_STRUCT(r->out);
5767 r->out.domains = talloc_zero(r, struct lsa_RefDomainList);
5768 if (r->out.domains == NULL) {
5773 r->out.sids = r->in.sids;
5774 r->out.count = r->in.count;
5775 r->out.result = _lsa_LookupNames4(p, r);
5777 if (p->rng_fault_state) {
5779 /* Return True here, srv_pipe_hnd.c will take care */
5783 if (DEBUGLEVEL >= 10)
5784 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, r);
5786 push = ndr_push_init_ctx(r);
5792 status = call->ndr_push(push, NDR_OUT, r);
5793 if (NT_STATUS_IS_ERR(status)) {
5798 blob = ndr_push_blob(push);
5799 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5809 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct *p)
5811 const struct ndr_interface_call *call;
5812 struct ndr_pull *pull;
5813 struct ndr_push *push;
5816 struct lsa_LSAROPENPOLICYSCE *r;
5818 call = &ndr_table_lsarpc.calls[NDR_LSA_LSAROPENPOLICYSCE];
5820 r = talloc(NULL, struct lsa_LSAROPENPOLICYSCE);
5825 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5830 pull = ndr_pull_init_blob(&blob, r);
5836 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5837 status = call->ndr_pull(pull, NDR_IN, r);
5838 if (NT_STATUS_IS_ERR(status)) {
5843 if (DEBUGLEVEL >= 10)
5844 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, r);
5846 r->out.result = _lsa_LSAROPENPOLICYSCE(p, r);
5848 if (p->rng_fault_state) {
5850 /* Return True here, srv_pipe_hnd.c will take care */
5854 if (DEBUGLEVEL >= 10)
5855 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, r);
5857 push = ndr_push_init_ctx(r);
5863 status = call->ndr_push(push, NDR_OUT, r);
5864 if (NT_STATUS_IS_ERR(status)) {
5869 blob = ndr_push_blob(push);
5870 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5880 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
5882 const struct ndr_interface_call *call;
5883 struct ndr_pull *pull;
5884 struct ndr_push *push;
5887 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r;
5889 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE];
5891 r = talloc(NULL, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
5896 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5901 pull = ndr_pull_init_blob(&blob, r);
5907 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5908 status = call->ndr_pull(pull, NDR_IN, r);
5909 if (NT_STATUS_IS_ERR(status)) {
5914 if (DEBUGLEVEL >= 10)
5915 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
5917 r->out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, r);
5919 if (p->rng_fault_state) {
5921 /* Return True here, srv_pipe_hnd.c will take care */
5925 if (DEBUGLEVEL >= 10)
5926 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, r);
5928 push = ndr_push_init_ctx(r);
5934 status = call->ndr_push(push, NDR_OUT, r);
5935 if (NT_STATUS_IS_ERR(status)) {
5940 blob = ndr_push_blob(push);
5941 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
5951 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
5953 const struct ndr_interface_call *call;
5954 struct ndr_pull *pull;
5955 struct ndr_push *push;
5958 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r;
5960 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE];
5962 r = talloc(NULL, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
5967 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
5972 pull = ndr_pull_init_blob(&blob, r);
5978 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
5979 status = call->ndr_pull(pull, NDR_IN, r);
5980 if (NT_STATUS_IS_ERR(status)) {
5985 if (DEBUGLEVEL >= 10)
5986 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
5988 r->out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, r);
5990 if (p->rng_fault_state) {
5992 /* Return True here, srv_pipe_hnd.c will take care */
5996 if (DEBUGLEVEL >= 10)
5997 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, r);
5999 push = ndr_push_init_ctx(r);
6005 status = call->ndr_push(push, NDR_OUT, r);
6006 if (NT_STATUS_IS_ERR(status)) {
6011 blob = ndr_push_blob(push);
6012 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
6022 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
6024 const struct ndr_interface_call *call;
6025 struct ndr_pull *pull;
6026 struct ndr_push *push;
6029 struct lsa_LSARADTREPORTSECURITYEVENT *r;
6031 call = &ndr_table_lsarpc.calls[NDR_LSA_LSARADTREPORTSECURITYEVENT];
6033 r = talloc(NULL, struct lsa_LSARADTREPORTSECURITYEVENT);
6038 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
6043 pull = ndr_pull_init_blob(&blob, r);
6049 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
6050 status = call->ndr_pull(pull, NDR_IN, r);
6051 if (NT_STATUS_IS_ERR(status)) {
6056 if (DEBUGLEVEL >= 10)
6057 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6059 r->out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, r);
6061 if (p->rng_fault_state) {
6063 /* Return True here, srv_pipe_hnd.c will take care */
6067 if (DEBUGLEVEL >= 10)
6068 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, r);
6070 push = ndr_push_init_ctx(r);
6076 status = call->ndr_push(push, NDR_OUT, r);
6077 if (NT_STATUS_IS_ERR(status)) {
6082 blob = ndr_push_blob(push);
6083 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
6095 static struct api_struct api_lsarpc_cmds[] =
6097 {"LSA_CLOSE", NDR_LSA_CLOSE, api_lsa_Close},
6098 {"LSA_DELETE", NDR_LSA_DELETE, api_lsa_Delete},
6099 {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS, api_lsa_EnumPrivs},
6100 {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY, api_lsa_QuerySecurity},
6101 {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ, api_lsa_SetSecObj},
6102 {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD, api_lsa_ChangePassword},
6103 {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY, api_lsa_OpenPolicy},
6104 {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY, api_lsa_QueryInfoPolicy},
6105 {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY, api_lsa_SetInfoPolicy},
6106 {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG, api_lsa_ClearAuditLog},
6107 {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT, api_lsa_CreateAccount},
6108 {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS, api_lsa_EnumAccounts},
6109 {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN, api_lsa_CreateTrustedDomain},
6110 {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM, api_lsa_EnumTrustDom},
6111 {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES, api_lsa_LookupNames},
6112 {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS, api_lsa_LookupSids},
6113 {"LSA_CREATESECRET", NDR_LSA_CREATESECRET, api_lsa_CreateSecret},
6114 {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT, api_lsa_OpenAccount},
6115 {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT, api_lsa_EnumPrivsAccount},
6116 {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT, api_lsa_AddPrivilegesToAccount},
6117 {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, api_lsa_RemovePrivilegesFromAccount},
6118 {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT, api_lsa_GetQuotasForAccount},
6119 {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT, api_lsa_SetQuotasForAccount},
6120 {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT, api_lsa_GetSystemAccessAccount},
6121 {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT, api_lsa_SetSystemAccessAccount},
6122 {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN, api_lsa_OpenTrustedDomain},
6123 {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO, api_lsa_QueryTrustedDomainInfo},
6124 {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, api_lsa_SetInformationTrustedDomain},
6125 {"LSA_OPENSECRET", NDR_LSA_OPENSECRET, api_lsa_OpenSecret},
6126 {"LSA_SETSECRET", NDR_LSA_SETSECRET, api_lsa_SetSecret},
6127 {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET, api_lsa_QuerySecret},
6128 {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE, api_lsa_LookupPrivValue},
6129 {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME, api_lsa_LookupPrivName},
6130 {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME, api_lsa_LookupPrivDisplayName},
6131 {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT, api_lsa_DeleteObject},
6132 {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, api_lsa_EnumAccountsWithUserRight},
6133 {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS, api_lsa_EnumAccountRights},
6134 {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS, api_lsa_AddAccountRights},
6135 {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS, api_lsa_RemoveAccountRights},
6136 {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, api_lsa_QueryTrustedDomainInfoBySid},
6137 {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO, api_lsa_SetTrustedDomainInfo},
6138 {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN, api_lsa_DeleteTrustedDomain},
6139 {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA, api_lsa_StorePrivateData},
6140 {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA, api_lsa_RetrievePrivateData},
6141 {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2, api_lsa_OpenPolicy2},
6142 {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME, api_lsa_GetUserName},
6143 {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2, api_lsa_QueryInfoPolicy2},
6144 {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2, api_lsa_SetInfoPolicy2},
6145 {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, api_lsa_QueryTrustedDomainInfoByName},
6146 {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, api_lsa_SetTrustedDomainInfoByName},
6147 {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX, api_lsa_EnumTrustedDomainsEx},
6148 {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX, api_lsa_CreateTrustedDomainEx},
6149 {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX, api_lsa_CloseTrustedDomainEx},
6150 {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY, api_lsa_QueryDomainInformationPolicy},
6151 {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY, api_lsa_SetDomainInformationPolicy},
6152 {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME, api_lsa_OpenTrustedDomainByName},
6153 {"LSA_TESTCALL", NDR_LSA_TESTCALL, api_lsa_TestCall},
6154 {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2, api_lsa_LookupSids2},
6155 {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2, api_lsa_LookupNames2},
6156 {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2, api_lsa_CreateTrustedDomainEx2},
6157 {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE, api_lsa_CREDRWRITE},
6158 {"LSA_CREDRREAD", NDR_LSA_CREDRREAD, api_lsa_CREDRREAD},
6159 {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE, api_lsa_CREDRENUMERATE},
6160 {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, api_lsa_CREDRWRITEDOMAINCREDENTIALS},
6161 {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS, api_lsa_CREDRREADDOMAINCREDENTIALS},
6162 {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE, api_lsa_CREDRDELETE},
6163 {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO, api_lsa_CREDRGETTARGETINFO},
6164 {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED, api_lsa_CREDRPROFILELOADED},
6165 {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3, api_lsa_LookupNames3},
6166 {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES, api_lsa_CREDRGETSESSIONTYPES},
6167 {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT, api_lsa_LSARREGISTERAUDITEVENT},
6168 {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT, api_lsa_LSARGENAUDITEVENT},
6169 {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT, api_lsa_LSARUNREGISTERAUDITEVENT},
6170 {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, api_lsa_LSARQUERYFORESTTRUSTINFORMATION},
6171 {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION, api_lsa_LSARSETFORESTTRUSTINFORMATION},
6172 {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME, api_lsa_CREDRRENAME},
6173 {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3, api_lsa_LookupSids3},
6174 {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4, api_lsa_LookupNames4},
6175 {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE, api_lsa_LSAROPENPOLICYSCE},
6176 {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE},
6177 {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE},
6178 {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT, api_lsa_LSARADTREPORTSECURITYEVENT},
6181 void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns)
6183 *fns = api_lsarpc_cmds;
6184 *n_fns = sizeof(api_lsarpc_cmds) / sizeof(struct api_struct);
6187 NTSTATUS rpc_lsarpc_init(void)
6189 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "lsarpc", "lsarpc", api_lsarpc_cmds, sizeof(api_lsarpc_cmds) / sizeof(struct api_struct));