2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/srv_netlogon.h"
9 static bool api_netr_LogonUasLogon(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
;
16 struct netr_LogonUasLogon
*r
;
18 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONUASLOGON
];
20 r
= talloc(talloc_tos(), struct netr_LogonUasLogon
);
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(netr_LogonUasLogon
, r
);
48 r
->out
.info
= talloc_zero(r
, struct netr_UasInfo
*);
49 if (r
->out
.info
== NULL
) {
54 r
->out
.result
= _netr_LogonUasLogon(p
, r
);
56 if (p
->rng_fault_state
) {
58 /* Return true here, srv_pipe_hnd.c will take care */
62 if (DEBUGLEVEL
>= 10) {
63 NDR_PRINT_OUT_DEBUG(netr_LogonUasLogon
, r
);
66 push
= ndr_push_init_ctx(r
, NULL
);
72 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
73 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
78 blob
= ndr_push_blob(push
);
79 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
89 static bool api_netr_LogonUasLogoff(pipes_struct
*p
)
91 const struct ndr_interface_call
*call
;
92 struct ndr_pull
*pull
;
93 struct ndr_push
*push
;
94 enum ndr_err_code ndr_err
;
96 struct netr_LogonUasLogoff
*r
;
98 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONUASLOGOFF
];
100 r
= talloc(talloc_tos(), struct netr_LogonUasLogoff
);
105 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
110 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
116 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
117 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
123 if (DEBUGLEVEL
>= 10) {
124 NDR_PRINT_IN_DEBUG(netr_LogonUasLogoff
, r
);
128 r
->out
.info
= talloc_zero(r
, struct netr_UasLogoffInfo
);
129 if (r
->out
.info
== NULL
) {
134 r
->out
.result
= _netr_LogonUasLogoff(p
, r
);
136 if (p
->rng_fault_state
) {
138 /* Return true here, srv_pipe_hnd.c will take care */
142 if (DEBUGLEVEL
>= 10) {
143 NDR_PRINT_OUT_DEBUG(netr_LogonUasLogoff
, r
);
146 push
= ndr_push_init_ctx(r
, NULL
);
152 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
153 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
158 blob
= ndr_push_blob(push
);
159 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
169 static bool api_netr_LogonSamLogon(pipes_struct
*p
)
171 const struct ndr_interface_call
*call
;
172 struct ndr_pull
*pull
;
173 struct ndr_push
*push
;
174 enum ndr_err_code ndr_err
;
176 struct netr_LogonSamLogon
*r
;
178 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGON
];
180 r
= talloc(talloc_tos(), struct netr_LogonSamLogon
);
185 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
190 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
196 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
197 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
198 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
203 if (DEBUGLEVEL
>= 10) {
204 NDR_PRINT_IN_DEBUG(netr_LogonSamLogon
, r
);
208 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
209 r
->out
.validation
= talloc_zero(r
, union netr_Validation
);
210 if (r
->out
.validation
== NULL
) {
215 r
->out
.authoritative
= talloc_zero(r
, uint8_t);
216 if (r
->out
.authoritative
== NULL
) {
221 r
->out
.result
= _netr_LogonSamLogon(p
, r
);
223 if (p
->rng_fault_state
) {
225 /* Return true here, srv_pipe_hnd.c will take care */
229 if (DEBUGLEVEL
>= 10) {
230 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogon
, r
);
233 push
= ndr_push_init_ctx(r
, NULL
);
239 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
240 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
245 blob
= ndr_push_blob(push
);
246 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
256 static bool api_netr_LogonSamLogoff(pipes_struct
*p
)
258 const struct ndr_interface_call
*call
;
259 struct ndr_pull
*pull
;
260 struct ndr_push
*push
;
261 enum ndr_err_code ndr_err
;
263 struct netr_LogonSamLogoff
*r
;
265 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGOFF
];
267 r
= talloc(talloc_tos(), struct netr_LogonSamLogoff
);
272 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
277 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
283 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
284 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
285 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
290 if (DEBUGLEVEL
>= 10) {
291 NDR_PRINT_IN_DEBUG(netr_LogonSamLogoff
, r
);
295 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
296 r
->out
.result
= _netr_LogonSamLogoff(p
, r
);
298 if (p
->rng_fault_state
) {
300 /* Return true here, srv_pipe_hnd.c will take care */
304 if (DEBUGLEVEL
>= 10) {
305 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogoff
, r
);
308 push
= ndr_push_init_ctx(r
, NULL
);
314 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
320 blob
= ndr_push_blob(push
);
321 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
331 static bool api_netr_ServerReqChallenge(pipes_struct
*p
)
333 const struct ndr_interface_call
*call
;
334 struct ndr_pull
*pull
;
335 struct ndr_push
*push
;
336 enum ndr_err_code ndr_err
;
338 struct netr_ServerReqChallenge
*r
;
340 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERREQCHALLENGE
];
342 r
= talloc(talloc_tos(), struct netr_ServerReqChallenge
);
347 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
352 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
358 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
359 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
360 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
365 if (DEBUGLEVEL
>= 10) {
366 NDR_PRINT_IN_DEBUG(netr_ServerReqChallenge
, r
);
370 r
->out
.return_credentials
= talloc_zero(r
, struct netr_Credential
);
371 if (r
->out
.return_credentials
== NULL
) {
376 r
->out
.result
= _netr_ServerReqChallenge(p
, r
);
378 if (p
->rng_fault_state
) {
380 /* Return true here, srv_pipe_hnd.c will take care */
384 if (DEBUGLEVEL
>= 10) {
385 NDR_PRINT_OUT_DEBUG(netr_ServerReqChallenge
, r
);
388 push
= ndr_push_init_ctx(r
, NULL
);
394 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
395 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
400 blob
= ndr_push_blob(push
);
401 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
411 static bool api_netr_ServerAuthenticate(pipes_struct
*p
)
413 const struct ndr_interface_call
*call
;
414 struct ndr_pull
*pull
;
415 struct ndr_push
*push
;
416 enum ndr_err_code ndr_err
;
418 struct netr_ServerAuthenticate
*r
;
420 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERAUTHENTICATE
];
422 r
= talloc(talloc_tos(), struct netr_ServerAuthenticate
);
427 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
432 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
438 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
439 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
440 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
445 if (DEBUGLEVEL
>= 10) {
446 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate
, r
);
450 r
->out
.return_credentials
= talloc_zero(r
, struct netr_Credential
);
451 if (r
->out
.return_credentials
== NULL
) {
456 r
->out
.result
= _netr_ServerAuthenticate(p
, r
);
458 if (p
->rng_fault_state
) {
460 /* Return true here, srv_pipe_hnd.c will take care */
464 if (DEBUGLEVEL
>= 10) {
465 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate
, r
);
468 push
= ndr_push_init_ctx(r
, NULL
);
474 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
475 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
480 blob
= ndr_push_blob(push
);
481 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
491 static bool api_netr_ServerPasswordSet(pipes_struct
*p
)
493 const struct ndr_interface_call
*call
;
494 struct ndr_pull
*pull
;
495 struct ndr_push
*push
;
496 enum ndr_err_code ndr_err
;
498 struct netr_ServerPasswordSet
*r
;
500 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERPASSWORDSET
];
502 r
= talloc(talloc_tos(), struct netr_ServerPasswordSet
);
507 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
512 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
518 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
519 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
520 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
525 if (DEBUGLEVEL
>= 10) {
526 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet
, r
);
530 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
531 if (r
->out
.return_authenticator
== NULL
) {
536 r
->out
.result
= _netr_ServerPasswordSet(p
, r
);
538 if (p
->rng_fault_state
) {
540 /* Return true here, srv_pipe_hnd.c will take care */
544 if (DEBUGLEVEL
>= 10) {
545 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet
, r
);
548 push
= ndr_push_init_ctx(r
, NULL
);
554 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
555 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
560 blob
= ndr_push_blob(push
);
561 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
571 static bool api_netr_DatabaseDeltas(pipes_struct
*p
)
573 const struct ndr_interface_call
*call
;
574 struct ndr_pull
*pull
;
575 struct ndr_push
*push
;
576 enum ndr_err_code ndr_err
;
578 struct netr_DatabaseDeltas
*r
;
580 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DATABASEDELTAS
];
582 r
= talloc(talloc_tos(), struct netr_DatabaseDeltas
);
587 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
592 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
598 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
599 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
600 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
605 if (DEBUGLEVEL
>= 10) {
606 NDR_PRINT_IN_DEBUG(netr_DatabaseDeltas
, r
);
610 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
611 r
->out
.sequence_num
= r
->in
.sequence_num
;
612 r
->out
.delta_enum_array
= talloc_zero(r
, struct netr_DELTA_ENUM_ARRAY
*);
613 if (r
->out
.delta_enum_array
== NULL
) {
618 r
->out
.result
= _netr_DatabaseDeltas(p
, r
);
620 if (p
->rng_fault_state
) {
622 /* Return true here, srv_pipe_hnd.c will take care */
626 if (DEBUGLEVEL
>= 10) {
627 NDR_PRINT_OUT_DEBUG(netr_DatabaseDeltas
, r
);
630 push
= ndr_push_init_ctx(r
, NULL
);
636 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
637 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
642 blob
= ndr_push_blob(push
);
643 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
653 static bool api_netr_DatabaseSync(pipes_struct
*p
)
655 const struct ndr_interface_call
*call
;
656 struct ndr_pull
*pull
;
657 struct ndr_push
*push
;
658 enum ndr_err_code ndr_err
;
660 struct netr_DatabaseSync
*r
;
662 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DATABASESYNC
];
664 r
= talloc(talloc_tos(), struct netr_DatabaseSync
);
669 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
674 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
680 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
681 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
682 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
687 if (DEBUGLEVEL
>= 10) {
688 NDR_PRINT_IN_DEBUG(netr_DatabaseSync
, r
);
692 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
693 r
->out
.sync_context
= r
->in
.sync_context
;
694 r
->out
.delta_enum_array
= talloc_zero(r
, struct netr_DELTA_ENUM_ARRAY
*);
695 if (r
->out
.delta_enum_array
== NULL
) {
700 r
->out
.result
= _netr_DatabaseSync(p
, r
);
702 if (p
->rng_fault_state
) {
704 /* Return true here, srv_pipe_hnd.c will take care */
708 if (DEBUGLEVEL
>= 10) {
709 NDR_PRINT_OUT_DEBUG(netr_DatabaseSync
, r
);
712 push
= ndr_push_init_ctx(r
, NULL
);
718 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
719 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
724 blob
= ndr_push_blob(push
);
725 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
735 static bool api_netr_AccountDeltas(pipes_struct
*p
)
737 const struct ndr_interface_call
*call
;
738 struct ndr_pull
*pull
;
739 struct ndr_push
*push
;
740 enum ndr_err_code ndr_err
;
742 struct netr_AccountDeltas
*r
;
744 call
= &ndr_table_netlogon
.calls
[NDR_NETR_ACCOUNTDELTAS
];
746 r
= talloc(talloc_tos(), struct netr_AccountDeltas
);
751 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
756 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
762 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
763 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
764 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
769 if (DEBUGLEVEL
>= 10) {
770 NDR_PRINT_IN_DEBUG(netr_AccountDeltas
, r
);
774 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
775 r
->out
.buffer
= talloc_zero(r
, struct netr_AccountBuffer
);
776 if (r
->out
.buffer
== NULL
) {
781 r
->out
.count_returned
= talloc_zero(r
, uint32_t);
782 if (r
->out
.count_returned
== NULL
) {
787 r
->out
.total_entries
= talloc_zero(r
, uint32_t);
788 if (r
->out
.total_entries
== NULL
) {
793 r
->out
.recordid
= talloc_zero(r
, struct netr_UAS_INFO_0
);
794 if (r
->out
.recordid
== NULL
) {
799 r
->out
.result
= _netr_AccountDeltas(p
, r
);
801 if (p
->rng_fault_state
) {
803 /* Return true here, srv_pipe_hnd.c will take care */
807 if (DEBUGLEVEL
>= 10) {
808 NDR_PRINT_OUT_DEBUG(netr_AccountDeltas
, r
);
811 push
= ndr_push_init_ctx(r
, NULL
);
817 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
818 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
823 blob
= ndr_push_blob(push
);
824 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
834 static bool api_netr_AccountSync(pipes_struct
*p
)
836 const struct ndr_interface_call
*call
;
837 struct ndr_pull
*pull
;
838 struct ndr_push
*push
;
839 enum ndr_err_code ndr_err
;
841 struct netr_AccountSync
*r
;
843 call
= &ndr_table_netlogon
.calls
[NDR_NETR_ACCOUNTSYNC
];
845 r
= talloc(talloc_tos(), struct netr_AccountSync
);
850 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
855 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
861 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
862 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
863 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
868 if (DEBUGLEVEL
>= 10) {
869 NDR_PRINT_IN_DEBUG(netr_AccountSync
, r
);
873 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
874 r
->out
.recordid
= r
->in
.recordid
;
875 r
->out
.buffer
= talloc_zero(r
, struct netr_AccountBuffer
);
876 if (r
->out
.buffer
== NULL
) {
881 r
->out
.count_returned
= talloc_zero(r
, uint32_t);
882 if (r
->out
.count_returned
== NULL
) {
887 r
->out
.total_entries
= talloc_zero(r
, uint32_t);
888 if (r
->out
.total_entries
== NULL
) {
893 r
->out
.next_reference
= talloc_zero(r
, uint32_t);
894 if (r
->out
.next_reference
== NULL
) {
899 r
->out
.result
= _netr_AccountSync(p
, r
);
901 if (p
->rng_fault_state
) {
903 /* Return true here, srv_pipe_hnd.c will take care */
907 if (DEBUGLEVEL
>= 10) {
908 NDR_PRINT_OUT_DEBUG(netr_AccountSync
, r
);
911 push
= ndr_push_init_ctx(r
, NULL
);
917 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
918 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
923 blob
= ndr_push_blob(push
);
924 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
934 static bool api_netr_GetDcName(pipes_struct
*p
)
936 const struct ndr_interface_call
*call
;
937 struct ndr_pull
*pull
;
938 struct ndr_push
*push
;
939 enum ndr_err_code ndr_err
;
941 struct netr_GetDcName
*r
;
943 call
= &ndr_table_netlogon
.calls
[NDR_NETR_GETDCNAME
];
945 r
= talloc(talloc_tos(), struct netr_GetDcName
);
950 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
955 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
961 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
962 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
963 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
968 if (DEBUGLEVEL
>= 10) {
969 NDR_PRINT_IN_DEBUG(netr_GetDcName
, r
);
973 r
->out
.dcname
= talloc_zero(r
, const char *);
974 if (r
->out
.dcname
== NULL
) {
979 r
->out
.result
= _netr_GetDcName(p
, r
);
981 if (p
->rng_fault_state
) {
983 /* Return true here, srv_pipe_hnd.c will take care */
987 if (DEBUGLEVEL
>= 10) {
988 NDR_PRINT_OUT_DEBUG(netr_GetDcName
, r
);
991 push
= ndr_push_init_ctx(r
, NULL
);
997 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
998 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1003 blob
= ndr_push_blob(push
);
1004 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1014 static bool api_netr_LogonControl(pipes_struct
*p
)
1016 const struct ndr_interface_call
*call
;
1017 struct ndr_pull
*pull
;
1018 struct ndr_push
*push
;
1019 enum ndr_err_code ndr_err
;
1021 struct netr_LogonControl
*r
;
1023 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONCONTROL
];
1025 r
= talloc(talloc_tos(), struct netr_LogonControl
);
1030 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1035 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1041 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1042 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1043 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1048 if (DEBUGLEVEL
>= 10) {
1049 NDR_PRINT_IN_DEBUG(netr_LogonControl
, r
);
1052 ZERO_STRUCT(r
->out
);
1053 r
->out
.info
= talloc_zero(r
, union netr_CONTROL_QUERY_INFORMATION
);
1054 if (r
->out
.info
== NULL
) {
1059 r
->out
.result
= _netr_LogonControl(p
, r
);
1061 if (p
->rng_fault_state
) {
1063 /* Return true here, srv_pipe_hnd.c will take care */
1067 if (DEBUGLEVEL
>= 10) {
1068 NDR_PRINT_OUT_DEBUG(netr_LogonControl
, r
);
1071 push
= ndr_push_init_ctx(r
, NULL
);
1077 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1078 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1083 blob
= ndr_push_blob(push
);
1084 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1094 static bool api_netr_GetAnyDCName(pipes_struct
*p
)
1096 const struct ndr_interface_call
*call
;
1097 struct ndr_pull
*pull
;
1098 struct ndr_push
*push
;
1099 enum ndr_err_code ndr_err
;
1101 struct netr_GetAnyDCName
*r
;
1103 call
= &ndr_table_netlogon
.calls
[NDR_NETR_GETANYDCNAME
];
1105 r
= talloc(talloc_tos(), struct netr_GetAnyDCName
);
1110 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1115 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1121 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1122 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1123 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1128 if (DEBUGLEVEL
>= 10) {
1129 NDR_PRINT_IN_DEBUG(netr_GetAnyDCName
, r
);
1132 ZERO_STRUCT(r
->out
);
1133 r
->out
.dcname
= talloc_zero(r
, const char *);
1134 if (r
->out
.dcname
== NULL
) {
1139 r
->out
.result
= _netr_GetAnyDCName(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(netr_GetAnyDCName
, 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_netr_LogonControl2(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 netr_LogonControl2
*r
;
1183 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONCONTROL2
];
1185 r
= talloc(talloc_tos(), struct netr_LogonControl2
);
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(netr_LogonControl2
, r
);
1212 ZERO_STRUCT(r
->out
);
1213 r
->out
.query
= talloc_zero(r
, union netr_CONTROL_QUERY_INFORMATION
);
1214 if (r
->out
.query
== NULL
) {
1219 r
->out
.result
= _netr_LogonControl2(p
, r
);
1221 if (p
->rng_fault_state
) {
1223 /* Return true here, srv_pipe_hnd.c will take care */
1227 if (DEBUGLEVEL
>= 10) {
1228 NDR_PRINT_OUT_DEBUG(netr_LogonControl2
, r
);
1231 push
= ndr_push_init_ctx(r
, NULL
);
1237 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1243 blob
= ndr_push_blob(push
);
1244 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1254 static bool api_netr_ServerAuthenticate2(pipes_struct
*p
)
1256 const struct ndr_interface_call
*call
;
1257 struct ndr_pull
*pull
;
1258 struct ndr_push
*push
;
1259 enum ndr_err_code ndr_err
;
1261 struct netr_ServerAuthenticate2
*r
;
1263 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERAUTHENTICATE2
];
1265 r
= talloc(talloc_tos(), struct netr_ServerAuthenticate2
);
1270 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1275 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1281 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1282 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1283 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1288 if (DEBUGLEVEL
>= 10) {
1289 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate2
, r
);
1292 ZERO_STRUCT(r
->out
);
1293 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
1294 r
->out
.return_credentials
= talloc_zero(r
, struct netr_Credential
);
1295 if (r
->out
.return_credentials
== NULL
) {
1300 r
->out
.result
= _netr_ServerAuthenticate2(p
, r
);
1302 if (p
->rng_fault_state
) {
1304 /* Return true here, srv_pipe_hnd.c will take care */
1308 if (DEBUGLEVEL
>= 10) {
1309 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate2
, r
);
1312 push
= ndr_push_init_ctx(r
, NULL
);
1318 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1324 blob
= ndr_push_blob(push
);
1325 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1335 static bool api_netr_DatabaseSync2(pipes_struct
*p
)
1337 const struct ndr_interface_call
*call
;
1338 struct ndr_pull
*pull
;
1339 struct ndr_push
*push
;
1340 enum ndr_err_code ndr_err
;
1342 struct netr_DatabaseSync2
*r
;
1344 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DATABASESYNC2
];
1346 r
= talloc(talloc_tos(), struct netr_DatabaseSync2
);
1351 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1356 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1362 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1363 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1364 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1369 if (DEBUGLEVEL
>= 10) {
1370 NDR_PRINT_IN_DEBUG(netr_DatabaseSync2
, r
);
1373 ZERO_STRUCT(r
->out
);
1374 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
1375 r
->out
.sync_context
= r
->in
.sync_context
;
1376 r
->out
.delta_enum_array
= talloc_zero(r
, struct netr_DELTA_ENUM_ARRAY
*);
1377 if (r
->out
.delta_enum_array
== NULL
) {
1382 r
->out
.result
= _netr_DatabaseSync2(p
, r
);
1384 if (p
->rng_fault_state
) {
1386 /* Return true here, srv_pipe_hnd.c will take care */
1390 if (DEBUGLEVEL
>= 10) {
1391 NDR_PRINT_OUT_DEBUG(netr_DatabaseSync2
, r
);
1394 push
= ndr_push_init_ctx(r
, NULL
);
1400 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1401 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1406 blob
= ndr_push_blob(push
);
1407 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1417 static bool api_netr_DatabaseRedo(pipes_struct
*p
)
1419 const struct ndr_interface_call
*call
;
1420 struct ndr_pull
*pull
;
1421 struct ndr_push
*push
;
1422 enum ndr_err_code ndr_err
;
1424 struct netr_DatabaseRedo
*r
;
1426 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DATABASEREDO
];
1428 r
= talloc(talloc_tos(), struct netr_DatabaseRedo
);
1433 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1438 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1444 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1445 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1446 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1451 if (DEBUGLEVEL
>= 10) {
1452 NDR_PRINT_IN_DEBUG(netr_DatabaseRedo
, r
);
1455 ZERO_STRUCT(r
->out
);
1456 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
1457 r
->out
.delta_enum_array
= talloc_zero(r
, struct netr_DELTA_ENUM_ARRAY
*);
1458 if (r
->out
.delta_enum_array
== NULL
) {
1463 r
->out
.result
= _netr_DatabaseRedo(p
, r
);
1465 if (p
->rng_fault_state
) {
1467 /* Return true here, srv_pipe_hnd.c will take care */
1471 if (DEBUGLEVEL
>= 10) {
1472 NDR_PRINT_OUT_DEBUG(netr_DatabaseRedo
, r
);
1475 push
= ndr_push_init_ctx(r
, NULL
);
1481 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1482 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1487 blob
= ndr_push_blob(push
);
1488 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1498 static bool api_netr_LogonControl2Ex(pipes_struct
*p
)
1500 const struct ndr_interface_call
*call
;
1501 struct ndr_pull
*pull
;
1502 struct ndr_push
*push
;
1503 enum ndr_err_code ndr_err
;
1505 struct netr_LogonControl2Ex
*r
;
1507 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONCONTROL2EX
];
1509 r
= talloc(talloc_tos(), struct netr_LogonControl2Ex
);
1514 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1519 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1525 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1526 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1527 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1532 if (DEBUGLEVEL
>= 10) {
1533 NDR_PRINT_IN_DEBUG(netr_LogonControl2Ex
, r
);
1536 ZERO_STRUCT(r
->out
);
1537 r
->out
.query
= talloc_zero(r
, union netr_CONTROL_QUERY_INFORMATION
);
1538 if (r
->out
.query
== NULL
) {
1543 r
->out
.result
= _netr_LogonControl2Ex(p
, r
);
1545 if (p
->rng_fault_state
) {
1547 /* Return true here, srv_pipe_hnd.c will take care */
1551 if (DEBUGLEVEL
>= 10) {
1552 NDR_PRINT_OUT_DEBUG(netr_LogonControl2Ex
, r
);
1555 push
= ndr_push_init_ctx(r
, NULL
);
1561 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1562 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1567 blob
= ndr_push_blob(push
);
1568 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1578 static bool api_netr_NetrEnumerateTrustedDomains(pipes_struct
*p
)
1580 const struct ndr_interface_call
*call
;
1581 struct ndr_pull
*pull
;
1582 struct ndr_push
*push
;
1583 enum ndr_err_code ndr_err
;
1585 struct netr_NetrEnumerateTrustedDomains
*r
;
1587 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
];
1589 r
= talloc(talloc_tos(), struct netr_NetrEnumerateTrustedDomains
);
1594 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1599 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1605 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1606 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1607 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1612 if (DEBUGLEVEL
>= 10) {
1613 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomains
, r
);
1616 ZERO_STRUCT(r
->out
);
1617 r
->out
.trusted_domains_blob
= talloc_zero(r
, struct netr_Blob
);
1618 if (r
->out
.trusted_domains_blob
== NULL
) {
1623 r
->out
.result
= _netr_NetrEnumerateTrustedDomains(p
, r
);
1625 if (p
->rng_fault_state
) {
1627 /* Return true here, srv_pipe_hnd.c will take care */
1631 if (DEBUGLEVEL
>= 10) {
1632 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomains
, r
);
1635 push
= ndr_push_init_ctx(r
, NULL
);
1641 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1642 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1647 blob
= ndr_push_blob(push
);
1648 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1658 static bool api_netr_DsRGetDCName(pipes_struct
*p
)
1660 const struct ndr_interface_call
*call
;
1661 struct ndr_pull
*pull
;
1662 struct ndr_push
*push
;
1663 enum ndr_err_code ndr_err
;
1665 struct netr_DsRGetDCName
*r
;
1667 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCNAME
];
1669 r
= talloc(talloc_tos(), struct netr_DsRGetDCName
);
1674 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1679 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1685 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1686 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1687 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1692 if (DEBUGLEVEL
>= 10) {
1693 NDR_PRINT_IN_DEBUG(netr_DsRGetDCName
, r
);
1696 ZERO_STRUCT(r
->out
);
1697 r
->out
.info
= talloc_zero(r
, struct netr_DsRGetDCNameInfo
*);
1698 if (r
->out
.info
== NULL
) {
1703 r
->out
.result
= _netr_DsRGetDCName(p
, r
);
1705 if (p
->rng_fault_state
) {
1707 /* Return true here, srv_pipe_hnd.c will take care */
1711 if (DEBUGLEVEL
>= 10) {
1712 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCName
, r
);
1715 push
= ndr_push_init_ctx(r
, NULL
);
1721 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1722 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1727 blob
= ndr_push_blob(push
);
1728 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1738 static bool api_netr_NETRLOGONDUMMYROUTINE1(pipes_struct
*p
)
1740 const struct ndr_interface_call
*call
;
1741 struct ndr_pull
*pull
;
1742 struct ndr_push
*push
;
1743 enum ndr_err_code ndr_err
;
1745 struct netr_NETRLOGONDUMMYROUTINE1
*r
;
1747 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONDUMMYROUTINE1
];
1749 r
= talloc(talloc_tos(), struct netr_NETRLOGONDUMMYROUTINE1
);
1754 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1759 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1765 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1766 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1767 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1772 if (DEBUGLEVEL
>= 10) {
1773 NDR_PRINT_IN_DEBUG(netr_NETRLOGONDUMMYROUTINE1
, r
);
1776 r
->out
.result
= _netr_NETRLOGONDUMMYROUTINE1(p
, r
);
1778 if (p
->rng_fault_state
) {
1780 /* Return true here, srv_pipe_hnd.c will take care */
1784 if (DEBUGLEVEL
>= 10) {
1785 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONDUMMYROUTINE1
, r
);
1788 push
= ndr_push_init_ctx(r
, NULL
);
1794 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1795 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1800 blob
= ndr_push_blob(push
);
1801 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1811 static bool api_netr_NETRLOGONSETSERVICEBITS(pipes_struct
*p
)
1813 const struct ndr_interface_call
*call
;
1814 struct ndr_pull
*pull
;
1815 struct ndr_push
*push
;
1816 enum ndr_err_code ndr_err
;
1818 struct netr_NETRLOGONSETSERVICEBITS
*r
;
1820 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONSETSERVICEBITS
];
1822 r
= talloc(talloc_tos(), struct netr_NETRLOGONSETSERVICEBITS
);
1827 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1832 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1838 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1839 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1840 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1845 if (DEBUGLEVEL
>= 10) {
1846 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSETSERVICEBITS
, r
);
1849 r
->out
.result
= _netr_NETRLOGONSETSERVICEBITS(p
, r
);
1851 if (p
->rng_fault_state
) {
1853 /* Return true here, srv_pipe_hnd.c will take care */
1857 if (DEBUGLEVEL
>= 10) {
1858 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSETSERVICEBITS
, r
);
1861 push
= ndr_push_init_ctx(r
, NULL
);
1867 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1868 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1873 blob
= ndr_push_blob(push
);
1874 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1884 static bool api_netr_LogonGetTrustRid(pipes_struct
*p
)
1886 const struct ndr_interface_call
*call
;
1887 struct ndr_pull
*pull
;
1888 struct ndr_push
*push
;
1889 enum ndr_err_code ndr_err
;
1891 struct netr_LogonGetTrustRid
*r
;
1893 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONGETTRUSTRID
];
1895 r
= talloc(talloc_tos(), struct netr_LogonGetTrustRid
);
1900 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1905 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1911 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1912 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1913 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1918 if (DEBUGLEVEL
>= 10) {
1919 NDR_PRINT_IN_DEBUG(netr_LogonGetTrustRid
, r
);
1922 ZERO_STRUCT(r
->out
);
1923 r
->out
.rid
= talloc_zero(r
, uint32_t);
1924 if (r
->out
.rid
== NULL
) {
1929 r
->out
.result
= _netr_LogonGetTrustRid(p
, r
);
1931 if (p
->rng_fault_state
) {
1933 /* Return true here, srv_pipe_hnd.c will take care */
1937 if (DEBUGLEVEL
>= 10) {
1938 NDR_PRINT_OUT_DEBUG(netr_LogonGetTrustRid
, r
);
1941 push
= ndr_push_init_ctx(r
, NULL
);
1947 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1948 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1953 blob
= ndr_push_blob(push
);
1954 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1964 static bool api_netr_NETRLOGONCOMPUTESERVERDIGEST(pipes_struct
*p
)
1966 const struct ndr_interface_call
*call
;
1967 struct ndr_pull
*pull
;
1968 struct ndr_push
*push
;
1969 enum ndr_err_code ndr_err
;
1971 struct netr_NETRLOGONCOMPUTESERVERDIGEST
*r
;
1973 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
];
1975 r
= talloc(talloc_tos(), struct netr_NETRLOGONCOMPUTESERVERDIGEST
);
1980 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1985 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
1991 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1992 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1993 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1998 if (DEBUGLEVEL
>= 10) {
1999 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST
, r
);
2002 r
->out
.result
= _netr_NETRLOGONCOMPUTESERVERDIGEST(p
, r
);
2004 if (p
->rng_fault_state
) {
2006 /* Return true here, srv_pipe_hnd.c will take care */
2010 if (DEBUGLEVEL
>= 10) {
2011 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST
, r
);
2014 push
= ndr_push_init_ctx(r
, NULL
);
2020 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2021 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2026 blob
= ndr_push_blob(push
);
2027 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2037 static bool api_netr_NETRLOGONCOMPUTECLIENTDIGEST(pipes_struct
*p
)
2039 const struct ndr_interface_call
*call
;
2040 struct ndr_pull
*pull
;
2041 struct ndr_push
*push
;
2042 enum ndr_err_code ndr_err
;
2044 struct netr_NETRLOGONCOMPUTECLIENTDIGEST
*r
;
2046 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
];
2048 r
= talloc(talloc_tos(), struct netr_NETRLOGONCOMPUTECLIENTDIGEST
);
2053 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2058 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2064 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2065 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2066 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2071 if (DEBUGLEVEL
>= 10) {
2072 NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST
, r
);
2075 r
->out
.result
= _netr_NETRLOGONCOMPUTECLIENTDIGEST(p
, r
);
2077 if (p
->rng_fault_state
) {
2079 /* Return true here, srv_pipe_hnd.c will take care */
2083 if (DEBUGLEVEL
>= 10) {
2084 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST
, r
);
2087 push
= ndr_push_init_ctx(r
, NULL
);
2093 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2094 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2099 blob
= ndr_push_blob(push
);
2100 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2110 static bool api_netr_ServerAuthenticate3(pipes_struct
*p
)
2112 const struct ndr_interface_call
*call
;
2113 struct ndr_pull
*pull
;
2114 struct ndr_push
*push
;
2115 enum ndr_err_code ndr_err
;
2117 struct netr_ServerAuthenticate3
*r
;
2119 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERAUTHENTICATE3
];
2121 r
= talloc(talloc_tos(), struct netr_ServerAuthenticate3
);
2126 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2131 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2137 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2138 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2144 if (DEBUGLEVEL
>= 10) {
2145 NDR_PRINT_IN_DEBUG(netr_ServerAuthenticate3
, r
);
2148 ZERO_STRUCT(r
->out
);
2149 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
2150 r
->out
.return_credentials
= talloc_zero(r
, struct netr_Credential
);
2151 if (r
->out
.return_credentials
== NULL
) {
2156 r
->out
.rid
= talloc_zero(r
, uint32_t);
2157 if (r
->out
.rid
== NULL
) {
2162 r
->out
.result
= _netr_ServerAuthenticate3(p
, r
);
2164 if (p
->rng_fault_state
) {
2166 /* Return true here, srv_pipe_hnd.c will take care */
2170 if (DEBUGLEVEL
>= 10) {
2171 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3
, r
);
2174 push
= ndr_push_init_ctx(r
, NULL
);
2180 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2181 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2186 blob
= ndr_push_blob(push
);
2187 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2197 static bool api_netr_DsRGetDCNameEx(pipes_struct
*p
)
2199 const struct ndr_interface_call
*call
;
2200 struct ndr_pull
*pull
;
2201 struct ndr_push
*push
;
2202 enum ndr_err_code ndr_err
;
2204 struct netr_DsRGetDCNameEx
*r
;
2206 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCNAMEEX
];
2208 r
= talloc(talloc_tos(), struct netr_DsRGetDCNameEx
);
2213 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2218 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2224 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2225 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2226 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2231 if (DEBUGLEVEL
>= 10) {
2232 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx
, r
);
2235 ZERO_STRUCT(r
->out
);
2236 r
->out
.info
= talloc_zero(r
, struct netr_DsRGetDCNameInfo
*);
2237 if (r
->out
.info
== NULL
) {
2242 r
->out
.result
= _netr_DsRGetDCNameEx(p
, r
);
2244 if (p
->rng_fault_state
) {
2246 /* Return true here, srv_pipe_hnd.c will take care */
2250 if (DEBUGLEVEL
>= 10) {
2251 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx
, r
);
2254 push
= ndr_push_init_ctx(r
, NULL
);
2260 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2261 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2266 blob
= ndr_push_blob(push
);
2267 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2277 static bool api_netr_DsRGetSiteName(pipes_struct
*p
)
2279 const struct ndr_interface_call
*call
;
2280 struct ndr_pull
*pull
;
2281 struct ndr_push
*push
;
2282 enum ndr_err_code ndr_err
;
2284 struct netr_DsRGetSiteName
*r
;
2286 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETSITENAME
];
2288 r
= talloc(talloc_tos(), struct netr_DsRGetSiteName
);
2293 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2298 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2304 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2305 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2306 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2311 if (DEBUGLEVEL
>= 10) {
2312 NDR_PRINT_IN_DEBUG(netr_DsRGetSiteName
, r
);
2315 ZERO_STRUCT(r
->out
);
2316 r
->out
.site
= talloc_zero(r
, const char *);
2317 if (r
->out
.site
== NULL
) {
2322 r
->out
.result
= _netr_DsRGetSiteName(p
, r
);
2324 if (p
->rng_fault_state
) {
2326 /* Return true here, srv_pipe_hnd.c will take care */
2330 if (DEBUGLEVEL
>= 10) {
2331 NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName
, r
);
2334 push
= ndr_push_init_ctx(r
, NULL
);
2340 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2341 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2346 blob
= ndr_push_blob(push
);
2347 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2357 static bool api_netr_LogonGetDomainInfo(pipes_struct
*p
)
2359 const struct ndr_interface_call
*call
;
2360 struct ndr_pull
*pull
;
2361 struct ndr_push
*push
;
2362 enum ndr_err_code ndr_err
;
2364 struct netr_LogonGetDomainInfo
*r
;
2366 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONGETDOMAININFO
];
2368 r
= talloc(talloc_tos(), struct netr_LogonGetDomainInfo
);
2373 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2378 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2384 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2385 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2386 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2391 if (DEBUGLEVEL
>= 10) {
2392 NDR_PRINT_IN_DEBUG(netr_LogonGetDomainInfo
, r
);
2395 ZERO_STRUCT(r
->out
);
2396 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
2397 r
->out
.info
= talloc_zero(r
, union netr_DomainInfo
);
2398 if (r
->out
.info
== NULL
) {
2403 r
->out
.result
= _netr_LogonGetDomainInfo(p
, r
);
2405 if (p
->rng_fault_state
) {
2407 /* Return true here, srv_pipe_hnd.c will take care */
2411 if (DEBUGLEVEL
>= 10) {
2412 NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo
, r
);
2415 push
= ndr_push_init_ctx(r
, NULL
);
2421 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2422 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2427 blob
= ndr_push_blob(push
);
2428 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2438 static bool api_netr_ServerPasswordSet2(pipes_struct
*p
)
2440 const struct ndr_interface_call
*call
;
2441 struct ndr_pull
*pull
;
2442 struct ndr_push
*push
;
2443 enum ndr_err_code ndr_err
;
2445 struct netr_ServerPasswordSet2
*r
;
2447 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERPASSWORDSET2
];
2449 r
= talloc(talloc_tos(), struct netr_ServerPasswordSet2
);
2454 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2459 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2465 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2466 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2472 if (DEBUGLEVEL
>= 10) {
2473 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet2
, r
);
2476 ZERO_STRUCT(r
->out
);
2477 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
2478 if (r
->out
.return_authenticator
== NULL
) {
2483 r
->out
.result
= _netr_ServerPasswordSet2(p
, r
);
2485 if (p
->rng_fault_state
) {
2487 /* Return true here, srv_pipe_hnd.c will take care */
2491 if (DEBUGLEVEL
>= 10) {
2492 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2
, r
);
2495 push
= ndr_push_init_ctx(r
, NULL
);
2501 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2502 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2507 blob
= ndr_push_blob(push
);
2508 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2518 static bool api_netr_ServerPasswordGet(pipes_struct
*p
)
2520 const struct ndr_interface_call
*call
;
2521 struct ndr_pull
*pull
;
2522 struct ndr_push
*push
;
2523 enum ndr_err_code ndr_err
;
2525 struct netr_ServerPasswordGet
*r
;
2527 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERPASSWORDGET
];
2529 r
= talloc(talloc_tos(), struct netr_ServerPasswordGet
);
2534 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2539 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2545 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2546 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2547 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2552 if (DEBUGLEVEL
>= 10) {
2553 NDR_PRINT_IN_DEBUG(netr_ServerPasswordGet
, r
);
2556 ZERO_STRUCT(r
->out
);
2557 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
2558 if (r
->out
.return_authenticator
== NULL
) {
2563 r
->out
.password
= talloc_zero(r
, struct samr_Password
);
2564 if (r
->out
.password
== NULL
) {
2569 r
->out
.result
= _netr_ServerPasswordGet(p
, r
);
2571 if (p
->rng_fault_state
) {
2573 /* Return true here, srv_pipe_hnd.c will take care */
2577 if (DEBUGLEVEL
>= 10) {
2578 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordGet
, r
);
2581 push
= ndr_push_init_ctx(r
, NULL
);
2587 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2588 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2593 blob
= ndr_push_blob(push
);
2594 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2604 static bool api_netr_NETRLOGONSENDTOSAM(pipes_struct
*p
)
2606 const struct ndr_interface_call
*call
;
2607 struct ndr_pull
*pull
;
2608 struct ndr_push
*push
;
2609 enum ndr_err_code ndr_err
;
2611 struct netr_NETRLOGONSENDTOSAM
*r
;
2613 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONSENDTOSAM
];
2615 r
= talloc(talloc_tos(), struct netr_NETRLOGONSENDTOSAM
);
2620 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2625 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2631 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2632 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2633 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2638 if (DEBUGLEVEL
>= 10) {
2639 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM
, r
);
2642 r
->out
.result
= _netr_NETRLOGONSENDTOSAM(p
, r
);
2644 if (p
->rng_fault_state
) {
2646 /* Return true here, srv_pipe_hnd.c will take care */
2650 if (DEBUGLEVEL
>= 10) {
2651 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM
, r
);
2654 push
= ndr_push_init_ctx(r
, NULL
);
2660 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2661 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2666 blob
= ndr_push_blob(push
);
2667 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2677 static bool api_netr_DsRAddressToSitenamesW(pipes_struct
*p
)
2679 const struct ndr_interface_call
*call
;
2680 struct ndr_pull
*pull
;
2681 struct ndr_push
*push
;
2682 enum ndr_err_code ndr_err
;
2684 struct netr_DsRAddressToSitenamesW
*r
;
2686 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRADDRESSTOSITENAMESW
];
2688 r
= talloc(talloc_tos(), struct netr_DsRAddressToSitenamesW
);
2693 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2698 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2704 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2705 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2706 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2711 if (DEBUGLEVEL
>= 10) {
2712 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesW
, r
);
2715 ZERO_STRUCT(r
->out
);
2716 r
->out
.ctr
= talloc_zero(r
, struct netr_DsRAddressToSitenamesWCtr
*);
2717 if (r
->out
.ctr
== NULL
) {
2722 r
->out
.result
= _netr_DsRAddressToSitenamesW(p
, r
);
2724 if (p
->rng_fault_state
) {
2726 /* Return true here, srv_pipe_hnd.c will take care */
2730 if (DEBUGLEVEL
>= 10) {
2731 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesW
, r
);
2734 push
= ndr_push_init_ctx(r
, NULL
);
2740 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2741 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2746 blob
= ndr_push_blob(push
);
2747 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2757 static bool api_netr_DsRGetDCNameEx2(pipes_struct
*p
)
2759 const struct ndr_interface_call
*call
;
2760 struct ndr_pull
*pull
;
2761 struct ndr_push
*push
;
2762 enum ndr_err_code ndr_err
;
2764 struct netr_DsRGetDCNameEx2
*r
;
2766 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCNAMEEX2
];
2768 r
= talloc(talloc_tos(), struct netr_DsRGetDCNameEx2
);
2773 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2778 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2784 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2785 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2786 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2791 if (DEBUGLEVEL
>= 10) {
2792 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx2
, r
);
2795 ZERO_STRUCT(r
->out
);
2796 r
->out
.info
= talloc_zero(r
, struct netr_DsRGetDCNameInfo
*);
2797 if (r
->out
.info
== NULL
) {
2802 r
->out
.result
= _netr_DsRGetDCNameEx2(p
, r
);
2804 if (p
->rng_fault_state
) {
2806 /* Return true here, srv_pipe_hnd.c will take care */
2810 if (DEBUGLEVEL
>= 10) {
2811 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2
, r
);
2814 push
= ndr_push_init_ctx(r
, NULL
);
2820 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2821 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2826 blob
= ndr_push_blob(push
);
2827 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2837 static bool api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(pipes_struct
*p
)
2839 const struct ndr_interface_call
*call
;
2840 struct ndr_pull
*pull
;
2841 struct ndr_push
*push
;
2842 enum ndr_err_code ndr_err
;
2844 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
*r
;
2846 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
];
2848 r
= talloc(talloc_tos(), struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
);
2853 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2858 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2864 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2865 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2866 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2871 if (DEBUGLEVEL
>= 10) {
2872 NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, r
);
2875 r
->out
.result
= _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(p
, r
);
2877 if (p
->rng_fault_state
) {
2879 /* Return true here, srv_pipe_hnd.c will take care */
2883 if (DEBUGLEVEL
>= 10) {
2884 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, r
);
2887 push
= ndr_push_init_ctx(r
, NULL
);
2893 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2894 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2899 blob
= ndr_push_blob(push
);
2900 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2910 static bool api_netr_NetrEnumerateTrustedDomainsEx(pipes_struct
*p
)
2912 const struct ndr_interface_call
*call
;
2913 struct ndr_pull
*pull
;
2914 struct ndr_push
*push
;
2915 enum ndr_err_code ndr_err
;
2917 struct netr_NetrEnumerateTrustedDomainsEx
*r
;
2919 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
];
2921 r
= talloc(talloc_tos(), struct netr_NetrEnumerateTrustedDomainsEx
);
2926 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2931 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
2937 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2938 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2939 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2944 if (DEBUGLEVEL
>= 10) {
2945 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomainsEx
, r
);
2948 ZERO_STRUCT(r
->out
);
2949 r
->out
.dom_trust_list
= talloc_zero(r
, struct netr_DomainTrustList
);
2950 if (r
->out
.dom_trust_list
== NULL
) {
2955 r
->out
.result
= _netr_NetrEnumerateTrustedDomainsEx(p
, r
);
2957 if (p
->rng_fault_state
) {
2959 /* Return true here, srv_pipe_hnd.c will take care */
2963 if (DEBUGLEVEL
>= 10) {
2964 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomainsEx
, r
);
2967 push
= ndr_push_init_ctx(r
, NULL
);
2973 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2974 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2979 blob
= ndr_push_blob(push
);
2980 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2990 static bool api_netr_DsRAddressToSitenamesExW(pipes_struct
*p
)
2992 const struct ndr_interface_call
*call
;
2993 struct ndr_pull
*pull
;
2994 struct ndr_push
*push
;
2995 enum ndr_err_code ndr_err
;
2997 struct netr_DsRAddressToSitenamesExW
*r
;
2999 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRADDRESSTOSITENAMESEXW
];
3001 r
= talloc(talloc_tos(), struct netr_DsRAddressToSitenamesExW
);
3006 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3011 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3017 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3018 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3019 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3024 if (DEBUGLEVEL
>= 10) {
3025 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesExW
, r
);
3028 ZERO_STRUCT(r
->out
);
3029 r
->out
.ctr
= talloc_zero(r
, struct netr_DsRAddressToSitenamesExWCtr
*);
3030 if (r
->out
.ctr
== NULL
) {
3035 r
->out
.result
= _netr_DsRAddressToSitenamesExW(p
, r
);
3037 if (p
->rng_fault_state
) {
3039 /* Return true here, srv_pipe_hnd.c will take care */
3043 if (DEBUGLEVEL
>= 10) {
3044 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesExW
, r
);
3047 push
= ndr_push_init_ctx(r
, NULL
);
3053 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3054 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3059 blob
= ndr_push_blob(push
);
3060 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3070 static bool api_netr_DsrGetDcSiteCoverageW(pipes_struct
*p
)
3072 const struct ndr_interface_call
*call
;
3073 struct ndr_pull
*pull
;
3074 struct ndr_push
*push
;
3075 enum ndr_err_code ndr_err
;
3077 struct netr_DsrGetDcSiteCoverageW
*r
;
3079 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCSITECOVERAGEW
];
3081 r
= talloc(talloc_tos(), struct netr_DsrGetDcSiteCoverageW
);
3086 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3091 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3097 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3098 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3099 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3104 if (DEBUGLEVEL
>= 10) {
3105 NDR_PRINT_IN_DEBUG(netr_DsrGetDcSiteCoverageW
, r
);
3108 ZERO_STRUCT(r
->out
);
3109 r
->out
.ctr
= talloc_zero(r
, struct DcSitesCtr
*);
3110 if (r
->out
.ctr
== NULL
) {
3115 r
->out
.result
= _netr_DsrGetDcSiteCoverageW(p
, r
);
3117 if (p
->rng_fault_state
) {
3119 /* Return true here, srv_pipe_hnd.c will take care */
3123 if (DEBUGLEVEL
>= 10) {
3124 NDR_PRINT_OUT_DEBUG(netr_DsrGetDcSiteCoverageW
, r
);
3127 push
= ndr_push_init_ctx(r
, NULL
);
3133 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3134 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3139 blob
= ndr_push_blob(push
);
3140 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3150 static bool api_netr_LogonSamLogonEx(pipes_struct
*p
)
3152 const struct ndr_interface_call
*call
;
3153 struct ndr_pull
*pull
;
3154 struct ndr_push
*push
;
3155 enum ndr_err_code ndr_err
;
3157 struct netr_LogonSamLogonEx
*r
;
3159 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGONEX
];
3161 r
= talloc(talloc_tos(), struct netr_LogonSamLogonEx
);
3166 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3171 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3177 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3178 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3179 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3184 if (DEBUGLEVEL
>= 10) {
3185 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonEx
, r
);
3188 ZERO_STRUCT(r
->out
);
3189 r
->out
.flags
= r
->in
.flags
;
3190 r
->out
.validation
= talloc_zero(r
, union netr_Validation
);
3191 if (r
->out
.validation
== NULL
) {
3196 r
->out
.authoritative
= talloc_zero(r
, uint8_t);
3197 if (r
->out
.authoritative
== NULL
) {
3202 r
->out
.result
= _netr_LogonSamLogonEx(p
, r
);
3204 if (p
->rng_fault_state
) {
3206 /* Return true here, srv_pipe_hnd.c will take care */
3210 if (DEBUGLEVEL
>= 10) {
3211 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx
, r
);
3214 push
= ndr_push_init_ctx(r
, NULL
);
3220 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3226 blob
= ndr_push_blob(push
);
3227 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3237 static bool api_netr_DsrEnumerateDomainTrusts(pipes_struct
*p
)
3239 const struct ndr_interface_call
*call
;
3240 struct ndr_pull
*pull
;
3241 struct ndr_push
*push
;
3242 enum ndr_err_code ndr_err
;
3244 struct netr_DsrEnumerateDomainTrusts
*r
;
3246 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRENUMERATEDOMAINTRUSTS
];
3248 r
= talloc(talloc_tos(), struct netr_DsrEnumerateDomainTrusts
);
3253 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3258 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3264 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3265 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3271 if (DEBUGLEVEL
>= 10) {
3272 NDR_PRINT_IN_DEBUG(netr_DsrEnumerateDomainTrusts
, r
);
3275 ZERO_STRUCT(r
->out
);
3276 r
->out
.trusts
= talloc_zero(r
, struct netr_DomainTrustList
);
3277 if (r
->out
.trusts
== NULL
) {
3282 r
->out
.result
= _netr_DsrEnumerateDomainTrusts(p
, r
);
3284 if (p
->rng_fault_state
) {
3286 /* Return true here, srv_pipe_hnd.c will take care */
3290 if (DEBUGLEVEL
>= 10) {
3291 NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts
, r
);
3294 push
= ndr_push_init_ctx(r
, NULL
);
3300 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3301 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3306 blob
= ndr_push_blob(push
);
3307 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3317 static bool api_netr_DsrDeregisterDNSHostRecords(pipes_struct
*p
)
3319 const struct ndr_interface_call
*call
;
3320 struct ndr_pull
*pull
;
3321 struct ndr_push
*push
;
3322 enum ndr_err_code ndr_err
;
3324 struct netr_DsrDeregisterDNSHostRecords
*r
;
3326 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
];
3328 r
= talloc(talloc_tos(), struct netr_DsrDeregisterDNSHostRecords
);
3333 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3338 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3344 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3345 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3346 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3351 if (DEBUGLEVEL
>= 10) {
3352 NDR_PRINT_IN_DEBUG(netr_DsrDeregisterDNSHostRecords
, r
);
3355 r
->out
.result
= _netr_DsrDeregisterDNSHostRecords(p
, r
);
3357 if (p
->rng_fault_state
) {
3359 /* Return true here, srv_pipe_hnd.c will take care */
3363 if (DEBUGLEVEL
>= 10) {
3364 NDR_PRINT_OUT_DEBUG(netr_DsrDeregisterDNSHostRecords
, r
);
3367 push
= ndr_push_init_ctx(r
, NULL
);
3373 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3374 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3379 blob
= ndr_push_blob(push
);
3380 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3390 static bool api_netr_ServerTrustPasswordsGet(pipes_struct
*p
)
3392 const struct ndr_interface_call
*call
;
3393 struct ndr_pull
*pull
;
3394 struct ndr_push
*push
;
3395 enum ndr_err_code ndr_err
;
3397 struct netr_ServerTrustPasswordsGet
*r
;
3399 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERTRUSTPASSWORDSGET
];
3401 r
= talloc(talloc_tos(), struct netr_ServerTrustPasswordsGet
);
3406 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3411 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3417 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3418 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3419 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3424 if (DEBUGLEVEL
>= 10) {
3425 NDR_PRINT_IN_DEBUG(netr_ServerTrustPasswordsGet
, r
);
3428 ZERO_STRUCT(r
->out
);
3429 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
3430 if (r
->out
.return_authenticator
== NULL
) {
3435 r
->out
.password
= talloc_zero(r
, struct samr_Password
);
3436 if (r
->out
.password
== NULL
) {
3441 r
->out
.password2
= talloc_zero(r
, struct samr_Password
);
3442 if (r
->out
.password2
== NULL
) {
3447 r
->out
.result
= _netr_ServerTrustPasswordsGet(p
, r
);
3449 if (p
->rng_fault_state
) {
3451 /* Return true here, srv_pipe_hnd.c will take care */
3455 if (DEBUGLEVEL
>= 10) {
3456 NDR_PRINT_OUT_DEBUG(netr_ServerTrustPasswordsGet
, r
);
3459 push
= ndr_push_init_ctx(r
, NULL
);
3465 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3466 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3471 blob
= ndr_push_blob(push
);
3472 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3482 static bool api_netr_DsRGetForestTrustInformation(pipes_struct
*p
)
3484 const struct ndr_interface_call
*call
;
3485 struct ndr_pull
*pull
;
3486 struct ndr_push
*push
;
3487 enum ndr_err_code ndr_err
;
3489 struct netr_DsRGetForestTrustInformation
*r
;
3491 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETFORESTTRUSTINFORMATION
];
3493 r
= talloc(talloc_tos(), struct netr_DsRGetForestTrustInformation
);
3498 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3503 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3509 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3510 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3511 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3516 if (DEBUGLEVEL
>= 10) {
3517 NDR_PRINT_IN_DEBUG(netr_DsRGetForestTrustInformation
, r
);
3520 ZERO_STRUCT(r
->out
);
3521 r
->out
.forest_trust_info
= talloc_zero(r
, struct lsa_ForestTrustInformation
*);
3522 if (r
->out
.forest_trust_info
== NULL
) {
3527 r
->out
.result
= _netr_DsRGetForestTrustInformation(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(netr_DsRGetForestTrustInformation
, 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_netr_GetForestTrustInformation(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 netr_GetForestTrustInformation
*r
;
3571 call
= &ndr_table_netlogon
.calls
[NDR_NETR_GETFORESTTRUSTINFORMATION
];
3573 r
= talloc(talloc_tos(), struct netr_GetForestTrustInformation
);
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(netr_GetForestTrustInformation
, r
);
3600 ZERO_STRUCT(r
->out
);
3601 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
3602 if (r
->out
.return_authenticator
== NULL
) {
3607 r
->out
.forest_trust_info
= talloc_zero(r
, struct lsa_ForestTrustInformation
*);
3608 if (r
->out
.forest_trust_info
== NULL
) {
3613 r
->out
.result
= _netr_GetForestTrustInformation(p
, r
);
3615 if (p
->rng_fault_state
) {
3617 /* Return true here, srv_pipe_hnd.c will take care */
3621 if (DEBUGLEVEL
>= 10) {
3622 NDR_PRINT_OUT_DEBUG(netr_GetForestTrustInformation
, r
);
3625 push
= ndr_push_init_ctx(r
, NULL
);
3631 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3632 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3637 blob
= ndr_push_blob(push
);
3638 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3648 static bool api_netr_LogonSamLogonWithFlags(pipes_struct
*p
)
3650 const struct ndr_interface_call
*call
;
3651 struct ndr_pull
*pull
;
3652 struct ndr_push
*push
;
3653 enum ndr_err_code ndr_err
;
3655 struct netr_LogonSamLogonWithFlags
*r
;
3657 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGONWITHFLAGS
];
3659 r
= talloc(talloc_tos(), struct netr_LogonSamLogonWithFlags
);
3664 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3669 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3675 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3676 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3677 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3682 if (DEBUGLEVEL
>= 10) {
3683 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonWithFlags
, r
);
3686 ZERO_STRUCT(r
->out
);
3687 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
3688 r
->out
.flags
= r
->in
.flags
;
3689 r
->out
.validation
= talloc_zero(r
, union netr_Validation
);
3690 if (r
->out
.validation
== NULL
) {
3695 r
->out
.authoritative
= talloc_zero(r
, uint8_t);
3696 if (r
->out
.authoritative
== NULL
) {
3701 r
->out
.result
= _netr_LogonSamLogonWithFlags(p
, r
);
3703 if (p
->rng_fault_state
) {
3705 /* Return true here, srv_pipe_hnd.c will take care */
3709 if (DEBUGLEVEL
>= 10) {
3710 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags
, r
);
3713 push
= ndr_push_init_ctx(r
, NULL
);
3719 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3720 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3725 blob
= ndr_push_blob(push
);
3726 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3736 static bool api_netr_ServerGetTrustInfo(pipes_struct
*p
)
3738 const struct ndr_interface_call
*call
;
3739 struct ndr_pull
*pull
;
3740 struct ndr_push
*push
;
3741 enum ndr_err_code ndr_err
;
3743 struct netr_ServerGetTrustInfo
*r
;
3745 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERGETTRUSTINFO
];
3747 r
= talloc(talloc_tos(), struct netr_ServerGetTrustInfo
);
3752 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3757 pull
= ndr_pull_init_blob(&blob
, r
, NULL
);
3763 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3764 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3765 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3770 if (DEBUGLEVEL
>= 10) {
3771 NDR_PRINT_IN_DEBUG(netr_ServerGetTrustInfo
, r
);
3774 ZERO_STRUCT(r
->out
);
3775 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
3776 if (r
->out
.return_authenticator
== NULL
) {
3781 r
->out
.new_owf_password
= talloc_zero(r
, struct samr_Password
);
3782 if (r
->out
.new_owf_password
== NULL
) {
3787 r
->out
.old_owf_password
= talloc_zero(r
, struct samr_Password
);
3788 if (r
->out
.old_owf_password
== NULL
) {
3793 r
->out
.trust_info
= talloc_zero(r
, struct netr_TrustInfo
*);
3794 if (r
->out
.trust_info
== NULL
) {
3799 r
->out
.result
= _netr_ServerGetTrustInfo(p
, r
);
3801 if (p
->rng_fault_state
) {
3803 /* Return true here, srv_pipe_hnd.c will take care */
3807 if (DEBUGLEVEL
>= 10) {
3808 NDR_PRINT_OUT_DEBUG(netr_ServerGetTrustInfo
, r
);
3811 push
= ndr_push_init_ctx(r
, NULL
);
3817 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3818 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3823 blob
= ndr_push_blob(push
);
3824 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3836 static struct api_struct api_netlogon_cmds
[] =
3838 {"NETR_LOGONUASLOGON", NDR_NETR_LOGONUASLOGON
, api_netr_LogonUasLogon
},
3839 {"NETR_LOGONUASLOGOFF", NDR_NETR_LOGONUASLOGOFF
, api_netr_LogonUasLogoff
},
3840 {"NETR_LOGONSAMLOGON", NDR_NETR_LOGONSAMLOGON
, api_netr_LogonSamLogon
},
3841 {"NETR_LOGONSAMLOGOFF", NDR_NETR_LOGONSAMLOGOFF
, api_netr_LogonSamLogoff
},
3842 {"NETR_SERVERREQCHALLENGE", NDR_NETR_SERVERREQCHALLENGE
, api_netr_ServerReqChallenge
},
3843 {"NETR_SERVERAUTHENTICATE", NDR_NETR_SERVERAUTHENTICATE
, api_netr_ServerAuthenticate
},
3844 {"NETR_SERVERPASSWORDSET", NDR_NETR_SERVERPASSWORDSET
, api_netr_ServerPasswordSet
},
3845 {"NETR_DATABASEDELTAS", NDR_NETR_DATABASEDELTAS
, api_netr_DatabaseDeltas
},
3846 {"NETR_DATABASESYNC", NDR_NETR_DATABASESYNC
, api_netr_DatabaseSync
},
3847 {"NETR_ACCOUNTDELTAS", NDR_NETR_ACCOUNTDELTAS
, api_netr_AccountDeltas
},
3848 {"NETR_ACCOUNTSYNC", NDR_NETR_ACCOUNTSYNC
, api_netr_AccountSync
},
3849 {"NETR_GETDCNAME", NDR_NETR_GETDCNAME
, api_netr_GetDcName
},
3850 {"NETR_LOGONCONTROL", NDR_NETR_LOGONCONTROL
, api_netr_LogonControl
},
3851 {"NETR_GETANYDCNAME", NDR_NETR_GETANYDCNAME
, api_netr_GetAnyDCName
},
3852 {"NETR_LOGONCONTROL2", NDR_NETR_LOGONCONTROL2
, api_netr_LogonControl2
},
3853 {"NETR_SERVERAUTHENTICATE2", NDR_NETR_SERVERAUTHENTICATE2
, api_netr_ServerAuthenticate2
},
3854 {"NETR_DATABASESYNC2", NDR_NETR_DATABASESYNC2
, api_netr_DatabaseSync2
},
3855 {"NETR_DATABASEREDO", NDR_NETR_DATABASEREDO
, api_netr_DatabaseRedo
},
3856 {"NETR_LOGONCONTROL2EX", NDR_NETR_LOGONCONTROL2EX
, api_netr_LogonControl2Ex
},
3857 {"NETR_NETRENUMERATETRUSTEDDOMAINS", NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
, api_netr_NetrEnumerateTrustedDomains
},
3858 {"NETR_DSRGETDCNAME", NDR_NETR_DSRGETDCNAME
, api_netr_DsRGetDCName
},
3859 {"NETR_NETRLOGONDUMMYROUTINE1", NDR_NETR_NETRLOGONDUMMYROUTINE1
, api_netr_NETRLOGONDUMMYROUTINE1
},
3860 {"NETR_NETRLOGONSETSERVICEBITS", NDR_NETR_NETRLOGONSETSERVICEBITS
, api_netr_NETRLOGONSETSERVICEBITS
},
3861 {"NETR_LOGONGETTRUSTRID", NDR_NETR_LOGONGETTRUSTRID
, api_netr_LogonGetTrustRid
},
3862 {"NETR_NETRLOGONCOMPUTESERVERDIGEST", NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
, api_netr_NETRLOGONCOMPUTESERVERDIGEST
},
3863 {"NETR_NETRLOGONCOMPUTECLIENTDIGEST", NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
, api_netr_NETRLOGONCOMPUTECLIENTDIGEST
},
3864 {"NETR_SERVERAUTHENTICATE3", NDR_NETR_SERVERAUTHENTICATE3
, api_netr_ServerAuthenticate3
},
3865 {"NETR_DSRGETDCNAMEEX", NDR_NETR_DSRGETDCNAMEEX
, api_netr_DsRGetDCNameEx
},
3866 {"NETR_DSRGETSITENAME", NDR_NETR_DSRGETSITENAME
, api_netr_DsRGetSiteName
},
3867 {"NETR_LOGONGETDOMAININFO", NDR_NETR_LOGONGETDOMAININFO
, api_netr_LogonGetDomainInfo
},
3868 {"NETR_SERVERPASSWORDSET2", NDR_NETR_SERVERPASSWORDSET2
, api_netr_ServerPasswordSet2
},
3869 {"NETR_SERVERPASSWORDGET", NDR_NETR_SERVERPASSWORDGET
, api_netr_ServerPasswordGet
},
3870 {"NETR_NETRLOGONSENDTOSAM", NDR_NETR_NETRLOGONSENDTOSAM
, api_netr_NETRLOGONSENDTOSAM
},
3871 {"NETR_DSRADDRESSTOSITENAMESW", NDR_NETR_DSRADDRESSTOSITENAMESW
, api_netr_DsRAddressToSitenamesW
},
3872 {"NETR_DSRGETDCNAMEEX2", NDR_NETR_DSRGETDCNAMEEX2
, api_netr_DsRGetDCNameEx2
},
3873 {"NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN", NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
},
3874 {"NETR_NETRENUMERATETRUSTEDDOMAINSEX", NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
, api_netr_NetrEnumerateTrustedDomainsEx
},
3875 {"NETR_DSRADDRESSTOSITENAMESEXW", NDR_NETR_DSRADDRESSTOSITENAMESEXW
, api_netr_DsRAddressToSitenamesExW
},
3876 {"NETR_DSRGETDCSITECOVERAGEW", NDR_NETR_DSRGETDCSITECOVERAGEW
, api_netr_DsrGetDcSiteCoverageW
},
3877 {"NETR_LOGONSAMLOGONEX", NDR_NETR_LOGONSAMLOGONEX
, api_netr_LogonSamLogonEx
},
3878 {"NETR_DSRENUMERATEDOMAINTRUSTS", NDR_NETR_DSRENUMERATEDOMAINTRUSTS
, api_netr_DsrEnumerateDomainTrusts
},
3879 {"NETR_DSRDEREGISTERDNSHOSTRECORDS", NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
, api_netr_DsrDeregisterDNSHostRecords
},
3880 {"NETR_SERVERTRUSTPASSWORDSGET", NDR_NETR_SERVERTRUSTPASSWORDSGET
, api_netr_ServerTrustPasswordsGet
},
3881 {"NETR_DSRGETFORESTTRUSTINFORMATION", NDR_NETR_DSRGETFORESTTRUSTINFORMATION
, api_netr_DsRGetForestTrustInformation
},
3882 {"NETR_GETFORESTTRUSTINFORMATION", NDR_NETR_GETFORESTTRUSTINFORMATION
, api_netr_GetForestTrustInformation
},
3883 {"NETR_LOGONSAMLOGONWITHFLAGS", NDR_NETR_LOGONSAMLOGONWITHFLAGS
, api_netr_LogonSamLogonWithFlags
},
3884 {"NETR_SERVERGETTRUSTINFO", NDR_NETR_SERVERGETTRUSTINFO
, api_netr_ServerGetTrustInfo
},
3887 void netlogon_get_pipe_fns(struct api_struct
**fns
, int *n_fns
)
3889 *fns
= api_netlogon_cmds
;
3890 *n_fns
= sizeof(api_netlogon_cmds
) / sizeof(struct api_struct
);
3893 NTSTATUS
rpc_netlogon_dispatch(struct rpc_pipe_client
*cli
, TALLOC_CTX
*mem_ctx
, const struct ndr_interface_table
*table
, uint32_t opnum
, void *_r
)
3895 if (cli
->pipes_struct
== NULL
) {
3896 return NT_STATUS_INVALID_PARAMETER
;
3901 case NDR_NETR_LOGONUASLOGON
: {
3902 struct netr_LogonUasLogon
*r
= (struct netr_LogonUasLogon
*)_r
;
3903 ZERO_STRUCT(r
->out
);
3904 r
->out
.info
= talloc_zero(mem_ctx
, struct netr_UasInfo
*);
3905 if (r
->out
.info
== NULL
) {
3906 return NT_STATUS_NO_MEMORY
;
3909 r
->out
.result
= _netr_LogonUasLogon(cli
->pipes_struct
, r
);
3910 return NT_STATUS_OK
;
3913 case NDR_NETR_LOGONUASLOGOFF
: {
3914 struct netr_LogonUasLogoff
*r
= (struct netr_LogonUasLogoff
*)_r
;
3915 ZERO_STRUCT(r
->out
);
3916 r
->out
.info
= talloc_zero(mem_ctx
, struct netr_UasLogoffInfo
);
3917 if (r
->out
.info
== NULL
) {
3918 return NT_STATUS_NO_MEMORY
;
3921 r
->out
.result
= _netr_LogonUasLogoff(cli
->pipes_struct
, r
);
3922 return NT_STATUS_OK
;
3925 case NDR_NETR_LOGONSAMLOGON
: {
3926 struct netr_LogonSamLogon
*r
= (struct netr_LogonSamLogon
*)_r
;
3927 ZERO_STRUCT(r
->out
);
3928 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
3929 r
->out
.validation
= talloc_zero(mem_ctx
, union netr_Validation
);
3930 if (r
->out
.validation
== NULL
) {
3931 return NT_STATUS_NO_MEMORY
;
3934 r
->out
.authoritative
= talloc_zero(mem_ctx
, uint8_t);
3935 if (r
->out
.authoritative
== NULL
) {
3936 return NT_STATUS_NO_MEMORY
;
3939 r
->out
.result
= _netr_LogonSamLogon(cli
->pipes_struct
, r
);
3940 return NT_STATUS_OK
;
3943 case NDR_NETR_LOGONSAMLOGOFF
: {
3944 struct netr_LogonSamLogoff
*r
= (struct netr_LogonSamLogoff
*)_r
;
3945 ZERO_STRUCT(r
->out
);
3946 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
3947 r
->out
.result
= _netr_LogonSamLogoff(cli
->pipes_struct
, r
);
3948 return NT_STATUS_OK
;
3951 case NDR_NETR_SERVERREQCHALLENGE
: {
3952 struct netr_ServerReqChallenge
*r
= (struct netr_ServerReqChallenge
*)_r
;
3953 ZERO_STRUCT(r
->out
);
3954 r
->out
.return_credentials
= talloc_zero(mem_ctx
, struct netr_Credential
);
3955 if (r
->out
.return_credentials
== NULL
) {
3956 return NT_STATUS_NO_MEMORY
;
3959 r
->out
.result
= _netr_ServerReqChallenge(cli
->pipes_struct
, r
);
3960 return NT_STATUS_OK
;
3963 case NDR_NETR_SERVERAUTHENTICATE
: {
3964 struct netr_ServerAuthenticate
*r
= (struct netr_ServerAuthenticate
*)_r
;
3965 ZERO_STRUCT(r
->out
);
3966 r
->out
.return_credentials
= talloc_zero(mem_ctx
, struct netr_Credential
);
3967 if (r
->out
.return_credentials
== NULL
) {
3968 return NT_STATUS_NO_MEMORY
;
3971 r
->out
.result
= _netr_ServerAuthenticate(cli
->pipes_struct
, r
);
3972 return NT_STATUS_OK
;
3975 case NDR_NETR_SERVERPASSWORDSET
: {
3976 struct netr_ServerPasswordSet
*r
= (struct netr_ServerPasswordSet
*)_r
;
3977 ZERO_STRUCT(r
->out
);
3978 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
3979 if (r
->out
.return_authenticator
== NULL
) {
3980 return NT_STATUS_NO_MEMORY
;
3983 r
->out
.result
= _netr_ServerPasswordSet(cli
->pipes_struct
, r
);
3984 return NT_STATUS_OK
;
3987 case NDR_NETR_DATABASEDELTAS
: {
3988 struct netr_DatabaseDeltas
*r
= (struct netr_DatabaseDeltas
*)_r
;
3989 ZERO_STRUCT(r
->out
);
3990 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
3991 r
->out
.sequence_num
= r
->in
.sequence_num
;
3992 r
->out
.delta_enum_array
= talloc_zero(mem_ctx
, struct netr_DELTA_ENUM_ARRAY
*);
3993 if (r
->out
.delta_enum_array
== NULL
) {
3994 return NT_STATUS_NO_MEMORY
;
3997 r
->out
.result
= _netr_DatabaseDeltas(cli
->pipes_struct
, r
);
3998 return NT_STATUS_OK
;
4001 case NDR_NETR_DATABASESYNC
: {
4002 struct netr_DatabaseSync
*r
= (struct netr_DatabaseSync
*)_r
;
4003 ZERO_STRUCT(r
->out
);
4004 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4005 r
->out
.sync_context
= r
->in
.sync_context
;
4006 r
->out
.delta_enum_array
= talloc_zero(mem_ctx
, struct netr_DELTA_ENUM_ARRAY
*);
4007 if (r
->out
.delta_enum_array
== NULL
) {
4008 return NT_STATUS_NO_MEMORY
;
4011 r
->out
.result
= _netr_DatabaseSync(cli
->pipes_struct
, r
);
4012 return NT_STATUS_OK
;
4015 case NDR_NETR_ACCOUNTDELTAS
: {
4016 struct netr_AccountDeltas
*r
= (struct netr_AccountDeltas
*)_r
;
4017 ZERO_STRUCT(r
->out
);
4018 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4019 r
->out
.buffer
= talloc_zero(mem_ctx
, struct netr_AccountBuffer
);
4020 if (r
->out
.buffer
== NULL
) {
4021 return NT_STATUS_NO_MEMORY
;
4024 r
->out
.count_returned
= talloc_zero(mem_ctx
, uint32_t);
4025 if (r
->out
.count_returned
== NULL
) {
4026 return NT_STATUS_NO_MEMORY
;
4029 r
->out
.total_entries
= talloc_zero(mem_ctx
, uint32_t);
4030 if (r
->out
.total_entries
== NULL
) {
4031 return NT_STATUS_NO_MEMORY
;
4034 r
->out
.recordid
= talloc_zero(mem_ctx
, struct netr_UAS_INFO_0
);
4035 if (r
->out
.recordid
== NULL
) {
4036 return NT_STATUS_NO_MEMORY
;
4039 r
->out
.result
= _netr_AccountDeltas(cli
->pipes_struct
, r
);
4040 return NT_STATUS_OK
;
4043 case NDR_NETR_ACCOUNTSYNC
: {
4044 struct netr_AccountSync
*r
= (struct netr_AccountSync
*)_r
;
4045 ZERO_STRUCT(r
->out
);
4046 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4047 r
->out
.recordid
= r
->in
.recordid
;
4048 r
->out
.buffer
= talloc_zero(mem_ctx
, struct netr_AccountBuffer
);
4049 if (r
->out
.buffer
== NULL
) {
4050 return NT_STATUS_NO_MEMORY
;
4053 r
->out
.count_returned
= talloc_zero(mem_ctx
, uint32_t);
4054 if (r
->out
.count_returned
== NULL
) {
4055 return NT_STATUS_NO_MEMORY
;
4058 r
->out
.total_entries
= talloc_zero(mem_ctx
, uint32_t);
4059 if (r
->out
.total_entries
== NULL
) {
4060 return NT_STATUS_NO_MEMORY
;
4063 r
->out
.next_reference
= talloc_zero(mem_ctx
, uint32_t);
4064 if (r
->out
.next_reference
== NULL
) {
4065 return NT_STATUS_NO_MEMORY
;
4068 r
->out
.result
= _netr_AccountSync(cli
->pipes_struct
, r
);
4069 return NT_STATUS_OK
;
4072 case NDR_NETR_GETDCNAME
: {
4073 struct netr_GetDcName
*r
= (struct netr_GetDcName
*)_r
;
4074 ZERO_STRUCT(r
->out
);
4075 r
->out
.dcname
= talloc_zero(mem_ctx
, const char *);
4076 if (r
->out
.dcname
== NULL
) {
4077 return NT_STATUS_NO_MEMORY
;
4080 r
->out
.result
= _netr_GetDcName(cli
->pipes_struct
, r
);
4081 return NT_STATUS_OK
;
4084 case NDR_NETR_LOGONCONTROL
: {
4085 struct netr_LogonControl
*r
= (struct netr_LogonControl
*)_r
;
4086 ZERO_STRUCT(r
->out
);
4087 r
->out
.info
= talloc_zero(mem_ctx
, union netr_CONTROL_QUERY_INFORMATION
);
4088 if (r
->out
.info
== NULL
) {
4089 return NT_STATUS_NO_MEMORY
;
4092 r
->out
.result
= _netr_LogonControl(cli
->pipes_struct
, r
);
4093 return NT_STATUS_OK
;
4096 case NDR_NETR_GETANYDCNAME
: {
4097 struct netr_GetAnyDCName
*r
= (struct netr_GetAnyDCName
*)_r
;
4098 ZERO_STRUCT(r
->out
);
4099 r
->out
.dcname
= talloc_zero(mem_ctx
, const char *);
4100 if (r
->out
.dcname
== NULL
) {
4101 return NT_STATUS_NO_MEMORY
;
4104 r
->out
.result
= _netr_GetAnyDCName(cli
->pipes_struct
, r
);
4105 return NT_STATUS_OK
;
4108 case NDR_NETR_LOGONCONTROL2
: {
4109 struct netr_LogonControl2
*r
= (struct netr_LogonControl2
*)_r
;
4110 ZERO_STRUCT(r
->out
);
4111 r
->out
.query
= talloc_zero(mem_ctx
, union netr_CONTROL_QUERY_INFORMATION
);
4112 if (r
->out
.query
== NULL
) {
4113 return NT_STATUS_NO_MEMORY
;
4116 r
->out
.result
= _netr_LogonControl2(cli
->pipes_struct
, r
);
4117 return NT_STATUS_OK
;
4120 case NDR_NETR_SERVERAUTHENTICATE2
: {
4121 struct netr_ServerAuthenticate2
*r
= (struct netr_ServerAuthenticate2
*)_r
;
4122 ZERO_STRUCT(r
->out
);
4123 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
4124 r
->out
.return_credentials
= talloc_zero(mem_ctx
, struct netr_Credential
);
4125 if (r
->out
.return_credentials
== NULL
) {
4126 return NT_STATUS_NO_MEMORY
;
4129 r
->out
.result
= _netr_ServerAuthenticate2(cli
->pipes_struct
, r
);
4130 return NT_STATUS_OK
;
4133 case NDR_NETR_DATABASESYNC2
: {
4134 struct netr_DatabaseSync2
*r
= (struct netr_DatabaseSync2
*)_r
;
4135 ZERO_STRUCT(r
->out
);
4136 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4137 r
->out
.sync_context
= r
->in
.sync_context
;
4138 r
->out
.delta_enum_array
= talloc_zero(mem_ctx
, struct netr_DELTA_ENUM_ARRAY
*);
4139 if (r
->out
.delta_enum_array
== NULL
) {
4140 return NT_STATUS_NO_MEMORY
;
4143 r
->out
.result
= _netr_DatabaseSync2(cli
->pipes_struct
, r
);
4144 return NT_STATUS_OK
;
4147 case NDR_NETR_DATABASEREDO
: {
4148 struct netr_DatabaseRedo
*r
= (struct netr_DatabaseRedo
*)_r
;
4149 ZERO_STRUCT(r
->out
);
4150 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4151 r
->out
.delta_enum_array
= talloc_zero(mem_ctx
, struct netr_DELTA_ENUM_ARRAY
*);
4152 if (r
->out
.delta_enum_array
== NULL
) {
4153 return NT_STATUS_NO_MEMORY
;
4156 r
->out
.result
= _netr_DatabaseRedo(cli
->pipes_struct
, r
);
4157 return NT_STATUS_OK
;
4160 case NDR_NETR_LOGONCONTROL2EX
: {
4161 struct netr_LogonControl2Ex
*r
= (struct netr_LogonControl2Ex
*)_r
;
4162 ZERO_STRUCT(r
->out
);
4163 r
->out
.query
= talloc_zero(mem_ctx
, union netr_CONTROL_QUERY_INFORMATION
);
4164 if (r
->out
.query
== NULL
) {
4165 return NT_STATUS_NO_MEMORY
;
4168 r
->out
.result
= _netr_LogonControl2Ex(cli
->pipes_struct
, r
);
4169 return NT_STATUS_OK
;
4172 case NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
: {
4173 struct netr_NetrEnumerateTrustedDomains
*r
= (struct netr_NetrEnumerateTrustedDomains
*)_r
;
4174 ZERO_STRUCT(r
->out
);
4175 r
->out
.trusted_domains_blob
= talloc_zero(mem_ctx
, struct netr_Blob
);
4176 if (r
->out
.trusted_domains_blob
== NULL
) {
4177 return NT_STATUS_NO_MEMORY
;
4180 r
->out
.result
= _netr_NetrEnumerateTrustedDomains(cli
->pipes_struct
, r
);
4181 return NT_STATUS_OK
;
4184 case NDR_NETR_DSRGETDCNAME
: {
4185 struct netr_DsRGetDCName
*r
= (struct netr_DsRGetDCName
*)_r
;
4186 ZERO_STRUCT(r
->out
);
4187 r
->out
.info
= talloc_zero(mem_ctx
, struct netr_DsRGetDCNameInfo
*);
4188 if (r
->out
.info
== NULL
) {
4189 return NT_STATUS_NO_MEMORY
;
4192 r
->out
.result
= _netr_DsRGetDCName(cli
->pipes_struct
, r
);
4193 return NT_STATUS_OK
;
4196 case NDR_NETR_NETRLOGONDUMMYROUTINE1
: {
4197 struct netr_NETRLOGONDUMMYROUTINE1
*r
= (struct netr_NETRLOGONDUMMYROUTINE1
*)_r
;
4198 r
->out
.result
= _netr_NETRLOGONDUMMYROUTINE1(cli
->pipes_struct
, r
);
4199 return NT_STATUS_OK
;
4202 case NDR_NETR_NETRLOGONSETSERVICEBITS
: {
4203 struct netr_NETRLOGONSETSERVICEBITS
*r
= (struct netr_NETRLOGONSETSERVICEBITS
*)_r
;
4204 r
->out
.result
= _netr_NETRLOGONSETSERVICEBITS(cli
->pipes_struct
, r
);
4205 return NT_STATUS_OK
;
4208 case NDR_NETR_LOGONGETTRUSTRID
: {
4209 struct netr_LogonGetTrustRid
*r
= (struct netr_LogonGetTrustRid
*)_r
;
4210 ZERO_STRUCT(r
->out
);
4211 r
->out
.rid
= talloc_zero(mem_ctx
, uint32_t);
4212 if (r
->out
.rid
== NULL
) {
4213 return NT_STATUS_NO_MEMORY
;
4216 r
->out
.result
= _netr_LogonGetTrustRid(cli
->pipes_struct
, r
);
4217 return NT_STATUS_OK
;
4220 case NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
: {
4221 struct netr_NETRLOGONCOMPUTESERVERDIGEST
*r
= (struct netr_NETRLOGONCOMPUTESERVERDIGEST
*)_r
;
4222 r
->out
.result
= _netr_NETRLOGONCOMPUTESERVERDIGEST(cli
->pipes_struct
, r
);
4223 return NT_STATUS_OK
;
4226 case NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
: {
4227 struct netr_NETRLOGONCOMPUTECLIENTDIGEST
*r
= (struct netr_NETRLOGONCOMPUTECLIENTDIGEST
*)_r
;
4228 r
->out
.result
= _netr_NETRLOGONCOMPUTECLIENTDIGEST(cli
->pipes_struct
, r
);
4229 return NT_STATUS_OK
;
4232 case NDR_NETR_SERVERAUTHENTICATE3
: {
4233 struct netr_ServerAuthenticate3
*r
= (struct netr_ServerAuthenticate3
*)_r
;
4234 ZERO_STRUCT(r
->out
);
4235 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
4236 r
->out
.return_credentials
= talloc_zero(mem_ctx
, struct netr_Credential
);
4237 if (r
->out
.return_credentials
== NULL
) {
4238 return NT_STATUS_NO_MEMORY
;
4241 r
->out
.rid
= talloc_zero(mem_ctx
, uint32_t);
4242 if (r
->out
.rid
== NULL
) {
4243 return NT_STATUS_NO_MEMORY
;
4246 r
->out
.result
= _netr_ServerAuthenticate3(cli
->pipes_struct
, r
);
4247 return NT_STATUS_OK
;
4250 case NDR_NETR_DSRGETDCNAMEEX
: {
4251 struct netr_DsRGetDCNameEx
*r
= (struct netr_DsRGetDCNameEx
*)_r
;
4252 ZERO_STRUCT(r
->out
);
4253 r
->out
.info
= talloc_zero(mem_ctx
, struct netr_DsRGetDCNameInfo
*);
4254 if (r
->out
.info
== NULL
) {
4255 return NT_STATUS_NO_MEMORY
;
4258 r
->out
.result
= _netr_DsRGetDCNameEx(cli
->pipes_struct
, r
);
4259 return NT_STATUS_OK
;
4262 case NDR_NETR_DSRGETSITENAME
: {
4263 struct netr_DsRGetSiteName
*r
= (struct netr_DsRGetSiteName
*)_r
;
4264 ZERO_STRUCT(r
->out
);
4265 r
->out
.site
= talloc_zero(mem_ctx
, const char *);
4266 if (r
->out
.site
== NULL
) {
4267 return NT_STATUS_NO_MEMORY
;
4270 r
->out
.result
= _netr_DsRGetSiteName(cli
->pipes_struct
, r
);
4271 return NT_STATUS_OK
;
4274 case NDR_NETR_LOGONGETDOMAININFO
: {
4275 struct netr_LogonGetDomainInfo
*r
= (struct netr_LogonGetDomainInfo
*)_r
;
4276 ZERO_STRUCT(r
->out
);
4277 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4278 r
->out
.info
= talloc_zero(mem_ctx
, union netr_DomainInfo
);
4279 if (r
->out
.info
== NULL
) {
4280 return NT_STATUS_NO_MEMORY
;
4283 r
->out
.result
= _netr_LogonGetDomainInfo(cli
->pipes_struct
, r
);
4284 return NT_STATUS_OK
;
4287 case NDR_NETR_SERVERPASSWORDSET2
: {
4288 struct netr_ServerPasswordSet2
*r
= (struct netr_ServerPasswordSet2
*)_r
;
4289 ZERO_STRUCT(r
->out
);
4290 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
4291 if (r
->out
.return_authenticator
== NULL
) {
4292 return NT_STATUS_NO_MEMORY
;
4295 r
->out
.result
= _netr_ServerPasswordSet2(cli
->pipes_struct
, r
);
4296 return NT_STATUS_OK
;
4299 case NDR_NETR_SERVERPASSWORDGET
: {
4300 struct netr_ServerPasswordGet
*r
= (struct netr_ServerPasswordGet
*)_r
;
4301 ZERO_STRUCT(r
->out
);
4302 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
4303 if (r
->out
.return_authenticator
== NULL
) {
4304 return NT_STATUS_NO_MEMORY
;
4307 r
->out
.password
= talloc_zero(mem_ctx
, struct samr_Password
);
4308 if (r
->out
.password
== NULL
) {
4309 return NT_STATUS_NO_MEMORY
;
4312 r
->out
.result
= _netr_ServerPasswordGet(cli
->pipes_struct
, r
);
4313 return NT_STATUS_OK
;
4316 case NDR_NETR_NETRLOGONSENDTOSAM
: {
4317 struct netr_NETRLOGONSENDTOSAM
*r
= (struct netr_NETRLOGONSENDTOSAM
*)_r
;
4318 r
->out
.result
= _netr_NETRLOGONSENDTOSAM(cli
->pipes_struct
, r
);
4319 return NT_STATUS_OK
;
4322 case NDR_NETR_DSRADDRESSTOSITENAMESW
: {
4323 struct netr_DsRAddressToSitenamesW
*r
= (struct netr_DsRAddressToSitenamesW
*)_r
;
4324 ZERO_STRUCT(r
->out
);
4325 r
->out
.ctr
= talloc_zero(mem_ctx
, struct netr_DsRAddressToSitenamesWCtr
*);
4326 if (r
->out
.ctr
== NULL
) {
4327 return NT_STATUS_NO_MEMORY
;
4330 r
->out
.result
= _netr_DsRAddressToSitenamesW(cli
->pipes_struct
, r
);
4331 return NT_STATUS_OK
;
4334 case NDR_NETR_DSRGETDCNAMEEX2
: {
4335 struct netr_DsRGetDCNameEx2
*r
= (struct netr_DsRGetDCNameEx2
*)_r
;
4336 ZERO_STRUCT(r
->out
);
4337 r
->out
.info
= talloc_zero(mem_ctx
, struct netr_DsRGetDCNameInfo
*);
4338 if (r
->out
.info
== NULL
) {
4339 return NT_STATUS_NO_MEMORY
;
4342 r
->out
.result
= _netr_DsRGetDCNameEx2(cli
->pipes_struct
, r
);
4343 return NT_STATUS_OK
;
4346 case NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
: {
4347 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
*r
= (struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
*)_r
;
4348 r
->out
.result
= _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(cli
->pipes_struct
, r
);
4349 return NT_STATUS_OK
;
4352 case NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
: {
4353 struct netr_NetrEnumerateTrustedDomainsEx
*r
= (struct netr_NetrEnumerateTrustedDomainsEx
*)_r
;
4354 ZERO_STRUCT(r
->out
);
4355 r
->out
.dom_trust_list
= talloc_zero(mem_ctx
, struct netr_DomainTrustList
);
4356 if (r
->out
.dom_trust_list
== NULL
) {
4357 return NT_STATUS_NO_MEMORY
;
4360 r
->out
.result
= _netr_NetrEnumerateTrustedDomainsEx(cli
->pipes_struct
, r
);
4361 return NT_STATUS_OK
;
4364 case NDR_NETR_DSRADDRESSTOSITENAMESEXW
: {
4365 struct netr_DsRAddressToSitenamesExW
*r
= (struct netr_DsRAddressToSitenamesExW
*)_r
;
4366 ZERO_STRUCT(r
->out
);
4367 r
->out
.ctr
= talloc_zero(mem_ctx
, struct netr_DsRAddressToSitenamesExWCtr
*);
4368 if (r
->out
.ctr
== NULL
) {
4369 return NT_STATUS_NO_MEMORY
;
4372 r
->out
.result
= _netr_DsRAddressToSitenamesExW(cli
->pipes_struct
, r
);
4373 return NT_STATUS_OK
;
4376 case NDR_NETR_DSRGETDCSITECOVERAGEW
: {
4377 struct netr_DsrGetDcSiteCoverageW
*r
= (struct netr_DsrGetDcSiteCoverageW
*)_r
;
4378 ZERO_STRUCT(r
->out
);
4379 r
->out
.ctr
= talloc_zero(mem_ctx
, struct DcSitesCtr
*);
4380 if (r
->out
.ctr
== NULL
) {
4381 return NT_STATUS_NO_MEMORY
;
4384 r
->out
.result
= _netr_DsrGetDcSiteCoverageW(cli
->pipes_struct
, r
);
4385 return NT_STATUS_OK
;
4388 case NDR_NETR_LOGONSAMLOGONEX
: {
4389 struct netr_LogonSamLogonEx
*r
= (struct netr_LogonSamLogonEx
*)_r
;
4390 ZERO_STRUCT(r
->out
);
4391 r
->out
.flags
= r
->in
.flags
;
4392 r
->out
.validation
= talloc_zero(mem_ctx
, union netr_Validation
);
4393 if (r
->out
.validation
== NULL
) {
4394 return NT_STATUS_NO_MEMORY
;
4397 r
->out
.authoritative
= talloc_zero(mem_ctx
, uint8_t);
4398 if (r
->out
.authoritative
== NULL
) {
4399 return NT_STATUS_NO_MEMORY
;
4402 r
->out
.result
= _netr_LogonSamLogonEx(cli
->pipes_struct
, r
);
4403 return NT_STATUS_OK
;
4406 case NDR_NETR_DSRENUMERATEDOMAINTRUSTS
: {
4407 struct netr_DsrEnumerateDomainTrusts
*r
= (struct netr_DsrEnumerateDomainTrusts
*)_r
;
4408 ZERO_STRUCT(r
->out
);
4409 r
->out
.trusts
= talloc_zero(mem_ctx
, struct netr_DomainTrustList
);
4410 if (r
->out
.trusts
== NULL
) {
4411 return NT_STATUS_NO_MEMORY
;
4414 r
->out
.result
= _netr_DsrEnumerateDomainTrusts(cli
->pipes_struct
, r
);
4415 return NT_STATUS_OK
;
4418 case NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
: {
4419 struct netr_DsrDeregisterDNSHostRecords
*r
= (struct netr_DsrDeregisterDNSHostRecords
*)_r
;
4420 r
->out
.result
= _netr_DsrDeregisterDNSHostRecords(cli
->pipes_struct
, r
);
4421 return NT_STATUS_OK
;
4424 case NDR_NETR_SERVERTRUSTPASSWORDSGET
: {
4425 struct netr_ServerTrustPasswordsGet
*r
= (struct netr_ServerTrustPasswordsGet
*)_r
;
4426 ZERO_STRUCT(r
->out
);
4427 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
4428 if (r
->out
.return_authenticator
== NULL
) {
4429 return NT_STATUS_NO_MEMORY
;
4432 r
->out
.password
= talloc_zero(mem_ctx
, struct samr_Password
);
4433 if (r
->out
.password
== NULL
) {
4434 return NT_STATUS_NO_MEMORY
;
4437 r
->out
.password2
= talloc_zero(mem_ctx
, struct samr_Password
);
4438 if (r
->out
.password2
== NULL
) {
4439 return NT_STATUS_NO_MEMORY
;
4442 r
->out
.result
= _netr_ServerTrustPasswordsGet(cli
->pipes_struct
, r
);
4443 return NT_STATUS_OK
;
4446 case NDR_NETR_DSRGETFORESTTRUSTINFORMATION
: {
4447 struct netr_DsRGetForestTrustInformation
*r
= (struct netr_DsRGetForestTrustInformation
*)_r
;
4448 ZERO_STRUCT(r
->out
);
4449 r
->out
.forest_trust_info
= talloc_zero(mem_ctx
, struct lsa_ForestTrustInformation
*);
4450 if (r
->out
.forest_trust_info
== NULL
) {
4451 return NT_STATUS_NO_MEMORY
;
4454 r
->out
.result
= _netr_DsRGetForestTrustInformation(cli
->pipes_struct
, r
);
4455 return NT_STATUS_OK
;
4458 case NDR_NETR_GETFORESTTRUSTINFORMATION
: {
4459 struct netr_GetForestTrustInformation
*r
= (struct netr_GetForestTrustInformation
*)_r
;
4460 ZERO_STRUCT(r
->out
);
4461 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
4462 if (r
->out
.return_authenticator
== NULL
) {
4463 return NT_STATUS_NO_MEMORY
;
4466 r
->out
.forest_trust_info
= talloc_zero(mem_ctx
, struct lsa_ForestTrustInformation
*);
4467 if (r
->out
.forest_trust_info
== NULL
) {
4468 return NT_STATUS_NO_MEMORY
;
4471 r
->out
.result
= _netr_GetForestTrustInformation(cli
->pipes_struct
, r
);
4472 return NT_STATUS_OK
;
4475 case NDR_NETR_LOGONSAMLOGONWITHFLAGS
: {
4476 struct netr_LogonSamLogonWithFlags
*r
= (struct netr_LogonSamLogonWithFlags
*)_r
;
4477 ZERO_STRUCT(r
->out
);
4478 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
4479 r
->out
.flags
= r
->in
.flags
;
4480 r
->out
.validation
= talloc_zero(mem_ctx
, union netr_Validation
);
4481 if (r
->out
.validation
== NULL
) {
4482 return NT_STATUS_NO_MEMORY
;
4485 r
->out
.authoritative
= talloc_zero(mem_ctx
, uint8_t);
4486 if (r
->out
.authoritative
== NULL
) {
4487 return NT_STATUS_NO_MEMORY
;
4490 r
->out
.result
= _netr_LogonSamLogonWithFlags(cli
->pipes_struct
, r
);
4491 return NT_STATUS_OK
;
4494 case NDR_NETR_SERVERGETTRUSTINFO
: {
4495 struct netr_ServerGetTrustInfo
*r
= (struct netr_ServerGetTrustInfo
*)_r
;
4496 ZERO_STRUCT(r
->out
);
4497 r
->out
.return_authenticator
= talloc_zero(mem_ctx
, struct netr_Authenticator
);
4498 if (r
->out
.return_authenticator
== NULL
) {
4499 return NT_STATUS_NO_MEMORY
;
4502 r
->out
.new_owf_password
= talloc_zero(mem_ctx
, struct samr_Password
);
4503 if (r
->out
.new_owf_password
== NULL
) {
4504 return NT_STATUS_NO_MEMORY
;
4507 r
->out
.old_owf_password
= talloc_zero(mem_ctx
, struct samr_Password
);
4508 if (r
->out
.old_owf_password
== NULL
) {
4509 return NT_STATUS_NO_MEMORY
;
4512 r
->out
.trust_info
= talloc_zero(mem_ctx
, struct netr_TrustInfo
*);
4513 if (r
->out
.trust_info
== NULL
) {
4514 return NT_STATUS_NO_MEMORY
;
4517 r
->out
.result
= _netr_ServerGetTrustInfo(cli
->pipes_struct
, r
);
4518 return NT_STATUS_OK
;
4522 return NT_STATUS_NOT_IMPLEMENTED
;
4526 NTSTATUS
rpc_netlogon_init(void)
4528 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION
, "netlogon", "netlogon", &ndr_table_netlogon
, api_netlogon_cmds
, sizeof(api_netlogon_cmds
) / sizeof(struct api_struct
));