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

Last change on this file was 590, checked in by Herwig Bauernfeind, 14 years ago

Samba 3.5: Update trunk to 3.5.6
File size: 29.5 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "../librpc/gen_ndr/cli_epmapper.h"
8
9struct rpccli_epm_Insert_state {
10 struct epm_Insert orig;
11 struct epm_Insert tmp;
12 TALLOC_CTX *out_mem_ctx;
13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
14};
15
16static void rpccli_epm_Insert_done(struct tevent_req *subreq);
17
18struct tevent_req *rpccli_epm_Insert_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 uint32_t _num_ents /* [in] */,
22 struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */,
23 uint32_t _replace /* [in] */)
24{
25 struct tevent_req *req;
26 struct rpccli_epm_Insert_state *state;
27 struct tevent_req *subreq;
28
29 req = tevent_req_create(mem_ctx, &state,
30 struct rpccli_epm_Insert_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.num_ents = _num_ents;
39 state->orig.in.entries = _entries;
40 state->orig.in.replace = _replace;
41
42 /* Out parameters */
43
44 /* Result */
45 ZERO_STRUCT(state->orig.out.result);
46
47 /* make a temporary copy, that we pass to the dispatch function */
48 state->tmp = state->orig;
49
50 subreq = cli->dispatch_send(state, ev, cli,
51 &ndr_table_epmapper,
52 NDR_EPM_INSERT,
53 &state->tmp);
54 if (tevent_req_nomem(subreq, req)) {
55 return tevent_req_post(req, ev);
56 }
57 tevent_req_set_callback(subreq, rpccli_epm_Insert_done, req);
58 return req;
59}
60
61static void rpccli_epm_Insert_done(struct tevent_req *subreq)
62{
63 struct tevent_req *req = tevent_req_callback_data(
64 subreq, struct tevent_req);
65 struct rpccli_epm_Insert_state *state = tevent_req_data(
66 req, struct rpccli_epm_Insert_state);
67 NTSTATUS status;
68 TALLOC_CTX *mem_ctx;
69
70 if (state->out_mem_ctx) {
71 mem_ctx = state->out_mem_ctx;
72 } else {
73 mem_ctx = state;
74 }
75
76 status = state->dispatch_recv(subreq, mem_ctx);
77 TALLOC_FREE(subreq);
78 if (!NT_STATUS_IS_OK(status)) {
79 tevent_req_nterror(req, status);
80 return;
81 }
82
83 /* Copy out parameters */
84
85 /* Copy result */
86 state->orig.out.result = state->tmp.out.result;
87
88 /* Reset temporary structure */
89 ZERO_STRUCT(state->tmp);
90
91 tevent_req_done(req);
92}
93
94NTSTATUS rpccli_epm_Insert_recv(struct tevent_req *req,
95 TALLOC_CTX *mem_ctx,
96 uint32 *result)
97{
98 struct rpccli_epm_Insert_state *state = tevent_req_data(
99 req, struct rpccli_epm_Insert_state);
100 NTSTATUS status;
101
102 if (tevent_req_is_nterror(req, &status)) {
103 tevent_req_received(req);
104 return status;
105 }
106
107 /* Steal possbile out parameters to the callers context */
108 talloc_steal(mem_ctx, state->out_mem_ctx);
109
110 /* Return result */
111 *result = state->orig.out.result;
112
113 tevent_req_received(req);
114 return NT_STATUS_OK;
115}
116
117NTSTATUS rpccli_epm_Insert(struct rpc_pipe_client *cli,
118 TALLOC_CTX *mem_ctx,
119 uint32_t num_ents /* [in] */,
120 struct epm_entry_t *entries /* [in] [size_is(num_ents)] */,
121 uint32_t replace /* [in] */)
122{
123 struct epm_Insert r;
124 NTSTATUS status;
125
126 /* In parameters */
127 r.in.num_ents = num_ents;
128 r.in.entries = entries;
129 r.in.replace = replace;
130
131 status = cli->dispatch(cli,
132 mem_ctx,
133 &ndr_table_epmapper,
134 NDR_EPM_INSERT,
135 &r);
136
137 if (!NT_STATUS_IS_OK(status)) {
138 return status;
139 }
140
141 if (NT_STATUS_IS_ERR(status)) {
142 return status;
143 }
144
145 /* Return variables */
146
147 /* Return result */
148 return NT_STATUS_OK;
149}
150
151struct rpccli_epm_Delete_state {
152 struct epm_Delete orig;
153 struct epm_Delete tmp;
154 TALLOC_CTX *out_mem_ctx;
155 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
156};
157
158static void rpccli_epm_Delete_done(struct tevent_req *subreq);
159
160struct tevent_req *rpccli_epm_Delete_send(TALLOC_CTX *mem_ctx,
161 struct tevent_context *ev,
162 struct rpc_pipe_client *cli,
163 uint32_t _num_ents /* [in] */,
164 struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */)
165{
166 struct tevent_req *req;
167 struct rpccli_epm_Delete_state *state;
168 struct tevent_req *subreq;
169
170 req = tevent_req_create(mem_ctx, &state,
171 struct rpccli_epm_Delete_state);
172 if (req == NULL) {
173 return NULL;
174 }
175 state->out_mem_ctx = NULL;
176 state->dispatch_recv = cli->dispatch_recv;
177
178 /* In parameters */
179 state->orig.in.num_ents = _num_ents;
180 state->orig.in.entries = _entries;
181
182 /* Out parameters */
183
184 /* Result */
185 ZERO_STRUCT(state->orig.out.result);
186
187 /* make a temporary copy, that we pass to the dispatch function */
188 state->tmp = state->orig;
189
190 subreq = cli->dispatch_send(state, ev, cli,
191 &ndr_table_epmapper,
192 NDR_EPM_DELETE,
193 &state->tmp);
194 if (tevent_req_nomem(subreq, req)) {
195 return tevent_req_post(req, ev);
196 }
197 tevent_req_set_callback(subreq, rpccli_epm_Delete_done, req);
198 return req;
199}
200
201static void rpccli_epm_Delete_done(struct tevent_req *subreq)
202{
203 struct tevent_req *req = tevent_req_callback_data(
204 subreq, struct tevent_req);
205 struct rpccli_epm_Delete_state *state = tevent_req_data(
206 req, struct rpccli_epm_Delete_state);
207 NTSTATUS status;
208 TALLOC_CTX *mem_ctx;
209
210 if (state->out_mem_ctx) {
211 mem_ctx = state->out_mem_ctx;
212 } else {
213 mem_ctx = state;
214 }
215
216 status = state->dispatch_recv(subreq, mem_ctx);
217 TALLOC_FREE(subreq);
218 if (!NT_STATUS_IS_OK(status)) {
219 tevent_req_nterror(req, status);
220 return;
221 }
222
223 /* Copy out parameters */
224
225 /* Copy result */
226 state->orig.out.result = state->tmp.out.result;
227
228 /* Reset temporary structure */
229 ZERO_STRUCT(state->tmp);
230
231 tevent_req_done(req);
232}
233
234NTSTATUS rpccli_epm_Delete_recv(struct tevent_req *req,
235 TALLOC_CTX *mem_ctx,
236 uint32 *result)
237{
238 struct rpccli_epm_Delete_state *state = tevent_req_data(
239 req, struct rpccli_epm_Delete_state);
240 NTSTATUS status;
241
242 if (tevent_req_is_nterror(req, &status)) {
243 tevent_req_received(req);
244 return status;
245 }
246
247 /* Steal possbile out parameters to the callers context */
248 talloc_steal(mem_ctx, state->out_mem_ctx);
249
250 /* Return result */
251 *result = state->orig.out.result;
252
253 tevent_req_received(req);
254 return NT_STATUS_OK;
255}
256
257NTSTATUS rpccli_epm_Delete(struct rpc_pipe_client *cli,
258 TALLOC_CTX *mem_ctx,
259 uint32_t num_ents /* [in] */,
260 struct epm_entry_t *entries /* [in] [size_is(num_ents)] */)
261{
262 struct epm_Delete r;
263 NTSTATUS status;
264
265 /* In parameters */
266 r.in.num_ents = num_ents;
267 r.in.entries = entries;
268
269 status = cli->dispatch(cli,
270 mem_ctx,
271 &ndr_table_epmapper,
272 NDR_EPM_DELETE,
273 &r);
274
275 if (!NT_STATUS_IS_OK(status)) {
276 return status;
277 }
278
279 if (NT_STATUS_IS_ERR(status)) {
280 return status;
281 }
282
283 /* Return variables */
284
285 /* Return result */
286 return NT_STATUS_OK;
287}
288
289struct rpccli_epm_Lookup_state {
290 struct epm_Lookup orig;
291 struct epm_Lookup tmp;
292 TALLOC_CTX *out_mem_ctx;
293 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
294};
295
296static void rpccli_epm_Lookup_done(struct tevent_req *subreq);
297
298struct tevent_req *rpccli_epm_Lookup_send(TALLOC_CTX *mem_ctx,
299 struct tevent_context *ev,
300 struct rpc_pipe_client *cli,
301 uint32_t _inquiry_type /* [in] */,
302 struct GUID *_object /* [in] [ptr] */,
303 struct rpc_if_id_t *_interface_id /* [in] [ptr] */,
304 uint32_t _vers_option /* [in] */,
305 struct policy_handle *_entry_handle /* [in,out] [ref] */,
306 uint32_t _max_ents /* [in] */,
307 uint32_t *_num_ents /* [out] [ref] */,
308 struct epm_entry_t *_entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
309{
310 struct tevent_req *req;
311 struct rpccli_epm_Lookup_state *state;
312 struct tevent_req *subreq;
313
314 req = tevent_req_create(mem_ctx, &state,
315 struct rpccli_epm_Lookup_state);
316 if (req == NULL) {
317 return NULL;
318 }
319 state->out_mem_ctx = NULL;
320 state->dispatch_recv = cli->dispatch_recv;
321
322 /* In parameters */
323 state->orig.in.inquiry_type = _inquiry_type;
324 state->orig.in.object = _object;
325 state->orig.in.interface_id = _interface_id;
326 state->orig.in.vers_option = _vers_option;
327 state->orig.in.entry_handle = _entry_handle;
328 state->orig.in.max_ents = _max_ents;
329
330 /* Out parameters */
331 state->orig.out.entry_handle = _entry_handle;
332 state->orig.out.num_ents = _num_ents;
333 state->orig.out.entries = _entries;
334
335 /* Result */
336 ZERO_STRUCT(state->orig.out.result);
337
338 state->out_mem_ctx = talloc_named_const(state, 0,
339 "rpccli_epm_Lookup_out_memory");
340 if (tevent_req_nomem(state->out_mem_ctx, req)) {
341 return tevent_req_post(req, ev);
342 }
343
344 /* make a temporary copy, that we pass to the dispatch function */
345 state->tmp = state->orig;
346
347 subreq = cli->dispatch_send(state, ev, cli,
348 &ndr_table_epmapper,
349 NDR_EPM_LOOKUP,
350 &state->tmp);
351 if (tevent_req_nomem(subreq, req)) {
352 return tevent_req_post(req, ev);
353 }
354 tevent_req_set_callback(subreq, rpccli_epm_Lookup_done, req);
355 return req;
356}
357
358static void rpccli_epm_Lookup_done(struct tevent_req *subreq)
359{
360 struct tevent_req *req = tevent_req_callback_data(
361 subreq, struct tevent_req);
362 struct rpccli_epm_Lookup_state *state = tevent_req_data(
363 req, struct rpccli_epm_Lookup_state);
364 NTSTATUS status;
365 TALLOC_CTX *mem_ctx;
366
367 if (state->out_mem_ctx) {
368 mem_ctx = state->out_mem_ctx;
369 } else {
370 mem_ctx = state;
371 }
372
373 status = state->dispatch_recv(subreq, mem_ctx);
374 TALLOC_FREE(subreq);
375 if (!NT_STATUS_IS_OK(status)) {
376 tevent_req_nterror(req, status);
377 return;
378 }
379
380 /* Copy out parameters */
381 *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
382 *state->orig.out.num_ents = *state->tmp.out.num_ents;
383 if ((*state->tmp.out.num_ents) > (state->tmp.in.max_ents)) {
384 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
385 return;
386 }
387 memcpy(state->orig.out.entries, state->tmp.out.entries, (*state->tmp.out.num_ents) * sizeof(*state->orig.out.entries));
388
389 /* Copy result */
390 state->orig.out.result = state->tmp.out.result;
391
392 /* Reset temporary structure */
393 ZERO_STRUCT(state->tmp);
394
395 tevent_req_done(req);
396}
397
398NTSTATUS rpccli_epm_Lookup_recv(struct tevent_req *req,
399 TALLOC_CTX *mem_ctx,
400 uint32 *result)
401{
402 struct rpccli_epm_Lookup_state *state = tevent_req_data(
403 req, struct rpccli_epm_Lookup_state);
404 NTSTATUS status;
405
406 if (tevent_req_is_nterror(req, &status)) {
407 tevent_req_received(req);
408 return status;
409 }
410
411 /* Steal possbile out parameters to the callers context */
412 talloc_steal(mem_ctx, state->out_mem_ctx);
413
414 /* Return result */
415 *result = state->orig.out.result;
416
417 tevent_req_received(req);
418 return NT_STATUS_OK;
419}
420
421NTSTATUS rpccli_epm_Lookup(struct rpc_pipe_client *cli,
422 TALLOC_CTX *mem_ctx,
423 uint32_t inquiry_type /* [in] */,
424 struct GUID *object /* [in] [ptr] */,
425 struct rpc_if_id_t *interface_id /* [in] [ptr] */,
426 uint32_t vers_option /* [in] */,
427 struct policy_handle *entry_handle /* [in,out] [ref] */,
428 uint32_t max_ents /* [in] */,
429 uint32_t *num_ents /* [out] [ref] */,
430 struct epm_entry_t *entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
431{
432 struct epm_Lookup r;
433 NTSTATUS status;
434
435 /* In parameters */
436 r.in.inquiry_type = inquiry_type;
437 r.in.object = object;
438 r.in.interface_id = interface_id;
439 r.in.vers_option = vers_option;
440 r.in.entry_handle = entry_handle;
441 r.in.max_ents = max_ents;
442
443 status = cli->dispatch(cli,
444 mem_ctx,
445 &ndr_table_epmapper,
446 NDR_EPM_LOOKUP,
447 &r);
448
449 if (!NT_STATUS_IS_OK(status)) {
450 return status;
451 }
452
453 if (NT_STATUS_IS_ERR(status)) {
454 return status;
455 }
456
457 /* Return variables */
458 *entry_handle = *r.out.entry_handle;
459 *num_ents = *r.out.num_ents;
460 if ((*r.out.num_ents) > (r.in.max_ents)) {
461 return NT_STATUS_INVALID_NETWORK_RESPONSE;
462 }
463 memcpy(entries, r.out.entries, (*r.out.num_ents) * sizeof(*entries));
464
465 /* Return result */
466 return NT_STATUS_OK;
467}
468
469struct rpccli_epm_Map_state {
470 struct epm_Map orig;
471 struct epm_Map tmp;
472 TALLOC_CTX *out_mem_ctx;
473 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
474};
475
476static void rpccli_epm_Map_done(struct tevent_req *subreq);
477
478struct tevent_req *rpccli_epm_Map_send(TALLOC_CTX *mem_ctx,
479 struct tevent_context *ev,
480 struct rpc_pipe_client *cli,
481 struct GUID *_object /* [in] [ptr] */,
482 struct epm_twr_t *_map_tower /* [in] [ptr] */,
483 struct policy_handle *_entry_handle /* [in,out] [ref] */,
484 uint32_t _max_towers /* [in] */,
485 uint32_t *_num_towers /* [out] [ref] */,
486 struct epm_twr_p_t *_towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
487{
488 struct tevent_req *req;
489 struct rpccli_epm_Map_state *state;
490 struct tevent_req *subreq;
491
492 req = tevent_req_create(mem_ctx, &state,
493 struct rpccli_epm_Map_state);
494 if (req == NULL) {
495 return NULL;
496 }
497 state->out_mem_ctx = NULL;
498 state->dispatch_recv = cli->dispatch_recv;
499
500 /* In parameters */
501 state->orig.in.object = _object;
502 state->orig.in.map_tower = _map_tower;
503 state->orig.in.entry_handle = _entry_handle;
504 state->orig.in.max_towers = _max_towers;
505
506 /* Out parameters */
507 state->orig.out.entry_handle = _entry_handle;
508 state->orig.out.num_towers = _num_towers;
509 state->orig.out.towers = _towers;
510
511 /* Result */
512 ZERO_STRUCT(state->orig.out.result);
513
514 state->out_mem_ctx = talloc_named_const(state, 0,
515 "rpccli_epm_Map_out_memory");
516 if (tevent_req_nomem(state->out_mem_ctx, req)) {
517 return tevent_req_post(req, ev);
518 }
519
520 /* make a temporary copy, that we pass to the dispatch function */
521 state->tmp = state->orig;
522
523 subreq = cli->dispatch_send(state, ev, cli,
524 &ndr_table_epmapper,
525 NDR_EPM_MAP,
526 &state->tmp);
527 if (tevent_req_nomem(subreq, req)) {
528 return tevent_req_post(req, ev);
529 }
530 tevent_req_set_callback(subreq, rpccli_epm_Map_done, req);
531 return req;
532}
533
534static void rpccli_epm_Map_done(struct tevent_req *subreq)
535{
536 struct tevent_req *req = tevent_req_callback_data(
537 subreq, struct tevent_req);
538 struct rpccli_epm_Map_state *state = tevent_req_data(
539 req, struct rpccli_epm_Map_state);
540 NTSTATUS status;
541 TALLOC_CTX *mem_ctx;
542
543 if (state->out_mem_ctx) {
544 mem_ctx = state->out_mem_ctx;
545 } else {
546 mem_ctx = state;
547 }
548
549 status = state->dispatch_recv(subreq, mem_ctx);
550 TALLOC_FREE(subreq);
551 if (!NT_STATUS_IS_OK(status)) {
552 tevent_req_nterror(req, status);
553 return;
554 }
555
556 /* Copy out parameters */
557 *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
558 *state->orig.out.num_towers = *state->tmp.out.num_towers;
559 if ((*state->tmp.out.num_towers) > (state->tmp.in.max_towers)) {
560 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
561 return;
562 }
563 memcpy(state->orig.out.towers, state->tmp.out.towers, (*state->tmp.out.num_towers) * sizeof(*state->orig.out.towers));
564
565 /* Copy result */
566 state->orig.out.result = state->tmp.out.result;
567
568 /* Reset temporary structure */
569 ZERO_STRUCT(state->tmp);
570
571 tevent_req_done(req);
572}
573
574NTSTATUS rpccli_epm_Map_recv(struct tevent_req *req,
575 TALLOC_CTX *mem_ctx,
576 uint32 *result)
577{
578 struct rpccli_epm_Map_state *state = tevent_req_data(
579 req, struct rpccli_epm_Map_state);
580 NTSTATUS status;
581
582 if (tevent_req_is_nterror(req, &status)) {
583 tevent_req_received(req);
584 return status;
585 }
586
587 /* Steal possbile out parameters to the callers context */
588 talloc_steal(mem_ctx, state->out_mem_ctx);
589
590 /* Return result */
591 *result = state->orig.out.result;
592
593 tevent_req_received(req);
594 return NT_STATUS_OK;
595}
596
597NTSTATUS rpccli_epm_Map(struct rpc_pipe_client *cli,
598 TALLOC_CTX *mem_ctx,
599 struct GUID *object /* [in] [ptr] */,
600 struct epm_twr_t *map_tower /* [in] [ptr] */,
601 struct policy_handle *entry_handle /* [in,out] [ref] */,
602 uint32_t max_towers /* [in] */,
603 uint32_t *num_towers /* [out] [ref] */,
604 struct epm_twr_p_t *towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
605{
606 struct epm_Map r;
607 NTSTATUS status;
608
609 /* In parameters */
610 r.in.object = object;
611 r.in.map_tower = map_tower;
612 r.in.entry_handle = entry_handle;
613 r.in.max_towers = max_towers;
614
615 status = cli->dispatch(cli,
616 mem_ctx,
617 &ndr_table_epmapper,
618 NDR_EPM_MAP,
619 &r);
620
621 if (!NT_STATUS_IS_OK(status)) {
622 return status;
623 }
624
625 if (NT_STATUS_IS_ERR(status)) {
626 return status;
627 }
628
629 /* Return variables */
630 *entry_handle = *r.out.entry_handle;
631 *num_towers = *r.out.num_towers;
632 if ((*r.out.num_towers) > (r.in.max_towers)) {
633 return NT_STATUS_INVALID_NETWORK_RESPONSE;
634 }
635 memcpy(towers, r.out.towers, (*r.out.num_towers) * sizeof(*towers));
636
637 /* Return result */
638 return NT_STATUS_OK;
639}
640
641struct rpccli_epm_LookupHandleFree_state {
642 struct epm_LookupHandleFree orig;
643 struct epm_LookupHandleFree tmp;
644 TALLOC_CTX *out_mem_ctx;
645 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
646};
647
648static void rpccli_epm_LookupHandleFree_done(struct tevent_req *subreq);
649
650struct tevent_req *rpccli_epm_LookupHandleFree_send(TALLOC_CTX *mem_ctx,
651 struct tevent_context *ev,
652 struct rpc_pipe_client *cli,
653 struct policy_handle *_entry_handle /* [in,out] [ref] */)
654{
655 struct tevent_req *req;
656 struct rpccli_epm_LookupHandleFree_state *state;
657 struct tevent_req *subreq;
658
659 req = tevent_req_create(mem_ctx, &state,
660 struct rpccli_epm_LookupHandleFree_state);
661 if (req == NULL) {
662 return NULL;
663 }
664 state->out_mem_ctx = NULL;
665 state->dispatch_recv = cli->dispatch_recv;
666
667 /* In parameters */
668 state->orig.in.entry_handle = _entry_handle;
669
670 /* Out parameters */
671 state->orig.out.entry_handle = _entry_handle;
672
673 /* Result */
674 ZERO_STRUCT(state->orig.out.result);
675
676 state->out_mem_ctx = talloc_named_const(state, 0,
677 "rpccli_epm_LookupHandleFree_out_memory");
678 if (tevent_req_nomem(state->out_mem_ctx, req)) {
679 return tevent_req_post(req, ev);
680 }
681
682 /* make a temporary copy, that we pass to the dispatch function */
683 state->tmp = state->orig;
684
685 subreq = cli->dispatch_send(state, ev, cli,
686 &ndr_table_epmapper,
687 NDR_EPM_LOOKUPHANDLEFREE,
688 &state->tmp);
689 if (tevent_req_nomem(subreq, req)) {
690 return tevent_req_post(req, ev);
691 }
692 tevent_req_set_callback(subreq, rpccli_epm_LookupHandleFree_done, req);
693 return req;
694}
695
696static void rpccli_epm_LookupHandleFree_done(struct tevent_req *subreq)
697{
698 struct tevent_req *req = tevent_req_callback_data(
699 subreq, struct tevent_req);
700 struct rpccli_epm_LookupHandleFree_state *state = tevent_req_data(
701 req, struct rpccli_epm_LookupHandleFree_state);
702 NTSTATUS status;
703 TALLOC_CTX *mem_ctx;
704
705 if (state->out_mem_ctx) {
706 mem_ctx = state->out_mem_ctx;
707 } else {
708 mem_ctx = state;
709 }
710
711 status = state->dispatch_recv(subreq, mem_ctx);
712 TALLOC_FREE(subreq);
713 if (!NT_STATUS_IS_OK(status)) {
714 tevent_req_nterror(req, status);
715 return;
716 }
717
718 /* Copy out parameters */
719 *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
720
721 /* Copy result */
722 state->orig.out.result = state->tmp.out.result;
723
724 /* Reset temporary structure */
725 ZERO_STRUCT(state->tmp);
726
727 tevent_req_done(req);
728}
729
730NTSTATUS rpccli_epm_LookupHandleFree_recv(struct tevent_req *req,
731 TALLOC_CTX *mem_ctx,
732 uint32 *result)
733{
734 struct rpccli_epm_LookupHandleFree_state *state = tevent_req_data(
735 req, struct rpccli_epm_LookupHandleFree_state);
736 NTSTATUS status;
737
738 if (tevent_req_is_nterror(req, &status)) {
739 tevent_req_received(req);
740 return status;
741 }
742
743 /* Steal possbile out parameters to the callers context */
744 talloc_steal(mem_ctx, state->out_mem_ctx);
745
746 /* Return result */
747 *result = state->orig.out.result;
748
749 tevent_req_received(req);
750 return NT_STATUS_OK;
751}
752
753NTSTATUS rpccli_epm_LookupHandleFree(struct rpc_pipe_client *cli,
754 TALLOC_CTX *mem_ctx,
755 struct policy_handle *entry_handle /* [in,out] [ref] */)
756{
757 struct epm_LookupHandleFree r;
758 NTSTATUS status;
759
760 /* In parameters */
761 r.in.entry_handle = entry_handle;
762
763 status = cli->dispatch(cli,
764 mem_ctx,
765 &ndr_table_epmapper,
766 NDR_EPM_LOOKUPHANDLEFREE,
767 &r);
768
769 if (!NT_STATUS_IS_OK(status)) {
770 return status;
771 }
772
773 if (NT_STATUS_IS_ERR(status)) {
774 return status;
775 }
776
777 /* Return variables */
778 *entry_handle = *r.out.entry_handle;
779
780 /* Return result */
781 return NT_STATUS_OK;
782}
783
784struct rpccli_epm_InqObject_state {
785 struct epm_InqObject orig;
786 struct epm_InqObject tmp;
787 TALLOC_CTX *out_mem_ctx;
788 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
789};
790
791static void rpccli_epm_InqObject_done(struct tevent_req *subreq);
792
793struct tevent_req *rpccli_epm_InqObject_send(TALLOC_CTX *mem_ctx,
794 struct tevent_context *ev,
795 struct rpc_pipe_client *cli,
796 struct GUID *_epm_object /* [in] [ref] */)
797{
798 struct tevent_req *req;
799 struct rpccli_epm_InqObject_state *state;
800 struct tevent_req *subreq;
801
802 req = tevent_req_create(mem_ctx, &state,
803 struct rpccli_epm_InqObject_state);
804 if (req == NULL) {
805 return NULL;
806 }
807 state->out_mem_ctx = NULL;
808 state->dispatch_recv = cli->dispatch_recv;
809
810 /* In parameters */
811 state->orig.in.epm_object = _epm_object;
812
813 /* Out parameters */
814
815 /* Result */
816 ZERO_STRUCT(state->orig.out.result);
817
818 /* make a temporary copy, that we pass to the dispatch function */
819 state->tmp = state->orig;
820
821 subreq = cli->dispatch_send(state, ev, cli,
822 &ndr_table_epmapper,
823 NDR_EPM_INQOBJECT,
824 &state->tmp);
825 if (tevent_req_nomem(subreq, req)) {
826 return tevent_req_post(req, ev);
827 }
828 tevent_req_set_callback(subreq, rpccli_epm_InqObject_done, req);
829 return req;
830}
831
832static void rpccli_epm_InqObject_done(struct tevent_req *subreq)
833{
834 struct tevent_req *req = tevent_req_callback_data(
835 subreq, struct tevent_req);
836 struct rpccli_epm_InqObject_state *state = tevent_req_data(
837 req, struct rpccli_epm_InqObject_state);
838 NTSTATUS status;
839 TALLOC_CTX *mem_ctx;
840
841 if (state->out_mem_ctx) {
842 mem_ctx = state->out_mem_ctx;
843 } else {
844 mem_ctx = state;
845 }
846
847 status = state->dispatch_recv(subreq, mem_ctx);
848 TALLOC_FREE(subreq);
849 if (!NT_STATUS_IS_OK(status)) {
850 tevent_req_nterror(req, status);
851 return;
852 }
853
854 /* Copy out parameters */
855
856 /* Copy result */
857 state->orig.out.result = state->tmp.out.result;
858
859 /* Reset temporary structure */
860 ZERO_STRUCT(state->tmp);
861
862 tevent_req_done(req);
863}
864
865NTSTATUS rpccli_epm_InqObject_recv(struct tevent_req *req,
866 TALLOC_CTX *mem_ctx,
867 uint32 *result)
868{
869 struct rpccli_epm_InqObject_state *state = tevent_req_data(
870 req, struct rpccli_epm_InqObject_state);
871 NTSTATUS status;
872
873 if (tevent_req_is_nterror(req, &status)) {
874 tevent_req_received(req);
875 return status;
876 }
877
878 /* Steal possbile out parameters to the callers context */
879 talloc_steal(mem_ctx, state->out_mem_ctx);
880
881 /* Return result */
882 *result = state->orig.out.result;
883
884 tevent_req_received(req);
885 return NT_STATUS_OK;
886}
887
888NTSTATUS rpccli_epm_InqObject(struct rpc_pipe_client *cli,
889 TALLOC_CTX *mem_ctx,
890 struct GUID *epm_object /* [in] [ref] */)
891{
892 struct epm_InqObject r;
893 NTSTATUS status;
894
895 /* In parameters */
896 r.in.epm_object = epm_object;
897
898 status = cli->dispatch(cli,
899 mem_ctx,
900 &ndr_table_epmapper,
901 NDR_EPM_INQOBJECT,
902 &r);
903
904 if (!NT_STATUS_IS_OK(status)) {
905 return status;
906 }
907
908 if (NT_STATUS_IS_ERR(status)) {
909 return status;
910 }
911
912 /* Return variables */
913
914 /* Return result */
915 return NT_STATUS_OK;
916}
917
918struct rpccli_epm_MgmtDelete_state {
919 struct epm_MgmtDelete orig;
920 struct epm_MgmtDelete tmp;
921 TALLOC_CTX *out_mem_ctx;
922 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
923};
924
925static void rpccli_epm_MgmtDelete_done(struct tevent_req *subreq);
926
927struct tevent_req *rpccli_epm_MgmtDelete_send(TALLOC_CTX *mem_ctx,
928 struct tevent_context *ev,
929 struct rpc_pipe_client *cli,
930 uint32_t _object_speced /* [in] */,
931 struct GUID *_object /* [in] [ptr] */,
932 struct epm_twr_t *_tower /* [in] [ptr] */)
933{
934 struct tevent_req *req;
935 struct rpccli_epm_MgmtDelete_state *state;
936 struct tevent_req *subreq;
937
938 req = tevent_req_create(mem_ctx, &state,
939 struct rpccli_epm_MgmtDelete_state);
940 if (req == NULL) {
941 return NULL;
942 }
943 state->out_mem_ctx = NULL;
944 state->dispatch_recv = cli->dispatch_recv;
945
946 /* In parameters */
947 state->orig.in.object_speced = _object_speced;
948 state->orig.in.object = _object;
949 state->orig.in.tower = _tower;
950
951 /* Out parameters */
952
953 /* Result */
954 ZERO_STRUCT(state->orig.out.result);
955
956 /* make a temporary copy, that we pass to the dispatch function */
957 state->tmp = state->orig;
958
959 subreq = cli->dispatch_send(state, ev, cli,
960 &ndr_table_epmapper,
961 NDR_EPM_MGMTDELETE,
962 &state->tmp);
963 if (tevent_req_nomem(subreq, req)) {
964 return tevent_req_post(req, ev);
965 }
966 tevent_req_set_callback(subreq, rpccli_epm_MgmtDelete_done, req);
967 return req;
968}
969
970static void rpccli_epm_MgmtDelete_done(struct tevent_req *subreq)
971{
972 struct tevent_req *req = tevent_req_callback_data(
973 subreq, struct tevent_req);
974 struct rpccli_epm_MgmtDelete_state *state = tevent_req_data(
975 req, struct rpccli_epm_MgmtDelete_state);
976 NTSTATUS status;
977 TALLOC_CTX *mem_ctx;
978
979 if (state->out_mem_ctx) {
980 mem_ctx = state->out_mem_ctx;
981 } else {
982 mem_ctx = state;
983 }
984
985 status = state->dispatch_recv(subreq, mem_ctx);
986 TALLOC_FREE(subreq);
987 if (!NT_STATUS_IS_OK(status)) {
988 tevent_req_nterror(req, status);
989 return;
990 }
991
992 /* Copy out parameters */
993
994 /* Copy result */
995 state->orig.out.result = state->tmp.out.result;
996
997 /* Reset temporary structure */
998 ZERO_STRUCT(state->tmp);
999
1000 tevent_req_done(req);
1001}
1002
1003NTSTATUS rpccli_epm_MgmtDelete_recv(struct tevent_req *req,
1004 TALLOC_CTX *mem_ctx,
1005 uint32 *result)
1006{
1007 struct rpccli_epm_MgmtDelete_state *state = tevent_req_data(
1008 req, struct rpccli_epm_MgmtDelete_state);
1009 NTSTATUS status;
1010
1011 if (tevent_req_is_nterror(req, &status)) {
1012 tevent_req_received(req);
1013 return status;
1014 }
1015
1016 /* Steal possbile out parameters to the callers context */
1017 talloc_steal(mem_ctx, state->out_mem_ctx);
1018
1019 /* Return result */
1020 *result = state->orig.out.result;
1021
1022 tevent_req_received(req);
1023 return NT_STATUS_OK;
1024}
1025
1026NTSTATUS rpccli_epm_MgmtDelete(struct rpc_pipe_client *cli,
1027 TALLOC_CTX *mem_ctx,
1028 uint32_t object_speced /* [in] */,
1029 struct GUID *object /* [in] [ptr] */,
1030 struct epm_twr_t *tower /* [in] [ptr] */)
1031{
1032 struct epm_MgmtDelete r;
1033 NTSTATUS status;
1034
1035 /* In parameters */
1036 r.in.object_speced = object_speced;
1037 r.in.object = object;
1038 r.in.tower = tower;
1039
1040 status = cli->dispatch(cli,
1041 mem_ctx,
1042 &ndr_table_epmapper,
1043 NDR_EPM_MGMTDELETE,
1044 &r);
1045
1046 if (!NT_STATUS_IS_OK(status)) {
1047 return status;
1048 }
1049
1050 if (NT_STATUS_IS_ERR(status)) {
1051 return status;
1052 }
1053
1054 /* Return variables */
1055
1056 /* Return result */
1057 return NT_STATUS_OK;
1058}
1059
1060struct rpccli_epm_MapAuth_state {
1061 struct epm_MapAuth orig;
1062 struct epm_MapAuth tmp;
1063 TALLOC_CTX *out_mem_ctx;
1064 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1065};
1066
1067static void rpccli_epm_MapAuth_done(struct tevent_req *subreq);
1068
1069struct tevent_req *rpccli_epm_MapAuth_send(TALLOC_CTX *mem_ctx,
1070 struct tevent_context *ev,
1071 struct rpc_pipe_client *cli)
1072{
1073 struct tevent_req *req;
1074 struct rpccli_epm_MapAuth_state *state;
1075 struct tevent_req *subreq;
1076
1077 req = tevent_req_create(mem_ctx, &state,
1078 struct rpccli_epm_MapAuth_state);
1079 if (req == NULL) {
1080 return NULL;
1081 }
1082 state->out_mem_ctx = NULL;
1083 state->dispatch_recv = cli->dispatch_recv;
1084
1085 /* In parameters */
1086
1087 /* Out parameters */
1088
1089 /* Result */
1090 ZERO_STRUCT(state->orig.out.result);
1091
1092 /* make a temporary copy, that we pass to the dispatch function */
1093 state->tmp = state->orig;
1094
1095 subreq = cli->dispatch_send(state, ev, cli,
1096 &ndr_table_epmapper,
1097 NDR_EPM_MAPAUTH,
1098 &state->tmp);
1099 if (tevent_req_nomem(subreq, req)) {
1100 return tevent_req_post(req, ev);
1101 }
1102 tevent_req_set_callback(subreq, rpccli_epm_MapAuth_done, req);
1103 return req;
1104}
1105
1106static void rpccli_epm_MapAuth_done(struct tevent_req *subreq)
1107{
1108 struct tevent_req *req = tevent_req_callback_data(
1109 subreq, struct tevent_req);
1110 struct rpccli_epm_MapAuth_state *state = tevent_req_data(
1111 req, struct rpccli_epm_MapAuth_state);
1112 NTSTATUS status;
1113 TALLOC_CTX *mem_ctx;
1114
1115 if (state->out_mem_ctx) {
1116 mem_ctx = state->out_mem_ctx;
1117 } else {
1118 mem_ctx = state;
1119 }
1120
1121 status = state->dispatch_recv(subreq, mem_ctx);
1122 TALLOC_FREE(subreq);
1123 if (!NT_STATUS_IS_OK(status)) {
1124 tevent_req_nterror(req, status);
1125 return;
1126 }
1127
1128 /* Copy out parameters */
1129
1130 /* Copy result */
1131 state->orig.out.result = state->tmp.out.result;
1132
1133 /* Reset temporary structure */
1134 ZERO_STRUCT(state->tmp);
1135
1136 tevent_req_done(req);
1137}
1138
1139NTSTATUS rpccli_epm_MapAuth_recv(struct tevent_req *req,
1140 TALLOC_CTX *mem_ctx,
1141 uint32 *result)
1142{
1143 struct rpccli_epm_MapAuth_state *state = tevent_req_data(
1144 req, struct rpccli_epm_MapAuth_state);
1145 NTSTATUS status;
1146
1147 if (tevent_req_is_nterror(req, &status)) {
1148 tevent_req_received(req);
1149 return status;
1150 }
1151
1152 /* Steal possbile out parameters to the callers context */
1153 talloc_steal(mem_ctx, state->out_mem_ctx);
1154
1155 /* Return result */
1156 *result = state->orig.out.result;
1157
1158 tevent_req_received(req);
1159 return NT_STATUS_OK;
1160}
1161
1162NTSTATUS rpccli_epm_MapAuth(struct rpc_pipe_client *cli,
1163 TALLOC_CTX *mem_ctx)
1164{
1165 struct epm_MapAuth r;
1166 NTSTATUS status;
1167
1168 /* In parameters */
1169
1170 status = cli->dispatch(cli,
1171 mem_ctx,
1172 &ndr_table_epmapper,
1173 NDR_EPM_MAPAUTH,
1174 &r);
1175
1176 if (!NT_STATUS_IS_OK(status)) {
1177 return status;
1178 }
1179
1180 if (NT_STATUS_IS_ERR(status)) {
1181 return status;
1182 }
1183
1184 /* Return variables */
1185
1186 /* Return result */
1187 return NT_STATUS_OK;
1188}
1189
Note: See TracBrowser for help on using the repository browser.