3115a20d9df9f3bbbadc4fdf2d1cd745461d0d15
[ira/wip.git] / source3 / librpc / gen_ndr / cli_wbint.c
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_wbint.h"
8
9 struct rpccli_wbint_Ping_state {
10         struct wbint_Ping orig;
11         struct wbint_Ping 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_wbint_Ping_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_wbint_Ping_send(TALLOC_CTX *mem_ctx,
19                                           struct tevent_context *ev,
20                                           struct rpc_pipe_client *cli,
21                                           uint32_t _in_data /* [in]  */,
22                                           uint32_t *_out_data /* [out] [ref] */)
23 {
24         struct tevent_req *req;
25         struct rpccli_wbint_Ping_state *state;
26         struct tevent_req *subreq;
27
28         req = tevent_req_create(mem_ctx, &state,
29                                 struct rpccli_wbint_Ping_state);
30         if (req == NULL) {
31                 return NULL;
32         }
33         state->out_mem_ctx = NULL;
34         state->dispatch_recv = cli->dispatch_recv;
35
36         /* In parameters */
37         state->orig.in.in_data = _in_data;
38
39         /* Out parameters */
40         state->orig.out.out_data = _out_data;
41
42         state->out_mem_ctx = talloc_named_const(state, 0,
43                              "rpccli_wbint_Ping_out_memory");
44         if (tevent_req_nomem(state->out_mem_ctx, req)) {
45                 return tevent_req_post(req, ev);
46         }
47
48         /* make a temporary copy, that we pass to the dispatch function */
49         state->tmp = state->orig;
50
51         subreq = cli->dispatch_send(state, ev, cli,
52                                     &ndr_table_wbint,
53                                     NDR_WBINT_PING,
54                                     &state->tmp);
55         if (tevent_req_nomem(subreq, req)) {
56                 return tevent_req_post(req, ev);
57         }
58         tevent_req_set_callback(subreq, rpccli_wbint_Ping_done, req);
59         return req;
60 }
61
62 static void rpccli_wbint_Ping_done(struct tevent_req *subreq)
63 {
64         struct tevent_req *req = tevent_req_callback_data(
65                 subreq, struct tevent_req);
66         struct rpccli_wbint_Ping_state *state = tevent_req_data(
67                 req, struct rpccli_wbint_Ping_state);
68         NTSTATUS status;
69         TALLOC_CTX *mem_ctx;
70
71         if (state->out_mem_ctx) {
72                 mem_ctx = state->out_mem_ctx;
73         } else {
74                 mem_ctx = state;
75         }
76
77         status = state->dispatch_recv(subreq, mem_ctx);
78         TALLOC_FREE(subreq);
79         if (!NT_STATUS_IS_OK(status)) {
80                 tevent_req_nterror(req, status);
81                 return;
82         }
83
84         /* Copy out parameters */
85         *state->orig.out.out_data = *state->tmp.out.out_data;
86
87         /* Reset temporary structure */
88         ZERO_STRUCT(state->tmp);
89
90         tevent_req_done(req);
91 }
92
93 NTSTATUS rpccli_wbint_Ping_recv(struct tevent_req *req,
94                                 TALLOC_CTX *mem_ctx)
95 {
96         struct rpccli_wbint_Ping_state *state = tevent_req_data(
97                 req, struct rpccli_wbint_Ping_state);
98         NTSTATUS status;
99
100         if (tevent_req_is_nterror(req, &status)) {
101                 tevent_req_received(req);
102                 return status;
103         }
104
105         /* Steal possbile out parameters to the callers context */
106         talloc_steal(mem_ctx, state->out_mem_ctx);
107
108         tevent_req_received(req);
109         return NT_STATUS_OK;
110 }
111
112 NTSTATUS rpccli_wbint_Ping(struct rpc_pipe_client *cli,
113                            TALLOC_CTX *mem_ctx,
114                            uint32_t in_data /* [in]  */,
115                            uint32_t *out_data /* [out] [ref] */)
116 {
117         struct wbint_Ping r;
118         NTSTATUS status;
119
120         /* In parameters */
121         r.in.in_data = in_data;
122
123         status = cli->dispatch(cli,
124                                 mem_ctx,
125                                 &ndr_table_wbint,
126                                 NDR_WBINT_PING,
127                                 &r);
128
129         if (!NT_STATUS_IS_OK(status)) {
130                 return status;
131         }
132
133         if (NT_STATUS_IS_ERR(status)) {
134                 return status;
135         }
136
137         /* Return variables */
138         *out_data = *r.out.out_data;
139
140         /* Return result */
141         return NT_STATUS_OK;
142 }
143
144 struct rpccli_wbint_LookupSid_state {
145         struct wbint_LookupSid orig;
146         struct wbint_LookupSid tmp;
147         TALLOC_CTX *out_mem_ctx;
148         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
149 };
150
151 static void rpccli_wbint_LookupSid_done(struct tevent_req *subreq);
152
153 struct tevent_req *rpccli_wbint_LookupSid_send(TALLOC_CTX *mem_ctx,
154                                                struct tevent_context *ev,
155                                                struct rpc_pipe_client *cli,
156                                                struct dom_sid *_sid /* [in] [ref] */,
157                                                enum lsa_SidType *_type /* [out] [ref] */,
158                                                const char **_domain /* [out] [ref,charset(UTF8)] */,
159                                                const char **_name /* [out] [ref,charset(UTF8)] */)
160 {
161         struct tevent_req *req;
162         struct rpccli_wbint_LookupSid_state *state;
163         struct tevent_req *subreq;
164
165         req = tevent_req_create(mem_ctx, &state,
166                                 struct rpccli_wbint_LookupSid_state);
167         if (req == NULL) {
168                 return NULL;
169         }
170         state->out_mem_ctx = NULL;
171         state->dispatch_recv = cli->dispatch_recv;
172
173         /* In parameters */
174         state->orig.in.sid = _sid;
175
176         /* Out parameters */
177         state->orig.out.type = _type;
178         state->orig.out.domain = _domain;
179         state->orig.out.name = _name;
180
181         /* Result */
182         ZERO_STRUCT(state->orig.out.result);
183
184         state->out_mem_ctx = talloc_named_const(state, 0,
185                              "rpccli_wbint_LookupSid_out_memory");
186         if (tevent_req_nomem(state->out_mem_ctx, req)) {
187                 return tevent_req_post(req, ev);
188         }
189
190         /* make a temporary copy, that we pass to the dispatch function */
191         state->tmp = state->orig;
192
193         subreq = cli->dispatch_send(state, ev, cli,
194                                     &ndr_table_wbint,
195                                     NDR_WBINT_LOOKUPSID,
196                                     &state->tmp);
197         if (tevent_req_nomem(subreq, req)) {
198                 return tevent_req_post(req, ev);
199         }
200         tevent_req_set_callback(subreq, rpccli_wbint_LookupSid_done, req);
201         return req;
202 }
203
204 static void rpccli_wbint_LookupSid_done(struct tevent_req *subreq)
205 {
206         struct tevent_req *req = tevent_req_callback_data(
207                 subreq, struct tevent_req);
208         struct rpccli_wbint_LookupSid_state *state = tevent_req_data(
209                 req, struct rpccli_wbint_LookupSid_state);
210         NTSTATUS status;
211         TALLOC_CTX *mem_ctx;
212
213         if (state->out_mem_ctx) {
214                 mem_ctx = state->out_mem_ctx;
215         } else {
216                 mem_ctx = state;
217         }
218
219         status = state->dispatch_recv(subreq, mem_ctx);
220         TALLOC_FREE(subreq);
221         if (!NT_STATUS_IS_OK(status)) {
222                 tevent_req_nterror(req, status);
223                 return;
224         }
225
226         /* Copy out parameters */
227         *state->orig.out.type = *state->tmp.out.type;
228         *state->orig.out.domain = *state->tmp.out.domain;
229         *state->orig.out.name = *state->tmp.out.name;
230
231         /* Copy result */
232         state->orig.out.result = state->tmp.out.result;
233
234         /* Reset temporary structure */
235         ZERO_STRUCT(state->tmp);
236
237         tevent_req_done(req);
238 }
239
240 NTSTATUS rpccli_wbint_LookupSid_recv(struct tevent_req *req,
241                                      TALLOC_CTX *mem_ctx,
242                                      NTSTATUS *result)
243 {
244         struct rpccli_wbint_LookupSid_state *state = tevent_req_data(
245                 req, struct rpccli_wbint_LookupSid_state);
246         NTSTATUS status;
247
248         if (tevent_req_is_nterror(req, &status)) {
249                 tevent_req_received(req);
250                 return status;
251         }
252
253         /* Steal possbile out parameters to the callers context */
254         talloc_steal(mem_ctx, state->out_mem_ctx);
255
256         /* Return result */
257         *result = state->orig.out.result;
258
259         tevent_req_received(req);
260         return NT_STATUS_OK;
261 }
262
263 NTSTATUS rpccli_wbint_LookupSid(struct rpc_pipe_client *cli,
264                                 TALLOC_CTX *mem_ctx,
265                                 struct dom_sid *sid /* [in] [ref] */,
266                                 enum lsa_SidType *type /* [out] [ref] */,
267                                 const char **domain /* [out] [ref,charset(UTF8)] */,
268                                 const char **name /* [out] [ref,charset(UTF8)] */)
269 {
270         struct wbint_LookupSid r;
271         NTSTATUS status;
272
273         /* In parameters */
274         r.in.sid = sid;
275
276         status = cli->dispatch(cli,
277                                 mem_ctx,
278                                 &ndr_table_wbint,
279                                 NDR_WBINT_LOOKUPSID,
280                                 &r);
281
282         if (!NT_STATUS_IS_OK(status)) {
283                 return status;
284         }
285
286         if (NT_STATUS_IS_ERR(status)) {
287                 return status;
288         }
289
290         /* Return variables */
291         *type = *r.out.type;
292         *domain = *r.out.domain;
293         *name = *r.out.name;
294
295         /* Return result */
296         return r.out.result;
297 }
298
299 struct rpccli_wbint_LookupName_state {
300         struct wbint_LookupName orig;
301         struct wbint_LookupName tmp;
302         TALLOC_CTX *out_mem_ctx;
303         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
304 };
305
306 static void rpccli_wbint_LookupName_done(struct tevent_req *subreq);
307
308 struct tevent_req *rpccli_wbint_LookupName_send(TALLOC_CTX *mem_ctx,
309                                                 struct tevent_context *ev,
310                                                 struct rpc_pipe_client *cli,
311                                                 const char *_domain /* [in] [ref,charset(UTF8)] */,
312                                                 const char *_name /* [in] [ref,charset(UTF8)] */,
313                                                 uint32_t _flags /* [in]  */,
314                                                 enum lsa_SidType *_type /* [out] [ref] */,
315                                                 struct dom_sid *_sid /* [out] [ref] */)
316 {
317         struct tevent_req *req;
318         struct rpccli_wbint_LookupName_state *state;
319         struct tevent_req *subreq;
320
321         req = tevent_req_create(mem_ctx, &state,
322                                 struct rpccli_wbint_LookupName_state);
323         if (req == NULL) {
324                 return NULL;
325         }
326         state->out_mem_ctx = NULL;
327         state->dispatch_recv = cli->dispatch_recv;
328
329         /* In parameters */
330         state->orig.in.domain = _domain;
331         state->orig.in.name = _name;
332         state->orig.in.flags = _flags;
333
334         /* Out parameters */
335         state->orig.out.type = _type;
336         state->orig.out.sid = _sid;
337
338         /* Result */
339         ZERO_STRUCT(state->orig.out.result);
340
341         state->out_mem_ctx = talloc_named_const(state, 0,
342                              "rpccli_wbint_LookupName_out_memory");
343         if (tevent_req_nomem(state->out_mem_ctx, req)) {
344                 return tevent_req_post(req, ev);
345         }
346
347         /* make a temporary copy, that we pass to the dispatch function */
348         state->tmp = state->orig;
349
350         subreq = cli->dispatch_send(state, ev, cli,
351                                     &ndr_table_wbint,
352                                     NDR_WBINT_LOOKUPNAME,
353                                     &state->tmp);
354         if (tevent_req_nomem(subreq, req)) {
355                 return tevent_req_post(req, ev);
356         }
357         tevent_req_set_callback(subreq, rpccli_wbint_LookupName_done, req);
358         return req;
359 }
360
361 static void rpccli_wbint_LookupName_done(struct tevent_req *subreq)
362 {
363         struct tevent_req *req = tevent_req_callback_data(
364                 subreq, struct tevent_req);
365         struct rpccli_wbint_LookupName_state *state = tevent_req_data(
366                 req, struct rpccli_wbint_LookupName_state);
367         NTSTATUS status;
368         TALLOC_CTX *mem_ctx;
369
370         if (state->out_mem_ctx) {
371                 mem_ctx = state->out_mem_ctx;
372         } else {
373                 mem_ctx = state;
374         }
375
376         status = state->dispatch_recv(subreq, mem_ctx);
377         TALLOC_FREE(subreq);
378         if (!NT_STATUS_IS_OK(status)) {
379                 tevent_req_nterror(req, status);
380                 return;
381         }
382
383         /* Copy out parameters */
384         *state->orig.out.type = *state->tmp.out.type;
385         *state->orig.out.sid = *state->tmp.out.sid;
386
387         /* Copy result */
388         state->orig.out.result = state->tmp.out.result;
389
390         /* Reset temporary structure */
391         ZERO_STRUCT(state->tmp);
392
393         tevent_req_done(req);
394 }
395
396 NTSTATUS rpccli_wbint_LookupName_recv(struct tevent_req *req,
397                                       TALLOC_CTX *mem_ctx,
398                                       NTSTATUS *result)
399 {
400         struct rpccli_wbint_LookupName_state *state = tevent_req_data(
401                 req, struct rpccli_wbint_LookupName_state);
402         NTSTATUS status;
403
404         if (tevent_req_is_nterror(req, &status)) {
405                 tevent_req_received(req);
406                 return status;
407         }
408
409         /* Steal possbile out parameters to the callers context */
410         talloc_steal(mem_ctx, state->out_mem_ctx);
411
412         /* Return result */
413         *result = state->orig.out.result;
414
415         tevent_req_received(req);
416         return NT_STATUS_OK;
417 }
418
419 NTSTATUS rpccli_wbint_LookupName(struct rpc_pipe_client *cli,
420                                  TALLOC_CTX *mem_ctx,
421                                  const char *domain /* [in] [ref,charset(UTF8)] */,
422                                  const char *name /* [in] [ref,charset(UTF8)] */,
423                                  uint32_t flags /* [in]  */,
424                                  enum lsa_SidType *type /* [out] [ref] */,
425                                  struct dom_sid *sid /* [out] [ref] */)
426 {
427         struct wbint_LookupName r;
428         NTSTATUS status;
429
430         /* In parameters */
431         r.in.domain = domain;
432         r.in.name = name;
433         r.in.flags = flags;
434
435         status = cli->dispatch(cli,
436                                 mem_ctx,
437                                 &ndr_table_wbint,
438                                 NDR_WBINT_LOOKUPNAME,
439                                 &r);
440
441         if (!NT_STATUS_IS_OK(status)) {
442                 return status;
443         }
444
445         if (NT_STATUS_IS_ERR(status)) {
446                 return status;
447         }
448
449         /* Return variables */
450         *type = *r.out.type;
451         *sid = *r.out.sid;
452
453         /* Return result */
454         return r.out.result;
455 }
456
457 struct rpccli_wbint_Sid2Uid_state {
458         struct wbint_Sid2Uid orig;
459         struct wbint_Sid2Uid tmp;
460         TALLOC_CTX *out_mem_ctx;
461         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
462 };
463
464 static void rpccli_wbint_Sid2Uid_done(struct tevent_req *subreq);
465
466 struct tevent_req *rpccli_wbint_Sid2Uid_send(TALLOC_CTX *mem_ctx,
467                                              struct tevent_context *ev,
468                                              struct rpc_pipe_client *cli,
469                                              const char *_dom_name /* [in] [unique,charset(UTF8)] */,
470                                              struct dom_sid *_sid /* [in] [ref] */,
471                                              uint64_t *_uid /* [out] [ref] */)
472 {
473         struct tevent_req *req;
474         struct rpccli_wbint_Sid2Uid_state *state;
475         struct tevent_req *subreq;
476
477         req = tevent_req_create(mem_ctx, &state,
478                                 struct rpccli_wbint_Sid2Uid_state);
479         if (req == NULL) {
480                 return NULL;
481         }
482         state->out_mem_ctx = NULL;
483         state->dispatch_recv = cli->dispatch_recv;
484
485         /* In parameters */
486         state->orig.in.dom_name = _dom_name;
487         state->orig.in.sid = _sid;
488
489         /* Out parameters */
490         state->orig.out.uid = _uid;
491
492         /* Result */
493         ZERO_STRUCT(state->orig.out.result);
494
495         state->out_mem_ctx = talloc_named_const(state, 0,
496                              "rpccli_wbint_Sid2Uid_out_memory");
497         if (tevent_req_nomem(state->out_mem_ctx, req)) {
498                 return tevent_req_post(req, ev);
499         }
500
501         /* make a temporary copy, that we pass to the dispatch function */
502         state->tmp = state->orig;
503
504         subreq = cli->dispatch_send(state, ev, cli,
505                                     &ndr_table_wbint,
506                                     NDR_WBINT_SID2UID,
507                                     &state->tmp);
508         if (tevent_req_nomem(subreq, req)) {
509                 return tevent_req_post(req, ev);
510         }
511         tevent_req_set_callback(subreq, rpccli_wbint_Sid2Uid_done, req);
512         return req;
513 }
514
515 static void rpccli_wbint_Sid2Uid_done(struct tevent_req *subreq)
516 {
517         struct tevent_req *req = tevent_req_callback_data(
518                 subreq, struct tevent_req);
519         struct rpccli_wbint_Sid2Uid_state *state = tevent_req_data(
520                 req, struct rpccli_wbint_Sid2Uid_state);
521         NTSTATUS status;
522         TALLOC_CTX *mem_ctx;
523
524         if (state->out_mem_ctx) {
525                 mem_ctx = state->out_mem_ctx;
526         } else {
527                 mem_ctx = state;
528         }
529
530         status = state->dispatch_recv(subreq, mem_ctx);
531         TALLOC_FREE(subreq);
532         if (!NT_STATUS_IS_OK(status)) {
533                 tevent_req_nterror(req, status);
534                 return;
535         }
536
537         /* Copy out parameters */
538         *state->orig.out.uid = *state->tmp.out.uid;
539
540         /* Copy result */
541         state->orig.out.result = state->tmp.out.result;
542
543         /* Reset temporary structure */
544         ZERO_STRUCT(state->tmp);
545
546         tevent_req_done(req);
547 }
548
549 NTSTATUS rpccli_wbint_Sid2Uid_recv(struct tevent_req *req,
550                                    TALLOC_CTX *mem_ctx,
551                                    NTSTATUS *result)
552 {
553         struct rpccli_wbint_Sid2Uid_state *state = tevent_req_data(
554                 req, struct rpccli_wbint_Sid2Uid_state);
555         NTSTATUS status;
556
557         if (tevent_req_is_nterror(req, &status)) {
558                 tevent_req_received(req);
559                 return status;
560         }
561
562         /* Steal possbile out parameters to the callers context */
563         talloc_steal(mem_ctx, state->out_mem_ctx);
564
565         /* Return result */
566         *result = state->orig.out.result;
567
568         tevent_req_received(req);
569         return NT_STATUS_OK;
570 }
571
572 NTSTATUS rpccli_wbint_Sid2Uid(struct rpc_pipe_client *cli,
573                               TALLOC_CTX *mem_ctx,
574                               const char *dom_name /* [in] [unique,charset(UTF8)] */,
575                               struct dom_sid *sid /* [in] [ref] */,
576                               uint64_t *uid /* [out] [ref] */)
577 {
578         struct wbint_Sid2Uid r;
579         NTSTATUS status;
580
581         /* In parameters */
582         r.in.dom_name = dom_name;
583         r.in.sid = sid;
584
585         status = cli->dispatch(cli,
586                                 mem_ctx,
587                                 &ndr_table_wbint,
588                                 NDR_WBINT_SID2UID,
589                                 &r);
590
591         if (!NT_STATUS_IS_OK(status)) {
592                 return status;
593         }
594
595         if (NT_STATUS_IS_ERR(status)) {
596                 return status;
597         }
598
599         /* Return variables */
600         *uid = *r.out.uid;
601
602         /* Return result */
603         return r.out.result;
604 }
605
606 struct rpccli_wbint_Sid2Gid_state {
607         struct wbint_Sid2Gid orig;
608         struct wbint_Sid2Gid tmp;
609         TALLOC_CTX *out_mem_ctx;
610         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
611 };
612
613 static void rpccli_wbint_Sid2Gid_done(struct tevent_req *subreq);
614
615 struct tevent_req *rpccli_wbint_Sid2Gid_send(TALLOC_CTX *mem_ctx,
616                                              struct tevent_context *ev,
617                                              struct rpc_pipe_client *cli,
618                                              const char *_dom_name /* [in] [unique,charset(UTF8)] */,
619                                              struct dom_sid *_sid /* [in] [ref] */,
620                                              uint64_t *_gid /* [out] [ref] */)
621 {
622         struct tevent_req *req;
623         struct rpccli_wbint_Sid2Gid_state *state;
624         struct tevent_req *subreq;
625
626         req = tevent_req_create(mem_ctx, &state,
627                                 struct rpccli_wbint_Sid2Gid_state);
628         if (req == NULL) {
629                 return NULL;
630         }
631         state->out_mem_ctx = NULL;
632         state->dispatch_recv = cli->dispatch_recv;
633
634         /* In parameters */
635         state->orig.in.dom_name = _dom_name;
636         state->orig.in.sid = _sid;
637
638         /* Out parameters */
639         state->orig.out.gid = _gid;
640
641         /* Result */
642         ZERO_STRUCT(state->orig.out.result);
643
644         state->out_mem_ctx = talloc_named_const(state, 0,
645                              "rpccli_wbint_Sid2Gid_out_memory");
646         if (tevent_req_nomem(state->out_mem_ctx, req)) {
647                 return tevent_req_post(req, ev);
648         }
649
650         /* make a temporary copy, that we pass to the dispatch function */
651         state->tmp = state->orig;
652
653         subreq = cli->dispatch_send(state, ev, cli,
654                                     &ndr_table_wbint,
655                                     NDR_WBINT_SID2GID,
656                                     &state->tmp);
657         if (tevent_req_nomem(subreq, req)) {
658                 return tevent_req_post(req, ev);
659         }
660         tevent_req_set_callback(subreq, rpccli_wbint_Sid2Gid_done, req);
661         return req;
662 }
663
664 static void rpccli_wbint_Sid2Gid_done(struct tevent_req *subreq)
665 {
666         struct tevent_req *req = tevent_req_callback_data(
667                 subreq, struct tevent_req);
668         struct rpccli_wbint_Sid2Gid_state *state = tevent_req_data(
669                 req, struct rpccli_wbint_Sid2Gid_state);
670         NTSTATUS status;
671         TALLOC_CTX *mem_ctx;
672
673         if (state->out_mem_ctx) {
674                 mem_ctx = state->out_mem_ctx;
675         } else {
676                 mem_ctx = state;
677         }
678
679         status = state->dispatch_recv(subreq, mem_ctx);
680         TALLOC_FREE(subreq);
681         if (!NT_STATUS_IS_OK(status)) {
682                 tevent_req_nterror(req, status);
683                 return;
684         }
685
686         /* Copy out parameters */
687         *state->orig.out.gid = *state->tmp.out.gid;
688
689         /* Copy result */
690         state->orig.out.result = state->tmp.out.result;
691
692         /* Reset temporary structure */
693         ZERO_STRUCT(state->tmp);
694
695         tevent_req_done(req);
696 }
697
698 NTSTATUS rpccli_wbint_Sid2Gid_recv(struct tevent_req *req,
699                                    TALLOC_CTX *mem_ctx,
700                                    NTSTATUS *result)
701 {
702         struct rpccli_wbint_Sid2Gid_state *state = tevent_req_data(
703                 req, struct rpccli_wbint_Sid2Gid_state);
704         NTSTATUS status;
705
706         if (tevent_req_is_nterror(req, &status)) {
707                 tevent_req_received(req);
708                 return status;
709         }
710
711         /* Steal possbile out parameters to the callers context */
712         talloc_steal(mem_ctx, state->out_mem_ctx);
713
714         /* Return result */
715         *result = state->orig.out.result;
716
717         tevent_req_received(req);
718         return NT_STATUS_OK;
719 }
720
721 NTSTATUS rpccli_wbint_Sid2Gid(struct rpc_pipe_client *cli,
722                               TALLOC_CTX *mem_ctx,
723                               const char *dom_name /* [in] [unique,charset(UTF8)] */,
724                               struct dom_sid *sid /* [in] [ref] */,
725                               uint64_t *gid /* [out] [ref] */)
726 {
727         struct wbint_Sid2Gid r;
728         NTSTATUS status;
729
730         /* In parameters */
731         r.in.dom_name = dom_name;
732         r.in.sid = sid;
733
734         status = cli->dispatch(cli,
735                                 mem_ctx,
736                                 &ndr_table_wbint,
737                                 NDR_WBINT_SID2GID,
738                                 &r);
739
740         if (!NT_STATUS_IS_OK(status)) {
741                 return status;
742         }
743
744         if (NT_STATUS_IS_ERR(status)) {
745                 return status;
746         }
747
748         /* Return variables */
749         *gid = *r.out.gid;
750
751         /* Return result */
752         return r.out.result;
753 }
754
755 struct rpccli_wbint_Uid2Sid_state {
756         struct wbint_Uid2Sid orig;
757         struct wbint_Uid2Sid tmp;
758         TALLOC_CTX *out_mem_ctx;
759         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
760 };
761
762 static void rpccli_wbint_Uid2Sid_done(struct tevent_req *subreq);
763
764 struct tevent_req *rpccli_wbint_Uid2Sid_send(TALLOC_CTX *mem_ctx,
765                                              struct tevent_context *ev,
766                                              struct rpc_pipe_client *cli,
767                                              const char *_dom_name /* [in] [unique,charset(UTF8)] */,
768                                              uint64_t _uid /* [in]  */,
769                                              struct dom_sid *_sid /* [out] [ref] */)
770 {
771         struct tevent_req *req;
772         struct rpccli_wbint_Uid2Sid_state *state;
773         struct tevent_req *subreq;
774
775         req = tevent_req_create(mem_ctx, &state,
776                                 struct rpccli_wbint_Uid2Sid_state);
777         if (req == NULL) {
778                 return NULL;
779         }
780         state->out_mem_ctx = NULL;
781         state->dispatch_recv = cli->dispatch_recv;
782
783         /* In parameters */
784         state->orig.in.dom_name = _dom_name;
785         state->orig.in.uid = _uid;
786
787         /* Out parameters */
788         state->orig.out.sid = _sid;
789
790         /* Result */
791         ZERO_STRUCT(state->orig.out.result);
792
793         state->out_mem_ctx = talloc_named_const(state, 0,
794                              "rpccli_wbint_Uid2Sid_out_memory");
795         if (tevent_req_nomem(state->out_mem_ctx, req)) {
796                 return tevent_req_post(req, ev);
797         }
798
799         /* make a temporary copy, that we pass to the dispatch function */
800         state->tmp = state->orig;
801
802         subreq = cli->dispatch_send(state, ev, cli,
803                                     &ndr_table_wbint,
804                                     NDR_WBINT_UID2SID,
805                                     &state->tmp);
806         if (tevent_req_nomem(subreq, req)) {
807                 return tevent_req_post(req, ev);
808         }
809         tevent_req_set_callback(subreq, rpccli_wbint_Uid2Sid_done, req);
810         return req;
811 }
812
813 static void rpccli_wbint_Uid2Sid_done(struct tevent_req *subreq)
814 {
815         struct tevent_req *req = tevent_req_callback_data(
816                 subreq, struct tevent_req);
817         struct rpccli_wbint_Uid2Sid_state *state = tevent_req_data(
818                 req, struct rpccli_wbint_Uid2Sid_state);
819         NTSTATUS status;
820         TALLOC_CTX *mem_ctx;
821
822         if (state->out_mem_ctx) {
823                 mem_ctx = state->out_mem_ctx;
824         } else {
825                 mem_ctx = state;
826         }
827
828         status = state->dispatch_recv(subreq, mem_ctx);
829         TALLOC_FREE(subreq);
830         if (!NT_STATUS_IS_OK(status)) {
831                 tevent_req_nterror(req, status);
832                 return;
833         }
834
835         /* Copy out parameters */
836         *state->orig.out.sid = *state->tmp.out.sid;
837
838         /* Copy result */
839         state->orig.out.result = state->tmp.out.result;
840
841         /* Reset temporary structure */
842         ZERO_STRUCT(state->tmp);
843
844         tevent_req_done(req);
845 }
846
847 NTSTATUS rpccli_wbint_Uid2Sid_recv(struct tevent_req *req,
848                                    TALLOC_CTX *mem_ctx,
849                                    NTSTATUS *result)
850 {
851         struct rpccli_wbint_Uid2Sid_state *state = tevent_req_data(
852                 req, struct rpccli_wbint_Uid2Sid_state);
853         NTSTATUS status;
854
855         if (tevent_req_is_nterror(req, &status)) {
856                 tevent_req_received(req);
857                 return status;
858         }
859
860         /* Steal possbile out parameters to the callers context */
861         talloc_steal(mem_ctx, state->out_mem_ctx);
862
863         /* Return result */
864         *result = state->orig.out.result;
865
866         tevent_req_received(req);
867         return NT_STATUS_OK;
868 }
869
870 NTSTATUS rpccli_wbint_Uid2Sid(struct rpc_pipe_client *cli,
871                               TALLOC_CTX *mem_ctx,
872                               const char *dom_name /* [in] [unique,charset(UTF8)] */,
873                               uint64_t uid /* [in]  */,
874                               struct dom_sid *sid /* [out] [ref] */)
875 {
876         struct wbint_Uid2Sid r;
877         NTSTATUS status;
878
879         /* In parameters */
880         r.in.dom_name = dom_name;
881         r.in.uid = uid;
882
883         status = cli->dispatch(cli,
884                                 mem_ctx,
885                                 &ndr_table_wbint,
886                                 NDR_WBINT_UID2SID,
887                                 &r);
888
889         if (!NT_STATUS_IS_OK(status)) {
890                 return status;
891         }
892
893         if (NT_STATUS_IS_ERR(status)) {
894                 return status;
895         }
896
897         /* Return variables */
898         *sid = *r.out.sid;
899
900         /* Return result */
901         return r.out.result;
902 }
903
904 struct rpccli_wbint_Gid2Sid_state {
905         struct wbint_Gid2Sid orig;
906         struct wbint_Gid2Sid tmp;
907         TALLOC_CTX *out_mem_ctx;
908         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
909 };
910
911 static void rpccli_wbint_Gid2Sid_done(struct tevent_req *subreq);
912
913 struct tevent_req *rpccli_wbint_Gid2Sid_send(TALLOC_CTX *mem_ctx,
914                                              struct tevent_context *ev,
915                                              struct rpc_pipe_client *cli,
916                                              const char *_dom_name /* [in] [unique,charset(UTF8)] */,
917                                              uint64_t _gid /* [in]  */,
918                                              struct dom_sid *_sid /* [out] [ref] */)
919 {
920         struct tevent_req *req;
921         struct rpccli_wbint_Gid2Sid_state *state;
922         struct tevent_req *subreq;
923
924         req = tevent_req_create(mem_ctx, &state,
925                                 struct rpccli_wbint_Gid2Sid_state);
926         if (req == NULL) {
927                 return NULL;
928         }
929         state->out_mem_ctx = NULL;
930         state->dispatch_recv = cli->dispatch_recv;
931
932         /* In parameters */
933         state->orig.in.dom_name = _dom_name;
934         state->orig.in.gid = _gid;
935
936         /* Out parameters */
937         state->orig.out.sid = _sid;
938
939         /* Result */
940         ZERO_STRUCT(state->orig.out.result);
941
942         state->out_mem_ctx = talloc_named_const(state, 0,
943                              "rpccli_wbint_Gid2Sid_out_memory");
944         if (tevent_req_nomem(state->out_mem_ctx, req)) {
945                 return tevent_req_post(req, ev);
946         }
947
948         /* make a temporary copy, that we pass to the dispatch function */
949         state->tmp = state->orig;
950
951         subreq = cli->dispatch_send(state, ev, cli,
952                                     &ndr_table_wbint,
953                                     NDR_WBINT_GID2SID,
954                                     &state->tmp);
955         if (tevent_req_nomem(subreq, req)) {
956                 return tevent_req_post(req, ev);
957         }
958         tevent_req_set_callback(subreq, rpccli_wbint_Gid2Sid_done, req);
959         return req;
960 }
961
962 static void rpccli_wbint_Gid2Sid_done(struct tevent_req *subreq)
963 {
964         struct tevent_req *req = tevent_req_callback_data(
965                 subreq, struct tevent_req);
966         struct rpccli_wbint_Gid2Sid_state *state = tevent_req_data(
967                 req, struct rpccli_wbint_Gid2Sid_state);
968         NTSTATUS status;
969         TALLOC_CTX *mem_ctx;
970
971         if (state->out_mem_ctx) {
972                 mem_ctx = state->out_mem_ctx;
973         } else {
974                 mem_ctx = state;
975         }
976
977         status = state->dispatch_recv(subreq, mem_ctx);
978         TALLOC_FREE(subreq);
979         if (!NT_STATUS_IS_OK(status)) {
980                 tevent_req_nterror(req, status);
981                 return;
982         }
983
984         /* Copy out parameters */
985         *state->orig.out.sid = *state->tmp.out.sid;
986
987         /* Copy result */
988         state->orig.out.result = state->tmp.out.result;
989
990         /* Reset temporary structure */
991         ZERO_STRUCT(state->tmp);
992
993         tevent_req_done(req);
994 }
995
996 NTSTATUS rpccli_wbint_Gid2Sid_recv(struct tevent_req *req,
997                                    TALLOC_CTX *mem_ctx,
998                                    NTSTATUS *result)
999 {
1000         struct rpccli_wbint_Gid2Sid_state *state = tevent_req_data(
1001                 req, struct rpccli_wbint_Gid2Sid_state);
1002         NTSTATUS status;
1003
1004         if (tevent_req_is_nterror(req, &status)) {
1005                 tevent_req_received(req);
1006                 return status;
1007         }
1008
1009         /* Steal possbile out parameters to the callers context */
1010         talloc_steal(mem_ctx, state->out_mem_ctx);
1011
1012         /* Return result */
1013         *result = state->orig.out.result;
1014
1015         tevent_req_received(req);
1016         return NT_STATUS_OK;
1017 }
1018
1019 NTSTATUS rpccli_wbint_Gid2Sid(struct rpc_pipe_client *cli,
1020                               TALLOC_CTX *mem_ctx,
1021                               const char *dom_name /* [in] [unique,charset(UTF8)] */,
1022                               uint64_t gid /* [in]  */,
1023                               struct dom_sid *sid /* [out] [ref] */)
1024 {
1025         struct wbint_Gid2Sid r;
1026         NTSTATUS status;
1027
1028         /* In parameters */
1029         r.in.dom_name = dom_name;
1030         r.in.gid = gid;
1031
1032         status = cli->dispatch(cli,
1033                                 mem_ctx,
1034                                 &ndr_table_wbint,
1035                                 NDR_WBINT_GID2SID,
1036                                 &r);
1037
1038         if (!NT_STATUS_IS_OK(status)) {
1039                 return status;
1040         }
1041
1042         if (NT_STATUS_IS_ERR(status)) {
1043                 return status;
1044         }
1045
1046         /* Return variables */
1047         *sid = *r.out.sid;
1048
1049         /* Return result */
1050         return r.out.result;
1051 }
1052
1053 struct rpccli_wbint_AllocateUid_state {
1054         struct wbint_AllocateUid orig;
1055         struct wbint_AllocateUid tmp;
1056         TALLOC_CTX *out_mem_ctx;
1057         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1058 };
1059
1060 static void rpccli_wbint_AllocateUid_done(struct tevent_req *subreq);
1061
1062 struct tevent_req *rpccli_wbint_AllocateUid_send(TALLOC_CTX *mem_ctx,
1063                                                  struct tevent_context *ev,
1064                                                  struct rpc_pipe_client *cli,
1065                                                  uint64_t *_uid /* [out] [ref] */)
1066 {
1067         struct tevent_req *req;
1068         struct rpccli_wbint_AllocateUid_state *state;
1069         struct tevent_req *subreq;
1070
1071         req = tevent_req_create(mem_ctx, &state,
1072                                 struct rpccli_wbint_AllocateUid_state);
1073         if (req == NULL) {
1074                 return NULL;
1075         }
1076         state->out_mem_ctx = NULL;
1077         state->dispatch_recv = cli->dispatch_recv;
1078
1079         /* In parameters */
1080
1081         /* Out parameters */
1082         state->orig.out.uid = _uid;
1083
1084         /* Result */
1085         ZERO_STRUCT(state->orig.out.result);
1086
1087         state->out_mem_ctx = talloc_named_const(state, 0,
1088                              "rpccli_wbint_AllocateUid_out_memory");
1089         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1090                 return tevent_req_post(req, ev);
1091         }
1092
1093         /* make a temporary copy, that we pass to the dispatch function */
1094         state->tmp = state->orig;
1095
1096         subreq = cli->dispatch_send(state, ev, cli,
1097                                     &ndr_table_wbint,
1098                                     NDR_WBINT_ALLOCATEUID,
1099                                     &state->tmp);
1100         if (tevent_req_nomem(subreq, req)) {
1101                 return tevent_req_post(req, ev);
1102         }
1103         tevent_req_set_callback(subreq, rpccli_wbint_AllocateUid_done, req);
1104         return req;
1105 }
1106
1107 static void rpccli_wbint_AllocateUid_done(struct tevent_req *subreq)
1108 {
1109         struct tevent_req *req = tevent_req_callback_data(
1110                 subreq, struct tevent_req);
1111         struct rpccli_wbint_AllocateUid_state *state = tevent_req_data(
1112                 req, struct rpccli_wbint_AllocateUid_state);
1113         NTSTATUS status;
1114         TALLOC_CTX *mem_ctx;
1115
1116         if (state->out_mem_ctx) {
1117                 mem_ctx = state->out_mem_ctx;
1118         } else {
1119                 mem_ctx = state;
1120         }
1121
1122         status = state->dispatch_recv(subreq, mem_ctx);
1123         TALLOC_FREE(subreq);
1124         if (!NT_STATUS_IS_OK(status)) {
1125                 tevent_req_nterror(req, status);
1126                 return;
1127         }
1128
1129         /* Copy out parameters */
1130         *state->orig.out.uid = *state->tmp.out.uid;
1131
1132         /* Copy result */
1133         state->orig.out.result = state->tmp.out.result;
1134
1135         /* Reset temporary structure */
1136         ZERO_STRUCT(state->tmp);
1137
1138         tevent_req_done(req);
1139 }
1140
1141 NTSTATUS rpccli_wbint_AllocateUid_recv(struct tevent_req *req,
1142                                        TALLOC_CTX *mem_ctx,
1143                                        NTSTATUS *result)
1144 {
1145         struct rpccli_wbint_AllocateUid_state *state = tevent_req_data(
1146                 req, struct rpccli_wbint_AllocateUid_state);
1147         NTSTATUS status;
1148
1149         if (tevent_req_is_nterror(req, &status)) {
1150                 tevent_req_received(req);
1151                 return status;
1152         }
1153
1154         /* Steal possbile out parameters to the callers context */
1155         talloc_steal(mem_ctx, state->out_mem_ctx);
1156
1157         /* Return result */
1158         *result = state->orig.out.result;
1159
1160         tevent_req_received(req);
1161         return NT_STATUS_OK;
1162 }
1163
1164 NTSTATUS rpccli_wbint_AllocateUid(struct rpc_pipe_client *cli,
1165                                   TALLOC_CTX *mem_ctx,
1166                                   uint64_t *uid /* [out] [ref] */)
1167 {
1168         struct wbint_AllocateUid r;
1169         NTSTATUS status;
1170
1171         /* In parameters */
1172
1173         status = cli->dispatch(cli,
1174                                 mem_ctx,
1175                                 &ndr_table_wbint,
1176                                 NDR_WBINT_ALLOCATEUID,
1177                                 &r);
1178
1179         if (!NT_STATUS_IS_OK(status)) {
1180                 return status;
1181         }
1182
1183         if (NT_STATUS_IS_ERR(status)) {
1184                 return status;
1185         }
1186
1187         /* Return variables */
1188         *uid = *r.out.uid;
1189
1190         /* Return result */
1191         return r.out.result;
1192 }
1193
1194 struct rpccli_wbint_AllocateGid_state {
1195         struct wbint_AllocateGid orig;
1196         struct wbint_AllocateGid tmp;
1197         TALLOC_CTX *out_mem_ctx;
1198         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1199 };
1200
1201 static void rpccli_wbint_AllocateGid_done(struct tevent_req *subreq);
1202
1203 struct tevent_req *rpccli_wbint_AllocateGid_send(TALLOC_CTX *mem_ctx,
1204                                                  struct tevent_context *ev,
1205                                                  struct rpc_pipe_client *cli,
1206                                                  uint64_t *_gid /* [out] [ref] */)
1207 {
1208         struct tevent_req *req;
1209         struct rpccli_wbint_AllocateGid_state *state;
1210         struct tevent_req *subreq;
1211
1212         req = tevent_req_create(mem_ctx, &state,
1213                                 struct rpccli_wbint_AllocateGid_state);
1214         if (req == NULL) {
1215                 return NULL;
1216         }
1217         state->out_mem_ctx = NULL;
1218         state->dispatch_recv = cli->dispatch_recv;
1219
1220         /* In parameters */
1221
1222         /* Out parameters */
1223         state->orig.out.gid = _gid;
1224
1225         /* Result */
1226         ZERO_STRUCT(state->orig.out.result);
1227
1228         state->out_mem_ctx = talloc_named_const(state, 0,
1229                              "rpccli_wbint_AllocateGid_out_memory");
1230         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1231                 return tevent_req_post(req, ev);
1232         }
1233
1234         /* make a temporary copy, that we pass to the dispatch function */
1235         state->tmp = state->orig;
1236
1237         subreq = cli->dispatch_send(state, ev, cli,
1238                                     &ndr_table_wbint,
1239                                     NDR_WBINT_ALLOCATEGID,
1240                                     &state->tmp);
1241         if (tevent_req_nomem(subreq, req)) {
1242                 return tevent_req_post(req, ev);
1243         }
1244         tevent_req_set_callback(subreq, rpccli_wbint_AllocateGid_done, req);
1245         return req;
1246 }
1247
1248 static void rpccli_wbint_AllocateGid_done(struct tevent_req *subreq)
1249 {
1250         struct tevent_req *req = tevent_req_callback_data(
1251                 subreq, struct tevent_req);
1252         struct rpccli_wbint_AllocateGid_state *state = tevent_req_data(
1253                 req, struct rpccli_wbint_AllocateGid_state);
1254         NTSTATUS status;
1255         TALLOC_CTX *mem_ctx;
1256
1257         if (state->out_mem_ctx) {
1258                 mem_ctx = state->out_mem_ctx;
1259         } else {
1260                 mem_ctx = state;
1261         }
1262
1263         status = state->dispatch_recv(subreq, mem_ctx);
1264         TALLOC_FREE(subreq);
1265         if (!NT_STATUS_IS_OK(status)) {
1266                 tevent_req_nterror(req, status);
1267                 return;
1268         }
1269
1270         /* Copy out parameters */
1271         *state->orig.out.gid = *state->tmp.out.gid;
1272
1273         /* Copy result */
1274         state->orig.out.result = state->tmp.out.result;
1275
1276         /* Reset temporary structure */
1277         ZERO_STRUCT(state->tmp);
1278
1279         tevent_req_done(req);
1280 }
1281
1282 NTSTATUS rpccli_wbint_AllocateGid_recv(struct tevent_req *req,
1283                                        TALLOC_CTX *mem_ctx,
1284                                        NTSTATUS *result)
1285 {
1286         struct rpccli_wbint_AllocateGid_state *state = tevent_req_data(
1287                 req, struct rpccli_wbint_AllocateGid_state);
1288         NTSTATUS status;
1289
1290         if (tevent_req_is_nterror(req, &status)) {
1291                 tevent_req_received(req);
1292                 return status;
1293         }
1294
1295         /* Steal possbile out parameters to the callers context */
1296         talloc_steal(mem_ctx, state->out_mem_ctx);
1297
1298         /* Return result */
1299         *result = state->orig.out.result;
1300
1301         tevent_req_received(req);
1302         return NT_STATUS_OK;
1303 }
1304
1305 NTSTATUS rpccli_wbint_AllocateGid(struct rpc_pipe_client *cli,
1306                                   TALLOC_CTX *mem_ctx,
1307                                   uint64_t *gid /* [out] [ref] */)
1308 {
1309         struct wbint_AllocateGid r;
1310         NTSTATUS status;
1311
1312         /* In parameters */
1313
1314         status = cli->dispatch(cli,
1315                                 mem_ctx,
1316                                 &ndr_table_wbint,
1317                                 NDR_WBINT_ALLOCATEGID,
1318                                 &r);
1319
1320         if (!NT_STATUS_IS_OK(status)) {
1321                 return status;
1322         }
1323
1324         if (NT_STATUS_IS_ERR(status)) {
1325                 return status;
1326         }
1327
1328         /* Return variables */
1329         *gid = *r.out.gid;
1330
1331         /* Return result */
1332         return r.out.result;
1333 }
1334
1335 struct rpccli_wbint_QueryUser_state {
1336         struct wbint_QueryUser orig;
1337         struct wbint_QueryUser tmp;
1338         TALLOC_CTX *out_mem_ctx;
1339         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1340 };
1341
1342 static void rpccli_wbint_QueryUser_done(struct tevent_req *subreq);
1343
1344 struct tevent_req *rpccli_wbint_QueryUser_send(TALLOC_CTX *mem_ctx,
1345                                                struct tevent_context *ev,
1346                                                struct rpc_pipe_client *cli,
1347                                                struct dom_sid *_sid /* [in] [ref] */,
1348                                                struct wbint_userinfo *_info /* [out] [ref] */)
1349 {
1350         struct tevent_req *req;
1351         struct rpccli_wbint_QueryUser_state *state;
1352         struct tevent_req *subreq;
1353
1354         req = tevent_req_create(mem_ctx, &state,
1355                                 struct rpccli_wbint_QueryUser_state);
1356         if (req == NULL) {
1357                 return NULL;
1358         }
1359         state->out_mem_ctx = NULL;
1360         state->dispatch_recv = cli->dispatch_recv;
1361
1362         /* In parameters */
1363         state->orig.in.sid = _sid;
1364
1365         /* Out parameters */
1366         state->orig.out.info = _info;
1367
1368         /* Result */
1369         ZERO_STRUCT(state->orig.out.result);
1370
1371         state->out_mem_ctx = talloc_named_const(state, 0,
1372                              "rpccli_wbint_QueryUser_out_memory");
1373         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1374                 return tevent_req_post(req, ev);
1375         }
1376
1377         /* make a temporary copy, that we pass to the dispatch function */
1378         state->tmp = state->orig;
1379
1380         subreq = cli->dispatch_send(state, ev, cli,
1381                                     &ndr_table_wbint,
1382                                     NDR_WBINT_QUERYUSER,
1383                                     &state->tmp);
1384         if (tevent_req_nomem(subreq, req)) {
1385                 return tevent_req_post(req, ev);
1386         }
1387         tevent_req_set_callback(subreq, rpccli_wbint_QueryUser_done, req);
1388         return req;
1389 }
1390
1391 static void rpccli_wbint_QueryUser_done(struct tevent_req *subreq)
1392 {
1393         struct tevent_req *req = tevent_req_callback_data(
1394                 subreq, struct tevent_req);
1395         struct rpccli_wbint_QueryUser_state *state = tevent_req_data(
1396                 req, struct rpccli_wbint_QueryUser_state);
1397         NTSTATUS status;
1398         TALLOC_CTX *mem_ctx;
1399
1400         if (state->out_mem_ctx) {
1401                 mem_ctx = state->out_mem_ctx;
1402         } else {
1403                 mem_ctx = state;
1404         }
1405
1406         status = state->dispatch_recv(subreq, mem_ctx);
1407         TALLOC_FREE(subreq);
1408         if (!NT_STATUS_IS_OK(status)) {
1409                 tevent_req_nterror(req, status);
1410                 return;
1411         }
1412
1413         /* Copy out parameters */
1414         *state->orig.out.info = *state->tmp.out.info;
1415
1416         /* Copy result */
1417         state->orig.out.result = state->tmp.out.result;
1418
1419         /* Reset temporary structure */
1420         ZERO_STRUCT(state->tmp);
1421
1422         tevent_req_done(req);
1423 }
1424
1425 NTSTATUS rpccli_wbint_QueryUser_recv(struct tevent_req *req,
1426                                      TALLOC_CTX *mem_ctx,
1427                                      NTSTATUS *result)
1428 {
1429         struct rpccli_wbint_QueryUser_state *state = tevent_req_data(
1430                 req, struct rpccli_wbint_QueryUser_state);
1431         NTSTATUS status;
1432
1433         if (tevent_req_is_nterror(req, &status)) {
1434                 tevent_req_received(req);
1435                 return status;
1436         }
1437
1438         /* Steal possbile out parameters to the callers context */
1439         talloc_steal(mem_ctx, state->out_mem_ctx);
1440
1441         /* Return result */
1442         *result = state->orig.out.result;
1443
1444         tevent_req_received(req);
1445         return NT_STATUS_OK;
1446 }
1447
1448 NTSTATUS rpccli_wbint_QueryUser(struct rpc_pipe_client *cli,
1449                                 TALLOC_CTX *mem_ctx,
1450                                 struct dom_sid *sid /* [in] [ref] */,
1451                                 struct wbint_userinfo *info /* [out] [ref] */)
1452 {
1453         struct wbint_QueryUser r;
1454         NTSTATUS status;
1455
1456         /* In parameters */
1457         r.in.sid = sid;
1458
1459         status = cli->dispatch(cli,
1460                                 mem_ctx,
1461                                 &ndr_table_wbint,
1462                                 NDR_WBINT_QUERYUSER,
1463                                 &r);
1464
1465         if (!NT_STATUS_IS_OK(status)) {
1466                 return status;
1467         }
1468
1469         if (NT_STATUS_IS_ERR(status)) {
1470                 return status;
1471         }
1472
1473         /* Return variables */
1474         *info = *r.out.info;
1475
1476         /* Return result */
1477         return r.out.result;
1478 }
1479
1480 struct rpccli_wbint_LookupUserAliases_state {
1481         struct wbint_LookupUserAliases orig;
1482         struct wbint_LookupUserAliases tmp;
1483         TALLOC_CTX *out_mem_ctx;
1484         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1485 };
1486
1487 static void rpccli_wbint_LookupUserAliases_done(struct tevent_req *subreq);
1488
1489 struct tevent_req *rpccli_wbint_LookupUserAliases_send(TALLOC_CTX *mem_ctx,
1490                                                        struct tevent_context *ev,
1491                                                        struct rpc_pipe_client *cli,
1492                                                        struct wbint_SidArray *_sids /* [in] [ref] */,
1493                                                        struct wbint_RidArray *_rids /* [out] [ref] */)
1494 {
1495         struct tevent_req *req;
1496         struct rpccli_wbint_LookupUserAliases_state *state;
1497         struct tevent_req *subreq;
1498
1499         req = tevent_req_create(mem_ctx, &state,
1500                                 struct rpccli_wbint_LookupUserAliases_state);
1501         if (req == NULL) {
1502                 return NULL;
1503         }
1504         state->out_mem_ctx = NULL;
1505         state->dispatch_recv = cli->dispatch_recv;
1506
1507         /* In parameters */
1508         state->orig.in.sids = _sids;
1509
1510         /* Out parameters */
1511         state->orig.out.rids = _rids;
1512
1513         /* Result */
1514         ZERO_STRUCT(state->orig.out.result);
1515
1516         state->out_mem_ctx = talloc_named_const(state, 0,
1517                              "rpccli_wbint_LookupUserAliases_out_memory");
1518         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1519                 return tevent_req_post(req, ev);
1520         }
1521
1522         /* make a temporary copy, that we pass to the dispatch function */
1523         state->tmp = state->orig;
1524
1525         subreq = cli->dispatch_send(state, ev, cli,
1526                                     &ndr_table_wbint,
1527                                     NDR_WBINT_LOOKUPUSERALIASES,
1528                                     &state->tmp);
1529         if (tevent_req_nomem(subreq, req)) {
1530                 return tevent_req_post(req, ev);
1531         }
1532         tevent_req_set_callback(subreq, rpccli_wbint_LookupUserAliases_done, req);
1533         return req;
1534 }
1535
1536 static void rpccli_wbint_LookupUserAliases_done(struct tevent_req *subreq)
1537 {
1538         struct tevent_req *req = tevent_req_callback_data(
1539                 subreq, struct tevent_req);
1540         struct rpccli_wbint_LookupUserAliases_state *state = tevent_req_data(
1541                 req, struct rpccli_wbint_LookupUserAliases_state);
1542         NTSTATUS status;
1543         TALLOC_CTX *mem_ctx;
1544
1545         if (state->out_mem_ctx) {
1546                 mem_ctx = state->out_mem_ctx;
1547         } else {
1548                 mem_ctx = state;
1549         }
1550
1551         status = state->dispatch_recv(subreq, mem_ctx);
1552         TALLOC_FREE(subreq);
1553         if (!NT_STATUS_IS_OK(status)) {
1554                 tevent_req_nterror(req, status);
1555                 return;
1556         }
1557
1558         /* Copy out parameters */
1559         *state->orig.out.rids = *state->tmp.out.rids;
1560
1561         /* Copy result */
1562         state->orig.out.result = state->tmp.out.result;
1563
1564         /* Reset temporary structure */
1565         ZERO_STRUCT(state->tmp);
1566
1567         tevent_req_done(req);
1568 }
1569
1570 NTSTATUS rpccli_wbint_LookupUserAliases_recv(struct tevent_req *req,
1571                                              TALLOC_CTX *mem_ctx,
1572                                              NTSTATUS *result)
1573 {
1574         struct rpccli_wbint_LookupUserAliases_state *state = tevent_req_data(
1575                 req, struct rpccli_wbint_LookupUserAliases_state);
1576         NTSTATUS status;
1577
1578         if (tevent_req_is_nterror(req, &status)) {
1579                 tevent_req_received(req);
1580                 return status;
1581         }
1582
1583         /* Steal possbile out parameters to the callers context */
1584         talloc_steal(mem_ctx, state->out_mem_ctx);
1585
1586         /* Return result */
1587         *result = state->orig.out.result;
1588
1589         tevent_req_received(req);
1590         return NT_STATUS_OK;
1591 }
1592
1593 NTSTATUS rpccli_wbint_LookupUserAliases(struct rpc_pipe_client *cli,
1594                                         TALLOC_CTX *mem_ctx,
1595                                         struct wbint_SidArray *sids /* [in] [ref] */,
1596                                         struct wbint_RidArray *rids /* [out] [ref] */)
1597 {
1598         struct wbint_LookupUserAliases r;
1599         NTSTATUS status;
1600
1601         /* In parameters */
1602         r.in.sids = sids;
1603
1604         status = cli->dispatch(cli,
1605                                 mem_ctx,
1606                                 &ndr_table_wbint,
1607                                 NDR_WBINT_LOOKUPUSERALIASES,
1608                                 &r);
1609
1610         if (!NT_STATUS_IS_OK(status)) {
1611                 return status;
1612         }
1613
1614         if (NT_STATUS_IS_ERR(status)) {
1615                 return status;
1616         }
1617
1618         /* Return variables */
1619         *rids = *r.out.rids;
1620
1621         /* Return result */
1622         return r.out.result;
1623 }
1624
1625 struct rpccli_wbint_LookupUserGroups_state {
1626         struct wbint_LookupUserGroups orig;
1627         struct wbint_LookupUserGroups tmp;
1628         TALLOC_CTX *out_mem_ctx;
1629         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1630 };
1631
1632 static void rpccli_wbint_LookupUserGroups_done(struct tevent_req *subreq);
1633
1634 struct tevent_req *rpccli_wbint_LookupUserGroups_send(TALLOC_CTX *mem_ctx,
1635                                                       struct tevent_context *ev,
1636                                                       struct rpc_pipe_client *cli,
1637                                                       struct dom_sid *_sid /* [in] [ref] */,
1638                                                       struct wbint_SidArray *_sids /* [out] [ref] */)
1639 {
1640         struct tevent_req *req;
1641         struct rpccli_wbint_LookupUserGroups_state *state;
1642         struct tevent_req *subreq;
1643
1644         req = tevent_req_create(mem_ctx, &state,
1645                                 struct rpccli_wbint_LookupUserGroups_state);
1646         if (req == NULL) {
1647                 return NULL;
1648         }
1649         state->out_mem_ctx = NULL;
1650         state->dispatch_recv = cli->dispatch_recv;
1651
1652         /* In parameters */
1653         state->orig.in.sid = _sid;
1654
1655         /* Out parameters */
1656         state->orig.out.sids = _sids;
1657
1658         /* Result */
1659         ZERO_STRUCT(state->orig.out.result);
1660
1661         state->out_mem_ctx = talloc_named_const(state, 0,
1662                              "rpccli_wbint_LookupUserGroups_out_memory");
1663         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1664                 return tevent_req_post(req, ev);
1665         }
1666
1667         /* make a temporary copy, that we pass to the dispatch function */
1668         state->tmp = state->orig;
1669
1670         subreq = cli->dispatch_send(state, ev, cli,
1671                                     &ndr_table_wbint,
1672                                     NDR_WBINT_LOOKUPUSERGROUPS,
1673                                     &state->tmp);
1674         if (tevent_req_nomem(subreq, req)) {
1675                 return tevent_req_post(req, ev);
1676         }
1677         tevent_req_set_callback(subreq, rpccli_wbint_LookupUserGroups_done, req);
1678         return req;
1679 }
1680
1681 static void rpccli_wbint_LookupUserGroups_done(struct tevent_req *subreq)
1682 {
1683         struct tevent_req *req = tevent_req_callback_data(
1684                 subreq, struct tevent_req);
1685         struct rpccli_wbint_LookupUserGroups_state *state = tevent_req_data(
1686                 req, struct rpccli_wbint_LookupUserGroups_state);
1687         NTSTATUS status;
1688         TALLOC_CTX *mem_ctx;
1689
1690         if (state->out_mem_ctx) {
1691                 mem_ctx = state->out_mem_ctx;
1692         } else {
1693                 mem_ctx = state;
1694         }
1695
1696         status = state->dispatch_recv(subreq, mem_ctx);
1697         TALLOC_FREE(subreq);
1698         if (!NT_STATUS_IS_OK(status)) {
1699                 tevent_req_nterror(req, status);
1700                 return;
1701         }
1702
1703         /* Copy out parameters */
1704         *state->orig.out.sids = *state->tmp.out.sids;
1705
1706         /* Copy result */
1707         state->orig.out.result = state->tmp.out.result;
1708
1709         /* Reset temporary structure */
1710         ZERO_STRUCT(state->tmp);
1711
1712         tevent_req_done(req);
1713 }
1714
1715 NTSTATUS rpccli_wbint_LookupUserGroups_recv(struct tevent_req *req,
1716                                             TALLOC_CTX *mem_ctx,
1717                                             NTSTATUS *result)
1718 {
1719         struct rpccli_wbint_LookupUserGroups_state *state = tevent_req_data(
1720                 req, struct rpccli_wbint_LookupUserGroups_state);
1721         NTSTATUS status;
1722
1723         if (tevent_req_is_nterror(req, &status)) {
1724                 tevent_req_received(req);
1725                 return status;
1726         }
1727
1728         /* Steal possbile out parameters to the callers context */
1729         talloc_steal(mem_ctx, state->out_mem_ctx);
1730
1731         /* Return result */
1732         *result = state->orig.out.result;
1733
1734         tevent_req_received(req);
1735         return NT_STATUS_OK;
1736 }
1737
1738 NTSTATUS rpccli_wbint_LookupUserGroups(struct rpc_pipe_client *cli,
1739                                        TALLOC_CTX *mem_ctx,
1740                                        struct dom_sid *sid /* [in] [ref] */,
1741                                        struct wbint_SidArray *sids /* [out] [ref] */)
1742 {
1743         struct wbint_LookupUserGroups r;
1744         NTSTATUS status;
1745
1746         /* In parameters */
1747         r.in.sid = sid;
1748
1749         status = cli->dispatch(cli,
1750                                 mem_ctx,
1751                                 &ndr_table_wbint,
1752                                 NDR_WBINT_LOOKUPUSERGROUPS,
1753                                 &r);
1754
1755         if (!NT_STATUS_IS_OK(status)) {
1756                 return status;
1757         }
1758
1759         if (NT_STATUS_IS_ERR(status)) {
1760                 return status;
1761         }
1762
1763         /* Return variables */
1764         *sids = *r.out.sids;
1765
1766         /* Return result */
1767         return r.out.result;
1768 }
1769
1770 struct rpccli_wbint_QuerySequenceNumber_state {
1771         struct wbint_QuerySequenceNumber orig;
1772         struct wbint_QuerySequenceNumber tmp;
1773         TALLOC_CTX *out_mem_ctx;
1774         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1775 };
1776
1777 static void rpccli_wbint_QuerySequenceNumber_done(struct tevent_req *subreq);
1778
1779 struct tevent_req *rpccli_wbint_QuerySequenceNumber_send(TALLOC_CTX *mem_ctx,
1780                                                          struct tevent_context *ev,
1781                                                          struct rpc_pipe_client *cli,
1782                                                          uint32_t *_sequence /* [out] [ref] */)
1783 {
1784         struct tevent_req *req;
1785         struct rpccli_wbint_QuerySequenceNumber_state *state;
1786         struct tevent_req *subreq;
1787
1788         req = tevent_req_create(mem_ctx, &state,
1789                                 struct rpccli_wbint_QuerySequenceNumber_state);
1790         if (req == NULL) {
1791                 return NULL;
1792         }
1793         state->out_mem_ctx = NULL;
1794         state->dispatch_recv = cli->dispatch_recv;
1795
1796         /* In parameters */
1797
1798         /* Out parameters */
1799         state->orig.out.sequence = _sequence;
1800
1801         /* Result */
1802         ZERO_STRUCT(state->orig.out.result);
1803
1804         state->out_mem_ctx = talloc_named_const(state, 0,
1805                              "rpccli_wbint_QuerySequenceNumber_out_memory");
1806         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1807                 return tevent_req_post(req, ev);
1808         }
1809
1810         /* make a temporary copy, that we pass to the dispatch function */
1811         state->tmp = state->orig;
1812
1813         subreq = cli->dispatch_send(state, ev, cli,
1814                                     &ndr_table_wbint,
1815                                     NDR_WBINT_QUERYSEQUENCENUMBER,
1816                                     &state->tmp);
1817         if (tevent_req_nomem(subreq, req)) {
1818                 return tevent_req_post(req, ev);
1819         }
1820         tevent_req_set_callback(subreq, rpccli_wbint_QuerySequenceNumber_done, req);
1821         return req;
1822 }
1823
1824 static void rpccli_wbint_QuerySequenceNumber_done(struct tevent_req *subreq)
1825 {
1826         struct tevent_req *req = tevent_req_callback_data(
1827                 subreq, struct tevent_req);
1828         struct rpccli_wbint_QuerySequenceNumber_state *state = tevent_req_data(
1829                 req, struct rpccli_wbint_QuerySequenceNumber_state);
1830         NTSTATUS status;
1831         TALLOC_CTX *mem_ctx;
1832
1833         if (state->out_mem_ctx) {
1834                 mem_ctx = state->out_mem_ctx;
1835         } else {
1836                 mem_ctx = state;
1837         }
1838
1839         status = state->dispatch_recv(subreq, mem_ctx);
1840         TALLOC_FREE(subreq);
1841         if (!NT_STATUS_IS_OK(status)) {
1842                 tevent_req_nterror(req, status);
1843                 return;
1844         }
1845
1846         /* Copy out parameters */
1847         *state->orig.out.sequence = *state->tmp.out.sequence;
1848
1849         /* Copy result */
1850         state->orig.out.result = state->tmp.out.result;
1851
1852         /* Reset temporary structure */
1853         ZERO_STRUCT(state->tmp);
1854
1855         tevent_req_done(req);
1856 }
1857
1858 NTSTATUS rpccli_wbint_QuerySequenceNumber_recv(struct tevent_req *req,
1859                                                TALLOC_CTX *mem_ctx,
1860                                                NTSTATUS *result)
1861 {
1862         struct rpccli_wbint_QuerySequenceNumber_state *state = tevent_req_data(
1863                 req, struct rpccli_wbint_QuerySequenceNumber_state);
1864         NTSTATUS status;
1865
1866         if (tevent_req_is_nterror(req, &status)) {
1867                 tevent_req_received(req);
1868                 return status;
1869         }
1870
1871         /* Steal possbile out parameters to the callers context */
1872         talloc_steal(mem_ctx, state->out_mem_ctx);
1873
1874         /* Return result */
1875         *result = state->orig.out.result;
1876
1877         tevent_req_received(req);
1878         return NT_STATUS_OK;
1879 }
1880
1881 NTSTATUS rpccli_wbint_QuerySequenceNumber(struct rpc_pipe_client *cli,
1882                                           TALLOC_CTX *mem_ctx,
1883                                           uint32_t *sequence /* [out] [ref] */)
1884 {
1885         struct wbint_QuerySequenceNumber r;
1886         NTSTATUS status;
1887
1888         /* In parameters */
1889
1890         status = cli->dispatch(cli,
1891                                 mem_ctx,
1892                                 &ndr_table_wbint,
1893                                 NDR_WBINT_QUERYSEQUENCENUMBER,
1894                                 &r);
1895
1896         if (!NT_STATUS_IS_OK(status)) {
1897                 return status;
1898         }
1899
1900         if (NT_STATUS_IS_ERR(status)) {
1901                 return status;
1902         }
1903
1904         /* Return variables */
1905         *sequence = *r.out.sequence;
1906
1907         /* Return result */
1908         return r.out.result;
1909 }
1910
1911 struct rpccli_wbint_LookupGroupMembers_state {
1912         struct wbint_LookupGroupMembers orig;
1913         struct wbint_LookupGroupMembers tmp;
1914         TALLOC_CTX *out_mem_ctx;
1915         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1916 };
1917
1918 static void rpccli_wbint_LookupGroupMembers_done(struct tevent_req *subreq);
1919
1920 struct tevent_req *rpccli_wbint_LookupGroupMembers_send(TALLOC_CTX *mem_ctx,
1921                                                         struct tevent_context *ev,
1922                                                         struct rpc_pipe_client *cli,
1923                                                         struct dom_sid *_sid /* [in] [ref] */,
1924                                                         enum lsa_SidType _type /* [in]  */,
1925                                                         struct wbint_Principals *_members /* [out] [ref] */)
1926 {
1927         struct tevent_req *req;
1928         struct rpccli_wbint_LookupGroupMembers_state *state;
1929         struct tevent_req *subreq;
1930
1931         req = tevent_req_create(mem_ctx, &state,
1932                                 struct rpccli_wbint_LookupGroupMembers_state);
1933         if (req == NULL) {
1934                 return NULL;
1935         }
1936         state->out_mem_ctx = NULL;
1937         state->dispatch_recv = cli->dispatch_recv;
1938
1939         /* In parameters */
1940         state->orig.in.sid = _sid;
1941         state->orig.in.type = _type;
1942
1943         /* Out parameters */
1944         state->orig.out.members = _members;
1945
1946         /* Result */
1947         ZERO_STRUCT(state->orig.out.result);
1948
1949         state->out_mem_ctx = talloc_named_const(state, 0,
1950                              "rpccli_wbint_LookupGroupMembers_out_memory");
1951         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1952                 return tevent_req_post(req, ev);
1953         }
1954
1955         /* make a temporary copy, that we pass to the dispatch function */
1956         state->tmp = state->orig;
1957
1958         subreq = cli->dispatch_send(state, ev, cli,
1959                                     &ndr_table_wbint,
1960                                     NDR_WBINT_LOOKUPGROUPMEMBERS,
1961                                     &state->tmp);
1962         if (tevent_req_nomem(subreq, req)) {
1963                 return tevent_req_post(req, ev);
1964         }
1965         tevent_req_set_callback(subreq, rpccli_wbint_LookupGroupMembers_done, req);
1966         return req;
1967 }
1968
1969 static void rpccli_wbint_LookupGroupMembers_done(struct tevent_req *subreq)
1970 {
1971         struct tevent_req *req = tevent_req_callback_data(
1972                 subreq, struct tevent_req);
1973         struct rpccli_wbint_LookupGroupMembers_state *state = tevent_req_data(
1974                 req, struct rpccli_wbint_LookupGroupMembers_state);
1975         NTSTATUS status;
1976         TALLOC_CTX *mem_ctx;
1977
1978         if (state->out_mem_ctx) {
1979                 mem_ctx = state->out_mem_ctx;
1980         } else {
1981                 mem_ctx = state;
1982         }
1983
1984         status = state->dispatch_recv(subreq, mem_ctx);
1985         TALLOC_FREE(subreq);
1986         if (!NT_STATUS_IS_OK(status)) {
1987                 tevent_req_nterror(req, status);
1988                 return;
1989         }
1990
1991         /* Copy out parameters */
1992         *state->orig.out.members = *state->tmp.out.members;
1993
1994         /* Copy result */
1995         state->orig.out.result = state->tmp.out.result;
1996
1997         /* Reset temporary structure */
1998         ZERO_STRUCT(state->tmp);
1999
2000         tevent_req_done(req);
2001 }
2002
2003 NTSTATUS rpccli_wbint_LookupGroupMembers_recv(struct tevent_req *req,
2004                                               TALLOC_CTX *mem_ctx,
2005                                               NTSTATUS *result)
2006 {
2007         struct rpccli_wbint_LookupGroupMembers_state *state = tevent_req_data(
2008                 req, struct rpccli_wbint_LookupGroupMembers_state);
2009         NTSTATUS status;
2010
2011         if (tevent_req_is_nterror(req, &status)) {
2012                 tevent_req_received(req);
2013                 return status;
2014         }
2015
2016         /* Steal possbile out parameters to the callers context */
2017         talloc_steal(mem_ctx, state->out_mem_ctx);
2018
2019         /* Return result */
2020         *result = state->orig.out.result;
2021
2022         tevent_req_received(req);
2023         return NT_STATUS_OK;
2024 }
2025
2026 NTSTATUS rpccli_wbint_LookupGroupMembers(struct rpc_pipe_client *cli,
2027                                          TALLOC_CTX *mem_ctx,
2028                                          struct dom_sid *sid /* [in] [ref] */,
2029                                          enum lsa_SidType type /* [in]  */,
2030                                          struct wbint_Principals *members /* [out] [ref] */)
2031 {
2032         struct wbint_LookupGroupMembers r;
2033         NTSTATUS status;
2034
2035         /* In parameters */
2036         r.in.sid = sid;
2037         r.in.type = type;
2038
2039         status = cli->dispatch(cli,
2040                                 mem_ctx,
2041                                 &ndr_table_wbint,
2042                                 NDR_WBINT_LOOKUPGROUPMEMBERS,
2043                                 &r);
2044
2045         if (!NT_STATUS_IS_OK(status)) {
2046                 return status;
2047         }
2048
2049         if (NT_STATUS_IS_ERR(status)) {
2050                 return status;
2051         }
2052
2053         /* Return variables */
2054         *members = *r.out.members;
2055
2056         /* Return result */
2057         return r.out.result;
2058 }
2059
2060 struct rpccli_wbint_QueryUserList_state {
2061         struct wbint_QueryUserList orig;
2062         struct wbint_QueryUserList tmp;
2063         TALLOC_CTX *out_mem_ctx;
2064         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2065 };
2066
2067 static void rpccli_wbint_QueryUserList_done(struct tevent_req *subreq);
2068
2069 struct tevent_req *rpccli_wbint_QueryUserList_send(TALLOC_CTX *mem_ctx,
2070                                                    struct tevent_context *ev,
2071                                                    struct rpc_pipe_client *cli,
2072                                                    struct wbint_userinfos *_users /* [out] [ref] */)
2073 {
2074         struct tevent_req *req;
2075         struct rpccli_wbint_QueryUserList_state *state;
2076         struct tevent_req *subreq;
2077
2078         req = tevent_req_create(mem_ctx, &state,
2079                                 struct rpccli_wbint_QueryUserList_state);
2080         if (req == NULL) {
2081                 return NULL;
2082         }
2083         state->out_mem_ctx = NULL;
2084         state->dispatch_recv = cli->dispatch_recv;
2085
2086         /* In parameters */
2087
2088         /* Out parameters */
2089         state->orig.out.users = _users;
2090
2091         /* Result */
2092         ZERO_STRUCT(state->orig.out.result);
2093
2094         state->out_mem_ctx = talloc_named_const(state, 0,
2095                              "rpccli_wbint_QueryUserList_out_memory");
2096         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2097                 return tevent_req_post(req, ev);
2098         }
2099
2100         /* make a temporary copy, that we pass to the dispatch function */
2101         state->tmp = state->orig;
2102
2103         subreq = cli->dispatch_send(state, ev, cli,
2104                                     &ndr_table_wbint,
2105                                     NDR_WBINT_QUERYUSERLIST,
2106                                     &state->tmp);
2107         if (tevent_req_nomem(subreq, req)) {
2108                 return tevent_req_post(req, ev);
2109         }
2110         tevent_req_set_callback(subreq, rpccli_wbint_QueryUserList_done, req);
2111         return req;
2112 }
2113
2114 static void rpccli_wbint_QueryUserList_done(struct tevent_req *subreq)
2115 {
2116         struct tevent_req *req = tevent_req_callback_data(
2117                 subreq, struct tevent_req);
2118         struct rpccli_wbint_QueryUserList_state *state = tevent_req_data(
2119                 req, struct rpccli_wbint_QueryUserList_state);
2120         NTSTATUS status;
2121         TALLOC_CTX *mem_ctx;
2122
2123         if (state->out_mem_ctx) {
2124                 mem_ctx = state->out_mem_ctx;
2125         } else {
2126                 mem_ctx = state;
2127         }
2128
2129         status = state->dispatch_recv(subreq, mem_ctx);
2130         TALLOC_FREE(subreq);
2131         if (!NT_STATUS_IS_OK(status)) {
2132                 tevent_req_nterror(req, status);
2133                 return;
2134         }
2135
2136         /* Copy out parameters */
2137         *state->orig.out.users = *state->tmp.out.users;
2138
2139         /* Copy result */
2140         state->orig.out.result = state->tmp.out.result;
2141
2142         /* Reset temporary structure */
2143         ZERO_STRUCT(state->tmp);
2144
2145         tevent_req_done(req);
2146 }
2147
2148 NTSTATUS rpccli_wbint_QueryUserList_recv(struct tevent_req *req,
2149                                          TALLOC_CTX *mem_ctx,
2150                                          NTSTATUS *result)
2151 {
2152         struct rpccli_wbint_QueryUserList_state *state = tevent_req_data(
2153                 req, struct rpccli_wbint_QueryUserList_state);
2154         NTSTATUS status;
2155
2156         if (tevent_req_is_nterror(req, &status)) {
2157                 tevent_req_received(req);
2158                 return status;
2159         }
2160
2161         /* Steal possbile out parameters to the callers context */
2162         talloc_steal(mem_ctx, state->out_mem_ctx);
2163
2164         /* Return result */
2165         *result = state->orig.out.result;
2166
2167         tevent_req_received(req);
2168         return NT_STATUS_OK;
2169 }
2170
2171 NTSTATUS rpccli_wbint_QueryUserList(struct rpc_pipe_client *cli,
2172                                     TALLOC_CTX *mem_ctx,
2173                                     struct wbint_userinfos *users /* [out] [ref] */)
2174 {
2175         struct wbint_QueryUserList r;
2176         NTSTATUS status;
2177
2178         /* In parameters */
2179
2180         status = cli->dispatch(cli,
2181                                 mem_ctx,
2182                                 &ndr_table_wbint,
2183                                 NDR_WBINT_QUERYUSERLIST,
2184                                 &r);
2185
2186         if (!NT_STATUS_IS_OK(status)) {
2187                 return status;
2188         }
2189
2190         if (NT_STATUS_IS_ERR(status)) {
2191                 return status;
2192         }
2193
2194         /* Return variables */
2195         *users = *r.out.users;
2196
2197         /* Return result */
2198         return r.out.result;
2199 }
2200
2201 struct rpccli_wbint_QueryGroupList_state {
2202         struct wbint_QueryGroupList orig;
2203         struct wbint_QueryGroupList tmp;
2204         TALLOC_CTX *out_mem_ctx;
2205         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2206 };
2207
2208 static void rpccli_wbint_QueryGroupList_done(struct tevent_req *subreq);
2209
2210 struct tevent_req *rpccli_wbint_QueryGroupList_send(TALLOC_CTX *mem_ctx,
2211                                                     struct tevent_context *ev,
2212                                                     struct rpc_pipe_client *cli,
2213                                                     struct wbint_Principals *_groups /* [out] [ref] */)
2214 {
2215         struct tevent_req *req;
2216         struct rpccli_wbint_QueryGroupList_state *state;
2217         struct tevent_req *subreq;
2218
2219         req = tevent_req_create(mem_ctx, &state,
2220                                 struct rpccli_wbint_QueryGroupList_state);
2221         if (req == NULL) {
2222                 return NULL;
2223         }
2224         state->out_mem_ctx = NULL;
2225         state->dispatch_recv = cli->dispatch_recv;
2226
2227         /* In parameters */
2228
2229         /* Out parameters */
2230         state->orig.out.groups = _groups;
2231
2232         /* Result */
2233         ZERO_STRUCT(state->orig.out.result);
2234
2235         state->out_mem_ctx = talloc_named_const(state, 0,
2236                              "rpccli_wbint_QueryGroupList_out_memory");
2237         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2238                 return tevent_req_post(req, ev);
2239         }
2240
2241         /* make a temporary copy, that we pass to the dispatch function */
2242         state->tmp = state->orig;
2243
2244         subreq = cli->dispatch_send(state, ev, cli,
2245                                     &ndr_table_wbint,
2246                                     NDR_WBINT_QUERYGROUPLIST,
2247                                     &state->tmp);
2248         if (tevent_req_nomem(subreq, req)) {
2249                 return tevent_req_post(req, ev);
2250         }
2251         tevent_req_set_callback(subreq, rpccli_wbint_QueryGroupList_done, req);
2252         return req;
2253 }
2254
2255 static void rpccli_wbint_QueryGroupList_done(struct tevent_req *subreq)
2256 {
2257         struct tevent_req *req = tevent_req_callback_data(
2258                 subreq, struct tevent_req);
2259         struct rpccli_wbint_QueryGroupList_state *state = tevent_req_data(
2260                 req, struct rpccli_wbint_QueryGroupList_state);
2261         NTSTATUS status;
2262         TALLOC_CTX *mem_ctx;
2263
2264         if (state->out_mem_ctx) {
2265                 mem_ctx = state->out_mem_ctx;
2266         } else {
2267                 mem_ctx = state;
2268         }
2269
2270         status = state->dispatch_recv(subreq, mem_ctx);
2271         TALLOC_FREE(subreq);
2272         if (!NT_STATUS_IS_OK(status)) {
2273                 tevent_req_nterror(req, status);
2274                 return;
2275         }
2276
2277         /* Copy out parameters */
2278         *state->orig.out.groups = *state->tmp.out.groups;
2279
2280         /* Copy result */
2281         state->orig.out.result = state->tmp.out.result;
2282
2283         /* Reset temporary structure */
2284         ZERO_STRUCT(state->tmp);
2285
2286         tevent_req_done(req);
2287 }
2288
2289 NTSTATUS rpccli_wbint_QueryGroupList_recv(struct tevent_req *req,
2290                                           TALLOC_CTX *mem_ctx,
2291                                           NTSTATUS *result)
2292 {
2293         struct rpccli_wbint_QueryGroupList_state *state = tevent_req_data(
2294                 req, struct rpccli_wbint_QueryGroupList_state);
2295         NTSTATUS status;
2296
2297         if (tevent_req_is_nterror(req, &status)) {
2298                 tevent_req_received(req);
2299                 return status;
2300         }
2301
2302         /* Steal possbile out parameters to the callers context */
2303         talloc_steal(mem_ctx, state->out_mem_ctx);
2304
2305         /* Return result */
2306         *result = state->orig.out.result;
2307
2308         tevent_req_received(req);
2309         return NT_STATUS_OK;
2310 }
2311
2312 NTSTATUS rpccli_wbint_QueryGroupList(struct rpc_pipe_client *cli,
2313                                      TALLOC_CTX *mem_ctx,
2314                                      struct wbint_Principals *groups /* [out] [ref] */)
2315 {
2316         struct wbint_QueryGroupList r;
2317         NTSTATUS status;
2318
2319         /* In parameters */
2320
2321         status = cli->dispatch(cli,
2322                                 mem_ctx,
2323                                 &ndr_table_wbint,
2324                                 NDR_WBINT_QUERYGROUPLIST,
2325                                 &r);
2326
2327         if (!NT_STATUS_IS_OK(status)) {
2328                 return status;
2329         }
2330
2331         if (NT_STATUS_IS_ERR(status)) {
2332                 return status;
2333         }
2334
2335         /* Return variables */
2336         *groups = *r.out.groups;
2337
2338         /* Return result */
2339         return r.out.result;
2340 }
2341
2342 struct rpccli_wbint_DsGetDcName_state {
2343         struct wbint_DsGetDcName orig;
2344         struct wbint_DsGetDcName tmp;
2345         TALLOC_CTX *out_mem_ctx;
2346         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2347 };
2348
2349 static void rpccli_wbint_DsGetDcName_done(struct tevent_req *subreq);
2350
2351 struct tevent_req *rpccli_wbint_DsGetDcName_send(TALLOC_CTX *mem_ctx,
2352                                                  struct tevent_context *ev,
2353                                                  struct rpc_pipe_client *cli,
2354                                                  const char *_domain_name /* [in] [ref,charset(UTF8)] */,
2355                                                  struct GUID *_domain_guid /* [in] [unique] */,
2356                                                  const char *_site_name /* [in] [unique,charset(UTF8)] */,
2357                                                  uint32_t _flags /* [in]  */,
2358                                                  struct netr_DsRGetDCNameInfo **_dc_info /* [out] [ref] */)
2359 {
2360         struct tevent_req *req;
2361         struct rpccli_wbint_DsGetDcName_state *state;
2362         struct tevent_req *subreq;
2363
2364         req = tevent_req_create(mem_ctx, &state,
2365                                 struct rpccli_wbint_DsGetDcName_state);
2366         if (req == NULL) {
2367                 return NULL;
2368         }
2369         state->out_mem_ctx = NULL;
2370         state->dispatch_recv = cli->dispatch_recv;
2371
2372         /* In parameters */
2373         state->orig.in.domain_name = _domain_name;
2374         state->orig.in.domain_guid = _domain_guid;
2375         state->orig.in.site_name = _site_name;
2376         state->orig.in.flags = _flags;
2377
2378         /* Out parameters */
2379         state->orig.out.dc_info = _dc_info;
2380
2381         /* Result */
2382         ZERO_STRUCT(state->orig.out.result);
2383
2384         state->out_mem_ctx = talloc_named_const(state, 0,
2385                              "rpccli_wbint_DsGetDcName_out_memory");
2386         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2387                 return tevent_req_post(req, ev);
2388         }
2389
2390         /* make a temporary copy, that we pass to the dispatch function */
2391         state->tmp = state->orig;
2392
2393         subreq = cli->dispatch_send(state, ev, cli,
2394                                     &ndr_table_wbint,
2395                                     NDR_WBINT_DSGETDCNAME,
2396                                     &state->tmp);
2397         if (tevent_req_nomem(subreq, req)) {
2398                 return tevent_req_post(req, ev);
2399         }
2400         tevent_req_set_callback(subreq, rpccli_wbint_DsGetDcName_done, req);
2401         return req;
2402 }
2403
2404 static void rpccli_wbint_DsGetDcName_done(struct tevent_req *subreq)
2405 {
2406         struct tevent_req *req = tevent_req_callback_data(
2407                 subreq, struct tevent_req);
2408         struct rpccli_wbint_DsGetDcName_state *state = tevent_req_data(
2409                 req, struct rpccli_wbint_DsGetDcName_state);
2410         NTSTATUS status;
2411         TALLOC_CTX *mem_ctx;
2412
2413         if (state->out_mem_ctx) {
2414                 mem_ctx = state->out_mem_ctx;
2415         } else {
2416                 mem_ctx = state;
2417         }
2418
2419         status = state->dispatch_recv(subreq, mem_ctx);
2420         TALLOC_FREE(subreq);
2421         if (!NT_STATUS_IS_OK(status)) {
2422                 tevent_req_nterror(req, status);
2423                 return;
2424         }
2425
2426         /* Copy out parameters */
2427         *state->orig.out.dc_info = *state->tmp.out.dc_info;
2428
2429         /* Copy result */
2430         state->orig.out.result = state->tmp.out.result;
2431
2432         /* Reset temporary structure */
2433         ZERO_STRUCT(state->tmp);
2434
2435         tevent_req_done(req);
2436 }
2437
2438 NTSTATUS rpccli_wbint_DsGetDcName_recv(struct tevent_req *req,
2439                                        TALLOC_CTX *mem_ctx,
2440                                        NTSTATUS *result)
2441 {
2442         struct rpccli_wbint_DsGetDcName_state *state = tevent_req_data(
2443                 req, struct rpccli_wbint_DsGetDcName_state);
2444         NTSTATUS status;
2445
2446         if (tevent_req_is_nterror(req, &status)) {
2447                 tevent_req_received(req);
2448                 return status;
2449         }
2450
2451         /* Steal possbile out parameters to the callers context */
2452         talloc_steal(mem_ctx, state->out_mem_ctx);
2453
2454         /* Return result */
2455         *result = state->orig.out.result;
2456
2457         tevent_req_received(req);
2458         return NT_STATUS_OK;
2459 }
2460
2461 NTSTATUS rpccli_wbint_DsGetDcName(struct rpc_pipe_client *cli,
2462                                   TALLOC_CTX *mem_ctx,
2463                                   const char *domain_name /* [in] [ref,charset(UTF8)] */,
2464                                   struct GUID *domain_guid /* [in] [unique] */,
2465                                   const char *site_name /* [in] [unique,charset(UTF8)] */,
2466                                   uint32_t flags /* [in]  */,
2467                                   struct netr_DsRGetDCNameInfo **dc_info /* [out] [ref] */)
2468 {
2469         struct wbint_DsGetDcName r;
2470         NTSTATUS status;
2471
2472         /* In parameters */
2473         r.in.domain_name = domain_name;
2474         r.in.domain_guid = domain_guid;
2475         r.in.site_name = site_name;
2476         r.in.flags = flags;
2477
2478         status = cli->dispatch(cli,
2479                                 mem_ctx,
2480                                 &ndr_table_wbint,
2481                                 NDR_WBINT_DSGETDCNAME,
2482                                 &r);
2483
2484         if (!NT_STATUS_IS_OK(status)) {
2485                 return status;
2486         }
2487
2488         if (NT_STATUS_IS_ERR(status)) {
2489                 return status;
2490         }
2491
2492         /* Return variables */
2493         *dc_info = *r.out.dc_info;
2494
2495         /* Return result */
2496         return r.out.result;
2497 }
2498
2499 struct rpccli_wbint_LookupRids_state {
2500         struct wbint_LookupRids orig;
2501         struct wbint_LookupRids tmp;
2502         TALLOC_CTX *out_mem_ctx;
2503         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2504 };
2505
2506 static void rpccli_wbint_LookupRids_done(struct tevent_req *subreq);
2507
2508 struct tevent_req *rpccli_wbint_LookupRids_send(TALLOC_CTX *mem_ctx,
2509                                                 struct tevent_context *ev,
2510                                                 struct rpc_pipe_client *cli,
2511                                                 struct wbint_RidArray *_rids /* [in] [ref] */,
2512                                                 struct wbint_Principals *_names /* [out] [ref] */)
2513 {
2514         struct tevent_req *req;
2515         struct rpccli_wbint_LookupRids_state *state;
2516         struct tevent_req *subreq;
2517
2518         req = tevent_req_create(mem_ctx, &state,
2519                                 struct rpccli_wbint_LookupRids_state);
2520         if (req == NULL) {
2521                 return NULL;
2522         }
2523         state->out_mem_ctx = NULL;
2524         state->dispatch_recv = cli->dispatch_recv;
2525
2526         /* In parameters */
2527         state->orig.in.rids = _rids;
2528
2529         /* Out parameters */
2530         state->orig.out.names = _names;
2531
2532         /* Result */
2533         ZERO_STRUCT(state->orig.out.result);
2534
2535         state->out_mem_ctx = talloc_named_const(state, 0,
2536                              "rpccli_wbint_LookupRids_out_memory");
2537         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2538                 return tevent_req_post(req, ev);
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_wbint,
2546                                     NDR_WBINT_LOOKUPRIDS,
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_wbint_LookupRids_done, req);
2552         return req;
2553 }
2554
2555 static void rpccli_wbint_LookupRids_done(struct tevent_req *subreq)
2556 {
2557         struct tevent_req *req = tevent_req_callback_data(
2558                 subreq, struct tevent_req);
2559         struct rpccli_wbint_LookupRids_state *state = tevent_req_data(
2560                 req, struct rpccli_wbint_LookupRids_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         *state->orig.out.names = *state->tmp.out.names;
2579
2580         /* Copy result */
2581         state->orig.out.result = state->tmp.out.result;
2582
2583         /* Reset temporary structure */
2584         ZERO_STRUCT(state->tmp);
2585
2586         tevent_req_done(req);
2587 }
2588
2589 NTSTATUS rpccli_wbint_LookupRids_recv(struct tevent_req *req,
2590                                       TALLOC_CTX *mem_ctx,
2591                                       NTSTATUS *result)
2592 {
2593         struct rpccli_wbint_LookupRids_state *state = tevent_req_data(
2594                 req, struct rpccli_wbint_LookupRids_state);
2595         NTSTATUS status;
2596
2597         if (tevent_req_is_nterror(req, &status)) {
2598                 tevent_req_received(req);
2599                 return status;
2600         }
2601
2602         /* Steal possbile out parameters to the callers context */
2603         talloc_steal(mem_ctx, state->out_mem_ctx);
2604
2605         /* Return result */
2606         *result = state->orig.out.result;
2607
2608         tevent_req_received(req);
2609         return NT_STATUS_OK;
2610 }
2611
2612 NTSTATUS rpccli_wbint_LookupRids(struct rpc_pipe_client *cli,
2613                                  TALLOC_CTX *mem_ctx,
2614                                  struct wbint_RidArray *rids /* [in] [ref] */,
2615                                  struct wbint_Principals *names /* [out] [ref] */)
2616 {
2617         struct wbint_LookupRids r;
2618         NTSTATUS status;
2619
2620         /* In parameters */
2621         r.in.rids = rids;
2622
2623         status = cli->dispatch(cli,
2624                                 mem_ctx,
2625                                 &ndr_table_wbint,
2626                                 NDR_WBINT_LOOKUPRIDS,
2627                                 &r);
2628
2629         if (!NT_STATUS_IS_OK(status)) {
2630                 return status;
2631         }
2632
2633         if (NT_STATUS_IS_ERR(status)) {
2634                 return status;
2635         }
2636
2637         /* Return variables */
2638         *names = *r.out.names;
2639
2640         /* Return result */
2641         return r.out.result;
2642 }
2643
2644 struct rpccli_wbint_CheckMachineAccount_state {
2645         struct wbint_CheckMachineAccount orig;
2646         struct wbint_CheckMachineAccount tmp;
2647         TALLOC_CTX *out_mem_ctx;
2648         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2649 };
2650
2651 static void rpccli_wbint_CheckMachineAccount_done(struct tevent_req *subreq);
2652
2653 struct tevent_req *rpccli_wbint_CheckMachineAccount_send(TALLOC_CTX *mem_ctx,
2654                                                          struct tevent_context *ev,
2655                                                          struct rpc_pipe_client *cli)
2656 {
2657         struct tevent_req *req;
2658         struct rpccli_wbint_CheckMachineAccount_state *state;
2659         struct tevent_req *subreq;
2660
2661         req = tevent_req_create(mem_ctx, &state,
2662                                 struct rpccli_wbint_CheckMachineAccount_state);
2663         if (req == NULL) {
2664                 return NULL;
2665         }
2666         state->out_mem_ctx = NULL;
2667         state->dispatch_recv = cli->dispatch_recv;
2668
2669         /* In parameters */
2670
2671         /* Out parameters */
2672
2673         /* Result */
2674         ZERO_STRUCT(state->orig.out.result);
2675
2676         /* make a temporary copy, that we pass to the dispatch function */
2677         state->tmp = state->orig;
2678
2679         subreq = cli->dispatch_send(state, ev, cli,
2680                                     &ndr_table_wbint,
2681                                     NDR_WBINT_CHECKMACHINEACCOUNT,
2682                                     &state->tmp);
2683         if (tevent_req_nomem(subreq, req)) {
2684                 return tevent_req_post(req, ev);
2685         }
2686         tevent_req_set_callback(subreq, rpccli_wbint_CheckMachineAccount_done, req);
2687         return req;
2688 }
2689
2690 static void rpccli_wbint_CheckMachineAccount_done(struct tevent_req *subreq)
2691 {
2692         struct tevent_req *req = tevent_req_callback_data(
2693                 subreq, struct tevent_req);
2694         struct rpccli_wbint_CheckMachineAccount_state *state = tevent_req_data(
2695                 req, struct rpccli_wbint_CheckMachineAccount_state);
2696         NTSTATUS status;
2697         TALLOC_CTX *mem_ctx;
2698
2699         if (state->out_mem_ctx) {
2700                 mem_ctx = state->out_mem_ctx;
2701         } else {
2702                 mem_ctx = state;
2703         }
2704
2705         status = state->dispatch_recv(subreq, mem_ctx);
2706         TALLOC_FREE(subreq);
2707         if (!NT_STATUS_IS_OK(status)) {
2708                 tevent_req_nterror(req, status);
2709                 return;
2710         }
2711
2712         /* Copy out parameters */
2713
2714         /* Copy result */
2715         state->orig.out.result = state->tmp.out.result;
2716
2717         /* Reset temporary structure */
2718         ZERO_STRUCT(state->tmp);
2719
2720         tevent_req_done(req);
2721 }
2722
2723 NTSTATUS rpccli_wbint_CheckMachineAccount_recv(struct tevent_req *req,
2724                                                TALLOC_CTX *mem_ctx,
2725                                                NTSTATUS *result)
2726 {
2727         struct rpccli_wbint_CheckMachineAccount_state *state = tevent_req_data(
2728                 req, struct rpccli_wbint_CheckMachineAccount_state);
2729         NTSTATUS status;
2730
2731         if (tevent_req_is_nterror(req, &status)) {
2732                 tevent_req_received(req);
2733                 return status;
2734         }
2735
2736         /* Steal possbile out parameters to the callers context */
2737         talloc_steal(mem_ctx, state->out_mem_ctx);
2738
2739         /* Return result */
2740         *result = state->orig.out.result;
2741
2742         tevent_req_received(req);
2743         return NT_STATUS_OK;
2744 }
2745
2746 NTSTATUS rpccli_wbint_CheckMachineAccount(struct rpc_pipe_client *cli,
2747                                           TALLOC_CTX *mem_ctx)
2748 {
2749         struct wbint_CheckMachineAccount r;
2750         NTSTATUS status;
2751
2752         /* In parameters */
2753
2754         status = cli->dispatch(cli,
2755                                 mem_ctx,
2756                                 &ndr_table_wbint,
2757                                 NDR_WBINT_CHECKMACHINEACCOUNT,
2758                                 &r);
2759
2760         if (!NT_STATUS_IS_OK(status)) {
2761                 return status;
2762         }
2763
2764         if (NT_STATUS_IS_ERR(status)) {
2765                 return status;
2766         }
2767
2768         /* Return variables */
2769
2770         /* Return result */
2771         return r.out.result;
2772 }
2773
2774 struct rpccli_wbint_ChangeMachineAccount_state {
2775         struct wbint_ChangeMachineAccount orig;
2776         struct wbint_ChangeMachineAccount tmp;
2777         TALLOC_CTX *out_mem_ctx;
2778         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2779 };
2780
2781 static void rpccli_wbint_ChangeMachineAccount_done(struct tevent_req *subreq);
2782
2783 struct tevent_req *rpccli_wbint_ChangeMachineAccount_send(TALLOC_CTX *mem_ctx,
2784                                                           struct tevent_context *ev,
2785                                                           struct rpc_pipe_client *cli)
2786 {
2787         struct tevent_req *req;
2788         struct rpccli_wbint_ChangeMachineAccount_state *state;
2789         struct tevent_req *subreq;
2790
2791         req = tevent_req_create(mem_ctx, &state,
2792                                 struct rpccli_wbint_ChangeMachineAccount_state);
2793         if (req == NULL) {
2794                 return NULL;
2795         }
2796         state->out_mem_ctx = NULL;
2797         state->dispatch_recv = cli->dispatch_recv;
2798
2799         /* In parameters */
2800
2801         /* Out parameters */
2802
2803         /* Result */
2804         ZERO_STRUCT(state->orig.out.result);
2805
2806         /* make a temporary copy, that we pass to the dispatch function */
2807         state->tmp = state->orig;
2808
2809         subreq = cli->dispatch_send(state, ev, cli,
2810                                     &ndr_table_wbint,
2811                                     NDR_WBINT_CHANGEMACHINEACCOUNT,
2812                                     &state->tmp);
2813         if (tevent_req_nomem(subreq, req)) {
2814                 return tevent_req_post(req, ev);
2815         }
2816         tevent_req_set_callback(subreq, rpccli_wbint_ChangeMachineAccount_done, req);
2817         return req;
2818 }
2819
2820 static void rpccli_wbint_ChangeMachineAccount_done(struct tevent_req *subreq)
2821 {
2822         struct tevent_req *req = tevent_req_callback_data(
2823                 subreq, struct tevent_req);
2824         struct rpccli_wbint_ChangeMachineAccount_state *state = tevent_req_data(
2825                 req, struct rpccli_wbint_ChangeMachineAccount_state);
2826         NTSTATUS status;
2827         TALLOC_CTX *mem_ctx;
2828
2829         if (state->out_mem_ctx) {
2830                 mem_ctx = state->out_mem_ctx;
2831         } else {
2832                 mem_ctx = state;
2833         }
2834
2835         status = state->dispatch_recv(subreq, mem_ctx);
2836         TALLOC_FREE(subreq);
2837         if (!NT_STATUS_IS_OK(status)) {
2838                 tevent_req_nterror(req, status);
2839                 return;
2840         }
2841
2842         /* Copy out parameters */
2843
2844         /* Copy result */
2845         state->orig.out.result = state->tmp.out.result;
2846
2847         /* Reset temporary structure */
2848         ZERO_STRUCT(state->tmp);
2849
2850         tevent_req_done(req);
2851 }
2852
2853 NTSTATUS rpccli_wbint_ChangeMachineAccount_recv(struct tevent_req *req,
2854                                                 TALLOC_CTX *mem_ctx,
2855                                                 NTSTATUS *result)
2856 {
2857         struct rpccli_wbint_ChangeMachineAccount_state *state = tevent_req_data(
2858                 req, struct rpccli_wbint_ChangeMachineAccount_state);
2859         NTSTATUS status;
2860
2861         if (tevent_req_is_nterror(req, &status)) {
2862                 tevent_req_received(req);
2863                 return status;
2864         }
2865
2866         /* Steal possbile out parameters to the callers context */
2867         talloc_steal(mem_ctx, state->out_mem_ctx);
2868
2869         /* Return result */
2870         *result = state->orig.out.result;
2871
2872         tevent_req_received(req);
2873         return NT_STATUS_OK;
2874 }
2875
2876 NTSTATUS rpccli_wbint_ChangeMachineAccount(struct rpc_pipe_client *cli,
2877                                            TALLOC_CTX *mem_ctx)
2878 {
2879         struct wbint_ChangeMachineAccount r;
2880         NTSTATUS status;
2881
2882         /* In parameters */
2883
2884         status = cli->dispatch(cli,
2885                                 mem_ctx,
2886                                 &ndr_table_wbint,
2887                                 NDR_WBINT_CHANGEMACHINEACCOUNT,
2888                                 &r);
2889
2890         if (!NT_STATUS_IS_OK(status)) {
2891                 return status;
2892         }
2893
2894         if (NT_STATUS_IS_ERR(status)) {
2895                 return status;
2896         }
2897
2898         /* Return variables */
2899
2900         /* Return result */
2901         return r.out.result;
2902 }
2903
2904 struct rpccli_wbint_SetMapping_state {
2905         struct wbint_SetMapping orig;
2906         struct wbint_SetMapping tmp;
2907         TALLOC_CTX *out_mem_ctx;
2908         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2909 };
2910
2911 static void rpccli_wbint_SetMapping_done(struct tevent_req *subreq);
2912
2913 struct tevent_req *rpccli_wbint_SetMapping_send(TALLOC_CTX *mem_ctx,
2914                                                 struct tevent_context *ev,
2915                                                 struct rpc_pipe_client *cli,
2916                                                 struct dom_sid *_sid /* [in] [ref] */,
2917                                                 enum wbint_IdType _type /* [in]  */,
2918                                                 uint64_t _id /* [in]  */)
2919 {
2920         struct tevent_req *req;
2921         struct rpccli_wbint_SetMapping_state *state;
2922         struct tevent_req *subreq;
2923
2924         req = tevent_req_create(mem_ctx, &state,
2925                                 struct rpccli_wbint_SetMapping_state);
2926         if (req == NULL) {
2927                 return NULL;
2928         }
2929         state->out_mem_ctx = NULL;
2930         state->dispatch_recv = cli->dispatch_recv;
2931
2932         /* In parameters */
2933         state->orig.in.sid = _sid;
2934         state->orig.in.type = _type;
2935         state->orig.in.id = _id;
2936
2937         /* Out parameters */
2938
2939         /* Result */
2940         ZERO_STRUCT(state->orig.out.result);
2941
2942         /* make a temporary copy, that we pass to the dispatch function */
2943         state->tmp = state->orig;
2944
2945         subreq = cli->dispatch_send(state, ev, cli,
2946                                     &ndr_table_wbint,
2947                                     NDR_WBINT_SETMAPPING,
2948                                     &state->tmp);
2949         if (tevent_req_nomem(subreq, req)) {
2950                 return tevent_req_post(req, ev);
2951         }
2952         tevent_req_set_callback(subreq, rpccli_wbint_SetMapping_done, req);
2953         return req;
2954 }
2955
2956 static void rpccli_wbint_SetMapping_done(struct tevent_req *subreq)
2957 {
2958         struct tevent_req *req = tevent_req_callback_data(
2959                 subreq, struct tevent_req);
2960         struct rpccli_wbint_SetMapping_state *state = tevent_req_data(
2961                 req, struct rpccli_wbint_SetMapping_state);
2962         NTSTATUS status;
2963         TALLOC_CTX *mem_ctx;
2964
2965         if (state->out_mem_ctx) {
2966                 mem_ctx = state->out_mem_ctx;
2967         } else {
2968                 mem_ctx = state;
2969         }
2970
2971         status = state->dispatch_recv(subreq, mem_ctx);
2972         TALLOC_FREE(subreq);
2973         if (!NT_STATUS_IS_OK(status)) {
2974                 tevent_req_nterror(req, status);
2975                 return;
2976         }
2977
2978         /* Copy out parameters */
2979
2980         /* Copy result */
2981         state->orig.out.result = state->tmp.out.result;
2982
2983         /* Reset temporary structure */
2984         ZERO_STRUCT(state->tmp);
2985
2986         tevent_req_done(req);
2987 }
2988
2989 NTSTATUS rpccli_wbint_SetMapping_recv(struct tevent_req *req,
2990                                       TALLOC_CTX *mem_ctx,
2991                                       NTSTATUS *result)
2992 {
2993         struct rpccli_wbint_SetMapping_state *state = tevent_req_data(
2994                 req, struct rpccli_wbint_SetMapping_state);
2995         NTSTATUS status;
2996
2997         if (tevent_req_is_nterror(req, &status)) {
2998                 tevent_req_received(req);
2999                 return status;
3000         }
3001
3002         /* Steal possbile out parameters to the callers context */
3003         talloc_steal(mem_ctx, state->out_mem_ctx);
3004
3005         /* Return result */
3006         *result = state->orig.out.result;
3007
3008         tevent_req_received(req);
3009         return NT_STATUS_OK;
3010 }
3011
3012 NTSTATUS rpccli_wbint_SetMapping(struct rpc_pipe_client *cli,
3013                                  TALLOC_CTX *mem_ctx,
3014                                  struct dom_sid *sid /* [in] [ref] */,
3015                                  enum wbint_IdType type /* [in]  */,
3016                                  uint64_t id /* [in]  */)
3017 {
3018         struct wbint_SetMapping r;
3019         NTSTATUS status;
3020
3021         /* In parameters */
3022         r.in.sid = sid;
3023         r.in.type = type;
3024         r.in.id = id;
3025
3026         status = cli->dispatch(cli,
3027                                 mem_ctx,
3028                                 &ndr_table_wbint,
3029                                 NDR_WBINT_SETMAPPING,
3030                                 &r);
3031
3032         if (!NT_STATUS_IS_OK(status)) {
3033                 return status;
3034         }
3035
3036         if (NT_STATUS_IS_ERR(status)) {
3037                 return status;
3038         }
3039
3040         /* Return variables */
3041
3042         /* Return result */
3043         return r.out.result;
3044 }
3045
3046 struct rpccli_wbint_RemoveMapping_state {
3047         struct wbint_RemoveMapping orig;
3048         struct wbint_RemoveMapping tmp;
3049         TALLOC_CTX *out_mem_ctx;
3050         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3051 };
3052
3053 static void rpccli_wbint_RemoveMapping_done(struct tevent_req *subreq);
3054
3055 struct tevent_req *rpccli_wbint_RemoveMapping_send(TALLOC_CTX *mem_ctx,
3056                                                    struct tevent_context *ev,
3057                                                    struct rpc_pipe_client *cli,
3058                                                    struct dom_sid *_sid /* [in] [ref] */,
3059                                                    enum wbint_IdType _type /* [in]  */,
3060                                                    uint64_t _id /* [in]  */)
3061 {
3062         struct tevent_req *req;
3063         struct rpccli_wbint_RemoveMapping_state *state;
3064         struct tevent_req *subreq;
3065
3066         req = tevent_req_create(mem_ctx, &state,
3067                                 struct rpccli_wbint_RemoveMapping_state);
3068         if (req == NULL) {
3069                 return NULL;
3070         }
3071         state->out_mem_ctx = NULL;
3072         state->dispatch_recv = cli->dispatch_recv;
3073
3074         /* In parameters */
3075         state->orig.in.sid = _sid;
3076         state->orig.in.type = _type;
3077         state->orig.in.id = _id;
3078
3079         /* Out parameters */
3080
3081         /* Result */
3082         ZERO_STRUCT(state->orig.out.result);
3083
3084         /* make a temporary copy, that we pass to the dispatch function */
3085         state->tmp = state->orig;
3086
3087         subreq = cli->dispatch_send(state, ev, cli,
3088                                     &ndr_table_wbint,
3089                                     NDR_WBINT_REMOVEMAPPING,
3090                                     &state->tmp);
3091         if (tevent_req_nomem(subreq, req)) {
3092                 return tevent_req_post(req, ev);
3093         }
3094         tevent_req_set_callback(subreq, rpccli_wbint_RemoveMapping_done, req);
3095         return req;
3096 }
3097
3098 static void rpccli_wbint_RemoveMapping_done(struct tevent_req *subreq)
3099 {
3100         struct tevent_req *req = tevent_req_callback_data(
3101                 subreq, struct tevent_req);
3102         struct rpccli_wbint_RemoveMapping_state *state = tevent_req_data(
3103                 req, struct rpccli_wbint_RemoveMapping_state);
3104         NTSTATUS status;
3105         TALLOC_CTX *mem_ctx;
3106
3107         if (state->out_mem_ctx) {
3108                 mem_ctx = state->out_mem_ctx;
3109         } else {
3110                 mem_ctx = state;
3111         }
3112
3113         status = state->dispatch_recv(subreq, mem_ctx);
3114         TALLOC_FREE(subreq);
3115         if (!NT_STATUS_IS_OK(status)) {
3116                 tevent_req_nterror(req, status);
3117                 return;
3118         }
3119
3120         /* Copy out parameters */
3121
3122         /* Copy result */
3123         state->orig.out.result = state->tmp.out.result;
3124
3125         /* Reset temporary structure */
3126         ZERO_STRUCT(state->tmp);
3127
3128         tevent_req_done(req);
3129 }
3130
3131 NTSTATUS rpccli_wbint_RemoveMapping_recv(struct tevent_req *req,
3132                                          TALLOC_CTX *mem_ctx,
3133                                          NTSTATUS *result)
3134 {
3135         struct rpccli_wbint_RemoveMapping_state *state = tevent_req_data(
3136                 req, struct rpccli_wbint_RemoveMapping_state);
3137         NTSTATUS status;
3138
3139         if (tevent_req_is_nterror(req, &status)) {
3140                 tevent_req_received(req);
3141                 return status;
3142         }
3143
3144         /* Steal possbile out parameters to the callers context */
3145         talloc_steal(mem_ctx, state->out_mem_ctx);
3146
3147         /* Return result */
3148         *result = state->orig.out.result;
3149
3150         tevent_req_received(req);
3151         return NT_STATUS_OK;
3152 }
3153
3154 NTSTATUS rpccli_wbint_RemoveMapping(struct rpc_pipe_client *cli,
3155                                     TALLOC_CTX *mem_ctx,
3156                                     struct dom_sid *sid /* [in] [ref] */,
3157                                     enum wbint_IdType type /* [in]  */,
3158                                     uint64_t id /* [in]  */)
3159 {
3160         struct wbint_RemoveMapping r;
3161         NTSTATUS status;
3162
3163         /* In parameters */
3164         r.in.sid = sid;
3165         r.in.type = type;
3166         r.in.id = id;
3167
3168         status = cli->dispatch(cli,
3169                                 mem_ctx,
3170                                 &ndr_table_wbint,
3171                                 NDR_WBINT_REMOVEMAPPING,
3172                                 &r);
3173
3174         if (!NT_STATUS_IS_OK(status)) {
3175                 return status;
3176         }
3177
3178         if (NT_STATUS_IS_ERR(status)) {
3179                 return status;
3180         }
3181
3182         /* Return variables */
3183
3184         /* Return result */
3185         return r.out.result;
3186 }
3187
3188 struct rpccli_wbint_SetHWM_state {
3189         struct wbint_SetHWM orig;
3190         struct wbint_SetHWM tmp;
3191         TALLOC_CTX *out_mem_ctx;
3192         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3193 };
3194
3195 static void rpccli_wbint_SetHWM_done(struct tevent_req *subreq);
3196
3197 struct tevent_req *rpccli_wbint_SetHWM_send(TALLOC_CTX *mem_ctx,
3198                                             struct tevent_context *ev,
3199                                             struct rpc_pipe_client *cli,
3200                                             enum wbint_IdType _type /* [in]  */,
3201                                             uint64_t _id /* [in]  */)
3202 {
3203         struct tevent_req *req;
3204         struct rpccli_wbint_SetHWM_state *state;
3205         struct tevent_req *subreq;
3206
3207         req = tevent_req_create(mem_ctx, &state,
3208                                 struct rpccli_wbint_SetHWM_state);
3209         if (req == NULL) {
3210                 return NULL;
3211         }
3212         state->out_mem_ctx = NULL;
3213         state->dispatch_recv = cli->dispatch_recv;
3214
3215         /* In parameters */
3216         state->orig.in.type = _type;
3217         state->orig.in.id = _id;
3218
3219         /* Out parameters */
3220
3221         /* Result */
3222         ZERO_STRUCT(state->orig.out.result);
3223
3224         /* make a temporary copy, that we pass to the dispatch function */
3225         state->tmp = state->orig;
3226
3227         subreq = cli->dispatch_send(state, ev, cli,
3228                                     &ndr_table_wbint,
3229                                     NDR_WBINT_SETHWM,
3230                                     &state->tmp);
3231         if (tevent_req_nomem(subreq, req)) {
3232                 return tevent_req_post(req, ev);
3233         }
3234         tevent_req_set_callback(subreq, rpccli_wbint_SetHWM_done, req);
3235         return req;
3236 }
3237
3238 static void rpccli_wbint_SetHWM_done(struct tevent_req *subreq)
3239 {
3240         struct tevent_req *req = tevent_req_callback_data(
3241                 subreq, struct tevent_req);
3242         struct rpccli_wbint_SetHWM_state *state = tevent_req_data(
3243                 req, struct rpccli_wbint_SetHWM_state);
3244         NTSTATUS status;
3245         TALLOC_CTX *mem_ctx;
3246
3247         if (state->out_mem_ctx) {
3248                 mem_ctx = state->out_mem_ctx;
3249         } else {
3250                 mem_ctx = state;
3251         }
3252
3253         status = state->dispatch_recv(subreq, mem_ctx);
3254         TALLOC_FREE(subreq);
3255         if (!NT_STATUS_IS_OK(status)) {
3256                 tevent_req_nterror(req, status);
3257                 return;
3258         }
3259
3260         /* Copy out parameters */
3261
3262         /* Copy result */
3263         state->orig.out.result = state->tmp.out.result;
3264
3265         /* Reset temporary structure */
3266         ZERO_STRUCT(state->tmp);
3267
3268         tevent_req_done(req);
3269 }
3270
3271 NTSTATUS rpccli_wbint_SetHWM_recv(struct tevent_req *req,
3272                                   TALLOC_CTX *mem_ctx,
3273                                   NTSTATUS *result)
3274 {
3275         struct rpccli_wbint_SetHWM_state *state = tevent_req_data(
3276                 req, struct rpccli_wbint_SetHWM_state);
3277         NTSTATUS status;
3278
3279         if (tevent_req_is_nterror(req, &status)) {
3280                 tevent_req_received(req);
3281                 return status;
3282         }
3283
3284         /* Steal possbile out parameters to the callers context */
3285         talloc_steal(mem_ctx, state->out_mem_ctx);
3286
3287         /* Return result */
3288         *result = state->orig.out.result;
3289
3290         tevent_req_received(req);
3291         return NT_STATUS_OK;
3292 }
3293
3294 NTSTATUS rpccli_wbint_SetHWM(struct rpc_pipe_client *cli,
3295                              TALLOC_CTX *mem_ctx,
3296                              enum wbint_IdType type /* [in]  */,
3297                              uint64_t id /* [in]  */)
3298 {
3299         struct wbint_SetHWM r;
3300         NTSTATUS status;
3301
3302         /* In parameters */
3303         r.in.type = type;
3304         r.in.id = id;
3305
3306         status = cli->dispatch(cli,
3307                                 mem_ctx,
3308                                 &ndr_table_wbint,
3309                                 NDR_WBINT_SETHWM,
3310                                 &r);
3311
3312         if (!NT_STATUS_IS_OK(status)) {
3313                 return status;
3314         }
3315
3316         if (NT_STATUS_IS_ERR(status)) {
3317                 return status;
3318         }
3319
3320         /* Return variables */
3321
3322         /* Return result */
3323         return r.out.result;
3324 }
3325