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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
.buffer
= talloc_zero(r
, struct netr_AccountBuffer
);
875 if (r
->out
.buffer
== NULL
) {
880 r
->out
.count_returned
= talloc_zero(r
, uint32_t);
881 if (r
->out
.count_returned
== NULL
) {
886 r
->out
.total_entries
= talloc_zero(r
, uint32_t);
887 if (r
->out
.total_entries
== NULL
) {
892 r
->out
.next_reference
= talloc_zero(r
, uint32_t);
893 if (r
->out
.next_reference
== NULL
) {
898 r
->out
.recordid
= r
->in
.recordid
;
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
.return_credentials
= talloc_zero(r
, struct netr_Credential
);
1294 if (r
->out
.return_credentials
== NULL
) {
1299 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
.credentials
= r
->in
.credentials
;
2150 r
->out
.negotiate_flags
= r
->in
.negotiate_flags
;
2151 r
->out
.rid
= talloc_zero(r
, uint32_t);
2152 if (r
->out
.rid
== NULL
) {
2157 r
->out
.result
= _netr_ServerAuthenticate3(p
, r
);
2159 if (p
->rng_fault_state
) {
2161 /* Return true here, srv_pipe_hnd.c will take care */
2165 if (DEBUGLEVEL
>= 10) {
2166 NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3
, r
);
2169 push
= ndr_push_init_ctx(r
);
2175 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2176 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2181 blob
= ndr_push_blob(push
);
2182 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2192 static bool api_netr_DsRGetDCNameEx(pipes_struct
*p
)
2194 const struct ndr_interface_call
*call
;
2195 struct ndr_pull
*pull
;
2196 struct ndr_push
*push
;
2197 enum ndr_err_code ndr_err
;
2199 struct netr_DsRGetDCNameEx
*r
;
2201 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCNAMEEX
];
2203 r
= talloc(talloc_tos(), struct netr_DsRGetDCNameEx
);
2208 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2213 pull
= ndr_pull_init_blob(&blob
, r
);
2219 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2220 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2221 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2226 if (DEBUGLEVEL
>= 10) {
2227 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx
, r
);
2230 ZERO_STRUCT(r
->out
);
2231 r
->out
.info
= talloc_zero(r
, struct netr_DsRGetDCNameInfo
*);
2232 if (r
->out
.info
== NULL
) {
2237 r
->out
.result
= _netr_DsRGetDCNameEx(p
, r
);
2239 if (p
->rng_fault_state
) {
2241 /* Return true here, srv_pipe_hnd.c will take care */
2245 if (DEBUGLEVEL
>= 10) {
2246 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx
, r
);
2249 push
= ndr_push_init_ctx(r
);
2255 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2256 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2261 blob
= ndr_push_blob(push
);
2262 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2272 static bool api_netr_DsRGetSiteName(pipes_struct
*p
)
2274 const struct ndr_interface_call
*call
;
2275 struct ndr_pull
*pull
;
2276 struct ndr_push
*push
;
2277 enum ndr_err_code ndr_err
;
2279 struct netr_DsRGetSiteName
*r
;
2281 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETSITENAME
];
2283 r
= talloc(talloc_tos(), struct netr_DsRGetSiteName
);
2288 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2293 pull
= ndr_pull_init_blob(&blob
, r
);
2299 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2300 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2301 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2306 if (DEBUGLEVEL
>= 10) {
2307 NDR_PRINT_IN_DEBUG(netr_DsRGetSiteName
, r
);
2310 ZERO_STRUCT(r
->out
);
2311 r
->out
.site
= talloc_zero(r
, const char *);
2312 if (r
->out
.site
== NULL
) {
2317 r
->out
.result
= _netr_DsRGetSiteName(p
, r
);
2319 if (p
->rng_fault_state
) {
2321 /* Return true here, srv_pipe_hnd.c will take care */
2325 if (DEBUGLEVEL
>= 10) {
2326 NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName
, r
);
2329 push
= ndr_push_init_ctx(r
);
2335 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2336 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2341 blob
= ndr_push_blob(push
);
2342 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2352 static bool api_netr_LogonGetDomainInfo(pipes_struct
*p
)
2354 const struct ndr_interface_call
*call
;
2355 struct ndr_pull
*pull
;
2356 struct ndr_push
*push
;
2357 enum ndr_err_code ndr_err
;
2359 struct netr_LogonGetDomainInfo
*r
;
2361 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONGETDOMAININFO
];
2363 r
= talloc(talloc_tos(), struct netr_LogonGetDomainInfo
);
2368 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2373 pull
= ndr_pull_init_blob(&blob
, r
);
2379 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2380 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2381 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2386 if (DEBUGLEVEL
>= 10) {
2387 NDR_PRINT_IN_DEBUG(netr_LogonGetDomainInfo
, r
);
2390 ZERO_STRUCT(r
->out
);
2391 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
2392 r
->out
.info
= talloc_zero(r
, union netr_DomainInfo
);
2393 if (r
->out
.info
== NULL
) {
2398 r
->out
.result
= _netr_LogonGetDomainInfo(p
, r
);
2400 if (p
->rng_fault_state
) {
2402 /* Return true here, srv_pipe_hnd.c will take care */
2406 if (DEBUGLEVEL
>= 10) {
2407 NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo
, r
);
2410 push
= ndr_push_init_ctx(r
);
2416 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2417 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2422 blob
= ndr_push_blob(push
);
2423 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2433 static bool api_netr_ServerPasswordSet2(pipes_struct
*p
)
2435 const struct ndr_interface_call
*call
;
2436 struct ndr_pull
*pull
;
2437 struct ndr_push
*push
;
2438 enum ndr_err_code ndr_err
;
2440 struct netr_ServerPasswordSet2
*r
;
2442 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERPASSWORDSET2
];
2444 r
= talloc(talloc_tos(), struct netr_ServerPasswordSet2
);
2449 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2454 pull
= ndr_pull_init_blob(&blob
, r
);
2460 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2461 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2462 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2467 if (DEBUGLEVEL
>= 10) {
2468 NDR_PRINT_IN_DEBUG(netr_ServerPasswordSet2
, r
);
2471 ZERO_STRUCT(r
->out
);
2472 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
2473 if (r
->out
.return_authenticator
== NULL
) {
2478 r
->out
.result
= _netr_ServerPasswordSet2(p
, r
);
2480 if (p
->rng_fault_state
) {
2482 /* Return true here, srv_pipe_hnd.c will take care */
2486 if (DEBUGLEVEL
>= 10) {
2487 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2
, r
);
2490 push
= ndr_push_init_ctx(r
);
2496 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2497 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2502 blob
= ndr_push_blob(push
);
2503 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2513 static bool api_netr_ServerPasswordGet(pipes_struct
*p
)
2515 const struct ndr_interface_call
*call
;
2516 struct ndr_pull
*pull
;
2517 struct ndr_push
*push
;
2518 enum ndr_err_code ndr_err
;
2520 struct netr_ServerPasswordGet
*r
;
2522 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERPASSWORDGET
];
2524 r
= talloc(talloc_tos(), struct netr_ServerPasswordGet
);
2529 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2534 pull
= ndr_pull_init_blob(&blob
, r
);
2540 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2541 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2542 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2547 if (DEBUGLEVEL
>= 10) {
2548 NDR_PRINT_IN_DEBUG(netr_ServerPasswordGet
, r
);
2551 ZERO_STRUCT(r
->out
);
2552 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
2553 if (r
->out
.return_authenticator
== NULL
) {
2558 r
->out
.password
= talloc_zero(r
, struct samr_Password
);
2559 if (r
->out
.password
== NULL
) {
2564 r
->out
.result
= _netr_ServerPasswordGet(p
, r
);
2566 if (p
->rng_fault_state
) {
2568 /* Return true here, srv_pipe_hnd.c will take care */
2572 if (DEBUGLEVEL
>= 10) {
2573 NDR_PRINT_OUT_DEBUG(netr_ServerPasswordGet
, r
);
2576 push
= ndr_push_init_ctx(r
);
2582 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2583 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2588 blob
= ndr_push_blob(push
);
2589 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2599 static bool api_netr_NETRLOGONSENDTOSAM(pipes_struct
*p
)
2601 const struct ndr_interface_call
*call
;
2602 struct ndr_pull
*pull
;
2603 struct ndr_push
*push
;
2604 enum ndr_err_code ndr_err
;
2606 struct netr_NETRLOGONSENDTOSAM
*r
;
2608 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONSENDTOSAM
];
2610 r
= talloc(talloc_tos(), struct netr_NETRLOGONSENDTOSAM
);
2615 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2620 pull
= ndr_pull_init_blob(&blob
, r
);
2626 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2627 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2628 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2633 if (DEBUGLEVEL
>= 10) {
2634 NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM
, r
);
2637 r
->out
.result
= _netr_NETRLOGONSENDTOSAM(p
, r
);
2639 if (p
->rng_fault_state
) {
2641 /* Return true here, srv_pipe_hnd.c will take care */
2645 if (DEBUGLEVEL
>= 10) {
2646 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM
, r
);
2649 push
= ndr_push_init_ctx(r
);
2655 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2656 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2661 blob
= ndr_push_blob(push
);
2662 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2672 static bool api_netr_DsRAddressToSitenamesW(pipes_struct
*p
)
2674 const struct ndr_interface_call
*call
;
2675 struct ndr_pull
*pull
;
2676 struct ndr_push
*push
;
2677 enum ndr_err_code ndr_err
;
2679 struct netr_DsRAddressToSitenamesW
*r
;
2681 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRADDRESSTOSITENAMESW
];
2683 r
= talloc(talloc_tos(), struct netr_DsRAddressToSitenamesW
);
2688 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2693 pull
= ndr_pull_init_blob(&blob
, r
);
2699 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2700 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2701 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2706 if (DEBUGLEVEL
>= 10) {
2707 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesW
, r
);
2710 ZERO_STRUCT(r
->out
);
2711 r
->out
.ctr
= talloc_zero(r
, struct netr_DsRAddressToSitenamesWCtr
*);
2712 if (r
->out
.ctr
== NULL
) {
2717 r
->out
.result
= _netr_DsRAddressToSitenamesW(p
, r
);
2719 if (p
->rng_fault_state
) {
2721 /* Return true here, srv_pipe_hnd.c will take care */
2725 if (DEBUGLEVEL
>= 10) {
2726 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesW
, r
);
2729 push
= ndr_push_init_ctx(r
);
2735 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2736 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2741 blob
= ndr_push_blob(push
);
2742 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2752 static bool api_netr_DsRGetDCNameEx2(pipes_struct
*p
)
2754 const struct ndr_interface_call
*call
;
2755 struct ndr_pull
*pull
;
2756 struct ndr_push
*push
;
2757 enum ndr_err_code ndr_err
;
2759 struct netr_DsRGetDCNameEx2
*r
;
2761 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCNAMEEX2
];
2763 r
= talloc(talloc_tos(), struct netr_DsRGetDCNameEx2
);
2768 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2773 pull
= ndr_pull_init_blob(&blob
, r
);
2779 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2780 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2781 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2786 if (DEBUGLEVEL
>= 10) {
2787 NDR_PRINT_IN_DEBUG(netr_DsRGetDCNameEx2
, r
);
2790 ZERO_STRUCT(r
->out
);
2791 r
->out
.info
= talloc_zero(r
, struct netr_DsRGetDCNameInfo
*);
2792 if (r
->out
.info
== NULL
) {
2797 r
->out
.result
= _netr_DsRGetDCNameEx2(p
, r
);
2799 if (p
->rng_fault_state
) {
2801 /* Return true here, srv_pipe_hnd.c will take care */
2805 if (DEBUGLEVEL
>= 10) {
2806 NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2
, r
);
2809 push
= ndr_push_init_ctx(r
);
2815 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2816 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2821 blob
= ndr_push_blob(push
);
2822 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2832 static bool api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(pipes_struct
*p
)
2834 const struct ndr_interface_call
*call
;
2835 struct ndr_pull
*pull
;
2836 struct ndr_push
*push
;
2837 enum ndr_err_code ndr_err
;
2839 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
*r
;
2841 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
];
2843 r
= talloc(talloc_tos(), struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
);
2848 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2853 pull
= ndr_pull_init_blob(&blob
, r
);
2859 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2860 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2861 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2866 if (DEBUGLEVEL
>= 10) {
2867 NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, r
);
2870 r
->out
.result
= _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(p
, r
);
2872 if (p
->rng_fault_state
) {
2874 /* Return true here, srv_pipe_hnd.c will take care */
2878 if (DEBUGLEVEL
>= 10) {
2879 NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, r
);
2882 push
= ndr_push_init_ctx(r
);
2888 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2889 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2894 blob
= ndr_push_blob(push
);
2895 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2905 static bool api_netr_NetrEnumerateTrustedDomainsEx(pipes_struct
*p
)
2907 const struct ndr_interface_call
*call
;
2908 struct ndr_pull
*pull
;
2909 struct ndr_push
*push
;
2910 enum ndr_err_code ndr_err
;
2912 struct netr_NetrEnumerateTrustedDomainsEx
*r
;
2914 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
];
2916 r
= talloc(talloc_tos(), struct netr_NetrEnumerateTrustedDomainsEx
);
2921 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2926 pull
= ndr_pull_init_blob(&blob
, r
);
2932 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2933 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2934 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2939 if (DEBUGLEVEL
>= 10) {
2940 NDR_PRINT_IN_DEBUG(netr_NetrEnumerateTrustedDomainsEx
, r
);
2943 ZERO_STRUCT(r
->out
);
2944 r
->out
.dom_trust_list
= talloc_zero(r
, struct netr_DomainTrustList
);
2945 if (r
->out
.dom_trust_list
== NULL
) {
2950 r
->out
.result
= _netr_NetrEnumerateTrustedDomainsEx(p
, r
);
2952 if (p
->rng_fault_state
) {
2954 /* Return true here, srv_pipe_hnd.c will take care */
2958 if (DEBUGLEVEL
>= 10) {
2959 NDR_PRINT_OUT_DEBUG(netr_NetrEnumerateTrustedDomainsEx
, r
);
2962 push
= ndr_push_init_ctx(r
);
2968 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2969 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2974 blob
= ndr_push_blob(push
);
2975 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2985 static bool api_netr_DsRAddressToSitenamesExW(pipes_struct
*p
)
2987 const struct ndr_interface_call
*call
;
2988 struct ndr_pull
*pull
;
2989 struct ndr_push
*push
;
2990 enum ndr_err_code ndr_err
;
2992 struct netr_DsRAddressToSitenamesExW
*r
;
2994 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRADDRESSTOSITENAMESEXW
];
2996 r
= talloc(talloc_tos(), struct netr_DsRAddressToSitenamesExW
);
3001 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3006 pull
= ndr_pull_init_blob(&blob
, r
);
3012 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3013 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3014 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3019 if (DEBUGLEVEL
>= 10) {
3020 NDR_PRINT_IN_DEBUG(netr_DsRAddressToSitenamesExW
, r
);
3023 ZERO_STRUCT(r
->out
);
3024 r
->out
.ctr
= talloc_zero(r
, struct netr_DsRAddressToSitenamesExWCtr
*);
3025 if (r
->out
.ctr
== NULL
) {
3030 r
->out
.result
= _netr_DsRAddressToSitenamesExW(p
, r
);
3032 if (p
->rng_fault_state
) {
3034 /* Return true here, srv_pipe_hnd.c will take care */
3038 if (DEBUGLEVEL
>= 10) {
3039 NDR_PRINT_OUT_DEBUG(netr_DsRAddressToSitenamesExW
, r
);
3042 push
= ndr_push_init_ctx(r
);
3048 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3049 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3054 blob
= ndr_push_blob(push
);
3055 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3065 static bool api_netr_DsrGetDcSiteCoverageW(pipes_struct
*p
)
3067 const struct ndr_interface_call
*call
;
3068 struct ndr_pull
*pull
;
3069 struct ndr_push
*push
;
3070 enum ndr_err_code ndr_err
;
3072 struct netr_DsrGetDcSiteCoverageW
*r
;
3074 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETDCSITECOVERAGEW
];
3076 r
= talloc(talloc_tos(), struct netr_DsrGetDcSiteCoverageW
);
3081 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3086 pull
= ndr_pull_init_blob(&blob
, r
);
3092 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3093 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3094 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3099 if (DEBUGLEVEL
>= 10) {
3100 NDR_PRINT_IN_DEBUG(netr_DsrGetDcSiteCoverageW
, r
);
3103 ZERO_STRUCT(r
->out
);
3104 r
->out
.ctr
= talloc_zero(r
, struct DcSitesCtr
);
3105 if (r
->out
.ctr
== NULL
) {
3110 r
->out
.result
= _netr_DsrGetDcSiteCoverageW(p
, r
);
3112 if (p
->rng_fault_state
) {
3114 /* Return true here, srv_pipe_hnd.c will take care */
3118 if (DEBUGLEVEL
>= 10) {
3119 NDR_PRINT_OUT_DEBUG(netr_DsrGetDcSiteCoverageW
, r
);
3122 push
= ndr_push_init_ctx(r
);
3128 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3129 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3134 blob
= ndr_push_blob(push
);
3135 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3145 static bool api_netr_LogonSamLogonEx(pipes_struct
*p
)
3147 const struct ndr_interface_call
*call
;
3148 struct ndr_pull
*pull
;
3149 struct ndr_push
*push
;
3150 enum ndr_err_code ndr_err
;
3152 struct netr_LogonSamLogonEx
*r
;
3154 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGONEX
];
3156 r
= talloc(talloc_tos(), struct netr_LogonSamLogonEx
);
3161 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3166 pull
= ndr_pull_init_blob(&blob
, r
);
3172 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3173 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3174 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3179 if (DEBUGLEVEL
>= 10) {
3180 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonEx
, r
);
3183 ZERO_STRUCT(r
->out
);
3184 r
->out
.validation
= talloc_zero(r
, union netr_Validation
);
3185 if (r
->out
.validation
== NULL
) {
3190 r
->out
.authoritative
= talloc_zero(r
, uint8_t);
3191 if (r
->out
.authoritative
== NULL
) {
3196 r
->out
.flags
= r
->in
.flags
;
3197 r
->out
.result
= _netr_LogonSamLogonEx(p
, r
);
3199 if (p
->rng_fault_state
) {
3201 /* Return true here, srv_pipe_hnd.c will take care */
3205 if (DEBUGLEVEL
>= 10) {
3206 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx
, r
);
3209 push
= ndr_push_init_ctx(r
);
3215 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3216 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3221 blob
= ndr_push_blob(push
);
3222 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3232 static bool api_netr_DsrEnumerateDomainTrusts(pipes_struct
*p
)
3234 const struct ndr_interface_call
*call
;
3235 struct ndr_pull
*pull
;
3236 struct ndr_push
*push
;
3237 enum ndr_err_code ndr_err
;
3239 struct netr_DsrEnumerateDomainTrusts
*r
;
3241 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRENUMERATEDOMAINTRUSTS
];
3243 r
= talloc(talloc_tos(), struct netr_DsrEnumerateDomainTrusts
);
3248 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3253 pull
= ndr_pull_init_blob(&blob
, r
);
3259 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3260 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3261 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3266 if (DEBUGLEVEL
>= 10) {
3267 NDR_PRINT_IN_DEBUG(netr_DsrEnumerateDomainTrusts
, r
);
3270 ZERO_STRUCT(r
->out
);
3271 r
->out
.trusts
= talloc_zero(r
, struct netr_DomainTrustList
);
3272 if (r
->out
.trusts
== NULL
) {
3277 r
->out
.result
= _netr_DsrEnumerateDomainTrusts(p
, r
);
3279 if (p
->rng_fault_state
) {
3281 /* Return true here, srv_pipe_hnd.c will take care */
3285 if (DEBUGLEVEL
>= 10) {
3286 NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts
, r
);
3289 push
= ndr_push_init_ctx(r
);
3295 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3296 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3301 blob
= ndr_push_blob(push
);
3302 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3312 static bool api_netr_DsrDeregisterDNSHostRecords(pipes_struct
*p
)
3314 const struct ndr_interface_call
*call
;
3315 struct ndr_pull
*pull
;
3316 struct ndr_push
*push
;
3317 enum ndr_err_code ndr_err
;
3319 struct netr_DsrDeregisterDNSHostRecords
*r
;
3321 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
];
3323 r
= talloc(talloc_tos(), struct netr_DsrDeregisterDNSHostRecords
);
3328 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3333 pull
= ndr_pull_init_blob(&blob
, r
);
3339 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3340 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3341 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3346 if (DEBUGLEVEL
>= 10) {
3347 NDR_PRINT_IN_DEBUG(netr_DsrDeregisterDNSHostRecords
, r
);
3350 r
->out
.result
= _netr_DsrDeregisterDNSHostRecords(p
, r
);
3352 if (p
->rng_fault_state
) {
3354 /* Return true here, srv_pipe_hnd.c will take care */
3358 if (DEBUGLEVEL
>= 10) {
3359 NDR_PRINT_OUT_DEBUG(netr_DsrDeregisterDNSHostRecords
, r
);
3362 push
= ndr_push_init_ctx(r
);
3368 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3369 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3374 blob
= ndr_push_blob(push
);
3375 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3385 static bool api_netr_ServerTrustPasswordsGet(pipes_struct
*p
)
3387 const struct ndr_interface_call
*call
;
3388 struct ndr_pull
*pull
;
3389 struct ndr_push
*push
;
3390 enum ndr_err_code ndr_err
;
3392 struct netr_ServerTrustPasswordsGet
*r
;
3394 call
= &ndr_table_netlogon
.calls
[NDR_NETR_SERVERTRUSTPASSWORDSGET
];
3396 r
= talloc(talloc_tos(), struct netr_ServerTrustPasswordsGet
);
3401 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3406 pull
= ndr_pull_init_blob(&blob
, r
);
3412 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3413 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3414 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3419 if (DEBUGLEVEL
>= 10) {
3420 NDR_PRINT_IN_DEBUG(netr_ServerTrustPasswordsGet
, r
);
3423 ZERO_STRUCT(r
->out
);
3424 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
3425 if (r
->out
.return_authenticator
== NULL
) {
3430 r
->out
.password
= talloc_zero(r
, struct samr_Password
);
3431 if (r
->out
.password
== NULL
) {
3436 r
->out
.password2
= talloc_zero(r
, struct samr_Password
);
3437 if (r
->out
.password2
== NULL
) {
3442 r
->out
.result
= _netr_ServerTrustPasswordsGet(p
, r
);
3444 if (p
->rng_fault_state
) {
3446 /* Return true here, srv_pipe_hnd.c will take care */
3450 if (DEBUGLEVEL
>= 10) {
3451 NDR_PRINT_OUT_DEBUG(netr_ServerTrustPasswordsGet
, r
);
3454 push
= ndr_push_init_ctx(r
);
3460 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3466 blob
= ndr_push_blob(push
);
3467 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3477 static bool api_netr_DsRGetForestTrustInformation(pipes_struct
*p
)
3479 const struct ndr_interface_call
*call
;
3480 struct ndr_pull
*pull
;
3481 struct ndr_push
*push
;
3482 enum ndr_err_code ndr_err
;
3484 struct netr_DsRGetForestTrustInformation
*r
;
3486 call
= &ndr_table_netlogon
.calls
[NDR_NETR_DSRGETFORESTTRUSTINFORMATION
];
3488 r
= talloc(talloc_tos(), struct netr_DsRGetForestTrustInformation
);
3493 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3498 pull
= ndr_pull_init_blob(&blob
, r
);
3504 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3505 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3506 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3511 if (DEBUGLEVEL
>= 10) {
3512 NDR_PRINT_IN_DEBUG(netr_DsRGetForestTrustInformation
, r
);
3515 ZERO_STRUCT(r
->out
);
3516 r
->out
.forest_trust_info
= talloc_zero(r
, struct lsa_ForestTrustInformation
*);
3517 if (r
->out
.forest_trust_info
== NULL
) {
3522 r
->out
.result
= _netr_DsRGetForestTrustInformation(p
, r
);
3524 if (p
->rng_fault_state
) {
3526 /* Return true here, srv_pipe_hnd.c will take care */
3530 if (DEBUGLEVEL
>= 10) {
3531 NDR_PRINT_OUT_DEBUG(netr_DsRGetForestTrustInformation
, r
);
3534 push
= ndr_push_init_ctx(r
);
3540 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3541 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3546 blob
= ndr_push_blob(push
);
3547 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3557 static bool api_netr_GetForestTrustInformation(pipes_struct
*p
)
3559 const struct ndr_interface_call
*call
;
3560 struct ndr_pull
*pull
;
3561 struct ndr_push
*push
;
3562 enum ndr_err_code ndr_err
;
3564 struct netr_GetForestTrustInformation
*r
;
3566 call
= &ndr_table_netlogon
.calls
[NDR_NETR_GETFORESTTRUSTINFORMATION
];
3568 r
= talloc(talloc_tos(), struct netr_GetForestTrustInformation
);
3573 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3578 pull
= ndr_pull_init_blob(&blob
, r
);
3584 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3585 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3586 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3591 if (DEBUGLEVEL
>= 10) {
3592 NDR_PRINT_IN_DEBUG(netr_GetForestTrustInformation
, r
);
3595 ZERO_STRUCT(r
->out
);
3596 r
->out
.return_authenticator
= talloc_zero(r
, struct netr_Authenticator
);
3597 if (r
->out
.return_authenticator
== NULL
) {
3602 r
->out
.forest_trust_info
= talloc_zero(r
, struct lsa_ForestTrustInformation
*);
3603 if (r
->out
.forest_trust_info
== NULL
) {
3608 r
->out
.result
= _netr_GetForestTrustInformation(p
, r
);
3610 if (p
->rng_fault_state
) {
3612 /* Return true here, srv_pipe_hnd.c will take care */
3616 if (DEBUGLEVEL
>= 10) {
3617 NDR_PRINT_OUT_DEBUG(netr_GetForestTrustInformation
, r
);
3620 push
= ndr_push_init_ctx(r
);
3626 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3627 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3632 blob
= ndr_push_blob(push
);
3633 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3643 static bool api_netr_LogonSamLogonWithFlags(pipes_struct
*p
)
3645 const struct ndr_interface_call
*call
;
3646 struct ndr_pull
*pull
;
3647 struct ndr_push
*push
;
3648 enum ndr_err_code ndr_err
;
3650 struct netr_LogonSamLogonWithFlags
*r
;
3652 call
= &ndr_table_netlogon
.calls
[NDR_NETR_LOGONSAMLOGONWITHFLAGS
];
3654 r
= talloc(talloc_tos(), struct netr_LogonSamLogonWithFlags
);
3659 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3664 pull
= ndr_pull_init_blob(&blob
, r
);
3670 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3671 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3672 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3677 if (DEBUGLEVEL
>= 10) {
3678 NDR_PRINT_IN_DEBUG(netr_LogonSamLogonWithFlags
, r
);
3681 ZERO_STRUCT(r
->out
);
3682 r
->out
.return_authenticator
= r
->in
.return_authenticator
;
3683 r
->out
.validation
= talloc_zero(r
, union netr_Validation
);
3684 if (r
->out
.validation
== NULL
) {
3689 r
->out
.authoritative
= talloc_zero(r
, uint8_t);
3690 if (r
->out
.authoritative
== NULL
) {
3695 r
->out
.flags
= r
->in
.flags
;
3696 r
->out
.result
= _netr_LogonSamLogonWithFlags(p
, r
);
3698 if (p
->rng_fault_state
) {
3700 /* Return true here, srv_pipe_hnd.c will take care */
3704 if (DEBUGLEVEL
>= 10) {
3705 NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags
, r
);
3708 push
= ndr_push_init_ctx(r
);
3714 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3715 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3720 blob
= ndr_push_blob(push
);
3721 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3731 static bool api_netr_NETRSERVERGETTRUSTINFO(pipes_struct
*p
)
3733 const struct ndr_interface_call
*call
;
3734 struct ndr_pull
*pull
;
3735 struct ndr_push
*push
;
3736 enum ndr_err_code ndr_err
;
3738 struct netr_NETRSERVERGETTRUSTINFO
*r
;
3740 call
= &ndr_table_netlogon
.calls
[NDR_NETR_NETRSERVERGETTRUSTINFO
];
3742 r
= talloc(talloc_tos(), struct netr_NETRSERVERGETTRUSTINFO
);
3747 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3752 pull
= ndr_pull_init_blob(&blob
, r
);
3758 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3759 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3760 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3765 if (DEBUGLEVEL
>= 10) {
3766 NDR_PRINT_IN_DEBUG(netr_NETRSERVERGETTRUSTINFO
, r
);
3769 r
->out
.result
= _netr_NETRSERVERGETTRUSTINFO(p
, r
);
3771 if (p
->rng_fault_state
) {
3773 /* Return true here, srv_pipe_hnd.c will take care */
3777 if (DEBUGLEVEL
>= 10) {
3778 NDR_PRINT_OUT_DEBUG(netr_NETRSERVERGETTRUSTINFO
, r
);
3781 push
= ndr_push_init_ctx(r
);
3787 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3788 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3793 blob
= ndr_push_blob(push
);
3794 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3806 static struct api_struct api_netlogon_cmds
[] =
3808 {"NETR_LOGONUASLOGON", NDR_NETR_LOGONUASLOGON
, api_netr_LogonUasLogon
},
3809 {"NETR_LOGONUASLOGOFF", NDR_NETR_LOGONUASLOGOFF
, api_netr_LogonUasLogoff
},
3810 {"NETR_LOGONSAMLOGON", NDR_NETR_LOGONSAMLOGON
, api_netr_LogonSamLogon
},
3811 {"NETR_LOGONSAMLOGOFF", NDR_NETR_LOGONSAMLOGOFF
, api_netr_LogonSamLogoff
},
3812 {"NETR_SERVERREQCHALLENGE", NDR_NETR_SERVERREQCHALLENGE
, api_netr_ServerReqChallenge
},
3813 {"NETR_SERVERAUTHENTICATE", NDR_NETR_SERVERAUTHENTICATE
, api_netr_ServerAuthenticate
},
3814 {"NETR_SERVERPASSWORDSET", NDR_NETR_SERVERPASSWORDSET
, api_netr_ServerPasswordSet
},
3815 {"NETR_DATABASEDELTAS", NDR_NETR_DATABASEDELTAS
, api_netr_DatabaseDeltas
},
3816 {"NETR_DATABASESYNC", NDR_NETR_DATABASESYNC
, api_netr_DatabaseSync
},
3817 {"NETR_ACCOUNTDELTAS", NDR_NETR_ACCOUNTDELTAS
, api_netr_AccountDeltas
},
3818 {"NETR_ACCOUNTSYNC", NDR_NETR_ACCOUNTSYNC
, api_netr_AccountSync
},
3819 {"NETR_GETDCNAME", NDR_NETR_GETDCNAME
, api_netr_GetDcName
},
3820 {"NETR_LOGONCONTROL", NDR_NETR_LOGONCONTROL
, api_netr_LogonControl
},
3821 {"NETR_GETANYDCNAME", NDR_NETR_GETANYDCNAME
, api_netr_GetAnyDCName
},
3822 {"NETR_LOGONCONTROL2", NDR_NETR_LOGONCONTROL2
, api_netr_LogonControl2
},
3823 {"NETR_SERVERAUTHENTICATE2", NDR_NETR_SERVERAUTHENTICATE2
, api_netr_ServerAuthenticate2
},
3824 {"NETR_DATABASESYNC2", NDR_NETR_DATABASESYNC2
, api_netr_DatabaseSync2
},
3825 {"NETR_DATABASEREDO", NDR_NETR_DATABASEREDO
, api_netr_DatabaseRedo
},
3826 {"NETR_LOGONCONTROL2EX", NDR_NETR_LOGONCONTROL2EX
, api_netr_LogonControl2Ex
},
3827 {"NETR_NETRENUMERATETRUSTEDDOMAINS", NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
, api_netr_NetrEnumerateTrustedDomains
},
3828 {"NETR_DSRGETDCNAME", NDR_NETR_DSRGETDCNAME
, api_netr_DsRGetDCName
},
3829 {"NETR_NETRLOGONDUMMYROUTINE1", NDR_NETR_NETRLOGONDUMMYROUTINE1
, api_netr_NETRLOGONDUMMYROUTINE1
},
3830 {"NETR_NETRLOGONSETSERVICEBITS", NDR_NETR_NETRLOGONSETSERVICEBITS
, api_netr_NETRLOGONSETSERVICEBITS
},
3831 {"NETR_LOGONGETTRUSTRID", NDR_NETR_LOGONGETTRUSTRID
, api_netr_LogonGetTrustRid
},
3832 {"NETR_NETRLOGONCOMPUTESERVERDIGEST", NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
, api_netr_NETRLOGONCOMPUTESERVERDIGEST
},
3833 {"NETR_NETRLOGONCOMPUTECLIENTDIGEST", NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
, api_netr_NETRLOGONCOMPUTECLIENTDIGEST
},
3834 {"NETR_SERVERAUTHENTICATE3", NDR_NETR_SERVERAUTHENTICATE3
, api_netr_ServerAuthenticate3
},
3835 {"NETR_DSRGETDCNAMEEX", NDR_NETR_DSRGETDCNAMEEX
, api_netr_DsRGetDCNameEx
},
3836 {"NETR_DSRGETSITENAME", NDR_NETR_DSRGETSITENAME
, api_netr_DsRGetSiteName
},
3837 {"NETR_LOGONGETDOMAININFO", NDR_NETR_LOGONGETDOMAININFO
, api_netr_LogonGetDomainInfo
},
3838 {"NETR_SERVERPASSWORDSET2", NDR_NETR_SERVERPASSWORDSET2
, api_netr_ServerPasswordSet2
},
3839 {"NETR_SERVERPASSWORDGET", NDR_NETR_SERVERPASSWORDGET
, api_netr_ServerPasswordGet
},
3840 {"NETR_NETRLOGONSENDTOSAM", NDR_NETR_NETRLOGONSENDTOSAM
, api_netr_NETRLOGONSENDTOSAM
},
3841 {"NETR_DSRADDRESSTOSITENAMESW", NDR_NETR_DSRADDRESSTOSITENAMESW
, api_netr_DsRAddressToSitenamesW
},
3842 {"NETR_DSRGETDCNAMEEX2", NDR_NETR_DSRGETDCNAMEEX2
, api_netr_DsRGetDCNameEx2
},
3843 {"NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN", NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
, api_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN
},
3844 {"NETR_NETRENUMERATETRUSTEDDOMAINSEX", NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
, api_netr_NetrEnumerateTrustedDomainsEx
},
3845 {"NETR_DSRADDRESSTOSITENAMESEXW", NDR_NETR_DSRADDRESSTOSITENAMESEXW
, api_netr_DsRAddressToSitenamesExW
},
3846 {"NETR_DSRGETDCSITECOVERAGEW", NDR_NETR_DSRGETDCSITECOVERAGEW
, api_netr_DsrGetDcSiteCoverageW
},
3847 {"NETR_LOGONSAMLOGONEX", NDR_NETR_LOGONSAMLOGONEX
, api_netr_LogonSamLogonEx
},
3848 {"NETR_DSRENUMERATEDOMAINTRUSTS", NDR_NETR_DSRENUMERATEDOMAINTRUSTS
, api_netr_DsrEnumerateDomainTrusts
},
3849 {"NETR_DSRDEREGISTERDNSHOSTRECORDS", NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
, api_netr_DsrDeregisterDNSHostRecords
},
3850 {"NETR_SERVERTRUSTPASSWORDSGET", NDR_NETR_SERVERTRUSTPASSWORDSGET
, api_netr_ServerTrustPasswordsGet
},
3851 {"NETR_DSRGETFORESTTRUSTINFORMATION", NDR_NETR_DSRGETFORESTTRUSTINFORMATION
, api_netr_DsRGetForestTrustInformation
},
3852 {"NETR_GETFORESTTRUSTINFORMATION", NDR_NETR_GETFORESTTRUSTINFORMATION
, api_netr_GetForestTrustInformation
},
3853 {"NETR_LOGONSAMLOGONWITHFLAGS", NDR_NETR_LOGONSAMLOGONWITHFLAGS
, api_netr_LogonSamLogonWithFlags
},
3854 {"NETR_NETRSERVERGETTRUSTINFO", NDR_NETR_NETRSERVERGETTRUSTINFO
, api_netr_NETRSERVERGETTRUSTINFO
},
3857 void netlogon_get_pipe_fns(struct api_struct
**fns
, int *n_fns
)
3859 *fns
= api_netlogon_cmds
;
3860 *n_fns
= sizeof(api_netlogon_cmds
) / sizeof(struct api_struct
);
3863 NTSTATUS
rpc_netlogon_init(void)
3865 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION
, "netlogon", "netlogon", api_netlogon_cmds
, sizeof(api_netlogon_cmds
) / sizeof(struct api_struct
));