source: branches/samba-3.5.x/librpc/gen_ndr/cli_netlogon.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 209.1 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "../librpc/gen_ndr/cli_netlogon.h"
8
9struct 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);
14};
15
16static void rpccli_netr_LogonUasLogon_done(struct tevent_req *subreq);
17
18struct 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] */)
25{
26 struct tevent_req *req;
27 struct rpccli_netr_LogonUasLogon_state *state;
28 struct tevent_req *subreq;
29
30 req = tevent_req_create(mem_ctx, &state,
31 struct rpccli_netr_LogonUasLogon_state);
32 if (req == NULL) {
33 return NULL;
34 }
35 state->out_mem_ctx = NULL;
36 state->dispatch_recv = cli->dispatch_recv;
37
38 /* In parameters */
39 state->orig.in.server_name = _server_name;
40 state->orig.in.account_name = _account_name;
41 state->orig.in.workstation = _workstation;
42
43 /* Out parameters */
44 state->orig.out.info = _info;
45
46 /* Result */
47 ZERO_STRUCT(state->orig.out.result);
48
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);
53 }
54
55 /* make a temporary copy, that we pass to the dispatch function */
56 state->tmp = state->orig;
57
58 subreq = cli->dispatch_send(state, ev, cli,
59 &ndr_table_netlogon,
60 NDR_NETR_LOGONUASLOGON,
61 &state->tmp);
62 if (tevent_req_nomem(subreq, req)) {
63 return tevent_req_post(req, ev);
64 }
65 tevent_req_set_callback(subreq, rpccli_netr_LogonUasLogon_done, req);
66 return req;
67}
68
69static void rpccli_netr_LogonUasLogon_done(struct tevent_req *subreq)
70{
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);
75 NTSTATUS status;
76 TALLOC_CTX *mem_ctx;
77
78 if (state->out_mem_ctx) {
79 mem_ctx = state->out_mem_ctx;
80 } else {
81 mem_ctx = state;
82 }
83
84 status = state->dispatch_recv(subreq, mem_ctx);
85 TALLOC_FREE(subreq);
86 if (!NT_STATUS_IS_OK(status)) {
87 tevent_req_nterror(req, status);
88 return;
89 }
90
91 /* Copy out parameters */
92 *state->orig.out.info = *state->tmp.out.info;
93
94 /* Copy result */
95 state->orig.out.result = state->tmp.out.result;
96
97 /* Reset temporary structure */
98 ZERO_STRUCT(state->tmp);
99
100 tevent_req_done(req);
101}
102
103NTSTATUS rpccli_netr_LogonUasLogon_recv(struct tevent_req *req,
104 TALLOC_CTX *mem_ctx,
105 WERROR *result)
106{
107 struct rpccli_netr_LogonUasLogon_state *state = tevent_req_data(
108 req, struct rpccli_netr_LogonUasLogon_state);
109 NTSTATUS status;
110
111 if (tevent_req_is_nterror(req, &status)) {
112 tevent_req_received(req);
113 return status;
114 }
115
116 /* Steal possbile out parameters to the callers context */
117 talloc_steal(mem_ctx, state->out_mem_ctx);
118
119 /* Return result */
120 *result = state->orig.out.result;
121
122 tevent_req_received(req);
123 return NT_STATUS_OK;
124}
125
126NTSTATUS rpccli_netr_LogonUasLogon(struct rpc_pipe_client *cli,
127 TALLOC_CTX *mem_ctx,
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] */,
132 WERROR *werror)
133{
134 struct netr_LogonUasLogon r;
135 NTSTATUS status;
136
137 /* In parameters */
138 r.in.server_name = server_name;
139 r.in.account_name = account_name;
140 r.in.workstation = workstation;
141
142 status = cli->dispatch(cli,
143 mem_ctx,
144 &ndr_table_netlogon,
145 NDR_NETR_LOGONUASLOGON,
146 &r);
147
148 if (!NT_STATUS_IS_OK(status)) {
149 return status;
150 }
151
152 if (NT_STATUS_IS_ERR(status)) {
153 return status;
154 }
155
156 /* Return variables */
157 *info = *r.out.info;
158
159 /* Return result */
160 if (werror) {
161 *werror = r.out.result;
162 }
163
164 return werror_to_ntstatus(r.out.result);
165}
166
167struct 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);
172};
173
174static void rpccli_netr_LogonUasLogoff_done(struct tevent_req *subreq);
175
176struct 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] */)
183{
184 struct tevent_req *req;
185 struct rpccli_netr_LogonUasLogoff_state *state;
186 struct tevent_req *subreq;
187
188 req = tevent_req_create(mem_ctx, &state,
189 struct rpccli_netr_LogonUasLogoff_state);
190 if (req == NULL) {
191 return NULL;
192 }
193 state->out_mem_ctx = NULL;
194 state->dispatch_recv = cli->dispatch_recv;
195
196 /* In parameters */
197 state->orig.in.server_name = _server_name;
198 state->orig.in.account_name = _account_name;
199 state->orig.in.workstation = _workstation;
200
201 /* Out parameters */
202 state->orig.out.info = _info;
203
204 /* Result */
205 ZERO_STRUCT(state->orig.out.result);
206
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);
211 }
212
213 /* make a temporary copy, that we pass to the dispatch function */
214 state->tmp = state->orig;
215
216 subreq = cli->dispatch_send(state, ev, cli,
217 &ndr_table_netlogon,
218 NDR_NETR_LOGONUASLOGOFF,
219 &state->tmp);
220 if (tevent_req_nomem(subreq, req)) {
221 return tevent_req_post(req, ev);
222 }
223 tevent_req_set_callback(subreq, rpccli_netr_LogonUasLogoff_done, req);
224 return req;
225}
226
227static void rpccli_netr_LogonUasLogoff_done(struct tevent_req *subreq)
228{
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);
233 NTSTATUS status;
234 TALLOC_CTX *mem_ctx;
235
236 if (state->out_mem_ctx) {
237 mem_ctx = state->out_mem_ctx;
238 } else {
239 mem_ctx = state;
240 }
241
242 status = state->dispatch_recv(subreq, mem_ctx);
243 TALLOC_FREE(subreq);
244 if (!NT_STATUS_IS_OK(status)) {
245 tevent_req_nterror(req, status);
246 return;
247 }
248
249 /* Copy out parameters */
250 *state->orig.out.info = *state->tmp.out.info;
251
252 /* Copy result */
253 state->orig.out.result = state->tmp.out.result;
254
255 /* Reset temporary structure */
256 ZERO_STRUCT(state->tmp);
257
258 tevent_req_done(req);
259}
260
261NTSTATUS rpccli_netr_LogonUasLogoff_recv(struct tevent_req *req,
262 TALLOC_CTX *mem_ctx,
263 WERROR *result)
264{
265 struct rpccli_netr_LogonUasLogoff_state *state = tevent_req_data(
266 req, struct rpccli_netr_LogonUasLogoff_state);
267 NTSTATUS status;
268
269 if (tevent_req_is_nterror(req, &status)) {
270 tevent_req_received(req);
271 return status;
272 }
273
274 /* Steal possbile out parameters to the callers context */
275 talloc_steal(mem_ctx, state->out_mem_ctx);
276
277 /* Return result */
278 *result = state->orig.out.result;
279
280 tevent_req_received(req);
281 return NT_STATUS_OK;
282}
283
284NTSTATUS rpccli_netr_LogonUasLogoff(struct rpc_pipe_client *cli,
285 TALLOC_CTX *mem_ctx,
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] */,
290 WERROR *werror)
291{
292 struct netr_LogonUasLogoff r;
293 NTSTATUS status;
294
295 /* In parameters */
296 r.in.server_name = server_name;
297 r.in.account_name = account_name;
298 r.in.workstation = workstation;
299
300 status = cli->dispatch(cli,
301 mem_ctx,
302 &ndr_table_netlogon,
303 NDR_NETR_LOGONUASLOGOFF,
304 &r);
305
306 if (!NT_STATUS_IS_OK(status)) {
307 return status;
308 }
309
310 if (NT_STATUS_IS_ERR(status)) {
311 return status;
312 }
313
314 /* Return variables */
315 *info = *r.out.info;
316
317 /* Return result */
318 if (werror) {
319 *werror = r.out.result;
320 }
321
322 return werror_to_ntstatus(r.out.result);
323}
324
325struct 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);
330};
331
332static void rpccli_netr_LogonSamLogon_done(struct tevent_req *subreq);
333
334struct 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] */)
346{
347 struct tevent_req *req;
348 struct rpccli_netr_LogonSamLogon_state *state;
349 struct tevent_req *subreq;
350
351 req = tevent_req_create(mem_ctx, &state,
352 struct rpccli_netr_LogonSamLogon_state);
353 if (req == NULL) {
354 return NULL;
355 }
356 state->out_mem_ctx = NULL;
357 state->dispatch_recv = cli->dispatch_recv;
358
359 /* In parameters */
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;
367
368 /* Out parameters */
369 state->orig.out.return_authenticator = _return_authenticator;
370 state->orig.out.validation = _validation;
371 state->orig.out.authoritative = _authoritative;
372
373 /* Result */
374 ZERO_STRUCT(state->orig.out.result);
375
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);
380 }
381
382 /* make a temporary copy, that we pass to the dispatch function */
383 state->tmp = state->orig;
384
385 subreq = cli->dispatch_send(state, ev, cli,
386 &ndr_table_netlogon,
387 NDR_NETR_LOGONSAMLOGON,
388 &state->tmp);
389 if (tevent_req_nomem(subreq, req)) {
390 return tevent_req_post(req, ev);
391 }
392 tevent_req_set_callback(subreq, rpccli_netr_LogonSamLogon_done, req);
393 return req;
394}
395
396static void rpccli_netr_LogonSamLogon_done(struct tevent_req *subreq)
397{
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);
402 NTSTATUS status;
403 TALLOC_CTX *mem_ctx;
404
405 if (state->out_mem_ctx) {
406 mem_ctx = state->out_mem_ctx;
407 } else {
408 mem_ctx = state;
409 }
410
411 status = state->dispatch_recv(subreq, mem_ctx);
412 TALLOC_FREE(subreq);
413 if (!NT_STATUS_IS_OK(status)) {
414 tevent_req_nterror(req, status);
415 return;
416 }
417
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;
421 }
422 *state->orig.out.validation = *state->tmp.out.validation;
423 *state->orig.out.authoritative = *state->tmp.out.authoritative;
424
425 /* Copy result */
426 state->orig.out.result = state->tmp.out.result;
427
428 /* Reset temporary structure */
429 ZERO_STRUCT(state->tmp);
430
431 tevent_req_done(req);
432}
433
434NTSTATUS rpccli_netr_LogonSamLogon_recv(struct tevent_req *req,
435 TALLOC_CTX *mem_ctx,
436 NTSTATUS *result)
437{
438 struct rpccli_netr_LogonSamLogon_state *state = tevent_req_data(
439 req, struct rpccli_netr_LogonSamLogon_state);
440 NTSTATUS status;
441
442 if (tevent_req_is_nterror(req, &status)) {
443 tevent_req_received(req);
444 return status;
445 }
446
447 /* Steal possbile out parameters to the callers context */
448 talloc_steal(mem_ctx, state->out_mem_ctx);
449
450 /* Return result */
451 *result = state->orig.out.result;
452
453 tevent_req_received(req);
454 return NT_STATUS_OK;
455}
456
457NTSTATUS rpccli_netr_LogonSamLogon(struct rpc_pipe_client *cli,
458 TALLOC_CTX *mem_ctx,
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] */)
468{
469 struct netr_LogonSamLogon r;
470 NTSTATUS status;
471
472 /* In parameters */
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;
478 r.in.logon = logon;
479 r.in.validation_level = validation_level;
480
481 status = cli->dispatch(cli,
482 mem_ctx,
483 &ndr_table_netlogon,
484 NDR_NETR_LOGONSAMLOGON,
485 &r);
486
487 if (!NT_STATUS_IS_OK(status)) {
488 return status;
489 }
490
491 if (NT_STATUS_IS_ERR(status)) {
492 return status;
493 }
494
495 /* Return variables */
496 if (return_authenticator && r.out.return_authenticator) {
497 *return_authenticator = *r.out.return_authenticator;
498 }
499 *validation = *r.out.validation;
500 *authoritative = *r.out.authoritative;
501
502 /* Return result */
503 return r.out.result;
504}
505
506struct 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);
511};
512
513static void rpccli_netr_LogonSamLogoff_done(struct tevent_req *subreq);
514
515struct 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)] */)
524{
525 struct tevent_req *req;
526 struct rpccli_netr_LogonSamLogoff_state *state;
527 struct tevent_req *subreq;
528
529 req = tevent_req_create(mem_ctx, &state,
530 struct rpccli_netr_LogonSamLogoff_state);
531 if (req == NULL) {
532 return NULL;
533 }
534 state->out_mem_ctx = NULL;
535 state->dispatch_recv = cli->dispatch_recv;
536
537 /* In parameters */
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;
544
545 /* Out parameters */
546 state->orig.out.return_authenticator = _return_authenticator;
547
548 /* Result */
549 ZERO_STRUCT(state->orig.out.result);
550
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);
555 }
556
557 /* make a temporary copy, that we pass to the dispatch function */
558 state->tmp = state->orig;
559
560 subreq = cli->dispatch_send(state, ev, cli,
561 &ndr_table_netlogon,
562 NDR_NETR_LOGONSAMLOGOFF,
563 &state->tmp);
564 if (tevent_req_nomem(subreq, req)) {
565 return tevent_req_post(req, ev);
566 }
567 tevent_req_set_callback(subreq, rpccli_netr_LogonSamLogoff_done, req);
568 return req;
569}
570
571static void rpccli_netr_LogonSamLogoff_done(struct tevent_req *subreq)
572{
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);
577 NTSTATUS status;
578 TALLOC_CTX *mem_ctx;
579
580 if (state->out_mem_ctx) {
581 mem_ctx = state->out_mem_ctx;
582 } else {
583 mem_ctx = state;
584 }
585
586 status = state->dispatch_recv(subreq, mem_ctx);
587 TALLOC_FREE(subreq);
588 if (!NT_STATUS_IS_OK(status)) {
589 tevent_req_nterror(req, status);
590 return;
591 }
592
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;
596 }
597
598 /* Copy result */
599 state->orig.out.result = state->tmp.out.result;
600
601 /* Reset temporary structure */
602 ZERO_STRUCT(state->tmp);
603
604 tevent_req_done(req);
605}
606
607NTSTATUS rpccli_netr_LogonSamLogoff_recv(struct tevent_req *req,
608 TALLOC_CTX *mem_ctx,
609 NTSTATUS *result)
610{
611 struct rpccli_netr_LogonSamLogoff_state *state = tevent_req_data(
612 req, struct rpccli_netr_LogonSamLogoff_state);
613 NTSTATUS status;
614
615 if (tevent_req_is_nterror(req, &status)) {
616 tevent_req_received(req);
617 return status;
618 }
619
620 /* Steal possbile out parameters to the callers context */
621 talloc_steal(mem_ctx, state->out_mem_ctx);
622
623 /* Return result */
624 *result = state->orig.out.result;
625
626 tevent_req_received(req);
627 return NT_STATUS_OK;
628}
629
630NTSTATUS rpccli_netr_LogonSamLogoff(struct rpc_pipe_client *cli,
631 TALLOC_CTX *mem_ctx,
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)] */)
638{
639 struct netr_LogonSamLogoff r;
640 NTSTATUS status;
641
642 /* In parameters */
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;
648 r.in.logon = logon;
649
650 status = cli->dispatch(cli,
651 mem_ctx,
652 &ndr_table_netlogon,
653 NDR_NETR_LOGONSAMLOGOFF,
654 &r);
655
656 if (!NT_STATUS_IS_OK(status)) {
657 return status;
658 }
659
660 if (NT_STATUS_IS_ERR(status)) {
661 return status;
662 }
663
664 /* Return variables */
665 if (return_authenticator && r.out.return_authenticator) {
666 *return_authenticator = *r.out.return_authenticator;
667 }
668
669 /* Return result */
670 return r.out.result;
671}
672
673struct 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);
678};
679
680static void rpccli_netr_ServerReqChallenge_done(struct tevent_req *subreq);
681
682struct 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] */)
689{
690 struct tevent_req *req;
691 struct rpccli_netr_ServerReqChallenge_state *state;
692 struct tevent_req *subreq;
693
694 req = tevent_req_create(mem_ctx, &state,
695 struct rpccli_netr_ServerReqChallenge_state);
696 if (req == NULL) {
697 return NULL;
698 }
699 state->out_mem_ctx = NULL;
700 state->dispatch_recv = cli->dispatch_recv;
701
702 /* In parameters */
703 state->orig.in.server_name = _server_name;
704 state->orig.in.computer_name = _computer_name;
705 state->orig.in.credentials = _credentials;
706
707 /* Out parameters */
708 state->orig.out.return_credentials = _return_credentials;
709
710 /* Result */
711 ZERO_STRUCT(state->orig.out.result);
712
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);
717 }
718
719 /* make a temporary copy, that we pass to the dispatch function */
720 state->tmp = state->orig;
721
722 subreq = cli->dispatch_send(state, ev, cli,
723 &ndr_table_netlogon,
724 NDR_NETR_SERVERREQCHALLENGE,
725 &state->tmp);
726 if (tevent_req_nomem(subreq, req)) {
727 return tevent_req_post(req, ev);
728 }
729 tevent_req_set_callback(subreq, rpccli_netr_ServerReqChallenge_done, req);
730 return req;
731}
732
733static void rpccli_netr_ServerReqChallenge_done(struct tevent_req *subreq)
734{
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);
739 NTSTATUS status;
740 TALLOC_CTX *mem_ctx;
741
742 if (state->out_mem_ctx) {
743 mem_ctx = state->out_mem_ctx;
744 } else {
745 mem_ctx = state;
746 }
747
748 status = state->dispatch_recv(subreq, mem_ctx);
749 TALLOC_FREE(subreq);
750 if (!NT_STATUS_IS_OK(status)) {
751 tevent_req_nterror(req, status);
752 return;
753 }
754
755 /* Copy out parameters */
756 *state->orig.out.return_credentials = *state->tmp.out.return_credentials;
757
758 /* Copy result */
759 state->orig.out.result = state->tmp.out.result;
760
761 /* Reset temporary structure */
762 ZERO_STRUCT(state->tmp);
763
764 tevent_req_done(req);
765}
766
767NTSTATUS rpccli_netr_ServerReqChallenge_recv(struct tevent_req *req,
768 TALLOC_CTX *mem_ctx,
769 NTSTATUS *result)
770{
771 struct rpccli_netr_ServerReqChallenge_state *state = tevent_req_data(
772 req, struct rpccli_netr_ServerReqChallenge_state);
773 NTSTATUS status;
774
775 if (tevent_req_is_nterror(req, &status)) {
776 tevent_req_received(req);
777 return status;
778 }
779
780 /* Steal possbile out parameters to the callers context */
781 talloc_steal(mem_ctx, state->out_mem_ctx);
782
783 /* Return result */
784 *result = state->orig.out.result;
785
786 tevent_req_received(req);
787 return NT_STATUS_OK;
788}
789
790NTSTATUS rpccli_netr_ServerReqChallenge(struct rpc_pipe_client *cli,
791 TALLOC_CTX *mem_ctx,
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] */)
796{
797 struct netr_ServerReqChallenge r;
798 NTSTATUS status;
799
800 /* In parameters */
801 r.in.server_name = server_name;
802 r.in.computer_name = computer_name;
803 r.in.credentials = credentials;
804
805 status = cli->dispatch(cli,
806 mem_ctx,
807 &ndr_table_netlogon,
808 NDR_NETR_SERVERREQCHALLENGE,
809 &r);
810
811 if (!NT_STATUS_IS_OK(status)) {
812 return status;
813 }
814
815 if (NT_STATUS_IS_ERR(status)) {
816 return status;
817 }
818
819 /* Return variables */
820 *return_credentials = *r.out.return_credentials;
821
822 /* Return result */
823 return r.out.result;
824}
825
826struct 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);
831};
832
833static void rpccli_netr_ServerAuthenticate_done(struct tevent_req *subreq);
834
835struct 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] */)
844{
845 struct tevent_req *req;
846 struct rpccli_netr_ServerAuthenticate_state *state;
847 struct tevent_req *subreq;
848
849 req = tevent_req_create(mem_ctx, &state,
850 struct rpccli_netr_ServerAuthenticate_state);
851 if (req == NULL) {
852 return NULL;
853 }
854 state->out_mem_ctx = NULL;
855 state->dispatch_recv = cli->dispatch_recv;
856
857 /* In parameters */
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;
863
864 /* Out parameters */
865 state->orig.out.return_credentials = _return_credentials;
866
867 /* Result */
868 ZERO_STRUCT(state->orig.out.result);
869
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);
874 }
875
876 /* make a temporary copy, that we pass to the dispatch function */
877 state->tmp = state->orig;
878
879 subreq = cli->dispatch_send(state, ev, cli,
880 &ndr_table_netlogon,
881 NDR_NETR_SERVERAUTHENTICATE,
882 &state->tmp);
883 if (tevent_req_nomem(subreq, req)) {
884 return tevent_req_post(req, ev);
885 }
886 tevent_req_set_callback(subreq, rpccli_netr_ServerAuthenticate_done, req);
887 return req;
888}
889
890static void rpccli_netr_ServerAuthenticate_done(struct tevent_req *subreq)
891{
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);
896 NTSTATUS status;
897 TALLOC_CTX *mem_ctx;
898
899 if (state->out_mem_ctx) {
900 mem_ctx = state->out_mem_ctx;
901 } else {
902 mem_ctx = state;
903 }
904
905 status = state->dispatch_recv(subreq, mem_ctx);
906 TALLOC_FREE(subreq);
907 if (!NT_STATUS_IS_OK(status)) {
908 tevent_req_nterror(req, status);
909 return;
910 }
911
912 /* Copy out parameters */
913 *state->orig.out.return_credentials = *state->tmp.out.return_credentials;
914
915 /* Copy result */
916 state->orig.out.result = state->tmp.out.result;
917
918 /* Reset temporary structure */
919 ZERO_STRUCT(state->tmp);
920
921 tevent_req_done(req);
922}
923
924NTSTATUS rpccli_netr_ServerAuthenticate_recv(struct tevent_req *req,
925 TALLOC_CTX *mem_ctx,
926 NTSTATUS *result)
927{
928 struct rpccli_netr_ServerAuthenticate_state *state = tevent_req_data(
929 req, struct rpccli_netr_ServerAuthenticate_state);
930 NTSTATUS status;
931
932 if (tevent_req_is_nterror(req, &status)) {
933 tevent_req_received(req);
934 return status;
935 }
936
937 /* Steal possbile out parameters to the callers context */
938 talloc_steal(mem_ctx, state->out_mem_ctx);
939
940 /* Return result */
941 *result = state->orig.out.result;
942
943 tevent_req_received(req);
944 return NT_STATUS_OK;
945}
946
947NTSTATUS rpccli_netr_ServerAuthenticate(struct rpc_pipe_client *cli,
948 TALLOC_CTX *mem_ctx,
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] */)
955{
956 struct netr_ServerAuthenticate r;
957 NTSTATUS status;
958
959 /* In parameters */
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;
965
966 status = cli->dispatch(cli,
967 mem_ctx,
968 &ndr_table_netlogon,
969 NDR_NETR_SERVERAUTHENTICATE,
970 &r);
971
972 if (!NT_STATUS_IS_OK(status)) {
973 return status;
974 }
975
976 if (NT_STATUS_IS_ERR(status)) {
977 return status;
978 }
979
980 /* Return variables */
981 *return_credentials = *r.out.return_credentials;
982
983 /* Return result */
984 return r.out.result;
985}
986
987struct 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);
992};
993
994static void rpccli_netr_ServerPasswordSet_done(struct tevent_req *subreq);
995
996struct 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] */)
1006{
1007 struct tevent_req *req;
1008 struct rpccli_netr_ServerPasswordSet_state *state;
1009 struct tevent_req *subreq;
1010
1011 req = tevent_req_create(mem_ctx, &state,
1012 struct rpccli_netr_ServerPasswordSet_state);
1013 if (req == NULL) {
1014 return NULL;
1015 }
1016 state->out_mem_ctx = NULL;
1017 state->dispatch_recv = cli->dispatch_recv;
1018
1019 /* In parameters */
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;
1026
1027 /* Out parameters */
1028 state->orig.out.return_authenticator = _return_authenticator;
1029
1030 /* Result */
1031 ZERO_STRUCT(state->orig.out.result);
1032
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);
1037 }
1038
1039 /* make a temporary copy, that we pass to the dispatch function */
1040 state->tmp = state->orig;
1041
1042 subreq = cli->dispatch_send(state, ev, cli,
1043 &ndr_table_netlogon,
1044 NDR_NETR_SERVERPASSWORDSET,
1045 &state->tmp);
1046 if (tevent_req_nomem(subreq, req)) {
1047 return tevent_req_post(req, ev);
1048 }
1049 tevent_req_set_callback(subreq, rpccli_netr_ServerPasswordSet_done, req);
1050 return req;
1051}
1052
1053static void rpccli_netr_ServerPasswordSet_done(struct tevent_req *subreq)
1054{
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);
1059 NTSTATUS status;
1060 TALLOC_CTX *mem_ctx;
1061
1062 if (state->out_mem_ctx) {
1063 mem_ctx = state->out_mem_ctx;
1064 } else {
1065 mem_ctx = state;
1066 }
1067
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);
1072 return;
1073 }
1074
1075 /* Copy out parameters */
1076 *state->orig.out.return_authenticator = *state->tmp.out.return_authenticator;
1077
1078 /* Copy result */
1079 state->orig.out.result = state->tmp.out.result;
1080
1081 /* Reset temporary structure */
1082 ZERO_STRUCT(state->tmp);
1083
1084 tevent_req_done(req);
1085}
1086
1087NTSTATUS rpccli_netr_ServerPasswordSet_recv(struct tevent_req *req,
1088 TALLOC_CTX *mem_ctx,
1089 NTSTATUS *result)
1090{
1091 struct rpccli_netr_ServerPasswordSet_state *state = tevent_req_data(
1092 req, struct rpccli_netr_ServerPasswordSet_state);
1093 NTSTATUS status;
1094
1095 if (tevent_req_is_nterror(req, &status)) {
1096 tevent_req_received(req);
1097 return status;
1098 }
1099
1100 /* Steal possbile out parameters to the callers context */
1101 talloc_steal(mem_ctx, state->out_mem_ctx);
1102
1103 /* Return result */
1104 *result = state->orig.out.result;
1105
1106 tevent_req_received(req);
1107 return NT_STATUS_OK;
1108}
1109
1110NTSTATUS 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] */)
1119{
1120 struct netr_ServerPasswordSet r;
1121 NTSTATUS status;
1122
1123 /* In parameters */
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;
1130
1131 status = cli->dispatch(cli,
1132 mem_ctx,
1133 &ndr_table_netlogon,
1134 NDR_NETR_SERVERPASSWORDSET,
1135 &r);
1136
1137 if (!NT_STATUS_IS_OK(status)) {
1138 return status;
1139 }
1140
1141 if (NT_STATUS_IS_ERR(status)) {
1142 return status;
1143 }
1144
1145 /* Return variables */
1146 *return_authenticator = *r.out.return_authenticator;
1147
1148 /* Return result */
1149 return r.out.result;
1150}
1151
1152struct 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);
1157};
1158
1159static void rpccli_netr_DatabaseDeltas_done(struct tevent_req *subreq);
1160
1161struct 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] */)
1172{
1173 struct tevent_req *req;
1174 struct rpccli_netr_DatabaseDeltas_state *state;
1175 struct tevent_req *subreq;
1176
1177 req = tevent_req_create(mem_ctx, &state,
1178 struct rpccli_netr_DatabaseDeltas_state);
1179 if (req == NULL) {
1180 return NULL;
1181 }
1182 state->out_mem_ctx = NULL;
1183 state->dispatch_recv = cli->dispatch_recv;
1184
1185 /* In parameters */
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;
1193
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;
1198
1199 /* Result */
1200 ZERO_STRUCT(state->orig.out.result);
1201
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);
1206 }
1207
1208 /* make a temporary copy, that we pass to the dispatch function */
1209 state->tmp = state->orig;
1210
1211 subreq = cli->dispatch_send(state, ev, cli,
1212 &ndr_table_netlogon,
1213 NDR_NETR_DATABASEDELTAS,
1214 &state->tmp);
1215 if (tevent_req_nomem(subreq, req)) {
1216 return tevent_req_post(req, ev);
1217 }
1218 tevent_req_set_callback(subreq, rpccli_netr_DatabaseDeltas_done, req);
1219 return req;
1220}
1221
1222static void rpccli_netr_DatabaseDeltas_done(struct tevent_req *subreq)
1223{
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);
1228 NTSTATUS status;
1229 TALLOC_CTX *mem_ctx;
1230
1231 if (state->out_mem_ctx) {
1232 mem_ctx = state->out_mem_ctx;
1233 } else {
1234 mem_ctx = state;
1235 }
1236
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);
1241 return;
1242 }
1243
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;
1248
1249 /* Copy result */
1250 state->orig.out.result = state->tmp.out.result;
1251
1252 /* Reset temporary structure */
1253 ZERO_STRUCT(state->tmp);
1254
1255 tevent_req_done(req);
1256}
1257
1258NTSTATUS rpccli_netr_DatabaseDeltas_recv(struct tevent_req *req,
1259 TALLOC_CTX *mem_ctx,
1260 NTSTATUS *result)
1261{
1262 struct rpccli_netr_DatabaseDeltas_state *state = tevent_req_data(
1263 req, struct rpccli_netr_DatabaseDeltas_state);
1264 NTSTATUS status;
1265
1266 if (tevent_req_is_nterror(req, &status)) {
1267 tevent_req_received(req);
1268 return status;
1269 }
1270
1271 /* Steal possbile out parameters to the callers context */
1272 talloc_steal(mem_ctx, state->out_mem_ctx);
1273
1274 /* Return result */
1275 *result = state->orig.out.result;
1276
1277 tevent_req_received(req);
1278 return NT_STATUS_OK;
1279}
1280
1281NTSTATUS 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] */)
1291{
1292 struct netr_DatabaseDeltas r;
1293 NTSTATUS status;
1294
1295 /* In parameters */
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;
1303
1304 status = cli->dispatch(cli,
1305 mem_ctx,
1306 &ndr_table_netlogon,
1307 NDR_NETR_DATABASEDELTAS,
1308 &r);
1309
1310 if (!NT_STATUS_IS_OK(status)) {
1311 return status;
1312 }
1313
1314 if (NT_STATUS_IS_ERR(status)) {
1315 return status;
1316 }
1317
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;
1322
1323 /* Return result */
1324 return r.out.result;
1325}
1326
1327struct 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);
1332};
1333
1334static void rpccli_netr_DatabaseSync_done(struct tevent_req *subreq);
1335
1336struct 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] */)
1347{
1348 struct tevent_req *req;
1349 struct rpccli_netr_DatabaseSync_state *state;
1350 struct tevent_req *subreq;
1351
1352 req = tevent_req_create(mem_ctx, &state,
1353 struct rpccli_netr_DatabaseSync_state);
1354 if (req == NULL) {
1355 return NULL;
1356 }
1357 state->out_mem_ctx = NULL;
1358 state->dispatch_recv = cli->dispatch_recv;
1359
1360 /* In parameters */
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;
1368
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;
1373
1374 /* Result */
1375 ZERO_STRUCT(state->orig.out.result);
1376
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);
1381 }
1382
1383 /* make a temporary copy, that we pass to the dispatch function */
1384 state->tmp = state->orig;
1385
1386 subreq = cli->dispatch_send(state, ev, cli,
1387 &ndr_table_netlogon,
1388 NDR_NETR_DATABASESYNC,
1389 &state->tmp);
1390 if (tevent_req_nomem(subreq, req)) {
1391 return tevent_req_post(req, ev);
1392 }
1393 tevent_req_set_callback(subreq, rpccli_netr_DatabaseSync_done, req);
1394 return req;
1395}
1396
1397static void rpccli_netr_DatabaseSync_done(struct tevent_req *subreq)
1398{
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);
1403 NTSTATUS status;
1404 TALLOC_CTX *mem_ctx;
1405
1406 if (state->out_mem_ctx) {
1407 mem_ctx = state->out_mem_ctx;
1408 } else {
1409 mem_ctx = state;
1410 }
1411
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);
1416 return;
1417 }
1418
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;
1423
1424 /* Copy result */
1425 state->orig.out.result = state->tmp.out.result;
1426
1427 /* Reset temporary structure */
1428 ZERO_STRUCT(state->tmp);
1429
1430 tevent_req_done(req);
1431}
1432
1433NTSTATUS rpccli_netr_DatabaseSync_recv(struct tevent_req *req,
1434 TALLOC_CTX *mem_ctx,
1435 NTSTATUS *result)
1436{
1437 struct rpccli_netr_DatabaseSync_state *state = tevent_req_data(
1438 req, struct rpccli_netr_DatabaseSync_state);
1439 NTSTATUS status;
1440
1441 if (tevent_req_is_nterror(req, &status)) {
1442 tevent_req_received(req);
1443 return status;
1444 }
1445
1446 /* Steal possbile out parameters to the callers context */
1447 talloc_steal(mem_ctx, state->out_mem_ctx);
1448
1449 /* Return result */
1450 *result = state->orig.out.result;
1451
1452 tevent_req_received(req);
1453 return NT_STATUS_OK;
1454}
1455
1456NTSTATUS 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] */)
1466{
1467 struct netr_DatabaseSync r;
1468 NTSTATUS status;
1469
1470 /* In parameters */
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;
1478
1479 status = cli->dispatch(cli,
1480 mem_ctx,
1481 &ndr_table_netlogon,
1482 NDR_NETR_DATABASESYNC,
1483 &r);
1484
1485 if (!NT_STATUS_IS_OK(status)) {
1486 return status;
1487 }
1488
1489 if (NT_STATUS_IS_ERR(status)) {
1490 return status;
1491 }
1492
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;
1497
1498 /* Return result */
1499 return r.out.result;
1500}
1501
1502struct 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);
1507};
1508
1509static void rpccli_netr_AccountDeltas_done(struct tevent_req *subreq);
1510
1511struct 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] */)
1526{
1527 struct tevent_req *req;
1528 struct rpccli_netr_AccountDeltas_state *state;
1529 struct tevent_req *subreq;
1530
1531 req = tevent_req_create(mem_ctx, &state,
1532 struct rpccli_netr_AccountDeltas_state);
1533 if (req == NULL) {
1534 return NULL;
1535 }
1536 state->out_mem_ctx = NULL;
1537 state->dispatch_recv = cli->dispatch_recv;
1538
1539 /* In parameters */
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;
1548
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;
1555
1556 /* Result */
1557 ZERO_STRUCT(state->orig.out.result);
1558
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);
1563 }
1564
1565 /* make a temporary copy, that we pass to the dispatch function */
1566 state->tmp = state->orig;
1567
1568 subreq = cli->dispatch_send(state, ev, cli,
1569 &ndr_table_netlogon,
1570 NDR_NETR_ACCOUNTDELTAS,
1571 &state->tmp);
1572 if (tevent_req_nomem(subreq, req)) {
1573 return tevent_req_post(req, ev);
1574 }
1575 tevent_req_set_callback(subreq, rpccli_netr_AccountDeltas_done, req);
1576 return req;
1577}
1578
1579static void rpccli_netr_AccountDeltas_done(struct tevent_req *subreq)
1580{
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);
1585 NTSTATUS status;
1586 TALLOC_CTX *mem_ctx;
1587
1588 if (state->out_mem_ctx) {
1589 mem_ctx = state->out_mem_ctx;
1590 } else {
1591 mem_ctx = state;
1592 }
1593
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);
1598 return;
1599 }
1600
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;
1607
1608 /* Copy result */
1609 state->orig.out.result = state->tmp.out.result;
1610
1611 /* Reset temporary structure */
1612 ZERO_STRUCT(state->tmp);
1613
1614 tevent_req_done(req);
1615}
1616
1617NTSTATUS rpccli_netr_AccountDeltas_recv(struct tevent_req *req,
1618 TALLOC_CTX *mem_ctx,
1619 NTSTATUS *result)
1620{
1621 struct rpccli_netr_AccountDeltas_state *state = tevent_req_data(
1622 req, struct rpccli_netr_AccountDeltas_state);
1623 NTSTATUS status;
1624
1625 if (tevent_req_is_nterror(req, &status)) {
1626 tevent_req_received(req);
1627 return status;
1628 }
1629
1630 /* Steal possbile out parameters to the callers context */
1631 talloc_steal(mem_ctx, state->out_mem_ctx);
1632
1633 /* Return result */
1634 *result = state->orig.out.result;
1635
1636 tevent_req_received(req);
1637 return NT_STATUS_OK;
1638}
1639
1640NTSTATUS 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] */)
1654{
1655 struct netr_AccountDeltas r;
1656 NTSTATUS status;
1657
1658 /* In parameters */
1659 r.in.logon_server = logon_server;
1660 r.in.computername = computername;
1661 r.in.credential = credential;
1662 r.in.return_authenticator = return_authenticator;
1663 r.in.uas = uas;
1664 r.in.count = count;
1665 r.in.level = level;
1666 r.in.buffersize = buffersize;
1667
1668 status = cli->dispatch(cli,
1669 mem_ctx,
1670 &ndr_table_netlogon,
1671 NDR_NETR_ACCOUNTDELTAS,
1672 &r);
1673
1674 if (!NT_STATUS_IS_OK(status)) {
1675 return status;
1676 }
1677
1678 if (NT_STATUS_IS_ERR(status)) {
1679 return status;
1680 }
1681
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;
1688
1689 /* Return result */
1690 return r.out.result;
1691}
1692
1693struct 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);
1698};
1699
1700static void rpccli_netr_AccountSync_done(struct tevent_req *subreq);
1701
1702struct 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] */)
1717{
1718 struct tevent_req *req;
1719 struct rpccli_netr_AccountSync_state *state;
1720 struct tevent_req *subreq;
1721
1722 req = tevent_req_create(mem_ctx, &state,
1723 struct rpccli_netr_AccountSync_state);
1724 if (req == NULL) {
1725 return NULL;
1726 }
1727 state->out_mem_ctx = NULL;
1728 state->dispatch_recv = cli->dispatch_recv;
1729
1730 /* In parameters */
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;
1739
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;
1747
1748 /* Result */
1749 ZERO_STRUCT(state->orig.out.result);
1750
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);
1755 }
1756
1757 /* make a temporary copy, that we pass to the dispatch function */
1758 state->tmp = state->orig;
1759
1760 subreq = cli->dispatch_send(state, ev, cli,
1761 &ndr_table_netlogon,
1762 NDR_NETR_ACCOUNTSYNC,
1763 &state->tmp);
1764 if (tevent_req_nomem(subreq, req)) {
1765 return tevent_req_post(req, ev);
1766 }
1767 tevent_req_set_callback(subreq, rpccli_netr_AccountSync_done, req);
1768 return req;
1769}
1770
1771static void rpccli_netr_AccountSync_done(struct tevent_req *subreq)
1772{
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);
1777 NTSTATUS status;
1778 TALLOC_CTX *mem_ctx;
1779
1780 if (state->out_mem_ctx) {
1781 mem_ctx = state->out_mem_ctx;
1782 } else {
1783 mem_ctx = state;
1784 }
1785
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);
1790 return;
1791 }
1792
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;
1800
1801 /* Copy result */
1802 state->orig.out.result = state->tmp.out.result;
1803
1804 /* Reset temporary structure */
1805 ZERO_STRUCT(state->tmp);
1806
1807 tevent_req_done(req);
1808}
1809
1810NTSTATUS rpccli_netr_AccountSync_recv(struct tevent_req *req,
1811 TALLOC_CTX *mem_ctx,
1812 NTSTATUS *result)
1813{
1814 struct rpccli_netr_AccountSync_state *state = tevent_req_data(
1815 req, struct rpccli_netr_AccountSync_state);
1816 NTSTATUS status;
1817
1818 if (tevent_req_is_nterror(req, &status)) {
1819 tevent_req_received(req);
1820 return status;
1821 }
1822
1823 /* Steal possbile out parameters to the callers context */
1824 talloc_steal(mem_ctx, state->out_mem_ctx);
1825
1826 /* Return result */
1827 *result = state->orig.out.result;
1828
1829 tevent_req_received(req);
1830 return NT_STATUS_OK;
1831}
1832
1833NTSTATUS 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] */)
1847{
1848 struct netr_AccountSync r;
1849 NTSTATUS status;
1850
1851 /* In parameters */
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;
1857 r.in.level = level;
1858 r.in.buffersize = buffersize;
1859 r.in.recordid = recordid;
1860
1861 status = cli->dispatch(cli,
1862 mem_ctx,
1863 &ndr_table_netlogon,
1864 NDR_NETR_ACCOUNTSYNC,
1865 &r);
1866
1867 if (!NT_STATUS_IS_OK(status)) {
1868 return status;
1869 }
1870
1871 if (NT_STATUS_IS_ERR(status)) {
1872 return status;
1873 }
1874
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;
1882
1883 /* Return result */
1884 return r.out.result;
1885}
1886
1887struct 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);
1892};
1893
1894static void rpccli_netr_GetDcName_done(struct tevent_req *subreq);
1895
1896struct 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)] */)
1902{
1903 struct tevent_req *req;
1904 struct rpccli_netr_GetDcName_state *state;
1905 struct tevent_req *subreq;
1906
1907 req = tevent_req_create(mem_ctx, &state,
1908 struct rpccli_netr_GetDcName_state);
1909 if (req == NULL) {
1910 return NULL;
1911 }
1912 state->out_mem_ctx = NULL;
1913 state->dispatch_recv = cli->dispatch_recv;
1914
1915 /* In parameters */
1916 state->orig.in.logon_server = _logon_server;
1917 state->orig.in.domainname = _domainname;
1918
1919 /* Out parameters */
1920 state->orig.out.dcname = _dcname;
1921
1922 /* Result */
1923 ZERO_STRUCT(state->orig.out.result);
1924
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);
1929 }
1930
1931 /* make a temporary copy, that we pass to the dispatch function */
1932 state->tmp = state->orig;
1933
1934 subreq = cli->dispatch_send(state, ev, cli,
1935 &ndr_table_netlogon,
1936 NDR_NETR_GETDCNAME,
1937 &state->tmp);
1938 if (tevent_req_nomem(subreq, req)) {
1939 return tevent_req_post(req, ev);
1940 }
1941 tevent_req_set_callback(subreq, rpccli_netr_GetDcName_done, req);
1942 return req;
1943}
1944
1945static void rpccli_netr_GetDcName_done(struct tevent_req *subreq)
1946{
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);
1951 NTSTATUS status;
1952 TALLOC_CTX *mem_ctx;
1953
1954 if (state->out_mem_ctx) {
1955 mem_ctx = state->out_mem_ctx;
1956 } else {
1957 mem_ctx = state;
1958 }
1959
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);
1964 return;
1965 }
1966
1967 /* Copy out parameters */
1968 *state->orig.out.dcname = *state->tmp.out.dcname;
1969
1970 /* Copy result */
1971 state->orig.out.result = state->tmp.out.result;
1972
1973 /* Reset temporary structure */
1974 ZERO_STRUCT(state->tmp);
1975
1976 tevent_req_done(req);
1977}
1978
1979NTSTATUS rpccli_netr_GetDcName_recv(struct tevent_req *req,
1980 TALLOC_CTX *mem_ctx,
1981 WERROR *result)
1982{
1983 struct rpccli_netr_GetDcName_state *state = tevent_req_data(
1984 req, struct rpccli_netr_GetDcName_state);
1985 NTSTATUS status;
1986
1987 if (tevent_req_is_nterror(req, &status)) {
1988 tevent_req_received(req);
1989 return status;
1990 }
1991
1992 /* Steal possbile out parameters to the callers context */
1993 talloc_steal(mem_ctx, state->out_mem_ctx);
1994
1995 /* Return result */
1996 *result = state->orig.out.result;
1997
1998 tevent_req_received(req);
1999 return NT_STATUS_OK;
2000}
2001
2002NTSTATUS 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)] */,
2007 WERROR *werror)
2008{
2009 struct netr_GetDcName r;
2010 NTSTATUS status;
2011
2012 /* In parameters */
2013 r.in.logon_server = logon_server;
2014 r.in.domainname = domainname;
2015
2016 status = cli->dispatch(cli,
2017 mem_ctx,
2018 &ndr_table_netlogon,
2019 NDR_NETR_GETDCNAME,
2020 &r);
2021
2022 if (!NT_STATUS_IS_OK(status)) {
2023 return status;
2024 }
2025
2026 if (NT_STATUS_IS_ERR(status)) {
2027 return status;
2028 }
2029
2030 /* Return variables */
2031 *dcname = *r.out.dcname;
2032
2033 /* Return result */
2034 if (werror) {
2035 *werror = r.out.result;
2036 }
2037
2038 return werror_to_ntstatus(r.out.result);
2039}
2040
2041struct 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);
2046};
2047
2048static void rpccli_netr_LogonControl_done(struct tevent_req *subreq);
2049
2050struct 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)] */)
2057{
2058 struct tevent_req *req;
2059 struct rpccli_netr_LogonControl_state *state;
2060 struct tevent_req *subreq;
2061
2062 req = tevent_req_create(mem_ctx, &state,
2063 struct rpccli_netr_LogonControl_state);
2064 if (req == NULL) {
2065 return NULL;
2066 }
2067 state->out_mem_ctx = NULL;
2068 state->dispatch_recv = cli->dispatch_recv;
2069
2070 /* In parameters */
2071 state->orig.in.logon_server = _logon_server;
2072 state->orig.in.function_code = _function_code;
2073 state->orig.in.level = _level;
2074
2075 /* Out parameters */
2076 state->orig.out.query = _query;
2077
2078 /* Result */
2079 ZERO_STRUCT(state->orig.out.result);
2080
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);
2085 }
2086
2087 /* make a temporary copy, that we pass to the dispatch function */
2088 state->tmp = state->orig;
2089
2090 subreq = cli->dispatch_send(state, ev, cli,
2091 &ndr_table_netlogon,
2092 NDR_NETR_LOGONCONTROL,
2093 &state->tmp);
2094 if (tevent_req_nomem(subreq, req)) {
2095 return tevent_req_post(req, ev);
2096 }
2097 tevent_req_set_callback(subreq, rpccli_netr_LogonControl_done, req);
2098 return req;
2099}
2100
2101static void rpccli_netr_LogonControl_done(struct tevent_req *subreq)
2102{
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);
2107 NTSTATUS status;
2108 TALLOC_CTX *mem_ctx;
2109
2110 if (state->out_mem_ctx) {
2111 mem_ctx = state->out_mem_ctx;
2112 } else {
2113 mem_ctx = state;
2114 }
2115
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);
2120 return;
2121 }
2122
2123 /* Copy out parameters */
2124 *state->orig.out.query = *state->tmp.out.query;
2125
2126 /* Copy result */
2127 state->orig.out.result = state->tmp.out.result;
2128
2129 /* Reset temporary structure */
2130 ZERO_STRUCT(state->tmp);
2131
2132 tevent_req_done(req);
2133}
2134
2135NTSTATUS rpccli_netr_LogonControl_recv(struct tevent_req *req,
2136 TALLOC_CTX *mem_ctx,
2137 WERROR *result)
2138{
2139 struct rpccli_netr_LogonControl_state *state = tevent_req_data(
2140 req, struct rpccli_netr_LogonControl_state);
2141 NTSTATUS status;
2142
2143 if (tevent_req_is_nterror(req, &status)) {
2144 tevent_req_received(req);
2145 return status;
2146 }
2147
2148 /* Steal possbile out parameters to the callers context */
2149 talloc_steal(mem_ctx, state->out_mem_ctx);
2150
2151 /* Return result */
2152 *result = state->orig.out.result;
2153
2154 tevent_req_received(req);
2155 return NT_STATUS_OK;
2156}
2157
2158NTSTATUS 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)] */,
2164 WERROR *werror)
2165{
2166 struct netr_LogonControl r;
2167 NTSTATUS status;
2168
2169 /* In parameters */
2170 r.in.logon_server = logon_server;
2171 r.in.function_code = function_code;
2172 r.in.level = level;
2173
2174 status = cli->dispatch(cli,
2175 mem_ctx,
2176 &ndr_table_netlogon,
2177 NDR_NETR_LOGONCONTROL,
2178 &r);
2179
2180 if (!NT_STATUS_IS_OK(status)) {
2181 return status;
2182 }
2183
2184 if (NT_STATUS_IS_ERR(status)) {
2185 return status;
2186 }
2187
2188 /* Return variables */
2189 *query = *r.out.query;
2190
2191 /* Return result */
2192 if (werror) {
2193 *werror = r.out.result;
2194 }
2195
2196 return werror_to_ntstatus(r.out.result);
2197}
2198
2199struct 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);
2204};
2205
2206static void rpccli_netr_GetAnyDCName_done(struct tevent_req *subreq);
2207
2208struct 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)] */)
2214{
2215 struct tevent_req *req;
2216 struct rpccli_netr_GetAnyDCName_state *state;
2217 struct tevent_req *subreq;
2218
2219 req = tevent_req_create(mem_ctx, &state,
2220 struct rpccli_netr_GetAnyDCName_state);
2221 if (req == NULL) {
2222 return NULL;
2223 }
2224 state->out_mem_ctx = NULL;
2225 state->dispatch_recv = cli->dispatch_recv;
2226
2227 /* In parameters */
2228 state->orig.in.logon_server = _logon_server;
2229 state->orig.in.domainname = _domainname;
2230
2231 /* Out parameters */
2232 state->orig.out.dcname = _dcname;
2233
2234 /* Result */
2235 ZERO_STRUCT(state->orig.out.result);
2236
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);
2241 }
2242
2243 /* make a temporary copy, that we pass to the dispatch function */
2244 state->tmp = state->orig;
2245
2246 subreq = cli->dispatch_send(state, ev, cli,
2247 &ndr_table_netlogon,
2248 NDR_NETR_GETANYDCNAME,
2249 &state->tmp);
2250 if (tevent_req_nomem(subreq, req)) {
2251 return tevent_req_post(req, ev);
2252 }
2253 tevent_req_set_callback(subreq, rpccli_netr_GetAnyDCName_done, req);
2254 return req;
2255}
2256
2257static void rpccli_netr_GetAnyDCName_done(struct tevent_req *subreq)
2258{
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);
2263 NTSTATUS status;
2264 TALLOC_CTX *mem_ctx;
2265
2266 if (state->out_mem_ctx) {
2267 mem_ctx = state->out_mem_ctx;
2268 } else {
2269 mem_ctx = state;
2270 }
2271
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);
2276 return;
2277 }
2278
2279 /* Copy out parameters */
2280 *state->orig.out.dcname = *state->tmp.out.dcname;
2281
2282 /* Copy result */
2283 state->orig.out.result = state->tmp.out.result;
2284
2285 /* Reset temporary structure */
2286 ZERO_STRUCT(state->tmp);
2287
2288 tevent_req_done(req);
2289}
2290
2291NTSTATUS rpccli_netr_GetAnyDCName_recv(struct tevent_req *req,
2292 TALLOC_CTX *mem_ctx,
2293 WERROR *result)
2294{
2295 struct rpccli_netr_GetAnyDCName_state *state = tevent_req_data(
2296 req, struct rpccli_netr_GetAnyDCName_state);
2297 NTSTATUS status;
2298
2299 if (tevent_req_is_nterror(req, &status)) {
2300 tevent_req_received(req);
2301 return status;
2302 }
2303
2304 /* Steal possbile out parameters to the callers context */
2305 talloc_steal(mem_ctx, state->out_mem_ctx);
2306
2307 /* Return result */
2308 *result = state->orig.out.result;
2309
2310 tevent_req_received(req);
2311 return NT_STATUS_OK;
2312}
2313
2314NTSTATUS 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)] */,
2319 WERROR *werror)
2320{
2321 struct netr_GetAnyDCName r;
2322 NTSTATUS status;
2323
2324 /* In parameters */
2325 r.in.logon_server = logon_server;
2326 r.in.domainname = domainname;
2327
2328 status = cli->dispatch(cli,
2329 mem_ctx,
2330 &ndr_table_netlogon,
2331 NDR_NETR_GETANYDCNAME,
2332 &r);
2333
2334 if (!NT_STATUS_IS_OK(status)) {
2335 return status;
2336 }
2337
2338 if (NT_STATUS_IS_ERR(status)) {
2339 return status;
2340 }
2341
2342 /* Return variables */
2343 *dcname = *r.out.dcname;
2344
2345 /* Return result */
2346 if (werror) {
2347 *werror = r.out.result;
2348 }
2349
2350 return werror_to_ntstatus(r.out.result);
2351}
2352
2353struct 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);
2358};
2359
2360static void rpccli_netr_LogonControl2_done(struct tevent_req *subreq);
2361
2362struct 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)] */)
2370{
2371 struct tevent_req *req;
2372 struct rpccli_netr_LogonControl2_state *state;
2373 struct tevent_req *subreq;
2374
2375 req = tevent_req_create(mem_ctx, &state,
2376 struct rpccli_netr_LogonControl2_state);
2377 if (req == NULL) {
2378 return NULL;
2379 }
2380 state->out_mem_ctx = NULL;
2381 state->dispatch_recv = cli->dispatch_recv;
2382
2383 /* In parameters */
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;
2388
2389 /* Out parameters */
2390 state->orig.out.query = _query;
2391
2392 /* Result */
2393 ZERO_STRUCT(state->orig.out.result);
2394
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);
2399 }
2400
2401 /* make a temporary copy, that we pass to the dispatch function */
2402 state->tmp = state->orig;
2403
2404 subreq = cli->dispatch_send(state, ev, cli,
2405 &ndr_table_netlogon,
2406 NDR_NETR_LOGONCONTROL2,
2407 &state->tmp);
2408 if (tevent_req_nomem(subreq, req)) {
2409 return tevent_req_post(req, ev);
2410 }
2411 tevent_req_set_callback(subreq, rpccli_netr_LogonControl2_done, req);
2412 return req;
2413}
2414
2415static void rpccli_netr_LogonControl2_done(struct tevent_req *subreq)
2416{
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);
2421 NTSTATUS status;
2422 TALLOC_CTX *mem_ctx;
2423
2424 if (state->out_mem_ctx) {
2425 mem_ctx = state->out_mem_ctx;
2426 } else {
2427 mem_ctx = state;
2428 }
2429
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);
2434 return;
2435 }
2436
2437 /* Copy out parameters */
2438 *state->orig.out.query = *state->tmp.out.query;
2439
2440 /* Copy result */
2441 state->orig.out.result = state->tmp.out.result;
2442
2443 /* Reset temporary structure */
2444 ZERO_STRUCT(state->tmp);
2445
2446 tevent_req_done(req);
2447}
2448
2449NTSTATUS rpccli_netr_LogonControl2_recv(struct tevent_req *req,
2450 TALLOC_CTX *mem_ctx,
2451 WERROR *result)
2452{
2453 struct rpccli_netr_LogonControl2_state *state = tevent_req_data(
2454 req, struct rpccli_netr_LogonControl2_state);
2455 NTSTATUS status;
2456
2457 if (tevent_req_is_nterror(req, &status)) {
2458 tevent_req_received(req);
2459 return status;
2460 }
2461
2462 /* Steal possbile out parameters to the callers context */
2463 talloc_steal(mem_ctx, state->out_mem_ctx);
2464
2465 /* Return result */
2466 *result = state->orig.out.result;
2467
2468 tevent_req_received(req);
2469 return NT_STATUS_OK;
2470}
2471
2472NTSTATUS 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)] */,
2479 WERROR *werror)
2480{
2481 struct netr_LogonControl2 r;
2482 NTSTATUS status;
2483
2484 /* In parameters */
2485 r.in.logon_server = logon_server;
2486 r.in.function_code = function_code;
2487 r.in.level = level;
2488 r.in.data = data;
2489
2490 status = cli->dispatch(cli,
2491 mem_ctx,
2492 &ndr_table_netlogon,
2493 NDR_NETR_LOGONCONTROL2,
2494 &r);
2495
2496 if (!NT_STATUS_IS_OK(status)) {
2497 return status;
2498 }
2499
2500 if (NT_STATUS_IS_ERR(status)) {
2501 return status;
2502 }
2503
2504 /* Return variables */
2505 *query = *r.out.query;
2506
2507 /* Return result */
2508 if (werror) {
2509 *werror = r.out.result;
2510 }
2511
2512 return werror_to_ntstatus(r.out.result);
2513}
2514
2515struct 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);
2520};
2521
2522static void rpccli_netr_ServerAuthenticate2_done(struct tevent_req *subreq);
2523
2524struct 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] */)
2534{
2535 struct tevent_req *req;
2536 struct rpccli_netr_ServerAuthenticate2_state *state;
2537 struct tevent_req *subreq;
2538
2539 req = tevent_req_create(mem_ctx, &state,
2540 struct rpccli_netr_ServerAuthenticate2_state);
2541 if (req == NULL) {
2542 return NULL;
2543 }
2544 state->out_mem_ctx = NULL;
2545 state->dispatch_recv = cli->dispatch_recv;
2546
2547 /* In parameters */
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;
2554
2555 /* Out parameters */
2556 state->orig.out.return_credentials = _return_credentials;
2557 state->orig.out.negotiate_flags = _negotiate_flags;
2558
2559 /* Result */
2560 ZERO_STRUCT(state->orig.out.result);
2561
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);
2566 }
2567
2568 /* make a temporary copy, that we pass to the dispatch function */
2569 state->tmp = state->orig;
2570
2571 subreq = cli->dispatch_send(state, ev, cli,
2572 &ndr_table_netlogon,
2573 NDR_NETR_SERVERAUTHENTICATE2,
2574 &state->tmp);
2575 if (tevent_req_nomem(subreq, req)) {
2576 return tevent_req_post(req, ev);
2577 }
2578 tevent_req_set_callback(subreq, rpccli_netr_ServerAuthenticate2_done, req);
2579 return req;
2580}
2581
2582static void rpccli_netr_ServerAuthenticate2_done(struct tevent_req *subreq)
2583{
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);
2588 NTSTATUS status;
2589 TALLOC_CTX *mem_ctx;
2590
2591 if (state->out_mem_ctx) {
2592 mem_ctx = state->out_mem_ctx;
2593 } else {
2594 mem_ctx = state;
2595 }
2596
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);
2601 return;
2602 }
2603
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;
2607
2608 /* Copy result */
2609 state->orig.out.result = state->tmp.out.result;
2610
2611 /* Reset temporary structure */
2612 ZERO_STRUCT(state->tmp);
2613
2614 tevent_req_done(req);
2615}
2616
2617NTSTATUS rpccli_netr_ServerAuthenticate2_recv(struct tevent_req *req,
2618 TALLOC_CTX *mem_ctx,
2619 NTSTATUS *result)
2620{
2621 struct rpccli_netr_ServerAuthenticate2_state *state = tevent_req_data(
2622 req, struct rpccli_netr_ServerAuthenticate2_state);
2623 NTSTATUS status;
2624
2625 if (tevent_req_is_nterror(req, &status)) {
2626 tevent_req_received(req);
2627 return status;
2628 }
2629
2630 /* Steal possbile out parameters to the callers context */
2631 talloc_steal(mem_ctx, state->out_mem_ctx);
2632
2633 /* Return result */
2634 *result = state->orig.out.result;
2635
2636 tevent_req_received(req);
2637 return NT_STATUS_OK;
2638}
2639
2640NTSTATUS 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] */)
2649{
2650 struct netr_ServerAuthenticate2 r;
2651 NTSTATUS status;
2652
2653 /* In parameters */
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;
2660
2661 status = cli->dispatch(cli,
2662 mem_ctx,
2663 &ndr_table_netlogon,
2664 NDR_NETR_SERVERAUTHENTICATE2,
2665 &r);
2666
2667 if (!NT_STATUS_IS_OK(status)) {
2668 return status;
2669 }
2670
2671 if (NT_STATUS_IS_ERR(status)) {
2672 return status;
2673 }
2674
2675 /* Return variables */
2676 *return_credentials = *r.out.return_credentials;
2677 *negotiate_flags = *r.out.negotiate_flags;
2678
2679 /* Return result */
2680 return r.out.result;
2681}
2682
2683struct 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);
2688};
2689
2690static void rpccli_netr_DatabaseSync2_done(struct tevent_req *subreq);
2691
2692struct 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] */)
2704{
2705 struct tevent_req *req;
2706 struct rpccli_netr_DatabaseSync2_state *state;
2707 struct tevent_req *subreq;
2708
2709 req = tevent_req_create(mem_ctx, &state,
2710 struct rpccli_netr_DatabaseSync2_state);
2711 if (req == NULL) {
2712 return NULL;
2713 }
2714 state->out_mem_ctx = NULL;
2715 state->dispatch_recv = cli->dispatch_recv;
2716
2717 /* In parameters */
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;
2726
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;
2731
2732 /* Result */
2733 ZERO_STRUCT(state->orig.out.result);
2734
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);
2739 }
2740
2741 /* make a temporary copy, that we pass to the dispatch function */
2742 state->tmp = state->orig;
2743
2744 subreq = cli->dispatch_send(state, ev, cli,
2745 &ndr_table_netlogon,
2746 NDR_NETR_DATABASESYNC2,
2747 &state->tmp);
2748 if (tevent_req_nomem(subreq, req)) {
2749 return tevent_req_post(req, ev);
2750 }
2751 tevent_req_set_callback(subreq, rpccli_netr_DatabaseSync2_done, req);
2752 return req;
2753}
2754
2755static void rpccli_netr_DatabaseSync2_done(struct tevent_req *subreq)
2756{
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);
2761 NTSTATUS status;
2762 TALLOC_CTX *mem_ctx;
2763
2764 if (state->out_mem_ctx) {
2765 mem_ctx = state->out_mem_ctx;
2766 } else {
2767 mem_ctx = state;
2768 }
2769
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);
2774 return;
2775 }
2776
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;
2781
2782 /* Copy result */
2783 state->orig.out.result = state->tmp.out.result;
2784
2785 /* Reset temporary structure */
2786 ZERO_STRUCT(state->tmp);
2787
2788 tevent_req_done(req);
2789}
2790
2791NTSTATUS rpccli_netr_DatabaseSync2_recv(struct tevent_req *req,
2792 TALLOC_CTX *mem_ctx,
2793 NTSTATUS *result)
2794{
2795 struct rpccli_netr_DatabaseSync2_state *state = tevent_req_data(
2796 req, struct rpccli_netr_DatabaseSync2_state);
2797 NTSTATUS status;
2798
2799 if (tevent_req_is_nterror(req, &status)) {
2800 tevent_req_received(req);
2801 return status;
2802 }
2803
2804 /* Steal possbile out parameters to the callers context */
2805 talloc_steal(mem_ctx, state->out_mem_ctx);
2806
2807 /* Return result */
2808 *result = state->orig.out.result;
2809
2810 tevent_req_received(req);
2811 return NT_STATUS_OK;
2812}
2813
2814NTSTATUS 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] */)
2825{
2826 struct netr_DatabaseSync2 r;
2827 NTSTATUS status;
2828
2829 /* In parameters */
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;
2838
2839 status = cli->dispatch(cli,
2840 mem_ctx,
2841 &ndr_table_netlogon,
2842 NDR_NETR_DATABASESYNC2,
2843 &r);
2844
2845 if (!NT_STATUS_IS_OK(status)) {
2846 return status;
2847 }
2848
2849 if (NT_STATUS_IS_ERR(status)) {
2850 return status;
2851 }
2852
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;
2857
2858 /* Return result */
2859 return r.out.result;
2860}
2861
2862struct 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);
2867};
2868
2869static void rpccli_netr_DatabaseRedo_done(struct tevent_req *subreq);
2870
2871struct 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] */)
2881{
2882 struct tevent_req *req;
2883 struct rpccli_netr_DatabaseRedo_state *state;
2884 struct tevent_req *subreq;
2885
2886 req = tevent_req_create(mem_ctx, &state,
2887 struct rpccli_netr_DatabaseRedo_state);
2888 if (req == NULL) {
2889 return NULL;
2890 }
2891 state->out_mem_ctx = NULL;
2892 state->dispatch_recv = cli->dispatch_recv;
2893
2894 /* In parameters */
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;
2901
2902 /* Out parameters */
2903 state->orig.out.return_authenticator = _return_authenticator;
2904 state->orig.out.delta_enum_array = _delta_enum_array;
2905
2906 /* Result */
2907 ZERO_STRUCT(state->orig.out.result);
2908
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);
2913 }
2914
2915 /* make a temporary copy, that we pass to the dispatch function */
2916 state->tmp = state->orig;
2917
2918 subreq = cli->dispatch_send(state, ev, cli,
2919 &ndr_table_netlogon,
2920 NDR_NETR_DATABASEREDO,
2921 &state->tmp);
2922 if (tevent_req_nomem(subreq, req)) {
2923 return tevent_req_post(req, ev);
2924 }
2925 tevent_req_set_callback(subreq, rpccli_netr_DatabaseRedo_done, req);
2926 return req;
2927}
2928
2929static void rpccli_netr_DatabaseRedo_done(struct tevent_req *subreq)
2930{
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);
2935 NTSTATUS status;
2936 TALLOC_CTX *mem_ctx;
2937
2938 if (state->out_mem_ctx) {
2939 mem_ctx = state->out_mem_ctx;
2940 } else {
2941 mem_ctx = state;
2942 }
2943
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);
2948 return;
2949 }
2950
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;
2954
2955 /* Copy result */
2956 state->orig.out.result = state->tmp.out.result;
2957
2958 /* Reset temporary structure */
2959 ZERO_STRUCT(state->tmp);
2960
2961 tevent_req_done(req);
2962}
2963
2964NTSTATUS rpccli_netr_DatabaseRedo_recv(struct tevent_req *req,
2965 TALLOC_CTX *mem_ctx,
2966 NTSTATUS *result)
2967{
2968 struct rpccli_netr_DatabaseRedo_state *state = tevent_req_data(
2969 req, struct rpccli_netr_DatabaseRedo_state);
2970 NTSTATUS status;
2971
2972 if (tevent_req_is_nterror(req, &status)) {
2973 tevent_req_received(req);
2974 return status;
2975 }
2976
2977 /* Steal possbile out parameters to the callers context */
2978 talloc_steal(mem_ctx, state->out_mem_ctx);
2979
2980 /* Return result */
2981 *result = state->orig.out.result;
2982
2983 tevent_req_received(req);
2984 return NT_STATUS_OK;
2985}
2986
2987NTSTATUS 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] */)
2996{
2997 struct netr_DatabaseRedo r;
2998 NTSTATUS status;
2999
3000 /* In parameters */
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;
3007
3008 status = cli->dispatch(cli,
3009 mem_ctx,
3010 &ndr_table_netlogon,
3011 NDR_NETR_DATABASEREDO,
3012 &r);
3013
3014 if (!NT_STATUS_IS_OK(status)) {
3015 return status;
3016 }
3017
3018 if (NT_STATUS_IS_ERR(status)) {
3019 return status;
3020 }
3021
3022 /* Return variables */
3023 *return_authenticator = *r.out.return_authenticator;
3024 *delta_enum_array = *r.out.delta_enum_array;
3025
3026 /* Return result */
3027 return r.out.result;
3028}
3029
3030struct 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);
3035};
3036
3037static void rpccli_netr_LogonControl2Ex_done(struct tevent_req *subreq);
3038
3039struct 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)] */)
3047{
3048 struct tevent_req *req;
3049 struct rpccli_netr_LogonControl2Ex_state *state;
3050 struct tevent_req *subreq;
3051
3052 req = tevent_req_create(mem_ctx, &state,
3053 struct rpccli_netr_LogonControl2Ex_state);
3054 if (req == NULL) {
3055 return NULL;
3056 }
3057 state->out_mem_ctx = NULL;
3058 state->dispatch_recv = cli->dispatch_recv;
3059
3060 /* In parameters */
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;
3065
3066 /* Out parameters */
3067 state->orig.out.query = _query;
3068
3069 /* Result */
3070 ZERO_STRUCT(state->orig.out.result);
3071
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);
3076 }
3077
3078 /* make a temporary copy, that we pass to the dispatch function */
3079 state->tmp = state->orig;
3080
3081 subreq = cli->dispatch_send(state, ev, cli,
3082 &ndr_table_netlogon,
3083 NDR_NETR_LOGONCONTROL2EX,
3084 &state->tmp);
3085 if (tevent_req_nomem(subreq, req)) {
3086 return tevent_req_post(req, ev);
3087 }
3088 tevent_req_set_callback(subreq, rpccli_netr_LogonControl2Ex_done, req);
3089 return req;
3090}
3091
3092static void rpccli_netr_LogonControl2Ex_done(struct tevent_req *subreq)
3093{
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);
3098 NTSTATUS status;
3099 TALLOC_CTX *mem_ctx;
3100
3101 if (state->out_mem_ctx) {
3102 mem_ctx = state->out_mem_ctx;
3103 } else {
3104 mem_ctx = state;
3105 }
3106
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);
3111 return;
3112 }
3113
3114 /* Copy out parameters */
3115 *state->orig.out.query = *state->tmp.out.query;
3116
3117 /* Copy result */
3118 state->orig.out.result = state->tmp.out.result;
3119
3120 /* Reset temporary structure */
3121 ZERO_STRUCT(state->tmp);
3122
3123 tevent_req_done(req);
3124}
3125
3126NTSTATUS rpccli_netr_LogonControl2Ex_recv(struct tevent_req *req,
3127 TALLOC_CTX *mem_ctx,
3128 WERROR *result)
3129{
3130 struct rpccli_netr_LogonControl2Ex_state *state = tevent_req_data(
3131 req, struct rpccli_netr_LogonControl2Ex_state);
3132 NTSTATUS status;
3133
3134 if (tevent_req_is_nterror(req, &status)) {
3135 tevent_req_received(req);
3136 return status;
3137 }
3138
3139 /* Steal possbile out parameters to the callers context */
3140 talloc_steal(mem_ctx, state->out_mem_ctx);
3141
3142 /* Return result */
3143 *result = state->orig.out.result;
3144
3145 tevent_req_received(req);
3146 return NT_STATUS_OK;
3147}
3148
3149NTSTATUS 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)] */,
3156 WERROR *werror)
3157{
3158 struct netr_LogonControl2Ex r;
3159 NTSTATUS status;
3160
3161 /* In parameters */
3162 r.in.logon_server = logon_server;
3163 r.in.function_code = function_code;
3164 r.in.level = level;
3165 r.in.data = data;
3166
3167 status = cli->dispatch(cli,
3168 mem_ctx,
3169 &ndr_table_netlogon,
3170 NDR_NETR_LOGONCONTROL2EX,
3171 &r);
3172
3173 if (!NT_STATUS_IS_OK(status)) {
3174 return status;
3175 }
3176
3177 if (NT_STATUS_IS_ERR(status)) {
3178 return status;
3179 }
3180
3181 /* Return variables */
3182 *query = *r.out.query;
3183
3184 /* Return result */
3185 if (werror) {
3186 *werror = r.out.result;
3187 }
3188
3189 return werror_to_ntstatus(r.out.result);
3190}
3191
3192struct 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);
3197};
3198
3199static void rpccli_netr_NetrEnumerateTrustedDomains_done(struct tevent_req *subreq);
3200
3201struct 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] */)
3206{
3207 struct tevent_req *req;
3208 struct rpccli_netr_NetrEnumerateTrustedDomains_state *state;
3209 struct tevent_req *subreq;
3210
3211 req = tevent_req_create(mem_ctx, &state,
3212 struct rpccli_netr_NetrEnumerateTrustedDomains_state);
3213 if (req == NULL) {
3214 return NULL;
3215 }
3216 state->out_mem_ctx = NULL;
3217 state->dispatch_recv = cli->dispatch_recv;
3218
3219 /* In parameters */
3220 state->orig.in.server_name = _server_name;
3221
3222 /* Out parameters */
3223 state->orig.out.trusted_domains_blob = _trusted_domains_blob;
3224
3225 /* Result */
3226 ZERO_STRUCT(state->orig.out.result);
3227
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);
3232 }
3233
3234 /* make a temporary copy, that we pass to the dispatch function */
3235 state->tmp = state->orig;
3236
3237 subreq = cli->dispatch_send(state, ev, cli,
3238 &ndr_table_netlogon,
3239 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS,
3240 &state->tmp);
3241 if (tevent_req_nomem(subreq, req)) {
3242 return tevent_req_post(req, ev);
3243 }
3244 tevent_req_set_callback(subreq, rpccli_netr_NetrEnumerateTrustedDomains_done, req);
3245 return req;
3246}
3247
3248static void rpccli_netr_NetrEnumerateTrustedDomains_done(struct tevent_req *subreq)
3249{
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);
3254 NTSTATUS status;
3255 TALLOC_CTX *mem_ctx;
3256
3257 if (state->out_mem_ctx) {
3258 mem_ctx = state->out_mem_ctx;
3259 } else {
3260 mem_ctx = state;
3261 }
3262
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);
3267 return;
3268 }
3269
3270 /* Copy out parameters */
3271 *state->orig.out.trusted_domains_blob = *state->tmp.out.trusted_domains_blob;
3272
3273 /* Copy result */
3274 state->orig.out.result = state->tmp.out.result;
3275
3276 /* Reset temporary structure */
3277 ZERO_STRUCT(state->tmp);
3278
3279 tevent_req_done(req);
3280}
3281
3282NTSTATUS rpccli_netr_NetrEnumerateTrustedDomains_recv(struct tevent_req *req,
3283 TALLOC_CTX *mem_ctx,
3284 WERROR *result)
3285{
3286 struct rpccli_netr_NetrEnumerateTrustedDomains_state *state = tevent_req_data(
3287 req, struct rpccli_netr_NetrEnumerateTrustedDomains_state);
3288 NTSTATUS status;
3289
3290 if (tevent_req_is_nterror(req, &status)) {
3291 tevent_req_received(req);
3292 return status;
3293 }
3294
3295 /* Steal possbile out parameters to the callers context */
3296 talloc_steal(mem_ctx, state->out_mem_ctx);
3297
3298 /* Return result */
3299 *result = state->orig.out.result;
3300
3301 tevent_req_received(req);
3302 return NT_STATUS_OK;
3303}
3304
3305NTSTATUS 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] */,
3309 WERROR *werror)
3310{
3311 struct netr_NetrEnumerateTrustedDomains r;
3312 NTSTATUS status;
3313
3314 /* In parameters */
3315 r.in.server_name = server_name;
3316
3317 status = cli->dispatch(cli,
3318 mem_ctx,
3319 &ndr_table_netlogon,
3320 NDR_NETR_NETRENUMERATETRUSTEDDOMAINS,
3321 &r);
3322
3323 if (!NT_STATUS_IS_OK(status)) {
3324 return status;
3325 }
3326
3327 if (NT_STATUS_IS_ERR(status)) {
3328 return status;
3329 }
3330
3331 /* Return variables */
3332 *trusted_domains_blob = *r.out.trusted_domains_blob;
3333
3334 /* Return result */
3335 if (werror) {
3336 *werror = r.out.result;
3337 }
3338
3339 return werror_to_ntstatus(r.out.result);
3340}
3341
3342struct 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);
3347};
3348
3349static void rpccli_netr_DsRGetDCName_done(struct tevent_req *subreq);
3350
3351struct 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] */)
3360{
3361 struct tevent_req *req;
3362 struct rpccli_netr_DsRGetDCName_state *state;
3363 struct tevent_req *subreq;
3364
3365 req = tevent_req_create(mem_ctx, &state,
3366 struct rpccli_netr_DsRGetDCName_state);
3367 if (req == NULL) {
3368 return NULL;
3369 }
3370 state->out_mem_ctx = NULL;
3371 state->dispatch_recv = cli->dispatch_recv;
3372
3373 /* In parameters */
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;
3379
3380 /* Out parameters */
3381 state->orig.out.info = _info;
3382
3383 /* Result */
3384 ZERO_STRUCT(state->orig.out.result);
3385
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);
3390 }
3391
3392 /* make a temporary copy, that we pass to the dispatch function */
3393 state->tmp = state->orig;
3394
3395 subreq = cli->dispatch_send(state, ev, cli,
3396 &ndr_table_netlogon,
3397 NDR_NETR_DSRGETDCNAME,
3398 &state->tmp);
3399 if (tevent_req_nomem(subreq, req)) {
3400 return tevent_req_post(req, ev);
3401 }
3402 tevent_req_set_callback(subreq, rpccli_netr_DsRGetDCName_done, req);
3403 return req;
3404}
3405
3406static void rpccli_netr_DsRGetDCName_done(struct tevent_req *subreq)
3407{
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);
3412 NTSTATUS status;
3413 TALLOC_CTX *mem_ctx;
3414
3415 if (state->out_mem_ctx) {
3416 mem_ctx = state->out_mem_ctx;
3417 } else {
3418 mem_ctx = state;
3419 }
3420
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);
3425 return;
3426 }
3427
3428 /* Copy out parameters */
3429 *state->orig.out.info = *state->tmp.out.info;
3430
3431 /* Copy result */
3432 state->orig.out.result = state->tmp.out.result;
3433
3434 /* Reset temporary structure */
3435 ZERO_STRUCT(state->tmp);
3436
3437 tevent_req_done(req);
3438}
3439
3440NTSTATUS rpccli_netr_DsRGetDCName_recv(struct tevent_req *req,
3441 TALLOC_CTX *mem_ctx,
3442 WERROR *result)
3443{
3444 struct rpccli_netr_DsRGetDCName_state *state = tevent_req_data(
3445 req, struct rpccli_netr_DsRGetDCName_state);
3446 NTSTATUS status;
3447
3448 if (tevent_req_is_nterror(req, &status)) {
3449 tevent_req_received(req);
3450 return status;
3451 }
3452
3453 /* Steal possbile out parameters to the callers context */
3454 talloc_steal(mem_ctx, state->out_mem_ctx);
3455
3456 /* Return result */
3457 *result = state->orig.out.result;
3458
3459 tevent_req_received(req);
3460 return NT_STATUS_OK;
3461}
3462
3463NTSTATUS 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] */,
3471 WERROR *werror)
3472{
3473 struct netr_DsRGetDCName r;
3474 NTSTATUS status;
3475
3476 /* In parameters */
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;
3481 r.in.flags = flags;
3482
3483 status = cli->dispatch(cli,
3484 mem_ctx,
3485 &ndr_table_netlogon,
3486 NDR_NETR_DSRGETDCNAME,
3487 &r);
3488
3489 if (!NT_STATUS_IS_OK(status)) {
3490 return status;
3491 }
3492
3493 if (NT_STATUS_IS_ERR(status)) {
3494 return status;
3495 }
3496
3497 /* Return variables */
3498 *info = *r.out.info;
3499
3500 /* Return result */
3501 if (werror) {
3502 *werror = r.out.result;
3503 }
3504
3505 return werror_to_ntstatus(r.out.result);
3506}
3507
3508struct 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);
3513};
3514
3515static void rpccli_netr_LogonGetCapabilities_done(struct tevent_req *subreq);
3516
3517struct 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)] */)
3526{
3527 struct tevent_req *req;
3528 struct rpccli_netr_LogonGetCapabilities_state *state;
3529 struct tevent_req *subreq;
3530
3531 req = tevent_req_create(mem_ctx, &state,
3532 struct rpccli_netr_LogonGetCapabilities_state);
3533 if (req == NULL) {
3534 return NULL;
3535 }
3536 state->out_mem_ctx = NULL;
3537 state->dispatch_recv = cli->dispatch_recv;
3538
3539 /* In parameters */
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;
3545
3546 /* Out parameters */
3547 state->orig.out.return_authenticator = _return_authenticator;
3548 state->orig.out.capabilities = _capabilities;
3549
3550 /* Result */
3551 ZERO_STRUCT(state->orig.out.result);
3552
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);
3557 }
3558
3559 /* make a temporary copy, that we pass to the dispatch function */
3560 state->tmp = state->orig;
3561
3562 subreq = cli->dispatch_send(state, ev, cli,
3563 &ndr_table_netlogon,
3564 NDR_NETR_LOGONGETCAPABILITIES,
3565 &state->tmp);
3566 if (tevent_req_nomem(subreq, req)) {
3567 return tevent_req_post(req, ev);
3568 }
3569 tevent_req_set_callback(subreq, rpccli_netr_LogonGetCapabilities_done, req);
3570 return req;
3571}
3572
3573static void rpccli_netr_LogonGetCapabilities_done(struct tevent_req *subreq)
3574{
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);
3579 NTSTATUS status;
3580 TALLOC_CTX *mem_ctx;
3581
3582 if (state->out_mem_ctx) {
3583 mem_ctx = state->out_mem_ctx;
3584 } else {
3585 mem_ctx = state;
3586 }
3587
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);
3592 return;
3593 }
3594
3595 /* Copy out parameters */
3596 *state->orig.out.return_authenticator = *state->tmp.out.return_authenticator;
3597 *state->orig.out.capabilities = *state->tmp.out.capabilities;
3598
3599 /* Copy result */
3600 state->orig.out.result = state->tmp.out.result;
3601
3602 /* Reset temporary structure */
3603 ZERO_STRUCT(state->tmp);
3604
3605 tevent_req_done(req);
3606}
3607
3608NTSTATUS rpccli_netr_LogonGetCapabilities_recv(struct tevent_req *req,
3609 TALLOC_CTX *mem_ctx,
3610 NTSTATUS *result)
3611{
3612 struct rpccli_netr_LogonGetCapabilities_state *state = tevent_req_data(
3613 req, struct rpccli_netr_LogonGetCapabilities_state);
3614 NTSTATUS status;
3615
3616 if (tevent_req_is_nterror(req, &status)) {
3617 tevent_req_received(req);
3618 return status;
3619 }
3620
3621 /* Steal possbile out parameters to the callers context */
3622 talloc_steal(mem_ctx, state->out_mem_ctx);
3623
3624 /* Return result */
3625 *result = state->orig.out.result;
3626
3627 tevent_req_received(req);
3628 return NT_STATUS_OK;
3629}
3630
3631NTSTATUS 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)] */)
3639{
3640 struct netr_LogonGetCapabilities r;
3641 NTSTATUS status;
3642
3643 /* In parameters */
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;
3649
3650 status = cli->dispatch(cli,
3651 mem_ctx,
3652 &ndr_table_netlogon,
3653 NDR_NETR_LOGONGETCAPABILITIES,
3654 &r);
3655
3656 if (!NT_STATUS_IS_OK(status)) {
3657 return status;
3658 }
3659
3660 if (NT_STATUS_IS_ERR(status)) {
3661 return status;
3662 }
3663
3664 /* Return variables */
3665 *return_authenticator = *r.out.return_authenticator;
3666 *capabilities = *r.out.capabilities;
3667
3668 /* Return result */
3669 return r.out.result;
3670}
3671
3672struct 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);
3677};
3678
3679static void rpccli_netr_NETRLOGONSETSERVICEBITS_done(struct tevent_req *subreq);
3680
3681struct tevent_req *rpccli_netr_NETRLOGONSETSERVICEBITS_send(TALLOC_CTX *mem_ctx,
3682 struct tevent_context *ev,
3683 struct rpc_pipe_client *cli)
3684{
3685 struct tevent_req *req;
3686 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state *state;
3687 struct tevent_req *subreq;
3688
3689 req = tevent_req_create(mem_ctx, &state,
3690 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state);
3691 if (req == NULL) {
3692 return NULL;
3693 }
3694 state->out_mem_ctx = NULL;
3695 state->dispatch_recv = cli->dispatch_recv;
3696
3697 /* In parameters */
3698
3699 /* Out parameters */
3700
3701 /* Result */
3702 ZERO_STRUCT(state->orig.out.result);
3703
3704 /* make a temporary copy, that we pass to the dispatch function */
3705 state->tmp = state->orig;
3706
3707 subreq = cli->dispatch_send(state, ev, cli,
3708 &ndr_table_netlogon,
3709 NDR_NETR_NETRLOGONSETSERVICEBITS,
3710 &state->tmp);
3711 if (tevent_req_nomem(subreq, req)) {
3712 return tevent_req_post(req, ev);
3713 }
3714 tevent_req_set_callback(subreq, rpccli_netr_NETRLOGONSETSERVICEBITS_done, req);
3715 return req;
3716}
3717
3718static void rpccli_netr_NETRLOGONSETSERVICEBITS_done(struct tevent_req *subreq)
3719{
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);
3724 NTSTATUS status;
3725 TALLOC_CTX *mem_ctx;
3726
3727 if (state->out_mem_ctx) {
3728 mem_ctx = state->out_mem_ctx;
3729 } else {
3730 mem_ctx = state;
3731 }
3732
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);
3737 return;
3738 }
3739
3740 /* Copy out parameters */
3741
3742 /* Copy result */
3743 state->orig.out.result = state->tmp.out.result;
3744
3745 /* Reset temporary structure */
3746 ZERO_STRUCT(state->tmp);
3747
3748 tevent_req_done(req);
3749}
3750
3751NTSTATUS rpccli_netr_NETRLOGONSETSERVICEBITS_recv(struct tevent_req *req,
3752 TALLOC_CTX *mem_ctx,
3753 WERROR *result)
3754{
3755 struct rpccli_netr_NETRLOGONSETSERVICEBITS_state *state = tevent_req_data(
3756 req, struct rpccli_netr_NETRLOGONSETSERVICEBITS_state);
3757 NTSTATUS status;
3758
3759 if (tevent_req_is_nterror(req, &status)) {
3760 tevent_req_received(req);
3761 return status;
3762 }
3763
3764 /* Steal possbile out parameters to the callers context */
3765 talloc_steal(mem_ctx, state->out_mem_ctx);
3766
3767 /* Return result */
3768 *result = state->orig.out.result;
3769
3770 tevent_req_received(req);
3771 return NT_STATUS_OK;
3772}
3773
3774NTSTATUS rpccli_netr_NETRLOGONSETSERVICEBITS(struct rpc_pipe_client *cli,
3775 TALLOC_CTX *mem_ctx,
3776 WERROR *werror)
3777{
3778 struct netr_NETRLOGONSETSERVICEBITS r;
3779 NTSTATUS status;
3780
3781 /* In parameters */
3782
3783 status = cli->dispatch(cli,
3784 mem_ctx,
3785 &ndr_table_netlogon,
3786 NDR_NETR_NETRLOGONSETSERVICEBITS,
3787 &r);
3788
3789 if (!NT_STATUS_IS_OK(status)) {
3790 return status;
3791 }
3792
3793 if (NT_STATUS_IS_ERR(status)) {
3794 return status;
3795 }
3796
3797 /* Return variables */
3798
3799 /* Return result */
3800 if (werror) {
3801 *werror = r.out.result;
3802 }
3803
3804 return werror_to_ntstatus(r.out.result);
3805}
3806
3807struct 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);
3812};
3813
3814static void rpccli_netr_LogonGetTrustRid_done(struct tevent_req *subreq);
3815
3816struct 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] */)
3822{
3823 struct tevent_req *req;
3824 struct rpccli_netr_LogonGetTrustRid_state *state;
3825 struct tevent_req *subreq;
3826
3827 req = tevent_req_create(mem_ctx, &state,
3828 struct rpccli_netr_LogonGetTrustRid_state);
3829 if (req == NULL) {
3830 return NULL;
3831 }
3832 state->out_mem_ctx = NULL;
3833 state->dispatch_recv = cli->dispatch_recv;
3834
3835 /* In parameters */
3836 state->orig.in.server_name = _server_name;
3837 state->orig.in.domain_name = _domain_name;
3838
3839 /* Out parameters */
3840 state->orig.out.rid = _rid;
3841
3842 /* Result */
3843 ZERO_STRUCT(state->orig.out.result);
3844
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);
3849 }
3850
3851 /* make a temporary copy, that we pass to the dispatch function */
3852 state->tmp = state->orig;
3853
3854 subreq = cli->dispatch_send(state, ev, cli,
3855 &ndr_table_netlogon,
3856 NDR_NETR_LOGONGETTRUSTRID,
3857 &state->tmp);
3858 if (tevent_req_nomem(subreq, req)) {
3859 return tevent_req_post(req, ev);
3860 }
3861 tevent_req_set_callback(subreq, rpccli_netr_LogonGetTrustRid_done, req);
3862 return req;
3863}
3864
3865static void rpccli_netr_LogonGetTrustRid_done(struct tevent_req *subreq)
3866{
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);
3871 NTSTATUS status;
3872 TALLOC_CTX *mem_ctx;
3873
3874 if (state->out_mem_ctx) {
3875 mem_ctx = state->out_mem_ctx;
3876 } else {
3877 mem_ctx = state;
3878 }
3879
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);
3884 return;
3885 }
3886
3887 /* Copy out parameters */
3888 *state->orig.out.rid = *state->tmp.out.rid;
3889
3890 /* Copy result */
3891 state->orig.out.result = state->tmp.out.result;
3892
3893 /* Reset temporary structure */
3894 ZERO_STRUCT(state->tmp);
3895
3896 tevent_req_done(req);
3897}
3898
3899NTSTATUS rpccli_netr_LogonGetTrustRid_recv(struct tevent_req *req,
3900 TALLOC_CTX *mem_ctx,
3901 WERROR *result)
3902{
3903 struct rpccli_netr_LogonGetTrustRid_state *state = tevent_req_data(
3904 req, struct rpccli_netr_LogonGetTrustRid_state);
3905 NTSTATUS status;
3906
3907 if (tevent_req_is_nterror(req, &status)) {
3908 tevent_req_received(req);
3909 return status;
3910 }
3911
3912 /* Steal possbile out parameters to the callers context */
3913 talloc_steal(mem_ctx, state->out_mem_ctx);
3914
3915 /* Return result */
3916 *result = state->orig.out.result;
3917
3918 tevent_req_received(req);
3919 return NT_STATUS_OK;
3920}
3921
3922NTSTATUS 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] */,
3927 WERROR *werror)
3928{
3929 struct netr_LogonGetTrustRid r;
3930 NTSTATUS status;
3931
3932 /* In parameters */
3933 r.in.server_name = server_name;
3934 r.in.domain_name = domain_name;
3935
3936 status = cli->dispatch(cli,
3937 mem_ctx,
3938 &ndr_table_netlogon,
3939 NDR_NETR_LOGONGETTRUSTRID,
3940 &r);
3941
3942 if (!NT_STATUS_IS_OK(status)) {
3943 return status;
3944 }
3945
3946 if (NT_STATUS_IS_ERR(status)) {
3947 return status;
3948 }
3949
3950 /* Return variables */
3951 *rid = *r.out.rid;
3952
3953 /* Return result */
3954 if (werror) {
3955 *werror = r.out.result;
3956 }
3957
3958 return werror_to_ntstatus(r.out.result);
3959}
3960
3961struct 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);
3966};
3967
3968static void rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done(struct tevent_req *subreq);
3969
3970struct tevent_req *rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_send(TALLOC_CTX *mem_ctx,
3971 struct tevent_context *ev,
3972 struct rpc_pipe_client *cli)
3973{
3974 struct tevent_req *req;
3975 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state *state;
3976 struct tevent_req *subreq;
3977
3978 req = tevent_req_create(mem_ctx, &state,
3979 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state);
3980 if (req == NULL) {
3981 return NULL;
3982 }
3983 state->out_mem_ctx = NULL;
3984 state->dispatch_recv = cli->dispatch_recv;
3985
3986 /* In parameters */
3987
3988 /* Out parameters */
3989
3990 /* Result */
3991 ZERO_STRUCT(state->orig.out.result);
3992
3993 /* make a temporary copy, that we pass to the dispatch function */
3994 state->tmp = state->orig;
3995
3996 subreq = cli->dispatch_send(state, ev, cli,
3997 &ndr_table_netlogon,
3998 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST,
3999 &state->tmp);
4000 if (tevent_req_nomem(subreq, req)) {
4001 return tevent_req_post(req, ev);
4002 }
4003 tevent_req_set_callback(subreq, rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done, req);
4004 return req;
4005}
4006
4007static void rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_done(struct tevent_req *subreq)
4008{
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);
4013 NTSTATUS status;
4014 TALLOC_CTX *mem_ctx;
4015
4016 if (state->out_mem_ctx) {
4017 mem_ctx = state->out_mem_ctx;
4018 } else {
4019 mem_ctx = state;
4020 }
4021
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);
4026 return;
4027 }
4028
4029 /* Copy out parameters */
4030
4031 /* Copy result */
4032 state->orig.out.result = state->tmp.out.result;
4033
4034 /* Reset temporary structure */
4035 ZERO_STRUCT(state->tmp);
4036
4037 tevent_req_done(req);
4038}
4039
4040NTSTATUS rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_recv(struct tevent_req *req,
4041 TALLOC_CTX *mem_ctx,
4042 WERROR *result)
4043{
4044 struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state *state = tevent_req_data(
4045 req, struct rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST_state);
4046 NTSTATUS status;
4047
4048 if (tevent_req_is_nterror(req, &status)) {
4049 tevent_req_received(req);
4050 return status;
4051 }
4052
4053 /* Steal possbile out parameters to the callers context */
4054 talloc_steal(mem_ctx, state->out_mem_ctx);
4055
4056 /* Return result */
4057 *result = state->orig.out.result;
4058
4059 tevent_req_received(req);
4060 return NT_STATUS_OK;
4061}
4062
4063NTSTATUS rpccli_netr_NETRLOGONCOMPUTESERVERDIGEST(struct rpc_pipe_client *cli,
4064 TALLOC_CTX *mem_ctx,
4065 WERROR *werror)
4066{
4067 struct netr_NETRLOGONCOMPUTESERVERDIGEST r;
4068 NTSTATUS status;
4069
4070 /* In parameters */
4071
4072 status = cli->dispatch(cli,
4073 mem_ctx,
4074 &ndr_table_netlogon,
4075 NDR_NETR_NETRLOGONCOMPUTESERVERDIGEST,
4076 &r);
4077
4078 if (!NT_STATUS_IS_OK(status)) {
4079 return status;
4080 }
4081
4082 if (NT_STATUS_IS_ERR(status)) {
4083 return status;
4084 }
4085
4086 /* Return variables */
4087
4088 /* Return result */
4089 if (werror) {
4090 *werror = r.out.result;
4091 }
4092
4093 return werror_to_ntstatus(r.out.result);
4094}
4095
4096struct 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);
4101};
4102
4103static void rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done(struct tevent_req *subreq);
4104
4105struct tevent_req *rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_send(TALLOC_CTX *mem_ctx,
4106 struct tevent_context *ev,
4107 struct rpc_pipe_client *cli)
4108{
4109 struct tevent_req *req;
4110 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state *state;
4111 struct tevent_req *subreq;
4112
4113 req = tevent_req_create(mem_ctx, &state,
4114 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state);
4115 if (req == NULL) {
4116 return NULL;
4117 }
4118 state->out_mem_ctx = NULL;
4119 state->dispatch_recv = cli->dispatch_recv;
4120
4121 /* In parameters */
4122
4123 /* Out parameters */
4124
4125 /* Result */
4126 ZERO_STRUCT(state->orig.out.result);
4127
4128 /* make a temporary copy, that we pass to the dispatch function */
4129 state->tmp = state->orig;
4130
4131 subreq = cli->dispatch_send(state, ev, cli,
4132 &ndr_table_netlogon,
4133 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST,
4134 &state->tmp);
4135 if (tevent_req_nomem(subreq, req)) {
4136 return tevent_req_post(req, ev);
4137 }
4138 tevent_req_set_callback(subreq, rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done, req);
4139 return req;
4140}
4141
4142static void rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_done(struct tevent_req *subreq)
4143{
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);
4148 NTSTATUS status;
4149 TALLOC_CTX *mem_ctx;
4150
4151 if (state->out_mem_ctx) {
4152 mem_ctx = state->out_mem_ctx;
4153 } else {
4154 mem_ctx = state;
4155 }
4156
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);
4161 return;
4162 }
4163
4164 /* Copy out parameters */
4165
4166 /* Copy result */
4167 state->orig.out.result = state->tmp.out.result;
4168
4169 /* Reset temporary structure */
4170 ZERO_STRUCT(state->tmp);
4171
4172 tevent_req_done(req);
4173}
4174
4175NTSTATUS rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_recv(struct tevent_req *req,
4176 TALLOC_CTX *mem_ctx,
4177 WERROR *result)
4178{
4179 struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state *state = tevent_req_data(
4180 req, struct rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST_state);
4181 NTSTATUS status;
4182
4183 if (tevent_req_is_nterror(req, &status)) {
4184 tevent_req_received(req);
4185 return status;
4186 }
4187
4188 /* Steal possbile out parameters to the callers context */
4189 talloc_steal(mem_ctx, state->out_mem_ctx);
4190
4191 /* Return result */
4192 *result = state->orig.out.result;
4193
4194 tevent_req_received(req);
4195 return NT_STATUS_OK;
4196}
4197
4198NTSTATUS rpccli_netr_NETRLOGONCOMPUTECLIENTDIGEST(struct rpc_pipe_client *cli,
4199 TALLOC_CTX *mem_ctx,
4200 WERROR *werror)
4201{
4202 struct netr_NETRLOGONCOMPUTECLIENTDIGEST r;
4203 NTSTATUS status;
4204
4205 /* In parameters */
4206
4207 status = cli->dispatch(cli,
4208 mem_ctx,
4209 &ndr_table_netlogon,
4210 NDR_NETR_NETRLOGONCOMPUTECLIENTDIGEST,
4211 &r);
4212
4213 if (!NT_STATUS_IS_OK(status)) {
4214 return status;
4215 }
4216
4217 if (NT_STATUS_IS_ERR(status)) {
4218 return status;
4219 }
4220
4221 /* Return variables */
4222
4223 /* Return result */
4224 if (werror) {
4225 *werror = r.out.result;
4226 }
4227
4228 return werror_to_ntstatus(r.out.result);
4229}
4230
4231struct 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);
4236};
4237
4238static void rpccli_netr_ServerAuthenticate3_done(struct tevent_req *subreq);
4239
4240struct 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] */)
4251{
4252 struct tevent_req *req;
4253 struct rpccli_netr_ServerAuthenticate3_state *state;
4254 struct tevent_req *subreq;
4255
4256 req = tevent_req_create(mem_ctx, &state,
4257 struct rpccli_netr_ServerAuthenticate3_state);
4258 if (req == NULL) {
4259 return NULL;
4260 }
4261 state->out_mem_ctx = NULL;
4262 state->dispatch_recv = cli->dispatch_recv;
4263
4264 /* In parameters */
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;
4271
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;
4276
4277 /* Result */
4278 ZERO_STRUCT(state->orig.out.result);
4279
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);
4284 }
4285
4286 /* make a temporary copy, that we pass to the dispatch function */
4287 state->tmp = state->orig;
4288
4289 subreq = cli->dispatch_send(state, ev, cli,
4290 &ndr_table_netlogon,
4291 NDR_NETR_SERVERAUTHENTICATE3,
4292 &state->tmp);
4293 if (tevent_req_nomem(subreq, req)) {
4294 return tevent_req_post(req, ev);
4295 }
4296 tevent_req_set_callback(subreq, rpccli_netr_ServerAuthenticate3_done, req);
4297 return req;
4298}
4299
4300static void rpccli_netr_ServerAuthenticate3_done(struct tevent_req *subreq)
4301{
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);
4306 NTSTATUS status;
4307 TALLOC_CTX *mem_ctx;
4308
4309 if (state->out_mem_ctx) {
4310 mem_ctx = state->out_mem_ctx;
4311 } else {
4312 mem_ctx = state;
4313 }
4314
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);
4319 return;
4320 }
4321
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;
4326
4327 /* Copy result */
4328 state->orig.out.result = state->tmp.out.result;
4329
4330 /* Reset temporary structure */
4331 ZERO_STRUCT(state->tmp);
4332
4333 tevent_req_done(req);
4334}
4335
4336NTSTATUS rpccli_netr_ServerAuthenticate3_recv(struct tevent_req *req,
4337 TALLOC_CTX *mem_ctx,
4338 NTSTATUS *result)
4339{
4340 struct rpccli_netr_ServerAuthenticate3_state *state = tevent_req_data(
4341 req, struct rpccli_netr_ServerAuthenticate3_state);
4342 NTSTATUS status;
4343
4344 if (tevent_req_is_nterror(req, &status)) {
4345 tevent_req_received(req);
4346 return status;
4347 }
4348
4349 /* Steal possbile out parameters to the callers context */
4350 talloc_steal(mem_ctx, state->out_mem_ctx);
4351
4352 /* Return result */
4353 *result = state->orig.out.result;
4354
4355 tevent_req_received(req);
4356 return NT_STATUS_OK;
4357}
4358
4359NTSTATUS 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] */)
4369{
4370 struct netr_ServerAuthenticate3 r;
4371 NTSTATUS status;
4372
4373 /* In parameters */
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;
4380
4381 status = cli->dispatch(cli,
4382 mem_ctx,
4383 &ndr_table_netlogon,
4384 NDR_NETR_SERVERAUTHENTICATE3,
4385 &r);
4386
4387 if (!NT_STATUS_IS_OK(status)) {
4388 return status;
4389 }
4390
4391 if (NT_STATUS_IS_ERR(status)) {
4392 return status;
4393 }
4394
4395 /* Return variables */
4396 *return_credentials = *r.out.return_credentials;
4397 *negotiate_flags = *r.out.negotiate_flags;
4398 *rid = *r.out.rid;
4399
4400 /* Return result */
4401 return r.out.result;
4402}
4403
4404struct 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);
4409};
4410
4411static void rpccli_netr_DsRGetDCNameEx_done(struct tevent_req *subreq);
4412
4413struct 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] */)
4422{
4423 struct tevent_req *req;
4424 struct rpccli_netr_DsRGetDCNameEx_state *state;
4425 struct tevent_req *subreq;
4426
4427 req = tevent_req_create(mem_ctx, &state,
4428 struct rpccli_netr_DsRGetDCNameEx_state);
4429 if (req == NULL) {
4430 return NULL;
4431 }
4432 state->out_mem_ctx = NULL;
4433 state->dispatch_recv = cli->dispatch_recv;
4434
4435 /* In parameters */
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;
4441
4442 /* Out parameters */
4443 state->orig.out.info = _info;
4444
4445 /* Result */
4446 ZERO_STRUCT(state->orig.out.result);
4447
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);
4452 }
4453
4454 /* make a temporary copy, that we pass to the dispatch function */
4455 state->tmp = state->orig;
4456
4457 subreq = cli->dispatch_send(state, ev, cli,
4458 &ndr_table_netlogon,
4459 NDR_NETR_DSRGETDCNAMEEX,
4460 &state->tmp);
4461 if (tevent_req_nomem(subreq, req)) {
4462 return tevent_req_post(req, ev);
4463 }
4464 tevent_req_set_callback(subreq, rpccli_netr_DsRGetDCNameEx_done, req);
4465 return req;
4466}
4467
4468static void rpccli_netr_DsRGetDCNameEx_done(struct tevent_req *subreq)
4469{
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);
4474 NTSTATUS status;
4475 TALLOC_CTX *mem_ctx;
4476
4477 if (state->out_mem_ctx) {
4478 mem_ctx = state->out_mem_ctx;
4479 } else {
4480 mem_ctx = state;
4481 }
4482
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);
4487 return;
4488 }
4489
4490 /* Copy out parameters */
4491 *state->orig.out.info = *state->tmp.out.info;
4492
4493 /* Copy result */
4494 state->orig.out.result = state->tmp.out.result;
4495
4496 /* Reset temporary structure */
4497 ZERO_STRUCT(state->tmp);
4498
4499 tevent_req_done(req);
4500}
4501
4502NTSTATUS rpccli_netr_DsRGetDCNameEx_recv(struct tevent_req *req,
4503 TALLOC_CTX *mem_ctx,
4504 WERROR *result)
4505{
4506 struct rpccli_netr_DsRGetDCNameEx_state *state = tevent_req_data(
4507 req, struct rpccli_netr_DsRGetDCNameEx_state);
4508 NTSTATUS status;
4509
4510 if (tevent_req_is_nterror(req, &status)) {
4511 tevent_req_received(req);
4512 return status;
4513 }
4514
4515 /* Steal possbile out parameters to the callers context */
4516 talloc_steal(mem_ctx, state->out_mem_ctx);
4517
4518 /* Return result */
4519 *result = state->orig.out.result;
4520
4521 tevent_req_received(req);
4522 return NT_STATUS_OK;
4523}
4524
4525NTSTATUS 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] */,
4533 WERROR *werror)
4534{
4535 struct netr_DsRGetDCNameEx r;
4536 NTSTATUS status;
4537
4538 /* In parameters */
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;
4543 r.in.flags = flags;
4544
4545 status = cli->dispatch(cli,
4546 mem_ctx,
4547 &ndr_table_netlogon,
4548 NDR_NETR_DSRGETDCNAMEEX,
4549 &r);
4550
4551 if (!NT_STATUS_IS_OK(status)) {
4552 return status;
4553 }
4554
4555 if (NT_STATUS_IS_ERR(status)) {
4556 return status;
4557 }
4558
4559 /* Return variables */
4560 *info = *r.out.info;
4561
4562 /* Return result */
4563 if (werror) {
4564 *werror = r.out.result;
4565 }
4566
4567 return werror_to_ntstatus(r.out.result);
4568}
4569
4570struct 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);
4575};
4576
4577static void rpccli_netr_DsRGetSiteName_done(struct tevent_req *subreq);
4578
4579struct 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)] */)
4584{
4585 struct tevent_req *req;
4586 struct rpccli_netr_DsRGetSiteName_state *state;
4587 struct tevent_req *subreq;
4588
4589 req = tevent_req_create(mem_ctx, &state,
4590 struct rpccli_netr_DsRGetSiteName_state);
4591 if (req == NULL) {
4592 return NULL;
4593 }
4594 state->out_mem_ctx = NULL;
4595 state->dispatch_recv = cli->dispatch_recv;
4596
4597 /* In parameters */
4598 state->orig.in.computer_name = _computer_name;
4599
4600 /* Out parameters */
4601 state->orig.out.site = _site;
4602
4603 /* Result */
4604 ZERO_STRUCT(state->orig.out.result);
4605
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);
4610 }
4611
4612 /* make a temporary copy, that we pass to the dispatch function */
4613 state->tmp = state->orig;
4614
4615 subreq = cli->dispatch_send(state, ev, cli,
4616 &ndr_table_netlogon,
4617 NDR_NETR_DSRGETSITENAME,
4618 &state->tmp);
4619 if (tevent_req_nomem(subreq, req)) {
4620 return tevent_req_post(req, ev);
4621 }
4622 tevent_req_set_callback(subreq, rpccli_netr_DsRGetSiteName_done, req);
4623 return req;
4624}
4625
4626static void rpccli_netr_DsRGetSiteName_done(struct tevent_req *subreq)
4627{
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);
4632 NTSTATUS status;
4633 TALLOC_CTX *mem_ctx;
4634
4635 if (state->out_mem_ctx) {
4636 mem_ctx = state->out_mem_ctx;
4637 } else {
4638 mem_ctx = state;
4639 }
4640
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);
4645 return;
4646 }
4647
4648 /* Copy out parameters */
4649 *state->orig.out.site = *state->tmp.out.site;
4650
4651 /* Copy result */
4652 state->orig.out.result = state->tmp.out.result;
4653
4654 /* Reset temporary structure */
4655 ZERO_STRUCT(state->tmp);
4656
4657 tevent_req_done(req);
4658}
4659
4660NTSTATUS rpccli_netr_DsRGetSiteName_recv(struct tevent_req *req,
4661 TALLOC_CTX *mem_ctx,
4662 WERROR *result)
4663{
4664 struct rpccli_netr_DsRGetSiteName_state *state = tevent_req_data(
4665 req, struct rpccli_netr_DsRGetSiteName_state);
4666 NTSTATUS status;
4667
4668 if (tevent_req_is_nterror(req, &status)) {
4669 tevent_req_received(req);
4670 return status;
4671 }
4672
4673 /* Steal possbile out parameters to the callers context */
4674 talloc_steal(mem_ctx, state->out_mem_ctx);
4675
4676 /* Return result */
4677 *result = state->orig.out.result;
4678
4679 tevent_req_received(req);
4680 return NT_STATUS_OK;
4681}
4682
4683NTSTATUS 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)] */,
4687 WERROR *werror)
4688{
4689 struct netr_DsRGetSiteName r;
4690 NTSTATUS status;
4691
4692 /* In parameters */
4693 r.in.computer_name = computer_name;
4694
4695 status = cli->dispatch(cli,
4696 mem_ctx,
4697 &ndr_table_netlogon,
4698 NDR_NETR_DSRGETSITENAME,
4699 &r);
4700
4701 if (!NT_STATUS_IS_OK(status)) {
4702 return status;
4703 }
4704
4705 if (NT_STATUS_IS_ERR(status)) {
4706 return status;
4707 }
4708
4709 /* Return variables */
4710 *site = *r.out.site;
4711
4712 /* Return result */
4713 if (werror) {
4714 *werror = r.out.result;
4715 }
4716
4717 return werror_to_ntstatus(r.out.result);
4718}
4719
4720struct 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);
4725};
4726
4727static void rpccli_netr_LogonGetDomainInfo_done(struct tevent_req *subreq);
4728
4729struct 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)] */)
4739{
4740 struct tevent_req *req;
4741 struct rpccli_netr_LogonGetDomainInfo_state *state;
4742 struct tevent_req *subreq;
4743
4744 req = tevent_req_create(mem_ctx, &state,
4745 struct rpccli_netr_LogonGetDomainInfo_state);
4746 if (req == NULL) {
4747 return NULL;
4748 }
4749 state->out_mem_ctx = NULL;
4750 state->dispatch_recv = cli->dispatch_recv;
4751
4752 /* In parameters */
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;
4759
4760 /* Out parameters */
4761 state->orig.out.return_authenticator = _return_authenticator;
4762 state->orig.out.info = _info;
4763
4764 /* Result */
4765 ZERO_STRUCT(state->orig.out.result);
4766
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);
4771 }
4772
4773 /* make a temporary copy, that we pass to the dispatch function */
4774 state->tmp = state->orig;
4775
4776 subreq = cli->dispatch_send(state, ev, cli,
4777 &ndr_table_netlogon,
4778 NDR_NETR_LOGONGETDOMAININFO,
4779 &state->tmp);
4780 if (tevent_req_nomem(subreq, req)) {
4781 return tevent_req_post(req, ev);
4782 }
4783 tevent_req_set_callback(subreq, rpccli_netr_LogonGetDomainInfo_done, req);
4784 return req;
4785}
4786
4787static void rpccli_netr_LogonGetDomainInfo_done(struct tevent_req *subreq)
4788{
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);
4793 NTSTATUS status;
4794 TALLOC_CTX *mem_ctx;
4795
4796 if (state->out_mem_ctx) {
4797 mem_ctx = state->out_mem_ctx;
4798 } else {
4799 mem_ctx = state;
4800 }
4801
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);
4806 return;
4807 }
4808
4809 /* Copy out parameters */
4810 *state->orig.out.return_authenticator = *state->tmp.out.return_authenticator;
4811 *state->orig.out.info = *state->tmp.out.info;
4812
4813 /* Copy result */
4814 state->orig.out.result = state->tmp.out.result;
4815
4816 /* Reset temporary structure */
4817 ZERO_STRUCT(state->tmp);
4818
4819 tevent_req_done(req);
4820}
4821
4822NTSTATUS rpccli_netr_LogonGetDomainInfo_recv(struct tevent_req *req,
4823 TALLOC_CTX *mem_ctx,
4824 NTSTATUS *result)
4825{
4826 struct rpccli_netr_LogonGetDomainInfo_state *state = tevent_req_data(
4827 req, struct rpccli_netr_LogonGetDomainInfo_state);
4828 NTSTATUS status;
4829
4830 if (tevent_req_is_nterror(req, &status)) {
4831 tevent_req_received(req);
4832 return status;
4833 }
4834
4835 /* Steal possbile out parameters to the callers context */
4836 talloc_steal(mem_ctx, state->out_mem_ctx);
4837
4838 /* Return result */
4839 *result = state->orig.out.result;
4840
4841 tevent_req_received(req);
4842 return NT_STATUS_OK;
4843}
4844
4845NTSTATUS 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)] */)
4854{
4855 struct netr_LogonGetDomainInfo r;
4856 NTSTATUS status;
4857
4858 /* In parameters */
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;
4863 r.in.level = level;
4864 r.in.query = query;
4865
4866 status = cli->dispatch(cli,
4867 mem_ctx,
4868 &ndr_table_netlogon,
4869 NDR_NETR_LOGONGETDOMAININFO,
4870 &r);
4871
4872 if (!NT_STATUS_IS_OK(status)) {
4873 return status;
4874 }
4875
4876 if (NT_STATUS_IS_ERR(status)) {
4877 return status;
4878 }
4879
4880 /* Return variables */
4881 *return_authenticator = *r.out.return_authenticator;
4882 *info = *r.out.info;
4883
4884 /* Return result */
4885 return r.out.result;
4886}
4887
4888struct 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);
4893};
4894
4895static void rpccli_netr_ServerPasswordSet2_done(struct tevent_req *subreq);
4896
4897struct 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] */)
4907{
4908 struct tevent_req *req;
4909 struct rpccli_netr_ServerPasswordSet2_state *state;
4910 struct tevent_req *subreq;
4911
4912 req = tevent_req_create(mem_ctx, &state,
4913 struct rpccli_netr_ServerPasswordSet2_state);
4914 if (req == NULL) {
4915 return NULL;
4916 }
4917 state->out_mem_ctx = NULL;
4918 state->dispatch_recv = cli->dispatch_recv;
4919
4920 /* In parameters */
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;
4927
4928 /* Out parameters */
4929 state->orig.out.return_authenticator = _return_authenticator;
4930
4931 /* Result */
4932 ZERO_STRUCT(state->orig.out.result);
4933
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);
4938 }
4939
4940 /* make a temporary copy, that we pass to the dispatch function */
4941 state->tmp = state->orig;
4942
4943 subreq = cli->dispatch_send(state, ev, cli,
4944 &ndr_table_netlogon,
4945 NDR_NETR_SERVERPASSWORDSET2,
4946 &state->tmp);
4947 if (tevent_req_nomem(subreq, req)) {
4948 return tevent_req_post(req, ev);
4949 }
4950 tevent_req_set_callback(subreq, rpccli_netr_ServerPasswordSet2_done, req);
4951 return req;
4952}
4953
4954static void rpccli_netr_ServerPasswordSet2_done(struct tevent_req *subreq)
4955{
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);
4960 NTSTATUS status;
4961 TALLOC_CTX *mem_ctx;
4962
4963 if (state->out_mem_ctx) {
4964 mem_ctx = state->out_mem_ctx;
4965 } else {
4966 mem_ctx = state;
4967 }
4968
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);
4973 return;
4974 }
4975
4976 /* Copy out parameters */
4977 *state->orig.out.return_authenticator = *state->tmp.out.return_authenticator;
4978
4979 /* Copy result */
4980 state->orig.out.result = state->tmp.out.result;
4981
4982 /* Reset temporary structure */
4983 ZERO_STRUCT(state->tmp);
4984
4985 tevent_req_done(req);
4986}
4987
4988NTSTATUS rpccli_netr_ServerPasswordSet2_recv(struct tevent_req *req,
4989 TALLOC_CTX *mem_ctx,
4990 NTSTATUS *result)
4991{
4992 struct rpccli_netr_ServerPasswordSet2_state *state = tevent_req_data(
4993 req, struct rpccli_netr_ServerPasswordSet2_state);
4994 NTSTATUS status;
4995
4996 if (tevent_req_is_nterror(req, &status)) {
4997 tevent_req_received(req);
4998 return status;
4999 }
5000
5001 /* Steal possbile out parameters to the callers context */
5002 talloc_steal(mem_ctx, state->out_mem_ctx);
5003
5004 /* Return result */
5005 *result = state->orig.out.result;
5006
5007 tevent_req_received(req);
5008 return NT_STATUS_OK;
5009}
5010
5011NTSTATUS 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] */)
5020{
5021 struct netr_ServerPasswordSet2 r;
5022 NTSTATUS status;
5023
5024 /* In parameters */
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;
5031
5032 status = cli->dispatch(cli,
5033 mem_ctx,
5034 &ndr_table_netlogon,
5035 NDR_NETR_SERVERPASSWORDSET2,
5036 &r);
5037
5038 if (!NT_STATUS_IS_OK(status)) {
5039 return status;
5040 }
5041
5042 if (NT_STATUS_IS_ERR(status)) {
5043 return status;
5044 }
5045
5046 /* Return variables */
5047 *return_authenticator = *r.out.return_authenticator;
5048
5049 /* Return result */
5050 return r.out.result;
5051}
5052
5053struct 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);
5058};
5059
5060static void rpccli_netr_ServerPasswordGet_done(struct tevent_req *subreq);
5061
5062struct 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] */)
5072{
5073 struct tevent_req *req;
5074 struct rpccli_netr_ServerPasswordGet_state *state;
5075 struct tevent_req *subreq;
5076
5077 req = tevent_req_create(mem_ctx, &state,
5078 struct rpccli_netr_ServerPasswordGet_state);
5079 if (req == NULL) {
5080 return NULL;
5081 }
5082 state->out_mem_ctx = NULL;
5083 state->dispatch_recv = cli->dispatch_recv;
5084
5085 /* In parameters */
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;
5091
5092 /* Out parameters */
5093 state->orig.out.return_authenticator = _return_authenticator;
5094 state->orig.out.password = _password;
5095
5096 /* Result */
5097 ZERO_STRUCT(state->orig.out.result);
5098
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);
5103 }
5104
5105 /* make a temporary copy, that we pass to the dispatch function */
5106 state->tmp = state->orig;
5107
5108 subreq = cli->dispatch_send(state, ev, cli,
5109 &ndr_table_netlogon,
5110 NDR_NETR_SERVERPASSWORDGET,
5111 &state->tmp);
5112 if (tevent_req_nomem(subreq, req)) {
5113 return tevent_req_post(req, ev);
5114 }
5115 tevent_req_set_callback(subreq, rpccli_netr_ServerPasswordGet_done, req);
5116 return req;
5117}
5118
5119static void rpccli_netr_ServerPasswordGet_done(struct tevent_req *subreq)
5120{
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);
5125 NTSTATUS status;
5126 TALLOC_CTX *mem_ctx;
5127
5128 if (state->out_mem_ctx) {
5129 mem_ctx = state->out_mem_ctx;
5130 } else {
5131 mem_ctx = state;
5132 }
5133
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);
5138 return;
5139 }
5140
5141 /* Copy out parameters */
5142 *state->orig.out.return_authenticator = *state->tmp.out.return_authenticator;
5143 *state->orig.out.password = *state->tmp.out.password;
5144
5145 /* Copy result */
5146 state->orig.out.result = state->tmp.out.result;
5147
5148 /* Reset temporary structure */
5149 ZERO_STRUCT(state->tmp);
5150
5151 tevent_req_done(req);
5152}
5153
5154NTSTATUS rpccli_netr_ServerPasswordGet_recv(struct tevent_req *req,
5155 TALLOC_CTX *mem_ctx,
5156 WERROR *result)
5157{
5158 struct rpccli_netr_ServerPasswordGet_state *state = tevent_req_data(
5159 req, struct rpccli_netr_ServerPasswordGet_state);
5160 NTSTATUS status;
5161
5162 if (tevent_req_is_nterror(req, &status)) {
5163 tevent_req_received(req);
5164 return status;
5165 }
5166
5167 /* Steal possbile out parameters to the callers context */
5168 talloc_steal(mem_ctx, state->out_mem_ctx);
5169
5170 /* Return result */
5171 *result = state->orig.out.result;
5172
5173 tevent_req_received(req);
5174 return NT_STATUS_OK;
5175}
5176
5177NTSTATUS 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] */,
5186 WERROR *werror)
5187{
5188 struct netr_ServerPasswordGet r;
5189 NTSTATUS status;
5190
5191 /* In parameters */
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;
5197
5198 status = cli->dispatch(cli,
5199 mem_ctx,
5200 &ndr_table_netlogon,
5201 NDR_NETR_SERVERPASSWORDGET,
5202 &r);
5203
5204 if (!NT_STATUS_IS_OK(status)) {
5205 return status;
5206 }
5207
5208 if (NT_STATUS_IS_ERR(status)) {
5209 return status;
5210 }
5211
5212 /* Return variables */
5213 *return_authenticator = *r.out.return_authenticator;
5214 *password = *r.out.password;
5215
5216 /* Return result */
5217 if (werror) {
5218 *werror = r.out.result;
5219 }
5220
5221 return werror_to_ntstatus(r.out.result);
5222}
5223
5224struct 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);
5229};
5230
5231static void rpccli_netr_NETRLOGONSENDTOSAM_done(struct tevent_req *subreq);
5232
5233struct tevent_req *rpccli_netr_NETRLOGONSENDTOSAM_send(TALLOC_CTX *mem_ctx,
5234 struct tevent_context *ev,
5235 struct rpc_pipe_client *cli)
5236{
5237 struct tevent_req *req;
5238 struct rpccli_netr_NETRLOGONSENDTOSAM_state *state;
5239 struct tevent_req *subreq;
5240
5241 req = tevent_req_create(mem_ctx, &state,
5242 struct rpccli_netr_NETRLOGONSENDTOSAM_state);
5243 if (req == NULL) {
5244 return NULL;
5245 }
5246 state->out_mem_ctx = NULL;
5247 state->dispatch_recv = cli->dispatch_recv;
5248
5249 /* In parameters */
5250
5251 /* Out parameters */
5252
5253 /* Result */
5254 ZERO_STRUCT(state->orig.out.result);
5255
5256 /* make a temporary copy, that we pass to the dispatch function */
5257 state->tmp = state->orig;
5258
5259 subreq = cli->dispatch_send(state, ev, cli,
5260 &ndr_table_netlogon,
5261 NDR_NETR_NETRLOGONSENDTOSAM,
5262 &state->tmp);
5263 if (tevent_req_nomem(subreq, req)) {
5264 return tevent_req_post(req, ev);
5265 }
5266 tevent_req_set_callback(subreq, rpccli_netr_NETRLOGONSENDTOSAM_done, req);
5267 return req;
5268}
5269
5270static void rpccli_netr_NETRLOGONSENDTOSAM_done(struct tevent_req *subreq)
5271{
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);
5276 NTSTATUS status;
5277 TALLOC_CTX *mem_ctx;
5278
5279 if (state->out_mem_ctx) {
5280 mem_ctx = state->out_mem_ctx;
5281 } else {
5282 mem_ctx = state;
5283 }
5284
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);
5289 return;
5290 }
5291
5292 /* Copy out parameters */
5293
5294 /* Copy result */
5295 state->orig.out.result = state->tmp.out.result;
5296
5297 /* Reset temporary structure */
5298 ZERO_STRUCT(state->tmp);
5299
5300 tevent_req_done(req);
5301}
5302
5303NTSTATUS rpccli_netr_NETRLOGONSENDTOSAM_recv(struct tevent_req *req,
5304 TALLOC_CTX *mem_ctx,
5305 WERROR *result)
5306{
5307 struct rpccli_netr_NETRLOGONSENDTOSAM_state *state = tevent_req_data(
5308 req, struct rpccli_netr_NETRLOGONSENDTOSAM_state);
5309 NTSTATUS status;
5310
5311 if (tevent_req_is_nterror(req, &status)) {
5312 tevent_req_received(req);
5313 return status;
5314 }
5315
5316 /* Steal possbile out parameters to the callers context */
5317 talloc_steal(mem_ctx, state->out_mem_ctx);
5318
5319 /* Return result */
5320 *result = state->orig.out.result;
5321
5322 tevent_req_received(req);
5323 return NT_STATUS_OK;
5324}
5325
5326NTSTATUS rpccli_netr_NETRLOGONSENDTOSAM(struct rpc_pipe_client *cli,
5327 TALLOC_CTX *mem_ctx,
5328 WERROR *werror)
5329{
5330 struct netr_NETRLOGONSENDTOSAM r;
5331 NTSTATUS status;
5332
5333 /* In parameters */
5334
5335 status = cli->dispatch(cli,
5336 mem_ctx,
5337 &ndr_table_netlogon,
5338 NDR_NETR_NETRLOGONSENDTOSAM,
5339 &r);
5340
5341 if (!NT_STATUS_IS_OK(status)) {
5342 return status;
5343 }
5344
5345 if (NT_STATUS_IS_ERR(status)) {
5346 return status;
5347 }
5348
5349 /* Return variables */
5350
5351 /* Return result */
5352 if (werror) {
5353 *werror = r.out.result;
5354 }
5355
5356 return werror_to_ntstatus(r.out.result);
5357}
5358
5359struct 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);
5364};
5365
5366static void rpccli_netr_DsRAddressToSitenamesW_done(struct tevent_req *subreq);
5367
5368struct 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] */)
5375{
5376 struct tevent_req *req;
5377 struct rpccli_netr_DsRAddressToSitenamesW_state *state;
5378 struct tevent_req *subreq;
5379
5380 req = tevent_req_create(mem_ctx, &state,
5381 struct rpccli_netr_DsRAddressToSitenamesW_state);
5382 if (req == NULL) {
5383 return NULL;
5384 }
5385 state->out_mem_ctx = NULL;
5386 state->dispatch_recv = cli->dispatch_recv;
5387
5388 /* In parameters */
5389 state->orig.in.server_name = _server_name;
5390 state->orig.in.count = _count;
5391 state->orig.in.addresses = _addresses;
5392
5393 /* Out parameters */
5394 state->orig.out.ctr = _ctr;
5395
5396 /* Result */
5397 ZERO_STRUCT(state->orig.out.result);
5398
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);
5403 }
5404
5405 /* make a temporary copy, that we pass to the dispatch function */
5406 state->tmp = state->orig;
5407
5408 subreq = cli->dispatch_send(state, ev, cli,
5409 &ndr_table_netlogon,
5410 NDR_NETR_DSRADDRESSTOSITENAMESW,
5411 &state->tmp);
5412 if (tevent_req_nomem(subreq, req)) {
5413 return tevent_req_post(req, ev);
5414 }
5415 tevent_req_set_callback(subreq, rpccli_netr_DsRAddressToSitenamesW_done, req);
5416 return req;
5417}
5418
5419static void rpccli_netr_DsRAddressToSitenamesW_done(struct tevent_req *subreq)
5420{
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);
5425 NTSTATUS status;
5426 TALLOC_CTX *mem_ctx;
5427
5428 if (state->out_mem_ctx) {
5429 mem_ctx = state->out_mem_ctx;
5430 } else {
5431 mem_ctx = state;
5432 }
5433
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);
5438 return;
5439 }
5440
5441 /* Copy out parameters */
5442 *state->orig.out.ctr = *state->tmp.out.ctr;
5443
5444 /* Copy result */
5445 state->orig.out.result = state->tmp.out.result;
5446
5447 /* Reset temporary structure */
5448 ZERO_STRUCT(state->tmp);
5449
5450 tevent_req_done(req);
5451}
5452
5453NTSTATUS rpccli_netr_DsRAddressToSitenamesW_recv(struct tevent_req *req,
5454 TALLOC_CTX *mem_ctx,
5455 WERROR *result)
5456{
5457 struct rpccli_netr_DsRAddressToSitenamesW_state *state = tevent_req_data(
5458 req, struct rpccli_netr_DsRAddressToSitenamesW_state);
5459 NTSTATUS status;
5460
5461 if (tevent_req_is_nterror(req, &status)) {
5462 tevent_req_received(req);
5463 return status;
5464 }
5465
5466 /* Steal possbile out parameters to the callers context */
5467 talloc_steal(mem_ctx, state->out_mem_ctx);
5468
5469 /* Return result */
5470 *result = state->orig.out.result;
5471
5472 tevent_req_received(req);
5473 return NT_STATUS_OK;
5474}
5475
5476NTSTATUS 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] */,
5482 WERROR *werror)
5483{
5484 struct netr_DsRAddressToSitenamesW r;
5485 NTSTATUS status;
5486
5487 /* In parameters */
5488 r.in.server_name = server_name;
5489 r.in.count = count;
5490 r.in.addresses = addresses;
5491
5492 status = cli->dispatch(cli,
5493 mem_ctx,
5494 &ndr_table_netlogon,
5495 NDR_NETR_DSRADDRESSTOSITENAMESW,
5496 &r);
5497
5498 if (!NT_STATUS_IS_OK(status)) {
5499 return status;
5500 }
5501
5502 if (NT_STATUS_IS_ERR(status)) {
5503 return status;
5504 }
5505
5506 /* Return variables */
5507 *ctr = *r.out.ctr;
5508
5509 /* Return result */
5510 if (werror) {
5511 *werror = r.out.result;
5512 }
5513
5514 return werror_to_ntstatus(r.out.result);
5515}
5516
5517struct 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);
5522};
5523
5524static void rpccli_netr_DsRGetDCNameEx2_done(struct tevent_req *subreq);
5525
5526struct 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] */)
5537{
5538 struct tevent_req *req;
5539 struct rpccli_netr_DsRGetDCNameEx2_state *state;
5540 struct tevent_req *subreq;
5541
5542 req = tevent_req_create(mem_ctx, &state,
5543 struct rpccli_netr_DsRGetDCNameEx2_state);
5544 if (req == NULL) {
5545 return NULL;
5546 }
5547 state->out_mem_ctx = NULL;
5548 state->dispatch_recv = cli->dispatch_recv;
5549
5550 /* In parameters */
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;
5558
5559 /* Out parameters */
5560 state->orig.out.info = _info;
5561
5562 /* Result */
5563 ZERO_STRUCT(state->orig.out.result);
5564
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);
5569 }
5570
5571 /* make a temporary copy, that we pass to the dispatch function */
5572 state->tmp = state->orig;
5573
5574 subreq = cli->dispatch_send(state, ev, cli,
5575 &ndr_table_netlogon,
5576 NDR_NETR_DSRGETDCNAMEEX2,
5577 &state->tmp);
5578 if (tevent_req_nomem(subreq, req)) {
5579 return tevent_req_post(req, ev);
5580 }
5581 tevent_req_set_callback(subreq, rpccli_netr_DsRGetDCNameEx2_done, req);
5582 return req;
5583}
5584
5585static void rpccli_netr_DsRGetDCNameEx2_done(struct tevent_req *subreq)
5586{
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);
5591 NTSTATUS status;
5592 TALLOC_CTX *mem_ctx;
5593
5594 if (state->out_mem_ctx) {
5595 mem_ctx = state->out_mem_ctx;
5596 } else {
5597 mem_ctx = state;
5598 }
5599
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);
5604 return;
5605 }
5606
5607 /* Copy out parameters */
5608 *state->orig.out.info = *state->tmp.out.info;
5609
5610 /* Copy result */
5611 state->orig.out.result = state->tmp.out.result;
5612
5613 /* Reset temporary structure */
5614 ZERO_STRUCT(state->tmp);
5615
5616 tevent_req_done(req);
5617}
5618
5619NTSTATUS rpccli_netr_DsRGetDCNameEx2_recv(struct tevent_req *req,
5620 TALLOC_CTX *mem_ctx,
5621 WERROR *result)
5622{
5623 struct rpccli_netr_DsRGetDCNameEx2_state *state = tevent_req_data(
5624 req, struct rpccli_netr_DsRGetDCNameEx2_state);
5625 NTSTATUS status;
5626
5627 if (tevent_req_is_nterror(req, &status)) {
5628 tevent_req_received(req);
5629 return status;
5630 }
5631
5632 /* Steal possbile out parameters to the callers context */
5633 talloc_steal(mem_ctx, state->out_mem_ctx);
5634
5635 /* Return result */
5636 *result = state->orig.out.result;
5637
5638 tevent_req_received(req);
5639 return NT_STATUS_OK;
5640}
5641
5642NTSTATUS 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] */,
5652 WERROR *werror)
5653{
5654 struct netr_DsRGetDCNameEx2 r;
5655 NTSTATUS status;
5656
5657 /* In parameters */
5658 r.in.server_unc = server_unc;
5659 r.in.client_account = client_account;
5660 r.in.mask = mask;
5661 r.in.domain_name = domain_name;
5662 r.in.domain_guid = domain_guid;
5663 r.in.site_name = site_name;
5664 r.in.flags = flags;
5665
5666 status = cli->dispatch(cli,
5667 mem_ctx,
5668 &ndr_table_netlogon,
5669 NDR_NETR_DSRGETDCNAMEEX2,
5670 &r);
5671
5672 if (!NT_STATUS_IS_OK(status)) {
5673 return status;
5674 }
5675
5676 if (NT_STATUS_IS_ERR(status)) {
5677 return status;
5678 }
5679
5680 /* Return variables */
5681 *info = *r.out.info;
5682
5683 /* Return result */
5684 if (werror) {
5685 *werror = r.out.result;
5686 }
5687
5688 return werror_to_ntstatus(r.out.result);
5689}
5690
5691struct 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);
5696};
5697
5698static void rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done(struct tevent_req *subreq);
5699
5700struct tevent_req *rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_send(TALLOC_CTX *mem_ctx,
5701 struct tevent_context *ev,
5702 struct rpc_pipe_client *cli)
5703{
5704 struct tevent_req *req;
5705 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state *state;
5706 struct tevent_req *subreq;
5707
5708 req = tevent_req_create(mem_ctx, &state,
5709 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state);
5710 if (req == NULL) {
5711 return NULL;
5712 }
5713 state->out_mem_ctx = NULL;
5714 state->dispatch_recv = cli->dispatch_recv;
5715
5716 /* In parameters */
5717
5718 /* Out parameters */
5719
5720 /* Result */
5721 ZERO_STRUCT(state->orig.out.result);
5722
5723 /* make a temporary copy, that we pass to the dispatch function */
5724 state->tmp = state->orig;
5725
5726 subreq = cli->dispatch_send(state, ev, cli,
5727 &ndr_table_netlogon,
5728 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN,
5729 &state->tmp);
5730 if (tevent_req_nomem(subreq, req)) {
5731 return tevent_req_post(req, ev);
5732 }
5733 tevent_req_set_callback(subreq, rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done, req);
5734 return req;
5735}
5736
5737static void rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_done(struct tevent_req *subreq)
5738{
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);
5743 NTSTATUS status;
5744 TALLOC_CTX *mem_ctx;
5745
5746 if (state->out_mem_ctx) {
5747 mem_ctx = state->out_mem_ctx;
5748 } else {
5749 mem_ctx = state;
5750 }
5751
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);
5756 return;
5757 }
5758
5759 /* Copy out parameters */
5760
5761 /* Copy result */
5762 state->orig.out.result = state->tmp.out.result;
5763
5764 /* Reset temporary structure */
5765 ZERO_STRUCT(state->tmp);
5766
5767 tevent_req_done(req);
5768}
5769
5770NTSTATUS rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_recv(struct tevent_req *req,
5771 TALLOC_CTX *mem_ctx,
5772 WERROR *result)
5773{
5774 struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state *state = tevent_req_data(
5775 req, struct rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN_state);
5776 NTSTATUS status;
5777
5778 if (tevent_req_is_nterror(req, &status)) {
5779 tevent_req_received(req);
5780 return status;
5781 }
5782
5783 /* Steal possbile out parameters to the callers context */
5784 talloc_steal(mem_ctx, state->out_mem_ctx);
5785
5786 /* Return result */
5787 *result = state->orig.out.result;
5788
5789 tevent_req_received(req);
5790 return NT_STATUS_OK;
5791}
5792
5793NTSTATUS rpccli_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(struct rpc_pipe_client *cli,
5794 TALLOC_CTX *mem_ctx,
5795 WERROR *werror)
5796{
5797 struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN r;
5798 NTSTATUS status;
5799
5800 /* In parameters */
5801
5802 status = cli->dispatch(cli,
5803 mem_ctx,
5804 &ndr_table_netlogon,
5805 NDR_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN,
5806 &r);
5807
5808 if (!NT_STATUS_IS_OK(status)) {
5809 return status;
5810 }
5811
5812 if (NT_STATUS_IS_ERR(status)) {
5813 return status;
5814 }
5815
5816 /* Return variables */
5817
5818 /* Return result */
5819 if (werror) {
5820 *werror = r.out.result;
5821 }
5822
5823 return werror_to_ntstatus(r.out.result);
5824}
5825
5826struct 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);
5831};
5832
5833static void rpccli_netr_NetrEnumerateTrustedDomainsEx_done(struct tevent_req *subreq);
5834
5835struct 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] */)
5840{
5841 struct tevent_req *req;
5842 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state *state;
5843 struct tevent_req *subreq;
5844
5845 req = tevent_req_create(mem_ctx, &state,
5846 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state);
5847 if (req == NULL) {
5848 return NULL;
5849 }
5850 state->out_mem_ctx = NULL;
5851 state->dispatch_recv = cli->dispatch_recv;
5852
5853 /* In parameters */
5854 state->orig.in.server_name = _server_name;
5855
5856 /* Out parameters */
5857 state->orig.out.dom_trust_list = _dom_trust_list;
5858
5859 /* Result */
5860 ZERO_STRUCT(state->orig.out.result);
5861
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);
5866 }
5867
5868 /* make a temporary copy, that we pass to the dispatch function */
5869 state->tmp = state->orig;
5870
5871 subreq = cli->dispatch_send(state, ev, cli,
5872 &ndr_table_netlogon,
5873 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX,
5874 &state->tmp);
5875 if (tevent_req_nomem(subreq, req)) {
5876 return tevent_req_post(req, ev);
5877 }
5878 tevent_req_set_callback(subreq, rpccli_netr_NetrEnumerateTrustedDomainsEx_done, req);
5879 return req;
5880}
5881
5882static void rpccli_netr_NetrEnumerateTrustedDomainsEx_done(struct tevent_req *subreq)
5883{
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);
5888 NTSTATUS status;
5889 TALLOC_CTX *mem_ctx;
5890
5891 if (state->out_mem_ctx) {
5892 mem_ctx = state->out_mem_ctx;
5893 } else {
5894 mem_ctx = state;
5895 }
5896
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);
5901 return;
5902 }
5903
5904 /* Copy out parameters */
5905 *state->orig.out.dom_trust_list = *state->tmp.out.dom_trust_list;
5906
5907 /* Copy result */
5908 state->orig.out.result = state->tmp.out.result;
5909
5910 /* Reset temporary structure */
5911 ZERO_STRUCT(state->tmp);
5912
5913 tevent_req_done(req);
5914}
5915
5916NTSTATUS rpccli_netr_NetrEnumerateTrustedDomainsEx_recv(struct tevent_req *req,
5917 TALLOC_CTX *mem_ctx,
5918 WERROR *result)
5919{
5920 struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state *state = tevent_req_data(
5921 req, struct rpccli_netr_NetrEnumerateTrustedDomainsEx_state);
5922 NTSTATUS status;
5923
5924 if (tevent_req_is_nterror(req, &status)) {
5925 tevent_req_received(req);
5926 return status;
5927 }
5928
5929 /* Steal possbile out parameters to the callers context */
5930 talloc_steal(mem_ctx, state->out_mem_ctx);
5931
5932 /* Return result */
5933 *result = state->orig.out.result;
5934
5935 tevent_req_received(req);
5936 return NT_STATUS_OK;
5937}
5938
5939NTSTATUS 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] */,
5943 WERROR *werror)
5944{
5945 struct netr_NetrEnumerateTrustedDomainsEx r;
5946 NTSTATUS status;
5947
5948 /* In parameters */
5949 r.in.server_name = server_name;
5950
5951 status = cli->dispatch(cli,
5952 mem_ctx,
5953 &ndr_table_netlogon,
5954 NDR_NETR_NETRENUMERATETRUSTEDDOMAINSEX,
5955 &r);
5956
5957 if (!NT_STATUS_IS_OK(status)) {
5958 return status;
5959 }
5960
5961 if (NT_STATUS_IS_ERR(status)) {
5962 return status;
5963 }
5964
5965 /* Return variables */
5966 *dom_trust_list = *r.out.dom_trust_list;
5967
5968 /* Return result */
5969 if (werror) {
5970 *werror = r.out.result;
5971 }
5972
5973 return werror_to_ntstatus(r.out.result);
5974}
5975
5976struct 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);
5981};
5982
5983static void rpccli_netr_DsRAddressToSitenamesExW_done(struct tevent_req *subreq);
5984
5985struct 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] */)
5992{
5993 struct tevent_req *req;
5994 struct rpccli_netr_DsRAddressToSitenamesExW_state *state;
5995 struct tevent_req *subreq;
5996
5997 req = tevent_req_create(mem_ctx, &state,
5998 struct rpccli_netr_DsRAddressToSitenamesExW_state);
5999 if (req == NULL) {
6000 return NULL;
6001 }
6002 state->out_mem_ctx = NULL;
6003 state->dispatch_recv = cli->dispatch_recv;
6004
6005 /* In parameters */
6006 state->orig.in.server_name = _server_name;
6007 state->orig.in.count = _count;
6008 state->orig.in.addresses = _addresses;
6009
6010 /* Out parameters */
6011 state->orig.out.ctr = _ctr;
6012
6013 /* Result */
6014 ZERO_STRUCT(state->orig.out.result);
6015
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);
6020 }
6021
6022 /* make a temporary copy, that we pass to the dispatch function */
6023 state->tmp = state->orig;
6024
6025 subreq = cli->dispatch_send(state, ev, cli,
6026 &ndr_table_netlogon,
6027 NDR_NETR_DSRADDRESSTOSITENAMESEXW,
6028 &state->tmp);
6029 if (tevent_req_nomem(subreq, req)) {
6030 return tevent_req_post(req, ev);
6031 }
6032 tevent_req_set_callback(subreq, rpccli_netr_DsRAddressToSitenamesExW_done, req);
6033 return req;
6034}
6035
6036static void rpccli_netr_DsRAddressToSitenamesExW_done(struct tevent_req *subreq)
6037{
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);
6042 NTSTATUS status;
6043 TALLOC_CTX *mem_ctx;
6044
6045 if (state->out_mem_ctx) {
6046 mem_ctx = state->out_mem_ctx;
6047 } else {
6048 mem_ctx = state;
6049 }
6050
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);
6055 return;
6056 }
6057
6058 /* Copy out parameters */
6059 *state->orig.out.ctr = *state->tmp.out.ctr;
6060
6061 /* Copy result */
6062 state->orig.out.result = state->tmp.out.result;
6063
6064 /* Reset temporary structure */
6065 ZERO_STRUCT(state->tmp);
6066
6067 tevent_req_done(req);
6068}
6069
6070NTSTATUS rpccli_netr_DsRAddressToSitenamesExW_recv(struct tevent_req *req,
6071 TALLOC_CTX *mem_ctx,
6072 WERROR *result)
6073{
6074 struct rpccli_netr_DsRAddressToSitenamesExW_state *state = tevent_req_data(
6075 req, struct rpccli_netr_DsRAddressToSitenamesExW_state);
6076 NTSTATUS status;
6077
6078 if (tevent_req_is_nterror(req, &status)) {
6079 tevent_req_received(req);
6080 return status;
6081 }
6082
6083 /* Steal possbile out parameters to the callers context */
6084 talloc_steal(mem_ctx, state->out_mem_ctx);
6085
6086 /* Return result */
6087 *result = state->orig.out.result;
6088
6089 tevent_req_received(req);
6090 return NT_STATUS_OK;
6091}
6092
6093NTSTATUS 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] */,
6099 WERROR *werror)
6100{
6101 struct netr_DsRAddressToSitenamesExW r;
6102 NTSTATUS status;
6103
6104 /* In parameters */
6105 r.in.server_name = server_name;
6106 r.in.count = count;
6107 r.in.addresses = addresses;
6108
6109 status = cli->dispatch(cli,
6110 mem_ctx,
6111 &ndr_table_netlogon,
6112 NDR_NETR_DSRADDRESSTOSITENAMESEXW,
6113 &r);
6114
6115 if (!NT_STATUS_IS_OK(status)) {
6116 return status;
6117 }
6118
6119 if (NT_STATUS_IS_ERR(status)) {
6120 return status;
6121 }
6122
6123 /* Return variables */
6124 *ctr = *r.out.ctr;
6125
6126 /* Return result */
6127 if (werror) {
6128 *werror = r.out.result;
6129 }
6130
6131 return werror_to_ntstatus(r.out.result);
6132}
6133
6134struct 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);
6139};
6140
6141static void rpccli_netr_DsrGetDcSiteCoverageW_done(struct tevent_req *subreq);
6142
6143struct 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] */)
6148{
6149 struct tevent_req *req;
6150 struct rpccli_netr_DsrGetDcSiteCoverageW_state *state;
6151 struct tevent_req *subreq;
6152
6153 req = tevent_req_create(mem_ctx, &state,
6154 struct rpccli_netr_DsrGetDcSiteCoverageW_state);
6155 if (req == NULL) {
6156 return NULL;
6157 }
6158 state->out_mem_ctx = NULL;
6159 state->dispatch_recv = cli->dispatch_recv;
6160
6161 /* In parameters */
6162 state->orig.in.server_name = _server_name;
6163
6164 /* Out parameters */
6165 state->orig.out.ctr = _ctr;
6166
6167 /* Result */
6168 ZERO_STRUCT(state->orig.out.result);
6169
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);
6174 }
6175
6176 /* make a temporary copy, that we pass to the dispatch function */
6177 state->tmp = state->orig;
6178
6179 subreq = cli->dispatch_send(state, ev, cli,
6180 &ndr_table_netlogon,
6181 NDR_NETR_DSRGETDCSITECOVERAGEW,
6182 &state->tmp);
6183 if (tevent_req_nomem(subreq, req)) {
6184 return tevent_req_post(req, ev);
6185 }
6186 tevent_req_set_callback(subreq, rpccli_netr_DsrGetDcSiteCoverageW_done, req);
6187 return req;
6188}
6189
6190static void rpccli_netr_DsrGetDcSiteCoverageW_done(struct tevent_req *subreq)
6191{
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);
6196 NTSTATUS status;
6197 TALLOC_CTX *mem_ctx;
6198
6199 if (state->out_mem_ctx) {
6200 mem_ctx = state->out_mem_ctx;
6201 } else {
6202 mem_ctx = state;
6203 }
6204
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);
6209 return;
6210 }
6211
6212 /* Copy out parameters */
6213 *state->orig.out.ctr = *state->tmp.out.ctr;
6214
6215 /* Copy result */
6216 state->orig.out.result = state->tmp.out.result;
6217
6218 /* Reset temporary structure */
6219 ZERO_STRUCT(state->tmp);
6220
6221 tevent_req_done(req);
6222}
6223
6224NTSTATUS rpccli_netr_DsrGetDcSiteCoverageW_recv(struct tevent_req *req,
6225 TALLOC_CTX *mem_ctx,
6226 WERROR *result)
6227{
6228 struct rpccli_netr_DsrGetDcSiteCoverageW_state *state = tevent_req_data(
6229 req, struct rpccli_netr_DsrGetDcSiteCoverageW_state);
6230 NTSTATUS status;
6231
6232 if (tevent_req_is_nterror(req, &status)) {
6233 tevent_req_received(req);
6234 return status;
6235 }
6236
6237 /* Steal possbile out parameters to the callers context */
6238 talloc_steal(mem_ctx, state->out_mem_ctx);
6239
6240 /* Return result */
6241 *result = state->orig.out.result;
6242
6243 tevent_req_received(req);
6244 return NT_STATUS_OK;
6245}
6246
6247NTSTATUS 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] */,
6251 WERROR *werror)
6252{
6253 struct netr_DsrGetDcSiteCoverageW r;
6254 NTSTATUS status;
6255
6256 /* In parameters */
6257 r.in.server_name = server_name;
6258
6259 status = cli->dispatch(cli,
6260 mem_ctx,
6261 &ndr_table_netlogon,
6262 NDR_NETR_DSRGETDCSITECOVERAGEW,
6263 &r);
6264
6265 if (!NT_STATUS_IS_OK(status)) {
6266 return status;
6267 }
6268
6269 if (NT_STATUS_IS_ERR(status)) {
6270 return status;
6271 }
6272
6273 /* Return variables */
6274 *ctr = *r.out.ctr;
6275
6276 /* Return result */
6277 if (werror) {
6278 *werror = r.out.result;
6279 }
6280
6281 return werror_to_ntstatus(r.out.result);
6282}
6283
6284struct 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);
6289};
6290
6291static void rpccli_netr_LogonSamLogonEx_done(struct tevent_req *subreq);
6292
6293struct 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] */)
6304{
6305 struct tevent_req *req;
6306 struct rpccli_netr_LogonSamLogonEx_state *state;
6307 struct tevent_req *subreq;
6308
6309 req = tevent_req_create(mem_ctx, &state,
6310 struct rpccli_netr_LogonSamLogonEx_state);
6311 if (req == NULL) {
6312 return NULL;
6313 }
6314 state->out_mem_ctx = NULL;
6315 state->dispatch_recv = cli->dispatch_recv;
6316
6317 /* In parameters */
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;
6324
6325 /* Out parameters */
6326 state->orig.out.validation = _validation;
6327 state->orig.out.authoritative = _authoritative;
6328 state->orig.out.flags = _flags;
6329
6330 /* Result */
6331 ZERO_STRUCT(state->orig.out.result);
6332
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);
6337 }
6338
6339 /* make a temporary copy, that we pass to the dispatch function */
6340 state->tmp = state->orig;
6341
6342 subreq = cli->dispatch_send(state, ev, cli,
6343 &ndr_table_netlogon,
6344 NDR_NETR_LOGONSAMLOGONEX,
6345 &state->tmp);
6346 if (tevent_req_nomem(subreq, req)) {
6347 return tevent_req_post(req, ev);
6348 }
6349 tevent_req_set_callback(subreq, rpccli_netr_LogonSamLogonEx_done, req);
6350 return req;
6351}
6352
6353static void rpccli_netr_LogonSamLogonEx_done(struct tevent_req *subreq)
6354{
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);
6359 NTSTATUS status;
6360 TALLOC_CTX *mem_ctx;
6361
6362 if (state->out_mem_ctx) {
6363 mem_ctx = state->out_mem_ctx;
6364 } else {
6365 mem_ctx = state;
6366 }
6367
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);
6372 return;
6373 }
6374
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;
6379
6380 /* Copy result */
6381 state->orig.out.result = state->tmp.out.result;
6382
6383 /* Reset temporary structure */
6384 ZERO_STRUCT(state->tmp);
6385
6386 tevent_req_done(req);
6387}
6388
6389NTSTATUS rpccli_netr_LogonSamLogonEx_recv(struct tevent_req *req,
6390 TALLOC_CTX *mem_ctx,
6391 NTSTATUS *result)
6392{
6393 struct rpccli_netr_LogonSamLogonEx_state *state = tevent_req_data(
6394 req, struct rpccli_netr_LogonSamLogonEx_state);
6395 NTSTATUS status;
6396
6397 if (tevent_req_is_nterror(req, &status)) {
6398 tevent_req_received(req);
6399 return status;
6400 }
6401
6402 /* Steal possbile out parameters to the callers context */
6403 talloc_steal(mem_ctx, state->out_mem_ctx);
6404
6405 /* Return result */
6406 *result = state->orig.out.result;
6407
6408 tevent_req_received(req);
6409 return NT_STATUS_OK;
6410}
6411
6412NTSTATUS 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] */)
6422{
6423 struct netr_LogonSamLogonEx r;
6424 NTSTATUS status;
6425
6426 /* In parameters */
6427 r.in.server_name = server_name;
6428 r.in.computer_name = computer_name;
6429 r.in.logon_level = logon_level;
6430 r.in.logon = logon;
6431 r.in.validation_level = validation_level;
6432 r.in.flags = flags;
6433
6434 status = cli->dispatch(cli,
6435 mem_ctx,
6436 &ndr_table_netlogon,
6437 NDR_NETR_LOGONSAMLOGONEX,
6438 &r);
6439
6440 if (!NT_STATUS_IS_OK(status)) {
6441 return status;
6442 }
6443
6444 if (NT_STATUS_IS_ERR(status)) {
6445 return status;
6446 }
6447
6448 /* Return variables */
6449 *validation = *r.out.validation;
6450 *authoritative = *r.out.authoritative;
6451 *flags = *r.out.flags;
6452
6453 /* Return result */
6454 return r.out.result;
6455}
6456
6457struct 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);
6462};
6463
6464static void rpccli_netr_DsrEnumerateDomainTrusts_done(struct tevent_req *subreq);
6465
6466struct 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] */)
6472{
6473 struct tevent_req *req;
6474 struct rpccli_netr_DsrEnumerateDomainTrusts_state *state;
6475 struct tevent_req *subreq;
6476
6477 req = tevent_req_create(mem_ctx, &state,
6478 struct rpccli_netr_DsrEnumerateDomainTrusts_state);
6479 if (req == NULL) {
6480 return NULL;
6481 }
6482 state->out_mem_ctx = NULL;
6483 state->dispatch_recv = cli->dispatch_recv;
6484
6485 /* In parameters */
6486 state->orig.in.server_name = _server_name;
6487 state->orig.in.trust_flags = _trust_flags;
6488
6489 /* Out parameters */
6490 state->orig.out.trusts = _trusts;
6491
6492 /* Result */
6493 ZERO_STRUCT(state->orig.out.result);
6494
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);
6499 }
6500
6501 /* make a temporary copy, that we pass to the dispatch function */
6502 state->tmp = state->orig;
6503
6504 subreq = cli->dispatch_send(state, ev, cli,
6505 &ndr_table_netlogon,
6506 NDR_NETR_DSRENUMERATEDOMAINTRUSTS,
6507 &state->tmp);
6508 if (tevent_req_nomem(subreq, req)) {
6509 return tevent_req_post(req, ev);
6510 }
6511 tevent_req_set_callback(subreq, rpccli_netr_DsrEnumerateDomainTrusts_done, req);
6512 return req;
6513}
6514
6515static void rpccli_netr_DsrEnumerateDomainTrusts_done(struct tevent_req *subreq)
6516{
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);
6521 NTSTATUS status;
6522 TALLOC_CTX *mem_ctx;
6523
6524 if (state->out_mem_ctx) {
6525 mem_ctx = state->out_mem_ctx;
6526 } else {
6527 mem_ctx = state;
6528 }
6529
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);
6534 return;
6535 }
6536
6537 /* Copy out parameters */
6538 *state->orig.out.trusts = *state->tmp.out.trusts;
6539
6540 /* Copy result */
6541 state->orig.out.result = state->tmp.out.result;
6542
6543 /* Reset temporary structure */
6544 ZERO_STRUCT(state->tmp);
6545
6546 tevent_req_done(req);
6547}
6548
6549NTSTATUS rpccli_netr_DsrEnumerateDomainTrusts_recv(struct tevent_req *req,
6550 TALLOC_CTX *mem_ctx,
6551 WERROR *result)
6552{
6553 struct rpccli_netr_DsrEnumerateDomainTrusts_state *state = tevent_req_data(
6554 req, struct rpccli_netr_DsrEnumerateDomainTrusts_state);
6555 NTSTATUS status;
6556
6557 if (tevent_req_is_nterror(req, &status)) {
6558 tevent_req_received(req);
6559 return status;
6560 }
6561
6562 /* Steal possbile out parameters to the callers context */
6563 talloc_steal(mem_ctx, state->out_mem_ctx);
6564
6565 /* Return result */
6566 *result = state->orig.out.result;
6567
6568 tevent_req_received(req);
6569 return NT_STATUS_OK;
6570}
6571
6572NTSTATUS 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] */,
6577 WERROR *werror)
6578{
6579 struct netr_DsrEnumerateDomainTrusts r;
6580 NTSTATUS status;
6581
6582 /* In parameters */
6583 r.in.server_name = server_name;
6584 r.in.trust_flags = trust_flags;
6585
6586 status = cli->dispatch(cli,
6587 mem_ctx,
6588 &ndr_table_netlogon,
6589 NDR_NETR_DSRENUMERATEDOMAINTRUSTS,
6590 &r);
6591
6592 if (!NT_STATUS_IS_OK(status)) {
6593 return status;
6594 }
6595
6596 if (NT_STATUS_IS_ERR(status)) {
6597 return status;
6598 }
6599
6600 /* Return variables */
6601 *trusts = *r.out.trusts;
6602
6603 /* Return result */
6604 if (werror) {
6605 *werror = r.out.result;
6606 }
6607
6608 return werror_to_ntstatus(r.out.result);
6609}
6610
6611struct 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);
6616};
6617
6618static void rpccli_netr_DsrDeregisterDNSHostRecords_done(struct tevent_req *subreq);
6619
6620struct 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)] */)
6628{
6629 struct tevent_req *req;
6630 struct rpccli_netr_DsrDeregisterDNSHostRecords_state *state;
6631 struct tevent_req *subreq;
6632
6633 req = tevent_req_create(mem_ctx, &state,
6634 struct rpccli_netr_DsrDeregisterDNSHostRecords_state);
6635 if (req == NULL) {
6636 return NULL;
6637 }
6638 state->out_mem_ctx = NULL;
6639 state->dispatch_recv = cli->dispatch_recv;
6640
6641 /* In parameters */
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;
6647
6648 /* Out parameters */
6649
6650 /* Result */
6651 ZERO_STRUCT(state->orig.out.result);
6652
6653 /* make a temporary copy, that we pass to the dispatch function */
6654 state->tmp = state->orig;
6655
6656 subreq = cli->dispatch_send(state, ev, cli,
6657 &ndr_table_netlogon,
6658 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS,
6659 &state->tmp);
6660 if (tevent_req_nomem(subreq, req)) {
6661 return tevent_req_post(req, ev);
6662 }
6663 tevent_req_set_callback(subreq, rpccli_netr_DsrDeregisterDNSHostRecords_done, req);
6664 return req;
6665}
6666
6667static void rpccli_netr_DsrDeregisterDNSHostRecords_done(struct tevent_req *subreq)
6668{
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);
6673 NTSTATUS status;
6674 TALLOC_CTX *mem_ctx;
6675
6676 if (state->out_mem_ctx) {
6677 mem_ctx = state->out_mem_ctx;
6678 } else {
6679 mem_ctx = state;
6680 }
6681
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);
6686 return;
6687 }
6688
6689 /* Copy out parameters */
6690
6691 /* Copy result */
6692 state->orig.out.result = state->tmp.out.result;
6693
6694 /* Reset temporary structure */
6695 ZERO_STRUCT(state->tmp);
6696
6697 tevent_req_done(req);
6698}
6699
6700NTSTATUS rpccli_netr_DsrDeregisterDNSHostRecords_recv(struct tevent_req *req,
6701 TALLOC_CTX *mem_ctx,
6702 WERROR *result)
6703{
6704 struct rpccli_netr_DsrDeregisterDNSHostRecords_state *state = tevent_req_data(
6705 req, struct rpccli_netr_DsrDeregisterDNSHostRecords_state);
6706 NTSTATUS status;
6707
6708 if (tevent_req_is_nterror(req, &status)) {
6709 tevent_req_received(req);
6710 return status;
6711 }
6712
6713 /* Steal possbile out parameters to the callers context */
6714 talloc_steal(mem_ctx, state->out_mem_ctx);
6715
6716 /* Return result */
6717 *result = state->orig.out.result;
6718
6719 tevent_req_received(req);
6720 return NT_STATUS_OK;
6721}
6722
6723NTSTATUS 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)] */,
6730 WERROR *werror)
6731{
6732 struct netr_DsrDeregisterDNSHostRecords r;
6733 NTSTATUS status;
6734
6735 /* In parameters */
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;
6741
6742 status = cli->dispatch(cli,
6743 mem_ctx,
6744 &ndr_table_netlogon,
6745 NDR_NETR_DSRDEREGISTERDNSHOSTRECORDS,
6746 &r);
6747
6748 if (!NT_STATUS_IS_OK(status)) {
6749 return status;
6750 }
6751
6752 if (NT_STATUS_IS_ERR(status)) {
6753 return status;
6754 }
6755
6756 /* Return variables */
6757
6758 /* Return result */
6759 if (werror) {
6760 *werror = r.out.result;
6761 }
6762
6763 return werror_to_ntstatus(r.out.result);
6764}
6765
6766struct 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);
6771};
6772
6773static void rpccli_netr_ServerTrustPasswordsGet_done(struct tevent_req *subreq);
6774
6775struct 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] */)
6786{
6787 struct tevent_req *req;
6788 struct rpccli_netr_ServerTrustPasswordsGet_state *state;
6789 struct tevent_req *subreq;
6790
6791 req = tevent_req_create(mem_ctx, &state,
6792 struct rpccli_netr_ServerTrustPasswordsGet_state);
6793 if (req == NULL) {
6794 return NULL;
6795 }
6796 state->out_mem_ctx = NULL;
6797 state->dispatch_recv = cli->dispatch_recv;
6798
6799 /* In parameters */
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;
6805
6806 /* Out parameters */
6807 state->orig.out.return_authenticator = _return_authenticator;
6808 state->orig.out.password = _password;
6809 state->orig.out.password2 = _password2;
6810
6811 /* Result */
6812 ZERO_STRUCT(state->orig.out.result);
6813
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);
6818 }
6819
6820 /* make a temporary copy, that we pass to the dispatch function */
6821 state->tmp = state->orig;
6822
6823 subreq = cli->dispatch_send(state, ev, cli,
6824 &ndr_table_netlogon,
6825 NDR_NETR_SERVERTRUSTPASSWORDSGET,
6826 &state->tmp);
6827 if (tevent_req_nomem(subreq, req)) {
6828 return tevent_req_post(req, ev);
6829 }
6830 tevent_req_set_callback(subreq, rpccli_netr_ServerTrustPasswordsGet_done, req);
6831 return req;
6832}
6833
6834static void rpccli_netr_ServerTrustPasswordsGet_done(struct tevent_req *subreq)
6835{
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);
6840 NTSTATUS status;
6841 TALLOC_CTX *mem_ctx;
6842
6843 if (state->out_mem_ctx) {
6844 mem_ctx = state->out_mem_ctx;
6845 } else {
6846 mem_ctx = state;
6847 }
6848
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);
6853 return;
6854 }
6855
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;
6860
6861 /* Copy result */
6862 state->orig.out.result = state->tmp.out.result;
6863
6864 /* Reset temporary structure */
6865 ZERO_STRUCT(state->tmp);
6866
6867 tevent_req_done(req);
6868}
6869
6870NTSTATUS rpccli_netr_ServerTrustPasswordsGet_recv(struct tevent_req *req,
6871 TALLOC_CTX *mem_ctx,
6872 NTSTATUS *result)
6873{
6874 struct rpccli_netr_ServerTrustPasswordsGet_state *state = tevent_req_data(
6875 req, struct rpccli_netr_ServerTrustPasswordsGet_state);
6876 NTSTATUS status;
6877
6878 if (tevent_req_is_nterror(req, &status)) {
6879 tevent_req_received(req);
6880 return status;
6881 }
6882
6883 /* Steal possbile out parameters to the callers context */
6884 talloc_steal(mem_ctx, state->out_mem_ctx);
6885
6886 /* Return result */
6887 *result = state->orig.out.result;
6888
6889 tevent_req_received(req);
6890 return NT_STATUS_OK;
6891}
6892
6893NTSTATUS 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] */)
6903{
6904 struct netr_ServerTrustPasswordsGet r;
6905 NTSTATUS status;
6906
6907 /* In parameters */
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;
6913
6914 status = cli->dispatch(cli,
6915 mem_ctx,
6916 &ndr_table_netlogon,
6917 NDR_NETR_SERVERTRUSTPASSWORDSGET,
6918 &r);
6919
6920 if (!NT_STATUS_IS_OK(status)) {
6921 return status;
6922 }
6923
6924 if (NT_STATUS_IS_ERR(status)) {
6925 return status;
6926 }
6927
6928 /* Return variables */
6929 *return_authenticator = *r.out.return_authenticator;
6930 *password = *r.out.password;
6931 *password2 = *r.out.password2;
6932
6933 /* Return result */
6934 return r.out.result;
6935}
6936
6937struct 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);
6942};
6943
6944static void rpccli_netr_DsRGetForestTrustInformation_done(struct tevent_req *subreq);
6945
6946struct 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] */)
6953{
6954 struct tevent_req *req;
6955 struct rpccli_netr_DsRGetForestTrustInformation_state *state;
6956 struct tevent_req *subreq;
6957
6958 req = tevent_req_create(mem_ctx, &state,
6959 struct rpccli_netr_DsRGetForestTrustInformation_state);
6960 if (req == NULL) {
6961 return NULL;
6962 }
6963 state->out_mem_ctx = NULL;
6964 state->dispatch_recv = cli->dispatch_recv;
6965
6966 /* In parameters */
6967 state->orig.in.server_name = _server_name;
6968 state->orig.in.trusted_domain_name = _trusted_domain_name;
6969 state->orig.in.flags = _flags;
6970
6971 /* Out parameters */
6972 state->orig.out.forest_trust_info = _forest_trust_info;
6973
6974 /* Result */
6975 ZERO_STRUCT(state->orig.out.result);
6976
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);
6981 }
6982
6983 /* make a temporary copy, that we pass to the dispatch function */
6984 state->tmp = state->orig;
6985
6986 subreq = cli->dispatch_send(state, ev, cli,
6987 &ndr_table_netlogon,
6988 NDR_NETR_DSRGETFORESTTRUSTINFORMATION,
6989 &state->tmp);
6990 if (tevent_req_nomem(subreq, req)) {
6991 return tevent_req_post(req, ev);
6992 }
6993 tevent_req_set_callback(subreq, rpccli_netr_DsRGetForestTrustInformation_done, req);
6994 return req;
6995}
6996
6997static void rpccli_netr_DsRGetForestTrustInformation_done(struct tevent_req *subreq)
6998{
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);
7003 NTSTATUS status;
7004 TALLOC_CTX *mem_ctx;
7005
7006 if (state->out_mem_ctx) {
7007 mem_ctx = state->out_mem_ctx;
7008 } else {
7009 mem_ctx = state;
7010 }
7011
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);
7016 return;
7017 }
7018
7019 /* Copy out parameters */
7020 *state->orig.out.forest_trust_info = *state->tmp.out.forest_trust_info;
7021
7022 /* Copy result */
7023 state->orig.out.result = state->tmp.out.result;
7024
7025 /* Reset temporary structure */
7026 ZERO_STRUCT(state->tmp);
7027
7028 tevent_req_done(req);
7029}
7030
7031NTSTATUS rpccli_netr_DsRGetForestTrustInformation_recv(struct tevent_req *req,
7032 TALLOC_CTX *mem_ctx,
7033 WERROR *result)
7034{
7035 struct rpccli_netr_DsRGetForestTrustInformation_state *state = tevent_req_data(
7036 req, struct rpccli_netr_DsRGetForestTrustInformation_state);
7037 NTSTATUS status;
7038
7039 if (tevent_req_is_nterror(req, &status)) {
7040 tevent_req_received(req);
7041 return status;
7042 }
7043
7044 /* Steal possbile out parameters to the callers context */
7045 talloc_steal(mem_ctx, state->out_mem_ctx);
7046
7047 /* Return result */
7048 *result = state->orig.out.result;
7049
7050 tevent_req_received(req);
7051 return NT_STATUS_OK;
7052}
7053
7054NTSTATUS 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] */,
7060 WERROR *werror)
7061{
7062 struct netr_DsRGetForestTrustInformation r;
7063 NTSTATUS status;
7064
7065 /* In parameters */
7066 r.in.server_name = server_name;
7067 r.in.trusted_domain_name = trusted_domain_name;
7068 r.in.flags = flags;
7069
7070 status = cli->dispatch(cli,
7071 mem_ctx,
7072 &ndr_table_netlogon,
7073 NDR_NETR_DSRGETFORESTTRUSTINFORMATION,
7074 &r);
7075
7076 if (!NT_STATUS_IS_OK(status)) {
7077 return status;
7078 }
7079
7080 if (NT_STATUS_IS_ERR(status)) {
7081 return status;
7082 }
7083
7084 /* Return variables */
7085 *forest_trust_info = *r.out.forest_trust_info;
7086
7087 /* Return result */
7088 if (werror) {
7089 *werror = r.out.result;
7090 }
7091
7092 return werror_to_ntstatus(r.out.result);
7093}
7094
7095struct 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);
7100};
7101
7102static void rpccli_netr_GetForestTrustInformation_done(struct tevent_req *subreq);
7103
7104struct 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] */)
7113{
7114 struct tevent_req *req;
7115 struct rpccli_netr_GetForestTrustInformation_state *state;
7116 struct tevent_req *subreq;
7117
7118 req = tevent_req_create(mem_ctx, &state,
7119 struct rpccli_netr_GetForestTrustInformation_state);
7120 if (req == NULL) {
7121 return NULL;
7122 }
7123 state->out_mem_ctx = NULL;
7124 state->dispatch_recv = cli->dispatch_recv;
7125
7126 /* In parameters */
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;
7131
7132 /* Out parameters */
7133 state->orig.out.return_authenticator = _return_authenticator;
7134 state->orig.out.forest_trust_info = _forest_trust_info;
7135
7136 /* Result */
7137 ZERO_STRUCT(state->orig.out.result);
7138
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);
7143 }
7144
7145 /* make a temporary copy, that we pass to the dispatch function */
7146 state->tmp = state->orig;
7147
7148 subreq = cli->dispatch_send(state, ev, cli,
7149 &ndr_table_netlogon,
7150 NDR_NETR_GETFORESTTRUSTINFORMATION,
7151 &state->tmp);
7152 if (tevent_req_nomem(subreq, req)) {
7153 return tevent_req_post(req, ev);
7154 }
7155 tevent_req_set_callback(subreq, rpccli_netr_GetForestTrustInformation_done, req);
7156 return req;
7157}
7158
7159static void rpccli_netr_GetForestTrustInformation_done(struct tevent_req *subreq)
7160{
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);
7165 NTSTATUS status;
7166 TALLOC_CTX *mem_ctx;
7167
7168 if (state->out_mem_ctx) {
7169 mem_ctx = state->out_mem_ctx;
7170 } else {
7171 mem_ctx = state;
7172 }
7173
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);
7178 return;
7179 }
7180
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;
7184
7185 /* Copy result */
7186 state->orig.out.result = state->tmp.out.result;
7187
7188 /* Reset temporary structure */
7189 ZERO_STRUCT(state->tmp);
7190
7191 tevent_req_done(req);
7192}
7193
7194NTSTATUS rpccli_netr_GetForestTrustInformation_recv(struct tevent_req *req,
7195 TALLOC_CTX *mem_ctx,
7196 WERROR *result)
7197{
7198 struct rpccli_netr_GetForestTrustInformation_state *state = tevent_req_data(
7199 req, struct rpccli_netr_GetForestTrustInformation_state);
7200 NTSTATUS status;
7201
7202 if (tevent_req_is_nterror(req, &status)) {
7203 tevent_req_received(req);
7204 return status;
7205 }
7206
7207 /* Steal possbile out parameters to the callers context */
7208 talloc_steal(mem_ctx, state->out_mem_ctx);
7209
7210 /* Return result */
7211 *result = state->orig.out.result;
7212
7213 tevent_req_received(req);
7214 return NT_STATUS_OK;
7215}
7216
7217NTSTATUS 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] */,
7225 WERROR *werror)
7226{
7227 struct netr_GetForestTrustInformation r;
7228 NTSTATUS status;
7229
7230 /* In parameters */
7231 r.in.server_name = server_name;
7232 r.in.trusted_domain_name = trusted_domain_name;
7233 r.in.credential = credential;
7234 r.in.flags = flags;
7235
7236 status = cli->dispatch(cli,
7237 mem_ctx,
7238 &ndr_table_netlogon,
7239 NDR_NETR_GETFORESTTRUSTINFORMATION,
7240 &r);
7241
7242 if (!NT_STATUS_IS_OK(status)) {
7243 return status;
7244 }
7245
7246 if (NT_STATUS_IS_ERR(status)) {
7247 return status;
7248 }
7249
7250 /* Return variables */
7251 *return_authenticator = *r.out.return_authenticator;
7252 *forest_trust_info = *r.out.forest_trust_info;
7253
7254 /* Return result */
7255 if (werror) {
7256 *werror = r.out.result;
7257 }
7258
7259 return werror_to_ntstatus(r.out.result);
7260}
7261
7262struct 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);
7267};
7268
7269static void rpccli_netr_LogonSamLogonWithFlags_done(struct tevent_req *subreq);
7270
7271struct 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] */)
7284{
7285 struct tevent_req *req;
7286 struct rpccli_netr_LogonSamLogonWithFlags_state *state;
7287 struct tevent_req *subreq;
7288
7289 req = tevent_req_create(mem_ctx, &state,
7290 struct rpccli_netr_LogonSamLogonWithFlags_state);
7291 if (req == NULL) {
7292 return NULL;
7293 }
7294 state->out_mem_ctx = NULL;
7295 state->dispatch_recv = cli->dispatch_recv;
7296
7297 /* In parameters */
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;
7306
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;
7312
7313 /* Result */
7314 ZERO_STRUCT(state->orig.out.result);
7315
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);
7320 }
7321
7322 /* make a temporary copy, that we pass to the dispatch function */
7323 state->tmp = state->orig;
7324
7325 subreq = cli->dispatch_send(state, ev, cli,
7326 &ndr_table_netlogon,
7327 NDR_NETR_LOGONSAMLOGONWITHFLAGS,
7328 &state->tmp);
7329 if (tevent_req_nomem(subreq, req)) {
7330 return tevent_req_post(req, ev);
7331 }
7332 tevent_req_set_callback(subreq, rpccli_netr_LogonSamLogonWithFlags_done, req);
7333 return req;
7334}
7335
7336static void rpccli_netr_LogonSamLogonWithFlags_done(struct tevent_req *subreq)
7337{
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);
7342 NTSTATUS status;
7343 TALLOC_CTX *mem_ctx;
7344
7345 if (state->out_mem_ctx) {
7346 mem_ctx = state->out_mem_ctx;
7347 } else {
7348 mem_ctx = state;
7349 }
7350
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);
7355 return;
7356 }
7357
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;
7361 }
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;
7365
7366 /* Copy result */
7367 state->orig.out.result = state->tmp.out.result;
7368
7369 /* Reset temporary structure */
7370 ZERO_STRUCT(state->tmp);
7371
7372 tevent_req_done(req);
7373}
7374
7375NTSTATUS rpccli_netr_LogonSamLogonWithFlags_recv(struct tevent_req *req,
7376 TALLOC_CTX *mem_ctx,
7377 NTSTATUS *result)
7378{
7379 struct rpccli_netr_LogonSamLogonWithFlags_state *state = tevent_req_data(
7380 req, struct rpccli_netr_LogonSamLogonWithFlags_state);
7381 NTSTATUS status;
7382
7383 if (tevent_req_is_nterror(req, &status)) {
7384 tevent_req_received(req);
7385 return status;
7386 }
7387
7388 /* Steal possbile out parameters to the callers context */
7389 talloc_steal(mem_ctx, state->out_mem_ctx);
7390
7391 /* Return result */
7392 *result = state->orig.out.result;
7393
7394 tevent_req_received(req);
7395 return NT_STATUS_OK;
7396}
7397
7398NTSTATUS 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] */)
7410{
7411 struct netr_LogonSamLogonWithFlags r;
7412 NTSTATUS status;
7413
7414 /* In parameters */
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;
7420 r.in.logon = logon;
7421 r.in.validation_level = validation_level;
7422 r.in.flags = flags;
7423
7424 status = cli->dispatch(cli,
7425 mem_ctx,
7426 &ndr_table_netlogon,
7427 NDR_NETR_LOGONSAMLOGONWITHFLAGS,
7428 &r);
7429
7430 if (!NT_STATUS_IS_OK(status)) {
7431 return status;
7432 }
7433
7434 if (NT_STATUS_IS_ERR(status)) {
7435 return status;
7436 }
7437
7438 /* Return variables */
7439 if (return_authenticator && r.out.return_authenticator) {
7440 *return_authenticator = *r.out.return_authenticator;
7441 }
7442 *validation = *r.out.validation;
7443 *authoritative = *r.out.authoritative;
7444 *flags = *r.out.flags;
7445
7446 /* Return result */
7447 return r.out.result;
7448}
7449
7450struct 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);
7455};
7456
7457static void rpccli_netr_ServerGetTrustInfo_done(struct tevent_req *subreq);
7458
7459struct 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] */)
7471{
7472 struct tevent_req *req;
7473 struct rpccli_netr_ServerGetTrustInfo_state *state;
7474 struct tevent_req *subreq;
7475
7476 req = tevent_req_create(mem_ctx, &state,
7477 struct rpccli_netr_ServerGetTrustInfo_state);
7478 if (req == NULL) {
7479 return NULL;
7480 }
7481 state->out_mem_ctx = NULL;
7482 state->dispatch_recv = cli->dispatch_recv;
7483
7484 /* In parameters */
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;
7490
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;
7496
7497 /* Result */
7498 ZERO_STRUCT(state->orig.out.result);
7499
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);
7504 }
7505
7506 /* make a temporary copy, that we pass to the dispatch function */
7507 state->tmp = state->orig;
7508
7509 subreq = cli->dispatch_send(state, ev, cli,
7510 &ndr_table_netlogon,
7511 NDR_NETR_SERVERGETTRUSTINFO,
7512 &state->tmp);
7513 if (tevent_req_nomem(subreq, req)) {
7514 return tevent_req_post(req, ev);
7515 }
7516 tevent_req_set_callback(subreq, rpccli_netr_ServerGetTrustInfo_done, req);
7517 return req;
7518}
7519
7520static void rpccli_netr_ServerGetTrustInfo_done(struct tevent_req *subreq)
7521{
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);
7526 NTSTATUS status;
7527 TALLOC_CTX *mem_ctx;
7528
7529 if (state->out_mem_ctx) {
7530 mem_ctx = state->out_mem_ctx;
7531 } else {
7532 mem_ctx = state;
7533 }
7534
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);
7539 return;
7540 }
7541
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;
7547
7548 /* Copy result */
7549 state->orig.out.result = state->tmp.out.result;
7550
7551 /* Reset temporary structure */
7552 ZERO_STRUCT(state->tmp);
7553
7554 tevent_req_done(req);
7555}
7556
7557NTSTATUS rpccli_netr_ServerGetTrustInfo_recv(struct tevent_req *req,
7558 TALLOC_CTX *mem_ctx,
7559 NTSTATUS *result)
7560{
7561 struct rpccli_netr_ServerGetTrustInfo_state *state = tevent_req_data(
7562 req, struct rpccli_netr_ServerGetTrustInfo_state);
7563 NTSTATUS status;
7564
7565 if (tevent_req_is_nterror(req, &status)) {
7566 tevent_req_received(req);
7567 return status;
7568 }
7569
7570 /* Steal possbile out parameters to the callers context */
7571 talloc_steal(mem_ctx, state->out_mem_ctx);
7572
7573 /* Return result */
7574 *result = state->orig.out.result;
7575
7576 tevent_req_received(req);
7577 return NT_STATUS_OK;
7578}
7579
7580NTSTATUS 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] */)
7591{
7592 struct netr_ServerGetTrustInfo r;
7593 NTSTATUS status;
7594
7595 /* In parameters */
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;
7601
7602 status = cli->dispatch(cli,
7603 mem_ctx,
7604 &ndr_table_netlogon,
7605 NDR_NETR_SERVERGETTRUSTINFO,
7606 &r);
7607
7608 if (!NT_STATUS_IS_OK(status)) {
7609 return status;
7610 }
7611
7612 if (NT_STATUS_IS_ERR(status)) {
7613 return status;
7614 }
7615
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;
7621
7622 /* Return result */
7623 return r.out.result;
7624}
7625
Note: See TracBrowser for help on using the repository browser.