?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
report the location of the original talloc_free on double free
[Samba.git] / librpc / gen_ndr / cli_drsuapi.c
blob14c89aa19406982a5c9960c4bb370edfb188f4c4
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_REPLICA_ADD_state {
856 struct DRSUAPI_REPLICA_ADD orig;
857 struct DRSUAPI_REPLICA_ADD 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_REPLICA_ADD_done(struct tevent_req *subreq);
863
864 struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx,
865 struct tevent_context *ev,
866 struct rpc_pipe_client *cli)
867 {
868 struct tevent_req *req;
869 struct rpccli_DRSUAPI_REPLICA_ADD_state *state;
870 struct tevent_req *subreq;
871
872 req = tevent_req_create(mem_ctx, &state,
873 struct rpccli_DRSUAPI_REPLICA_ADD_state);
874 if (req == NULL) {
875 return NULL;
876 }
877 state->out_mem_ctx = NULL;
878 state->dispatch_recv = cli->dispatch_recv;
879
880 /* In parameters */
881
882 /* Out parameters */
883
884 /* Result */
885 ZERO_STRUCT(state->orig.out.result);
886
887 if (DEBUGLEVEL >= 10) {
888 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_ADD, &state->orig);
889 }
890
891 /* make a temporary copy, that we pass to the dispatch function */
892 state->tmp = state->orig;
893
894 subreq = cli->dispatch_send(state, ev, cli,
895 &ndr_table_drsuapi,
896 NDR_DRSUAPI_REPLICA_ADD,
897 &state->tmp);
898 if (tevent_req_nomem(subreq, req)) {
899 return tevent_req_post(req, ev);
900 }
901 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_ADD_done, req);
902 return req;
903 }
904
905 static void rpccli_DRSUAPI_REPLICA_ADD_done(struct tevent_req *subreq)
906 {
907 struct tevent_req *req = tevent_req_callback_data(
908 subreq, struct tevent_req);
909 struct rpccli_DRSUAPI_REPLICA_ADD_state *state = tevent_req_data(
910 req, struct rpccli_DRSUAPI_REPLICA_ADD_state);
911 NTSTATUS status;
912 TALLOC_CTX *mem_ctx;
913
914 if (state->out_mem_ctx) {
915 mem_ctx = state->out_mem_ctx;
916 } else {
917 mem_ctx = state;
918 }
919
920 status = state->dispatch_recv(subreq, mem_ctx);
921 TALLOC_FREE(subreq);
922 if (!NT_STATUS_IS_OK(status)) {
923 tevent_req_nterror(req, status);
924 return;
925 }
926
927 /* Copy out parameters */
928
929 /* Copy result */
930 state->orig.out.result = state->tmp.out.result;
931
932 /* Reset temporary structure */
933 ZERO_STRUCT(state->tmp);
934
935 if (DEBUGLEVEL >= 10) {
936 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_ADD, &state->orig);
937 }
938
939 tevent_req_done(req);
940 }
941
942 NTSTATUS rpccli_DRSUAPI_REPLICA_ADD_recv(struct tevent_req *req,
943 TALLOC_CTX *mem_ctx,
944 WERROR *result)
945 {
946 struct rpccli_DRSUAPI_REPLICA_ADD_state *state = tevent_req_data(
947 req, struct rpccli_DRSUAPI_REPLICA_ADD_state);
948 NTSTATUS status;
949
950 if (tevent_req_is_nterror(req, &status)) {
951 tevent_req_received(req);
952 return status;
953 }
954
955 /* Steal possbile out parameters to the callers context */
956 talloc_steal(mem_ctx, state->out_mem_ctx);
957
958 /* Return result */
959 *result = state->orig.out.result;
960
961 tevent_req_received(req);
962 return NT_STATUS_OK;
963 }
964
965 NTSTATUS rpccli_DRSUAPI_REPLICA_ADD(struct rpc_pipe_client *cli,
966 TALLOC_CTX *mem_ctx,
967 WERROR *werror)
968 {
969 struct DRSUAPI_REPLICA_ADD r;
970 NTSTATUS status;
971
972 /* In parameters */
973
974 if (DEBUGLEVEL >= 10) {
975 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_ADD, &r);
976 }
977
978 status = cli->dispatch(cli,
979 mem_ctx,
980 &ndr_table_drsuapi,
981 NDR_DRSUAPI_REPLICA_ADD,
982 &r);
983
984 if (!NT_STATUS_IS_OK(status)) {
985 return status;
986 }
987
988 if (DEBUGLEVEL >= 10) {
989 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_ADD, &r);
990 }
991
992 if (NT_STATUS_IS_ERR(status)) {
993 return status;
994 }
995
996 /* Return variables */
997
998 /* Return result */
999 if (werror) {
1000 *werror = r.out.result;
1001 }
1002
1003 return werror_to_ntstatus(r.out.result);
1004 }
1005
1006 struct rpccli_DRSUAPI_REPLICA_DEL_state {
1007 struct DRSUAPI_REPLICA_DEL orig;
1008 struct DRSUAPI_REPLICA_DEL tmp;
1009 TALLOC_CTX *out_mem_ctx;
1010 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1011 };
1012
1013 static void rpccli_DRSUAPI_REPLICA_DEL_done(struct tevent_req *subreq);
1014
1015 struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx,
1016 struct tevent_context *ev,
1017 struct rpc_pipe_client *cli)
1018 {
1019 struct tevent_req *req;
1020 struct rpccli_DRSUAPI_REPLICA_DEL_state *state;
1021 struct tevent_req *subreq;
1022
1023 req = tevent_req_create(mem_ctx, &state,
1024 struct rpccli_DRSUAPI_REPLICA_DEL_state);
1025 if (req == NULL) {
1026 return NULL;
1027 }
1028 state->out_mem_ctx = NULL;
1029 state->dispatch_recv = cli->dispatch_recv;
1030
1031 /* In parameters */
1032
1033 /* Out parameters */
1034
1035 /* Result */
1036 ZERO_STRUCT(state->orig.out.result);
1037
1038 if (DEBUGLEVEL >= 10) {
1039 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_DEL, &state->orig);
1040 }
1041
1042 /* make a temporary copy, that we pass to the dispatch function */
1043 state->tmp = state->orig;
1044
1045 subreq = cli->dispatch_send(state, ev, cli,
1046 &ndr_table_drsuapi,
1047 NDR_DRSUAPI_REPLICA_DEL,
1048 &state->tmp);
1049 if (tevent_req_nomem(subreq, req)) {
1050 return tevent_req_post(req, ev);
1051 }
1052 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_DEL_done, req);
1053 return req;
1054 }
1055
1056 static void rpccli_DRSUAPI_REPLICA_DEL_done(struct tevent_req *subreq)
1057 {
1058 struct tevent_req *req = tevent_req_callback_data(
1059 subreq, struct tevent_req);
1060 struct rpccli_DRSUAPI_REPLICA_DEL_state *state = tevent_req_data(
1061 req, struct rpccli_DRSUAPI_REPLICA_DEL_state);
1062 NTSTATUS status;
1063 TALLOC_CTX *mem_ctx;
1064
1065 if (state->out_mem_ctx) {
1066 mem_ctx = state->out_mem_ctx;
1067 } else {
1068 mem_ctx = state;
1069 }
1070
1071 status = state->dispatch_recv(subreq, mem_ctx);
1072 TALLOC_FREE(subreq);
1073 if (!NT_STATUS_IS_OK(status)) {
1074 tevent_req_nterror(req, status);
1075 return;
1076 }
1077
1078 /* Copy out parameters */
1079
1080 /* Copy result */
1081 state->orig.out.result = state->tmp.out.result;
1082
1083 /* Reset temporary structure */
1084 ZERO_STRUCT(state->tmp);
1085
1086 if (DEBUGLEVEL >= 10) {
1087 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_DEL, &state->orig);
1088 }
1089
1090 tevent_req_done(req);
1091 }
1092
1093 NTSTATUS rpccli_DRSUAPI_REPLICA_DEL_recv(struct tevent_req *req,
1094 TALLOC_CTX *mem_ctx,
1095 WERROR *result)
1096 {
1097 struct rpccli_DRSUAPI_REPLICA_DEL_state *state = tevent_req_data(
1098 req, struct rpccli_DRSUAPI_REPLICA_DEL_state);
1099 NTSTATUS status;
1100
1101 if (tevent_req_is_nterror(req, &status)) {
1102 tevent_req_received(req);
1103 return status;
1104 }
1105
1106 /* Steal possbile out parameters to the callers context */
1107 talloc_steal(mem_ctx, state->out_mem_ctx);
1108
1109 /* Return result */
1110 *result = state->orig.out.result;
1111
1112 tevent_req_received(req);
1113 return NT_STATUS_OK;
1114 }
1115
1116 NTSTATUS rpccli_DRSUAPI_REPLICA_DEL(struct rpc_pipe_client *cli,
1117 TALLOC_CTX *mem_ctx,
1118 WERROR *werror)
1119 {
1120 struct DRSUAPI_REPLICA_DEL r;
1121 NTSTATUS status;
1122
1123 /* In parameters */
1124
1125 if (DEBUGLEVEL >= 10) {
1126 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_DEL, &r);
1127 }
1128
1129 status = cli->dispatch(cli,
1130 mem_ctx,
1131 &ndr_table_drsuapi,
1132 NDR_DRSUAPI_REPLICA_DEL,
1133 &r);
1134
1135 if (!NT_STATUS_IS_OK(status)) {
1136 return status;
1137 }
1138
1139 if (DEBUGLEVEL >= 10) {
1140 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_DEL, &r);
1141 }
1142
1143 if (NT_STATUS_IS_ERR(status)) {
1144 return status;
1145 }
1146
1147 /* Return variables */
1148
1149 /* Return result */
1150 if (werror) {
1151 *werror = r.out.result;
1152 }
1153
1154 return werror_to_ntstatus(r.out.result);
1155 }
1156
1157 struct rpccli_DRSUAPI_REPLICA_MODIFY_state {
1158 struct DRSUAPI_REPLICA_MODIFY orig;
1159 struct DRSUAPI_REPLICA_MODIFY tmp;
1160 TALLOC_CTX *out_mem_ctx;
1161 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1162 };
1163
1164 static void rpccli_DRSUAPI_REPLICA_MODIFY_done(struct tevent_req *subreq);
1165
1166 struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx,
1167 struct tevent_context *ev,
1168 struct rpc_pipe_client *cli)
1169 {
1170 struct tevent_req *req;
1171 struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state;
1172 struct tevent_req *subreq;
1173
1174 req = tevent_req_create(mem_ctx, &state,
1175 struct rpccli_DRSUAPI_REPLICA_MODIFY_state);
1176 if (req == NULL) {
1177 return NULL;
1178 }
1179 state->out_mem_ctx = NULL;
1180 state->dispatch_recv = cli->dispatch_recv;
1181
1182 /* In parameters */
1183
1184 /* Out parameters */
1185
1186 /* Result */
1187 ZERO_STRUCT(state->orig.out.result);
1188
1189 if (DEBUGLEVEL >= 10) {
1190 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_MODIFY, &state->orig);
1191 }
1192
1193 /* make a temporary copy, that we pass to the dispatch function */
1194 state->tmp = state->orig;
1195
1196 subreq = cli->dispatch_send(state, ev, cli,
1197 &ndr_table_drsuapi,
1198 NDR_DRSUAPI_REPLICA_MODIFY,
1199 &state->tmp);
1200 if (tevent_req_nomem(subreq, req)) {
1201 return tevent_req_post(req, ev);
1202 }
1203 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_MODIFY_done, req);
1204 return req;
1205 }
1206
1207 static void rpccli_DRSUAPI_REPLICA_MODIFY_done(struct tevent_req *subreq)
1208 {
1209 struct tevent_req *req = tevent_req_callback_data(
1210 subreq, struct tevent_req);
1211 struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state = tevent_req_data(
1212 req, struct rpccli_DRSUAPI_REPLICA_MODIFY_state);
1213 NTSTATUS status;
1214 TALLOC_CTX *mem_ctx;
1215
1216 if (state->out_mem_ctx) {
1217 mem_ctx = state->out_mem_ctx;
1218 } else {
1219 mem_ctx = state;
1220 }
1221
1222 status = state->dispatch_recv(subreq, mem_ctx);
1223 TALLOC_FREE(subreq);
1224 if (!NT_STATUS_IS_OK(status)) {
1225 tevent_req_nterror(req, status);
1226 return;
1227 }
1228
1229 /* Copy out parameters */
1230
1231 /* Copy result */
1232 state->orig.out.result = state->tmp.out.result;
1233
1234 /* Reset temporary structure */
1235 ZERO_STRUCT(state->tmp);
1236
1237 if (DEBUGLEVEL >= 10) {
1238 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_MODIFY, &state->orig);
1239 }
1240
1241 tevent_req_done(req);
1242 }
1243
1244 NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY_recv(struct tevent_req *req,
1245 TALLOC_CTX *mem_ctx,
1246 WERROR *result)
1247 {
1248 struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state = tevent_req_data(
1249 req, struct rpccli_DRSUAPI_REPLICA_MODIFY_state);
1250 NTSTATUS status;
1251
1252 if (tevent_req_is_nterror(req, &status)) {
1253 tevent_req_received(req);
1254 return status;
1255 }
1256
1257 /* Steal possbile out parameters to the callers context */
1258 talloc_steal(mem_ctx, state->out_mem_ctx);
1259
1260 /* Return result */
1261 *result = state->orig.out.result;
1262
1263 tevent_req_received(req);
1264 return NT_STATUS_OK;
1265 }
1266
1267 NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY(struct rpc_pipe_client *cli,
1268 TALLOC_CTX *mem_ctx,
1269 WERROR *werror)
1270 {
1271 struct DRSUAPI_REPLICA_MODIFY r;
1272 NTSTATUS status;
1273
1274 /* In parameters */
1275
1276 if (DEBUGLEVEL >= 10) {
1277 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_MODIFY, &r);
1278 }
1279
1280 status = cli->dispatch(cli,
1281 mem_ctx,
1282 &ndr_table_drsuapi,
1283 NDR_DRSUAPI_REPLICA_MODIFY,
1284 &r);
1285
1286 if (!NT_STATUS_IS_OK(status)) {
1287 return status;
1288 }
1289
1290 if (DEBUGLEVEL >= 10) {
1291 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_MODIFY, &r);
1292 }
1293
1294 if (NT_STATUS_IS_ERR(status)) {
1295 return status;
1296 }
1297
1298 /* Return variables */
1299
1300 /* Return result */
1301 if (werror) {
1302 *werror = r.out.result;
1303 }
1304
1305 return werror_to_ntstatus(r.out.result);
1306 }
1307
1308 struct rpccli_DRSUAPI_VERIFY_NAMES_state {
1309 struct DRSUAPI_VERIFY_NAMES orig;
1310 struct DRSUAPI_VERIFY_NAMES tmp;
1311 TALLOC_CTX *out_mem_ctx;
1312 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1313 };
1314
1315 static void rpccli_DRSUAPI_VERIFY_NAMES_done(struct tevent_req *subreq);
1316
1317 struct tevent_req *rpccli_DRSUAPI_VERIFY_NAMES_send(TALLOC_CTX *mem_ctx,
1318 struct tevent_context *ev,
1319 struct rpc_pipe_client *cli)
1320 {
1321 struct tevent_req *req;
1322 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state;
1323 struct tevent_req *subreq;
1324
1325 req = tevent_req_create(mem_ctx, &state,
1326 struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1327 if (req == NULL) {
1328 return NULL;
1329 }
1330 state->out_mem_ctx = NULL;
1331 state->dispatch_recv = cli->dispatch_recv;
1332
1333 /* In parameters */
1334
1335 /* Out parameters */
1336
1337 /* Result */
1338 ZERO_STRUCT(state->orig.out.result);
1339
1340 if (DEBUGLEVEL >= 10) {
1341 NDR_PRINT_IN_DEBUG(DRSUAPI_VERIFY_NAMES, &state->orig);
1342 }
1343
1344 /* make a temporary copy, that we pass to the dispatch function */
1345 state->tmp = state->orig;
1346
1347 subreq = cli->dispatch_send(state, ev, cli,
1348 &ndr_table_drsuapi,
1349 NDR_DRSUAPI_VERIFY_NAMES,
1350 &state->tmp);
1351 if (tevent_req_nomem(subreq, req)) {
1352 return tevent_req_post(req, ev);
1353 }
1354 tevent_req_set_callback(subreq, rpccli_DRSUAPI_VERIFY_NAMES_done, req);
1355 return req;
1356 }
1357
1358 static void rpccli_DRSUAPI_VERIFY_NAMES_done(struct tevent_req *subreq)
1359 {
1360 struct tevent_req *req = tevent_req_callback_data(
1361 subreq, struct tevent_req);
1362 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state = tevent_req_data(
1363 req, struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1364 NTSTATUS status;
1365 TALLOC_CTX *mem_ctx;
1366
1367 if (state->out_mem_ctx) {
1368 mem_ctx = state->out_mem_ctx;
1369 } else {
1370 mem_ctx = state;
1371 }
1372
1373 status = state->dispatch_recv(subreq, mem_ctx);
1374 TALLOC_FREE(subreq);
1375 if (!NT_STATUS_IS_OK(status)) {
1376 tevent_req_nterror(req, status);
1377 return;
1378 }
1379
1380 /* Copy out parameters */
1381
1382 /* Copy result */
1383 state->orig.out.result = state->tmp.out.result;
1384
1385 /* Reset temporary structure */
1386 ZERO_STRUCT(state->tmp);
1387
1388 if (DEBUGLEVEL >= 10) {
1389 NDR_PRINT_OUT_DEBUG(DRSUAPI_VERIFY_NAMES, &state->orig);
1390 }
1391
1392 tevent_req_done(req);
1393 }
1394
1395 NTSTATUS rpccli_DRSUAPI_VERIFY_NAMES_recv(struct tevent_req *req,
1396 TALLOC_CTX *mem_ctx,
1397 WERROR *result)
1398 {
1399 struct rpccli_DRSUAPI_VERIFY_NAMES_state *state = tevent_req_data(
1400 req, struct rpccli_DRSUAPI_VERIFY_NAMES_state);
1401 NTSTATUS status;
1402
1403 if (tevent_req_is_nterror(req, &status)) {
1404 tevent_req_received(req);
1405 return status;
1406 }
1407
1408 /* Steal possbile out parameters to the callers context */
1409 talloc_steal(mem_ctx, state->out_mem_ctx);
1410
1411 /* Return result */
1412 *result = state->orig.out.result;
1413
1414 tevent_req_received(req);
1415 return NT_STATUS_OK;
1416 }
1417
1418 NTSTATUS rpccli_DRSUAPI_VERIFY_NAMES(struct rpc_pipe_client *cli,
1419 TALLOC_CTX *mem_ctx,
1420 WERROR *werror)
1421 {
1422 struct DRSUAPI_VERIFY_NAMES r;
1423 NTSTATUS status;
1424
1425 /* In parameters */
1426
1427 if (DEBUGLEVEL >= 10) {
1428 NDR_PRINT_IN_DEBUG(DRSUAPI_VERIFY_NAMES, &r);
1429 }
1430
1431 status = cli->dispatch(cli,
1432 mem_ctx,
1433 &ndr_table_drsuapi,
1434 NDR_DRSUAPI_VERIFY_NAMES,
1435 &r);
1436
1437 if (!NT_STATUS_IS_OK(status)) {
1438 return status;
1439 }
1440
1441 if (DEBUGLEVEL >= 10) {
1442 NDR_PRINT_OUT_DEBUG(DRSUAPI_VERIFY_NAMES, &r);
1443 }
1444
1445 if (NT_STATUS_IS_ERR(status)) {
1446 return status;
1447 }
1448
1449 /* Return variables */
1450
1451 /* Return result */
1452 if (werror) {
1453 *werror = r.out.result;
1454 }
1455
1456 return werror_to_ntstatus(r.out.result);
1457 }
1458
1459 struct rpccli_drsuapi_DsGetMemberships_state {
1460 struct drsuapi_DsGetMemberships orig;
1461 struct drsuapi_DsGetMemberships tmp;
1462 TALLOC_CTX *out_mem_ctx;
1463 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1464 };
1465
1466 static void rpccli_drsuapi_DsGetMemberships_done(struct tevent_req *subreq);
1467
1468 struct tevent_req *rpccli_drsuapi_DsGetMemberships_send(TALLOC_CTX *mem_ctx,
1469 struct tevent_context *ev,
1470 struct rpc_pipe_client *cli,
1471 struct policy_handle *_bind_handle /* [in] [ref] */,
1472 int32_t _level /* [in] */,
1473 union drsuapi_DsGetMembershipsRequest *_req /* [in] [ref,switch_is(level)] */,
1474 int32_t *_level_out /* [out] [ref] */,
1475 union drsuapi_DsGetMembershipsCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
1476 {
1477 struct tevent_req *req;
1478 struct rpccli_drsuapi_DsGetMemberships_state *state;
1479 struct tevent_req *subreq;
1480
1481 req = tevent_req_create(mem_ctx, &state,
1482 struct rpccli_drsuapi_DsGetMemberships_state);
1483 if (req == NULL) {
1484 return NULL;
1485 }
1486 state->out_mem_ctx = NULL;
1487 state->dispatch_recv = cli->dispatch_recv;
1488
1489 /* In parameters */
1490 state->orig.in.bind_handle = _bind_handle;
1491 state->orig.in.level = _level;
1492 state->orig.in.req = _req;
1493
1494 /* Out parameters */
1495 state->orig.out.level_out = _level_out;
1496 state->orig.out.ctr = _ctr;
1497
1498 /* Result */
1499 ZERO_STRUCT(state->orig.out.result);
1500
1501 if (DEBUGLEVEL >= 10) {
1502 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships, &state->orig);
1503 }
1504
1505 state->out_mem_ctx = talloc_named_const(state, 0,
1506 "rpccli_drsuapi_DsGetMemberships_out_memory");
1507 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1508 return tevent_req_post(req, ev);
1509 }
1510
1511 /* make a temporary copy, that we pass to the dispatch function */
1512 state->tmp = state->orig;
1513
1514 subreq = cli->dispatch_send(state, ev, cli,
1515 &ndr_table_drsuapi,
1516 NDR_DRSUAPI_DSGETMEMBERSHIPS,
1517 &state->tmp);
1518 if (tevent_req_nomem(subreq, req)) {
1519 return tevent_req_post(req, ev);
1520 }
1521 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetMemberships_done, req);
1522 return req;
1523 }
1524
1525 static void rpccli_drsuapi_DsGetMemberships_done(struct tevent_req *subreq)
1526 {
1527 struct tevent_req *req = tevent_req_callback_data(
1528 subreq, struct tevent_req);
1529 struct rpccli_drsuapi_DsGetMemberships_state *state = tevent_req_data(
1530 req, struct rpccli_drsuapi_DsGetMemberships_state);
1531 NTSTATUS status;
1532 TALLOC_CTX *mem_ctx;
1533
1534 if (state->out_mem_ctx) {
1535 mem_ctx = state->out_mem_ctx;
1536 } else {
1537 mem_ctx = state;
1538 }
1539
1540 status = state->dispatch_recv(subreq, mem_ctx);
1541 TALLOC_FREE(subreq);
1542 if (!NT_STATUS_IS_OK(status)) {
1543 tevent_req_nterror(req, status);
1544 return;
1545 }
1546
1547 /* Copy out parameters */
1548 *state->orig.out.level_out = *state->tmp.out.level_out;
1549 *state->orig.out.ctr = *state->tmp.out.ctr;
1550
1551 /* Copy result */
1552 state->orig.out.result = state->tmp.out.result;
1553
1554 /* Reset temporary structure */
1555 ZERO_STRUCT(state->tmp);
1556
1557 if (DEBUGLEVEL >= 10) {
1558 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships, &state->orig);
1559 }
1560
1561 tevent_req_done(req);
1562 }
1563
1564 NTSTATUS rpccli_drsuapi_DsGetMemberships_recv(struct tevent_req *req,
1565 TALLOC_CTX *mem_ctx,
1566 WERROR *result)
1567 {
1568 struct rpccli_drsuapi_DsGetMemberships_state *state = tevent_req_data(
1569 req, struct rpccli_drsuapi_DsGetMemberships_state);
1570 NTSTATUS status;
1571
1572 if (tevent_req_is_nterror(req, &status)) {
1573 tevent_req_received(req);
1574 return status;
1575 }
1576
1577 /* Steal possbile out parameters to the callers context */
1578 talloc_steal(mem_ctx, state->out_mem_ctx);
1579
1580 /* Return result */
1581 *result = state->orig.out.result;
1582
1583 tevent_req_received(req);
1584 return NT_STATUS_OK;
1585 }
1586
1587 NTSTATUS rpccli_drsuapi_DsGetMemberships(struct rpc_pipe_client *cli,
1588 TALLOC_CTX *mem_ctx,
1589 struct policy_handle *bind_handle /* [in] [ref] */,
1590 int32_t level /* [in] */,
1591 union drsuapi_DsGetMembershipsRequest *req /* [in] [ref,switch_is(level)] */,
1592 int32_t *level_out /* [out] [ref] */,
1593 union drsuapi_DsGetMembershipsCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
1594 WERROR *werror)
1595 {
1596 struct drsuapi_DsGetMemberships r;
1597 NTSTATUS status;
1598
1599 /* In parameters */
1600 r.in.bind_handle = bind_handle;
1601 r.in.level = level;
1602 r.in.req = req;
1603
1604 if (DEBUGLEVEL >= 10) {
1605 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships, &r);
1606 }
1607
1608 status = cli->dispatch(cli,
1609 mem_ctx,
1610 &ndr_table_drsuapi,
1611 NDR_DRSUAPI_DSGETMEMBERSHIPS,
1612 &r);
1613
1614 if (!NT_STATUS_IS_OK(status)) {
1615 return status;
1616 }
1617
1618 if (DEBUGLEVEL >= 10) {
1619 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships, &r);
1620 }
1621
1622 if (NT_STATUS_IS_ERR(status)) {
1623 return status;
1624 }
1625
1626 /* Return variables */
1627 *level_out = *r.out.level_out;
1628 *ctr = *r.out.ctr;
1629
1630 /* Return result */
1631 if (werror) {
1632 *werror = r.out.result;
1633 }
1634
1635 return werror_to_ntstatus(r.out.result);
1636 }
1637
1638 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state {
1639 struct DRSUAPI_INTER_DOMAIN_MOVE orig;
1640 struct DRSUAPI_INTER_DOMAIN_MOVE tmp;
1641 TALLOC_CTX *out_mem_ctx;
1642 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1643 };
1644
1645 static void rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done(struct tevent_req *subreq);
1646
1647 struct tevent_req *rpccli_DRSUAPI_INTER_DOMAIN_MOVE_send(TALLOC_CTX *mem_ctx,
1648 struct tevent_context *ev,
1649 struct rpc_pipe_client *cli)
1650 {
1651 struct tevent_req *req;
1652 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state;
1653 struct tevent_req *subreq;
1654
1655 req = tevent_req_create(mem_ctx, &state,
1656 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1657 if (req == NULL) {
1658 return NULL;
1659 }
1660 state->out_mem_ctx = NULL;
1661 state->dispatch_recv = cli->dispatch_recv;
1662
1663 /* In parameters */
1664
1665 /* Out parameters */
1666
1667 /* Result */
1668 ZERO_STRUCT(state->orig.out.result);
1669
1670 if (DEBUGLEVEL >= 10) {
1671 NDR_PRINT_IN_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &state->orig);
1672 }
1673
1674 /* make a temporary copy, that we pass to the dispatch function */
1675 state->tmp = state->orig;
1676
1677 subreq = cli->dispatch_send(state, ev, cli,
1678 &ndr_table_drsuapi,
1679 NDR_DRSUAPI_INTER_DOMAIN_MOVE,
1680 &state->tmp);
1681 if (tevent_req_nomem(subreq, req)) {
1682 return tevent_req_post(req, ev);
1683 }
1684 tevent_req_set_callback(subreq, rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done, req);
1685 return req;
1686 }
1687
1688 static void rpccli_DRSUAPI_INTER_DOMAIN_MOVE_done(struct tevent_req *subreq)
1689 {
1690 struct tevent_req *req = tevent_req_callback_data(
1691 subreq, struct tevent_req);
1692 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state = tevent_req_data(
1693 req, struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1694 NTSTATUS status;
1695 TALLOC_CTX *mem_ctx;
1696
1697 if (state->out_mem_ctx) {
1698 mem_ctx = state->out_mem_ctx;
1699 } else {
1700 mem_ctx = state;
1701 }
1702
1703 status = state->dispatch_recv(subreq, mem_ctx);
1704 TALLOC_FREE(subreq);
1705 if (!NT_STATUS_IS_OK(status)) {
1706 tevent_req_nterror(req, status);
1707 return;
1708 }
1709
1710 /* Copy out parameters */
1711
1712 /* Copy result */
1713 state->orig.out.result = state->tmp.out.result;
1714
1715 /* Reset temporary structure */
1716 ZERO_STRUCT(state->tmp);
1717
1718 if (DEBUGLEVEL >= 10) {
1719 NDR_PRINT_OUT_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &state->orig);
1720 }
1721
1722 tevent_req_done(req);
1723 }
1724
1725 NTSTATUS rpccli_DRSUAPI_INTER_DOMAIN_MOVE_recv(struct tevent_req *req,
1726 TALLOC_CTX *mem_ctx,
1727 WERROR *result)
1728 {
1729 struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state *state = tevent_req_data(
1730 req, struct rpccli_DRSUAPI_INTER_DOMAIN_MOVE_state);
1731 NTSTATUS status;
1732
1733 if (tevent_req_is_nterror(req, &status)) {
1734 tevent_req_received(req);
1735 return status;
1736 }
1737
1738 /* Steal possbile out parameters to the callers context */
1739 talloc_steal(mem_ctx, state->out_mem_ctx);
1740
1741 /* Return result */
1742 *result = state->orig.out.result;
1743
1744 tevent_req_received(req);
1745 return NT_STATUS_OK;
1746 }
1747
1748 NTSTATUS rpccli_DRSUAPI_INTER_DOMAIN_MOVE(struct rpc_pipe_client *cli,
1749 TALLOC_CTX *mem_ctx,
1750 WERROR *werror)
1751 {
1752 struct DRSUAPI_INTER_DOMAIN_MOVE r;
1753 NTSTATUS status;
1754
1755 /* In parameters */
1756
1757 if (DEBUGLEVEL >= 10) {
1758 NDR_PRINT_IN_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &r);
1759 }
1760
1761 status = cli->dispatch(cli,
1762 mem_ctx,
1763 &ndr_table_drsuapi,
1764 NDR_DRSUAPI_INTER_DOMAIN_MOVE,
1765 &r);
1766
1767 if (!NT_STATUS_IS_OK(status)) {
1768 return status;
1769 }
1770
1771 if (DEBUGLEVEL >= 10) {
1772 NDR_PRINT_OUT_DEBUG(DRSUAPI_INTER_DOMAIN_MOVE, &r);
1773 }
1774
1775 if (NT_STATUS_IS_ERR(status)) {
1776 return status;
1777 }
1778
1779 /* Return variables */
1780
1781 /* Return result */
1782 if (werror) {
1783 *werror = r.out.result;
1784 }
1785
1786 return werror_to_ntstatus(r.out.result);
1787 }
1788
1789 struct rpccli_drsuapi_DsGetNT4ChangeLog_state {
1790 struct drsuapi_DsGetNT4ChangeLog orig;
1791 struct drsuapi_DsGetNT4ChangeLog tmp;
1792 TALLOC_CTX *out_mem_ctx;
1793 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1794 };
1795
1796 static void rpccli_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq);
1797
1798 struct tevent_req *rpccli_drsuapi_DsGetNT4ChangeLog_send(TALLOC_CTX *mem_ctx,
1799 struct tevent_context *ev,
1800 struct rpc_pipe_client *cli,
1801 struct policy_handle *_bind_handle /* [in] [ref] */,
1802 uint32_t _level /* [in] */,
1803 union drsuapi_DsGetNT4ChangeLogRequest *_req /* [in] [ref,switch_is(level)] */,
1804 uint32_t *_level_out /* [out] [ref] */,
1805 union drsuapi_DsGetNT4ChangeLogInfo *_info /* [out] [ref,switch_is(*level_out)] */)
1806 {
1807 struct tevent_req *req;
1808 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state;
1809 struct tevent_req *subreq;
1810
1811 req = tevent_req_create(mem_ctx, &state,
1812 struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1813 if (req == NULL) {
1814 return NULL;
1815 }
1816 state->out_mem_ctx = NULL;
1817 state->dispatch_recv = cli->dispatch_recv;
1818
1819 /* In parameters */
1820 state->orig.in.bind_handle = _bind_handle;
1821 state->orig.in.level = _level;
1822 state->orig.in.req = _req;
1823
1824 /* Out parameters */
1825 state->orig.out.level_out = _level_out;
1826 state->orig.out.info = _info;
1827
1828 /* Result */
1829 ZERO_STRUCT(state->orig.out.result);
1830
1831 if (DEBUGLEVEL >= 10) {
1832 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNT4ChangeLog, &state->orig);
1833 }
1834
1835 state->out_mem_ctx = talloc_named_const(state, 0,
1836 "rpccli_drsuapi_DsGetNT4ChangeLog_out_memory");
1837 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1838 return tevent_req_post(req, ev);
1839 }
1840
1841 /* make a temporary copy, that we pass to the dispatch function */
1842 state->tmp = state->orig;
1843
1844 subreq = cli->dispatch_send(state, ev, cli,
1845 &ndr_table_drsuapi,
1846 NDR_DRSUAPI_DSGETNT4CHANGELOG,
1847 &state->tmp);
1848 if (tevent_req_nomem(subreq, req)) {
1849 return tevent_req_post(req, ev);
1850 }
1851 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetNT4ChangeLog_done, req);
1852 return req;
1853 }
1854
1855 static void rpccli_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq)
1856 {
1857 struct tevent_req *req = tevent_req_callback_data(
1858 subreq, struct tevent_req);
1859 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
1860 req, struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1861 NTSTATUS status;
1862 TALLOC_CTX *mem_ctx;
1863
1864 if (state->out_mem_ctx) {
1865 mem_ctx = state->out_mem_ctx;
1866 } else {
1867 mem_ctx = state;
1868 }
1869
1870 status = state->dispatch_recv(subreq, mem_ctx);
1871 TALLOC_FREE(subreq);
1872 if (!NT_STATUS_IS_OK(status)) {
1873 tevent_req_nterror(req, status);
1874 return;
1875 }
1876
1877 /* Copy out parameters */
1878 *state->orig.out.level_out = *state->tmp.out.level_out;
1879 *state->orig.out.info = *state->tmp.out.info;
1880
1881 /* Copy result */
1882 state->orig.out.result = state->tmp.out.result;
1883
1884 /* Reset temporary structure */
1885 ZERO_STRUCT(state->tmp);
1886
1887 if (DEBUGLEVEL >= 10) {
1888 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNT4ChangeLog, &state->orig);
1889 }
1890
1891 tevent_req_done(req);
1892 }
1893
1894 NTSTATUS rpccli_drsuapi_DsGetNT4ChangeLog_recv(struct tevent_req *req,
1895 TALLOC_CTX *mem_ctx,
1896 WERROR *result)
1897 {
1898 struct rpccli_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
1899 req, struct rpccli_drsuapi_DsGetNT4ChangeLog_state);
1900 NTSTATUS status;
1901
1902 if (tevent_req_is_nterror(req, &status)) {
1903 tevent_req_received(req);
1904 return status;
1905 }
1906
1907 /* Steal possbile out parameters to the callers context */
1908 talloc_steal(mem_ctx, state->out_mem_ctx);
1909
1910 /* Return result */
1911 *result = state->orig.out.result;
1912
1913 tevent_req_received(req);
1914 return NT_STATUS_OK;
1915 }
1916
1917 NTSTATUS rpccli_drsuapi_DsGetNT4ChangeLog(struct rpc_pipe_client *cli,
1918 TALLOC_CTX *mem_ctx,
1919 struct policy_handle *bind_handle /* [in] [ref] */,
1920 uint32_t level /* [in] */,
1921 union drsuapi_DsGetNT4ChangeLogRequest *req /* [in] [ref,switch_is(level)] */,
1922 uint32_t *level_out /* [out] [ref] */,
1923 union drsuapi_DsGetNT4ChangeLogInfo *info /* [out] [ref,switch_is(*level_out)] */,
1924 WERROR *werror)
1925 {
1926 struct drsuapi_DsGetNT4ChangeLog r;
1927 NTSTATUS status;
1928
1929 /* In parameters */
1930 r.in.bind_handle = bind_handle;
1931 r.in.level = level;
1932 r.in.req = req;
1933
1934 if (DEBUGLEVEL >= 10) {
1935 NDR_PRINT_IN_DEBUG(drsuapi_DsGetNT4ChangeLog, &r);
1936 }
1937
1938 status = cli->dispatch(cli,
1939 mem_ctx,
1940 &ndr_table_drsuapi,
1941 NDR_DRSUAPI_DSGETNT4CHANGELOG,
1942 &r);
1943
1944 if (!NT_STATUS_IS_OK(status)) {
1945 return status;
1946 }
1947
1948 if (DEBUGLEVEL >= 10) {
1949 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNT4ChangeLog, &r);
1950 }
1951
1952 if (NT_STATUS_IS_ERR(status)) {
1953 return status;
1954 }
1955
1956 /* Return variables */
1957 *level_out = *r.out.level_out;
1958 *info = *r.out.info;
1959
1960 /* Return result */
1961 if (werror) {
1962 *werror = r.out.result;
1963 }
1964
1965 return werror_to_ntstatus(r.out.result);
1966 }
1967
1968 struct rpccli_drsuapi_DsCrackNames_state {
1969 struct drsuapi_DsCrackNames orig;
1970 struct drsuapi_DsCrackNames tmp;
1971 TALLOC_CTX *out_mem_ctx;
1972 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1973 };
1974
1975 static void rpccli_drsuapi_DsCrackNames_done(struct tevent_req *subreq);
1976
1977 struct tevent_req *rpccli_drsuapi_DsCrackNames_send(TALLOC_CTX *mem_ctx,
1978 struct tevent_context *ev,
1979 struct rpc_pipe_client *cli,
1980 struct policy_handle *_bind_handle /* [in] [ref] */,
1981 int32_t _level /* [in] */,
1982 union drsuapi_DsNameRequest *_req /* [in] [ref,switch_is(level)] */,
1983 int32_t *_level_out /* [out] [ref] */,
1984 union drsuapi_DsNameCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
1985 {
1986 struct tevent_req *req;
1987 struct rpccli_drsuapi_DsCrackNames_state *state;
1988 struct tevent_req *subreq;
1989
1990 req = tevent_req_create(mem_ctx, &state,
1991 struct rpccli_drsuapi_DsCrackNames_state);
1992 if (req == NULL) {
1993 return NULL;
1994 }
1995 state->out_mem_ctx = NULL;
1996 state->dispatch_recv = cli->dispatch_recv;
1997
1998 /* In parameters */
1999 state->orig.in.bind_handle = _bind_handle;
2000 state->orig.in.level = _level;
2001 state->orig.in.req = _req;
2002
2003 /* Out parameters */
2004 state->orig.out.level_out = _level_out;
2005 state->orig.out.ctr = _ctr;
2006
2007 /* Result */
2008 ZERO_STRUCT(state->orig.out.result);
2009
2010 if (DEBUGLEVEL >= 10) {
2011 NDR_PRINT_IN_DEBUG(drsuapi_DsCrackNames, &state->orig);
2012 }
2013
2014 state->out_mem_ctx = talloc_named_const(state, 0,
2015 "rpccli_drsuapi_DsCrackNames_out_memory");
2016 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2017 return tevent_req_post(req, ev);
2018 }
2019
2020 /* make a temporary copy, that we pass to the dispatch function */
2021 state->tmp = state->orig;
2022
2023 subreq = cli->dispatch_send(state, ev, cli,
2024 &ndr_table_drsuapi,
2025 NDR_DRSUAPI_DSCRACKNAMES,
2026 &state->tmp);
2027 if (tevent_req_nomem(subreq, req)) {
2028 return tevent_req_post(req, ev);
2029 }
2030 tevent_req_set_callback(subreq, rpccli_drsuapi_DsCrackNames_done, req);
2031 return req;
2032 }
2033
2034 static void rpccli_drsuapi_DsCrackNames_done(struct tevent_req *subreq)
2035 {
2036 struct tevent_req *req = tevent_req_callback_data(
2037 subreq, struct tevent_req);
2038 struct rpccli_drsuapi_DsCrackNames_state *state = tevent_req_data(
2039 req, struct rpccli_drsuapi_DsCrackNames_state);
2040 NTSTATUS status;
2041 TALLOC_CTX *mem_ctx;
2042
2043 if (state->out_mem_ctx) {
2044 mem_ctx = state->out_mem_ctx;
2045 } else {
2046 mem_ctx = state;
2047 }
2048
2049 status = state->dispatch_recv(subreq, mem_ctx);
2050 TALLOC_FREE(subreq);
2051 if (!NT_STATUS_IS_OK(status)) {
2052 tevent_req_nterror(req, status);
2053 return;
2054 }
2055
2056 /* Copy out parameters */
2057 *state->orig.out.level_out = *state->tmp.out.level_out;
2058 *state->orig.out.ctr = *state->tmp.out.ctr;
2059
2060 /* Copy result */
2061 state->orig.out.result = state->tmp.out.result;
2062
2063 /* Reset temporary structure */
2064 ZERO_STRUCT(state->tmp);
2065
2066 if (DEBUGLEVEL >= 10) {
2067 NDR_PRINT_OUT_DEBUG(drsuapi_DsCrackNames, &state->orig);
2068 }
2069
2070 tevent_req_done(req);
2071 }
2072
2073 NTSTATUS rpccli_drsuapi_DsCrackNames_recv(struct tevent_req *req,
2074 TALLOC_CTX *mem_ctx,
2075 WERROR *result)
2076 {
2077 struct rpccli_drsuapi_DsCrackNames_state *state = tevent_req_data(
2078 req, struct rpccli_drsuapi_DsCrackNames_state);
2079 NTSTATUS status;
2080
2081 if (tevent_req_is_nterror(req, &status)) {
2082 tevent_req_received(req);
2083 return status;
2084 }
2085
2086 /* Steal possbile out parameters to the callers context */
2087 talloc_steal(mem_ctx, state->out_mem_ctx);
2088
2089 /* Return result */
2090 *result = state->orig.out.result;
2091
2092 tevent_req_received(req);
2093 return NT_STATUS_OK;
2094 }
2095
2096 NTSTATUS rpccli_drsuapi_DsCrackNames(struct rpc_pipe_client *cli,
2097 TALLOC_CTX *mem_ctx,
2098 struct policy_handle *bind_handle /* [in] [ref] */,
2099 int32_t level /* [in] */,
2100 union drsuapi_DsNameRequest *req /* [in] [ref,switch_is(level)] */,
2101 int32_t *level_out /* [out] [ref] */,
2102 union drsuapi_DsNameCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
2103 WERROR *werror)
2104 {
2105 struct drsuapi_DsCrackNames r;
2106 NTSTATUS status;
2107
2108 /* In parameters */
2109 r.in.bind_handle = bind_handle;
2110 r.in.level = level;
2111 r.in.req = req;
2112
2113 if (DEBUGLEVEL >= 10) {
2114 NDR_PRINT_IN_DEBUG(drsuapi_DsCrackNames, &r);
2115 }
2116
2117 status = cli->dispatch(cli,
2118 mem_ctx,
2119 &ndr_table_drsuapi,
2120 NDR_DRSUAPI_DSCRACKNAMES,
2121 &r);
2122
2123 if (!NT_STATUS_IS_OK(status)) {
2124 return status;
2125 }
2126
2127 if (DEBUGLEVEL >= 10) {
2128 NDR_PRINT_OUT_DEBUG(drsuapi_DsCrackNames, &r);
2129 }
2130
2131 if (NT_STATUS_IS_ERR(status)) {
2132 return status;
2133 }
2134
2135 /* Return variables */
2136 *level_out = *r.out.level_out;
2137 *ctr = *r.out.ctr;
2138
2139 /* Return result */
2140 if (werror) {
2141 *werror = r.out.result;
2142 }
2143
2144 return werror_to_ntstatus(r.out.result);
2145 }
2146
2147 struct rpccli_drsuapi_DsWriteAccountSpn_state {
2148 struct drsuapi_DsWriteAccountSpn orig;
2149 struct drsuapi_DsWriteAccountSpn tmp;
2150 TALLOC_CTX *out_mem_ctx;
2151 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2152 };
2153
2154 static void rpccli_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq);
2155
2156 struct tevent_req *rpccli_drsuapi_DsWriteAccountSpn_send(TALLOC_CTX *mem_ctx,
2157 struct tevent_context *ev,
2158 struct rpc_pipe_client *cli,
2159 struct policy_handle *_bind_handle /* [in] [ref] */,
2160 int32_t _level /* [in] */,
2161 union drsuapi_DsWriteAccountSpnRequest *_req /* [in] [ref,switch_is(level)] */,
2162 int32_t *_level_out /* [out] [ref] */,
2163 union drsuapi_DsWriteAccountSpnResult *_res /* [out] [ref,switch_is(*level_out)] */)
2164 {
2165 struct tevent_req *req;
2166 struct rpccli_drsuapi_DsWriteAccountSpn_state *state;
2167 struct tevent_req *subreq;
2168
2169 req = tevent_req_create(mem_ctx, &state,
2170 struct rpccli_drsuapi_DsWriteAccountSpn_state);
2171 if (req == NULL) {
2172 return NULL;
2173 }
2174 state->out_mem_ctx = NULL;
2175 state->dispatch_recv = cli->dispatch_recv;
2176
2177 /* In parameters */
2178 state->orig.in.bind_handle = _bind_handle;
2179 state->orig.in.level = _level;
2180 state->orig.in.req = _req;
2181
2182 /* Out parameters */
2183 state->orig.out.level_out = _level_out;
2184 state->orig.out.res = _res;
2185
2186 /* Result */
2187 ZERO_STRUCT(state->orig.out.result);
2188
2189 if (DEBUGLEVEL >= 10) {
2190 NDR_PRINT_IN_DEBUG(drsuapi_DsWriteAccountSpn, &state->orig);
2191 }
2192
2193 state->out_mem_ctx = talloc_named_const(state, 0,
2194 "rpccli_drsuapi_DsWriteAccountSpn_out_memory");
2195 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2196 return tevent_req_post(req, ev);
2197 }
2198
2199 /* make a temporary copy, that we pass to the dispatch function */
2200 state->tmp = state->orig;
2201
2202 subreq = cli->dispatch_send(state, ev, cli,
2203 &ndr_table_drsuapi,
2204 NDR_DRSUAPI_DSWRITEACCOUNTSPN,
2205 &state->tmp);
2206 if (tevent_req_nomem(subreq, req)) {
2207 return tevent_req_post(req, ev);
2208 }
2209 tevent_req_set_callback(subreq, rpccli_drsuapi_DsWriteAccountSpn_done, req);
2210 return req;
2211 }
2212
2213 static void rpccli_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq)
2214 {
2215 struct tevent_req *req = tevent_req_callback_data(
2216 subreq, struct tevent_req);
2217 struct rpccli_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
2218 req, struct rpccli_drsuapi_DsWriteAccountSpn_state);
2219 NTSTATUS status;
2220 TALLOC_CTX *mem_ctx;
2221
2222 if (state->out_mem_ctx) {
2223 mem_ctx = state->out_mem_ctx;
2224 } else {
2225 mem_ctx = state;
2226 }
2227
2228 status = state->dispatch_recv(subreq, mem_ctx);
2229 TALLOC_FREE(subreq);
2230 if (!NT_STATUS_IS_OK(status)) {
2231 tevent_req_nterror(req, status);
2232 return;
2233 }
2234
2235 /* Copy out parameters */
2236 *state->orig.out.level_out = *state->tmp.out.level_out;
2237 *state->orig.out.res = *state->tmp.out.res;
2238
2239 /* Copy result */
2240 state->orig.out.result = state->tmp.out.result;
2241
2242 /* Reset temporary structure */
2243 ZERO_STRUCT(state->tmp);
2244
2245 if (DEBUGLEVEL >= 10) {
2246 NDR_PRINT_OUT_DEBUG(drsuapi_DsWriteAccountSpn, &state->orig);
2247 }
2248
2249 tevent_req_done(req);
2250 }
2251
2252 NTSTATUS rpccli_drsuapi_DsWriteAccountSpn_recv(struct tevent_req *req,
2253 TALLOC_CTX *mem_ctx,
2254 WERROR *result)
2255 {
2256 struct rpccli_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
2257 req, struct rpccli_drsuapi_DsWriteAccountSpn_state);
2258 NTSTATUS status;
2259
2260 if (tevent_req_is_nterror(req, &status)) {
2261 tevent_req_received(req);
2262 return status;
2263 }
2264
2265 /* Steal possbile out parameters to the callers context */
2266 talloc_steal(mem_ctx, state->out_mem_ctx);
2267
2268 /* Return result */
2269 *result = state->orig.out.result;
2270
2271 tevent_req_received(req);
2272 return NT_STATUS_OK;
2273 }
2274
2275 NTSTATUS rpccli_drsuapi_DsWriteAccountSpn(struct rpc_pipe_client *cli,
2276 TALLOC_CTX *mem_ctx,
2277 struct policy_handle *bind_handle /* [in] [ref] */,
2278 int32_t level /* [in] */,
2279 union drsuapi_DsWriteAccountSpnRequest *req /* [in] [ref,switch_is(level)] */,
2280 int32_t *level_out /* [out] [ref] */,
2281 union drsuapi_DsWriteAccountSpnResult *res /* [out] [ref,switch_is(*level_out)] */,
2282 WERROR *werror)
2283 {
2284 struct drsuapi_DsWriteAccountSpn r;
2285 NTSTATUS status;
2286
2287 /* In parameters */
2288 r.in.bind_handle = bind_handle;
2289 r.in.level = level;
2290 r.in.req = req;
2291
2292 if (DEBUGLEVEL >= 10) {
2293 NDR_PRINT_IN_DEBUG(drsuapi_DsWriteAccountSpn, &r);
2294 }
2295
2296 status = cli->dispatch(cli,
2297 mem_ctx,
2298 &ndr_table_drsuapi,
2299 NDR_DRSUAPI_DSWRITEACCOUNTSPN,
2300 &r);
2301
2302 if (!NT_STATUS_IS_OK(status)) {
2303 return status;
2304 }
2305
2306 if (DEBUGLEVEL >= 10) {
2307 NDR_PRINT_OUT_DEBUG(drsuapi_DsWriteAccountSpn, &r);
2308 }
2309
2310 if (NT_STATUS_IS_ERR(status)) {
2311 return status;
2312 }
2313
2314 /* Return variables */
2315 *level_out = *r.out.level_out;
2316 *res = *r.out.res;
2317
2318 /* Return result */
2319 if (werror) {
2320 *werror = r.out.result;
2321 }
2322
2323 return werror_to_ntstatus(r.out.result);
2324 }
2325
2326 struct rpccli_drsuapi_DsRemoveDSServer_state {
2327 struct drsuapi_DsRemoveDSServer orig;
2328 struct drsuapi_DsRemoveDSServer tmp;
2329 TALLOC_CTX *out_mem_ctx;
2330 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2331 };
2332
2333 static void rpccli_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq);
2334
2335 struct tevent_req *rpccli_drsuapi_DsRemoveDSServer_send(TALLOC_CTX *mem_ctx,
2336 struct tevent_context *ev,
2337 struct rpc_pipe_client *cli,
2338 struct policy_handle *_bind_handle /* [in] [ref] */,
2339 int32_t _level /* [in] */,
2340 union drsuapi_DsRemoveDSServerRequest *_req /* [in] [ref,switch_is(level)] */,
2341 int32_t *_level_out /* [out] [ref] */,
2342 union drsuapi_DsRemoveDSServerResult *_res /* [out] [ref,switch_is(*level_out)] */)
2343 {
2344 struct tevent_req *req;
2345 struct rpccli_drsuapi_DsRemoveDSServer_state *state;
2346 struct tevent_req *subreq;
2347
2348 req = tevent_req_create(mem_ctx, &state,
2349 struct rpccli_drsuapi_DsRemoveDSServer_state);
2350 if (req == NULL) {
2351 return NULL;
2352 }
2353 state->out_mem_ctx = NULL;
2354 state->dispatch_recv = cli->dispatch_recv;
2355
2356 /* In parameters */
2357 state->orig.in.bind_handle = _bind_handle;
2358 state->orig.in.level = _level;
2359 state->orig.in.req = _req;
2360
2361 /* Out parameters */
2362 state->orig.out.level_out = _level_out;
2363 state->orig.out.res = _res;
2364
2365 /* Result */
2366 ZERO_STRUCT(state->orig.out.result);
2367
2368 if (DEBUGLEVEL >= 10) {
2369 NDR_PRINT_IN_DEBUG(drsuapi_DsRemoveDSServer, &state->orig);
2370 }
2371
2372 state->out_mem_ctx = talloc_named_const(state, 0,
2373 "rpccli_drsuapi_DsRemoveDSServer_out_memory");
2374 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2375 return tevent_req_post(req, ev);
2376 }
2377
2378 /* make a temporary copy, that we pass to the dispatch function */
2379 state->tmp = state->orig;
2380
2381 subreq = cli->dispatch_send(state, ev, cli,
2382 &ndr_table_drsuapi,
2383 NDR_DRSUAPI_DSREMOVEDSSERVER,
2384 &state->tmp);
2385 if (tevent_req_nomem(subreq, req)) {
2386 return tevent_req_post(req, ev);
2387 }
2388 tevent_req_set_callback(subreq, rpccli_drsuapi_DsRemoveDSServer_done, req);
2389 return req;
2390 }
2391
2392 static void rpccli_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq)
2393 {
2394 struct tevent_req *req = tevent_req_callback_data(
2395 subreq, struct tevent_req);
2396 struct rpccli_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
2397 req, struct rpccli_drsuapi_DsRemoveDSServer_state);
2398 NTSTATUS status;
2399 TALLOC_CTX *mem_ctx;
2400
2401 if (state->out_mem_ctx) {
2402 mem_ctx = state->out_mem_ctx;
2403 } else {
2404 mem_ctx = state;
2405 }
2406
2407 status = state->dispatch_recv(subreq, mem_ctx);
2408 TALLOC_FREE(subreq);
2409 if (!NT_STATUS_IS_OK(status)) {
2410 tevent_req_nterror(req, status);
2411 return;
2412 }
2413
2414 /* Copy out parameters */
2415 *state->orig.out.level_out = *state->tmp.out.level_out;
2416 *state->orig.out.res = *state->tmp.out.res;
2417
2418 /* Copy result */
2419 state->orig.out.result = state->tmp.out.result;
2420
2421 /* Reset temporary structure */
2422 ZERO_STRUCT(state->tmp);
2423
2424 if (DEBUGLEVEL >= 10) {
2425 NDR_PRINT_OUT_DEBUG(drsuapi_DsRemoveDSServer, &state->orig);
2426 }
2427
2428 tevent_req_done(req);
2429 }
2430
2431 NTSTATUS rpccli_drsuapi_DsRemoveDSServer_recv(struct tevent_req *req,
2432 TALLOC_CTX *mem_ctx,
2433 WERROR *result)
2434 {
2435 struct rpccli_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
2436 req, struct rpccli_drsuapi_DsRemoveDSServer_state);
2437 NTSTATUS status;
2438
2439 if (tevent_req_is_nterror(req, &status)) {
2440 tevent_req_received(req);
2441 return status;
2442 }
2443
2444 /* Steal possbile out parameters to the callers context */
2445 talloc_steal(mem_ctx, state->out_mem_ctx);
2446
2447 /* Return result */
2448 *result = state->orig.out.result;
2449
2450 tevent_req_received(req);
2451 return NT_STATUS_OK;
2452 }
2453
2454 NTSTATUS rpccli_drsuapi_DsRemoveDSServer(struct rpc_pipe_client *cli,
2455 TALLOC_CTX *mem_ctx,
2456 struct policy_handle *bind_handle /* [in] [ref] */,
2457 int32_t level /* [in] */,
2458 union drsuapi_DsRemoveDSServerRequest *req /* [in] [ref,switch_is(level)] */,
2459 int32_t *level_out /* [out] [ref] */,
2460 union drsuapi_DsRemoveDSServerResult *res /* [out] [ref,switch_is(*level_out)] */,
2461 WERROR *werror)
2462 {
2463 struct drsuapi_DsRemoveDSServer r;
2464 NTSTATUS status;
2465
2466 /* In parameters */
2467 r.in.bind_handle = bind_handle;
2468 r.in.level = level;
2469 r.in.req = req;
2470
2471 if (DEBUGLEVEL >= 10) {
2472 NDR_PRINT_IN_DEBUG(drsuapi_DsRemoveDSServer, &r);
2473 }
2474
2475 status = cli->dispatch(cli,
2476 mem_ctx,
2477 &ndr_table_drsuapi,
2478 NDR_DRSUAPI_DSREMOVEDSSERVER,
2479 &r);
2480
2481 if (!NT_STATUS_IS_OK(status)) {
2482 return status;
2483 }
2484
2485 if (DEBUGLEVEL >= 10) {
2486 NDR_PRINT_OUT_DEBUG(drsuapi_DsRemoveDSServer, &r);
2487 }
2488
2489 if (NT_STATUS_IS_ERR(status)) {
2490 return status;
2491 }
2492
2493 /* Return variables */
2494 *level_out = *r.out.level_out;
2495 *res = *r.out.res;
2496
2497 /* Return result */
2498 if (werror) {
2499 *werror = r.out.result;
2500 }
2501
2502 return werror_to_ntstatus(r.out.result);
2503 }
2504
2505 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state {
2506 struct DRSUAPI_REMOVE_DS_DOMAIN orig;
2507 struct DRSUAPI_REMOVE_DS_DOMAIN tmp;
2508 TALLOC_CTX *out_mem_ctx;
2509 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2510 };
2511
2512 static void rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done(struct tevent_req *subreq);
2513
2514 struct tevent_req *rpccli_DRSUAPI_REMOVE_DS_DOMAIN_send(TALLOC_CTX *mem_ctx,
2515 struct tevent_context *ev,
2516 struct rpc_pipe_client *cli)
2517 {
2518 struct tevent_req *req;
2519 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state;
2520 struct tevent_req *subreq;
2521
2522 req = tevent_req_create(mem_ctx, &state,
2523 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2524 if (req == NULL) {
2525 return NULL;
2526 }
2527 state->out_mem_ctx = NULL;
2528 state->dispatch_recv = cli->dispatch_recv;
2529
2530 /* In parameters */
2531
2532 /* Out parameters */
2533
2534 /* Result */
2535 ZERO_STRUCT(state->orig.out.result);
2536
2537 if (DEBUGLEVEL >= 10) {
2538 NDR_PRINT_IN_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &state->orig);
2539 }
2540
2541 /* make a temporary copy, that we pass to the dispatch function */
2542 state->tmp = state->orig;
2543
2544 subreq = cli->dispatch_send(state, ev, cli,
2545 &ndr_table_drsuapi,
2546 NDR_DRSUAPI_REMOVE_DS_DOMAIN,
2547 &state->tmp);
2548 if (tevent_req_nomem(subreq, req)) {
2549 return tevent_req_post(req, ev);
2550 }
2551 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done, req);
2552 return req;
2553 }
2554
2555 static void rpccli_DRSUAPI_REMOVE_DS_DOMAIN_done(struct tevent_req *subreq)
2556 {
2557 struct tevent_req *req = tevent_req_callback_data(
2558 subreq, struct tevent_req);
2559 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state = tevent_req_data(
2560 req, struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2561 NTSTATUS status;
2562 TALLOC_CTX *mem_ctx;
2563
2564 if (state->out_mem_ctx) {
2565 mem_ctx = state->out_mem_ctx;
2566 } else {
2567 mem_ctx = state;
2568 }
2569
2570 status = state->dispatch_recv(subreq, mem_ctx);
2571 TALLOC_FREE(subreq);
2572 if (!NT_STATUS_IS_OK(status)) {
2573 tevent_req_nterror(req, status);
2574 return;
2575 }
2576
2577 /* Copy out parameters */
2578
2579 /* Copy result */
2580 state->orig.out.result = state->tmp.out.result;
2581
2582 /* Reset temporary structure */
2583 ZERO_STRUCT(state->tmp);
2584
2585 if (DEBUGLEVEL >= 10) {
2586 NDR_PRINT_OUT_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &state->orig);
2587 }
2588
2589 tevent_req_done(req);
2590 }
2591
2592 NTSTATUS rpccli_DRSUAPI_REMOVE_DS_DOMAIN_recv(struct tevent_req *req,
2593 TALLOC_CTX *mem_ctx,
2594 WERROR *result)
2595 {
2596 struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state *state = tevent_req_data(
2597 req, struct rpccli_DRSUAPI_REMOVE_DS_DOMAIN_state);
2598 NTSTATUS status;
2599
2600 if (tevent_req_is_nterror(req, &status)) {
2601 tevent_req_received(req);
2602 return status;
2603 }
2604
2605 /* Steal possbile out parameters to the callers context */
2606 talloc_steal(mem_ctx, state->out_mem_ctx);
2607
2608 /* Return result */
2609 *result = state->orig.out.result;
2610
2611 tevent_req_received(req);
2612 return NT_STATUS_OK;
2613 }
2614
2615 NTSTATUS rpccli_DRSUAPI_REMOVE_DS_DOMAIN(struct rpc_pipe_client *cli,
2616 TALLOC_CTX *mem_ctx,
2617 WERROR *werror)
2618 {
2619 struct DRSUAPI_REMOVE_DS_DOMAIN r;
2620 NTSTATUS status;
2621
2622 /* In parameters */
2623
2624 if (DEBUGLEVEL >= 10) {
2625 NDR_PRINT_IN_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &r);
2626 }
2627
2628 status = cli->dispatch(cli,
2629 mem_ctx,
2630 &ndr_table_drsuapi,
2631 NDR_DRSUAPI_REMOVE_DS_DOMAIN,
2632 &r);
2633
2634 if (!NT_STATUS_IS_OK(status)) {
2635 return status;
2636 }
2637
2638 if (DEBUGLEVEL >= 10) {
2639 NDR_PRINT_OUT_DEBUG(DRSUAPI_REMOVE_DS_DOMAIN, &r);
2640 }
2641
2642 if (NT_STATUS_IS_ERR(status)) {
2643 return status;
2644 }
2645
2646 /* Return variables */
2647
2648 /* Return result */
2649 if (werror) {
2650 *werror = r.out.result;
2651 }
2652
2653 return werror_to_ntstatus(r.out.result);
2654 }
2655
2656 struct rpccli_drsuapi_DsGetDomainControllerInfo_state {
2657 struct drsuapi_DsGetDomainControllerInfo orig;
2658 struct drsuapi_DsGetDomainControllerInfo tmp;
2659 TALLOC_CTX *out_mem_ctx;
2660 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2661 };
2662
2663 static void rpccli_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq);
2664
2665 struct tevent_req *rpccli_drsuapi_DsGetDomainControllerInfo_send(TALLOC_CTX *mem_ctx,
2666 struct tevent_context *ev,
2667 struct rpc_pipe_client *cli,
2668 struct policy_handle *_bind_handle /* [in] [ref] */,
2669 int32_t _level /* [in] */,
2670 union drsuapi_DsGetDCInfoRequest *_req /* [in] [ref,switch_is(level)] */,
2671 int32_t *_level_out /* [out] [ref] */,
2672 union drsuapi_DsGetDCInfoCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
2673 {
2674 struct tevent_req *req;
2675 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state;
2676 struct tevent_req *subreq;
2677
2678 req = tevent_req_create(mem_ctx, &state,
2679 struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2680 if (req == NULL) {
2681 return NULL;
2682 }
2683 state->out_mem_ctx = NULL;
2684 state->dispatch_recv = cli->dispatch_recv;
2685
2686 /* In parameters */
2687 state->orig.in.bind_handle = _bind_handle;
2688 state->orig.in.level = _level;
2689 state->orig.in.req = _req;
2690
2691 /* Out parameters */
2692 state->orig.out.level_out = _level_out;
2693 state->orig.out.ctr = _ctr;
2694
2695 /* Result */
2696 ZERO_STRUCT(state->orig.out.result);
2697
2698 if (DEBUGLEVEL >= 10) {
2699 NDR_PRINT_IN_DEBUG(drsuapi_DsGetDomainControllerInfo, &state->orig);
2700 }
2701
2702 state->out_mem_ctx = talloc_named_const(state, 0,
2703 "rpccli_drsuapi_DsGetDomainControllerInfo_out_memory");
2704 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2705 return tevent_req_post(req, ev);
2706 }
2707
2708 /* make a temporary copy, that we pass to the dispatch function */
2709 state->tmp = state->orig;
2710
2711 subreq = cli->dispatch_send(state, ev, cli,
2712 &ndr_table_drsuapi,
2713 NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO,
2714 &state->tmp);
2715 if (tevent_req_nomem(subreq, req)) {
2716 return tevent_req_post(req, ev);
2717 }
2718 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetDomainControllerInfo_done, req);
2719 return req;
2720 }
2721
2722 static void rpccli_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq)
2723 {
2724 struct tevent_req *req = tevent_req_callback_data(
2725 subreq, struct tevent_req);
2726 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
2727 req, struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2728 NTSTATUS status;
2729 TALLOC_CTX *mem_ctx;
2730
2731 if (state->out_mem_ctx) {
2732 mem_ctx = state->out_mem_ctx;
2733 } else {
2734 mem_ctx = state;
2735 }
2736
2737 status = state->dispatch_recv(subreq, mem_ctx);
2738 TALLOC_FREE(subreq);
2739 if (!NT_STATUS_IS_OK(status)) {
2740 tevent_req_nterror(req, status);
2741 return;
2742 }
2743
2744 /* Copy out parameters */
2745 *state->orig.out.level_out = *state->tmp.out.level_out;
2746 *state->orig.out.ctr = *state->tmp.out.ctr;
2747
2748 /* Copy result */
2749 state->orig.out.result = state->tmp.out.result;
2750
2751 /* Reset temporary structure */
2752 ZERO_STRUCT(state->tmp);
2753
2754 if (DEBUGLEVEL >= 10) {
2755 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetDomainControllerInfo, &state->orig);
2756 }
2757
2758 tevent_req_done(req);
2759 }
2760
2761 NTSTATUS rpccli_drsuapi_DsGetDomainControllerInfo_recv(struct tevent_req *req,
2762 TALLOC_CTX *mem_ctx,
2763 WERROR *result)
2764 {
2765 struct rpccli_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
2766 req, struct rpccli_drsuapi_DsGetDomainControllerInfo_state);
2767 NTSTATUS status;
2768
2769 if (tevent_req_is_nterror(req, &status)) {
2770 tevent_req_received(req);
2771 return status;
2772 }
2773
2774 /* Steal possbile out parameters to the callers context */
2775 talloc_steal(mem_ctx, state->out_mem_ctx);
2776
2777 /* Return result */
2778 *result = state->orig.out.result;
2779
2780 tevent_req_received(req);
2781 return NT_STATUS_OK;
2782 }
2783
2784 NTSTATUS rpccli_drsuapi_DsGetDomainControllerInfo(struct rpc_pipe_client *cli,
2785 TALLOC_CTX *mem_ctx,
2786 struct policy_handle *bind_handle /* [in] [ref] */,
2787 int32_t level /* [in] */,
2788 union drsuapi_DsGetDCInfoRequest *req /* [in] [ref,switch_is(level)] */,
2789 int32_t *level_out /* [out] [ref] */,
2790 union drsuapi_DsGetDCInfoCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
2791 WERROR *werror)
2792 {
2793 struct drsuapi_DsGetDomainControllerInfo r;
2794 NTSTATUS status;
2795
2796 /* In parameters */
2797 r.in.bind_handle = bind_handle;
2798 r.in.level = level;
2799 r.in.req = req;
2800
2801 if (DEBUGLEVEL >= 10) {
2802 NDR_PRINT_IN_DEBUG(drsuapi_DsGetDomainControllerInfo, &r);
2803 }
2804
2805 status = cli->dispatch(cli,
2806 mem_ctx,
2807 &ndr_table_drsuapi,
2808 NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO,
2809 &r);
2810
2811 if (!NT_STATUS_IS_OK(status)) {
2812 return status;
2813 }
2814
2815 if (DEBUGLEVEL >= 10) {
2816 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetDomainControllerInfo, &r);
2817 }
2818
2819 if (NT_STATUS_IS_ERR(status)) {
2820 return status;
2821 }
2822
2823 /* Return variables */
2824 *level_out = *r.out.level_out;
2825 *ctr = *r.out.ctr;
2826
2827 /* Return result */
2828 if (werror) {
2829 *werror = r.out.result;
2830 }
2831
2832 return werror_to_ntstatus(r.out.result);
2833 }
2834
2835 struct rpccli_drsuapi_DsAddEntry_state {
2836 struct drsuapi_DsAddEntry orig;
2837 struct drsuapi_DsAddEntry tmp;
2838 TALLOC_CTX *out_mem_ctx;
2839 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2840 };
2841
2842 static void rpccli_drsuapi_DsAddEntry_done(struct tevent_req *subreq);
2843
2844 struct tevent_req *rpccli_drsuapi_DsAddEntry_send(TALLOC_CTX *mem_ctx,
2845 struct tevent_context *ev,
2846 struct rpc_pipe_client *cli,
2847 struct policy_handle *_bind_handle /* [in] [ref] */,
2848 int32_t _level /* [in] */,
2849 union drsuapi_DsAddEntryRequest *_req /* [in] [ref,switch_is(level)] */,
2850 int32_t *_level_out /* [out] [ref] */,
2851 union drsuapi_DsAddEntryCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
2852 {
2853 struct tevent_req *req;
2854 struct rpccli_drsuapi_DsAddEntry_state *state;
2855 struct tevent_req *subreq;
2856
2857 req = tevent_req_create(mem_ctx, &state,
2858 struct rpccli_drsuapi_DsAddEntry_state);
2859 if (req == NULL) {
2860 return NULL;
2861 }
2862 state->out_mem_ctx = NULL;
2863 state->dispatch_recv = cli->dispatch_recv;
2864
2865 /* In parameters */
2866 state->orig.in.bind_handle = _bind_handle;
2867 state->orig.in.level = _level;
2868 state->orig.in.req = _req;
2869
2870 /* Out parameters */
2871 state->orig.out.level_out = _level_out;
2872 state->orig.out.ctr = _ctr;
2873
2874 /* Result */
2875 ZERO_STRUCT(state->orig.out.result);
2876
2877 if (DEBUGLEVEL >= 10) {
2878 NDR_PRINT_IN_DEBUG(drsuapi_DsAddEntry, &state->orig);
2879 }
2880
2881 state->out_mem_ctx = talloc_named_const(state, 0,
2882 "rpccli_drsuapi_DsAddEntry_out_memory");
2883 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2884 return tevent_req_post(req, ev);
2885 }
2886
2887 /* make a temporary copy, that we pass to the dispatch function */
2888 state->tmp = state->orig;
2889
2890 subreq = cli->dispatch_send(state, ev, cli,
2891 &ndr_table_drsuapi,
2892 NDR_DRSUAPI_DSADDENTRY,
2893 &state->tmp);
2894 if (tevent_req_nomem(subreq, req)) {
2895 return tevent_req_post(req, ev);
2896 }
2897 tevent_req_set_callback(subreq, rpccli_drsuapi_DsAddEntry_done, req);
2898 return req;
2899 }
2900
2901 static void rpccli_drsuapi_DsAddEntry_done(struct tevent_req *subreq)
2902 {
2903 struct tevent_req *req = tevent_req_callback_data(
2904 subreq, struct tevent_req);
2905 struct rpccli_drsuapi_DsAddEntry_state *state = tevent_req_data(
2906 req, struct rpccli_drsuapi_DsAddEntry_state);
2907 NTSTATUS status;
2908 TALLOC_CTX *mem_ctx;
2909
2910 if (state->out_mem_ctx) {
2911 mem_ctx = state->out_mem_ctx;
2912 } else {
2913 mem_ctx = state;
2914 }
2915
2916 status = state->dispatch_recv(subreq, mem_ctx);
2917 TALLOC_FREE(subreq);
2918 if (!NT_STATUS_IS_OK(status)) {
2919 tevent_req_nterror(req, status);
2920 return;
2921 }
2922
2923 /* Copy out parameters */
2924 *state->orig.out.level_out = *state->tmp.out.level_out;
2925 *state->orig.out.ctr = *state->tmp.out.ctr;
2926
2927 /* Copy result */
2928 state->orig.out.result = state->tmp.out.result;
2929
2930 /* Reset temporary structure */
2931 ZERO_STRUCT(state->tmp);
2932
2933 if (DEBUGLEVEL >= 10) {
2934 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, &state->orig);
2935 }
2936
2937 tevent_req_done(req);
2938 }
2939
2940 NTSTATUS rpccli_drsuapi_DsAddEntry_recv(struct tevent_req *req,
2941 TALLOC_CTX *mem_ctx,
2942 WERROR *result)
2943 {
2944 struct rpccli_drsuapi_DsAddEntry_state *state = tevent_req_data(
2945 req, struct rpccli_drsuapi_DsAddEntry_state);
2946 NTSTATUS status;
2947
2948 if (tevent_req_is_nterror(req, &status)) {
2949 tevent_req_received(req);
2950 return status;
2951 }
2952
2953 /* Steal possbile out parameters to the callers context */
2954 talloc_steal(mem_ctx, state->out_mem_ctx);
2955
2956 /* Return result */
2957 *result = state->orig.out.result;
2958
2959 tevent_req_received(req);
2960 return NT_STATUS_OK;
2961 }
2962
2963 NTSTATUS rpccli_drsuapi_DsAddEntry(struct rpc_pipe_client *cli,
2964 TALLOC_CTX *mem_ctx,
2965 struct policy_handle *bind_handle /* [in] [ref] */,
2966 int32_t level /* [in] */,
2967 union drsuapi_DsAddEntryRequest *req /* [in] [ref,switch_is(level)] */,
2968 int32_t *level_out /* [out] [ref] */,
2969 union drsuapi_DsAddEntryCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
2970 WERROR *werror)
2971 {
2972 struct drsuapi_DsAddEntry r;
2973 NTSTATUS status;
2974
2975 /* In parameters */
2976 r.in.bind_handle = bind_handle;
2977 r.in.level = level;
2978 r.in.req = req;
2979
2980 if (DEBUGLEVEL >= 10) {
2981 NDR_PRINT_IN_DEBUG(drsuapi_DsAddEntry, &r);
2982 }
2983
2984 status = cli->dispatch(cli,
2985 mem_ctx,
2986 &ndr_table_drsuapi,
2987 NDR_DRSUAPI_DSADDENTRY,
2988 &r);
2989
2990 if (!NT_STATUS_IS_OK(status)) {
2991 return status;
2992 }
2993
2994 if (DEBUGLEVEL >= 10) {
2995 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, &r);
2996 }
2997
2998 if (NT_STATUS_IS_ERR(status)) {
2999 return status;
3000 }
3001
3002 /* Return variables */
3003 *level_out = *r.out.level_out;
3004 *ctr = *r.out.ctr;
3005
3006 /* Return result */
3007 if (werror) {
3008 *werror = r.out.result;
3009 }
3010
3011 return werror_to_ntstatus(r.out.result);
3012 }
3013
3014 struct rpccli_DRSUAPI_EXECUTE_KCC_state {
3015 struct DRSUAPI_EXECUTE_KCC orig;
3016 struct DRSUAPI_EXECUTE_KCC tmp;
3017 TALLOC_CTX *out_mem_ctx;
3018 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3019 };
3020
3021 static void rpccli_DRSUAPI_EXECUTE_KCC_done(struct tevent_req *subreq);
3022
3023 struct tevent_req *rpccli_DRSUAPI_EXECUTE_KCC_send(TALLOC_CTX *mem_ctx,
3024 struct tevent_context *ev,
3025 struct rpc_pipe_client *cli)
3026 {
3027 struct tevent_req *req;
3028 struct rpccli_DRSUAPI_EXECUTE_KCC_state *state;
3029 struct tevent_req *subreq;
3030
3031 req = tevent_req_create(mem_ctx, &state,
3032 struct rpccli_DRSUAPI_EXECUTE_KCC_state);
3033 if (req == NULL) {
3034 return NULL;
3035 }
3036 state->out_mem_ctx = NULL;
3037 state->dispatch_recv = cli->dispatch_recv;
3038
3039 /* In parameters */
3040
3041 /* Out parameters */
3042
3043 /* Result */
3044 ZERO_STRUCT(state->orig.out.result);
3045
3046 if (DEBUGLEVEL >= 10) {
3047 NDR_PRINT_IN_DEBUG(DRSUAPI_EXECUTE_KCC, &state->orig);
3048 }
3049
3050 /* make a temporary copy, that we pass to the dispatch function */
3051 state->tmp = state->orig;
3052
3053 subreq = cli->dispatch_send(state, ev, cli,
3054 &ndr_table_drsuapi,
3055 NDR_DRSUAPI_EXECUTE_KCC,
3056 &state->tmp);
3057 if (tevent_req_nomem(subreq, req)) {
3058 return tevent_req_post(req, ev);
3059 }
3060 tevent_req_set_callback(subreq, rpccli_DRSUAPI_EXECUTE_KCC_done, req);
3061 return req;
3062 }
3063
3064 static void rpccli_DRSUAPI_EXECUTE_KCC_done(struct tevent_req *subreq)
3065 {
3066 struct tevent_req *req = tevent_req_callback_data(
3067 subreq, struct tevent_req);
3068 struct rpccli_DRSUAPI_EXECUTE_KCC_state *state = tevent_req_data(
3069 req, struct rpccli_DRSUAPI_EXECUTE_KCC_state);
3070 NTSTATUS status;
3071 TALLOC_CTX *mem_ctx;
3072
3073 if (state->out_mem_ctx) {
3074 mem_ctx = state->out_mem_ctx;
3075 } else {
3076 mem_ctx = state;
3077 }
3078
3079 status = state->dispatch_recv(subreq, mem_ctx);
3080 TALLOC_FREE(subreq);
3081 if (!NT_STATUS_IS_OK(status)) {
3082 tevent_req_nterror(req, status);
3083 return;
3084 }
3085
3086 /* Copy out parameters */
3087
3088 /* Copy result */
3089 state->orig.out.result = state->tmp.out.result;
3090
3091 /* Reset temporary structure */
3092 ZERO_STRUCT(state->tmp);
3093
3094 if (DEBUGLEVEL >= 10) {
3095 NDR_PRINT_OUT_DEBUG(DRSUAPI_EXECUTE_KCC, &state->orig);
3096 }
3097
3098 tevent_req_done(req);
3099 }
3100
3101 NTSTATUS rpccli_DRSUAPI_EXECUTE_KCC_recv(struct tevent_req *req,
3102 TALLOC_CTX *mem_ctx,
3103 WERROR *result)
3104 {
3105 struct rpccli_DRSUAPI_EXECUTE_KCC_state *state = tevent_req_data(
3106 req, struct rpccli_DRSUAPI_EXECUTE_KCC_state);
3107 NTSTATUS status;
3108
3109 if (tevent_req_is_nterror(req, &status)) {
3110 tevent_req_received(req);
3111 return status;
3112 }
3113
3114 /* Steal possbile out parameters to the callers context */
3115 talloc_steal(mem_ctx, state->out_mem_ctx);
3116
3117 /* Return result */
3118 *result = state->orig.out.result;
3119
3120 tevent_req_received(req);
3121 return NT_STATUS_OK;
3122 }
3123
3124 NTSTATUS rpccli_DRSUAPI_EXECUTE_KCC(struct rpc_pipe_client *cli,
3125 TALLOC_CTX *mem_ctx,
3126 WERROR *werror)
3127 {
3128 struct DRSUAPI_EXECUTE_KCC r;
3129 NTSTATUS status;
3130
3131 /* In parameters */
3132
3133 if (DEBUGLEVEL >= 10) {
3134 NDR_PRINT_IN_DEBUG(DRSUAPI_EXECUTE_KCC, &r);
3135 }
3136
3137 status = cli->dispatch(cli,
3138 mem_ctx,
3139 &ndr_table_drsuapi,
3140 NDR_DRSUAPI_EXECUTE_KCC,
3141 &r);
3142
3143 if (!NT_STATUS_IS_OK(status)) {
3144 return status;
3145 }
3146
3147 if (DEBUGLEVEL >= 10) {
3148 NDR_PRINT_OUT_DEBUG(DRSUAPI_EXECUTE_KCC, &r);
3149 }
3150
3151 if (NT_STATUS_IS_ERR(status)) {
3152 return status;
3153 }
3154
3155 /* Return variables */
3156
3157 /* Return result */
3158 if (werror) {
3159 *werror = r.out.result;
3160 }
3161
3162 return werror_to_ntstatus(r.out.result);
3163 }
3164
3165 struct rpccli_drsuapi_DsReplicaGetInfo_state {
3166 struct drsuapi_DsReplicaGetInfo orig;
3167 struct drsuapi_DsReplicaGetInfo tmp;
3168 TALLOC_CTX *out_mem_ctx;
3169 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3170 };
3171
3172 static void rpccli_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq);
3173
3174 struct tevent_req *rpccli_drsuapi_DsReplicaGetInfo_send(TALLOC_CTX *mem_ctx,
3175 struct tevent_context *ev,
3176 struct rpc_pipe_client *cli,
3177 struct policy_handle *_bind_handle /* [in] [ref] */,
3178 enum drsuapi_DsReplicaGetInfoLevel _level /* [in] */,
3179 union drsuapi_DsReplicaGetInfoRequest *_req /* [in] [ref,switch_is(level)] */,
3180 enum drsuapi_DsReplicaInfoType *_info_type /* [out] [ref] */,
3181 union drsuapi_DsReplicaInfo *_info /* [out] [ref,switch_is(*info_type)] */)
3182 {
3183 struct tevent_req *req;
3184 struct rpccli_drsuapi_DsReplicaGetInfo_state *state;
3185 struct tevent_req *subreq;
3186
3187 req = tevent_req_create(mem_ctx, &state,
3188 struct rpccli_drsuapi_DsReplicaGetInfo_state);
3189 if (req == NULL) {
3190 return NULL;
3191 }
3192 state->out_mem_ctx = NULL;
3193 state->dispatch_recv = cli->dispatch_recv;
3194
3195 /* In parameters */
3196 state->orig.in.bind_handle = _bind_handle;
3197 state->orig.in.level = _level;
3198 state->orig.in.req = _req;
3199
3200 /* Out parameters */
3201 state->orig.out.info_type = _info_type;
3202 state->orig.out.info = _info;
3203
3204 /* Result */
3205 ZERO_STRUCT(state->orig.out.result);
3206
3207 if (DEBUGLEVEL >= 10) {
3208 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, &state->orig);
3209 }
3210
3211 state->out_mem_ctx = talloc_named_const(state, 0,
3212 "rpccli_drsuapi_DsReplicaGetInfo_out_memory");
3213 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3214 return tevent_req_post(req, ev);
3215 }
3216
3217 /* make a temporary copy, that we pass to the dispatch function */
3218 state->tmp = state->orig;
3219
3220 subreq = cli->dispatch_send(state, ev, cli,
3221 &ndr_table_drsuapi,
3222 NDR_DRSUAPI_DSREPLICAGETINFO,
3223 &state->tmp);
3224 if (tevent_req_nomem(subreq, req)) {
3225 return tevent_req_post(req, ev);
3226 }
3227 tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaGetInfo_done, req);
3228 return req;
3229 }
3230
3231 static void rpccli_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq)
3232 {
3233 struct tevent_req *req = tevent_req_callback_data(
3234 subreq, struct tevent_req);
3235 struct rpccli_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
3236 req, struct rpccli_drsuapi_DsReplicaGetInfo_state);
3237 NTSTATUS status;
3238 TALLOC_CTX *mem_ctx;
3239
3240 if (state->out_mem_ctx) {
3241 mem_ctx = state->out_mem_ctx;
3242 } else {
3243 mem_ctx = state;
3244 }
3245
3246 status = state->dispatch_recv(subreq, mem_ctx);
3247 TALLOC_FREE(subreq);
3248 if (!NT_STATUS_IS_OK(status)) {
3249 tevent_req_nterror(req, status);
3250 return;
3251 }
3252
3253 /* Copy out parameters */
3254 *state->orig.out.info_type = *state->tmp.out.info_type;
3255 *state->orig.out.info = *state->tmp.out.info;
3256
3257 /* Copy result */
3258 state->orig.out.result = state->tmp.out.result;
3259
3260 /* Reset temporary structure */
3261 ZERO_STRUCT(state->tmp);
3262
3263 if (DEBUGLEVEL >= 10) {
3264 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, &state->orig);
3265 }
3266
3267 tevent_req_done(req);
3268 }
3269
3270 NTSTATUS rpccli_drsuapi_DsReplicaGetInfo_recv(struct tevent_req *req,
3271 TALLOC_CTX *mem_ctx,
3272 WERROR *result)
3273 {
3274 struct rpccli_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
3275 req, struct rpccli_drsuapi_DsReplicaGetInfo_state);
3276 NTSTATUS status;
3277
3278 if (tevent_req_is_nterror(req, &status)) {
3279 tevent_req_received(req);
3280 return status;
3281 }
3282
3283 /* Steal possbile out parameters to the callers context */
3284 talloc_steal(mem_ctx, state->out_mem_ctx);
3285
3286 /* Return result */
3287 *result = state->orig.out.result;
3288
3289 tevent_req_received(req);
3290 return NT_STATUS_OK;
3291 }
3292
3293 NTSTATUS rpccli_drsuapi_DsReplicaGetInfo(struct rpc_pipe_client *cli,
3294 TALLOC_CTX *mem_ctx,
3295 struct policy_handle *bind_handle /* [in] [ref] */,
3296 enum drsuapi_DsReplicaGetInfoLevel level /* [in] */,
3297 union drsuapi_DsReplicaGetInfoRequest *req /* [in] [ref,switch_is(level)] */,
3298 enum drsuapi_DsReplicaInfoType *info_type /* [out] [ref] */,
3299 union drsuapi_DsReplicaInfo *info /* [out] [ref,switch_is(*info_type)] */,
3300 WERROR *werror)
3301 {
3302 struct drsuapi_DsReplicaGetInfo r;
3303 NTSTATUS status;
3304
3305 /* In parameters */
3306 r.in.bind_handle = bind_handle;
3307 r.in.level = level;
3308 r.in.req = req;
3309
3310 if (DEBUGLEVEL >= 10) {
3311 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, &r);
3312 }
3313
3314 status = cli->dispatch(cli,
3315 mem_ctx,
3316 &ndr_table_drsuapi,
3317 NDR_DRSUAPI_DSREPLICAGETINFO,
3318 &r);
3319
3320 if (!NT_STATUS_IS_OK(status)) {
3321 return status;
3322 }
3323
3324 if (DEBUGLEVEL >= 10) {
3325 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, &r);
3326 }
3327
3328 if (NT_STATUS_IS_ERR(status)) {
3329 return status;
3330 }
3331
3332 /* Return variables */
3333 *info_type = *r.out.info_type;
3334 *info = *r.out.info;
3335
3336 /* Return result */
3337 if (werror) {
3338 *werror = r.out.result;
3339 }
3340
3341 return werror_to_ntstatus(r.out.result);
3342 }
3343
3344 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state {
3345 struct DRSUAPI_ADD_SID_HISTORY orig;
3346 struct DRSUAPI_ADD_SID_HISTORY tmp;
3347 TALLOC_CTX *out_mem_ctx;
3348 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3349 };
3350
3351 static void rpccli_DRSUAPI_ADD_SID_HISTORY_done(struct tevent_req *subreq);
3352
3353 struct tevent_req *rpccli_DRSUAPI_ADD_SID_HISTORY_send(TALLOC_CTX *mem_ctx,
3354 struct tevent_context *ev,
3355 struct rpc_pipe_client *cli)
3356 {
3357 struct tevent_req *req;
3358 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state;
3359 struct tevent_req *subreq;
3360
3361 req = tevent_req_create(mem_ctx, &state,
3362 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3363 if (req == NULL) {
3364 return NULL;
3365 }
3366 state->out_mem_ctx = NULL;
3367 state->dispatch_recv = cli->dispatch_recv;
3368
3369 /* In parameters */
3370
3371 /* Out parameters */
3372
3373 /* Result */
3374 ZERO_STRUCT(state->orig.out.result);
3375
3376 if (DEBUGLEVEL >= 10) {
3377 NDR_PRINT_IN_DEBUG(DRSUAPI_ADD_SID_HISTORY, &state->orig);
3378 }
3379
3380 /* make a temporary copy, that we pass to the dispatch function */
3381 state->tmp = state->orig;
3382
3383 subreq = cli->dispatch_send(state, ev, cli,
3384 &ndr_table_drsuapi,
3385 NDR_DRSUAPI_ADD_SID_HISTORY,
3386 &state->tmp);
3387 if (tevent_req_nomem(subreq, req)) {
3388 return tevent_req_post(req, ev);
3389 }
3390 tevent_req_set_callback(subreq, rpccli_DRSUAPI_ADD_SID_HISTORY_done, req);
3391 return req;
3392 }
3393
3394 static void rpccli_DRSUAPI_ADD_SID_HISTORY_done(struct tevent_req *subreq)
3395 {
3396 struct tevent_req *req = tevent_req_callback_data(
3397 subreq, struct tevent_req);
3398 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state = tevent_req_data(
3399 req, struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3400 NTSTATUS status;
3401 TALLOC_CTX *mem_ctx;
3402
3403 if (state->out_mem_ctx) {
3404 mem_ctx = state->out_mem_ctx;
3405 } else {
3406 mem_ctx = state;
3407 }
3408
3409 status = state->dispatch_recv(subreq, mem_ctx);
3410 TALLOC_FREE(subreq);
3411 if (!NT_STATUS_IS_OK(status)) {
3412 tevent_req_nterror(req, status);
3413 return;
3414 }
3415
3416 /* Copy out parameters */
3417
3418 /* Copy result */
3419 state->orig.out.result = state->tmp.out.result;
3420
3421 /* Reset temporary structure */
3422 ZERO_STRUCT(state->tmp);
3423
3424 if (DEBUGLEVEL >= 10) {
3425 NDR_PRINT_OUT_DEBUG(DRSUAPI_ADD_SID_HISTORY, &state->orig);
3426 }
3427
3428 tevent_req_done(req);
3429 }
3430
3431 NTSTATUS rpccli_DRSUAPI_ADD_SID_HISTORY_recv(struct tevent_req *req,
3432 TALLOC_CTX *mem_ctx,
3433 WERROR *result)
3434 {
3435 struct rpccli_DRSUAPI_ADD_SID_HISTORY_state *state = tevent_req_data(
3436 req, struct rpccli_DRSUAPI_ADD_SID_HISTORY_state);
3437 NTSTATUS status;
3438
3439 if (tevent_req_is_nterror(req, &status)) {
3440 tevent_req_received(req);
3441 return status;
3442 }
3443
3444 /* Steal possbile out parameters to the callers context */
3445 talloc_steal(mem_ctx, state->out_mem_ctx);
3446
3447 /* Return result */
3448 *result = state->orig.out.result;
3449
3450 tevent_req_received(req);
3451 return NT_STATUS_OK;
3452 }
3453
3454 NTSTATUS rpccli_DRSUAPI_ADD_SID_HISTORY(struct rpc_pipe_client *cli,
3455 TALLOC_CTX *mem_ctx,
3456 WERROR *werror)
3457 {
3458 struct DRSUAPI_ADD_SID_HISTORY r;
3459 NTSTATUS status;
3460
3461 /* In parameters */
3462
3463 if (DEBUGLEVEL >= 10) {
3464 NDR_PRINT_IN_DEBUG(DRSUAPI_ADD_SID_HISTORY, &r);
3465 }
3466
3467 status = cli->dispatch(cli,
3468 mem_ctx,
3469 &ndr_table_drsuapi,
3470 NDR_DRSUAPI_ADD_SID_HISTORY,
3471 &r);
3472
3473 if (!NT_STATUS_IS_OK(status)) {
3474 return status;
3475 }
3476
3477 if (DEBUGLEVEL >= 10) {
3478 NDR_PRINT_OUT_DEBUG(DRSUAPI_ADD_SID_HISTORY, &r);
3479 }
3480
3481 if (NT_STATUS_IS_ERR(status)) {
3482 return status;
3483 }
3484
3485 /* Return variables */
3486
3487 /* Return result */
3488 if (werror) {
3489 *werror = r.out.result;
3490 }
3491
3492 return werror_to_ntstatus(r.out.result);
3493 }
3494
3495 struct rpccli_drsuapi_DsGetMemberships2_state {
3496 struct drsuapi_DsGetMemberships2 orig;
3497 struct drsuapi_DsGetMemberships2 tmp;
3498 TALLOC_CTX *out_mem_ctx;
3499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3500 };
3501
3502 static void rpccli_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq);
3503
3504 struct tevent_req *rpccli_drsuapi_DsGetMemberships2_send(TALLOC_CTX *mem_ctx,
3505 struct tevent_context *ev,
3506 struct rpc_pipe_client *cli,
3507 struct policy_handle *_bind_handle /* [in] [ref] */,
3508 int32_t _level /* [in] */,
3509 union drsuapi_DsGetMemberships2Request *_req /* [in] [ref,switch_is(level)] */,
3510 int32_t *_level_out /* [out] [ref] */,
3511 union drsuapi_DsGetMemberships2Ctr *_ctr /* [out] [ref,switch_is(*level_out)] */)
3512 {
3513 struct tevent_req *req;
3514 struct rpccli_drsuapi_DsGetMemberships2_state *state;
3515 struct tevent_req *subreq;
3516
3517 req = tevent_req_create(mem_ctx, &state,
3518 struct rpccli_drsuapi_DsGetMemberships2_state);
3519 if (req == NULL) {
3520 return NULL;
3521 }
3522 state->out_mem_ctx = NULL;
3523 state->dispatch_recv = cli->dispatch_recv;
3524
3525 /* In parameters */
3526 state->orig.in.bind_handle = _bind_handle;
3527 state->orig.in.level = _level;
3528 state->orig.in.req = _req;
3529
3530 /* Out parameters */
3531 state->orig.out.level_out = _level_out;
3532 state->orig.out.ctr = _ctr;
3533
3534 /* Result */
3535 ZERO_STRUCT(state->orig.out.result);
3536
3537 if (DEBUGLEVEL >= 10) {
3538 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships2, &state->orig);
3539 }
3540
3541 state->out_mem_ctx = talloc_named_const(state, 0,
3542 "rpccli_drsuapi_DsGetMemberships2_out_memory");
3543 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3544 return tevent_req_post(req, ev);
3545 }
3546
3547 /* make a temporary copy, that we pass to the dispatch function */
3548 state->tmp = state->orig;
3549
3550 subreq = cli->dispatch_send(state, ev, cli,
3551 &ndr_table_drsuapi,
3552 NDR_DRSUAPI_DSGETMEMBERSHIPS2,
3553 &state->tmp);
3554 if (tevent_req_nomem(subreq, req)) {
3555 return tevent_req_post(req, ev);
3556 }
3557 tevent_req_set_callback(subreq, rpccli_drsuapi_DsGetMemberships2_done, req);
3558 return req;
3559 }
3560
3561 static void rpccli_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq)
3562 {
3563 struct tevent_req *req = tevent_req_callback_data(
3564 subreq, struct tevent_req);
3565 struct rpccli_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
3566 req, struct rpccli_drsuapi_DsGetMemberships2_state);
3567 NTSTATUS status;
3568 TALLOC_CTX *mem_ctx;
3569
3570 if (state->out_mem_ctx) {
3571 mem_ctx = state->out_mem_ctx;
3572 } else {
3573 mem_ctx = state;
3574 }
3575
3576 status = state->dispatch_recv(subreq, mem_ctx);
3577 TALLOC_FREE(subreq);
3578 if (!NT_STATUS_IS_OK(status)) {
3579 tevent_req_nterror(req, status);
3580 return;
3581 }
3582
3583 /* Copy out parameters */
3584 *state->orig.out.level_out = *state->tmp.out.level_out;
3585 *state->orig.out.ctr = *state->tmp.out.ctr;
3586
3587 /* Copy result */
3588 state->orig.out.result = state->tmp.out.result;
3589
3590 /* Reset temporary structure */
3591 ZERO_STRUCT(state->tmp);
3592
3593 if (DEBUGLEVEL >= 10) {
3594 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships2, &state->orig);
3595 }
3596
3597 tevent_req_done(req);
3598 }
3599
3600 NTSTATUS rpccli_drsuapi_DsGetMemberships2_recv(struct tevent_req *req,
3601 TALLOC_CTX *mem_ctx,
3602 WERROR *result)
3603 {
3604 struct rpccli_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
3605 req, struct rpccli_drsuapi_DsGetMemberships2_state);
3606 NTSTATUS status;
3607
3608 if (tevent_req_is_nterror(req, &status)) {
3609 tevent_req_received(req);
3610 return status;
3611 }
3612
3613 /* Steal possbile out parameters to the callers context */
3614 talloc_steal(mem_ctx, state->out_mem_ctx);
3615
3616 /* Return result */
3617 *result = state->orig.out.result;
3618
3619 tevent_req_received(req);
3620 return NT_STATUS_OK;
3621 }
3622
3623 NTSTATUS rpccli_drsuapi_DsGetMemberships2(struct rpc_pipe_client *cli,
3624 TALLOC_CTX *mem_ctx,
3625 struct policy_handle *bind_handle /* [in] [ref] */,
3626 int32_t level /* [in] */,
3627 union drsuapi_DsGetMemberships2Request *req /* [in] [ref,switch_is(level)] */,
3628 int32_t *level_out /* [out] [ref] */,
3629 union drsuapi_DsGetMemberships2Ctr *ctr /* [out] [ref,switch_is(*level_out)] */,
3630 WERROR *werror)
3631 {
3632 struct drsuapi_DsGetMemberships2 r;
3633 NTSTATUS status;
3634
3635 /* In parameters */
3636 r.in.bind_handle = bind_handle;
3637 r.in.level = level;
3638 r.in.req = req;
3639
3640 if (DEBUGLEVEL >= 10) {
3641 NDR_PRINT_IN_DEBUG(drsuapi_DsGetMemberships2, &r);
3642 }
3643
3644 status = cli->dispatch(cli,
3645 mem_ctx,
3646 &ndr_table_drsuapi,
3647 NDR_DRSUAPI_DSGETMEMBERSHIPS2,
3648 &r);
3649
3650 if (!NT_STATUS_IS_OK(status)) {
3651 return status;
3652 }
3653
3654 if (DEBUGLEVEL >= 10) {
3655 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetMemberships2, &r);
3656 }
3657
3658 if (NT_STATUS_IS_ERR(status)) {
3659 return status;
3660 }
3661
3662 /* Return variables */
3663 *level_out = *r.out.level_out;
3664 *ctr = *r.out.ctr;
3665
3666 /* Return result */
3667 if (werror) {
3668 *werror = r.out.result;
3669 }
3670
3671 return werror_to_ntstatus(r.out.result);
3672 }
3673
3674 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state {
3675 struct DRSUAPI_REPLICA_VERIFY_OBJECTS orig;
3676 struct DRSUAPI_REPLICA_VERIFY_OBJECTS tmp;
3677 TALLOC_CTX *out_mem_ctx;
3678 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3679 };
3680
3681 static void rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done(struct tevent_req *subreq);
3682
3683 struct tevent_req *rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_send(TALLOC_CTX *mem_ctx,
3684 struct tevent_context *ev,
3685 struct rpc_pipe_client *cli)
3686 {
3687 struct tevent_req *req;
3688 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state;
3689 struct tevent_req *subreq;
3690
3691 req = tevent_req_create(mem_ctx, &state,
3692 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3693 if (req == NULL) {
3694 return NULL;
3695 }
3696 state->out_mem_ctx = NULL;
3697 state->dispatch_recv = cli->dispatch_recv;
3698
3699 /* In parameters */
3700
3701 /* Out parameters */
3702
3703 /* Result */
3704 ZERO_STRUCT(state->orig.out.result);
3705
3706 if (DEBUGLEVEL >= 10) {
3707 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &state->orig);
3708 }
3709
3710 /* make a temporary copy, that we pass to the dispatch function */
3711 state->tmp = state->orig;
3712
3713 subreq = cli->dispatch_send(state, ev, cli,
3714 &ndr_table_drsuapi,
3715 NDR_DRSUAPI_REPLICA_VERIFY_OBJECTS,
3716 &state->tmp);
3717 if (tevent_req_nomem(subreq, req)) {
3718 return tevent_req_post(req, ev);
3719 }
3720 tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done, req);
3721 return req;
3722 }
3723
3724 static void rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_done(struct tevent_req *subreq)
3725 {
3726 struct tevent_req *req = tevent_req_callback_data(
3727 subreq, struct tevent_req);
3728 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state = tevent_req_data(
3729 req, struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3730 NTSTATUS status;
3731 TALLOC_CTX *mem_ctx;
3732
3733 if (state->out_mem_ctx) {
3734 mem_ctx = state->out_mem_ctx;
3735 } else {
3736 mem_ctx = state;
3737 }
3738
3739 status = state->dispatch_recv(subreq, mem_ctx);
3740 TALLOC_FREE(subreq);
3741 if (!NT_STATUS_IS_OK(status)) {
3742 tevent_req_nterror(req, status);
3743 return;
3744 }
3745
3746 /* Copy out parameters */
3747
3748 /* Copy result */
3749 state->orig.out.result = state->tmp.out.result;
3750
3751 /* Reset temporary structure */
3752 ZERO_STRUCT(state->tmp);
3753
3754 if (DEBUGLEVEL >= 10) {
3755 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &state->orig);
3756 }
3757
3758 tevent_req_done(req);
3759 }
3760
3761 NTSTATUS rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_recv(struct tevent_req *req,
3762 TALLOC_CTX *mem_ctx,
3763 WERROR *result)
3764 {
3765 struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state *state = tevent_req_data(
3766 req, struct rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS_state);
3767 NTSTATUS status;
3768
3769 if (tevent_req_is_nterror(req, &status)) {
3770 tevent_req_received(req);
3771 return status;
3772 }
3773
3774 /* Steal possbile out parameters to the callers context */
3775 talloc_steal(mem_ctx, state->out_mem_ctx);
3776
3777 /* Return result */
3778 *result = state->orig.out.result;
3779
3780 tevent_req_received(req);
3781 return NT_STATUS_OK;
3782 }
3783
3784 NTSTATUS rpccli_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct rpc_pipe_client *cli,
3785 TALLOC_CTX *mem_ctx,
3786 WERROR *werror)
3787 {
3788 struct DRSUAPI_REPLICA_VERIFY_OBJECTS r;
3789 NTSTATUS status;
3790
3791 /* In parameters */
3792
3793 if (DEBUGLEVEL >= 10) {
3794 NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &r);
3795 }
3796
3797 status = cli->dispatch(cli,
3798 mem_ctx,
3799 &ndr_table_drsuapi,
3800 NDR_DRSUAPI_REPLICA_VERIFY_OBJECTS,
3801 &r);
3802
3803 if (!NT_STATUS_IS_OK(status)) {
3804 return status;
3805 }
3806
3807 if (DEBUGLEVEL >= 10) {
3808 NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_VERIFY_OBJECTS, &r);
3809 }
3810
3811 if (NT_STATUS_IS_ERR(status)) {
3812 return status;
3813 }
3814
3815 /* Return variables */
3816
3817 /* Return result */
3818 if (werror) {
3819 *werror = r.out.result;
3820 }
3821
3822 return werror_to_ntstatus(r.out.result);
3823 }
3824
3825 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state {
3826 struct DRSUAPI_GET_OBJECT_EXISTENCE orig;
3827 struct DRSUAPI_GET_OBJECT_EXISTENCE tmp;
3828 TALLOC_CTX *out_mem_ctx;
3829 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3830 };
3831
3832 static void rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done(struct tevent_req *subreq);
3833
3834 struct tevent_req *rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_send(TALLOC_CTX *mem_ctx,
3835 struct tevent_context *ev,
3836 struct rpc_pipe_client *cli)
3837 {
3838 struct tevent_req *req;
3839 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state;
3840 struct tevent_req *subreq;
3841
3842 req = tevent_req_create(mem_ctx, &state,
3843 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3844 if (req == NULL) {
3845 return NULL;
3846 }
3847 state->out_mem_ctx = NULL;
3848 state->dispatch_recv = cli->dispatch_recv;
3849
3850 /* In parameters */
3851
3852 /* Out parameters */
3853
3854 /* Result */
3855 ZERO_STRUCT(state->orig.out.result);
3856
3857 if (DEBUGLEVEL >= 10) {
3858 NDR_PRINT_IN_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &state->orig);
3859 }
3860
3861 /* make a temporary copy, that we pass to the dispatch function */
3862 state->tmp = state->orig;
3863
3864 subreq = cli->dispatch_send(state, ev, cli,
3865 &ndr_table_drsuapi,
3866 NDR_DRSUAPI_GET_OBJECT_EXISTENCE,
3867 &state->tmp);
3868 if (tevent_req_nomem(subreq, req)) {
3869 return tevent_req_post(req, ev);
3870 }
3871 tevent_req_set_callback(subreq, rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done, req);
3872 return req;
3873 }
3874
3875 static void rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_done(struct tevent_req *subreq)
3876 {
3877 struct tevent_req *req = tevent_req_callback_data(
3878 subreq, struct tevent_req);
3879 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state = tevent_req_data(
3880 req, struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3881 NTSTATUS status;
3882 TALLOC_CTX *mem_ctx;
3883
3884 if (state->out_mem_ctx) {
3885 mem_ctx = state->out_mem_ctx;
3886 } else {
3887 mem_ctx = state;
3888 }
3889
3890 status = state->dispatch_recv(subreq, mem_ctx);
3891 TALLOC_FREE(subreq);
3892 if (!NT_STATUS_IS_OK(status)) {
3893 tevent_req_nterror(req, status);
3894 return;
3895 }
3896
3897 /* Copy out parameters */
3898
3899 /* Copy result */
3900 state->orig.out.result = state->tmp.out.result;
3901
3902 /* Reset temporary structure */
3903 ZERO_STRUCT(state->tmp);
3904
3905 if (DEBUGLEVEL >= 10) {
3906 NDR_PRINT_OUT_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &state->orig);
3907 }
3908
3909 tevent_req_done(req);
3910 }
3911
3912 NTSTATUS rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_recv(struct tevent_req *req,
3913 TALLOC_CTX *mem_ctx,
3914 WERROR *result)
3915 {
3916 struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state *state = tevent_req_data(
3917 req, struct rpccli_DRSUAPI_GET_OBJECT_EXISTENCE_state);
3918 NTSTATUS status;
3919
3920 if (tevent_req_is_nterror(req, &status)) {
3921 tevent_req_received(req);
3922 return status;
3923 }
3924
3925 /* Steal possbile out parameters to the callers context */
3926 talloc_steal(mem_ctx, state->out_mem_ctx);
3927
3928 /* Return result */
3929 *result = state->orig.out.result;
3930
3931 tevent_req_received(req);
3932 return NT_STATUS_OK;
3933 }
3934
3935 NTSTATUS rpccli_DRSUAPI_GET_OBJECT_EXISTENCE(struct rpc_pipe_client *cli,
3936 TALLOC_CTX *mem_ctx,
3937 WERROR *werror)
3938 {
3939 struct DRSUAPI_GET_OBJECT_EXISTENCE r;
3940 NTSTATUS status;
3941
3942 /* In parameters */
3943
3944 if (DEBUGLEVEL >= 10) {
3945 NDR_PRINT_IN_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &r);
3946 }
3947
3948 status = cli->dispatch(cli,
3949 mem_ctx,
3950 &ndr_table_drsuapi,
3951 NDR_DRSUAPI_GET_OBJECT_EXISTENCE,
3952 &r);
3953
3954 if (!NT_STATUS_IS_OK(status)) {
3955 return status;
3956 }
3957
3958 if (DEBUGLEVEL >= 10) {
3959 NDR_PRINT_OUT_DEBUG(DRSUAPI_GET_OBJECT_EXISTENCE, &r);
3960 }
3961
3962 if (NT_STATUS_IS_ERR(status)) {
3963 return status;
3964 }
3965
3966 /* Return variables */
3967
3968 /* Return result */
3969 if (werror) {
3970 *werror = r.out.result;
3971 }
3972
3973 return werror_to_ntstatus(r.out.result);
3974 }
3975
3976 struct rpccli_drsuapi_QuerySitesByCost_state {
3977 struct drsuapi_QuerySitesByCost orig;
3978 struct drsuapi_QuerySitesByCost tmp;
3979 TALLOC_CTX *out_mem_ctx;
3980 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3981 };
3982
3983 static void rpccli_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq);
3984
3985 struct tevent_req *rpccli_drsuapi_QuerySitesByCost_send(TALLOC_CTX *mem_ctx,
3986 struct tevent_context *ev,
3987 struct rpc_pipe_client *cli,
3988 struct policy_handle *_bind_handle /* [in] [ref] */,
3989 int32_t _level /* [in] */,
3990 union drsuapi_QuerySitesByCostRequest *_req /* [in] [ref,switch_is(level)] */,
3991 int32_t *_level_out /* [out] [ref] */,
3992 union drsuapi_QuerySitesByCostCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
3993 {
3994 struct tevent_req *req;
3995 struct rpccli_drsuapi_QuerySitesByCost_state *state;
3996 struct tevent_req *subreq;
3997
3998 req = tevent_req_create(mem_ctx, &state,
3999 struct rpccli_drsuapi_QuerySitesByCost_state);
4000 if (req == NULL) {
4001 return NULL;
4002 }
4003 state->out_mem_ctx = NULL;
4004 state->dispatch_recv = cli->dispatch_recv;
4005
4006 /* In parameters */
4007 state->orig.in.bind_handle = _bind_handle;
4008 state->orig.in.level = _level;
4009 state->orig.in.req = _req;
4010
4011 /* Out parameters */
4012 state->orig.out.level_out = _level_out;
4013 state->orig.out.ctr = _ctr;
4014
4015 /* Result */
4016 ZERO_STRUCT(state->orig.out.result);
4017
4018 if (DEBUGLEVEL >= 10) {
4019 NDR_PRINT_IN_DEBUG(drsuapi_QuerySitesByCost, &state->orig);
4020 }
4021
4022 state->out_mem_ctx = talloc_named_const(state, 0,
4023 "rpccli_drsuapi_QuerySitesByCost_out_memory");
4024 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4025 return tevent_req_post(req, ev);
4026 }
4027
4028 /* make a temporary copy, that we pass to the dispatch function */
4029 state->tmp = state->orig;
4030
4031 subreq = cli->dispatch_send(state, ev, cli,
4032 &ndr_table_drsuapi,
4033 NDR_DRSUAPI_QUERYSITESBYCOST,
4034 &state->tmp);
4035 if (tevent_req_nomem(subreq, req)) {
4036 return tevent_req_post(req, ev);
4037 }
4038 tevent_req_set_callback(subreq, rpccli_drsuapi_QuerySitesByCost_done, req);
4039 return req;
4040 }
4041
4042 static void rpccli_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq)
4043 {
4044 struct tevent_req *req = tevent_req_callback_data(
4045 subreq, struct tevent_req);
4046 struct rpccli_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
4047 req, struct rpccli_drsuapi_QuerySitesByCost_state);
4048 NTSTATUS status;
4049 TALLOC_CTX *mem_ctx;
4050
4051 if (state->out_mem_ctx) {
4052 mem_ctx = state->out_mem_ctx;
4053 } else {
4054 mem_ctx = state;
4055 }
4056
4057 status = state->dispatch_recv(subreq, mem_ctx);
4058 TALLOC_FREE(subreq);
4059 if (!NT_STATUS_IS_OK(status)) {
4060 tevent_req_nterror(req, status);
4061 return;
4062 }
4063
4064 /* Copy out parameters */
4065 *state->orig.out.level_out = *state->tmp.out.level_out;
4066 *state->orig.out.ctr = *state->tmp.out.ctr;
4067
4068 /* Copy result */
4069 state->orig.out.result = state->tmp.out.result;
4070
4071 /* Reset temporary structure */
4072 ZERO_STRUCT(state->tmp);
4073
4074 if (DEBUGLEVEL >= 10) {
4075 NDR_PRINT_OUT_DEBUG(drsuapi_QuerySitesByCost, &state->orig);
4076 }
4077
4078 tevent_req_done(req);
4079 }
4080
4081 NTSTATUS rpccli_drsuapi_QuerySitesByCost_recv(struct tevent_req *req,
4082 TALLOC_CTX *mem_ctx,
4083 WERROR *result)
4084 {
4085 struct rpccli_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
4086 req, struct rpccli_drsuapi_QuerySitesByCost_state);
4087 NTSTATUS status;
4088
4089 if (tevent_req_is_nterror(req, &status)) {
4090 tevent_req_received(req);
4091 return status;
4092 }
4093
4094 /* Steal possbile out parameters to the callers context */
4095 talloc_steal(mem_ctx, state->out_mem_ctx);
4096
4097 /* Return result */
4098 *result = state->orig.out.result;
4099
4100 tevent_req_received(req);
4101 return NT_STATUS_OK;
4102 }
4103
4104 NTSTATUS rpccli_drsuapi_QuerySitesByCost(struct rpc_pipe_client *cli,
4105 TALLOC_CTX *mem_ctx,
4106 struct policy_handle *bind_handle /* [in] [ref] */,
4107 int32_t level /* [in] */,
4108 union drsuapi_QuerySitesByCostRequest *req /* [in] [ref,switch_is(level)] */,
4109 int32_t *level_out /* [out] [ref] */,
4110 union drsuapi_QuerySitesByCostCtr *ctr /* [out] [ref,switch_is(*level_out)] */,
4111 WERROR *werror)
4112 {
4113 struct drsuapi_QuerySitesByCost r;
4114 NTSTATUS status;
4115
4116 /* In parameters */
4117 r.in.bind_handle = bind_handle;
4118 r.in.level = level;
4119 r.in.req = req;
4120
4121 if (DEBUGLEVEL >= 10) {
4122 NDR_PRINT_IN_DEBUG(drsuapi_QuerySitesByCost, &r);
4123 }
4124
4125 status = cli->dispatch(cli,
4126 mem_ctx,
4127 &ndr_table_drsuapi,
4128 NDR_DRSUAPI_QUERYSITESBYCOST,
4129 &r);
4130
4131 if (!NT_STATUS_IS_OK(status)) {
4132 return status;
4133 }
4134
4135 if (DEBUGLEVEL >= 10) {
4136 NDR_PRINT_OUT_DEBUG(drsuapi_QuerySitesByCost, &r);
4137 }
4138
4139 if (NT_STATUS_IS_ERR(status)) {
4140 return status;
4141 }
4142
4143 /* Return variables */
4144 *level_out = *r.out.level_out;
4145 *ctr = *r.out.ctr;
4146
4147 /* Return result */
4148 if (werror) {
4149 *werror = r.out.result;
4150 }
4151
4152 return werror_to_ntstatus(r.out.result);
4153 }
4154
Samba GIT mirror