2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/cli_netlogon.h"
9 struct rpccli_netr_LogonUasLogon_state
{
10 struct netr_LogonUasLogon orig
;
11 struct netr_LogonUasLogon tmp
;
12 TALLOC_CTX
*out_mem_ctx
;
13 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
16 static void rpccli_netr_LogonUasLogon_done(struct tevent_req
*subreq
);
18 struct tevent_req
*rpccli_netr_LogonUasLogon_send(TALLOC_CTX
*mem_ctx
,
19 struct tevent_context
*ev
,
20 struct rpc_pipe_client
*cli
,
21 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
22 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
23 const char *_workstation
/* [in] [ref,charset(UTF16)] */,
24 struct netr_UasInfo
**_info
/* [out] [ref] */)
26 struct tevent_req
*req
;
27 struct rpccli_netr_LogonUasLogon_state
*state
;
28 struct tevent_req
*subreq
;
30 req
= tevent_req_create(mem_ctx
, &state
,
31 struct rpccli_netr_LogonUasLogon_state
);
35 state
->out_mem_ctx
= NULL
;
36 state
->dispatch_recv
= cli
->dispatch_recv
;
39 state
->orig
.in
.server_name
= _server_name
;
40 state
->orig
.in
.account_name
= _account_name
;
41 state
->orig
.in
.workstation
= _workstation
;
44 state
->orig
.out
.info
= _info
;
47 ZERO_STRUCT(state
->orig
.out
.result
);
49 state
->out_mem_ctx
= talloc_named_const(state
, 0,
50 "rpccli_netr_LogonUasLogon_out_memory");
51 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
52 return tevent_req_post(req
, ev
);
55 /* make a temporary copy, that we pass to the dispatch function */
56 state
->tmp
= state
->orig
;
58 subreq
= cli
->dispatch_send(state
, ev
, cli
,
60 NDR_NETR_LOGONUASLOGON
,
62 if (tevent_req_nomem(subreq
, req
)) {
63 return tevent_req_post(req
, ev
);
65 tevent_req_set_callback(subreq
, rpccli_netr_LogonUasLogon_done
, req
);
69 static void rpccli_netr_LogonUasLogon_done(struct tevent_req
*subreq
)
71 struct tevent_req
*req
= tevent_req_callback_data(
72 subreq
, struct tevent_req
);
73 struct rpccli_netr_LogonUasLogon_state
*state
= tevent_req_data(
74 req
, struct rpccli_netr_LogonUasLogon_state
);
78 if (state
->out_mem_ctx
) {
79 mem_ctx
= state
->out_mem_ctx
;
84 status
= state
->dispatch_recv(subreq
, mem_ctx
);
86 if (!NT_STATUS_IS_OK(status
)) {
87 tevent_req_nterror(req
, status
);
91 /* Copy out parameters */
92 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
95 state
->orig
.out
.result
= state
->tmp
.out
.result
;
97 /* Reset temporary structure */
98 ZERO_STRUCT(state
->tmp
);
100 tevent_req_done(req
);
103 NTSTATUS
rpccli_netr_LogonUasLogon_recv(struct tevent_req
*req
,
107 struct rpccli_netr_LogonUasLogon_state
*state
= tevent_req_data(
108 req
, struct rpccli_netr_LogonUasLogon_state
);
111 if (tevent_req_is_nterror(req
, &status
)) {
112 tevent_req_received(req
);
116 /* Steal possbile out parameters to the callers context */
117 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
120 *result
= state
->orig
.out
.result
;
122 tevent_req_received(req
);
126 NTSTATUS
rpccli_netr_LogonUasLogon(struct rpc_pipe_client
*cli
,
128 const char *server_name
/* [in] [unique,charset(UTF16)] */,
129 const char *account_name
/* [in] [ref,charset(UTF16)] */,
130 const char *workstation
/* [in] [ref,charset(UTF16)] */,
131 struct netr_UasInfo
**info
/* [out] [ref] */,
134 struct netr_LogonUasLogon r
;
138 r
.in
.server_name
= server_name
;
139 r
.in
.account_name
= account_name
;
140 r
.in
.workstation
= workstation
;
142 status
= cli
->dispatch(cli
,
145 NDR_NETR_LOGONUASLOGON
,
148 if (!NT_STATUS_IS_OK(status
)) {
152 if (NT_STATUS_IS_ERR(status
)) {
156 /* Return variables */
161 *werror
= r
.out
.result
;
164 return werror_to_ntstatus(r
.out
.result
);
167 struct rpccli_netr_LogonUasLogoff_state
{
168 struct netr_LogonUasLogoff orig
;
169 struct netr_LogonUasLogoff tmp
;
170 TALLOC_CTX
*out_mem_ctx
;
171 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
174 static void rpccli_netr_LogonUasLogoff_done(struct tevent_req
*subreq
);
176 struct tevent_req
*rpccli_netr_LogonUasLogoff_send(TALLOC_CTX
*mem_ctx
,
177 struct tevent_context
*ev
,
178 struct rpc_pipe_client
*cli
,
179 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
180 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
181 const char *_workstation
/* [in] [ref,charset(UTF16)] */,
182 struct netr_UasLogoffInfo
*_info
/* [out] [ref] */)
184 struct tevent_req
*req
;
185 struct rpccli_netr_LogonUasLogoff_state
*state
;
186 struct tevent_req
*subreq
;
188 req
= tevent_req_create(mem_ctx
, &state
,
189 struct rpccli_netr_LogonUasLogoff_state
);
193 state
->out_mem_ctx
= NULL
;
194 state
->dispatch_recv
= cli
->dispatch_recv
;
197 state
->orig
.in
.server_name
= _server_name
;
198 state
->orig
.in
.account_name
= _account_name
;
199 state
->orig
.in
.workstation
= _workstation
;
202 state
->orig
.out
.info
= _info
;
205 ZERO_STRUCT(state
->orig
.out
.result
);
207 state
->out_mem_ctx
= talloc_named_const(state
, 0,
208 "rpccli_netr_LogonUasLogoff_out_memory");
209 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
210 return tevent_req_post(req
, ev
);
213 /* make a temporary copy, that we pass to the dispatch function */
214 state
->tmp
= state
->orig
;
216 subreq
= cli
->dispatch_send(state
, ev
, cli
,
218 NDR_NETR_LOGONUASLOGOFF
,
220 if (tevent_req_nomem(subreq
, req
)) {
221 return tevent_req_post(req
, ev
);
223 tevent_req_set_callback(subreq
, rpccli_netr_LogonUasLogoff_done
, req
);
227 static void rpccli_netr_LogonUasLogoff_done(struct tevent_req
*subreq
)
229 struct tevent_req
*req
= tevent_req_callback_data(
230 subreq
, struct tevent_req
);
231 struct rpccli_netr_LogonUasLogoff_state
*state
= tevent_req_data(
232 req
, struct rpccli_netr_LogonUasLogoff_state
);
236 if (state
->out_mem_ctx
) {
237 mem_ctx
= state
->out_mem_ctx
;
242 status
= state
->dispatch_recv(subreq
, mem_ctx
);
244 if (!NT_STATUS_IS_OK(status
)) {
245 tevent_req_nterror(req
, status
);
249 /* Copy out parameters */
250 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
253 state
->orig
.out
.result
= state
->tmp
.out
.result
;
255 /* Reset temporary structure */
256 ZERO_STRUCT(state
->tmp
);
258 tevent_req_done(req
);
261 NTSTATUS
rpccli_netr_LogonUasLogoff_recv(struct tevent_req
*req
,
265 struct rpccli_netr_LogonUasLogoff_state
*state
= tevent_req_data(
266 req
, struct rpccli_netr_LogonUasLogoff_state
);
269 if (tevent_req_is_nterror(req
, &status
)) {
270 tevent_req_received(req
);
274 /* Steal possbile out parameters to the callers context */
275 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
278 *result
= state
->orig
.out
.result
;
280 tevent_req_received(req
);
284 NTSTATUS
rpccli_netr_LogonUasLogoff(struct rpc_pipe_client
*cli
,
286 const char *server_name
/* [in] [unique,charset(UTF16)] */,
287 const char *account_name
/* [in] [ref,charset(UTF16)] */,
288 const char *workstation
/* [in] [ref,charset(UTF16)] */,
289 struct netr_UasLogoffInfo
*info
/* [out] [ref] */,
292 struct netr_LogonUasLogoff r
;
296 r
.in
.server_name
= server_name
;
297 r
.in
.account_name
= account_name
;
298 r
.in
.workstation
= workstation
;
300 status
= cli
->dispatch(cli
,
303 NDR_NETR_LOGONUASLOGOFF
,
306 if (!NT_STATUS_IS_OK(status
)) {
310 if (NT_STATUS_IS_ERR(status
)) {
314 /* Return variables */
319 *werror
= r
.out
.result
;
322 return werror_to_ntstatus(r
.out
.result
);
325 struct rpccli_netr_LogonSamLogon_state
{
326 struct netr_LogonSamLogon orig
;
327 struct netr_LogonSamLogon tmp
;
328 TALLOC_CTX
*out_mem_ctx
;
329 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
332 static void rpccli_netr_LogonSamLogon_done(struct tevent_req
*subreq
);
334 struct tevent_req
*rpccli_netr_LogonSamLogon_send(TALLOC_CTX
*mem_ctx
,
335 struct tevent_context
*ev
,
336 struct rpc_pipe_client
*cli
,
337 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
338 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
339 struct netr_Authenticator
*_credential
/* [in] [unique] */,
340 struct netr_Authenticator
*_return_authenticator
/* [in,out] [unique] */,
341 enum netr_LogonInfoClass _logon_level
/* [in] */,
342 union netr_LogonLevel
*_logon
/* [in] [ref,switch_is(logon_level)] */,
343 uint16_t _validation_level
/* [in] */,
344 union netr_Validation
*_validation
/* [out] [ref,switch_is(validation_level)] */,
345 uint8_t *_authoritative
/* [out] [ref] */)
347 struct tevent_req
*req
;
348 struct rpccli_netr_LogonSamLogon_state
*state
;
349 struct tevent_req
*subreq
;
351 req
= tevent_req_create(mem_ctx
, &state
,
352 struct rpccli_netr_LogonSamLogon_state
);
356 state
->out_mem_ctx
= NULL
;
357 state
->dispatch_recv
= cli
->dispatch_recv
;
360 state
->orig
.in
.server_name
= _server_name
;
361 state
->orig
.in
.computer_name
= _computer_name
;
362 state
->orig
.in
.credential
= _credential
;
363 state
->orig
.in
.return_authenticator
= _return_authenticator
;
364 state
->orig
.in
.logon_level
= _logon_level
;
365 state
->orig
.in
.logon
= _logon
;
366 state
->orig
.in
.validation_level
= _validation_level
;
369 state
->orig
.out
.return_authenticator
= _return_authenticator
;
370 state
->orig
.out
.validation
= _validation
;
371 state
->orig
.out
.authoritative
= _authoritative
;
374 ZERO_STRUCT(state
->orig
.out
.result
);
376 state
->out_mem_ctx
= talloc_named_const(state
, 0,
377 "rpccli_netr_LogonSamLogon_out_memory");
378 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
379 return tevent_req_post(req
, ev
);
382 /* make a temporary copy, that we pass to the dispatch function */
383 state
->tmp
= state
->orig
;
385 subreq
= cli
->dispatch_send(state
, ev
, cli
,
387 NDR_NETR_LOGONSAMLOGON
,
389 if (tevent_req_nomem(subreq
, req
)) {
390 return tevent_req_post(req
, ev
);
392 tevent_req_set_callback(subreq
, rpccli_netr_LogonSamLogon_done
, req
);
396 static void rpccli_netr_LogonSamLogon_done(struct tevent_req
*subreq
)
398 struct tevent_req
*req
= tevent_req_callback_data(
399 subreq
, struct tevent_req
);
400 struct rpccli_netr_LogonSamLogon_state
*state
= tevent_req_data(
401 req
, struct rpccli_netr_LogonSamLogon_state
);
405 if (state
->out_mem_ctx
) {
406 mem_ctx
= state
->out_mem_ctx
;
411 status
= state
->dispatch_recv(subreq
, mem_ctx
);
413 if (!NT_STATUS_IS_OK(status
)) {
414 tevent_req_nterror(req
, status
);
418 /* Copy out parameters */
419 if (state
->orig
.out
.return_authenticator
&& state
->tmp
.out
.return_authenticator
) {
420 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
422 *state
->orig
.out
.validation
= *state
->tmp
.out
.validation
;
423 *state
->orig
.out
.authoritative
= *state
->tmp
.out
.authoritative
;
426 state
->orig
.out
.result
= state
->tmp
.out
.result
;
428 /* Reset temporary structure */
429 ZERO_STRUCT(state
->tmp
);
431 tevent_req_done(req
);
434 NTSTATUS
rpccli_netr_LogonSamLogon_recv(struct tevent_req
*req
,
438 struct rpccli_netr_LogonSamLogon_state
*state
= tevent_req_data(
439 req
, struct rpccli_netr_LogonSamLogon_state
);
442 if (tevent_req_is_nterror(req
, &status
)) {
443 tevent_req_received(req
);
447 /* Steal possbile out parameters to the callers context */
448 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
451 *result
= state
->orig
.out
.result
;
453 tevent_req_received(req
);
457 NTSTATUS
rpccli_netr_LogonSamLogon(struct rpc_pipe_client
*cli
,
459 const char *server_name
/* [in] [unique,charset(UTF16)] */,
460 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
461 struct netr_Authenticator
*credential
/* [in] [unique] */,
462 struct netr_Authenticator
*return_authenticator
/* [in,out] [unique] */,
463 enum netr_LogonInfoClass logon_level
/* [in] */,
464 union netr_LogonLevel
*logon
/* [in] [ref,switch_is(logon_level)] */,
465 uint16_t validation_level
/* [in] */,
466 union netr_Validation
*validation
/* [out] [ref,switch_is(validation_level)] */,
467 uint8_t *authoritative
/* [out] [ref] */)
469 struct netr_LogonSamLogon r
;
473 r
.in
.server_name
= server_name
;
474 r
.in
.computer_name
= computer_name
;
475 r
.in
.credential
= credential
;
476 r
.in
.return_authenticator
= return_authenticator
;
477 r
.in
.logon_level
= logon_level
;
479 r
.in
.validation_level
= validation_level
;
481 status
= cli
->dispatch(cli
,
484 NDR_NETR_LOGONSAMLOGON
,
487 if (!NT_STATUS_IS_OK(status
)) {
491 if (NT_STATUS_IS_ERR(status
)) {
495 /* Return variables */
496 if (return_authenticator
&& r
.out
.return_authenticator
) {
497 *return_authenticator
= *r
.out
.return_authenticator
;
499 *validation
= *r
.out
.validation
;
500 *authoritative
= *r
.out
.authoritative
;
506 struct rpccli_netr_LogonSamLogoff_state
{
507 struct netr_LogonSamLogoff orig
;
508 struct netr_LogonSamLogoff tmp
;
509 TALLOC_CTX
*out_mem_ctx
;
510 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
513 static void rpccli_netr_LogonSamLogoff_done(struct tevent_req
*subreq
);
515 struct tevent_req
*rpccli_netr_LogonSamLogoff_send(TALLOC_CTX
*mem_ctx
,
516 struct tevent_context
*ev
,
517 struct rpc_pipe_client
*cli
,
518 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
519 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
520 struct netr_Authenticator
*_credential
/* [in] [unique] */,
521 struct netr_Authenticator
*_return_authenticator
/* [in,out] [unique] */,
522 enum netr_LogonInfoClass _logon_level
/* [in] */,
523 union netr_LogonLevel _logon
/* [in] [switch_is(logon_level)] */)
525 struct tevent_req
*req
;
526 struct rpccli_netr_LogonSamLogoff_state
*state
;
527 struct tevent_req
*subreq
;
529 req
= tevent_req_create(mem_ctx
, &state
,
530 struct rpccli_netr_LogonSamLogoff_state
);
534 state
->out_mem_ctx
= NULL
;
535 state
->dispatch_recv
= cli
->dispatch_recv
;
538 state
->orig
.in
.server_name
= _server_name
;
539 state
->orig
.in
.computer_name
= _computer_name
;
540 state
->orig
.in
.credential
= _credential
;
541 state
->orig
.in
.return_authenticator
= _return_authenticator
;
542 state
->orig
.in
.logon_level
= _logon_level
;
543 state
->orig
.in
.logon
= _logon
;
546 state
->orig
.out
.return_authenticator
= _return_authenticator
;
549 ZERO_STRUCT(state
->orig
.out
.result
);
551 state
->out_mem_ctx
= talloc_named_const(state
, 0,
552 "rpccli_netr_LogonSamLogoff_out_memory");
553 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
554 return tevent_req_post(req
, ev
);
557 /* make a temporary copy, that we pass to the dispatch function */
558 state
->tmp
= state
->orig
;
560 subreq
= cli
->dispatch_send(state
, ev
, cli
,
562 NDR_NETR_LOGONSAMLOGOFF
,
564 if (tevent_req_nomem(subreq
, req
)) {
565 return tevent_req_post(req
, ev
);
567 tevent_req_set_callback(subreq
, rpccli_netr_LogonSamLogoff_done
, req
);
571 static void rpccli_netr_LogonSamLogoff_done(struct tevent_req
*subreq
)
573 struct tevent_req
*req
= tevent_req_callback_data(
574 subreq
, struct tevent_req
);
575 struct rpccli_netr_LogonSamLogoff_state
*state
= tevent_req_data(
576 req
, struct rpccli_netr_LogonSamLogoff_state
);
580 if (state
->out_mem_ctx
) {
581 mem_ctx
= state
->out_mem_ctx
;
586 status
= state
->dispatch_recv(subreq
, mem_ctx
);
588 if (!NT_STATUS_IS_OK(status
)) {
589 tevent_req_nterror(req
, status
);
593 /* Copy out parameters */
594 if (state
->orig
.out
.return_authenticator
&& state
->tmp
.out
.return_authenticator
) {
595 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
599 state
->orig
.out
.result
= state
->tmp
.out
.result
;
601 /* Reset temporary structure */
602 ZERO_STRUCT(state
->tmp
);
604 tevent_req_done(req
);
607 NTSTATUS
rpccli_netr_LogonSamLogoff_recv(struct tevent_req
*req
,
611 struct rpccli_netr_LogonSamLogoff_state
*state
= tevent_req_data(
612 req
, struct rpccli_netr_LogonSamLogoff_state
);
615 if (tevent_req_is_nterror(req
, &status
)) {
616 tevent_req_received(req
);
620 /* Steal possbile out parameters to the callers context */
621 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
624 *result
= state
->orig
.out
.result
;
626 tevent_req_received(req
);
630 NTSTATUS
rpccli_netr_LogonSamLogoff(struct rpc_pipe_client
*cli
,
632 const char *server_name
/* [in] [unique,charset(UTF16)] */,
633 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
634 struct netr_Authenticator
*credential
/* [in] [unique] */,
635 struct netr_Authenticator
*return_authenticator
/* [in,out] [unique] */,
636 enum netr_LogonInfoClass logon_level
/* [in] */,
637 union netr_LogonLevel logon
/* [in] [switch_is(logon_level)] */)
639 struct netr_LogonSamLogoff r
;
643 r
.in
.server_name
= server_name
;
644 r
.in
.computer_name
= computer_name
;
645 r
.in
.credential
= credential
;
646 r
.in
.return_authenticator
= return_authenticator
;
647 r
.in
.logon_level
= logon_level
;
650 status
= cli
->dispatch(cli
,
653 NDR_NETR_LOGONSAMLOGOFF
,
656 if (!NT_STATUS_IS_OK(status
)) {
660 if (NT_STATUS_IS_ERR(status
)) {
664 /* Return variables */
665 if (return_authenticator
&& r
.out
.return_authenticator
) {
666 *return_authenticator
= *r
.out
.return_authenticator
;
673 struct rpccli_netr_ServerReqChallenge_state
{
674 struct netr_ServerReqChallenge orig
;
675 struct netr_ServerReqChallenge tmp
;
676 TALLOC_CTX
*out_mem_ctx
;
677 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
680 static void rpccli_netr_ServerReqChallenge_done(struct tevent_req
*subreq
);
682 struct tevent_req
*rpccli_netr_ServerReqChallenge_send(TALLOC_CTX
*mem_ctx
,
683 struct tevent_context
*ev
,
684 struct rpc_pipe_client
*cli
,
685 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
686 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
687 struct netr_Credential
*_credentials
/* [in] [ref] */,
688 struct netr_Credential
*_return_credentials
/* [out] [ref] */)
690 struct tevent_req
*req
;
691 struct rpccli_netr_ServerReqChallenge_state
*state
;
692 struct tevent_req
*subreq
;
694 req
= tevent_req_create(mem_ctx
, &state
,
695 struct rpccli_netr_ServerReqChallenge_state
);
699 state
->out_mem_ctx
= NULL
;
700 state
->dispatch_recv
= cli
->dispatch_recv
;
703 state
->orig
.in
.server_name
= _server_name
;
704 state
->orig
.in
.computer_name
= _computer_name
;
705 state
->orig
.in
.credentials
= _credentials
;
708 state
->orig
.out
.return_credentials
= _return_credentials
;
711 ZERO_STRUCT(state
->orig
.out
.result
);
713 state
->out_mem_ctx
= talloc_named_const(state
, 0,
714 "rpccli_netr_ServerReqChallenge_out_memory");
715 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
716 return tevent_req_post(req
, ev
);
719 /* make a temporary copy, that we pass to the dispatch function */
720 state
->tmp
= state
->orig
;
722 subreq
= cli
->dispatch_send(state
, ev
, cli
,
724 NDR_NETR_SERVERREQCHALLENGE
,
726 if (tevent_req_nomem(subreq
, req
)) {
727 return tevent_req_post(req
, ev
);
729 tevent_req_set_callback(subreq
, rpccli_netr_ServerReqChallenge_done
, req
);
733 static void rpccli_netr_ServerReqChallenge_done(struct tevent_req
*subreq
)
735 struct tevent_req
*req
= tevent_req_callback_data(
736 subreq
, struct tevent_req
);
737 struct rpccli_netr_ServerReqChallenge_state
*state
= tevent_req_data(
738 req
, struct rpccli_netr_ServerReqChallenge_state
);
742 if (state
->out_mem_ctx
) {
743 mem_ctx
= state
->out_mem_ctx
;
748 status
= state
->dispatch_recv(subreq
, mem_ctx
);
750 if (!NT_STATUS_IS_OK(status
)) {
751 tevent_req_nterror(req
, status
);
755 /* Copy out parameters */
756 *state
->orig
.out
.return_credentials
= *state
->tmp
.out
.return_credentials
;
759 state
->orig
.out
.result
= state
->tmp
.out
.result
;
761 /* Reset temporary structure */
762 ZERO_STRUCT(state
->tmp
);
764 tevent_req_done(req
);
767 NTSTATUS
rpccli_netr_ServerReqChallenge_recv(struct tevent_req
*req
,
771 struct rpccli_netr_ServerReqChallenge_state
*state
= tevent_req_data(
772 req
, struct rpccli_netr_ServerReqChallenge_state
);
775 if (tevent_req_is_nterror(req
, &status
)) {
776 tevent_req_received(req
);
780 /* Steal possbile out parameters to the callers context */
781 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
784 *result
= state
->orig
.out
.result
;
786 tevent_req_received(req
);
790 NTSTATUS
rpccli_netr_ServerReqChallenge(struct rpc_pipe_client
*cli
,
792 const char *server_name
/* [in] [unique,charset(UTF16)] */,
793 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
794 struct netr_Credential
*credentials
/* [in] [ref] */,
795 struct netr_Credential
*return_credentials
/* [out] [ref] */)
797 struct netr_ServerReqChallenge r
;
801 r
.in
.server_name
= server_name
;
802 r
.in
.computer_name
= computer_name
;
803 r
.in
.credentials
= credentials
;
805 status
= cli
->dispatch(cli
,
808 NDR_NETR_SERVERREQCHALLENGE
,
811 if (!NT_STATUS_IS_OK(status
)) {
815 if (NT_STATUS_IS_ERR(status
)) {
819 /* Return variables */
820 *return_credentials
= *r
.out
.return_credentials
;
826 struct rpccli_netr_ServerAuthenticate_state
{
827 struct netr_ServerAuthenticate orig
;
828 struct netr_ServerAuthenticate tmp
;
829 TALLOC_CTX
*out_mem_ctx
;
830 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
833 static void rpccli_netr_ServerAuthenticate_done(struct tevent_req
*subreq
);
835 struct tevent_req
*rpccli_netr_ServerAuthenticate_send(TALLOC_CTX
*mem_ctx
,
836 struct tevent_context
*ev
,
837 struct rpc_pipe_client
*cli
,
838 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
839 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
840 enum netr_SchannelType _secure_channel_type
/* [in] */,
841 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
842 struct netr_Credential
*_credentials
/* [in] [ref] */,
843 struct netr_Credential
*_return_credentials
/* [out] [ref] */)
845 struct tevent_req
*req
;
846 struct rpccli_netr_ServerAuthenticate_state
*state
;
847 struct tevent_req
*subreq
;
849 req
= tevent_req_create(mem_ctx
, &state
,
850 struct rpccli_netr_ServerAuthenticate_state
);
854 state
->out_mem_ctx
= NULL
;
855 state
->dispatch_recv
= cli
->dispatch_recv
;
858 state
->orig
.in
.server_name
= _server_name
;
859 state
->orig
.in
.account_name
= _account_name
;
860 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
861 state
->orig
.in
.computer_name
= _computer_name
;
862 state
->orig
.in
.credentials
= _credentials
;
865 state
->orig
.out
.return_credentials
= _return_credentials
;
868 ZERO_STRUCT(state
->orig
.out
.result
);
870 state
->out_mem_ctx
= talloc_named_const(state
, 0,
871 "rpccli_netr_ServerAuthenticate_out_memory");
872 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
873 return tevent_req_post(req
, ev
);
876 /* make a temporary copy, that we pass to the dispatch function */
877 state
->tmp
= state
->orig
;
879 subreq
= cli
->dispatch_send(state
, ev
, cli
,
881 NDR_NETR_SERVERAUTHENTICATE
,
883 if (tevent_req_nomem(subreq
, req
)) {
884 return tevent_req_post(req
, ev
);
886 tevent_req_set_callback(subreq
, rpccli_netr_ServerAuthenticate_done
, req
);
890 static void rpccli_netr_ServerAuthenticate_done(struct tevent_req
*subreq
)
892 struct tevent_req
*req
= tevent_req_callback_data(
893 subreq
, struct tevent_req
);
894 struct rpccli_netr_ServerAuthenticate_state
*state
= tevent_req_data(
895 req
, struct rpccli_netr_ServerAuthenticate_state
);
899 if (state
->out_mem_ctx
) {
900 mem_ctx
= state
->out_mem_ctx
;
905 status
= state
->dispatch_recv(subreq
, mem_ctx
);
907 if (!NT_STATUS_IS_OK(status
)) {
908 tevent_req_nterror(req
, status
);
912 /* Copy out parameters */
913 *state
->orig
.out
.return_credentials
= *state
->tmp
.out
.return_credentials
;
916 state
->orig
.out
.result
= state
->tmp
.out
.result
;
918 /* Reset temporary structure */
919 ZERO_STRUCT(state
->tmp
);
921 tevent_req_done(req
);
924 NTSTATUS
rpccli_netr_ServerAuthenticate_recv(struct tevent_req
*req
,
928 struct rpccli_netr_ServerAuthenticate_state
*state
= tevent_req_data(
929 req
, struct rpccli_netr_ServerAuthenticate_state
);
932 if (tevent_req_is_nterror(req
, &status
)) {
933 tevent_req_received(req
);
937 /* Steal possbile out parameters to the callers context */
938 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
941 *result
= state
->orig
.out
.result
;
943 tevent_req_received(req
);
947 NTSTATUS
rpccli_netr_ServerAuthenticate(struct rpc_pipe_client
*cli
,
949 const char *server_name
/* [in] [unique,charset(UTF16)] */,
950 const char *account_name
/* [in] [ref,charset(UTF16)] */,
951 enum netr_SchannelType secure_channel_type
/* [in] */,
952 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
953 struct netr_Credential
*credentials
/* [in] [ref] */,
954 struct netr_Credential
*return_credentials
/* [out] [ref] */)
956 struct netr_ServerAuthenticate r
;
960 r
.in
.server_name
= server_name
;
961 r
.in
.account_name
= account_name
;
962 r
.in
.secure_channel_type
= secure_channel_type
;
963 r
.in
.computer_name
= computer_name
;
964 r
.in
.credentials
= credentials
;
966 status
= cli
->dispatch(cli
,
969 NDR_NETR_SERVERAUTHENTICATE
,
972 if (!NT_STATUS_IS_OK(status
)) {
976 if (NT_STATUS_IS_ERR(status
)) {
980 /* Return variables */
981 *return_credentials
= *r
.out
.return_credentials
;
987 struct rpccli_netr_ServerPasswordSet_state
{
988 struct netr_ServerPasswordSet orig
;
989 struct netr_ServerPasswordSet tmp
;
990 TALLOC_CTX
*out_mem_ctx
;
991 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
994 static void rpccli_netr_ServerPasswordSet_done(struct tevent_req
*subreq
);
996 struct tevent_req
*rpccli_netr_ServerPasswordSet_send(TALLOC_CTX
*mem_ctx
,
997 struct tevent_context
*ev
,
998 struct rpc_pipe_client
*cli
,
999 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
1000 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
1001 enum netr_SchannelType _secure_channel_type
/* [in] */,
1002 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
1003 struct netr_Authenticator
*_credential
/* [in] [ref] */,
1004 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
1005 struct samr_Password
*_new_password
/* [in] [ref] */)
1007 struct tevent_req
*req
;
1008 struct rpccli_netr_ServerPasswordSet_state
*state
;
1009 struct tevent_req
*subreq
;
1011 req
= tevent_req_create(mem_ctx
, &state
,
1012 struct rpccli_netr_ServerPasswordSet_state
);
1016 state
->out_mem_ctx
= NULL
;
1017 state
->dispatch_recv
= cli
->dispatch_recv
;
1020 state
->orig
.in
.server_name
= _server_name
;
1021 state
->orig
.in
.account_name
= _account_name
;
1022 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
1023 state
->orig
.in
.computer_name
= _computer_name
;
1024 state
->orig
.in
.credential
= _credential
;
1025 state
->orig
.in
.new_password
= _new_password
;
1027 /* Out parameters */
1028 state
->orig
.out
.return_authenticator
= _return_authenticator
;
1031 ZERO_STRUCT(state
->orig
.out
.result
);
1033 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1034 "rpccli_netr_ServerPasswordSet_out_memory");
1035 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1036 return tevent_req_post(req
, ev
);
1039 /* make a temporary copy, that we pass to the dispatch function */
1040 state
->tmp
= state
->orig
;
1042 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1043 &ndr_table_netlogon
,
1044 NDR_NETR_SERVERPASSWORDSET
,
1046 if (tevent_req_nomem(subreq
, req
)) {
1047 return tevent_req_post(req
, ev
);
1049 tevent_req_set_callback(subreq
, rpccli_netr_ServerPasswordSet_done
, req
);
1053 static void rpccli_netr_ServerPasswordSet_done(struct tevent_req
*subreq
)
1055 struct tevent_req
*req
= tevent_req_callback_data(
1056 subreq
, struct tevent_req
);
1057 struct rpccli_netr_ServerPasswordSet_state
*state
= tevent_req_data(
1058 req
, struct rpccli_netr_ServerPasswordSet_state
);
1060 TALLOC_CTX
*mem_ctx
;
1062 if (state
->out_mem_ctx
) {
1063 mem_ctx
= state
->out_mem_ctx
;
1068 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1069 TALLOC_FREE(subreq
);
1070 if (!NT_STATUS_IS_OK(status
)) {
1071 tevent_req_nterror(req
, status
);
1075 /* Copy out parameters */
1076 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
1079 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1081 /* Reset temporary structure */
1082 ZERO_STRUCT(state
->tmp
);
1084 tevent_req_done(req
);
1087 NTSTATUS
rpccli_netr_ServerPasswordSet_recv(struct tevent_req
*req
,
1088 TALLOC_CTX
*mem_ctx
,
1091 struct rpccli_netr_ServerPasswordSet_state
*state
= tevent_req_data(
1092 req
, struct rpccli_netr_ServerPasswordSet_state
);
1095 if (tevent_req_is_nterror(req
, &status
)) {
1096 tevent_req_received(req
);
1100 /* Steal possbile out parameters to the callers context */
1101 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1104 *result
= state
->orig
.out
.result
;
1106 tevent_req_received(req
);
1107 return NT_STATUS_OK
;
1110 NTSTATUS
rpccli_netr_ServerPasswordSet(struct rpc_pipe_client
*cli
,
1111 TALLOC_CTX
*mem_ctx
,
1112 const char *server_name
/* [in] [unique,charset(UTF16)] */,
1113 const char *account_name
/* [in] [ref,charset(UTF16)] */,
1114 enum netr_SchannelType secure_channel_type
/* [in] */,
1115 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
1116 struct netr_Authenticator
*credential
/* [in] [ref] */,
1117 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
1118 struct samr_Password
*new_password
/* [in] [ref] */)
1120 struct netr_ServerPasswordSet r
;
1124 r
.in
.server_name
= server_name
;
1125 r
.in
.account_name
= account_name
;
1126 r
.in
.secure_channel_type
= secure_channel_type
;
1127 r
.in
.computer_name
= computer_name
;
1128 r
.in
.credential
= credential
;
1129 r
.in
.new_password
= new_password
;
1131 status
= cli
->dispatch(cli
,
1133 &ndr_table_netlogon
,
1134 NDR_NETR_SERVERPASSWORDSET
,
1137 if (!NT_STATUS_IS_OK(status
)) {
1141 if (NT_STATUS_IS_ERR(status
)) {
1145 /* Return variables */
1146 *return_authenticator
= *r
.out
.return_authenticator
;
1149 return r
.out
.result
;
1152 struct rpccli_netr_DatabaseDeltas_state
{
1153 struct netr_DatabaseDeltas orig
;
1154 struct netr_DatabaseDeltas tmp
;
1155 TALLOC_CTX
*out_mem_ctx
;
1156 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1159 static void rpccli_netr_DatabaseDeltas_done(struct tevent_req
*subreq
);
1161 struct tevent_req
*rpccli_netr_DatabaseDeltas_send(TALLOC_CTX
*mem_ctx
,
1162 struct tevent_context
*ev
,
1163 struct rpc_pipe_client
*cli
,
1164 const char *_logon_server
/* [in] [ref,charset(UTF16)] */,
1165 const char *_computername
/* [in] [ref,charset(UTF16)] */,
1166 struct netr_Authenticator
*_credential
/* [in] [ref] */,
1167 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
1168 enum netr_SamDatabaseID _database_id
/* [in] */,
1169 uint64_t *_sequence_num
/* [in,out] [ref] */,
1170 struct netr_DELTA_ENUM_ARRAY
**_delta_enum_array
/* [out] [ref] */,
1171 uint32_t _preferredmaximumlength
/* [in] */)
1173 struct tevent_req
*req
;
1174 struct rpccli_netr_DatabaseDeltas_state
*state
;
1175 struct tevent_req
*subreq
;
1177 req
= tevent_req_create(mem_ctx
, &state
,
1178 struct rpccli_netr_DatabaseDeltas_state
);
1182 state
->out_mem_ctx
= NULL
;
1183 state
->dispatch_recv
= cli
->dispatch_recv
;
1186 state
->orig
.in
.logon_server
= _logon_server
;
1187 state
->orig
.in
.computername
= _computername
;
1188 state
->orig
.in
.credential
= _credential
;
1189 state
->orig
.in
.return_authenticator
= _return_authenticator
;
1190 state
->orig
.in
.database_id
= _database_id
;
1191 state
->orig
.in
.sequence_num
= _sequence_num
;
1192 state
->orig
.in
.preferredmaximumlength
= _preferredmaximumlength
;
1194 /* Out parameters */
1195 state
->orig
.out
.return_authenticator
= _return_authenticator
;
1196 state
->orig
.out
.sequence_num
= _sequence_num
;
1197 state
->orig
.out
.delta_enum_array
= _delta_enum_array
;
1200 ZERO_STRUCT(state
->orig
.out
.result
);
1202 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1203 "rpccli_netr_DatabaseDeltas_out_memory");
1204 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1205 return tevent_req_post(req
, ev
);
1208 /* make a temporary copy, that we pass to the dispatch function */
1209 state
->tmp
= state
->orig
;
1211 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1212 &ndr_table_netlogon
,
1213 NDR_NETR_DATABASEDELTAS
,
1215 if (tevent_req_nomem(subreq
, req
)) {
1216 return tevent_req_post(req
, ev
);
1218 tevent_req_set_callback(subreq
, rpccli_netr_DatabaseDeltas_done
, req
);
1222 static void rpccli_netr_DatabaseDeltas_done(struct tevent_req
*subreq
)
1224 struct tevent_req
*req
= tevent_req_callback_data(
1225 subreq
, struct tevent_req
);
1226 struct rpccli_netr_DatabaseDeltas_state
*state
= tevent_req_data(
1227 req
, struct rpccli_netr_DatabaseDeltas_state
);
1229 TALLOC_CTX
*mem_ctx
;
1231 if (state
->out_mem_ctx
) {
1232 mem_ctx
= state
->out_mem_ctx
;
1237 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1238 TALLOC_FREE(subreq
);
1239 if (!NT_STATUS_IS_OK(status
)) {
1240 tevent_req_nterror(req
, status
);
1244 /* Copy out parameters */
1245 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
1246 *state
->orig
.out
.sequence_num
= *state
->tmp
.out
.sequence_num
;
1247 *state
->orig
.out
.delta_enum_array
= *state
->tmp
.out
.delta_enum_array
;
1250 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1252 /* Reset temporary structure */
1253 ZERO_STRUCT(state
->tmp
);
1255 tevent_req_done(req
);
1258 NTSTATUS
rpccli_netr_DatabaseDeltas_recv(struct tevent_req
*req
,
1259 TALLOC_CTX
*mem_ctx
,
1262 struct rpccli_netr_DatabaseDeltas_state
*state
= tevent_req_data(
1263 req
, struct rpccli_netr_DatabaseDeltas_state
);
1266 if (tevent_req_is_nterror(req
, &status
)) {
1267 tevent_req_received(req
);
1271 /* Steal possbile out parameters to the callers context */
1272 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1275 *result
= state
->orig
.out
.result
;
1277 tevent_req_received(req
);
1278 return NT_STATUS_OK
;
1281 NTSTATUS
rpccli_netr_DatabaseDeltas(struct rpc_pipe_client
*cli
,
1282 TALLOC_CTX
*mem_ctx
,
1283 const char *logon_server
/* [in] [ref,charset(UTF16)] */,
1284 const char *computername
/* [in] [ref,charset(UTF16)] */,
1285 struct netr_Authenticator
*credential
/* [in] [ref] */,
1286 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
1287 enum netr_SamDatabaseID database_id
/* [in] */,
1288 uint64_t *sequence_num
/* [in,out] [ref] */,
1289 struct netr_DELTA_ENUM_ARRAY
**delta_enum_array
/* [out] [ref] */,
1290 uint32_t preferredmaximumlength
/* [in] */)
1292 struct netr_DatabaseDeltas r
;
1296 r
.in
.logon_server
= logon_server
;
1297 r
.in
.computername
= computername
;
1298 r
.in
.credential
= credential
;
1299 r
.in
.return_authenticator
= return_authenticator
;
1300 r
.in
.database_id
= database_id
;
1301 r
.in
.sequence_num
= sequence_num
;
1302 r
.in
.preferredmaximumlength
= preferredmaximumlength
;
1304 status
= cli
->dispatch(cli
,
1306 &ndr_table_netlogon
,
1307 NDR_NETR_DATABASEDELTAS
,
1310 if (!NT_STATUS_IS_OK(status
)) {
1314 if (NT_STATUS_IS_ERR(status
)) {
1318 /* Return variables */
1319 *return_authenticator
= *r
.out
.return_authenticator
;
1320 *sequence_num
= *r
.out
.sequence_num
;
1321 *delta_enum_array
= *r
.out
.delta_enum_array
;
1324 return r
.out
.result
;
1327 struct rpccli_netr_DatabaseSync_state
{
1328 struct netr_DatabaseSync orig
;
1329 struct netr_DatabaseSync tmp
;
1330 TALLOC_CTX
*out_mem_ctx
;
1331 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1334 static void rpccli_netr_DatabaseSync_done(struct tevent_req
*subreq
);
1336 struct tevent_req
*rpccli_netr_DatabaseSync_send(TALLOC_CTX
*mem_ctx
,
1337 struct tevent_context
*ev
,
1338 struct rpc_pipe_client
*cli
,
1339 const char *_logon_server
/* [in] [ref,charset(UTF16)] */,
1340 const char *_computername
/* [in] [ref,charset(UTF16)] */,
1341 struct netr_Authenticator
*_credential
/* [in] [ref] */,
1342 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
1343 enum netr_SamDatabaseID _database_id
/* [in] */,
1344 uint32_t *_sync_context
/* [in,out] [ref] */,
1345 struct netr_DELTA_ENUM_ARRAY
**_delta_enum_array
/* [out] [ref] */,
1346 uint32_t _preferredmaximumlength
/* [in] */)
1348 struct tevent_req
*req
;
1349 struct rpccli_netr_DatabaseSync_state
*state
;
1350 struct tevent_req
*subreq
;
1352 req
= tevent_req_create(mem_ctx
, &state
,
1353 struct rpccli_netr_DatabaseSync_state
);
1357 state
->out_mem_ctx
= NULL
;
1358 state
->dispatch_recv
= cli
->dispatch_recv
;
1361 state
->orig
.in
.logon_server
= _logon_server
;
1362 state
->orig
.in
.computername
= _computername
;
1363 state
->orig
.in
.credential
= _credential
;
1364 state
->orig
.in
.return_authenticator
= _return_authenticator
;
1365 state
->orig
.in
.database_id
= _database_id
;
1366 state
->orig
.in
.sync_context
= _sync_context
;
1367 state
->orig
.in
.preferredmaximumlength
= _preferredmaximumlength
;
1369 /* Out parameters */
1370 state
->orig
.out
.return_authenticator
= _return_authenticator
;
1371 state
->orig
.out
.sync_context
= _sync_context
;
1372 state
->orig
.out
.delta_enum_array
= _delta_enum_array
;
1375 ZERO_STRUCT(state
->orig
.out
.result
);
1377 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1378 "rpccli_netr_DatabaseSync_out_memory");
1379 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1380 return tevent_req_post(req
, ev
);
1383 /* make a temporary copy, that we pass to the dispatch function */
1384 state
->tmp
= state
->orig
;
1386 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1387 &ndr_table_netlogon
,
1388 NDR_NETR_DATABASESYNC
,
1390 if (tevent_req_nomem(subreq
, req
)) {
1391 return tevent_req_post(req
, ev
);
1393 tevent_req_set_callback(subreq
, rpccli_netr_DatabaseSync_done
, req
);
1397 static void rpccli_netr_DatabaseSync_done(struct tevent_req
*subreq
)
1399 struct tevent_req
*req
= tevent_req_callback_data(
1400 subreq
, struct tevent_req
);
1401 struct rpccli_netr_DatabaseSync_state
*state
= tevent_req_data(
1402 req
, struct rpccli_netr_DatabaseSync_state
);
1404 TALLOC_CTX
*mem_ctx
;
1406 if (state
->out_mem_ctx
) {
1407 mem_ctx
= state
->out_mem_ctx
;
1412 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1413 TALLOC_FREE(subreq
);
1414 if (!NT_STATUS_IS_OK(status
)) {
1415 tevent_req_nterror(req
, status
);
1419 /* Copy out parameters */
1420 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
1421 *state
->orig
.out
.sync_context
= *state
->tmp
.out
.sync_context
;
1422 *state
->orig
.out
.delta_enum_array
= *state
->tmp
.out
.delta_enum_array
;
1425 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1427 /* Reset temporary structure */
1428 ZERO_STRUCT(state
->tmp
);
1430 tevent_req_done(req
);
1433 NTSTATUS
rpccli_netr_DatabaseSync_recv(struct tevent_req
*req
,
1434 TALLOC_CTX
*mem_ctx
,
1437 struct rpccli_netr_DatabaseSync_state
*state
= tevent_req_data(
1438 req
, struct rpccli_netr_DatabaseSync_state
);
1441 if (tevent_req_is_nterror(req
, &status
)) {
1442 tevent_req_received(req
);
1446 /* Steal possbile out parameters to the callers context */
1447 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1450 *result
= state
->orig
.out
.result
;
1452 tevent_req_received(req
);
1453 return NT_STATUS_OK
;
1456 NTSTATUS
rpccli_netr_DatabaseSync(struct rpc_pipe_client
*cli
,
1457 TALLOC_CTX
*mem_ctx
,
1458 const char *logon_server
/* [in] [ref,charset(UTF16)] */,
1459 const char *computername
/* [in] [ref,charset(UTF16)] */,
1460 struct netr_Authenticator
*credential
/* [in] [ref] */,
1461 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
1462 enum netr_SamDatabaseID database_id
/* [in] */,
1463 uint32_t *sync_context
/* [in,out] [ref] */,
1464 struct netr_DELTA_ENUM_ARRAY
**delta_enum_array
/* [out] [ref] */,
1465 uint32_t preferredmaximumlength
/* [in] */)
1467 struct netr_DatabaseSync r
;
1471 r
.in
.logon_server
= logon_server
;
1472 r
.in
.computername
= computername
;
1473 r
.in
.credential
= credential
;
1474 r
.in
.return_authenticator
= return_authenticator
;
1475 r
.in
.database_id
= database_id
;
1476 r
.in
.sync_context
= sync_context
;
1477 r
.in
.preferredmaximumlength
= preferredmaximumlength
;
1479 status
= cli
->dispatch(cli
,
1481 &ndr_table_netlogon
,
1482 NDR_NETR_DATABASESYNC
,
1485 if (!NT_STATUS_IS_OK(status
)) {
1489 if (NT_STATUS_IS_ERR(status
)) {
1493 /* Return variables */
1494 *return_authenticator
= *r
.out
.return_authenticator
;
1495 *sync_context
= *r
.out
.sync_context
;
1496 *delta_enum_array
= *r
.out
.delta_enum_array
;
1499 return r
.out
.result
;
1502 struct rpccli_netr_AccountDeltas_state
{
1503 struct netr_AccountDeltas orig
;
1504 struct netr_AccountDeltas tmp
;
1505 TALLOC_CTX
*out_mem_ctx
;
1506 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1509 static void rpccli_netr_AccountDeltas_done(struct tevent_req
*subreq
);
1511 struct tevent_req
*rpccli_netr_AccountDeltas_send(TALLOC_CTX
*mem_ctx
,
1512 struct tevent_context
*ev
,
1513 struct rpc_pipe_client
*cli
,
1514 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
1515 const char *_computername
/* [in] [ref,charset(UTF16)] */,
1516 struct netr_Authenticator _credential
/* [in] */,
1517 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
1518 struct netr_UAS_INFO_0 _uas
/* [in] */,
1519 uint32_t _count
/* [in] */,
1520 uint32_t _level
/* [in] */,
1521 uint32_t _buffersize
/* [in] */,
1522 struct netr_AccountBuffer
*_buffer
/* [out] [ref,subcontext(4)] */,
1523 uint32_t *_count_returned
/* [out] [ref] */,
1524 uint32_t *_total_entries
/* [out] [ref] */,
1525 struct netr_UAS_INFO_0
*_recordid
/* [out] [ref] */)
1527 struct tevent_req
*req
;
1528 struct rpccli_netr_AccountDeltas_state
*state
;
1529 struct tevent_req
*subreq
;
1531 req
= tevent_req_create(mem_ctx
, &state
,
1532 struct rpccli_netr_AccountDeltas_state
);
1536 state
->out_mem_ctx
= NULL
;
1537 state
->dispatch_recv
= cli
->dispatch_recv
;
1540 state
->orig
.in
.logon_server
= _logon_server
;
1541 state
->orig
.in
.computername
= _computername
;
1542 state
->orig
.in
.credential
= _credential
;
1543 state
->orig
.in
.return_authenticator
= _return_authenticator
;
1544 state
->orig
.in
.uas
= _uas
;
1545 state
->orig
.in
.count
= _count
;
1546 state
->orig
.in
.level
= _level
;
1547 state
->orig
.in
.buffersize
= _buffersize
;
1549 /* Out parameters */
1550 state
->orig
.out
.return_authenticator
= _return_authenticator
;
1551 state
->orig
.out
.buffer
= _buffer
;
1552 state
->orig
.out
.count_returned
= _count_returned
;
1553 state
->orig
.out
.total_entries
= _total_entries
;
1554 state
->orig
.out
.recordid
= _recordid
;
1557 ZERO_STRUCT(state
->orig
.out
.result
);
1559 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1560 "rpccli_netr_AccountDeltas_out_memory");
1561 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1562 return tevent_req_post(req
, ev
);
1565 /* make a temporary copy, that we pass to the dispatch function */
1566 state
->tmp
= state
->orig
;
1568 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1569 &ndr_table_netlogon
,
1570 NDR_NETR_ACCOUNTDELTAS
,
1572 if (tevent_req_nomem(subreq
, req
)) {
1573 return tevent_req_post(req
, ev
);
1575 tevent_req_set_callback(subreq
, rpccli_netr_AccountDeltas_done
, req
);
1579 static void rpccli_netr_AccountDeltas_done(struct tevent_req
*subreq
)
1581 struct tevent_req
*req
= tevent_req_callback_data(
1582 subreq
, struct tevent_req
);
1583 struct rpccli_netr_AccountDeltas_state
*state
= tevent_req_data(
1584 req
, struct rpccli_netr_AccountDeltas_state
);
1586 TALLOC_CTX
*mem_ctx
;
1588 if (state
->out_mem_ctx
) {
1589 mem_ctx
= state
->out_mem_ctx
;
1594 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1595 TALLOC_FREE(subreq
);
1596 if (!NT_STATUS_IS_OK(status
)) {
1597 tevent_req_nterror(req
, status
);
1601 /* Copy out parameters */
1602 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
1603 *state
->orig
.out
.buffer
= *state
->tmp
.out
.buffer
;
1604 *state
->orig
.out
.count_returned
= *state
->tmp
.out
.count_returned
;
1605 *state
->orig
.out
.total_entries
= *state
->tmp
.out
.total_entries
;
1606 *state
->orig
.out
.recordid
= *state
->tmp
.out
.recordid
;
1609 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1611 /* Reset temporary structure */
1612 ZERO_STRUCT(state
->tmp
);
1614 tevent_req_done(req
);
1617 NTSTATUS
rpccli_netr_AccountDeltas_recv(struct tevent_req
*req
,
1618 TALLOC_CTX
*mem_ctx
,
1621 struct rpccli_netr_AccountDeltas_state
*state
= tevent_req_data(
1622 req
, struct rpccli_netr_AccountDeltas_state
);
1625 if (tevent_req_is_nterror(req
, &status
)) {
1626 tevent_req_received(req
);
1630 /* Steal possbile out parameters to the callers context */
1631 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1634 *result
= state
->orig
.out
.result
;
1636 tevent_req_received(req
);
1637 return NT_STATUS_OK
;
1640 NTSTATUS
rpccli_netr_AccountDeltas(struct rpc_pipe_client
*cli
,
1641 TALLOC_CTX
*mem_ctx
,
1642 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
1643 const char *computername
/* [in] [ref,charset(UTF16)] */,
1644 struct netr_Authenticator credential
/* [in] */,
1645 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
1646 struct netr_UAS_INFO_0 uas
/* [in] */,
1647 uint32_t count
/* [in] */,
1648 uint32_t level
/* [in] */,
1649 uint32_t buffersize
/* [in] */,
1650 struct netr_AccountBuffer
*buffer
/* [out] [ref,subcontext(4)] */,
1651 uint32_t *count_returned
/* [out] [ref] */,
1652 uint32_t *total_entries
/* [out] [ref] */,
1653 struct netr_UAS_INFO_0
*recordid
/* [out] [ref] */)
1655 struct netr_AccountDeltas r
;
1659 r
.in
.logon_server
= logon_server
;
1660 r
.in
.computername
= computername
;
1661 r
.in
.credential
= credential
;
1662 r
.in
.return_authenticator
= return_authenticator
;
1666 r
.in
.buffersize
= buffersize
;
1668 status
= cli
->dispatch(cli
,
1670 &ndr_table_netlogon
,
1671 NDR_NETR_ACCOUNTDELTAS
,
1674 if (!NT_STATUS_IS_OK(status
)) {
1678 if (NT_STATUS_IS_ERR(status
)) {
1682 /* Return variables */
1683 *return_authenticator
= *r
.out
.return_authenticator
;
1684 *buffer
= *r
.out
.buffer
;
1685 *count_returned
= *r
.out
.count_returned
;
1686 *total_entries
= *r
.out
.total_entries
;
1687 *recordid
= *r
.out
.recordid
;
1690 return r
.out
.result
;
1693 struct rpccli_netr_AccountSync_state
{
1694 struct netr_AccountSync orig
;
1695 struct netr_AccountSync tmp
;
1696 TALLOC_CTX
*out_mem_ctx
;
1697 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1700 static void rpccli_netr_AccountSync_done(struct tevent_req
*subreq
);
1702 struct tevent_req
*rpccli_netr_AccountSync_send(TALLOC_CTX
*mem_ctx
,
1703 struct tevent_context
*ev
,
1704 struct rpc_pipe_client
*cli
,
1705 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
1706 const char *_computername
/* [in] [ref,charset(UTF16)] */,
1707 struct netr_Authenticator _credential
/* [in] */,
1708 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
1709 uint32_t _reference
/* [in] */,
1710 uint32_t _level
/* [in] */,
1711 uint32_t _buffersize
/* [in] */,
1712 struct netr_AccountBuffer
*_buffer
/* [out] [ref,subcontext(4)] */,
1713 uint32_t *_count_returned
/* [out] [ref] */,
1714 uint32_t *_total_entries
/* [out] [ref] */,
1715 uint32_t *_next_reference
/* [out] [ref] */,
1716 struct netr_UAS_INFO_0
*_recordid
/* [in,out] [ref] */)
1718 struct tevent_req
*req
;
1719 struct rpccli_netr_AccountSync_state
*state
;
1720 struct tevent_req
*subreq
;
1722 req
= tevent_req_create(mem_ctx
, &state
,
1723 struct rpccli_netr_AccountSync_state
);
1727 state
->out_mem_ctx
= NULL
;
1728 state
->dispatch_recv
= cli
->dispatch_recv
;
1731 state
->orig
.in
.logon_server
= _logon_server
;
1732 state
->orig
.in
.computername
= _computername
;
1733 state
->orig
.in
.credential
= _credential
;
1734 state
->orig
.in
.return_authenticator
= _return_authenticator
;
1735 state
->orig
.in
.reference
= _reference
;
1736 state
->orig
.in
.level
= _level
;
1737 state
->orig
.in
.buffersize
= _buffersize
;
1738 state
->orig
.in
.recordid
= _recordid
;
1740 /* Out parameters */
1741 state
->orig
.out
.return_authenticator
= _return_authenticator
;
1742 state
->orig
.out
.buffer
= _buffer
;
1743 state
->orig
.out
.count_returned
= _count_returned
;
1744 state
->orig
.out
.total_entries
= _total_entries
;
1745 state
->orig
.out
.next_reference
= _next_reference
;
1746 state
->orig
.out
.recordid
= _recordid
;
1749 ZERO_STRUCT(state
->orig
.out
.result
);
1751 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1752 "rpccli_netr_AccountSync_out_memory");
1753 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1754 return tevent_req_post(req
, ev
);
1757 /* make a temporary copy, that we pass to the dispatch function */
1758 state
->tmp
= state
->orig
;
1760 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1761 &ndr_table_netlogon
,
1762 NDR_NETR_ACCOUNTSYNC
,
1764 if (tevent_req_nomem(subreq
, req
)) {
1765 return tevent_req_post(req
, ev
);
1767 tevent_req_set_callback(subreq
, rpccli_netr_AccountSync_done
, req
);
1771 static void rpccli_netr_AccountSync_done(struct tevent_req
*subreq
)
1773 struct tevent_req
*req
= tevent_req_callback_data(
1774 subreq
, struct tevent_req
);
1775 struct rpccli_netr_AccountSync_state
*state
= tevent_req_data(
1776 req
, struct rpccli_netr_AccountSync_state
);
1778 TALLOC_CTX
*mem_ctx
;
1780 if (state
->out_mem_ctx
) {
1781 mem_ctx
= state
->out_mem_ctx
;
1786 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1787 TALLOC_FREE(subreq
);
1788 if (!NT_STATUS_IS_OK(status
)) {
1789 tevent_req_nterror(req
, status
);
1793 /* Copy out parameters */
1794 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
1795 *state
->orig
.out
.buffer
= *state
->tmp
.out
.buffer
;
1796 *state
->orig
.out
.count_returned
= *state
->tmp
.out
.count_returned
;
1797 *state
->orig
.out
.total_entries
= *state
->tmp
.out
.total_entries
;
1798 *state
->orig
.out
.next_reference
= *state
->tmp
.out
.next_reference
;
1799 *state
->orig
.out
.recordid
= *state
->tmp
.out
.recordid
;
1802 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1804 /* Reset temporary structure */
1805 ZERO_STRUCT(state
->tmp
);
1807 tevent_req_done(req
);
1810 NTSTATUS
rpccli_netr_AccountSync_recv(struct tevent_req
*req
,
1811 TALLOC_CTX
*mem_ctx
,
1814 struct rpccli_netr_AccountSync_state
*state
= tevent_req_data(
1815 req
, struct rpccli_netr_AccountSync_state
);
1818 if (tevent_req_is_nterror(req
, &status
)) {
1819 tevent_req_received(req
);
1823 /* Steal possbile out parameters to the callers context */
1824 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1827 *result
= state
->orig
.out
.result
;
1829 tevent_req_received(req
);
1830 return NT_STATUS_OK
;
1833 NTSTATUS
rpccli_netr_AccountSync(struct rpc_pipe_client
*cli
,
1834 TALLOC_CTX
*mem_ctx
,
1835 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
1836 const char *computername
/* [in] [ref,charset(UTF16)] */,
1837 struct netr_Authenticator credential
/* [in] */,
1838 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
1839 uint32_t reference
/* [in] */,
1840 uint32_t level
/* [in] */,
1841 uint32_t buffersize
/* [in] */,
1842 struct netr_AccountBuffer
*buffer
/* [out] [ref,subcontext(4)] */,
1843 uint32_t *count_returned
/* [out] [ref] */,
1844 uint32_t *total_entries
/* [out] [ref] */,
1845 uint32_t *next_reference
/* [out] [ref] */,
1846 struct netr_UAS_INFO_0
*recordid
/* [in,out] [ref] */)
1848 struct netr_AccountSync r
;
1852 r
.in
.logon_server
= logon_server
;
1853 r
.in
.computername
= computername
;
1854 r
.in
.credential
= credential
;
1855 r
.in
.return_authenticator
= return_authenticator
;
1856 r
.in
.reference
= reference
;
1858 r
.in
.buffersize
= buffersize
;
1859 r
.in
.recordid
= recordid
;
1861 status
= cli
->dispatch(cli
,
1863 &ndr_table_netlogon
,
1864 NDR_NETR_ACCOUNTSYNC
,
1867 if (!NT_STATUS_IS_OK(status
)) {
1871 if (NT_STATUS_IS_ERR(status
)) {
1875 /* Return variables */
1876 *return_authenticator
= *r
.out
.return_authenticator
;
1877 *buffer
= *r
.out
.buffer
;
1878 *count_returned
= *r
.out
.count_returned
;
1879 *total_entries
= *r
.out
.total_entries
;
1880 *next_reference
= *r
.out
.next_reference
;
1881 *recordid
= *r
.out
.recordid
;
1884 return r
.out
.result
;
1887 struct rpccli_netr_GetDcName_state
{
1888 struct netr_GetDcName orig
;
1889 struct netr_GetDcName tmp
;
1890 TALLOC_CTX
*out_mem_ctx
;
1891 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1894 static void rpccli_netr_GetDcName_done(struct tevent_req
*subreq
);
1896 struct tevent_req
*rpccli_netr_GetDcName_send(TALLOC_CTX
*mem_ctx
,
1897 struct tevent_context
*ev
,
1898 struct rpc_pipe_client
*cli
,
1899 const char *_logon_server
/* [in] [ref,charset(UTF16)] */,
1900 const char *_domainname
/* [in] [unique,charset(UTF16)] */,
1901 const char **_dcname
/* [out] [ref,charset(UTF16)] */)
1903 struct tevent_req
*req
;
1904 struct rpccli_netr_GetDcName_state
*state
;
1905 struct tevent_req
*subreq
;
1907 req
= tevent_req_create(mem_ctx
, &state
,
1908 struct rpccli_netr_GetDcName_state
);
1912 state
->out_mem_ctx
= NULL
;
1913 state
->dispatch_recv
= cli
->dispatch_recv
;
1916 state
->orig
.in
.logon_server
= _logon_server
;
1917 state
->orig
.in
.domainname
= _domainname
;
1919 /* Out parameters */
1920 state
->orig
.out
.dcname
= _dcname
;
1923 ZERO_STRUCT(state
->orig
.out
.result
);
1925 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1926 "rpccli_netr_GetDcName_out_memory");
1927 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1928 return tevent_req_post(req
, ev
);
1931 /* make a temporary copy, that we pass to the dispatch function */
1932 state
->tmp
= state
->orig
;
1934 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1935 &ndr_table_netlogon
,
1938 if (tevent_req_nomem(subreq
, req
)) {
1939 return tevent_req_post(req
, ev
);
1941 tevent_req_set_callback(subreq
, rpccli_netr_GetDcName_done
, req
);
1945 static void rpccli_netr_GetDcName_done(struct tevent_req
*subreq
)
1947 struct tevent_req
*req
= tevent_req_callback_data(
1948 subreq
, struct tevent_req
);
1949 struct rpccli_netr_GetDcName_state
*state
= tevent_req_data(
1950 req
, struct rpccli_netr_GetDcName_state
);
1952 TALLOC_CTX
*mem_ctx
;
1954 if (state
->out_mem_ctx
) {
1955 mem_ctx
= state
->out_mem_ctx
;
1960 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1961 TALLOC_FREE(subreq
);
1962 if (!NT_STATUS_IS_OK(status
)) {
1963 tevent_req_nterror(req
, status
);
1967 /* Copy out parameters */
1968 *state
->orig
.out
.dcname
= *state
->tmp
.out
.dcname
;
1971 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1973 /* Reset temporary structure */
1974 ZERO_STRUCT(state
->tmp
);
1976 tevent_req_done(req
);
1979 NTSTATUS
rpccli_netr_GetDcName_recv(struct tevent_req
*req
,
1980 TALLOC_CTX
*mem_ctx
,
1983 struct rpccli_netr_GetDcName_state
*state
= tevent_req_data(
1984 req
, struct rpccli_netr_GetDcName_state
);
1987 if (tevent_req_is_nterror(req
, &status
)) {
1988 tevent_req_received(req
);
1992 /* Steal possbile out parameters to the callers context */
1993 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1996 *result
= state
->orig
.out
.result
;
1998 tevent_req_received(req
);
1999 return NT_STATUS_OK
;
2002 NTSTATUS
rpccli_netr_GetDcName(struct rpc_pipe_client
*cli
,
2003 TALLOC_CTX
*mem_ctx
,
2004 const char *logon_server
/* [in] [ref,charset(UTF16)] */,
2005 const char *domainname
/* [in] [unique,charset(UTF16)] */,
2006 const char **dcname
/* [out] [ref,charset(UTF16)] */,
2009 struct netr_GetDcName r
;
2013 r
.in
.logon_server
= logon_server
;
2014 r
.in
.domainname
= domainname
;
2016 status
= cli
->dispatch(cli
,
2018 &ndr_table_netlogon
,
2022 if (!NT_STATUS_IS_OK(status
)) {
2026 if (NT_STATUS_IS_ERR(status
)) {
2030 /* Return variables */
2031 *dcname
= *r
.out
.dcname
;
2035 *werror
= r
.out
.result
;
2038 return werror_to_ntstatus(r
.out
.result
);
2041 struct rpccli_netr_LogonControl_state
{
2042 struct netr_LogonControl orig
;
2043 struct netr_LogonControl tmp
;
2044 TALLOC_CTX
*out_mem_ctx
;
2045 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2048 static void rpccli_netr_LogonControl_done(struct tevent_req
*subreq
);
2050 struct tevent_req
*rpccli_netr_LogonControl_send(TALLOC_CTX
*mem_ctx
,
2051 struct tevent_context
*ev
,
2052 struct rpc_pipe_client
*cli
,
2053 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
2054 enum netr_LogonControlCode _function_code
/* [in] */,
2055 uint32_t _level
/* [in] */,
2056 union netr_CONTROL_QUERY_INFORMATION
*_query
/* [out] [ref,switch_is(level)] */)
2058 struct tevent_req
*req
;
2059 struct rpccli_netr_LogonControl_state
*state
;
2060 struct tevent_req
*subreq
;
2062 req
= tevent_req_create(mem_ctx
, &state
,
2063 struct rpccli_netr_LogonControl_state
);
2067 state
->out_mem_ctx
= NULL
;
2068 state
->dispatch_recv
= cli
->dispatch_recv
;
2071 state
->orig
.in
.logon_server
= _logon_server
;
2072 state
->orig
.in
.function_code
= _function_code
;
2073 state
->orig
.in
.level
= _level
;
2075 /* Out parameters */
2076 state
->orig
.out
.query
= _query
;
2079 ZERO_STRUCT(state
->orig
.out
.result
);
2081 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2082 "rpccli_netr_LogonControl_out_memory");
2083 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2084 return tevent_req_post(req
, ev
);
2087 /* make a temporary copy, that we pass to the dispatch function */
2088 state
->tmp
= state
->orig
;
2090 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2091 &ndr_table_netlogon
,
2092 NDR_NETR_LOGONCONTROL
,
2094 if (tevent_req_nomem(subreq
, req
)) {
2095 return tevent_req_post(req
, ev
);
2097 tevent_req_set_callback(subreq
, rpccli_netr_LogonControl_done
, req
);
2101 static void rpccli_netr_LogonControl_done(struct tevent_req
*subreq
)
2103 struct tevent_req
*req
= tevent_req_callback_data(
2104 subreq
, struct tevent_req
);
2105 struct rpccli_netr_LogonControl_state
*state
= tevent_req_data(
2106 req
, struct rpccli_netr_LogonControl_state
);
2108 TALLOC_CTX
*mem_ctx
;
2110 if (state
->out_mem_ctx
) {
2111 mem_ctx
= state
->out_mem_ctx
;
2116 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2117 TALLOC_FREE(subreq
);
2118 if (!NT_STATUS_IS_OK(status
)) {
2119 tevent_req_nterror(req
, status
);
2123 /* Copy out parameters */
2124 *state
->orig
.out
.query
= *state
->tmp
.out
.query
;
2127 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2129 /* Reset temporary structure */
2130 ZERO_STRUCT(state
->tmp
);
2132 tevent_req_done(req
);
2135 NTSTATUS
rpccli_netr_LogonControl_recv(struct tevent_req
*req
,
2136 TALLOC_CTX
*mem_ctx
,
2139 struct rpccli_netr_LogonControl_state
*state
= tevent_req_data(
2140 req
, struct rpccli_netr_LogonControl_state
);
2143 if (tevent_req_is_nterror(req
, &status
)) {
2144 tevent_req_received(req
);
2148 /* Steal possbile out parameters to the callers context */
2149 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2152 *result
= state
->orig
.out
.result
;
2154 tevent_req_received(req
);
2155 return NT_STATUS_OK
;
2158 NTSTATUS
rpccli_netr_LogonControl(struct rpc_pipe_client
*cli
,
2159 TALLOC_CTX
*mem_ctx
,
2160 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
2161 enum netr_LogonControlCode function_code
/* [in] */,
2162 uint32_t level
/* [in] */,
2163 union netr_CONTROL_QUERY_INFORMATION
*query
/* [out] [ref,switch_is(level)] */,
2166 struct netr_LogonControl r
;
2170 r
.in
.logon_server
= logon_server
;
2171 r
.in
.function_code
= function_code
;
2174 status
= cli
->dispatch(cli
,
2176 &ndr_table_netlogon
,
2177 NDR_NETR_LOGONCONTROL
,
2180 if (!NT_STATUS_IS_OK(status
)) {
2184 if (NT_STATUS_IS_ERR(status
)) {
2188 /* Return variables */
2189 *query
= *r
.out
.query
;
2193 *werror
= r
.out
.result
;
2196 return werror_to_ntstatus(r
.out
.result
);
2199 struct rpccli_netr_GetAnyDCName_state
{
2200 struct netr_GetAnyDCName orig
;
2201 struct netr_GetAnyDCName tmp
;
2202 TALLOC_CTX
*out_mem_ctx
;
2203 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2206 static void rpccli_netr_GetAnyDCName_done(struct tevent_req
*subreq
);
2208 struct tevent_req
*rpccli_netr_GetAnyDCName_send(TALLOC_CTX
*mem_ctx
,
2209 struct tevent_context
*ev
,
2210 struct rpc_pipe_client
*cli
,
2211 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
2212 const char *_domainname
/* [in] [unique,charset(UTF16)] */,
2213 const char **_dcname
/* [out] [ref,charset(UTF16)] */)
2215 struct tevent_req
*req
;
2216 struct rpccli_netr_GetAnyDCName_state
*state
;
2217 struct tevent_req
*subreq
;
2219 req
= tevent_req_create(mem_ctx
, &state
,
2220 struct rpccli_netr_GetAnyDCName_state
);
2224 state
->out_mem_ctx
= NULL
;
2225 state
->dispatch_recv
= cli
->dispatch_recv
;
2228 state
->orig
.in
.logon_server
= _logon_server
;
2229 state
->orig
.in
.domainname
= _domainname
;
2231 /* Out parameters */
2232 state
->orig
.out
.dcname
= _dcname
;
2235 ZERO_STRUCT(state
->orig
.out
.result
);
2237 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2238 "rpccli_netr_GetAnyDCName_out_memory");
2239 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2240 return tevent_req_post(req
, ev
);
2243 /* make a temporary copy, that we pass to the dispatch function */
2244 state
->tmp
= state
->orig
;
2246 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2247 &ndr_table_netlogon
,
2248 NDR_NETR_GETANYDCNAME
,
2250 if (tevent_req_nomem(subreq
, req
)) {
2251 return tevent_req_post(req
, ev
);
2253 tevent_req_set_callback(subreq
, rpccli_netr_GetAnyDCName_done
, req
);
2257 static void rpccli_netr_GetAnyDCName_done(struct tevent_req
*subreq
)
2259 struct tevent_req
*req
= tevent_req_callback_data(
2260 subreq
, struct tevent_req
);
2261 struct rpccli_netr_GetAnyDCName_state
*state
= tevent_req_data(
2262 req
, struct rpccli_netr_GetAnyDCName_state
);
2264 TALLOC_CTX
*mem_ctx
;
2266 if (state
->out_mem_ctx
) {
2267 mem_ctx
= state
->out_mem_ctx
;
2272 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2273 TALLOC_FREE(subreq
);
2274 if (!NT_STATUS_IS_OK(status
)) {
2275 tevent_req_nterror(req
, status
);
2279 /* Copy out parameters */
2280 *state
->orig
.out
.dcname
= *state
->tmp
.out
.dcname
;
2283 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2285 /* Reset temporary structure */
2286 ZERO_STRUCT(state
->tmp
);
2288 tevent_req_done(req
);
2291 NTSTATUS
rpccli_netr_GetAnyDCName_recv(struct tevent_req
*req
,
2292 TALLOC_CTX
*mem_ctx
,
2295 struct rpccli_netr_GetAnyDCName_state
*state
= tevent_req_data(
2296 req
, struct rpccli_netr_GetAnyDCName_state
);
2299 if (tevent_req_is_nterror(req
, &status
)) {
2300 tevent_req_received(req
);
2304 /* Steal possbile out parameters to the callers context */
2305 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2308 *result
= state
->orig
.out
.result
;
2310 tevent_req_received(req
);
2311 return NT_STATUS_OK
;
2314 NTSTATUS
rpccli_netr_GetAnyDCName(struct rpc_pipe_client
*cli
,
2315 TALLOC_CTX
*mem_ctx
,
2316 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
2317 const char *domainname
/* [in] [unique,charset(UTF16)] */,
2318 const char **dcname
/* [out] [ref,charset(UTF16)] */,
2321 struct netr_GetAnyDCName r
;
2325 r
.in
.logon_server
= logon_server
;
2326 r
.in
.domainname
= domainname
;
2328 status
= cli
->dispatch(cli
,
2330 &ndr_table_netlogon
,
2331 NDR_NETR_GETANYDCNAME
,
2334 if (!NT_STATUS_IS_OK(status
)) {
2338 if (NT_STATUS_IS_ERR(status
)) {
2342 /* Return variables */
2343 *dcname
= *r
.out
.dcname
;
2347 *werror
= r
.out
.result
;
2350 return werror_to_ntstatus(r
.out
.result
);
2353 struct rpccli_netr_LogonControl2_state
{
2354 struct netr_LogonControl2 orig
;
2355 struct netr_LogonControl2 tmp
;
2356 TALLOC_CTX
*out_mem_ctx
;
2357 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2360 static void rpccli_netr_LogonControl2_done(struct tevent_req
*subreq
);
2362 struct tevent_req
*rpccli_netr_LogonControl2_send(TALLOC_CTX
*mem_ctx
,
2363 struct tevent_context
*ev
,
2364 struct rpc_pipe_client
*cli
,
2365 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
2366 enum netr_LogonControlCode _function_code
/* [in] */,
2367 uint32_t _level
/* [in] */,
2368 union netr_CONTROL_DATA_INFORMATION
*_data
/* [in] [ref,switch_is(function_code)] */,
2369 union netr_CONTROL_QUERY_INFORMATION
*_query
/* [out] [ref,switch_is(level)] */)
2371 struct tevent_req
*req
;
2372 struct rpccli_netr_LogonControl2_state
*state
;
2373 struct tevent_req
*subreq
;
2375 req
= tevent_req_create(mem_ctx
, &state
,
2376 struct rpccli_netr_LogonControl2_state
);
2380 state
->out_mem_ctx
= NULL
;
2381 state
->dispatch_recv
= cli
->dispatch_recv
;
2384 state
->orig
.in
.logon_server
= _logon_server
;
2385 state
->orig
.in
.function_code
= _function_code
;
2386 state
->orig
.in
.level
= _level
;
2387 state
->orig
.in
.data
= _data
;
2389 /* Out parameters */
2390 state
->orig
.out
.query
= _query
;
2393 ZERO_STRUCT(state
->orig
.out
.result
);
2395 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2396 "rpccli_netr_LogonControl2_out_memory");
2397 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2398 return tevent_req_post(req
, ev
);
2401 /* make a temporary copy, that we pass to the dispatch function */
2402 state
->tmp
= state
->orig
;
2404 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2405 &ndr_table_netlogon
,
2406 NDR_NETR_LOGONCONTROL2
,
2408 if (tevent_req_nomem(subreq
, req
)) {
2409 return tevent_req_post(req
, ev
);
2411 tevent_req_set_callback(subreq
, rpccli_netr_LogonControl2_done
, req
);
2415 static void rpccli_netr_LogonControl2_done(struct tevent_req
*subreq
)
2417 struct tevent_req
*req
= tevent_req_callback_data(
2418 subreq
, struct tevent_req
);
2419 struct rpccli_netr_LogonControl2_state
*state
= tevent_req_data(
2420 req
, struct rpccli_netr_LogonControl2_state
);
2422 TALLOC_CTX
*mem_ctx
;
2424 if (state
->out_mem_ctx
) {
2425 mem_ctx
= state
->out_mem_ctx
;
2430 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2431 TALLOC_FREE(subreq
);
2432 if (!NT_STATUS_IS_OK(status
)) {
2433 tevent_req_nterror(req
, status
);
2437 /* Copy out parameters */
2438 *state
->orig
.out
.query
= *state
->tmp
.out
.query
;
2441 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2443 /* Reset temporary structure */
2444 ZERO_STRUCT(state
->tmp
);
2446 tevent_req_done(req
);
2449 NTSTATUS
rpccli_netr_LogonControl2_recv(struct tevent_req
*req
,
2450 TALLOC_CTX
*mem_ctx
,
2453 struct rpccli_netr_LogonControl2_state
*state
= tevent_req_data(
2454 req
, struct rpccli_netr_LogonControl2_state
);
2457 if (tevent_req_is_nterror(req
, &status
)) {
2458 tevent_req_received(req
);
2462 /* Steal possbile out parameters to the callers context */
2463 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2466 *result
= state
->orig
.out
.result
;
2468 tevent_req_received(req
);
2469 return NT_STATUS_OK
;
2472 NTSTATUS
rpccli_netr_LogonControl2(struct rpc_pipe_client
*cli
,
2473 TALLOC_CTX
*mem_ctx
,
2474 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
2475 enum netr_LogonControlCode function_code
/* [in] */,
2476 uint32_t level
/* [in] */,
2477 union netr_CONTROL_DATA_INFORMATION
*data
/* [in] [ref,switch_is(function_code)] */,
2478 union netr_CONTROL_QUERY_INFORMATION
*query
/* [out] [ref,switch_is(level)] */,
2481 struct netr_LogonControl2 r
;
2485 r
.in
.logon_server
= logon_server
;
2486 r
.in
.function_code
= function_code
;
2490 status
= cli
->dispatch(cli
,
2492 &ndr_table_netlogon
,
2493 NDR_NETR_LOGONCONTROL2
,
2496 if (!NT_STATUS_IS_OK(status
)) {
2500 if (NT_STATUS_IS_ERR(status
)) {
2504 /* Return variables */
2505 *query
= *r
.out
.query
;
2509 *werror
= r
.out
.result
;
2512 return werror_to_ntstatus(r
.out
.result
);
2515 struct rpccli_netr_ServerAuthenticate2_state
{
2516 struct netr_ServerAuthenticate2 orig
;
2517 struct netr_ServerAuthenticate2 tmp
;
2518 TALLOC_CTX
*out_mem_ctx
;
2519 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2522 static void rpccli_netr_ServerAuthenticate2_done(struct tevent_req
*subreq
);
2524 struct tevent_req
*rpccli_netr_ServerAuthenticate2_send(TALLOC_CTX
*mem_ctx
,
2525 struct tevent_context
*ev
,
2526 struct rpc_pipe_client
*cli
,
2527 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
2528 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
2529 enum netr_SchannelType _secure_channel_type
/* [in] */,
2530 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
2531 struct netr_Credential
*_credentials
/* [in] [ref] */,
2532 struct netr_Credential
*_return_credentials
/* [out] [ref] */,
2533 uint32_t *_negotiate_flags
/* [in,out] [ref] */)
2535 struct tevent_req
*req
;
2536 struct rpccli_netr_ServerAuthenticate2_state
*state
;
2537 struct tevent_req
*subreq
;
2539 req
= tevent_req_create(mem_ctx
, &state
,
2540 struct rpccli_netr_ServerAuthenticate2_state
);
2544 state
->out_mem_ctx
= NULL
;
2545 state
->dispatch_recv
= cli
->dispatch_recv
;
2548 state
->orig
.in
.server_name
= _server_name
;
2549 state
->orig
.in
.account_name
= _account_name
;
2550 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
2551 state
->orig
.in
.computer_name
= _computer_name
;
2552 state
->orig
.in
.credentials
= _credentials
;
2553 state
->orig
.in
.negotiate_flags
= _negotiate_flags
;
2555 /* Out parameters */
2556 state
->orig
.out
.return_credentials
= _return_credentials
;
2557 state
->orig
.out
.negotiate_flags
= _negotiate_flags
;
2560 ZERO_STRUCT(state
->orig
.out
.result
);
2562 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2563 "rpccli_netr_ServerAuthenticate2_out_memory");
2564 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2565 return tevent_req_post(req
, ev
);
2568 /* make a temporary copy, that we pass to the dispatch function */
2569 state
->tmp
= state
->orig
;
2571 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2572 &ndr_table_netlogon
,
2573 NDR_NETR_SERVERAUTHENTICATE2
,
2575 if (tevent_req_nomem(subreq
, req
)) {
2576 return tevent_req_post(req
, ev
);
2578 tevent_req_set_callback(subreq
, rpccli_netr_ServerAuthenticate2_done
, req
);
2582 static void rpccli_netr_ServerAuthenticate2_done(struct tevent_req
*subreq
)
2584 struct tevent_req
*req
= tevent_req_callback_data(
2585 subreq
, struct tevent_req
);
2586 struct rpccli_netr_ServerAuthenticate2_state
*state
= tevent_req_data(
2587 req
, struct rpccli_netr_ServerAuthenticate2_state
);
2589 TALLOC_CTX
*mem_ctx
;
2591 if (state
->out_mem_ctx
) {
2592 mem_ctx
= state
->out_mem_ctx
;
2597 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2598 TALLOC_FREE(subreq
);
2599 if (!NT_STATUS_IS_OK(status
)) {
2600 tevent_req_nterror(req
, status
);
2604 /* Copy out parameters */
2605 *state
->orig
.out
.return_credentials
= *state
->tmp
.out
.return_credentials
;
2606 *state
->orig
.out
.negotiate_flags
= *state
->tmp
.out
.negotiate_flags
;
2609 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2611 /* Reset temporary structure */
2612 ZERO_STRUCT(state
->tmp
);
2614 tevent_req_done(req
);
2617 NTSTATUS
rpccli_netr_ServerAuthenticate2_recv(struct tevent_req
*req
,
2618 TALLOC_CTX
*mem_ctx
,
2621 struct rpccli_netr_ServerAuthenticate2_state
*state
= tevent_req_data(
2622 req
, struct rpccli_netr_ServerAuthenticate2_state
);
2625 if (tevent_req_is_nterror(req
, &status
)) {
2626 tevent_req_received(req
);
2630 /* Steal possbile out parameters to the callers context */
2631 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2634 *result
= state
->orig
.out
.result
;
2636 tevent_req_received(req
);
2637 return NT_STATUS_OK
;
2640 NTSTATUS
rpccli_netr_ServerAuthenticate2(struct rpc_pipe_client
*cli
,
2641 TALLOC_CTX
*mem_ctx
,
2642 const char *server_name
/* [in] [unique,charset(UTF16)] */,
2643 const char *account_name
/* [in] [ref,charset(UTF16)] */,
2644 enum netr_SchannelType secure_channel_type
/* [in] */,
2645 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
2646 struct netr_Credential
*credentials
/* [in] [ref] */,
2647 struct netr_Credential
*return_credentials
/* [out] [ref] */,
2648 uint32_t *negotiate_flags
/* [in,out] [ref] */)
2650 struct netr_ServerAuthenticate2 r
;
2654 r
.in
.server_name
= server_name
;
2655 r
.in
.account_name
= account_name
;
2656 r
.in
.secure_channel_type
= secure_channel_type
;
2657 r
.in
.computer_name
= computer_name
;
2658 r
.in
.credentials
= credentials
;
2659 r
.in
.negotiate_flags
= negotiate_flags
;
2661 status
= cli
->dispatch(cli
,
2663 &ndr_table_netlogon
,
2664 NDR_NETR_SERVERAUTHENTICATE2
,
2667 if (!NT_STATUS_IS_OK(status
)) {
2671 if (NT_STATUS_IS_ERR(status
)) {
2675 /* Return variables */
2676 *return_credentials
= *r
.out
.return_credentials
;
2677 *negotiate_flags
= *r
.out
.negotiate_flags
;
2680 return r
.out
.result
;
2683 struct rpccli_netr_DatabaseSync2_state
{
2684 struct netr_DatabaseSync2 orig
;
2685 struct netr_DatabaseSync2 tmp
;
2686 TALLOC_CTX
*out_mem_ctx
;
2687 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2690 static void rpccli_netr_DatabaseSync2_done(struct tevent_req
*subreq
);
2692 struct tevent_req
*rpccli_netr_DatabaseSync2_send(TALLOC_CTX
*mem_ctx
,
2693 struct tevent_context
*ev
,
2694 struct rpc_pipe_client
*cli
,
2695 const char *_logon_server
/* [in] [ref,charset(UTF16)] */,
2696 const char *_computername
/* [in] [ref,charset(UTF16)] */,
2697 struct netr_Authenticator
*_credential
/* [in] [ref] */,
2698 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
2699 enum netr_SamDatabaseID _database_id
/* [in] */,
2700 enum SyncStateEnum _restart_state
/* [in] */,
2701 uint32_t *_sync_context
/* [in,out] [ref] */,
2702 struct netr_DELTA_ENUM_ARRAY
**_delta_enum_array
/* [out] [ref] */,
2703 uint32_t _preferredmaximumlength
/* [in] */)
2705 struct tevent_req
*req
;
2706 struct rpccli_netr_DatabaseSync2_state
*state
;
2707 struct tevent_req
*subreq
;
2709 req
= tevent_req_create(mem_ctx
, &state
,
2710 struct rpccli_netr_DatabaseSync2_state
);
2714 state
->out_mem_ctx
= NULL
;
2715 state
->dispatch_recv
= cli
->dispatch_recv
;
2718 state
->orig
.in
.logon_server
= _logon_server
;
2719 state
->orig
.in
.computername
= _computername
;
2720 state
->orig
.in
.credential
= _credential
;
2721 state
->orig
.in
.return_authenticator
= _return_authenticator
;
2722 state
->orig
.in
.database_id
= _database_id
;
2723 state
->orig
.in
.restart_state
= _restart_state
;
2724 state
->orig
.in
.sync_context
= _sync_context
;
2725 state
->orig
.in
.preferredmaximumlength
= _preferredmaximumlength
;
2727 /* Out parameters */
2728 state
->orig
.out
.return_authenticator
= _return_authenticator
;
2729 state
->orig
.out
.sync_context
= _sync_context
;
2730 state
->orig
.out
.delta_enum_array
= _delta_enum_array
;
2733 ZERO_STRUCT(state
->orig
.out
.result
);
2735 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2736 "rpccli_netr_DatabaseSync2_out_memory");
2737 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2738 return tevent_req_post(req
, ev
);
2741 /* make a temporary copy, that we pass to the dispatch function */
2742 state
->tmp
= state
->orig
;
2744 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2745 &ndr_table_netlogon
,
2746 NDR_NETR_DATABASESYNC2
,
2748 if (tevent_req_nomem(subreq
, req
)) {
2749 return tevent_req_post(req
, ev
);
2751 tevent_req_set_callback(subreq
, rpccli_netr_DatabaseSync2_done
, req
);
2755 static void rpccli_netr_DatabaseSync2_done(struct tevent_req
*subreq
)
2757 struct tevent_req
*req
= tevent_req_callback_data(
2758 subreq
, struct tevent_req
);
2759 struct rpccli_netr_DatabaseSync2_state
*state
= tevent_req_data(
2760 req
, struct rpccli_netr_DatabaseSync2_state
);
2762 TALLOC_CTX
*mem_ctx
;
2764 if (state
->out_mem_ctx
) {
2765 mem_ctx
= state
->out_mem_ctx
;
2770 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2771 TALLOC_FREE(subreq
);
2772 if (!NT_STATUS_IS_OK(status
)) {
2773 tevent_req_nterror(req
, status
);
2777 /* Copy out parameters */
2778 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
2779 *state
->orig
.out
.sync_context
= *state
->tmp
.out
.sync_context
;
2780 *state
->orig
.out
.delta_enum_array
= *state
->tmp
.out
.delta_enum_array
;
2783 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2785 /* Reset temporary structure */
2786 ZERO_STRUCT(state
->tmp
);
2788 tevent_req_done(req
);
2791 NTSTATUS
rpccli_netr_DatabaseSync2_recv(struct tevent_req
*req
,
2792 TALLOC_CTX
*mem_ctx
,
2795 struct rpccli_netr_DatabaseSync2_state
*state
= tevent_req_data(
2796 req
, struct rpccli_netr_DatabaseSync2_state
);
2799 if (tevent_req_is_nterror(req
, &status
)) {
2800 tevent_req_received(req
);
2804 /* Steal possbile out parameters to the callers context */
2805 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2808 *result
= state
->orig
.out
.result
;
2810 tevent_req_received(req
);
2811 return NT_STATUS_OK
;
2814 NTSTATUS
rpccli_netr_DatabaseSync2(struct rpc_pipe_client
*cli
,
2815 TALLOC_CTX
*mem_ctx
,
2816 const char *logon_server
/* [in] [ref,charset(UTF16)] */,
2817 const char *computername
/* [in] [ref,charset(UTF16)] */,
2818 struct netr_Authenticator
*credential
/* [in] [ref] */,
2819 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
2820 enum netr_SamDatabaseID database_id
/* [in] */,
2821 enum SyncStateEnum restart_state
/* [in] */,
2822 uint32_t *sync_context
/* [in,out] [ref] */,
2823 struct netr_DELTA_ENUM_ARRAY
**delta_enum_array
/* [out] [ref] */,
2824 uint32_t preferredmaximumlength
/* [in] */)
2826 struct netr_DatabaseSync2 r
;
2830 r
.in
.logon_server
= logon_server
;
2831 r
.in
.computername
= computername
;
2832 r
.in
.credential
= credential
;
2833 r
.in
.return_authenticator
= return_authenticator
;
2834 r
.in
.database_id
= database_id
;
2835 r
.in
.restart_state
= restart_state
;
2836 r
.in
.sync_context
= sync_context
;
2837 r
.in
.preferredmaximumlength
= preferredmaximumlength
;
2839 status
= cli
->dispatch(cli
,
2841 &ndr_table_netlogon
,
2842 NDR_NETR_DATABASESYNC2
,
2845 if (!NT_STATUS_IS_OK(status
)) {
2849 if (NT_STATUS_IS_ERR(status
)) {
2853 /* Return variables */
2854 *return_authenticator
= *r
.out
.return_authenticator
;
2855 *sync_context
= *r
.out
.sync_context
;
2856 *delta_enum_array
= *r
.out
.delta_enum_array
;
2859 return r
.out
.result
;
2862 struct rpccli_netr_DatabaseRedo_state
{
2863 struct netr_DatabaseRedo orig
;
2864 struct netr_DatabaseRedo tmp
;
2865 TALLOC_CTX
*out_mem_ctx
;
2866 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2869 static void rpccli_netr_DatabaseRedo_done(struct tevent_req
*subreq
);
2871 struct tevent_req
*rpccli_netr_DatabaseRedo_send(TALLOC_CTX
*mem_ctx
,
2872 struct tevent_context
*ev
,
2873 struct rpc_pipe_client
*cli
,
2874 const char *_logon_server
/* [in] [ref,charset(UTF16)] */,
2875 const char *_computername
/* [in] [ref,charset(UTF16)] */,
2876 struct netr_Authenticator
*_credential
/* [in] [ref] */,
2877 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
2878 struct netr_ChangeLogEntry _change_log_entry
/* [in] [subcontext_size(change_log_entry_size),subcontext(4)] */,
2879 uint32_t _change_log_entry_size
/* [in] [value(ndr_size_netr_ChangeLogEntry(&change_log_entry,ndr->iconv_convenience,ndr->flags))] */,
2880 struct netr_DELTA_ENUM_ARRAY
**_delta_enum_array
/* [out] [ref] */)
2882 struct tevent_req
*req
;
2883 struct rpccli_netr_DatabaseRedo_state
*state
;
2884 struct tevent_req
*subreq
;
2886 req
= tevent_req_create(mem_ctx
, &state
,
2887 struct rpccli_netr_DatabaseRedo_state
);
2891 state
->out_mem_ctx
= NULL
;
2892 state
->dispatch_recv
= cli
->dispatch_recv
;
2895 state
->orig
.in
.logon_server
= _logon_server
;
2896 state
->orig
.in
.computername
= _computername
;
2897 state
->orig
.in
.credential
= _credential
;
2898 state
->orig
.in
.return_authenticator
= _return_authenticator
;
2899 state
->orig
.in
.change_log_entry
= _change_log_entry
;
2900 state
->orig
.in
.change_log_entry_size
= _change_log_entry_size
;
2902 /* Out parameters */
2903 state
->orig
.out
.return_authenticator
= _return_authenticator
;
2904 state
->orig
.out
.delta_enum_array
= _delta_enum_array
;
2907 ZERO_STRUCT(state
->orig
.out
.result
);
2909 state
->out_mem_ctx
= talloc_named_const(state
, 0,
2910 "rpccli_netr_DatabaseRedo_out_memory");
2911 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
2912 return tevent_req_post(req
, ev
);
2915 /* make a temporary copy, that we pass to the dispatch function */
2916 state
->tmp
= state
->orig
;
2918 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2919 &ndr_table_netlogon
,
2920 NDR_NETR_DATABASEREDO
,
2922 if (tevent_req_nomem(subreq
, req
)) {
2923 return tevent_req_post(req
, ev
);
2925 tevent_req_set_callback(subreq
, rpccli_netr_DatabaseRedo_done
, req
);
2929 static void rpccli_netr_DatabaseRedo_done(struct tevent_req
*subreq
)
2931 struct tevent_req
*req
= tevent_req_callback_data(
2932 subreq
, struct tevent_req
);
2933 struct rpccli_netr_DatabaseRedo_state
*state
= tevent_req_data(
2934 req
, struct rpccli_netr_DatabaseRedo_state
);
2936 TALLOC_CTX
*mem_ctx
;
2938 if (state
->out_mem_ctx
) {
2939 mem_ctx
= state
->out_mem_ctx
;
2944 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2945 TALLOC_FREE(subreq
);
2946 if (!NT_STATUS_IS_OK(status
)) {
2947 tevent_req_nterror(req
, status
);
2951 /* Copy out parameters */
2952 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
2953 *state
->orig
.out
.delta_enum_array
= *state
->tmp
.out
.delta_enum_array
;
2956 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2958 /* Reset temporary structure */
2959 ZERO_STRUCT(state
->tmp
);
2961 tevent_req_done(req
);
2964 NTSTATUS
rpccli_netr_DatabaseRedo_recv(struct tevent_req
*req
,
2965 TALLOC_CTX
*mem_ctx
,
2968 struct rpccli_netr_DatabaseRedo_state
*state
= tevent_req_data(
2969 req
, struct rpccli_netr_DatabaseRedo_state
);
2972 if (tevent_req_is_nterror(req
, &status
)) {
2973 tevent_req_received(req
);
2977 /* Steal possbile out parameters to the callers context */
2978 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2981 *result
= state
->orig
.out
.result
;
2983 tevent_req_received(req
);
2984 return NT_STATUS_OK
;
2987 NTSTATUS
rpccli_netr_DatabaseRedo(struct rpc_pipe_client
*cli
,
2988 TALLOC_CTX
*mem_ctx
,
2989 const char *logon_server
/* [in] [ref,charset(UTF16)] */,
2990 const char *computername
/* [in] [ref,charset(UTF16)] */,
2991 struct netr_Authenticator
*credential
/* [in] [ref] */,
2992 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
2993 struct netr_ChangeLogEntry change_log_entry
/* [in] [subcontext_size(change_log_entry_size),subcontext(4)] */,
2994 uint32_t change_log_entry_size
/* [in] [value(ndr_size_netr_ChangeLogEntry(&change_log_entry,ndr->iconv_convenience,ndr->flags))] */,
2995 struct netr_DELTA_ENUM_ARRAY
**delta_enum_array
/* [out] [ref] */)
2997 struct netr_DatabaseRedo r
;
3001 r
.in
.logon_server
= logon_server
;
3002 r
.in
.computername
= computername
;
3003 r
.in
.credential
= credential
;
3004 r
.in
.return_authenticator
= return_authenticator
;
3005 r
.in
.change_log_entry
= change_log_entry
;
3006 r
.in
.change_log_entry_size
= change_log_entry_size
;
3008 status
= cli
->dispatch(cli
,
3010 &ndr_table_netlogon
,
3011 NDR_NETR_DATABASEREDO
,
3014 if (!NT_STATUS_IS_OK(status
)) {
3018 if (NT_STATUS_IS_ERR(status
)) {
3022 /* Return variables */
3023 *return_authenticator
= *r
.out
.return_authenticator
;
3024 *delta_enum_array
= *r
.out
.delta_enum_array
;
3027 return r
.out
.result
;
3030 struct rpccli_netr_LogonControl2Ex_state
{
3031 struct netr_LogonControl2Ex orig
;
3032 struct netr_LogonControl2Ex tmp
;
3033 TALLOC_CTX
*out_mem_ctx
;
3034 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3037 static void rpccli_netr_LogonControl2Ex_done(struct tevent_req
*subreq
);
3039 struct tevent_req
*rpccli_netr_LogonControl2Ex_send(TALLOC_CTX
*mem_ctx
,
3040 struct tevent_context
*ev
,
3041 struct rpc_pipe_client
*cli
,
3042 const char *_logon_server
/* [in] [unique,charset(UTF16)] */,
3043 enum netr_LogonControlCode _function_code
/* [in] */,
3044 uint32_t _level
/* [in] */,
3045 union netr_CONTROL_DATA_INFORMATION
*_data
/* [in] [ref,switch_is(function_code)] */,
3046 union netr_CONTROL_QUERY_INFORMATION
*_query
/* [out] [ref,switch_is(level)] */)
3048 struct tevent_req
*req
;
3049 struct rpccli_netr_LogonControl2Ex_state
*state
;
3050 struct tevent_req
*subreq
;
3052 req
= tevent_req_create(mem_ctx
, &state
,
3053 struct rpccli_netr_LogonControl2Ex_state
);
3057 state
->out_mem_ctx
= NULL
;
3058 state
->dispatch_recv
= cli
->dispatch_recv
;
3061 state
->orig
.in
.logon_server
= _logon_server
;
3062 state
->orig
.in
.function_code
= _function_code
;
3063 state
->orig
.in
.level
= _level
;
3064 state
->orig
.in
.data
= _data
;
3066 /* Out parameters */
3067 state
->orig
.out
.query
= _query
;
3070 ZERO_STRUCT(state
->orig
.out
.result
);
3072 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3073 "rpccli_netr_LogonControl2Ex_out_memory");
3074 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3075 return tevent_req_post(req
, ev
);
3078 /* make a temporary copy, that we pass to the dispatch function */
3079 state
->tmp
= state
->orig
;
3081 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3082 &ndr_table_netlogon
,
3083 NDR_NETR_LOGONCONTROL2EX
,
3085 if (tevent_req_nomem(subreq
, req
)) {
3086 return tevent_req_post(req
, ev
);
3088 tevent_req_set_callback(subreq
, rpccli_netr_LogonControl2Ex_done
, req
);
3092 static void rpccli_netr_LogonControl2Ex_done(struct tevent_req
*subreq
)
3094 struct tevent_req
*req
= tevent_req_callback_data(
3095 subreq
, struct tevent_req
);
3096 struct rpccli_netr_LogonControl2Ex_state
*state
= tevent_req_data(
3097 req
, struct rpccli_netr_LogonControl2Ex_state
);
3099 TALLOC_CTX
*mem_ctx
;
3101 if (state
->out_mem_ctx
) {
3102 mem_ctx
= state
->out_mem_ctx
;
3107 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3108 TALLOC_FREE(subreq
);
3109 if (!NT_STATUS_IS_OK(status
)) {
3110 tevent_req_nterror(req
, status
);
3114 /* Copy out parameters */
3115 *state
->orig
.out
.query
= *state
->tmp
.out
.query
;
3118 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3120 /* Reset temporary structure */
3121 ZERO_STRUCT(state
->tmp
);
3123 tevent_req_done(req
);
3126 NTSTATUS
rpccli_netr_LogonControl2Ex_recv(struct tevent_req
*req
,
3127 TALLOC_CTX
*mem_ctx
,
3130 struct rpccli_netr_LogonControl2Ex_state
*state
= tevent_req_data(
3131 req
, struct rpccli_netr_LogonControl2Ex_state
);
3134 if (tevent_req_is_nterror(req
, &status
)) {
3135 tevent_req_received(req
);
3139 /* Steal possbile out parameters to the callers context */
3140 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3143 *result
= state
->orig
.out
.result
;
3145 tevent_req_received(req
);
3146 return NT_STATUS_OK
;
3149 NTSTATUS
rpccli_netr_LogonControl2Ex(struct rpc_pipe_client
*cli
,
3150 TALLOC_CTX
*mem_ctx
,
3151 const char *logon_server
/* [in] [unique,charset(UTF16)] */,
3152 enum netr_LogonControlCode function_code
/* [in] */,
3153 uint32_t level
/* [in] */,
3154 union netr_CONTROL_DATA_INFORMATION
*data
/* [in] [ref,switch_is(function_code)] */,
3155 union netr_CONTROL_QUERY_INFORMATION
*query
/* [out] [ref,switch_is(level)] */,
3158 struct netr_LogonControl2Ex r
;
3162 r
.in
.logon_server
= logon_server
;
3163 r
.in
.function_code
= function_code
;
3167 status
= cli
->dispatch(cli
,
3169 &ndr_table_netlogon
,
3170 NDR_NETR_LOGONCONTROL2EX
,
3173 if (!NT_STATUS_IS_OK(status
)) {
3177 if (NT_STATUS_IS_ERR(status
)) {
3181 /* Return variables */
3182 *query
= *r
.out
.query
;
3186 *werror
= r
.out
.result
;
3189 return werror_to_ntstatus(r
.out
.result
);
3192 struct rpccli_netr_NetrEnumerateTrustedDomains_state
{
3193 struct netr_NetrEnumerateTrustedDomains orig
;
3194 struct netr_NetrEnumerateTrustedDomains tmp
;
3195 TALLOC_CTX
*out_mem_ctx
;
3196 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3199 static void rpccli_netr_NetrEnumerateTrustedDomains_done(struct tevent_req
*subreq
);
3201 struct tevent_req
*rpccli_netr_NetrEnumerateTrustedDomains_send(TALLOC_CTX
*mem_ctx
,
3202 struct tevent_context
*ev
,
3203 struct rpc_pipe_client
*cli
,
3204 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
3205 struct netr_Blob
*_trusted_domains_blob
/* [out] [ref] */)
3207 struct tevent_req
*req
;
3208 struct rpccli_netr_NetrEnumerateTrustedDomains_state
*state
;
3209 struct tevent_req
*subreq
;
3211 req
= tevent_req_create(mem_ctx
, &state
,
3212 struct rpccli_netr_NetrEnumerateTrustedDomains_state
);
3216 state
->out_mem_ctx
= NULL
;
3217 state
->dispatch_recv
= cli
->dispatch_recv
;
3220 state
->orig
.in
.server_name
= _server_name
;
3222 /* Out parameters */
3223 state
->orig
.out
.trusted_domains_blob
= _trusted_domains_blob
;
3226 ZERO_STRUCT(state
->orig
.out
.result
);
3228 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3229 "rpccli_netr_NetrEnumerateTrustedDomains_out_memory");
3230 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3231 return tevent_req_post(req
, ev
);
3234 /* make a temporary copy, that we pass to the dispatch function */
3235 state
->tmp
= state
->orig
;
3237 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3238 &ndr_table_netlogon
,
3239 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
,
3241 if (tevent_req_nomem(subreq
, req
)) {
3242 return tevent_req_post(req
, ev
);
3244 tevent_req_set_callback(subreq
, rpccli_netr_NetrEnumerateTrustedDomains_done
, req
);
3248 static void rpccli_netr_NetrEnumerateTrustedDomains_done(struct tevent_req
*subreq
)
3250 struct tevent_req
*req
= tevent_req_callback_data(
3251 subreq
, struct tevent_req
);
3252 struct rpccli_netr_NetrEnumerateTrustedDomains_state
*state
= tevent_req_data(
3253 req
, struct rpccli_netr_NetrEnumerateTrustedDomains_state
);
3255 TALLOC_CTX
*mem_ctx
;
3257 if (state
->out_mem_ctx
) {
3258 mem_ctx
= state
->out_mem_ctx
;
3263 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3264 TALLOC_FREE(subreq
);
3265 if (!NT_STATUS_IS_OK(status
)) {
3266 tevent_req_nterror(req
, status
);
3270 /* Copy out parameters */
3271 *state
->orig
.out
.trusted_domains_blob
= *state
->tmp
.out
.trusted_domains_blob
;
3274 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3276 /* Reset temporary structure */
3277 ZERO_STRUCT(state
->tmp
);
3279 tevent_req_done(req
);
3282 NTSTATUS
rpccli_netr_NetrEnumerateTrustedDomains_recv(struct tevent_req
*req
,
3283 TALLOC_CTX
*mem_ctx
,
3286 struct rpccli_netr_NetrEnumerateTrustedDomains_state
*state
= tevent_req_data(
3287 req
, struct rpccli_netr_NetrEnumerateTrustedDomains_state
);
3290 if (tevent_req_is_nterror(req
, &status
)) {
3291 tevent_req_received(req
);
3295 /* Steal possbile out parameters to the callers context */
3296 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3299 *result
= state
->orig
.out
.result
;
3301 tevent_req_received(req
);
3302 return NT_STATUS_OK
;
3305 NTSTATUS
rpccli_netr_NetrEnumerateTrustedDomains(struct rpc_pipe_client
*cli
,
3306 TALLOC_CTX
*mem_ctx
,
3307 const char *server_name
/* [in] [unique,charset(UTF16)] */,
3308 struct netr_Blob
*trusted_domains_blob
/* [out] [ref] */,
3311 struct netr_NetrEnumerateTrustedDomains r
;
3315 r
.in
.server_name
= server_name
;
3317 status
= cli
->dispatch(cli
,
3319 &ndr_table_netlogon
,
3320 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS
,
3323 if (!NT_STATUS_IS_OK(status
)) {
3327 if (NT_STATUS_IS_ERR(status
)) {
3331 /* Return variables */
3332 *trusted_domains_blob
= *r
.out
.trusted_domains_blob
;
3336 *werror
= r
.out
.result
;
3339 return werror_to_ntstatus(r
.out
.result
);
3342 struct rpccli_netr_DsRGetDCName_state
{
3343 struct netr_DsRGetDCName orig
;
3344 struct netr_DsRGetDCName tmp
;
3345 TALLOC_CTX
*out_mem_ctx
;
3346 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3349 static void rpccli_netr_DsRGetDCName_done(struct tevent_req
*subreq
);
3351 struct tevent_req
*rpccli_netr_DsRGetDCName_send(TALLOC_CTX
*mem_ctx
,
3352 struct tevent_context
*ev
,
3353 struct rpc_pipe_client
*cli
,
3354 const char *_server_unc
/* [in] [unique,charset(UTF16)] */,
3355 const char *_domain_name
/* [in] [unique,charset(UTF16)] */,
3356 struct GUID
*_domain_guid
/* [in] [unique] */,
3357 struct GUID
*_site_guid
/* [in] [unique] */,
3358 uint32_t _flags
/* [in] */,
3359 struct netr_DsRGetDCNameInfo
**_info
/* [out] [ref] */)
3361 struct tevent_req
*req
;
3362 struct rpccli_netr_DsRGetDCName_state
*state
;
3363 struct tevent_req
*subreq
;
3365 req
= tevent_req_create(mem_ctx
, &state
,
3366 struct rpccli_netr_DsRGetDCName_state
);
3370 state
->out_mem_ctx
= NULL
;
3371 state
->dispatch_recv
= cli
->dispatch_recv
;
3374 state
->orig
.in
.server_unc
= _server_unc
;
3375 state
->orig
.in
.domain_name
= _domain_name
;
3376 state
->orig
.in
.domain_guid
= _domain_guid
;
3377 state
->orig
.in
.site_guid
= _site_guid
;
3378 state
->orig
.in
.flags
= _flags
;
3380 /* Out parameters */
3381 state
->orig
.out
.info
= _info
;
3384 ZERO_STRUCT(state
->orig
.out
.result
);
3386 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3387 "rpccli_netr_DsRGetDCName_out_memory");
3388 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3389 return tevent_req_post(req
, ev
);
3392 /* make a temporary copy, that we pass to the dispatch function */
3393 state
->tmp
= state
->orig
;
3395 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3396 &ndr_table_netlogon
,
3397 NDR_NETR_DSRGETDCNAME
,
3399 if (tevent_req_nomem(subreq
, req
)) {
3400 return tevent_req_post(req
, ev
);
3402 tevent_req_set_callback(subreq
, rpccli_netr_DsRGetDCName_done
, req
);
3406 static void rpccli_netr_DsRGetDCName_done(struct tevent_req
*subreq
)
3408 struct tevent_req
*req
= tevent_req_callback_data(
3409 subreq
, struct tevent_req
);
3410 struct rpccli_netr_DsRGetDCName_state
*state
= tevent_req_data(
3411 req
, struct rpccli_netr_DsRGetDCName_state
);
3413 TALLOC_CTX
*mem_ctx
;
3415 if (state
->out_mem_ctx
) {
3416 mem_ctx
= state
->out_mem_ctx
;
3421 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3422 TALLOC_FREE(subreq
);
3423 if (!NT_STATUS_IS_OK(status
)) {
3424 tevent_req_nterror(req
, status
);
3428 /* Copy out parameters */
3429 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
3432 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3434 /* Reset temporary structure */
3435 ZERO_STRUCT(state
->tmp
);
3437 tevent_req_done(req
);
3440 NTSTATUS
rpccli_netr_DsRGetDCName_recv(struct tevent_req
*req
,
3441 TALLOC_CTX
*mem_ctx
,
3444 struct rpccli_netr_DsRGetDCName_state
*state
= tevent_req_data(
3445 req
, struct rpccli_netr_DsRGetDCName_state
);
3448 if (tevent_req_is_nterror(req
, &status
)) {
3449 tevent_req_received(req
);
3453 /* Steal possbile out parameters to the callers context */
3454 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3457 *result
= state
->orig
.out
.result
;
3459 tevent_req_received(req
);
3460 return NT_STATUS_OK
;
3463 NTSTATUS
rpccli_netr_DsRGetDCName(struct rpc_pipe_client
*cli
,
3464 TALLOC_CTX
*mem_ctx
,
3465 const char *server_unc
/* [in] [unique,charset(UTF16)] */,
3466 const char *domain_name
/* [in] [unique,charset(UTF16)] */,
3467 struct GUID
*domain_guid
/* [in] [unique] */,
3468 struct GUID
*site_guid
/* [in] [unique] */,
3469 uint32_t flags
/* [in] */,
3470 struct netr_DsRGetDCNameInfo
**info
/* [out] [ref] */,
3473 struct netr_DsRGetDCName r
;
3477 r
.in
.server_unc
= server_unc
;
3478 r
.in
.domain_name
= domain_name
;
3479 r
.in
.domain_guid
= domain_guid
;
3480 r
.in
.site_guid
= site_guid
;
3483 status
= cli
->dispatch(cli
,
3485 &ndr_table_netlogon
,
3486 NDR_NETR_DSRGETDCNAME
,
3489 if (!NT_STATUS_IS_OK(status
)) {
3493 if (NT_STATUS_IS_ERR(status
)) {
3497 /* Return variables */
3498 *info
= *r
.out
.info
;
3502 *werror
= r
.out
.result
;
3505 return werror_to_ntstatus(r
.out
.result
);
3508 struct rpccli_netr_LogonGetCapabilities_state
{
3509 struct netr_LogonGetCapabilities orig
;
3510 struct netr_LogonGetCapabilities tmp
;
3511 TALLOC_CTX
*out_mem_ctx
;
3512 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3515 static void rpccli_netr_LogonGetCapabilities_done(struct tevent_req
*subreq
);
3517 struct tevent_req
*rpccli_netr_LogonGetCapabilities_send(TALLOC_CTX
*mem_ctx
,
3518 struct tevent_context
*ev
,
3519 struct rpc_pipe_client
*cli
,
3520 const char *_server_name
/* [in] [ref,charset(UTF16)] */,
3521 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
3522 struct netr_Authenticator
*_credential
/* [in] [ref] */,
3523 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
3524 uint32_t _query_level
/* [in] */,
3525 union netr_Capabilities
*_capabilities
/* [out] [ref,switch_is(query_level)] */)
3527 struct tevent_req
*req
;
3528 struct rpccli_netr_LogonGetCapabilities_state
*state
;
3529 struct tevent_req
*subreq
;
3531 req
= tevent_req_create(mem_ctx
, &state
,
3532 struct rpccli_netr_LogonGetCapabilities_state
);
3536 state
->out_mem_ctx
= NULL
;
3537 state
->dispatch_recv
= cli
->dispatch_recv
;
3540 state
->orig
.in
.server_name
= _server_name
;
3541 state
->orig
.in
.computer_name
= _computer_name
;
3542 state
->orig
.in
.credential
= _credential
;
3543 state
->orig
.in
.return_authenticator
= _return_authenticator
;
3544 state
->orig
.in
.query_level
= _query_level
;
3546 /* Out parameters */
3547 state
->orig
.out
.return_authenticator
= _return_authenticator
;
3548 state
->orig
.out
.capabilities
= _capabilities
;
3551 ZERO_STRUCT(state
->orig
.out
.result
);
3553 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3554 "rpccli_netr_LogonGetCapabilities_out_memory");
3555 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3556 return tevent_req_post(req
, ev
);
3559 /* make a temporary copy, that we pass to the dispatch function */
3560 state
->tmp
= state
->orig
;
3562 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3563 &ndr_table_netlogon
,
3564 NDR_NETR_LOGONGETCAPABILITIES
,
3566 if (tevent_req_nomem(subreq
, req
)) {
3567 return tevent_req_post(req
, ev
);
3569 tevent_req_set_callback(subreq
, rpccli_netr_LogonGetCapabilities_done
, req
);
3573 static void rpccli_netr_LogonGetCapabilities_done(struct tevent_req
*subreq
)
3575 struct tevent_req
*req
= tevent_req_callback_data(
3576 subreq
, struct tevent_req
);
3577 struct rpccli_netr_LogonGetCapabilities_state
*state
= tevent_req_data(
3578 req
, struct rpccli_netr_LogonGetCapabilities_state
);
3580 TALLOC_CTX
*mem_ctx
;
3582 if (state
->out_mem_ctx
) {
3583 mem_ctx
= state
->out_mem_ctx
;
3588 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3589 TALLOC_FREE(subreq
);
3590 if (!NT_STATUS_IS_OK(status
)) {
3591 tevent_req_nterror(req
, status
);
3595 /* Copy out parameters */
3596 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
3597 *state
->orig
.out
.capabilities
= *state
->tmp
.out
.capabilities
;
3600 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3602 /* Reset temporary structure */
3603 ZERO_STRUCT(state
->tmp
);
3605 tevent_req_done(req
);
3608 NTSTATUS
rpccli_netr_LogonGetCapabilities_recv(struct tevent_req
*req
,
3609 TALLOC_CTX
*mem_ctx
,
3612 struct rpccli_netr_LogonGetCapabilities_state
*state
= tevent_req_data(
3613 req
, struct rpccli_netr_LogonGetCapabilities_state
);
3616 if (tevent_req_is_nterror(req
, &status
)) {
3617 tevent_req_received(req
);
3621 /* Steal possbile out parameters to the callers context */
3622 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3625 *result
= state
->orig
.out
.result
;
3627 tevent_req_received(req
);
3628 return NT_STATUS_OK
;
3631 NTSTATUS
rpccli_netr_LogonGetCapabilities(struct rpc_pipe_client
*cli
,
3632 TALLOC_CTX
*mem_ctx
,
3633 const char *server_name
/* [in] [ref,charset(UTF16)] */,
3634 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
3635 struct netr_Authenticator
*credential
/* [in] [ref] */,
3636 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
3637 uint32_t query_level
/* [in] */,
3638 union netr_Capabilities
*capabilities
/* [out] [ref,switch_is(query_level)] */)
3640 struct netr_LogonGetCapabilities r
;
3644 r
.in
.server_name
= server_name
;
3645 r
.in
.computer_name
= computer_name
;
3646 r
.in
.credential
= credential
;
3647 r
.in
.return_authenticator
= return_authenticator
;
3648 r
.in
.query_level
= query_level
;
3650 status
= cli
->dispatch(cli
,
3652 &ndr_table_netlogon
,
3653 NDR_NETR_LOGONGETCAPABILITIES
,
3656 if (!NT_STATUS_IS_OK(status
)) {
3660 if (NT_STATUS_IS_ERR(status
)) {
3664 /* Return variables */
3665 *return_authenticator
= *r
.out
.return_authenticator
;
3666 *capabilities
= *r
.out
.capabilities
;
3669 return r
.out
.result
;
3672 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
{
3673 struct netr_NETRLOGONSETSERVICEBITS orig
;
3674 struct netr_NETRLOGONSETSERVICEBITS tmp
;
3675 TALLOC_CTX
*out_mem_ctx
;
3676 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3679 static void rpccli_netr_NETRLOGONSETSERVICEBITS_done(struct tevent_req
*subreq
);
3681 struct tevent_req
*rpccli_netr_NETRLOGONSETSERVICEBITS_send(TALLOC_CTX
*mem_ctx
,
3682 struct tevent_context
*ev
,
3683 struct rpc_pipe_client
*cli
)
3685 struct tevent_req
*req
;
3686 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
*state
;
3687 struct tevent_req
*subreq
;
3689 req
= tevent_req_create(mem_ctx
, &state
,
3690 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
);
3694 state
->out_mem_ctx
= NULL
;
3695 state
->dispatch_recv
= cli
->dispatch_recv
;
3699 /* Out parameters */
3702 ZERO_STRUCT(state
->orig
.out
.result
);
3704 /* make a temporary copy, that we pass to the dispatch function */
3705 state
->tmp
= state
->orig
;
3707 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3708 &ndr_table_netlogon
,
3709 NDR_NETR_NETRLOGONSETSERVICEBITS
,
3711 if (tevent_req_nomem(subreq
, req
)) {
3712 return tevent_req_post(req
, ev
);
3714 tevent_req_set_callback(subreq
, rpccli_netr_NETRLOGONSETSERVICEBITS_done
, req
);
3718 static void rpccli_netr_NETRLOGONSETSERVICEBITS_done(struct tevent_req
*subreq
)
3720 struct tevent_req
*req
= tevent_req_callback_data(
3721 subreq
, struct tevent_req
);
3722 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
*state
= tevent_req_data(
3723 req
, struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
);
3725 TALLOC_CTX
*mem_ctx
;
3727 if (state
->out_mem_ctx
) {
3728 mem_ctx
= state
->out_mem_ctx
;
3733 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3734 TALLOC_FREE(subreq
);
3735 if (!NT_STATUS_IS_OK(status
)) {
3736 tevent_req_nterror(req
, status
);
3740 /* Copy out parameters */
3743 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3745 /* Reset temporary structure */
3746 ZERO_STRUCT(state
->tmp
);
3748 tevent_req_done(req
);
3751 NTSTATUS
rpccli_netr_NETRLOGONSETSERVICEBITS_recv(struct tevent_req
*req
,
3752 TALLOC_CTX
*mem_ctx
,
3755 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
*state
= tevent_req_data(
3756 req
, struct rpccli_netr_NETRLOGONSETSERVICEBITS_state
);
3759 if (tevent_req_is_nterror(req
, &status
)) {
3760 tevent_req_received(req
);
3764 /* Steal possbile out parameters to the callers context */
3765 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3768 *result
= state
->orig
.out
.result
;
3770 tevent_req_received(req
);
3771 return NT_STATUS_OK
;
3774 NTSTATUS
rpccli_netr_NETRLOGONSETSERVICEBITS(struct rpc_pipe_client
*cli
,
3775 TALLOC_CTX
*mem_ctx
,
3778 struct netr_NETRLOGONSETSERVICEBITS r
;
3783 status
= cli
->dispatch(cli
,
3785 &ndr_table_netlogon
,
3786 NDR_NETR_NETRLOGONSETSERVICEBITS
,
3789 if (!NT_STATUS_IS_OK(status
)) {
3793 if (NT_STATUS_IS_ERR(status
)) {
3797 /* Return variables */
3801 *werror
= r
.out
.result
;
3804 return werror_to_ntstatus(r
.out
.result
);
3807 struct rpccli_netr_LogonGetTrustRid_state
{
3808 struct netr_LogonGetTrustRid orig
;
3809 struct netr_LogonGetTrustRid tmp
;
3810 TALLOC_CTX
*out_mem_ctx
;
3811 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3814 static void rpccli_netr_LogonGetTrustRid_done(struct tevent_req
*subreq
);
3816 struct tevent_req
*rpccli_netr_LogonGetTrustRid_send(TALLOC_CTX
*mem_ctx
,
3817 struct tevent_context
*ev
,
3818 struct rpc_pipe_client
*cli
,
3819 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
3820 const char *_domain_name
/* [in] [unique,charset(UTF16)] */,
3821 uint32_t *_rid
/* [out] [ref] */)
3823 struct tevent_req
*req
;
3824 struct rpccli_netr_LogonGetTrustRid_state
*state
;
3825 struct tevent_req
*subreq
;
3827 req
= tevent_req_create(mem_ctx
, &state
,
3828 struct rpccli_netr_LogonGetTrustRid_state
);
3832 state
->out_mem_ctx
= NULL
;
3833 state
->dispatch_recv
= cli
->dispatch_recv
;
3836 state
->orig
.in
.server_name
= _server_name
;
3837 state
->orig
.in
.domain_name
= _domain_name
;
3839 /* Out parameters */
3840 state
->orig
.out
.rid
= _rid
;
3843 ZERO_STRUCT(state
->orig
.out
.result
);
3845 state
->out_mem_ctx
= talloc_named_const(state
, 0,
3846 "rpccli_netr_LogonGetTrustRid_out_memory");
3847 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
3848 return tevent_req_post(req
, ev
);
3851 /* make a temporary copy, that we pass to the dispatch function */
3852 state
->tmp
= state
->orig
;
3854 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3855 &ndr_table_netlogon
,
3856 NDR_NETR_LOGONGETTRUSTRID
,
3858 if (tevent_req_nomem(subreq
, req
)) {
3859 return tevent_req_post(req
, ev
);
3861 tevent_req_set_callback(subreq
, rpccli_netr_LogonGetTrustRid_done
, req
);
3865 static void rpccli_netr_LogonGetTrustRid_done(struct tevent_req
*subreq
)
3867 struct tevent_req
*req
= tevent_req_callback_data(
3868 subreq
, struct tevent_req
);
3869 struct rpccli_netr_LogonGetTrustRid_state
*state
= tevent_req_data(
3870 req
, struct rpccli_netr_LogonGetTrustRid_state
);
3872 TALLOC_CTX
*mem_ctx
;
3874 if (state
->out_mem_ctx
) {
3875 mem_ctx
= state
->out_mem_ctx
;
3880 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3881 TALLOC_FREE(subreq
);
3882 if (!NT_STATUS_IS_OK(status
)) {
3883 tevent_req_nterror(req
, status
);
3887 /* Copy out parameters */
3888 *state
->orig
.out
.rid
= *state
->tmp
.out
.rid
;
3891 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3893 /* Reset temporary structure */
3894 ZERO_STRUCT(state
->tmp
);
3896 tevent_req_done(req
);
3899 NTSTATUS
rpccli_netr_LogonGetTrustRid_recv(struct tevent_req
*req
,
3900 TALLOC_CTX
*mem_ctx
,
3903 struct rpccli_netr_LogonGetTrustRid_state
*state
= tevent_req_data(
3904 req
, struct rpccli_netr_LogonGetTrustRid_state
);
3907 if (tevent_req_is_nterror(req
, &status
)) {
3908 tevent_req_received(req
);
3912 /* Steal possbile out parameters to the callers context */
3913 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3916 *result
= state
->orig
.out
.result
;
3918 tevent_req_received(req
);
3919 return NT_STATUS_OK
;
3922 NTSTATUS
rpccli_netr_LogonGetTrustRid(struct rpc_pipe_client
*cli
,
3923 TALLOC_CTX
*mem_ctx
,
3924 const char *server_name
/* [in] [unique,charset(UTF16)] */,
3925 const char *domain_name
/* [in] [unique,charset(UTF16)] */,
3926 uint32_t *rid
/* [out] [ref] */,
3929 struct netr_LogonGetTrustRid r
;
3933 r
.in
.server_name
= server_name
;
3934 r
.in
.domain_name
= domain_name
;
3936 status
= cli
->dispatch(cli
,
3938 &ndr_table_netlogon
,
3939 NDR_NETR_LOGONGETTRUSTRID
,
3942 if (!NT_STATUS_IS_OK(status
)) {
3946 if (NT_STATUS_IS_ERR(status
)) {
3950 /* Return variables */
3955 *werror
= r
.out
.result
;
3958 return werror_to_ntstatus(r
.out
.result
);
3961 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
{
3962 struct netr_NETRLOGONCOMPUTESERVERDIGEST orig
;
3963 struct netr_NETRLOGONCOMPUTESERVERDIGEST tmp
;
3964 TALLOC_CTX
*out_mem_ctx
;
3965 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3968 static void rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done(struct tevent_req
*subreq
);
3970 struct tevent_req
*rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_send(TALLOC_CTX
*mem_ctx
,
3971 struct tevent_context
*ev
,
3972 struct rpc_pipe_client
*cli
)
3974 struct tevent_req
*req
;
3975 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
*state
;
3976 struct tevent_req
*subreq
;
3978 req
= tevent_req_create(mem_ctx
, &state
,
3979 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
);
3983 state
->out_mem_ctx
= NULL
;
3984 state
->dispatch_recv
= cli
->dispatch_recv
;
3988 /* Out parameters */
3991 ZERO_STRUCT(state
->orig
.out
.result
);
3993 /* make a temporary copy, that we pass to the dispatch function */
3994 state
->tmp
= state
->orig
;
3996 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3997 &ndr_table_netlogon
,
3998 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
,
4000 if (tevent_req_nomem(subreq
, req
)) {
4001 return tevent_req_post(req
, ev
);
4003 tevent_req_set_callback(subreq
, rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done
, req
);
4007 static void rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done(struct tevent_req
*subreq
)
4009 struct tevent_req
*req
= tevent_req_callback_data(
4010 subreq
, struct tevent_req
);
4011 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
*state
= tevent_req_data(
4012 req
, struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
);
4014 TALLOC_CTX
*mem_ctx
;
4016 if (state
->out_mem_ctx
) {
4017 mem_ctx
= state
->out_mem_ctx
;
4022 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4023 TALLOC_FREE(subreq
);
4024 if (!NT_STATUS_IS_OK(status
)) {
4025 tevent_req_nterror(req
, status
);
4029 /* Copy out parameters */
4032 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4034 /* Reset temporary structure */
4035 ZERO_STRUCT(state
->tmp
);
4037 tevent_req_done(req
);
4040 NTSTATUS
rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_recv(struct tevent_req
*req
,
4041 TALLOC_CTX
*mem_ctx
,
4044 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
*state
= tevent_req_data(
4045 req
, struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state
);
4048 if (tevent_req_is_nterror(req
, &status
)) {
4049 tevent_req_received(req
);
4053 /* Steal possbile out parameters to the callers context */
4054 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4057 *result
= state
->orig
.out
.result
;
4059 tevent_req_received(req
);
4060 return NT_STATUS_OK
;
4063 NTSTATUS
rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST(struct rpc_pipe_client
*cli
,
4064 TALLOC_CTX
*mem_ctx
,
4067 struct netr_NETRLOGONCOMPUTESERVERDIGEST r
;
4072 status
= cli
->dispatch(cli
,
4074 &ndr_table_netlogon
,
4075 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST
,
4078 if (!NT_STATUS_IS_OK(status
)) {
4082 if (NT_STATUS_IS_ERR(status
)) {
4086 /* Return variables */
4090 *werror
= r
.out
.result
;
4093 return werror_to_ntstatus(r
.out
.result
);
4096 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
{
4097 struct netr_NETRLOGONCOMPUTECLIENTDIGEST orig
;
4098 struct netr_NETRLOGONCOMPUTECLIENTDIGEST tmp
;
4099 TALLOC_CTX
*out_mem_ctx
;
4100 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4103 static void rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done(struct tevent_req
*subreq
);
4105 struct tevent_req
*rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_send(TALLOC_CTX
*mem_ctx
,
4106 struct tevent_context
*ev
,
4107 struct rpc_pipe_client
*cli
)
4109 struct tevent_req
*req
;
4110 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
*state
;
4111 struct tevent_req
*subreq
;
4113 req
= tevent_req_create(mem_ctx
, &state
,
4114 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
);
4118 state
->out_mem_ctx
= NULL
;
4119 state
->dispatch_recv
= cli
->dispatch_recv
;
4123 /* Out parameters */
4126 ZERO_STRUCT(state
->orig
.out
.result
);
4128 /* make a temporary copy, that we pass to the dispatch function */
4129 state
->tmp
= state
->orig
;
4131 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4132 &ndr_table_netlogon
,
4133 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
,
4135 if (tevent_req_nomem(subreq
, req
)) {
4136 return tevent_req_post(req
, ev
);
4138 tevent_req_set_callback(subreq
, rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done
, req
);
4142 static void rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done(struct tevent_req
*subreq
)
4144 struct tevent_req
*req
= tevent_req_callback_data(
4145 subreq
, struct tevent_req
);
4146 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
*state
= tevent_req_data(
4147 req
, struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
);
4149 TALLOC_CTX
*mem_ctx
;
4151 if (state
->out_mem_ctx
) {
4152 mem_ctx
= state
->out_mem_ctx
;
4157 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4158 TALLOC_FREE(subreq
);
4159 if (!NT_STATUS_IS_OK(status
)) {
4160 tevent_req_nterror(req
, status
);
4164 /* Copy out parameters */
4167 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4169 /* Reset temporary structure */
4170 ZERO_STRUCT(state
->tmp
);
4172 tevent_req_done(req
);
4175 NTSTATUS
rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_recv(struct tevent_req
*req
,
4176 TALLOC_CTX
*mem_ctx
,
4179 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
*state
= tevent_req_data(
4180 req
, struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state
);
4183 if (tevent_req_is_nterror(req
, &status
)) {
4184 tevent_req_received(req
);
4188 /* Steal possbile out parameters to the callers context */
4189 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4192 *result
= state
->orig
.out
.result
;
4194 tevent_req_received(req
);
4195 return NT_STATUS_OK
;
4198 NTSTATUS
rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST(struct rpc_pipe_client
*cli
,
4199 TALLOC_CTX
*mem_ctx
,
4202 struct netr_NETRLOGONCOMPUTECLIENTDIGEST r
;
4207 status
= cli
->dispatch(cli
,
4209 &ndr_table_netlogon
,
4210 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST
,
4213 if (!NT_STATUS_IS_OK(status
)) {
4217 if (NT_STATUS_IS_ERR(status
)) {
4221 /* Return variables */
4225 *werror
= r
.out
.result
;
4228 return werror_to_ntstatus(r
.out
.result
);
4231 struct rpccli_netr_ServerAuthenticate3_state
{
4232 struct netr_ServerAuthenticate3 orig
;
4233 struct netr_ServerAuthenticate3 tmp
;
4234 TALLOC_CTX
*out_mem_ctx
;
4235 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4238 static void rpccli_netr_ServerAuthenticate3_done(struct tevent_req
*subreq
);
4240 struct tevent_req
*rpccli_netr_ServerAuthenticate3_send(TALLOC_CTX
*mem_ctx
,
4241 struct tevent_context
*ev
,
4242 struct rpc_pipe_client
*cli
,
4243 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
4244 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
4245 enum netr_SchannelType _secure_channel_type
/* [in] */,
4246 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
4247 struct netr_Credential
*_credentials
/* [in] [ref] */,
4248 struct netr_Credential
*_return_credentials
/* [out] [ref] */,
4249 uint32_t *_negotiate_flags
/* [in,out] [ref] */,
4250 uint32_t *_rid
/* [out] [ref] */)
4252 struct tevent_req
*req
;
4253 struct rpccli_netr_ServerAuthenticate3_state
*state
;
4254 struct tevent_req
*subreq
;
4256 req
= tevent_req_create(mem_ctx
, &state
,
4257 struct rpccli_netr_ServerAuthenticate3_state
);
4261 state
->out_mem_ctx
= NULL
;
4262 state
->dispatch_recv
= cli
->dispatch_recv
;
4265 state
->orig
.in
.server_name
= _server_name
;
4266 state
->orig
.in
.account_name
= _account_name
;
4267 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
4268 state
->orig
.in
.computer_name
= _computer_name
;
4269 state
->orig
.in
.credentials
= _credentials
;
4270 state
->orig
.in
.negotiate_flags
= _negotiate_flags
;
4272 /* Out parameters */
4273 state
->orig
.out
.return_credentials
= _return_credentials
;
4274 state
->orig
.out
.negotiate_flags
= _negotiate_flags
;
4275 state
->orig
.out
.rid
= _rid
;
4278 ZERO_STRUCT(state
->orig
.out
.result
);
4280 state
->out_mem_ctx
= talloc_named_const(state
, 0,
4281 "rpccli_netr_ServerAuthenticate3_out_memory");
4282 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
4283 return tevent_req_post(req
, ev
);
4286 /* make a temporary copy, that we pass to the dispatch function */
4287 state
->tmp
= state
->orig
;
4289 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4290 &ndr_table_netlogon
,
4291 NDR_NETR_SERVERAUTHENTICATE3
,
4293 if (tevent_req_nomem(subreq
, req
)) {
4294 return tevent_req_post(req
, ev
);
4296 tevent_req_set_callback(subreq
, rpccli_netr_ServerAuthenticate3_done
, req
);
4300 static void rpccli_netr_ServerAuthenticate3_done(struct tevent_req
*subreq
)
4302 struct tevent_req
*req
= tevent_req_callback_data(
4303 subreq
, struct tevent_req
);
4304 struct rpccli_netr_ServerAuthenticate3_state
*state
= tevent_req_data(
4305 req
, struct rpccli_netr_ServerAuthenticate3_state
);
4307 TALLOC_CTX
*mem_ctx
;
4309 if (state
->out_mem_ctx
) {
4310 mem_ctx
= state
->out_mem_ctx
;
4315 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4316 TALLOC_FREE(subreq
);
4317 if (!NT_STATUS_IS_OK(status
)) {
4318 tevent_req_nterror(req
, status
);
4322 /* Copy out parameters */
4323 *state
->orig
.out
.return_credentials
= *state
->tmp
.out
.return_credentials
;
4324 *state
->orig
.out
.negotiate_flags
= *state
->tmp
.out
.negotiate_flags
;
4325 *state
->orig
.out
.rid
= *state
->tmp
.out
.rid
;
4328 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4330 /* Reset temporary structure */
4331 ZERO_STRUCT(state
->tmp
);
4333 tevent_req_done(req
);
4336 NTSTATUS
rpccli_netr_ServerAuthenticate3_recv(struct tevent_req
*req
,
4337 TALLOC_CTX
*mem_ctx
,
4340 struct rpccli_netr_ServerAuthenticate3_state
*state
= tevent_req_data(
4341 req
, struct rpccli_netr_ServerAuthenticate3_state
);
4344 if (tevent_req_is_nterror(req
, &status
)) {
4345 tevent_req_received(req
);
4349 /* Steal possbile out parameters to the callers context */
4350 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4353 *result
= state
->orig
.out
.result
;
4355 tevent_req_received(req
);
4356 return NT_STATUS_OK
;
4359 NTSTATUS
rpccli_netr_ServerAuthenticate3(struct rpc_pipe_client
*cli
,
4360 TALLOC_CTX
*mem_ctx
,
4361 const char *server_name
/* [in] [unique,charset(UTF16)] */,
4362 const char *account_name
/* [in] [ref,charset(UTF16)] */,
4363 enum netr_SchannelType secure_channel_type
/* [in] */,
4364 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
4365 struct netr_Credential
*credentials
/* [in] [ref] */,
4366 struct netr_Credential
*return_credentials
/* [out] [ref] */,
4367 uint32_t *negotiate_flags
/* [in,out] [ref] */,
4368 uint32_t *rid
/* [out] [ref] */)
4370 struct netr_ServerAuthenticate3 r
;
4374 r
.in
.server_name
= server_name
;
4375 r
.in
.account_name
= account_name
;
4376 r
.in
.secure_channel_type
= secure_channel_type
;
4377 r
.in
.computer_name
= computer_name
;
4378 r
.in
.credentials
= credentials
;
4379 r
.in
.negotiate_flags
= negotiate_flags
;
4381 status
= cli
->dispatch(cli
,
4383 &ndr_table_netlogon
,
4384 NDR_NETR_SERVERAUTHENTICATE3
,
4387 if (!NT_STATUS_IS_OK(status
)) {
4391 if (NT_STATUS_IS_ERR(status
)) {
4395 /* Return variables */
4396 *return_credentials
= *r
.out
.return_credentials
;
4397 *negotiate_flags
= *r
.out
.negotiate_flags
;
4401 return r
.out
.result
;
4404 struct rpccli_netr_DsRGetDCNameEx_state
{
4405 struct netr_DsRGetDCNameEx orig
;
4406 struct netr_DsRGetDCNameEx tmp
;
4407 TALLOC_CTX
*out_mem_ctx
;
4408 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4411 static void rpccli_netr_DsRGetDCNameEx_done(struct tevent_req
*subreq
);
4413 struct tevent_req
*rpccli_netr_DsRGetDCNameEx_send(TALLOC_CTX
*mem_ctx
,
4414 struct tevent_context
*ev
,
4415 struct rpc_pipe_client
*cli
,
4416 const char *_server_unc
/* [in] [unique,charset(UTF16)] */,
4417 const char *_domain_name
/* [in] [unique,charset(UTF16)] */,
4418 struct GUID
*_domain_guid
/* [in] [unique] */,
4419 const char *_site_name
/* [in] [unique,charset(UTF16)] */,
4420 uint32_t _flags
/* [in] */,
4421 struct netr_DsRGetDCNameInfo
**_info
/* [out] [ref] */)
4423 struct tevent_req
*req
;
4424 struct rpccli_netr_DsRGetDCNameEx_state
*state
;
4425 struct tevent_req
*subreq
;
4427 req
= tevent_req_create(mem_ctx
, &state
,
4428 struct rpccli_netr_DsRGetDCNameEx_state
);
4432 state
->out_mem_ctx
= NULL
;
4433 state
->dispatch_recv
= cli
->dispatch_recv
;
4436 state
->orig
.in
.server_unc
= _server_unc
;
4437 state
->orig
.in
.domain_name
= _domain_name
;
4438 state
->orig
.in
.domain_guid
= _domain_guid
;
4439 state
->orig
.in
.site_name
= _site_name
;
4440 state
->orig
.in
.flags
= _flags
;
4442 /* Out parameters */
4443 state
->orig
.out
.info
= _info
;
4446 ZERO_STRUCT(state
->orig
.out
.result
);
4448 state
->out_mem_ctx
= talloc_named_const(state
, 0,
4449 "rpccli_netr_DsRGetDCNameEx_out_memory");
4450 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
4451 return tevent_req_post(req
, ev
);
4454 /* make a temporary copy, that we pass to the dispatch function */
4455 state
->tmp
= state
->orig
;
4457 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4458 &ndr_table_netlogon
,
4459 NDR_NETR_DSRGETDCNAMEEX
,
4461 if (tevent_req_nomem(subreq
, req
)) {
4462 return tevent_req_post(req
, ev
);
4464 tevent_req_set_callback(subreq
, rpccli_netr_DsRGetDCNameEx_done
, req
);
4468 static void rpccli_netr_DsRGetDCNameEx_done(struct tevent_req
*subreq
)
4470 struct tevent_req
*req
= tevent_req_callback_data(
4471 subreq
, struct tevent_req
);
4472 struct rpccli_netr_DsRGetDCNameEx_state
*state
= tevent_req_data(
4473 req
, struct rpccli_netr_DsRGetDCNameEx_state
);
4475 TALLOC_CTX
*mem_ctx
;
4477 if (state
->out_mem_ctx
) {
4478 mem_ctx
= state
->out_mem_ctx
;
4483 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4484 TALLOC_FREE(subreq
);
4485 if (!NT_STATUS_IS_OK(status
)) {
4486 tevent_req_nterror(req
, status
);
4490 /* Copy out parameters */
4491 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
4494 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4496 /* Reset temporary structure */
4497 ZERO_STRUCT(state
->tmp
);
4499 tevent_req_done(req
);
4502 NTSTATUS
rpccli_netr_DsRGetDCNameEx_recv(struct tevent_req
*req
,
4503 TALLOC_CTX
*mem_ctx
,
4506 struct rpccli_netr_DsRGetDCNameEx_state
*state
= tevent_req_data(
4507 req
, struct rpccli_netr_DsRGetDCNameEx_state
);
4510 if (tevent_req_is_nterror(req
, &status
)) {
4511 tevent_req_received(req
);
4515 /* Steal possbile out parameters to the callers context */
4516 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4519 *result
= state
->orig
.out
.result
;
4521 tevent_req_received(req
);
4522 return NT_STATUS_OK
;
4525 NTSTATUS
rpccli_netr_DsRGetDCNameEx(struct rpc_pipe_client
*cli
,
4526 TALLOC_CTX
*mem_ctx
,
4527 const char *server_unc
/* [in] [unique,charset(UTF16)] */,
4528 const char *domain_name
/* [in] [unique,charset(UTF16)] */,
4529 struct GUID
*domain_guid
/* [in] [unique] */,
4530 const char *site_name
/* [in] [unique,charset(UTF16)] */,
4531 uint32_t flags
/* [in] */,
4532 struct netr_DsRGetDCNameInfo
**info
/* [out] [ref] */,
4535 struct netr_DsRGetDCNameEx r
;
4539 r
.in
.server_unc
= server_unc
;
4540 r
.in
.domain_name
= domain_name
;
4541 r
.in
.domain_guid
= domain_guid
;
4542 r
.in
.site_name
= site_name
;
4545 status
= cli
->dispatch(cli
,
4547 &ndr_table_netlogon
,
4548 NDR_NETR_DSRGETDCNAMEEX
,
4551 if (!NT_STATUS_IS_OK(status
)) {
4555 if (NT_STATUS_IS_ERR(status
)) {
4559 /* Return variables */
4560 *info
= *r
.out
.info
;
4564 *werror
= r
.out
.result
;
4567 return werror_to_ntstatus(r
.out
.result
);
4570 struct rpccli_netr_DsRGetSiteName_state
{
4571 struct netr_DsRGetSiteName orig
;
4572 struct netr_DsRGetSiteName tmp
;
4573 TALLOC_CTX
*out_mem_ctx
;
4574 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4577 static void rpccli_netr_DsRGetSiteName_done(struct tevent_req
*subreq
);
4579 struct tevent_req
*rpccli_netr_DsRGetSiteName_send(TALLOC_CTX
*mem_ctx
,
4580 struct tevent_context
*ev
,
4581 struct rpc_pipe_client
*cli
,
4582 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
4583 const char **_site
/* [out] [ref,charset(UTF16)] */)
4585 struct tevent_req
*req
;
4586 struct rpccli_netr_DsRGetSiteName_state
*state
;
4587 struct tevent_req
*subreq
;
4589 req
= tevent_req_create(mem_ctx
, &state
,
4590 struct rpccli_netr_DsRGetSiteName_state
);
4594 state
->out_mem_ctx
= NULL
;
4595 state
->dispatch_recv
= cli
->dispatch_recv
;
4598 state
->orig
.in
.computer_name
= _computer_name
;
4600 /* Out parameters */
4601 state
->orig
.out
.site
= _site
;
4604 ZERO_STRUCT(state
->orig
.out
.result
);
4606 state
->out_mem_ctx
= talloc_named_const(state
, 0,
4607 "rpccli_netr_DsRGetSiteName_out_memory");
4608 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
4609 return tevent_req_post(req
, ev
);
4612 /* make a temporary copy, that we pass to the dispatch function */
4613 state
->tmp
= state
->orig
;
4615 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4616 &ndr_table_netlogon
,
4617 NDR_NETR_DSRGETSITENAME
,
4619 if (tevent_req_nomem(subreq
, req
)) {
4620 return tevent_req_post(req
, ev
);
4622 tevent_req_set_callback(subreq
, rpccli_netr_DsRGetSiteName_done
, req
);
4626 static void rpccli_netr_DsRGetSiteName_done(struct tevent_req
*subreq
)
4628 struct tevent_req
*req
= tevent_req_callback_data(
4629 subreq
, struct tevent_req
);
4630 struct rpccli_netr_DsRGetSiteName_state
*state
= tevent_req_data(
4631 req
, struct rpccli_netr_DsRGetSiteName_state
);
4633 TALLOC_CTX
*mem_ctx
;
4635 if (state
->out_mem_ctx
) {
4636 mem_ctx
= state
->out_mem_ctx
;
4641 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4642 TALLOC_FREE(subreq
);
4643 if (!NT_STATUS_IS_OK(status
)) {
4644 tevent_req_nterror(req
, status
);
4648 /* Copy out parameters */
4649 *state
->orig
.out
.site
= *state
->tmp
.out
.site
;
4652 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4654 /* Reset temporary structure */
4655 ZERO_STRUCT(state
->tmp
);
4657 tevent_req_done(req
);
4660 NTSTATUS
rpccli_netr_DsRGetSiteName_recv(struct tevent_req
*req
,
4661 TALLOC_CTX
*mem_ctx
,
4664 struct rpccli_netr_DsRGetSiteName_state
*state
= tevent_req_data(
4665 req
, struct rpccli_netr_DsRGetSiteName_state
);
4668 if (tevent_req_is_nterror(req
, &status
)) {
4669 tevent_req_received(req
);
4673 /* Steal possbile out parameters to the callers context */
4674 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4677 *result
= state
->orig
.out
.result
;
4679 tevent_req_received(req
);
4680 return NT_STATUS_OK
;
4683 NTSTATUS
rpccli_netr_DsRGetSiteName(struct rpc_pipe_client
*cli
,
4684 TALLOC_CTX
*mem_ctx
,
4685 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
4686 const char **site
/* [out] [ref,charset(UTF16)] */,
4689 struct netr_DsRGetSiteName r
;
4693 r
.in
.computer_name
= computer_name
;
4695 status
= cli
->dispatch(cli
,
4697 &ndr_table_netlogon
,
4698 NDR_NETR_DSRGETSITENAME
,
4701 if (!NT_STATUS_IS_OK(status
)) {
4705 if (NT_STATUS_IS_ERR(status
)) {
4709 /* Return variables */
4710 *site
= *r
.out
.site
;
4714 *werror
= r
.out
.result
;
4717 return werror_to_ntstatus(r
.out
.result
);
4720 struct rpccli_netr_LogonGetDomainInfo_state
{
4721 struct netr_LogonGetDomainInfo orig
;
4722 struct netr_LogonGetDomainInfo tmp
;
4723 TALLOC_CTX
*out_mem_ctx
;
4724 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4727 static void rpccli_netr_LogonGetDomainInfo_done(struct tevent_req
*subreq
);
4729 struct tevent_req
*rpccli_netr_LogonGetDomainInfo_send(TALLOC_CTX
*mem_ctx
,
4730 struct tevent_context
*ev
,
4731 struct rpc_pipe_client
*cli
,
4732 const char *_server_name
/* [in] [ref,charset(UTF16)] */,
4733 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
4734 struct netr_Authenticator
*_credential
/* [in] [ref] */,
4735 struct netr_Authenticator
*_return_authenticator
/* [in,out] [ref] */,
4736 uint32_t _level
/* [in] */,
4737 union netr_WorkstationInfo
*_query
/* [in] [ref,switch_is(level)] */,
4738 union netr_DomainInfo
*_info
/* [out] [ref,switch_is(level)] */)
4740 struct tevent_req
*req
;
4741 struct rpccli_netr_LogonGetDomainInfo_state
*state
;
4742 struct tevent_req
*subreq
;
4744 req
= tevent_req_create(mem_ctx
, &state
,
4745 struct rpccli_netr_LogonGetDomainInfo_state
);
4749 state
->out_mem_ctx
= NULL
;
4750 state
->dispatch_recv
= cli
->dispatch_recv
;
4753 state
->orig
.in
.server_name
= _server_name
;
4754 state
->orig
.in
.computer_name
= _computer_name
;
4755 state
->orig
.in
.credential
= _credential
;
4756 state
->orig
.in
.return_authenticator
= _return_authenticator
;
4757 state
->orig
.in
.level
= _level
;
4758 state
->orig
.in
.query
= _query
;
4760 /* Out parameters */
4761 state
->orig
.out
.return_authenticator
= _return_authenticator
;
4762 state
->orig
.out
.info
= _info
;
4765 ZERO_STRUCT(state
->orig
.out
.result
);
4767 state
->out_mem_ctx
= talloc_named_const(state
, 0,
4768 "rpccli_netr_LogonGetDomainInfo_out_memory");
4769 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
4770 return tevent_req_post(req
, ev
);
4773 /* make a temporary copy, that we pass to the dispatch function */
4774 state
->tmp
= state
->orig
;
4776 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4777 &ndr_table_netlogon
,
4778 NDR_NETR_LOGONGETDOMAININFO
,
4780 if (tevent_req_nomem(subreq
, req
)) {
4781 return tevent_req_post(req
, ev
);
4783 tevent_req_set_callback(subreq
, rpccli_netr_LogonGetDomainInfo_done
, req
);
4787 static void rpccli_netr_LogonGetDomainInfo_done(struct tevent_req
*subreq
)
4789 struct tevent_req
*req
= tevent_req_callback_data(
4790 subreq
, struct tevent_req
);
4791 struct rpccli_netr_LogonGetDomainInfo_state
*state
= tevent_req_data(
4792 req
, struct rpccli_netr_LogonGetDomainInfo_state
);
4794 TALLOC_CTX
*mem_ctx
;
4796 if (state
->out_mem_ctx
) {
4797 mem_ctx
= state
->out_mem_ctx
;
4802 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4803 TALLOC_FREE(subreq
);
4804 if (!NT_STATUS_IS_OK(status
)) {
4805 tevent_req_nterror(req
, status
);
4809 /* Copy out parameters */
4810 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
4811 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
4814 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4816 /* Reset temporary structure */
4817 ZERO_STRUCT(state
->tmp
);
4819 tevent_req_done(req
);
4822 NTSTATUS
rpccli_netr_LogonGetDomainInfo_recv(struct tevent_req
*req
,
4823 TALLOC_CTX
*mem_ctx
,
4826 struct rpccli_netr_LogonGetDomainInfo_state
*state
= tevent_req_data(
4827 req
, struct rpccli_netr_LogonGetDomainInfo_state
);
4830 if (tevent_req_is_nterror(req
, &status
)) {
4831 tevent_req_received(req
);
4835 /* Steal possbile out parameters to the callers context */
4836 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4839 *result
= state
->orig
.out
.result
;
4841 tevent_req_received(req
);
4842 return NT_STATUS_OK
;
4845 NTSTATUS
rpccli_netr_LogonGetDomainInfo(struct rpc_pipe_client
*cli
,
4846 TALLOC_CTX
*mem_ctx
,
4847 const char *server_name
/* [in] [ref,charset(UTF16)] */,
4848 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
4849 struct netr_Authenticator
*credential
/* [in] [ref] */,
4850 struct netr_Authenticator
*return_authenticator
/* [in,out] [ref] */,
4851 uint32_t level
/* [in] */,
4852 union netr_WorkstationInfo
*query
/* [in] [ref,switch_is(level)] */,
4853 union netr_DomainInfo
*info
/* [out] [ref,switch_is(level)] */)
4855 struct netr_LogonGetDomainInfo r
;
4859 r
.in
.server_name
= server_name
;
4860 r
.in
.computer_name
= computer_name
;
4861 r
.in
.credential
= credential
;
4862 r
.in
.return_authenticator
= return_authenticator
;
4866 status
= cli
->dispatch(cli
,
4868 &ndr_table_netlogon
,
4869 NDR_NETR_LOGONGETDOMAININFO
,
4872 if (!NT_STATUS_IS_OK(status
)) {
4876 if (NT_STATUS_IS_ERR(status
)) {
4880 /* Return variables */
4881 *return_authenticator
= *r
.out
.return_authenticator
;
4882 *info
= *r
.out
.info
;
4885 return r
.out
.result
;
4888 struct rpccli_netr_ServerPasswordSet2_state
{
4889 struct netr_ServerPasswordSet2 orig
;
4890 struct netr_ServerPasswordSet2 tmp
;
4891 TALLOC_CTX
*out_mem_ctx
;
4892 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4895 static void rpccli_netr_ServerPasswordSet2_done(struct tevent_req
*subreq
);
4897 struct tevent_req
*rpccli_netr_ServerPasswordSet2_send(TALLOC_CTX
*mem_ctx
,
4898 struct tevent_context
*ev
,
4899 struct rpc_pipe_client
*cli
,
4900 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
4901 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
4902 enum netr_SchannelType _secure_channel_type
/* [in] */,
4903 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
4904 struct netr_Authenticator
*_credential
/* [in] [ref] */,
4905 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
4906 struct netr_CryptPassword
*_new_password
/* [in] [ref] */)
4908 struct tevent_req
*req
;
4909 struct rpccli_netr_ServerPasswordSet2_state
*state
;
4910 struct tevent_req
*subreq
;
4912 req
= tevent_req_create(mem_ctx
, &state
,
4913 struct rpccli_netr_ServerPasswordSet2_state
);
4917 state
->out_mem_ctx
= NULL
;
4918 state
->dispatch_recv
= cli
->dispatch_recv
;
4921 state
->orig
.in
.server_name
= _server_name
;
4922 state
->orig
.in
.account_name
= _account_name
;
4923 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
4924 state
->orig
.in
.computer_name
= _computer_name
;
4925 state
->orig
.in
.credential
= _credential
;
4926 state
->orig
.in
.new_password
= _new_password
;
4928 /* Out parameters */
4929 state
->orig
.out
.return_authenticator
= _return_authenticator
;
4932 ZERO_STRUCT(state
->orig
.out
.result
);
4934 state
->out_mem_ctx
= talloc_named_const(state
, 0,
4935 "rpccli_netr_ServerPasswordSet2_out_memory");
4936 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
4937 return tevent_req_post(req
, ev
);
4940 /* make a temporary copy, that we pass to the dispatch function */
4941 state
->tmp
= state
->orig
;
4943 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4944 &ndr_table_netlogon
,
4945 NDR_NETR_SERVERPASSWORDSET2
,
4947 if (tevent_req_nomem(subreq
, req
)) {
4948 return tevent_req_post(req
, ev
);
4950 tevent_req_set_callback(subreq
, rpccli_netr_ServerPasswordSet2_done
, req
);
4954 static void rpccli_netr_ServerPasswordSet2_done(struct tevent_req
*subreq
)
4956 struct tevent_req
*req
= tevent_req_callback_data(
4957 subreq
, struct tevent_req
);
4958 struct rpccli_netr_ServerPasswordSet2_state
*state
= tevent_req_data(
4959 req
, struct rpccli_netr_ServerPasswordSet2_state
);
4961 TALLOC_CTX
*mem_ctx
;
4963 if (state
->out_mem_ctx
) {
4964 mem_ctx
= state
->out_mem_ctx
;
4969 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4970 TALLOC_FREE(subreq
);
4971 if (!NT_STATUS_IS_OK(status
)) {
4972 tevent_req_nterror(req
, status
);
4976 /* Copy out parameters */
4977 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
4980 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4982 /* Reset temporary structure */
4983 ZERO_STRUCT(state
->tmp
);
4985 tevent_req_done(req
);
4988 NTSTATUS
rpccli_netr_ServerPasswordSet2_recv(struct tevent_req
*req
,
4989 TALLOC_CTX
*mem_ctx
,
4992 struct rpccli_netr_ServerPasswordSet2_state
*state
= tevent_req_data(
4993 req
, struct rpccli_netr_ServerPasswordSet2_state
);
4996 if (tevent_req_is_nterror(req
, &status
)) {
4997 tevent_req_received(req
);
5001 /* Steal possbile out parameters to the callers context */
5002 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5005 *result
= state
->orig
.out
.result
;
5007 tevent_req_received(req
);
5008 return NT_STATUS_OK
;
5011 NTSTATUS
rpccli_netr_ServerPasswordSet2(struct rpc_pipe_client
*cli
,
5012 TALLOC_CTX
*mem_ctx
,
5013 const char *server_name
/* [in] [unique,charset(UTF16)] */,
5014 const char *account_name
/* [in] [ref,charset(UTF16)] */,
5015 enum netr_SchannelType secure_channel_type
/* [in] */,
5016 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
5017 struct netr_Authenticator
*credential
/* [in] [ref] */,
5018 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
5019 struct netr_CryptPassword
*new_password
/* [in] [ref] */)
5021 struct netr_ServerPasswordSet2 r
;
5025 r
.in
.server_name
= server_name
;
5026 r
.in
.account_name
= account_name
;
5027 r
.in
.secure_channel_type
= secure_channel_type
;
5028 r
.in
.computer_name
= computer_name
;
5029 r
.in
.credential
= credential
;
5030 r
.in
.new_password
= new_password
;
5032 status
= cli
->dispatch(cli
,
5034 &ndr_table_netlogon
,
5035 NDR_NETR_SERVERPASSWORDSET2
,
5038 if (!NT_STATUS_IS_OK(status
)) {
5042 if (NT_STATUS_IS_ERR(status
)) {
5046 /* Return variables */
5047 *return_authenticator
= *r
.out
.return_authenticator
;
5050 return r
.out
.result
;
5053 struct rpccli_netr_ServerPasswordGet_state
{
5054 struct netr_ServerPasswordGet orig
;
5055 struct netr_ServerPasswordGet tmp
;
5056 TALLOC_CTX
*out_mem_ctx
;
5057 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5060 static void rpccli_netr_ServerPasswordGet_done(struct tevent_req
*subreq
);
5062 struct tevent_req
*rpccli_netr_ServerPasswordGet_send(TALLOC_CTX
*mem_ctx
,
5063 struct tevent_context
*ev
,
5064 struct rpc_pipe_client
*cli
,
5065 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
5066 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
5067 enum netr_SchannelType _secure_channel_type
/* [in] */,
5068 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
5069 struct netr_Authenticator
*_credential
/* [in] [ref] */,
5070 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
5071 struct samr_Password
*_password
/* [out] [ref] */)
5073 struct tevent_req
*req
;
5074 struct rpccli_netr_ServerPasswordGet_state
*state
;
5075 struct tevent_req
*subreq
;
5077 req
= tevent_req_create(mem_ctx
, &state
,
5078 struct rpccli_netr_ServerPasswordGet_state
);
5082 state
->out_mem_ctx
= NULL
;
5083 state
->dispatch_recv
= cli
->dispatch_recv
;
5086 state
->orig
.in
.server_name
= _server_name
;
5087 state
->orig
.in
.account_name
= _account_name
;
5088 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
5089 state
->orig
.in
.computer_name
= _computer_name
;
5090 state
->orig
.in
.credential
= _credential
;
5092 /* Out parameters */
5093 state
->orig
.out
.return_authenticator
= _return_authenticator
;
5094 state
->orig
.out
.password
= _password
;
5097 ZERO_STRUCT(state
->orig
.out
.result
);
5099 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5100 "rpccli_netr_ServerPasswordGet_out_memory");
5101 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5102 return tevent_req_post(req
, ev
);
5105 /* make a temporary copy, that we pass to the dispatch function */
5106 state
->tmp
= state
->orig
;
5108 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5109 &ndr_table_netlogon
,
5110 NDR_NETR_SERVERPASSWORDGET
,
5112 if (tevent_req_nomem(subreq
, req
)) {
5113 return tevent_req_post(req
, ev
);
5115 tevent_req_set_callback(subreq
, rpccli_netr_ServerPasswordGet_done
, req
);
5119 static void rpccli_netr_ServerPasswordGet_done(struct tevent_req
*subreq
)
5121 struct tevent_req
*req
= tevent_req_callback_data(
5122 subreq
, struct tevent_req
);
5123 struct rpccli_netr_ServerPasswordGet_state
*state
= tevent_req_data(
5124 req
, struct rpccli_netr_ServerPasswordGet_state
);
5126 TALLOC_CTX
*mem_ctx
;
5128 if (state
->out_mem_ctx
) {
5129 mem_ctx
= state
->out_mem_ctx
;
5134 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5135 TALLOC_FREE(subreq
);
5136 if (!NT_STATUS_IS_OK(status
)) {
5137 tevent_req_nterror(req
, status
);
5141 /* Copy out parameters */
5142 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
5143 *state
->orig
.out
.password
= *state
->tmp
.out
.password
;
5146 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5148 /* Reset temporary structure */
5149 ZERO_STRUCT(state
->tmp
);
5151 tevent_req_done(req
);
5154 NTSTATUS
rpccli_netr_ServerPasswordGet_recv(struct tevent_req
*req
,
5155 TALLOC_CTX
*mem_ctx
,
5158 struct rpccli_netr_ServerPasswordGet_state
*state
= tevent_req_data(
5159 req
, struct rpccli_netr_ServerPasswordGet_state
);
5162 if (tevent_req_is_nterror(req
, &status
)) {
5163 tevent_req_received(req
);
5167 /* Steal possbile out parameters to the callers context */
5168 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5171 *result
= state
->orig
.out
.result
;
5173 tevent_req_received(req
);
5174 return NT_STATUS_OK
;
5177 NTSTATUS
rpccli_netr_ServerPasswordGet(struct rpc_pipe_client
*cli
,
5178 TALLOC_CTX
*mem_ctx
,
5179 const char *server_name
/* [in] [unique,charset(UTF16)] */,
5180 const char *account_name
/* [in] [ref,charset(UTF16)] */,
5181 enum netr_SchannelType secure_channel_type
/* [in] */,
5182 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
5183 struct netr_Authenticator
*credential
/* [in] [ref] */,
5184 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
5185 struct samr_Password
*password
/* [out] [ref] */,
5188 struct netr_ServerPasswordGet r
;
5192 r
.in
.server_name
= server_name
;
5193 r
.in
.account_name
= account_name
;
5194 r
.in
.secure_channel_type
= secure_channel_type
;
5195 r
.in
.computer_name
= computer_name
;
5196 r
.in
.credential
= credential
;
5198 status
= cli
->dispatch(cli
,
5200 &ndr_table_netlogon
,
5201 NDR_NETR_SERVERPASSWORDGET
,
5204 if (!NT_STATUS_IS_OK(status
)) {
5208 if (NT_STATUS_IS_ERR(status
)) {
5212 /* Return variables */
5213 *return_authenticator
= *r
.out
.return_authenticator
;
5214 *password
= *r
.out
.password
;
5218 *werror
= r
.out
.result
;
5221 return werror_to_ntstatus(r
.out
.result
);
5224 struct rpccli_netr_NETRLOGONSENDTOSAM_state
{
5225 struct netr_NETRLOGONSENDTOSAM orig
;
5226 struct netr_NETRLOGONSENDTOSAM tmp
;
5227 TALLOC_CTX
*out_mem_ctx
;
5228 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5231 static void rpccli_netr_NETRLOGONSENDTOSAM_done(struct tevent_req
*subreq
);
5233 struct tevent_req
*rpccli_netr_NETRLOGONSENDTOSAM_send(TALLOC_CTX
*mem_ctx
,
5234 struct tevent_context
*ev
,
5235 struct rpc_pipe_client
*cli
)
5237 struct tevent_req
*req
;
5238 struct rpccli_netr_NETRLOGONSENDTOSAM_state
*state
;
5239 struct tevent_req
*subreq
;
5241 req
= tevent_req_create(mem_ctx
, &state
,
5242 struct rpccli_netr_NETRLOGONSENDTOSAM_state
);
5246 state
->out_mem_ctx
= NULL
;
5247 state
->dispatch_recv
= cli
->dispatch_recv
;
5251 /* Out parameters */
5254 ZERO_STRUCT(state
->orig
.out
.result
);
5256 /* make a temporary copy, that we pass to the dispatch function */
5257 state
->tmp
= state
->orig
;
5259 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5260 &ndr_table_netlogon
,
5261 NDR_NETR_NETRLOGONSENDTOSAM
,
5263 if (tevent_req_nomem(subreq
, req
)) {
5264 return tevent_req_post(req
, ev
);
5266 tevent_req_set_callback(subreq
, rpccli_netr_NETRLOGONSENDTOSAM_done
, req
);
5270 static void rpccli_netr_NETRLOGONSENDTOSAM_done(struct tevent_req
*subreq
)
5272 struct tevent_req
*req
= tevent_req_callback_data(
5273 subreq
, struct tevent_req
);
5274 struct rpccli_netr_NETRLOGONSENDTOSAM_state
*state
= tevent_req_data(
5275 req
, struct rpccli_netr_NETRLOGONSENDTOSAM_state
);
5277 TALLOC_CTX
*mem_ctx
;
5279 if (state
->out_mem_ctx
) {
5280 mem_ctx
= state
->out_mem_ctx
;
5285 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5286 TALLOC_FREE(subreq
);
5287 if (!NT_STATUS_IS_OK(status
)) {
5288 tevent_req_nterror(req
, status
);
5292 /* Copy out parameters */
5295 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5297 /* Reset temporary structure */
5298 ZERO_STRUCT(state
->tmp
);
5300 tevent_req_done(req
);
5303 NTSTATUS
rpccli_netr_NETRLOGONSENDTOSAM_recv(struct tevent_req
*req
,
5304 TALLOC_CTX
*mem_ctx
,
5307 struct rpccli_netr_NETRLOGONSENDTOSAM_state
*state
= tevent_req_data(
5308 req
, struct rpccli_netr_NETRLOGONSENDTOSAM_state
);
5311 if (tevent_req_is_nterror(req
, &status
)) {
5312 tevent_req_received(req
);
5316 /* Steal possbile out parameters to the callers context */
5317 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5320 *result
= state
->orig
.out
.result
;
5322 tevent_req_received(req
);
5323 return NT_STATUS_OK
;
5326 NTSTATUS
rpccli_netr_NETRLOGONSENDTOSAM(struct rpc_pipe_client
*cli
,
5327 TALLOC_CTX
*mem_ctx
,
5330 struct netr_NETRLOGONSENDTOSAM r
;
5335 status
= cli
->dispatch(cli
,
5337 &ndr_table_netlogon
,
5338 NDR_NETR_NETRLOGONSENDTOSAM
,
5341 if (!NT_STATUS_IS_OK(status
)) {
5345 if (NT_STATUS_IS_ERR(status
)) {
5349 /* Return variables */
5353 *werror
= r
.out
.result
;
5356 return werror_to_ntstatus(r
.out
.result
);
5359 struct rpccli_netr_DsRAddressToSitenamesW_state
{
5360 struct netr_DsRAddressToSitenamesW orig
;
5361 struct netr_DsRAddressToSitenamesW tmp
;
5362 TALLOC_CTX
*out_mem_ctx
;
5363 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5366 static void rpccli_netr_DsRAddressToSitenamesW_done(struct tevent_req
*subreq
);
5368 struct tevent_req
*rpccli_netr_DsRAddressToSitenamesW_send(TALLOC_CTX
*mem_ctx
,
5369 struct tevent_context
*ev
,
5370 struct rpc_pipe_client
*cli
,
5371 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
5372 uint32_t _count
/* [in] [range(0,32000)] */,
5373 struct netr_DsRAddress
*_addresses
/* [in] [ref,size_is(count)] */,
5374 struct netr_DsRAddressToSitenamesWCtr
**_ctr
/* [out] [ref] */)
5376 struct tevent_req
*req
;
5377 struct rpccli_netr_DsRAddressToSitenamesW_state
*state
;
5378 struct tevent_req
*subreq
;
5380 req
= tevent_req_create(mem_ctx
, &state
,
5381 struct rpccli_netr_DsRAddressToSitenamesW_state
);
5385 state
->out_mem_ctx
= NULL
;
5386 state
->dispatch_recv
= cli
->dispatch_recv
;
5389 state
->orig
.in
.server_name
= _server_name
;
5390 state
->orig
.in
.count
= _count
;
5391 state
->orig
.in
.addresses
= _addresses
;
5393 /* Out parameters */
5394 state
->orig
.out
.ctr
= _ctr
;
5397 ZERO_STRUCT(state
->orig
.out
.result
);
5399 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5400 "rpccli_netr_DsRAddressToSitenamesW_out_memory");
5401 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5402 return tevent_req_post(req
, ev
);
5405 /* make a temporary copy, that we pass to the dispatch function */
5406 state
->tmp
= state
->orig
;
5408 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5409 &ndr_table_netlogon
,
5410 NDR_NETR_DSRADDRESSTOSITENAMESW
,
5412 if (tevent_req_nomem(subreq
, req
)) {
5413 return tevent_req_post(req
, ev
);
5415 tevent_req_set_callback(subreq
, rpccli_netr_DsRAddressToSitenamesW_done
, req
);
5419 static void rpccli_netr_DsRAddressToSitenamesW_done(struct tevent_req
*subreq
)
5421 struct tevent_req
*req
= tevent_req_callback_data(
5422 subreq
, struct tevent_req
);
5423 struct rpccli_netr_DsRAddressToSitenamesW_state
*state
= tevent_req_data(
5424 req
, struct rpccli_netr_DsRAddressToSitenamesW_state
);
5426 TALLOC_CTX
*mem_ctx
;
5428 if (state
->out_mem_ctx
) {
5429 mem_ctx
= state
->out_mem_ctx
;
5434 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5435 TALLOC_FREE(subreq
);
5436 if (!NT_STATUS_IS_OK(status
)) {
5437 tevent_req_nterror(req
, status
);
5441 /* Copy out parameters */
5442 *state
->orig
.out
.ctr
= *state
->tmp
.out
.ctr
;
5445 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5447 /* Reset temporary structure */
5448 ZERO_STRUCT(state
->tmp
);
5450 tevent_req_done(req
);
5453 NTSTATUS
rpccli_netr_DsRAddressToSitenamesW_recv(struct tevent_req
*req
,
5454 TALLOC_CTX
*mem_ctx
,
5457 struct rpccli_netr_DsRAddressToSitenamesW_state
*state
= tevent_req_data(
5458 req
, struct rpccli_netr_DsRAddressToSitenamesW_state
);
5461 if (tevent_req_is_nterror(req
, &status
)) {
5462 tevent_req_received(req
);
5466 /* Steal possbile out parameters to the callers context */
5467 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5470 *result
= state
->orig
.out
.result
;
5472 tevent_req_received(req
);
5473 return NT_STATUS_OK
;
5476 NTSTATUS
rpccli_netr_DsRAddressToSitenamesW(struct rpc_pipe_client
*cli
,
5477 TALLOC_CTX
*mem_ctx
,
5478 const char *server_name
/* [in] [unique,charset(UTF16)] */,
5479 uint32_t count
/* [in] [range(0,32000)] */,
5480 struct netr_DsRAddress
*addresses
/* [in] [ref,size_is(count)] */,
5481 struct netr_DsRAddressToSitenamesWCtr
**ctr
/* [out] [ref] */,
5484 struct netr_DsRAddressToSitenamesW r
;
5488 r
.in
.server_name
= server_name
;
5490 r
.in
.addresses
= addresses
;
5492 status
= cli
->dispatch(cli
,
5494 &ndr_table_netlogon
,
5495 NDR_NETR_DSRADDRESSTOSITENAMESW
,
5498 if (!NT_STATUS_IS_OK(status
)) {
5502 if (NT_STATUS_IS_ERR(status
)) {
5506 /* Return variables */
5511 *werror
= r
.out
.result
;
5514 return werror_to_ntstatus(r
.out
.result
);
5517 struct rpccli_netr_DsRGetDCNameEx2_state
{
5518 struct netr_DsRGetDCNameEx2 orig
;
5519 struct netr_DsRGetDCNameEx2 tmp
;
5520 TALLOC_CTX
*out_mem_ctx
;
5521 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5524 static void rpccli_netr_DsRGetDCNameEx2_done(struct tevent_req
*subreq
);
5526 struct tevent_req
*rpccli_netr_DsRGetDCNameEx2_send(TALLOC_CTX
*mem_ctx
,
5527 struct tevent_context
*ev
,
5528 struct rpc_pipe_client
*cli
,
5529 const char *_server_unc
/* [in] [unique,charset(UTF16)] */,
5530 const char *_client_account
/* [in] [unique,charset(UTF16)] */,
5531 uint32_t _mask
/* [in] */,
5532 const char *_domain_name
/* [in] [unique,charset(UTF16)] */,
5533 struct GUID
*_domain_guid
/* [in] [unique] */,
5534 const char *_site_name
/* [in] [unique,charset(UTF16)] */,
5535 uint32_t _flags
/* [in] */,
5536 struct netr_DsRGetDCNameInfo
**_info
/* [out] [ref] */)
5538 struct tevent_req
*req
;
5539 struct rpccli_netr_DsRGetDCNameEx2_state
*state
;
5540 struct tevent_req
*subreq
;
5542 req
= tevent_req_create(mem_ctx
, &state
,
5543 struct rpccli_netr_DsRGetDCNameEx2_state
);
5547 state
->out_mem_ctx
= NULL
;
5548 state
->dispatch_recv
= cli
->dispatch_recv
;
5551 state
->orig
.in
.server_unc
= _server_unc
;
5552 state
->orig
.in
.client_account
= _client_account
;
5553 state
->orig
.in
.mask
= _mask
;
5554 state
->orig
.in
.domain_name
= _domain_name
;
5555 state
->orig
.in
.domain_guid
= _domain_guid
;
5556 state
->orig
.in
.site_name
= _site_name
;
5557 state
->orig
.in
.flags
= _flags
;
5559 /* Out parameters */
5560 state
->orig
.out
.info
= _info
;
5563 ZERO_STRUCT(state
->orig
.out
.result
);
5565 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5566 "rpccli_netr_DsRGetDCNameEx2_out_memory");
5567 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5568 return tevent_req_post(req
, ev
);
5571 /* make a temporary copy, that we pass to the dispatch function */
5572 state
->tmp
= state
->orig
;
5574 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5575 &ndr_table_netlogon
,
5576 NDR_NETR_DSRGETDCNAMEEX2
,
5578 if (tevent_req_nomem(subreq
, req
)) {
5579 return tevent_req_post(req
, ev
);
5581 tevent_req_set_callback(subreq
, rpccli_netr_DsRGetDCNameEx2_done
, req
);
5585 static void rpccli_netr_DsRGetDCNameEx2_done(struct tevent_req
*subreq
)
5587 struct tevent_req
*req
= tevent_req_callback_data(
5588 subreq
, struct tevent_req
);
5589 struct rpccli_netr_DsRGetDCNameEx2_state
*state
= tevent_req_data(
5590 req
, struct rpccli_netr_DsRGetDCNameEx2_state
);
5592 TALLOC_CTX
*mem_ctx
;
5594 if (state
->out_mem_ctx
) {
5595 mem_ctx
= state
->out_mem_ctx
;
5600 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5601 TALLOC_FREE(subreq
);
5602 if (!NT_STATUS_IS_OK(status
)) {
5603 tevent_req_nterror(req
, status
);
5607 /* Copy out parameters */
5608 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
5611 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5613 /* Reset temporary structure */
5614 ZERO_STRUCT(state
->tmp
);
5616 tevent_req_done(req
);
5619 NTSTATUS
rpccli_netr_DsRGetDCNameEx2_recv(struct tevent_req
*req
,
5620 TALLOC_CTX
*mem_ctx
,
5623 struct rpccli_netr_DsRGetDCNameEx2_state
*state
= tevent_req_data(
5624 req
, struct rpccli_netr_DsRGetDCNameEx2_state
);
5627 if (tevent_req_is_nterror(req
, &status
)) {
5628 tevent_req_received(req
);
5632 /* Steal possbile out parameters to the callers context */
5633 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5636 *result
= state
->orig
.out
.result
;
5638 tevent_req_received(req
);
5639 return NT_STATUS_OK
;
5642 NTSTATUS
rpccli_netr_DsRGetDCNameEx2(struct rpc_pipe_client
*cli
,
5643 TALLOC_CTX
*mem_ctx
,
5644 const char *server_unc
/* [in] [unique,charset(UTF16)] */,
5645 const char *client_account
/* [in] [unique,charset(UTF16)] */,
5646 uint32_t mask
/* [in] */,
5647 const char *domain_name
/* [in] [unique,charset(UTF16)] */,
5648 struct GUID
*domain_guid
/* [in] [unique] */,
5649 const char *site_name
/* [in] [unique,charset(UTF16)] */,
5650 uint32_t flags
/* [in] */,
5651 struct netr_DsRGetDCNameInfo
**info
/* [out] [ref] */,
5654 struct netr_DsRGetDCNameEx2 r
;
5658 r
.in
.server_unc
= server_unc
;
5659 r
.in
.client_account
= client_account
;
5661 r
.in
.domain_name
= domain_name
;
5662 r
.in
.domain_guid
= domain_guid
;
5663 r
.in
.site_name
= site_name
;
5666 status
= cli
->dispatch(cli
,
5668 &ndr_table_netlogon
,
5669 NDR_NETR_DSRGETDCNAMEEX2
,
5672 if (!NT_STATUS_IS_OK(status
)) {
5676 if (NT_STATUS_IS_ERR(status
)) {
5680 /* Return variables */
5681 *info
= *r
.out
.info
;
5685 *werror
= r
.out
.result
;
5688 return werror_to_ntstatus(r
.out
.result
);
5691 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
{
5692 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN orig
;
5693 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN tmp
;
5694 TALLOC_CTX
*out_mem_ctx
;
5695 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5698 static void rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done(struct tevent_req
*subreq
);
5700 struct tevent_req
*rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_send(TALLOC_CTX
*mem_ctx
,
5701 struct tevent_context
*ev
,
5702 struct rpc_pipe_client
*cli
)
5704 struct tevent_req
*req
;
5705 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
*state
;
5706 struct tevent_req
*subreq
;
5708 req
= tevent_req_create(mem_ctx
, &state
,
5709 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
);
5713 state
->out_mem_ctx
= NULL
;
5714 state
->dispatch_recv
= cli
->dispatch_recv
;
5718 /* Out parameters */
5721 ZERO_STRUCT(state
->orig
.out
.result
);
5723 /* make a temporary copy, that we pass to the dispatch function */
5724 state
->tmp
= state
->orig
;
5726 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5727 &ndr_table_netlogon
,
5728 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
,
5730 if (tevent_req_nomem(subreq
, req
)) {
5731 return tevent_req_post(req
, ev
);
5733 tevent_req_set_callback(subreq
, rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done
, req
);
5737 static void rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done(struct tevent_req
*subreq
)
5739 struct tevent_req
*req
= tevent_req_callback_data(
5740 subreq
, struct tevent_req
);
5741 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
*state
= tevent_req_data(
5742 req
, struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
);
5744 TALLOC_CTX
*mem_ctx
;
5746 if (state
->out_mem_ctx
) {
5747 mem_ctx
= state
->out_mem_ctx
;
5752 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5753 TALLOC_FREE(subreq
);
5754 if (!NT_STATUS_IS_OK(status
)) {
5755 tevent_req_nterror(req
, status
);
5759 /* Copy out parameters */
5762 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5764 /* Reset temporary structure */
5765 ZERO_STRUCT(state
->tmp
);
5767 tevent_req_done(req
);
5770 NTSTATUS
rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_recv(struct tevent_req
*req
,
5771 TALLOC_CTX
*mem_ctx
,
5774 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
*state
= tevent_req_data(
5775 req
, struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state
);
5778 if (tevent_req_is_nterror(req
, &status
)) {
5779 tevent_req_received(req
);
5783 /* Steal possbile out parameters to the callers context */
5784 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5787 *result
= state
->orig
.out
.result
;
5789 tevent_req_received(req
);
5790 return NT_STATUS_OK
;
5793 NTSTATUS
rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(struct rpc_pipe_client
*cli
,
5794 TALLOC_CTX
*mem_ctx
,
5797 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN r
;
5802 status
= cli
->dispatch(cli
,
5804 &ndr_table_netlogon
,
5805 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN
,
5808 if (!NT_STATUS_IS_OK(status
)) {
5812 if (NT_STATUS_IS_ERR(status
)) {
5816 /* Return variables */
5820 *werror
= r
.out
.result
;
5823 return werror_to_ntstatus(r
.out
.result
);
5826 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
{
5827 struct netr_NetrEnumerateTrustedDomainsEx orig
;
5828 struct netr_NetrEnumerateTrustedDomainsEx tmp
;
5829 TALLOC_CTX
*out_mem_ctx
;
5830 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5833 static void rpccli_netr_NetrEnumerateTrustedDomainsEx_done(struct tevent_req
*subreq
);
5835 struct tevent_req
*rpccli_netr_NetrEnumerateTrustedDomainsEx_send(TALLOC_CTX
*mem_ctx
,
5836 struct tevent_context
*ev
,
5837 struct rpc_pipe_client
*cli
,
5838 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
5839 struct netr_DomainTrustList
*_dom_trust_list
/* [out] [ref] */)
5841 struct tevent_req
*req
;
5842 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
*state
;
5843 struct tevent_req
*subreq
;
5845 req
= tevent_req_create(mem_ctx
, &state
,
5846 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
);
5850 state
->out_mem_ctx
= NULL
;
5851 state
->dispatch_recv
= cli
->dispatch_recv
;
5854 state
->orig
.in
.server_name
= _server_name
;
5856 /* Out parameters */
5857 state
->orig
.out
.dom_trust_list
= _dom_trust_list
;
5860 ZERO_STRUCT(state
->orig
.out
.result
);
5862 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5863 "rpccli_netr_NetrEnumerateTrustedDomainsEx_out_memory");
5864 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5865 return tevent_req_post(req
, ev
);
5868 /* make a temporary copy, that we pass to the dispatch function */
5869 state
->tmp
= state
->orig
;
5871 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5872 &ndr_table_netlogon
,
5873 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
,
5875 if (tevent_req_nomem(subreq
, req
)) {
5876 return tevent_req_post(req
, ev
);
5878 tevent_req_set_callback(subreq
, rpccli_netr_NetrEnumerateTrustedDomainsEx_done
, req
);
5882 static void rpccli_netr_NetrEnumerateTrustedDomainsEx_done(struct tevent_req
*subreq
)
5884 struct tevent_req
*req
= tevent_req_callback_data(
5885 subreq
, struct tevent_req
);
5886 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
*state
= tevent_req_data(
5887 req
, struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
);
5889 TALLOC_CTX
*mem_ctx
;
5891 if (state
->out_mem_ctx
) {
5892 mem_ctx
= state
->out_mem_ctx
;
5897 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5898 TALLOC_FREE(subreq
);
5899 if (!NT_STATUS_IS_OK(status
)) {
5900 tevent_req_nterror(req
, status
);
5904 /* Copy out parameters */
5905 *state
->orig
.out
.dom_trust_list
= *state
->tmp
.out
.dom_trust_list
;
5908 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5910 /* Reset temporary structure */
5911 ZERO_STRUCT(state
->tmp
);
5913 tevent_req_done(req
);
5916 NTSTATUS
rpccli_netr_NetrEnumerateTrustedDomainsEx_recv(struct tevent_req
*req
,
5917 TALLOC_CTX
*mem_ctx
,
5920 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
*state
= tevent_req_data(
5921 req
, struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state
);
5924 if (tevent_req_is_nterror(req
, &status
)) {
5925 tevent_req_received(req
);
5929 /* Steal possbile out parameters to the callers context */
5930 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5933 *result
= state
->orig
.out
.result
;
5935 tevent_req_received(req
);
5936 return NT_STATUS_OK
;
5939 NTSTATUS
rpccli_netr_NetrEnumerateTrustedDomainsEx(struct rpc_pipe_client
*cli
,
5940 TALLOC_CTX
*mem_ctx
,
5941 const char *server_name
/* [in] [unique,charset(UTF16)] */,
5942 struct netr_DomainTrustList
*dom_trust_list
/* [out] [ref] */,
5945 struct netr_NetrEnumerateTrustedDomainsEx r
;
5949 r
.in
.server_name
= server_name
;
5951 status
= cli
->dispatch(cli
,
5953 &ndr_table_netlogon
,
5954 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX
,
5957 if (!NT_STATUS_IS_OK(status
)) {
5961 if (NT_STATUS_IS_ERR(status
)) {
5965 /* Return variables */
5966 *dom_trust_list
= *r
.out
.dom_trust_list
;
5970 *werror
= r
.out
.result
;
5973 return werror_to_ntstatus(r
.out
.result
);
5976 struct rpccli_netr_DsRAddressToSitenamesExW_state
{
5977 struct netr_DsRAddressToSitenamesExW orig
;
5978 struct netr_DsRAddressToSitenamesExW tmp
;
5979 TALLOC_CTX
*out_mem_ctx
;
5980 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5983 static void rpccli_netr_DsRAddressToSitenamesExW_done(struct tevent_req
*subreq
);
5985 struct tevent_req
*rpccli_netr_DsRAddressToSitenamesExW_send(TALLOC_CTX
*mem_ctx
,
5986 struct tevent_context
*ev
,
5987 struct rpc_pipe_client
*cli
,
5988 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
5989 uint32_t _count
/* [in] [range(0,32000)] */,
5990 struct netr_DsRAddress
*_addresses
/* [in] [ref,size_is(count)] */,
5991 struct netr_DsRAddressToSitenamesExWCtr
**_ctr
/* [out] [ref] */)
5993 struct tevent_req
*req
;
5994 struct rpccli_netr_DsRAddressToSitenamesExW_state
*state
;
5995 struct tevent_req
*subreq
;
5997 req
= tevent_req_create(mem_ctx
, &state
,
5998 struct rpccli_netr_DsRAddressToSitenamesExW_state
);
6002 state
->out_mem_ctx
= NULL
;
6003 state
->dispatch_recv
= cli
->dispatch_recv
;
6006 state
->orig
.in
.server_name
= _server_name
;
6007 state
->orig
.in
.count
= _count
;
6008 state
->orig
.in
.addresses
= _addresses
;
6010 /* Out parameters */
6011 state
->orig
.out
.ctr
= _ctr
;
6014 ZERO_STRUCT(state
->orig
.out
.result
);
6016 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6017 "rpccli_netr_DsRAddressToSitenamesExW_out_memory");
6018 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6019 return tevent_req_post(req
, ev
);
6022 /* make a temporary copy, that we pass to the dispatch function */
6023 state
->tmp
= state
->orig
;
6025 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6026 &ndr_table_netlogon
,
6027 NDR_NETR_DSRADDRESSTOSITENAMESEXW
,
6029 if (tevent_req_nomem(subreq
, req
)) {
6030 return tevent_req_post(req
, ev
);
6032 tevent_req_set_callback(subreq
, rpccli_netr_DsRAddressToSitenamesExW_done
, req
);
6036 static void rpccli_netr_DsRAddressToSitenamesExW_done(struct tevent_req
*subreq
)
6038 struct tevent_req
*req
= tevent_req_callback_data(
6039 subreq
, struct tevent_req
);
6040 struct rpccli_netr_DsRAddressToSitenamesExW_state
*state
= tevent_req_data(
6041 req
, struct rpccli_netr_DsRAddressToSitenamesExW_state
);
6043 TALLOC_CTX
*mem_ctx
;
6045 if (state
->out_mem_ctx
) {
6046 mem_ctx
= state
->out_mem_ctx
;
6051 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6052 TALLOC_FREE(subreq
);
6053 if (!NT_STATUS_IS_OK(status
)) {
6054 tevent_req_nterror(req
, status
);
6058 /* Copy out parameters */
6059 *state
->orig
.out
.ctr
= *state
->tmp
.out
.ctr
;
6062 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6064 /* Reset temporary structure */
6065 ZERO_STRUCT(state
->tmp
);
6067 tevent_req_done(req
);
6070 NTSTATUS
rpccli_netr_DsRAddressToSitenamesExW_recv(struct tevent_req
*req
,
6071 TALLOC_CTX
*mem_ctx
,
6074 struct rpccli_netr_DsRAddressToSitenamesExW_state
*state
= tevent_req_data(
6075 req
, struct rpccli_netr_DsRAddressToSitenamesExW_state
);
6078 if (tevent_req_is_nterror(req
, &status
)) {
6079 tevent_req_received(req
);
6083 /* Steal possbile out parameters to the callers context */
6084 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6087 *result
= state
->orig
.out
.result
;
6089 tevent_req_received(req
);
6090 return NT_STATUS_OK
;
6093 NTSTATUS
rpccli_netr_DsRAddressToSitenamesExW(struct rpc_pipe_client
*cli
,
6094 TALLOC_CTX
*mem_ctx
,
6095 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6096 uint32_t count
/* [in] [range(0,32000)] */,
6097 struct netr_DsRAddress
*addresses
/* [in] [ref,size_is(count)] */,
6098 struct netr_DsRAddressToSitenamesExWCtr
**ctr
/* [out] [ref] */,
6101 struct netr_DsRAddressToSitenamesExW r
;
6105 r
.in
.server_name
= server_name
;
6107 r
.in
.addresses
= addresses
;
6109 status
= cli
->dispatch(cli
,
6111 &ndr_table_netlogon
,
6112 NDR_NETR_DSRADDRESSTOSITENAMESEXW
,
6115 if (!NT_STATUS_IS_OK(status
)) {
6119 if (NT_STATUS_IS_ERR(status
)) {
6123 /* Return variables */
6128 *werror
= r
.out
.result
;
6131 return werror_to_ntstatus(r
.out
.result
);
6134 struct rpccli_netr_DsrGetDcSiteCoverageW_state
{
6135 struct netr_DsrGetDcSiteCoverageW orig
;
6136 struct netr_DsrGetDcSiteCoverageW tmp
;
6137 TALLOC_CTX
*out_mem_ctx
;
6138 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6141 static void rpccli_netr_DsrGetDcSiteCoverageW_done(struct tevent_req
*subreq
);
6143 struct tevent_req
*rpccli_netr_DsrGetDcSiteCoverageW_send(TALLOC_CTX
*mem_ctx
,
6144 struct tevent_context
*ev
,
6145 struct rpc_pipe_client
*cli
,
6146 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6147 struct DcSitesCtr
**_ctr
/* [out] [ref] */)
6149 struct tevent_req
*req
;
6150 struct rpccli_netr_DsrGetDcSiteCoverageW_state
*state
;
6151 struct tevent_req
*subreq
;
6153 req
= tevent_req_create(mem_ctx
, &state
,
6154 struct rpccli_netr_DsrGetDcSiteCoverageW_state
);
6158 state
->out_mem_ctx
= NULL
;
6159 state
->dispatch_recv
= cli
->dispatch_recv
;
6162 state
->orig
.in
.server_name
= _server_name
;
6164 /* Out parameters */
6165 state
->orig
.out
.ctr
= _ctr
;
6168 ZERO_STRUCT(state
->orig
.out
.result
);
6170 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6171 "rpccli_netr_DsrGetDcSiteCoverageW_out_memory");
6172 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6173 return tevent_req_post(req
, ev
);
6176 /* make a temporary copy, that we pass to the dispatch function */
6177 state
->tmp
= state
->orig
;
6179 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6180 &ndr_table_netlogon
,
6181 NDR_NETR_DSRGETDCSITECOVERAGEW
,
6183 if (tevent_req_nomem(subreq
, req
)) {
6184 return tevent_req_post(req
, ev
);
6186 tevent_req_set_callback(subreq
, rpccli_netr_DsrGetDcSiteCoverageW_done
, req
);
6190 static void rpccli_netr_DsrGetDcSiteCoverageW_done(struct tevent_req
*subreq
)
6192 struct tevent_req
*req
= tevent_req_callback_data(
6193 subreq
, struct tevent_req
);
6194 struct rpccli_netr_DsrGetDcSiteCoverageW_state
*state
= tevent_req_data(
6195 req
, struct rpccli_netr_DsrGetDcSiteCoverageW_state
);
6197 TALLOC_CTX
*mem_ctx
;
6199 if (state
->out_mem_ctx
) {
6200 mem_ctx
= state
->out_mem_ctx
;
6205 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6206 TALLOC_FREE(subreq
);
6207 if (!NT_STATUS_IS_OK(status
)) {
6208 tevent_req_nterror(req
, status
);
6212 /* Copy out parameters */
6213 *state
->orig
.out
.ctr
= *state
->tmp
.out
.ctr
;
6216 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6218 /* Reset temporary structure */
6219 ZERO_STRUCT(state
->tmp
);
6221 tevent_req_done(req
);
6224 NTSTATUS
rpccli_netr_DsrGetDcSiteCoverageW_recv(struct tevent_req
*req
,
6225 TALLOC_CTX
*mem_ctx
,
6228 struct rpccli_netr_DsrGetDcSiteCoverageW_state
*state
= tevent_req_data(
6229 req
, struct rpccli_netr_DsrGetDcSiteCoverageW_state
);
6232 if (tevent_req_is_nterror(req
, &status
)) {
6233 tevent_req_received(req
);
6237 /* Steal possbile out parameters to the callers context */
6238 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6241 *result
= state
->orig
.out
.result
;
6243 tevent_req_received(req
);
6244 return NT_STATUS_OK
;
6247 NTSTATUS
rpccli_netr_DsrGetDcSiteCoverageW(struct rpc_pipe_client
*cli
,
6248 TALLOC_CTX
*mem_ctx
,
6249 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6250 struct DcSitesCtr
**ctr
/* [out] [ref] */,
6253 struct netr_DsrGetDcSiteCoverageW r
;
6257 r
.in
.server_name
= server_name
;
6259 status
= cli
->dispatch(cli
,
6261 &ndr_table_netlogon
,
6262 NDR_NETR_DSRGETDCSITECOVERAGEW
,
6265 if (!NT_STATUS_IS_OK(status
)) {
6269 if (NT_STATUS_IS_ERR(status
)) {
6273 /* Return variables */
6278 *werror
= r
.out
.result
;
6281 return werror_to_ntstatus(r
.out
.result
);
6284 struct rpccli_netr_LogonSamLogonEx_state
{
6285 struct netr_LogonSamLogonEx orig
;
6286 struct netr_LogonSamLogonEx tmp
;
6287 TALLOC_CTX
*out_mem_ctx
;
6288 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6291 static void rpccli_netr_LogonSamLogonEx_done(struct tevent_req
*subreq
);
6293 struct tevent_req
*rpccli_netr_LogonSamLogonEx_send(TALLOC_CTX
*mem_ctx
,
6294 struct tevent_context
*ev
,
6295 struct rpc_pipe_client
*cli
,
6296 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6297 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
6298 enum netr_LogonInfoClass _logon_level
/* [in] */,
6299 union netr_LogonLevel
*_logon
/* [in] [ref,switch_is(logon_level)] */,
6300 uint16_t _validation_level
/* [in] */,
6301 union netr_Validation
*_validation
/* [out] [ref,switch_is(validation_level)] */,
6302 uint8_t *_authoritative
/* [out] [ref] */,
6303 uint32_t *_flags
/* [in,out] [ref] */)
6305 struct tevent_req
*req
;
6306 struct rpccli_netr_LogonSamLogonEx_state
*state
;
6307 struct tevent_req
*subreq
;
6309 req
= tevent_req_create(mem_ctx
, &state
,
6310 struct rpccli_netr_LogonSamLogonEx_state
);
6314 state
->out_mem_ctx
= NULL
;
6315 state
->dispatch_recv
= cli
->dispatch_recv
;
6318 state
->orig
.in
.server_name
= _server_name
;
6319 state
->orig
.in
.computer_name
= _computer_name
;
6320 state
->orig
.in
.logon_level
= _logon_level
;
6321 state
->orig
.in
.logon
= _logon
;
6322 state
->orig
.in
.validation_level
= _validation_level
;
6323 state
->orig
.in
.flags
= _flags
;
6325 /* Out parameters */
6326 state
->orig
.out
.validation
= _validation
;
6327 state
->orig
.out
.authoritative
= _authoritative
;
6328 state
->orig
.out
.flags
= _flags
;
6331 ZERO_STRUCT(state
->orig
.out
.result
);
6333 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6334 "rpccli_netr_LogonSamLogonEx_out_memory");
6335 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6336 return tevent_req_post(req
, ev
);
6339 /* make a temporary copy, that we pass to the dispatch function */
6340 state
->tmp
= state
->orig
;
6342 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6343 &ndr_table_netlogon
,
6344 NDR_NETR_LOGONSAMLOGONEX
,
6346 if (tevent_req_nomem(subreq
, req
)) {
6347 return tevent_req_post(req
, ev
);
6349 tevent_req_set_callback(subreq
, rpccli_netr_LogonSamLogonEx_done
, req
);
6353 static void rpccli_netr_LogonSamLogonEx_done(struct tevent_req
*subreq
)
6355 struct tevent_req
*req
= tevent_req_callback_data(
6356 subreq
, struct tevent_req
);
6357 struct rpccli_netr_LogonSamLogonEx_state
*state
= tevent_req_data(
6358 req
, struct rpccli_netr_LogonSamLogonEx_state
);
6360 TALLOC_CTX
*mem_ctx
;
6362 if (state
->out_mem_ctx
) {
6363 mem_ctx
= state
->out_mem_ctx
;
6368 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6369 TALLOC_FREE(subreq
);
6370 if (!NT_STATUS_IS_OK(status
)) {
6371 tevent_req_nterror(req
, status
);
6375 /* Copy out parameters */
6376 *state
->orig
.out
.validation
= *state
->tmp
.out
.validation
;
6377 *state
->orig
.out
.authoritative
= *state
->tmp
.out
.authoritative
;
6378 *state
->orig
.out
.flags
= *state
->tmp
.out
.flags
;
6381 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6383 /* Reset temporary structure */
6384 ZERO_STRUCT(state
->tmp
);
6386 tevent_req_done(req
);
6389 NTSTATUS
rpccli_netr_LogonSamLogonEx_recv(struct tevent_req
*req
,
6390 TALLOC_CTX
*mem_ctx
,
6393 struct rpccli_netr_LogonSamLogonEx_state
*state
= tevent_req_data(
6394 req
, struct rpccli_netr_LogonSamLogonEx_state
);
6397 if (tevent_req_is_nterror(req
, &status
)) {
6398 tevent_req_received(req
);
6402 /* Steal possbile out parameters to the callers context */
6403 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6406 *result
= state
->orig
.out
.result
;
6408 tevent_req_received(req
);
6409 return NT_STATUS_OK
;
6412 NTSTATUS
rpccli_netr_LogonSamLogonEx(struct rpc_pipe_client
*cli
,
6413 TALLOC_CTX
*mem_ctx
,
6414 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6415 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
6416 enum netr_LogonInfoClass logon_level
/* [in] */,
6417 union netr_LogonLevel
*logon
/* [in] [ref,switch_is(logon_level)] */,
6418 uint16_t validation_level
/* [in] */,
6419 union netr_Validation
*validation
/* [out] [ref,switch_is(validation_level)] */,
6420 uint8_t *authoritative
/* [out] [ref] */,
6421 uint32_t *flags
/* [in,out] [ref] */)
6423 struct netr_LogonSamLogonEx r
;
6427 r
.in
.server_name
= server_name
;
6428 r
.in
.computer_name
= computer_name
;
6429 r
.in
.logon_level
= logon_level
;
6431 r
.in
.validation_level
= validation_level
;
6434 status
= cli
->dispatch(cli
,
6436 &ndr_table_netlogon
,
6437 NDR_NETR_LOGONSAMLOGONEX
,
6440 if (!NT_STATUS_IS_OK(status
)) {
6444 if (NT_STATUS_IS_ERR(status
)) {
6448 /* Return variables */
6449 *validation
= *r
.out
.validation
;
6450 *authoritative
= *r
.out
.authoritative
;
6451 *flags
= *r
.out
.flags
;
6454 return r
.out
.result
;
6457 struct rpccli_netr_DsrEnumerateDomainTrusts_state
{
6458 struct netr_DsrEnumerateDomainTrusts orig
;
6459 struct netr_DsrEnumerateDomainTrusts tmp
;
6460 TALLOC_CTX
*out_mem_ctx
;
6461 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6464 static void rpccli_netr_DsrEnumerateDomainTrusts_done(struct tevent_req
*subreq
);
6466 struct tevent_req
*rpccli_netr_DsrEnumerateDomainTrusts_send(TALLOC_CTX
*mem_ctx
,
6467 struct tevent_context
*ev
,
6468 struct rpc_pipe_client
*cli
,
6469 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6470 uint32_t _trust_flags
/* [in] */,
6471 struct netr_DomainTrustList
*_trusts
/* [out] [ref] */)
6473 struct tevent_req
*req
;
6474 struct rpccli_netr_DsrEnumerateDomainTrusts_state
*state
;
6475 struct tevent_req
*subreq
;
6477 req
= tevent_req_create(mem_ctx
, &state
,
6478 struct rpccli_netr_DsrEnumerateDomainTrusts_state
);
6482 state
->out_mem_ctx
= NULL
;
6483 state
->dispatch_recv
= cli
->dispatch_recv
;
6486 state
->orig
.in
.server_name
= _server_name
;
6487 state
->orig
.in
.trust_flags
= _trust_flags
;
6489 /* Out parameters */
6490 state
->orig
.out
.trusts
= _trusts
;
6493 ZERO_STRUCT(state
->orig
.out
.result
);
6495 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6496 "rpccli_netr_DsrEnumerateDomainTrusts_out_memory");
6497 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6498 return tevent_req_post(req
, ev
);
6501 /* make a temporary copy, that we pass to the dispatch function */
6502 state
->tmp
= state
->orig
;
6504 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6505 &ndr_table_netlogon
,
6506 NDR_NETR_DSRENUMERATEDOMAINTRUSTS
,
6508 if (tevent_req_nomem(subreq
, req
)) {
6509 return tevent_req_post(req
, ev
);
6511 tevent_req_set_callback(subreq
, rpccli_netr_DsrEnumerateDomainTrusts_done
, req
);
6515 static void rpccli_netr_DsrEnumerateDomainTrusts_done(struct tevent_req
*subreq
)
6517 struct tevent_req
*req
= tevent_req_callback_data(
6518 subreq
, struct tevent_req
);
6519 struct rpccli_netr_DsrEnumerateDomainTrusts_state
*state
= tevent_req_data(
6520 req
, struct rpccli_netr_DsrEnumerateDomainTrusts_state
);
6522 TALLOC_CTX
*mem_ctx
;
6524 if (state
->out_mem_ctx
) {
6525 mem_ctx
= state
->out_mem_ctx
;
6530 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6531 TALLOC_FREE(subreq
);
6532 if (!NT_STATUS_IS_OK(status
)) {
6533 tevent_req_nterror(req
, status
);
6537 /* Copy out parameters */
6538 *state
->orig
.out
.trusts
= *state
->tmp
.out
.trusts
;
6541 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6543 /* Reset temporary structure */
6544 ZERO_STRUCT(state
->tmp
);
6546 tevent_req_done(req
);
6549 NTSTATUS
rpccli_netr_DsrEnumerateDomainTrusts_recv(struct tevent_req
*req
,
6550 TALLOC_CTX
*mem_ctx
,
6553 struct rpccli_netr_DsrEnumerateDomainTrusts_state
*state
= tevent_req_data(
6554 req
, struct rpccli_netr_DsrEnumerateDomainTrusts_state
);
6557 if (tevent_req_is_nterror(req
, &status
)) {
6558 tevent_req_received(req
);
6562 /* Steal possbile out parameters to the callers context */
6563 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6566 *result
= state
->orig
.out
.result
;
6568 tevent_req_received(req
);
6569 return NT_STATUS_OK
;
6572 NTSTATUS
rpccli_netr_DsrEnumerateDomainTrusts(struct rpc_pipe_client
*cli
,
6573 TALLOC_CTX
*mem_ctx
,
6574 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6575 uint32_t trust_flags
/* [in] */,
6576 struct netr_DomainTrustList
*trusts
/* [out] [ref] */,
6579 struct netr_DsrEnumerateDomainTrusts r
;
6583 r
.in
.server_name
= server_name
;
6584 r
.in
.trust_flags
= trust_flags
;
6586 status
= cli
->dispatch(cli
,
6588 &ndr_table_netlogon
,
6589 NDR_NETR_DSRENUMERATEDOMAINTRUSTS
,
6592 if (!NT_STATUS_IS_OK(status
)) {
6596 if (NT_STATUS_IS_ERR(status
)) {
6600 /* Return variables */
6601 *trusts
= *r
.out
.trusts
;
6605 *werror
= r
.out
.result
;
6608 return werror_to_ntstatus(r
.out
.result
);
6611 struct rpccli_netr_DsrDeregisterDNSHostRecords_state
{
6612 struct netr_DsrDeregisterDNSHostRecords orig
;
6613 struct netr_DsrDeregisterDNSHostRecords tmp
;
6614 TALLOC_CTX
*out_mem_ctx
;
6615 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6618 static void rpccli_netr_DsrDeregisterDNSHostRecords_done(struct tevent_req
*subreq
);
6620 struct tevent_req
*rpccli_netr_DsrDeregisterDNSHostRecords_send(TALLOC_CTX
*mem_ctx
,
6621 struct tevent_context
*ev
,
6622 struct rpc_pipe_client
*cli
,
6623 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6624 const char *_domain
/* [in] [unique,charset(UTF16)] */,
6625 struct GUID
*_domain_guid
/* [in] [unique] */,
6626 struct GUID
*_dsa_guid
/* [in] [unique] */,
6627 const char *_dns_host
/* [in] [ref,charset(UTF16)] */)
6629 struct tevent_req
*req
;
6630 struct rpccli_netr_DsrDeregisterDNSHostRecords_state
*state
;
6631 struct tevent_req
*subreq
;
6633 req
= tevent_req_create(mem_ctx
, &state
,
6634 struct rpccli_netr_DsrDeregisterDNSHostRecords_state
);
6638 state
->out_mem_ctx
= NULL
;
6639 state
->dispatch_recv
= cli
->dispatch_recv
;
6642 state
->orig
.in
.server_name
= _server_name
;
6643 state
->orig
.in
.domain
= _domain
;
6644 state
->orig
.in
.domain_guid
= _domain_guid
;
6645 state
->orig
.in
.dsa_guid
= _dsa_guid
;
6646 state
->orig
.in
.dns_host
= _dns_host
;
6648 /* Out parameters */
6651 ZERO_STRUCT(state
->orig
.out
.result
);
6653 /* make a temporary copy, that we pass to the dispatch function */
6654 state
->tmp
= state
->orig
;
6656 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6657 &ndr_table_netlogon
,
6658 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
,
6660 if (tevent_req_nomem(subreq
, req
)) {
6661 return tevent_req_post(req
, ev
);
6663 tevent_req_set_callback(subreq
, rpccli_netr_DsrDeregisterDNSHostRecords_done
, req
);
6667 static void rpccli_netr_DsrDeregisterDNSHostRecords_done(struct tevent_req
*subreq
)
6669 struct tevent_req
*req
= tevent_req_callback_data(
6670 subreq
, struct tevent_req
);
6671 struct rpccli_netr_DsrDeregisterDNSHostRecords_state
*state
= tevent_req_data(
6672 req
, struct rpccli_netr_DsrDeregisterDNSHostRecords_state
);
6674 TALLOC_CTX
*mem_ctx
;
6676 if (state
->out_mem_ctx
) {
6677 mem_ctx
= state
->out_mem_ctx
;
6682 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6683 TALLOC_FREE(subreq
);
6684 if (!NT_STATUS_IS_OK(status
)) {
6685 tevent_req_nterror(req
, status
);
6689 /* Copy out parameters */
6692 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6694 /* Reset temporary structure */
6695 ZERO_STRUCT(state
->tmp
);
6697 tevent_req_done(req
);
6700 NTSTATUS
rpccli_netr_DsrDeregisterDNSHostRecords_recv(struct tevent_req
*req
,
6701 TALLOC_CTX
*mem_ctx
,
6704 struct rpccli_netr_DsrDeregisterDNSHostRecords_state
*state
= tevent_req_data(
6705 req
, struct rpccli_netr_DsrDeregisterDNSHostRecords_state
);
6708 if (tevent_req_is_nterror(req
, &status
)) {
6709 tevent_req_received(req
);
6713 /* Steal possbile out parameters to the callers context */
6714 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6717 *result
= state
->orig
.out
.result
;
6719 tevent_req_received(req
);
6720 return NT_STATUS_OK
;
6723 NTSTATUS
rpccli_netr_DsrDeregisterDNSHostRecords(struct rpc_pipe_client
*cli
,
6724 TALLOC_CTX
*mem_ctx
,
6725 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6726 const char *domain
/* [in] [unique,charset(UTF16)] */,
6727 struct GUID
*domain_guid
/* [in] [unique] */,
6728 struct GUID
*dsa_guid
/* [in] [unique] */,
6729 const char *dns_host
/* [in] [ref,charset(UTF16)] */,
6732 struct netr_DsrDeregisterDNSHostRecords r
;
6736 r
.in
.server_name
= server_name
;
6737 r
.in
.domain
= domain
;
6738 r
.in
.domain_guid
= domain_guid
;
6739 r
.in
.dsa_guid
= dsa_guid
;
6740 r
.in
.dns_host
= dns_host
;
6742 status
= cli
->dispatch(cli
,
6744 &ndr_table_netlogon
,
6745 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS
,
6748 if (!NT_STATUS_IS_OK(status
)) {
6752 if (NT_STATUS_IS_ERR(status
)) {
6756 /* Return variables */
6760 *werror
= r
.out
.result
;
6763 return werror_to_ntstatus(r
.out
.result
);
6766 struct rpccli_netr_ServerTrustPasswordsGet_state
{
6767 struct netr_ServerTrustPasswordsGet orig
;
6768 struct netr_ServerTrustPasswordsGet tmp
;
6769 TALLOC_CTX
*out_mem_ctx
;
6770 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6773 static void rpccli_netr_ServerTrustPasswordsGet_done(struct tevent_req
*subreq
);
6775 struct tevent_req
*rpccli_netr_ServerTrustPasswordsGet_send(TALLOC_CTX
*mem_ctx
,
6776 struct tevent_context
*ev
,
6777 struct rpc_pipe_client
*cli
,
6778 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6779 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
6780 enum netr_SchannelType _secure_channel_type
/* [in] */,
6781 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
6782 struct netr_Authenticator
*_credential
/* [in] [ref] */,
6783 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
6784 struct samr_Password
*_password
/* [out] [ref] */,
6785 struct samr_Password
*_password2
/* [out] [ref] */)
6787 struct tevent_req
*req
;
6788 struct rpccli_netr_ServerTrustPasswordsGet_state
*state
;
6789 struct tevent_req
*subreq
;
6791 req
= tevent_req_create(mem_ctx
, &state
,
6792 struct rpccli_netr_ServerTrustPasswordsGet_state
);
6796 state
->out_mem_ctx
= NULL
;
6797 state
->dispatch_recv
= cli
->dispatch_recv
;
6800 state
->orig
.in
.server_name
= _server_name
;
6801 state
->orig
.in
.account_name
= _account_name
;
6802 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
6803 state
->orig
.in
.computer_name
= _computer_name
;
6804 state
->orig
.in
.credential
= _credential
;
6806 /* Out parameters */
6807 state
->orig
.out
.return_authenticator
= _return_authenticator
;
6808 state
->orig
.out
.password
= _password
;
6809 state
->orig
.out
.password2
= _password2
;
6812 ZERO_STRUCT(state
->orig
.out
.result
);
6814 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6815 "rpccli_netr_ServerTrustPasswordsGet_out_memory");
6816 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6817 return tevent_req_post(req
, ev
);
6820 /* make a temporary copy, that we pass to the dispatch function */
6821 state
->tmp
= state
->orig
;
6823 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6824 &ndr_table_netlogon
,
6825 NDR_NETR_SERVERTRUSTPASSWORDSGET
,
6827 if (tevent_req_nomem(subreq
, req
)) {
6828 return tevent_req_post(req
, ev
);
6830 tevent_req_set_callback(subreq
, rpccli_netr_ServerTrustPasswordsGet_done
, req
);
6834 static void rpccli_netr_ServerTrustPasswordsGet_done(struct tevent_req
*subreq
)
6836 struct tevent_req
*req
= tevent_req_callback_data(
6837 subreq
, struct tevent_req
);
6838 struct rpccli_netr_ServerTrustPasswordsGet_state
*state
= tevent_req_data(
6839 req
, struct rpccli_netr_ServerTrustPasswordsGet_state
);
6841 TALLOC_CTX
*mem_ctx
;
6843 if (state
->out_mem_ctx
) {
6844 mem_ctx
= state
->out_mem_ctx
;
6849 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6850 TALLOC_FREE(subreq
);
6851 if (!NT_STATUS_IS_OK(status
)) {
6852 tevent_req_nterror(req
, status
);
6856 /* Copy out parameters */
6857 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
6858 *state
->orig
.out
.password
= *state
->tmp
.out
.password
;
6859 *state
->orig
.out
.password2
= *state
->tmp
.out
.password2
;
6862 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6864 /* Reset temporary structure */
6865 ZERO_STRUCT(state
->tmp
);
6867 tevent_req_done(req
);
6870 NTSTATUS
rpccli_netr_ServerTrustPasswordsGet_recv(struct tevent_req
*req
,
6871 TALLOC_CTX
*mem_ctx
,
6874 struct rpccli_netr_ServerTrustPasswordsGet_state
*state
= tevent_req_data(
6875 req
, struct rpccli_netr_ServerTrustPasswordsGet_state
);
6878 if (tevent_req_is_nterror(req
, &status
)) {
6879 tevent_req_received(req
);
6883 /* Steal possbile out parameters to the callers context */
6884 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6887 *result
= state
->orig
.out
.result
;
6889 tevent_req_received(req
);
6890 return NT_STATUS_OK
;
6893 NTSTATUS
rpccli_netr_ServerTrustPasswordsGet(struct rpc_pipe_client
*cli
,
6894 TALLOC_CTX
*mem_ctx
,
6895 const char *server_name
/* [in] [unique,charset(UTF16)] */,
6896 const char *account_name
/* [in] [ref,charset(UTF16)] */,
6897 enum netr_SchannelType secure_channel_type
/* [in] */,
6898 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
6899 struct netr_Authenticator
*credential
/* [in] [ref] */,
6900 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
6901 struct samr_Password
*password
/* [out] [ref] */,
6902 struct samr_Password
*password2
/* [out] [ref] */)
6904 struct netr_ServerTrustPasswordsGet r
;
6908 r
.in
.server_name
= server_name
;
6909 r
.in
.account_name
= account_name
;
6910 r
.in
.secure_channel_type
= secure_channel_type
;
6911 r
.in
.computer_name
= computer_name
;
6912 r
.in
.credential
= credential
;
6914 status
= cli
->dispatch(cli
,
6916 &ndr_table_netlogon
,
6917 NDR_NETR_SERVERTRUSTPASSWORDSGET
,
6920 if (!NT_STATUS_IS_OK(status
)) {
6924 if (NT_STATUS_IS_ERR(status
)) {
6928 /* Return variables */
6929 *return_authenticator
= *r
.out
.return_authenticator
;
6930 *password
= *r
.out
.password
;
6931 *password2
= *r
.out
.password2
;
6934 return r
.out
.result
;
6937 struct rpccli_netr_DsRGetForestTrustInformation_state
{
6938 struct netr_DsRGetForestTrustInformation orig
;
6939 struct netr_DsRGetForestTrustInformation tmp
;
6940 TALLOC_CTX
*out_mem_ctx
;
6941 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6944 static void rpccli_netr_DsRGetForestTrustInformation_done(struct tevent_req
*subreq
);
6946 struct tevent_req
*rpccli_netr_DsRGetForestTrustInformation_send(TALLOC_CTX
*mem_ctx
,
6947 struct tevent_context
*ev
,
6948 struct rpc_pipe_client
*cli
,
6949 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
6950 const char *_trusted_domain_name
/* [in] [unique,charset(UTF16)] */,
6951 uint32_t _flags
/* [in] */,
6952 struct lsa_ForestTrustInformation
**_forest_trust_info
/* [out] [ref] */)
6954 struct tevent_req
*req
;
6955 struct rpccli_netr_DsRGetForestTrustInformation_state
*state
;
6956 struct tevent_req
*subreq
;
6958 req
= tevent_req_create(mem_ctx
, &state
,
6959 struct rpccli_netr_DsRGetForestTrustInformation_state
);
6963 state
->out_mem_ctx
= NULL
;
6964 state
->dispatch_recv
= cli
->dispatch_recv
;
6967 state
->orig
.in
.server_name
= _server_name
;
6968 state
->orig
.in
.trusted_domain_name
= _trusted_domain_name
;
6969 state
->orig
.in
.flags
= _flags
;
6971 /* Out parameters */
6972 state
->orig
.out
.forest_trust_info
= _forest_trust_info
;
6975 ZERO_STRUCT(state
->orig
.out
.result
);
6977 state
->out_mem_ctx
= talloc_named_const(state
, 0,
6978 "rpccli_netr_DsRGetForestTrustInformation_out_memory");
6979 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
6980 return tevent_req_post(req
, ev
);
6983 /* make a temporary copy, that we pass to the dispatch function */
6984 state
->tmp
= state
->orig
;
6986 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6987 &ndr_table_netlogon
,
6988 NDR_NETR_DSRGETFORESTTRUSTINFORMATION
,
6990 if (tevent_req_nomem(subreq
, req
)) {
6991 return tevent_req_post(req
, ev
);
6993 tevent_req_set_callback(subreq
, rpccli_netr_DsRGetForestTrustInformation_done
, req
);
6997 static void rpccli_netr_DsRGetForestTrustInformation_done(struct tevent_req
*subreq
)
6999 struct tevent_req
*req
= tevent_req_callback_data(
7000 subreq
, struct tevent_req
);
7001 struct rpccli_netr_DsRGetForestTrustInformation_state
*state
= tevent_req_data(
7002 req
, struct rpccli_netr_DsRGetForestTrustInformation_state
);
7004 TALLOC_CTX
*mem_ctx
;
7006 if (state
->out_mem_ctx
) {
7007 mem_ctx
= state
->out_mem_ctx
;
7012 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7013 TALLOC_FREE(subreq
);
7014 if (!NT_STATUS_IS_OK(status
)) {
7015 tevent_req_nterror(req
, status
);
7019 /* Copy out parameters */
7020 *state
->orig
.out
.forest_trust_info
= *state
->tmp
.out
.forest_trust_info
;
7023 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7025 /* Reset temporary structure */
7026 ZERO_STRUCT(state
->tmp
);
7028 tevent_req_done(req
);
7031 NTSTATUS
rpccli_netr_DsRGetForestTrustInformation_recv(struct tevent_req
*req
,
7032 TALLOC_CTX
*mem_ctx
,
7035 struct rpccli_netr_DsRGetForestTrustInformation_state
*state
= tevent_req_data(
7036 req
, struct rpccli_netr_DsRGetForestTrustInformation_state
);
7039 if (tevent_req_is_nterror(req
, &status
)) {
7040 tevent_req_received(req
);
7044 /* Steal possbile out parameters to the callers context */
7045 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7048 *result
= state
->orig
.out
.result
;
7050 tevent_req_received(req
);
7051 return NT_STATUS_OK
;
7054 NTSTATUS
rpccli_netr_DsRGetForestTrustInformation(struct rpc_pipe_client
*cli
,
7055 TALLOC_CTX
*mem_ctx
,
7056 const char *server_name
/* [in] [unique,charset(UTF16)] */,
7057 const char *trusted_domain_name
/* [in] [unique,charset(UTF16)] */,
7058 uint32_t flags
/* [in] */,
7059 struct lsa_ForestTrustInformation
**forest_trust_info
/* [out] [ref] */,
7062 struct netr_DsRGetForestTrustInformation r
;
7066 r
.in
.server_name
= server_name
;
7067 r
.in
.trusted_domain_name
= trusted_domain_name
;
7070 status
= cli
->dispatch(cli
,
7072 &ndr_table_netlogon
,
7073 NDR_NETR_DSRGETFORESTTRUSTINFORMATION
,
7076 if (!NT_STATUS_IS_OK(status
)) {
7080 if (NT_STATUS_IS_ERR(status
)) {
7084 /* Return variables */
7085 *forest_trust_info
= *r
.out
.forest_trust_info
;
7089 *werror
= r
.out
.result
;
7092 return werror_to_ntstatus(r
.out
.result
);
7095 struct rpccli_netr_GetForestTrustInformation_state
{
7096 struct netr_GetForestTrustInformation orig
;
7097 struct netr_GetForestTrustInformation tmp
;
7098 TALLOC_CTX
*out_mem_ctx
;
7099 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7102 static void rpccli_netr_GetForestTrustInformation_done(struct tevent_req
*subreq
);
7104 struct tevent_req
*rpccli_netr_GetForestTrustInformation_send(TALLOC_CTX
*mem_ctx
,
7105 struct tevent_context
*ev
,
7106 struct rpc_pipe_client
*cli
,
7107 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
7108 const char *_trusted_domain_name
/* [in] [ref,charset(UTF16)] */,
7109 struct netr_Authenticator
*_credential
/* [in] [ref] */,
7110 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
7111 uint32_t _flags
/* [in] */,
7112 struct lsa_ForestTrustInformation
**_forest_trust_info
/* [out] [ref] */)
7114 struct tevent_req
*req
;
7115 struct rpccli_netr_GetForestTrustInformation_state
*state
;
7116 struct tevent_req
*subreq
;
7118 req
= tevent_req_create(mem_ctx
, &state
,
7119 struct rpccli_netr_GetForestTrustInformation_state
);
7123 state
->out_mem_ctx
= NULL
;
7124 state
->dispatch_recv
= cli
->dispatch_recv
;
7127 state
->orig
.in
.server_name
= _server_name
;
7128 state
->orig
.in
.trusted_domain_name
= _trusted_domain_name
;
7129 state
->orig
.in
.credential
= _credential
;
7130 state
->orig
.in
.flags
= _flags
;
7132 /* Out parameters */
7133 state
->orig
.out
.return_authenticator
= _return_authenticator
;
7134 state
->orig
.out
.forest_trust_info
= _forest_trust_info
;
7137 ZERO_STRUCT(state
->orig
.out
.result
);
7139 state
->out_mem_ctx
= talloc_named_const(state
, 0,
7140 "rpccli_netr_GetForestTrustInformation_out_memory");
7141 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
7142 return tevent_req_post(req
, ev
);
7145 /* make a temporary copy, that we pass to the dispatch function */
7146 state
->tmp
= state
->orig
;
7148 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7149 &ndr_table_netlogon
,
7150 NDR_NETR_GETFORESTTRUSTINFORMATION
,
7152 if (tevent_req_nomem(subreq
, req
)) {
7153 return tevent_req_post(req
, ev
);
7155 tevent_req_set_callback(subreq
, rpccli_netr_GetForestTrustInformation_done
, req
);
7159 static void rpccli_netr_GetForestTrustInformation_done(struct tevent_req
*subreq
)
7161 struct tevent_req
*req
= tevent_req_callback_data(
7162 subreq
, struct tevent_req
);
7163 struct rpccli_netr_GetForestTrustInformation_state
*state
= tevent_req_data(
7164 req
, struct rpccli_netr_GetForestTrustInformation_state
);
7166 TALLOC_CTX
*mem_ctx
;
7168 if (state
->out_mem_ctx
) {
7169 mem_ctx
= state
->out_mem_ctx
;
7174 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7175 TALLOC_FREE(subreq
);
7176 if (!NT_STATUS_IS_OK(status
)) {
7177 tevent_req_nterror(req
, status
);
7181 /* Copy out parameters */
7182 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
7183 *state
->orig
.out
.forest_trust_info
= *state
->tmp
.out
.forest_trust_info
;
7186 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7188 /* Reset temporary structure */
7189 ZERO_STRUCT(state
->tmp
);
7191 tevent_req_done(req
);
7194 NTSTATUS
rpccli_netr_GetForestTrustInformation_recv(struct tevent_req
*req
,
7195 TALLOC_CTX
*mem_ctx
,
7198 struct rpccli_netr_GetForestTrustInformation_state
*state
= tevent_req_data(
7199 req
, struct rpccli_netr_GetForestTrustInformation_state
);
7202 if (tevent_req_is_nterror(req
, &status
)) {
7203 tevent_req_received(req
);
7207 /* Steal possbile out parameters to the callers context */
7208 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7211 *result
= state
->orig
.out
.result
;
7213 tevent_req_received(req
);
7214 return NT_STATUS_OK
;
7217 NTSTATUS
rpccli_netr_GetForestTrustInformation(struct rpc_pipe_client
*cli
,
7218 TALLOC_CTX
*mem_ctx
,
7219 const char *server_name
/* [in] [unique,charset(UTF16)] */,
7220 const char *trusted_domain_name
/* [in] [ref,charset(UTF16)] */,
7221 struct netr_Authenticator
*credential
/* [in] [ref] */,
7222 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
7223 uint32_t flags
/* [in] */,
7224 struct lsa_ForestTrustInformation
**forest_trust_info
/* [out] [ref] */,
7227 struct netr_GetForestTrustInformation r
;
7231 r
.in
.server_name
= server_name
;
7232 r
.in
.trusted_domain_name
= trusted_domain_name
;
7233 r
.in
.credential
= credential
;
7236 status
= cli
->dispatch(cli
,
7238 &ndr_table_netlogon
,
7239 NDR_NETR_GETFORESTTRUSTINFORMATION
,
7242 if (!NT_STATUS_IS_OK(status
)) {
7246 if (NT_STATUS_IS_ERR(status
)) {
7250 /* Return variables */
7251 *return_authenticator
= *r
.out
.return_authenticator
;
7252 *forest_trust_info
= *r
.out
.forest_trust_info
;
7256 *werror
= r
.out
.result
;
7259 return werror_to_ntstatus(r
.out
.result
);
7262 struct rpccli_netr_LogonSamLogonWithFlags_state
{
7263 struct netr_LogonSamLogonWithFlags orig
;
7264 struct netr_LogonSamLogonWithFlags tmp
;
7265 TALLOC_CTX
*out_mem_ctx
;
7266 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7269 static void rpccli_netr_LogonSamLogonWithFlags_done(struct tevent_req
*subreq
);
7271 struct tevent_req
*rpccli_netr_LogonSamLogonWithFlags_send(TALLOC_CTX
*mem_ctx
,
7272 struct tevent_context
*ev
,
7273 struct rpc_pipe_client
*cli
,
7274 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
7275 const char *_computer_name
/* [in] [unique,charset(UTF16)] */,
7276 struct netr_Authenticator
*_credential
/* [in] [unique] */,
7277 struct netr_Authenticator
*_return_authenticator
/* [in,out] [unique] */,
7278 enum netr_LogonInfoClass _logon_level
/* [in] */,
7279 union netr_LogonLevel
*_logon
/* [in] [ref,switch_is(logon_level)] */,
7280 uint16_t _validation_level
/* [in] */,
7281 union netr_Validation
*_validation
/* [out] [ref,switch_is(validation_level)] */,
7282 uint8_t *_authoritative
/* [out] [ref] */,
7283 uint32_t *_flags
/* [in,out] [ref] */)
7285 struct tevent_req
*req
;
7286 struct rpccli_netr_LogonSamLogonWithFlags_state
*state
;
7287 struct tevent_req
*subreq
;
7289 req
= tevent_req_create(mem_ctx
, &state
,
7290 struct rpccli_netr_LogonSamLogonWithFlags_state
);
7294 state
->out_mem_ctx
= NULL
;
7295 state
->dispatch_recv
= cli
->dispatch_recv
;
7298 state
->orig
.in
.server_name
= _server_name
;
7299 state
->orig
.in
.computer_name
= _computer_name
;
7300 state
->orig
.in
.credential
= _credential
;
7301 state
->orig
.in
.return_authenticator
= _return_authenticator
;
7302 state
->orig
.in
.logon_level
= _logon_level
;
7303 state
->orig
.in
.logon
= _logon
;
7304 state
->orig
.in
.validation_level
= _validation_level
;
7305 state
->orig
.in
.flags
= _flags
;
7307 /* Out parameters */
7308 state
->orig
.out
.return_authenticator
= _return_authenticator
;
7309 state
->orig
.out
.validation
= _validation
;
7310 state
->orig
.out
.authoritative
= _authoritative
;
7311 state
->orig
.out
.flags
= _flags
;
7314 ZERO_STRUCT(state
->orig
.out
.result
);
7316 state
->out_mem_ctx
= talloc_named_const(state
, 0,
7317 "rpccli_netr_LogonSamLogonWithFlags_out_memory");
7318 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
7319 return tevent_req_post(req
, ev
);
7322 /* make a temporary copy, that we pass to the dispatch function */
7323 state
->tmp
= state
->orig
;
7325 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7326 &ndr_table_netlogon
,
7327 NDR_NETR_LOGONSAMLOGONWITHFLAGS
,
7329 if (tevent_req_nomem(subreq
, req
)) {
7330 return tevent_req_post(req
, ev
);
7332 tevent_req_set_callback(subreq
, rpccli_netr_LogonSamLogonWithFlags_done
, req
);
7336 static void rpccli_netr_LogonSamLogonWithFlags_done(struct tevent_req
*subreq
)
7338 struct tevent_req
*req
= tevent_req_callback_data(
7339 subreq
, struct tevent_req
);
7340 struct rpccli_netr_LogonSamLogonWithFlags_state
*state
= tevent_req_data(
7341 req
, struct rpccli_netr_LogonSamLogonWithFlags_state
);
7343 TALLOC_CTX
*mem_ctx
;
7345 if (state
->out_mem_ctx
) {
7346 mem_ctx
= state
->out_mem_ctx
;
7351 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7352 TALLOC_FREE(subreq
);
7353 if (!NT_STATUS_IS_OK(status
)) {
7354 tevent_req_nterror(req
, status
);
7358 /* Copy out parameters */
7359 if (state
->orig
.out
.return_authenticator
&& state
->tmp
.out
.return_authenticator
) {
7360 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
7362 *state
->orig
.out
.validation
= *state
->tmp
.out
.validation
;
7363 *state
->orig
.out
.authoritative
= *state
->tmp
.out
.authoritative
;
7364 *state
->orig
.out
.flags
= *state
->tmp
.out
.flags
;
7367 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7369 /* Reset temporary structure */
7370 ZERO_STRUCT(state
->tmp
);
7372 tevent_req_done(req
);
7375 NTSTATUS
rpccli_netr_LogonSamLogonWithFlags_recv(struct tevent_req
*req
,
7376 TALLOC_CTX
*mem_ctx
,
7379 struct rpccli_netr_LogonSamLogonWithFlags_state
*state
= tevent_req_data(
7380 req
, struct rpccli_netr_LogonSamLogonWithFlags_state
);
7383 if (tevent_req_is_nterror(req
, &status
)) {
7384 tevent_req_received(req
);
7388 /* Steal possbile out parameters to the callers context */
7389 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7392 *result
= state
->orig
.out
.result
;
7394 tevent_req_received(req
);
7395 return NT_STATUS_OK
;
7398 NTSTATUS
rpccli_netr_LogonSamLogonWithFlags(struct rpc_pipe_client
*cli
,
7399 TALLOC_CTX
*mem_ctx
,
7400 const char *server_name
/* [in] [unique,charset(UTF16)] */,
7401 const char *computer_name
/* [in] [unique,charset(UTF16)] */,
7402 struct netr_Authenticator
*credential
/* [in] [unique] */,
7403 struct netr_Authenticator
*return_authenticator
/* [in,out] [unique] */,
7404 enum netr_LogonInfoClass logon_level
/* [in] */,
7405 union netr_LogonLevel
*logon
/* [in] [ref,switch_is(logon_level)] */,
7406 uint16_t validation_level
/* [in] */,
7407 union netr_Validation
*validation
/* [out] [ref,switch_is(validation_level)] */,
7408 uint8_t *authoritative
/* [out] [ref] */,
7409 uint32_t *flags
/* [in,out] [ref] */)
7411 struct netr_LogonSamLogonWithFlags r
;
7415 r
.in
.server_name
= server_name
;
7416 r
.in
.computer_name
= computer_name
;
7417 r
.in
.credential
= credential
;
7418 r
.in
.return_authenticator
= return_authenticator
;
7419 r
.in
.logon_level
= logon_level
;
7421 r
.in
.validation_level
= validation_level
;
7424 status
= cli
->dispatch(cli
,
7426 &ndr_table_netlogon
,
7427 NDR_NETR_LOGONSAMLOGONWITHFLAGS
,
7430 if (!NT_STATUS_IS_OK(status
)) {
7434 if (NT_STATUS_IS_ERR(status
)) {
7438 /* Return variables */
7439 if (return_authenticator
&& r
.out
.return_authenticator
) {
7440 *return_authenticator
= *r
.out
.return_authenticator
;
7442 *validation
= *r
.out
.validation
;
7443 *authoritative
= *r
.out
.authoritative
;
7444 *flags
= *r
.out
.flags
;
7447 return r
.out
.result
;
7450 struct rpccli_netr_ServerGetTrustInfo_state
{
7451 struct netr_ServerGetTrustInfo orig
;
7452 struct netr_ServerGetTrustInfo tmp
;
7453 TALLOC_CTX
*out_mem_ctx
;
7454 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7457 static void rpccli_netr_ServerGetTrustInfo_done(struct tevent_req
*subreq
);
7459 struct tevent_req
*rpccli_netr_ServerGetTrustInfo_send(TALLOC_CTX
*mem_ctx
,
7460 struct tevent_context
*ev
,
7461 struct rpc_pipe_client
*cli
,
7462 const char *_server_name
/* [in] [unique,charset(UTF16)] */,
7463 const char *_account_name
/* [in] [ref,charset(UTF16)] */,
7464 enum netr_SchannelType _secure_channel_type
/* [in] */,
7465 const char *_computer_name
/* [in] [ref,charset(UTF16)] */,
7466 struct netr_Authenticator
*_credential
/* [in] [ref] */,
7467 struct netr_Authenticator
*_return_authenticator
/* [out] [ref] */,
7468 struct samr_Password
*_new_owf_password
/* [out] [ref] */,
7469 struct samr_Password
*_old_owf_password
/* [out] [ref] */,
7470 struct netr_TrustInfo
**_trust_info
/* [out] [ref] */)
7472 struct tevent_req
*req
;
7473 struct rpccli_netr_ServerGetTrustInfo_state
*state
;
7474 struct tevent_req
*subreq
;
7476 req
= tevent_req_create(mem_ctx
, &state
,
7477 struct rpccli_netr_ServerGetTrustInfo_state
);
7481 state
->out_mem_ctx
= NULL
;
7482 state
->dispatch_recv
= cli
->dispatch_recv
;
7485 state
->orig
.in
.server_name
= _server_name
;
7486 state
->orig
.in
.account_name
= _account_name
;
7487 state
->orig
.in
.secure_channel_type
= _secure_channel_type
;
7488 state
->orig
.in
.computer_name
= _computer_name
;
7489 state
->orig
.in
.credential
= _credential
;
7491 /* Out parameters */
7492 state
->orig
.out
.return_authenticator
= _return_authenticator
;
7493 state
->orig
.out
.new_owf_password
= _new_owf_password
;
7494 state
->orig
.out
.old_owf_password
= _old_owf_password
;
7495 state
->orig
.out
.trust_info
= _trust_info
;
7498 ZERO_STRUCT(state
->orig
.out
.result
);
7500 state
->out_mem_ctx
= talloc_named_const(state
, 0,
7501 "rpccli_netr_ServerGetTrustInfo_out_memory");
7502 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
7503 return tevent_req_post(req
, ev
);
7506 /* make a temporary copy, that we pass to the dispatch function */
7507 state
->tmp
= state
->orig
;
7509 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7510 &ndr_table_netlogon
,
7511 NDR_NETR_SERVERGETTRUSTINFO
,
7513 if (tevent_req_nomem(subreq
, req
)) {
7514 return tevent_req_post(req
, ev
);
7516 tevent_req_set_callback(subreq
, rpccli_netr_ServerGetTrustInfo_done
, req
);
7520 static void rpccli_netr_ServerGetTrustInfo_done(struct tevent_req
*subreq
)
7522 struct tevent_req
*req
= tevent_req_callback_data(
7523 subreq
, struct tevent_req
);
7524 struct rpccli_netr_ServerGetTrustInfo_state
*state
= tevent_req_data(
7525 req
, struct rpccli_netr_ServerGetTrustInfo_state
);
7527 TALLOC_CTX
*mem_ctx
;
7529 if (state
->out_mem_ctx
) {
7530 mem_ctx
= state
->out_mem_ctx
;
7535 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7536 TALLOC_FREE(subreq
);
7537 if (!NT_STATUS_IS_OK(status
)) {
7538 tevent_req_nterror(req
, status
);
7542 /* Copy out parameters */
7543 *state
->orig
.out
.return_authenticator
= *state
->tmp
.out
.return_authenticator
;
7544 *state
->orig
.out
.new_owf_password
= *state
->tmp
.out
.new_owf_password
;
7545 *state
->orig
.out
.old_owf_password
= *state
->tmp
.out
.old_owf_password
;
7546 *state
->orig
.out
.trust_info
= *state
->tmp
.out
.trust_info
;
7549 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7551 /* Reset temporary structure */
7552 ZERO_STRUCT(state
->tmp
);
7554 tevent_req_done(req
);
7557 NTSTATUS
rpccli_netr_ServerGetTrustInfo_recv(struct tevent_req
*req
,
7558 TALLOC_CTX
*mem_ctx
,
7561 struct rpccli_netr_ServerGetTrustInfo_state
*state
= tevent_req_data(
7562 req
, struct rpccli_netr_ServerGetTrustInfo_state
);
7565 if (tevent_req_is_nterror(req
, &status
)) {
7566 tevent_req_received(req
);
7570 /* Steal possbile out parameters to the callers context */
7571 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7574 *result
= state
->orig
.out
.result
;
7576 tevent_req_received(req
);
7577 return NT_STATUS_OK
;
7580 NTSTATUS
rpccli_netr_ServerGetTrustInfo(struct rpc_pipe_client
*cli
,
7581 TALLOC_CTX
*mem_ctx
,
7582 const char *server_name
/* [in] [unique,charset(UTF16)] */,
7583 const char *account_name
/* [in] [ref,charset(UTF16)] */,
7584 enum netr_SchannelType secure_channel_type
/* [in] */,
7585 const char *computer_name
/* [in] [ref,charset(UTF16)] */,
7586 struct netr_Authenticator
*credential
/* [in] [ref] */,
7587 struct netr_Authenticator
*return_authenticator
/* [out] [ref] */,
7588 struct samr_Password
*new_owf_password
/* [out] [ref] */,
7589 struct samr_Password
*old_owf_password
/* [out] [ref] */,
7590 struct netr_TrustInfo
**trust_info
/* [out] [ref] */)
7592 struct netr_ServerGetTrustInfo r
;
7596 r
.in
.server_name
= server_name
;
7597 r
.in
.account_name
= account_name
;
7598 r
.in
.secure_channel_type
= secure_channel_type
;
7599 r
.in
.computer_name
= computer_name
;
7600 r
.in
.credential
= credential
;
7602 status
= cli
->dispatch(cli
,
7604 &ndr_table_netlogon
,
7605 NDR_NETR_SERVERGETTRUSTINFO
,
7608 if (!NT_STATUS_IS_OK(status
)) {
7612 if (NT_STATUS_IS_ERR(status
)) {
7616 /* Return variables */
7617 *return_authenticator
= *r
.out
.return_authenticator
;
7618 *new_owf_password
= *r
.out
.new_owf_password
;
7619 *old_owf_password
= *r
.out
.old_owf_password
;
7620 *trust_info
= *r
.out
.trust_info
;
7623 return r
.out
.result
;