?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
idl: recompile our IDL
[Samba/aatanasov.git] / librpc / gen_ndr / cli_drsuapi.c
blob69171dc34dcfbc98cd124f4103b836cc1ca7241d
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_drsuapi.h"
8
9 struct rpccli_drsuapi_DsBind_state {
10 struct drsuapi_DsBind orig;
11 struct drsuapi_DsBind tmp;
12 TALLOC_CTX *out_mem_ctx;
13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14 };
15
16 static void rpccli_drsuapi_DsBind_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_drsuapi_DsBind_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 struct GUID *_bind_guid /* [in] [unique] */,
22 struct drsuapi_DsBindInfoCtr *_bind_info /* [in,out] [unique] */,
23 struct policy_handle *_bind_handle /* [out] [ref] */)
24 {
25 struct tevent_req *req;
26 struct rpccli_drsuapi_DsBind_state *state;
27 struct tevent_req *subreq;
28
29 req = tevent_req_create(mem_ctx, &state,
30 struct rpccli_drsuapi_DsBind_state);
31 if (req == NULL) {
32 return NULL;
33 }
34 state->out_mem_ctx = NULL;
35 state->dispatch_recv = cli->dispatch_recv;
36
37 /* In parameters */
38 state->orig.in.bind_guid = _bind_guid;
39 state->orig.in.bind_info = _bind_info;
40
41 /* Out parameters */
42 state->orig.out.bind_info = _bind_info;
43 state->orig.out.bind_handle = _bind_handle;
44
45 /* Result */
46 ZERO_STRUCT(state->orig.out.result);
47
48 if (DEBUGLEVEL >= 10) {
49 NDR_PRINT_IN_DEBUG(drsuapi_DsBind, &state->orig);
50 }
51
52 state->out_mem_ctx = talloc_named_const(state, 0,
53 "rpccli_drsuapi_DsBind_out_memory");
54 if (tevent_req_nomem(state->out_mem_ctx, req)) {
55 return tevent_req_post(req, ev);
56 }
57
58 /* make a temporary copy, that we pass to the dispatch function */
59 state->tmp = state->orig;
60
61 subreq = cli->dispatch_send(state, ev, cli,
62 &ndr_table_drsuapi,
63 NDR_DRSUAPI_DSBIND,
64 &state->tmp);
65 if (tevent_req_nomem(subreq, req)) {
66 return tevent_req_post(req, ev);
67 }
68 tevent_req_set_callback(subreq, rpccli_drsuapi_DsBind_done, req);
69 return req;
70 }
71
72 static void rpccli_drsuapi_DsBind_done(struct tevent_req *subreq)
73 {
74 struct tevent_req *req = tevent_req_callback_data(
75 subreq, struct tevent_req);
76 struct rpccli_drsuapi_DsBind_state *state = tevent_req_data(
77 req, struct rpccli_drsuapi_DsBind_state);
78 NTSTATUS status;
79 TALLOC_CTX *mem_ctx;
80
81 if (state->out_mem_ctx) {
82 mem_ctx = state->out_mem_ctx;
83 } else {
84 mem_ctx = state;
85 }
86
87 status = state->dispatch_recv(subreq, mem_ctx);
88 TALLOC_FREE(subreq);
89 if (!NT_STATUS_IS_OK(status)) {
90 tevent_req_nterror(req, status);
91 return;
92 }
93
94 /* Copy out parameters */
95 if (state->orig.out.bind_info && state->tmp.out.bind_info) {
96 *state->orig.out.bind_info = *state->tmp.out.bind_info;
97 }
98 *state->orig.out.bind_handle = *state->tmp.out.bind_handle;
99
100 /* Copy result */
101 state->orig.out.result = state->tmp.out.result;
102
103 /* Reset temporary structure */
104 ZERO_STRUCT(state->tmp);
105
106 if (DEBUGLEVEL >= 10) {
107 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &state->orig);
108 }
109
110 tevent_req_done(req);
111 }
112
113 NTSTATUS rpccli_drsuapi_DsBind_recv(struct tevent_req *req,
114 TALLOC_CTX *mem_ctx,
115 WERROR *result)
116 {
117 struct rpccli_drsuapi_DsBind_state *state = tevent_req_data(
118 req, struct rpccli_drsuapi_DsBind_state);
119 NTSTATUS status;
120
121 if (tevent_req_is_nterror(req, &status)) {
122 tevent_req_received(req);
123 return status;
124 }
125
126 /* Steal possbile out parameters to the callers context */
127 talloc_steal(mem_ctx, state->out_mem_ctx);
128
129 /* Return result */
130 *result = state->orig.out.result;
131
132 tevent_req_received(req);
133 return NT_STATUS_OK;
134 }
135
136 NTSTATUS rpccli_drsuapi_DsBind(struct rpc_pipe_client *cli,
137 TALLOC_CTX *mem_ctx,
138 struct GUID *bind_guid /* [in] [unique] */,
139 struct drsuapi_DsBindInfoCtr *bind_info /* [in,out] [unique] */,
140 struct policy_handle *bind_handle /* [out] [ref] */,
141 WERROR *werror)
142 {
143 struct drsuapi_DsBind r;
144 NTSTATUS status;
145
146 /* In parameters */
147 r.in.bind_guid = bind_guid;
148 r.in.bind_info = bind_info;
149
150 if (DEBUGLEVEL >= 10) {
151 NDR_PRINT_IN_DEBUG(drsuapi_DsBind, &r);
152 }
153
154 status = cli->dispatch(cli,
155 mem_ctx,
156 &ndr_table_drsuapi,
157 NDR_DRSUAPI_DSBIND,
158 &r);
159
160 if (!NT_STATUS_IS_OK(status)) {
161 return status;
162 }
163
164 if (DEBUGLEVEL >= 10) {
165 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &r);
166 }
167
168 if (NT_STATUS_IS_ERR(status)) {
169 return status;
170 }
171
172 /* Return variables */
173 if (bind_info && r.out.bind_info) {
174 *bind_info = *r.out.bind_info;
175 }
176 *bind_handle = *r.out.bind_handle;
177
178 /* Return result */
179 if (werror) {
180 *werror = r.out.result;
181 }
182
183 return werror_to_ntstatus(r.out.result);
184 }
185
186 struct rpccli_drsuapi_DsUnbind_state {
187 struct drsuapi_DsUnbind orig;
188 struct drsuapi_DsUnbind tmp;
189 TALLOC_CTX *out_mem_ctx;
190 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
191 };
192
193 static void rpccli_drsuapi_DsUnbind_done(struct tevent_req *subreq);
194
195 struct tevent_req *rpccli_drsuapi_DsUnbind_send(TALLOC_CTX *mem_ctx,
196 struct tevent_context *ev,
197 struct rpc_pipe_client *cli,
198 struct policy_handle *_bind_handle /* [in,out] [ref] */)
199 {
200 struct tevent_req *req;
201 struct rpccli_drsuapi_DsUnbind_state *state;
202 struct tevent_req *subreq;
203
204 req = tevent_req_create(mem_ctx, &state,
205 struct rpccli_drsuapi_DsUnbind_state);
206 if (req == NULL) {
207 return NULL;
208 }
209 state->out_mem_ctx = NULL;
210 state->dispatch_recv = cli->dispatch_recv;
211
212 /* In parameters */
213 state->orig.in.bind_handle = _bind_handle;
214
215 /* Out parameters */
216 state->orig.out.bind_handle = _bind_handle;
217
218 /* Result */
219 ZERO_STRUCT(state->orig.out.result);
220
221 if (DEBUGLEVEL >= 10) {
222 NDR_PRINT_IN_DEBUG(drsuapi_DsUnbind, &state->orig);
223 }
224
225 state->out_mem_ctx = talloc_named_const(state, 0,
226 "rpccli_drsuapi_DsUnbind_out_memory");
227 if (tevent_req_nomem(state->out_mem_ctx, req)) {
228 return tevent_req_post(req, ev);
229 }
230
231 /* make a temporary copy, that we pass to the dispatch function */
232 state->tmp = state->orig;
233
234 subreq = cli->dispatch_send(state, ev, cli,
235 &ndr_table_drsuapi,
236 NDR_DRSUAPI_DSUNBIND,
237 &state->tmp);
238 if (tevent_req_nomem(subreq, req)) {
239 return tevent_req_post(req, ev);
240 }
241 tevent_req_set_callback(subreq, rpccli_drsuapi_DsUnbind_done, req);
242 return req;
243 }
244
245 static void rpccli_drsuapi_DsUnbind_done(struct tevent_req *subreq)
246 {
247 struct tevent_req *req = tevent_req_callback_data(
248 subreq, struct tevent_req);
249 struct rpccli_drsuapi_DsUnbind_state *state = tevent_req_data(
250 req, struct rpccli_drsuapi_DsUnbind_state);
251 NTSTATUS status;
252 TALLOC_CTX *mem_ctx;
253
254 if (state->out_mem_ctx) {
255 mem_ctx = state->out_mem_ctx;
256 } else {
257 mem_ctx = state;
258 }
259
260 status = state->dispatch_recv(subreq, mem_ctx);
261 TALLOC_FREE(subreq);
262 if (!NT_STATUS_IS_OK(status)) {
263 tevent_req_nterror(req, status);
264 return;
265 }
266
267 /* Copy out parameters */
268 *state->orig.out.bind_handle = *state->tmp.out.bind_handle;
269
270 /* Copy result */
271 state->orig.out.result = state->tmp.out.result;
272
273 /* Reset temporary structure */
274 ZERO_STRUCT(state->tmp);
275
276 if (DEBUGLEVEL >= 10) {
277 NDR_PRINT_OUT_DEBUG(drsuapi_DsUnbind, &state->orig);
278 }
279
280 tevent_req_done(req);
281 }
282
283 NTSTATUS rpccli_drsuapi_DsUnbind_recv(struct tevent_req *req,
284 TALLOC_CTX *mem_ctx,
285 WERROR *result)
286 {
287 struct rpccli_drsuapi_DsUnbind_state *state = tevent_req_data(
288 req, struct rpccli_drsuapi_DsUnbind_state);
289 NTSTATUS status;
290
291 if (tevent_req_is_nterror(req, &status)) {
292 tevent_req_received(req);
293 return status;
294 }
295
296 /* Steal possbile out parameters to the callers context */
297 talloc_steal(mem_ctx, state->out_mem_ctx);
298
299 /* Return result */
300 *result = state->orig.out.result;
301
302 tevent_req_received(req);
303 return NT_STATUS_OK;
304 }
305
306 NTSTATUS rpccli_drsuapi_DsUnbind(struct rpc_pipe_client *cli,
307 TALLOC_CTX *mem_ctx,
308 struct policy_handle *bind_handle /* [in,out] [ref] */,
309 WERROR *werror)
310 {
311 struct drsuapi_DsUnbind r;
312 NTSTATUS status;
313
314 /* In parameters */
315 r.in.bind_handle = bind_handle;
316
317 if (DEBUGLEVEL >= 10) {
318 NDR_PRINT_IN_DEBUG(drsuapi_DsUnbind, &r);
319 }
320
321 status = cli->dispatch(cli,
322 mem_ctx,
323 &ndr_table_drsuapi,
324 NDR_DRSUAPI_DSUNBIND,
325 &r);
326
327 if (!NT_STATUS_IS_OK(status)) {
328 return status;
329 }
330
331 if (DEBUGLEVEL >= 10) {
332 NDR_PRINT_OUT_DEBUG(drsuapi_DsUnbind, &r);
333 }
334
335 if (NT_STATUS_IS_ERR(status)) {
336 return status;
337 }
338
339 /* Return variables */
340 *bind_handle = *r.out.bind_handle;
341
342 /* Return result */
343 if (werror) {
344 *werror = r.out.result;
345 }
346
347 return werror_to_ntstatus(r.out.result);
348 }
349
350 struct rpccli_drsuapi_DsReplicaSync_state {
351 struct drsuapi_DsReplicaSync orig;
352 struct drsuapi_DsReplicaSync tmp;
353 TALLOC_CTX *out_mem_ctx;
354 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
355 };
356
357 static void rpccli_drsuapi_DsReplicaSync_done(struct tevent_req *subreq);
358
359 struct tevent_req *rpccli_drsuapi_DsReplicaSync_send(TALLOC_CTX *mem_ctx,
360 struct tevent_context *ev,
361 struct rpc_pipe_client *cli,
362 struct policy_handle *_bind_handle /* [in] [ref] */,
363 int32_t _level /* [in] */,
364 union drsuapi_DsReplicaSyncRequest _req /* [in] [switch_is(level)] */)
365 {
366 struct tevent_req *req;
367 struct rpccli_drsuapi_DsReplicaSync_state *state;
368 struct tevent_req *subreq;
369
370 req = tevent_req_create(mem_ctx, &state,
371 struct rpccli_drsuapi_DsReplicaSync_state);
372 if (req == NULL) {
373 return NULL;
374 }
375 state->out_mem_ctx = NULL;
376 state->dispatch_recv = cli->dispatch_recv;
377
378 /* In parameters */
379 state->orig.in.bind_handle = _bind_handle;
380 state->orig.in.level = _level;
381 state->orig.in.req = _req;
382
383 /* Out parameters */
384
385 /* Result */
386 ZERO_STRUCT(state->orig.out.result);
387
388 if (DEBUGLEVEL >= 10) {
389 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaSync, &state->orig);
390 }
391
392 /* make a temporary copy, that we pass to the dispatch function */
393 state->tmp = state->orig;
394
395 subreq = cli->dispatch_send(state, ev, cli,
396 &ndr_table_drsuapi,
397 NDR_DRSUAPI_DSREPLICASYNC,
398 &state->tmp);
399 if (tevent_req_nomem(subreq, req)) {
400 return tevent_req_post(req, ev);
401 }
402 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaSync_done, req);
403 return req;
404 }
405
406 static void rpccli_drsuapi_DsReplicaSync_done(struct tevent_req *subreq)
407 {
408 struct tevent_req *req = tevent_req_callback_data(
409 subreq, struct tevent_req);
410 struct rpccli_drsuapi_DsReplicaSync_state *state = tevent_req_data(
411 req, struct rpccli_drsuapi_DsReplicaSync_state);
412 NTSTATUS status;
413 TALLOC_CTX *mem_ctx;
414
415 if (state->out_mem_ctx) {
416 mem_ctx = state->out_mem_ctx;
417 } else {
418 mem_ctx = state;
419 }
420
421 status = state->dispatch_recv(subreq, mem_ctx);
422 TALLOC_FREE(subreq);
423 if (!NT_STATUS_IS_OK(status)) {
424 tevent_req_nterror(req, status);
425 return;
426 }
427
428 /* Copy out parameters */
429
430 /* Copy result */
431 state->orig.out.result = state->tmp.out.result;
432
433 /* Reset temporary structure */
434 ZERO_STRUCT(state->tmp);
435
436 if (DEBUGLEVEL >= 10) {
437 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaSync, &state->orig);
438 }
439
440 tevent_req_done(req);
441 }
442
443 NTSTATUS rpccli_drsuapi_DsReplicaSync_recv(struct tevent_req *req,
444 TALLOC_CTX *mem_ctx,
445 WERROR *result)
446 {
447 struct rpccli_drsuapi_DsReplicaSync_state *state = tevent_req_data(
448 req, struct rpccli_drsuapi_DsReplicaSync_state);
449 NTSTATUS status;
450
451 if (tevent_req_is_nterror(req, &status)) {
452 tevent_req_received(req);
453 return status;
454 }
455
456 /* Steal possbile out parameters to the callers context */
457 talloc_steal(mem_ctx, state->out_mem_ctx);
458
459 /* Return result */
460 *result = state->orig.out.result;
461
462 tevent_req_received(req);
463 return NT_STATUS_OK;
464 }
465
466 NTSTATUS rpccli_drsuapi_DsReplicaSync(struct rpc_pipe_client *cli,
467 TALLOC_CTX *mem_ctx,
468 struct policy_handle *bind_handle /* [in] [ref] */,
469 int32_t level /* [in] */,
470 union drsuapi_DsReplicaSyncRequest req /* [in] [switch_is(level)] */,
471 WERROR *werror)
472 {
473 struct drsuapi_DsReplicaSync r;
474 NTSTATUS status;
475
476 /* In parameters */
477 r.in.bind_handle = bind_handle;
478 r.in.level = level;
479 r.in.req = req;
480
481 if (DEBUGLEVEL >= 10) {
482 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaSync, &r);
483 }
484
485 status = cli->dispatch(cli,
486 mem_ctx,
487 &ndr_table_drsuapi,
488 NDR_DRSUAPI_DSREPLICASYNC,
489 &r);
490
491 if (!NT_STATUS_IS_OK(status)) {
492 return status;
493 }
494
495 if (DEBUGLEVEL >= 10) {
496 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaSync, &r);
497 }
498
499 if (NT_STATUS_IS_ERR(status)) {
500 return status;
501 }
502
503 /* Return variables */
504
505 /* Return result */
506 if (werror) {
507 *werror = r.out.result;
508 }
509
510 return werror_to_ntstatus(r.out.result);
511 }
512
513 struct rpccli_drsuapi_DsGetNCChanges_state {
514 struct drsuapi_DsGetNCChanges orig;
515 struct drsuapi_DsGetNCChanges tmp;
516 TALLOC_CTX *out_mem_ctx;
517 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
518 };
519
520 static void rpccli_drsuapi_DsGetNCChanges_done(struct tevent_req *subreq);
521
522 struct tevent_req *rpccli_drsuapi_DsGetNCChanges_send(TALLOC_CTX *mem_ctx,
523 struct tevent_context *ev,
524 struct rpc_pipe_client *cli,
525 struct policy_handle *_bind_handle /* [in] [ref] */,
526 int32_t _level /* [in] */,
527 union drsuapi_DsGetNCChangesRequest *_req /* [in] [ref,switch_is(level)] */,
528 int32_t *_level_out /* [out] [ref] */,
529 union drsuapi_DsGetNCChangesCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
530 {
531 struct tevent_req *req;
532 struct rpccli_drsuapi_DsGetNCChanges_state *state;
533 struct tevent_req *subreq;
534
535 req = tevent_req_create(mem_ctx, &state,
536 struct rpccli_drsuapi_DsGetNCChanges_state);
537 if (req == NULL) {
538 return NULL;
539 }
540 state->out_mem_ctx = NULL;
541 state->dispatch_recv = cli->dispatch_recv;
542
543 /* In parameters */
544 state->orig.in.bind_handle = _bind_handle;
545 state->orig.in.level = _level;
546 state->orig.in.req = _req;
547
548 /* Out parameters */
549 state->orig.out.level_out = _level_out;
550 state->orig.out.ctr = _ctr;
551
552 /* Result */
553 ZERO_STRUCT(state->orig.out.result);
554
555 if (DEBUGLEVEL >= 10) {
556 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNCChanges, &state->orig);
557 }
558
559 state->out_mem_ctx = talloc_named_const(state, 0,
560 "rpccli_drsuapi_DsGetNCChanges_out_memory");
561 if (tevent_req_nomem(state->out_mem_ctx, req)) {
562 return tevent_req_post(req, ev);
563 }
564
565 /* make a temporary copy, that we pass to the dispatch function */
566 state->tmp = state->orig;
567
568 subreq = cli->dispatch_send(state, ev, cli,
569 &ndr_table_drsuapi,
570 NDR_DRSUAPI_DSGETNCCHANGES,
571 &state->tmp);
572 if (tevent_req_nomem(subreq, req)) {
573 return tevent_req_post(req, ev);
574 }
575 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetNCChanges_done, req);
576 return req;
577 }
578
579 static void rpccli_drsuapi_DsGetNCChanges_done(struct tevent_req *subreq)
580 {
581 struct tevent_req *req = tevent_req_callback_data(
582 subreq, struct tevent_req);
583 struct rpccli_drsuapi_DsGetNCChanges_state *state = tevent_req_data(
584 req, struct rpccli_drsuapi_DsGetNCChanges_state);
585 NTSTATUS status;
586 TALLOC_CTX *mem_ctx;
587
588 if (state->out_mem_ctx) {
589 mem_ctx = state->out_mem_ctx;
590 } else {
591 mem_ctx = state;
592 }
593
594 status = state->dispatch_recv(subreq, mem_ctx);
595 TALLOC_FREE(subreq);
596 if (!NT_STATUS_IS_OK(status)) {
597 tevent_req_nterror(req, status);
598 return;
599 }
600
601 /* Copy out parameters */
602 *state->orig.out.level_out = *state->tmp.out.level_out;
603 *state->orig.out.ctr = *state->tmp.out.ctr;
604
605 /* Copy result */
606 state->orig.out.result = state->tmp.out.result;
607
608 /* Reset temporary structure */
609 ZERO_STRUCT(state->tmp);
610
611 if (DEBUGLEVEL >= 10) {
612 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, &state->orig);
613 }
614
615 tevent_req_done(req);
616 }
617
618 NTSTATUS rpccli_drsuapi_DsGetNCChanges_recv(struct tevent_req *req,
619 TALLOC_CTX *mem_ctx,
620 WERROR *result)
621 {
622 struct rpccli_drsuapi_DsGetNCChanges_state *state = tevent_req_data(
623 req, struct rpccli_drsuapi_DsGetNCChanges_state);
624 NTSTATUS status;
625
626 if (tevent_req_is_nterror(req, &status)) {
627 tevent_req_received(req);
628 return status;
629 }
630
631 /* Steal possbile out parameters to the callers context */
632 talloc_steal(mem_ctx, state->out_mem_ctx);
633
634 /* Return result */
635 *result = state->orig.out.result;
636
637 tevent_req_received(req);
638 return NT_STATUS_OK;
639 }
640
641 NTSTATUS rpccli_drsuapi_DsGetNCChanges(struct rpc_pipe_client *cli,
642 TALLOC_CTX *mem_ctx,
643 struct policy_handle *bind_handle /* [in] [ref] */,
644 int32_t level /* [in] */,
645 union drsuapi_DsGetNCChangesRequest *req /* [in] [ref,switch_is(level)] */,
646 int32_t *level_out /* [out] [ref] */,
647 union drsuapi_DsGetNCChangesCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
648 WERROR *werror)
649 {
650 struct drsuapi_DsGetNCChanges r;
651 NTSTATUS status;
652
653 /* In parameters */
654 r.in.bind_handle = bind_handle;
655 r.in.level = level;
656 r.in.req = req;
657
658 if (DEBUGLEVEL >= 10) {
659 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNCChanges, &r);
660 }
661
662 status = cli->dispatch(cli,
663 mem_ctx,
664 &ndr_table_drsuapi,
665 NDR_DRSUAPI_DSGETNCCHANGES,
666 &r);
667
668 if (!NT_STATUS_IS_OK(status)) {
669 return status;
670 }
671
672 if (DEBUGLEVEL >= 10) {
673 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, &r);
674 }
675
676 if (NT_STATUS_IS_ERR(status)) {
677 return status;
678 }
679
680 /* Return variables */
681 *level_out = *r.out.level_out;
682 *ctr = *r.out.ctr;
683
684 /* Return result */
685 if (werror) {
686 *werror = r.out.result;
687 }
688
689 return werror_to_ntstatus(r.out.result);
690 }
691
692 struct rpccli_drsuapi_DsReplicaUpdateRefs_state {
693 struct drsuapi_DsReplicaUpdateRefs orig;
694 struct drsuapi_DsReplicaUpdateRefs tmp;
695 TALLOC_CTX *out_mem_ctx;
696 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
697 };
698
699 static void rpccli_drsuapi_DsReplicaUpdateRefs_done(struct tevent_req *subreq);
700
701 struct tevent_req *rpccli_drsuapi_DsReplicaUpdateRefs_send(TALLOC_CTX *mem_ctx,
702 struct tevent_context *ev,
703 struct rpc_pipe_client *cli,
704 struct policy_handle *_bind_handle /* [in] [ref] */,
705 int32_t _level /* [in] */,
706 union drsuapi_DsReplicaUpdateRefsRequest _req /* [in] [switch_is(level)] */)
707 {
708 struct tevent_req *req;
709 struct rpccli_drsuapi_DsReplicaUpdateRefs_state *state;
710 struct tevent_req *subreq;
711
712 req = tevent_req_create(mem_ctx, &state,
713 struct rpccli_drsuapi_DsReplicaUpdateRefs_state);
714 if (req == NULL) {
715 return NULL;
716 }
717 state->out_mem_ctx = NULL;
718 state->dispatch_recv = cli->dispatch_recv;
719
720 /* In parameters */
721 state->orig.in.bind_handle = _bind_handle;
722 state->orig.in.level = _level;
723 state->orig.in.req = _req;
724
725 /* Out parameters */
726
727 /* Result */
728 ZERO_STRUCT(state->orig.out.result);
729
730 if (DEBUGLEVEL >= 10) {
731 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaUpdateRefs, &state->orig);
732 }
733
734 /* make a temporary copy, that we pass to the dispatch function */
735 state->tmp = state->orig;
736
737 subreq = cli->dispatch_send(state, ev, cli,
738 &ndr_table_drsuapi,
739 NDR_DRSUAPI_DSREPLICAUPDATEREFS,
740 &state->tmp);
741 if (tevent_req_nomem(subreq, req)) {
742 return tevent_req_post(req, ev);
743 }
744 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaUpdateRefs_done, req);
745 return req;
746 }
747
748 static void rpccli_drsuapi_DsReplicaUpdateRefs_done(struct tevent_req *subreq)
749 {
750 struct tevent_req *req = tevent_req_callback_data(
751 subreq, struct tevent_req);
752 struct rpccli_drsuapi_DsReplicaUpdateRefs_state *state = tevent_req_data(
753 req, struct rpccli_drsuapi_DsReplicaUpdateRefs_state);
754 NTSTATUS status;
755 TALLOC_CTX *mem_ctx;
756
757 if (state->out_mem_ctx) {
758 mem_ctx = state->out_mem_ctx;
759 } else {
760 mem_ctx = state;
761 }
762
763 status = state->dispatch_recv(subreq, mem_ctx);
764 TALLOC_FREE(subreq);
765 if (!NT_STATUS_IS_OK(status)) {
766 tevent_req_nterror(req, status);
767 return;
768 }
769
770 /* Copy out parameters */
771
772 /* Copy result */
773 state->orig.out.result = state->tmp.out.result;
774
775 /* Reset temporary structure */
776 ZERO_STRUCT(state->tmp);
777
778 if (DEBUGLEVEL >= 10) {
779 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaUpdateRefs, &state->orig);
780 }
781
782 tevent_req_done(req);
783 }
784
785 NTSTATUS rpccli_drsuapi_DsReplicaUpdateRefs_recv(struct tevent_req *req,
786 TALLOC_CTX *mem_ctx,
787 WERROR *result)
788 {
789 struct rpccli_drsuapi_DsReplicaUpdateRefs_state *state = tevent_req_data(
790 req, struct rpccli_drsuapi_DsReplicaUpdateRefs_state);
791 NTSTATUS status;
792
793 if (tevent_req_is_nterror(req, &status)) {
794 tevent_req_received(req);
795 return status;
796 }
797
798 /* Steal possbile out parameters to the callers context */
799 talloc_steal(mem_ctx, state->out_mem_ctx);
800
801 /* Return result */
802 *result = state->orig.out.result;
803
804 tevent_req_received(req);
805 return NT_STATUS_OK;
806 }
807
808 NTSTATUS rpccli_drsuapi_DsReplicaUpdateRefs(struct rpc_pipe_client *cli,
809 TALLOC_CTX *mem_ctx,
810 struct policy_handle *bind_handle /* [in] [ref] */,
811 int32_t level /* [in] */,
812 union drsuapi_DsReplicaUpdateRefsRequest req /* [in] [switch_is(level)] */,
813 WERROR *werror)
814 {
815 struct drsuapi_DsReplicaUpdateRefs r;
816 NTSTATUS status;
817
818 /* In parameters */
819 r.in.bind_handle = bind_handle;
820 r.in.level = level;
821 r.in.req = req;
822
823 if (DEBUGLEVEL >= 10) {
824 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaUpdateRefs, &r);
825 }
826
827 status = cli->dispatch(cli,
828 mem_ctx,
829 &ndr_table_drsuapi,
830 NDR_DRSUAPI_DSREPLICAUPDATEREFS,
831 &r);
832
833 if (!NT_STATUS_IS_OK(status)) {
834 return status;
835 }
836
837 if (DEBUGLEVEL >= 10) {
838 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaUpdateRefs, &r);
839 }
840
841 if (NT_STATUS_IS_ERR(status)) {
842 return status;
843 }
844
845 /* Return variables */
846
847 /* Return result */
848 if (werror) {
849 *werror = r.out.result;
850 }
851
852 return werror_to_ntstatus(r.out.result);
853 }
854
855 struct rpccli_drsuapi_DsReplicaAdd_state {
856 struct drsuapi_DsReplicaAdd orig;
857 struct drsuapi_DsReplicaAdd tmp;
858 TALLOC_CTX *out_mem_ctx;
859 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
860 };
861
862 static void rpccli_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq);
863
864 struct tevent_req *rpccli_drsuapi_DsReplicaAdd_send(TALLOC_CTX *mem_ctx,
865 struct tevent_context *ev,
866 struct rpc_pipe_client *cli,
867 struct policy_handle *_bind_handle /* [in] [ref] */,
868 int32_t _level /* [in] */,
869 union drsuapi_DsReplicaAddRequest _req /* [in] [switch_is(level)] */)
870 {
871 struct tevent_req *req;
872 struct rpccli_drsuapi_DsReplicaAdd_state *state;
873 struct tevent_req *subreq;
874
875 req = tevent_req_create(mem_ctx, &state,
876 struct rpccli_drsuapi_DsReplicaAdd_state);
877 if (req == NULL) {
878 return NULL;
879 }
880 state->out_mem_ctx = NULL;
881 state->dispatch_recv = cli->dispatch_recv;
882
883 /* In parameters */
884 state->orig.in.bind_handle = _bind_handle;
885 state->orig.in.level = _level;
886 state->orig.in.req = _req;
887
888 /* Out parameters */
889
890 /* Result */
891 ZERO_STRUCT(state->orig.out.result);
892
893 if (DEBUGLEVEL >= 10) {
894 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaAdd, &state->orig);
895 }
896
897 /* make a temporary copy, that we pass to the dispatch function */
898 state->tmp = state->orig;
899
900 subreq = cli->dispatch_send(state, ev, cli,
901 &ndr_table_drsuapi,
902 NDR_DRSUAPI_DSREPLICAADD,
903 &state->tmp);
904 if (tevent_req_nomem(subreq, req)) {
905 return tevent_req_post(req, ev);
906 }
907 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaAdd_done, req);
908 return req;
909 }
910
911 static void rpccli_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq)
912 {
913 struct tevent_req *req = tevent_req_callback_data(
914 subreq, struct tevent_req);
915 struct rpccli_drsuapi_DsReplicaAdd_state *state = tevent_req_data(
916 req, struct rpccli_drsuapi_DsReplicaAdd_state);
917 NTSTATUS status;
918 TALLOC_CTX *mem_ctx;
919
920 if (state->out_mem_ctx) {
921 mem_ctx = state->out_mem_ctx;
922 } else {
923 mem_ctx = state;
924 }
925
926 status = state->dispatch_recv(subreq, mem_ctx);
927 TALLOC_FREE(subreq);
928 if (!NT_STATUS_IS_OK(status)) {
929 tevent_req_nterror(req, status);
930 return;
931 }
932
933 /* Copy out parameters */
934
935 /* Copy result */
936 state->orig.out.result = state->tmp.out.result;
937
938 /* Reset temporary structure */
939 ZERO_STRUCT(state->tmp);
940
941 if (DEBUGLEVEL >= 10) {
942 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaAdd, &state->orig);
943 }
944
945 tevent_req_done(req);
946 }
947
948 NTSTATUS rpccli_drsuapi_DsReplicaAdd_recv(struct tevent_req *req,
949 TALLOC_CTX *mem_ctx,
950 WERROR *result)
951 {
952 struct rpccli_drsuapi_DsReplicaAdd_state *state = tevent_req_data(
953 req, struct rpccli_drsuapi_DsReplicaAdd_state);
954 NTSTATUS status;
955
956 if (tevent_req_is_nterror(req, &status)) {
957 tevent_req_received(req);
958 return status;
959 }
960
961 /* Steal possbile out parameters to the callers context */
962 talloc_steal(mem_ctx, state->out_mem_ctx);
963
964 /* Return result */
965 *result = state->orig.out.result;
966
967 tevent_req_received(req);
968 return NT_STATUS_OK;
969 }
970
971 NTSTATUS rpccli_drsuapi_DsReplicaAdd(struct rpc_pipe_client *cli,
972 TALLOC_CTX *mem_ctx,
973 struct policy_handle *bind_handle /* [in] [ref] */,
974 int32_t level /* [in] */,
975 union drsuapi_DsReplicaAddRequest req /* [in] [switch_is(level)] */,
976 WERROR *werror)
977 {
978 struct drsuapi_DsReplicaAdd r;
979 NTSTATUS status;
980
981 /* In parameters */
982 r.in.bind_handle = bind_handle;
983 r.in.level = level;
984 r.in.req = req;
985
986 if (DEBUGLEVEL >= 10) {
987 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaAdd, &r);
988 }
989
990 status = cli->dispatch(cli,
991 mem_ctx,
992 &ndr_table_drsuapi,
993 NDR_DRSUAPI_DSREPLICAADD,
994 &r);
995
996 if (!NT_STATUS_IS_OK(status)) {
997 return status;
998 }
999
1000 if (DEBUGLEVEL >= 10) {
1001 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaAdd, &r);
1002 }
1003
1004 if (NT_STATUS_IS_ERR(status)) {
1005 return status;
1006 }
1007
1008 /* Return variables */
1009
1010 /* Return result */
1011 if (werror) {
1012 *werror = r.out.result;
1013 }
1014
1015 return werror_to_ntstatus(r.out.result);
1016 }
1017
1018 struct rpccli_drsuapi_DsReplicaDel_state {
1019 struct drsuapi_DsReplicaDel orig;
1020 struct drsuapi_DsReplicaDel tmp;
1021 TALLOC_CTX *out_mem_ctx;
1022 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1023 };
1024
1025 static void rpccli_drsuapi_DsReplicaDel_done(struct tevent_req *subreq);
1026
1027 struct tevent_req *rpccli_drsuapi_DsReplicaDel_send(TALLOC_CTX *mem_ctx,
1028 struct tevent_context *ev,
1029 struct rpc_pipe_client *cli,
1030 struct policy_handle *_bind_handle /* [in] [ref] */,
1031 int32_t _level /* [in] */,
1032 union drsuapi_DsReplicaDelRequest _req /* [in] [switch_is(level)] */)
1033 {
1034 struct tevent_req *req;
1035 struct rpccli_drsuapi_DsReplicaDel_state *state;
1036 struct tevent_req *subreq;
1037
1038 req = tevent_req_create(mem_ctx, &state,
1039 struct rpccli_drsuapi_DsReplicaDel_state);
1040 if (req == NULL) {
1041 return NULL;
1042 }
1043 state->out_mem_ctx = NULL;
1044 state->dispatch_recv = cli->dispatch_recv;
1045
1046 /* In parameters */
1047 state->orig.in.bind_handle = _bind_handle;
1048 state->orig.in.level = _level;
1049 state->orig.in.req = _req;
1050
1051 /* Out parameters */
1052
1053 /* Result */
1054 ZERO_STRUCT(state->orig.out.result);
1055
1056 if (DEBUGLEVEL >= 10) {
1057 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaDel, &state->orig);
1058 }
1059
1060 /* make a temporary copy, that we pass to the dispatch function */
1061 state->tmp = state->orig;
1062
1063 subreq = cli->dispatch_send(state, ev, cli,
1064 &ndr_table_drsuapi,
1065 NDR_DRSUAPI_DSREPLICADEL,
1066 &state->tmp);
1067 if (tevent_req_nomem(subreq, req)) {
1068 return tevent_req_post(req, ev);
1069 }
1070 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaDel_done, req);
1071 return req;
1072 }
1073
1074 static void rpccli_drsuapi_DsReplicaDel_done(struct tevent_req *subreq)
1075 {
1076 struct tevent_req *req = tevent_req_callback_data(
1077 subreq, struct tevent_req);
1078 struct rpccli_drsuapi_DsReplicaDel_state *state = tevent_req_data(
1079 req, struct rpccli_drsuapi_DsReplicaDel_state);
1080 NTSTATUS status;
1081 TALLOC_CTX *mem_ctx;
1082
1083 if (state->out_mem_ctx) {
1084 mem_ctx = state->out_mem_ctx;
1085 } else {
1086 mem_ctx = state;
1087 }
1088
1089 status = state->dispatch_recv(subreq, mem_ctx);
1090 TALLOC_FREE(subreq);
1091 if (!NT_STATUS_IS_OK(status)) {
1092 tevent_req_nterror(req, status);
1093 return;
1094 }
1095
1096 /* Copy out parameters */
1097
1098 /* Copy result */
1099 state->orig.out.result = state->tmp.out.result;
1100
1101 /* Reset temporary structure */
1102 ZERO_STRUCT(state->tmp);
1103
1104 if (DEBUGLEVEL >= 10) {
1105 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaDel, &state->orig);
1106 }
1107
1108 tevent_req_done(req);
1109 }
1110
1111 NTSTATUS rpccli_drsuapi_DsReplicaDel_recv(struct tevent_req *req,
1112 TALLOC_CTX *mem_ctx,
1113 WERROR *result)
1114 {
1115 struct rpccli_drsuapi_DsReplicaDel_state *state = tevent_req_data(
1116 req, struct rpccli_drsuapi_DsReplicaDel_state);
1117 NTSTATUS status;
1118
1119 if (tevent_req_is_nterror(req, &status)) {
1120 tevent_req_received(req);
1121 return status;
1122 }
1123
1124 /* Steal possbile out parameters to the callers context */
1125 talloc_steal(mem_ctx, state->out_mem_ctx);
1126
1127 /* Return result */
1128 *result = state->orig.out.result;
1129
1130 tevent_req_received(req);
1131 return NT_STATUS_OK;
1132 }
1133
1134 NTSTATUS rpccli_drsuapi_DsReplicaDel(struct rpc_pipe_client *cli,
1135 TALLOC_CTX *mem_ctx,
1136 struct policy_handle *bind_handle /* [in] [ref] */,
1137 int32_t level /* [in] */,
1138 union drsuapi_DsReplicaDelRequest req /* [in] [switch_is(level)] */,
1139 WERROR *werror)
1140 {
1141 struct drsuapi_DsReplicaDel r;
1142 NTSTATUS status;
1143
1144 /* In parameters */
1145 r.in.bind_handle = bind_handle;
1146 r.in.level = level;
1147 r.in.req = req;
1148
1149 if (DEBUGLEVEL >= 10) {
1150 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaDel, &r);
1151 }
1152
1153 status = cli->dispatch(cli,
1154 mem_ctx,
1155 &ndr_table_drsuapi,
1156 NDR_DRSUAPI_DSREPLICADEL,
1157 &r);
1158
1159 if (!NT_STATUS_IS_OK(status)) {
1160 return status;
1161 }
1162
1163 if (DEBUGLEVEL >= 10) {
1164 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaDel, &r);
1165 }
1166
1167 if (NT_STATUS_IS_ERR(status)) {
1168 return status;
1169 }
1170
1171 /* Return variables */
1172
1173 /* Return result */
1174 if (werror) {
1175 *werror = r.out.result;
1176 }
1177
1178 return werror_to_ntstatus(r.out.result);
1179 }
1180
1181 struct rpccli_drsuapi_DsReplicaMod_state {
1182 struct drsuapi_DsReplicaMod orig;
1183 struct drsuapi_DsReplicaMod tmp;
1184 TALLOC_CTX *out_mem_ctx;
1185 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1186 };
1187
1188 static void rpccli_drsuapi_DsReplicaMod_done(struct tevent_req *subreq);
1189
1190 struct tevent_req *rpccli_drsuapi_DsReplicaMod_send(TALLOC_CTX *mem_ctx,
1191 struct tevent_context *ev,
1192 struct rpc_pipe_client *cli,
1193 struct policy_handle *_bind_handle /* [in] [ref] */,
1194 int32_t _level /* [in] */,
1195 union drsuapi_DsReplicaModRequest _req /* [in] [switch_is(level)] */)
1196 {
1197 struct tevent_req *req;
1198 struct rpccli_drsuapi_DsReplicaMod_state *state;
1199 struct tevent_req *subreq;
1200
1201 req = tevent_req_create(mem_ctx, &state,
1202 struct rpccli_drsuapi_DsReplicaMod_state);
1203 if (req == NULL) {
1204 return NULL;
1205 }
1206 state->out_mem_ctx = NULL;
1207 state->dispatch_recv = cli->dispatch_recv;
1208
1209 /* In parameters */
1210 state->orig.in.bind_handle = _bind_handle;
1211 state->orig.in.level = _level;
1212 state->orig.in.req = _req;
1213
1214 /* Out parameters */
1215
1216 /* Result */
1217 ZERO_STRUCT(state->orig.out.result);
1218
1219 if (DEBUGLEVEL >= 10) {
1220 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaMod, &state->orig);
1221 }
1222
1223 /* make a temporary copy, that we pass to the dispatch function */
1224 state->tmp = state->orig;
1225
1226 subreq = cli->dispatch_send(state, ev, cli,
1227 &ndr_table_drsuapi,
1228 NDR_DRSUAPI_DSREPLICAMOD,
1229 &state->tmp);
1230 if (tevent_req_nomem(subreq, req)) {
1231 return tevent_req_post(req, ev);
1232 }
1233 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaMod_done, req);
1234 return req;
1235 }
1236
1237 static void rpccli_drsuapi_DsReplicaMod_done(struct tevent_req *subreq)
1238 {
1239 struct tevent_req *req = tevent_req_callback_data(
1240 subreq, struct tevent_req);
1241 struct rpccli_drsuapi_DsReplicaMod_state *state = tevent_req_data(
1242 req, struct rpccli_drsuapi_DsReplicaMod_state);
1243 NTSTATUS status;
1244 TALLOC_CTX *mem_ctx;
1245
1246 if (state->out_mem_ctx) {
1247 mem_ctx = state->out_mem_ctx;
1248 } else {
1249 mem_ctx = state;
1250 }
1251
1252 status = state->dispatch_recv(subreq, mem_ctx);
1253 TALLOC_FREE(subreq);
1254 if (!NT_STATUS_IS_OK(status)) {
1255 tevent_req_nterror(req, status);
1256 return;
1257 }
1258
1259 /* Copy out parameters */
1260
1261 /* Copy result */
1262 state->orig.out.result = state->tmp.out.result;
1263
1264 /* Reset temporary structure */
1265 ZERO_STRUCT(state->tmp);
1266
1267 if (DEBUGLEVEL >= 10) {
1268 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaMod, &state->orig);
1269 }
1270
1271 tevent_req_done(req);
1272 }
1273
1274 NTSTATUS rpccli_drsuapi_DsReplicaMod_recv(struct tevent_req *req,
1275 TALLOC_CTX *mem_ctx,
1276 WERROR *result)
1277 {
1278 struct rpccli_drsuapi_DsReplicaMod_state *state = tevent_req_data(
1279 req, struct rpccli_drsuapi_DsReplicaMod_state);
1280 NTSTATUS status;
1281
1282 if (tevent_req_is_nterror(req, &status)) {
1283 tevent_req_received(req);
1284 return status;
1285 }
1286
1287 /* Steal possbile out parameters to the callers context */
1288 talloc_steal(mem_ctx, state->out_mem_ctx);
1289
1290 /* Return result */
1291 *result = state->orig.out.result;
1292
1293 tevent_req_received(req);
1294 return NT_STATUS_OK;
1295 }
1296
1297 NTSTATUS rpccli_drsuapi_DsReplicaMod(struct rpc_pipe_client *cli,
1298 TALLOC_CTX *mem_ctx,
1299 struct policy_handle *bind_handle /* [in] [ref] */,
1300 int32_t level /* [in] */,
1301 union drsuapi_DsReplicaModRequest req /* [in] [switch_is(level)] */,
1302 WERROR *werror)
1303 {
1304 struct drsuapi_DsReplicaMod r;
1305 NTSTATUS status;
1306
1307 /* In parameters */
1308 r.in.bind_handle = bind_handle;
1309 r.in.level = level;
1310 r.in.req = req;
1311
1312 if (DEBUGLEVEL >= 10) {
1313 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaMod, &r);
1314 }
1315
1316 status = cli->dispatch(cli,
1317 mem_ctx,
1318 &ndr_table_drsuapi,
1319 NDR_DRSUAPI_DSREPLICAMOD,
1320 &r);
1321
1322 if (!NT_STATUS_IS_OK(status)) {
1323 return status;
1324 }
1325
1326 if (DEBUGLEVEL >= 10) {
1327 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaMod, &r);
1328 }
1329
1330 if (NT_STATUS_IS_ERR(status)) {
1331 return status;
1332 }
1333
1334 /* Return variables */
1335
1336 /* Return result */
1337 if (werror) {
1338 *werror = r.out.result;
1339 }
1340
1341 return werror_to_ntstatus(r.out.result);
1342 }
1343
1344 struct rpccli_DRSUAPI_VERIFY_NAMES_state {
1345 struct DRSUAPI_VERIFY_NAMES orig;
1346 struct DRSUAPI_VERIFY_NAMES tmp;
1347 TALLOC_CTX *out_mem_ctx;
1348 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1349 };
1350
1351 static void rpccli_DRSUAPI_VERIFY_NAMES_done(struct tevent_req *subreq);
1352
1353 struct tevent_req *rpccli_DRSUAPI_VERIFY_NAMES_send(TALLOC_CTX *mem_ctx,
1354 struct tevent_context *ev,
1355 struct rpc_pipe_client *cli)
1356 {
1357 struct tevent_req *req;
1358 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state;
1359 struct tevent_req *subreq;
1360
1361 req = tevent_req_create(mem_ctx, &state,
1362 struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1363 if (req == NULL) {
1364 return NULL;
1365 }
1366 state->out_mem_ctx = NULL;
1367 state->dispatch_recv = cli->dispatch_recv;
1368
1369 /* In parameters */
1370
1371 /* Out parameters */
1372
1373 /* Result */
1374 ZERO_STRUCT(state->orig.out.result);
1375
1376 if (DEBUGLEVEL >= 10) {
1377 NDR_PRINT_IN_DEBUG(DRSUAPI_VERIFY_NAMES, &state->orig);
1378 }
1379
1380 /* make a temporary copy, that we pass to the dispatch function */
1381 state->tmp = state->orig;
1382
1383 subreq = cli->dispatch_send(state, ev, cli,
1384 &ndr_table_drsuapi,
1385 NDR_DRSUAPI_VERIFY_NAMES,
1386 &state->tmp);
1387 if (tevent_req_nomem(subreq, req)) {
1388 return tevent_req_post(req, ev);
1389 }
1390 tevent_req_set_callback(subreq, rpccli_DRSUAPI_VERIFY_NAMES_done, req);
1391 return req;
1392 }
1393
1394 static void rpccli_DRSUAPI_VERIFY_NAMES_done(struct tevent_req *subreq)
1395 {
1396 struct tevent_req *req = tevent_req_callback_data(
1397 subreq, struct tevent_req);
1398 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state = tevent_req_data(
1399 req, struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1400 NTSTATUS status;
1401 TALLOC_CTX *mem_ctx;
1402
1403 if (state->out_mem_ctx) {
1404 mem_ctx = state->out_mem_ctx;
1405 } else {
1406 mem_ctx = state;
1407 }
1408
1409 status = state->dispatch_recv(subreq, mem_ctx);
1410 TALLOC_FREE(subreq);
1411 if (!NT_STATUS_IS_OK(status)) {
1412 tevent_req_nterror(req, status);
1413 return;
1414 }
1415
1416 /* Copy out parameters */
1417
1418 /* Copy result */
1419 state->orig.out.result = state->tmp.out.result;
1420
1421 /* Reset temporary structure */
1422 ZERO_STRUCT(state->tmp);
1423
1424 if (DEBUGLEVEL >= 10) {
1425 NDR_PRINT_OUT_DEBUG(DRSUAPI_VERIFY_NAMES, &state->orig);
1426 }
1427
1428 tevent_req_done(req);
1429 }
1430
1431 NTSTATUS rpccli_DRSUAPI_VERIFY_NAMES_recv(struct tevent_req *req,
1432 TALLOC_CTX *mem_ctx,
1433 WERROR *result)
1434 {
1435 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state = tevent_req_data(
1436 req, struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1437 NTSTATUS status;
1438
1439 if (tevent_req_is_nterror(req, &status)) {
1440 tevent_req_received(req);
1441 return status;
1442 }
1443
1444 /* Steal possbile out parameters to the callers context */
1445 talloc_steal(mem_ctx, state->out_mem_ctx);
1446
1447 /* Return result */
1448 *result = state->orig.out.result;
1449
1450 tevent_req_received(req);
1451 return NT_STATUS_OK;
1452 }
1453
1454 NTSTATUS rpccli_DRSUAPI_VERIFY_NAMES(struct rpc_pipe_client *cli,
1455 TALLOC_CTX *mem_ctx,
1456 WERROR *werror)
1457 {
1458 struct DRSUAPI_VERIFY_NAMES r;
1459 NTSTATUS status;
1460
1461 /* In parameters */
1462
1463 if (DEBUGLEVEL >= 10) {
1464 NDR_PRINT_IN_DEBUG(DRSUAPI_VERIFY_NAMES, &r);
1465 }
1466
1467 status = cli->dispatch(cli,
1468 mem_ctx,
1469 &ndr_table_drsuapi,
1470 NDR_DRSUAPI_VERIFY_NAMES,
1471 &r);
1472
1473 if (!NT_STATUS_IS_OK(status)) {
1474 return status;
1475 }
1476
1477 if (DEBUGLEVEL >= 10) {
1478 NDR_PRINT_OUT_DEBUG(DRSUAPI_VERIFY_NAMES, &r);
1479 }
1480
1481 if (NT_STATUS_IS_ERR(status)) {
1482 return status;
1483 }
1484
1485 /* Return variables */
1486
1487 /* Return result */
1488 if (werror) {
1489 *werror = r.out.result;
1490 }
1491
1492 return werror_to_ntstatus(r.out.result);
1493 }
1494
1495 struct rpccli_drsuapi_DsGetMemberships_state {
1496 struct drsuapi_DsGetMemberships orig;
1497 struct drsuapi_DsGetMemberships tmp;
1498 TALLOC_CTX *out_mem_ctx;
1499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1500 };
1501
1502 static void rpccli_drsuapi_DsGetMemberships_done(struct tevent_req *subreq);
1503
1504 struct tevent_req *rpccli_drsuapi_DsGetMemberships_send(TALLOC_CTX *mem_ctx,
1505 struct tevent_context *ev,
1506 struct rpc_pipe_client *cli,
1507 struct policy_handle *_bind_handle /* [in] [ref] */,
1508 int32_t _level /* [in] */,
1509 union drsuapi_DsGetMembershipsRequest *_req /* [in] [ref,switch_is(level)] */,
1510 int32_t *_level_out /* [out] [ref] */,
1511 union drsuapi_DsGetMembershipsCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
1512 {
1513 struct tevent_req *req;
1514 struct rpccli_drsuapi_DsGetMemberships_state *state;
1515 struct tevent_req *subreq;
1516
1517 req = tevent_req_create(mem_ctx, &state,
1518 struct rpccli_drsuapi_DsGetMemberships_state);
1519 if (req == NULL) {
1520 return NULL;
1521 }
1522 state->out_mem_ctx = NULL;
1523 state->dispatch_recv = cli->dispatch_recv;
1524
1525 /* In parameters */
1526 state->orig.in.bind_handle = _bind_handle;
1527 state->orig.in.level = _level;
1528 state->orig.in.req = _req;
1529
1530 /* Out parameters */
1531 state->orig.out.level_out = _level_out;
1532 state->orig.out.ctr = _ctr;
1533
1534 /* Result */
1535 ZERO_STRUCT(state->orig.out.result);
1536
1537 if (DEBUGLEVEL >= 10) {
1538 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships, &state->orig);
1539 }
1540
1541 state->out_mem_ctx = talloc_named_const(state, 0,
1542 "rpccli_drsuapi_DsGetMemberships_out_memory");
1543 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1544 return tevent_req_post(req, ev);
1545 }
1546
1547 /* make a temporary copy, that we pass to the dispatch function */
1548 state->tmp = state->orig;
1549
1550 subreq = cli->dispatch_send(state, ev, cli,
1551 &ndr_table_drsuapi,
1552 NDR_DRSUAPI_DSGETMEMBERSHIPS,
1553 &state->tmp);
1554 if (tevent_req_nomem(subreq, req)) {
1555 return tevent_req_post(req, ev);
1556 }
1557 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetMemberships_done, req);
1558 return req;
1559 }
1560
1561 static void rpccli_drsuapi_DsGetMemberships_done(struct tevent_req *subreq)
1562 {
1563 struct tevent_req *req = tevent_req_callback_data(
1564 subreq, struct tevent_req);
1565 struct rpccli_drsuapi_DsGetMemberships_state *state = tevent_req_data(
1566 req, struct rpccli_drsuapi_DsGetMemberships_state);
1567 NTSTATUS status;
1568 TALLOC_CTX *mem_ctx;
1569
1570 if (state->out_mem_ctx) {
1571 mem_ctx = state->out_mem_ctx;
1572 } else {
1573 mem_ctx = state;
1574 }
1575
1576 status = state->dispatch_recv(subreq, mem_ctx);
1577 TALLOC_FREE(subreq);
1578 if (!NT_STATUS_IS_OK(status)) {
1579 tevent_req_nterror(req, status);
1580 return;
1581 }
1582
1583 /* Copy out parameters */
1584 *state->orig.out.level_out = *state->tmp.out.level_out;
1585 *state->orig.out.ctr = *state->tmp.out.ctr;
1586
1587 /* Copy result */
1588 state->orig.out.result = state->tmp.out.result;
1589
1590 /* Reset temporary structure */
1591 ZERO_STRUCT(state->tmp);
1592
1593 if (DEBUGLEVEL >= 10) {
1594 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships, &state->orig);
1595 }
1596
1597 tevent_req_done(req);
1598 }
1599
1600 NTSTATUS rpccli_drsuapi_DsGetMemberships_recv(struct tevent_req *req,
1601 TALLOC_CTX *mem_ctx,
1602 WERROR *result)
1603 {
1604 struct rpccli_drsuapi_DsGetMemberships_state *state = tevent_req_data(
1605 req, struct rpccli_drsuapi_DsGetMemberships_state);
1606 NTSTATUS status;
1607
1608 if (tevent_req_is_nterror(req, &status)) {
1609 tevent_req_received(req);
1610 return status;
1611 }
1612
1613 /* Steal possbile out parameters to the callers context */
1614 talloc_steal(mem_ctx, state->out_mem_ctx);
1615
1616 /* Return result */
1617 *result = state->orig.out.result;
1618
1619 tevent_req_received(req);
1620 return NT_STATUS_OK;
1621 }
1622
1623 NTSTATUS rpccli_drsuapi_DsGetMemberships(struct rpc_pipe_client *cli,
1624 TALLOC_CTX *mem_ctx,
1625 struct policy_handle *bind_handle /* [in] [ref] */,
1626 int32_t level /* [in] */,
1627 union drsuapi_DsGetMembershipsRequest *req /* [in] [ref,switch_is(level)] */,
1628 int32_t *level_out /* [out] [ref] */,
1629 union drsuapi_DsGetMembershipsCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
1630 WERROR *werror)
1631 {
1632 struct drsuapi_DsGetMemberships r;
1633 NTSTATUS status;
1634
1635 /* In parameters */
1636 r.in.bind_handle = bind_handle;
1637 r.in.level = level;
1638 r.in.req = req;
1639
1640 if (DEBUGLEVEL >= 10) {
1641 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships, &r);
1642 }
1643
1644 status = cli->dispatch(cli,
1645 mem_ctx,
1646 &ndr_table_drsuapi,
1647 NDR_DRSUAPI_DSGETMEMBERSHIPS,
1648 &r);
1649
1650 if (!NT_STATUS_IS_OK(status)) {
1651 return status;
1652 }
1653
1654 if (DEBUGLEVEL >= 10) {
1655 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships, &r);
1656 }
1657
1658 if (NT_STATUS_IS_ERR(status)) {
1659 return status;
1660 }
1661
1662 /* Return variables */
1663 *level_out = *r.out.level_out;
1664 *ctr = *r.out.ctr;
1665
1666 /* Return result */
1667 if (werror) {
1668 *werror = r.out.result;
1669 }
1670
1671 return werror_to_ntstatus(r.out.result);
1672 }
1673
1674 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state {
1675 struct DRSUAPI_INTER_DOMAIN_MOVE orig;
1676 struct DRSUAPI_INTER_DOMAIN_MOVE tmp;
1677 TALLOC_CTX *out_mem_ctx;
1678 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1679 };
1680
1681 static void rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done(struct tevent_req *subreq);
1682
1683 struct tevent_req *rpccli_DRSUAPI_INTER_DOMAIN_MOVE_send(TALLOC_CTX *mem_ctx,
1684 struct tevent_context *ev,
1685 struct rpc_pipe_client *cli)
1686 {
1687 struct tevent_req *req;
1688 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state;
1689 struct tevent_req *subreq;
1690
1691 req = tevent_req_create(mem_ctx, &state,
1692 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1693 if (req == NULL) {
1694 return NULL;
1695 }
1696 state->out_mem_ctx = NULL;
1697 state->dispatch_recv = cli->dispatch_recv;
1698
1699 /* In parameters */
1700
1701 /* Out parameters */
1702
1703 /* Result */
1704 ZERO_STRUCT(state->orig.out.result);
1705
1706 if (DEBUGLEVEL >= 10) {
1707 NDR_PRINT_IN_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &state->orig);
1708 }
1709
1710 /* make a temporary copy, that we pass to the dispatch function */
1711 state->tmp = state->orig;
1712
1713 subreq = cli->dispatch_send(state, ev, cli,
1714 &ndr_table_drsuapi,
1715 NDR_DRSUAPI_INTER_DOMAIN_MOVE,
1716 &state->tmp);
1717 if (tevent_req_nomem(subreq, req)) {
1718 return tevent_req_post(req, ev);
1719 }
1720 tevent_req_set_callback(subreq, rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done, req);
1721 return req;
1722 }
1723
1724 static void rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done(struct tevent_req *subreq)
1725 {
1726 struct tevent_req *req = tevent_req_callback_data(
1727 subreq, struct tevent_req);
1728 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state = tevent_req_data(
1729 req, struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1730 NTSTATUS status;
1731 TALLOC_CTX *mem_ctx;
1732
1733 if (state->out_mem_ctx) {
1734 mem_ctx = state->out_mem_ctx;
1735 } else {
1736 mem_ctx = state;
1737 }
1738
1739 status = state->dispatch_recv(subreq, mem_ctx);
1740 TALLOC_FREE(subreq);
1741 if (!NT_STATUS_IS_OK(status)) {
1742 tevent_req_nterror(req, status);
1743 return;
1744 }
1745
1746 /* Copy out parameters */
1747
1748 /* Copy result */
1749 state->orig.out.result = state->tmp.out.result;
1750
1751 /* Reset temporary structure */
1752 ZERO_STRUCT(state->tmp);
1753
1754 if (DEBUGLEVEL >= 10) {
1755 NDR_PRINT_OUT_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &state->orig);
1756 }
1757
1758 tevent_req_done(req);
1759 }
1760
1761 NTSTATUS rpccli_DRSUAPI_INTER_DOMAIN_MOVE_recv(struct tevent_req *req,
1762 TALLOC_CTX *mem_ctx,
1763 WERROR *result)
1764 {
1765 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state = tevent_req_data(
1766 req, struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1767 NTSTATUS status;
1768
1769 if (tevent_req_is_nterror(req, &status)) {
1770 tevent_req_received(req);
1771 return status;
1772 }
1773
1774 /* Steal possbile out parameters to the callers context */
1775 talloc_steal(mem_ctx, state->out_mem_ctx);
1776
1777 /* Return result */
1778 *result = state->orig.out.result;
1779
1780 tevent_req_received(req);
1781 return NT_STATUS_OK;
1782 }
1783
1784 NTSTATUS rpccli_DRSUAPI_INTER_DOMAIN_MOVE(struct rpc_pipe_client *cli,
1785 TALLOC_CTX *mem_ctx,
1786 WERROR *werror)
1787 {
1788 struct DRSUAPI_INTER_DOMAIN_MOVE r;
1789 NTSTATUS status;
1790
1791 /* In parameters */
1792
1793 if (DEBUGLEVEL >= 10) {
1794 NDR_PRINT_IN_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &r);
1795 }
1796
1797 status = cli->dispatch(cli,
1798 mem_ctx,
1799 &ndr_table_drsuapi,
1800 NDR_DRSUAPI_INTER_DOMAIN_MOVE,
1801 &r);
1802
1803 if (!NT_STATUS_IS_OK(status)) {
1804 return status;
1805 }
1806
1807 if (DEBUGLEVEL >= 10) {
1808 NDR_PRINT_OUT_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &r);
1809 }
1810
1811 if (NT_STATUS_IS_ERR(status)) {
1812 return status;
1813 }
1814
1815 /* Return variables */
1816
1817 /* Return result */
1818 if (werror) {
1819 *werror = r.out.result;
1820 }
1821
1822 return werror_to_ntstatus(r.out.result);
1823 }
1824
1825 struct rpccli_drsuapi_DsGetNT4ChangeLog_state {
1826 struct drsuapi_DsGetNT4ChangeLog orig;
1827 struct drsuapi_DsGetNT4ChangeLog tmp;
1828 TALLOC_CTX *out_mem_ctx;
1829 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1830 };
1831
1832 static void rpccli_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq);
1833
1834 struct tevent_req *rpccli_drsuapi_DsGetNT4ChangeLog_send(TALLOC_CTX *mem_ctx,
1835 struct tevent_context *ev,
1836 struct rpc_pipe_client *cli,
1837 struct policy_handle *_bind_handle /* [in] [ref] */,
1838 uint32_t _level /* [in] */,
1839 union drsuapi_DsGetNT4ChangeLogRequest *_req /* [in] [ref,switch_is(level)] */,
1840 uint32_t *_level_out /* [out] [ref] */,
1841 union drsuapi_DsGetNT4ChangeLogInfo *_info /* [out] [ref,switch_is(*level_out)] */)
1842 {
1843 struct tevent_req *req;
1844 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state;
1845 struct tevent_req *subreq;
1846
1847 req = tevent_req_create(mem_ctx, &state,
1848 struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1849 if (req == NULL) {
1850 return NULL;
1851 }
1852 state->out_mem_ctx = NULL;
1853 state->dispatch_recv = cli->dispatch_recv;
1854
1855 /* In parameters */
1856 state->orig.in.bind_handle = _bind_handle;
1857 state->orig.in.level = _level;
1858 state->orig.in.req = _req;
1859
1860 /* Out parameters */
1861 state->orig.out.level_out = _level_out;
1862 state->orig.out.info = _info;
1863
1864 /* Result */
1865 ZERO_STRUCT(state->orig.out.result);
1866
1867 if (DEBUGLEVEL >= 10) {
1868 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNT4ChangeLog, &state->orig);
1869 }
1870
1871 state->out_mem_ctx = talloc_named_const(state, 0,
1872 "rpccli_drsuapi_DsGetNT4ChangeLog_out_memory");
1873 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1874 return tevent_req_post(req, ev);
1875 }
1876
1877 /* make a temporary copy, that we pass to the dispatch function */
1878 state->tmp = state->orig;
1879
1880 subreq = cli->dispatch_send(state, ev, cli,
1881 &ndr_table_drsuapi,
1882 NDR_DRSUAPI_DSGETNT4CHANGELOG,
1883 &state->tmp);
1884 if (tevent_req_nomem(subreq, req)) {
1885 return tevent_req_post(req, ev);
1886 }
1887 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetNT4ChangeLog_done, req);
1888 return req;
1889 }
1890
1891 static void rpccli_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq)
1892 {
1893 struct tevent_req *req = tevent_req_callback_data(
1894 subreq, struct tevent_req);
1895 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
1896 req, struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1897 NTSTATUS status;
1898 TALLOC_CTX *mem_ctx;
1899
1900 if (state->out_mem_ctx) {
1901 mem_ctx = state->out_mem_ctx;
1902 } else {
1903 mem_ctx = state;
1904 }
1905
1906 status = state->dispatch_recv(subreq, mem_ctx);
1907 TALLOC_FREE(subreq);
1908 if (!NT_STATUS_IS_OK(status)) {
1909 tevent_req_nterror(req, status);
1910 return;
1911 }
1912
1913 /* Copy out parameters */
1914 *state->orig.out.level_out = *state->tmp.out.level_out;
1915 *state->orig.out.info = *state->tmp.out.info;
1916
1917 /* Copy result */
1918 state->orig.out.result = state->tmp.out.result;
1919
1920 /* Reset temporary structure */
1921 ZERO_STRUCT(state->tmp);
1922
1923 if (DEBUGLEVEL >= 10) {
1924 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNT4ChangeLog, &state->orig);
1925 }
1926
1927 tevent_req_done(req);
1928 }
1929
1930 NTSTATUS rpccli_drsuapi_DsGetNT4ChangeLog_recv(struct tevent_req *req,
1931 TALLOC_CTX *mem_ctx,
1932 WERROR *result)
1933 {
1934 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
1935 req, struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1936 NTSTATUS status;
1937
1938 if (tevent_req_is_nterror(req, &status)) {
1939 tevent_req_received(req);
1940 return status;
1941 }
1942
1943 /* Steal possbile out parameters to the callers context */
1944 talloc_steal(mem_ctx, state->out_mem_ctx);
1945
1946 /* Return result */
1947 *result = state->orig.out.result;
1948
1949 tevent_req_received(req);
1950 return NT_STATUS_OK;
1951 }
1952
1953 NTSTATUS rpccli_drsuapi_DsGetNT4ChangeLog(struct rpc_pipe_client *cli,
1954 TALLOC_CTX *mem_ctx,
1955 struct policy_handle *bind_handle /* [in] [ref] */,
1956 uint32_t level /* [in] */,
1957 union drsuapi_DsGetNT4ChangeLogRequest *req /* [in] [ref,switch_is(level)] */,
1958 uint32_t *level_out /* [out] [ref] */,
1959 union drsuapi_DsGetNT4ChangeLogInfo *info /* [out] [ref,switch_is(*level_out)] */,
1960 WERROR *werror)
1961 {
1962 struct drsuapi_DsGetNT4ChangeLog r;
1963 NTSTATUS status;
1964
1965 /* In parameters */
1966 r.in.bind_handle = bind_handle;
1967 r.in.level = level;
1968 r.in.req = req;
1969
1970 if (DEBUGLEVEL >= 10) {
1971 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNT4ChangeLog, &r);
1972 }
1973
1974 status = cli->dispatch(cli,
1975 mem_ctx,
1976 &ndr_table_drsuapi,
1977 NDR_DRSUAPI_DSGETNT4CHANGELOG,
1978 &r);
1979
1980 if (!NT_STATUS_IS_OK(status)) {
1981 return status;
1982 }
1983
1984 if (DEBUGLEVEL >= 10) {
1985 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNT4ChangeLog, &r);
1986 }
1987
1988 if (NT_STATUS_IS_ERR(status)) {
1989 return status;
1990 }
1991
1992 /* Return variables */
1993 *level_out = *r.out.level_out;
1994 *info = *r.out.info;
1995
1996 /* Return result */
1997 if (werror) {
1998 *werror = r.out.result;
1999 }
2000
2001 return werror_to_ntstatus(r.out.result);
2002 }
2003
2004 struct rpccli_drsuapi_DsCrackNames_state {
2005 struct drsuapi_DsCrackNames orig;
2006 struct drsuapi_DsCrackNames tmp;
2007 TALLOC_CTX *out_mem_ctx;
2008 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2009 };
2010
2011 static void rpccli_drsuapi_DsCrackNames_done(struct tevent_req *subreq);
2012
2013 struct tevent_req *rpccli_drsuapi_DsCrackNames_send(TALLOC_CTX *mem_ctx,
2014 struct tevent_context *ev,
2015 struct rpc_pipe_client *cli,
2016 struct policy_handle *_bind_handle /* [in] [ref] */,
2017 int32_t _level /* [in] */,
2018 union drsuapi_DsNameRequest *_req /* [in] [ref,switch_is(level)] */,
2019 int32_t *_level_out /* [out] [ref] */,
2020 union drsuapi_DsNameCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
2021 {
2022 struct tevent_req *req;
2023 struct rpccli_drsuapi_DsCrackNames_state *state;
2024 struct tevent_req *subreq;
2025
2026 req = tevent_req_create(mem_ctx, &state,
2027 struct rpccli_drsuapi_DsCrackNames_state);
2028 if (req == NULL) {
2029 return NULL;
2030 }
2031 state->out_mem_ctx = NULL;
2032 state->dispatch_recv = cli->dispatch_recv;
2033
2034 /* In parameters */
2035 state->orig.in.bind_handle = _bind_handle;
2036 state->orig.in.level = _level;
2037 state->orig.in.req = _req;
2038
2039 /* Out parameters */
2040 state->orig.out.level_out = _level_out;
2041 state->orig.out.ctr = _ctr;
2042
2043 /* Result */
2044 ZERO_STRUCT(state->orig.out.result);
2045
2046 if (DEBUGLEVEL >= 10) {
2047 NDR_PRINT_IN_DEBUG(drsuapi_DsCrackNames, &state->orig);
2048 }
2049
2050 state->out_mem_ctx = talloc_named_const(state, 0,
2051 "rpccli_drsuapi_DsCrackNames_out_memory");
2052 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2053 return tevent_req_post(req, ev);
2054 }
2055
2056 /* make a temporary copy, that we pass to the dispatch function */
2057 state->tmp = state->orig;
2058
2059 subreq = cli->dispatch_send(state, ev, cli,
2060 &ndr_table_drsuapi,
2061 NDR_DRSUAPI_DSCRACKNAMES,
2062 &state->tmp);
2063 if (tevent_req_nomem(subreq, req)) {
2064 return tevent_req_post(req, ev);
2065 }
2066 tevent_req_set_callback(subreq, rpccli_drsuapi_DsCrackNames_done, req);
2067 return req;
2068 }
2069
2070 static void rpccli_drsuapi_DsCrackNames_done(struct tevent_req *subreq)
2071 {
2072 struct tevent_req *req = tevent_req_callback_data(
2073 subreq, struct tevent_req);
2074 struct rpccli_drsuapi_DsCrackNames_state *state = tevent_req_data(
2075 req, struct rpccli_drsuapi_DsCrackNames_state);
2076 NTSTATUS status;
2077 TALLOC_CTX *mem_ctx;
2078
2079 if (state->out_mem_ctx) {
2080 mem_ctx = state->out_mem_ctx;
2081 } else {
2082 mem_ctx = state;
2083 }
2084
2085 status = state->dispatch_recv(subreq, mem_ctx);
2086 TALLOC_FREE(subreq);
2087 if (!NT_STATUS_IS_OK(status)) {
2088 tevent_req_nterror(req, status);
2089 return;
2090 }
2091
2092 /* Copy out parameters */
2093 *state->orig.out.level_out = *state->tmp.out.level_out;
2094 *state->orig.out.ctr = *state->tmp.out.ctr;
2095
2096 /* Copy result */
2097 state->orig.out.result = state->tmp.out.result;
2098
2099 /* Reset temporary structure */
2100 ZERO_STRUCT(state->tmp);
2101
2102 if (DEBUGLEVEL >= 10) {
2103 NDR_PRINT_OUT_DEBUG(drsuapi_DsCrackNames, &state->orig);
2104 }
2105
2106 tevent_req_done(req);
2107 }
2108
2109 NTSTATUS rpccli_drsuapi_DsCrackNames_recv(struct tevent_req *req,
2110 TALLOC_CTX *mem_ctx,
2111 WERROR *result)
2112 {
2113 struct rpccli_drsuapi_DsCrackNames_state *state = tevent_req_data(
2114 req, struct rpccli_drsuapi_DsCrackNames_state);
2115 NTSTATUS status;
2116
2117 if (tevent_req_is_nterror(req, &status)) {
2118 tevent_req_received(req);
2119 return status;
2120 }
2121
2122 /* Steal possbile out parameters to the callers context */
2123 talloc_steal(mem_ctx, state->out_mem_ctx);
2124
2125 /* Return result */
2126 *result = state->orig.out.result;
2127
2128 tevent_req_received(req);
2129 return NT_STATUS_OK;
2130 }
2131
2132 NTSTATUS rpccli_drsuapi_DsCrackNames(struct rpc_pipe_client *cli,
2133 TALLOC_CTX *mem_ctx,
2134 struct policy_handle *bind_handle /* [in] [ref] */,
2135 int32_t level /* [in] */,
2136 union drsuapi_DsNameRequest *req /* [in] [ref,switch_is(level)] */,
2137 int32_t *level_out /* [out] [ref] */,
2138 union drsuapi_DsNameCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
2139 WERROR *werror)
2140 {
2141 struct drsuapi_DsCrackNames r;
2142 NTSTATUS status;
2143
2144 /* In parameters */
2145 r.in.bind_handle = bind_handle;
2146 r.in.level = level;
2147 r.in.req = req;
2148
2149 if (DEBUGLEVEL >= 10) {
2150 NDR_PRINT_IN_DEBUG(drsuapi_DsCrackNames, &r);
2151 }
2152
2153 status = cli->dispatch(cli,
2154 mem_ctx,
2155 &ndr_table_drsuapi,
2156 NDR_DRSUAPI_DSCRACKNAMES,
2157 &r);
2158
2159 if (!NT_STATUS_IS_OK(status)) {
2160 return status;
2161 }
2162
2163 if (DEBUGLEVEL >= 10) {
2164 NDR_PRINT_OUT_DEBUG(drsuapi_DsCrackNames, &r);
2165 }
2166
2167 if (NT_STATUS_IS_ERR(status)) {
2168 return status;
2169 }
2170
2171 /* Return variables */
2172 *level_out = *r.out.level_out;
2173 *ctr = *r.out.ctr;
2174
2175 /* Return result */
2176 if (werror) {
2177 *werror = r.out.result;
2178 }
2179
2180 return werror_to_ntstatus(r.out.result);
2181 }
2182
2183 struct rpccli_drsuapi_DsWriteAccountSpn_state {
2184 struct drsuapi_DsWriteAccountSpn orig;
2185 struct drsuapi_DsWriteAccountSpn tmp;
2186 TALLOC_CTX *out_mem_ctx;
2187 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2188 };
2189
2190 static void rpccli_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq);
2191
2192 struct tevent_req *rpccli_drsuapi_DsWriteAccountSpn_send(TALLOC_CTX *mem_ctx,
2193 struct tevent_context *ev,
2194 struct rpc_pipe_client *cli,
2195 struct policy_handle *_bind_handle /* [in] [ref] */,
2196 int32_t _level /* [in] */,
2197 union drsuapi_DsWriteAccountSpnRequest *_req /* [in] [ref,switch_is(level)] */,
2198 int32_t *_level_out /* [out] [ref] */,
2199 union drsuapi_DsWriteAccountSpnResult *_res /* [out] [ref,switch_is(*level_out)] */)
2200 {
2201 struct tevent_req *req;
2202 struct rpccli_drsuapi_DsWriteAccountSpn_state *state;
2203 struct tevent_req *subreq;
2204
2205 req = tevent_req_create(mem_ctx, &state,
2206 struct rpccli_drsuapi_DsWriteAccountSpn_state);
2207 if (req == NULL) {
2208 return NULL;
2209 }
2210 state->out_mem_ctx = NULL;
2211 state->dispatch_recv = cli->dispatch_recv;
2212
2213 /* In parameters */
2214 state->orig.in.bind_handle = _bind_handle;
2215 state->orig.in.level = _level;
2216 state->orig.in.req = _req;
2217
2218 /* Out parameters */
2219 state->orig.out.level_out = _level_out;
2220 state->orig.out.res = _res;
2221
2222 /* Result */
2223 ZERO_STRUCT(state->orig.out.result);
2224
2225 if (DEBUGLEVEL >= 10) {
2226 NDR_PRINT_IN_DEBUG(drsuapi_DsWriteAccountSpn, &state->orig);
2227 }
2228
2229 state->out_mem_ctx = talloc_named_const(state, 0,
2230 "rpccli_drsuapi_DsWriteAccountSpn_out_memory");
2231 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2232 return tevent_req_post(req, ev);
2233 }
2234
2235 /* make a temporary copy, that we pass to the dispatch function */
2236 state->tmp = state->orig;
2237
2238 subreq = cli->dispatch_send(state, ev, cli,
2239 &ndr_table_drsuapi,
2240 NDR_DRSUAPI_DSWRITEACCOUNTSPN,
2241 &state->tmp);
2242 if (tevent_req_nomem(subreq, req)) {
2243 return tevent_req_post(req, ev);
2244 }
2245 tevent_req_set_callback(subreq, rpccli_drsuapi_DsWriteAccountSpn_done, req);
2246 return req;
2247 }
2248
2249 static void rpccli_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq)
2250 {
2251 struct tevent_req *req = tevent_req_callback_data(
2252 subreq, struct tevent_req);
2253 struct rpccli_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
2254 req, struct rpccli_drsuapi_DsWriteAccountSpn_state);
2255 NTSTATUS status;
2256 TALLOC_CTX *mem_ctx;
2257
2258 if (state->out_mem_ctx) {
2259 mem_ctx = state->out_mem_ctx;
2260 } else {
2261 mem_ctx = state;
2262 }
2263
2264 status = state->dispatch_recv(subreq, mem_ctx);
2265 TALLOC_FREE(subreq);
2266 if (!NT_STATUS_IS_OK(status)) {
2267 tevent_req_nterror(req, status);
2268 return;
2269 }
2270
2271 /* Copy out parameters */
2272 *state->orig.out.level_out = *state->tmp.out.level_out;
2273 *state->orig.out.res = *state->tmp.out.res;
2274
2275 /* Copy result */
2276 state->orig.out.result = state->tmp.out.result;
2277
2278 /* Reset temporary structure */
2279 ZERO_STRUCT(state->tmp);
2280
2281 if (DEBUGLEVEL >= 10) {
2282 NDR_PRINT_OUT_DEBUG(drsuapi_DsWriteAccountSpn, &state->orig);
2283 }
2284
2285 tevent_req_done(req);
2286 }
2287
2288 NTSTATUS rpccli_drsuapi_DsWriteAccountSpn_recv(struct tevent_req *req,
2289 TALLOC_CTX *mem_ctx,
2290 WERROR *result)
2291 {
2292 struct rpccli_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
2293 req, struct rpccli_drsuapi_DsWriteAccountSpn_state);
2294 NTSTATUS status;
2295
2296 if (tevent_req_is_nterror(req, &status)) {
2297 tevent_req_received(req);
2298 return status;
2299 }
2300
2301 /* Steal possbile out parameters to the callers context */
2302 talloc_steal(mem_ctx, state->out_mem_ctx);
2303
2304 /* Return result */
2305 *result = state->orig.out.result;
2306
2307 tevent_req_received(req);
2308 return NT_STATUS_OK;
2309 }
2310
2311 NTSTATUS rpccli_drsuapi_DsWriteAccountSpn(struct rpc_pipe_client *cli,
2312 TALLOC_CTX *mem_ctx,
2313 struct policy_handle *bind_handle /* [in] [ref] */,
2314 int32_t level /* [in] */,
2315 union drsuapi_DsWriteAccountSpnRequest *req /* [in] [ref,switch_is(level)] */,
2316 int32_t *level_out /* [out] [ref] */,
2317 union drsuapi_DsWriteAccountSpnResult *res /* [out] [ref,switch_is(*level_out)] */,
2318 WERROR *werror)
2319 {
2320 struct drsuapi_DsWriteAccountSpn r;
2321 NTSTATUS status;
2322
2323 /* In parameters */
2324 r.in.bind_handle = bind_handle;
2325 r.in.level = level;
2326 r.in.req = req;
2327
2328 if (DEBUGLEVEL >= 10) {
2329 NDR_PRINT_IN_DEBUG(drsuapi_DsWriteAccountSpn, &r);
2330 }
2331
2332 status = cli->dispatch(cli,
2333 mem_ctx,
2334 &ndr_table_drsuapi,
2335 NDR_DRSUAPI_DSWRITEACCOUNTSPN,
2336 &r);
2337
2338 if (!NT_STATUS_IS_OK(status)) {
2339 return status;
2340 }
2341
2342 if (DEBUGLEVEL >= 10) {
2343 NDR_PRINT_OUT_DEBUG(drsuapi_DsWriteAccountSpn, &r);
2344 }
2345
2346 if (NT_STATUS_IS_ERR(status)) {
2347 return status;
2348 }
2349
2350 /* Return variables */
2351 *level_out = *r.out.level_out;
2352 *res = *r.out.res;
2353
2354 /* Return result */
2355 if (werror) {
2356 *werror = r.out.result;
2357 }
2358
2359 return werror_to_ntstatus(r.out.result);
2360 }
2361
2362 struct rpccli_drsuapi_DsRemoveDSServer_state {
2363 struct drsuapi_DsRemoveDSServer orig;
2364 struct drsuapi_DsRemoveDSServer tmp;
2365 TALLOC_CTX *out_mem_ctx;
2366 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2367 };
2368
2369 static void rpccli_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq);
2370
2371 struct tevent_req *rpccli_drsuapi_DsRemoveDSServer_send(TALLOC_CTX *mem_ctx,
2372 struct tevent_context *ev,
2373 struct rpc_pipe_client *cli,
2374 struct policy_handle *_bind_handle /* [in] [ref] */,
2375 int32_t _level /* [in] */,
2376 union drsuapi_DsRemoveDSServerRequest *_req /* [in] [ref,switch_is(level)] */,
2377 int32_t *_level_out /* [out] [ref] */,
2378 union drsuapi_DsRemoveDSServerResult *_res /* [out] [ref,switch_is(*level_out)] */)
2379 {
2380 struct tevent_req *req;
2381 struct rpccli_drsuapi_DsRemoveDSServer_state *state;
2382 struct tevent_req *subreq;
2383
2384 req = tevent_req_create(mem_ctx, &state,
2385 struct rpccli_drsuapi_DsRemoveDSServer_state);
2386 if (req == NULL) {
2387 return NULL;
2388 }
2389 state->out_mem_ctx = NULL;
2390 state->dispatch_recv = cli->dispatch_recv;
2391
2392 /* In parameters */
2393 state->orig.in.bind_handle = _bind_handle;
2394 state->orig.in.level = _level;
2395 state->orig.in.req = _req;
2396
2397 /* Out parameters */
2398 state->orig.out.level_out = _level_out;
2399 state->orig.out.res = _res;
2400
2401 /* Result */
2402 ZERO_STRUCT(state->orig.out.result);
2403
2404 if (DEBUGLEVEL >= 10) {
2405 NDR_PRINT_IN_DEBUG(drsuapi_DsRemoveDSServer, &state->orig);
2406 }
2407
2408 state->out_mem_ctx = talloc_named_const(state, 0,
2409 "rpccli_drsuapi_DsRemoveDSServer_out_memory");
2410 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2411 return tevent_req_post(req, ev);
2412 }
2413
2414 /* make a temporary copy, that we pass to the dispatch function */
2415 state->tmp = state->orig;
2416
2417 subreq = cli->dispatch_send(state, ev, cli,
2418 &ndr_table_drsuapi,
2419 NDR_DRSUAPI_DSREMOVEDSSERVER,
2420 &state->tmp);
2421 if (tevent_req_nomem(subreq, req)) {
2422 return tevent_req_post(req, ev);
2423 }
2424 tevent_req_set_callback(subreq, rpccli_drsuapi_DsRemoveDSServer_done, req);
2425 return req;
2426 }
2427
2428 static void rpccli_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq)
2429 {
2430 struct tevent_req *req = tevent_req_callback_data(
2431 subreq, struct tevent_req);
2432 struct rpccli_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
2433 req, struct rpccli_drsuapi_DsRemoveDSServer_state);
2434 NTSTATUS status;
2435 TALLOC_CTX *mem_ctx;
2436
2437 if (state->out_mem_ctx) {
2438 mem_ctx = state->out_mem_ctx;
2439 } else {
2440 mem_ctx = state;
2441 }
2442
2443 status = state->dispatch_recv(subreq, mem_ctx);
2444 TALLOC_FREE(subreq);
2445 if (!NT_STATUS_IS_OK(status)) {
2446 tevent_req_nterror(req, status);
2447 return;
2448 }
2449
2450 /* Copy out parameters */
2451 *state->orig.out.level_out = *state->tmp.out.level_out;
2452 *state->orig.out.res = *state->tmp.out.res;
2453
2454 /* Copy result */
2455 state->orig.out.result = state->tmp.out.result;
2456
2457 /* Reset temporary structure */
2458 ZERO_STRUCT(state->tmp);
2459
2460 if (DEBUGLEVEL >= 10) {
2461 NDR_PRINT_OUT_DEBUG(drsuapi_DsRemoveDSServer, &state->orig);
2462 }
2463
2464 tevent_req_done(req);
2465 }
2466
2467 NTSTATUS rpccli_drsuapi_DsRemoveDSServer_recv(struct tevent_req *req,
2468 TALLOC_CTX *mem_ctx,
2469 WERROR *result)
2470 {
2471 struct rpccli_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
2472 req, struct rpccli_drsuapi_DsRemoveDSServer_state);
2473 NTSTATUS status;
2474
2475 if (tevent_req_is_nterror(req, &status)) {
2476 tevent_req_received(req);
2477 return status;
2478 }
2479
2480 /* Steal possbile out parameters to the callers context */
2481 talloc_steal(mem_ctx, state->out_mem_ctx);
2482
2483 /* Return result */
2484 *result = state->orig.out.result;
2485
2486 tevent_req_received(req);
2487 return NT_STATUS_OK;
2488 }
2489
2490 NTSTATUS rpccli_drsuapi_DsRemoveDSServer(struct rpc_pipe_client *cli,
2491 TALLOC_CTX *mem_ctx,
2492 struct policy_handle *bind_handle /* [in] [ref] */,
2493 int32_t level /* [in] */,
2494 union drsuapi_DsRemoveDSServerRequest *req /* [in] [ref,switch_is(level)] */,
2495 int32_t *level_out /* [out] [ref] */,
2496 union drsuapi_DsRemoveDSServerResult *res /* [out] [ref,switch_is(*level_out)] */,
2497 WERROR *werror)
2498 {
2499 struct drsuapi_DsRemoveDSServer r;
2500 NTSTATUS status;
2501
2502 /* In parameters */
2503 r.in.bind_handle = bind_handle;
2504 r.in.level = level;
2505 r.in.req = req;
2506
2507 if (DEBUGLEVEL >= 10) {
2508 NDR_PRINT_IN_DEBUG(drsuapi_DsRemoveDSServer, &r);
2509 }
2510
2511 status = cli->dispatch(cli,
2512 mem_ctx,
2513 &ndr_table_drsuapi,
2514 NDR_DRSUAPI_DSREMOVEDSSERVER,
2515 &r);
2516
2517 if (!NT_STATUS_IS_OK(status)) {
2518 return status;
2519 }
2520
2521 if (DEBUGLEVEL >= 10) {
2522 NDR_PRINT_OUT_DEBUG(drsuapi_DsRemoveDSServer, &r);
2523 }
2524
2525 if (NT_STATUS_IS_ERR(status)) {
2526 return status;
2527 }
2528
2529 /* Return variables */
2530 *level_out = *r.out.level_out;
2531 *res = *r.out.res;
2532
2533 /* Return result */
2534 if (werror) {
2535 *werror = r.out.result;
2536 }
2537
2538 return werror_to_ntstatus(r.out.result);
2539 }
2540
2541 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state {
2542 struct DRSUAPI_REMOVE_DS_DOMAIN orig;
2543 struct DRSUAPI_REMOVE_DS_DOMAIN tmp;
2544 TALLOC_CTX *out_mem_ctx;
2545 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2546 };
2547
2548 static void rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done(struct tevent_req *subreq);
2549
2550 struct tevent_req *rpccli_DRSUAPI_REMOVE_DS_DOMAIN_send(TALLOC_CTX *mem_ctx,
2551 struct tevent_context *ev,
2552 struct rpc_pipe_client *cli)
2553 {
2554 struct tevent_req *req;
2555 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state;
2556 struct tevent_req *subreq;
2557
2558 req = tevent_req_create(mem_ctx, &state,
2559 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2560 if (req == NULL) {
2561 return NULL;
2562 }
2563 state->out_mem_ctx = NULL;
2564 state->dispatch_recv = cli->dispatch_recv;
2565
2566 /* In parameters */
2567
2568 /* Out parameters */
2569
2570 /* Result */
2571 ZERO_STRUCT(state->orig.out.result);
2572
2573 if (DEBUGLEVEL >= 10) {
2574 NDR_PRINT_IN_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &state->orig);
2575 }
2576
2577 /* make a temporary copy, that we pass to the dispatch function */
2578 state->tmp = state->orig;
2579
2580 subreq = cli->dispatch_send(state, ev, cli,
2581 &ndr_table_drsuapi,
2582 NDR_DRSUAPI_REMOVE_DS_DOMAIN,
2583 &state->tmp);
2584 if (tevent_req_nomem(subreq, req)) {
2585 return tevent_req_post(req, ev);
2586 }
2587 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done, req);
2588 return req;
2589 }
2590
2591 static void rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done(struct tevent_req *subreq)
2592 {
2593 struct tevent_req *req = tevent_req_callback_data(
2594 subreq, struct tevent_req);
2595 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state = tevent_req_data(
2596 req, struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2597 NTSTATUS status;
2598 TALLOC_CTX *mem_ctx;
2599
2600 if (state->out_mem_ctx) {
2601 mem_ctx = state->out_mem_ctx;
2602 } else {
2603 mem_ctx = state;
2604 }
2605
2606 status = state->dispatch_recv(subreq, mem_ctx);
2607 TALLOC_FREE(subreq);
2608 if (!NT_STATUS_IS_OK(status)) {
2609 tevent_req_nterror(req, status);
2610 return;
2611 }
2612
2613 /* Copy out parameters */
2614
2615 /* Copy result */
2616 state->orig.out.result = state->tmp.out.result;
2617
2618 /* Reset temporary structure */
2619 ZERO_STRUCT(state->tmp);
2620
2621 if (DEBUGLEVEL >= 10) {
2622 NDR_PRINT_OUT_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &state->orig);
2623 }
2624
2625 tevent_req_done(req);
2626 }
2627
2628 NTSTATUS rpccli_DRSUAPI_REMOVE_DS_DOMAIN_recv(struct tevent_req *req,
2629 TALLOC_CTX *mem_ctx,
2630 WERROR *result)
2631 {
2632 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state = tevent_req_data(
2633 req, struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2634 NTSTATUS status;
2635
2636 if (tevent_req_is_nterror(req, &status)) {
2637 tevent_req_received(req);
2638 return status;
2639 }
2640
2641 /* Steal possbile out parameters to the callers context */
2642 talloc_steal(mem_ctx, state->out_mem_ctx);
2643
2644 /* Return result */
2645 *result = state->orig.out.result;
2646
2647 tevent_req_received(req);
2648 return NT_STATUS_OK;
2649 }
2650
2651 NTSTATUS rpccli_DRSUAPI_REMOVE_DS_DOMAIN(struct rpc_pipe_client *cli,
2652 TALLOC_CTX *mem_ctx,
2653 WERROR *werror)
2654 {
2655 struct DRSUAPI_REMOVE_DS_DOMAIN r;
2656 NTSTATUS status;
2657
2658 /* In parameters */
2659
2660 if (DEBUGLEVEL >= 10) {
2661 NDR_PRINT_IN_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &r);
2662 }
2663
2664 status = cli->dispatch(cli,
2665 mem_ctx,
2666 &ndr_table_drsuapi,
2667 NDR_DRSUAPI_REMOVE_DS_DOMAIN,
2668 &r);
2669
2670 if (!NT_STATUS_IS_OK(status)) {
2671 return status;
2672 }
2673
2674 if (DEBUGLEVEL >= 10) {
2675 NDR_PRINT_OUT_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &r);
2676 }
2677
2678 if (NT_STATUS_IS_ERR(status)) {
2679 return status;
2680 }
2681
2682 /* Return variables */
2683
2684 /* Return result */
2685 if (werror) {
2686 *werror = r.out.result;
2687 }
2688
2689 return werror_to_ntstatus(r.out.result);
2690 }
2691
2692 struct rpccli_drsuapi_DsGetDomainControllerInfo_state {
2693 struct drsuapi_DsGetDomainControllerInfo orig;
2694 struct drsuapi_DsGetDomainControllerInfo tmp;
2695 TALLOC_CTX *out_mem_ctx;
2696 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2697 };
2698
2699 static void rpccli_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq);
2700
2701 struct tevent_req *rpccli_drsuapi_DsGetDomainControllerInfo_send(TALLOC_CTX *mem_ctx,
2702 struct tevent_context *ev,
2703 struct rpc_pipe_client *cli,
2704 struct policy_handle *_bind_handle /* [in] [ref] */,
2705 int32_t _level /* [in] */,
2706 union drsuapi_DsGetDCInfoRequest *_req /* [in] [ref,switch_is(level)] */,
2707 int32_t *_level_out /* [out] [ref] */,
2708 union drsuapi_DsGetDCInfoCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
2709 {
2710 struct tevent_req *req;
2711 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state;
2712 struct tevent_req *subreq;
2713
2714 req = tevent_req_create(mem_ctx, &state,
2715 struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2716 if (req == NULL) {
2717 return NULL;
2718 }
2719 state->out_mem_ctx = NULL;
2720 state->dispatch_recv = cli->dispatch_recv;
2721
2722 /* In parameters */
2723 state->orig.in.bind_handle = _bind_handle;
2724 state->orig.in.level = _level;
2725 state->orig.in.req = _req;
2726
2727 /* Out parameters */
2728 state->orig.out.level_out = _level_out;
2729 state->orig.out.ctr = _ctr;
2730
2731 /* Result */
2732 ZERO_STRUCT(state->orig.out.result);
2733
2734 if (DEBUGLEVEL >= 10) {
2735 NDR_PRINT_IN_DEBUG(drsuapi_DsGetDomainControllerInfo, &state->orig);
2736 }
2737
2738 state->out_mem_ctx = talloc_named_const(state, 0,
2739 "rpccli_drsuapi_DsGetDomainControllerInfo_out_memory");
2740 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2741 return tevent_req_post(req, ev);
2742 }
2743
2744 /* make a temporary copy, that we pass to the dispatch function */
2745 state->tmp = state->orig;
2746
2747 subreq = cli->dispatch_send(state, ev, cli,
2748 &ndr_table_drsuapi,
2749 NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO,
2750 &state->tmp);
2751 if (tevent_req_nomem(subreq, req)) {
2752 return tevent_req_post(req, ev);
2753 }
2754 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetDomainControllerInfo_done, req);
2755 return req;
2756 }
2757
2758 static void rpccli_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq)
2759 {
2760 struct tevent_req *req = tevent_req_callback_data(
2761 subreq, struct tevent_req);
2762 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
2763 req, struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2764 NTSTATUS status;
2765 TALLOC_CTX *mem_ctx;
2766
2767 if (state->out_mem_ctx) {
2768 mem_ctx = state->out_mem_ctx;
2769 } else {
2770 mem_ctx = state;
2771 }
2772
2773 status = state->dispatch_recv(subreq, mem_ctx);
2774 TALLOC_FREE(subreq);
2775 if (!NT_STATUS_IS_OK(status)) {
2776 tevent_req_nterror(req, status);
2777 return;
2778 }
2779
2780 /* Copy out parameters */
2781 *state->orig.out.level_out = *state->tmp.out.level_out;
2782 *state->orig.out.ctr = *state->tmp.out.ctr;
2783
2784 /* Copy result */
2785 state->orig.out.result = state->tmp.out.result;
2786
2787 /* Reset temporary structure */
2788 ZERO_STRUCT(state->tmp);
2789
2790 if (DEBUGLEVEL >= 10) {
2791 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetDomainControllerInfo, &state->orig);
2792 }
2793
2794 tevent_req_done(req);
2795 }
2796
2797 NTSTATUS rpccli_drsuapi_DsGetDomainControllerInfo_recv(struct tevent_req *req,
2798 TALLOC_CTX *mem_ctx,
2799 WERROR *result)
2800 {
2801 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
2802 req, struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2803 NTSTATUS status;
2804
2805 if (tevent_req_is_nterror(req, &status)) {
2806 tevent_req_received(req);
2807 return status;
2808 }
2809
2810 /* Steal possbile out parameters to the callers context */
2811 talloc_steal(mem_ctx, state->out_mem_ctx);
2812
2813 /* Return result */
2814 *result = state->orig.out.result;
2815
2816 tevent_req_received(req);
2817 return NT_STATUS_OK;
2818 }
2819
2820 NTSTATUS rpccli_drsuapi_DsGetDomainControllerInfo(struct rpc_pipe_client *cli,
2821 TALLOC_CTX *mem_ctx,
2822 struct policy_handle *bind_handle /* [in] [ref] */,
2823 int32_t level /* [in] */,
2824 union drsuapi_DsGetDCInfoRequest *req /* [in] [ref,switch_is(level)] */,
2825 int32_t *level_out /* [out] [ref] */,
2826 union drsuapi_DsGetDCInfoCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
2827 WERROR *werror)
2828 {
2829 struct drsuapi_DsGetDomainControllerInfo r;
2830 NTSTATUS status;
2831
2832 /* In parameters */
2833 r.in.bind_handle = bind_handle;
2834 r.in.level = level;
2835 r.in.req = req;
2836
2837 if (DEBUGLEVEL >= 10) {
2838 NDR_PRINT_IN_DEBUG(drsuapi_DsGetDomainControllerInfo, &r);
2839 }
2840
2841 status = cli->dispatch(cli,
2842 mem_ctx,
2843 &ndr_table_drsuapi,
2844 NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO,
2845 &r);
2846
2847 if (!NT_STATUS_IS_OK(status)) {
2848 return status;
2849 }
2850
2851 if (DEBUGLEVEL >= 10) {
2852 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetDomainControllerInfo, &r);
2853 }
2854
2855 if (NT_STATUS_IS_ERR(status)) {
2856 return status;
2857 }
2858
2859 /* Return variables */
2860 *level_out = *r.out.level_out;
2861 *ctr = *r.out.ctr;
2862
2863 /* Return result */
2864 if (werror) {
2865 *werror = r.out.result;
2866 }
2867
2868 return werror_to_ntstatus(r.out.result);
2869 }
2870
2871 struct rpccli_drsuapi_DsAddEntry_state {
2872 struct drsuapi_DsAddEntry orig;
2873 struct drsuapi_DsAddEntry tmp;
2874 TALLOC_CTX *out_mem_ctx;
2875 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2876 };
2877
2878 static void rpccli_drsuapi_DsAddEntry_done(struct tevent_req *subreq);
2879
2880 struct tevent_req *rpccli_drsuapi_DsAddEntry_send(TALLOC_CTX *mem_ctx,
2881 struct tevent_context *ev,
2882 struct rpc_pipe_client *cli,
2883 struct policy_handle *_bind_handle /* [in] [ref] */,
2884 int32_t _level /* [in] */,
2885 union drsuapi_DsAddEntryRequest *_req /* [in] [ref,switch_is(level)] */,
2886 int32_t *_level_out /* [out] [ref] */,
2887 union drsuapi_DsAddEntryCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
2888 {
2889 struct tevent_req *req;
2890 struct rpccli_drsuapi_DsAddEntry_state *state;
2891 struct tevent_req *subreq;
2892
2893 req = tevent_req_create(mem_ctx, &state,
2894 struct rpccli_drsuapi_DsAddEntry_state);
2895 if (req == NULL) {
2896 return NULL;
2897 }
2898 state->out_mem_ctx = NULL;
2899 state->dispatch_recv = cli->dispatch_recv;
2900
2901 /* In parameters */
2902 state->orig.in.bind_handle = _bind_handle;
2903 state->orig.in.level = _level;
2904 state->orig.in.req = _req;
2905
2906 /* Out parameters */
2907 state->orig.out.level_out = _level_out;
2908 state->orig.out.ctr = _ctr;
2909
2910 /* Result */
2911 ZERO_STRUCT(state->orig.out.result);
2912
2913 if (DEBUGLEVEL >= 10) {
2914 NDR_PRINT_IN_DEBUG(drsuapi_DsAddEntry, &state->orig);
2915 }
2916
2917 state->out_mem_ctx = talloc_named_const(state, 0,
2918 "rpccli_drsuapi_DsAddEntry_out_memory");
2919 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2920 return tevent_req_post(req, ev);
2921 }
2922
2923 /* make a temporary copy, that we pass to the dispatch function */
2924 state->tmp = state->orig;
2925
2926 subreq = cli->dispatch_send(state, ev, cli,
2927 &ndr_table_drsuapi,
2928 NDR_DRSUAPI_DSADDENTRY,
2929 &state->tmp);
2930 if (tevent_req_nomem(subreq, req)) {
2931 return tevent_req_post(req, ev);
2932 }
2933 tevent_req_set_callback(subreq, rpccli_drsuapi_DsAddEntry_done, req);
2934 return req;
2935 }
2936
2937 static void rpccli_drsuapi_DsAddEntry_done(struct tevent_req *subreq)
2938 {
2939 struct tevent_req *req = tevent_req_callback_data(
2940 subreq, struct tevent_req);
2941 struct rpccli_drsuapi_DsAddEntry_state *state = tevent_req_data(
2942 req, struct rpccli_drsuapi_DsAddEntry_state);
2943 NTSTATUS status;
2944 TALLOC_CTX *mem_ctx;
2945
2946 if (state->out_mem_ctx) {
2947 mem_ctx = state->out_mem_ctx;
2948 } else {
2949 mem_ctx = state;
2950 }
2951
2952 status = state->dispatch_recv(subreq, mem_ctx);
2953 TALLOC_FREE(subreq);
2954 if (!NT_STATUS_IS_OK(status)) {
2955 tevent_req_nterror(req, status);
2956 return;
2957 }
2958
2959 /* Copy out parameters */
2960 *state->orig.out.level_out = *state->tmp.out.level_out;
2961 *state->orig.out.ctr = *state->tmp.out.ctr;
2962
2963 /* Copy result */
2964 state->orig.out.result = state->tmp.out.result;
2965
2966 /* Reset temporary structure */
2967 ZERO_STRUCT(state->tmp);
2968
2969 if (DEBUGLEVEL >= 10) {
2970 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, &state->orig);
2971 }
2972
2973 tevent_req_done(req);
2974 }
2975
2976 NTSTATUS rpccli_drsuapi_DsAddEntry_recv(struct tevent_req *req,
2977 TALLOC_CTX *mem_ctx,
2978 WERROR *result)
2979 {
2980 struct rpccli_drsuapi_DsAddEntry_state *state = tevent_req_data(
2981 req, struct rpccli_drsuapi_DsAddEntry_state);
2982 NTSTATUS status;
2983
2984 if (tevent_req_is_nterror(req, &status)) {
2985 tevent_req_received(req);
2986 return status;
2987 }
2988
2989 /* Steal possbile out parameters to the callers context */
2990 talloc_steal(mem_ctx, state->out_mem_ctx);
2991
2992 /* Return result */
2993 *result = state->orig.out.result;
2994
2995 tevent_req_received(req);
2996 return NT_STATUS_OK;
2997 }
2998
2999 NTSTATUS rpccli_drsuapi_DsAddEntry(struct rpc_pipe_client *cli,
3000 TALLOC_CTX *mem_ctx,
3001 struct policy_handle *bind_handle /* [in] [ref] */,
3002 int32_t level /* [in] */,
3003 union drsuapi_DsAddEntryRequest *req /* [in] [ref,switch_is(level)] */,
3004 int32_t *level_out /* [out] [ref] */,
3005 union drsuapi_DsAddEntryCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
3006 WERROR *werror)
3007 {
3008 struct drsuapi_DsAddEntry r;
3009 NTSTATUS status;
3010
3011 /* In parameters */
3012 r.in.bind_handle = bind_handle;
3013 r.in.level = level;
3014 r.in.req = req;
3015
3016 if (DEBUGLEVEL >= 10) {
3017 NDR_PRINT_IN_DEBUG(drsuapi_DsAddEntry, &r);
3018 }
3019
3020 status = cli->dispatch(cli,
3021 mem_ctx,
3022 &ndr_table_drsuapi,
3023 NDR_DRSUAPI_DSADDENTRY,
3024 &r);
3025
3026 if (!NT_STATUS_IS_OK(status)) {
3027 return status;
3028 }
3029
3030 if (DEBUGLEVEL >= 10) {
3031 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, &r);
3032 }
3033
3034 if (NT_STATUS_IS_ERR(status)) {
3035 return status;
3036 }
3037
3038 /* Return variables */
3039 *level_out = *r.out.level_out;
3040 *ctr = *r.out.ctr;
3041
3042 /* Return result */
3043 if (werror) {
3044 *werror = r.out.result;
3045 }
3046
3047 return werror_to_ntstatus(r.out.result);
3048 }
3049
3050 struct rpccli_drsuapi_DsExecuteKCC_state {
3051 struct drsuapi_DsExecuteKCC orig;
3052 struct drsuapi_DsExecuteKCC tmp;
3053 TALLOC_CTX *out_mem_ctx;
3054 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3055 };
3056
3057 static void rpccli_drsuapi_DsExecuteKCC_done(struct tevent_req *subreq);
3058
3059 struct tevent_req *rpccli_drsuapi_DsExecuteKCC_send(TALLOC_CTX *mem_ctx,
3060 struct tevent_context *ev,
3061 struct rpc_pipe_client *cli,
3062 struct policy_handle *_bind_handle /* [in] [ref] */,
3063 uint32_t _level /* [in] */,
3064 union drsuapi_DsExecuteKCCRequest *_req /* [in] [ref,switch_is(level)] */)
3065 {
3066 struct tevent_req *req;
3067 struct rpccli_drsuapi_DsExecuteKCC_state *state;
3068 struct tevent_req *subreq;
3069
3070 req = tevent_req_create(mem_ctx, &state,
3071 struct rpccli_drsuapi_DsExecuteKCC_state);
3072 if (req == NULL) {
3073 return NULL;
3074 }
3075 state->out_mem_ctx = NULL;
3076 state->dispatch_recv = cli->dispatch_recv;
3077
3078 /* In parameters */
3079 state->orig.in.bind_handle = _bind_handle;
3080 state->orig.in.level = _level;
3081 state->orig.in.req = _req;
3082
3083 /* Out parameters */
3084
3085 /* Result */
3086 ZERO_STRUCT(state->orig.out.result);
3087
3088 if (DEBUGLEVEL >= 10) {
3089 NDR_PRINT_IN_DEBUG(drsuapi_DsExecuteKCC, &state->orig);
3090 }
3091
3092 /* make a temporary copy, that we pass to the dispatch function */
3093 state->tmp = state->orig;
3094
3095 subreq = cli->dispatch_send(state, ev, cli,
3096 &ndr_table_drsuapi,
3097 NDR_DRSUAPI_DSEXECUTEKCC,
3098 &state->tmp);
3099 if (tevent_req_nomem(subreq, req)) {
3100 return tevent_req_post(req, ev);
3101 }
3102 tevent_req_set_callback(subreq, rpccli_drsuapi_DsExecuteKCC_done, req);
3103 return req;
3104 }
3105
3106 static void rpccli_drsuapi_DsExecuteKCC_done(struct tevent_req *subreq)
3107 {
3108 struct tevent_req *req = tevent_req_callback_data(
3109 subreq, struct tevent_req);
3110 struct rpccli_drsuapi_DsExecuteKCC_state *state = tevent_req_data(
3111 req, struct rpccli_drsuapi_DsExecuteKCC_state);
3112 NTSTATUS status;
3113 TALLOC_CTX *mem_ctx;
3114
3115 if (state->out_mem_ctx) {
3116 mem_ctx = state->out_mem_ctx;
3117 } else {
3118 mem_ctx = state;
3119 }
3120
3121 status = state->dispatch_recv(subreq, mem_ctx);
3122 TALLOC_FREE(subreq);
3123 if (!NT_STATUS_IS_OK(status)) {
3124 tevent_req_nterror(req, status);
3125 return;
3126 }
3127
3128 /* Copy out parameters */
3129
3130 /* Copy result */
3131 state->orig.out.result = state->tmp.out.result;
3132
3133 /* Reset temporary structure */
3134 ZERO_STRUCT(state->tmp);
3135
3136 if (DEBUGLEVEL >= 10) {
3137 NDR_PRINT_OUT_DEBUG(drsuapi_DsExecuteKCC, &state->orig);
3138 }
3139
3140 tevent_req_done(req);
3141 }
3142
3143 NTSTATUS rpccli_drsuapi_DsExecuteKCC_recv(struct tevent_req *req,
3144 TALLOC_CTX *mem_ctx,
3145 WERROR *result)
3146 {
3147 struct rpccli_drsuapi_DsExecuteKCC_state *state = tevent_req_data(
3148 req, struct rpccli_drsuapi_DsExecuteKCC_state);
3149 NTSTATUS status;
3150
3151 if (tevent_req_is_nterror(req, &status)) {
3152 tevent_req_received(req);
3153 return status;
3154 }
3155
3156 /* Steal possbile out parameters to the callers context */
3157 talloc_steal(mem_ctx, state->out_mem_ctx);
3158
3159 /* Return result */
3160 *result = state->orig.out.result;
3161
3162 tevent_req_received(req);
3163 return NT_STATUS_OK;
3164 }
3165
3166 NTSTATUS rpccli_drsuapi_DsExecuteKCC(struct rpc_pipe_client *cli,
3167 TALLOC_CTX *mem_ctx,
3168 struct policy_handle *bind_handle /* [in] [ref] */,
3169 uint32_t level /* [in] */,
3170 union drsuapi_DsExecuteKCCRequest *req /* [in] [ref,switch_is(level)] */,
3171 WERROR *werror)
3172 {
3173 struct drsuapi_DsExecuteKCC r;
3174 NTSTATUS status;
3175
3176 /* In parameters */
3177 r.in.bind_handle = bind_handle;
3178 r.in.level = level;
3179 r.in.req = req;
3180
3181 if (DEBUGLEVEL >= 10) {
3182 NDR_PRINT_IN_DEBUG(drsuapi_DsExecuteKCC, &r);
3183 }
3184
3185 status = cli->dispatch(cli,
3186 mem_ctx,
3187 &ndr_table_drsuapi,
3188 NDR_DRSUAPI_DSEXECUTEKCC,
3189 &r);
3190
3191 if (!NT_STATUS_IS_OK(status)) {
3192 return status;
3193 }
3194
3195 if (DEBUGLEVEL >= 10) {
3196 NDR_PRINT_OUT_DEBUG(drsuapi_DsExecuteKCC, &r);
3197 }
3198
3199 if (NT_STATUS_IS_ERR(status)) {
3200 return status;
3201 }
3202
3203 /* Return variables */
3204
3205 /* Return result */
3206 if (werror) {
3207 *werror = r.out.result;
3208 }
3209
3210 return werror_to_ntstatus(r.out.result);
3211 }
3212
3213 struct rpccli_drsuapi_DsReplicaGetInfo_state {
3214 struct drsuapi_DsReplicaGetInfo orig;
3215 struct drsuapi_DsReplicaGetInfo tmp;
3216 TALLOC_CTX *out_mem_ctx;
3217 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3218 };
3219
3220 static void rpccli_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq);
3221
3222 struct tevent_req *rpccli_drsuapi_DsReplicaGetInfo_send(TALLOC_CTX *mem_ctx,
3223 struct tevent_context *ev,
3224 struct rpc_pipe_client *cli,
3225 struct policy_handle *_bind_handle /* [in] [ref] */,
3226 enum drsuapi_DsReplicaGetInfoLevel _level /* [in] */,
3227 union drsuapi_DsReplicaGetInfoRequest *_req /* [in] [ref,switch_is(level)] */,
3228 enum drsuapi_DsReplicaInfoType *_info_type /* [out] [ref] */,
3229 union drsuapi_DsReplicaInfo *_info /* [out] [ref,switch_is(*info_type)] */)
3230 {
3231 struct tevent_req *req;
3232 struct rpccli_drsuapi_DsReplicaGetInfo_state *state;
3233 struct tevent_req *subreq;
3234
3235 req = tevent_req_create(mem_ctx, &state,
3236 struct rpccli_drsuapi_DsReplicaGetInfo_state);
3237 if (req == NULL) {
3238 return NULL;
3239 }
3240 state->out_mem_ctx = NULL;
3241 state->dispatch_recv = cli->dispatch_recv;
3242
3243 /* In parameters */
3244 state->orig.in.bind_handle = _bind_handle;
3245 state->orig.in.level = _level;
3246 state->orig.in.req = _req;
3247
3248 /* Out parameters */
3249 state->orig.out.info_type = _info_type;
3250 state->orig.out.info = _info;
3251
3252 /* Result */
3253 ZERO_STRUCT(state->orig.out.result);
3254
3255 if (DEBUGLEVEL >= 10) {
3256 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, &state->orig);
3257 }
3258
3259 state->out_mem_ctx = talloc_named_const(state, 0,
3260 "rpccli_drsuapi_DsReplicaGetInfo_out_memory");
3261 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3262 return tevent_req_post(req, ev);
3263 }
3264
3265 /* make a temporary copy, that we pass to the dispatch function */
3266 state->tmp = state->orig;
3267
3268 subreq = cli->dispatch_send(state, ev, cli,
3269 &ndr_table_drsuapi,
3270 NDR_DRSUAPI_DSREPLICAGETINFO,
3271 &state->tmp);
3272 if (tevent_req_nomem(subreq, req)) {
3273 return tevent_req_post(req, ev);
3274 }
3275 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaGetInfo_done, req);
3276 return req;
3277 }
3278
3279 static void rpccli_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq)
3280 {
3281 struct tevent_req *req = tevent_req_callback_data(
3282 subreq, struct tevent_req);
3283 struct rpccli_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
3284 req, struct rpccli_drsuapi_DsReplicaGetInfo_state);
3285 NTSTATUS status;
3286 TALLOC_CTX *mem_ctx;
3287
3288 if (state->out_mem_ctx) {
3289 mem_ctx = state->out_mem_ctx;
3290 } else {
3291 mem_ctx = state;
3292 }
3293
3294 status = state->dispatch_recv(subreq, mem_ctx);
3295 TALLOC_FREE(subreq);
3296 if (!NT_STATUS_IS_OK(status)) {
3297 tevent_req_nterror(req, status);
3298 return;
3299 }
3300
3301 /* Copy out parameters */
3302 *state->orig.out.info_type = *state->tmp.out.info_type;
3303 *state->orig.out.info = *state->tmp.out.info;
3304
3305 /* Copy result */
3306 state->orig.out.result = state->tmp.out.result;
3307
3308 /* Reset temporary structure */
3309 ZERO_STRUCT(state->tmp);
3310
3311 if (DEBUGLEVEL >= 10) {
3312 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, &state->orig);
3313 }
3314
3315 tevent_req_done(req);
3316 }
3317
3318 NTSTATUS rpccli_drsuapi_DsReplicaGetInfo_recv(struct tevent_req *req,
3319 TALLOC_CTX *mem_ctx,
3320 WERROR *result)
3321 {
3322 struct rpccli_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
3323 req, struct rpccli_drsuapi_DsReplicaGetInfo_state);
3324 NTSTATUS status;
3325
3326 if (tevent_req_is_nterror(req, &status)) {
3327 tevent_req_received(req);
3328 return status;
3329 }
3330
3331 /* Steal possbile out parameters to the callers context */
3332 talloc_steal(mem_ctx, state->out_mem_ctx);
3333
3334 /* Return result */
3335 *result = state->orig.out.result;
3336
3337 tevent_req_received(req);
3338 return NT_STATUS_OK;
3339 }
3340
3341 NTSTATUS rpccli_drsuapi_DsReplicaGetInfo(struct rpc_pipe_client *cli,
3342 TALLOC_CTX *mem_ctx,
3343 struct policy_handle *bind_handle /* [in] [ref] */,
3344 enum drsuapi_DsReplicaGetInfoLevel level /* [in] */,
3345 union drsuapi_DsReplicaGetInfoRequest *req /* [in] [ref,switch_is(level)] */,
3346 enum drsuapi_DsReplicaInfoType *info_type /* [out] [ref] */,
3347 union drsuapi_DsReplicaInfo *info /* [out] [ref,switch_is(*info_type)] */,
3348 WERROR *werror)
3349 {
3350 struct drsuapi_DsReplicaGetInfo r;
3351 NTSTATUS status;
3352
3353 /* In parameters */
3354 r.in.bind_handle = bind_handle;
3355 r.in.level = level;
3356 r.in.req = req;
3357
3358 if (DEBUGLEVEL >= 10) {
3359 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, &r);
3360 }
3361
3362 status = cli->dispatch(cli,
3363 mem_ctx,
3364 &ndr_table_drsuapi,
3365 NDR_DRSUAPI_DSREPLICAGETINFO,
3366 &r);
3367
3368 if (!NT_STATUS_IS_OK(status)) {
3369 return status;
3370 }
3371
3372 if (DEBUGLEVEL >= 10) {
3373 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, &r);
3374 }
3375
3376 if (NT_STATUS_IS_ERR(status)) {
3377 return status;
3378 }
3379
3380 /* Return variables */
3381 *info_type = *r.out.info_type;
3382 *info = *r.out.info;
3383
3384 /* Return result */
3385 if (werror) {
3386 *werror = r.out.result;
3387 }
3388
3389 return werror_to_ntstatus(r.out.result);
3390 }
3391
3392 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state {
3393 struct DRSUAPI_ADD_SID_HISTORY orig;
3394 struct DRSUAPI_ADD_SID_HISTORY tmp;
3395 TALLOC_CTX *out_mem_ctx;
3396 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3397 };
3398
3399 static void rpccli_DRSUAPI_ADD_SID_HISTORY_done(struct tevent_req *subreq);
3400
3401 struct tevent_req *rpccli_DRSUAPI_ADD_SID_HISTORY_send(TALLOC_CTX *mem_ctx,
3402 struct tevent_context *ev,
3403 struct rpc_pipe_client *cli)
3404 {
3405 struct tevent_req *req;
3406 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state;
3407 struct tevent_req *subreq;
3408
3409 req = tevent_req_create(mem_ctx, &state,
3410 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3411 if (req == NULL) {
3412 return NULL;
3413 }
3414 state->out_mem_ctx = NULL;
3415 state->dispatch_recv = cli->dispatch_recv;
3416
3417 /* In parameters */
3418
3419 /* Out parameters */
3420
3421 /* Result */
3422 ZERO_STRUCT(state->orig.out.result);
3423
3424 if (DEBUGLEVEL >= 10) {
3425 NDR_PRINT_IN_DEBUG(DRSUAPI_ADD_SID_HISTORY, &state->orig);
3426 }
3427
3428 /* make a temporary copy, that we pass to the dispatch function */
3429 state->tmp = state->orig;
3430
3431 subreq = cli->dispatch_send(state, ev, cli,
3432 &ndr_table_drsuapi,
3433 NDR_DRSUAPI_ADD_SID_HISTORY,
3434 &state->tmp);
3435 if (tevent_req_nomem(subreq, req)) {
3436 return tevent_req_post(req, ev);
3437 }
3438 tevent_req_set_callback(subreq, rpccli_DRSUAPI_ADD_SID_HISTORY_done, req);
3439 return req;
3440 }
3441
3442 static void rpccli_DRSUAPI_ADD_SID_HISTORY_done(struct tevent_req *subreq)
3443 {
3444 struct tevent_req *req = tevent_req_callback_data(
3445 subreq, struct tevent_req);
3446 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state = tevent_req_data(
3447 req, struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3448 NTSTATUS status;
3449 TALLOC_CTX *mem_ctx;
3450
3451 if (state->out_mem_ctx) {
3452 mem_ctx = state->out_mem_ctx;
3453 } else {
3454 mem_ctx = state;
3455 }
3456
3457 status = state->dispatch_recv(subreq, mem_ctx);
3458 TALLOC_FREE(subreq);
3459 if (!NT_STATUS_IS_OK(status)) {
3460 tevent_req_nterror(req, status);
3461 return;
3462 }
3463
3464 /* Copy out parameters */
3465
3466 /* Copy result */
3467 state->orig.out.result = state->tmp.out.result;
3468
3469 /* Reset temporary structure */
3470 ZERO_STRUCT(state->tmp);
3471
3472 if (DEBUGLEVEL >= 10) {
3473 NDR_PRINT_OUT_DEBUG(DRSUAPI_ADD_SID_HISTORY, &state->orig);
3474 }
3475
3476 tevent_req_done(req);
3477 }
3478
3479 NTSTATUS rpccli_DRSUAPI_ADD_SID_HISTORY_recv(struct tevent_req *req,
3480 TALLOC_CTX *mem_ctx,
3481 WERROR *result)
3482 {
3483 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state = tevent_req_data(
3484 req, struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3485 NTSTATUS status;
3486
3487 if (tevent_req_is_nterror(req, &status)) {
3488 tevent_req_received(req);
3489 return status;
3490 }
3491
3492 /* Steal possbile out parameters to the callers context */
3493 talloc_steal(mem_ctx, state->out_mem_ctx);
3494
3495 /* Return result */
3496 *result = state->orig.out.result;
3497
3498 tevent_req_received(req);
3499 return NT_STATUS_OK;
3500 }
3501
3502 NTSTATUS rpccli_DRSUAPI_ADD_SID_HISTORY(struct rpc_pipe_client *cli,
3503 TALLOC_CTX *mem_ctx,
3504 WERROR *werror)
3505 {
3506 struct DRSUAPI_ADD_SID_HISTORY r;
3507 NTSTATUS status;
3508
3509 /* In parameters */
3510
3511 if (DEBUGLEVEL >= 10) {
3512 NDR_PRINT_IN_DEBUG(DRSUAPI_ADD_SID_HISTORY, &r);
3513 }
3514
3515 status = cli->dispatch(cli,
3516 mem_ctx,
3517 &ndr_table_drsuapi,
3518 NDR_DRSUAPI_ADD_SID_HISTORY,
3519 &r);
3520
3521 if (!NT_STATUS_IS_OK(status)) {
3522 return status;
3523 }
3524
3525 if (DEBUGLEVEL >= 10) {
3526 NDR_PRINT_OUT_DEBUG(DRSUAPI_ADD_SID_HISTORY, &r);
3527 }
3528
3529 if (NT_STATUS_IS_ERR(status)) {
3530 return status;
3531 }
3532
3533 /* Return variables */
3534
3535 /* Return result */
3536 if (werror) {
3537 *werror = r.out.result;
3538 }
3539
3540 return werror_to_ntstatus(r.out.result);
3541 }
3542
3543 struct rpccli_drsuapi_DsGetMemberships2_state {
3544 struct drsuapi_DsGetMemberships2 orig;
3545 struct drsuapi_DsGetMemberships2 tmp;
3546 TALLOC_CTX *out_mem_ctx;
3547 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3548 };
3549
3550 static void rpccli_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq);
3551
3552 struct tevent_req *rpccli_drsuapi_DsGetMemberships2_send(TALLOC_CTX *mem_ctx,
3553 struct tevent_context *ev,
3554 struct rpc_pipe_client *cli,
3555 struct policy_handle *_bind_handle /* [in] [ref] */,
3556 int32_t _level /* [in] */,
3557 union drsuapi_DsGetMemberships2Request *_req /* [in] [ref,switch_is(level)] */,
3558 int32_t *_level_out /* [out] [ref] */,
3559 union drsuapi_DsGetMemberships2Ctr *_ctr /* [out] [ref,switch_is(*level_out)] */)
3560 {
3561 struct tevent_req *req;
3562 struct rpccli_drsuapi_DsGetMemberships2_state *state;
3563 struct tevent_req *subreq;
3564
3565 req = tevent_req_create(mem_ctx, &state,
3566 struct rpccli_drsuapi_DsGetMemberships2_state);
3567 if (req == NULL) {
3568 return NULL;
3569 }
3570 state->out_mem_ctx = NULL;
3571 state->dispatch_recv = cli->dispatch_recv;
3572
3573 /* In parameters */
3574 state->orig.in.bind_handle = _bind_handle;
3575 state->orig.in.level = _level;
3576 state->orig.in.req = _req;
3577
3578 /* Out parameters */
3579 state->orig.out.level_out = _level_out;
3580 state->orig.out.ctr = _ctr;
3581
3582 /* Result */
3583 ZERO_STRUCT(state->orig.out.result);
3584
3585 if (DEBUGLEVEL >= 10) {
3586 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships2, &state->orig);
3587 }
3588
3589 state->out_mem_ctx = talloc_named_const(state, 0,
3590 "rpccli_drsuapi_DsGetMemberships2_out_memory");
3591 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3592 return tevent_req_post(req, ev);
3593 }
3594
3595 /* make a temporary copy, that we pass to the dispatch function */
3596 state->tmp = state->orig;
3597
3598 subreq = cli->dispatch_send(state, ev, cli,
3599 &ndr_table_drsuapi,
3600 NDR_DRSUAPI_DSGETMEMBERSHIPS2,
3601 &state->tmp);
3602 if (tevent_req_nomem(subreq, req)) {
3603 return tevent_req_post(req, ev);
3604 }
3605 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetMemberships2_done, req);
3606 return req;
3607 }
3608
3609 static void rpccli_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq)
3610 {
3611 struct tevent_req *req = tevent_req_callback_data(
3612 subreq, struct tevent_req);
3613 struct rpccli_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
3614 req, struct rpccli_drsuapi_DsGetMemberships2_state);
3615 NTSTATUS status;
3616 TALLOC_CTX *mem_ctx;
3617
3618 if (state->out_mem_ctx) {
3619 mem_ctx = state->out_mem_ctx;
3620 } else {
3621 mem_ctx = state;
3622 }
3623
3624 status = state->dispatch_recv(subreq, mem_ctx);
3625 TALLOC_FREE(subreq);
3626 if (!NT_STATUS_IS_OK(status)) {
3627 tevent_req_nterror(req, status);
3628 return;
3629 }
3630
3631 /* Copy out parameters */
3632 *state->orig.out.level_out = *state->tmp.out.level_out;
3633 *state->orig.out.ctr = *state->tmp.out.ctr;
3634
3635 /* Copy result */
3636 state->orig.out.result = state->tmp.out.result;
3637
3638 /* Reset temporary structure */
3639 ZERO_STRUCT(state->tmp);
3640
3641 if (DEBUGLEVEL >= 10) {
3642 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships2, &state->orig);
3643 }
3644
3645 tevent_req_done(req);
3646 }
3647
3648 NTSTATUS rpccli_drsuapi_DsGetMemberships2_recv(struct tevent_req *req,
3649 TALLOC_CTX *mem_ctx,
3650 WERROR *result)
3651 {
3652 struct rpccli_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
3653 req, struct rpccli_drsuapi_DsGetMemberships2_state);
3654 NTSTATUS status;
3655
3656 if (tevent_req_is_nterror(req, &status)) {
3657 tevent_req_received(req);
3658 return status;
3659 }
3660
3661 /* Steal possbile out parameters to the callers context */
3662 talloc_steal(mem_ctx, state->out_mem_ctx);
3663
3664 /* Return result */
3665 *result = state->orig.out.result;
3666
3667 tevent_req_received(req);
3668 return NT_STATUS_OK;
3669 }
3670
3671 NTSTATUS rpccli_drsuapi_DsGetMemberships2(struct rpc_pipe_client *cli,
3672 TALLOC_CTX *mem_ctx,
3673 struct policy_handle *bind_handle /* [in] [ref] */,
3674 int32_t level /* [in] */,
3675 union drsuapi_DsGetMemberships2Request *req /* [in] [ref,switch_is(level)] */,
3676 int32_t *level_out /* [out] [ref] */,
3677 union drsuapi_DsGetMemberships2Ctr *ctr /* [out] [ref,switch_is(*level_out)] */,
3678 WERROR *werror)
3679 {
3680 struct drsuapi_DsGetMemberships2 r;
3681 NTSTATUS status;
3682
3683 /* In parameters */
3684 r.in.bind_handle = bind_handle;
3685 r.in.level = level;
3686 r.in.req = req;
3687
3688 if (DEBUGLEVEL >= 10) {
3689 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships2, &r);
3690 }
3691
3692 status = cli->dispatch(cli,
3693 mem_ctx,
3694 &ndr_table_drsuapi,
3695 NDR_DRSUAPI_DSGETMEMBERSHIPS2,
3696 &r);
3697
3698 if (!NT_STATUS_IS_OK(status)) {
3699 return status;
3700 }
3701
3702 if (DEBUGLEVEL >= 10) {
3703 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships2, &r);
3704 }
3705
3706 if (NT_STATUS_IS_ERR(status)) {
3707 return status;
3708 }
3709
3710 /* Return variables */
3711 *level_out = *r.out.level_out;
3712 *ctr = *r.out.ctr;
3713
3714 /* Return result */
3715 if (werror) {
3716 *werror = r.out.result;
3717 }
3718
3719 return werror_to_ntstatus(r.out.result);
3720 }
3721
3722 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state {
3723 struct DRSUAPI_REPLICA_VERIFY_OBJECTS orig;
3724 struct DRSUAPI_REPLICA_VERIFY_OBJECTS tmp;
3725 TALLOC_CTX *out_mem_ctx;
3726 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3727 };
3728
3729 static void rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done(struct tevent_req *subreq);
3730
3731 struct tevent_req *rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_send(TALLOC_CTX *mem_ctx,
3732 struct tevent_context *ev,
3733 struct rpc_pipe_client *cli)
3734 {
3735 struct tevent_req *req;
3736 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state;
3737 struct tevent_req *subreq;
3738
3739 req = tevent_req_create(mem_ctx, &state,
3740 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3741 if (req == NULL) {
3742 return NULL;
3743 }
3744 state->out_mem_ctx = NULL;
3745 state->dispatch_recv = cli->dispatch_recv;
3746
3747 /* In parameters */
3748
3749 /* Out parameters */
3750
3751 /* Result */
3752 ZERO_STRUCT(state->orig.out.result);
3753
3754 if (DEBUGLEVEL >= 10) {
3755 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &state->orig);
3756 }
3757
3758 /* make a temporary copy, that we pass to the dispatch function */
3759 state->tmp = state->orig;
3760
3761 subreq = cli->dispatch_send(state, ev, cli,
3762 &ndr_table_drsuapi,
3763 NDR_DRSUAPI_REPLICA_VERIFY_OBJECTS,
3764 &state->tmp);
3765 if (tevent_req_nomem(subreq, req)) {
3766 return tevent_req_post(req, ev);
3767 }
3768 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done, req);
3769 return req;
3770 }
3771
3772 static void rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done(struct tevent_req *subreq)
3773 {
3774 struct tevent_req *req = tevent_req_callback_data(
3775 subreq, struct tevent_req);
3776 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state = tevent_req_data(
3777 req, struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3778 NTSTATUS status;
3779 TALLOC_CTX *mem_ctx;
3780
3781 if (state->out_mem_ctx) {
3782 mem_ctx = state->out_mem_ctx;
3783 } else {
3784 mem_ctx = state;
3785 }
3786
3787 status = state->dispatch_recv(subreq, mem_ctx);
3788 TALLOC_FREE(subreq);
3789 if (!NT_STATUS_IS_OK(status)) {
3790 tevent_req_nterror(req, status);
3791 return;
3792 }
3793
3794 /* Copy out parameters */
3795
3796 /* Copy result */
3797 state->orig.out.result = state->tmp.out.result;
3798
3799 /* Reset temporary structure */
3800 ZERO_STRUCT(state->tmp);
3801
3802 if (DEBUGLEVEL >= 10) {
3803 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &state->orig);
3804 }
3805
3806 tevent_req_done(req);
3807 }
3808
3809 NTSTATUS rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_recv(struct tevent_req *req,
3810 TALLOC_CTX *mem_ctx,
3811 WERROR *result)
3812 {
3813 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state = tevent_req_data(
3814 req, struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3815 NTSTATUS status;
3816
3817 if (tevent_req_is_nterror(req, &status)) {
3818 tevent_req_received(req);
3819 return status;
3820 }
3821
3822 /* Steal possbile out parameters to the callers context */
3823 talloc_steal(mem_ctx, state->out_mem_ctx);
3824
3825 /* Return result */
3826 *result = state->orig.out.result;
3827
3828 tevent_req_received(req);
3829 return NT_STATUS_OK;
3830 }
3831
3832 NTSTATUS rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct rpc_pipe_client *cli,
3833 TALLOC_CTX *mem_ctx,
3834 WERROR *werror)
3835 {
3836 struct DRSUAPI_REPLICA_VERIFY_OBJECTS r;
3837 NTSTATUS status;
3838
3839 /* In parameters */
3840
3841 if (DEBUGLEVEL >= 10) {
3842 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &r);
3843 }
3844
3845 status = cli->dispatch(cli,
3846 mem_ctx,
3847 &ndr_table_drsuapi,
3848 NDR_DRSUAPI_REPLICA_VERIFY_OBJECTS,
3849 &r);
3850
3851 if (!NT_STATUS_IS_OK(status)) {
3852 return status;
3853 }
3854
3855 if (DEBUGLEVEL >= 10) {
3856 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &r);
3857 }
3858
3859 if (NT_STATUS_IS_ERR(status)) {
3860 return status;
3861 }
3862
3863 /* Return variables */
3864
3865 /* Return result */
3866 if (werror) {
3867 *werror = r.out.result;
3868 }
3869
3870 return werror_to_ntstatus(r.out.result);
3871 }
3872
3873 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state {
3874 struct DRSUAPI_GET_OBJECT_EXISTENCE orig;
3875 struct DRSUAPI_GET_OBJECT_EXISTENCE tmp;
3876 TALLOC_CTX *out_mem_ctx;
3877 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3878 };
3879
3880 static void rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done(struct tevent_req *subreq);
3881
3882 struct tevent_req *rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_send(TALLOC_CTX *mem_ctx,
3883 struct tevent_context *ev,
3884 struct rpc_pipe_client *cli)
3885 {
3886 struct tevent_req *req;
3887 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state;
3888 struct tevent_req *subreq;
3889
3890 req = tevent_req_create(mem_ctx, &state,
3891 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3892 if (req == NULL) {
3893 return NULL;
3894 }
3895 state->out_mem_ctx = NULL;
3896 state->dispatch_recv = cli->dispatch_recv;
3897
3898 /* In parameters */
3899
3900 /* Out parameters */
3901
3902 /* Result */
3903 ZERO_STRUCT(state->orig.out.result);
3904
3905 if (DEBUGLEVEL >= 10) {
3906 NDR_PRINT_IN_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &state->orig);
3907 }
3908
3909 /* make a temporary copy, that we pass to the dispatch function */
3910 state->tmp = state->orig;
3911
3912 subreq = cli->dispatch_send(state, ev, cli,
3913 &ndr_table_drsuapi,
3914 NDR_DRSUAPI_GET_OBJECT_EXISTENCE,
3915 &state->tmp);
3916 if (tevent_req_nomem(subreq, req)) {
3917 return tevent_req_post(req, ev);
3918 }
3919 tevent_req_set_callback(subreq, rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done, req);
3920 return req;
3921 }
3922
3923 static void rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done(struct tevent_req *subreq)
3924 {
3925 struct tevent_req *req = tevent_req_callback_data(
3926 subreq, struct tevent_req);
3927 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state = tevent_req_data(
3928 req, struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3929 NTSTATUS status;
3930 TALLOC_CTX *mem_ctx;
3931
3932 if (state->out_mem_ctx) {
3933 mem_ctx = state->out_mem_ctx;
3934 } else {
3935 mem_ctx = state;
3936 }
3937
3938 status = state->dispatch_recv(subreq, mem_ctx);
3939 TALLOC_FREE(subreq);
3940 if (!NT_STATUS_IS_OK(status)) {
3941 tevent_req_nterror(req, status);
3942 return;
3943 }
3944
3945 /* Copy out parameters */
3946
3947 /* Copy result */
3948 state->orig.out.result = state->tmp.out.result;
3949
3950 /* Reset temporary structure */
3951 ZERO_STRUCT(state->tmp);
3952
3953 if (DEBUGLEVEL >= 10) {
3954 NDR_PRINT_OUT_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &state->orig);
3955 }
3956
3957 tevent_req_done(req);
3958 }
3959
3960 NTSTATUS rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_recv(struct tevent_req *req,
3961 TALLOC_CTX *mem_ctx,
3962 WERROR *result)
3963 {
3964 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state = tevent_req_data(
3965 req, struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3966 NTSTATUS status;
3967
3968 if (tevent_req_is_nterror(req, &status)) {
3969 tevent_req_received(req);
3970 return status;
3971 }
3972
3973 /* Steal possbile out parameters to the callers context */
3974 talloc_steal(mem_ctx, state->out_mem_ctx);
3975
3976 /* Return result */
3977 *result = state->orig.out.result;
3978
3979 tevent_req_received(req);
3980 return NT_STATUS_OK;
3981 }
3982
3983 NTSTATUS rpccli_DRSUAPI_GET_OBJECT_EXISTENCE(struct rpc_pipe_client *cli,
3984 TALLOC_CTX *mem_ctx,
3985 WERROR *werror)
3986 {
3987 struct DRSUAPI_GET_OBJECT_EXISTENCE r;
3988 NTSTATUS status;
3989
3990 /* In parameters */
3991
3992 if (DEBUGLEVEL >= 10) {
3993 NDR_PRINT_IN_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &r);
3994 }
3995
3996 status = cli->dispatch(cli,
3997 mem_ctx,
3998 &ndr_table_drsuapi,
3999 NDR_DRSUAPI_GET_OBJECT_EXISTENCE,
4000 &r);
4001
4002 if (!NT_STATUS_IS_OK(status)) {
4003 return status;
4004 }
4005
4006 if (DEBUGLEVEL >= 10) {
4007 NDR_PRINT_OUT_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &r);
4008 }
4009
4010 if (NT_STATUS_IS_ERR(status)) {
4011 return status;
4012 }
4013
4014 /* Return variables */
4015
4016 /* Return result */
4017 if (werror) {
4018 *werror = r.out.result;
4019 }
4020
4021 return werror_to_ntstatus(r.out.result);
4022 }
4023
4024 struct rpccli_drsuapi_QuerySitesByCost_state {
4025 struct drsuapi_QuerySitesByCost orig;
4026 struct drsuapi_QuerySitesByCost tmp;
4027 TALLOC_CTX *out_mem_ctx;
4028 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4029 };
4030
4031 static void rpccli_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq);
4032
4033 struct tevent_req *rpccli_drsuapi_QuerySitesByCost_send(TALLOC_CTX *mem_ctx,
4034 struct tevent_context *ev,
4035 struct rpc_pipe_client *cli,
4036 struct policy_handle *_bind_handle /* [in] [ref] */,
4037 int32_t _level /* [in] */,
4038 union drsuapi_QuerySitesByCostRequest *_req /* [in] [ref,switch_is(level)] */,
4039 int32_t *_level_out /* [out] [ref] */,
4040 union drsuapi_QuerySitesByCostCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
4041 {
4042 struct tevent_req *req;
4043 struct rpccli_drsuapi_QuerySitesByCost_state *state;
4044 struct tevent_req *subreq;
4045
4046 req = tevent_req_create(mem_ctx, &state,
4047 struct rpccli_drsuapi_QuerySitesByCost_state);
4048 if (req == NULL) {
4049 return NULL;
4050 }
4051 state->out_mem_ctx = NULL;
4052 state->dispatch_recv = cli->dispatch_recv;
4053
4054 /* In parameters */
4055 state->orig.in.bind_handle = _bind_handle;
4056 state->orig.in.level = _level;
4057 state->orig.in.req = _req;
4058
4059 /* Out parameters */
4060 state->orig.out.level_out = _level_out;
4061 state->orig.out.ctr = _ctr;
4062
4063 /* Result */
4064 ZERO_STRUCT(state->orig.out.result);
4065
4066 if (DEBUGLEVEL >= 10) {
4067 NDR_PRINT_IN_DEBUG(drsuapi_QuerySitesByCost, &state->orig);
4068 }
4069
4070 state->out_mem_ctx = talloc_named_const(state, 0,
4071 "rpccli_drsuapi_QuerySitesByCost_out_memory");
4072 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4073 return tevent_req_post(req, ev);
4074 }
4075
4076 /* make a temporary copy, that we pass to the dispatch function */
4077 state->tmp = state->orig;
4078
4079 subreq = cli->dispatch_send(state, ev, cli,
4080 &ndr_table_drsuapi,
4081 NDR_DRSUAPI_QUERYSITESBYCOST,
4082 &state->tmp);
4083 if (tevent_req_nomem(subreq, req)) {
4084 return tevent_req_post(req, ev);
4085 }
4086 tevent_req_set_callback(subreq, rpccli_drsuapi_QuerySitesByCost_done, req);
4087 return req;
4088 }
4089
4090 static void rpccli_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq)
4091 {
4092 struct tevent_req *req = tevent_req_callback_data(
4093 subreq, struct tevent_req);
4094 struct rpccli_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
4095 req, struct rpccli_drsuapi_QuerySitesByCost_state);
4096 NTSTATUS status;
4097 TALLOC_CTX *mem_ctx;
4098
4099 if (state->out_mem_ctx) {
4100 mem_ctx = state->out_mem_ctx;
4101 } else {
4102 mem_ctx = state;
4103 }
4104
4105 status = state->dispatch_recv(subreq, mem_ctx);
4106 TALLOC_FREE(subreq);
4107 if (!NT_STATUS_IS_OK(status)) {
4108 tevent_req_nterror(req, status);
4109 return;
4110 }
4111
4112 /* Copy out parameters */
4113 *state->orig.out.level_out = *state->tmp.out.level_out;
4114 *state->orig.out.ctr = *state->tmp.out.ctr;
4115
4116 /* Copy result */
4117 state->orig.out.result = state->tmp.out.result;
4118
4119 /* Reset temporary structure */
4120 ZERO_STRUCT(state->tmp);
4121
4122 if (DEBUGLEVEL >= 10) {
4123 NDR_PRINT_OUT_DEBUG(drsuapi_QuerySitesByCost, &state->orig);
4124 }
4125
4126 tevent_req_done(req);
4127 }
4128
4129 NTSTATUS rpccli_drsuapi_QuerySitesByCost_recv(struct tevent_req *req,
4130 TALLOC_CTX *mem_ctx,
4131 WERROR *result)
4132 {
4133 struct rpccli_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
4134 req, struct rpccli_drsuapi_QuerySitesByCost_state);
4135 NTSTATUS status;
4136
4137 if (tevent_req_is_nterror(req, &status)) {
4138 tevent_req_received(req);
4139 return status;
4140 }
4141
4142 /* Steal possbile out parameters to the callers context */
4143 talloc_steal(mem_ctx, state->out_mem_ctx);
4144
4145 /* Return result */
4146 *result = state->orig.out.result;
4147
4148 tevent_req_received(req);
4149 return NT_STATUS_OK;
4150 }
4151
4152 NTSTATUS rpccli_drsuapi_QuerySitesByCost(struct rpc_pipe_client *cli,
4153 TALLOC_CTX *mem_ctx,
4154 struct policy_handle *bind_handle /* [in] [ref] */,
4155 int32_t level /* [in] */,
4156 union drsuapi_QuerySitesByCostRequest *req /* [in] [ref,switch_is(level)] */,
4157 int32_t *level_out /* [out] [ref] */,
4158 union drsuapi_QuerySitesByCostCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
4159 WERROR *werror)
4160 {
4161 struct drsuapi_QuerySitesByCost r;
4162 NTSTATUS status;
4163
4164 /* In parameters */
4165 r.in.bind_handle = bind_handle;
4166 r.in.level = level;
4167 r.in.req = req;
4168
4169 if (DEBUGLEVEL >= 10) {
4170 NDR_PRINT_IN_DEBUG(drsuapi_QuerySitesByCost, &r);
4171 }
4172
4173 status = cli->dispatch(cli,
4174 mem_ctx,
4175 &ndr_table_drsuapi,
4176 NDR_DRSUAPI_QUERYSITESBYCOST,
4177 &r);
4178
4179 if (!NT_STATUS_IS_OK(status)) {
4180 return status;
4181 }
4182
4183 if (DEBUGLEVEL >= 10) {
4184 NDR_PRINT_OUT_DEBUG(drsuapi_QuerySitesByCost, &r);
4185 }
4186
4187 if (NT_STATUS_IS_ERR(status)) {
4188 return status;
4189 }
4190
4191 /* Return variables */
4192 *level_out = *r.out.level_out;
4193 *ctr = *r.out.ctr;
4194
4195 /* Return result */
4196 if (werror) {
4197 *werror = r.out.result;
4198 }
4199
4200 return werror_to_ntstatus(r.out.result);
4201 }
4202
aatanasov's samba4 branch