2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/srv_lsa.h"
9 static bool api_lsa_Close(pipes_struct
*p
)
11 const struct ndr_interface_call
*call
;
12 struct ndr_pull
*pull
;
13 struct ndr_push
*push
;
14 enum ndr_err_code ndr_err
;
18 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CLOSE
];
20 r
= talloc(talloc_tos(), struct lsa_Close
);
25 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
30 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
36 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
37 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
43 if (DEBUGLEVEL
>= 10) {
44 NDR_PRINT_IN_DEBUG(lsa_Close
, r
);
48 r
->out
.handle
= r
->in
.handle
;
49 r
->out
.result
= _lsa_Close(p
, r
);
51 if (p
->rng_fault_state
) {
53 /* Return true here, srv_pipe_hnd.c will take care */
57 if (DEBUGLEVEL
>= 10) {
58 NDR_PRINT_OUT_DEBUG(lsa_Close
, r
);
61 push
= ndr_push_init_ctx(r
, NULL
);
67 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
68 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
73 blob
= ndr_push_blob(push
);
74 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
84 static bool api_lsa_Delete(pipes_struct
*p
)
86 const struct ndr_interface_call
*call
;
87 struct ndr_pull
*pull
;
88 struct ndr_push
*push
;
89 enum ndr_err_code ndr_err
;
93 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_DELETE
];
95 r
= talloc(talloc_tos(), struct lsa_Delete
);
100 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
105 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
111 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
112 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
113 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
118 if (DEBUGLEVEL
>= 10) {
119 NDR_PRINT_IN_DEBUG(lsa_Delete
, r
);
122 r
->out
.result
= _lsa_Delete(p
, r
);
124 if (p
->rng_fault_state
) {
126 /* Return true here, srv_pipe_hnd.c will take care */
130 if (DEBUGLEVEL
>= 10) {
131 NDR_PRINT_OUT_DEBUG(lsa_Delete
, r
);
134 push
= ndr_push_init_ctx(r
, NULL
);
140 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
146 blob
= ndr_push_blob(push
);
147 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
157 static bool api_lsa_EnumPrivs(pipes_struct
*p
)
159 const struct ndr_interface_call
*call
;
160 struct ndr_pull
*pull
;
161 struct ndr_push
*push
;
162 enum ndr_err_code ndr_err
;
164 struct lsa_EnumPrivs
*r
;
166 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMPRIVS
];
168 r
= talloc(talloc_tos(), struct lsa_EnumPrivs
);
173 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
178 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
184 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
185 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
186 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
191 if (DEBUGLEVEL
>= 10) {
192 NDR_PRINT_IN_DEBUG(lsa_EnumPrivs
, r
);
196 r
->out
.resume_handle
= r
->in
.resume_handle
;
197 r
->out
.privs
= talloc_zero(r
, struct lsa_PrivArray
);
198 if (r
->out
.privs
== NULL
) {
203 r
->out
.result
= _lsa_EnumPrivs(p
, r
);
205 if (p
->rng_fault_state
) {
207 /* Return true here, srv_pipe_hnd.c will take care */
211 if (DEBUGLEVEL
>= 10) {
212 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs
, r
);
215 push
= ndr_push_init_ctx(r
, NULL
);
221 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
227 blob
= ndr_push_blob(push
);
228 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
238 static bool api_lsa_QuerySecurity(pipes_struct
*p
)
240 const struct ndr_interface_call
*call
;
241 struct ndr_pull
*pull
;
242 struct ndr_push
*push
;
243 enum ndr_err_code ndr_err
;
245 struct lsa_QuerySecurity
*r
;
247 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYSECURITY
];
249 r
= talloc(talloc_tos(), struct lsa_QuerySecurity
);
254 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
259 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
265 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
266 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
267 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
272 if (DEBUGLEVEL
>= 10) {
273 NDR_PRINT_IN_DEBUG(lsa_QuerySecurity
, r
);
277 r
->out
.sdbuf
= talloc_zero(r
, struct sec_desc_buf
*);
278 if (r
->out
.sdbuf
== NULL
) {
283 r
->out
.result
= _lsa_QuerySecurity(p
, r
);
285 if (p
->rng_fault_state
) {
287 /* Return true here, srv_pipe_hnd.c will take care */
291 if (DEBUGLEVEL
>= 10) {
292 NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity
, r
);
295 push
= ndr_push_init_ctx(r
, NULL
);
301 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
302 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
307 blob
= ndr_push_blob(push
);
308 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
318 static bool api_lsa_SetSecObj(pipes_struct
*p
)
320 const struct ndr_interface_call
*call
;
321 struct ndr_pull
*pull
;
322 struct ndr_push
*push
;
323 enum ndr_err_code ndr_err
;
325 struct lsa_SetSecObj
*r
;
327 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETSECOBJ
];
329 r
= talloc(talloc_tos(), struct lsa_SetSecObj
);
334 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
339 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
345 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
346 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
347 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
352 if (DEBUGLEVEL
>= 10) {
353 NDR_PRINT_IN_DEBUG(lsa_SetSecObj
, r
);
356 r
->out
.result
= _lsa_SetSecObj(p
, r
);
358 if (p
->rng_fault_state
) {
360 /* Return true here, srv_pipe_hnd.c will take care */
364 if (DEBUGLEVEL
>= 10) {
365 NDR_PRINT_OUT_DEBUG(lsa_SetSecObj
, r
);
368 push
= ndr_push_init_ctx(r
, NULL
);
374 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
375 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
380 blob
= ndr_push_blob(push
);
381 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
391 static bool api_lsa_ChangePassword(pipes_struct
*p
)
393 const struct ndr_interface_call
*call
;
394 struct ndr_pull
*pull
;
395 struct ndr_push
*push
;
396 enum ndr_err_code ndr_err
;
398 struct lsa_ChangePassword
*r
;
400 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CHANGEPASSWORD
];
402 r
= talloc(talloc_tos(), struct lsa_ChangePassword
);
407 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
412 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
418 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
419 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
420 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
425 if (DEBUGLEVEL
>= 10) {
426 NDR_PRINT_IN_DEBUG(lsa_ChangePassword
, r
);
429 r
->out
.result
= _lsa_ChangePassword(p
, r
);
431 if (p
->rng_fault_state
) {
433 /* Return true here, srv_pipe_hnd.c will take care */
437 if (DEBUGLEVEL
>= 10) {
438 NDR_PRINT_OUT_DEBUG(lsa_ChangePassword
, r
);
441 push
= ndr_push_init_ctx(r
, NULL
);
447 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
448 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
453 blob
= ndr_push_blob(push
);
454 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
464 static bool api_lsa_OpenPolicy(pipes_struct
*p
)
466 const struct ndr_interface_call
*call
;
467 struct ndr_pull
*pull
;
468 struct ndr_push
*push
;
469 enum ndr_err_code ndr_err
;
471 struct lsa_OpenPolicy
*r
;
473 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENPOLICY
];
475 r
= talloc(talloc_tos(), struct lsa_OpenPolicy
);
480 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
485 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
491 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
492 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
493 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
498 if (DEBUGLEVEL
>= 10) {
499 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy
, r
);
503 r
->out
.handle
= talloc_zero(r
, struct policy_handle
);
504 if (r
->out
.handle
== NULL
) {
509 r
->out
.result
= _lsa_OpenPolicy(p
, r
);
511 if (p
->rng_fault_state
) {
513 /* Return true here, srv_pipe_hnd.c will take care */
517 if (DEBUGLEVEL
>= 10) {
518 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy
, r
);
521 push
= ndr_push_init_ctx(r
, NULL
);
527 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
528 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
533 blob
= ndr_push_blob(push
);
534 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
544 static bool api_lsa_QueryInfoPolicy(pipes_struct
*p
)
546 const struct ndr_interface_call
*call
;
547 struct ndr_pull
*pull
;
548 struct ndr_push
*push
;
549 enum ndr_err_code ndr_err
;
551 struct lsa_QueryInfoPolicy
*r
;
553 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYINFOPOLICY
];
555 r
= talloc(talloc_tos(), struct lsa_QueryInfoPolicy
);
560 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
565 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
571 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
572 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
573 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
578 if (DEBUGLEVEL
>= 10) {
579 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy
, r
);
583 r
->out
.info
= talloc_zero(r
, union lsa_PolicyInformation
*);
584 if (r
->out
.info
== NULL
) {
589 r
->out
.result
= _lsa_QueryInfoPolicy(p
, r
);
591 if (p
->rng_fault_state
) {
593 /* Return true here, srv_pipe_hnd.c will take care */
597 if (DEBUGLEVEL
>= 10) {
598 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy
, r
);
601 push
= ndr_push_init_ctx(r
, NULL
);
607 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
608 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
613 blob
= ndr_push_blob(push
);
614 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
624 static bool api_lsa_SetInfoPolicy(pipes_struct
*p
)
626 const struct ndr_interface_call
*call
;
627 struct ndr_pull
*pull
;
628 struct ndr_push
*push
;
629 enum ndr_err_code ndr_err
;
631 struct lsa_SetInfoPolicy
*r
;
633 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETINFOPOLICY
];
635 r
= talloc(talloc_tos(), struct lsa_SetInfoPolicy
);
640 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
645 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
651 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
652 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
653 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
658 if (DEBUGLEVEL
>= 10) {
659 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy
, r
);
662 r
->out
.result
= _lsa_SetInfoPolicy(p
, r
);
664 if (p
->rng_fault_state
) {
666 /* Return true here, srv_pipe_hnd.c will take care */
670 if (DEBUGLEVEL
>= 10) {
671 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy
, r
);
674 push
= ndr_push_init_ctx(r
, NULL
);
680 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
681 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
686 blob
= ndr_push_blob(push
);
687 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
697 static bool api_lsa_ClearAuditLog(pipes_struct
*p
)
699 const struct ndr_interface_call
*call
;
700 struct ndr_pull
*pull
;
701 struct ndr_push
*push
;
702 enum ndr_err_code ndr_err
;
704 struct lsa_ClearAuditLog
*r
;
706 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CLEARAUDITLOG
];
708 r
= talloc(talloc_tos(), struct lsa_ClearAuditLog
);
713 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
718 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
724 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
725 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
726 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
731 if (DEBUGLEVEL
>= 10) {
732 NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog
, r
);
735 r
->out
.result
= _lsa_ClearAuditLog(p
, r
);
737 if (p
->rng_fault_state
) {
739 /* Return true here, srv_pipe_hnd.c will take care */
743 if (DEBUGLEVEL
>= 10) {
744 NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog
, r
);
747 push
= ndr_push_init_ctx(r
, NULL
);
753 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
754 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
759 blob
= ndr_push_blob(push
);
760 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
770 static bool api_lsa_CreateAccount(pipes_struct
*p
)
772 const struct ndr_interface_call
*call
;
773 struct ndr_pull
*pull
;
774 struct ndr_push
*push
;
775 enum ndr_err_code ndr_err
;
777 struct lsa_CreateAccount
*r
;
779 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREATEACCOUNT
];
781 r
= talloc(talloc_tos(), struct lsa_CreateAccount
);
786 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
791 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
797 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
798 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
799 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
804 if (DEBUGLEVEL
>= 10) {
805 NDR_PRINT_IN_DEBUG(lsa_CreateAccount
, r
);
809 r
->out
.acct_handle
= talloc_zero(r
, struct policy_handle
);
810 if (r
->out
.acct_handle
== NULL
) {
815 r
->out
.result
= _lsa_CreateAccount(p
, r
);
817 if (p
->rng_fault_state
) {
819 /* Return true here, srv_pipe_hnd.c will take care */
823 if (DEBUGLEVEL
>= 10) {
824 NDR_PRINT_OUT_DEBUG(lsa_CreateAccount
, r
);
827 push
= ndr_push_init_ctx(r
, NULL
);
833 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
834 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
839 blob
= ndr_push_blob(push
);
840 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
850 static bool api_lsa_EnumAccounts(pipes_struct
*p
)
852 const struct ndr_interface_call
*call
;
853 struct ndr_pull
*pull
;
854 struct ndr_push
*push
;
855 enum ndr_err_code ndr_err
;
857 struct lsa_EnumAccounts
*r
;
859 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMACCOUNTS
];
861 r
= talloc(talloc_tos(), struct lsa_EnumAccounts
);
866 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
871 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
877 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
878 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
879 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
884 if (DEBUGLEVEL
>= 10) {
885 NDR_PRINT_IN_DEBUG(lsa_EnumAccounts
, r
);
889 r
->out
.resume_handle
= r
->in
.resume_handle
;
890 r
->out
.sids
= talloc_zero(r
, struct lsa_SidArray
);
891 if (r
->out
.sids
== NULL
) {
896 r
->out
.result
= _lsa_EnumAccounts(p
, r
);
898 if (p
->rng_fault_state
) {
900 /* Return true here, srv_pipe_hnd.c will take care */
904 if (DEBUGLEVEL
>= 10) {
905 NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts
, r
);
908 push
= ndr_push_init_ctx(r
, NULL
);
914 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
920 blob
= ndr_push_blob(push
);
921 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
931 static bool api_lsa_CreateTrustedDomain(pipes_struct
*p
)
933 const struct ndr_interface_call
*call
;
934 struct ndr_pull
*pull
;
935 struct ndr_push
*push
;
936 enum ndr_err_code ndr_err
;
938 struct lsa_CreateTrustedDomain
*r
;
940 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREATETRUSTEDDOMAIN
];
942 r
= talloc(talloc_tos(), struct lsa_CreateTrustedDomain
);
947 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
952 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
958 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
959 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
960 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
965 if (DEBUGLEVEL
>= 10) {
966 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain
, r
);
970 r
->out
.trustdom_handle
= talloc_zero(r
, struct policy_handle
);
971 if (r
->out
.trustdom_handle
== NULL
) {
976 r
->out
.result
= _lsa_CreateTrustedDomain(p
, r
);
978 if (p
->rng_fault_state
) {
980 /* Return true here, srv_pipe_hnd.c will take care */
984 if (DEBUGLEVEL
>= 10) {
985 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain
, r
);
988 push
= ndr_push_init_ctx(r
, NULL
);
994 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
995 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1000 blob
= ndr_push_blob(push
);
1001 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1011 static bool api_lsa_EnumTrustDom(pipes_struct
*p
)
1013 const struct ndr_interface_call
*call
;
1014 struct ndr_pull
*pull
;
1015 struct ndr_push
*push
;
1016 enum ndr_err_code ndr_err
;
1018 struct lsa_EnumTrustDom
*r
;
1020 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMTRUSTDOM
];
1022 r
= talloc(talloc_tos(), struct lsa_EnumTrustDom
);
1027 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1032 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1038 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1039 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1040 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1045 if (DEBUGLEVEL
>= 10) {
1046 NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom
, r
);
1049 ZERO_STRUCT(r
->out
);
1050 r
->out
.resume_handle
= r
->in
.resume_handle
;
1051 r
->out
.domains
= talloc_zero(r
, struct lsa_DomainList
);
1052 if (r
->out
.domains
== NULL
) {
1057 r
->out
.result
= _lsa_EnumTrustDom(p
, r
);
1059 if (p
->rng_fault_state
) {
1061 /* Return true here, srv_pipe_hnd.c will take care */
1065 if (DEBUGLEVEL
>= 10) {
1066 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom
, r
);
1069 push
= ndr_push_init_ctx(r
, NULL
);
1075 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1081 blob
= ndr_push_blob(push
);
1082 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1092 static bool api_lsa_LookupNames(pipes_struct
*p
)
1094 const struct ndr_interface_call
*call
;
1095 struct ndr_pull
*pull
;
1096 struct ndr_push
*push
;
1097 enum ndr_err_code ndr_err
;
1099 struct lsa_LookupNames
*r
;
1101 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPNAMES
];
1103 r
= talloc(talloc_tos(), struct lsa_LookupNames
);
1108 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1113 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1119 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1120 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1126 if (DEBUGLEVEL
>= 10) {
1127 NDR_PRINT_IN_DEBUG(lsa_LookupNames
, r
);
1130 ZERO_STRUCT(r
->out
);
1131 r
->out
.sids
= r
->in
.sids
;
1132 r
->out
.count
= r
->in
.count
;
1133 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
1134 if (r
->out
.domains
== NULL
) {
1139 r
->out
.result
= _lsa_LookupNames(p
, r
);
1141 if (p
->rng_fault_state
) {
1143 /* Return true here, srv_pipe_hnd.c will take care */
1147 if (DEBUGLEVEL
>= 10) {
1148 NDR_PRINT_OUT_DEBUG(lsa_LookupNames
, r
);
1151 push
= ndr_push_init_ctx(r
, NULL
);
1157 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1163 blob
= ndr_push_blob(push
);
1164 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1174 static bool api_lsa_LookupSids(pipes_struct
*p
)
1176 const struct ndr_interface_call
*call
;
1177 struct ndr_pull
*pull
;
1178 struct ndr_push
*push
;
1179 enum ndr_err_code ndr_err
;
1181 struct lsa_LookupSids
*r
;
1183 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPSIDS
];
1185 r
= talloc(talloc_tos(), struct lsa_LookupSids
);
1190 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1195 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1201 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1202 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1208 if (DEBUGLEVEL
>= 10) {
1209 NDR_PRINT_IN_DEBUG(lsa_LookupSids
, r
);
1212 ZERO_STRUCT(r
->out
);
1213 r
->out
.names
= r
->in
.names
;
1214 r
->out
.count
= r
->in
.count
;
1215 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
1216 if (r
->out
.domains
== NULL
) {
1221 r
->out
.result
= _lsa_LookupSids(p
, r
);
1223 if (p
->rng_fault_state
) {
1225 /* Return true here, srv_pipe_hnd.c will take care */
1229 if (DEBUGLEVEL
>= 10) {
1230 NDR_PRINT_OUT_DEBUG(lsa_LookupSids
, r
);
1233 push
= ndr_push_init_ctx(r
, NULL
);
1239 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1245 blob
= ndr_push_blob(push
);
1246 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1256 static bool api_lsa_CreateSecret(pipes_struct
*p
)
1258 const struct ndr_interface_call
*call
;
1259 struct ndr_pull
*pull
;
1260 struct ndr_push
*push
;
1261 enum ndr_err_code ndr_err
;
1263 struct lsa_CreateSecret
*r
;
1265 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREATESECRET
];
1267 r
= talloc(talloc_tos(), struct lsa_CreateSecret
);
1272 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1277 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1283 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1284 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1290 if (DEBUGLEVEL
>= 10) {
1291 NDR_PRINT_IN_DEBUG(lsa_CreateSecret
, r
);
1294 ZERO_STRUCT(r
->out
);
1295 r
->out
.sec_handle
= talloc_zero(r
, struct policy_handle
);
1296 if (r
->out
.sec_handle
== NULL
) {
1301 r
->out
.result
= _lsa_CreateSecret(p
, r
);
1303 if (p
->rng_fault_state
) {
1305 /* Return true here, srv_pipe_hnd.c will take care */
1309 if (DEBUGLEVEL
>= 10) {
1310 NDR_PRINT_OUT_DEBUG(lsa_CreateSecret
, r
);
1313 push
= ndr_push_init_ctx(r
, NULL
);
1319 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1320 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1325 blob
= ndr_push_blob(push
);
1326 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1336 static bool api_lsa_OpenAccount(pipes_struct
*p
)
1338 const struct ndr_interface_call
*call
;
1339 struct ndr_pull
*pull
;
1340 struct ndr_push
*push
;
1341 enum ndr_err_code ndr_err
;
1343 struct lsa_OpenAccount
*r
;
1345 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENACCOUNT
];
1347 r
= talloc(talloc_tos(), struct lsa_OpenAccount
);
1352 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1357 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1363 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1364 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1370 if (DEBUGLEVEL
>= 10) {
1371 NDR_PRINT_IN_DEBUG(lsa_OpenAccount
, r
);
1374 ZERO_STRUCT(r
->out
);
1375 r
->out
.acct_handle
= talloc_zero(r
, struct policy_handle
);
1376 if (r
->out
.acct_handle
== NULL
) {
1381 r
->out
.result
= _lsa_OpenAccount(p
, r
);
1383 if (p
->rng_fault_state
) {
1385 /* Return true here, srv_pipe_hnd.c will take care */
1389 if (DEBUGLEVEL
>= 10) {
1390 NDR_PRINT_OUT_DEBUG(lsa_OpenAccount
, r
);
1393 push
= ndr_push_init_ctx(r
, NULL
);
1399 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1400 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1405 blob
= ndr_push_blob(push
);
1406 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1416 static bool api_lsa_EnumPrivsAccount(pipes_struct
*p
)
1418 const struct ndr_interface_call
*call
;
1419 struct ndr_pull
*pull
;
1420 struct ndr_push
*push
;
1421 enum ndr_err_code ndr_err
;
1423 struct lsa_EnumPrivsAccount
*r
;
1425 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMPRIVSACCOUNT
];
1427 r
= talloc(talloc_tos(), struct lsa_EnumPrivsAccount
);
1432 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1437 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1443 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1444 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1445 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1450 if (DEBUGLEVEL
>= 10) {
1451 NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount
, r
);
1454 ZERO_STRUCT(r
->out
);
1455 r
->out
.privs
= talloc_zero(r
, struct lsa_PrivilegeSet
*);
1456 if (r
->out
.privs
== NULL
) {
1461 r
->out
.result
= _lsa_EnumPrivsAccount(p
, r
);
1463 if (p
->rng_fault_state
) {
1465 /* Return true here, srv_pipe_hnd.c will take care */
1469 if (DEBUGLEVEL
>= 10) {
1470 NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount
, r
);
1473 push
= ndr_push_init_ctx(r
, NULL
);
1479 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1480 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1485 blob
= ndr_push_blob(push
);
1486 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1496 static bool api_lsa_AddPrivilegesToAccount(pipes_struct
*p
)
1498 const struct ndr_interface_call
*call
;
1499 struct ndr_pull
*pull
;
1500 struct ndr_push
*push
;
1501 enum ndr_err_code ndr_err
;
1503 struct lsa_AddPrivilegesToAccount
*r
;
1505 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ADDPRIVILEGESTOACCOUNT
];
1507 r
= talloc(talloc_tos(), struct lsa_AddPrivilegesToAccount
);
1512 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1517 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1523 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1524 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1525 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1530 if (DEBUGLEVEL
>= 10) {
1531 NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount
, r
);
1534 r
->out
.result
= _lsa_AddPrivilegesToAccount(p
, r
);
1536 if (p
->rng_fault_state
) {
1538 /* Return true here, srv_pipe_hnd.c will take care */
1542 if (DEBUGLEVEL
>= 10) {
1543 NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount
, r
);
1546 push
= ndr_push_init_ctx(r
, NULL
);
1552 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1553 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1558 blob
= ndr_push_blob(push
);
1559 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1569 static bool api_lsa_RemovePrivilegesFromAccount(pipes_struct
*p
)
1571 const struct ndr_interface_call
*call
;
1572 struct ndr_pull
*pull
;
1573 struct ndr_push
*push
;
1574 enum ndr_err_code ndr_err
;
1576 struct lsa_RemovePrivilegesFromAccount
*r
;
1578 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT
];
1580 r
= talloc(talloc_tos(), struct lsa_RemovePrivilegesFromAccount
);
1585 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1590 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1596 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1597 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1598 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1603 if (DEBUGLEVEL
>= 10) {
1604 NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount
, r
);
1607 r
->out
.result
= _lsa_RemovePrivilegesFromAccount(p
, r
);
1609 if (p
->rng_fault_state
) {
1611 /* Return true here, srv_pipe_hnd.c will take care */
1615 if (DEBUGLEVEL
>= 10) {
1616 NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount
, r
);
1619 push
= ndr_push_init_ctx(r
, NULL
);
1625 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1631 blob
= ndr_push_blob(push
);
1632 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1642 static bool api_lsa_GetQuotasForAccount(pipes_struct
*p
)
1644 const struct ndr_interface_call
*call
;
1645 struct ndr_pull
*pull
;
1646 struct ndr_push
*push
;
1647 enum ndr_err_code ndr_err
;
1649 struct lsa_GetQuotasForAccount
*r
;
1651 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_GETQUOTASFORACCOUNT
];
1653 r
= talloc(talloc_tos(), struct lsa_GetQuotasForAccount
);
1658 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1663 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1669 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1670 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1671 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1676 if (DEBUGLEVEL
>= 10) {
1677 NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount
, r
);
1680 r
->out
.result
= _lsa_GetQuotasForAccount(p
, r
);
1682 if (p
->rng_fault_state
) {
1684 /* Return true here, srv_pipe_hnd.c will take care */
1688 if (DEBUGLEVEL
>= 10) {
1689 NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount
, r
);
1692 push
= ndr_push_init_ctx(r
, NULL
);
1698 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1704 blob
= ndr_push_blob(push
);
1705 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1715 static bool api_lsa_SetQuotasForAccount(pipes_struct
*p
)
1717 const struct ndr_interface_call
*call
;
1718 struct ndr_pull
*pull
;
1719 struct ndr_push
*push
;
1720 enum ndr_err_code ndr_err
;
1722 struct lsa_SetQuotasForAccount
*r
;
1724 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETQUOTASFORACCOUNT
];
1726 r
= talloc(talloc_tos(), struct lsa_SetQuotasForAccount
);
1731 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1736 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1742 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1743 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1744 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1749 if (DEBUGLEVEL
>= 10) {
1750 NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount
, r
);
1753 r
->out
.result
= _lsa_SetQuotasForAccount(p
, r
);
1755 if (p
->rng_fault_state
) {
1757 /* Return true here, srv_pipe_hnd.c will take care */
1761 if (DEBUGLEVEL
>= 10) {
1762 NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount
, r
);
1765 push
= ndr_push_init_ctx(r
, NULL
);
1771 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1772 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1777 blob
= ndr_push_blob(push
);
1778 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1788 static bool api_lsa_GetSystemAccessAccount(pipes_struct
*p
)
1790 const struct ndr_interface_call
*call
;
1791 struct ndr_pull
*pull
;
1792 struct ndr_push
*push
;
1793 enum ndr_err_code ndr_err
;
1795 struct lsa_GetSystemAccessAccount
*r
;
1797 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_GETSYSTEMACCESSACCOUNT
];
1799 r
= talloc(talloc_tos(), struct lsa_GetSystemAccessAccount
);
1804 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1809 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1815 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1816 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1817 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1822 if (DEBUGLEVEL
>= 10) {
1823 NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount
, r
);
1826 ZERO_STRUCT(r
->out
);
1827 r
->out
.access_mask
= talloc_zero(r
, uint32_t);
1828 if (r
->out
.access_mask
== NULL
) {
1833 r
->out
.result
= _lsa_GetSystemAccessAccount(p
, r
);
1835 if (p
->rng_fault_state
) {
1837 /* Return true here, srv_pipe_hnd.c will take care */
1841 if (DEBUGLEVEL
>= 10) {
1842 NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount
, r
);
1845 push
= ndr_push_init_ctx(r
, NULL
);
1851 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1852 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1857 blob
= ndr_push_blob(push
);
1858 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1868 static bool api_lsa_SetSystemAccessAccount(pipes_struct
*p
)
1870 const struct ndr_interface_call
*call
;
1871 struct ndr_pull
*pull
;
1872 struct ndr_push
*push
;
1873 enum ndr_err_code ndr_err
;
1875 struct lsa_SetSystemAccessAccount
*r
;
1877 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETSYSTEMACCESSACCOUNT
];
1879 r
= talloc(talloc_tos(), struct lsa_SetSystemAccessAccount
);
1884 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1889 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1895 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1896 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1897 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1902 if (DEBUGLEVEL
>= 10) {
1903 NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount
, r
);
1906 r
->out
.result
= _lsa_SetSystemAccessAccount(p
, r
);
1908 if (p
->rng_fault_state
) {
1910 /* Return true here, srv_pipe_hnd.c will take care */
1914 if (DEBUGLEVEL
>= 10) {
1915 NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount
, r
);
1918 push
= ndr_push_init_ctx(r
, NULL
);
1924 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1925 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1930 blob
= ndr_push_blob(push
);
1931 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1941 static bool api_lsa_OpenTrustedDomain(pipes_struct
*p
)
1943 const struct ndr_interface_call
*call
;
1944 struct ndr_pull
*pull
;
1945 struct ndr_push
*push
;
1946 enum ndr_err_code ndr_err
;
1948 struct lsa_OpenTrustedDomain
*r
;
1950 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENTRUSTEDDOMAIN
];
1952 r
= talloc(talloc_tos(), struct lsa_OpenTrustedDomain
);
1957 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1962 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1968 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1969 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1970 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1975 if (DEBUGLEVEL
>= 10) {
1976 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain
, r
);
1979 ZERO_STRUCT(r
->out
);
1980 r
->out
.trustdom_handle
= talloc_zero(r
, struct policy_handle
);
1981 if (r
->out
.trustdom_handle
== NULL
) {
1986 r
->out
.result
= _lsa_OpenTrustedDomain(p
, r
);
1988 if (p
->rng_fault_state
) {
1990 /* Return true here, srv_pipe_hnd.c will take care */
1994 if (DEBUGLEVEL
>= 10) {
1995 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain
, r
);
1998 push
= ndr_push_init_ctx(r
, NULL
);
2004 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2005 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2010 blob
= ndr_push_blob(push
);
2011 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2021 static bool api_lsa_QueryTrustedDomainInfo(pipes_struct
*p
)
2023 const struct ndr_interface_call
*call
;
2024 struct ndr_pull
*pull
;
2025 struct ndr_push
*push
;
2026 enum ndr_err_code ndr_err
;
2028 struct lsa_QueryTrustedDomainInfo
*r
;
2030 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYTRUSTEDDOMAININFO
];
2032 r
= talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfo
);
2037 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2042 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2048 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2049 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2050 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2055 if (DEBUGLEVEL
>= 10) {
2056 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfo
, r
);
2059 ZERO_STRUCT(r
->out
);
2060 r
->out
.info
= talloc_zero(r
, union lsa_TrustedDomainInfo
*);
2061 if (r
->out
.info
== NULL
) {
2066 r
->out
.result
= _lsa_QueryTrustedDomainInfo(p
, r
);
2068 if (p
->rng_fault_state
) {
2070 /* Return true here, srv_pipe_hnd.c will take care */
2074 if (DEBUGLEVEL
>= 10) {
2075 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo
, r
);
2078 push
= ndr_push_init_ctx(r
, NULL
);
2084 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2085 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2090 blob
= ndr_push_blob(push
);
2091 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2101 static bool api_lsa_SetInformationTrustedDomain(pipes_struct
*p
)
2103 const struct ndr_interface_call
*call
;
2104 struct ndr_pull
*pull
;
2105 struct ndr_push
*push
;
2106 enum ndr_err_code ndr_err
;
2108 struct lsa_SetInformationTrustedDomain
*r
;
2110 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN
];
2112 r
= talloc(talloc_tos(), struct lsa_SetInformationTrustedDomain
);
2117 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2122 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2128 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2129 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2130 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2135 if (DEBUGLEVEL
>= 10) {
2136 NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain
, r
);
2139 r
->out
.result
= _lsa_SetInformationTrustedDomain(p
, r
);
2141 if (p
->rng_fault_state
) {
2143 /* Return true here, srv_pipe_hnd.c will take care */
2147 if (DEBUGLEVEL
>= 10) {
2148 NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain
, r
);
2151 push
= ndr_push_init_ctx(r
, NULL
);
2157 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2158 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2163 blob
= ndr_push_blob(push
);
2164 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2174 static bool api_lsa_OpenSecret(pipes_struct
*p
)
2176 const struct ndr_interface_call
*call
;
2177 struct ndr_pull
*pull
;
2178 struct ndr_push
*push
;
2179 enum ndr_err_code ndr_err
;
2181 struct lsa_OpenSecret
*r
;
2183 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENSECRET
];
2185 r
= talloc(talloc_tos(), struct lsa_OpenSecret
);
2190 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2195 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2201 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2202 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2203 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2208 if (DEBUGLEVEL
>= 10) {
2209 NDR_PRINT_IN_DEBUG(lsa_OpenSecret
, r
);
2212 ZERO_STRUCT(r
->out
);
2213 r
->out
.sec_handle
= talloc_zero(r
, struct policy_handle
);
2214 if (r
->out
.sec_handle
== NULL
) {
2219 r
->out
.result
= _lsa_OpenSecret(p
, r
);
2221 if (p
->rng_fault_state
) {
2223 /* Return true here, srv_pipe_hnd.c will take care */
2227 if (DEBUGLEVEL
>= 10) {
2228 NDR_PRINT_OUT_DEBUG(lsa_OpenSecret
, r
);
2231 push
= ndr_push_init_ctx(r
, NULL
);
2237 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2243 blob
= ndr_push_blob(push
);
2244 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2254 static bool api_lsa_SetSecret(pipes_struct
*p
)
2256 const struct ndr_interface_call
*call
;
2257 struct ndr_pull
*pull
;
2258 struct ndr_push
*push
;
2259 enum ndr_err_code ndr_err
;
2261 struct lsa_SetSecret
*r
;
2263 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETSECRET
];
2265 r
= talloc(talloc_tos(), struct lsa_SetSecret
);
2270 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2275 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2281 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2282 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2283 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2288 if (DEBUGLEVEL
>= 10) {
2289 NDR_PRINT_IN_DEBUG(lsa_SetSecret
, r
);
2292 r
->out
.result
= _lsa_SetSecret(p
, r
);
2294 if (p
->rng_fault_state
) {
2296 /* Return true here, srv_pipe_hnd.c will take care */
2300 if (DEBUGLEVEL
>= 10) {
2301 NDR_PRINT_OUT_DEBUG(lsa_SetSecret
, r
);
2304 push
= ndr_push_init_ctx(r
, NULL
);
2310 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2316 blob
= ndr_push_blob(push
);
2317 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2327 static bool api_lsa_QuerySecret(pipes_struct
*p
)
2329 const struct ndr_interface_call
*call
;
2330 struct ndr_pull
*pull
;
2331 struct ndr_push
*push
;
2332 enum ndr_err_code ndr_err
;
2334 struct lsa_QuerySecret
*r
;
2336 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYSECRET
];
2338 r
= talloc(talloc_tos(), struct lsa_QuerySecret
);
2343 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2348 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2354 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2355 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2356 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2361 if (DEBUGLEVEL
>= 10) {
2362 NDR_PRINT_IN_DEBUG(lsa_QuerySecret
, r
);
2365 ZERO_STRUCT(r
->out
);
2366 r
->out
.new_val
= r
->in
.new_val
;
2367 r
->out
.new_mtime
= r
->in
.new_mtime
;
2368 r
->out
.old_val
= r
->in
.old_val
;
2369 r
->out
.old_mtime
= r
->in
.old_mtime
;
2370 r
->out
.result
= _lsa_QuerySecret(p
, r
);
2372 if (p
->rng_fault_state
) {
2374 /* Return true here, srv_pipe_hnd.c will take care */
2378 if (DEBUGLEVEL
>= 10) {
2379 NDR_PRINT_OUT_DEBUG(lsa_QuerySecret
, r
);
2382 push
= ndr_push_init_ctx(r
, NULL
);
2388 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2389 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2394 blob
= ndr_push_blob(push
);
2395 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2405 static bool api_lsa_LookupPrivValue(pipes_struct
*p
)
2407 const struct ndr_interface_call
*call
;
2408 struct ndr_pull
*pull
;
2409 struct ndr_push
*push
;
2410 enum ndr_err_code ndr_err
;
2412 struct lsa_LookupPrivValue
*r
;
2414 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPPRIVVALUE
];
2416 r
= talloc(talloc_tos(), struct lsa_LookupPrivValue
);
2421 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2426 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2432 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2433 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2434 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2439 if (DEBUGLEVEL
>= 10) {
2440 NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue
, r
);
2443 ZERO_STRUCT(r
->out
);
2444 r
->out
.luid
= talloc_zero(r
, struct lsa_LUID
);
2445 if (r
->out
.luid
== NULL
) {
2450 r
->out
.result
= _lsa_LookupPrivValue(p
, r
);
2452 if (p
->rng_fault_state
) {
2454 /* Return true here, srv_pipe_hnd.c will take care */
2458 if (DEBUGLEVEL
>= 10) {
2459 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue
, r
);
2462 push
= ndr_push_init_ctx(r
, NULL
);
2468 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2469 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2474 blob
= ndr_push_blob(push
);
2475 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2485 static bool api_lsa_LookupPrivName(pipes_struct
*p
)
2487 const struct ndr_interface_call
*call
;
2488 struct ndr_pull
*pull
;
2489 struct ndr_push
*push
;
2490 enum ndr_err_code ndr_err
;
2492 struct lsa_LookupPrivName
*r
;
2494 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPPRIVNAME
];
2496 r
= talloc(talloc_tos(), struct lsa_LookupPrivName
);
2501 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2506 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2512 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2513 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2514 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2519 if (DEBUGLEVEL
>= 10) {
2520 NDR_PRINT_IN_DEBUG(lsa_LookupPrivName
, r
);
2523 ZERO_STRUCT(r
->out
);
2524 r
->out
.name
= talloc_zero(r
, struct lsa_StringLarge
*);
2525 if (r
->out
.name
== NULL
) {
2530 r
->out
.result
= _lsa_LookupPrivName(p
, r
);
2532 if (p
->rng_fault_state
) {
2534 /* Return true here, srv_pipe_hnd.c will take care */
2538 if (DEBUGLEVEL
>= 10) {
2539 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName
, r
);
2542 push
= ndr_push_init_ctx(r
, NULL
);
2548 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2549 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2554 blob
= ndr_push_blob(push
);
2555 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2565 static bool api_lsa_LookupPrivDisplayName(pipes_struct
*p
)
2567 const struct ndr_interface_call
*call
;
2568 struct ndr_pull
*pull
;
2569 struct ndr_push
*push
;
2570 enum ndr_err_code ndr_err
;
2572 struct lsa_LookupPrivDisplayName
*r
;
2574 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPPRIVDISPLAYNAME
];
2576 r
= talloc(talloc_tos(), struct lsa_LookupPrivDisplayName
);
2581 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2586 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2592 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2593 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2594 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2599 if (DEBUGLEVEL
>= 10) {
2600 NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName
, r
);
2603 ZERO_STRUCT(r
->out
);
2604 r
->out
.disp_name
= talloc_zero(r
, struct lsa_StringLarge
*);
2605 if (r
->out
.disp_name
== NULL
) {
2610 r
->out
.returned_language_id
= talloc_zero(r
, uint16_t);
2611 if (r
->out
.returned_language_id
== NULL
) {
2616 r
->out
.result
= _lsa_LookupPrivDisplayName(p
, r
);
2618 if (p
->rng_fault_state
) {
2620 /* Return true here, srv_pipe_hnd.c will take care */
2624 if (DEBUGLEVEL
>= 10) {
2625 NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName
, r
);
2628 push
= ndr_push_init_ctx(r
, NULL
);
2634 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2640 blob
= ndr_push_blob(push
);
2641 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2651 static bool api_lsa_DeleteObject(pipes_struct
*p
)
2653 const struct ndr_interface_call
*call
;
2654 struct ndr_pull
*pull
;
2655 struct ndr_push
*push
;
2656 enum ndr_err_code ndr_err
;
2658 struct lsa_DeleteObject
*r
;
2660 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_DELETEOBJECT
];
2662 r
= talloc(talloc_tos(), struct lsa_DeleteObject
);
2667 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2672 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2678 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2679 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2680 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2685 if (DEBUGLEVEL
>= 10) {
2686 NDR_PRINT_IN_DEBUG(lsa_DeleteObject
, r
);
2689 ZERO_STRUCT(r
->out
);
2690 r
->out
.handle
= r
->in
.handle
;
2691 r
->out
.result
= _lsa_DeleteObject(p
, r
);
2693 if (p
->rng_fault_state
) {
2695 /* Return true here, srv_pipe_hnd.c will take care */
2699 if (DEBUGLEVEL
>= 10) {
2700 NDR_PRINT_OUT_DEBUG(lsa_DeleteObject
, r
);
2703 push
= ndr_push_init_ctx(r
, NULL
);
2709 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2710 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2715 blob
= ndr_push_blob(push
);
2716 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2726 static bool api_lsa_EnumAccountsWithUserRight(pipes_struct
*p
)
2728 const struct ndr_interface_call
*call
;
2729 struct ndr_pull
*pull
;
2730 struct ndr_push
*push
;
2731 enum ndr_err_code ndr_err
;
2733 struct lsa_EnumAccountsWithUserRight
*r
;
2735 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT
];
2737 r
= talloc(talloc_tos(), struct lsa_EnumAccountsWithUserRight
);
2742 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2747 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2753 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2754 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2755 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2760 if (DEBUGLEVEL
>= 10) {
2761 NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight
, r
);
2764 ZERO_STRUCT(r
->out
);
2765 r
->out
.sids
= talloc_zero(r
, struct lsa_SidArray
);
2766 if (r
->out
.sids
== NULL
) {
2771 r
->out
.result
= _lsa_EnumAccountsWithUserRight(p
, r
);
2773 if (p
->rng_fault_state
) {
2775 /* Return true here, srv_pipe_hnd.c will take care */
2779 if (DEBUGLEVEL
>= 10) {
2780 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight
, r
);
2783 push
= ndr_push_init_ctx(r
, NULL
);
2789 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2790 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2795 blob
= ndr_push_blob(push
);
2796 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2806 static bool api_lsa_EnumAccountRights(pipes_struct
*p
)
2808 const struct ndr_interface_call
*call
;
2809 struct ndr_pull
*pull
;
2810 struct ndr_push
*push
;
2811 enum ndr_err_code ndr_err
;
2813 struct lsa_EnumAccountRights
*r
;
2815 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMACCOUNTRIGHTS
];
2817 r
= talloc(talloc_tos(), struct lsa_EnumAccountRights
);
2822 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2827 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2833 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2834 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2835 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2840 if (DEBUGLEVEL
>= 10) {
2841 NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights
, r
);
2844 ZERO_STRUCT(r
->out
);
2845 r
->out
.rights
= talloc_zero(r
, struct lsa_RightSet
);
2846 if (r
->out
.rights
== NULL
) {
2851 r
->out
.result
= _lsa_EnumAccountRights(p
, r
);
2853 if (p
->rng_fault_state
) {
2855 /* Return true here, srv_pipe_hnd.c will take care */
2859 if (DEBUGLEVEL
>= 10) {
2860 NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights
, r
);
2863 push
= ndr_push_init_ctx(r
, NULL
);
2869 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2870 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2875 blob
= ndr_push_blob(push
);
2876 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2886 static bool api_lsa_AddAccountRights(pipes_struct
*p
)
2888 const struct ndr_interface_call
*call
;
2889 struct ndr_pull
*pull
;
2890 struct ndr_push
*push
;
2891 enum ndr_err_code ndr_err
;
2893 struct lsa_AddAccountRights
*r
;
2895 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ADDACCOUNTRIGHTS
];
2897 r
= talloc(talloc_tos(), struct lsa_AddAccountRights
);
2902 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2907 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2913 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2914 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2915 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2920 if (DEBUGLEVEL
>= 10) {
2921 NDR_PRINT_IN_DEBUG(lsa_AddAccountRights
, r
);
2924 r
->out
.result
= _lsa_AddAccountRights(p
, r
);
2926 if (p
->rng_fault_state
) {
2928 /* Return true here, srv_pipe_hnd.c will take care */
2932 if (DEBUGLEVEL
>= 10) {
2933 NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights
, r
);
2936 push
= ndr_push_init_ctx(r
, NULL
);
2942 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2948 blob
= ndr_push_blob(push
);
2949 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2959 static bool api_lsa_RemoveAccountRights(pipes_struct
*p
)
2961 const struct ndr_interface_call
*call
;
2962 struct ndr_pull
*pull
;
2963 struct ndr_push
*push
;
2964 enum ndr_err_code ndr_err
;
2966 struct lsa_RemoveAccountRights
*r
;
2968 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_REMOVEACCOUNTRIGHTS
];
2970 r
= talloc(talloc_tos(), struct lsa_RemoveAccountRights
);
2975 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2980 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2986 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2987 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2988 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2993 if (DEBUGLEVEL
>= 10) {
2994 NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights
, r
);
2997 r
->out
.result
= _lsa_RemoveAccountRights(p
, r
);
2999 if (p
->rng_fault_state
) {
3001 /* Return true here, srv_pipe_hnd.c will take care */
3005 if (DEBUGLEVEL
>= 10) {
3006 NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights
, r
);
3009 push
= ndr_push_init_ctx(r
, NULL
);
3015 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3016 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3021 blob
= ndr_push_blob(push
);
3022 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3032 static bool api_lsa_QueryTrustedDomainInfoBySid(pipes_struct
*p
)
3034 const struct ndr_interface_call
*call
;
3035 struct ndr_pull
*pull
;
3036 struct ndr_push
*push
;
3037 enum ndr_err_code ndr_err
;
3039 struct lsa_QueryTrustedDomainInfoBySid
*r
;
3041 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID
];
3043 r
= talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoBySid
);
3048 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3053 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3059 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3060 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3061 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3066 if (DEBUGLEVEL
>= 10) {
3067 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoBySid
, r
);
3070 ZERO_STRUCT(r
->out
);
3071 r
->out
.info
= talloc_zero(r
, union lsa_TrustedDomainInfo
*);
3072 if (r
->out
.info
== NULL
) {
3077 r
->out
.result
= _lsa_QueryTrustedDomainInfoBySid(p
, r
);
3079 if (p
->rng_fault_state
) {
3081 /* Return true here, srv_pipe_hnd.c will take care */
3085 if (DEBUGLEVEL
>= 10) {
3086 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid
, r
);
3089 push
= ndr_push_init_ctx(r
, NULL
);
3095 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3101 blob
= ndr_push_blob(push
);
3102 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3112 static bool api_lsa_SetTrustedDomainInfo(pipes_struct
*p
)
3114 const struct ndr_interface_call
*call
;
3115 struct ndr_pull
*pull
;
3116 struct ndr_push
*push
;
3117 enum ndr_err_code ndr_err
;
3119 struct lsa_SetTrustedDomainInfo
*r
;
3121 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETTRUSTEDDOMAININFO
];
3123 r
= talloc(talloc_tos(), struct lsa_SetTrustedDomainInfo
);
3128 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3133 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3139 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3140 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3141 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3146 if (DEBUGLEVEL
>= 10) {
3147 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo
, r
);
3150 r
->out
.result
= _lsa_SetTrustedDomainInfo(p
, r
);
3152 if (p
->rng_fault_state
) {
3154 /* Return true here, srv_pipe_hnd.c will take care */
3158 if (DEBUGLEVEL
>= 10) {
3159 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo
, r
);
3162 push
= ndr_push_init_ctx(r
, NULL
);
3168 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3174 blob
= ndr_push_blob(push
);
3175 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3185 static bool api_lsa_DeleteTrustedDomain(pipes_struct
*p
)
3187 const struct ndr_interface_call
*call
;
3188 struct ndr_pull
*pull
;
3189 struct ndr_push
*push
;
3190 enum ndr_err_code ndr_err
;
3192 struct lsa_DeleteTrustedDomain
*r
;
3194 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_DELETETRUSTEDDOMAIN
];
3196 r
= talloc(talloc_tos(), struct lsa_DeleteTrustedDomain
);
3201 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3206 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3212 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3213 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3214 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3219 if (DEBUGLEVEL
>= 10) {
3220 NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain
, r
);
3223 r
->out
.result
= _lsa_DeleteTrustedDomain(p
, r
);
3225 if (p
->rng_fault_state
) {
3227 /* Return true here, srv_pipe_hnd.c will take care */
3231 if (DEBUGLEVEL
>= 10) {
3232 NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain
, r
);
3235 push
= ndr_push_init_ctx(r
, NULL
);
3241 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3247 blob
= ndr_push_blob(push
);
3248 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3258 static bool api_lsa_StorePrivateData(pipes_struct
*p
)
3260 const struct ndr_interface_call
*call
;
3261 struct ndr_pull
*pull
;
3262 struct ndr_push
*push
;
3263 enum ndr_err_code ndr_err
;
3265 struct lsa_StorePrivateData
*r
;
3267 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_STOREPRIVATEDATA
];
3269 r
= talloc(talloc_tos(), struct lsa_StorePrivateData
);
3274 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3279 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3285 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3286 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3287 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3292 if (DEBUGLEVEL
>= 10) {
3293 NDR_PRINT_IN_DEBUG(lsa_StorePrivateData
, r
);
3296 r
->out
.result
= _lsa_StorePrivateData(p
, r
);
3298 if (p
->rng_fault_state
) {
3300 /* Return true here, srv_pipe_hnd.c will take care */
3304 if (DEBUGLEVEL
>= 10) {
3305 NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData
, r
);
3308 push
= ndr_push_init_ctx(r
, NULL
);
3314 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3320 blob
= ndr_push_blob(push
);
3321 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3331 static bool api_lsa_RetrievePrivateData(pipes_struct
*p
)
3333 const struct ndr_interface_call
*call
;
3334 struct ndr_pull
*pull
;
3335 struct ndr_push
*push
;
3336 enum ndr_err_code ndr_err
;
3338 struct lsa_RetrievePrivateData
*r
;
3340 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_RETRIEVEPRIVATEDATA
];
3342 r
= talloc(talloc_tos(), struct lsa_RetrievePrivateData
);
3347 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3352 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3358 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3359 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3360 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3365 if (DEBUGLEVEL
>= 10) {
3366 NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData
, r
);
3369 ZERO_STRUCT(r
->out
);
3370 r
->out
.val
= r
->in
.val
;
3371 r
->out
.result
= _lsa_RetrievePrivateData(p
, r
);
3373 if (p
->rng_fault_state
) {
3375 /* Return true here, srv_pipe_hnd.c will take care */
3379 if (DEBUGLEVEL
>= 10) {
3380 NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData
, r
);
3383 push
= ndr_push_init_ctx(r
, NULL
);
3389 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3390 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3395 blob
= ndr_push_blob(push
);
3396 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3406 static bool api_lsa_OpenPolicy2(pipes_struct
*p
)
3408 const struct ndr_interface_call
*call
;
3409 struct ndr_pull
*pull
;
3410 struct ndr_push
*push
;
3411 enum ndr_err_code ndr_err
;
3413 struct lsa_OpenPolicy2
*r
;
3415 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENPOLICY2
];
3417 r
= talloc(talloc_tos(), struct lsa_OpenPolicy2
);
3422 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3427 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3433 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3434 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3435 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3440 if (DEBUGLEVEL
>= 10) {
3441 NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2
, r
);
3444 ZERO_STRUCT(r
->out
);
3445 r
->out
.handle
= talloc_zero(r
, struct policy_handle
);
3446 if (r
->out
.handle
== NULL
) {
3451 r
->out
.result
= _lsa_OpenPolicy2(p
, r
);
3453 if (p
->rng_fault_state
) {
3455 /* Return true here, srv_pipe_hnd.c will take care */
3459 if (DEBUGLEVEL
>= 10) {
3460 NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2
, r
);
3463 push
= ndr_push_init_ctx(r
, NULL
);
3469 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3470 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3475 blob
= ndr_push_blob(push
);
3476 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3486 static bool api_lsa_GetUserName(pipes_struct
*p
)
3488 const struct ndr_interface_call
*call
;
3489 struct ndr_pull
*pull
;
3490 struct ndr_push
*push
;
3491 enum ndr_err_code ndr_err
;
3493 struct lsa_GetUserName
*r
;
3495 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_GETUSERNAME
];
3497 r
= talloc(talloc_tos(), struct lsa_GetUserName
);
3502 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3507 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3513 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3514 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3515 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3520 if (DEBUGLEVEL
>= 10) {
3521 NDR_PRINT_IN_DEBUG(lsa_GetUserName
, r
);
3524 ZERO_STRUCT(r
->out
);
3525 r
->out
.account_name
= r
->in
.account_name
;
3526 r
->out
.authority_name
= r
->in
.authority_name
;
3527 r
->out
.result
= _lsa_GetUserName(p
, r
);
3529 if (p
->rng_fault_state
) {
3531 /* Return true here, srv_pipe_hnd.c will take care */
3535 if (DEBUGLEVEL
>= 10) {
3536 NDR_PRINT_OUT_DEBUG(lsa_GetUserName
, r
);
3539 push
= ndr_push_init_ctx(r
, NULL
);
3545 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3546 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3551 blob
= ndr_push_blob(push
);
3552 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3562 static bool api_lsa_QueryInfoPolicy2(pipes_struct
*p
)
3564 const struct ndr_interface_call
*call
;
3565 struct ndr_pull
*pull
;
3566 struct ndr_push
*push
;
3567 enum ndr_err_code ndr_err
;
3569 struct lsa_QueryInfoPolicy2
*r
;
3571 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYINFOPOLICY2
];
3573 r
= talloc(talloc_tos(), struct lsa_QueryInfoPolicy2
);
3578 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3583 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3589 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3590 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3591 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3596 if (DEBUGLEVEL
>= 10) {
3597 NDR_PRINT_IN_DEBUG(lsa_QueryInfoPolicy2
, r
);
3600 ZERO_STRUCT(r
->out
);
3601 r
->out
.info
= talloc_zero(r
, union lsa_PolicyInformation
*);
3602 if (r
->out
.info
== NULL
) {
3607 r
->out
.result
= _lsa_QueryInfoPolicy2(p
, r
);
3609 if (p
->rng_fault_state
) {
3611 /* Return true here, srv_pipe_hnd.c will take care */
3615 if (DEBUGLEVEL
>= 10) {
3616 NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2
, r
);
3619 push
= ndr_push_init_ctx(r
, NULL
);
3625 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3626 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3631 blob
= ndr_push_blob(push
);
3632 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3642 static bool api_lsa_SetInfoPolicy2(pipes_struct
*p
)
3644 const struct ndr_interface_call
*call
;
3645 struct ndr_pull
*pull
;
3646 struct ndr_push
*push
;
3647 enum ndr_err_code ndr_err
;
3649 struct lsa_SetInfoPolicy2
*r
;
3651 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETINFOPOLICY2
];
3653 r
= talloc(talloc_tos(), struct lsa_SetInfoPolicy2
);
3658 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3663 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3669 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3670 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3671 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3676 if (DEBUGLEVEL
>= 10) {
3677 NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2
, r
);
3680 r
->out
.result
= _lsa_SetInfoPolicy2(p
, r
);
3682 if (p
->rng_fault_state
) {
3684 /* Return true here, srv_pipe_hnd.c will take care */
3688 if (DEBUGLEVEL
>= 10) {
3689 NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2
, r
);
3692 push
= ndr_push_init_ctx(r
, NULL
);
3698 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3699 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3704 blob
= ndr_push_blob(push
);
3705 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3715 static bool api_lsa_QueryTrustedDomainInfoByName(pipes_struct
*p
)
3717 const struct ndr_interface_call
*call
;
3718 struct ndr_pull
*pull
;
3719 struct ndr_push
*push
;
3720 enum ndr_err_code ndr_err
;
3722 struct lsa_QueryTrustedDomainInfoByName
*r
;
3724 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME
];
3726 r
= talloc(talloc_tos(), struct lsa_QueryTrustedDomainInfoByName
);
3731 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3736 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3742 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3743 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3744 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3749 if (DEBUGLEVEL
>= 10) {
3750 NDR_PRINT_IN_DEBUG(lsa_QueryTrustedDomainInfoByName
, r
);
3753 ZERO_STRUCT(r
->out
);
3754 r
->out
.info
= talloc_zero(r
, union lsa_TrustedDomainInfo
*);
3755 if (r
->out
.info
== NULL
) {
3760 r
->out
.result
= _lsa_QueryTrustedDomainInfoByName(p
, r
);
3762 if (p
->rng_fault_state
) {
3764 /* Return true here, srv_pipe_hnd.c will take care */
3768 if (DEBUGLEVEL
>= 10) {
3769 NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName
, r
);
3772 push
= ndr_push_init_ctx(r
, NULL
);
3778 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3779 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3784 blob
= ndr_push_blob(push
);
3785 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3795 static bool api_lsa_SetTrustedDomainInfoByName(pipes_struct
*p
)
3797 const struct ndr_interface_call
*call
;
3798 struct ndr_pull
*pull
;
3799 struct ndr_push
*push
;
3800 enum ndr_err_code ndr_err
;
3802 struct lsa_SetTrustedDomainInfoByName
*r
;
3804 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETTRUSTEDDOMAININFOBYNAME
];
3806 r
= talloc(talloc_tos(), struct lsa_SetTrustedDomainInfoByName
);
3811 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3816 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3822 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3823 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3824 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3829 if (DEBUGLEVEL
>= 10) {
3830 NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName
, r
);
3833 r
->out
.result
= _lsa_SetTrustedDomainInfoByName(p
, r
);
3835 if (p
->rng_fault_state
) {
3837 /* Return true here, srv_pipe_hnd.c will take care */
3841 if (DEBUGLEVEL
>= 10) {
3842 NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName
, r
);
3845 push
= ndr_push_init_ctx(r
, NULL
);
3851 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3852 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3857 blob
= ndr_push_blob(push
);
3858 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3868 static bool api_lsa_EnumTrustedDomainsEx(pipes_struct
*p
)
3870 const struct ndr_interface_call
*call
;
3871 struct ndr_pull
*pull
;
3872 struct ndr_push
*push
;
3873 enum ndr_err_code ndr_err
;
3875 struct lsa_EnumTrustedDomainsEx
*r
;
3877 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_ENUMTRUSTEDDOMAINSEX
];
3879 r
= talloc(talloc_tos(), struct lsa_EnumTrustedDomainsEx
);
3884 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3889 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3895 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3896 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3897 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3902 if (DEBUGLEVEL
>= 10) {
3903 NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx
, r
);
3906 ZERO_STRUCT(r
->out
);
3907 r
->out
.resume_handle
= r
->in
.resume_handle
;
3908 r
->out
.domains
= talloc_zero(r
, struct lsa_DomainListEx
);
3909 if (r
->out
.domains
== NULL
) {
3914 r
->out
.result
= _lsa_EnumTrustedDomainsEx(p
, r
);
3916 if (p
->rng_fault_state
) {
3918 /* Return true here, srv_pipe_hnd.c will take care */
3922 if (DEBUGLEVEL
>= 10) {
3923 NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx
, r
);
3926 push
= ndr_push_init_ctx(r
, NULL
);
3932 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3933 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3938 blob
= ndr_push_blob(push
);
3939 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3949 static bool api_lsa_CreateTrustedDomainEx(pipes_struct
*p
)
3951 const struct ndr_interface_call
*call
;
3952 struct ndr_pull
*pull
;
3953 struct ndr_push
*push
;
3954 enum ndr_err_code ndr_err
;
3956 struct lsa_CreateTrustedDomainEx
*r
;
3958 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREATETRUSTEDDOMAINEX
];
3960 r
= talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx
);
3965 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3970 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3976 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3977 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3978 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3983 if (DEBUGLEVEL
>= 10) {
3984 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx
, r
);
3987 ZERO_STRUCT(r
->out
);
3988 r
->out
.trustdom_handle
= talloc_zero(r
, struct policy_handle
);
3989 if (r
->out
.trustdom_handle
== NULL
) {
3994 r
->out
.result
= _lsa_CreateTrustedDomainEx(p
, r
);
3996 if (p
->rng_fault_state
) {
3998 /* Return true here, srv_pipe_hnd.c will take care */
4002 if (DEBUGLEVEL
>= 10) {
4003 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx
, r
);
4006 push
= ndr_push_init_ctx(r
, NULL
);
4012 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4013 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4018 blob
= ndr_push_blob(push
);
4019 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4029 static bool api_lsa_CloseTrustedDomainEx(pipes_struct
*p
)
4031 const struct ndr_interface_call
*call
;
4032 struct ndr_pull
*pull
;
4033 struct ndr_push
*push
;
4034 enum ndr_err_code ndr_err
;
4036 struct lsa_CloseTrustedDomainEx
*r
;
4038 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CLOSETRUSTEDDOMAINEX
];
4040 r
= talloc(talloc_tos(), struct lsa_CloseTrustedDomainEx
);
4045 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4050 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4056 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4057 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4058 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4063 if (DEBUGLEVEL
>= 10) {
4064 NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx
, r
);
4067 ZERO_STRUCT(r
->out
);
4068 r
->out
.handle
= r
->in
.handle
;
4069 r
->out
.result
= _lsa_CloseTrustedDomainEx(p
, r
);
4071 if (p
->rng_fault_state
) {
4073 /* Return true here, srv_pipe_hnd.c will take care */
4077 if (DEBUGLEVEL
>= 10) {
4078 NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx
, r
);
4081 push
= ndr_push_init_ctx(r
, NULL
);
4087 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4088 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4093 blob
= ndr_push_blob(push
);
4094 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4104 static bool api_lsa_QueryDomainInformationPolicy(pipes_struct
*p
)
4106 const struct ndr_interface_call
*call
;
4107 struct ndr_pull
*pull
;
4108 struct ndr_push
*push
;
4109 enum ndr_err_code ndr_err
;
4111 struct lsa_QueryDomainInformationPolicy
*r
;
4113 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_QUERYDOMAININFORMATIONPOLICY
];
4115 r
= talloc(talloc_tos(), struct lsa_QueryDomainInformationPolicy
);
4120 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4125 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4131 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4132 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4133 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4138 if (DEBUGLEVEL
>= 10) {
4139 NDR_PRINT_IN_DEBUG(lsa_QueryDomainInformationPolicy
, r
);
4142 ZERO_STRUCT(r
->out
);
4143 r
->out
.info
= talloc_zero(r
, union lsa_DomainInformationPolicy
*);
4144 if (r
->out
.info
== NULL
) {
4149 r
->out
.result
= _lsa_QueryDomainInformationPolicy(p
, r
);
4151 if (p
->rng_fault_state
) {
4153 /* Return true here, srv_pipe_hnd.c will take care */
4157 if (DEBUGLEVEL
>= 10) {
4158 NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy
, r
);
4161 push
= ndr_push_init_ctx(r
, NULL
);
4167 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4168 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4173 blob
= ndr_push_blob(push
);
4174 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4184 static bool api_lsa_SetDomainInformationPolicy(pipes_struct
*p
)
4186 const struct ndr_interface_call
*call
;
4187 struct ndr_pull
*pull
;
4188 struct ndr_push
*push
;
4189 enum ndr_err_code ndr_err
;
4191 struct lsa_SetDomainInformationPolicy
*r
;
4193 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_SETDOMAININFORMATIONPOLICY
];
4195 r
= talloc(talloc_tos(), struct lsa_SetDomainInformationPolicy
);
4200 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4205 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4211 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4212 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4213 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4218 if (DEBUGLEVEL
>= 10) {
4219 NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy
, r
);
4222 r
->out
.result
= _lsa_SetDomainInformationPolicy(p
, r
);
4224 if (p
->rng_fault_state
) {
4226 /* Return true here, srv_pipe_hnd.c will take care */
4230 if (DEBUGLEVEL
>= 10) {
4231 NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy
, r
);
4234 push
= ndr_push_init_ctx(r
, NULL
);
4240 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4241 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4246 blob
= ndr_push_blob(push
);
4247 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4257 static bool api_lsa_OpenTrustedDomainByName(pipes_struct
*p
)
4259 const struct ndr_interface_call
*call
;
4260 struct ndr_pull
*pull
;
4261 struct ndr_push
*push
;
4262 enum ndr_err_code ndr_err
;
4264 struct lsa_OpenTrustedDomainByName
*r
;
4266 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_OPENTRUSTEDDOMAINBYNAME
];
4268 r
= talloc(talloc_tos(), struct lsa_OpenTrustedDomainByName
);
4273 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4278 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4284 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4285 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4286 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4291 if (DEBUGLEVEL
>= 10) {
4292 NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName
, r
);
4295 ZERO_STRUCT(r
->out
);
4296 r
->out
.trustdom_handle
= talloc_zero(r
, struct policy_handle
);
4297 if (r
->out
.trustdom_handle
== NULL
) {
4302 r
->out
.result
= _lsa_OpenTrustedDomainByName(p
, r
);
4304 if (p
->rng_fault_state
) {
4306 /* Return true here, srv_pipe_hnd.c will take care */
4310 if (DEBUGLEVEL
>= 10) {
4311 NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName
, r
);
4314 push
= ndr_push_init_ctx(r
, NULL
);
4320 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4326 blob
= ndr_push_blob(push
);
4327 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4337 static bool api_lsa_TestCall(pipes_struct
*p
)
4339 const struct ndr_interface_call
*call
;
4340 struct ndr_pull
*pull
;
4341 struct ndr_push
*push
;
4342 enum ndr_err_code ndr_err
;
4344 struct lsa_TestCall
*r
;
4346 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_TESTCALL
];
4348 r
= talloc(talloc_tos(), struct lsa_TestCall
);
4353 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4358 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4364 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4365 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4366 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4371 if (DEBUGLEVEL
>= 10) {
4372 NDR_PRINT_IN_DEBUG(lsa_TestCall
, r
);
4375 r
->out
.result
= _lsa_TestCall(p
, r
);
4377 if (p
->rng_fault_state
) {
4379 /* Return true here, srv_pipe_hnd.c will take care */
4383 if (DEBUGLEVEL
>= 10) {
4384 NDR_PRINT_OUT_DEBUG(lsa_TestCall
, r
);
4387 push
= ndr_push_init_ctx(r
, NULL
);
4393 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4399 blob
= ndr_push_blob(push
);
4400 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4410 static bool api_lsa_LookupSids2(pipes_struct
*p
)
4412 const struct ndr_interface_call
*call
;
4413 struct ndr_pull
*pull
;
4414 struct ndr_push
*push
;
4415 enum ndr_err_code ndr_err
;
4417 struct lsa_LookupSids2
*r
;
4419 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPSIDS2
];
4421 r
= talloc(talloc_tos(), struct lsa_LookupSids2
);
4426 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4431 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4437 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4438 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4439 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4444 if (DEBUGLEVEL
>= 10) {
4445 NDR_PRINT_IN_DEBUG(lsa_LookupSids2
, r
);
4448 ZERO_STRUCT(r
->out
);
4449 r
->out
.names
= r
->in
.names
;
4450 r
->out
.count
= r
->in
.count
;
4451 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
4452 if (r
->out
.domains
== NULL
) {
4457 r
->out
.result
= _lsa_LookupSids2(p
, r
);
4459 if (p
->rng_fault_state
) {
4461 /* Return true here, srv_pipe_hnd.c will take care */
4465 if (DEBUGLEVEL
>= 10) {
4466 NDR_PRINT_OUT_DEBUG(lsa_LookupSids2
, r
);
4469 push
= ndr_push_init_ctx(r
, NULL
);
4475 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4476 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4481 blob
= ndr_push_blob(push
);
4482 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4492 static bool api_lsa_LookupNames2(pipes_struct
*p
)
4494 const struct ndr_interface_call
*call
;
4495 struct ndr_pull
*pull
;
4496 struct ndr_push
*push
;
4497 enum ndr_err_code ndr_err
;
4499 struct lsa_LookupNames2
*r
;
4501 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPNAMES2
];
4503 r
= talloc(talloc_tos(), struct lsa_LookupNames2
);
4508 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4513 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4519 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4520 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4521 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4526 if (DEBUGLEVEL
>= 10) {
4527 NDR_PRINT_IN_DEBUG(lsa_LookupNames2
, r
);
4530 ZERO_STRUCT(r
->out
);
4531 r
->out
.sids
= r
->in
.sids
;
4532 r
->out
.count
= r
->in
.count
;
4533 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
4534 if (r
->out
.domains
== NULL
) {
4539 r
->out
.result
= _lsa_LookupNames2(p
, r
);
4541 if (p
->rng_fault_state
) {
4543 /* Return true here, srv_pipe_hnd.c will take care */
4547 if (DEBUGLEVEL
>= 10) {
4548 NDR_PRINT_OUT_DEBUG(lsa_LookupNames2
, r
);
4551 push
= ndr_push_init_ctx(r
, NULL
);
4557 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4558 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4563 blob
= ndr_push_blob(push
);
4564 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4574 static bool api_lsa_CreateTrustedDomainEx2(pipes_struct
*p
)
4576 const struct ndr_interface_call
*call
;
4577 struct ndr_pull
*pull
;
4578 struct ndr_push
*push
;
4579 enum ndr_err_code ndr_err
;
4581 struct lsa_CreateTrustedDomainEx2
*r
;
4583 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREATETRUSTEDDOMAINEX2
];
4585 r
= talloc(talloc_tos(), struct lsa_CreateTrustedDomainEx2
);
4590 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4595 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4601 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4602 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4603 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4608 if (DEBUGLEVEL
>= 10) {
4609 NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2
, r
);
4612 ZERO_STRUCT(r
->out
);
4613 r
->out
.trustdom_handle
= talloc_zero(r
, struct policy_handle
);
4614 if (r
->out
.trustdom_handle
== NULL
) {
4619 r
->out
.result
= _lsa_CreateTrustedDomainEx2(p
, r
);
4621 if (p
->rng_fault_state
) {
4623 /* Return true here, srv_pipe_hnd.c will take care */
4627 if (DEBUGLEVEL
>= 10) {
4628 NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2
, r
);
4631 push
= ndr_push_init_ctx(r
, NULL
);
4637 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4638 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4643 blob
= ndr_push_blob(push
);
4644 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4654 static bool api_lsa_CREDRWRITE(pipes_struct
*p
)
4656 const struct ndr_interface_call
*call
;
4657 struct ndr_pull
*pull
;
4658 struct ndr_push
*push
;
4659 enum ndr_err_code ndr_err
;
4661 struct lsa_CREDRWRITE
*r
;
4663 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRWRITE
];
4665 r
= talloc(talloc_tos(), struct lsa_CREDRWRITE
);
4670 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4675 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4681 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4682 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4683 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4688 if (DEBUGLEVEL
>= 10) {
4689 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE
, r
);
4692 r
->out
.result
= _lsa_CREDRWRITE(p
, r
);
4694 if (p
->rng_fault_state
) {
4696 /* Return true here, srv_pipe_hnd.c will take care */
4700 if (DEBUGLEVEL
>= 10) {
4701 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE
, r
);
4704 push
= ndr_push_init_ctx(r
, NULL
);
4710 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4711 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4716 blob
= ndr_push_blob(push
);
4717 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4727 static bool api_lsa_CREDRREAD(pipes_struct
*p
)
4729 const struct ndr_interface_call
*call
;
4730 struct ndr_pull
*pull
;
4731 struct ndr_push
*push
;
4732 enum ndr_err_code ndr_err
;
4734 struct lsa_CREDRREAD
*r
;
4736 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRREAD
];
4738 r
= talloc(talloc_tos(), struct lsa_CREDRREAD
);
4743 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4748 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4754 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4755 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4756 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4761 if (DEBUGLEVEL
>= 10) {
4762 NDR_PRINT_IN_DEBUG(lsa_CREDRREAD
, r
);
4765 r
->out
.result
= _lsa_CREDRREAD(p
, r
);
4767 if (p
->rng_fault_state
) {
4769 /* Return true here, srv_pipe_hnd.c will take care */
4773 if (DEBUGLEVEL
>= 10) {
4774 NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD
, r
);
4777 push
= ndr_push_init_ctx(r
, NULL
);
4783 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4784 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4789 blob
= ndr_push_blob(push
);
4790 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4800 static bool api_lsa_CREDRENUMERATE(pipes_struct
*p
)
4802 const struct ndr_interface_call
*call
;
4803 struct ndr_pull
*pull
;
4804 struct ndr_push
*push
;
4805 enum ndr_err_code ndr_err
;
4807 struct lsa_CREDRENUMERATE
*r
;
4809 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRENUMERATE
];
4811 r
= talloc(talloc_tos(), struct lsa_CREDRENUMERATE
);
4816 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4821 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4827 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4828 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4829 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4834 if (DEBUGLEVEL
>= 10) {
4835 NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE
, r
);
4838 r
->out
.result
= _lsa_CREDRENUMERATE(p
, r
);
4840 if (p
->rng_fault_state
) {
4842 /* Return true here, srv_pipe_hnd.c will take care */
4846 if (DEBUGLEVEL
>= 10) {
4847 NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE
, r
);
4850 push
= ndr_push_init_ctx(r
, NULL
);
4856 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4862 blob
= ndr_push_blob(push
);
4863 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4873 static bool api_lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct
*p
)
4875 const struct ndr_interface_call
*call
;
4876 struct ndr_pull
*pull
;
4877 struct ndr_push
*push
;
4878 enum ndr_err_code ndr_err
;
4880 struct lsa_CREDRWRITEDOMAINCREDENTIALS
*r
;
4882 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRWRITEDOMAINCREDENTIALS
];
4884 r
= talloc(talloc_tos(), struct lsa_CREDRWRITEDOMAINCREDENTIALS
);
4889 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4894 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4900 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4901 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4902 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4907 if (DEBUGLEVEL
>= 10) {
4908 NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS
, r
);
4911 r
->out
.result
= _lsa_CREDRWRITEDOMAINCREDENTIALS(p
, r
);
4913 if (p
->rng_fault_state
) {
4915 /* Return true here, srv_pipe_hnd.c will take care */
4919 if (DEBUGLEVEL
>= 10) {
4920 NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS
, r
);
4923 push
= ndr_push_init_ctx(r
, NULL
);
4929 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4930 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4935 blob
= ndr_push_blob(push
);
4936 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4946 static bool api_lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct
*p
)
4948 const struct ndr_interface_call
*call
;
4949 struct ndr_pull
*pull
;
4950 struct ndr_push
*push
;
4951 enum ndr_err_code ndr_err
;
4953 struct lsa_CREDRREADDOMAINCREDENTIALS
*r
;
4955 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRREADDOMAINCREDENTIALS
];
4957 r
= talloc(talloc_tos(), struct lsa_CREDRREADDOMAINCREDENTIALS
);
4962 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4967 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
4973 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4974 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4975 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4980 if (DEBUGLEVEL
>= 10) {
4981 NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS
, r
);
4984 r
->out
.result
= _lsa_CREDRREADDOMAINCREDENTIALS(p
, r
);
4986 if (p
->rng_fault_state
) {
4988 /* Return true here, srv_pipe_hnd.c will take care */
4992 if (DEBUGLEVEL
>= 10) {
4993 NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS
, r
);
4996 push
= ndr_push_init_ctx(r
, NULL
);
5002 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5003 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5008 blob
= ndr_push_blob(push
);
5009 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5019 static bool api_lsa_CREDRDELETE(pipes_struct
*p
)
5021 const struct ndr_interface_call
*call
;
5022 struct ndr_pull
*pull
;
5023 struct ndr_push
*push
;
5024 enum ndr_err_code ndr_err
;
5026 struct lsa_CREDRDELETE
*r
;
5028 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRDELETE
];
5030 r
= talloc(talloc_tos(), struct lsa_CREDRDELETE
);
5035 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5040 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5046 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5047 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5048 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5053 if (DEBUGLEVEL
>= 10) {
5054 NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE
, r
);
5057 r
->out
.result
= _lsa_CREDRDELETE(p
, r
);
5059 if (p
->rng_fault_state
) {
5061 /* Return true here, srv_pipe_hnd.c will take care */
5065 if (DEBUGLEVEL
>= 10) {
5066 NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE
, r
);
5069 push
= ndr_push_init_ctx(r
, NULL
);
5075 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5081 blob
= ndr_push_blob(push
);
5082 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5092 static bool api_lsa_CREDRGETTARGETINFO(pipes_struct
*p
)
5094 const struct ndr_interface_call
*call
;
5095 struct ndr_pull
*pull
;
5096 struct ndr_push
*push
;
5097 enum ndr_err_code ndr_err
;
5099 struct lsa_CREDRGETTARGETINFO
*r
;
5101 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRGETTARGETINFO
];
5103 r
= talloc(talloc_tos(), struct lsa_CREDRGETTARGETINFO
);
5108 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5113 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5119 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5120 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5121 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5126 if (DEBUGLEVEL
>= 10) {
5127 NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO
, r
);
5130 r
->out
.result
= _lsa_CREDRGETTARGETINFO(p
, r
);
5132 if (p
->rng_fault_state
) {
5134 /* Return true here, srv_pipe_hnd.c will take care */
5138 if (DEBUGLEVEL
>= 10) {
5139 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO
, r
);
5142 push
= ndr_push_init_ctx(r
, NULL
);
5148 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5149 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5154 blob
= ndr_push_blob(push
);
5155 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5165 static bool api_lsa_CREDRPROFILELOADED(pipes_struct
*p
)
5167 const struct ndr_interface_call
*call
;
5168 struct ndr_pull
*pull
;
5169 struct ndr_push
*push
;
5170 enum ndr_err_code ndr_err
;
5172 struct lsa_CREDRPROFILELOADED
*r
;
5174 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRPROFILELOADED
];
5176 r
= talloc(talloc_tos(), struct lsa_CREDRPROFILELOADED
);
5181 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5186 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5192 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5193 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5194 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5199 if (DEBUGLEVEL
>= 10) {
5200 NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED
, r
);
5203 r
->out
.result
= _lsa_CREDRPROFILELOADED(p
, r
);
5205 if (p
->rng_fault_state
) {
5207 /* Return true here, srv_pipe_hnd.c will take care */
5211 if (DEBUGLEVEL
>= 10) {
5212 NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED
, r
);
5215 push
= ndr_push_init_ctx(r
, NULL
);
5221 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5227 blob
= ndr_push_blob(push
);
5228 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5238 static bool api_lsa_LookupNames3(pipes_struct
*p
)
5240 const struct ndr_interface_call
*call
;
5241 struct ndr_pull
*pull
;
5242 struct ndr_push
*push
;
5243 enum ndr_err_code ndr_err
;
5245 struct lsa_LookupNames3
*r
;
5247 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPNAMES3
];
5249 r
= talloc(talloc_tos(), struct lsa_LookupNames3
);
5254 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5259 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5265 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5266 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5267 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5272 if (DEBUGLEVEL
>= 10) {
5273 NDR_PRINT_IN_DEBUG(lsa_LookupNames3
, r
);
5276 ZERO_STRUCT(r
->out
);
5277 r
->out
.sids
= r
->in
.sids
;
5278 r
->out
.count
= r
->in
.count
;
5279 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
5280 if (r
->out
.domains
== NULL
) {
5285 r
->out
.result
= _lsa_LookupNames3(p
, r
);
5287 if (p
->rng_fault_state
) {
5289 /* Return true here, srv_pipe_hnd.c will take care */
5293 if (DEBUGLEVEL
>= 10) {
5294 NDR_PRINT_OUT_DEBUG(lsa_LookupNames3
, r
);
5297 push
= ndr_push_init_ctx(r
, NULL
);
5303 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5304 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5309 blob
= ndr_push_blob(push
);
5310 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5320 static bool api_lsa_CREDRGETSESSIONTYPES(pipes_struct
*p
)
5322 const struct ndr_interface_call
*call
;
5323 struct ndr_pull
*pull
;
5324 struct ndr_push
*push
;
5325 enum ndr_err_code ndr_err
;
5327 struct lsa_CREDRGETSESSIONTYPES
*r
;
5329 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRGETSESSIONTYPES
];
5331 r
= talloc(talloc_tos(), struct lsa_CREDRGETSESSIONTYPES
);
5336 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5341 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5347 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5348 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5349 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5354 if (DEBUGLEVEL
>= 10) {
5355 NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES
, r
);
5358 r
->out
.result
= _lsa_CREDRGETSESSIONTYPES(p
, r
);
5360 if (p
->rng_fault_state
) {
5362 /* Return true here, srv_pipe_hnd.c will take care */
5366 if (DEBUGLEVEL
>= 10) {
5367 NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES
, r
);
5370 push
= ndr_push_init_ctx(r
, NULL
);
5376 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5377 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5382 blob
= ndr_push_blob(push
);
5383 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5393 static bool api_lsa_LSARREGISTERAUDITEVENT(pipes_struct
*p
)
5395 const struct ndr_interface_call
*call
;
5396 struct ndr_pull
*pull
;
5397 struct ndr_push
*push
;
5398 enum ndr_err_code ndr_err
;
5400 struct lsa_LSARREGISTERAUDITEVENT
*r
;
5402 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARREGISTERAUDITEVENT
];
5404 r
= talloc(talloc_tos(), struct lsa_LSARREGISTERAUDITEVENT
);
5409 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5414 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5420 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5421 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5422 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5427 if (DEBUGLEVEL
>= 10) {
5428 NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT
, r
);
5431 r
->out
.result
= _lsa_LSARREGISTERAUDITEVENT(p
, r
);
5433 if (p
->rng_fault_state
) {
5435 /* Return true here, srv_pipe_hnd.c will take care */
5439 if (DEBUGLEVEL
>= 10) {
5440 NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT
, r
);
5443 push
= ndr_push_init_ctx(r
, NULL
);
5449 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5450 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5455 blob
= ndr_push_blob(push
);
5456 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5466 static bool api_lsa_LSARGENAUDITEVENT(pipes_struct
*p
)
5468 const struct ndr_interface_call
*call
;
5469 struct ndr_pull
*pull
;
5470 struct ndr_push
*push
;
5471 enum ndr_err_code ndr_err
;
5473 struct lsa_LSARGENAUDITEVENT
*r
;
5475 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARGENAUDITEVENT
];
5477 r
= talloc(talloc_tos(), struct lsa_LSARGENAUDITEVENT
);
5482 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5487 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5493 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5494 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5495 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5500 if (DEBUGLEVEL
>= 10) {
5501 NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT
, r
);
5504 r
->out
.result
= _lsa_LSARGENAUDITEVENT(p
, r
);
5506 if (p
->rng_fault_state
) {
5508 /* Return true here, srv_pipe_hnd.c will take care */
5512 if (DEBUGLEVEL
>= 10) {
5513 NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT
, r
);
5516 push
= ndr_push_init_ctx(r
, NULL
);
5522 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5523 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5528 blob
= ndr_push_blob(push
);
5529 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5539 static bool api_lsa_LSARUNREGISTERAUDITEVENT(pipes_struct
*p
)
5541 const struct ndr_interface_call
*call
;
5542 struct ndr_pull
*pull
;
5543 struct ndr_push
*push
;
5544 enum ndr_err_code ndr_err
;
5546 struct lsa_LSARUNREGISTERAUDITEVENT
*r
;
5548 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARUNREGISTERAUDITEVENT
];
5550 r
= talloc(talloc_tos(), struct lsa_LSARUNREGISTERAUDITEVENT
);
5555 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5560 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5566 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5567 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5568 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5573 if (DEBUGLEVEL
>= 10) {
5574 NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT
, r
);
5577 r
->out
.result
= _lsa_LSARUNREGISTERAUDITEVENT(p
, r
);
5579 if (p
->rng_fault_state
) {
5581 /* Return true here, srv_pipe_hnd.c will take care */
5585 if (DEBUGLEVEL
>= 10) {
5586 NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT
, r
);
5589 push
= ndr_push_init_ctx(r
, NULL
);
5595 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5596 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5601 blob
= ndr_push_blob(push
);
5602 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5612 static bool api_lsa_lsaRQueryForestTrustInformation(pipes_struct
*p
)
5614 const struct ndr_interface_call
*call
;
5615 struct ndr_pull
*pull
;
5616 struct ndr_push
*push
;
5617 enum ndr_err_code ndr_err
;
5619 struct lsa_lsaRQueryForestTrustInformation
*r
;
5621 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION
];
5623 r
= talloc(talloc_tos(), struct lsa_lsaRQueryForestTrustInformation
);
5628 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5633 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5639 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5640 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5641 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5646 if (DEBUGLEVEL
>= 10) {
5647 NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation
, r
);
5650 ZERO_STRUCT(r
->out
);
5651 r
->out
.forest_trust_info
= talloc_zero(r
, struct lsa_ForestTrustInformation
*);
5652 if (r
->out
.forest_trust_info
== NULL
) {
5657 r
->out
.result
= _lsa_lsaRQueryForestTrustInformation(p
, r
);
5659 if (p
->rng_fault_state
) {
5661 /* Return true here, srv_pipe_hnd.c will take care */
5665 if (DEBUGLEVEL
>= 10) {
5666 NDR_PRINT_OUT_DEBUG(lsa_lsaRQueryForestTrustInformation
, r
);
5669 push
= ndr_push_init_ctx(r
, NULL
);
5675 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5676 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5681 blob
= ndr_push_blob(push
);
5682 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5692 static bool api_lsa_lsaRSetForestTrustInformation(pipes_struct
*p
)
5694 const struct ndr_interface_call
*call
;
5695 struct ndr_pull
*pull
;
5696 struct ndr_push
*push
;
5697 enum ndr_err_code ndr_err
;
5699 struct lsa_lsaRSetForestTrustInformation
*r
;
5701 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARSETFORESTTRUSTINFORMATION
];
5703 r
= talloc(talloc_tos(), struct lsa_lsaRSetForestTrustInformation
);
5708 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5713 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5719 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5720 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5721 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5726 if (DEBUGLEVEL
>= 10) {
5727 NDR_PRINT_IN_DEBUG(lsa_lsaRSetForestTrustInformation
, r
);
5730 ZERO_STRUCT(r
->out
);
5731 r
->out
.collision_info
= talloc_zero(r
, struct lsa_ForestTrustCollisionInfo
*);
5732 if (r
->out
.collision_info
== NULL
) {
5737 r
->out
.result
= _lsa_lsaRSetForestTrustInformation(p
, r
);
5739 if (p
->rng_fault_state
) {
5741 /* Return true here, srv_pipe_hnd.c will take care */
5745 if (DEBUGLEVEL
>= 10) {
5746 NDR_PRINT_OUT_DEBUG(lsa_lsaRSetForestTrustInformation
, r
);
5749 push
= ndr_push_init_ctx(r
, NULL
);
5755 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5756 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5761 blob
= ndr_push_blob(push
);
5762 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5772 static bool api_lsa_CREDRRENAME(pipes_struct
*p
)
5774 const struct ndr_interface_call
*call
;
5775 struct ndr_pull
*pull
;
5776 struct ndr_push
*push
;
5777 enum ndr_err_code ndr_err
;
5779 struct lsa_CREDRRENAME
*r
;
5781 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_CREDRRENAME
];
5783 r
= talloc(talloc_tos(), struct lsa_CREDRRENAME
);
5788 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5793 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5799 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5800 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5801 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5806 if (DEBUGLEVEL
>= 10) {
5807 NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME
, r
);
5810 r
->out
.result
= _lsa_CREDRRENAME(p
, r
);
5812 if (p
->rng_fault_state
) {
5814 /* Return true here, srv_pipe_hnd.c will take care */
5818 if (DEBUGLEVEL
>= 10) {
5819 NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME
, r
);
5822 push
= ndr_push_init_ctx(r
, NULL
);
5828 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5829 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5834 blob
= ndr_push_blob(push
);
5835 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5845 static bool api_lsa_LookupSids3(pipes_struct
*p
)
5847 const struct ndr_interface_call
*call
;
5848 struct ndr_pull
*pull
;
5849 struct ndr_push
*push
;
5850 enum ndr_err_code ndr_err
;
5852 struct lsa_LookupSids3
*r
;
5854 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPSIDS3
];
5856 r
= talloc(talloc_tos(), struct lsa_LookupSids3
);
5861 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5866 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5872 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5873 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5874 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5879 if (DEBUGLEVEL
>= 10) {
5880 NDR_PRINT_IN_DEBUG(lsa_LookupSids3
, r
);
5883 ZERO_STRUCT(r
->out
);
5884 r
->out
.names
= r
->in
.names
;
5885 r
->out
.count
= r
->in
.count
;
5886 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
5887 if (r
->out
.domains
== NULL
) {
5892 r
->out
.result
= _lsa_LookupSids3(p
, r
);
5894 if (p
->rng_fault_state
) {
5896 /* Return true here, srv_pipe_hnd.c will take care */
5900 if (DEBUGLEVEL
>= 10) {
5901 NDR_PRINT_OUT_DEBUG(lsa_LookupSids3
, r
);
5904 push
= ndr_push_init_ctx(r
, NULL
);
5910 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5911 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5916 blob
= ndr_push_blob(push
);
5917 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
5927 static bool api_lsa_LookupNames4(pipes_struct
*p
)
5929 const struct ndr_interface_call
*call
;
5930 struct ndr_pull
*pull
;
5931 struct ndr_push
*push
;
5932 enum ndr_err_code ndr_err
;
5934 struct lsa_LookupNames4
*r
;
5936 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LOOKUPNAMES4
];
5938 r
= talloc(talloc_tos(), struct lsa_LookupNames4
);
5943 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
5948 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
5954 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
5955 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
5956 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5961 if (DEBUGLEVEL
>= 10) {
5962 NDR_PRINT_IN_DEBUG(lsa_LookupNames4
, r
);
5965 ZERO_STRUCT(r
->out
);
5966 r
->out
.sids
= r
->in
.sids
;
5967 r
->out
.count
= r
->in
.count
;
5968 r
->out
.domains
= talloc_zero(r
, struct lsa_RefDomainList
*);
5969 if (r
->out
.domains
== NULL
) {
5974 r
->out
.result
= _lsa_LookupNames4(p
, r
);
5976 if (p
->rng_fault_state
) {
5978 /* Return true here, srv_pipe_hnd.c will take care */
5982 if (DEBUGLEVEL
>= 10) {
5983 NDR_PRINT_OUT_DEBUG(lsa_LookupNames4
, r
);
5986 push
= ndr_push_init_ctx(r
, NULL
);
5992 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
5993 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
5998 blob
= ndr_push_blob(push
);
5999 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
6009 static bool api_lsa_LSAROPENPOLICYSCE(pipes_struct
*p
)
6011 const struct ndr_interface_call
*call
;
6012 struct ndr_pull
*pull
;
6013 struct ndr_push
*push
;
6014 enum ndr_err_code ndr_err
;
6016 struct lsa_LSAROPENPOLICYSCE
*r
;
6018 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSAROPENPOLICYSCE
];
6020 r
= talloc(talloc_tos(), struct lsa_LSAROPENPOLICYSCE
);
6025 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
6030 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
6036 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
6037 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
6038 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6043 if (DEBUGLEVEL
>= 10) {
6044 NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE
, r
);
6047 r
->out
.result
= _lsa_LSAROPENPOLICYSCE(p
, r
);
6049 if (p
->rng_fault_state
) {
6051 /* Return true here, srv_pipe_hnd.c will take care */
6055 if (DEBUGLEVEL
>= 10) {
6056 NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE
, r
);
6059 push
= ndr_push_init_ctx(r
, NULL
);
6065 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
6066 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6071 blob
= ndr_push_blob(push
);
6072 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
6082 static bool api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct
*p
)
6084 const struct ndr_interface_call
*call
;
6085 struct ndr_pull
*pull
;
6086 struct ndr_push
*push
;
6087 enum ndr_err_code ndr_err
;
6089 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE
*r
;
6091 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE
];
6093 r
= talloc(talloc_tos(), struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE
);
6098 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
6103 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
6109 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
6110 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
6111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6116 if (DEBUGLEVEL
>= 10) {
6117 NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE
, r
);
6120 r
->out
.result
= _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p
, r
);
6122 if (p
->rng_fault_state
) {
6124 /* Return true here, srv_pipe_hnd.c will take care */
6128 if (DEBUGLEVEL
>= 10) {
6129 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE
, r
);
6132 push
= ndr_push_init_ctx(r
, NULL
);
6138 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
6139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6144 blob
= ndr_push_blob(push
);
6145 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
6155 static bool api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct
*p
)
6157 const struct ndr_interface_call
*call
;
6158 struct ndr_pull
*pull
;
6159 struct ndr_push
*push
;
6160 enum ndr_err_code ndr_err
;
6162 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
*r
;
6164 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE
];
6166 r
= talloc(talloc_tos(), struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
);
6171 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
6176 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
6182 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
6183 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
6184 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6189 if (DEBUGLEVEL
>= 10) {
6190 NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
, r
);
6193 r
->out
.result
= _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p
, r
);
6195 if (p
->rng_fault_state
) {
6197 /* Return true here, srv_pipe_hnd.c will take care */
6201 if (DEBUGLEVEL
>= 10) {
6202 NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
, r
);
6205 push
= ndr_push_init_ctx(r
, NULL
);
6211 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
6212 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6217 blob
= ndr_push_blob(push
);
6218 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
6228 static bool api_lsa_LSARADTREPORTSECURITYEVENT(pipes_struct
*p
)
6230 const struct ndr_interface_call
*call
;
6231 struct ndr_pull
*pull
;
6232 struct ndr_push
*push
;
6233 enum ndr_err_code ndr_err
;
6235 struct lsa_LSARADTREPORTSECURITYEVENT
*r
;
6237 call
= &ndr_table_lsarpc
.calls
[NDR_LSA_LSARADTREPORTSECURITYEVENT
];
6239 r
= talloc(talloc_tos(), struct lsa_LSARADTREPORTSECURITYEVENT
);
6244 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
6249 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
6255 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
6256 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
6257 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6262 if (DEBUGLEVEL
>= 10) {
6263 NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT
, r
);
6266 r
->out
.result
= _lsa_LSARADTREPORTSECURITYEVENT(p
, r
);
6268 if (p
->rng_fault_state
) {
6270 /* Return true here, srv_pipe_hnd.c will take care */
6274 if (DEBUGLEVEL
>= 10) {
6275 NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT
, r
);
6278 push
= ndr_push_init_ctx(r
, NULL
);
6284 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
6285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
6290 blob
= ndr_push_blob(push
);
6291 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
6303 static struct api_struct api_lsarpc_cmds
[] =
6305 {"LSA_CLOSE", NDR_LSA_CLOSE
, api_lsa_Close
},
6306 {"LSA_DELETE", NDR_LSA_DELETE
, api_lsa_Delete
},
6307 {"LSA_ENUMPRIVS", NDR_LSA_ENUMPRIVS
, api_lsa_EnumPrivs
},
6308 {"LSA_QUERYSECURITY", NDR_LSA_QUERYSECURITY
, api_lsa_QuerySecurity
},
6309 {"LSA_SETSECOBJ", NDR_LSA_SETSECOBJ
, api_lsa_SetSecObj
},
6310 {"LSA_CHANGEPASSWORD", NDR_LSA_CHANGEPASSWORD
, api_lsa_ChangePassword
},
6311 {"LSA_OPENPOLICY", NDR_LSA_OPENPOLICY
, api_lsa_OpenPolicy
},
6312 {"LSA_QUERYINFOPOLICY", NDR_LSA_QUERYINFOPOLICY
, api_lsa_QueryInfoPolicy
},
6313 {"LSA_SETINFOPOLICY", NDR_LSA_SETINFOPOLICY
, api_lsa_SetInfoPolicy
},
6314 {"LSA_CLEARAUDITLOG", NDR_LSA_CLEARAUDITLOG
, api_lsa_ClearAuditLog
},
6315 {"LSA_CREATEACCOUNT", NDR_LSA_CREATEACCOUNT
, api_lsa_CreateAccount
},
6316 {"LSA_ENUMACCOUNTS", NDR_LSA_ENUMACCOUNTS
, api_lsa_EnumAccounts
},
6317 {"LSA_CREATETRUSTEDDOMAIN", NDR_LSA_CREATETRUSTEDDOMAIN
, api_lsa_CreateTrustedDomain
},
6318 {"LSA_ENUMTRUSTDOM", NDR_LSA_ENUMTRUSTDOM
, api_lsa_EnumTrustDom
},
6319 {"LSA_LOOKUPNAMES", NDR_LSA_LOOKUPNAMES
, api_lsa_LookupNames
},
6320 {"LSA_LOOKUPSIDS", NDR_LSA_LOOKUPSIDS
, api_lsa_LookupSids
},
6321 {"LSA_CREATESECRET", NDR_LSA_CREATESECRET
, api_lsa_CreateSecret
},
6322 {"LSA_OPENACCOUNT", NDR_LSA_OPENACCOUNT
, api_lsa_OpenAccount
},
6323 {"LSA_ENUMPRIVSACCOUNT", NDR_LSA_ENUMPRIVSACCOUNT
, api_lsa_EnumPrivsAccount
},
6324 {"LSA_ADDPRIVILEGESTOACCOUNT", NDR_LSA_ADDPRIVILEGESTOACCOUNT
, api_lsa_AddPrivilegesToAccount
},
6325 {"LSA_REMOVEPRIVILEGESFROMACCOUNT", NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT
, api_lsa_RemovePrivilegesFromAccount
},
6326 {"LSA_GETQUOTASFORACCOUNT", NDR_LSA_GETQUOTASFORACCOUNT
, api_lsa_GetQuotasForAccount
},
6327 {"LSA_SETQUOTASFORACCOUNT", NDR_LSA_SETQUOTASFORACCOUNT
, api_lsa_SetQuotasForAccount
},
6328 {"LSA_GETSYSTEMACCESSACCOUNT", NDR_LSA_GETSYSTEMACCESSACCOUNT
, api_lsa_GetSystemAccessAccount
},
6329 {"LSA_SETSYSTEMACCESSACCOUNT", NDR_LSA_SETSYSTEMACCESSACCOUNT
, api_lsa_SetSystemAccessAccount
},
6330 {"LSA_OPENTRUSTEDDOMAIN", NDR_LSA_OPENTRUSTEDDOMAIN
, api_lsa_OpenTrustedDomain
},
6331 {"LSA_QUERYTRUSTEDDOMAININFO", NDR_LSA_QUERYTRUSTEDDOMAININFO
, api_lsa_QueryTrustedDomainInfo
},
6332 {"LSA_SETINFORMATIONTRUSTEDDOMAIN", NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN
, api_lsa_SetInformationTrustedDomain
},
6333 {"LSA_OPENSECRET", NDR_LSA_OPENSECRET
, api_lsa_OpenSecret
},
6334 {"LSA_SETSECRET", NDR_LSA_SETSECRET
, api_lsa_SetSecret
},
6335 {"LSA_QUERYSECRET", NDR_LSA_QUERYSECRET
, api_lsa_QuerySecret
},
6336 {"LSA_LOOKUPPRIVVALUE", NDR_LSA_LOOKUPPRIVVALUE
, api_lsa_LookupPrivValue
},
6337 {"LSA_LOOKUPPRIVNAME", NDR_LSA_LOOKUPPRIVNAME
, api_lsa_LookupPrivName
},
6338 {"LSA_LOOKUPPRIVDISPLAYNAME", NDR_LSA_LOOKUPPRIVDISPLAYNAME
, api_lsa_LookupPrivDisplayName
},
6339 {"LSA_DELETEOBJECT", NDR_LSA_DELETEOBJECT
, api_lsa_DeleteObject
},
6340 {"LSA_ENUMACCOUNTSWITHUSERRIGHT", NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT
, api_lsa_EnumAccountsWithUserRight
},
6341 {"LSA_ENUMACCOUNTRIGHTS", NDR_LSA_ENUMACCOUNTRIGHTS
, api_lsa_EnumAccountRights
},
6342 {"LSA_ADDACCOUNTRIGHTS", NDR_LSA_ADDACCOUNTRIGHTS
, api_lsa_AddAccountRights
},
6343 {"LSA_REMOVEACCOUNTRIGHTS", NDR_LSA_REMOVEACCOUNTRIGHTS
, api_lsa_RemoveAccountRights
},
6344 {"LSA_QUERYTRUSTEDDOMAININFOBYSID", NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID
, api_lsa_QueryTrustedDomainInfoBySid
},
6345 {"LSA_SETTRUSTEDDOMAININFO", NDR_LSA_SETTRUSTEDDOMAININFO
, api_lsa_SetTrustedDomainInfo
},
6346 {"LSA_DELETETRUSTEDDOMAIN", NDR_LSA_DELETETRUSTEDDOMAIN
, api_lsa_DeleteTrustedDomain
},
6347 {"LSA_STOREPRIVATEDATA", NDR_LSA_STOREPRIVATEDATA
, api_lsa_StorePrivateData
},
6348 {"LSA_RETRIEVEPRIVATEDATA", NDR_LSA_RETRIEVEPRIVATEDATA
, api_lsa_RetrievePrivateData
},
6349 {"LSA_OPENPOLICY2", NDR_LSA_OPENPOLICY2
, api_lsa_OpenPolicy2
},
6350 {"LSA_GETUSERNAME", NDR_LSA_GETUSERNAME
, api_lsa_GetUserName
},
6351 {"LSA_QUERYINFOPOLICY2", NDR_LSA_QUERYINFOPOLICY2
, api_lsa_QueryInfoPolicy2
},
6352 {"LSA_SETINFOPOLICY2", NDR_LSA_SETINFOPOLICY2
, api_lsa_SetInfoPolicy2
},
6353 {"LSA_QUERYTRUSTEDDOMAININFOBYNAME", NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME
, api_lsa_QueryTrustedDomainInfoByName
},
6354 {"LSA_SETTRUSTEDDOMAININFOBYNAME", NDR_LSA_SETTRUSTEDDOMAININFOBYNAME
, api_lsa_SetTrustedDomainInfoByName
},
6355 {"LSA_ENUMTRUSTEDDOMAINSEX", NDR_LSA_ENUMTRUSTEDDOMAINSEX
, api_lsa_EnumTrustedDomainsEx
},
6356 {"LSA_CREATETRUSTEDDOMAINEX", NDR_LSA_CREATETRUSTEDDOMAINEX
, api_lsa_CreateTrustedDomainEx
},
6357 {"LSA_CLOSETRUSTEDDOMAINEX", NDR_LSA_CLOSETRUSTEDDOMAINEX
, api_lsa_CloseTrustedDomainEx
},
6358 {"LSA_QUERYDOMAININFORMATIONPOLICY", NDR_LSA_QUERYDOMAININFORMATIONPOLICY
, api_lsa_QueryDomainInformationPolicy
},
6359 {"LSA_SETDOMAININFORMATIONPOLICY", NDR_LSA_SETDOMAININFORMATIONPOLICY
, api_lsa_SetDomainInformationPolicy
},
6360 {"LSA_OPENTRUSTEDDOMAINBYNAME", NDR_LSA_OPENTRUSTEDDOMAINBYNAME
, api_lsa_OpenTrustedDomainByName
},
6361 {"LSA_TESTCALL", NDR_LSA_TESTCALL
, api_lsa_TestCall
},
6362 {"LSA_LOOKUPSIDS2", NDR_LSA_LOOKUPSIDS2
, api_lsa_LookupSids2
},
6363 {"LSA_LOOKUPNAMES2", NDR_LSA_LOOKUPNAMES2
, api_lsa_LookupNames2
},
6364 {"LSA_CREATETRUSTEDDOMAINEX2", NDR_LSA_CREATETRUSTEDDOMAINEX2
, api_lsa_CreateTrustedDomainEx2
},
6365 {"LSA_CREDRWRITE", NDR_LSA_CREDRWRITE
, api_lsa_CREDRWRITE
},
6366 {"LSA_CREDRREAD", NDR_LSA_CREDRREAD
, api_lsa_CREDRREAD
},
6367 {"LSA_CREDRENUMERATE", NDR_LSA_CREDRENUMERATE
, api_lsa_CREDRENUMERATE
},
6368 {"LSA_CREDRWRITEDOMAINCREDENTIALS", NDR_LSA_CREDRWRITEDOMAINCREDENTIALS
, api_lsa_CREDRWRITEDOMAINCREDENTIALS
},
6369 {"LSA_CREDRREADDOMAINCREDENTIALS", NDR_LSA_CREDRREADDOMAINCREDENTIALS
, api_lsa_CREDRREADDOMAINCREDENTIALS
},
6370 {"LSA_CREDRDELETE", NDR_LSA_CREDRDELETE
, api_lsa_CREDRDELETE
},
6371 {"LSA_CREDRGETTARGETINFO", NDR_LSA_CREDRGETTARGETINFO
, api_lsa_CREDRGETTARGETINFO
},
6372 {"LSA_CREDRPROFILELOADED", NDR_LSA_CREDRPROFILELOADED
, api_lsa_CREDRPROFILELOADED
},
6373 {"LSA_LOOKUPNAMES3", NDR_LSA_LOOKUPNAMES3
, api_lsa_LookupNames3
},
6374 {"LSA_CREDRGETSESSIONTYPES", NDR_LSA_CREDRGETSESSIONTYPES
, api_lsa_CREDRGETSESSIONTYPES
},
6375 {"LSA_LSARREGISTERAUDITEVENT", NDR_LSA_LSARREGISTERAUDITEVENT
, api_lsa_LSARREGISTERAUDITEVENT
},
6376 {"LSA_LSARGENAUDITEVENT", NDR_LSA_LSARGENAUDITEVENT
, api_lsa_LSARGENAUDITEVENT
},
6377 {"LSA_LSARUNREGISTERAUDITEVENT", NDR_LSA_LSARUNREGISTERAUDITEVENT
, api_lsa_LSARUNREGISTERAUDITEVENT
},
6378 {"LSA_LSARQUERYFORESTTRUSTINFORMATION", NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION
, api_lsa_lsaRQueryForestTrustInformation
},
6379 {"LSA_LSARSETFORESTTRUSTINFORMATION", NDR_LSA_LSARSETFORESTTRUSTINFORMATION
, api_lsa_lsaRSetForestTrustInformation
},
6380 {"LSA_CREDRRENAME", NDR_LSA_CREDRRENAME
, api_lsa_CREDRRENAME
},
6381 {"LSA_LOOKUPSIDS3", NDR_LSA_LOOKUPSIDS3
, api_lsa_LookupSids3
},
6382 {"LSA_LOOKUPNAMES4", NDR_LSA_LOOKUPNAMES4
, api_lsa_LookupNames4
},
6383 {"LSA_LSAROPENPOLICYSCE", NDR_LSA_LSAROPENPOLICYSCE
, api_lsa_LSAROPENPOLICYSCE
},
6384 {"LSA_LSARADTREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE
, api_lsa_LSARADTREGISTERSECURITYEVENTSOURCE
},
6385 {"LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE", NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE
, api_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
},
6386 {"LSA_LSARADTREPORTSECURITYEVENT", NDR_LSA_LSARADTREPORTSECURITYEVENT
, api_lsa_LSARADTREPORTSECURITYEVENT
},
6389 void lsarpc_get_pipe_fns(struct api_struct
**fns
, int *n_fns
)
6391 *fns
= api_lsarpc_cmds
;
6392 *n_fns
= sizeof(api_lsarpc_cmds
) / sizeof(struct api_struct
);
6395 NTSTATUS
rpc_lsarpc_dispatch(struct rpc_pipe_client
*cli
, TALLOC_CTX
*mem_ctx
, const struct ndr_interface_table
*table
, uint32_t opnum
, void *_r
)
6397 if (cli
->pipes_struct
== NULL
) {
6398 return NT_STATUS_INVALID_PARAMETER
;
6403 case NDR_LSA_CLOSE
: {
6404 struct lsa_Close
*r
= (struct lsa_Close
*)_r
;
6405 ZERO_STRUCT(r
->out
);
6406 r
->out
.handle
= r
->in
.handle
;
6407 r
->out
.result
= _lsa_Close(cli
->pipes_struct
, r
);
6408 return NT_STATUS_OK
;
6411 case NDR_LSA_DELETE
: {
6412 struct lsa_Delete
*r
= (struct lsa_Delete
*)_r
;
6413 r
->out
.result
= _lsa_Delete(cli
->pipes_struct
, r
);
6414 return NT_STATUS_OK
;
6417 case NDR_LSA_ENUMPRIVS
: {
6418 struct lsa_EnumPrivs
*r
= (struct lsa_EnumPrivs
*)_r
;
6419 ZERO_STRUCT(r
->out
);
6420 r
->out
.resume_handle
= r
->in
.resume_handle
;
6421 r
->out
.privs
= talloc_zero(mem_ctx
, struct lsa_PrivArray
);
6422 if (r
->out
.privs
== NULL
) {
6423 return NT_STATUS_NO_MEMORY
;
6426 r
->out
.result
= _lsa_EnumPrivs(cli
->pipes_struct
, r
);
6427 return NT_STATUS_OK
;
6430 case NDR_LSA_QUERYSECURITY
: {
6431 struct lsa_QuerySecurity
*r
= (struct lsa_QuerySecurity
*)_r
;
6432 ZERO_STRUCT(r
->out
);
6433 r
->out
.sdbuf
= talloc_zero(mem_ctx
, struct sec_desc_buf
*);
6434 if (r
->out
.sdbuf
== NULL
) {
6435 return NT_STATUS_NO_MEMORY
;
6438 r
->out
.result
= _lsa_QuerySecurity(cli
->pipes_struct
, r
);
6439 return NT_STATUS_OK
;
6442 case NDR_LSA_SETSECOBJ
: {
6443 struct lsa_SetSecObj
*r
= (struct lsa_SetSecObj
*)_r
;
6444 r
->out
.result
= _lsa_SetSecObj(cli
->pipes_struct
, r
);
6445 return NT_STATUS_OK
;
6448 case NDR_LSA_CHANGEPASSWORD
: {
6449 struct lsa_ChangePassword
*r
= (struct lsa_ChangePassword
*)_r
;
6450 r
->out
.result
= _lsa_ChangePassword(cli
->pipes_struct
, r
);
6451 return NT_STATUS_OK
;
6454 case NDR_LSA_OPENPOLICY
: {
6455 struct lsa_OpenPolicy
*r
= (struct lsa_OpenPolicy
*)_r
;
6456 ZERO_STRUCT(r
->out
);
6457 r
->out
.handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6458 if (r
->out
.handle
== NULL
) {
6459 return NT_STATUS_NO_MEMORY
;
6462 r
->out
.result
= _lsa_OpenPolicy(cli
->pipes_struct
, r
);
6463 return NT_STATUS_OK
;
6466 case NDR_LSA_QUERYINFOPOLICY
: {
6467 struct lsa_QueryInfoPolicy
*r
= (struct lsa_QueryInfoPolicy
*)_r
;
6468 ZERO_STRUCT(r
->out
);
6469 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_PolicyInformation
*);
6470 if (r
->out
.info
== NULL
) {
6471 return NT_STATUS_NO_MEMORY
;
6474 r
->out
.result
= _lsa_QueryInfoPolicy(cli
->pipes_struct
, r
);
6475 return NT_STATUS_OK
;
6478 case NDR_LSA_SETINFOPOLICY
: {
6479 struct lsa_SetInfoPolicy
*r
= (struct lsa_SetInfoPolicy
*)_r
;
6480 r
->out
.result
= _lsa_SetInfoPolicy(cli
->pipes_struct
, r
);
6481 return NT_STATUS_OK
;
6484 case NDR_LSA_CLEARAUDITLOG
: {
6485 struct lsa_ClearAuditLog
*r
= (struct lsa_ClearAuditLog
*)_r
;
6486 r
->out
.result
= _lsa_ClearAuditLog(cli
->pipes_struct
, r
);
6487 return NT_STATUS_OK
;
6490 case NDR_LSA_CREATEACCOUNT
: {
6491 struct lsa_CreateAccount
*r
= (struct lsa_CreateAccount
*)_r
;
6492 ZERO_STRUCT(r
->out
);
6493 r
->out
.acct_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6494 if (r
->out
.acct_handle
== NULL
) {
6495 return NT_STATUS_NO_MEMORY
;
6498 r
->out
.result
= _lsa_CreateAccount(cli
->pipes_struct
, r
);
6499 return NT_STATUS_OK
;
6502 case NDR_LSA_ENUMACCOUNTS
: {
6503 struct lsa_EnumAccounts
*r
= (struct lsa_EnumAccounts
*)_r
;
6504 ZERO_STRUCT(r
->out
);
6505 r
->out
.resume_handle
= r
->in
.resume_handle
;
6506 r
->out
.sids
= talloc_zero(mem_ctx
, struct lsa_SidArray
);
6507 if (r
->out
.sids
== NULL
) {
6508 return NT_STATUS_NO_MEMORY
;
6511 r
->out
.result
= _lsa_EnumAccounts(cli
->pipes_struct
, r
);
6512 return NT_STATUS_OK
;
6515 case NDR_LSA_CREATETRUSTEDDOMAIN
: {
6516 struct lsa_CreateTrustedDomain
*r
= (struct lsa_CreateTrustedDomain
*)_r
;
6517 ZERO_STRUCT(r
->out
);
6518 r
->out
.trustdom_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6519 if (r
->out
.trustdom_handle
== NULL
) {
6520 return NT_STATUS_NO_MEMORY
;
6523 r
->out
.result
= _lsa_CreateTrustedDomain(cli
->pipes_struct
, r
);
6524 return NT_STATUS_OK
;
6527 case NDR_LSA_ENUMTRUSTDOM
: {
6528 struct lsa_EnumTrustDom
*r
= (struct lsa_EnumTrustDom
*)_r
;
6529 ZERO_STRUCT(r
->out
);
6530 r
->out
.resume_handle
= r
->in
.resume_handle
;
6531 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_DomainList
);
6532 if (r
->out
.domains
== NULL
) {
6533 return NT_STATUS_NO_MEMORY
;
6536 r
->out
.result
= _lsa_EnumTrustDom(cli
->pipes_struct
, r
);
6537 return NT_STATUS_OK
;
6540 case NDR_LSA_LOOKUPNAMES
: {
6541 struct lsa_LookupNames
*r
= (struct lsa_LookupNames
*)_r
;
6542 ZERO_STRUCT(r
->out
);
6543 r
->out
.sids
= r
->in
.sids
;
6544 r
->out
.count
= r
->in
.count
;
6545 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
6546 if (r
->out
.domains
== NULL
) {
6547 return NT_STATUS_NO_MEMORY
;
6550 r
->out
.result
= _lsa_LookupNames(cli
->pipes_struct
, r
);
6551 return NT_STATUS_OK
;
6554 case NDR_LSA_LOOKUPSIDS
: {
6555 struct lsa_LookupSids
*r
= (struct lsa_LookupSids
*)_r
;
6556 ZERO_STRUCT(r
->out
);
6557 r
->out
.names
= r
->in
.names
;
6558 r
->out
.count
= r
->in
.count
;
6559 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
6560 if (r
->out
.domains
== NULL
) {
6561 return NT_STATUS_NO_MEMORY
;
6564 r
->out
.result
= _lsa_LookupSids(cli
->pipes_struct
, r
);
6565 return NT_STATUS_OK
;
6568 case NDR_LSA_CREATESECRET
: {
6569 struct lsa_CreateSecret
*r
= (struct lsa_CreateSecret
*)_r
;
6570 ZERO_STRUCT(r
->out
);
6571 r
->out
.sec_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6572 if (r
->out
.sec_handle
== NULL
) {
6573 return NT_STATUS_NO_MEMORY
;
6576 r
->out
.result
= _lsa_CreateSecret(cli
->pipes_struct
, r
);
6577 return NT_STATUS_OK
;
6580 case NDR_LSA_OPENACCOUNT
: {
6581 struct lsa_OpenAccount
*r
= (struct lsa_OpenAccount
*)_r
;
6582 ZERO_STRUCT(r
->out
);
6583 r
->out
.acct_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6584 if (r
->out
.acct_handle
== NULL
) {
6585 return NT_STATUS_NO_MEMORY
;
6588 r
->out
.result
= _lsa_OpenAccount(cli
->pipes_struct
, r
);
6589 return NT_STATUS_OK
;
6592 case NDR_LSA_ENUMPRIVSACCOUNT
: {
6593 struct lsa_EnumPrivsAccount
*r
= (struct lsa_EnumPrivsAccount
*)_r
;
6594 ZERO_STRUCT(r
->out
);
6595 r
->out
.privs
= talloc_zero(mem_ctx
, struct lsa_PrivilegeSet
*);
6596 if (r
->out
.privs
== NULL
) {
6597 return NT_STATUS_NO_MEMORY
;
6600 r
->out
.result
= _lsa_EnumPrivsAccount(cli
->pipes_struct
, r
);
6601 return NT_STATUS_OK
;
6604 case NDR_LSA_ADDPRIVILEGESTOACCOUNT
: {
6605 struct lsa_AddPrivilegesToAccount
*r
= (struct lsa_AddPrivilegesToAccount
*)_r
;
6606 r
->out
.result
= _lsa_AddPrivilegesToAccount(cli
->pipes_struct
, r
);
6607 return NT_STATUS_OK
;
6610 case NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT
: {
6611 struct lsa_RemovePrivilegesFromAccount
*r
= (struct lsa_RemovePrivilegesFromAccount
*)_r
;
6612 r
->out
.result
= _lsa_RemovePrivilegesFromAccount(cli
->pipes_struct
, r
);
6613 return NT_STATUS_OK
;
6616 case NDR_LSA_GETQUOTASFORACCOUNT
: {
6617 struct lsa_GetQuotasForAccount
*r
= (struct lsa_GetQuotasForAccount
*)_r
;
6618 r
->out
.result
= _lsa_GetQuotasForAccount(cli
->pipes_struct
, r
);
6619 return NT_STATUS_OK
;
6622 case NDR_LSA_SETQUOTASFORACCOUNT
: {
6623 struct lsa_SetQuotasForAccount
*r
= (struct lsa_SetQuotasForAccount
*)_r
;
6624 r
->out
.result
= _lsa_SetQuotasForAccount(cli
->pipes_struct
, r
);
6625 return NT_STATUS_OK
;
6628 case NDR_LSA_GETSYSTEMACCESSACCOUNT
: {
6629 struct lsa_GetSystemAccessAccount
*r
= (struct lsa_GetSystemAccessAccount
*)_r
;
6630 ZERO_STRUCT(r
->out
);
6631 r
->out
.access_mask
= talloc_zero(mem_ctx
, uint32_t);
6632 if (r
->out
.access_mask
== NULL
) {
6633 return NT_STATUS_NO_MEMORY
;
6636 r
->out
.result
= _lsa_GetSystemAccessAccount(cli
->pipes_struct
, r
);
6637 return NT_STATUS_OK
;
6640 case NDR_LSA_SETSYSTEMACCESSACCOUNT
: {
6641 struct lsa_SetSystemAccessAccount
*r
= (struct lsa_SetSystemAccessAccount
*)_r
;
6642 r
->out
.result
= _lsa_SetSystemAccessAccount(cli
->pipes_struct
, r
);
6643 return NT_STATUS_OK
;
6646 case NDR_LSA_OPENTRUSTEDDOMAIN
: {
6647 struct lsa_OpenTrustedDomain
*r
= (struct lsa_OpenTrustedDomain
*)_r
;
6648 ZERO_STRUCT(r
->out
);
6649 r
->out
.trustdom_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6650 if (r
->out
.trustdom_handle
== NULL
) {
6651 return NT_STATUS_NO_MEMORY
;
6654 r
->out
.result
= _lsa_OpenTrustedDomain(cli
->pipes_struct
, r
);
6655 return NT_STATUS_OK
;
6658 case NDR_LSA_QUERYTRUSTEDDOMAININFO
: {
6659 struct lsa_QueryTrustedDomainInfo
*r
= (struct lsa_QueryTrustedDomainInfo
*)_r
;
6660 ZERO_STRUCT(r
->out
);
6661 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_TrustedDomainInfo
*);
6662 if (r
->out
.info
== NULL
) {
6663 return NT_STATUS_NO_MEMORY
;
6666 r
->out
.result
= _lsa_QueryTrustedDomainInfo(cli
->pipes_struct
, r
);
6667 return NT_STATUS_OK
;
6670 case NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN
: {
6671 struct lsa_SetInformationTrustedDomain
*r
= (struct lsa_SetInformationTrustedDomain
*)_r
;
6672 r
->out
.result
= _lsa_SetInformationTrustedDomain(cli
->pipes_struct
, r
);
6673 return NT_STATUS_OK
;
6676 case NDR_LSA_OPENSECRET
: {
6677 struct lsa_OpenSecret
*r
= (struct lsa_OpenSecret
*)_r
;
6678 ZERO_STRUCT(r
->out
);
6679 r
->out
.sec_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6680 if (r
->out
.sec_handle
== NULL
) {
6681 return NT_STATUS_NO_MEMORY
;
6684 r
->out
.result
= _lsa_OpenSecret(cli
->pipes_struct
, r
);
6685 return NT_STATUS_OK
;
6688 case NDR_LSA_SETSECRET
: {
6689 struct lsa_SetSecret
*r
= (struct lsa_SetSecret
*)_r
;
6690 r
->out
.result
= _lsa_SetSecret(cli
->pipes_struct
, r
);
6691 return NT_STATUS_OK
;
6694 case NDR_LSA_QUERYSECRET
: {
6695 struct lsa_QuerySecret
*r
= (struct lsa_QuerySecret
*)_r
;
6696 ZERO_STRUCT(r
->out
);
6697 r
->out
.new_val
= r
->in
.new_val
;
6698 r
->out
.new_mtime
= r
->in
.new_mtime
;
6699 r
->out
.old_val
= r
->in
.old_val
;
6700 r
->out
.old_mtime
= r
->in
.old_mtime
;
6701 r
->out
.result
= _lsa_QuerySecret(cli
->pipes_struct
, r
);
6702 return NT_STATUS_OK
;
6705 case NDR_LSA_LOOKUPPRIVVALUE
: {
6706 struct lsa_LookupPrivValue
*r
= (struct lsa_LookupPrivValue
*)_r
;
6707 ZERO_STRUCT(r
->out
);
6708 r
->out
.luid
= talloc_zero(mem_ctx
, struct lsa_LUID
);
6709 if (r
->out
.luid
== NULL
) {
6710 return NT_STATUS_NO_MEMORY
;
6713 r
->out
.result
= _lsa_LookupPrivValue(cli
->pipes_struct
, r
);
6714 return NT_STATUS_OK
;
6717 case NDR_LSA_LOOKUPPRIVNAME
: {
6718 struct lsa_LookupPrivName
*r
= (struct lsa_LookupPrivName
*)_r
;
6719 ZERO_STRUCT(r
->out
);
6720 r
->out
.name
= talloc_zero(mem_ctx
, struct lsa_StringLarge
*);
6721 if (r
->out
.name
== NULL
) {
6722 return NT_STATUS_NO_MEMORY
;
6725 r
->out
.result
= _lsa_LookupPrivName(cli
->pipes_struct
, r
);
6726 return NT_STATUS_OK
;
6729 case NDR_LSA_LOOKUPPRIVDISPLAYNAME
: {
6730 struct lsa_LookupPrivDisplayName
*r
= (struct lsa_LookupPrivDisplayName
*)_r
;
6731 ZERO_STRUCT(r
->out
);
6732 r
->out
.disp_name
= talloc_zero(mem_ctx
, struct lsa_StringLarge
*);
6733 if (r
->out
.disp_name
== NULL
) {
6734 return NT_STATUS_NO_MEMORY
;
6737 r
->out
.returned_language_id
= talloc_zero(mem_ctx
, uint16_t);
6738 if (r
->out
.returned_language_id
== NULL
) {
6739 return NT_STATUS_NO_MEMORY
;
6742 r
->out
.result
= _lsa_LookupPrivDisplayName(cli
->pipes_struct
, r
);
6743 return NT_STATUS_OK
;
6746 case NDR_LSA_DELETEOBJECT
: {
6747 struct lsa_DeleteObject
*r
= (struct lsa_DeleteObject
*)_r
;
6748 ZERO_STRUCT(r
->out
);
6749 r
->out
.handle
= r
->in
.handle
;
6750 r
->out
.result
= _lsa_DeleteObject(cli
->pipes_struct
, r
);
6751 return NT_STATUS_OK
;
6754 case NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT
: {
6755 struct lsa_EnumAccountsWithUserRight
*r
= (struct lsa_EnumAccountsWithUserRight
*)_r
;
6756 ZERO_STRUCT(r
->out
);
6757 r
->out
.sids
= talloc_zero(mem_ctx
, struct lsa_SidArray
);
6758 if (r
->out
.sids
== NULL
) {
6759 return NT_STATUS_NO_MEMORY
;
6762 r
->out
.result
= _lsa_EnumAccountsWithUserRight(cli
->pipes_struct
, r
);
6763 return NT_STATUS_OK
;
6766 case NDR_LSA_ENUMACCOUNTRIGHTS
: {
6767 struct lsa_EnumAccountRights
*r
= (struct lsa_EnumAccountRights
*)_r
;
6768 ZERO_STRUCT(r
->out
);
6769 r
->out
.rights
= talloc_zero(mem_ctx
, struct lsa_RightSet
);
6770 if (r
->out
.rights
== NULL
) {
6771 return NT_STATUS_NO_MEMORY
;
6774 r
->out
.result
= _lsa_EnumAccountRights(cli
->pipes_struct
, r
);
6775 return NT_STATUS_OK
;
6778 case NDR_LSA_ADDACCOUNTRIGHTS
: {
6779 struct lsa_AddAccountRights
*r
= (struct lsa_AddAccountRights
*)_r
;
6780 r
->out
.result
= _lsa_AddAccountRights(cli
->pipes_struct
, r
);
6781 return NT_STATUS_OK
;
6784 case NDR_LSA_REMOVEACCOUNTRIGHTS
: {
6785 struct lsa_RemoveAccountRights
*r
= (struct lsa_RemoveAccountRights
*)_r
;
6786 r
->out
.result
= _lsa_RemoveAccountRights(cli
->pipes_struct
, r
);
6787 return NT_STATUS_OK
;
6790 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID
: {
6791 struct lsa_QueryTrustedDomainInfoBySid
*r
= (struct lsa_QueryTrustedDomainInfoBySid
*)_r
;
6792 ZERO_STRUCT(r
->out
);
6793 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_TrustedDomainInfo
*);
6794 if (r
->out
.info
== NULL
) {
6795 return NT_STATUS_NO_MEMORY
;
6798 r
->out
.result
= _lsa_QueryTrustedDomainInfoBySid(cli
->pipes_struct
, r
);
6799 return NT_STATUS_OK
;
6802 case NDR_LSA_SETTRUSTEDDOMAININFO
: {
6803 struct lsa_SetTrustedDomainInfo
*r
= (struct lsa_SetTrustedDomainInfo
*)_r
;
6804 r
->out
.result
= _lsa_SetTrustedDomainInfo(cli
->pipes_struct
, r
);
6805 return NT_STATUS_OK
;
6808 case NDR_LSA_DELETETRUSTEDDOMAIN
: {
6809 struct lsa_DeleteTrustedDomain
*r
= (struct lsa_DeleteTrustedDomain
*)_r
;
6810 r
->out
.result
= _lsa_DeleteTrustedDomain(cli
->pipes_struct
, r
);
6811 return NT_STATUS_OK
;
6814 case NDR_LSA_STOREPRIVATEDATA
: {
6815 struct lsa_StorePrivateData
*r
= (struct lsa_StorePrivateData
*)_r
;
6816 r
->out
.result
= _lsa_StorePrivateData(cli
->pipes_struct
, r
);
6817 return NT_STATUS_OK
;
6820 case NDR_LSA_RETRIEVEPRIVATEDATA
: {
6821 struct lsa_RetrievePrivateData
*r
= (struct lsa_RetrievePrivateData
*)_r
;
6822 ZERO_STRUCT(r
->out
);
6823 r
->out
.val
= r
->in
.val
;
6824 r
->out
.result
= _lsa_RetrievePrivateData(cli
->pipes_struct
, r
);
6825 return NT_STATUS_OK
;
6828 case NDR_LSA_OPENPOLICY2
: {
6829 struct lsa_OpenPolicy2
*r
= (struct lsa_OpenPolicy2
*)_r
;
6830 ZERO_STRUCT(r
->out
);
6831 r
->out
.handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6832 if (r
->out
.handle
== NULL
) {
6833 return NT_STATUS_NO_MEMORY
;
6836 r
->out
.result
= _lsa_OpenPolicy2(cli
->pipes_struct
, r
);
6837 return NT_STATUS_OK
;
6840 case NDR_LSA_GETUSERNAME
: {
6841 struct lsa_GetUserName
*r
= (struct lsa_GetUserName
*)_r
;
6842 ZERO_STRUCT(r
->out
);
6843 r
->out
.account_name
= r
->in
.account_name
;
6844 r
->out
.authority_name
= r
->in
.authority_name
;
6845 r
->out
.result
= _lsa_GetUserName(cli
->pipes_struct
, r
);
6846 return NT_STATUS_OK
;
6849 case NDR_LSA_QUERYINFOPOLICY2
: {
6850 struct lsa_QueryInfoPolicy2
*r
= (struct lsa_QueryInfoPolicy2
*)_r
;
6851 ZERO_STRUCT(r
->out
);
6852 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_PolicyInformation
*);
6853 if (r
->out
.info
== NULL
) {
6854 return NT_STATUS_NO_MEMORY
;
6857 r
->out
.result
= _lsa_QueryInfoPolicy2(cli
->pipes_struct
, r
);
6858 return NT_STATUS_OK
;
6861 case NDR_LSA_SETINFOPOLICY2
: {
6862 struct lsa_SetInfoPolicy2
*r
= (struct lsa_SetInfoPolicy2
*)_r
;
6863 r
->out
.result
= _lsa_SetInfoPolicy2(cli
->pipes_struct
, r
);
6864 return NT_STATUS_OK
;
6867 case NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME
: {
6868 struct lsa_QueryTrustedDomainInfoByName
*r
= (struct lsa_QueryTrustedDomainInfoByName
*)_r
;
6869 ZERO_STRUCT(r
->out
);
6870 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_TrustedDomainInfo
*);
6871 if (r
->out
.info
== NULL
) {
6872 return NT_STATUS_NO_MEMORY
;
6875 r
->out
.result
= _lsa_QueryTrustedDomainInfoByName(cli
->pipes_struct
, r
);
6876 return NT_STATUS_OK
;
6879 case NDR_LSA_SETTRUSTEDDOMAININFOBYNAME
: {
6880 struct lsa_SetTrustedDomainInfoByName
*r
= (struct lsa_SetTrustedDomainInfoByName
*)_r
;
6881 r
->out
.result
= _lsa_SetTrustedDomainInfoByName(cli
->pipes_struct
, r
);
6882 return NT_STATUS_OK
;
6885 case NDR_LSA_ENUMTRUSTEDDOMAINSEX
: {
6886 struct lsa_EnumTrustedDomainsEx
*r
= (struct lsa_EnumTrustedDomainsEx
*)_r
;
6887 ZERO_STRUCT(r
->out
);
6888 r
->out
.resume_handle
= r
->in
.resume_handle
;
6889 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_DomainListEx
);
6890 if (r
->out
.domains
== NULL
) {
6891 return NT_STATUS_NO_MEMORY
;
6894 r
->out
.result
= _lsa_EnumTrustedDomainsEx(cli
->pipes_struct
, r
);
6895 return NT_STATUS_OK
;
6898 case NDR_LSA_CREATETRUSTEDDOMAINEX
: {
6899 struct lsa_CreateTrustedDomainEx
*r
= (struct lsa_CreateTrustedDomainEx
*)_r
;
6900 ZERO_STRUCT(r
->out
);
6901 r
->out
.trustdom_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6902 if (r
->out
.trustdom_handle
== NULL
) {
6903 return NT_STATUS_NO_MEMORY
;
6906 r
->out
.result
= _lsa_CreateTrustedDomainEx(cli
->pipes_struct
, r
);
6907 return NT_STATUS_OK
;
6910 case NDR_LSA_CLOSETRUSTEDDOMAINEX
: {
6911 struct lsa_CloseTrustedDomainEx
*r
= (struct lsa_CloseTrustedDomainEx
*)_r
;
6912 ZERO_STRUCT(r
->out
);
6913 r
->out
.handle
= r
->in
.handle
;
6914 r
->out
.result
= _lsa_CloseTrustedDomainEx(cli
->pipes_struct
, r
);
6915 return NT_STATUS_OK
;
6918 case NDR_LSA_QUERYDOMAININFORMATIONPOLICY
: {
6919 struct lsa_QueryDomainInformationPolicy
*r
= (struct lsa_QueryDomainInformationPolicy
*)_r
;
6920 ZERO_STRUCT(r
->out
);
6921 r
->out
.info
= talloc_zero(mem_ctx
, union lsa_DomainInformationPolicy
*);
6922 if (r
->out
.info
== NULL
) {
6923 return NT_STATUS_NO_MEMORY
;
6926 r
->out
.result
= _lsa_QueryDomainInformationPolicy(cli
->pipes_struct
, r
);
6927 return NT_STATUS_OK
;
6930 case NDR_LSA_SETDOMAININFORMATIONPOLICY
: {
6931 struct lsa_SetDomainInformationPolicy
*r
= (struct lsa_SetDomainInformationPolicy
*)_r
;
6932 r
->out
.result
= _lsa_SetDomainInformationPolicy(cli
->pipes_struct
, r
);
6933 return NT_STATUS_OK
;
6936 case NDR_LSA_OPENTRUSTEDDOMAINBYNAME
: {
6937 struct lsa_OpenTrustedDomainByName
*r
= (struct lsa_OpenTrustedDomainByName
*)_r
;
6938 ZERO_STRUCT(r
->out
);
6939 r
->out
.trustdom_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6940 if (r
->out
.trustdom_handle
== NULL
) {
6941 return NT_STATUS_NO_MEMORY
;
6944 r
->out
.result
= _lsa_OpenTrustedDomainByName(cli
->pipes_struct
, r
);
6945 return NT_STATUS_OK
;
6948 case NDR_LSA_TESTCALL
: {
6949 struct lsa_TestCall
*r
= (struct lsa_TestCall
*)_r
;
6950 r
->out
.result
= _lsa_TestCall(cli
->pipes_struct
, r
);
6951 return NT_STATUS_OK
;
6954 case NDR_LSA_LOOKUPSIDS2
: {
6955 struct lsa_LookupSids2
*r
= (struct lsa_LookupSids2
*)_r
;
6956 ZERO_STRUCT(r
->out
);
6957 r
->out
.names
= r
->in
.names
;
6958 r
->out
.count
= r
->in
.count
;
6959 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
6960 if (r
->out
.domains
== NULL
) {
6961 return NT_STATUS_NO_MEMORY
;
6964 r
->out
.result
= _lsa_LookupSids2(cli
->pipes_struct
, r
);
6965 return NT_STATUS_OK
;
6968 case NDR_LSA_LOOKUPNAMES2
: {
6969 struct lsa_LookupNames2
*r
= (struct lsa_LookupNames2
*)_r
;
6970 ZERO_STRUCT(r
->out
);
6971 r
->out
.sids
= r
->in
.sids
;
6972 r
->out
.count
= r
->in
.count
;
6973 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
6974 if (r
->out
.domains
== NULL
) {
6975 return NT_STATUS_NO_MEMORY
;
6978 r
->out
.result
= _lsa_LookupNames2(cli
->pipes_struct
, r
);
6979 return NT_STATUS_OK
;
6982 case NDR_LSA_CREATETRUSTEDDOMAINEX2
: {
6983 struct lsa_CreateTrustedDomainEx2
*r
= (struct lsa_CreateTrustedDomainEx2
*)_r
;
6984 ZERO_STRUCT(r
->out
);
6985 r
->out
.trustdom_handle
= talloc_zero(mem_ctx
, struct policy_handle
);
6986 if (r
->out
.trustdom_handle
== NULL
) {
6987 return NT_STATUS_NO_MEMORY
;
6990 r
->out
.result
= _lsa_CreateTrustedDomainEx2(cli
->pipes_struct
, r
);
6991 return NT_STATUS_OK
;
6994 case NDR_LSA_CREDRWRITE
: {
6995 struct lsa_CREDRWRITE
*r
= (struct lsa_CREDRWRITE
*)_r
;
6996 r
->out
.result
= _lsa_CREDRWRITE(cli
->pipes_struct
, r
);
6997 return NT_STATUS_OK
;
7000 case NDR_LSA_CREDRREAD
: {
7001 struct lsa_CREDRREAD
*r
= (struct lsa_CREDRREAD
*)_r
;
7002 r
->out
.result
= _lsa_CREDRREAD(cli
->pipes_struct
, r
);
7003 return NT_STATUS_OK
;
7006 case NDR_LSA_CREDRENUMERATE
: {
7007 struct lsa_CREDRENUMERATE
*r
= (struct lsa_CREDRENUMERATE
*)_r
;
7008 r
->out
.result
= _lsa_CREDRENUMERATE(cli
->pipes_struct
, r
);
7009 return NT_STATUS_OK
;
7012 case NDR_LSA_CREDRWRITEDOMAINCREDENTIALS
: {
7013 struct lsa_CREDRWRITEDOMAINCREDENTIALS
*r
= (struct lsa_CREDRWRITEDOMAINCREDENTIALS
*)_r
;
7014 r
->out
.result
= _lsa_CREDRWRITEDOMAINCREDENTIALS(cli
->pipes_struct
, r
);
7015 return NT_STATUS_OK
;
7018 case NDR_LSA_CREDRREADDOMAINCREDENTIALS
: {
7019 struct lsa_CREDRREADDOMAINCREDENTIALS
*r
= (struct lsa_CREDRREADDOMAINCREDENTIALS
*)_r
;
7020 r
->out
.result
= _lsa_CREDRREADDOMAINCREDENTIALS(cli
->pipes_struct
, r
);
7021 return NT_STATUS_OK
;
7024 case NDR_LSA_CREDRDELETE
: {
7025 struct lsa_CREDRDELETE
*r
= (struct lsa_CREDRDELETE
*)_r
;
7026 r
->out
.result
= _lsa_CREDRDELETE(cli
->pipes_struct
, r
);
7027 return NT_STATUS_OK
;
7030 case NDR_LSA_CREDRGETTARGETINFO
: {
7031 struct lsa_CREDRGETTARGETINFO
*r
= (struct lsa_CREDRGETTARGETINFO
*)_r
;
7032 r
->out
.result
= _lsa_CREDRGETTARGETINFO(cli
->pipes_struct
, r
);
7033 return NT_STATUS_OK
;
7036 case NDR_LSA_CREDRPROFILELOADED
: {
7037 struct lsa_CREDRPROFILELOADED
*r
= (struct lsa_CREDRPROFILELOADED
*)_r
;
7038 r
->out
.result
= _lsa_CREDRPROFILELOADED(cli
->pipes_struct
, r
);
7039 return NT_STATUS_OK
;
7042 case NDR_LSA_LOOKUPNAMES3
: {
7043 struct lsa_LookupNames3
*r
= (struct lsa_LookupNames3
*)_r
;
7044 ZERO_STRUCT(r
->out
);
7045 r
->out
.sids
= r
->in
.sids
;
7046 r
->out
.count
= r
->in
.count
;
7047 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
7048 if (r
->out
.domains
== NULL
) {
7049 return NT_STATUS_NO_MEMORY
;
7052 r
->out
.result
= _lsa_LookupNames3(cli
->pipes_struct
, r
);
7053 return NT_STATUS_OK
;
7056 case NDR_LSA_CREDRGETSESSIONTYPES
: {
7057 struct lsa_CREDRGETSESSIONTYPES
*r
= (struct lsa_CREDRGETSESSIONTYPES
*)_r
;
7058 r
->out
.result
= _lsa_CREDRGETSESSIONTYPES(cli
->pipes_struct
, r
);
7059 return NT_STATUS_OK
;
7062 case NDR_LSA_LSARREGISTERAUDITEVENT
: {
7063 struct lsa_LSARREGISTERAUDITEVENT
*r
= (struct lsa_LSARREGISTERAUDITEVENT
*)_r
;
7064 r
->out
.result
= _lsa_LSARREGISTERAUDITEVENT(cli
->pipes_struct
, r
);
7065 return NT_STATUS_OK
;
7068 case NDR_LSA_LSARGENAUDITEVENT
: {
7069 struct lsa_LSARGENAUDITEVENT
*r
= (struct lsa_LSARGENAUDITEVENT
*)_r
;
7070 r
->out
.result
= _lsa_LSARGENAUDITEVENT(cli
->pipes_struct
, r
);
7071 return NT_STATUS_OK
;
7074 case NDR_LSA_LSARUNREGISTERAUDITEVENT
: {
7075 struct lsa_LSARUNREGISTERAUDITEVENT
*r
= (struct lsa_LSARUNREGISTERAUDITEVENT
*)_r
;
7076 r
->out
.result
= _lsa_LSARUNREGISTERAUDITEVENT(cli
->pipes_struct
, r
);
7077 return NT_STATUS_OK
;
7080 case NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION
: {
7081 struct lsa_lsaRQueryForestTrustInformation
*r
= (struct lsa_lsaRQueryForestTrustInformation
*)_r
;
7082 ZERO_STRUCT(r
->out
);
7083 r
->out
.forest_trust_info
= talloc_zero(mem_ctx
, struct lsa_ForestTrustInformation
*);
7084 if (r
->out
.forest_trust_info
== NULL
) {
7085 return NT_STATUS_NO_MEMORY
;
7088 r
->out
.result
= _lsa_lsaRQueryForestTrustInformation(cli
->pipes_struct
, r
);
7089 return NT_STATUS_OK
;
7092 case NDR_LSA_LSARSETFORESTTRUSTINFORMATION
: {
7093 struct lsa_lsaRSetForestTrustInformation
*r
= (struct lsa_lsaRSetForestTrustInformation
*)_r
;
7094 ZERO_STRUCT(r
->out
);
7095 r
->out
.collision_info
= talloc_zero(mem_ctx
, struct lsa_ForestTrustCollisionInfo
*);
7096 if (r
->out
.collision_info
== NULL
) {
7097 return NT_STATUS_NO_MEMORY
;
7100 r
->out
.result
= _lsa_lsaRSetForestTrustInformation(cli
->pipes_struct
, r
);
7101 return NT_STATUS_OK
;
7104 case NDR_LSA_CREDRRENAME
: {
7105 struct lsa_CREDRRENAME
*r
= (struct lsa_CREDRRENAME
*)_r
;
7106 r
->out
.result
= _lsa_CREDRRENAME(cli
->pipes_struct
, r
);
7107 return NT_STATUS_OK
;
7110 case NDR_LSA_LOOKUPSIDS3
: {
7111 struct lsa_LookupSids3
*r
= (struct lsa_LookupSids3
*)_r
;
7112 ZERO_STRUCT(r
->out
);
7113 r
->out
.names
= r
->in
.names
;
7114 r
->out
.count
= r
->in
.count
;
7115 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
7116 if (r
->out
.domains
== NULL
) {
7117 return NT_STATUS_NO_MEMORY
;
7120 r
->out
.result
= _lsa_LookupSids3(cli
->pipes_struct
, r
);
7121 return NT_STATUS_OK
;
7124 case NDR_LSA_LOOKUPNAMES4
: {
7125 struct lsa_LookupNames4
*r
= (struct lsa_LookupNames4
*)_r
;
7126 ZERO_STRUCT(r
->out
);
7127 r
->out
.sids
= r
->in
.sids
;
7128 r
->out
.count
= r
->in
.count
;
7129 r
->out
.domains
= talloc_zero(mem_ctx
, struct lsa_RefDomainList
*);
7130 if (r
->out
.domains
== NULL
) {
7131 return NT_STATUS_NO_MEMORY
;
7134 r
->out
.result
= _lsa_LookupNames4(cli
->pipes_struct
, r
);
7135 return NT_STATUS_OK
;
7138 case NDR_LSA_LSAROPENPOLICYSCE
: {
7139 struct lsa_LSAROPENPOLICYSCE
*r
= (struct lsa_LSAROPENPOLICYSCE
*)_r
;
7140 r
->out
.result
= _lsa_LSAROPENPOLICYSCE(cli
->pipes_struct
, r
);
7141 return NT_STATUS_OK
;
7144 case NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE
: {
7145 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE
*r
= (struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE
*)_r
;
7146 r
->out
.result
= _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(cli
->pipes_struct
, r
);
7147 return NT_STATUS_OK
;
7150 case NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE
: {
7151 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
*r
= (struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
*)_r
;
7152 r
->out
.result
= _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(cli
->pipes_struct
, r
);
7153 return NT_STATUS_OK
;
7156 case NDR_LSA_LSARADTREPORTSECURITYEVENT
: {
7157 struct lsa_LSARADTREPORTSECURITYEVENT
*r
= (struct lsa_LSARADTREPORTSECURITYEVENT
*)_r
;
7158 r
->out
.result
= _lsa_LSARADTREPORTSECURITYEVENT(cli
->pipes_struct
, r
);
7159 return NT_STATUS_OK
;
7163 return NT_STATUS_NOT_IMPLEMENTED
;
7167 NTSTATUS
rpc_lsarpc_init(void)
7169 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION
, "lsarpc", "lsarpc", &ndr_table_lsarpc
, api_lsarpc_cmds
, sizeof(api_lsarpc_cmds
) / sizeof(struct api_struct
));