?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
idl: recompile our IDL
[Samba/aatanasov.git] / librpc / gen_ndr / cli_samr.c
blob27119e53cc32c7bc79794869badf5637375c3f6e
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_samr.h"
8
9 struct rpccli_samr_Connect_state {
10 struct samr_Connect orig;
11 struct samr_Connect 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_samr_Connect_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_samr_Connect_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli,
21 uint16_t *_system_name /* [in] [unique] */,
22 uint32_t _access_mask /* [in] */,
23 struct policy_handle *_connect_handle /* [out] [ref] */)
24 {
25 struct tevent_req *req;
26 struct rpccli_samr_Connect_state *state;
27 struct tevent_req *subreq;
28
29 req = tevent_req_create(mem_ctx, &state,
30 struct rpccli_samr_Connect_state);
31 if (req == NULL) {
32 return NULL;
33 }
34 state->out_mem_ctx = NULL;
35 state->dispatch_recv = cli->dispatch_recv;
36
37 /* In parameters */
38 state->orig.in.system_name = _system_name;
39 state->orig.in.access_mask = _access_mask;
40
41 /* Out parameters */
42 state->orig.out.connect_handle = _connect_handle;
43
44 /* Result */
45 ZERO_STRUCT(state->orig.out.result);
46
47 if (DEBUGLEVEL >= 10) {
48 NDR_PRINT_IN_DEBUG(samr_Connect, &state->orig);
49 }
50
51 state->out_mem_ctx = talloc_named_const(state, 0,
52 "rpccli_samr_Connect_out_memory");
53 if (tevent_req_nomem(state->out_mem_ctx, req)) {
54 return tevent_req_post(req, ev);
55 }
56
57 /* make a temporary copy, that we pass to the dispatch function */
58 state->tmp = state->orig;
59
60 subreq = cli->dispatch_send(state, ev, cli,
61 &ndr_table_samr,
62 NDR_SAMR_CONNECT,
63 &state->tmp);
64 if (tevent_req_nomem(subreq, req)) {
65 return tevent_req_post(req, ev);
66 }
67 tevent_req_set_callback(subreq, rpccli_samr_Connect_done, req);
68 return req;
69 }
70
71 static void rpccli_samr_Connect_done(struct tevent_req *subreq)
72 {
73 struct tevent_req *req = tevent_req_callback_data(
74 subreq, struct tevent_req);
75 struct rpccli_samr_Connect_state *state = tevent_req_data(
76 req, struct rpccli_samr_Connect_state);
77 NTSTATUS status;
78 TALLOC_CTX *mem_ctx;
79
80 if (state->out_mem_ctx) {
81 mem_ctx = state->out_mem_ctx;
82 } else {
83 mem_ctx = state;
84 }
85
86 status = state->dispatch_recv(subreq, mem_ctx);
87 TALLOC_FREE(subreq);
88 if (!NT_STATUS_IS_OK(status)) {
89 tevent_req_nterror(req, status);
90 return;
91 }
92
93 /* Copy out parameters */
94 *state->orig.out.connect_handle = *state->tmp.out.connect_handle;
95
96 /* Copy result */
97 state->orig.out.result = state->tmp.out.result;
98
99 /* Reset temporary structure */
100 ZERO_STRUCT(state->tmp);
101
102 if (DEBUGLEVEL >= 10) {
103 NDR_PRINT_OUT_DEBUG(samr_Connect, &state->orig);
104 }
105
106 tevent_req_done(req);
107 }
108
109 NTSTATUS rpccli_samr_Connect_recv(struct tevent_req *req,
110 TALLOC_CTX *mem_ctx,
111 NTSTATUS *result)
112 {
113 struct rpccli_samr_Connect_state *state = tevent_req_data(
114 req, struct rpccli_samr_Connect_state);
115 NTSTATUS status;
116
117 if (tevent_req_is_nterror(req, &status)) {
118 tevent_req_received(req);
119 return status;
120 }
121
122 /* Steal possbile out parameters to the callers context */
123 talloc_steal(mem_ctx, state->out_mem_ctx);
124
125 /* Return result */
126 *result = state->orig.out.result;
127
128 tevent_req_received(req);
129 return NT_STATUS_OK;
130 }
131
132 NTSTATUS rpccli_samr_Connect(struct rpc_pipe_client *cli,
133 TALLOC_CTX *mem_ctx,
134 uint16_t *system_name /* [in] [unique] */,
135 uint32_t access_mask /* [in] */,
136 struct policy_handle *connect_handle /* [out] [ref] */)
137 {
138 struct samr_Connect r;
139 NTSTATUS status;
140
141 /* In parameters */
142 r.in.system_name = system_name;
143 r.in.access_mask = access_mask;
144
145 if (DEBUGLEVEL >= 10) {
146 NDR_PRINT_IN_DEBUG(samr_Connect, &r);
147 }
148
149 status = cli->dispatch(cli,
150 mem_ctx,
151 &ndr_table_samr,
152 NDR_SAMR_CONNECT,
153 &r);
154
155 if (!NT_STATUS_IS_OK(status)) {
156 return status;
157 }
158
159 if (DEBUGLEVEL >= 10) {
160 NDR_PRINT_OUT_DEBUG(samr_Connect, &r);
161 }
162
163 if (NT_STATUS_IS_ERR(status)) {
164 return status;
165 }
166
167 /* Return variables */
168 *connect_handle = *r.out.connect_handle;
169
170 /* Return result */
171 return r.out.result;
172 }
173
174 struct rpccli_samr_Close_state {
175 struct samr_Close orig;
176 struct samr_Close tmp;
177 TALLOC_CTX *out_mem_ctx;
178 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
179 };
180
181 static void rpccli_samr_Close_done(struct tevent_req *subreq);
182
183 struct tevent_req *rpccli_samr_Close_send(TALLOC_CTX *mem_ctx,
184 struct tevent_context *ev,
185 struct rpc_pipe_client *cli,
186 struct policy_handle *_handle /* [in,out] [ref] */)
187 {
188 struct tevent_req *req;
189 struct rpccli_samr_Close_state *state;
190 struct tevent_req *subreq;
191
192 req = tevent_req_create(mem_ctx, &state,
193 struct rpccli_samr_Close_state);
194 if (req == NULL) {
195 return NULL;
196 }
197 state->out_mem_ctx = NULL;
198 state->dispatch_recv = cli->dispatch_recv;
199
200 /* In parameters */
201 state->orig.in.handle = _handle;
202
203 /* Out parameters */
204 state->orig.out.handle = _handle;
205
206 /* Result */
207 ZERO_STRUCT(state->orig.out.result);
208
209 if (DEBUGLEVEL >= 10) {
210 NDR_PRINT_IN_DEBUG(samr_Close, &state->orig);
211 }
212
213 state->out_mem_ctx = talloc_named_const(state, 0,
214 "rpccli_samr_Close_out_memory");
215 if (tevent_req_nomem(state->out_mem_ctx, req)) {
216 return tevent_req_post(req, ev);
217 }
218
219 /* make a temporary copy, that we pass to the dispatch function */
220 state->tmp = state->orig;
221
222 subreq = cli->dispatch_send(state, ev, cli,
223 &ndr_table_samr,
224 NDR_SAMR_CLOSE,
225 &state->tmp);
226 if (tevent_req_nomem(subreq, req)) {
227 return tevent_req_post(req, ev);
228 }
229 tevent_req_set_callback(subreq, rpccli_samr_Close_done, req);
230 return req;
231 }
232
233 static void rpccli_samr_Close_done(struct tevent_req *subreq)
234 {
235 struct tevent_req *req = tevent_req_callback_data(
236 subreq, struct tevent_req);
237 struct rpccli_samr_Close_state *state = tevent_req_data(
238 req, struct rpccli_samr_Close_state);
239 NTSTATUS status;
240 TALLOC_CTX *mem_ctx;
241
242 if (state->out_mem_ctx) {
243 mem_ctx = state->out_mem_ctx;
244 } else {
245 mem_ctx = state;
246 }
247
248 status = state->dispatch_recv(subreq, mem_ctx);
249 TALLOC_FREE(subreq);
250 if (!NT_STATUS_IS_OK(status)) {
251 tevent_req_nterror(req, status);
252 return;
253 }
254
255 /* Copy out parameters */
256 *state->orig.out.handle = *state->tmp.out.handle;
257
258 /* Copy result */
259 state->orig.out.result = state->tmp.out.result;
260
261 /* Reset temporary structure */
262 ZERO_STRUCT(state->tmp);
263
264 if (DEBUGLEVEL >= 10) {
265 NDR_PRINT_OUT_DEBUG(samr_Close, &state->orig);
266 }
267
268 tevent_req_done(req);
269 }
270
271 NTSTATUS rpccli_samr_Close_recv(struct tevent_req *req,
272 TALLOC_CTX *mem_ctx,
273 NTSTATUS *result)
274 {
275 struct rpccli_samr_Close_state *state = tevent_req_data(
276 req, struct rpccli_samr_Close_state);
277 NTSTATUS status;
278
279 if (tevent_req_is_nterror(req, &status)) {
280 tevent_req_received(req);
281 return status;
282 }
283
284 /* Steal possbile out parameters to the callers context */
285 talloc_steal(mem_ctx, state->out_mem_ctx);
286
287 /* Return result */
288 *result = state->orig.out.result;
289
290 tevent_req_received(req);
291 return NT_STATUS_OK;
292 }
293
294 NTSTATUS rpccli_samr_Close(struct rpc_pipe_client *cli,
295 TALLOC_CTX *mem_ctx,
296 struct policy_handle *handle /* [in,out] [ref] */)
297 {
298 struct samr_Close r;
299 NTSTATUS status;
300
301 /* In parameters */
302 r.in.handle = handle;
303
304 if (DEBUGLEVEL >= 10) {
305 NDR_PRINT_IN_DEBUG(samr_Close, &r);
306 }
307
308 status = cli->dispatch(cli,
309 mem_ctx,
310 &ndr_table_samr,
311 NDR_SAMR_CLOSE,
312 &r);
313
314 if (!NT_STATUS_IS_OK(status)) {
315 return status;
316 }
317
318 if (DEBUGLEVEL >= 10) {
319 NDR_PRINT_OUT_DEBUG(samr_Close, &r);
320 }
321
322 if (NT_STATUS_IS_ERR(status)) {
323 return status;
324 }
325
326 /* Return variables */
327 *handle = *r.out.handle;
328
329 /* Return result */
330 return r.out.result;
331 }
332
333 struct rpccli_samr_SetSecurity_state {
334 struct samr_SetSecurity orig;
335 struct samr_SetSecurity tmp;
336 TALLOC_CTX *out_mem_ctx;
337 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
338 };
339
340 static void rpccli_samr_SetSecurity_done(struct tevent_req *subreq);
341
342 struct tevent_req *rpccli_samr_SetSecurity_send(TALLOC_CTX *mem_ctx,
343 struct tevent_context *ev,
344 struct rpc_pipe_client *cli,
345 struct policy_handle *_handle /* [in] [ref] */,
346 uint32_t _sec_info /* [in] */,
347 struct sec_desc_buf *_sdbuf /* [in] [ref] */)
348 {
349 struct tevent_req *req;
350 struct rpccli_samr_SetSecurity_state *state;
351 struct tevent_req *subreq;
352
353 req = tevent_req_create(mem_ctx, &state,
354 struct rpccli_samr_SetSecurity_state);
355 if (req == NULL) {
356 return NULL;
357 }
358 state->out_mem_ctx = NULL;
359 state->dispatch_recv = cli->dispatch_recv;
360
361 /* In parameters */
362 state->orig.in.handle = _handle;
363 state->orig.in.sec_info = _sec_info;
364 state->orig.in.sdbuf = _sdbuf;
365
366 /* Out parameters */
367
368 /* Result */
369 ZERO_STRUCT(state->orig.out.result);
370
371 if (DEBUGLEVEL >= 10) {
372 NDR_PRINT_IN_DEBUG(samr_SetSecurity, &state->orig);
373 }
374
375 /* make a temporary copy, that we pass to the dispatch function */
376 state->tmp = state->orig;
377
378 subreq = cli->dispatch_send(state, ev, cli,
379 &ndr_table_samr,
380 NDR_SAMR_SETSECURITY,
381 &state->tmp);
382 if (tevent_req_nomem(subreq, req)) {
383 return tevent_req_post(req, ev);
384 }
385 tevent_req_set_callback(subreq, rpccli_samr_SetSecurity_done, req);
386 return req;
387 }
388
389 static void rpccli_samr_SetSecurity_done(struct tevent_req *subreq)
390 {
391 struct tevent_req *req = tevent_req_callback_data(
392 subreq, struct tevent_req);
393 struct rpccli_samr_SetSecurity_state *state = tevent_req_data(
394 req, struct rpccli_samr_SetSecurity_state);
395 NTSTATUS status;
396 TALLOC_CTX *mem_ctx;
397
398 if (state->out_mem_ctx) {
399 mem_ctx = state->out_mem_ctx;
400 } else {
401 mem_ctx = state;
402 }
403
404 status = state->dispatch_recv(subreq, mem_ctx);
405 TALLOC_FREE(subreq);
406 if (!NT_STATUS_IS_OK(status)) {
407 tevent_req_nterror(req, status);
408 return;
409 }
410
411 /* Copy out parameters */
412
413 /* Copy result */
414 state->orig.out.result = state->tmp.out.result;
415
416 /* Reset temporary structure */
417 ZERO_STRUCT(state->tmp);
418
419 if (DEBUGLEVEL >= 10) {
420 NDR_PRINT_OUT_DEBUG(samr_SetSecurity, &state->orig);
421 }
422
423 tevent_req_done(req);
424 }
425
426 NTSTATUS rpccli_samr_SetSecurity_recv(struct tevent_req *req,
427 TALLOC_CTX *mem_ctx,
428 NTSTATUS *result)
429 {
430 struct rpccli_samr_SetSecurity_state *state = tevent_req_data(
431 req, struct rpccli_samr_SetSecurity_state);
432 NTSTATUS status;
433
434 if (tevent_req_is_nterror(req, &status)) {
435 tevent_req_received(req);
436 return status;
437 }
438
439 /* Steal possbile out parameters to the callers context */
440 talloc_steal(mem_ctx, state->out_mem_ctx);
441
442 /* Return result */
443 *result = state->orig.out.result;
444
445 tevent_req_received(req);
446 return NT_STATUS_OK;
447 }
448
449 NTSTATUS rpccli_samr_SetSecurity(struct rpc_pipe_client *cli,
450 TALLOC_CTX *mem_ctx,
451 struct policy_handle *handle /* [in] [ref] */,
452 uint32_t sec_info /* [in] */,
453 struct sec_desc_buf *sdbuf /* [in] [ref] */)
454 {
455 struct samr_SetSecurity r;
456 NTSTATUS status;
457
458 /* In parameters */
459 r.in.handle = handle;
460 r.in.sec_info = sec_info;
461 r.in.sdbuf = sdbuf;
462
463 if (DEBUGLEVEL >= 10) {
464 NDR_PRINT_IN_DEBUG(samr_SetSecurity, &r);
465 }
466
467 status = cli->dispatch(cli,
468 mem_ctx,
469 &ndr_table_samr,
470 NDR_SAMR_SETSECURITY,
471 &r);
472
473 if (!NT_STATUS_IS_OK(status)) {
474 return status;
475 }
476
477 if (DEBUGLEVEL >= 10) {
478 NDR_PRINT_OUT_DEBUG(samr_SetSecurity, &r);
479 }
480
481 if (NT_STATUS_IS_ERR(status)) {
482 return status;
483 }
484
485 /* Return variables */
486
487 /* Return result */
488 return r.out.result;
489 }
490
491 struct rpccli_samr_QuerySecurity_state {
492 struct samr_QuerySecurity orig;
493 struct samr_QuerySecurity tmp;
494 TALLOC_CTX *out_mem_ctx;
495 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
496 };
497
498 static void rpccli_samr_QuerySecurity_done(struct tevent_req *subreq);
499
500 struct tevent_req *rpccli_samr_QuerySecurity_send(TALLOC_CTX *mem_ctx,
501 struct tevent_context *ev,
502 struct rpc_pipe_client *cli,
503 struct policy_handle *_handle /* [in] [ref] */,
504 uint32_t _sec_info /* [in] */,
505 struct sec_desc_buf **_sdbuf /* [out] [ref] */)
506 {
507 struct tevent_req *req;
508 struct rpccli_samr_QuerySecurity_state *state;
509 struct tevent_req *subreq;
510
511 req = tevent_req_create(mem_ctx, &state,
512 struct rpccli_samr_QuerySecurity_state);
513 if (req == NULL) {
514 return NULL;
515 }
516 state->out_mem_ctx = NULL;
517 state->dispatch_recv = cli->dispatch_recv;
518
519 /* In parameters */
520 state->orig.in.handle = _handle;
521 state->orig.in.sec_info = _sec_info;
522
523 /* Out parameters */
524 state->orig.out.sdbuf = _sdbuf;
525
526 /* Result */
527 ZERO_STRUCT(state->orig.out.result);
528
529 if (DEBUGLEVEL >= 10) {
530 NDR_PRINT_IN_DEBUG(samr_QuerySecurity, &state->orig);
531 }
532
533 state->out_mem_ctx = talloc_named_const(state, 0,
534 "rpccli_samr_QuerySecurity_out_memory");
535 if (tevent_req_nomem(state->out_mem_ctx, req)) {
536 return tevent_req_post(req, ev);
537 }
538
539 /* make a temporary copy, that we pass to the dispatch function */
540 state->tmp = state->orig;
541
542 subreq = cli->dispatch_send(state, ev, cli,
543 &ndr_table_samr,
544 NDR_SAMR_QUERYSECURITY,
545 &state->tmp);
546 if (tevent_req_nomem(subreq, req)) {
547 return tevent_req_post(req, ev);
548 }
549 tevent_req_set_callback(subreq, rpccli_samr_QuerySecurity_done, req);
550 return req;
551 }
552
553 static void rpccli_samr_QuerySecurity_done(struct tevent_req *subreq)
554 {
555 struct tevent_req *req = tevent_req_callback_data(
556 subreq, struct tevent_req);
557 struct rpccli_samr_QuerySecurity_state *state = tevent_req_data(
558 req, struct rpccli_samr_QuerySecurity_state);
559 NTSTATUS status;
560 TALLOC_CTX *mem_ctx;
561
562 if (state->out_mem_ctx) {
563 mem_ctx = state->out_mem_ctx;
564 } else {
565 mem_ctx = state;
566 }
567
568 status = state->dispatch_recv(subreq, mem_ctx);
569 TALLOC_FREE(subreq);
570 if (!NT_STATUS_IS_OK(status)) {
571 tevent_req_nterror(req, status);
572 return;
573 }
574
575 /* Copy out parameters */
576 *state->orig.out.sdbuf = *state->tmp.out.sdbuf;
577
578 /* Copy result */
579 state->orig.out.result = state->tmp.out.result;
580
581 /* Reset temporary structure */
582 ZERO_STRUCT(state->tmp);
583
584 if (DEBUGLEVEL >= 10) {
585 NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, &state->orig);
586 }
587
588 tevent_req_done(req);
589 }
590
591 NTSTATUS rpccli_samr_QuerySecurity_recv(struct tevent_req *req,
592 TALLOC_CTX *mem_ctx,
593 NTSTATUS *result)
594 {
595 struct rpccli_samr_QuerySecurity_state *state = tevent_req_data(
596 req, struct rpccli_samr_QuerySecurity_state);
597 NTSTATUS status;
598
599 if (tevent_req_is_nterror(req, &status)) {
600 tevent_req_received(req);
601 return status;
602 }
603
604 /* Steal possbile out parameters to the callers context */
605 talloc_steal(mem_ctx, state->out_mem_ctx);
606
607 /* Return result */
608 *result = state->orig.out.result;
609
610 tevent_req_received(req);
611 return NT_STATUS_OK;
612 }
613
614 NTSTATUS rpccli_samr_QuerySecurity(struct rpc_pipe_client *cli,
615 TALLOC_CTX *mem_ctx,
616 struct policy_handle *handle /* [in] [ref] */,
617 uint32_t sec_info /* [in] */,
618 struct sec_desc_buf **sdbuf /* [out] [ref] */)
619 {
620 struct samr_QuerySecurity r;
621 NTSTATUS status;
622
623 /* In parameters */
624 r.in.handle = handle;
625 r.in.sec_info = sec_info;
626
627 if (DEBUGLEVEL >= 10) {
628 NDR_PRINT_IN_DEBUG(samr_QuerySecurity, &r);
629 }
630
631 status = cli->dispatch(cli,
632 mem_ctx,
633 &ndr_table_samr,
634 NDR_SAMR_QUERYSECURITY,
635 &r);
636
637 if (!NT_STATUS_IS_OK(status)) {
638 return status;
639 }
640
641 if (DEBUGLEVEL >= 10) {
642 NDR_PRINT_OUT_DEBUG(samr_QuerySecurity, &r);
643 }
644
645 if (NT_STATUS_IS_ERR(status)) {
646 return status;
647 }
648
649 /* Return variables */
650 *sdbuf = *r.out.sdbuf;
651
652 /* Return result */
653 return r.out.result;
654 }
655
656 struct rpccli_samr_Shutdown_state {
657 struct samr_Shutdown orig;
658 struct samr_Shutdown tmp;
659 TALLOC_CTX *out_mem_ctx;
660 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
661 };
662
663 static void rpccli_samr_Shutdown_done(struct tevent_req *subreq);
664
665 struct tevent_req *rpccli_samr_Shutdown_send(TALLOC_CTX *mem_ctx,
666 struct tevent_context *ev,
667 struct rpc_pipe_client *cli,
668 struct policy_handle *_connect_handle /* [in] [ref] */)
669 {
670 struct tevent_req *req;
671 struct rpccli_samr_Shutdown_state *state;
672 struct tevent_req *subreq;
673
674 req = tevent_req_create(mem_ctx, &state,
675 struct rpccli_samr_Shutdown_state);
676 if (req == NULL) {
677 return NULL;
678 }
679 state->out_mem_ctx = NULL;
680 state->dispatch_recv = cli->dispatch_recv;
681
682 /* In parameters */
683 state->orig.in.connect_handle = _connect_handle;
684
685 /* Out parameters */
686
687 /* Result */
688 ZERO_STRUCT(state->orig.out.result);
689
690 if (DEBUGLEVEL >= 10) {
691 NDR_PRINT_IN_DEBUG(samr_Shutdown, &state->orig);
692 }
693
694 /* make a temporary copy, that we pass to the dispatch function */
695 state->tmp = state->orig;
696
697 subreq = cli->dispatch_send(state, ev, cli,
698 &ndr_table_samr,
699 NDR_SAMR_SHUTDOWN,
700 &state->tmp);
701 if (tevent_req_nomem(subreq, req)) {
702 return tevent_req_post(req, ev);
703 }
704 tevent_req_set_callback(subreq, rpccli_samr_Shutdown_done, req);
705 return req;
706 }
707
708 static void rpccli_samr_Shutdown_done(struct tevent_req *subreq)
709 {
710 struct tevent_req *req = tevent_req_callback_data(
711 subreq, struct tevent_req);
712 struct rpccli_samr_Shutdown_state *state = tevent_req_data(
713 req, struct rpccli_samr_Shutdown_state);
714 NTSTATUS status;
715 TALLOC_CTX *mem_ctx;
716
717 if (state->out_mem_ctx) {
718 mem_ctx = state->out_mem_ctx;
719 } else {
720 mem_ctx = state;
721 }
722
723 status = state->dispatch_recv(subreq, mem_ctx);
724 TALLOC_FREE(subreq);
725 if (!NT_STATUS_IS_OK(status)) {
726 tevent_req_nterror(req, status);
727 return;
728 }
729
730 /* Copy out parameters */
731
732 /* Copy result */
733 state->orig.out.result = state->tmp.out.result;
734
735 /* Reset temporary structure */
736 ZERO_STRUCT(state->tmp);
737
738 if (DEBUGLEVEL >= 10) {
739 NDR_PRINT_OUT_DEBUG(samr_Shutdown, &state->orig);
740 }
741
742 tevent_req_done(req);
743 }
744
745 NTSTATUS rpccli_samr_Shutdown_recv(struct tevent_req *req,
746 TALLOC_CTX *mem_ctx,
747 NTSTATUS *result)
748 {
749 struct rpccli_samr_Shutdown_state *state = tevent_req_data(
750 req, struct rpccli_samr_Shutdown_state);
751 NTSTATUS status;
752
753 if (tevent_req_is_nterror(req, &status)) {
754 tevent_req_received(req);
755 return status;
756 }
757
758 /* Steal possbile out parameters to the callers context */
759 talloc_steal(mem_ctx, state->out_mem_ctx);
760
761 /* Return result */
762 *result = state->orig.out.result;
763
764 tevent_req_received(req);
765 return NT_STATUS_OK;
766 }
767
768 NTSTATUS rpccli_samr_Shutdown(struct rpc_pipe_client *cli,
769 TALLOC_CTX *mem_ctx,
770 struct policy_handle *connect_handle /* [in] [ref] */)
771 {
772 struct samr_Shutdown r;
773 NTSTATUS status;
774
775 /* In parameters */
776 r.in.connect_handle = connect_handle;
777
778 if (DEBUGLEVEL >= 10) {
779 NDR_PRINT_IN_DEBUG(samr_Shutdown, &r);
780 }
781
782 status = cli->dispatch(cli,
783 mem_ctx,
784 &ndr_table_samr,
785 NDR_SAMR_SHUTDOWN,
786 &r);
787
788 if (!NT_STATUS_IS_OK(status)) {
789 return status;
790 }
791
792 if (DEBUGLEVEL >= 10) {
793 NDR_PRINT_OUT_DEBUG(samr_Shutdown, &r);
794 }
795
796 if (NT_STATUS_IS_ERR(status)) {
797 return status;
798 }
799
800 /* Return variables */
801
802 /* Return result */
803 return r.out.result;
804 }
805
806 struct rpccli_samr_LookupDomain_state {
807 struct samr_LookupDomain orig;
808 struct samr_LookupDomain tmp;
809 TALLOC_CTX *out_mem_ctx;
810 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
811 };
812
813 static void rpccli_samr_LookupDomain_done(struct tevent_req *subreq);
814
815 struct tevent_req *rpccli_samr_LookupDomain_send(TALLOC_CTX *mem_ctx,
816 struct tevent_context *ev,
817 struct rpc_pipe_client *cli,
818 struct policy_handle *_connect_handle /* [in] [ref] */,
819 struct lsa_String *_domain_name /* [in] [ref] */,
820 struct dom_sid2 **_sid /* [out] [ref] */)
821 {
822 struct tevent_req *req;
823 struct rpccli_samr_LookupDomain_state *state;
824 struct tevent_req *subreq;
825
826 req = tevent_req_create(mem_ctx, &state,
827 struct rpccli_samr_LookupDomain_state);
828 if (req == NULL) {
829 return NULL;
830 }
831 state->out_mem_ctx = NULL;
832 state->dispatch_recv = cli->dispatch_recv;
833
834 /* In parameters */
835 state->orig.in.connect_handle = _connect_handle;
836 state->orig.in.domain_name = _domain_name;
837
838 /* Out parameters */
839 state->orig.out.sid = _sid;
840
841 /* Result */
842 ZERO_STRUCT(state->orig.out.result);
843
844 if (DEBUGLEVEL >= 10) {
845 NDR_PRINT_IN_DEBUG(samr_LookupDomain, &state->orig);
846 }
847
848 state->out_mem_ctx = talloc_named_const(state, 0,
849 "rpccli_samr_LookupDomain_out_memory");
850 if (tevent_req_nomem(state->out_mem_ctx, req)) {
851 return tevent_req_post(req, ev);
852 }
853
854 /* make a temporary copy, that we pass to the dispatch function */
855 state->tmp = state->orig;
856
857 subreq = cli->dispatch_send(state, ev, cli,
858 &ndr_table_samr,
859 NDR_SAMR_LOOKUPDOMAIN,
860 &state->tmp);
861 if (tevent_req_nomem(subreq, req)) {
862 return tevent_req_post(req, ev);
863 }
864 tevent_req_set_callback(subreq, rpccli_samr_LookupDomain_done, req);
865 return req;
866 }
867
868 static void rpccli_samr_LookupDomain_done(struct tevent_req *subreq)
869 {
870 struct tevent_req *req = tevent_req_callback_data(
871 subreq, struct tevent_req);
872 struct rpccli_samr_LookupDomain_state *state = tevent_req_data(
873 req, struct rpccli_samr_LookupDomain_state);
874 NTSTATUS status;
875 TALLOC_CTX *mem_ctx;
876
877 if (state->out_mem_ctx) {
878 mem_ctx = state->out_mem_ctx;
879 } else {
880 mem_ctx = state;
881 }
882
883 status = state->dispatch_recv(subreq, mem_ctx);
884 TALLOC_FREE(subreq);
885 if (!NT_STATUS_IS_OK(status)) {
886 tevent_req_nterror(req, status);
887 return;
888 }
889
890 /* Copy out parameters */
891 *state->orig.out.sid = *state->tmp.out.sid;
892
893 /* Copy result */
894 state->orig.out.result = state->tmp.out.result;
895
896 /* Reset temporary structure */
897 ZERO_STRUCT(state->tmp);
898
899 if (DEBUGLEVEL >= 10) {
900 NDR_PRINT_OUT_DEBUG(samr_LookupDomain, &state->orig);
901 }
902
903 tevent_req_done(req);
904 }
905
906 NTSTATUS rpccli_samr_LookupDomain_recv(struct tevent_req *req,
907 TALLOC_CTX *mem_ctx,
908 NTSTATUS *result)
909 {
910 struct rpccli_samr_LookupDomain_state *state = tevent_req_data(
911 req, struct rpccli_samr_LookupDomain_state);
912 NTSTATUS status;
913
914 if (tevent_req_is_nterror(req, &status)) {
915 tevent_req_received(req);
916 return status;
917 }
918
919 /* Steal possbile out parameters to the callers context */
920 talloc_steal(mem_ctx, state->out_mem_ctx);
921
922 /* Return result */
923 *result = state->orig.out.result;
924
925 tevent_req_received(req);
926 return NT_STATUS_OK;
927 }
928
929 NTSTATUS rpccli_samr_LookupDomain(struct rpc_pipe_client *cli,
930 TALLOC_CTX *mem_ctx,
931 struct policy_handle *connect_handle /* [in] [ref] */,
932 struct lsa_String *domain_name /* [in] [ref] */,
933 struct dom_sid2 **sid /* [out] [ref] */)
934 {
935 struct samr_LookupDomain r;
936 NTSTATUS status;
937
938 /* In parameters */
939 r.in.connect_handle = connect_handle;
940 r.in.domain_name = domain_name;
941
942 if (DEBUGLEVEL >= 10) {
943 NDR_PRINT_IN_DEBUG(samr_LookupDomain, &r);
944 }
945
946 status = cli->dispatch(cli,
947 mem_ctx,
948 &ndr_table_samr,
949 NDR_SAMR_LOOKUPDOMAIN,
950 &r);
951
952 if (!NT_STATUS_IS_OK(status)) {
953 return status;
954 }
955
956 if (DEBUGLEVEL >= 10) {
957 NDR_PRINT_OUT_DEBUG(samr_LookupDomain, &r);
958 }
959
960 if (NT_STATUS_IS_ERR(status)) {
961 return status;
962 }
963
964 /* Return variables */
965 *sid = *r.out.sid;
966
967 /* Return result */
968 return r.out.result;
969 }
970
971 struct rpccli_samr_EnumDomains_state {
972 struct samr_EnumDomains orig;
973 struct samr_EnumDomains tmp;
974 TALLOC_CTX *out_mem_ctx;
975 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
976 };
977
978 static void rpccli_samr_EnumDomains_done(struct tevent_req *subreq);
979
980 struct tevent_req *rpccli_samr_EnumDomains_send(TALLOC_CTX *mem_ctx,
981 struct tevent_context *ev,
982 struct rpc_pipe_client *cli,
983 struct policy_handle *_connect_handle /* [in] [ref] */,
984 uint32_t *_resume_handle /* [in,out] [ref] */,
985 struct samr_SamArray **_sam /* [out] [ref] */,
986 uint32_t _buf_size /* [in] */,
987 uint32_t *_num_entries /* [out] [ref] */)
988 {
989 struct tevent_req *req;
990 struct rpccli_samr_EnumDomains_state *state;
991 struct tevent_req *subreq;
992
993 req = tevent_req_create(mem_ctx, &state,
994 struct rpccli_samr_EnumDomains_state);
995 if (req == NULL) {
996 return NULL;
997 }
998 state->out_mem_ctx = NULL;
999 state->dispatch_recv = cli->dispatch_recv;
1000
1001 /* In parameters */
1002 state->orig.in.connect_handle = _connect_handle;
1003 state->orig.in.resume_handle = _resume_handle;
1004 state->orig.in.buf_size = _buf_size;
1005
1006 /* Out parameters */
1007 state->orig.out.resume_handle = _resume_handle;
1008 state->orig.out.sam = _sam;
1009 state->orig.out.num_entries = _num_entries;
1010
1011 /* Result */
1012 ZERO_STRUCT(state->orig.out.result);
1013
1014 if (DEBUGLEVEL >= 10) {
1015 NDR_PRINT_IN_DEBUG(samr_EnumDomains, &state->orig);
1016 }
1017
1018 state->out_mem_ctx = talloc_named_const(state, 0,
1019 "rpccli_samr_EnumDomains_out_memory");
1020 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1021 return tevent_req_post(req, ev);
1022 }
1023
1024 /* make a temporary copy, that we pass to the dispatch function */
1025 state->tmp = state->orig;
1026
1027 subreq = cli->dispatch_send(state, ev, cli,
1028 &ndr_table_samr,
1029 NDR_SAMR_ENUMDOMAINS,
1030 &state->tmp);
1031 if (tevent_req_nomem(subreq, req)) {
1032 return tevent_req_post(req, ev);
1033 }
1034 tevent_req_set_callback(subreq, rpccli_samr_EnumDomains_done, req);
1035 return req;
1036 }
1037
1038 static void rpccli_samr_EnumDomains_done(struct tevent_req *subreq)
1039 {
1040 struct tevent_req *req = tevent_req_callback_data(
1041 subreq, struct tevent_req);
1042 struct rpccli_samr_EnumDomains_state *state = tevent_req_data(
1043 req, struct rpccli_samr_EnumDomains_state);
1044 NTSTATUS status;
1045 TALLOC_CTX *mem_ctx;
1046
1047 if (state->out_mem_ctx) {
1048 mem_ctx = state->out_mem_ctx;
1049 } else {
1050 mem_ctx = state;
1051 }
1052
1053 status = state->dispatch_recv(subreq, mem_ctx);
1054 TALLOC_FREE(subreq);
1055 if (!NT_STATUS_IS_OK(status)) {
1056 tevent_req_nterror(req, status);
1057 return;
1058 }
1059
1060 /* Copy out parameters */
1061 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1062 *state->orig.out.sam = *state->tmp.out.sam;
1063 *state->orig.out.num_entries = *state->tmp.out.num_entries;
1064
1065 /* Copy result */
1066 state->orig.out.result = state->tmp.out.result;
1067
1068 /* Reset temporary structure */
1069 ZERO_STRUCT(state->tmp);
1070
1071 if (DEBUGLEVEL >= 10) {
1072 NDR_PRINT_OUT_DEBUG(samr_EnumDomains, &state->orig);
1073 }
1074
1075 tevent_req_done(req);
1076 }
1077
1078 NTSTATUS rpccli_samr_EnumDomains_recv(struct tevent_req *req,
1079 TALLOC_CTX *mem_ctx,
1080 NTSTATUS *result)
1081 {
1082 struct rpccli_samr_EnumDomains_state *state = tevent_req_data(
1083 req, struct rpccli_samr_EnumDomains_state);
1084 NTSTATUS status;
1085
1086 if (tevent_req_is_nterror(req, &status)) {
1087 tevent_req_received(req);
1088 return status;
1089 }
1090
1091 /* Steal possbile out parameters to the callers context */
1092 talloc_steal(mem_ctx, state->out_mem_ctx);
1093
1094 /* Return result */
1095 *result = state->orig.out.result;
1096
1097 tevent_req_received(req);
1098 return NT_STATUS_OK;
1099 }
1100
1101 NTSTATUS rpccli_samr_EnumDomains(struct rpc_pipe_client *cli,
1102 TALLOC_CTX *mem_ctx,
1103 struct policy_handle *connect_handle /* [in] [ref] */,
1104 uint32_t *resume_handle /* [in,out] [ref] */,
1105 struct samr_SamArray **sam /* [out] [ref] */,
1106 uint32_t buf_size /* [in] */,
1107 uint32_t *num_entries /* [out] [ref] */)
1108 {
1109 struct samr_EnumDomains r;
1110 NTSTATUS status;
1111
1112 /* In parameters */
1113 r.in.connect_handle = connect_handle;
1114 r.in.resume_handle = resume_handle;
1115 r.in.buf_size = buf_size;
1116
1117 if (DEBUGLEVEL >= 10) {
1118 NDR_PRINT_IN_DEBUG(samr_EnumDomains, &r);
1119 }
1120
1121 status = cli->dispatch(cli,
1122 mem_ctx,
1123 &ndr_table_samr,
1124 NDR_SAMR_ENUMDOMAINS,
1125 &r);
1126
1127 if (!NT_STATUS_IS_OK(status)) {
1128 return status;
1129 }
1130
1131 if (DEBUGLEVEL >= 10) {
1132 NDR_PRINT_OUT_DEBUG(samr_EnumDomains, &r);
1133 }
1134
1135 if (NT_STATUS_IS_ERR(status)) {
1136 return status;
1137 }
1138
1139 /* Return variables */
1140 *resume_handle = *r.out.resume_handle;
1141 *sam = *r.out.sam;
1142 *num_entries = *r.out.num_entries;
1143
1144 /* Return result */
1145 return r.out.result;
1146 }
1147
1148 struct rpccli_samr_OpenDomain_state {
1149 struct samr_OpenDomain orig;
1150 struct samr_OpenDomain tmp;
1151 TALLOC_CTX *out_mem_ctx;
1152 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1153 };
1154
1155 static void rpccli_samr_OpenDomain_done(struct tevent_req *subreq);
1156
1157 struct tevent_req *rpccli_samr_OpenDomain_send(TALLOC_CTX *mem_ctx,
1158 struct tevent_context *ev,
1159 struct rpc_pipe_client *cli,
1160 struct policy_handle *_connect_handle /* [in] [ref] */,
1161 uint32_t _access_mask /* [in] */,
1162 struct dom_sid2 *_sid /* [in] [ref] */,
1163 struct policy_handle *_domain_handle /* [out] [ref] */)
1164 {
1165 struct tevent_req *req;
1166 struct rpccli_samr_OpenDomain_state *state;
1167 struct tevent_req *subreq;
1168
1169 req = tevent_req_create(mem_ctx, &state,
1170 struct rpccli_samr_OpenDomain_state);
1171 if (req == NULL) {
1172 return NULL;
1173 }
1174 state->out_mem_ctx = NULL;
1175 state->dispatch_recv = cli->dispatch_recv;
1176
1177 /* In parameters */
1178 state->orig.in.connect_handle = _connect_handle;
1179 state->orig.in.access_mask = _access_mask;
1180 state->orig.in.sid = _sid;
1181
1182 /* Out parameters */
1183 state->orig.out.domain_handle = _domain_handle;
1184
1185 /* Result */
1186 ZERO_STRUCT(state->orig.out.result);
1187
1188 if (DEBUGLEVEL >= 10) {
1189 NDR_PRINT_IN_DEBUG(samr_OpenDomain, &state->orig);
1190 }
1191
1192 state->out_mem_ctx = talloc_named_const(state, 0,
1193 "rpccli_samr_OpenDomain_out_memory");
1194 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1195 return tevent_req_post(req, ev);
1196 }
1197
1198 /* make a temporary copy, that we pass to the dispatch function */
1199 state->tmp = state->orig;
1200
1201 subreq = cli->dispatch_send(state, ev, cli,
1202 &ndr_table_samr,
1203 NDR_SAMR_OPENDOMAIN,
1204 &state->tmp);
1205 if (tevent_req_nomem(subreq, req)) {
1206 return tevent_req_post(req, ev);
1207 }
1208 tevent_req_set_callback(subreq, rpccli_samr_OpenDomain_done, req);
1209 return req;
1210 }
1211
1212 static void rpccli_samr_OpenDomain_done(struct tevent_req *subreq)
1213 {
1214 struct tevent_req *req = tevent_req_callback_data(
1215 subreq, struct tevent_req);
1216 struct rpccli_samr_OpenDomain_state *state = tevent_req_data(
1217 req, struct rpccli_samr_OpenDomain_state);
1218 NTSTATUS status;
1219 TALLOC_CTX *mem_ctx;
1220
1221 if (state->out_mem_ctx) {
1222 mem_ctx = state->out_mem_ctx;
1223 } else {
1224 mem_ctx = state;
1225 }
1226
1227 status = state->dispatch_recv(subreq, mem_ctx);
1228 TALLOC_FREE(subreq);
1229 if (!NT_STATUS_IS_OK(status)) {
1230 tevent_req_nterror(req, status);
1231 return;
1232 }
1233
1234 /* Copy out parameters */
1235 *state->orig.out.domain_handle = *state->tmp.out.domain_handle;
1236
1237 /* Copy result */
1238 state->orig.out.result = state->tmp.out.result;
1239
1240 /* Reset temporary structure */
1241 ZERO_STRUCT(state->tmp);
1242
1243 if (DEBUGLEVEL >= 10) {
1244 NDR_PRINT_OUT_DEBUG(samr_OpenDomain, &state->orig);
1245 }
1246
1247 tevent_req_done(req);
1248 }
1249
1250 NTSTATUS rpccli_samr_OpenDomain_recv(struct tevent_req *req,
1251 TALLOC_CTX *mem_ctx,
1252 NTSTATUS *result)
1253 {
1254 struct rpccli_samr_OpenDomain_state *state = tevent_req_data(
1255 req, struct rpccli_samr_OpenDomain_state);
1256 NTSTATUS status;
1257
1258 if (tevent_req_is_nterror(req, &status)) {
1259 tevent_req_received(req);
1260 return status;
1261 }
1262
1263 /* Steal possbile out parameters to the callers context */
1264 talloc_steal(mem_ctx, state->out_mem_ctx);
1265
1266 /* Return result */
1267 *result = state->orig.out.result;
1268
1269 tevent_req_received(req);
1270 return NT_STATUS_OK;
1271 }
1272
1273 NTSTATUS rpccli_samr_OpenDomain(struct rpc_pipe_client *cli,
1274 TALLOC_CTX *mem_ctx,
1275 struct policy_handle *connect_handle /* [in] [ref] */,
1276 uint32_t access_mask /* [in] */,
1277 struct dom_sid2 *sid /* [in] [ref] */,
1278 struct policy_handle *domain_handle /* [out] [ref] */)
1279 {
1280 struct samr_OpenDomain r;
1281 NTSTATUS status;
1282
1283 /* In parameters */
1284 r.in.connect_handle = connect_handle;
1285 r.in.access_mask = access_mask;
1286 r.in.sid = sid;
1287
1288 if (DEBUGLEVEL >= 10) {
1289 NDR_PRINT_IN_DEBUG(samr_OpenDomain, &r);
1290 }
1291
1292 status = cli->dispatch(cli,
1293 mem_ctx,
1294 &ndr_table_samr,
1295 NDR_SAMR_OPENDOMAIN,
1296 &r);
1297
1298 if (!NT_STATUS_IS_OK(status)) {
1299 return status;
1300 }
1301
1302 if (DEBUGLEVEL >= 10) {
1303 NDR_PRINT_OUT_DEBUG(samr_OpenDomain, &r);
1304 }
1305
1306 if (NT_STATUS_IS_ERR(status)) {
1307 return status;
1308 }
1309
1310 /* Return variables */
1311 *domain_handle = *r.out.domain_handle;
1312
1313 /* Return result */
1314 return r.out.result;
1315 }
1316
1317 struct rpccli_samr_QueryDomainInfo_state {
1318 struct samr_QueryDomainInfo orig;
1319 struct samr_QueryDomainInfo tmp;
1320 TALLOC_CTX *out_mem_ctx;
1321 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1322 };
1323
1324 static void rpccli_samr_QueryDomainInfo_done(struct tevent_req *subreq);
1325
1326 struct tevent_req *rpccli_samr_QueryDomainInfo_send(TALLOC_CTX *mem_ctx,
1327 struct tevent_context *ev,
1328 struct rpc_pipe_client *cli,
1329 struct policy_handle *_domain_handle /* [in] [ref] */,
1330 enum samr_DomainInfoClass _level /* [in] */,
1331 union samr_DomainInfo **_info /* [out] [ref,switch_is(level)] */)
1332 {
1333 struct tevent_req *req;
1334 struct rpccli_samr_QueryDomainInfo_state *state;
1335 struct tevent_req *subreq;
1336
1337 req = tevent_req_create(mem_ctx, &state,
1338 struct rpccli_samr_QueryDomainInfo_state);
1339 if (req == NULL) {
1340 return NULL;
1341 }
1342 state->out_mem_ctx = NULL;
1343 state->dispatch_recv = cli->dispatch_recv;
1344
1345 /* In parameters */
1346 state->orig.in.domain_handle = _domain_handle;
1347 state->orig.in.level = _level;
1348
1349 /* Out parameters */
1350 state->orig.out.info = _info;
1351
1352 /* Result */
1353 ZERO_STRUCT(state->orig.out.result);
1354
1355 if (DEBUGLEVEL >= 10) {
1356 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, &state->orig);
1357 }
1358
1359 state->out_mem_ctx = talloc_named_const(state, 0,
1360 "rpccli_samr_QueryDomainInfo_out_memory");
1361 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1362 return tevent_req_post(req, ev);
1363 }
1364
1365 /* make a temporary copy, that we pass to the dispatch function */
1366 state->tmp = state->orig;
1367
1368 subreq = cli->dispatch_send(state, ev, cli,
1369 &ndr_table_samr,
1370 NDR_SAMR_QUERYDOMAININFO,
1371 &state->tmp);
1372 if (tevent_req_nomem(subreq, req)) {
1373 return tevent_req_post(req, ev);
1374 }
1375 tevent_req_set_callback(subreq, rpccli_samr_QueryDomainInfo_done, req);
1376 return req;
1377 }
1378
1379 static void rpccli_samr_QueryDomainInfo_done(struct tevent_req *subreq)
1380 {
1381 struct tevent_req *req = tevent_req_callback_data(
1382 subreq, struct tevent_req);
1383 struct rpccli_samr_QueryDomainInfo_state *state = tevent_req_data(
1384 req, struct rpccli_samr_QueryDomainInfo_state);
1385 NTSTATUS status;
1386 TALLOC_CTX *mem_ctx;
1387
1388 if (state->out_mem_ctx) {
1389 mem_ctx = state->out_mem_ctx;
1390 } else {
1391 mem_ctx = state;
1392 }
1393
1394 status = state->dispatch_recv(subreq, mem_ctx);
1395 TALLOC_FREE(subreq);
1396 if (!NT_STATUS_IS_OK(status)) {
1397 tevent_req_nterror(req, status);
1398 return;
1399 }
1400
1401 /* Copy out parameters */
1402 *state->orig.out.info = *state->tmp.out.info;
1403
1404 /* Copy result */
1405 state->orig.out.result = state->tmp.out.result;
1406
1407 /* Reset temporary structure */
1408 ZERO_STRUCT(state->tmp);
1409
1410 if (DEBUGLEVEL >= 10) {
1411 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, &state->orig);
1412 }
1413
1414 tevent_req_done(req);
1415 }
1416
1417 NTSTATUS rpccli_samr_QueryDomainInfo_recv(struct tevent_req *req,
1418 TALLOC_CTX *mem_ctx,
1419 NTSTATUS *result)
1420 {
1421 struct rpccli_samr_QueryDomainInfo_state *state = tevent_req_data(
1422 req, struct rpccli_samr_QueryDomainInfo_state);
1423 NTSTATUS status;
1424
1425 if (tevent_req_is_nterror(req, &status)) {
1426 tevent_req_received(req);
1427 return status;
1428 }
1429
1430 /* Steal possbile out parameters to the callers context */
1431 talloc_steal(mem_ctx, state->out_mem_ctx);
1432
1433 /* Return result */
1434 *result = state->orig.out.result;
1435
1436 tevent_req_received(req);
1437 return NT_STATUS_OK;
1438 }
1439
1440 NTSTATUS rpccli_samr_QueryDomainInfo(struct rpc_pipe_client *cli,
1441 TALLOC_CTX *mem_ctx,
1442 struct policy_handle *domain_handle /* [in] [ref] */,
1443 enum samr_DomainInfoClass level /* [in] */,
1444 union samr_DomainInfo **info /* [out] [ref,switch_is(level)] */)
1445 {
1446 struct samr_QueryDomainInfo r;
1447 NTSTATUS status;
1448
1449 /* In parameters */
1450 r.in.domain_handle = domain_handle;
1451 r.in.level = level;
1452
1453 if (DEBUGLEVEL >= 10) {
1454 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo, &r);
1455 }
1456
1457 status = cli->dispatch(cli,
1458 mem_ctx,
1459 &ndr_table_samr,
1460 NDR_SAMR_QUERYDOMAININFO,
1461 &r);
1462
1463 if (!NT_STATUS_IS_OK(status)) {
1464 return status;
1465 }
1466
1467 if (DEBUGLEVEL >= 10) {
1468 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo, &r);
1469 }
1470
1471 if (NT_STATUS_IS_ERR(status)) {
1472 return status;
1473 }
1474
1475 /* Return variables */
1476 *info = *r.out.info;
1477
1478 /* Return result */
1479 return r.out.result;
1480 }
1481
1482 struct rpccli_samr_SetDomainInfo_state {
1483 struct samr_SetDomainInfo orig;
1484 struct samr_SetDomainInfo tmp;
1485 TALLOC_CTX *out_mem_ctx;
1486 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1487 };
1488
1489 static void rpccli_samr_SetDomainInfo_done(struct tevent_req *subreq);
1490
1491 struct tevent_req *rpccli_samr_SetDomainInfo_send(TALLOC_CTX *mem_ctx,
1492 struct tevent_context *ev,
1493 struct rpc_pipe_client *cli,
1494 struct policy_handle *_domain_handle /* [in] [ref] */,
1495 enum samr_DomainInfoClass _level /* [in] */,
1496 union samr_DomainInfo *_info /* [in] [ref,switch_is(level)] */)
1497 {
1498 struct tevent_req *req;
1499 struct rpccli_samr_SetDomainInfo_state *state;
1500 struct tevent_req *subreq;
1501
1502 req = tevent_req_create(mem_ctx, &state,
1503 struct rpccli_samr_SetDomainInfo_state);
1504 if (req == NULL) {
1505 return NULL;
1506 }
1507 state->out_mem_ctx = NULL;
1508 state->dispatch_recv = cli->dispatch_recv;
1509
1510 /* In parameters */
1511 state->orig.in.domain_handle = _domain_handle;
1512 state->orig.in.level = _level;
1513 state->orig.in.info = _info;
1514
1515 /* Out parameters */
1516
1517 /* Result */
1518 ZERO_STRUCT(state->orig.out.result);
1519
1520 if (DEBUGLEVEL >= 10) {
1521 NDR_PRINT_IN_DEBUG(samr_SetDomainInfo, &state->orig);
1522 }
1523
1524 /* make a temporary copy, that we pass to the dispatch function */
1525 state->tmp = state->orig;
1526
1527 subreq = cli->dispatch_send(state, ev, cli,
1528 &ndr_table_samr,
1529 NDR_SAMR_SETDOMAININFO,
1530 &state->tmp);
1531 if (tevent_req_nomem(subreq, req)) {
1532 return tevent_req_post(req, ev);
1533 }
1534 tevent_req_set_callback(subreq, rpccli_samr_SetDomainInfo_done, req);
1535 return req;
1536 }
1537
1538 static void rpccli_samr_SetDomainInfo_done(struct tevent_req *subreq)
1539 {
1540 struct tevent_req *req = tevent_req_callback_data(
1541 subreq, struct tevent_req);
1542 struct rpccli_samr_SetDomainInfo_state *state = tevent_req_data(
1543 req, struct rpccli_samr_SetDomainInfo_state);
1544 NTSTATUS status;
1545 TALLOC_CTX *mem_ctx;
1546
1547 if (state->out_mem_ctx) {
1548 mem_ctx = state->out_mem_ctx;
1549 } else {
1550 mem_ctx = state;
1551 }
1552
1553 status = state->dispatch_recv(subreq, mem_ctx);
1554 TALLOC_FREE(subreq);
1555 if (!NT_STATUS_IS_OK(status)) {
1556 tevent_req_nterror(req, status);
1557 return;
1558 }
1559
1560 /* Copy out parameters */
1561
1562 /* Copy result */
1563 state->orig.out.result = state->tmp.out.result;
1564
1565 /* Reset temporary structure */
1566 ZERO_STRUCT(state->tmp);
1567
1568 if (DEBUGLEVEL >= 10) {
1569 NDR_PRINT_OUT_DEBUG(samr_SetDomainInfo, &state->orig);
1570 }
1571
1572 tevent_req_done(req);
1573 }
1574
1575 NTSTATUS rpccli_samr_SetDomainInfo_recv(struct tevent_req *req,
1576 TALLOC_CTX *mem_ctx,
1577 NTSTATUS *result)
1578 {
1579 struct rpccli_samr_SetDomainInfo_state *state = tevent_req_data(
1580 req, struct rpccli_samr_SetDomainInfo_state);
1581 NTSTATUS status;
1582
1583 if (tevent_req_is_nterror(req, &status)) {
1584 tevent_req_received(req);
1585 return status;
1586 }
1587
1588 /* Steal possbile out parameters to the callers context */
1589 talloc_steal(mem_ctx, state->out_mem_ctx);
1590
1591 /* Return result */
1592 *result = state->orig.out.result;
1593
1594 tevent_req_received(req);
1595 return NT_STATUS_OK;
1596 }
1597
1598 NTSTATUS rpccli_samr_SetDomainInfo(struct rpc_pipe_client *cli,
1599 TALLOC_CTX *mem_ctx,
1600 struct policy_handle *domain_handle /* [in] [ref] */,
1601 enum samr_DomainInfoClass level /* [in] */,
1602 union samr_DomainInfo *info /* [in] [ref,switch_is(level)] */)
1603 {
1604 struct samr_SetDomainInfo r;
1605 NTSTATUS status;
1606
1607 /* In parameters */
1608 r.in.domain_handle = domain_handle;
1609 r.in.level = level;
1610 r.in.info = info;
1611
1612 if (DEBUGLEVEL >= 10) {
1613 NDR_PRINT_IN_DEBUG(samr_SetDomainInfo, &r);
1614 }
1615
1616 status = cli->dispatch(cli,
1617 mem_ctx,
1618 &ndr_table_samr,
1619 NDR_SAMR_SETDOMAININFO,
1620 &r);
1621
1622 if (!NT_STATUS_IS_OK(status)) {
1623 return status;
1624 }
1625
1626 if (DEBUGLEVEL >= 10) {
1627 NDR_PRINT_OUT_DEBUG(samr_SetDomainInfo, &r);
1628 }
1629
1630 if (NT_STATUS_IS_ERR(status)) {
1631 return status;
1632 }
1633
1634 /* Return variables */
1635
1636 /* Return result */
1637 return r.out.result;
1638 }
1639
1640 struct rpccli_samr_CreateDomainGroup_state {
1641 struct samr_CreateDomainGroup orig;
1642 struct samr_CreateDomainGroup tmp;
1643 TALLOC_CTX *out_mem_ctx;
1644 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1645 };
1646
1647 static void rpccli_samr_CreateDomainGroup_done(struct tevent_req *subreq);
1648
1649 struct tevent_req *rpccli_samr_CreateDomainGroup_send(TALLOC_CTX *mem_ctx,
1650 struct tevent_context *ev,
1651 struct rpc_pipe_client *cli,
1652 struct policy_handle *_domain_handle /* [in] [ref] */,
1653 struct lsa_String *_name /* [in] [ref] */,
1654 uint32_t _access_mask /* [in] */,
1655 struct policy_handle *_group_handle /* [out] [ref] */,
1656 uint32_t *_rid /* [out] [ref] */)
1657 {
1658 struct tevent_req *req;
1659 struct rpccli_samr_CreateDomainGroup_state *state;
1660 struct tevent_req *subreq;
1661
1662 req = tevent_req_create(mem_ctx, &state,
1663 struct rpccli_samr_CreateDomainGroup_state);
1664 if (req == NULL) {
1665 return NULL;
1666 }
1667 state->out_mem_ctx = NULL;
1668 state->dispatch_recv = cli->dispatch_recv;
1669
1670 /* In parameters */
1671 state->orig.in.domain_handle = _domain_handle;
1672 state->orig.in.name = _name;
1673 state->orig.in.access_mask = _access_mask;
1674
1675 /* Out parameters */
1676 state->orig.out.group_handle = _group_handle;
1677 state->orig.out.rid = _rid;
1678
1679 /* Result */
1680 ZERO_STRUCT(state->orig.out.result);
1681
1682 if (DEBUGLEVEL >= 10) {
1683 NDR_PRINT_IN_DEBUG(samr_CreateDomainGroup, &state->orig);
1684 }
1685
1686 state->out_mem_ctx = talloc_named_const(state, 0,
1687 "rpccli_samr_CreateDomainGroup_out_memory");
1688 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1689 return tevent_req_post(req, ev);
1690 }
1691
1692 /* make a temporary copy, that we pass to the dispatch function */
1693 state->tmp = state->orig;
1694
1695 subreq = cli->dispatch_send(state, ev, cli,
1696 &ndr_table_samr,
1697 NDR_SAMR_CREATEDOMAINGROUP,
1698 &state->tmp);
1699 if (tevent_req_nomem(subreq, req)) {
1700 return tevent_req_post(req, ev);
1701 }
1702 tevent_req_set_callback(subreq, rpccli_samr_CreateDomainGroup_done, req);
1703 return req;
1704 }
1705
1706 static void rpccli_samr_CreateDomainGroup_done(struct tevent_req *subreq)
1707 {
1708 struct tevent_req *req = tevent_req_callback_data(
1709 subreq, struct tevent_req);
1710 struct rpccli_samr_CreateDomainGroup_state *state = tevent_req_data(
1711 req, struct rpccli_samr_CreateDomainGroup_state);
1712 NTSTATUS status;
1713 TALLOC_CTX *mem_ctx;
1714
1715 if (state->out_mem_ctx) {
1716 mem_ctx = state->out_mem_ctx;
1717 } else {
1718 mem_ctx = state;
1719 }
1720
1721 status = state->dispatch_recv(subreq, mem_ctx);
1722 TALLOC_FREE(subreq);
1723 if (!NT_STATUS_IS_OK(status)) {
1724 tevent_req_nterror(req, status);
1725 return;
1726 }
1727
1728 /* Copy out parameters */
1729 *state->orig.out.group_handle = *state->tmp.out.group_handle;
1730 *state->orig.out.rid = *state->tmp.out.rid;
1731
1732 /* Copy result */
1733 state->orig.out.result = state->tmp.out.result;
1734
1735 /* Reset temporary structure */
1736 ZERO_STRUCT(state->tmp);
1737
1738 if (DEBUGLEVEL >= 10) {
1739 NDR_PRINT_OUT_DEBUG(samr_CreateDomainGroup, &state->orig);
1740 }
1741
1742 tevent_req_done(req);
1743 }
1744
1745 NTSTATUS rpccli_samr_CreateDomainGroup_recv(struct tevent_req *req,
1746 TALLOC_CTX *mem_ctx,
1747 NTSTATUS *result)
1748 {
1749 struct rpccli_samr_CreateDomainGroup_state *state = tevent_req_data(
1750 req, struct rpccli_samr_CreateDomainGroup_state);
1751 NTSTATUS status;
1752
1753 if (tevent_req_is_nterror(req, &status)) {
1754 tevent_req_received(req);
1755 return status;
1756 }
1757
1758 /* Steal possbile out parameters to the callers context */
1759 talloc_steal(mem_ctx, state->out_mem_ctx);
1760
1761 /* Return result */
1762 *result = state->orig.out.result;
1763
1764 tevent_req_received(req);
1765 return NT_STATUS_OK;
1766 }
1767
1768 NTSTATUS rpccli_samr_CreateDomainGroup(struct rpc_pipe_client *cli,
1769 TALLOC_CTX *mem_ctx,
1770 struct policy_handle *domain_handle /* [in] [ref] */,
1771 struct lsa_String *name /* [in] [ref] */,
1772 uint32_t access_mask /* [in] */,
1773 struct policy_handle *group_handle /* [out] [ref] */,
1774 uint32_t *rid /* [out] [ref] */)
1775 {
1776 struct samr_CreateDomainGroup r;
1777 NTSTATUS status;
1778
1779 /* In parameters */
1780 r.in.domain_handle = domain_handle;
1781 r.in.name = name;
1782 r.in.access_mask = access_mask;
1783
1784 if (DEBUGLEVEL >= 10) {
1785 NDR_PRINT_IN_DEBUG(samr_CreateDomainGroup, &r);
1786 }
1787
1788 status = cli->dispatch(cli,
1789 mem_ctx,
1790 &ndr_table_samr,
1791 NDR_SAMR_CREATEDOMAINGROUP,
1792 &r);
1793
1794 if (!NT_STATUS_IS_OK(status)) {
1795 return status;
1796 }
1797
1798 if (DEBUGLEVEL >= 10) {
1799 NDR_PRINT_OUT_DEBUG(samr_CreateDomainGroup, &r);
1800 }
1801
1802 if (NT_STATUS_IS_ERR(status)) {
1803 return status;
1804 }
1805
1806 /* Return variables */
1807 *group_handle = *r.out.group_handle;
1808 *rid = *r.out.rid;
1809
1810 /* Return result */
1811 return r.out.result;
1812 }
1813
1814 struct rpccli_samr_EnumDomainGroups_state {
1815 struct samr_EnumDomainGroups orig;
1816 struct samr_EnumDomainGroups tmp;
1817 TALLOC_CTX *out_mem_ctx;
1818 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1819 };
1820
1821 static void rpccli_samr_EnumDomainGroups_done(struct tevent_req *subreq);
1822
1823 struct tevent_req *rpccli_samr_EnumDomainGroups_send(TALLOC_CTX *mem_ctx,
1824 struct tevent_context *ev,
1825 struct rpc_pipe_client *cli,
1826 struct policy_handle *_domain_handle /* [in] [ref] */,
1827 uint32_t *_resume_handle /* [in,out] [ref] */,
1828 struct samr_SamArray **_sam /* [out] [ref] */,
1829 uint32_t _max_size /* [in] */,
1830 uint32_t *_num_entries /* [out] [ref] */)
1831 {
1832 struct tevent_req *req;
1833 struct rpccli_samr_EnumDomainGroups_state *state;
1834 struct tevent_req *subreq;
1835
1836 req = tevent_req_create(mem_ctx, &state,
1837 struct rpccli_samr_EnumDomainGroups_state);
1838 if (req == NULL) {
1839 return NULL;
1840 }
1841 state->out_mem_ctx = NULL;
1842 state->dispatch_recv = cli->dispatch_recv;
1843
1844 /* In parameters */
1845 state->orig.in.domain_handle = _domain_handle;
1846 state->orig.in.resume_handle = _resume_handle;
1847 state->orig.in.max_size = _max_size;
1848
1849 /* Out parameters */
1850 state->orig.out.resume_handle = _resume_handle;
1851 state->orig.out.sam = _sam;
1852 state->orig.out.num_entries = _num_entries;
1853
1854 /* Result */
1855 ZERO_STRUCT(state->orig.out.result);
1856
1857 if (DEBUGLEVEL >= 10) {
1858 NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, &state->orig);
1859 }
1860
1861 state->out_mem_ctx = talloc_named_const(state, 0,
1862 "rpccli_samr_EnumDomainGroups_out_memory");
1863 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1864 return tevent_req_post(req, ev);
1865 }
1866
1867 /* make a temporary copy, that we pass to the dispatch function */
1868 state->tmp = state->orig;
1869
1870 subreq = cli->dispatch_send(state, ev, cli,
1871 &ndr_table_samr,
1872 NDR_SAMR_ENUMDOMAINGROUPS,
1873 &state->tmp);
1874 if (tevent_req_nomem(subreq, req)) {
1875 return tevent_req_post(req, ev);
1876 }
1877 tevent_req_set_callback(subreq, rpccli_samr_EnumDomainGroups_done, req);
1878 return req;
1879 }
1880
1881 static void rpccli_samr_EnumDomainGroups_done(struct tevent_req *subreq)
1882 {
1883 struct tevent_req *req = tevent_req_callback_data(
1884 subreq, struct tevent_req);
1885 struct rpccli_samr_EnumDomainGroups_state *state = tevent_req_data(
1886 req, struct rpccli_samr_EnumDomainGroups_state);
1887 NTSTATUS status;
1888 TALLOC_CTX *mem_ctx;
1889
1890 if (state->out_mem_ctx) {
1891 mem_ctx = state->out_mem_ctx;
1892 } else {
1893 mem_ctx = state;
1894 }
1895
1896 status = state->dispatch_recv(subreq, mem_ctx);
1897 TALLOC_FREE(subreq);
1898 if (!NT_STATUS_IS_OK(status)) {
1899 tevent_req_nterror(req, status);
1900 return;
1901 }
1902
1903 /* Copy out parameters */
1904 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
1905 *state->orig.out.sam = *state->tmp.out.sam;
1906 *state->orig.out.num_entries = *state->tmp.out.num_entries;
1907
1908 /* Copy result */
1909 state->orig.out.result = state->tmp.out.result;
1910
1911 /* Reset temporary structure */
1912 ZERO_STRUCT(state->tmp);
1913
1914 if (DEBUGLEVEL >= 10) {
1915 NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, &state->orig);
1916 }
1917
1918 tevent_req_done(req);
1919 }
1920
1921 NTSTATUS rpccli_samr_EnumDomainGroups_recv(struct tevent_req *req,
1922 TALLOC_CTX *mem_ctx,
1923 NTSTATUS *result)
1924 {
1925 struct rpccli_samr_EnumDomainGroups_state *state = tevent_req_data(
1926 req, struct rpccli_samr_EnumDomainGroups_state);
1927 NTSTATUS status;
1928
1929 if (tevent_req_is_nterror(req, &status)) {
1930 tevent_req_received(req);
1931 return status;
1932 }
1933
1934 /* Steal possbile out parameters to the callers context */
1935 talloc_steal(mem_ctx, state->out_mem_ctx);
1936
1937 /* Return result */
1938 *result = state->orig.out.result;
1939
1940 tevent_req_received(req);
1941 return NT_STATUS_OK;
1942 }
1943
1944 NTSTATUS rpccli_samr_EnumDomainGroups(struct rpc_pipe_client *cli,
1945 TALLOC_CTX *mem_ctx,
1946 struct policy_handle *domain_handle /* [in] [ref] */,
1947 uint32_t *resume_handle /* [in,out] [ref] */,
1948 struct samr_SamArray **sam /* [out] [ref] */,
1949 uint32_t max_size /* [in] */,
1950 uint32_t *num_entries /* [out] [ref] */)
1951 {
1952 struct samr_EnumDomainGroups r;
1953 NTSTATUS status;
1954
1955 /* In parameters */
1956 r.in.domain_handle = domain_handle;
1957 r.in.resume_handle = resume_handle;
1958 r.in.max_size = max_size;
1959
1960 if (DEBUGLEVEL >= 10) {
1961 NDR_PRINT_IN_DEBUG(samr_EnumDomainGroups, &r);
1962 }
1963
1964 status = cli->dispatch(cli,
1965 mem_ctx,
1966 &ndr_table_samr,
1967 NDR_SAMR_ENUMDOMAINGROUPS,
1968 &r);
1969
1970 if (!NT_STATUS_IS_OK(status)) {
1971 return status;
1972 }
1973
1974 if (DEBUGLEVEL >= 10) {
1975 NDR_PRINT_OUT_DEBUG(samr_EnumDomainGroups, &r);
1976 }
1977
1978 if (NT_STATUS_IS_ERR(status)) {
1979 return status;
1980 }
1981
1982 /* Return variables */
1983 *resume_handle = *r.out.resume_handle;
1984 *sam = *r.out.sam;
1985 *num_entries = *r.out.num_entries;
1986
1987 /* Return result */
1988 return r.out.result;
1989 }
1990
1991 struct rpccli_samr_CreateUser_state {
1992 struct samr_CreateUser orig;
1993 struct samr_CreateUser tmp;
1994 TALLOC_CTX *out_mem_ctx;
1995 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1996 };
1997
1998 static void rpccli_samr_CreateUser_done(struct tevent_req *subreq);
1999
2000 struct tevent_req *rpccli_samr_CreateUser_send(TALLOC_CTX *mem_ctx,
2001 struct tevent_context *ev,
2002 struct rpc_pipe_client *cli,
2003 struct policy_handle *_domain_handle /* [in] [ref] */,
2004 struct lsa_String *_account_name /* [in] [ref] */,
2005 uint32_t _access_mask /* [in] */,
2006 struct policy_handle *_user_handle /* [out] [ref] */,
2007 uint32_t *_rid /* [out] [ref] */)
2008 {
2009 struct tevent_req *req;
2010 struct rpccli_samr_CreateUser_state *state;
2011 struct tevent_req *subreq;
2012
2013 req = tevent_req_create(mem_ctx, &state,
2014 struct rpccli_samr_CreateUser_state);
2015 if (req == NULL) {
2016 return NULL;
2017 }
2018 state->out_mem_ctx = NULL;
2019 state->dispatch_recv = cli->dispatch_recv;
2020
2021 /* In parameters */
2022 state->orig.in.domain_handle = _domain_handle;
2023 state->orig.in.account_name = _account_name;
2024 state->orig.in.access_mask = _access_mask;
2025
2026 /* Out parameters */
2027 state->orig.out.user_handle = _user_handle;
2028 state->orig.out.rid = _rid;
2029
2030 /* Result */
2031 ZERO_STRUCT(state->orig.out.result);
2032
2033 if (DEBUGLEVEL >= 10) {
2034 NDR_PRINT_IN_DEBUG(samr_CreateUser, &state->orig);
2035 }
2036
2037 state->out_mem_ctx = talloc_named_const(state, 0,
2038 "rpccli_samr_CreateUser_out_memory");
2039 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2040 return tevent_req_post(req, ev);
2041 }
2042
2043 /* make a temporary copy, that we pass to the dispatch function */
2044 state->tmp = state->orig;
2045
2046 subreq = cli->dispatch_send(state, ev, cli,
2047 &ndr_table_samr,
2048 NDR_SAMR_CREATEUSER,
2049 &state->tmp);
2050 if (tevent_req_nomem(subreq, req)) {
2051 return tevent_req_post(req, ev);
2052 }
2053 tevent_req_set_callback(subreq, rpccli_samr_CreateUser_done, req);
2054 return req;
2055 }
2056
2057 static void rpccli_samr_CreateUser_done(struct tevent_req *subreq)
2058 {
2059 struct tevent_req *req = tevent_req_callback_data(
2060 subreq, struct tevent_req);
2061 struct rpccli_samr_CreateUser_state *state = tevent_req_data(
2062 req, struct rpccli_samr_CreateUser_state);
2063 NTSTATUS status;
2064 TALLOC_CTX *mem_ctx;
2065
2066 if (state->out_mem_ctx) {
2067 mem_ctx = state->out_mem_ctx;
2068 } else {
2069 mem_ctx = state;
2070 }
2071
2072 status = state->dispatch_recv(subreq, mem_ctx);
2073 TALLOC_FREE(subreq);
2074 if (!NT_STATUS_IS_OK(status)) {
2075 tevent_req_nterror(req, status);
2076 return;
2077 }
2078
2079 /* Copy out parameters */
2080 *state->orig.out.user_handle = *state->tmp.out.user_handle;
2081 *state->orig.out.rid = *state->tmp.out.rid;
2082
2083 /* Copy result */
2084 state->orig.out.result = state->tmp.out.result;
2085
2086 /* Reset temporary structure */
2087 ZERO_STRUCT(state->tmp);
2088
2089 if (DEBUGLEVEL >= 10) {
2090 NDR_PRINT_OUT_DEBUG(samr_CreateUser, &state->orig);
2091 }
2092
2093 tevent_req_done(req);
2094 }
2095
2096 NTSTATUS rpccli_samr_CreateUser_recv(struct tevent_req *req,
2097 TALLOC_CTX *mem_ctx,
2098 NTSTATUS *result)
2099 {
2100 struct rpccli_samr_CreateUser_state *state = tevent_req_data(
2101 req, struct rpccli_samr_CreateUser_state);
2102 NTSTATUS status;
2103
2104 if (tevent_req_is_nterror(req, &status)) {
2105 tevent_req_received(req);
2106 return status;
2107 }
2108
2109 /* Steal possbile out parameters to the callers context */
2110 talloc_steal(mem_ctx, state->out_mem_ctx);
2111
2112 /* Return result */
2113 *result = state->orig.out.result;
2114
2115 tevent_req_received(req);
2116 return NT_STATUS_OK;
2117 }
2118
2119 NTSTATUS rpccli_samr_CreateUser(struct rpc_pipe_client *cli,
2120 TALLOC_CTX *mem_ctx,
2121 struct policy_handle *domain_handle /* [in] [ref] */,
2122 struct lsa_String *account_name /* [in] [ref] */,
2123 uint32_t access_mask /* [in] */,
2124 struct policy_handle *user_handle /* [out] [ref] */,
2125 uint32_t *rid /* [out] [ref] */)
2126 {
2127 struct samr_CreateUser r;
2128 NTSTATUS status;
2129
2130 /* In parameters */
2131 r.in.domain_handle = domain_handle;
2132 r.in.account_name = account_name;
2133 r.in.access_mask = access_mask;
2134
2135 if (DEBUGLEVEL >= 10) {
2136 NDR_PRINT_IN_DEBUG(samr_CreateUser, &r);
2137 }
2138
2139 status = cli->dispatch(cli,
2140 mem_ctx,
2141 &ndr_table_samr,
2142 NDR_SAMR_CREATEUSER,
2143 &r);
2144
2145 if (!NT_STATUS_IS_OK(status)) {
2146 return status;
2147 }
2148
2149 if (DEBUGLEVEL >= 10) {
2150 NDR_PRINT_OUT_DEBUG(samr_CreateUser, &r);
2151 }
2152
2153 if (NT_STATUS_IS_ERR(status)) {
2154 return status;
2155 }
2156
2157 /* Return variables */
2158 *user_handle = *r.out.user_handle;
2159 *rid = *r.out.rid;
2160
2161 /* Return result */
2162 return r.out.result;
2163 }
2164
2165 struct rpccli_samr_EnumDomainUsers_state {
2166 struct samr_EnumDomainUsers orig;
2167 struct samr_EnumDomainUsers tmp;
2168 TALLOC_CTX *out_mem_ctx;
2169 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2170 };
2171
2172 static void rpccli_samr_EnumDomainUsers_done(struct tevent_req *subreq);
2173
2174 struct tevent_req *rpccli_samr_EnumDomainUsers_send(TALLOC_CTX *mem_ctx,
2175 struct tevent_context *ev,
2176 struct rpc_pipe_client *cli,
2177 struct policy_handle *_domain_handle /* [in] [ref] */,
2178 uint32_t *_resume_handle /* [in,out] [ref] */,
2179 uint32_t _acct_flags /* [in] */,
2180 struct samr_SamArray **_sam /* [out] [ref] */,
2181 uint32_t _max_size /* [in] */,
2182 uint32_t *_num_entries /* [out] [ref] */)
2183 {
2184 struct tevent_req *req;
2185 struct rpccli_samr_EnumDomainUsers_state *state;
2186 struct tevent_req *subreq;
2187
2188 req = tevent_req_create(mem_ctx, &state,
2189 struct rpccli_samr_EnumDomainUsers_state);
2190 if (req == NULL) {
2191 return NULL;
2192 }
2193 state->out_mem_ctx = NULL;
2194 state->dispatch_recv = cli->dispatch_recv;
2195
2196 /* In parameters */
2197 state->orig.in.domain_handle = _domain_handle;
2198 state->orig.in.resume_handle = _resume_handle;
2199 state->orig.in.acct_flags = _acct_flags;
2200 state->orig.in.max_size = _max_size;
2201
2202 /* Out parameters */
2203 state->orig.out.resume_handle = _resume_handle;
2204 state->orig.out.sam = _sam;
2205 state->orig.out.num_entries = _num_entries;
2206
2207 /* Result */
2208 ZERO_STRUCT(state->orig.out.result);
2209
2210 if (DEBUGLEVEL >= 10) {
2211 NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, &state->orig);
2212 }
2213
2214 state->out_mem_ctx = talloc_named_const(state, 0,
2215 "rpccli_samr_EnumDomainUsers_out_memory");
2216 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2217 return tevent_req_post(req, ev);
2218 }
2219
2220 /* make a temporary copy, that we pass to the dispatch function */
2221 state->tmp = state->orig;
2222
2223 subreq = cli->dispatch_send(state, ev, cli,
2224 &ndr_table_samr,
2225 NDR_SAMR_ENUMDOMAINUSERS,
2226 &state->tmp);
2227 if (tevent_req_nomem(subreq, req)) {
2228 return tevent_req_post(req, ev);
2229 }
2230 tevent_req_set_callback(subreq, rpccli_samr_EnumDomainUsers_done, req);
2231 return req;
2232 }
2233
2234 static void rpccli_samr_EnumDomainUsers_done(struct tevent_req *subreq)
2235 {
2236 struct tevent_req *req = tevent_req_callback_data(
2237 subreq, struct tevent_req);
2238 struct rpccli_samr_EnumDomainUsers_state *state = tevent_req_data(
2239 req, struct rpccli_samr_EnumDomainUsers_state);
2240 NTSTATUS status;
2241 TALLOC_CTX *mem_ctx;
2242
2243 if (state->out_mem_ctx) {
2244 mem_ctx = state->out_mem_ctx;
2245 } else {
2246 mem_ctx = state;
2247 }
2248
2249 status = state->dispatch_recv(subreq, mem_ctx);
2250 TALLOC_FREE(subreq);
2251 if (!NT_STATUS_IS_OK(status)) {
2252 tevent_req_nterror(req, status);
2253 return;
2254 }
2255
2256 /* Copy out parameters */
2257 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2258 *state->orig.out.sam = *state->tmp.out.sam;
2259 *state->orig.out.num_entries = *state->tmp.out.num_entries;
2260
2261 /* Copy result */
2262 state->orig.out.result = state->tmp.out.result;
2263
2264 /* Reset temporary structure */
2265 ZERO_STRUCT(state->tmp);
2266
2267 if (DEBUGLEVEL >= 10) {
2268 NDR_PRINT_OUT_DEBUG(samr_EnumDomainUsers, &state->orig);
2269 }
2270
2271 tevent_req_done(req);
2272 }
2273
2274 NTSTATUS rpccli_samr_EnumDomainUsers_recv(struct tevent_req *req,
2275 TALLOC_CTX *mem_ctx,
2276 NTSTATUS *result)
2277 {
2278 struct rpccli_samr_EnumDomainUsers_state *state = tevent_req_data(
2279 req, struct rpccli_samr_EnumDomainUsers_state);
2280 NTSTATUS status;
2281
2282 if (tevent_req_is_nterror(req, &status)) {
2283 tevent_req_received(req);
2284 return status;
2285 }
2286
2287 /* Steal possbile out parameters to the callers context */
2288 talloc_steal(mem_ctx, state->out_mem_ctx);
2289
2290 /* Return result */
2291 *result = state->orig.out.result;
2292
2293 tevent_req_received(req);
2294 return NT_STATUS_OK;
2295 }
2296
2297 NTSTATUS rpccli_samr_EnumDomainUsers(struct rpc_pipe_client *cli,
2298 TALLOC_CTX *mem_ctx,
2299 struct policy_handle *domain_handle /* [in] [ref] */,
2300 uint32_t *resume_handle /* [in,out] [ref] */,
2301 uint32_t acct_flags /* [in] */,
2302 struct samr_SamArray **sam /* [out] [ref] */,
2303 uint32_t max_size /* [in] */,
2304 uint32_t *num_entries /* [out] [ref] */)
2305 {
2306 struct samr_EnumDomainUsers r;
2307 NTSTATUS status;
2308
2309 /* In parameters */
2310 r.in.domain_handle = domain_handle;
2311 r.in.resume_handle = resume_handle;
2312 r.in.acct_flags = acct_flags;
2313 r.in.max_size = max_size;
2314
2315 if (DEBUGLEVEL >= 10) {
2316 NDR_PRINT_IN_DEBUG(samr_EnumDomainUsers, &r);
2317 }
2318
2319 status = cli->dispatch(cli,
2320 mem_ctx,
2321 &ndr_table_samr,
2322 NDR_SAMR_ENUMDOMAINUSERS,
2323 &r);
2324
2325 if (!NT_STATUS_IS_OK(status)) {
2326 return status;
2327 }
2328
2329 if (DEBUGLEVEL >= 10) {
2330 NDR_PRINT_OUT_DEBUG(samr_EnumDomainUsers, &r);
2331 }
2332
2333 if (NT_STATUS_IS_ERR(status)) {
2334 return status;
2335 }
2336
2337 /* Return variables */
2338 *resume_handle = *r.out.resume_handle;
2339 *sam = *r.out.sam;
2340 *num_entries = *r.out.num_entries;
2341
2342 /* Return result */
2343 return r.out.result;
2344 }
2345
2346 struct rpccli_samr_CreateDomAlias_state {
2347 struct samr_CreateDomAlias orig;
2348 struct samr_CreateDomAlias tmp;
2349 TALLOC_CTX *out_mem_ctx;
2350 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2351 };
2352
2353 static void rpccli_samr_CreateDomAlias_done(struct tevent_req *subreq);
2354
2355 struct tevent_req *rpccli_samr_CreateDomAlias_send(TALLOC_CTX *mem_ctx,
2356 struct tevent_context *ev,
2357 struct rpc_pipe_client *cli,
2358 struct policy_handle *_domain_handle /* [in] [ref] */,
2359 struct lsa_String *_alias_name /* [in] [ref] */,
2360 uint32_t _access_mask /* [in] */,
2361 struct policy_handle *_alias_handle /* [out] [ref] */,
2362 uint32_t *_rid /* [out] [ref] */)
2363 {
2364 struct tevent_req *req;
2365 struct rpccli_samr_CreateDomAlias_state *state;
2366 struct tevent_req *subreq;
2367
2368 req = tevent_req_create(mem_ctx, &state,
2369 struct rpccli_samr_CreateDomAlias_state);
2370 if (req == NULL) {
2371 return NULL;
2372 }
2373 state->out_mem_ctx = NULL;
2374 state->dispatch_recv = cli->dispatch_recv;
2375
2376 /* In parameters */
2377 state->orig.in.domain_handle = _domain_handle;
2378 state->orig.in.alias_name = _alias_name;
2379 state->orig.in.access_mask = _access_mask;
2380
2381 /* Out parameters */
2382 state->orig.out.alias_handle = _alias_handle;
2383 state->orig.out.rid = _rid;
2384
2385 /* Result */
2386 ZERO_STRUCT(state->orig.out.result);
2387
2388 if (DEBUGLEVEL >= 10) {
2389 NDR_PRINT_IN_DEBUG(samr_CreateDomAlias, &state->orig);
2390 }
2391
2392 state->out_mem_ctx = talloc_named_const(state, 0,
2393 "rpccli_samr_CreateDomAlias_out_memory");
2394 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2395 return tevent_req_post(req, ev);
2396 }
2397
2398 /* make a temporary copy, that we pass to the dispatch function */
2399 state->tmp = state->orig;
2400
2401 subreq = cli->dispatch_send(state, ev, cli,
2402 &ndr_table_samr,
2403 NDR_SAMR_CREATEDOMALIAS,
2404 &state->tmp);
2405 if (tevent_req_nomem(subreq, req)) {
2406 return tevent_req_post(req, ev);
2407 }
2408 tevent_req_set_callback(subreq, rpccli_samr_CreateDomAlias_done, req);
2409 return req;
2410 }
2411
2412 static void rpccli_samr_CreateDomAlias_done(struct tevent_req *subreq)
2413 {
2414 struct tevent_req *req = tevent_req_callback_data(
2415 subreq, struct tevent_req);
2416 struct rpccli_samr_CreateDomAlias_state *state = tevent_req_data(
2417 req, struct rpccli_samr_CreateDomAlias_state);
2418 NTSTATUS status;
2419 TALLOC_CTX *mem_ctx;
2420
2421 if (state->out_mem_ctx) {
2422 mem_ctx = state->out_mem_ctx;
2423 } else {
2424 mem_ctx = state;
2425 }
2426
2427 status = state->dispatch_recv(subreq, mem_ctx);
2428 TALLOC_FREE(subreq);
2429 if (!NT_STATUS_IS_OK(status)) {
2430 tevent_req_nterror(req, status);
2431 return;
2432 }
2433
2434 /* Copy out parameters */
2435 *state->orig.out.alias_handle = *state->tmp.out.alias_handle;
2436 *state->orig.out.rid = *state->tmp.out.rid;
2437
2438 /* Copy result */
2439 state->orig.out.result = state->tmp.out.result;
2440
2441 /* Reset temporary structure */
2442 ZERO_STRUCT(state->tmp);
2443
2444 if (DEBUGLEVEL >= 10) {
2445 NDR_PRINT_OUT_DEBUG(samr_CreateDomAlias, &state->orig);
2446 }
2447
2448 tevent_req_done(req);
2449 }
2450
2451 NTSTATUS rpccli_samr_CreateDomAlias_recv(struct tevent_req *req,
2452 TALLOC_CTX *mem_ctx,
2453 NTSTATUS *result)
2454 {
2455 struct rpccli_samr_CreateDomAlias_state *state = tevent_req_data(
2456 req, struct rpccli_samr_CreateDomAlias_state);
2457 NTSTATUS status;
2458
2459 if (tevent_req_is_nterror(req, &status)) {
2460 tevent_req_received(req);
2461 return status;
2462 }
2463
2464 /* Steal possbile out parameters to the callers context */
2465 talloc_steal(mem_ctx, state->out_mem_ctx);
2466
2467 /* Return result */
2468 *result = state->orig.out.result;
2469
2470 tevent_req_received(req);
2471 return NT_STATUS_OK;
2472 }
2473
2474 NTSTATUS rpccli_samr_CreateDomAlias(struct rpc_pipe_client *cli,
2475 TALLOC_CTX *mem_ctx,
2476 struct policy_handle *domain_handle /* [in] [ref] */,
2477 struct lsa_String *alias_name /* [in] [ref] */,
2478 uint32_t access_mask /* [in] */,
2479 struct policy_handle *alias_handle /* [out] [ref] */,
2480 uint32_t *rid /* [out] [ref] */)
2481 {
2482 struct samr_CreateDomAlias r;
2483 NTSTATUS status;
2484
2485 /* In parameters */
2486 r.in.domain_handle = domain_handle;
2487 r.in.alias_name = alias_name;
2488 r.in.access_mask = access_mask;
2489
2490 if (DEBUGLEVEL >= 10) {
2491 NDR_PRINT_IN_DEBUG(samr_CreateDomAlias, &r);
2492 }
2493
2494 status = cli->dispatch(cli,
2495 mem_ctx,
2496 &ndr_table_samr,
2497 NDR_SAMR_CREATEDOMALIAS,
2498 &r);
2499
2500 if (!NT_STATUS_IS_OK(status)) {
2501 return status;
2502 }
2503
2504 if (DEBUGLEVEL >= 10) {
2505 NDR_PRINT_OUT_DEBUG(samr_CreateDomAlias, &r);
2506 }
2507
2508 if (NT_STATUS_IS_ERR(status)) {
2509 return status;
2510 }
2511
2512 /* Return variables */
2513 *alias_handle = *r.out.alias_handle;
2514 *rid = *r.out.rid;
2515
2516 /* Return result */
2517 return r.out.result;
2518 }
2519
2520 struct rpccli_samr_EnumDomainAliases_state {
2521 struct samr_EnumDomainAliases orig;
2522 struct samr_EnumDomainAliases tmp;
2523 TALLOC_CTX *out_mem_ctx;
2524 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2525 };
2526
2527 static void rpccli_samr_EnumDomainAliases_done(struct tevent_req *subreq);
2528
2529 struct tevent_req *rpccli_samr_EnumDomainAliases_send(TALLOC_CTX *mem_ctx,
2530 struct tevent_context *ev,
2531 struct rpc_pipe_client *cli,
2532 struct policy_handle *_domain_handle /* [in] [ref] */,
2533 uint32_t *_resume_handle /* [in,out] [ref] */,
2534 struct samr_SamArray **_sam /* [out] [ref] */,
2535 uint32_t _max_size /* [in] */,
2536 uint32_t *_num_entries /* [out] [ref] */)
2537 {
2538 struct tevent_req *req;
2539 struct rpccli_samr_EnumDomainAliases_state *state;
2540 struct tevent_req *subreq;
2541
2542 req = tevent_req_create(mem_ctx, &state,
2543 struct rpccli_samr_EnumDomainAliases_state);
2544 if (req == NULL) {
2545 return NULL;
2546 }
2547 state->out_mem_ctx = NULL;
2548 state->dispatch_recv = cli->dispatch_recv;
2549
2550 /* In parameters */
2551 state->orig.in.domain_handle = _domain_handle;
2552 state->orig.in.resume_handle = _resume_handle;
2553 state->orig.in.max_size = _max_size;
2554
2555 /* Out parameters */
2556 state->orig.out.resume_handle = _resume_handle;
2557 state->orig.out.sam = _sam;
2558 state->orig.out.num_entries = _num_entries;
2559
2560 /* Result */
2561 ZERO_STRUCT(state->orig.out.result);
2562
2563 if (DEBUGLEVEL >= 10) {
2564 NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, &state->orig);
2565 }
2566
2567 state->out_mem_ctx = talloc_named_const(state, 0,
2568 "rpccli_samr_EnumDomainAliases_out_memory");
2569 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2570 return tevent_req_post(req, ev);
2571 }
2572
2573 /* make a temporary copy, that we pass to the dispatch function */
2574 state->tmp = state->orig;
2575
2576 subreq = cli->dispatch_send(state, ev, cli,
2577 &ndr_table_samr,
2578 NDR_SAMR_ENUMDOMAINALIASES,
2579 &state->tmp);
2580 if (tevent_req_nomem(subreq, req)) {
2581 return tevent_req_post(req, ev);
2582 }
2583 tevent_req_set_callback(subreq, rpccli_samr_EnumDomainAliases_done, req);
2584 return req;
2585 }
2586
2587 static void rpccli_samr_EnumDomainAliases_done(struct tevent_req *subreq)
2588 {
2589 struct tevent_req *req = tevent_req_callback_data(
2590 subreq, struct tevent_req);
2591 struct rpccli_samr_EnumDomainAliases_state *state = tevent_req_data(
2592 req, struct rpccli_samr_EnumDomainAliases_state);
2593 NTSTATUS status;
2594 TALLOC_CTX *mem_ctx;
2595
2596 if (state->out_mem_ctx) {
2597 mem_ctx = state->out_mem_ctx;
2598 } else {
2599 mem_ctx = state;
2600 }
2601
2602 status = state->dispatch_recv(subreq, mem_ctx);
2603 TALLOC_FREE(subreq);
2604 if (!NT_STATUS_IS_OK(status)) {
2605 tevent_req_nterror(req, status);
2606 return;
2607 }
2608
2609 /* Copy out parameters */
2610 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2611 *state->orig.out.sam = *state->tmp.out.sam;
2612 *state->orig.out.num_entries = *state->tmp.out.num_entries;
2613
2614 /* Copy result */
2615 state->orig.out.result = state->tmp.out.result;
2616
2617 /* Reset temporary structure */
2618 ZERO_STRUCT(state->tmp);
2619
2620 if (DEBUGLEVEL >= 10) {
2621 NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, &state->orig);
2622 }
2623
2624 tevent_req_done(req);
2625 }
2626
2627 NTSTATUS rpccli_samr_EnumDomainAliases_recv(struct tevent_req *req,
2628 TALLOC_CTX *mem_ctx,
2629 NTSTATUS *result)
2630 {
2631 struct rpccli_samr_EnumDomainAliases_state *state = tevent_req_data(
2632 req, struct rpccli_samr_EnumDomainAliases_state);
2633 NTSTATUS status;
2634
2635 if (tevent_req_is_nterror(req, &status)) {
2636 tevent_req_received(req);
2637 return status;
2638 }
2639
2640 /* Steal possbile out parameters to the callers context */
2641 talloc_steal(mem_ctx, state->out_mem_ctx);
2642
2643 /* Return result */
2644 *result = state->orig.out.result;
2645
2646 tevent_req_received(req);
2647 return NT_STATUS_OK;
2648 }
2649
2650 NTSTATUS rpccli_samr_EnumDomainAliases(struct rpc_pipe_client *cli,
2651 TALLOC_CTX *mem_ctx,
2652 struct policy_handle *domain_handle /* [in] [ref] */,
2653 uint32_t *resume_handle /* [in,out] [ref] */,
2654 struct samr_SamArray **sam /* [out] [ref] */,
2655 uint32_t max_size /* [in] */,
2656 uint32_t *num_entries /* [out] [ref] */)
2657 {
2658 struct samr_EnumDomainAliases r;
2659 NTSTATUS status;
2660
2661 /* In parameters */
2662 r.in.domain_handle = domain_handle;
2663 r.in.resume_handle = resume_handle;
2664 r.in.max_size = max_size;
2665
2666 if (DEBUGLEVEL >= 10) {
2667 NDR_PRINT_IN_DEBUG(samr_EnumDomainAliases, &r);
2668 }
2669
2670 status = cli->dispatch(cli,
2671 mem_ctx,
2672 &ndr_table_samr,
2673 NDR_SAMR_ENUMDOMAINALIASES,
2674 &r);
2675
2676 if (!NT_STATUS_IS_OK(status)) {
2677 return status;
2678 }
2679
2680 if (DEBUGLEVEL >= 10) {
2681 NDR_PRINT_OUT_DEBUG(samr_EnumDomainAliases, &r);
2682 }
2683
2684 if (NT_STATUS_IS_ERR(status)) {
2685 return status;
2686 }
2687
2688 /* Return variables */
2689 *resume_handle = *r.out.resume_handle;
2690 *sam = *r.out.sam;
2691 *num_entries = *r.out.num_entries;
2692
2693 /* Return result */
2694 return r.out.result;
2695 }
2696
2697 struct rpccli_samr_GetAliasMembership_state {
2698 struct samr_GetAliasMembership orig;
2699 struct samr_GetAliasMembership tmp;
2700 TALLOC_CTX *out_mem_ctx;
2701 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2702 };
2703
2704 static void rpccli_samr_GetAliasMembership_done(struct tevent_req *subreq);
2705
2706 struct tevent_req *rpccli_samr_GetAliasMembership_send(TALLOC_CTX *mem_ctx,
2707 struct tevent_context *ev,
2708 struct rpc_pipe_client *cli,
2709 struct policy_handle *_domain_handle /* [in] [ref] */,
2710 struct lsa_SidArray *_sids /* [in] [ref] */,
2711 struct samr_Ids *_rids /* [out] [ref] */)
2712 {
2713 struct tevent_req *req;
2714 struct rpccli_samr_GetAliasMembership_state *state;
2715 struct tevent_req *subreq;
2716
2717 req = tevent_req_create(mem_ctx, &state,
2718 struct rpccli_samr_GetAliasMembership_state);
2719 if (req == NULL) {
2720 return NULL;
2721 }
2722 state->out_mem_ctx = NULL;
2723 state->dispatch_recv = cli->dispatch_recv;
2724
2725 /* In parameters */
2726 state->orig.in.domain_handle = _domain_handle;
2727 state->orig.in.sids = _sids;
2728
2729 /* Out parameters */
2730 state->orig.out.rids = _rids;
2731
2732 /* Result */
2733 ZERO_STRUCT(state->orig.out.result);
2734
2735 if (DEBUGLEVEL >= 10) {
2736 NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, &state->orig);
2737 }
2738
2739 state->out_mem_ctx = talloc_named_const(state, 0,
2740 "rpccli_samr_GetAliasMembership_out_memory");
2741 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2742 return tevent_req_post(req, ev);
2743 }
2744
2745 /* make a temporary copy, that we pass to the dispatch function */
2746 state->tmp = state->orig;
2747
2748 subreq = cli->dispatch_send(state, ev, cli,
2749 &ndr_table_samr,
2750 NDR_SAMR_GETALIASMEMBERSHIP,
2751 &state->tmp);
2752 if (tevent_req_nomem(subreq, req)) {
2753 return tevent_req_post(req, ev);
2754 }
2755 tevent_req_set_callback(subreq, rpccli_samr_GetAliasMembership_done, req);
2756 return req;
2757 }
2758
2759 static void rpccli_samr_GetAliasMembership_done(struct tevent_req *subreq)
2760 {
2761 struct tevent_req *req = tevent_req_callback_data(
2762 subreq, struct tevent_req);
2763 struct rpccli_samr_GetAliasMembership_state *state = tevent_req_data(
2764 req, struct rpccli_samr_GetAliasMembership_state);
2765 NTSTATUS status;
2766 TALLOC_CTX *mem_ctx;
2767
2768 if (state->out_mem_ctx) {
2769 mem_ctx = state->out_mem_ctx;
2770 } else {
2771 mem_ctx = state;
2772 }
2773
2774 status = state->dispatch_recv(subreq, mem_ctx);
2775 TALLOC_FREE(subreq);
2776 if (!NT_STATUS_IS_OK(status)) {
2777 tevent_req_nterror(req, status);
2778 return;
2779 }
2780
2781 /* Copy out parameters */
2782 *state->orig.out.rids = *state->tmp.out.rids;
2783
2784 /* Copy result */
2785 state->orig.out.result = state->tmp.out.result;
2786
2787 /* Reset temporary structure */
2788 ZERO_STRUCT(state->tmp);
2789
2790 if (DEBUGLEVEL >= 10) {
2791 NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, &state->orig);
2792 }
2793
2794 tevent_req_done(req);
2795 }
2796
2797 NTSTATUS rpccli_samr_GetAliasMembership_recv(struct tevent_req *req,
2798 TALLOC_CTX *mem_ctx,
2799 NTSTATUS *result)
2800 {
2801 struct rpccli_samr_GetAliasMembership_state *state = tevent_req_data(
2802 req, struct rpccli_samr_GetAliasMembership_state);
2803 NTSTATUS status;
2804
2805 if (tevent_req_is_nterror(req, &status)) {
2806 tevent_req_received(req);
2807 return status;
2808 }
2809
2810 /* Steal possbile out parameters to the callers context */
2811 talloc_steal(mem_ctx, state->out_mem_ctx);
2812
2813 /* Return result */
2814 *result = state->orig.out.result;
2815
2816 tevent_req_received(req);
2817 return NT_STATUS_OK;
2818 }
2819
2820 NTSTATUS rpccli_samr_GetAliasMembership(struct rpc_pipe_client *cli,
2821 TALLOC_CTX *mem_ctx,
2822 struct policy_handle *domain_handle /* [in] [ref] */,
2823 struct lsa_SidArray *sids /* [in] [ref] */,
2824 struct samr_Ids *rids /* [out] [ref] */)
2825 {
2826 struct samr_GetAliasMembership r;
2827 NTSTATUS status;
2828
2829 /* In parameters */
2830 r.in.domain_handle = domain_handle;
2831 r.in.sids = sids;
2832
2833 if (DEBUGLEVEL >= 10) {
2834 NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, &r);
2835 }
2836
2837 status = cli->dispatch(cli,
2838 mem_ctx,
2839 &ndr_table_samr,
2840 NDR_SAMR_GETALIASMEMBERSHIP,
2841 &r);
2842
2843 if (!NT_STATUS_IS_OK(status)) {
2844 return status;
2845 }
2846
2847 if (DEBUGLEVEL >= 10) {
2848 NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, &r);
2849 }
2850
2851 if (NT_STATUS_IS_ERR(status)) {
2852 return status;
2853 }
2854
2855 /* Return variables */
2856 *rids = *r.out.rids;
2857
2858 /* Return result */
2859 return r.out.result;
2860 }
2861
2862 struct rpccli_samr_LookupNames_state {
2863 struct samr_LookupNames orig;
2864 struct samr_LookupNames tmp;
2865 TALLOC_CTX *out_mem_ctx;
2866 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2867 };
2868
2869 static void rpccli_samr_LookupNames_done(struct tevent_req *subreq);
2870
2871 struct tevent_req *rpccli_samr_LookupNames_send(TALLOC_CTX *mem_ctx,
2872 struct tevent_context *ev,
2873 struct rpc_pipe_client *cli,
2874 struct policy_handle *_domain_handle /* [in] [ref] */,
2875 uint32_t _num_names /* [in] [range(0,1000)] */,
2876 struct lsa_String *_names /* [in] [length_is(num_names),size_is(1000)] */,
2877 struct samr_Ids *_rids /* [out] [ref] */,
2878 struct samr_Ids *_types /* [out] [ref] */)
2879 {
2880 struct tevent_req *req;
2881 struct rpccli_samr_LookupNames_state *state;
2882 struct tevent_req *subreq;
2883
2884 req = tevent_req_create(mem_ctx, &state,
2885 struct rpccli_samr_LookupNames_state);
2886 if (req == NULL) {
2887 return NULL;
2888 }
2889 state->out_mem_ctx = NULL;
2890 state->dispatch_recv = cli->dispatch_recv;
2891
2892 /* In parameters */
2893 state->orig.in.domain_handle = _domain_handle;
2894 state->orig.in.num_names = _num_names;
2895 state->orig.in.names = _names;
2896
2897 /* Out parameters */
2898 state->orig.out.rids = _rids;
2899 state->orig.out.types = _types;
2900
2901 /* Result */
2902 ZERO_STRUCT(state->orig.out.result);
2903
2904 if (DEBUGLEVEL >= 10) {
2905 NDR_PRINT_IN_DEBUG(samr_LookupNames, &state->orig);
2906 }
2907
2908 state->out_mem_ctx = talloc_named_const(state, 0,
2909 "rpccli_samr_LookupNames_out_memory");
2910 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2911 return tevent_req_post(req, ev);
2912 }
2913
2914 /* make a temporary copy, that we pass to the dispatch function */
2915 state->tmp = state->orig;
2916
2917 subreq = cli->dispatch_send(state, ev, cli,
2918 &ndr_table_samr,
2919 NDR_SAMR_LOOKUPNAMES,
2920 &state->tmp);
2921 if (tevent_req_nomem(subreq, req)) {
2922 return tevent_req_post(req, ev);
2923 }
2924 tevent_req_set_callback(subreq, rpccli_samr_LookupNames_done, req);
2925 return req;
2926 }
2927
2928 static void rpccli_samr_LookupNames_done(struct tevent_req *subreq)
2929 {
2930 struct tevent_req *req = tevent_req_callback_data(
2931 subreq, struct tevent_req);
2932 struct rpccli_samr_LookupNames_state *state = tevent_req_data(
2933 req, struct rpccli_samr_LookupNames_state);
2934 NTSTATUS status;
2935 TALLOC_CTX *mem_ctx;
2936
2937 if (state->out_mem_ctx) {
2938 mem_ctx = state->out_mem_ctx;
2939 } else {
2940 mem_ctx = state;
2941 }
2942
2943 status = state->dispatch_recv(subreq, mem_ctx);
2944 TALLOC_FREE(subreq);
2945 if (!NT_STATUS_IS_OK(status)) {
2946 tevent_req_nterror(req, status);
2947 return;
2948 }
2949
2950 /* Copy out parameters */
2951 *state->orig.out.rids = *state->tmp.out.rids;
2952 *state->orig.out.types = *state->tmp.out.types;
2953
2954 /* Copy result */
2955 state->orig.out.result = state->tmp.out.result;
2956
2957 /* Reset temporary structure */
2958 ZERO_STRUCT(state->tmp);
2959
2960 if (DEBUGLEVEL >= 10) {
2961 NDR_PRINT_OUT_DEBUG(samr_LookupNames, &state->orig);
2962 }
2963
2964 tevent_req_done(req);
2965 }
2966
2967 NTSTATUS rpccli_samr_LookupNames_recv(struct tevent_req *req,
2968 TALLOC_CTX *mem_ctx,
2969 NTSTATUS *result)
2970 {
2971 struct rpccli_samr_LookupNames_state *state = tevent_req_data(
2972 req, struct rpccli_samr_LookupNames_state);
2973 NTSTATUS status;
2974
2975 if (tevent_req_is_nterror(req, &status)) {
2976 tevent_req_received(req);
2977 return status;
2978 }
2979
2980 /* Steal possbile out parameters to the callers context */
2981 talloc_steal(mem_ctx, state->out_mem_ctx);
2982
2983 /* Return result */
2984 *result = state->orig.out.result;
2985
2986 tevent_req_received(req);
2987 return NT_STATUS_OK;
2988 }
2989
2990 NTSTATUS rpccli_samr_LookupNames(struct rpc_pipe_client *cli,
2991 TALLOC_CTX *mem_ctx,
2992 struct policy_handle *domain_handle /* [in] [ref] */,
2993 uint32_t num_names /* [in] [range(0,1000)] */,
2994 struct lsa_String *names /* [in] [length_is(num_names),size_is(1000)] */,
2995 struct samr_Ids *rids /* [out] [ref] */,
2996 struct samr_Ids *types /* [out] [ref] */)
2997 {
2998 struct samr_LookupNames r;
2999 NTSTATUS status;
3000
3001 /* In parameters */
3002 r.in.domain_handle = domain_handle;
3003 r.in.num_names = num_names;
3004 r.in.names = names;
3005
3006 if (DEBUGLEVEL >= 10) {
3007 NDR_PRINT_IN_DEBUG(samr_LookupNames, &r);
3008 }
3009
3010 status = cli->dispatch(cli,
3011 mem_ctx,
3012 &ndr_table_samr,
3013 NDR_SAMR_LOOKUPNAMES,
3014 &r);
3015
3016 if (!NT_STATUS_IS_OK(status)) {
3017 return status;
3018 }
3019
3020 if (DEBUGLEVEL >= 10) {
3021 NDR_PRINT_OUT_DEBUG(samr_LookupNames, &r);
3022 }
3023
3024 if (NT_STATUS_IS_ERR(status)) {
3025 return status;
3026 }
3027
3028 /* Return variables */
3029 *rids = *r.out.rids;
3030 *types = *r.out.types;
3031
3032 /* Return result */
3033 return r.out.result;
3034 }
3035
3036 struct rpccli_samr_LookupRids_state {
3037 struct samr_LookupRids orig;
3038 struct samr_LookupRids tmp;
3039 TALLOC_CTX *out_mem_ctx;
3040 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3041 };
3042
3043 static void rpccli_samr_LookupRids_done(struct tevent_req *subreq);
3044
3045 struct tevent_req *rpccli_samr_LookupRids_send(TALLOC_CTX *mem_ctx,
3046 struct tevent_context *ev,
3047 struct rpc_pipe_client *cli,
3048 struct policy_handle *_domain_handle /* [in] [ref] */,
3049 uint32_t _num_rids /* [in] [range(0,1000)] */,
3050 uint32_t *_rids /* [in] [length_is(num_rids),size_is(1000)] */,
3051 struct lsa_Strings *_names /* [out] [ref] */,
3052 struct samr_Ids *_types /* [out] [ref] */)
3053 {
3054 struct tevent_req *req;
3055 struct rpccli_samr_LookupRids_state *state;
3056 struct tevent_req *subreq;
3057
3058 req = tevent_req_create(mem_ctx, &state,
3059 struct rpccli_samr_LookupRids_state);
3060 if (req == NULL) {
3061 return NULL;
3062 }
3063 state->out_mem_ctx = NULL;
3064 state->dispatch_recv = cli->dispatch_recv;
3065
3066 /* In parameters */
3067 state->orig.in.domain_handle = _domain_handle;
3068 state->orig.in.num_rids = _num_rids;
3069 state->orig.in.rids = _rids;
3070
3071 /* Out parameters */
3072 state->orig.out.names = _names;
3073 state->orig.out.types = _types;
3074
3075 /* Result */
3076 ZERO_STRUCT(state->orig.out.result);
3077
3078 if (DEBUGLEVEL >= 10) {
3079 NDR_PRINT_IN_DEBUG(samr_LookupRids, &state->orig);
3080 }
3081
3082 state->out_mem_ctx = talloc_named_const(state, 0,
3083 "rpccli_samr_LookupRids_out_memory");
3084 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3085 return tevent_req_post(req, ev);
3086 }
3087
3088 /* make a temporary copy, that we pass to the dispatch function */
3089 state->tmp = state->orig;
3090
3091 subreq = cli->dispatch_send(state, ev, cli,
3092 &ndr_table_samr,
3093 NDR_SAMR_LOOKUPRIDS,
3094 &state->tmp);
3095 if (tevent_req_nomem(subreq, req)) {
3096 return tevent_req_post(req, ev);
3097 }
3098 tevent_req_set_callback(subreq, rpccli_samr_LookupRids_done, req);
3099 return req;
3100 }
3101
3102 static void rpccli_samr_LookupRids_done(struct tevent_req *subreq)
3103 {
3104 struct tevent_req *req = tevent_req_callback_data(
3105 subreq, struct tevent_req);
3106 struct rpccli_samr_LookupRids_state *state = tevent_req_data(
3107 req, struct rpccli_samr_LookupRids_state);
3108 NTSTATUS status;
3109 TALLOC_CTX *mem_ctx;
3110
3111 if (state->out_mem_ctx) {
3112 mem_ctx = state->out_mem_ctx;
3113 } else {
3114 mem_ctx = state;
3115 }
3116
3117 status = state->dispatch_recv(subreq, mem_ctx);
3118 TALLOC_FREE(subreq);
3119 if (!NT_STATUS_IS_OK(status)) {
3120 tevent_req_nterror(req, status);
3121 return;
3122 }
3123
3124 /* Copy out parameters */
3125 *state->orig.out.names = *state->tmp.out.names;
3126 *state->orig.out.types = *state->tmp.out.types;
3127
3128 /* Copy result */
3129 state->orig.out.result = state->tmp.out.result;
3130
3131 /* Reset temporary structure */
3132 ZERO_STRUCT(state->tmp);
3133
3134 if (DEBUGLEVEL >= 10) {
3135 NDR_PRINT_OUT_DEBUG(samr_LookupRids, &state->orig);
3136 }
3137
3138 tevent_req_done(req);
3139 }
3140
3141 NTSTATUS rpccli_samr_LookupRids_recv(struct tevent_req *req,
3142 TALLOC_CTX *mem_ctx,
3143 NTSTATUS *result)
3144 {
3145 struct rpccli_samr_LookupRids_state *state = tevent_req_data(
3146 req, struct rpccli_samr_LookupRids_state);
3147 NTSTATUS status;
3148
3149 if (tevent_req_is_nterror(req, &status)) {
3150 tevent_req_received(req);
3151 return status;
3152 }
3153
3154 /* Steal possbile out parameters to the callers context */
3155 talloc_steal(mem_ctx, state->out_mem_ctx);
3156
3157 /* Return result */
3158 *result = state->orig.out.result;
3159
3160 tevent_req_received(req);
3161 return NT_STATUS_OK;
3162 }
3163
3164 NTSTATUS rpccli_samr_LookupRids(struct rpc_pipe_client *cli,
3165 TALLOC_CTX *mem_ctx,
3166 struct policy_handle *domain_handle /* [in] [ref] */,
3167 uint32_t num_rids /* [in] [range(0,1000)] */,
3168 uint32_t *rids /* [in] [length_is(num_rids),size_is(1000)] */,
3169 struct lsa_Strings *names /* [out] [ref] */,
3170 struct samr_Ids *types /* [out] [ref] */)
3171 {
3172 struct samr_LookupRids r;
3173 NTSTATUS status;
3174
3175 /* In parameters */
3176 r.in.domain_handle = domain_handle;
3177 r.in.num_rids = num_rids;
3178 r.in.rids = rids;
3179
3180 if (DEBUGLEVEL >= 10) {
3181 NDR_PRINT_IN_DEBUG(samr_LookupRids, &r);
3182 }
3183
3184 status = cli->dispatch(cli,
3185 mem_ctx,
3186 &ndr_table_samr,
3187 NDR_SAMR_LOOKUPRIDS,
3188 &r);
3189
3190 if (!NT_STATUS_IS_OK(status)) {
3191 return status;
3192 }
3193
3194 if (DEBUGLEVEL >= 10) {
3195 NDR_PRINT_OUT_DEBUG(samr_LookupRids, &r);
3196 }
3197
3198 if (NT_STATUS_IS_ERR(status)) {
3199 return status;
3200 }
3201
3202 /* Return variables */
3203 *names = *r.out.names;
3204 *types = *r.out.types;
3205
3206 /* Return result */
3207 return r.out.result;
3208 }
3209
3210 struct rpccli_samr_OpenGroup_state {
3211 struct samr_OpenGroup orig;
3212 struct samr_OpenGroup tmp;
3213 TALLOC_CTX *out_mem_ctx;
3214 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3215 };
3216
3217 static void rpccli_samr_OpenGroup_done(struct tevent_req *subreq);
3218
3219 struct tevent_req *rpccli_samr_OpenGroup_send(TALLOC_CTX *mem_ctx,
3220 struct tevent_context *ev,
3221 struct rpc_pipe_client *cli,
3222 struct policy_handle *_domain_handle /* [in] [ref] */,
3223 uint32_t _access_mask /* [in] */,
3224 uint32_t _rid /* [in] */,
3225 struct policy_handle *_group_handle /* [out] [ref] */)
3226 {
3227 struct tevent_req *req;
3228 struct rpccli_samr_OpenGroup_state *state;
3229 struct tevent_req *subreq;
3230
3231 req = tevent_req_create(mem_ctx, &state,
3232 struct rpccli_samr_OpenGroup_state);
3233 if (req == NULL) {
3234 return NULL;
3235 }
3236 state->out_mem_ctx = NULL;
3237 state->dispatch_recv = cli->dispatch_recv;
3238
3239 /* In parameters */
3240 state->orig.in.domain_handle = _domain_handle;
3241 state->orig.in.access_mask = _access_mask;
3242 state->orig.in.rid = _rid;
3243
3244 /* Out parameters */
3245 state->orig.out.group_handle = _group_handle;
3246
3247 /* Result */
3248 ZERO_STRUCT(state->orig.out.result);
3249
3250 if (DEBUGLEVEL >= 10) {
3251 NDR_PRINT_IN_DEBUG(samr_OpenGroup, &state->orig);
3252 }
3253
3254 state->out_mem_ctx = talloc_named_const(state, 0,
3255 "rpccli_samr_OpenGroup_out_memory");
3256 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3257 return tevent_req_post(req, ev);
3258 }
3259
3260 /* make a temporary copy, that we pass to the dispatch function */
3261 state->tmp = state->orig;
3262
3263 subreq = cli->dispatch_send(state, ev, cli,
3264 &ndr_table_samr,
3265 NDR_SAMR_OPENGROUP,
3266 &state->tmp);
3267 if (tevent_req_nomem(subreq, req)) {
3268 return tevent_req_post(req, ev);
3269 }
3270 tevent_req_set_callback(subreq, rpccli_samr_OpenGroup_done, req);
3271 return req;
3272 }
3273
3274 static void rpccli_samr_OpenGroup_done(struct tevent_req *subreq)
3275 {
3276 struct tevent_req *req = tevent_req_callback_data(
3277 subreq, struct tevent_req);
3278 struct rpccli_samr_OpenGroup_state *state = tevent_req_data(
3279 req, struct rpccli_samr_OpenGroup_state);
3280 NTSTATUS status;
3281 TALLOC_CTX *mem_ctx;
3282
3283 if (state->out_mem_ctx) {
3284 mem_ctx = state->out_mem_ctx;
3285 } else {
3286 mem_ctx = state;
3287 }
3288
3289 status = state->dispatch_recv(subreq, mem_ctx);
3290 TALLOC_FREE(subreq);
3291 if (!NT_STATUS_IS_OK(status)) {
3292 tevent_req_nterror(req, status);
3293 return;
3294 }
3295
3296 /* Copy out parameters */
3297 *state->orig.out.group_handle = *state->tmp.out.group_handle;
3298
3299 /* Copy result */
3300 state->orig.out.result = state->tmp.out.result;
3301
3302 /* Reset temporary structure */
3303 ZERO_STRUCT(state->tmp);
3304
3305 if (DEBUGLEVEL >= 10) {
3306 NDR_PRINT_OUT_DEBUG(samr_OpenGroup, &state->orig);
3307 }
3308
3309 tevent_req_done(req);
3310 }
3311
3312 NTSTATUS rpccli_samr_OpenGroup_recv(struct tevent_req *req,
3313 TALLOC_CTX *mem_ctx,
3314 NTSTATUS *result)
3315 {
3316 struct rpccli_samr_OpenGroup_state *state = tevent_req_data(
3317 req, struct rpccli_samr_OpenGroup_state);
3318 NTSTATUS status;
3319
3320 if (tevent_req_is_nterror(req, &status)) {
3321 tevent_req_received(req);
3322 return status;
3323 }
3324
3325 /* Steal possbile out parameters to the callers context */
3326 talloc_steal(mem_ctx, state->out_mem_ctx);
3327
3328 /* Return result */
3329 *result = state->orig.out.result;
3330
3331 tevent_req_received(req);
3332 return NT_STATUS_OK;
3333 }
3334
3335 NTSTATUS rpccli_samr_OpenGroup(struct rpc_pipe_client *cli,
3336 TALLOC_CTX *mem_ctx,
3337 struct policy_handle *domain_handle /* [in] [ref] */,
3338 uint32_t access_mask /* [in] */,
3339 uint32_t rid /* [in] */,
3340 struct policy_handle *group_handle /* [out] [ref] */)
3341 {
3342 struct samr_OpenGroup r;
3343 NTSTATUS status;
3344
3345 /* In parameters */
3346 r.in.domain_handle = domain_handle;
3347 r.in.access_mask = access_mask;
3348 r.in.rid = rid;
3349
3350 if (DEBUGLEVEL >= 10) {
3351 NDR_PRINT_IN_DEBUG(samr_OpenGroup, &r);
3352 }
3353
3354 status = cli->dispatch(cli,
3355 mem_ctx,
3356 &ndr_table_samr,
3357 NDR_SAMR_OPENGROUP,
3358 &r);
3359
3360 if (!NT_STATUS_IS_OK(status)) {
3361 return status;
3362 }
3363
3364 if (DEBUGLEVEL >= 10) {
3365 NDR_PRINT_OUT_DEBUG(samr_OpenGroup, &r);
3366 }
3367
3368 if (NT_STATUS_IS_ERR(status)) {
3369 return status;
3370 }
3371
3372 /* Return variables */
3373 *group_handle = *r.out.group_handle;
3374
3375 /* Return result */
3376 return r.out.result;
3377 }
3378
3379 struct rpccli_samr_QueryGroupInfo_state {
3380 struct samr_QueryGroupInfo orig;
3381 struct samr_QueryGroupInfo tmp;
3382 TALLOC_CTX *out_mem_ctx;
3383 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3384 };
3385
3386 static void rpccli_samr_QueryGroupInfo_done(struct tevent_req *subreq);
3387
3388 struct tevent_req *rpccli_samr_QueryGroupInfo_send(TALLOC_CTX *mem_ctx,
3389 struct tevent_context *ev,
3390 struct rpc_pipe_client *cli,
3391 struct policy_handle *_group_handle /* [in] [ref] */,
3392 enum samr_GroupInfoEnum _level /* [in] */,
3393 union samr_GroupInfo **_info /* [out] [ref,switch_is(level)] */)
3394 {
3395 struct tevent_req *req;
3396 struct rpccli_samr_QueryGroupInfo_state *state;
3397 struct tevent_req *subreq;
3398
3399 req = tevent_req_create(mem_ctx, &state,
3400 struct rpccli_samr_QueryGroupInfo_state);
3401 if (req == NULL) {
3402 return NULL;
3403 }
3404 state->out_mem_ctx = NULL;
3405 state->dispatch_recv = cli->dispatch_recv;
3406
3407 /* In parameters */
3408 state->orig.in.group_handle = _group_handle;
3409 state->orig.in.level = _level;
3410
3411 /* Out parameters */
3412 state->orig.out.info = _info;
3413
3414 /* Result */
3415 ZERO_STRUCT(state->orig.out.result);
3416
3417 if (DEBUGLEVEL >= 10) {
3418 NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, &state->orig);
3419 }
3420
3421 state->out_mem_ctx = talloc_named_const(state, 0,
3422 "rpccli_samr_QueryGroupInfo_out_memory");
3423 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3424 return tevent_req_post(req, ev);
3425 }
3426
3427 /* make a temporary copy, that we pass to the dispatch function */
3428 state->tmp = state->orig;
3429
3430 subreq = cli->dispatch_send(state, ev, cli,
3431 &ndr_table_samr,
3432 NDR_SAMR_QUERYGROUPINFO,
3433 &state->tmp);
3434 if (tevent_req_nomem(subreq, req)) {
3435 return tevent_req_post(req, ev);
3436 }
3437 tevent_req_set_callback(subreq, rpccli_samr_QueryGroupInfo_done, req);
3438 return req;
3439 }
3440
3441 static void rpccli_samr_QueryGroupInfo_done(struct tevent_req *subreq)
3442 {
3443 struct tevent_req *req = tevent_req_callback_data(
3444 subreq, struct tevent_req);
3445 struct rpccli_samr_QueryGroupInfo_state *state = tevent_req_data(
3446 req, struct rpccli_samr_QueryGroupInfo_state);
3447 NTSTATUS status;
3448 TALLOC_CTX *mem_ctx;
3449
3450 if (state->out_mem_ctx) {
3451 mem_ctx = state->out_mem_ctx;
3452 } else {
3453 mem_ctx = state;
3454 }
3455
3456 status = state->dispatch_recv(subreq, mem_ctx);
3457 TALLOC_FREE(subreq);
3458 if (!NT_STATUS_IS_OK(status)) {
3459 tevent_req_nterror(req, status);
3460 return;
3461 }
3462
3463 /* Copy out parameters */
3464 *state->orig.out.info = *state->tmp.out.info;
3465
3466 /* Copy result */
3467 state->orig.out.result = state->tmp.out.result;
3468
3469 /* Reset temporary structure */
3470 ZERO_STRUCT(state->tmp);
3471
3472 if (DEBUGLEVEL >= 10) {
3473 NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, &state->orig);
3474 }
3475
3476 tevent_req_done(req);
3477 }
3478
3479 NTSTATUS rpccli_samr_QueryGroupInfo_recv(struct tevent_req *req,
3480 TALLOC_CTX *mem_ctx,
3481 NTSTATUS *result)
3482 {
3483 struct rpccli_samr_QueryGroupInfo_state *state = tevent_req_data(
3484 req, struct rpccli_samr_QueryGroupInfo_state);
3485 NTSTATUS status;
3486
3487 if (tevent_req_is_nterror(req, &status)) {
3488 tevent_req_received(req);
3489 return status;
3490 }
3491
3492 /* Steal possbile out parameters to the callers context */
3493 talloc_steal(mem_ctx, state->out_mem_ctx);
3494
3495 /* Return result */
3496 *result = state->orig.out.result;
3497
3498 tevent_req_received(req);
3499 return NT_STATUS_OK;
3500 }
3501
3502 NTSTATUS rpccli_samr_QueryGroupInfo(struct rpc_pipe_client *cli,
3503 TALLOC_CTX *mem_ctx,
3504 struct policy_handle *group_handle /* [in] [ref] */,
3505 enum samr_GroupInfoEnum level /* [in] */,
3506 union samr_GroupInfo **info /* [out] [ref,switch_is(level)] */)
3507 {
3508 struct samr_QueryGroupInfo r;
3509 NTSTATUS status;
3510
3511 /* In parameters */
3512 r.in.group_handle = group_handle;
3513 r.in.level = level;
3514
3515 if (DEBUGLEVEL >= 10) {
3516 NDR_PRINT_IN_DEBUG(samr_QueryGroupInfo, &r);
3517 }
3518
3519 status = cli->dispatch(cli,
3520 mem_ctx,
3521 &ndr_table_samr,
3522 NDR_SAMR_QUERYGROUPINFO,
3523 &r);
3524
3525 if (!NT_STATUS_IS_OK(status)) {
3526 return status;
3527 }
3528
3529 if (DEBUGLEVEL >= 10) {
3530 NDR_PRINT_OUT_DEBUG(samr_QueryGroupInfo, &r);
3531 }
3532
3533 if (NT_STATUS_IS_ERR(status)) {
3534 return status;
3535 }
3536
3537 /* Return variables */
3538 *info = *r.out.info;
3539
3540 /* Return result */
3541 return r.out.result;
3542 }
3543
3544 struct rpccli_samr_SetGroupInfo_state {
3545 struct samr_SetGroupInfo orig;
3546 struct samr_SetGroupInfo tmp;
3547 TALLOC_CTX *out_mem_ctx;
3548 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3549 };
3550
3551 static void rpccli_samr_SetGroupInfo_done(struct tevent_req *subreq);
3552
3553 struct tevent_req *rpccli_samr_SetGroupInfo_send(TALLOC_CTX *mem_ctx,
3554 struct tevent_context *ev,
3555 struct rpc_pipe_client *cli,
3556 struct policy_handle *_group_handle /* [in] [ref] */,
3557 enum samr_GroupInfoEnum _level /* [in] */,
3558 union samr_GroupInfo *_info /* [in] [ref,switch_is(level)] */)
3559 {
3560 struct tevent_req *req;
3561 struct rpccli_samr_SetGroupInfo_state *state;
3562 struct tevent_req *subreq;
3563
3564 req = tevent_req_create(mem_ctx, &state,
3565 struct rpccli_samr_SetGroupInfo_state);
3566 if (req == NULL) {
3567 return NULL;
3568 }
3569 state->out_mem_ctx = NULL;
3570 state->dispatch_recv = cli->dispatch_recv;
3571
3572 /* In parameters */
3573 state->orig.in.group_handle = _group_handle;
3574 state->orig.in.level = _level;
3575 state->orig.in.info = _info;
3576
3577 /* Out parameters */
3578
3579 /* Result */
3580 ZERO_STRUCT(state->orig.out.result);
3581
3582 if (DEBUGLEVEL >= 10) {
3583 NDR_PRINT_IN_DEBUG(samr_SetGroupInfo, &state->orig);
3584 }
3585
3586 /* make a temporary copy, that we pass to the dispatch function */
3587 state->tmp = state->orig;
3588
3589 subreq = cli->dispatch_send(state, ev, cli,
3590 &ndr_table_samr,
3591 NDR_SAMR_SETGROUPINFO,
3592 &state->tmp);
3593 if (tevent_req_nomem(subreq, req)) {
3594 return tevent_req_post(req, ev);
3595 }
3596 tevent_req_set_callback(subreq, rpccli_samr_SetGroupInfo_done, req);
3597 return req;
3598 }
3599
3600 static void rpccli_samr_SetGroupInfo_done(struct tevent_req *subreq)
3601 {
3602 struct tevent_req *req = tevent_req_callback_data(
3603 subreq, struct tevent_req);
3604 struct rpccli_samr_SetGroupInfo_state *state = tevent_req_data(
3605 req, struct rpccli_samr_SetGroupInfo_state);
3606 NTSTATUS status;
3607 TALLOC_CTX *mem_ctx;
3608
3609 if (state->out_mem_ctx) {
3610 mem_ctx = state->out_mem_ctx;
3611 } else {
3612 mem_ctx = state;
3613 }
3614
3615 status = state->dispatch_recv(subreq, mem_ctx);
3616 TALLOC_FREE(subreq);
3617 if (!NT_STATUS_IS_OK(status)) {
3618 tevent_req_nterror(req, status);
3619 return;
3620 }
3621
3622 /* Copy out parameters */
3623
3624 /* Copy result */
3625 state->orig.out.result = state->tmp.out.result;
3626
3627 /* Reset temporary structure */
3628 ZERO_STRUCT(state->tmp);
3629
3630 if (DEBUGLEVEL >= 10) {
3631 NDR_PRINT_OUT_DEBUG(samr_SetGroupInfo, &state->orig);
3632 }
3633
3634 tevent_req_done(req);
3635 }
3636
3637 NTSTATUS rpccli_samr_SetGroupInfo_recv(struct tevent_req *req,
3638 TALLOC_CTX *mem_ctx,
3639 NTSTATUS *result)
3640 {
3641 struct rpccli_samr_SetGroupInfo_state *state = tevent_req_data(
3642 req, struct rpccli_samr_SetGroupInfo_state);
3643 NTSTATUS status;
3644
3645 if (tevent_req_is_nterror(req, &status)) {
3646 tevent_req_received(req);
3647 return status;
3648 }
3649
3650 /* Steal possbile out parameters to the callers context */
3651 talloc_steal(mem_ctx, state->out_mem_ctx);
3652
3653 /* Return result */
3654 *result = state->orig.out.result;
3655
3656 tevent_req_received(req);
3657 return NT_STATUS_OK;
3658 }
3659
3660 NTSTATUS rpccli_samr_SetGroupInfo(struct rpc_pipe_client *cli,
3661 TALLOC_CTX *mem_ctx,
3662 struct policy_handle *group_handle /* [in] [ref] */,
3663 enum samr_GroupInfoEnum level /* [in] */,
3664 union samr_GroupInfo *info /* [in] [ref,switch_is(level)] */)
3665 {
3666 struct samr_SetGroupInfo r;
3667 NTSTATUS status;
3668
3669 /* In parameters */
3670 r.in.group_handle = group_handle;
3671 r.in.level = level;
3672 r.in.info = info;
3673
3674 if (DEBUGLEVEL >= 10) {
3675 NDR_PRINT_IN_DEBUG(samr_SetGroupInfo, &r);
3676 }
3677
3678 status = cli->dispatch(cli,
3679 mem_ctx,
3680 &ndr_table_samr,
3681 NDR_SAMR_SETGROUPINFO,
3682 &r);
3683
3684 if (!NT_STATUS_IS_OK(status)) {
3685 return status;
3686 }
3687
3688 if (DEBUGLEVEL >= 10) {
3689 NDR_PRINT_OUT_DEBUG(samr_SetGroupInfo, &r);
3690 }
3691
3692 if (NT_STATUS_IS_ERR(status)) {
3693 return status;
3694 }
3695
3696 /* Return variables */
3697
3698 /* Return result */
3699 return r.out.result;
3700 }
3701
3702 struct rpccli_samr_AddGroupMember_state {
3703 struct samr_AddGroupMember orig;
3704 struct samr_AddGroupMember tmp;
3705 TALLOC_CTX *out_mem_ctx;
3706 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3707 };
3708
3709 static void rpccli_samr_AddGroupMember_done(struct tevent_req *subreq);
3710
3711 struct tevent_req *rpccli_samr_AddGroupMember_send(TALLOC_CTX *mem_ctx,
3712 struct tevent_context *ev,
3713 struct rpc_pipe_client *cli,
3714 struct policy_handle *_group_handle /* [in] [ref] */,
3715 uint32_t _rid /* [in] */,
3716 uint32_t _flags /* [in] */)
3717 {
3718 struct tevent_req *req;
3719 struct rpccli_samr_AddGroupMember_state *state;
3720 struct tevent_req *subreq;
3721
3722 req = tevent_req_create(mem_ctx, &state,
3723 struct rpccli_samr_AddGroupMember_state);
3724 if (req == NULL) {
3725 return NULL;
3726 }
3727 state->out_mem_ctx = NULL;
3728 state->dispatch_recv = cli->dispatch_recv;
3729
3730 /* In parameters */
3731 state->orig.in.group_handle = _group_handle;
3732 state->orig.in.rid = _rid;
3733 state->orig.in.flags = _flags;
3734
3735 /* Out parameters */
3736
3737 /* Result */
3738 ZERO_STRUCT(state->orig.out.result);
3739
3740 if (DEBUGLEVEL >= 10) {
3741 NDR_PRINT_IN_DEBUG(samr_AddGroupMember, &state->orig);
3742 }
3743
3744 /* make a temporary copy, that we pass to the dispatch function */
3745 state->tmp = state->orig;
3746
3747 subreq = cli->dispatch_send(state, ev, cli,
3748 &ndr_table_samr,
3749 NDR_SAMR_ADDGROUPMEMBER,
3750 &state->tmp);
3751 if (tevent_req_nomem(subreq, req)) {
3752 return tevent_req_post(req, ev);
3753 }
3754 tevent_req_set_callback(subreq, rpccli_samr_AddGroupMember_done, req);
3755 return req;
3756 }
3757
3758 static void rpccli_samr_AddGroupMember_done(struct tevent_req *subreq)
3759 {
3760 struct tevent_req *req = tevent_req_callback_data(
3761 subreq, struct tevent_req);
3762 struct rpccli_samr_AddGroupMember_state *state = tevent_req_data(
3763 req, struct rpccli_samr_AddGroupMember_state);
3764 NTSTATUS status;
3765 TALLOC_CTX *mem_ctx;
3766
3767 if (state->out_mem_ctx) {
3768 mem_ctx = state->out_mem_ctx;
3769 } else {
3770 mem_ctx = state;
3771 }
3772
3773 status = state->dispatch_recv(subreq, mem_ctx);
3774 TALLOC_FREE(subreq);
3775 if (!NT_STATUS_IS_OK(status)) {
3776 tevent_req_nterror(req, status);
3777 return;
3778 }
3779
3780 /* Copy out parameters */
3781
3782 /* Copy result */
3783 state->orig.out.result = state->tmp.out.result;
3784
3785 /* Reset temporary structure */
3786 ZERO_STRUCT(state->tmp);
3787
3788 if (DEBUGLEVEL >= 10) {
3789 NDR_PRINT_OUT_DEBUG(samr_AddGroupMember, &state->orig);
3790 }
3791
3792 tevent_req_done(req);
3793 }
3794
3795 NTSTATUS rpccli_samr_AddGroupMember_recv(struct tevent_req *req,
3796 TALLOC_CTX *mem_ctx,
3797 NTSTATUS *result)
3798 {
3799 struct rpccli_samr_AddGroupMember_state *state = tevent_req_data(
3800 req, struct rpccli_samr_AddGroupMember_state);
3801 NTSTATUS status;
3802
3803 if (tevent_req_is_nterror(req, &status)) {
3804 tevent_req_received(req);
3805 return status;
3806 }
3807
3808 /* Steal possbile out parameters to the callers context */
3809 talloc_steal(mem_ctx, state->out_mem_ctx);
3810
3811 /* Return result */
3812 *result = state->orig.out.result;
3813
3814 tevent_req_received(req);
3815 return NT_STATUS_OK;
3816 }
3817
3818 NTSTATUS rpccli_samr_AddGroupMember(struct rpc_pipe_client *cli,
3819 TALLOC_CTX *mem_ctx,
3820 struct policy_handle *group_handle /* [in] [ref] */,
3821 uint32_t rid /* [in] */,
3822 uint32_t flags /* [in] */)
3823 {
3824 struct samr_AddGroupMember r;
3825 NTSTATUS status;
3826
3827 /* In parameters */
3828 r.in.group_handle = group_handle;
3829 r.in.rid = rid;
3830 r.in.flags = flags;
3831
3832 if (DEBUGLEVEL >= 10) {
3833 NDR_PRINT_IN_DEBUG(samr_AddGroupMember, &r);
3834 }
3835
3836 status = cli->dispatch(cli,
3837 mem_ctx,
3838 &ndr_table_samr,
3839 NDR_SAMR_ADDGROUPMEMBER,
3840 &r);
3841
3842 if (!NT_STATUS_IS_OK(status)) {
3843 return status;
3844 }
3845
3846 if (DEBUGLEVEL >= 10) {
3847 NDR_PRINT_OUT_DEBUG(samr_AddGroupMember, &r);
3848 }
3849
3850 if (NT_STATUS_IS_ERR(status)) {
3851 return status;
3852 }
3853
3854 /* Return variables */
3855
3856 /* Return result */
3857 return r.out.result;
3858 }
3859
3860 struct rpccli_samr_DeleteDomainGroup_state {
3861 struct samr_DeleteDomainGroup orig;
3862 struct samr_DeleteDomainGroup tmp;
3863 TALLOC_CTX *out_mem_ctx;
3864 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3865 };
3866
3867 static void rpccli_samr_DeleteDomainGroup_done(struct tevent_req *subreq);
3868
3869 struct tevent_req *rpccli_samr_DeleteDomainGroup_send(TALLOC_CTX *mem_ctx,
3870 struct tevent_context *ev,
3871 struct rpc_pipe_client *cli,
3872 struct policy_handle *_group_handle /* [in,out] [ref] */)
3873 {
3874 struct tevent_req *req;
3875 struct rpccli_samr_DeleteDomainGroup_state *state;
3876 struct tevent_req *subreq;
3877
3878 req = tevent_req_create(mem_ctx, &state,
3879 struct rpccli_samr_DeleteDomainGroup_state);
3880 if (req == NULL) {
3881 return NULL;
3882 }
3883 state->out_mem_ctx = NULL;
3884 state->dispatch_recv = cli->dispatch_recv;
3885
3886 /* In parameters */
3887 state->orig.in.group_handle = _group_handle;
3888
3889 /* Out parameters */
3890 state->orig.out.group_handle = _group_handle;
3891
3892 /* Result */
3893 ZERO_STRUCT(state->orig.out.result);
3894
3895 if (DEBUGLEVEL >= 10) {
3896 NDR_PRINT_IN_DEBUG(samr_DeleteDomainGroup, &state->orig);
3897 }
3898
3899 state->out_mem_ctx = talloc_named_const(state, 0,
3900 "rpccli_samr_DeleteDomainGroup_out_memory");
3901 if (tevent_req_nomem(state->out_mem_ctx, req)) {
3902 return tevent_req_post(req, ev);
3903 }
3904
3905 /* make a temporary copy, that we pass to the dispatch function */
3906 state->tmp = state->orig;
3907
3908 subreq = cli->dispatch_send(state, ev, cli,
3909 &ndr_table_samr,
3910 NDR_SAMR_DELETEDOMAINGROUP,
3911 &state->tmp);
3912 if (tevent_req_nomem(subreq, req)) {
3913 return tevent_req_post(req, ev);
3914 }
3915 tevent_req_set_callback(subreq, rpccli_samr_DeleteDomainGroup_done, req);
3916 return req;
3917 }
3918
3919 static void rpccli_samr_DeleteDomainGroup_done(struct tevent_req *subreq)
3920 {
3921 struct tevent_req *req = tevent_req_callback_data(
3922 subreq, struct tevent_req);
3923 struct rpccli_samr_DeleteDomainGroup_state *state = tevent_req_data(
3924 req, struct rpccli_samr_DeleteDomainGroup_state);
3925 NTSTATUS status;
3926 TALLOC_CTX *mem_ctx;
3927
3928 if (state->out_mem_ctx) {
3929 mem_ctx = state->out_mem_ctx;
3930 } else {
3931 mem_ctx = state;
3932 }
3933
3934 status = state->dispatch_recv(subreq, mem_ctx);
3935 TALLOC_FREE(subreq);
3936 if (!NT_STATUS_IS_OK(status)) {
3937 tevent_req_nterror(req, status);
3938 return;
3939 }
3940
3941 /* Copy out parameters */
3942 *state->orig.out.group_handle = *state->tmp.out.group_handle;
3943
3944 /* Copy result */
3945 state->orig.out.result = state->tmp.out.result;
3946
3947 /* Reset temporary structure */
3948 ZERO_STRUCT(state->tmp);
3949
3950 if (DEBUGLEVEL >= 10) {
3951 NDR_PRINT_OUT_DEBUG(samr_DeleteDomainGroup, &state->orig);
3952 }
3953
3954 tevent_req_done(req);
3955 }
3956
3957 NTSTATUS rpccli_samr_DeleteDomainGroup_recv(struct tevent_req *req,
3958 TALLOC_CTX *mem_ctx,
3959 NTSTATUS *result)
3960 {
3961 struct rpccli_samr_DeleteDomainGroup_state *state = tevent_req_data(
3962 req, struct rpccli_samr_DeleteDomainGroup_state);
3963 NTSTATUS status;
3964
3965 if (tevent_req_is_nterror(req, &status)) {
3966 tevent_req_received(req);
3967 return status;
3968 }
3969
3970 /* Steal possbile out parameters to the callers context */
3971 talloc_steal(mem_ctx, state->out_mem_ctx);
3972
3973 /* Return result */
3974 *result = state->orig.out.result;
3975
3976 tevent_req_received(req);
3977 return NT_STATUS_OK;
3978 }
3979
3980 NTSTATUS rpccli_samr_DeleteDomainGroup(struct rpc_pipe_client *cli,
3981 TALLOC_CTX *mem_ctx,
3982 struct policy_handle *group_handle /* [in,out] [ref] */)
3983 {
3984 struct samr_DeleteDomainGroup r;
3985 NTSTATUS status;
3986
3987 /* In parameters */
3988 r.in.group_handle = group_handle;
3989
3990 if (DEBUGLEVEL >= 10) {
3991 NDR_PRINT_IN_DEBUG(samr_DeleteDomainGroup, &r);
3992 }
3993
3994 status = cli->dispatch(cli,
3995 mem_ctx,
3996 &ndr_table_samr,
3997 NDR_SAMR_DELETEDOMAINGROUP,
3998 &r);
3999
4000 if (!NT_STATUS_IS_OK(status)) {
4001 return status;
4002 }
4003
4004 if (DEBUGLEVEL >= 10) {
4005 NDR_PRINT_OUT_DEBUG(samr_DeleteDomainGroup, &r);
4006 }
4007
4008 if (NT_STATUS_IS_ERR(status)) {
4009 return status;
4010 }
4011
4012 /* Return variables */
4013 *group_handle = *r.out.group_handle;
4014
4015 /* Return result */
4016 return r.out.result;
4017 }
4018
4019 struct rpccli_samr_DeleteGroupMember_state {
4020 struct samr_DeleteGroupMember orig;
4021 struct samr_DeleteGroupMember tmp;
4022 TALLOC_CTX *out_mem_ctx;
4023 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4024 };
4025
4026 static void rpccli_samr_DeleteGroupMember_done(struct tevent_req *subreq);
4027
4028 struct tevent_req *rpccli_samr_DeleteGroupMember_send(TALLOC_CTX *mem_ctx,
4029 struct tevent_context *ev,
4030 struct rpc_pipe_client *cli,
4031 struct policy_handle *_group_handle /* [in] [ref] */,
4032 uint32_t _rid /* [in] */)
4033 {
4034 struct tevent_req *req;
4035 struct rpccli_samr_DeleteGroupMember_state *state;
4036 struct tevent_req *subreq;
4037
4038 req = tevent_req_create(mem_ctx, &state,
4039 struct rpccli_samr_DeleteGroupMember_state);
4040 if (req == NULL) {
4041 return NULL;
4042 }
4043 state->out_mem_ctx = NULL;
4044 state->dispatch_recv = cli->dispatch_recv;
4045
4046 /* In parameters */
4047 state->orig.in.group_handle = _group_handle;
4048 state->orig.in.rid = _rid;
4049
4050 /* Out parameters */
4051
4052 /* Result */
4053 ZERO_STRUCT(state->orig.out.result);
4054
4055 if (DEBUGLEVEL >= 10) {
4056 NDR_PRINT_IN_DEBUG(samr_DeleteGroupMember, &state->orig);
4057 }
4058
4059 /* make a temporary copy, that we pass to the dispatch function */
4060 state->tmp = state->orig;
4061
4062 subreq = cli->dispatch_send(state, ev, cli,
4063 &ndr_table_samr,
4064 NDR_SAMR_DELETEGROUPMEMBER,
4065 &state->tmp);
4066 if (tevent_req_nomem(subreq, req)) {
4067 return tevent_req_post(req, ev);
4068 }
4069 tevent_req_set_callback(subreq, rpccli_samr_DeleteGroupMember_done, req);
4070 return req;
4071 }
4072
4073 static void rpccli_samr_DeleteGroupMember_done(struct tevent_req *subreq)
4074 {
4075 struct tevent_req *req = tevent_req_callback_data(
4076 subreq, struct tevent_req);
4077 struct rpccli_samr_DeleteGroupMember_state *state = tevent_req_data(
4078 req, struct rpccli_samr_DeleteGroupMember_state);
4079 NTSTATUS status;
4080 TALLOC_CTX *mem_ctx;
4081
4082 if (state->out_mem_ctx) {
4083 mem_ctx = state->out_mem_ctx;
4084 } else {
4085 mem_ctx = state;
4086 }
4087
4088 status = state->dispatch_recv(subreq, mem_ctx);
4089 TALLOC_FREE(subreq);
4090 if (!NT_STATUS_IS_OK(status)) {
4091 tevent_req_nterror(req, status);
4092 return;
4093 }
4094
4095 /* Copy out parameters */
4096
4097 /* Copy result */
4098 state->orig.out.result = state->tmp.out.result;
4099
4100 /* Reset temporary structure */
4101 ZERO_STRUCT(state->tmp);
4102
4103 if (DEBUGLEVEL >= 10) {
4104 NDR_PRINT_OUT_DEBUG(samr_DeleteGroupMember, &state->orig);
4105 }
4106
4107 tevent_req_done(req);
4108 }
4109
4110 NTSTATUS rpccli_samr_DeleteGroupMember_recv(struct tevent_req *req,
4111 TALLOC_CTX *mem_ctx,
4112 NTSTATUS *result)
4113 {
4114 struct rpccli_samr_DeleteGroupMember_state *state = tevent_req_data(
4115 req, struct rpccli_samr_DeleteGroupMember_state);
4116 NTSTATUS status;
4117
4118 if (tevent_req_is_nterror(req, &status)) {
4119 tevent_req_received(req);
4120 return status;
4121 }
4122
4123 /* Steal possbile out parameters to the callers context */
4124 talloc_steal(mem_ctx, state->out_mem_ctx);
4125
4126 /* Return result */
4127 *result = state->orig.out.result;
4128
4129 tevent_req_received(req);
4130 return NT_STATUS_OK;
4131 }
4132
4133 NTSTATUS rpccli_samr_DeleteGroupMember(struct rpc_pipe_client *cli,
4134 TALLOC_CTX *mem_ctx,
4135 struct policy_handle *group_handle /* [in] [ref] */,
4136 uint32_t rid /* [in] */)
4137 {
4138 struct samr_DeleteGroupMember r;
4139 NTSTATUS status;
4140
4141 /* In parameters */
4142 r.in.group_handle = group_handle;
4143 r.in.rid = rid;
4144
4145 if (DEBUGLEVEL >= 10) {
4146 NDR_PRINT_IN_DEBUG(samr_DeleteGroupMember, &r);
4147 }
4148
4149 status = cli->dispatch(cli,
4150 mem_ctx,
4151 &ndr_table_samr,
4152 NDR_SAMR_DELETEGROUPMEMBER,
4153 &r);
4154
4155 if (!NT_STATUS_IS_OK(status)) {
4156 return status;
4157 }
4158
4159 if (DEBUGLEVEL >= 10) {
4160 NDR_PRINT_OUT_DEBUG(samr_DeleteGroupMember, &r);
4161 }
4162
4163 if (NT_STATUS_IS_ERR(status)) {
4164 return status;
4165 }
4166
4167 /* Return variables */
4168
4169 /* Return result */
4170 return r.out.result;
4171 }
4172
4173 struct rpccli_samr_QueryGroupMember_state {
4174 struct samr_QueryGroupMember orig;
4175 struct samr_QueryGroupMember tmp;
4176 TALLOC_CTX *out_mem_ctx;
4177 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4178 };
4179
4180 static void rpccli_samr_QueryGroupMember_done(struct tevent_req *subreq);
4181
4182 struct tevent_req *rpccli_samr_QueryGroupMember_send(TALLOC_CTX *mem_ctx,
4183 struct tevent_context *ev,
4184 struct rpc_pipe_client *cli,
4185 struct policy_handle *_group_handle /* [in] [ref] */,
4186 struct samr_RidTypeArray **_rids /* [out] [ref] */)
4187 {
4188 struct tevent_req *req;
4189 struct rpccli_samr_QueryGroupMember_state *state;
4190 struct tevent_req *subreq;
4191
4192 req = tevent_req_create(mem_ctx, &state,
4193 struct rpccli_samr_QueryGroupMember_state);
4194 if (req == NULL) {
4195 return NULL;
4196 }
4197 state->out_mem_ctx = NULL;
4198 state->dispatch_recv = cli->dispatch_recv;
4199
4200 /* In parameters */
4201 state->orig.in.group_handle = _group_handle;
4202
4203 /* Out parameters */
4204 state->orig.out.rids = _rids;
4205
4206 /* Result */
4207 ZERO_STRUCT(state->orig.out.result);
4208
4209 if (DEBUGLEVEL >= 10) {
4210 NDR_PRINT_IN_DEBUG(samr_QueryGroupMember, &state->orig);
4211 }
4212
4213 state->out_mem_ctx = talloc_named_const(state, 0,
4214 "rpccli_samr_QueryGroupMember_out_memory");
4215 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4216 return tevent_req_post(req, ev);
4217 }
4218
4219 /* make a temporary copy, that we pass to the dispatch function */
4220 state->tmp = state->orig;
4221
4222 subreq = cli->dispatch_send(state, ev, cli,
4223 &ndr_table_samr,
4224 NDR_SAMR_QUERYGROUPMEMBER,
4225 &state->tmp);
4226 if (tevent_req_nomem(subreq, req)) {
4227 return tevent_req_post(req, ev);
4228 }
4229 tevent_req_set_callback(subreq, rpccli_samr_QueryGroupMember_done, req);
4230 return req;
4231 }
4232
4233 static void rpccli_samr_QueryGroupMember_done(struct tevent_req *subreq)
4234 {
4235 struct tevent_req *req = tevent_req_callback_data(
4236 subreq, struct tevent_req);
4237 struct rpccli_samr_QueryGroupMember_state *state = tevent_req_data(
4238 req, struct rpccli_samr_QueryGroupMember_state);
4239 NTSTATUS status;
4240 TALLOC_CTX *mem_ctx;
4241
4242 if (state->out_mem_ctx) {
4243 mem_ctx = state->out_mem_ctx;
4244 } else {
4245 mem_ctx = state;
4246 }
4247
4248 status = state->dispatch_recv(subreq, mem_ctx);
4249 TALLOC_FREE(subreq);
4250 if (!NT_STATUS_IS_OK(status)) {
4251 tevent_req_nterror(req, status);
4252 return;
4253 }
4254
4255 /* Copy out parameters */
4256 *state->orig.out.rids = *state->tmp.out.rids;
4257
4258 /* Copy result */
4259 state->orig.out.result = state->tmp.out.result;
4260
4261 /* Reset temporary structure */
4262 ZERO_STRUCT(state->tmp);
4263
4264 if (DEBUGLEVEL >= 10) {
4265 NDR_PRINT_OUT_DEBUG(samr_QueryGroupMember, &state->orig);
4266 }
4267
4268 tevent_req_done(req);
4269 }
4270
4271 NTSTATUS rpccli_samr_QueryGroupMember_recv(struct tevent_req *req,
4272 TALLOC_CTX *mem_ctx,
4273 NTSTATUS *result)
4274 {
4275 struct rpccli_samr_QueryGroupMember_state *state = tevent_req_data(
4276 req, struct rpccli_samr_QueryGroupMember_state);
4277 NTSTATUS status;
4278
4279 if (tevent_req_is_nterror(req, &status)) {
4280 tevent_req_received(req);
4281 return status;
4282 }
4283
4284 /* Steal possbile out parameters to the callers context */
4285 talloc_steal(mem_ctx, state->out_mem_ctx);
4286
4287 /* Return result */
4288 *result = state->orig.out.result;
4289
4290 tevent_req_received(req);
4291 return NT_STATUS_OK;
4292 }
4293
4294 NTSTATUS rpccli_samr_QueryGroupMember(struct rpc_pipe_client *cli,
4295 TALLOC_CTX *mem_ctx,
4296 struct policy_handle *group_handle /* [in] [ref] */,
4297 struct samr_RidTypeArray **rids /* [out] [ref] */)
4298 {
4299 struct samr_QueryGroupMember r;
4300 NTSTATUS status;
4301
4302 /* In parameters */
4303 r.in.group_handle = group_handle;
4304
4305 if (DEBUGLEVEL >= 10) {
4306 NDR_PRINT_IN_DEBUG(samr_QueryGroupMember, &r);
4307 }
4308
4309 status = cli->dispatch(cli,
4310 mem_ctx,
4311 &ndr_table_samr,
4312 NDR_SAMR_QUERYGROUPMEMBER,
4313 &r);
4314
4315 if (!NT_STATUS_IS_OK(status)) {
4316 return status;
4317 }
4318
4319 if (DEBUGLEVEL >= 10) {
4320 NDR_PRINT_OUT_DEBUG(samr_QueryGroupMember, &r);
4321 }
4322
4323 if (NT_STATUS_IS_ERR(status)) {
4324 return status;
4325 }
4326
4327 /* Return variables */
4328 *rids = *r.out.rids;
4329
4330 /* Return result */
4331 return r.out.result;
4332 }
4333
4334 struct rpccli_samr_SetMemberAttributesOfGroup_state {
4335 struct samr_SetMemberAttributesOfGroup orig;
4336 struct samr_SetMemberAttributesOfGroup tmp;
4337 TALLOC_CTX *out_mem_ctx;
4338 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4339 };
4340
4341 static void rpccli_samr_SetMemberAttributesOfGroup_done(struct tevent_req *subreq);
4342
4343 struct tevent_req *rpccli_samr_SetMemberAttributesOfGroup_send(TALLOC_CTX *mem_ctx,
4344 struct tevent_context *ev,
4345 struct rpc_pipe_client *cli,
4346 struct policy_handle *_group_handle /* [in] [ref] */,
4347 uint32_t _unknown1 /* [in] */,
4348 uint32_t _unknown2 /* [in] */)
4349 {
4350 struct tevent_req *req;
4351 struct rpccli_samr_SetMemberAttributesOfGroup_state *state;
4352 struct tevent_req *subreq;
4353
4354 req = tevent_req_create(mem_ctx, &state,
4355 struct rpccli_samr_SetMemberAttributesOfGroup_state);
4356 if (req == NULL) {
4357 return NULL;
4358 }
4359 state->out_mem_ctx = NULL;
4360 state->dispatch_recv = cli->dispatch_recv;
4361
4362 /* In parameters */
4363 state->orig.in.group_handle = _group_handle;
4364 state->orig.in.unknown1 = _unknown1;
4365 state->orig.in.unknown2 = _unknown2;
4366
4367 /* Out parameters */
4368
4369 /* Result */
4370 ZERO_STRUCT(state->orig.out.result);
4371
4372 if (DEBUGLEVEL >= 10) {
4373 NDR_PRINT_IN_DEBUG(samr_SetMemberAttributesOfGroup, &state->orig);
4374 }
4375
4376 /* make a temporary copy, that we pass to the dispatch function */
4377 state->tmp = state->orig;
4378
4379 subreq = cli->dispatch_send(state, ev, cli,
4380 &ndr_table_samr,
4381 NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP,
4382 &state->tmp);
4383 if (tevent_req_nomem(subreq, req)) {
4384 return tevent_req_post(req, ev);
4385 }
4386 tevent_req_set_callback(subreq, rpccli_samr_SetMemberAttributesOfGroup_done, req);
4387 return req;
4388 }
4389
4390 static void rpccli_samr_SetMemberAttributesOfGroup_done(struct tevent_req *subreq)
4391 {
4392 struct tevent_req *req = tevent_req_callback_data(
4393 subreq, struct tevent_req);
4394 struct rpccli_samr_SetMemberAttributesOfGroup_state *state = tevent_req_data(
4395 req, struct rpccli_samr_SetMemberAttributesOfGroup_state);
4396 NTSTATUS status;
4397 TALLOC_CTX *mem_ctx;
4398
4399 if (state->out_mem_ctx) {
4400 mem_ctx = state->out_mem_ctx;
4401 } else {
4402 mem_ctx = state;
4403 }
4404
4405 status = state->dispatch_recv(subreq, mem_ctx);
4406 TALLOC_FREE(subreq);
4407 if (!NT_STATUS_IS_OK(status)) {
4408 tevent_req_nterror(req, status);
4409 return;
4410 }
4411
4412 /* Copy out parameters */
4413
4414 /* Copy result */
4415 state->orig.out.result = state->tmp.out.result;
4416
4417 /* Reset temporary structure */
4418 ZERO_STRUCT(state->tmp);
4419
4420 if (DEBUGLEVEL >= 10) {
4421 NDR_PRINT_OUT_DEBUG(samr_SetMemberAttributesOfGroup, &state->orig);
4422 }
4423
4424 tevent_req_done(req);
4425 }
4426
4427 NTSTATUS rpccli_samr_SetMemberAttributesOfGroup_recv(struct tevent_req *req,
4428 TALLOC_CTX *mem_ctx,
4429 NTSTATUS *result)
4430 {
4431 struct rpccli_samr_SetMemberAttributesOfGroup_state *state = tevent_req_data(
4432 req, struct rpccli_samr_SetMemberAttributesOfGroup_state);
4433 NTSTATUS status;
4434
4435 if (tevent_req_is_nterror(req, &status)) {
4436 tevent_req_received(req);
4437 return status;
4438 }
4439
4440 /* Steal possbile out parameters to the callers context */
4441 talloc_steal(mem_ctx, state->out_mem_ctx);
4442
4443 /* Return result */
4444 *result = state->orig.out.result;
4445
4446 tevent_req_received(req);
4447 return NT_STATUS_OK;
4448 }
4449
4450 NTSTATUS rpccli_samr_SetMemberAttributesOfGroup(struct rpc_pipe_client *cli,
4451 TALLOC_CTX *mem_ctx,
4452 struct policy_handle *group_handle /* [in] [ref] */,
4453 uint32_t unknown1 /* [in] */,
4454 uint32_t unknown2 /* [in] */)
4455 {
4456 struct samr_SetMemberAttributesOfGroup r;
4457 NTSTATUS status;
4458
4459 /* In parameters */
4460 r.in.group_handle = group_handle;
4461 r.in.unknown1 = unknown1;
4462 r.in.unknown2 = unknown2;
4463
4464 if (DEBUGLEVEL >= 10) {
4465 NDR_PRINT_IN_DEBUG(samr_SetMemberAttributesOfGroup, &r);
4466 }
4467
4468 status = cli->dispatch(cli,
4469 mem_ctx,
4470 &ndr_table_samr,
4471 NDR_SAMR_SETMEMBERATTRIBUTESOFGROUP,
4472 &r);
4473
4474 if (!NT_STATUS_IS_OK(status)) {
4475 return status;
4476 }
4477
4478 if (DEBUGLEVEL >= 10) {
4479 NDR_PRINT_OUT_DEBUG(samr_SetMemberAttributesOfGroup, &r);
4480 }
4481
4482 if (NT_STATUS_IS_ERR(status)) {
4483 return status;
4484 }
4485
4486 /* Return variables */
4487
4488 /* Return result */
4489 return r.out.result;
4490 }
4491
4492 struct rpccli_samr_OpenAlias_state {
4493 struct samr_OpenAlias orig;
4494 struct samr_OpenAlias tmp;
4495 TALLOC_CTX *out_mem_ctx;
4496 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4497 };
4498
4499 static void rpccli_samr_OpenAlias_done(struct tevent_req *subreq);
4500
4501 struct tevent_req *rpccli_samr_OpenAlias_send(TALLOC_CTX *mem_ctx,
4502 struct tevent_context *ev,
4503 struct rpc_pipe_client *cli,
4504 struct policy_handle *_domain_handle /* [in] [ref] */,
4505 uint32_t _access_mask /* [in] */,
4506 uint32_t _rid /* [in] */,
4507 struct policy_handle *_alias_handle /* [out] [ref] */)
4508 {
4509 struct tevent_req *req;
4510 struct rpccli_samr_OpenAlias_state *state;
4511 struct tevent_req *subreq;
4512
4513 req = tevent_req_create(mem_ctx, &state,
4514 struct rpccli_samr_OpenAlias_state);
4515 if (req == NULL) {
4516 return NULL;
4517 }
4518 state->out_mem_ctx = NULL;
4519 state->dispatch_recv = cli->dispatch_recv;
4520
4521 /* In parameters */
4522 state->orig.in.domain_handle = _domain_handle;
4523 state->orig.in.access_mask = _access_mask;
4524 state->orig.in.rid = _rid;
4525
4526 /* Out parameters */
4527 state->orig.out.alias_handle = _alias_handle;
4528
4529 /* Result */
4530 ZERO_STRUCT(state->orig.out.result);
4531
4532 if (DEBUGLEVEL >= 10) {
4533 NDR_PRINT_IN_DEBUG(samr_OpenAlias, &state->orig);
4534 }
4535
4536 state->out_mem_ctx = talloc_named_const(state, 0,
4537 "rpccli_samr_OpenAlias_out_memory");
4538 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4539 return tevent_req_post(req, ev);
4540 }
4541
4542 /* make a temporary copy, that we pass to the dispatch function */
4543 state->tmp = state->orig;
4544
4545 subreq = cli->dispatch_send(state, ev, cli,
4546 &ndr_table_samr,
4547 NDR_SAMR_OPENALIAS,
4548 &state->tmp);
4549 if (tevent_req_nomem(subreq, req)) {
4550 return tevent_req_post(req, ev);
4551 }
4552 tevent_req_set_callback(subreq, rpccli_samr_OpenAlias_done, req);
4553 return req;
4554 }
4555
4556 static void rpccli_samr_OpenAlias_done(struct tevent_req *subreq)
4557 {
4558 struct tevent_req *req = tevent_req_callback_data(
4559 subreq, struct tevent_req);
4560 struct rpccli_samr_OpenAlias_state *state = tevent_req_data(
4561 req, struct rpccli_samr_OpenAlias_state);
4562 NTSTATUS status;
4563 TALLOC_CTX *mem_ctx;
4564
4565 if (state->out_mem_ctx) {
4566 mem_ctx = state->out_mem_ctx;
4567 } else {
4568 mem_ctx = state;
4569 }
4570
4571 status = state->dispatch_recv(subreq, mem_ctx);
4572 TALLOC_FREE(subreq);
4573 if (!NT_STATUS_IS_OK(status)) {
4574 tevent_req_nterror(req, status);
4575 return;
4576 }
4577
4578 /* Copy out parameters */
4579 *state->orig.out.alias_handle = *state->tmp.out.alias_handle;
4580
4581 /* Copy result */
4582 state->orig.out.result = state->tmp.out.result;
4583
4584 /* Reset temporary structure */
4585 ZERO_STRUCT(state->tmp);
4586
4587 if (DEBUGLEVEL >= 10) {
4588 NDR_PRINT_OUT_DEBUG(samr_OpenAlias, &state->orig);
4589 }
4590
4591 tevent_req_done(req);
4592 }
4593
4594 NTSTATUS rpccli_samr_OpenAlias_recv(struct tevent_req *req,
4595 TALLOC_CTX *mem_ctx,
4596 NTSTATUS *result)
4597 {
4598 struct rpccli_samr_OpenAlias_state *state = tevent_req_data(
4599 req, struct rpccli_samr_OpenAlias_state);
4600 NTSTATUS status;
4601
4602 if (tevent_req_is_nterror(req, &status)) {
4603 tevent_req_received(req);
4604 return status;
4605 }
4606
4607 /* Steal possbile out parameters to the callers context */
4608 talloc_steal(mem_ctx, state->out_mem_ctx);
4609
4610 /* Return result */
4611 *result = state->orig.out.result;
4612
4613 tevent_req_received(req);
4614 return NT_STATUS_OK;
4615 }
4616
4617 NTSTATUS rpccli_samr_OpenAlias(struct rpc_pipe_client *cli,
4618 TALLOC_CTX *mem_ctx,
4619 struct policy_handle *domain_handle /* [in] [ref] */,
4620 uint32_t access_mask /* [in] */,
4621 uint32_t rid /* [in] */,
4622 struct policy_handle *alias_handle /* [out] [ref] */)
4623 {
4624 struct samr_OpenAlias r;
4625 NTSTATUS status;
4626
4627 /* In parameters */
4628 r.in.domain_handle = domain_handle;
4629 r.in.access_mask = access_mask;
4630 r.in.rid = rid;
4631
4632 if (DEBUGLEVEL >= 10) {
4633 NDR_PRINT_IN_DEBUG(samr_OpenAlias, &r);
4634 }
4635
4636 status = cli->dispatch(cli,
4637 mem_ctx,
4638 &ndr_table_samr,
4639 NDR_SAMR_OPENALIAS,
4640 &r);
4641
4642 if (!NT_STATUS_IS_OK(status)) {
4643 return status;
4644 }
4645
4646 if (DEBUGLEVEL >= 10) {
4647 NDR_PRINT_OUT_DEBUG(samr_OpenAlias, &r);
4648 }
4649
4650 if (NT_STATUS_IS_ERR(status)) {
4651 return status;
4652 }
4653
4654 /* Return variables */
4655 *alias_handle = *r.out.alias_handle;
4656
4657 /* Return result */
4658 return r.out.result;
4659 }
4660
4661 struct rpccli_samr_QueryAliasInfo_state {
4662 struct samr_QueryAliasInfo orig;
4663 struct samr_QueryAliasInfo tmp;
4664 TALLOC_CTX *out_mem_ctx;
4665 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4666 };
4667
4668 static void rpccli_samr_QueryAliasInfo_done(struct tevent_req *subreq);
4669
4670 struct tevent_req *rpccli_samr_QueryAliasInfo_send(TALLOC_CTX *mem_ctx,
4671 struct tevent_context *ev,
4672 struct rpc_pipe_client *cli,
4673 struct policy_handle *_alias_handle /* [in] [ref] */,
4674 enum samr_AliasInfoEnum _level /* [in] */,
4675 union samr_AliasInfo **_info /* [out] [ref,switch_is(level)] */)
4676 {
4677 struct tevent_req *req;
4678 struct rpccli_samr_QueryAliasInfo_state *state;
4679 struct tevent_req *subreq;
4680
4681 req = tevent_req_create(mem_ctx, &state,
4682 struct rpccli_samr_QueryAliasInfo_state);
4683 if (req == NULL) {
4684 return NULL;
4685 }
4686 state->out_mem_ctx = NULL;
4687 state->dispatch_recv = cli->dispatch_recv;
4688
4689 /* In parameters */
4690 state->orig.in.alias_handle = _alias_handle;
4691 state->orig.in.level = _level;
4692
4693 /* Out parameters */
4694 state->orig.out.info = _info;
4695
4696 /* Result */
4697 ZERO_STRUCT(state->orig.out.result);
4698
4699 if (DEBUGLEVEL >= 10) {
4700 NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, &state->orig);
4701 }
4702
4703 state->out_mem_ctx = talloc_named_const(state, 0,
4704 "rpccli_samr_QueryAliasInfo_out_memory");
4705 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4706 return tevent_req_post(req, ev);
4707 }
4708
4709 /* make a temporary copy, that we pass to the dispatch function */
4710 state->tmp = state->orig;
4711
4712 subreq = cli->dispatch_send(state, ev, cli,
4713 &ndr_table_samr,
4714 NDR_SAMR_QUERYALIASINFO,
4715 &state->tmp);
4716 if (tevent_req_nomem(subreq, req)) {
4717 return tevent_req_post(req, ev);
4718 }
4719 tevent_req_set_callback(subreq, rpccli_samr_QueryAliasInfo_done, req);
4720 return req;
4721 }
4722
4723 static void rpccli_samr_QueryAliasInfo_done(struct tevent_req *subreq)
4724 {
4725 struct tevent_req *req = tevent_req_callback_data(
4726 subreq, struct tevent_req);
4727 struct rpccli_samr_QueryAliasInfo_state *state = tevent_req_data(
4728 req, struct rpccli_samr_QueryAliasInfo_state);
4729 NTSTATUS status;
4730 TALLOC_CTX *mem_ctx;
4731
4732 if (state->out_mem_ctx) {
4733 mem_ctx = state->out_mem_ctx;
4734 } else {
4735 mem_ctx = state;
4736 }
4737
4738 status = state->dispatch_recv(subreq, mem_ctx);
4739 TALLOC_FREE(subreq);
4740 if (!NT_STATUS_IS_OK(status)) {
4741 tevent_req_nterror(req, status);
4742 return;
4743 }
4744
4745 /* Copy out parameters */
4746 *state->orig.out.info = *state->tmp.out.info;
4747
4748 /* Copy result */
4749 state->orig.out.result = state->tmp.out.result;
4750
4751 /* Reset temporary structure */
4752 ZERO_STRUCT(state->tmp);
4753
4754 if (DEBUGLEVEL >= 10) {
4755 NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, &state->orig);
4756 }
4757
4758 tevent_req_done(req);
4759 }
4760
4761 NTSTATUS rpccli_samr_QueryAliasInfo_recv(struct tevent_req *req,
4762 TALLOC_CTX *mem_ctx,
4763 NTSTATUS *result)
4764 {
4765 struct rpccli_samr_QueryAliasInfo_state *state = tevent_req_data(
4766 req, struct rpccli_samr_QueryAliasInfo_state);
4767 NTSTATUS status;
4768
4769 if (tevent_req_is_nterror(req, &status)) {
4770 tevent_req_received(req);
4771 return status;
4772 }
4773
4774 /* Steal possbile out parameters to the callers context */
4775 talloc_steal(mem_ctx, state->out_mem_ctx);
4776
4777 /* Return result */
4778 *result = state->orig.out.result;
4779
4780 tevent_req_received(req);
4781 return NT_STATUS_OK;
4782 }
4783
4784 NTSTATUS rpccli_samr_QueryAliasInfo(struct rpc_pipe_client *cli,
4785 TALLOC_CTX *mem_ctx,
4786 struct policy_handle *alias_handle /* [in] [ref] */,
4787 enum samr_AliasInfoEnum level /* [in] */,
4788 union samr_AliasInfo **info /* [out] [ref,switch_is(level)] */)
4789 {
4790 struct samr_QueryAliasInfo r;
4791 NTSTATUS status;
4792
4793 /* In parameters */
4794 r.in.alias_handle = alias_handle;
4795 r.in.level = level;
4796
4797 if (DEBUGLEVEL >= 10) {
4798 NDR_PRINT_IN_DEBUG(samr_QueryAliasInfo, &r);
4799 }
4800
4801 status = cli->dispatch(cli,
4802 mem_ctx,
4803 &ndr_table_samr,
4804 NDR_SAMR_QUERYALIASINFO,
4805 &r);
4806
4807 if (!NT_STATUS_IS_OK(status)) {
4808 return status;
4809 }
4810
4811 if (DEBUGLEVEL >= 10) {
4812 NDR_PRINT_OUT_DEBUG(samr_QueryAliasInfo, &r);
4813 }
4814
4815 if (NT_STATUS_IS_ERR(status)) {
4816 return status;
4817 }
4818
4819 /* Return variables */
4820 *info = *r.out.info;
4821
4822 /* Return result */
4823 return r.out.result;
4824 }
4825
4826 struct rpccli_samr_SetAliasInfo_state {
4827 struct samr_SetAliasInfo orig;
4828 struct samr_SetAliasInfo tmp;
4829 TALLOC_CTX *out_mem_ctx;
4830 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4831 };
4832
4833 static void rpccli_samr_SetAliasInfo_done(struct tevent_req *subreq);
4834
4835 struct tevent_req *rpccli_samr_SetAliasInfo_send(TALLOC_CTX *mem_ctx,
4836 struct tevent_context *ev,
4837 struct rpc_pipe_client *cli,
4838 struct policy_handle *_alias_handle /* [in] [ref] */,
4839 enum samr_AliasInfoEnum _level /* [in] */,
4840 union samr_AliasInfo *_info /* [in] [ref,switch_is(level)] */)
4841 {
4842 struct tevent_req *req;
4843 struct rpccli_samr_SetAliasInfo_state *state;
4844 struct tevent_req *subreq;
4845
4846 req = tevent_req_create(mem_ctx, &state,
4847 struct rpccli_samr_SetAliasInfo_state);
4848 if (req == NULL) {
4849 return NULL;
4850 }
4851 state->out_mem_ctx = NULL;
4852 state->dispatch_recv = cli->dispatch_recv;
4853
4854 /* In parameters */
4855 state->orig.in.alias_handle = _alias_handle;
4856 state->orig.in.level = _level;
4857 state->orig.in.info = _info;
4858
4859 /* Out parameters */
4860
4861 /* Result */
4862 ZERO_STRUCT(state->orig.out.result);
4863
4864 if (DEBUGLEVEL >= 10) {
4865 NDR_PRINT_IN_DEBUG(samr_SetAliasInfo, &state->orig);
4866 }
4867
4868 /* make a temporary copy, that we pass to the dispatch function */
4869 state->tmp = state->orig;
4870
4871 subreq = cli->dispatch_send(state, ev, cli,
4872 &ndr_table_samr,
4873 NDR_SAMR_SETALIASINFO,
4874 &state->tmp);
4875 if (tevent_req_nomem(subreq, req)) {
4876 return tevent_req_post(req, ev);
4877 }
4878 tevent_req_set_callback(subreq, rpccli_samr_SetAliasInfo_done, req);
4879 return req;
4880 }
4881
4882 static void rpccli_samr_SetAliasInfo_done(struct tevent_req *subreq)
4883 {
4884 struct tevent_req *req = tevent_req_callback_data(
4885 subreq, struct tevent_req);
4886 struct rpccli_samr_SetAliasInfo_state *state = tevent_req_data(
4887 req, struct rpccli_samr_SetAliasInfo_state);
4888 NTSTATUS status;
4889 TALLOC_CTX *mem_ctx;
4890
4891 if (state->out_mem_ctx) {
4892 mem_ctx = state->out_mem_ctx;
4893 } else {
4894 mem_ctx = state;
4895 }
4896
4897 status = state->dispatch_recv(subreq, mem_ctx);
4898 TALLOC_FREE(subreq);
4899 if (!NT_STATUS_IS_OK(status)) {
4900 tevent_req_nterror(req, status);
4901 return;
4902 }
4903
4904 /* Copy out parameters */
4905
4906 /* Copy result */
4907 state->orig.out.result = state->tmp.out.result;
4908
4909 /* Reset temporary structure */
4910 ZERO_STRUCT(state->tmp);
4911
4912 if (DEBUGLEVEL >= 10) {
4913 NDR_PRINT_OUT_DEBUG(samr_SetAliasInfo, &state->orig);
4914 }
4915
4916 tevent_req_done(req);
4917 }
4918
4919 NTSTATUS rpccli_samr_SetAliasInfo_recv(struct tevent_req *req,
4920 TALLOC_CTX *mem_ctx,
4921 NTSTATUS *result)
4922 {
4923 struct rpccli_samr_SetAliasInfo_state *state = tevent_req_data(
4924 req, struct rpccli_samr_SetAliasInfo_state);
4925 NTSTATUS status;
4926
4927 if (tevent_req_is_nterror(req, &status)) {
4928 tevent_req_received(req);
4929 return status;
4930 }
4931
4932 /* Steal possbile out parameters to the callers context */
4933 talloc_steal(mem_ctx, state->out_mem_ctx);
4934
4935 /* Return result */
4936 *result = state->orig.out.result;
4937
4938 tevent_req_received(req);
4939 return NT_STATUS_OK;
4940 }
4941
4942 NTSTATUS rpccli_samr_SetAliasInfo(struct rpc_pipe_client *cli,
4943 TALLOC_CTX *mem_ctx,
4944 struct policy_handle *alias_handle /* [in] [ref] */,
4945 enum samr_AliasInfoEnum level /* [in] */,
4946 union samr_AliasInfo *info /* [in] [ref,switch_is(level)] */)
4947 {
4948 struct samr_SetAliasInfo r;
4949 NTSTATUS status;
4950
4951 /* In parameters */
4952 r.in.alias_handle = alias_handle;
4953 r.in.level = level;
4954 r.in.info = info;
4955
4956 if (DEBUGLEVEL >= 10) {
4957 NDR_PRINT_IN_DEBUG(samr_SetAliasInfo, &r);
4958 }
4959
4960 status = cli->dispatch(cli,
4961 mem_ctx,
4962 &ndr_table_samr,
4963 NDR_SAMR_SETALIASINFO,
4964 &r);
4965
4966 if (!NT_STATUS_IS_OK(status)) {
4967 return status;
4968 }
4969
4970 if (DEBUGLEVEL >= 10) {
4971 NDR_PRINT_OUT_DEBUG(samr_SetAliasInfo, &r);
4972 }
4973
4974 if (NT_STATUS_IS_ERR(status)) {
4975 return status;
4976 }
4977
4978 /* Return variables */
4979
4980 /* Return result */
4981 return r.out.result;
4982 }
4983
4984 struct rpccli_samr_DeleteDomAlias_state {
4985 struct samr_DeleteDomAlias orig;
4986 struct samr_DeleteDomAlias tmp;
4987 TALLOC_CTX *out_mem_ctx;
4988 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4989 };
4990
4991 static void rpccli_samr_DeleteDomAlias_done(struct tevent_req *subreq);
4992
4993 struct tevent_req *rpccli_samr_DeleteDomAlias_send(TALLOC_CTX *mem_ctx,
4994 struct tevent_context *ev,
4995 struct rpc_pipe_client *cli,
4996 struct policy_handle *_alias_handle /* [in,out] [ref] */)
4997 {
4998 struct tevent_req *req;
4999 struct rpccli_samr_DeleteDomAlias_state *state;
5000 struct tevent_req *subreq;
5001
5002 req = tevent_req_create(mem_ctx, &state,
5003 struct rpccli_samr_DeleteDomAlias_state);
5004 if (req == NULL) {
5005 return NULL;
5006 }
5007 state->out_mem_ctx = NULL;
5008 state->dispatch_recv = cli->dispatch_recv;
5009
5010 /* In parameters */
5011 state->orig.in.alias_handle = _alias_handle;
5012
5013 /* Out parameters */
5014 state->orig.out.alias_handle = _alias_handle;
5015
5016 /* Result */
5017 ZERO_STRUCT(state->orig.out.result);
5018
5019 if (DEBUGLEVEL >= 10) {
5020 NDR_PRINT_IN_DEBUG(samr_DeleteDomAlias, &state->orig);
5021 }
5022
5023 state->out_mem_ctx = talloc_named_const(state, 0,
5024 "rpccli_samr_DeleteDomAlias_out_memory");
5025 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5026 return tevent_req_post(req, ev);
5027 }
5028
5029 /* make a temporary copy, that we pass to the dispatch function */
5030 state->tmp = state->orig;
5031
5032 subreq = cli->dispatch_send(state, ev, cli,
5033 &ndr_table_samr,
5034 NDR_SAMR_DELETEDOMALIAS,
5035 &state->tmp);
5036 if (tevent_req_nomem(subreq, req)) {
5037 return tevent_req_post(req, ev);
5038 }
5039 tevent_req_set_callback(subreq, rpccli_samr_DeleteDomAlias_done, req);
5040 return req;
5041 }
5042
5043 static void rpccli_samr_DeleteDomAlias_done(struct tevent_req *subreq)
5044 {
5045 struct tevent_req *req = tevent_req_callback_data(
5046 subreq, struct tevent_req);
5047 struct rpccli_samr_DeleteDomAlias_state *state = tevent_req_data(
5048 req, struct rpccli_samr_DeleteDomAlias_state);
5049 NTSTATUS status;
5050 TALLOC_CTX *mem_ctx;
5051
5052 if (state->out_mem_ctx) {
5053 mem_ctx = state->out_mem_ctx;
5054 } else {
5055 mem_ctx = state;
5056 }
5057
5058 status = state->dispatch_recv(subreq, mem_ctx);
5059 TALLOC_FREE(subreq);
5060 if (!NT_STATUS_IS_OK(status)) {
5061 tevent_req_nterror(req, status);
5062 return;
5063 }
5064
5065 /* Copy out parameters */
5066 *state->orig.out.alias_handle = *state->tmp.out.alias_handle;
5067
5068 /* Copy result */
5069 state->orig.out.result = state->tmp.out.result;
5070
5071 /* Reset temporary structure */
5072 ZERO_STRUCT(state->tmp);
5073
5074 if (DEBUGLEVEL >= 10) {
5075 NDR_PRINT_OUT_DEBUG(samr_DeleteDomAlias, &state->orig);
5076 }
5077
5078 tevent_req_done(req);
5079 }
5080
5081 NTSTATUS rpccli_samr_DeleteDomAlias_recv(struct tevent_req *req,
5082 TALLOC_CTX *mem_ctx,
5083 NTSTATUS *result)
5084 {
5085 struct rpccli_samr_DeleteDomAlias_state *state = tevent_req_data(
5086 req, struct rpccli_samr_DeleteDomAlias_state);
5087 NTSTATUS status;
5088
5089 if (tevent_req_is_nterror(req, &status)) {
5090 tevent_req_received(req);
5091 return status;
5092 }
5093
5094 /* Steal possbile out parameters to the callers context */
5095 talloc_steal(mem_ctx, state->out_mem_ctx);
5096
5097 /* Return result */
5098 *result = state->orig.out.result;
5099
5100 tevent_req_received(req);
5101 return NT_STATUS_OK;
5102 }
5103
5104 NTSTATUS rpccli_samr_DeleteDomAlias(struct rpc_pipe_client *cli,
5105 TALLOC_CTX *mem_ctx,
5106 struct policy_handle *alias_handle /* [in,out] [ref] */)
5107 {
5108 struct samr_DeleteDomAlias r;
5109 NTSTATUS status;
5110
5111 /* In parameters */
5112 r.in.alias_handle = alias_handle;
5113
5114 if (DEBUGLEVEL >= 10) {
5115 NDR_PRINT_IN_DEBUG(samr_DeleteDomAlias, &r);
5116 }
5117
5118 status = cli->dispatch(cli,
5119 mem_ctx,
5120 &ndr_table_samr,
5121 NDR_SAMR_DELETEDOMALIAS,
5122 &r);
5123
5124 if (!NT_STATUS_IS_OK(status)) {
5125 return status;
5126 }
5127
5128 if (DEBUGLEVEL >= 10) {
5129 NDR_PRINT_OUT_DEBUG(samr_DeleteDomAlias, &r);
5130 }
5131
5132 if (NT_STATUS_IS_ERR(status)) {
5133 return status;
5134 }
5135
5136 /* Return variables */
5137 *alias_handle = *r.out.alias_handle;
5138
5139 /* Return result */
5140 return r.out.result;
5141 }
5142
5143 struct rpccli_samr_AddAliasMember_state {
5144 struct samr_AddAliasMember orig;
5145 struct samr_AddAliasMember tmp;
5146 TALLOC_CTX *out_mem_ctx;
5147 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5148 };
5149
5150 static void rpccli_samr_AddAliasMember_done(struct tevent_req *subreq);
5151
5152 struct tevent_req *rpccli_samr_AddAliasMember_send(TALLOC_CTX *mem_ctx,
5153 struct tevent_context *ev,
5154 struct rpc_pipe_client *cli,
5155 struct policy_handle *_alias_handle /* [in] [ref] */,
5156 struct dom_sid2 *_sid /* [in] [ref] */)
5157 {
5158 struct tevent_req *req;
5159 struct rpccli_samr_AddAliasMember_state *state;
5160 struct tevent_req *subreq;
5161
5162 req = tevent_req_create(mem_ctx, &state,
5163 struct rpccli_samr_AddAliasMember_state);
5164 if (req == NULL) {
5165 return NULL;
5166 }
5167 state->out_mem_ctx = NULL;
5168 state->dispatch_recv = cli->dispatch_recv;
5169
5170 /* In parameters */
5171 state->orig.in.alias_handle = _alias_handle;
5172 state->orig.in.sid = _sid;
5173
5174 /* Out parameters */
5175
5176 /* Result */
5177 ZERO_STRUCT(state->orig.out.result);
5178
5179 if (DEBUGLEVEL >= 10) {
5180 NDR_PRINT_IN_DEBUG(samr_AddAliasMember, &state->orig);
5181 }
5182
5183 /* make a temporary copy, that we pass to the dispatch function */
5184 state->tmp = state->orig;
5185
5186 subreq = cli->dispatch_send(state, ev, cli,
5187 &ndr_table_samr,
5188 NDR_SAMR_ADDALIASMEMBER,
5189 &state->tmp);
5190 if (tevent_req_nomem(subreq, req)) {
5191 return tevent_req_post(req, ev);
5192 }
5193 tevent_req_set_callback(subreq, rpccli_samr_AddAliasMember_done, req);
5194 return req;
5195 }
5196
5197 static void rpccli_samr_AddAliasMember_done(struct tevent_req *subreq)
5198 {
5199 struct tevent_req *req = tevent_req_callback_data(
5200 subreq, struct tevent_req);
5201 struct rpccli_samr_AddAliasMember_state *state = tevent_req_data(
5202 req, struct rpccli_samr_AddAliasMember_state);
5203 NTSTATUS status;
5204 TALLOC_CTX *mem_ctx;
5205
5206 if (state->out_mem_ctx) {
5207 mem_ctx = state->out_mem_ctx;
5208 } else {
5209 mem_ctx = state;
5210 }
5211
5212 status = state->dispatch_recv(subreq, mem_ctx);
5213 TALLOC_FREE(subreq);
5214 if (!NT_STATUS_IS_OK(status)) {
5215 tevent_req_nterror(req, status);
5216 return;
5217 }
5218
5219 /* Copy out parameters */
5220
5221 /* Copy result */
5222 state->orig.out.result = state->tmp.out.result;
5223
5224 /* Reset temporary structure */
5225 ZERO_STRUCT(state->tmp);
5226
5227 if (DEBUGLEVEL >= 10) {
5228 NDR_PRINT_OUT_DEBUG(samr_AddAliasMember, &state->orig);
5229 }
5230
5231 tevent_req_done(req);
5232 }
5233
5234 NTSTATUS rpccli_samr_AddAliasMember_recv(struct tevent_req *req,
5235 TALLOC_CTX *mem_ctx,
5236 NTSTATUS *result)
5237 {
5238 struct rpccli_samr_AddAliasMember_state *state = tevent_req_data(
5239 req, struct rpccli_samr_AddAliasMember_state);
5240 NTSTATUS status;
5241
5242 if (tevent_req_is_nterror(req, &status)) {
5243 tevent_req_received(req);
5244 return status;
5245 }
5246
5247 /* Steal possbile out parameters to the callers context */
5248 talloc_steal(mem_ctx, state->out_mem_ctx);
5249
5250 /* Return result */
5251 *result = state->orig.out.result;
5252
5253 tevent_req_received(req);
5254 return NT_STATUS_OK;
5255 }
5256
5257 NTSTATUS rpccli_samr_AddAliasMember(struct rpc_pipe_client *cli,
5258 TALLOC_CTX *mem_ctx,
5259 struct policy_handle *alias_handle /* [in] [ref] */,
5260 struct dom_sid2 *sid /* [in] [ref] */)
5261 {
5262 struct samr_AddAliasMember r;
5263 NTSTATUS status;
5264
5265 /* In parameters */
5266 r.in.alias_handle = alias_handle;
5267 r.in.sid = sid;
5268
5269 if (DEBUGLEVEL >= 10) {
5270 NDR_PRINT_IN_DEBUG(samr_AddAliasMember, &r);
5271 }
5272
5273 status = cli->dispatch(cli,
5274 mem_ctx,
5275 &ndr_table_samr,
5276 NDR_SAMR_ADDALIASMEMBER,
5277 &r);
5278
5279 if (!NT_STATUS_IS_OK(status)) {
5280 return status;
5281 }
5282
5283 if (DEBUGLEVEL >= 10) {
5284 NDR_PRINT_OUT_DEBUG(samr_AddAliasMember, &r);
5285 }
5286
5287 if (NT_STATUS_IS_ERR(status)) {
5288 return status;
5289 }
5290
5291 /* Return variables */
5292
5293 /* Return result */
5294 return r.out.result;
5295 }
5296
5297 struct rpccli_samr_DeleteAliasMember_state {
5298 struct samr_DeleteAliasMember orig;
5299 struct samr_DeleteAliasMember tmp;
5300 TALLOC_CTX *out_mem_ctx;
5301 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5302 };
5303
5304 static void rpccli_samr_DeleteAliasMember_done(struct tevent_req *subreq);
5305
5306 struct tevent_req *rpccli_samr_DeleteAliasMember_send(TALLOC_CTX *mem_ctx,
5307 struct tevent_context *ev,
5308 struct rpc_pipe_client *cli,
5309 struct policy_handle *_alias_handle /* [in] [ref] */,
5310 struct dom_sid2 *_sid /* [in] [ref] */)
5311 {
5312 struct tevent_req *req;
5313 struct rpccli_samr_DeleteAliasMember_state *state;
5314 struct tevent_req *subreq;
5315
5316 req = tevent_req_create(mem_ctx, &state,
5317 struct rpccli_samr_DeleteAliasMember_state);
5318 if (req == NULL) {
5319 return NULL;
5320 }
5321 state->out_mem_ctx = NULL;
5322 state->dispatch_recv = cli->dispatch_recv;
5323
5324 /* In parameters */
5325 state->orig.in.alias_handle = _alias_handle;
5326 state->orig.in.sid = _sid;
5327
5328 /* Out parameters */
5329
5330 /* Result */
5331 ZERO_STRUCT(state->orig.out.result);
5332
5333 if (DEBUGLEVEL >= 10) {
5334 NDR_PRINT_IN_DEBUG(samr_DeleteAliasMember, &state->orig);
5335 }
5336
5337 /* make a temporary copy, that we pass to the dispatch function */
5338 state->tmp = state->orig;
5339
5340 subreq = cli->dispatch_send(state, ev, cli,
5341 &ndr_table_samr,
5342 NDR_SAMR_DELETEALIASMEMBER,
5343 &state->tmp);
5344 if (tevent_req_nomem(subreq, req)) {
5345 return tevent_req_post(req, ev);
5346 }
5347 tevent_req_set_callback(subreq, rpccli_samr_DeleteAliasMember_done, req);
5348 return req;
5349 }
5350
5351 static void rpccli_samr_DeleteAliasMember_done(struct tevent_req *subreq)
5352 {
5353 struct tevent_req *req = tevent_req_callback_data(
5354 subreq, struct tevent_req);
5355 struct rpccli_samr_DeleteAliasMember_state *state = tevent_req_data(
5356 req, struct rpccli_samr_DeleteAliasMember_state);
5357 NTSTATUS status;
5358 TALLOC_CTX *mem_ctx;
5359
5360 if (state->out_mem_ctx) {
5361 mem_ctx = state->out_mem_ctx;
5362 } else {
5363 mem_ctx = state;
5364 }
5365
5366 status = state->dispatch_recv(subreq, mem_ctx);
5367 TALLOC_FREE(subreq);
5368 if (!NT_STATUS_IS_OK(status)) {
5369 tevent_req_nterror(req, status);
5370 return;
5371 }
5372
5373 /* Copy out parameters */
5374
5375 /* Copy result */
5376 state->orig.out.result = state->tmp.out.result;
5377
5378 /* Reset temporary structure */
5379 ZERO_STRUCT(state->tmp);
5380
5381 if (DEBUGLEVEL >= 10) {
5382 NDR_PRINT_OUT_DEBUG(samr_DeleteAliasMember, &state->orig);
5383 }
5384
5385 tevent_req_done(req);
5386 }
5387
5388 NTSTATUS rpccli_samr_DeleteAliasMember_recv(struct tevent_req *req,
5389 TALLOC_CTX *mem_ctx,
5390 NTSTATUS *result)
5391 {
5392 struct rpccli_samr_DeleteAliasMember_state *state = tevent_req_data(
5393 req, struct rpccli_samr_DeleteAliasMember_state);
5394 NTSTATUS status;
5395
5396 if (tevent_req_is_nterror(req, &status)) {
5397 tevent_req_received(req);
5398 return status;
5399 }
5400
5401 /* Steal possbile out parameters to the callers context */
5402 talloc_steal(mem_ctx, state->out_mem_ctx);
5403
5404 /* Return result */
5405 *result = state->orig.out.result;
5406
5407 tevent_req_received(req);
5408 return NT_STATUS_OK;
5409 }
5410
5411 NTSTATUS rpccli_samr_DeleteAliasMember(struct rpc_pipe_client *cli,
5412 TALLOC_CTX *mem_ctx,
5413 struct policy_handle *alias_handle /* [in] [ref] */,
5414 struct dom_sid2 *sid /* [in] [ref] */)
5415 {
5416 struct samr_DeleteAliasMember r;
5417 NTSTATUS status;
5418
5419 /* In parameters */
5420 r.in.alias_handle = alias_handle;
5421 r.in.sid = sid;
5422
5423 if (DEBUGLEVEL >= 10) {
5424 NDR_PRINT_IN_DEBUG(samr_DeleteAliasMember, &r);
5425 }
5426
5427 status = cli->dispatch(cli,
5428 mem_ctx,
5429 &ndr_table_samr,
5430 NDR_SAMR_DELETEALIASMEMBER,
5431 &r);
5432
5433 if (!NT_STATUS_IS_OK(status)) {
5434 return status;
5435 }
5436
5437 if (DEBUGLEVEL >= 10) {
5438 NDR_PRINT_OUT_DEBUG(samr_DeleteAliasMember, &r);
5439 }
5440
5441 if (NT_STATUS_IS_ERR(status)) {
5442 return status;
5443 }
5444
5445 /* Return variables */
5446
5447 /* Return result */
5448 return r.out.result;
5449 }
5450
5451 struct rpccli_samr_GetMembersInAlias_state {
5452 struct samr_GetMembersInAlias orig;
5453 struct samr_GetMembersInAlias tmp;
5454 TALLOC_CTX *out_mem_ctx;
5455 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5456 };
5457
5458 static void rpccli_samr_GetMembersInAlias_done(struct tevent_req *subreq);
5459
5460 struct tevent_req *rpccli_samr_GetMembersInAlias_send(TALLOC_CTX *mem_ctx,
5461 struct tevent_context *ev,
5462 struct rpc_pipe_client *cli,
5463 struct policy_handle *_alias_handle /* [in] [ref] */,
5464 struct lsa_SidArray *_sids /* [out] [ref] */)
5465 {
5466 struct tevent_req *req;
5467 struct rpccli_samr_GetMembersInAlias_state *state;
5468 struct tevent_req *subreq;
5469
5470 req = tevent_req_create(mem_ctx, &state,
5471 struct rpccli_samr_GetMembersInAlias_state);
5472 if (req == NULL) {
5473 return NULL;
5474 }
5475 state->out_mem_ctx = NULL;
5476 state->dispatch_recv = cli->dispatch_recv;
5477
5478 /* In parameters */
5479 state->orig.in.alias_handle = _alias_handle;
5480
5481 /* Out parameters */
5482 state->orig.out.sids = _sids;
5483
5484 /* Result */
5485 ZERO_STRUCT(state->orig.out.result);
5486
5487 if (DEBUGLEVEL >= 10) {
5488 NDR_PRINT_IN_DEBUG(samr_GetMembersInAlias, &state->orig);
5489 }
5490
5491 state->out_mem_ctx = talloc_named_const(state, 0,
5492 "rpccli_samr_GetMembersInAlias_out_memory");
5493 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5494 return tevent_req_post(req, ev);
5495 }
5496
5497 /* make a temporary copy, that we pass to the dispatch function */
5498 state->tmp = state->orig;
5499
5500 subreq = cli->dispatch_send(state, ev, cli,
5501 &ndr_table_samr,
5502 NDR_SAMR_GETMEMBERSINALIAS,
5503 &state->tmp);
5504 if (tevent_req_nomem(subreq, req)) {
5505 return tevent_req_post(req, ev);
5506 }
5507 tevent_req_set_callback(subreq, rpccli_samr_GetMembersInAlias_done, req);
5508 return req;
5509 }
5510
5511 static void rpccli_samr_GetMembersInAlias_done(struct tevent_req *subreq)
5512 {
5513 struct tevent_req *req = tevent_req_callback_data(
5514 subreq, struct tevent_req);
5515 struct rpccli_samr_GetMembersInAlias_state *state = tevent_req_data(
5516 req, struct rpccli_samr_GetMembersInAlias_state);
5517 NTSTATUS status;
5518 TALLOC_CTX *mem_ctx;
5519
5520 if (state->out_mem_ctx) {
5521 mem_ctx = state->out_mem_ctx;
5522 } else {
5523 mem_ctx = state;
5524 }
5525
5526 status = state->dispatch_recv(subreq, mem_ctx);
5527 TALLOC_FREE(subreq);
5528 if (!NT_STATUS_IS_OK(status)) {
5529 tevent_req_nterror(req, status);
5530 return;
5531 }
5532
5533 /* Copy out parameters */
5534 *state->orig.out.sids = *state->tmp.out.sids;
5535
5536 /* Copy result */
5537 state->orig.out.result = state->tmp.out.result;
5538
5539 /* Reset temporary structure */
5540 ZERO_STRUCT(state->tmp);
5541
5542 if (DEBUGLEVEL >= 10) {
5543 NDR_PRINT_OUT_DEBUG(samr_GetMembersInAlias, &state->orig);
5544 }
5545
5546 tevent_req_done(req);
5547 }
5548
5549 NTSTATUS rpccli_samr_GetMembersInAlias_recv(struct tevent_req *req,
5550 TALLOC_CTX *mem_ctx,
5551 NTSTATUS *result)
5552 {
5553 struct rpccli_samr_GetMembersInAlias_state *state = tevent_req_data(
5554 req, struct rpccli_samr_GetMembersInAlias_state);
5555 NTSTATUS status;
5556
5557 if (tevent_req_is_nterror(req, &status)) {
5558 tevent_req_received(req);
5559 return status;
5560 }
5561
5562 /* Steal possbile out parameters to the callers context */
5563 talloc_steal(mem_ctx, state->out_mem_ctx);
5564
5565 /* Return result */
5566 *result = state->orig.out.result;
5567
5568 tevent_req_received(req);
5569 return NT_STATUS_OK;
5570 }
5571
5572 NTSTATUS rpccli_samr_GetMembersInAlias(struct rpc_pipe_client *cli,
5573 TALLOC_CTX *mem_ctx,
5574 struct policy_handle *alias_handle /* [in] [ref] */,
5575 struct lsa_SidArray *sids /* [out] [ref] */)
5576 {
5577 struct samr_GetMembersInAlias r;
5578 NTSTATUS status;
5579
5580 /* In parameters */
5581 r.in.alias_handle = alias_handle;
5582
5583 if (DEBUGLEVEL >= 10) {
5584 NDR_PRINT_IN_DEBUG(samr_GetMembersInAlias, &r);
5585 }
5586
5587 status = cli->dispatch(cli,
5588 mem_ctx,
5589 &ndr_table_samr,
5590 NDR_SAMR_GETMEMBERSINALIAS,
5591 &r);
5592
5593 if (!NT_STATUS_IS_OK(status)) {
5594 return status;
5595 }
5596
5597 if (DEBUGLEVEL >= 10) {
5598 NDR_PRINT_OUT_DEBUG(samr_GetMembersInAlias, &r);
5599 }
5600
5601 if (NT_STATUS_IS_ERR(status)) {
5602 return status;
5603 }
5604
5605 /* Return variables */
5606 *sids = *r.out.sids;
5607
5608 /* Return result */
5609 return r.out.result;
5610 }
5611
5612 struct rpccli_samr_OpenUser_state {
5613 struct samr_OpenUser orig;
5614 struct samr_OpenUser tmp;
5615 TALLOC_CTX *out_mem_ctx;
5616 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5617 };
5618
5619 static void rpccli_samr_OpenUser_done(struct tevent_req *subreq);
5620
5621 struct tevent_req *rpccli_samr_OpenUser_send(TALLOC_CTX *mem_ctx,
5622 struct tevent_context *ev,
5623 struct rpc_pipe_client *cli,
5624 struct policy_handle *_domain_handle /* [in] [ref] */,
5625 uint32_t _access_mask /* [in] */,
5626 uint32_t _rid /* [in] */,
5627 struct policy_handle *_user_handle /* [out] [ref] */)
5628 {
5629 struct tevent_req *req;
5630 struct rpccli_samr_OpenUser_state *state;
5631 struct tevent_req *subreq;
5632
5633 req = tevent_req_create(mem_ctx, &state,
5634 struct rpccli_samr_OpenUser_state);
5635 if (req == NULL) {
5636 return NULL;
5637 }
5638 state->out_mem_ctx = NULL;
5639 state->dispatch_recv = cli->dispatch_recv;
5640
5641 /* In parameters */
5642 state->orig.in.domain_handle = _domain_handle;
5643 state->orig.in.access_mask = _access_mask;
5644 state->orig.in.rid = _rid;
5645
5646 /* Out parameters */
5647 state->orig.out.user_handle = _user_handle;
5648
5649 /* Result */
5650 ZERO_STRUCT(state->orig.out.result);
5651
5652 if (DEBUGLEVEL >= 10) {
5653 NDR_PRINT_IN_DEBUG(samr_OpenUser, &state->orig);
5654 }
5655
5656 state->out_mem_ctx = talloc_named_const(state, 0,
5657 "rpccli_samr_OpenUser_out_memory");
5658 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5659 return tevent_req_post(req, ev);
5660 }
5661
5662 /* make a temporary copy, that we pass to the dispatch function */
5663 state->tmp = state->orig;
5664
5665 subreq = cli->dispatch_send(state, ev, cli,
5666 &ndr_table_samr,
5667 NDR_SAMR_OPENUSER,
5668 &state->tmp);
5669 if (tevent_req_nomem(subreq, req)) {
5670 return tevent_req_post(req, ev);
5671 }
5672 tevent_req_set_callback(subreq, rpccli_samr_OpenUser_done, req);
5673 return req;
5674 }
5675
5676 static void rpccli_samr_OpenUser_done(struct tevent_req *subreq)
5677 {
5678 struct tevent_req *req = tevent_req_callback_data(
5679 subreq, struct tevent_req);
5680 struct rpccli_samr_OpenUser_state *state = tevent_req_data(
5681 req, struct rpccli_samr_OpenUser_state);
5682 NTSTATUS status;
5683 TALLOC_CTX *mem_ctx;
5684
5685 if (state->out_mem_ctx) {
5686 mem_ctx = state->out_mem_ctx;
5687 } else {
5688 mem_ctx = state;
5689 }
5690
5691 status = state->dispatch_recv(subreq, mem_ctx);
5692 TALLOC_FREE(subreq);
5693 if (!NT_STATUS_IS_OK(status)) {
5694 tevent_req_nterror(req, status);
5695 return;
5696 }
5697
5698 /* Copy out parameters */
5699 *state->orig.out.user_handle = *state->tmp.out.user_handle;
5700
5701 /* Copy result */
5702 state->orig.out.result = state->tmp.out.result;
5703
5704 /* Reset temporary structure */
5705 ZERO_STRUCT(state->tmp);
5706
5707 if (DEBUGLEVEL >= 10) {
5708 NDR_PRINT_OUT_DEBUG(samr_OpenUser, &state->orig);
5709 }
5710
5711 tevent_req_done(req);
5712 }
5713
5714 NTSTATUS rpccli_samr_OpenUser_recv(struct tevent_req *req,
5715 TALLOC_CTX *mem_ctx,
5716 NTSTATUS *result)
5717 {
5718 struct rpccli_samr_OpenUser_state *state = tevent_req_data(
5719 req, struct rpccli_samr_OpenUser_state);
5720 NTSTATUS status;
5721
5722 if (tevent_req_is_nterror(req, &status)) {
5723 tevent_req_received(req);
5724 return status;
5725 }
5726
5727 /* Steal possbile out parameters to the callers context */
5728 talloc_steal(mem_ctx, state->out_mem_ctx);
5729
5730 /* Return result */
5731 *result = state->orig.out.result;
5732
5733 tevent_req_received(req);
5734 return NT_STATUS_OK;
5735 }
5736
5737 NTSTATUS rpccli_samr_OpenUser(struct rpc_pipe_client *cli,
5738 TALLOC_CTX *mem_ctx,
5739 struct policy_handle *domain_handle /* [in] [ref] */,
5740 uint32_t access_mask /* [in] */,
5741 uint32_t rid /* [in] */,
5742 struct policy_handle *user_handle /* [out] [ref] */)
5743 {
5744 struct samr_OpenUser r;
5745 NTSTATUS status;
5746
5747 /* In parameters */
5748 r.in.domain_handle = domain_handle;
5749 r.in.access_mask = access_mask;
5750 r.in.rid = rid;
5751
5752 if (DEBUGLEVEL >= 10) {
5753 NDR_PRINT_IN_DEBUG(samr_OpenUser, &r);
5754 }
5755
5756 status = cli->dispatch(cli,
5757 mem_ctx,
5758 &ndr_table_samr,
5759 NDR_SAMR_OPENUSER,
5760 &r);
5761
5762 if (!NT_STATUS_IS_OK(status)) {
5763 return status;
5764 }
5765
5766 if (DEBUGLEVEL >= 10) {
5767 NDR_PRINT_OUT_DEBUG(samr_OpenUser, &r);
5768 }
5769
5770 if (NT_STATUS_IS_ERR(status)) {
5771 return status;
5772 }
5773
5774 /* Return variables */
5775 *user_handle = *r.out.user_handle;
5776
5777 /* Return result */
5778 return r.out.result;
5779 }
5780
5781 struct rpccli_samr_DeleteUser_state {
5782 struct samr_DeleteUser orig;
5783 struct samr_DeleteUser tmp;
5784 TALLOC_CTX *out_mem_ctx;
5785 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5786 };
5787
5788 static void rpccli_samr_DeleteUser_done(struct tevent_req *subreq);
5789
5790 struct tevent_req *rpccli_samr_DeleteUser_send(TALLOC_CTX *mem_ctx,
5791 struct tevent_context *ev,
5792 struct rpc_pipe_client *cli,
5793 struct policy_handle *_user_handle /* [in,out] [ref] */)
5794 {
5795 struct tevent_req *req;
5796 struct rpccli_samr_DeleteUser_state *state;
5797 struct tevent_req *subreq;
5798
5799 req = tevent_req_create(mem_ctx, &state,
5800 struct rpccli_samr_DeleteUser_state);
5801 if (req == NULL) {
5802 return NULL;
5803 }
5804 state->out_mem_ctx = NULL;
5805 state->dispatch_recv = cli->dispatch_recv;
5806
5807 /* In parameters */
5808 state->orig.in.user_handle = _user_handle;
5809
5810 /* Out parameters */
5811 state->orig.out.user_handle = _user_handle;
5812
5813 /* Result */
5814 ZERO_STRUCT(state->orig.out.result);
5815
5816 if (DEBUGLEVEL >= 10) {
5817 NDR_PRINT_IN_DEBUG(samr_DeleteUser, &state->orig);
5818 }
5819
5820 state->out_mem_ctx = talloc_named_const(state, 0,
5821 "rpccli_samr_DeleteUser_out_memory");
5822 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5823 return tevent_req_post(req, ev);
5824 }
5825
5826 /* make a temporary copy, that we pass to the dispatch function */
5827 state->tmp = state->orig;
5828
5829 subreq = cli->dispatch_send(state, ev, cli,
5830 &ndr_table_samr,
5831 NDR_SAMR_DELETEUSER,
5832 &state->tmp);
5833 if (tevent_req_nomem(subreq, req)) {
5834 return tevent_req_post(req, ev);
5835 }
5836 tevent_req_set_callback(subreq, rpccli_samr_DeleteUser_done, req);
5837 return req;
5838 }
5839
5840 static void rpccli_samr_DeleteUser_done(struct tevent_req *subreq)
5841 {
5842 struct tevent_req *req = tevent_req_callback_data(
5843 subreq, struct tevent_req);
5844 struct rpccli_samr_DeleteUser_state *state = tevent_req_data(
5845 req, struct rpccli_samr_DeleteUser_state);
5846 NTSTATUS status;
5847 TALLOC_CTX *mem_ctx;
5848
5849 if (state->out_mem_ctx) {
5850 mem_ctx = state->out_mem_ctx;
5851 } else {
5852 mem_ctx = state;
5853 }
5854
5855 status = state->dispatch_recv(subreq, mem_ctx);
5856 TALLOC_FREE(subreq);
5857 if (!NT_STATUS_IS_OK(status)) {
5858 tevent_req_nterror(req, status);
5859 return;
5860 }
5861
5862 /* Copy out parameters */
5863 *state->orig.out.user_handle = *state->tmp.out.user_handle;
5864
5865 /* Copy result */
5866 state->orig.out.result = state->tmp.out.result;
5867
5868 /* Reset temporary structure */
5869 ZERO_STRUCT(state->tmp);
5870
5871 if (DEBUGLEVEL >= 10) {
5872 NDR_PRINT_OUT_DEBUG(samr_DeleteUser, &state->orig);
5873 }
5874
5875 tevent_req_done(req);
5876 }
5877
5878 NTSTATUS rpccli_samr_DeleteUser_recv(struct tevent_req *req,
5879 TALLOC_CTX *mem_ctx,
5880 NTSTATUS *result)
5881 {
5882 struct rpccli_samr_DeleteUser_state *state = tevent_req_data(
5883 req, struct rpccli_samr_DeleteUser_state);
5884 NTSTATUS status;
5885
5886 if (tevent_req_is_nterror(req, &status)) {
5887 tevent_req_received(req);
5888 return status;
5889 }
5890
5891 /* Steal possbile out parameters to the callers context */
5892 talloc_steal(mem_ctx, state->out_mem_ctx);
5893
5894 /* Return result */
5895 *result = state->orig.out.result;
5896
5897 tevent_req_received(req);
5898 return NT_STATUS_OK;
5899 }
5900
5901 NTSTATUS rpccli_samr_DeleteUser(struct rpc_pipe_client *cli,
5902 TALLOC_CTX *mem_ctx,
5903 struct policy_handle *user_handle /* [in,out] [ref] */)
5904 {
5905 struct samr_DeleteUser r;
5906 NTSTATUS status;
5907
5908 /* In parameters */
5909 r.in.user_handle = user_handle;
5910
5911 if (DEBUGLEVEL >= 10) {
5912 NDR_PRINT_IN_DEBUG(samr_DeleteUser, &r);
5913 }
5914
5915 status = cli->dispatch(cli,
5916 mem_ctx,
5917 &ndr_table_samr,
5918 NDR_SAMR_DELETEUSER,
5919 &r);
5920
5921 if (!NT_STATUS_IS_OK(status)) {
5922 return status;
5923 }
5924
5925 if (DEBUGLEVEL >= 10) {
5926 NDR_PRINT_OUT_DEBUG(samr_DeleteUser, &r);
5927 }
5928
5929 if (NT_STATUS_IS_ERR(status)) {
5930 return status;
5931 }
5932
5933 /* Return variables */
5934 *user_handle = *r.out.user_handle;
5935
5936 /* Return result */
5937 return r.out.result;
5938 }
5939
5940 struct rpccli_samr_QueryUserInfo_state {
5941 struct samr_QueryUserInfo orig;
5942 struct samr_QueryUserInfo tmp;
5943 TALLOC_CTX *out_mem_ctx;
5944 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5945 };
5946
5947 static void rpccli_samr_QueryUserInfo_done(struct tevent_req *subreq);
5948
5949 struct tevent_req *rpccli_samr_QueryUserInfo_send(TALLOC_CTX *mem_ctx,
5950 struct tevent_context *ev,
5951 struct rpc_pipe_client *cli,
5952 struct policy_handle *_user_handle /* [in] [ref] */,
5953 enum samr_UserInfoLevel _level /* [in] */,
5954 union samr_UserInfo **_info /* [out] [ref,switch_is(level)] */)
5955 {
5956 struct tevent_req *req;
5957 struct rpccli_samr_QueryUserInfo_state *state;
5958 struct tevent_req *subreq;
5959
5960 req = tevent_req_create(mem_ctx, &state,
5961 struct rpccli_samr_QueryUserInfo_state);
5962 if (req == NULL) {
5963 return NULL;
5964 }
5965 state->out_mem_ctx = NULL;
5966 state->dispatch_recv = cli->dispatch_recv;
5967
5968 /* In parameters */
5969 state->orig.in.user_handle = _user_handle;
5970 state->orig.in.level = _level;
5971
5972 /* Out parameters */
5973 state->orig.out.info = _info;
5974
5975 /* Result */
5976 ZERO_STRUCT(state->orig.out.result);
5977
5978 if (DEBUGLEVEL >= 10) {
5979 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, &state->orig);
5980 }
5981
5982 state->out_mem_ctx = talloc_named_const(state, 0,
5983 "rpccli_samr_QueryUserInfo_out_memory");
5984 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5985 return tevent_req_post(req, ev);
5986 }
5987
5988 /* make a temporary copy, that we pass to the dispatch function */
5989 state->tmp = state->orig;
5990
5991 subreq = cli->dispatch_send(state, ev, cli,
5992 &ndr_table_samr,
5993 NDR_SAMR_QUERYUSERINFO,
5994 &state->tmp);
5995 if (tevent_req_nomem(subreq, req)) {
5996 return tevent_req_post(req, ev);
5997 }
5998 tevent_req_set_callback(subreq, rpccli_samr_QueryUserInfo_done, req);
5999 return req;
6000 }
6001
6002 static void rpccli_samr_QueryUserInfo_done(struct tevent_req *subreq)
6003 {
6004 struct tevent_req *req = tevent_req_callback_data(
6005 subreq, struct tevent_req);
6006 struct rpccli_samr_QueryUserInfo_state *state = tevent_req_data(
6007 req, struct rpccli_samr_QueryUserInfo_state);
6008 NTSTATUS status;
6009 TALLOC_CTX *mem_ctx;
6010
6011 if (state->out_mem_ctx) {
6012 mem_ctx = state->out_mem_ctx;
6013 } else {
6014 mem_ctx = state;
6015 }
6016
6017 status = state->dispatch_recv(subreq, mem_ctx);
6018 TALLOC_FREE(subreq);
6019 if (!NT_STATUS_IS_OK(status)) {
6020 tevent_req_nterror(req, status);
6021 return;
6022 }
6023
6024 /* Copy out parameters */
6025 *state->orig.out.info = *state->tmp.out.info;
6026
6027 /* Copy result */
6028 state->orig.out.result = state->tmp.out.result;
6029
6030 /* Reset temporary structure */
6031 ZERO_STRUCT(state->tmp);
6032
6033 if (DEBUGLEVEL >= 10) {
6034 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, &state->orig);
6035 }
6036
6037 tevent_req_done(req);
6038 }
6039
6040 NTSTATUS rpccli_samr_QueryUserInfo_recv(struct tevent_req *req,
6041 TALLOC_CTX *mem_ctx,
6042 NTSTATUS *result)
6043 {
6044 struct rpccli_samr_QueryUserInfo_state *state = tevent_req_data(
6045 req, struct rpccli_samr_QueryUserInfo_state);
6046 NTSTATUS status;
6047
6048 if (tevent_req_is_nterror(req, &status)) {
6049 tevent_req_received(req);
6050 return status;
6051 }
6052
6053 /* Steal possbile out parameters to the callers context */
6054 talloc_steal(mem_ctx, state->out_mem_ctx);
6055
6056 /* Return result */
6057 *result = state->orig.out.result;
6058
6059 tevent_req_received(req);
6060 return NT_STATUS_OK;
6061 }
6062
6063 NTSTATUS rpccli_samr_QueryUserInfo(struct rpc_pipe_client *cli,
6064 TALLOC_CTX *mem_ctx,
6065 struct policy_handle *user_handle /* [in] [ref] */,
6066 enum samr_UserInfoLevel level /* [in] */,
6067 union samr_UserInfo **info /* [out] [ref,switch_is(level)] */)
6068 {
6069 struct samr_QueryUserInfo r;
6070 NTSTATUS status;
6071
6072 /* In parameters */
6073 r.in.user_handle = user_handle;
6074 r.in.level = level;
6075
6076 if (DEBUGLEVEL >= 10) {
6077 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo, &r);
6078 }
6079
6080 status = cli->dispatch(cli,
6081 mem_ctx,
6082 &ndr_table_samr,
6083 NDR_SAMR_QUERYUSERINFO,
6084 &r);
6085
6086 if (!NT_STATUS_IS_OK(status)) {
6087 return status;
6088 }
6089
6090 if (DEBUGLEVEL >= 10) {
6091 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo, &r);
6092 }
6093
6094 if (NT_STATUS_IS_ERR(status)) {
6095 return status;
6096 }
6097
6098 /* Return variables */
6099 *info = *r.out.info;
6100
6101 /* Return result */
6102 return r.out.result;
6103 }
6104
6105 struct rpccli_samr_SetUserInfo_state {
6106 struct samr_SetUserInfo orig;
6107 struct samr_SetUserInfo tmp;
6108 TALLOC_CTX *out_mem_ctx;
6109 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6110 };
6111
6112 static void rpccli_samr_SetUserInfo_done(struct tevent_req *subreq);
6113
6114 struct tevent_req *rpccli_samr_SetUserInfo_send(TALLOC_CTX *mem_ctx,
6115 struct tevent_context *ev,
6116 struct rpc_pipe_client *cli,
6117 struct policy_handle *_user_handle /* [in] [ref] */,
6118 enum samr_UserInfoLevel _level /* [in] */,
6119 union samr_UserInfo *_info /* [in] [ref,switch_is(level)] */)
6120 {
6121 struct tevent_req *req;
6122 struct rpccli_samr_SetUserInfo_state *state;
6123 struct tevent_req *subreq;
6124
6125 req = tevent_req_create(mem_ctx, &state,
6126 struct rpccli_samr_SetUserInfo_state);
6127 if (req == NULL) {
6128 return NULL;
6129 }
6130 state->out_mem_ctx = NULL;
6131 state->dispatch_recv = cli->dispatch_recv;
6132
6133 /* In parameters */
6134 state->orig.in.user_handle = _user_handle;
6135 state->orig.in.level = _level;
6136 state->orig.in.info = _info;
6137
6138 /* Out parameters */
6139
6140 /* Result */
6141 ZERO_STRUCT(state->orig.out.result);
6142
6143 if (DEBUGLEVEL >= 10) {
6144 NDR_PRINT_IN_DEBUG(samr_SetUserInfo, &state->orig);
6145 }
6146
6147 /* make a temporary copy, that we pass to the dispatch function */
6148 state->tmp = state->orig;
6149
6150 subreq = cli->dispatch_send(state, ev, cli,
6151 &ndr_table_samr,
6152 NDR_SAMR_SETUSERINFO,
6153 &state->tmp);
6154 if (tevent_req_nomem(subreq, req)) {
6155 return tevent_req_post(req, ev);
6156 }
6157 tevent_req_set_callback(subreq, rpccli_samr_SetUserInfo_done, req);
6158 return req;
6159 }
6160
6161 static void rpccli_samr_SetUserInfo_done(struct tevent_req *subreq)
6162 {
6163 struct tevent_req *req = tevent_req_callback_data(
6164 subreq, struct tevent_req);
6165 struct rpccli_samr_SetUserInfo_state *state = tevent_req_data(
6166 req, struct rpccli_samr_SetUserInfo_state);
6167 NTSTATUS status;
6168 TALLOC_CTX *mem_ctx;
6169
6170 if (state->out_mem_ctx) {
6171 mem_ctx = state->out_mem_ctx;
6172 } else {
6173 mem_ctx = state;
6174 }
6175
6176 status = state->dispatch_recv(subreq, mem_ctx);
6177 TALLOC_FREE(subreq);
6178 if (!NT_STATUS_IS_OK(status)) {
6179 tevent_req_nterror(req, status);
6180 return;
6181 }
6182
6183 /* Copy out parameters */
6184
6185 /* Copy result */
6186 state->orig.out.result = state->tmp.out.result;
6187
6188 /* Reset temporary structure */
6189 ZERO_STRUCT(state->tmp);
6190
6191 if (DEBUGLEVEL >= 10) {
6192 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo, &state->orig);
6193 }
6194
6195 tevent_req_done(req);
6196 }
6197
6198 NTSTATUS rpccli_samr_SetUserInfo_recv(struct tevent_req *req,
6199 TALLOC_CTX *mem_ctx,
6200 NTSTATUS *result)
6201 {
6202 struct rpccli_samr_SetUserInfo_state *state = tevent_req_data(
6203 req, struct rpccli_samr_SetUserInfo_state);
6204 NTSTATUS status;
6205
6206 if (tevent_req_is_nterror(req, &status)) {
6207 tevent_req_received(req);
6208 return status;
6209 }
6210
6211 /* Steal possbile out parameters to the callers context */
6212 talloc_steal(mem_ctx, state->out_mem_ctx);
6213
6214 /* Return result */
6215 *result = state->orig.out.result;
6216
6217 tevent_req_received(req);
6218 return NT_STATUS_OK;
6219 }
6220
6221 NTSTATUS rpccli_samr_SetUserInfo(struct rpc_pipe_client *cli,
6222 TALLOC_CTX *mem_ctx,
6223 struct policy_handle *user_handle /* [in] [ref] */,
6224 enum samr_UserInfoLevel level /* [in] */,
6225 union samr_UserInfo *info /* [in] [ref,switch_is(level)] */)
6226 {
6227 struct samr_SetUserInfo r;
6228 NTSTATUS status;
6229
6230 /* In parameters */
6231 r.in.user_handle = user_handle;
6232 r.in.level = level;
6233 r.in.info = info;
6234
6235 if (DEBUGLEVEL >= 10) {
6236 NDR_PRINT_IN_DEBUG(samr_SetUserInfo, &r);
6237 }
6238
6239 status = cli->dispatch(cli,
6240 mem_ctx,
6241 &ndr_table_samr,
6242 NDR_SAMR_SETUSERINFO,
6243 &r);
6244
6245 if (!NT_STATUS_IS_OK(status)) {
6246 return status;
6247 }
6248
6249 if (DEBUGLEVEL >= 10) {
6250 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo, &r);
6251 }
6252
6253 if (NT_STATUS_IS_ERR(status)) {
6254 return status;
6255 }
6256
6257 /* Return variables */
6258
6259 /* Return result */
6260 return r.out.result;
6261 }
6262
6263 struct rpccli_samr_ChangePasswordUser_state {
6264 struct samr_ChangePasswordUser orig;
6265 struct samr_ChangePasswordUser tmp;
6266 TALLOC_CTX *out_mem_ctx;
6267 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6268 };
6269
6270 static void rpccli_samr_ChangePasswordUser_done(struct tevent_req *subreq);
6271
6272 struct tevent_req *rpccli_samr_ChangePasswordUser_send(TALLOC_CTX *mem_ctx,
6273 struct tevent_context *ev,
6274 struct rpc_pipe_client *cli,
6275 struct policy_handle *_user_handle /* [in] [ref] */,
6276 uint8_t _lm_present /* [in] */,
6277 struct samr_Password *_old_lm_crypted /* [in] [unique] */,
6278 struct samr_Password *_new_lm_crypted /* [in] [unique] */,
6279 uint8_t _nt_present /* [in] */,
6280 struct samr_Password *_old_nt_crypted /* [in] [unique] */,
6281 struct samr_Password *_new_nt_crypted /* [in] [unique] */,
6282 uint8_t _cross1_present /* [in] */,
6283 struct samr_Password *_nt_cross /* [in] [unique] */,
6284 uint8_t _cross2_present /* [in] */,
6285 struct samr_Password *_lm_cross /* [in] [unique] */)
6286 {
6287 struct tevent_req *req;
6288 struct rpccli_samr_ChangePasswordUser_state *state;
6289 struct tevent_req *subreq;
6290
6291 req = tevent_req_create(mem_ctx, &state,
6292 struct rpccli_samr_ChangePasswordUser_state);
6293 if (req == NULL) {
6294 return NULL;
6295 }
6296 state->out_mem_ctx = NULL;
6297 state->dispatch_recv = cli->dispatch_recv;
6298
6299 /* In parameters */
6300 state->orig.in.user_handle = _user_handle;
6301 state->orig.in.lm_present = _lm_present;
6302 state->orig.in.old_lm_crypted = _old_lm_crypted;
6303 state->orig.in.new_lm_crypted = _new_lm_crypted;
6304 state->orig.in.nt_present = _nt_present;
6305 state->orig.in.old_nt_crypted = _old_nt_crypted;
6306 state->orig.in.new_nt_crypted = _new_nt_crypted;
6307 state->orig.in.cross1_present = _cross1_present;
6308 state->orig.in.nt_cross = _nt_cross;
6309 state->orig.in.cross2_present = _cross2_present;
6310 state->orig.in.lm_cross = _lm_cross;
6311
6312 /* Out parameters */
6313
6314 /* Result */
6315 ZERO_STRUCT(state->orig.out.result);
6316
6317 if (DEBUGLEVEL >= 10) {
6318 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser, &state->orig);
6319 }
6320
6321 /* make a temporary copy, that we pass to the dispatch function */
6322 state->tmp = state->orig;
6323
6324 subreq = cli->dispatch_send(state, ev, cli,
6325 &ndr_table_samr,
6326 NDR_SAMR_CHANGEPASSWORDUSER,
6327 &state->tmp);
6328 if (tevent_req_nomem(subreq, req)) {
6329 return tevent_req_post(req, ev);
6330 }
6331 tevent_req_set_callback(subreq, rpccli_samr_ChangePasswordUser_done, req);
6332 return req;
6333 }
6334
6335 static void rpccli_samr_ChangePasswordUser_done(struct tevent_req *subreq)
6336 {
6337 struct tevent_req *req = tevent_req_callback_data(
6338 subreq, struct tevent_req);
6339 struct rpccli_samr_ChangePasswordUser_state *state = tevent_req_data(
6340 req, struct rpccli_samr_ChangePasswordUser_state);
6341 NTSTATUS status;
6342 TALLOC_CTX *mem_ctx;
6343
6344 if (state->out_mem_ctx) {
6345 mem_ctx = state->out_mem_ctx;
6346 } else {
6347 mem_ctx = state;
6348 }
6349
6350 status = state->dispatch_recv(subreq, mem_ctx);
6351 TALLOC_FREE(subreq);
6352 if (!NT_STATUS_IS_OK(status)) {
6353 tevent_req_nterror(req, status);
6354 return;
6355 }
6356
6357 /* Copy out parameters */
6358
6359 /* Copy result */
6360 state->orig.out.result = state->tmp.out.result;
6361
6362 /* Reset temporary structure */
6363 ZERO_STRUCT(state->tmp);
6364
6365 if (DEBUGLEVEL >= 10) {
6366 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser, &state->orig);
6367 }
6368
6369 tevent_req_done(req);
6370 }
6371
6372 NTSTATUS rpccli_samr_ChangePasswordUser_recv(struct tevent_req *req,
6373 TALLOC_CTX *mem_ctx,
6374 NTSTATUS *result)
6375 {
6376 struct rpccli_samr_ChangePasswordUser_state *state = tevent_req_data(
6377 req, struct rpccli_samr_ChangePasswordUser_state);
6378 NTSTATUS status;
6379
6380 if (tevent_req_is_nterror(req, &status)) {
6381 tevent_req_received(req);
6382 return status;
6383 }
6384
6385 /* Steal possbile out parameters to the callers context */
6386 talloc_steal(mem_ctx, state->out_mem_ctx);
6387
6388 /* Return result */
6389 *result = state->orig.out.result;
6390
6391 tevent_req_received(req);
6392 return NT_STATUS_OK;
6393 }
6394
6395 NTSTATUS rpccli_samr_ChangePasswordUser(struct rpc_pipe_client *cli,
6396 TALLOC_CTX *mem_ctx,
6397 struct policy_handle *user_handle /* [in] [ref] */,
6398 uint8_t lm_present /* [in] */,
6399 struct samr_Password *old_lm_crypted /* [in] [unique] */,
6400 struct samr_Password *new_lm_crypted /* [in] [unique] */,
6401 uint8_t nt_present /* [in] */,
6402 struct samr_Password *old_nt_crypted /* [in] [unique] */,
6403 struct samr_Password *new_nt_crypted /* [in] [unique] */,
6404 uint8_t cross1_present /* [in] */,
6405 struct samr_Password *nt_cross /* [in] [unique] */,
6406 uint8_t cross2_present /* [in] */,
6407 struct samr_Password *lm_cross /* [in] [unique] */)
6408 {
6409 struct samr_ChangePasswordUser r;
6410 NTSTATUS status;
6411
6412 /* In parameters */
6413 r.in.user_handle = user_handle;
6414 r.in.lm_present = lm_present;
6415 r.in.old_lm_crypted = old_lm_crypted;
6416 r.in.new_lm_crypted = new_lm_crypted;
6417 r.in.nt_present = nt_present;
6418 r.in.old_nt_crypted = old_nt_crypted;
6419 r.in.new_nt_crypted = new_nt_crypted;
6420 r.in.cross1_present = cross1_present;
6421 r.in.nt_cross = nt_cross;
6422 r.in.cross2_present = cross2_present;
6423 r.in.lm_cross = lm_cross;
6424
6425 if (DEBUGLEVEL >= 10) {
6426 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser, &r);
6427 }
6428
6429 status = cli->dispatch(cli,
6430 mem_ctx,
6431 &ndr_table_samr,
6432 NDR_SAMR_CHANGEPASSWORDUSER,
6433 &r);
6434
6435 if (!NT_STATUS_IS_OK(status)) {
6436 return status;
6437 }
6438
6439 if (DEBUGLEVEL >= 10) {
6440 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser, &r);
6441 }
6442
6443 if (NT_STATUS_IS_ERR(status)) {
6444 return status;
6445 }
6446
6447 /* Return variables */
6448
6449 /* Return result */
6450 return r.out.result;
6451 }
6452
6453 struct rpccli_samr_GetGroupsForUser_state {
6454 struct samr_GetGroupsForUser orig;
6455 struct samr_GetGroupsForUser tmp;
6456 TALLOC_CTX *out_mem_ctx;
6457 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6458 };
6459
6460 static void rpccli_samr_GetGroupsForUser_done(struct tevent_req *subreq);
6461
6462 struct tevent_req *rpccli_samr_GetGroupsForUser_send(TALLOC_CTX *mem_ctx,
6463 struct tevent_context *ev,
6464 struct rpc_pipe_client *cli,
6465 struct policy_handle *_user_handle /* [in] [ref] */,
6466 struct samr_RidWithAttributeArray **_rids /* [out] [ref] */)
6467 {
6468 struct tevent_req *req;
6469 struct rpccli_samr_GetGroupsForUser_state *state;
6470 struct tevent_req *subreq;
6471
6472 req = tevent_req_create(mem_ctx, &state,
6473 struct rpccli_samr_GetGroupsForUser_state);
6474 if (req == NULL) {
6475 return NULL;
6476 }
6477 state->out_mem_ctx = NULL;
6478 state->dispatch_recv = cli->dispatch_recv;
6479
6480 /* In parameters */
6481 state->orig.in.user_handle = _user_handle;
6482
6483 /* Out parameters */
6484 state->orig.out.rids = _rids;
6485
6486 /* Result */
6487 ZERO_STRUCT(state->orig.out.result);
6488
6489 if (DEBUGLEVEL >= 10) {
6490 NDR_PRINT_IN_DEBUG(samr_GetGroupsForUser, &state->orig);
6491 }
6492
6493 state->out_mem_ctx = talloc_named_const(state, 0,
6494 "rpccli_samr_GetGroupsForUser_out_memory");
6495 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6496 return tevent_req_post(req, ev);
6497 }
6498
6499 /* make a temporary copy, that we pass to the dispatch function */
6500 state->tmp = state->orig;
6501
6502 subreq = cli->dispatch_send(state, ev, cli,
6503 &ndr_table_samr,
6504 NDR_SAMR_GETGROUPSFORUSER,
6505 &state->tmp);
6506 if (tevent_req_nomem(subreq, req)) {
6507 return tevent_req_post(req, ev);
6508 }
6509 tevent_req_set_callback(subreq, rpccli_samr_GetGroupsForUser_done, req);
6510 return req;
6511 }
6512
6513 static void rpccli_samr_GetGroupsForUser_done(struct tevent_req *subreq)
6514 {
6515 struct tevent_req *req = tevent_req_callback_data(
6516 subreq, struct tevent_req);
6517 struct rpccli_samr_GetGroupsForUser_state *state = tevent_req_data(
6518 req, struct rpccli_samr_GetGroupsForUser_state);
6519 NTSTATUS status;
6520 TALLOC_CTX *mem_ctx;
6521
6522 if (state->out_mem_ctx) {
6523 mem_ctx = state->out_mem_ctx;
6524 } else {
6525 mem_ctx = state;
6526 }
6527
6528 status = state->dispatch_recv(subreq, mem_ctx);
6529 TALLOC_FREE(subreq);
6530 if (!NT_STATUS_IS_OK(status)) {
6531 tevent_req_nterror(req, status);
6532 return;
6533 }
6534
6535 /* Copy out parameters */
6536 *state->orig.out.rids = *state->tmp.out.rids;
6537
6538 /* Copy result */
6539 state->orig.out.result = state->tmp.out.result;
6540
6541 /* Reset temporary structure */
6542 ZERO_STRUCT(state->tmp);
6543
6544 if (DEBUGLEVEL >= 10) {
6545 NDR_PRINT_OUT_DEBUG(samr_GetGroupsForUser, &state->orig);
6546 }
6547
6548 tevent_req_done(req);
6549 }
6550
6551 NTSTATUS rpccli_samr_GetGroupsForUser_recv(struct tevent_req *req,
6552 TALLOC_CTX *mem_ctx,
6553 NTSTATUS *result)
6554 {
6555 struct rpccli_samr_GetGroupsForUser_state *state = tevent_req_data(
6556 req, struct rpccli_samr_GetGroupsForUser_state);
6557 NTSTATUS status;
6558
6559 if (tevent_req_is_nterror(req, &status)) {
6560 tevent_req_received(req);
6561 return status;
6562 }
6563
6564 /* Steal possbile out parameters to the callers context */
6565 talloc_steal(mem_ctx, state->out_mem_ctx);
6566
6567 /* Return result */
6568 *result = state->orig.out.result;
6569
6570 tevent_req_received(req);
6571 return NT_STATUS_OK;
6572 }
6573
6574 NTSTATUS rpccli_samr_GetGroupsForUser(struct rpc_pipe_client *cli,
6575 TALLOC_CTX *mem_ctx,
6576 struct policy_handle *user_handle /* [in] [ref] */,
6577 struct samr_RidWithAttributeArray **rids /* [out] [ref] */)
6578 {
6579 struct samr_GetGroupsForUser r;
6580 NTSTATUS status;
6581
6582 /* In parameters */
6583 r.in.user_handle = user_handle;
6584
6585 if (DEBUGLEVEL >= 10) {
6586 NDR_PRINT_IN_DEBUG(samr_GetGroupsForUser, &r);
6587 }
6588
6589 status = cli->dispatch(cli,
6590 mem_ctx,
6591 &ndr_table_samr,
6592 NDR_SAMR_GETGROUPSFORUSER,
6593 &r);
6594
6595 if (!NT_STATUS_IS_OK(status)) {
6596 return status;
6597 }
6598
6599 if (DEBUGLEVEL >= 10) {
6600 NDR_PRINT_OUT_DEBUG(samr_GetGroupsForUser, &r);
6601 }
6602
6603 if (NT_STATUS_IS_ERR(status)) {
6604 return status;
6605 }
6606
6607 /* Return variables */
6608 *rids = *r.out.rids;
6609
6610 /* Return result */
6611 return r.out.result;
6612 }
6613
6614 struct rpccli_samr_QueryDisplayInfo_state {
6615 struct samr_QueryDisplayInfo orig;
6616 struct samr_QueryDisplayInfo tmp;
6617 TALLOC_CTX *out_mem_ctx;
6618 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6619 };
6620
6621 static void rpccli_samr_QueryDisplayInfo_done(struct tevent_req *subreq);
6622
6623 struct tevent_req *rpccli_samr_QueryDisplayInfo_send(TALLOC_CTX *mem_ctx,
6624 struct tevent_context *ev,
6625 struct rpc_pipe_client *cli,
6626 struct policy_handle *_domain_handle /* [in] [ref] */,
6627 uint16_t _level /* [in] */,
6628 uint32_t _start_idx /* [in] */,
6629 uint32_t _max_entries /* [in] */,
6630 uint32_t _buf_size /* [in] */,
6631 uint32_t *_total_size /* [out] [ref] */,
6632 uint32_t *_returned_size /* [out] [ref] */,
6633 union samr_DispInfo *_info /* [out] [ref,switch_is(level)] */)
6634 {
6635 struct tevent_req *req;
6636 struct rpccli_samr_QueryDisplayInfo_state *state;
6637 struct tevent_req *subreq;
6638
6639 req = tevent_req_create(mem_ctx, &state,
6640 struct rpccli_samr_QueryDisplayInfo_state);
6641 if (req == NULL) {
6642 return NULL;
6643 }
6644 state->out_mem_ctx = NULL;
6645 state->dispatch_recv = cli->dispatch_recv;
6646
6647 /* In parameters */
6648 state->orig.in.domain_handle = _domain_handle;
6649 state->orig.in.level = _level;
6650 state->orig.in.start_idx = _start_idx;
6651 state->orig.in.max_entries = _max_entries;
6652 state->orig.in.buf_size = _buf_size;
6653
6654 /* Out parameters */
6655 state->orig.out.total_size = _total_size;
6656 state->orig.out.returned_size = _returned_size;
6657 state->orig.out.info = _info;
6658
6659 /* Result */
6660 ZERO_STRUCT(state->orig.out.result);
6661
6662 if (DEBUGLEVEL >= 10) {
6663 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo, &state->orig);
6664 }
6665
6666 state->out_mem_ctx = talloc_named_const(state, 0,
6667 "rpccli_samr_QueryDisplayInfo_out_memory");
6668 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6669 return tevent_req_post(req, ev);
6670 }
6671
6672 /* make a temporary copy, that we pass to the dispatch function */
6673 state->tmp = state->orig;
6674
6675 subreq = cli->dispatch_send(state, ev, cli,
6676 &ndr_table_samr,
6677 NDR_SAMR_QUERYDISPLAYINFO,
6678 &state->tmp);
6679 if (tevent_req_nomem(subreq, req)) {
6680 return tevent_req_post(req, ev);
6681 }
6682 tevent_req_set_callback(subreq, rpccli_samr_QueryDisplayInfo_done, req);
6683 return req;
6684 }
6685
6686 static void rpccli_samr_QueryDisplayInfo_done(struct tevent_req *subreq)
6687 {
6688 struct tevent_req *req = tevent_req_callback_data(
6689 subreq, struct tevent_req);
6690 struct rpccli_samr_QueryDisplayInfo_state *state = tevent_req_data(
6691 req, struct rpccli_samr_QueryDisplayInfo_state);
6692 NTSTATUS status;
6693 TALLOC_CTX *mem_ctx;
6694
6695 if (state->out_mem_ctx) {
6696 mem_ctx = state->out_mem_ctx;
6697 } else {
6698 mem_ctx = state;
6699 }
6700
6701 status = state->dispatch_recv(subreq, mem_ctx);
6702 TALLOC_FREE(subreq);
6703 if (!NT_STATUS_IS_OK(status)) {
6704 tevent_req_nterror(req, status);
6705 return;
6706 }
6707
6708 /* Copy out parameters */
6709 *state->orig.out.total_size = *state->tmp.out.total_size;
6710 *state->orig.out.returned_size = *state->tmp.out.returned_size;
6711 *state->orig.out.info = *state->tmp.out.info;
6712
6713 /* Copy result */
6714 state->orig.out.result = state->tmp.out.result;
6715
6716 /* Reset temporary structure */
6717 ZERO_STRUCT(state->tmp);
6718
6719 if (DEBUGLEVEL >= 10) {
6720 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo, &state->orig);
6721 }
6722
6723 tevent_req_done(req);
6724 }
6725
6726 NTSTATUS rpccli_samr_QueryDisplayInfo_recv(struct tevent_req *req,
6727 TALLOC_CTX *mem_ctx,
6728 NTSTATUS *result)
6729 {
6730 struct rpccli_samr_QueryDisplayInfo_state *state = tevent_req_data(
6731 req, struct rpccli_samr_QueryDisplayInfo_state);
6732 NTSTATUS status;
6733
6734 if (tevent_req_is_nterror(req, &status)) {
6735 tevent_req_received(req);
6736 return status;
6737 }
6738
6739 /* Steal possbile out parameters to the callers context */
6740 talloc_steal(mem_ctx, state->out_mem_ctx);
6741
6742 /* Return result */
6743 *result = state->orig.out.result;
6744
6745 tevent_req_received(req);
6746 return NT_STATUS_OK;
6747 }
6748
6749 NTSTATUS rpccli_samr_QueryDisplayInfo(struct rpc_pipe_client *cli,
6750 TALLOC_CTX *mem_ctx,
6751 struct policy_handle *domain_handle /* [in] [ref] */,
6752 uint16_t level /* [in] */,
6753 uint32_t start_idx /* [in] */,
6754 uint32_t max_entries /* [in] */,
6755 uint32_t buf_size /* [in] */,
6756 uint32_t *total_size /* [out] [ref] */,
6757 uint32_t *returned_size /* [out] [ref] */,
6758 union samr_DispInfo *info /* [out] [ref,switch_is(level)] */)
6759 {
6760 struct samr_QueryDisplayInfo r;
6761 NTSTATUS status;
6762
6763 /* In parameters */
6764 r.in.domain_handle = domain_handle;
6765 r.in.level = level;
6766 r.in.start_idx = start_idx;
6767 r.in.max_entries = max_entries;
6768 r.in.buf_size = buf_size;
6769
6770 if (DEBUGLEVEL >= 10) {
6771 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo, &r);
6772 }
6773
6774 status = cli->dispatch(cli,
6775 mem_ctx,
6776 &ndr_table_samr,
6777 NDR_SAMR_QUERYDISPLAYINFO,
6778 &r);
6779
6780 if (!NT_STATUS_IS_OK(status)) {
6781 return status;
6782 }
6783
6784 if (DEBUGLEVEL >= 10) {
6785 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo, &r);
6786 }
6787
6788 if (NT_STATUS_IS_ERR(status)) {
6789 return status;
6790 }
6791
6792 /* Return variables */
6793 *total_size = *r.out.total_size;
6794 *returned_size = *r.out.returned_size;
6795 *info = *r.out.info;
6796
6797 /* Return result */
6798 return r.out.result;
6799 }
6800
6801 struct rpccli_samr_GetDisplayEnumerationIndex_state {
6802 struct samr_GetDisplayEnumerationIndex orig;
6803 struct samr_GetDisplayEnumerationIndex tmp;
6804 TALLOC_CTX *out_mem_ctx;
6805 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6806 };
6807
6808 static void rpccli_samr_GetDisplayEnumerationIndex_done(struct tevent_req *subreq);
6809
6810 struct tevent_req *rpccli_samr_GetDisplayEnumerationIndex_send(TALLOC_CTX *mem_ctx,
6811 struct tevent_context *ev,
6812 struct rpc_pipe_client *cli,
6813 struct policy_handle *_domain_handle /* [in] [ref] */,
6814 uint16_t _level /* [in] */,
6815 struct lsa_String *_name /* [in] [ref] */,
6816 uint32_t *_idx /* [out] [ref] */)
6817 {
6818 struct tevent_req *req;
6819 struct rpccli_samr_GetDisplayEnumerationIndex_state *state;
6820 struct tevent_req *subreq;
6821
6822 req = tevent_req_create(mem_ctx, &state,
6823 struct rpccli_samr_GetDisplayEnumerationIndex_state);
6824 if (req == NULL) {
6825 return NULL;
6826 }
6827 state->out_mem_ctx = NULL;
6828 state->dispatch_recv = cli->dispatch_recv;
6829
6830 /* In parameters */
6831 state->orig.in.domain_handle = _domain_handle;
6832 state->orig.in.level = _level;
6833 state->orig.in.name = _name;
6834
6835 /* Out parameters */
6836 state->orig.out.idx = _idx;
6837
6838 /* Result */
6839 ZERO_STRUCT(state->orig.out.result);
6840
6841 if (DEBUGLEVEL >= 10) {
6842 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex, &state->orig);
6843 }
6844
6845 state->out_mem_ctx = talloc_named_const(state, 0,
6846 "rpccli_samr_GetDisplayEnumerationIndex_out_memory");
6847 if (tevent_req_nomem(state->out_mem_ctx, req)) {
6848 return tevent_req_post(req, ev);
6849 }
6850
6851 /* make a temporary copy, that we pass to the dispatch function */
6852 state->tmp = state->orig;
6853
6854 subreq = cli->dispatch_send(state, ev, cli,
6855 &ndr_table_samr,
6856 NDR_SAMR_GETDISPLAYENUMERATIONINDEX,
6857 &state->tmp);
6858 if (tevent_req_nomem(subreq, req)) {
6859 return tevent_req_post(req, ev);
6860 }
6861 tevent_req_set_callback(subreq, rpccli_samr_GetDisplayEnumerationIndex_done, req);
6862 return req;
6863 }
6864
6865 static void rpccli_samr_GetDisplayEnumerationIndex_done(struct tevent_req *subreq)
6866 {
6867 struct tevent_req *req = tevent_req_callback_data(
6868 subreq, struct tevent_req);
6869 struct rpccli_samr_GetDisplayEnumerationIndex_state *state = tevent_req_data(
6870 req, struct rpccli_samr_GetDisplayEnumerationIndex_state);
6871 NTSTATUS status;
6872 TALLOC_CTX *mem_ctx;
6873
6874 if (state->out_mem_ctx) {
6875 mem_ctx = state->out_mem_ctx;
6876 } else {
6877 mem_ctx = state;
6878 }
6879
6880 status = state->dispatch_recv(subreq, mem_ctx);
6881 TALLOC_FREE(subreq);
6882 if (!NT_STATUS_IS_OK(status)) {
6883 tevent_req_nterror(req, status);
6884 return;
6885 }
6886
6887 /* Copy out parameters */
6888 *state->orig.out.idx = *state->tmp.out.idx;
6889
6890 /* Copy result */
6891 state->orig.out.result = state->tmp.out.result;
6892
6893 /* Reset temporary structure */
6894 ZERO_STRUCT(state->tmp);
6895
6896 if (DEBUGLEVEL >= 10) {
6897 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex, &state->orig);
6898 }
6899
6900 tevent_req_done(req);
6901 }
6902
6903 NTSTATUS rpccli_samr_GetDisplayEnumerationIndex_recv(struct tevent_req *req,
6904 TALLOC_CTX *mem_ctx,
6905 NTSTATUS *result)
6906 {
6907 struct rpccli_samr_GetDisplayEnumerationIndex_state *state = tevent_req_data(
6908 req, struct rpccli_samr_GetDisplayEnumerationIndex_state);
6909 NTSTATUS status;
6910
6911 if (tevent_req_is_nterror(req, &status)) {
6912 tevent_req_received(req);
6913 return status;
6914 }
6915
6916 /* Steal possbile out parameters to the callers context */
6917 talloc_steal(mem_ctx, state->out_mem_ctx);
6918
6919 /* Return result */
6920 *result = state->orig.out.result;
6921
6922 tevent_req_received(req);
6923 return NT_STATUS_OK;
6924 }
6925
6926 NTSTATUS rpccli_samr_GetDisplayEnumerationIndex(struct rpc_pipe_client *cli,
6927 TALLOC_CTX *mem_ctx,
6928 struct policy_handle *domain_handle /* [in] [ref] */,
6929 uint16_t level /* [in] */,
6930 struct lsa_String *name /* [in] [ref] */,
6931 uint32_t *idx /* [out] [ref] */)
6932 {
6933 struct samr_GetDisplayEnumerationIndex r;
6934 NTSTATUS status;
6935
6936 /* In parameters */
6937 r.in.domain_handle = domain_handle;
6938 r.in.level = level;
6939 r.in.name = name;
6940
6941 if (DEBUGLEVEL >= 10) {
6942 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex, &r);
6943 }
6944
6945 status = cli->dispatch(cli,
6946 mem_ctx,
6947 &ndr_table_samr,
6948 NDR_SAMR_GETDISPLAYENUMERATIONINDEX,
6949 &r);
6950
6951 if (!NT_STATUS_IS_OK(status)) {
6952 return status;
6953 }
6954
6955 if (DEBUGLEVEL >= 10) {
6956 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex, &r);
6957 }
6958
6959 if (NT_STATUS_IS_ERR(status)) {
6960 return status;
6961 }
6962
6963 /* Return variables */
6964 *idx = *r.out.idx;
6965
6966 /* Return result */
6967 return r.out.result;
6968 }
6969
6970 struct rpccli_samr_TestPrivateFunctionsDomain_state {
6971 struct samr_TestPrivateFunctionsDomain orig;
6972 struct samr_TestPrivateFunctionsDomain tmp;
6973 TALLOC_CTX *out_mem_ctx;
6974 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
6975 };
6976
6977 static void rpccli_samr_TestPrivateFunctionsDomain_done(struct tevent_req *subreq);
6978
6979 struct tevent_req *rpccli_samr_TestPrivateFunctionsDomain_send(TALLOC_CTX *mem_ctx,
6980 struct tevent_context *ev,
6981 struct rpc_pipe_client *cli,
6982 struct policy_handle *_domain_handle /* [in] [ref] */)
6983 {
6984 struct tevent_req *req;
6985 struct rpccli_samr_TestPrivateFunctionsDomain_state *state;
6986 struct tevent_req *subreq;
6987
6988 req = tevent_req_create(mem_ctx, &state,
6989 struct rpccli_samr_TestPrivateFunctionsDomain_state);
6990 if (req == NULL) {
6991 return NULL;
6992 }
6993 state->out_mem_ctx = NULL;
6994 state->dispatch_recv = cli->dispatch_recv;
6995
6996 /* In parameters */
6997 state->orig.in.domain_handle = _domain_handle;
6998
6999 /* Out parameters */
7000
7001 /* Result */
7002 ZERO_STRUCT(state->orig.out.result);
7003
7004 if (DEBUGLEVEL >= 10) {
7005 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsDomain, &state->orig);
7006 }
7007
7008 /* make a temporary copy, that we pass to the dispatch function */
7009 state->tmp = state->orig;
7010
7011 subreq = cli->dispatch_send(state, ev, cli,
7012 &ndr_table_samr,
7013 NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN,
7014 &state->tmp);
7015 if (tevent_req_nomem(subreq, req)) {
7016 return tevent_req_post(req, ev);
7017 }
7018 tevent_req_set_callback(subreq, rpccli_samr_TestPrivateFunctionsDomain_done, req);
7019 return req;
7020 }
7021
7022 static void rpccli_samr_TestPrivateFunctionsDomain_done(struct tevent_req *subreq)
7023 {
7024 struct tevent_req *req = tevent_req_callback_data(
7025 subreq, struct tevent_req);
7026 struct rpccli_samr_TestPrivateFunctionsDomain_state *state = tevent_req_data(
7027 req, struct rpccli_samr_TestPrivateFunctionsDomain_state);
7028 NTSTATUS status;
7029 TALLOC_CTX *mem_ctx;
7030
7031 if (state->out_mem_ctx) {
7032 mem_ctx = state->out_mem_ctx;
7033 } else {
7034 mem_ctx = state;
7035 }
7036
7037 status = state->dispatch_recv(subreq, mem_ctx);
7038 TALLOC_FREE(subreq);
7039 if (!NT_STATUS_IS_OK(status)) {
7040 tevent_req_nterror(req, status);
7041 return;
7042 }
7043
7044 /* Copy out parameters */
7045
7046 /* Copy result */
7047 state->orig.out.result = state->tmp.out.result;
7048
7049 /* Reset temporary structure */
7050 ZERO_STRUCT(state->tmp);
7051
7052 if (DEBUGLEVEL >= 10) {
7053 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsDomain, &state->orig);
7054 }
7055
7056 tevent_req_done(req);
7057 }
7058
7059 NTSTATUS rpccli_samr_TestPrivateFunctionsDomain_recv(struct tevent_req *req,
7060 TALLOC_CTX *mem_ctx,
7061 NTSTATUS *result)
7062 {
7063 struct rpccli_samr_TestPrivateFunctionsDomain_state *state = tevent_req_data(
7064 req, struct rpccli_samr_TestPrivateFunctionsDomain_state);
7065 NTSTATUS status;
7066
7067 if (tevent_req_is_nterror(req, &status)) {
7068 tevent_req_received(req);
7069 return status;
7070 }
7071
7072 /* Steal possbile out parameters to the callers context */
7073 talloc_steal(mem_ctx, state->out_mem_ctx);
7074
7075 /* Return result */
7076 *result = state->orig.out.result;
7077
7078 tevent_req_received(req);
7079 return NT_STATUS_OK;
7080 }
7081
7082 NTSTATUS rpccli_samr_TestPrivateFunctionsDomain(struct rpc_pipe_client *cli,
7083 TALLOC_CTX *mem_ctx,
7084 struct policy_handle *domain_handle /* [in] [ref] */)
7085 {
7086 struct samr_TestPrivateFunctionsDomain r;
7087 NTSTATUS status;
7088
7089 /* In parameters */
7090 r.in.domain_handle = domain_handle;
7091
7092 if (DEBUGLEVEL >= 10) {
7093 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsDomain, &r);
7094 }
7095
7096 status = cli->dispatch(cli,
7097 mem_ctx,
7098 &ndr_table_samr,
7099 NDR_SAMR_TESTPRIVATEFUNCTIONSDOMAIN,
7100 &r);
7101
7102 if (!NT_STATUS_IS_OK(status)) {
7103 return status;
7104 }
7105
7106 if (DEBUGLEVEL >= 10) {
7107 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsDomain, &r);
7108 }
7109
7110 if (NT_STATUS_IS_ERR(status)) {
7111 return status;
7112 }
7113
7114 /* Return variables */
7115
7116 /* Return result */
7117 return r.out.result;
7118 }
7119
7120 struct rpccli_samr_TestPrivateFunctionsUser_state {
7121 struct samr_TestPrivateFunctionsUser orig;
7122 struct samr_TestPrivateFunctionsUser tmp;
7123 TALLOC_CTX *out_mem_ctx;
7124 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7125 };
7126
7127 static void rpccli_samr_TestPrivateFunctionsUser_done(struct tevent_req *subreq);
7128
7129 struct tevent_req *rpccli_samr_TestPrivateFunctionsUser_send(TALLOC_CTX *mem_ctx,
7130 struct tevent_context *ev,
7131 struct rpc_pipe_client *cli,
7132 struct policy_handle *_user_handle /* [in] [ref] */)
7133 {
7134 struct tevent_req *req;
7135 struct rpccli_samr_TestPrivateFunctionsUser_state *state;
7136 struct tevent_req *subreq;
7137
7138 req = tevent_req_create(mem_ctx, &state,
7139 struct rpccli_samr_TestPrivateFunctionsUser_state);
7140 if (req == NULL) {
7141 return NULL;
7142 }
7143 state->out_mem_ctx = NULL;
7144 state->dispatch_recv = cli->dispatch_recv;
7145
7146 /* In parameters */
7147 state->orig.in.user_handle = _user_handle;
7148
7149 /* Out parameters */
7150
7151 /* Result */
7152 ZERO_STRUCT(state->orig.out.result);
7153
7154 if (DEBUGLEVEL >= 10) {
7155 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsUser, &state->orig);
7156 }
7157
7158 /* make a temporary copy, that we pass to the dispatch function */
7159 state->tmp = state->orig;
7160
7161 subreq = cli->dispatch_send(state, ev, cli,
7162 &ndr_table_samr,
7163 NDR_SAMR_TESTPRIVATEFUNCTIONSUSER,
7164 &state->tmp);
7165 if (tevent_req_nomem(subreq, req)) {
7166 return tevent_req_post(req, ev);
7167 }
7168 tevent_req_set_callback(subreq, rpccli_samr_TestPrivateFunctionsUser_done, req);
7169 return req;
7170 }
7171
7172 static void rpccli_samr_TestPrivateFunctionsUser_done(struct tevent_req *subreq)
7173 {
7174 struct tevent_req *req = tevent_req_callback_data(
7175 subreq, struct tevent_req);
7176 struct rpccli_samr_TestPrivateFunctionsUser_state *state = tevent_req_data(
7177 req, struct rpccli_samr_TestPrivateFunctionsUser_state);
7178 NTSTATUS status;
7179 TALLOC_CTX *mem_ctx;
7180
7181 if (state->out_mem_ctx) {
7182 mem_ctx = state->out_mem_ctx;
7183 } else {
7184 mem_ctx = state;
7185 }
7186
7187 status = state->dispatch_recv(subreq, mem_ctx);
7188 TALLOC_FREE(subreq);
7189 if (!NT_STATUS_IS_OK(status)) {
7190 tevent_req_nterror(req, status);
7191 return;
7192 }
7193
7194 /* Copy out parameters */
7195
7196 /* Copy result */
7197 state->orig.out.result = state->tmp.out.result;
7198
7199 /* Reset temporary structure */
7200 ZERO_STRUCT(state->tmp);
7201
7202 if (DEBUGLEVEL >= 10) {
7203 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsUser, &state->orig);
7204 }
7205
7206 tevent_req_done(req);
7207 }
7208
7209 NTSTATUS rpccli_samr_TestPrivateFunctionsUser_recv(struct tevent_req *req,
7210 TALLOC_CTX *mem_ctx,
7211 NTSTATUS *result)
7212 {
7213 struct rpccli_samr_TestPrivateFunctionsUser_state *state = tevent_req_data(
7214 req, struct rpccli_samr_TestPrivateFunctionsUser_state);
7215 NTSTATUS status;
7216
7217 if (tevent_req_is_nterror(req, &status)) {
7218 tevent_req_received(req);
7219 return status;
7220 }
7221
7222 /* Steal possbile out parameters to the callers context */
7223 talloc_steal(mem_ctx, state->out_mem_ctx);
7224
7225 /* Return result */
7226 *result = state->orig.out.result;
7227
7228 tevent_req_received(req);
7229 return NT_STATUS_OK;
7230 }
7231
7232 NTSTATUS rpccli_samr_TestPrivateFunctionsUser(struct rpc_pipe_client *cli,
7233 TALLOC_CTX *mem_ctx,
7234 struct policy_handle *user_handle /* [in] [ref] */)
7235 {
7236 struct samr_TestPrivateFunctionsUser r;
7237 NTSTATUS status;
7238
7239 /* In parameters */
7240 r.in.user_handle = user_handle;
7241
7242 if (DEBUGLEVEL >= 10) {
7243 NDR_PRINT_IN_DEBUG(samr_TestPrivateFunctionsUser, &r);
7244 }
7245
7246 status = cli->dispatch(cli,
7247 mem_ctx,
7248 &ndr_table_samr,
7249 NDR_SAMR_TESTPRIVATEFUNCTIONSUSER,
7250 &r);
7251
7252 if (!NT_STATUS_IS_OK(status)) {
7253 return status;
7254 }
7255
7256 if (DEBUGLEVEL >= 10) {
7257 NDR_PRINT_OUT_DEBUG(samr_TestPrivateFunctionsUser, &r);
7258 }
7259
7260 if (NT_STATUS_IS_ERR(status)) {
7261 return status;
7262 }
7263
7264 /* Return variables */
7265
7266 /* Return result */
7267 return r.out.result;
7268 }
7269
7270 struct rpccli_samr_GetUserPwInfo_state {
7271 struct samr_GetUserPwInfo orig;
7272 struct samr_GetUserPwInfo tmp;
7273 TALLOC_CTX *out_mem_ctx;
7274 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7275 };
7276
7277 static void rpccli_samr_GetUserPwInfo_done(struct tevent_req *subreq);
7278
7279 struct tevent_req *rpccli_samr_GetUserPwInfo_send(TALLOC_CTX *mem_ctx,
7280 struct tevent_context *ev,
7281 struct rpc_pipe_client *cli,
7282 struct policy_handle *_user_handle /* [in] [ref] */,
7283 struct samr_PwInfo *_info /* [out] [ref] */)
7284 {
7285 struct tevent_req *req;
7286 struct rpccli_samr_GetUserPwInfo_state *state;
7287 struct tevent_req *subreq;
7288
7289 req = tevent_req_create(mem_ctx, &state,
7290 struct rpccli_samr_GetUserPwInfo_state);
7291 if (req == NULL) {
7292 return NULL;
7293 }
7294 state->out_mem_ctx = NULL;
7295 state->dispatch_recv = cli->dispatch_recv;
7296
7297 /* In parameters */
7298 state->orig.in.user_handle = _user_handle;
7299
7300 /* Out parameters */
7301 state->orig.out.info = _info;
7302
7303 /* Result */
7304 ZERO_STRUCT(state->orig.out.result);
7305
7306 if (DEBUGLEVEL >= 10) {
7307 NDR_PRINT_IN_DEBUG(samr_GetUserPwInfo, &state->orig);
7308 }
7309
7310 state->out_mem_ctx = talloc_named_const(state, 0,
7311 "rpccli_samr_GetUserPwInfo_out_memory");
7312 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7313 return tevent_req_post(req, ev);
7314 }
7315
7316 /* make a temporary copy, that we pass to the dispatch function */
7317 state->tmp = state->orig;
7318
7319 subreq = cli->dispatch_send(state, ev, cli,
7320 &ndr_table_samr,
7321 NDR_SAMR_GETUSERPWINFO,
7322 &state->tmp);
7323 if (tevent_req_nomem(subreq, req)) {
7324 return tevent_req_post(req, ev);
7325 }
7326 tevent_req_set_callback(subreq, rpccli_samr_GetUserPwInfo_done, req);
7327 return req;
7328 }
7329
7330 static void rpccli_samr_GetUserPwInfo_done(struct tevent_req *subreq)
7331 {
7332 struct tevent_req *req = tevent_req_callback_data(
7333 subreq, struct tevent_req);
7334 struct rpccli_samr_GetUserPwInfo_state *state = tevent_req_data(
7335 req, struct rpccli_samr_GetUserPwInfo_state);
7336 NTSTATUS status;
7337 TALLOC_CTX *mem_ctx;
7338
7339 if (state->out_mem_ctx) {
7340 mem_ctx = state->out_mem_ctx;
7341 } else {
7342 mem_ctx = state;
7343 }
7344
7345 status = state->dispatch_recv(subreq, mem_ctx);
7346 TALLOC_FREE(subreq);
7347 if (!NT_STATUS_IS_OK(status)) {
7348 tevent_req_nterror(req, status);
7349 return;
7350 }
7351
7352 /* Copy out parameters */
7353 *state->orig.out.info = *state->tmp.out.info;
7354
7355 /* Copy result */
7356 state->orig.out.result = state->tmp.out.result;
7357
7358 /* Reset temporary structure */
7359 ZERO_STRUCT(state->tmp);
7360
7361 if (DEBUGLEVEL >= 10) {
7362 NDR_PRINT_OUT_DEBUG(samr_GetUserPwInfo, &state->orig);
7363 }
7364
7365 tevent_req_done(req);
7366 }
7367
7368 NTSTATUS rpccli_samr_GetUserPwInfo_recv(struct tevent_req *req,
7369 TALLOC_CTX *mem_ctx,
7370 NTSTATUS *result)
7371 {
7372 struct rpccli_samr_GetUserPwInfo_state *state = tevent_req_data(
7373 req, struct rpccli_samr_GetUserPwInfo_state);
7374 NTSTATUS status;
7375
7376 if (tevent_req_is_nterror(req, &status)) {
7377 tevent_req_received(req);
7378 return status;
7379 }
7380
7381 /* Steal possbile out parameters to the callers context */
7382 talloc_steal(mem_ctx, state->out_mem_ctx);
7383
7384 /* Return result */
7385 *result = state->orig.out.result;
7386
7387 tevent_req_received(req);
7388 return NT_STATUS_OK;
7389 }
7390
7391 NTSTATUS rpccli_samr_GetUserPwInfo(struct rpc_pipe_client *cli,
7392 TALLOC_CTX *mem_ctx,
7393 struct policy_handle *user_handle /* [in] [ref] */,
7394 struct samr_PwInfo *info /* [out] [ref] */)
7395 {
7396 struct samr_GetUserPwInfo r;
7397 NTSTATUS status;
7398
7399 /* In parameters */
7400 r.in.user_handle = user_handle;
7401
7402 if (DEBUGLEVEL >= 10) {
7403 NDR_PRINT_IN_DEBUG(samr_GetUserPwInfo, &r);
7404 }
7405
7406 status = cli->dispatch(cli,
7407 mem_ctx,
7408 &ndr_table_samr,
7409 NDR_SAMR_GETUSERPWINFO,
7410 &r);
7411
7412 if (!NT_STATUS_IS_OK(status)) {
7413 return status;
7414 }
7415
7416 if (DEBUGLEVEL >= 10) {
7417 NDR_PRINT_OUT_DEBUG(samr_GetUserPwInfo, &r);
7418 }
7419
7420 if (NT_STATUS_IS_ERR(status)) {
7421 return status;
7422 }
7423
7424 /* Return variables */
7425 *info = *r.out.info;
7426
7427 /* Return result */
7428 return r.out.result;
7429 }
7430
7431 struct rpccli_samr_RemoveMemberFromForeignDomain_state {
7432 struct samr_RemoveMemberFromForeignDomain orig;
7433 struct samr_RemoveMemberFromForeignDomain tmp;
7434 TALLOC_CTX *out_mem_ctx;
7435 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7436 };
7437
7438 static void rpccli_samr_RemoveMemberFromForeignDomain_done(struct tevent_req *subreq);
7439
7440 struct tevent_req *rpccli_samr_RemoveMemberFromForeignDomain_send(TALLOC_CTX *mem_ctx,
7441 struct tevent_context *ev,
7442 struct rpc_pipe_client *cli,
7443 struct policy_handle *_domain_handle /* [in] [ref] */,
7444 struct dom_sid2 *_sid /* [in] [ref] */)
7445 {
7446 struct tevent_req *req;
7447 struct rpccli_samr_RemoveMemberFromForeignDomain_state *state;
7448 struct tevent_req *subreq;
7449
7450 req = tevent_req_create(mem_ctx, &state,
7451 struct rpccli_samr_RemoveMemberFromForeignDomain_state);
7452 if (req == NULL) {
7453 return NULL;
7454 }
7455 state->out_mem_ctx = NULL;
7456 state->dispatch_recv = cli->dispatch_recv;
7457
7458 /* In parameters */
7459 state->orig.in.domain_handle = _domain_handle;
7460 state->orig.in.sid = _sid;
7461
7462 /* Out parameters */
7463
7464 /* Result */
7465 ZERO_STRUCT(state->orig.out.result);
7466
7467 if (DEBUGLEVEL >= 10) {
7468 NDR_PRINT_IN_DEBUG(samr_RemoveMemberFromForeignDomain, &state->orig);
7469 }
7470
7471 /* make a temporary copy, that we pass to the dispatch function */
7472 state->tmp = state->orig;
7473
7474 subreq = cli->dispatch_send(state, ev, cli,
7475 &ndr_table_samr,
7476 NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN,
7477 &state->tmp);
7478 if (tevent_req_nomem(subreq, req)) {
7479 return tevent_req_post(req, ev);
7480 }
7481 tevent_req_set_callback(subreq, rpccli_samr_RemoveMemberFromForeignDomain_done, req);
7482 return req;
7483 }
7484
7485 static void rpccli_samr_RemoveMemberFromForeignDomain_done(struct tevent_req *subreq)
7486 {
7487 struct tevent_req *req = tevent_req_callback_data(
7488 subreq, struct tevent_req);
7489 struct rpccli_samr_RemoveMemberFromForeignDomain_state *state = tevent_req_data(
7490 req, struct rpccli_samr_RemoveMemberFromForeignDomain_state);
7491 NTSTATUS status;
7492 TALLOC_CTX *mem_ctx;
7493
7494 if (state->out_mem_ctx) {
7495 mem_ctx = state->out_mem_ctx;
7496 } else {
7497 mem_ctx = state;
7498 }
7499
7500 status = state->dispatch_recv(subreq, mem_ctx);
7501 TALLOC_FREE(subreq);
7502 if (!NT_STATUS_IS_OK(status)) {
7503 tevent_req_nterror(req, status);
7504 return;
7505 }
7506
7507 /* Copy out parameters */
7508
7509 /* Copy result */
7510 state->orig.out.result = state->tmp.out.result;
7511
7512 /* Reset temporary structure */
7513 ZERO_STRUCT(state->tmp);
7514
7515 if (DEBUGLEVEL >= 10) {
7516 NDR_PRINT_OUT_DEBUG(samr_RemoveMemberFromForeignDomain, &state->orig);
7517 }
7518
7519 tevent_req_done(req);
7520 }
7521
7522 NTSTATUS rpccli_samr_RemoveMemberFromForeignDomain_recv(struct tevent_req *req,
7523 TALLOC_CTX *mem_ctx,
7524 NTSTATUS *result)
7525 {
7526 struct rpccli_samr_RemoveMemberFromForeignDomain_state *state = tevent_req_data(
7527 req, struct rpccli_samr_RemoveMemberFromForeignDomain_state);
7528 NTSTATUS status;
7529
7530 if (tevent_req_is_nterror(req, &status)) {
7531 tevent_req_received(req);
7532 return status;
7533 }
7534
7535 /* Steal possbile out parameters to the callers context */
7536 talloc_steal(mem_ctx, state->out_mem_ctx);
7537
7538 /* Return result */
7539 *result = state->orig.out.result;
7540
7541 tevent_req_received(req);
7542 return NT_STATUS_OK;
7543 }
7544
7545 NTSTATUS rpccli_samr_RemoveMemberFromForeignDomain(struct rpc_pipe_client *cli,
7546 TALLOC_CTX *mem_ctx,
7547 struct policy_handle *domain_handle /* [in] [ref] */,
7548 struct dom_sid2 *sid /* [in] [ref] */)
7549 {
7550 struct samr_RemoveMemberFromForeignDomain r;
7551 NTSTATUS status;
7552
7553 /* In parameters */
7554 r.in.domain_handle = domain_handle;
7555 r.in.sid = sid;
7556
7557 if (DEBUGLEVEL >= 10) {
7558 NDR_PRINT_IN_DEBUG(samr_RemoveMemberFromForeignDomain, &r);
7559 }
7560
7561 status = cli->dispatch(cli,
7562 mem_ctx,
7563 &ndr_table_samr,
7564 NDR_SAMR_REMOVEMEMBERFROMFOREIGNDOMAIN,
7565 &r);
7566
7567 if (!NT_STATUS_IS_OK(status)) {
7568 return status;
7569 }
7570
7571 if (DEBUGLEVEL >= 10) {
7572 NDR_PRINT_OUT_DEBUG(samr_RemoveMemberFromForeignDomain, &r);
7573 }
7574
7575 if (NT_STATUS_IS_ERR(status)) {
7576 return status;
7577 }
7578
7579 /* Return variables */
7580
7581 /* Return result */
7582 return r.out.result;
7583 }
7584
7585 struct rpccli_samr_QueryDomainInfo2_state {
7586 struct samr_QueryDomainInfo2 orig;
7587 struct samr_QueryDomainInfo2 tmp;
7588 TALLOC_CTX *out_mem_ctx;
7589 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7590 };
7591
7592 static void rpccli_samr_QueryDomainInfo2_done(struct tevent_req *subreq);
7593
7594 struct tevent_req *rpccli_samr_QueryDomainInfo2_send(TALLOC_CTX *mem_ctx,
7595 struct tevent_context *ev,
7596 struct rpc_pipe_client *cli,
7597 struct policy_handle *_domain_handle /* [in] [ref] */,
7598 enum samr_DomainInfoClass _level /* [in] */,
7599 union samr_DomainInfo **_info /* [out] [ref,switch_is(level)] */)
7600 {
7601 struct tevent_req *req;
7602 struct rpccli_samr_QueryDomainInfo2_state *state;
7603 struct tevent_req *subreq;
7604
7605 req = tevent_req_create(mem_ctx, &state,
7606 struct rpccli_samr_QueryDomainInfo2_state);
7607 if (req == NULL) {
7608 return NULL;
7609 }
7610 state->out_mem_ctx = NULL;
7611 state->dispatch_recv = cli->dispatch_recv;
7612
7613 /* In parameters */
7614 state->orig.in.domain_handle = _domain_handle;
7615 state->orig.in.level = _level;
7616
7617 /* Out parameters */
7618 state->orig.out.info = _info;
7619
7620 /* Result */
7621 ZERO_STRUCT(state->orig.out.result);
7622
7623 if (DEBUGLEVEL >= 10) {
7624 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo2, &state->orig);
7625 }
7626
7627 state->out_mem_ctx = talloc_named_const(state, 0,
7628 "rpccli_samr_QueryDomainInfo2_out_memory");
7629 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7630 return tevent_req_post(req, ev);
7631 }
7632
7633 /* make a temporary copy, that we pass to the dispatch function */
7634 state->tmp = state->orig;
7635
7636 subreq = cli->dispatch_send(state, ev, cli,
7637 &ndr_table_samr,
7638 NDR_SAMR_QUERYDOMAININFO2,
7639 &state->tmp);
7640 if (tevent_req_nomem(subreq, req)) {
7641 return tevent_req_post(req, ev);
7642 }
7643 tevent_req_set_callback(subreq, rpccli_samr_QueryDomainInfo2_done, req);
7644 return req;
7645 }
7646
7647 static void rpccli_samr_QueryDomainInfo2_done(struct tevent_req *subreq)
7648 {
7649 struct tevent_req *req = tevent_req_callback_data(
7650 subreq, struct tevent_req);
7651 struct rpccli_samr_QueryDomainInfo2_state *state = tevent_req_data(
7652 req, struct rpccli_samr_QueryDomainInfo2_state);
7653 NTSTATUS status;
7654 TALLOC_CTX *mem_ctx;
7655
7656 if (state->out_mem_ctx) {
7657 mem_ctx = state->out_mem_ctx;
7658 } else {
7659 mem_ctx = state;
7660 }
7661
7662 status = state->dispatch_recv(subreq, mem_ctx);
7663 TALLOC_FREE(subreq);
7664 if (!NT_STATUS_IS_OK(status)) {
7665 tevent_req_nterror(req, status);
7666 return;
7667 }
7668
7669 /* Copy out parameters */
7670 *state->orig.out.info = *state->tmp.out.info;
7671
7672 /* Copy result */
7673 state->orig.out.result = state->tmp.out.result;
7674
7675 /* Reset temporary structure */
7676 ZERO_STRUCT(state->tmp);
7677
7678 if (DEBUGLEVEL >= 10) {
7679 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo2, &state->orig);
7680 }
7681
7682 tevent_req_done(req);
7683 }
7684
7685 NTSTATUS rpccli_samr_QueryDomainInfo2_recv(struct tevent_req *req,
7686 TALLOC_CTX *mem_ctx,
7687 NTSTATUS *result)
7688 {
7689 struct rpccli_samr_QueryDomainInfo2_state *state = tevent_req_data(
7690 req, struct rpccli_samr_QueryDomainInfo2_state);
7691 NTSTATUS status;
7692
7693 if (tevent_req_is_nterror(req, &status)) {
7694 tevent_req_received(req);
7695 return status;
7696 }
7697
7698 /* Steal possbile out parameters to the callers context */
7699 talloc_steal(mem_ctx, state->out_mem_ctx);
7700
7701 /* Return result */
7702 *result = state->orig.out.result;
7703
7704 tevent_req_received(req);
7705 return NT_STATUS_OK;
7706 }
7707
7708 NTSTATUS rpccli_samr_QueryDomainInfo2(struct rpc_pipe_client *cli,
7709 TALLOC_CTX *mem_ctx,
7710 struct policy_handle *domain_handle /* [in] [ref] */,
7711 enum samr_DomainInfoClass level /* [in] */,
7712 union samr_DomainInfo **info /* [out] [ref,switch_is(level)] */)
7713 {
7714 struct samr_QueryDomainInfo2 r;
7715 NTSTATUS status;
7716
7717 /* In parameters */
7718 r.in.domain_handle = domain_handle;
7719 r.in.level = level;
7720
7721 if (DEBUGLEVEL >= 10) {
7722 NDR_PRINT_IN_DEBUG(samr_QueryDomainInfo2, &r);
7723 }
7724
7725 status = cli->dispatch(cli,
7726 mem_ctx,
7727 &ndr_table_samr,
7728 NDR_SAMR_QUERYDOMAININFO2,
7729 &r);
7730
7731 if (!NT_STATUS_IS_OK(status)) {
7732 return status;
7733 }
7734
7735 if (DEBUGLEVEL >= 10) {
7736 NDR_PRINT_OUT_DEBUG(samr_QueryDomainInfo2, &r);
7737 }
7738
7739 if (NT_STATUS_IS_ERR(status)) {
7740 return status;
7741 }
7742
7743 /* Return variables */
7744 *info = *r.out.info;
7745
7746 /* Return result */
7747 return r.out.result;
7748 }
7749
7750 struct rpccli_samr_QueryUserInfo2_state {
7751 struct samr_QueryUserInfo2 orig;
7752 struct samr_QueryUserInfo2 tmp;
7753 TALLOC_CTX *out_mem_ctx;
7754 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7755 };
7756
7757 static void rpccli_samr_QueryUserInfo2_done(struct tevent_req *subreq);
7758
7759 struct tevent_req *rpccli_samr_QueryUserInfo2_send(TALLOC_CTX *mem_ctx,
7760 struct tevent_context *ev,
7761 struct rpc_pipe_client *cli,
7762 struct policy_handle *_user_handle /* [in] [ref] */,
7763 enum samr_UserInfoLevel _level /* [in] */,
7764 union samr_UserInfo **_info /* [out] [ref,switch_is(level)] */)
7765 {
7766 struct tevent_req *req;
7767 struct rpccli_samr_QueryUserInfo2_state *state;
7768 struct tevent_req *subreq;
7769
7770 req = tevent_req_create(mem_ctx, &state,
7771 struct rpccli_samr_QueryUserInfo2_state);
7772 if (req == NULL) {
7773 return NULL;
7774 }
7775 state->out_mem_ctx = NULL;
7776 state->dispatch_recv = cli->dispatch_recv;
7777
7778 /* In parameters */
7779 state->orig.in.user_handle = _user_handle;
7780 state->orig.in.level = _level;
7781
7782 /* Out parameters */
7783 state->orig.out.info = _info;
7784
7785 /* Result */
7786 ZERO_STRUCT(state->orig.out.result);
7787
7788 if (DEBUGLEVEL >= 10) {
7789 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo2, &state->orig);
7790 }
7791
7792 state->out_mem_ctx = talloc_named_const(state, 0,
7793 "rpccli_samr_QueryUserInfo2_out_memory");
7794 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7795 return tevent_req_post(req, ev);
7796 }
7797
7798 /* make a temporary copy, that we pass to the dispatch function */
7799 state->tmp = state->orig;
7800
7801 subreq = cli->dispatch_send(state, ev, cli,
7802 &ndr_table_samr,
7803 NDR_SAMR_QUERYUSERINFO2,
7804 &state->tmp);
7805 if (tevent_req_nomem(subreq, req)) {
7806 return tevent_req_post(req, ev);
7807 }
7808 tevent_req_set_callback(subreq, rpccli_samr_QueryUserInfo2_done, req);
7809 return req;
7810 }
7811
7812 static void rpccli_samr_QueryUserInfo2_done(struct tevent_req *subreq)
7813 {
7814 struct tevent_req *req = tevent_req_callback_data(
7815 subreq, struct tevent_req);
7816 struct rpccli_samr_QueryUserInfo2_state *state = tevent_req_data(
7817 req, struct rpccli_samr_QueryUserInfo2_state);
7818 NTSTATUS status;
7819 TALLOC_CTX *mem_ctx;
7820
7821 if (state->out_mem_ctx) {
7822 mem_ctx = state->out_mem_ctx;
7823 } else {
7824 mem_ctx = state;
7825 }
7826
7827 status = state->dispatch_recv(subreq, mem_ctx);
7828 TALLOC_FREE(subreq);
7829 if (!NT_STATUS_IS_OK(status)) {
7830 tevent_req_nterror(req, status);
7831 return;
7832 }
7833
7834 /* Copy out parameters */
7835 *state->orig.out.info = *state->tmp.out.info;
7836
7837 /* Copy result */
7838 state->orig.out.result = state->tmp.out.result;
7839
7840 /* Reset temporary structure */
7841 ZERO_STRUCT(state->tmp);
7842
7843 if (DEBUGLEVEL >= 10) {
7844 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo2, &state->orig);
7845 }
7846
7847 tevent_req_done(req);
7848 }
7849
7850 NTSTATUS rpccli_samr_QueryUserInfo2_recv(struct tevent_req *req,
7851 TALLOC_CTX *mem_ctx,
7852 NTSTATUS *result)
7853 {
7854 struct rpccli_samr_QueryUserInfo2_state *state = tevent_req_data(
7855 req, struct rpccli_samr_QueryUserInfo2_state);
7856 NTSTATUS status;
7857
7858 if (tevent_req_is_nterror(req, &status)) {
7859 tevent_req_received(req);
7860 return status;
7861 }
7862
7863 /* Steal possbile out parameters to the callers context */
7864 talloc_steal(mem_ctx, state->out_mem_ctx);
7865
7866 /* Return result */
7867 *result = state->orig.out.result;
7868
7869 tevent_req_received(req);
7870 return NT_STATUS_OK;
7871 }
7872
7873 NTSTATUS rpccli_samr_QueryUserInfo2(struct rpc_pipe_client *cli,
7874 TALLOC_CTX *mem_ctx,
7875 struct policy_handle *user_handle /* [in] [ref] */,
7876 enum samr_UserInfoLevel level /* [in] */,
7877 union samr_UserInfo **info /* [out] [ref,switch_is(level)] */)
7878 {
7879 struct samr_QueryUserInfo2 r;
7880 NTSTATUS status;
7881
7882 /* In parameters */
7883 r.in.user_handle = user_handle;
7884 r.in.level = level;
7885
7886 if (DEBUGLEVEL >= 10) {
7887 NDR_PRINT_IN_DEBUG(samr_QueryUserInfo2, &r);
7888 }
7889
7890 status = cli->dispatch(cli,
7891 mem_ctx,
7892 &ndr_table_samr,
7893 NDR_SAMR_QUERYUSERINFO2,
7894 &r);
7895
7896 if (!NT_STATUS_IS_OK(status)) {
7897 return status;
7898 }
7899
7900 if (DEBUGLEVEL >= 10) {
7901 NDR_PRINT_OUT_DEBUG(samr_QueryUserInfo2, &r);
7902 }
7903
7904 if (NT_STATUS_IS_ERR(status)) {
7905 return status;
7906 }
7907
7908 /* Return variables */
7909 *info = *r.out.info;
7910
7911 /* Return result */
7912 return r.out.result;
7913 }
7914
7915 struct rpccli_samr_QueryDisplayInfo2_state {
7916 struct samr_QueryDisplayInfo2 orig;
7917 struct samr_QueryDisplayInfo2 tmp;
7918 TALLOC_CTX *out_mem_ctx;
7919 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
7920 };
7921
7922 static void rpccli_samr_QueryDisplayInfo2_done(struct tevent_req *subreq);
7923
7924 struct tevent_req *rpccli_samr_QueryDisplayInfo2_send(TALLOC_CTX *mem_ctx,
7925 struct tevent_context *ev,
7926 struct rpc_pipe_client *cli,
7927 struct policy_handle *_domain_handle /* [in] [ref] */,
7928 uint16_t _level /* [in] */,
7929 uint32_t _start_idx /* [in] */,
7930 uint32_t _max_entries /* [in] */,
7931 uint32_t _buf_size /* [in] */,
7932 uint32_t *_total_size /* [out] [ref] */,
7933 uint32_t *_returned_size /* [out] [ref] */,
7934 union samr_DispInfo *_info /* [out] [ref,switch_is(level)] */)
7935 {
7936 struct tevent_req *req;
7937 struct rpccli_samr_QueryDisplayInfo2_state *state;
7938 struct tevent_req *subreq;
7939
7940 req = tevent_req_create(mem_ctx, &state,
7941 struct rpccli_samr_QueryDisplayInfo2_state);
7942 if (req == NULL) {
7943 return NULL;
7944 }
7945 state->out_mem_ctx = NULL;
7946 state->dispatch_recv = cli->dispatch_recv;
7947
7948 /* In parameters */
7949 state->orig.in.domain_handle = _domain_handle;
7950 state->orig.in.level = _level;
7951 state->orig.in.start_idx = _start_idx;
7952 state->orig.in.max_entries = _max_entries;
7953 state->orig.in.buf_size = _buf_size;
7954
7955 /* Out parameters */
7956 state->orig.out.total_size = _total_size;
7957 state->orig.out.returned_size = _returned_size;
7958 state->orig.out.info = _info;
7959
7960 /* Result */
7961 ZERO_STRUCT(state->orig.out.result);
7962
7963 if (DEBUGLEVEL >= 10) {
7964 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo2, &state->orig);
7965 }
7966
7967 state->out_mem_ctx = talloc_named_const(state, 0,
7968 "rpccli_samr_QueryDisplayInfo2_out_memory");
7969 if (tevent_req_nomem(state->out_mem_ctx, req)) {
7970 return tevent_req_post(req, ev);
7971 }
7972
7973 /* make a temporary copy, that we pass to the dispatch function */
7974 state->tmp = state->orig;
7975
7976 subreq = cli->dispatch_send(state, ev, cli,
7977 &ndr_table_samr,
7978 NDR_SAMR_QUERYDISPLAYINFO2,
7979 &state->tmp);
7980 if (tevent_req_nomem(subreq, req)) {
7981 return tevent_req_post(req, ev);
7982 }
7983 tevent_req_set_callback(subreq, rpccli_samr_QueryDisplayInfo2_done, req);
7984 return req;
7985 }
7986
7987 static void rpccli_samr_QueryDisplayInfo2_done(struct tevent_req *subreq)
7988 {
7989 struct tevent_req *req = tevent_req_callback_data(
7990 subreq, struct tevent_req);
7991 struct rpccli_samr_QueryDisplayInfo2_state *state = tevent_req_data(
7992 req, struct rpccli_samr_QueryDisplayInfo2_state);
7993 NTSTATUS status;
7994 TALLOC_CTX *mem_ctx;
7995
7996 if (state->out_mem_ctx) {
7997 mem_ctx = state->out_mem_ctx;
7998 } else {
7999 mem_ctx = state;
8000 }
8001
8002 status = state->dispatch_recv(subreq, mem_ctx);
8003 TALLOC_FREE(subreq);
8004 if (!NT_STATUS_IS_OK(status)) {
8005 tevent_req_nterror(req, status);
8006 return;
8007 }
8008
8009 /* Copy out parameters */
8010 *state->orig.out.total_size = *state->tmp.out.total_size;
8011 *state->orig.out.returned_size = *state->tmp.out.returned_size;
8012 *state->orig.out.info = *state->tmp.out.info;
8013
8014 /* Copy result */
8015 state->orig.out.result = state->tmp.out.result;
8016
8017 /* Reset temporary structure */
8018 ZERO_STRUCT(state->tmp);
8019
8020 if (DEBUGLEVEL >= 10) {
8021 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo2, &state->orig);
8022 }
8023
8024 tevent_req_done(req);
8025 }
8026
8027 NTSTATUS rpccli_samr_QueryDisplayInfo2_recv(struct tevent_req *req,
8028 TALLOC_CTX *mem_ctx,
8029 NTSTATUS *result)
8030 {
8031 struct rpccli_samr_QueryDisplayInfo2_state *state = tevent_req_data(
8032 req, struct rpccli_samr_QueryDisplayInfo2_state);
8033 NTSTATUS status;
8034
8035 if (tevent_req_is_nterror(req, &status)) {
8036 tevent_req_received(req);
8037 return status;
8038 }
8039
8040 /* Steal possbile out parameters to the callers context */
8041 talloc_steal(mem_ctx, state->out_mem_ctx);
8042
8043 /* Return result */
8044 *result = state->orig.out.result;
8045
8046 tevent_req_received(req);
8047 return NT_STATUS_OK;
8048 }
8049
8050 NTSTATUS rpccli_samr_QueryDisplayInfo2(struct rpc_pipe_client *cli,
8051 TALLOC_CTX *mem_ctx,
8052 struct policy_handle *domain_handle /* [in] [ref] */,
8053 uint16_t level /* [in] */,
8054 uint32_t start_idx /* [in] */,
8055 uint32_t max_entries /* [in] */,
8056 uint32_t buf_size /* [in] */,
8057 uint32_t *total_size /* [out] [ref] */,
8058 uint32_t *returned_size /* [out] [ref] */,
8059 union samr_DispInfo *info /* [out] [ref,switch_is(level)] */)
8060 {
8061 struct samr_QueryDisplayInfo2 r;
8062 NTSTATUS status;
8063
8064 /* In parameters */
8065 r.in.domain_handle = domain_handle;
8066 r.in.level = level;
8067 r.in.start_idx = start_idx;
8068 r.in.max_entries = max_entries;
8069 r.in.buf_size = buf_size;
8070
8071 if (DEBUGLEVEL >= 10) {
8072 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo2, &r);
8073 }
8074
8075 status = cli->dispatch(cli,
8076 mem_ctx,
8077 &ndr_table_samr,
8078 NDR_SAMR_QUERYDISPLAYINFO2,
8079 &r);
8080
8081 if (!NT_STATUS_IS_OK(status)) {
8082 return status;
8083 }
8084
8085 if (DEBUGLEVEL >= 10) {
8086 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo2, &r);
8087 }
8088
8089 if (NT_STATUS_IS_ERR(status)) {
8090 return status;
8091 }
8092
8093 /* Return variables */
8094 *total_size = *r.out.total_size;
8095 *returned_size = *r.out.returned_size;
8096 *info = *r.out.info;
8097
8098 /* Return result */
8099 return r.out.result;
8100 }
8101
8102 struct rpccli_samr_GetDisplayEnumerationIndex2_state {
8103 struct samr_GetDisplayEnumerationIndex2 orig;
8104 struct samr_GetDisplayEnumerationIndex2 tmp;
8105 TALLOC_CTX *out_mem_ctx;
8106 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8107 };
8108
8109 static void rpccli_samr_GetDisplayEnumerationIndex2_done(struct tevent_req *subreq);
8110
8111 struct tevent_req *rpccli_samr_GetDisplayEnumerationIndex2_send(TALLOC_CTX *mem_ctx,
8112 struct tevent_context *ev,
8113 struct rpc_pipe_client *cli,
8114 struct policy_handle *_domain_handle /* [in] [ref] */,
8115 uint16_t _level /* [in] */,
8116 struct lsa_String *_name /* [in] [ref] */,
8117 uint32_t *_idx /* [out] [ref] */)
8118 {
8119 struct tevent_req *req;
8120 struct rpccli_samr_GetDisplayEnumerationIndex2_state *state;
8121 struct tevent_req *subreq;
8122
8123 req = tevent_req_create(mem_ctx, &state,
8124 struct rpccli_samr_GetDisplayEnumerationIndex2_state);
8125 if (req == NULL) {
8126 return NULL;
8127 }
8128 state->out_mem_ctx = NULL;
8129 state->dispatch_recv = cli->dispatch_recv;
8130
8131 /* In parameters */
8132 state->orig.in.domain_handle = _domain_handle;
8133 state->orig.in.level = _level;
8134 state->orig.in.name = _name;
8135
8136 /* Out parameters */
8137 state->orig.out.idx = _idx;
8138
8139 /* Result */
8140 ZERO_STRUCT(state->orig.out.result);
8141
8142 if (DEBUGLEVEL >= 10) {
8143 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex2, &state->orig);
8144 }
8145
8146 state->out_mem_ctx = talloc_named_const(state, 0,
8147 "rpccli_samr_GetDisplayEnumerationIndex2_out_memory");
8148 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8149 return tevent_req_post(req, ev);
8150 }
8151
8152 /* make a temporary copy, that we pass to the dispatch function */
8153 state->tmp = state->orig;
8154
8155 subreq = cli->dispatch_send(state, ev, cli,
8156 &ndr_table_samr,
8157 NDR_SAMR_GETDISPLAYENUMERATIONINDEX2,
8158 &state->tmp);
8159 if (tevent_req_nomem(subreq, req)) {
8160 return tevent_req_post(req, ev);
8161 }
8162 tevent_req_set_callback(subreq, rpccli_samr_GetDisplayEnumerationIndex2_done, req);
8163 return req;
8164 }
8165
8166 static void rpccli_samr_GetDisplayEnumerationIndex2_done(struct tevent_req *subreq)
8167 {
8168 struct tevent_req *req = tevent_req_callback_data(
8169 subreq, struct tevent_req);
8170 struct rpccli_samr_GetDisplayEnumerationIndex2_state *state = tevent_req_data(
8171 req, struct rpccli_samr_GetDisplayEnumerationIndex2_state);
8172 NTSTATUS status;
8173 TALLOC_CTX *mem_ctx;
8174
8175 if (state->out_mem_ctx) {
8176 mem_ctx = state->out_mem_ctx;
8177 } else {
8178 mem_ctx = state;
8179 }
8180
8181 status = state->dispatch_recv(subreq, mem_ctx);
8182 TALLOC_FREE(subreq);
8183 if (!NT_STATUS_IS_OK(status)) {
8184 tevent_req_nterror(req, status);
8185 return;
8186 }
8187
8188 /* Copy out parameters */
8189 *state->orig.out.idx = *state->tmp.out.idx;
8190
8191 /* Copy result */
8192 state->orig.out.result = state->tmp.out.result;
8193
8194 /* Reset temporary structure */
8195 ZERO_STRUCT(state->tmp);
8196
8197 if (DEBUGLEVEL >= 10) {
8198 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex2, &state->orig);
8199 }
8200
8201 tevent_req_done(req);
8202 }
8203
8204 NTSTATUS rpccli_samr_GetDisplayEnumerationIndex2_recv(struct tevent_req *req,
8205 TALLOC_CTX *mem_ctx,
8206 NTSTATUS *result)
8207 {
8208 struct rpccli_samr_GetDisplayEnumerationIndex2_state *state = tevent_req_data(
8209 req, struct rpccli_samr_GetDisplayEnumerationIndex2_state);
8210 NTSTATUS status;
8211
8212 if (tevent_req_is_nterror(req, &status)) {
8213 tevent_req_received(req);
8214 return status;
8215 }
8216
8217 /* Steal possbile out parameters to the callers context */
8218 talloc_steal(mem_ctx, state->out_mem_ctx);
8219
8220 /* Return result */
8221 *result = state->orig.out.result;
8222
8223 tevent_req_received(req);
8224 return NT_STATUS_OK;
8225 }
8226
8227 NTSTATUS rpccli_samr_GetDisplayEnumerationIndex2(struct rpc_pipe_client *cli,
8228 TALLOC_CTX *mem_ctx,
8229 struct policy_handle *domain_handle /* [in] [ref] */,
8230 uint16_t level /* [in] */,
8231 struct lsa_String *name /* [in] [ref] */,
8232 uint32_t *idx /* [out] [ref] */)
8233 {
8234 struct samr_GetDisplayEnumerationIndex2 r;
8235 NTSTATUS status;
8236
8237 /* In parameters */
8238 r.in.domain_handle = domain_handle;
8239 r.in.level = level;
8240 r.in.name = name;
8241
8242 if (DEBUGLEVEL >= 10) {
8243 NDR_PRINT_IN_DEBUG(samr_GetDisplayEnumerationIndex2, &r);
8244 }
8245
8246 status = cli->dispatch(cli,
8247 mem_ctx,
8248 &ndr_table_samr,
8249 NDR_SAMR_GETDISPLAYENUMERATIONINDEX2,
8250 &r);
8251
8252 if (!NT_STATUS_IS_OK(status)) {
8253 return status;
8254 }
8255
8256 if (DEBUGLEVEL >= 10) {
8257 NDR_PRINT_OUT_DEBUG(samr_GetDisplayEnumerationIndex2, &r);
8258 }
8259
8260 if (NT_STATUS_IS_ERR(status)) {
8261 return status;
8262 }
8263
8264 /* Return variables */
8265 *idx = *r.out.idx;
8266
8267 /* Return result */
8268 return r.out.result;
8269 }
8270
8271 struct rpccli_samr_CreateUser2_state {
8272 struct samr_CreateUser2 orig;
8273 struct samr_CreateUser2 tmp;
8274 TALLOC_CTX *out_mem_ctx;
8275 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8276 };
8277
8278 static void rpccli_samr_CreateUser2_done(struct tevent_req *subreq);
8279
8280 struct tevent_req *rpccli_samr_CreateUser2_send(TALLOC_CTX *mem_ctx,
8281 struct tevent_context *ev,
8282 struct rpc_pipe_client *cli,
8283 struct policy_handle *_domain_handle /* [in] [ref] */,
8284 struct lsa_String *_account_name /* [in] [ref] */,
8285 uint32_t _acct_flags /* [in] */,
8286 uint32_t _access_mask /* [in] */,
8287 struct policy_handle *_user_handle /* [out] [ref] */,
8288 uint32_t *_access_granted /* [out] [ref] */,
8289 uint32_t *_rid /* [out] [ref] */)
8290 {
8291 struct tevent_req *req;
8292 struct rpccli_samr_CreateUser2_state *state;
8293 struct tevent_req *subreq;
8294
8295 req = tevent_req_create(mem_ctx, &state,
8296 struct rpccli_samr_CreateUser2_state);
8297 if (req == NULL) {
8298 return NULL;
8299 }
8300 state->out_mem_ctx = NULL;
8301 state->dispatch_recv = cli->dispatch_recv;
8302
8303 /* In parameters */
8304 state->orig.in.domain_handle = _domain_handle;
8305 state->orig.in.account_name = _account_name;
8306 state->orig.in.acct_flags = _acct_flags;
8307 state->orig.in.access_mask = _access_mask;
8308
8309 /* Out parameters */
8310 state->orig.out.user_handle = _user_handle;
8311 state->orig.out.access_granted = _access_granted;
8312 state->orig.out.rid = _rid;
8313
8314 /* Result */
8315 ZERO_STRUCT(state->orig.out.result);
8316
8317 if (DEBUGLEVEL >= 10) {
8318 NDR_PRINT_IN_DEBUG(samr_CreateUser2, &state->orig);
8319 }
8320
8321 state->out_mem_ctx = talloc_named_const(state, 0,
8322 "rpccli_samr_CreateUser2_out_memory");
8323 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8324 return tevent_req_post(req, ev);
8325 }
8326
8327 /* make a temporary copy, that we pass to the dispatch function */
8328 state->tmp = state->orig;
8329
8330 subreq = cli->dispatch_send(state, ev, cli,
8331 &ndr_table_samr,
8332 NDR_SAMR_CREATEUSER2,
8333 &state->tmp);
8334 if (tevent_req_nomem(subreq, req)) {
8335 return tevent_req_post(req, ev);
8336 }
8337 tevent_req_set_callback(subreq, rpccli_samr_CreateUser2_done, req);
8338 return req;
8339 }
8340
8341 static void rpccli_samr_CreateUser2_done(struct tevent_req *subreq)
8342 {
8343 struct tevent_req *req = tevent_req_callback_data(
8344 subreq, struct tevent_req);
8345 struct rpccli_samr_CreateUser2_state *state = tevent_req_data(
8346 req, struct rpccli_samr_CreateUser2_state);
8347 NTSTATUS status;
8348 TALLOC_CTX *mem_ctx;
8349
8350 if (state->out_mem_ctx) {
8351 mem_ctx = state->out_mem_ctx;
8352 } else {
8353 mem_ctx = state;
8354 }
8355
8356 status = state->dispatch_recv(subreq, mem_ctx);
8357 TALLOC_FREE(subreq);
8358 if (!NT_STATUS_IS_OK(status)) {
8359 tevent_req_nterror(req, status);
8360 return;
8361 }
8362
8363 /* Copy out parameters */
8364 *state->orig.out.user_handle = *state->tmp.out.user_handle;
8365 *state->orig.out.access_granted = *state->tmp.out.access_granted;
8366 *state->orig.out.rid = *state->tmp.out.rid;
8367
8368 /* Copy result */
8369 state->orig.out.result = state->tmp.out.result;
8370
8371 /* Reset temporary structure */
8372 ZERO_STRUCT(state->tmp);
8373
8374 if (DEBUGLEVEL >= 10) {
8375 NDR_PRINT_OUT_DEBUG(samr_CreateUser2, &state->orig);
8376 }
8377
8378 tevent_req_done(req);
8379 }
8380
8381 NTSTATUS rpccli_samr_CreateUser2_recv(struct tevent_req *req,
8382 TALLOC_CTX *mem_ctx,
8383 NTSTATUS *result)
8384 {
8385 struct rpccli_samr_CreateUser2_state *state = tevent_req_data(
8386 req, struct rpccli_samr_CreateUser2_state);
8387 NTSTATUS status;
8388
8389 if (tevent_req_is_nterror(req, &status)) {
8390 tevent_req_received(req);
8391 return status;
8392 }
8393
8394 /* Steal possbile out parameters to the callers context */
8395 talloc_steal(mem_ctx, state->out_mem_ctx);
8396
8397 /* Return result */
8398 *result = state->orig.out.result;
8399
8400 tevent_req_received(req);
8401 return NT_STATUS_OK;
8402 }
8403
8404 NTSTATUS rpccli_samr_CreateUser2(struct rpc_pipe_client *cli,
8405 TALLOC_CTX *mem_ctx,
8406 struct policy_handle *domain_handle /* [in] [ref] */,
8407 struct lsa_String *account_name /* [in] [ref] */,
8408 uint32_t acct_flags /* [in] */,
8409 uint32_t access_mask /* [in] */,
8410 struct policy_handle *user_handle /* [out] [ref] */,
8411 uint32_t *access_granted /* [out] [ref] */,
8412 uint32_t *rid /* [out] [ref] */)
8413 {
8414 struct samr_CreateUser2 r;
8415 NTSTATUS status;
8416
8417 /* In parameters */
8418 r.in.domain_handle = domain_handle;
8419 r.in.account_name = account_name;
8420 r.in.acct_flags = acct_flags;
8421 r.in.access_mask = access_mask;
8422
8423 if (DEBUGLEVEL >= 10) {
8424 NDR_PRINT_IN_DEBUG(samr_CreateUser2, &r);
8425 }
8426
8427 status = cli->dispatch(cli,
8428 mem_ctx,
8429 &ndr_table_samr,
8430 NDR_SAMR_CREATEUSER2,
8431 &r);
8432
8433 if (!NT_STATUS_IS_OK(status)) {
8434 return status;
8435 }
8436
8437 if (DEBUGLEVEL >= 10) {
8438 NDR_PRINT_OUT_DEBUG(samr_CreateUser2, &r);
8439 }
8440
8441 if (NT_STATUS_IS_ERR(status)) {
8442 return status;
8443 }
8444
8445 /* Return variables */
8446 *user_handle = *r.out.user_handle;
8447 *access_granted = *r.out.access_granted;
8448 *rid = *r.out.rid;
8449
8450 /* Return result */
8451 return r.out.result;
8452 }
8453
8454 struct rpccli_samr_QueryDisplayInfo3_state {
8455 struct samr_QueryDisplayInfo3 orig;
8456 struct samr_QueryDisplayInfo3 tmp;
8457 TALLOC_CTX *out_mem_ctx;
8458 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8459 };
8460
8461 static void rpccli_samr_QueryDisplayInfo3_done(struct tevent_req *subreq);
8462
8463 struct tevent_req *rpccli_samr_QueryDisplayInfo3_send(TALLOC_CTX *mem_ctx,
8464 struct tevent_context *ev,
8465 struct rpc_pipe_client *cli,
8466 struct policy_handle *_domain_handle /* [in] [ref] */,
8467 uint16_t _level /* [in] */,
8468 uint32_t _start_idx /* [in] */,
8469 uint32_t _max_entries /* [in] */,
8470 uint32_t _buf_size /* [in] */,
8471 uint32_t *_total_size /* [out] [ref] */,
8472 uint32_t *_returned_size /* [out] [ref] */,
8473 union samr_DispInfo *_info /* [out] [ref,switch_is(level)] */)
8474 {
8475 struct tevent_req *req;
8476 struct rpccli_samr_QueryDisplayInfo3_state *state;
8477 struct tevent_req *subreq;
8478
8479 req = tevent_req_create(mem_ctx, &state,
8480 struct rpccli_samr_QueryDisplayInfo3_state);
8481 if (req == NULL) {
8482 return NULL;
8483 }
8484 state->out_mem_ctx = NULL;
8485 state->dispatch_recv = cli->dispatch_recv;
8486
8487 /* In parameters */
8488 state->orig.in.domain_handle = _domain_handle;
8489 state->orig.in.level = _level;
8490 state->orig.in.start_idx = _start_idx;
8491 state->orig.in.max_entries = _max_entries;
8492 state->orig.in.buf_size = _buf_size;
8493
8494 /* Out parameters */
8495 state->orig.out.total_size = _total_size;
8496 state->orig.out.returned_size = _returned_size;
8497 state->orig.out.info = _info;
8498
8499 /* Result */
8500 ZERO_STRUCT(state->orig.out.result);
8501
8502 if (DEBUGLEVEL >= 10) {
8503 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo3, &state->orig);
8504 }
8505
8506 state->out_mem_ctx = talloc_named_const(state, 0,
8507 "rpccli_samr_QueryDisplayInfo3_out_memory");
8508 if (tevent_req_nomem(state->out_mem_ctx, req)) {
8509 return tevent_req_post(req, ev);
8510 }
8511
8512 /* make a temporary copy, that we pass to the dispatch function */
8513 state->tmp = state->orig;
8514
8515 subreq = cli->dispatch_send(state, ev, cli,
8516 &ndr_table_samr,
8517 NDR_SAMR_QUERYDISPLAYINFO3,
8518 &state->tmp);
8519 if (tevent_req_nomem(subreq, req)) {
8520 return tevent_req_post(req, ev);
8521 }
8522 tevent_req_set_callback(subreq, rpccli_samr_QueryDisplayInfo3_done, req);
8523 return req;
8524 }
8525
8526 static void rpccli_samr_QueryDisplayInfo3_done(struct tevent_req *subreq)
8527 {
8528 struct tevent_req *req = tevent_req_callback_data(
8529 subreq, struct tevent_req);
8530 struct rpccli_samr_QueryDisplayInfo3_state *state = tevent_req_data(
8531 req, struct rpccli_samr_QueryDisplayInfo3_state);
8532 NTSTATUS status;
8533 TALLOC_CTX *mem_ctx;
8534
8535 if (state->out_mem_ctx) {
8536 mem_ctx = state->out_mem_ctx;
8537 } else {
8538 mem_ctx = state;
8539 }
8540
8541 status = state->dispatch_recv(subreq, mem_ctx);
8542 TALLOC_FREE(subreq);
8543 if (!NT_STATUS_IS_OK(status)) {
8544 tevent_req_nterror(req, status);
8545 return;
8546 }
8547
8548 /* Copy out parameters */
8549 *state->orig.out.total_size = *state->tmp.out.total_size;
8550 *state->orig.out.returned_size = *state->tmp.out.returned_size;
8551 *state->orig.out.info = *state->tmp.out.info;
8552
8553 /* Copy result */
8554 state->orig.out.result = state->tmp.out.result;
8555
8556 /* Reset temporary structure */
8557 ZERO_STRUCT(state->tmp);
8558
8559 if (DEBUGLEVEL >= 10) {
8560 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo3, &state->orig);
8561 }
8562
8563 tevent_req_done(req);
8564 }
8565
8566 NTSTATUS rpccli_samr_QueryDisplayInfo3_recv(struct tevent_req *req,
8567 TALLOC_CTX *mem_ctx,
8568 NTSTATUS *result)
8569 {
8570 struct rpccli_samr_QueryDisplayInfo3_state *state = tevent_req_data(
8571 req, struct rpccli_samr_QueryDisplayInfo3_state);
8572 NTSTATUS status;
8573
8574 if (tevent_req_is_nterror(req, &status)) {
8575 tevent_req_received(req);
8576 return status;
8577 }
8578
8579 /* Steal possbile out parameters to the callers context */
8580 talloc_steal(mem_ctx, state->out_mem_ctx);
8581
8582 /* Return result */
8583 *result = state->orig.out.result;
8584
8585 tevent_req_received(req);
8586 return NT_STATUS_OK;
8587 }
8588
8589 NTSTATUS rpccli_samr_QueryDisplayInfo3(struct rpc_pipe_client *cli,
8590 TALLOC_CTX *mem_ctx,
8591 struct policy_handle *domain_handle /* [in] [ref] */,
8592 uint16_t level /* [in] */,
8593 uint32_t start_idx /* [in] */,
8594 uint32_t max_entries /* [in] */,
8595 uint32_t buf_size /* [in] */,
8596 uint32_t *total_size /* [out] [ref] */,
8597 uint32_t *returned_size /* [out] [ref] */,
8598 union samr_DispInfo *info /* [out] [ref,switch_is(level)] */)
8599 {
8600 struct samr_QueryDisplayInfo3 r;
8601 NTSTATUS status;
8602
8603 /* In parameters */
8604 r.in.domain_handle = domain_handle;
8605 r.in.level = level;
8606 r.in.start_idx = start_idx;
8607 r.in.max_entries = max_entries;
8608 r.in.buf_size = buf_size;
8609
8610 if (DEBUGLEVEL >= 10) {
8611 NDR_PRINT_IN_DEBUG(samr_QueryDisplayInfo3, &r);
8612 }
8613
8614 status = cli->dispatch(cli,
8615 mem_ctx,
8616 &ndr_table_samr,
8617 NDR_SAMR_QUERYDISPLAYINFO3,
8618 &r);
8619
8620 if (!NT_STATUS_IS_OK(status)) {
8621 return status;
8622 }
8623
8624 if (DEBUGLEVEL >= 10) {
8625 NDR_PRINT_OUT_DEBUG(samr_QueryDisplayInfo3, &r);
8626 }
8627
8628 if (NT_STATUS_IS_ERR(status)) {
8629 return status;
8630 }
8631
8632 /* Return variables */
8633 *total_size = *r.out.total_size;
8634 *returned_size = *r.out.returned_size;
8635 *info = *r.out.info;
8636
8637 /* Return result */
8638 return r.out.result;
8639 }
8640
8641 struct rpccli_samr_AddMultipleMembersToAlias_state {
8642 struct samr_AddMultipleMembersToAlias orig;
8643 struct samr_AddMultipleMembersToAlias tmp;
8644 TALLOC_CTX *out_mem_ctx;
8645 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8646 };
8647
8648 static void rpccli_samr_AddMultipleMembersToAlias_done(struct tevent_req *subreq);
8649
8650 struct tevent_req *rpccli_samr_AddMultipleMembersToAlias_send(TALLOC_CTX *mem_ctx,
8651 struct tevent_context *ev,
8652 struct rpc_pipe_client *cli,
8653 struct policy_handle *_alias_handle /* [in] [ref] */,
8654 struct lsa_SidArray *_sids /* [in] [ref] */)
8655 {
8656 struct tevent_req *req;
8657 struct rpccli_samr_AddMultipleMembersToAlias_state *state;
8658 struct tevent_req *subreq;
8659
8660 req = tevent_req_create(mem_ctx, &state,
8661 struct rpccli_samr_AddMultipleMembersToAlias_state);
8662 if (req == NULL) {
8663 return NULL;
8664 }
8665 state->out_mem_ctx = NULL;
8666 state->dispatch_recv = cli->dispatch_recv;
8667
8668 /* In parameters */
8669 state->orig.in.alias_handle = _alias_handle;
8670 state->orig.in.sids = _sids;
8671
8672 /* Out parameters */
8673
8674 /* Result */
8675 ZERO_STRUCT(state->orig.out.result);
8676
8677 if (DEBUGLEVEL >= 10) {
8678 NDR_PRINT_IN_DEBUG(samr_AddMultipleMembersToAlias, &state->orig);
8679 }
8680
8681 /* make a temporary copy, that we pass to the dispatch function */
8682 state->tmp = state->orig;
8683
8684 subreq = cli->dispatch_send(state, ev, cli,
8685 &ndr_table_samr,
8686 NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS,
8687 &state->tmp);
8688 if (tevent_req_nomem(subreq, req)) {
8689 return tevent_req_post(req, ev);
8690 }
8691 tevent_req_set_callback(subreq, rpccli_samr_AddMultipleMembersToAlias_done, req);
8692 return req;
8693 }
8694
8695 static void rpccli_samr_AddMultipleMembersToAlias_done(struct tevent_req *subreq)
8696 {
8697 struct tevent_req *req = tevent_req_callback_data(
8698 subreq, struct tevent_req);
8699 struct rpccli_samr_AddMultipleMembersToAlias_state *state = tevent_req_data(
8700 req, struct rpccli_samr_AddMultipleMembersToAlias_state);
8701 NTSTATUS status;
8702 TALLOC_CTX *mem_ctx;
8703
8704 if (state->out_mem_ctx) {
8705 mem_ctx = state->out_mem_ctx;
8706 } else {
8707 mem_ctx = state;
8708 }
8709
8710 status = state->dispatch_recv(subreq, mem_ctx);
8711 TALLOC_FREE(subreq);
8712 if (!NT_STATUS_IS_OK(status)) {
8713 tevent_req_nterror(req, status);
8714 return;
8715 }
8716
8717 /* Copy out parameters */
8718
8719 /* Copy result */
8720 state->orig.out.result = state->tmp.out.result;
8721
8722 /* Reset temporary structure */
8723 ZERO_STRUCT(state->tmp);
8724
8725 if (DEBUGLEVEL >= 10) {
8726 NDR_PRINT_OUT_DEBUG(samr_AddMultipleMembersToAlias, &state->orig);
8727 }
8728
8729 tevent_req_done(req);
8730 }
8731
8732 NTSTATUS rpccli_samr_AddMultipleMembersToAlias_recv(struct tevent_req *req,
8733 TALLOC_CTX *mem_ctx,
8734 NTSTATUS *result)
8735 {
8736 struct rpccli_samr_AddMultipleMembersToAlias_state *state = tevent_req_data(
8737 req, struct rpccli_samr_AddMultipleMembersToAlias_state);
8738 NTSTATUS status;
8739
8740 if (tevent_req_is_nterror(req, &status)) {
8741 tevent_req_received(req);
8742 return status;
8743 }
8744
8745 /* Steal possbile out parameters to the callers context */
8746 talloc_steal(mem_ctx, state->out_mem_ctx);
8747
8748 /* Return result */
8749 *result = state->orig.out.result;
8750
8751 tevent_req_received(req);
8752 return NT_STATUS_OK;
8753 }
8754
8755 NTSTATUS rpccli_samr_AddMultipleMembersToAlias(struct rpc_pipe_client *cli,
8756 TALLOC_CTX *mem_ctx,
8757 struct policy_handle *alias_handle /* [in] [ref] */,
8758 struct lsa_SidArray *sids /* [in] [ref] */)
8759 {
8760 struct samr_AddMultipleMembersToAlias r;
8761 NTSTATUS status;
8762
8763 /* In parameters */
8764 r.in.alias_handle = alias_handle;
8765 r.in.sids = sids;
8766
8767 if (DEBUGLEVEL >= 10) {
8768 NDR_PRINT_IN_DEBUG(samr_AddMultipleMembersToAlias, &r);
8769 }
8770
8771 status = cli->dispatch(cli,
8772 mem_ctx,
8773 &ndr_table_samr,
8774 NDR_SAMR_ADDMULTIPLEMEMBERSTOALIAS,
8775 &r);
8776
8777 if (!NT_STATUS_IS_OK(status)) {
8778 return status;
8779 }
8780
8781 if (DEBUGLEVEL >= 10) {
8782 NDR_PRINT_OUT_DEBUG(samr_AddMultipleMembersToAlias, &r);
8783 }
8784
8785 if (NT_STATUS_IS_ERR(status)) {
8786 return status;
8787 }
8788
8789 /* Return variables */
8790
8791 /* Return result */
8792 return r.out.result;
8793 }
8794
8795 struct rpccli_samr_RemoveMultipleMembersFromAlias_state {
8796 struct samr_RemoveMultipleMembersFromAlias orig;
8797 struct samr_RemoveMultipleMembersFromAlias tmp;
8798 TALLOC_CTX *out_mem_ctx;
8799 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8800 };
8801
8802 static void rpccli_samr_RemoveMultipleMembersFromAlias_done(struct tevent_req *subreq);
8803
8804 struct tevent_req *rpccli_samr_RemoveMultipleMembersFromAlias_send(TALLOC_CTX *mem_ctx,
8805 struct tevent_context *ev,
8806 struct rpc_pipe_client *cli,
8807 struct policy_handle *_alias_handle /* [in] [ref] */,
8808 struct lsa_SidArray *_sids /* [in] [ref] */)
8809 {
8810 struct tevent_req *req;
8811 struct rpccli_samr_RemoveMultipleMembersFromAlias_state *state;
8812 struct tevent_req *subreq;
8813
8814 req = tevent_req_create(mem_ctx, &state,
8815 struct rpccli_samr_RemoveMultipleMembersFromAlias_state);
8816 if (req == NULL) {
8817 return NULL;
8818 }
8819 state->out_mem_ctx = NULL;
8820 state->dispatch_recv = cli->dispatch_recv;
8821
8822 /* In parameters */
8823 state->orig.in.alias_handle = _alias_handle;
8824 state->orig.in.sids = _sids;
8825
8826 /* Out parameters */
8827
8828 /* Result */
8829 ZERO_STRUCT(state->orig.out.result);
8830
8831 if (DEBUGLEVEL >= 10) {
8832 NDR_PRINT_IN_DEBUG(samr_RemoveMultipleMembersFromAlias, &state->orig);
8833 }
8834
8835 /* make a temporary copy, that we pass to the dispatch function */
8836 state->tmp = state->orig;
8837
8838 subreq = cli->dispatch_send(state, ev, cli,
8839 &ndr_table_samr,
8840 NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS,
8841 &state->tmp);
8842 if (tevent_req_nomem(subreq, req)) {
8843 return tevent_req_post(req, ev);
8844 }
8845 tevent_req_set_callback(subreq, rpccli_samr_RemoveMultipleMembersFromAlias_done, req);
8846 return req;
8847 }
8848
8849 static void rpccli_samr_RemoveMultipleMembersFromAlias_done(struct tevent_req *subreq)
8850 {
8851 struct tevent_req *req = tevent_req_callback_data(
8852 subreq, struct tevent_req);
8853 struct rpccli_samr_RemoveMultipleMembersFromAlias_state *state = tevent_req_data(
8854 req, struct rpccli_samr_RemoveMultipleMembersFromAlias_state);
8855 NTSTATUS status;
8856 TALLOC_CTX *mem_ctx;
8857
8858 if (state->out_mem_ctx) {
8859 mem_ctx = state->out_mem_ctx;
8860 } else {
8861 mem_ctx = state;
8862 }
8863
8864 status = state->dispatch_recv(subreq, mem_ctx);
8865 TALLOC_FREE(subreq);
8866 if (!NT_STATUS_IS_OK(status)) {
8867 tevent_req_nterror(req, status);
8868 return;
8869 }
8870
8871 /* Copy out parameters */
8872
8873 /* Copy result */
8874 state->orig.out.result = state->tmp.out.result;
8875
8876 /* Reset temporary structure */
8877 ZERO_STRUCT(state->tmp);
8878
8879 if (DEBUGLEVEL >= 10) {
8880 NDR_PRINT_OUT_DEBUG(samr_RemoveMultipleMembersFromAlias, &state->orig);
8881 }
8882
8883 tevent_req_done(req);
8884 }
8885
8886 NTSTATUS rpccli_samr_RemoveMultipleMembersFromAlias_recv(struct tevent_req *req,
8887 TALLOC_CTX *mem_ctx,
8888 NTSTATUS *result)
8889 {
8890 struct rpccli_samr_RemoveMultipleMembersFromAlias_state *state = tevent_req_data(
8891 req, struct rpccli_samr_RemoveMultipleMembersFromAlias_state);
8892 NTSTATUS status;
8893
8894 if (tevent_req_is_nterror(req, &status)) {
8895 tevent_req_received(req);
8896 return status;
8897 }
8898
8899 /* Steal possbile out parameters to the callers context */
8900 talloc_steal(mem_ctx, state->out_mem_ctx);
8901
8902 /* Return result */
8903 *result = state->orig.out.result;
8904
8905 tevent_req_received(req);
8906 return NT_STATUS_OK;
8907 }
8908
8909 NTSTATUS rpccli_samr_RemoveMultipleMembersFromAlias(struct rpc_pipe_client *cli,
8910 TALLOC_CTX *mem_ctx,
8911 struct policy_handle *alias_handle /* [in] [ref] */,
8912 struct lsa_SidArray *sids /* [in] [ref] */)
8913 {
8914 struct samr_RemoveMultipleMembersFromAlias r;
8915 NTSTATUS status;
8916
8917 /* In parameters */
8918 r.in.alias_handle = alias_handle;
8919 r.in.sids = sids;
8920
8921 if (DEBUGLEVEL >= 10) {
8922 NDR_PRINT_IN_DEBUG(samr_RemoveMultipleMembersFromAlias, &r);
8923 }
8924
8925 status = cli->dispatch(cli,
8926 mem_ctx,
8927 &ndr_table_samr,
8928 NDR_SAMR_REMOVEMULTIPLEMEMBERSFROMALIAS,
8929 &r);
8930
8931 if (!NT_STATUS_IS_OK(status)) {
8932 return status;
8933 }
8934
8935 if (DEBUGLEVEL >= 10) {
8936 NDR_PRINT_OUT_DEBUG(samr_RemoveMultipleMembersFromAlias, &r);
8937 }
8938
8939 if (NT_STATUS_IS_ERR(status)) {
8940 return status;
8941 }
8942
8943 /* Return variables */
8944
8945 /* Return result */
8946 return r.out.result;
8947 }
8948
8949 struct rpccli_samr_OemChangePasswordUser2_state {
8950 struct samr_OemChangePasswordUser2 orig;
8951 struct samr_OemChangePasswordUser2 tmp;
8952 TALLOC_CTX *out_mem_ctx;
8953 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
8954 };
8955
8956 static void rpccli_samr_OemChangePasswordUser2_done(struct tevent_req *subreq);
8957
8958 struct tevent_req *rpccli_samr_OemChangePasswordUser2_send(TALLOC_CTX *mem_ctx,
8959 struct tevent_context *ev,
8960 struct rpc_pipe_client *cli,
8961 struct lsa_AsciiString *_server /* [in] [unique] */,
8962 struct lsa_AsciiString *_account /* [in] [ref] */,
8963 struct samr_CryptPassword *_password /* [in] [unique] */,
8964 struct samr_Password *_hash /* [in] [unique] */)
8965 {
8966 struct tevent_req *req;
8967 struct rpccli_samr_OemChangePasswordUser2_state *state;
8968 struct tevent_req *subreq;
8969
8970 req = tevent_req_create(mem_ctx, &state,
8971 struct rpccli_samr_OemChangePasswordUser2_state);
8972 if (req == NULL) {
8973 return NULL;
8974 }
8975 state->out_mem_ctx = NULL;
8976 state->dispatch_recv = cli->dispatch_recv;
8977
8978 /* In parameters */
8979 state->orig.in.server = _server;
8980 state->orig.in.account = _account;
8981 state->orig.in.password = _password;
8982 state->orig.in.hash = _hash;
8983
8984 /* Out parameters */
8985
8986 /* Result */
8987 ZERO_STRUCT(state->orig.out.result);
8988
8989 if (DEBUGLEVEL >= 10) {
8990 NDR_PRINT_IN_DEBUG(samr_OemChangePasswordUser2, &state->orig);
8991 }
8992
8993 /* make a temporary copy, that we pass to the dispatch function */
8994 state->tmp = state->orig;
8995
8996 subreq = cli->dispatch_send(state, ev, cli,
8997 &ndr_table_samr,
8998 NDR_SAMR_OEMCHANGEPASSWORDUSER2,
8999 &state->tmp);
9000 if (tevent_req_nomem(subreq, req)) {
9001 return tevent_req_post(req, ev);
9002 }
9003 tevent_req_set_callback(subreq, rpccli_samr_OemChangePasswordUser2_done, req);
9004 return req;
9005 }
9006
9007 static void rpccli_samr_OemChangePasswordUser2_done(struct tevent_req *subreq)
9008 {
9009 struct tevent_req *req = tevent_req_callback_data(
9010 subreq, struct tevent_req);
9011 struct rpccli_samr_OemChangePasswordUser2_state *state = tevent_req_data(
9012 req, struct rpccli_samr_OemChangePasswordUser2_state);
9013 NTSTATUS status;
9014 TALLOC_CTX *mem_ctx;
9015
9016 if (state->out_mem_ctx) {
9017 mem_ctx = state->out_mem_ctx;
9018 } else {
9019 mem_ctx = state;
9020 }
9021
9022 status = state->dispatch_recv(subreq, mem_ctx);
9023 TALLOC_FREE(subreq);
9024 if (!NT_STATUS_IS_OK(status)) {
9025 tevent_req_nterror(req, status);
9026 return;
9027 }
9028
9029 /* Copy out parameters */
9030
9031 /* Copy result */
9032 state->orig.out.result = state->tmp.out.result;
9033
9034 /* Reset temporary structure */
9035 ZERO_STRUCT(state->tmp);
9036
9037 if (DEBUGLEVEL >= 10) {
9038 NDR_PRINT_OUT_DEBUG(samr_OemChangePasswordUser2, &state->orig);
9039 }
9040
9041 tevent_req_done(req);
9042 }
9043
9044 NTSTATUS rpccli_samr_OemChangePasswordUser2_recv(struct tevent_req *req,
9045 TALLOC_CTX *mem_ctx,
9046 NTSTATUS *result)
9047 {
9048 struct rpccli_samr_OemChangePasswordUser2_state *state = tevent_req_data(
9049 req, struct rpccli_samr_OemChangePasswordUser2_state);
9050 NTSTATUS status;
9051
9052 if (tevent_req_is_nterror(req, &status)) {
9053 tevent_req_received(req);
9054 return status;
9055 }
9056
9057 /* Steal possbile out parameters to the callers context */
9058 talloc_steal(mem_ctx, state->out_mem_ctx);
9059
9060 /* Return result */
9061 *result = state->orig.out.result;
9062
9063 tevent_req_received(req);
9064 return NT_STATUS_OK;
9065 }
9066
9067 NTSTATUS rpccli_samr_OemChangePasswordUser2(struct rpc_pipe_client *cli,
9068 TALLOC_CTX *mem_ctx,
9069 struct lsa_AsciiString *server /* [in] [unique] */,
9070 struct lsa_AsciiString *account /* [in] [ref] */,
9071 struct samr_CryptPassword *password /* [in] [unique] */,
9072 struct samr_Password *hash /* [in] [unique] */)
9073 {
9074 struct samr_OemChangePasswordUser2 r;
9075 NTSTATUS status;
9076
9077 /* In parameters */
9078 r.in.server = server;
9079 r.in.account = account;
9080 r.in.password = password;
9081 r.in.hash = hash;
9082
9083 if (DEBUGLEVEL >= 10) {
9084 NDR_PRINT_IN_DEBUG(samr_OemChangePasswordUser2, &r);
9085 }
9086
9087 status = cli->dispatch(cli,
9088 mem_ctx,
9089 &ndr_table_samr,
9090 NDR_SAMR_OEMCHANGEPASSWORDUSER2,
9091 &r);
9092
9093 if (!NT_STATUS_IS_OK(status)) {
9094 return status;
9095 }
9096
9097 if (DEBUGLEVEL >= 10) {
9098 NDR_PRINT_OUT_DEBUG(samr_OemChangePasswordUser2, &r);
9099 }
9100
9101 if (NT_STATUS_IS_ERR(status)) {
9102 return status;
9103 }
9104
9105 /* Return variables */
9106
9107 /* Return result */
9108 return r.out.result;
9109 }
9110
9111 struct rpccli_samr_ChangePasswordUser2_state {
9112 struct samr_ChangePasswordUser2 orig;
9113 struct samr_ChangePasswordUser2 tmp;
9114 TALLOC_CTX *out_mem_ctx;
9115 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9116 };
9117
9118 static void rpccli_samr_ChangePasswordUser2_done(struct tevent_req *subreq);
9119
9120 struct tevent_req *rpccli_samr_ChangePasswordUser2_send(TALLOC_CTX *mem_ctx,
9121 struct tevent_context *ev,
9122 struct rpc_pipe_client *cli,
9123 struct lsa_String *_server /* [in] [unique] */,
9124 struct lsa_String *_account /* [in] [ref] */,
9125 struct samr_CryptPassword *_nt_password /* [in] [unique] */,
9126 struct samr_Password *_nt_verifier /* [in] [unique] */,
9127 uint8_t _lm_change /* [in] */,
9128 struct samr_CryptPassword *_lm_password /* [in] [unique] */,
9129 struct samr_Password *_lm_verifier /* [in] [unique] */)
9130 {
9131 struct tevent_req *req;
9132 struct rpccli_samr_ChangePasswordUser2_state *state;
9133 struct tevent_req *subreq;
9134
9135 req = tevent_req_create(mem_ctx, &state,
9136 struct rpccli_samr_ChangePasswordUser2_state);
9137 if (req == NULL) {
9138 return NULL;
9139 }
9140 state->out_mem_ctx = NULL;
9141 state->dispatch_recv = cli->dispatch_recv;
9142
9143 /* In parameters */
9144 state->orig.in.server = _server;
9145 state->orig.in.account = _account;
9146 state->orig.in.nt_password = _nt_password;
9147 state->orig.in.nt_verifier = _nt_verifier;
9148 state->orig.in.lm_change = _lm_change;
9149 state->orig.in.lm_password = _lm_password;
9150 state->orig.in.lm_verifier = _lm_verifier;
9151
9152 /* Out parameters */
9153
9154 /* Result */
9155 ZERO_STRUCT(state->orig.out.result);
9156
9157 if (DEBUGLEVEL >= 10) {
9158 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser2, &state->orig);
9159 }
9160
9161 /* make a temporary copy, that we pass to the dispatch function */
9162 state->tmp = state->orig;
9163
9164 subreq = cli->dispatch_send(state, ev, cli,
9165 &ndr_table_samr,
9166 NDR_SAMR_CHANGEPASSWORDUSER2,
9167 &state->tmp);
9168 if (tevent_req_nomem(subreq, req)) {
9169 return tevent_req_post(req, ev);
9170 }
9171 tevent_req_set_callback(subreq, rpccli_samr_ChangePasswordUser2_done, req);
9172 return req;
9173 }
9174
9175 static void rpccli_samr_ChangePasswordUser2_done(struct tevent_req *subreq)
9176 {
9177 struct tevent_req *req = tevent_req_callback_data(
9178 subreq, struct tevent_req);
9179 struct rpccli_samr_ChangePasswordUser2_state *state = tevent_req_data(
9180 req, struct rpccli_samr_ChangePasswordUser2_state);
9181 NTSTATUS status;
9182 TALLOC_CTX *mem_ctx;
9183
9184 if (state->out_mem_ctx) {
9185 mem_ctx = state->out_mem_ctx;
9186 } else {
9187 mem_ctx = state;
9188 }
9189
9190 status = state->dispatch_recv(subreq, mem_ctx);
9191 TALLOC_FREE(subreq);
9192 if (!NT_STATUS_IS_OK(status)) {
9193 tevent_req_nterror(req, status);
9194 return;
9195 }
9196
9197 /* Copy out parameters */
9198
9199 /* Copy result */
9200 state->orig.out.result = state->tmp.out.result;
9201
9202 /* Reset temporary structure */
9203 ZERO_STRUCT(state->tmp);
9204
9205 if (DEBUGLEVEL >= 10) {
9206 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser2, &state->orig);
9207 }
9208
9209 tevent_req_done(req);
9210 }
9211
9212 NTSTATUS rpccli_samr_ChangePasswordUser2_recv(struct tevent_req *req,
9213 TALLOC_CTX *mem_ctx,
9214 NTSTATUS *result)
9215 {
9216 struct rpccli_samr_ChangePasswordUser2_state *state = tevent_req_data(
9217 req, struct rpccli_samr_ChangePasswordUser2_state);
9218 NTSTATUS status;
9219
9220 if (tevent_req_is_nterror(req, &status)) {
9221 tevent_req_received(req);
9222 return status;
9223 }
9224
9225 /* Steal possbile out parameters to the callers context */
9226 talloc_steal(mem_ctx, state->out_mem_ctx);
9227
9228 /* Return result */
9229 *result = state->orig.out.result;
9230
9231 tevent_req_received(req);
9232 return NT_STATUS_OK;
9233 }
9234
9235 NTSTATUS rpccli_samr_ChangePasswordUser2(struct rpc_pipe_client *cli,
9236 TALLOC_CTX *mem_ctx,
9237 struct lsa_String *server /* [in] [unique] */,
9238 struct lsa_String *account /* [in] [ref] */,
9239 struct samr_CryptPassword *nt_password /* [in] [unique] */,
9240 struct samr_Password *nt_verifier /* [in] [unique] */,
9241 uint8_t lm_change /* [in] */,
9242 struct samr_CryptPassword *lm_password /* [in] [unique] */,
9243 struct samr_Password *lm_verifier /* [in] [unique] */)
9244 {
9245 struct samr_ChangePasswordUser2 r;
9246 NTSTATUS status;
9247
9248 /* In parameters */
9249 r.in.server = server;
9250 r.in.account = account;
9251 r.in.nt_password = nt_password;
9252 r.in.nt_verifier = nt_verifier;
9253 r.in.lm_change = lm_change;
9254 r.in.lm_password = lm_password;
9255 r.in.lm_verifier = lm_verifier;
9256
9257 if (DEBUGLEVEL >= 10) {
9258 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser2, &r);
9259 }
9260
9261 status = cli->dispatch(cli,
9262 mem_ctx,
9263 &ndr_table_samr,
9264 NDR_SAMR_CHANGEPASSWORDUSER2,
9265 &r);
9266
9267 if (!NT_STATUS_IS_OK(status)) {
9268 return status;
9269 }
9270
9271 if (DEBUGLEVEL >= 10) {
9272 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser2, &r);
9273 }
9274
9275 if (NT_STATUS_IS_ERR(status)) {
9276 return status;
9277 }
9278
9279 /* Return variables */
9280
9281 /* Return result */
9282 return r.out.result;
9283 }
9284
9285 struct rpccli_samr_GetDomPwInfo_state {
9286 struct samr_GetDomPwInfo orig;
9287 struct samr_GetDomPwInfo tmp;
9288 TALLOC_CTX *out_mem_ctx;
9289 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9290 };
9291
9292 static void rpccli_samr_GetDomPwInfo_done(struct tevent_req *subreq);
9293
9294 struct tevent_req *rpccli_samr_GetDomPwInfo_send(TALLOC_CTX *mem_ctx,
9295 struct tevent_context *ev,
9296 struct rpc_pipe_client *cli,
9297 struct lsa_String *_domain_name /* [in] [unique] */,
9298 struct samr_PwInfo *_info /* [out] [ref] */)
9299 {
9300 struct tevent_req *req;
9301 struct rpccli_samr_GetDomPwInfo_state *state;
9302 struct tevent_req *subreq;
9303
9304 req = tevent_req_create(mem_ctx, &state,
9305 struct rpccli_samr_GetDomPwInfo_state);
9306 if (req == NULL) {
9307 return NULL;
9308 }
9309 state->out_mem_ctx = NULL;
9310 state->dispatch_recv = cli->dispatch_recv;
9311
9312 /* In parameters */
9313 state->orig.in.domain_name = _domain_name;
9314
9315 /* Out parameters */
9316 state->orig.out.info = _info;
9317
9318 /* Result */
9319 ZERO_STRUCT(state->orig.out.result);
9320
9321 if (DEBUGLEVEL >= 10) {
9322 NDR_PRINT_IN_DEBUG(samr_GetDomPwInfo, &state->orig);
9323 }
9324
9325 state->out_mem_ctx = talloc_named_const(state, 0,
9326 "rpccli_samr_GetDomPwInfo_out_memory");
9327 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9328 return tevent_req_post(req, ev);
9329 }
9330
9331 /* make a temporary copy, that we pass to the dispatch function */
9332 state->tmp = state->orig;
9333
9334 subreq = cli->dispatch_send(state, ev, cli,
9335 &ndr_table_samr,
9336 NDR_SAMR_GETDOMPWINFO,
9337 &state->tmp);
9338 if (tevent_req_nomem(subreq, req)) {
9339 return tevent_req_post(req, ev);
9340 }
9341 tevent_req_set_callback(subreq, rpccli_samr_GetDomPwInfo_done, req);
9342 return req;
9343 }
9344
9345 static void rpccli_samr_GetDomPwInfo_done(struct tevent_req *subreq)
9346 {
9347 struct tevent_req *req = tevent_req_callback_data(
9348 subreq, struct tevent_req);
9349 struct rpccli_samr_GetDomPwInfo_state *state = tevent_req_data(
9350 req, struct rpccli_samr_GetDomPwInfo_state);
9351 NTSTATUS status;
9352 TALLOC_CTX *mem_ctx;
9353
9354 if (state->out_mem_ctx) {
9355 mem_ctx = state->out_mem_ctx;
9356 } else {
9357 mem_ctx = state;
9358 }
9359
9360 status = state->dispatch_recv(subreq, mem_ctx);
9361 TALLOC_FREE(subreq);
9362 if (!NT_STATUS_IS_OK(status)) {
9363 tevent_req_nterror(req, status);
9364 return;
9365 }
9366
9367 /* Copy out parameters */
9368 *state->orig.out.info = *state->tmp.out.info;
9369
9370 /* Copy result */
9371 state->orig.out.result = state->tmp.out.result;
9372
9373 /* Reset temporary structure */
9374 ZERO_STRUCT(state->tmp);
9375
9376 if (DEBUGLEVEL >= 10) {
9377 NDR_PRINT_OUT_DEBUG(samr_GetDomPwInfo, &state->orig);
9378 }
9379
9380 tevent_req_done(req);
9381 }
9382
9383 NTSTATUS rpccli_samr_GetDomPwInfo_recv(struct tevent_req *req,
9384 TALLOC_CTX *mem_ctx,
9385 NTSTATUS *result)
9386 {
9387 struct rpccli_samr_GetDomPwInfo_state *state = tevent_req_data(
9388 req, struct rpccli_samr_GetDomPwInfo_state);
9389 NTSTATUS status;
9390
9391 if (tevent_req_is_nterror(req, &status)) {
9392 tevent_req_received(req);
9393 return status;
9394 }
9395
9396 /* Steal possbile out parameters to the callers context */
9397 talloc_steal(mem_ctx, state->out_mem_ctx);
9398
9399 /* Return result */
9400 *result = state->orig.out.result;
9401
9402 tevent_req_received(req);
9403 return NT_STATUS_OK;
9404 }
9405
9406 NTSTATUS rpccli_samr_GetDomPwInfo(struct rpc_pipe_client *cli,
9407 TALLOC_CTX *mem_ctx,
9408 struct lsa_String *domain_name /* [in] [unique] */,
9409 struct samr_PwInfo *info /* [out] [ref] */)
9410 {
9411 struct samr_GetDomPwInfo r;
9412 NTSTATUS status;
9413
9414 /* In parameters */
9415 r.in.domain_name = domain_name;
9416
9417 if (DEBUGLEVEL >= 10) {
9418 NDR_PRINT_IN_DEBUG(samr_GetDomPwInfo, &r);
9419 }
9420
9421 status = cli->dispatch(cli,
9422 mem_ctx,
9423 &ndr_table_samr,
9424 NDR_SAMR_GETDOMPWINFO,
9425 &r);
9426
9427 if (!NT_STATUS_IS_OK(status)) {
9428 return status;
9429 }
9430
9431 if (DEBUGLEVEL >= 10) {
9432 NDR_PRINT_OUT_DEBUG(samr_GetDomPwInfo, &r);
9433 }
9434
9435 if (NT_STATUS_IS_ERR(status)) {
9436 return status;
9437 }
9438
9439 /* Return variables */
9440 *info = *r.out.info;
9441
9442 /* Return result */
9443 return r.out.result;
9444 }
9445
9446 struct rpccli_samr_Connect2_state {
9447 struct samr_Connect2 orig;
9448 struct samr_Connect2 tmp;
9449 TALLOC_CTX *out_mem_ctx;
9450 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9451 };
9452
9453 static void rpccli_samr_Connect2_done(struct tevent_req *subreq);
9454
9455 struct tevent_req *rpccli_samr_Connect2_send(TALLOC_CTX *mem_ctx,
9456 struct tevent_context *ev,
9457 struct rpc_pipe_client *cli,
9458 const char *_system_name /* [in] [unique,charset(UTF16)] */,
9459 uint32_t _access_mask /* [in] */,
9460 struct policy_handle *_connect_handle /* [out] [ref] */)
9461 {
9462 struct tevent_req *req;
9463 struct rpccli_samr_Connect2_state *state;
9464 struct tevent_req *subreq;
9465
9466 req = tevent_req_create(mem_ctx, &state,
9467 struct rpccli_samr_Connect2_state);
9468 if (req == NULL) {
9469 return NULL;
9470 }
9471 state->out_mem_ctx = NULL;
9472 state->dispatch_recv = cli->dispatch_recv;
9473
9474 /* In parameters */
9475 state->orig.in.system_name = _system_name;
9476 state->orig.in.access_mask = _access_mask;
9477
9478 /* Out parameters */
9479 state->orig.out.connect_handle = _connect_handle;
9480
9481 /* Result */
9482 ZERO_STRUCT(state->orig.out.result);
9483
9484 if (DEBUGLEVEL >= 10) {
9485 NDR_PRINT_IN_DEBUG(samr_Connect2, &state->orig);
9486 }
9487
9488 state->out_mem_ctx = talloc_named_const(state, 0,
9489 "rpccli_samr_Connect2_out_memory");
9490 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9491 return tevent_req_post(req, ev);
9492 }
9493
9494 /* make a temporary copy, that we pass to the dispatch function */
9495 state->tmp = state->orig;
9496
9497 subreq = cli->dispatch_send(state, ev, cli,
9498 &ndr_table_samr,
9499 NDR_SAMR_CONNECT2,
9500 &state->tmp);
9501 if (tevent_req_nomem(subreq, req)) {
9502 return tevent_req_post(req, ev);
9503 }
9504 tevent_req_set_callback(subreq, rpccli_samr_Connect2_done, req);
9505 return req;
9506 }
9507
9508 static void rpccli_samr_Connect2_done(struct tevent_req *subreq)
9509 {
9510 struct tevent_req *req = tevent_req_callback_data(
9511 subreq, struct tevent_req);
9512 struct rpccli_samr_Connect2_state *state = tevent_req_data(
9513 req, struct rpccli_samr_Connect2_state);
9514 NTSTATUS status;
9515 TALLOC_CTX *mem_ctx;
9516
9517 if (state->out_mem_ctx) {
9518 mem_ctx = state->out_mem_ctx;
9519 } else {
9520 mem_ctx = state;
9521 }
9522
9523 status = state->dispatch_recv(subreq, mem_ctx);
9524 TALLOC_FREE(subreq);
9525 if (!NT_STATUS_IS_OK(status)) {
9526 tevent_req_nterror(req, status);
9527 return;
9528 }
9529
9530 /* Copy out parameters */
9531 *state->orig.out.connect_handle = *state->tmp.out.connect_handle;
9532
9533 /* Copy result */
9534 state->orig.out.result = state->tmp.out.result;
9535
9536 /* Reset temporary structure */
9537 ZERO_STRUCT(state->tmp);
9538
9539 if (DEBUGLEVEL >= 10) {
9540 NDR_PRINT_OUT_DEBUG(samr_Connect2, &state->orig);
9541 }
9542
9543 tevent_req_done(req);
9544 }
9545
9546 NTSTATUS rpccli_samr_Connect2_recv(struct tevent_req *req,
9547 TALLOC_CTX *mem_ctx,
9548 NTSTATUS *result)
9549 {
9550 struct rpccli_samr_Connect2_state *state = tevent_req_data(
9551 req, struct rpccli_samr_Connect2_state);
9552 NTSTATUS status;
9553
9554 if (tevent_req_is_nterror(req, &status)) {
9555 tevent_req_received(req);
9556 return status;
9557 }
9558
9559 /* Steal possbile out parameters to the callers context */
9560 talloc_steal(mem_ctx, state->out_mem_ctx);
9561
9562 /* Return result */
9563 *result = state->orig.out.result;
9564
9565 tevent_req_received(req);
9566 return NT_STATUS_OK;
9567 }
9568
9569 NTSTATUS rpccli_samr_Connect2(struct rpc_pipe_client *cli,
9570 TALLOC_CTX *mem_ctx,
9571 const char *system_name /* [in] [unique,charset(UTF16)] */,
9572 uint32_t access_mask /* [in] */,
9573 struct policy_handle *connect_handle /* [out] [ref] */)
9574 {
9575 struct samr_Connect2 r;
9576 NTSTATUS status;
9577
9578 /* In parameters */
9579 r.in.system_name = system_name;
9580 r.in.access_mask = access_mask;
9581
9582 if (DEBUGLEVEL >= 10) {
9583 NDR_PRINT_IN_DEBUG(samr_Connect2, &r);
9584 }
9585
9586 status = cli->dispatch(cli,
9587 mem_ctx,
9588 &ndr_table_samr,
9589 NDR_SAMR_CONNECT2,
9590 &r);
9591
9592 if (!NT_STATUS_IS_OK(status)) {
9593 return status;
9594 }
9595
9596 if (DEBUGLEVEL >= 10) {
9597 NDR_PRINT_OUT_DEBUG(samr_Connect2, &r);
9598 }
9599
9600 if (NT_STATUS_IS_ERR(status)) {
9601 return status;
9602 }
9603
9604 /* Return variables */
9605 *connect_handle = *r.out.connect_handle;
9606
9607 /* Return result */
9608 return r.out.result;
9609 }
9610
9611 struct rpccli_samr_SetUserInfo2_state {
9612 struct samr_SetUserInfo2 orig;
9613 struct samr_SetUserInfo2 tmp;
9614 TALLOC_CTX *out_mem_ctx;
9615 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9616 };
9617
9618 static void rpccli_samr_SetUserInfo2_done(struct tevent_req *subreq);
9619
9620 struct tevent_req *rpccli_samr_SetUserInfo2_send(TALLOC_CTX *mem_ctx,
9621 struct tevent_context *ev,
9622 struct rpc_pipe_client *cli,
9623 struct policy_handle *_user_handle /* [in] [ref] */,
9624 enum samr_UserInfoLevel _level /* [in] */,
9625 union samr_UserInfo *_info /* [in] [ref,switch_is(level)] */)
9626 {
9627 struct tevent_req *req;
9628 struct rpccli_samr_SetUserInfo2_state *state;
9629 struct tevent_req *subreq;
9630
9631 req = tevent_req_create(mem_ctx, &state,
9632 struct rpccli_samr_SetUserInfo2_state);
9633 if (req == NULL) {
9634 return NULL;
9635 }
9636 state->out_mem_ctx = NULL;
9637 state->dispatch_recv = cli->dispatch_recv;
9638
9639 /* In parameters */
9640 state->orig.in.user_handle = _user_handle;
9641 state->orig.in.level = _level;
9642 state->orig.in.info = _info;
9643
9644 /* Out parameters */
9645
9646 /* Result */
9647 ZERO_STRUCT(state->orig.out.result);
9648
9649 if (DEBUGLEVEL >= 10) {
9650 NDR_PRINT_IN_DEBUG(samr_SetUserInfo2, &state->orig);
9651 }
9652
9653 /* make a temporary copy, that we pass to the dispatch function */
9654 state->tmp = state->orig;
9655
9656 subreq = cli->dispatch_send(state, ev, cli,
9657 &ndr_table_samr,
9658 NDR_SAMR_SETUSERINFO2,
9659 &state->tmp);
9660 if (tevent_req_nomem(subreq, req)) {
9661 return tevent_req_post(req, ev);
9662 }
9663 tevent_req_set_callback(subreq, rpccli_samr_SetUserInfo2_done, req);
9664 return req;
9665 }
9666
9667 static void rpccli_samr_SetUserInfo2_done(struct tevent_req *subreq)
9668 {
9669 struct tevent_req *req = tevent_req_callback_data(
9670 subreq, struct tevent_req);
9671 struct rpccli_samr_SetUserInfo2_state *state = tevent_req_data(
9672 req, struct rpccli_samr_SetUserInfo2_state);
9673 NTSTATUS status;
9674 TALLOC_CTX *mem_ctx;
9675
9676 if (state->out_mem_ctx) {
9677 mem_ctx = state->out_mem_ctx;
9678 } else {
9679 mem_ctx = state;
9680 }
9681
9682 status = state->dispatch_recv(subreq, mem_ctx);
9683 TALLOC_FREE(subreq);
9684 if (!NT_STATUS_IS_OK(status)) {
9685 tevent_req_nterror(req, status);
9686 return;
9687 }
9688
9689 /* Copy out parameters */
9690
9691 /* Copy result */
9692 state->orig.out.result = state->tmp.out.result;
9693
9694 /* Reset temporary structure */
9695 ZERO_STRUCT(state->tmp);
9696
9697 if (DEBUGLEVEL >= 10) {
9698 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo2, &state->orig);
9699 }
9700
9701 tevent_req_done(req);
9702 }
9703
9704 NTSTATUS rpccli_samr_SetUserInfo2_recv(struct tevent_req *req,
9705 TALLOC_CTX *mem_ctx,
9706 NTSTATUS *result)
9707 {
9708 struct rpccli_samr_SetUserInfo2_state *state = tevent_req_data(
9709 req, struct rpccli_samr_SetUserInfo2_state);
9710 NTSTATUS status;
9711
9712 if (tevent_req_is_nterror(req, &status)) {
9713 tevent_req_received(req);
9714 return status;
9715 }
9716
9717 /* Steal possbile out parameters to the callers context */
9718 talloc_steal(mem_ctx, state->out_mem_ctx);
9719
9720 /* Return result */
9721 *result = state->orig.out.result;
9722
9723 tevent_req_received(req);
9724 return NT_STATUS_OK;
9725 }
9726
9727 NTSTATUS rpccli_samr_SetUserInfo2(struct rpc_pipe_client *cli,
9728 TALLOC_CTX *mem_ctx,
9729 struct policy_handle *user_handle /* [in] [ref] */,
9730 enum samr_UserInfoLevel level /* [in] */,
9731 union samr_UserInfo *info /* [in] [ref,switch_is(level)] */)
9732 {
9733 struct samr_SetUserInfo2 r;
9734 NTSTATUS status;
9735
9736 /* In parameters */
9737 r.in.user_handle = user_handle;
9738 r.in.level = level;
9739 r.in.info = info;
9740
9741 if (DEBUGLEVEL >= 10) {
9742 NDR_PRINT_IN_DEBUG(samr_SetUserInfo2, &r);
9743 }
9744
9745 status = cli->dispatch(cli,
9746 mem_ctx,
9747 &ndr_table_samr,
9748 NDR_SAMR_SETUSERINFO2,
9749 &r);
9750
9751 if (!NT_STATUS_IS_OK(status)) {
9752 return status;
9753 }
9754
9755 if (DEBUGLEVEL >= 10) {
9756 NDR_PRINT_OUT_DEBUG(samr_SetUserInfo2, &r);
9757 }
9758
9759 if (NT_STATUS_IS_ERR(status)) {
9760 return status;
9761 }
9762
9763 /* Return variables */
9764
9765 /* Return result */
9766 return r.out.result;
9767 }
9768
9769 struct rpccli_samr_SetBootKeyInformation_state {
9770 struct samr_SetBootKeyInformation orig;
9771 struct samr_SetBootKeyInformation tmp;
9772 TALLOC_CTX *out_mem_ctx;
9773 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9774 };
9775
9776 static void rpccli_samr_SetBootKeyInformation_done(struct tevent_req *subreq);
9777
9778 struct tevent_req *rpccli_samr_SetBootKeyInformation_send(TALLOC_CTX *mem_ctx,
9779 struct tevent_context *ev,
9780 struct rpc_pipe_client *cli,
9781 struct policy_handle *_connect_handle /* [in] [ref] */,
9782 uint32_t _unknown1 /* [in] */,
9783 uint32_t _unknown2 /* [in] */,
9784 uint32_t _unknown3 /* [in] */)
9785 {
9786 struct tevent_req *req;
9787 struct rpccli_samr_SetBootKeyInformation_state *state;
9788 struct tevent_req *subreq;
9789
9790 req = tevent_req_create(mem_ctx, &state,
9791 struct rpccli_samr_SetBootKeyInformation_state);
9792 if (req == NULL) {
9793 return NULL;
9794 }
9795 state->out_mem_ctx = NULL;
9796 state->dispatch_recv = cli->dispatch_recv;
9797
9798 /* In parameters */
9799 state->orig.in.connect_handle = _connect_handle;
9800 state->orig.in.unknown1 = _unknown1;
9801 state->orig.in.unknown2 = _unknown2;
9802 state->orig.in.unknown3 = _unknown3;
9803
9804 /* Out parameters */
9805
9806 /* Result */
9807 ZERO_STRUCT(state->orig.out.result);
9808
9809 if (DEBUGLEVEL >= 10) {
9810 NDR_PRINT_IN_DEBUG(samr_SetBootKeyInformation, &state->orig);
9811 }
9812
9813 /* make a temporary copy, that we pass to the dispatch function */
9814 state->tmp = state->orig;
9815
9816 subreq = cli->dispatch_send(state, ev, cli,
9817 &ndr_table_samr,
9818 NDR_SAMR_SETBOOTKEYINFORMATION,
9819 &state->tmp);
9820 if (tevent_req_nomem(subreq, req)) {
9821 return tevent_req_post(req, ev);
9822 }
9823 tevent_req_set_callback(subreq, rpccli_samr_SetBootKeyInformation_done, req);
9824 return req;
9825 }
9826
9827 static void rpccli_samr_SetBootKeyInformation_done(struct tevent_req *subreq)
9828 {
9829 struct tevent_req *req = tevent_req_callback_data(
9830 subreq, struct tevent_req);
9831 struct rpccli_samr_SetBootKeyInformation_state *state = tevent_req_data(
9832 req, struct rpccli_samr_SetBootKeyInformation_state);
9833 NTSTATUS status;
9834 TALLOC_CTX *mem_ctx;
9835
9836 if (state->out_mem_ctx) {
9837 mem_ctx = state->out_mem_ctx;
9838 } else {
9839 mem_ctx = state;
9840 }
9841
9842 status = state->dispatch_recv(subreq, mem_ctx);
9843 TALLOC_FREE(subreq);
9844 if (!NT_STATUS_IS_OK(status)) {
9845 tevent_req_nterror(req, status);
9846 return;
9847 }
9848
9849 /* Copy out parameters */
9850
9851 /* Copy result */
9852 state->orig.out.result = state->tmp.out.result;
9853
9854 /* Reset temporary structure */
9855 ZERO_STRUCT(state->tmp);
9856
9857 if (DEBUGLEVEL >= 10) {
9858 NDR_PRINT_OUT_DEBUG(samr_SetBootKeyInformation, &state->orig);
9859 }
9860
9861 tevent_req_done(req);
9862 }
9863
9864 NTSTATUS rpccli_samr_SetBootKeyInformation_recv(struct tevent_req *req,
9865 TALLOC_CTX *mem_ctx,
9866 NTSTATUS *result)
9867 {
9868 struct rpccli_samr_SetBootKeyInformation_state *state = tevent_req_data(
9869 req, struct rpccli_samr_SetBootKeyInformation_state);
9870 NTSTATUS status;
9871
9872 if (tevent_req_is_nterror(req, &status)) {
9873 tevent_req_received(req);
9874 return status;
9875 }
9876
9877 /* Steal possbile out parameters to the callers context */
9878 talloc_steal(mem_ctx, state->out_mem_ctx);
9879
9880 /* Return result */
9881 *result = state->orig.out.result;
9882
9883 tevent_req_received(req);
9884 return NT_STATUS_OK;
9885 }
9886
9887 NTSTATUS rpccli_samr_SetBootKeyInformation(struct rpc_pipe_client *cli,
9888 TALLOC_CTX *mem_ctx,
9889 struct policy_handle *connect_handle /* [in] [ref] */,
9890 uint32_t unknown1 /* [in] */,
9891 uint32_t unknown2 /* [in] */,
9892 uint32_t unknown3 /* [in] */)
9893 {
9894 struct samr_SetBootKeyInformation r;
9895 NTSTATUS status;
9896
9897 /* In parameters */
9898 r.in.connect_handle = connect_handle;
9899 r.in.unknown1 = unknown1;
9900 r.in.unknown2 = unknown2;
9901 r.in.unknown3 = unknown3;
9902
9903 if (DEBUGLEVEL >= 10) {
9904 NDR_PRINT_IN_DEBUG(samr_SetBootKeyInformation, &r);
9905 }
9906
9907 status = cli->dispatch(cli,
9908 mem_ctx,
9909 &ndr_table_samr,
9910 NDR_SAMR_SETBOOTKEYINFORMATION,
9911 &r);
9912
9913 if (!NT_STATUS_IS_OK(status)) {
9914 return status;
9915 }
9916
9917 if (DEBUGLEVEL >= 10) {
9918 NDR_PRINT_OUT_DEBUG(samr_SetBootKeyInformation, &r);
9919 }
9920
9921 if (NT_STATUS_IS_ERR(status)) {
9922 return status;
9923 }
9924
9925 /* Return variables */
9926
9927 /* Return result */
9928 return r.out.result;
9929 }
9930
9931 struct rpccli_samr_GetBootKeyInformation_state {
9932 struct samr_GetBootKeyInformation orig;
9933 struct samr_GetBootKeyInformation tmp;
9934 TALLOC_CTX *out_mem_ctx;
9935 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
9936 };
9937
9938 static void rpccli_samr_GetBootKeyInformation_done(struct tevent_req *subreq);
9939
9940 struct tevent_req *rpccli_samr_GetBootKeyInformation_send(TALLOC_CTX *mem_ctx,
9941 struct tevent_context *ev,
9942 struct rpc_pipe_client *cli,
9943 struct policy_handle *_domain_handle /* [in] [ref] */,
9944 uint32_t *_unknown /* [out] [ref] */)
9945 {
9946 struct tevent_req *req;
9947 struct rpccli_samr_GetBootKeyInformation_state *state;
9948 struct tevent_req *subreq;
9949
9950 req = tevent_req_create(mem_ctx, &state,
9951 struct rpccli_samr_GetBootKeyInformation_state);
9952 if (req == NULL) {
9953 return NULL;
9954 }
9955 state->out_mem_ctx = NULL;
9956 state->dispatch_recv = cli->dispatch_recv;
9957
9958 /* In parameters */
9959 state->orig.in.domain_handle = _domain_handle;
9960
9961 /* Out parameters */
9962 state->orig.out.unknown = _unknown;
9963
9964 /* Result */
9965 ZERO_STRUCT(state->orig.out.result);
9966
9967 if (DEBUGLEVEL >= 10) {
9968 NDR_PRINT_IN_DEBUG(samr_GetBootKeyInformation, &state->orig);
9969 }
9970
9971 state->out_mem_ctx = talloc_named_const(state, 0,
9972 "rpccli_samr_GetBootKeyInformation_out_memory");
9973 if (tevent_req_nomem(state->out_mem_ctx, req)) {
9974 return tevent_req_post(req, ev);
9975 }
9976
9977 /* make a temporary copy, that we pass to the dispatch function */
9978 state->tmp = state->orig;
9979
9980 subreq = cli->dispatch_send(state, ev, cli,
9981 &ndr_table_samr,
9982 NDR_SAMR_GETBOOTKEYINFORMATION,
9983 &state->tmp);
9984 if (tevent_req_nomem(subreq, req)) {
9985 return tevent_req_post(req, ev);
9986 }
9987 tevent_req_set_callback(subreq, rpccli_samr_GetBootKeyInformation_done, req);
9988 return req;
9989 }
9990
9991 static void rpccli_samr_GetBootKeyInformation_done(struct tevent_req *subreq)
9992 {
9993 struct tevent_req *req = tevent_req_callback_data(
9994 subreq, struct tevent_req);
9995 struct rpccli_samr_GetBootKeyInformation_state *state = tevent_req_data(
9996 req, struct rpccli_samr_GetBootKeyInformation_state);
9997 NTSTATUS status;
9998 TALLOC_CTX *mem_ctx;
9999
10000 if (state->out_mem_ctx) {
10001 mem_ctx = state->out_mem_ctx;
10002 } else {
10003 mem_ctx = state;
10004 }
10005
10006 status = state->dispatch_recv(subreq, mem_ctx);
10007 TALLOC_FREE(subreq);
10008 if (!NT_STATUS_IS_OK(status)) {
10009 tevent_req_nterror(req, status);
10010 return;
10011 }
10012
10013 /* Copy out parameters */
10014 *state->orig.out.unknown = *state->tmp.out.unknown;
10015
10016 /* Copy result */
10017 state->orig.out.result = state->tmp.out.result;
10018
10019 /* Reset temporary structure */
10020 ZERO_STRUCT(state->tmp);
10021
10022 if (DEBUGLEVEL >= 10) {
10023 NDR_PRINT_OUT_DEBUG(samr_GetBootKeyInformation, &state->orig);
10024 }
10025
10026 tevent_req_done(req);
10027 }
10028
10029 NTSTATUS rpccli_samr_GetBootKeyInformation_recv(struct tevent_req *req,
10030 TALLOC_CTX *mem_ctx,
10031 NTSTATUS *result)
10032 {
10033 struct rpccli_samr_GetBootKeyInformation_state *state = tevent_req_data(
10034 req, struct rpccli_samr_GetBootKeyInformation_state);
10035 NTSTATUS status;
10036
10037 if (tevent_req_is_nterror(req, &status)) {
10038 tevent_req_received(req);
10039 return status;
10040 }
10041
10042 /* Steal possbile out parameters to the callers context */
10043 talloc_steal(mem_ctx, state->out_mem_ctx);
10044
10045 /* Return result */
10046 *result = state->orig.out.result;
10047
10048 tevent_req_received(req);
10049 return NT_STATUS_OK;
10050 }
10051
10052 NTSTATUS rpccli_samr_GetBootKeyInformation(struct rpc_pipe_client *cli,
10053 TALLOC_CTX *mem_ctx,
10054 struct policy_handle *domain_handle /* [in] [ref] */,
10055 uint32_t *unknown /* [out] [ref] */)
10056 {
10057 struct samr_GetBootKeyInformation r;
10058 NTSTATUS status;
10059
10060 /* In parameters */
10061 r.in.domain_handle = domain_handle;
10062
10063 if (DEBUGLEVEL >= 10) {
10064 NDR_PRINT_IN_DEBUG(samr_GetBootKeyInformation, &r);
10065 }
10066
10067 status = cli->dispatch(cli,
10068 mem_ctx,
10069 &ndr_table_samr,
10070 NDR_SAMR_GETBOOTKEYINFORMATION,
10071 &r);
10072
10073 if (!NT_STATUS_IS_OK(status)) {
10074 return status;
10075 }
10076
10077 if (DEBUGLEVEL >= 10) {
10078 NDR_PRINT_OUT_DEBUG(samr_GetBootKeyInformation, &r);
10079 }
10080
10081 if (NT_STATUS_IS_ERR(status)) {
10082 return status;
10083 }
10084
10085 /* Return variables */
10086 *unknown = *r.out.unknown;
10087
10088 /* Return result */
10089 return r.out.result;
10090 }
10091
10092 struct rpccli_samr_Connect3_state {
10093 struct samr_Connect3 orig;
10094 struct samr_Connect3 tmp;
10095 TALLOC_CTX *out_mem_ctx;
10096 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10097 };
10098
10099 static void rpccli_samr_Connect3_done(struct tevent_req *subreq);
10100
10101 struct tevent_req *rpccli_samr_Connect3_send(TALLOC_CTX *mem_ctx,
10102 struct tevent_context *ev,
10103 struct rpc_pipe_client *cli,
10104 const char *_system_name /* [in] [unique,charset(UTF16)] */,
10105 uint32_t _unknown /* [in] */,
10106 uint32_t _access_mask /* [in] */,
10107 struct policy_handle *_connect_handle /* [out] [ref] */)
10108 {
10109 struct tevent_req *req;
10110 struct rpccli_samr_Connect3_state *state;
10111 struct tevent_req *subreq;
10112
10113 req = tevent_req_create(mem_ctx, &state,
10114 struct rpccli_samr_Connect3_state);
10115 if (req == NULL) {
10116 return NULL;
10117 }
10118 state->out_mem_ctx = NULL;
10119 state->dispatch_recv = cli->dispatch_recv;
10120
10121 /* In parameters */
10122 state->orig.in.system_name = _system_name;
10123 state->orig.in.unknown = _unknown;
10124 state->orig.in.access_mask = _access_mask;
10125
10126 /* Out parameters */
10127 state->orig.out.connect_handle = _connect_handle;
10128
10129 /* Result */
10130 ZERO_STRUCT(state->orig.out.result);
10131
10132 if (DEBUGLEVEL >= 10) {
10133 NDR_PRINT_IN_DEBUG(samr_Connect3, &state->orig);
10134 }
10135
10136 state->out_mem_ctx = talloc_named_const(state, 0,
10137 "rpccli_samr_Connect3_out_memory");
10138 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10139 return tevent_req_post(req, ev);
10140 }
10141
10142 /* make a temporary copy, that we pass to the dispatch function */
10143 state->tmp = state->orig;
10144
10145 subreq = cli->dispatch_send(state, ev, cli,
10146 &ndr_table_samr,
10147 NDR_SAMR_CONNECT3,
10148 &state->tmp);
10149 if (tevent_req_nomem(subreq, req)) {
10150 return tevent_req_post(req, ev);
10151 }
10152 tevent_req_set_callback(subreq, rpccli_samr_Connect3_done, req);
10153 return req;
10154 }
10155
10156 static void rpccli_samr_Connect3_done(struct tevent_req *subreq)
10157 {
10158 struct tevent_req *req = tevent_req_callback_data(
10159 subreq, struct tevent_req);
10160 struct rpccli_samr_Connect3_state *state = tevent_req_data(
10161 req, struct rpccli_samr_Connect3_state);
10162 NTSTATUS status;
10163 TALLOC_CTX *mem_ctx;
10164
10165 if (state->out_mem_ctx) {
10166 mem_ctx = state->out_mem_ctx;
10167 } else {
10168 mem_ctx = state;
10169 }
10170
10171 status = state->dispatch_recv(subreq, mem_ctx);
10172 TALLOC_FREE(subreq);
10173 if (!NT_STATUS_IS_OK(status)) {
10174 tevent_req_nterror(req, status);
10175 return;
10176 }
10177
10178 /* Copy out parameters */
10179 *state->orig.out.connect_handle = *state->tmp.out.connect_handle;
10180
10181 /* Copy result */
10182 state->orig.out.result = state->tmp.out.result;
10183
10184 /* Reset temporary structure */
10185 ZERO_STRUCT(state->tmp);
10186
10187 if (DEBUGLEVEL >= 10) {
10188 NDR_PRINT_OUT_DEBUG(samr_Connect3, &state->orig);
10189 }
10190
10191 tevent_req_done(req);
10192 }
10193
10194 NTSTATUS rpccli_samr_Connect3_recv(struct tevent_req *req,
10195 TALLOC_CTX *mem_ctx,
10196 NTSTATUS *result)
10197 {
10198 struct rpccli_samr_Connect3_state *state = tevent_req_data(
10199 req, struct rpccli_samr_Connect3_state);
10200 NTSTATUS status;
10201
10202 if (tevent_req_is_nterror(req, &status)) {
10203 tevent_req_received(req);
10204 return status;
10205 }
10206
10207 /* Steal possbile out parameters to the callers context */
10208 talloc_steal(mem_ctx, state->out_mem_ctx);
10209
10210 /* Return result */
10211 *result = state->orig.out.result;
10212
10213 tevent_req_received(req);
10214 return NT_STATUS_OK;
10215 }
10216
10217 NTSTATUS rpccli_samr_Connect3(struct rpc_pipe_client *cli,
10218 TALLOC_CTX *mem_ctx,
10219 const char *system_name /* [in] [unique,charset(UTF16)] */,
10220 uint32_t unknown /* [in] */,
10221 uint32_t access_mask /* [in] */,
10222 struct policy_handle *connect_handle /* [out] [ref] */)
10223 {
10224 struct samr_Connect3 r;
10225 NTSTATUS status;
10226
10227 /* In parameters */
10228 r.in.system_name = system_name;
10229 r.in.unknown = unknown;
10230 r.in.access_mask = access_mask;
10231
10232 if (DEBUGLEVEL >= 10) {
10233 NDR_PRINT_IN_DEBUG(samr_Connect3, &r);
10234 }
10235
10236 status = cli->dispatch(cli,
10237 mem_ctx,
10238 &ndr_table_samr,
10239 NDR_SAMR_CONNECT3,
10240 &r);
10241
10242 if (!NT_STATUS_IS_OK(status)) {
10243 return status;
10244 }
10245
10246 if (DEBUGLEVEL >= 10) {
10247 NDR_PRINT_OUT_DEBUG(samr_Connect3, &r);
10248 }
10249
10250 if (NT_STATUS_IS_ERR(status)) {
10251 return status;
10252 }
10253
10254 /* Return variables */
10255 *connect_handle = *r.out.connect_handle;
10256
10257 /* Return result */
10258 return r.out.result;
10259 }
10260
10261 struct rpccli_samr_Connect4_state {
10262 struct samr_Connect4 orig;
10263 struct samr_Connect4 tmp;
10264 TALLOC_CTX *out_mem_ctx;
10265 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10266 };
10267
10268 static void rpccli_samr_Connect4_done(struct tevent_req *subreq);
10269
10270 struct tevent_req *rpccli_samr_Connect4_send(TALLOC_CTX *mem_ctx,
10271 struct tevent_context *ev,
10272 struct rpc_pipe_client *cli,
10273 const char *_system_name /* [in] [unique,charset(UTF16)] */,
10274 enum samr_ConnectVersion _client_version /* [in] */,
10275 uint32_t _access_mask /* [in] */,
10276 struct policy_handle *_connect_handle /* [out] [ref] */)
10277 {
10278 struct tevent_req *req;
10279 struct rpccli_samr_Connect4_state *state;
10280 struct tevent_req *subreq;
10281
10282 req = tevent_req_create(mem_ctx, &state,
10283 struct rpccli_samr_Connect4_state);
10284 if (req == NULL) {
10285 return NULL;
10286 }
10287 state->out_mem_ctx = NULL;
10288 state->dispatch_recv = cli->dispatch_recv;
10289
10290 /* In parameters */
10291 state->orig.in.system_name = _system_name;
10292 state->orig.in.client_version = _client_version;
10293 state->orig.in.access_mask = _access_mask;
10294
10295 /* Out parameters */
10296 state->orig.out.connect_handle = _connect_handle;
10297
10298 /* Result */
10299 ZERO_STRUCT(state->orig.out.result);
10300
10301 if (DEBUGLEVEL >= 10) {
10302 NDR_PRINT_IN_DEBUG(samr_Connect4, &state->orig);
10303 }
10304
10305 state->out_mem_ctx = talloc_named_const(state, 0,
10306 "rpccli_samr_Connect4_out_memory");
10307 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10308 return tevent_req_post(req, ev);
10309 }
10310
10311 /* make a temporary copy, that we pass to the dispatch function */
10312 state->tmp = state->orig;
10313
10314 subreq = cli->dispatch_send(state, ev, cli,
10315 &ndr_table_samr,
10316 NDR_SAMR_CONNECT4,
10317 &state->tmp);
10318 if (tevent_req_nomem(subreq, req)) {
10319 return tevent_req_post(req, ev);
10320 }
10321 tevent_req_set_callback(subreq, rpccli_samr_Connect4_done, req);
10322 return req;
10323 }
10324
10325 static void rpccli_samr_Connect4_done(struct tevent_req *subreq)
10326 {
10327 struct tevent_req *req = tevent_req_callback_data(
10328 subreq, struct tevent_req);
10329 struct rpccli_samr_Connect4_state *state = tevent_req_data(
10330 req, struct rpccli_samr_Connect4_state);
10331 NTSTATUS status;
10332 TALLOC_CTX *mem_ctx;
10333
10334 if (state->out_mem_ctx) {
10335 mem_ctx = state->out_mem_ctx;
10336 } else {
10337 mem_ctx = state;
10338 }
10339
10340 status = state->dispatch_recv(subreq, mem_ctx);
10341 TALLOC_FREE(subreq);
10342 if (!NT_STATUS_IS_OK(status)) {
10343 tevent_req_nterror(req, status);
10344 return;
10345 }
10346
10347 /* Copy out parameters */
10348 *state->orig.out.connect_handle = *state->tmp.out.connect_handle;
10349
10350 /* Copy result */
10351 state->orig.out.result = state->tmp.out.result;
10352
10353 /* Reset temporary structure */
10354 ZERO_STRUCT(state->tmp);
10355
10356 if (DEBUGLEVEL >= 10) {
10357 NDR_PRINT_OUT_DEBUG(samr_Connect4, &state->orig);
10358 }
10359
10360 tevent_req_done(req);
10361 }
10362
10363 NTSTATUS rpccli_samr_Connect4_recv(struct tevent_req *req,
10364 TALLOC_CTX *mem_ctx,
10365 NTSTATUS *result)
10366 {
10367 struct rpccli_samr_Connect4_state *state = tevent_req_data(
10368 req, struct rpccli_samr_Connect4_state);
10369 NTSTATUS status;
10370
10371 if (tevent_req_is_nterror(req, &status)) {
10372 tevent_req_received(req);
10373 return status;
10374 }
10375
10376 /* Steal possbile out parameters to the callers context */
10377 talloc_steal(mem_ctx, state->out_mem_ctx);
10378
10379 /* Return result */
10380 *result = state->orig.out.result;
10381
10382 tevent_req_received(req);
10383 return NT_STATUS_OK;
10384 }
10385
10386 NTSTATUS rpccli_samr_Connect4(struct rpc_pipe_client *cli,
10387 TALLOC_CTX *mem_ctx,
10388 const char *system_name /* [in] [unique,charset(UTF16)] */,
10389 enum samr_ConnectVersion client_version /* [in] */,
10390 uint32_t access_mask /* [in] */,
10391 struct policy_handle *connect_handle /* [out] [ref] */)
10392 {
10393 struct samr_Connect4 r;
10394 NTSTATUS status;
10395
10396 /* In parameters */
10397 r.in.system_name = system_name;
10398 r.in.client_version = client_version;
10399 r.in.access_mask = access_mask;
10400
10401 if (DEBUGLEVEL >= 10) {
10402 NDR_PRINT_IN_DEBUG(samr_Connect4, &r);
10403 }
10404
10405 status = cli->dispatch(cli,
10406 mem_ctx,
10407 &ndr_table_samr,
10408 NDR_SAMR_CONNECT4,
10409 &r);
10410
10411 if (!NT_STATUS_IS_OK(status)) {
10412 return status;
10413 }
10414
10415 if (DEBUGLEVEL >= 10) {
10416 NDR_PRINT_OUT_DEBUG(samr_Connect4, &r);
10417 }
10418
10419 if (NT_STATUS_IS_ERR(status)) {
10420 return status;
10421 }
10422
10423 /* Return variables */
10424 *connect_handle = *r.out.connect_handle;
10425
10426 /* Return result */
10427 return r.out.result;
10428 }
10429
10430 struct rpccli_samr_ChangePasswordUser3_state {
10431 struct samr_ChangePasswordUser3 orig;
10432 struct samr_ChangePasswordUser3 tmp;
10433 TALLOC_CTX *out_mem_ctx;
10434 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10435 };
10436
10437 static void rpccli_samr_ChangePasswordUser3_done(struct tevent_req *subreq);
10438
10439 struct tevent_req *rpccli_samr_ChangePasswordUser3_send(TALLOC_CTX *mem_ctx,
10440 struct tevent_context *ev,
10441 struct rpc_pipe_client *cli,
10442 struct lsa_String *_server /* [in] [unique] */,
10443 struct lsa_String *_account /* [in] [ref] */,
10444 struct samr_CryptPassword *_nt_password /* [in] [unique] */,
10445 struct samr_Password *_nt_verifier /* [in] [unique] */,
10446 uint8_t _lm_change /* [in] */,
10447 struct samr_CryptPassword *_lm_password /* [in] [unique] */,
10448 struct samr_Password *_lm_verifier /* [in] [unique] */,
10449 struct samr_CryptPassword *_password3 /* [in] [unique] */,
10450 struct samr_DomInfo1 **_dominfo /* [out] [ref] */,
10451 struct samr_ChangeReject **_reject /* [out] [ref] */)
10452 {
10453 struct tevent_req *req;
10454 struct rpccli_samr_ChangePasswordUser3_state *state;
10455 struct tevent_req *subreq;
10456
10457 req = tevent_req_create(mem_ctx, &state,
10458 struct rpccli_samr_ChangePasswordUser3_state);
10459 if (req == NULL) {
10460 return NULL;
10461 }
10462 state->out_mem_ctx = NULL;
10463 state->dispatch_recv = cli->dispatch_recv;
10464
10465 /* In parameters */
10466 state->orig.in.server = _server;
10467 state->orig.in.account = _account;
10468 state->orig.in.nt_password = _nt_password;
10469 state->orig.in.nt_verifier = _nt_verifier;
10470 state->orig.in.lm_change = _lm_change;
10471 state->orig.in.lm_password = _lm_password;
10472 state->orig.in.lm_verifier = _lm_verifier;
10473 state->orig.in.password3 = _password3;
10474
10475 /* Out parameters */
10476 state->orig.out.dominfo = _dominfo;
10477 state->orig.out.reject = _reject;
10478
10479 /* Result */
10480 ZERO_STRUCT(state->orig.out.result);
10481
10482 if (DEBUGLEVEL >= 10) {
10483 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser3, &state->orig);
10484 }
10485
10486 state->out_mem_ctx = talloc_named_const(state, 0,
10487 "rpccli_samr_ChangePasswordUser3_out_memory");
10488 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10489 return tevent_req_post(req, ev);
10490 }
10491
10492 /* make a temporary copy, that we pass to the dispatch function */
10493 state->tmp = state->orig;
10494
10495 subreq = cli->dispatch_send(state, ev, cli,
10496 &ndr_table_samr,
10497 NDR_SAMR_CHANGEPASSWORDUSER3,
10498 &state->tmp);
10499 if (tevent_req_nomem(subreq, req)) {
10500 return tevent_req_post(req, ev);
10501 }
10502 tevent_req_set_callback(subreq, rpccli_samr_ChangePasswordUser3_done, req);
10503 return req;
10504 }
10505
10506 static void rpccli_samr_ChangePasswordUser3_done(struct tevent_req *subreq)
10507 {
10508 struct tevent_req *req = tevent_req_callback_data(
10509 subreq, struct tevent_req);
10510 struct rpccli_samr_ChangePasswordUser3_state *state = tevent_req_data(
10511 req, struct rpccli_samr_ChangePasswordUser3_state);
10512 NTSTATUS status;
10513 TALLOC_CTX *mem_ctx;
10514
10515 if (state->out_mem_ctx) {
10516 mem_ctx = state->out_mem_ctx;
10517 } else {
10518 mem_ctx = state;
10519 }
10520
10521 status = state->dispatch_recv(subreq, mem_ctx);
10522 TALLOC_FREE(subreq);
10523 if (!NT_STATUS_IS_OK(status)) {
10524 tevent_req_nterror(req, status);
10525 return;
10526 }
10527
10528 /* Copy out parameters */
10529 *state->orig.out.dominfo = *state->tmp.out.dominfo;
10530 *state->orig.out.reject = *state->tmp.out.reject;
10531
10532 /* Copy result */
10533 state->orig.out.result = state->tmp.out.result;
10534
10535 /* Reset temporary structure */
10536 ZERO_STRUCT(state->tmp);
10537
10538 if (DEBUGLEVEL >= 10) {
10539 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser3, &state->orig);
10540 }
10541
10542 tevent_req_done(req);
10543 }
10544
10545 NTSTATUS rpccli_samr_ChangePasswordUser3_recv(struct tevent_req *req,
10546 TALLOC_CTX *mem_ctx,
10547 NTSTATUS *result)
10548 {
10549 struct rpccli_samr_ChangePasswordUser3_state *state = tevent_req_data(
10550 req, struct rpccli_samr_ChangePasswordUser3_state);
10551 NTSTATUS status;
10552
10553 if (tevent_req_is_nterror(req, &status)) {
10554 tevent_req_received(req);
10555 return status;
10556 }
10557
10558 /* Steal possbile out parameters to the callers context */
10559 talloc_steal(mem_ctx, state->out_mem_ctx);
10560
10561 /* Return result */
10562 *result = state->orig.out.result;
10563
10564 tevent_req_received(req);
10565 return NT_STATUS_OK;
10566 }
10567
10568 NTSTATUS rpccli_samr_ChangePasswordUser3(struct rpc_pipe_client *cli,
10569 TALLOC_CTX *mem_ctx,
10570 struct lsa_String *server /* [in] [unique] */,
10571 struct lsa_String *account /* [in] [ref] */,
10572 struct samr_CryptPassword *nt_password /* [in] [unique] */,
10573 struct samr_Password *nt_verifier /* [in] [unique] */,
10574 uint8_t lm_change /* [in] */,
10575 struct samr_CryptPassword *lm_password /* [in] [unique] */,
10576 struct samr_Password *lm_verifier /* [in] [unique] */,
10577 struct samr_CryptPassword *password3 /* [in] [unique] */,
10578 struct samr_DomInfo1 **dominfo /* [out] [ref] */,
10579 struct samr_ChangeReject **reject /* [out] [ref] */)
10580 {
10581 struct samr_ChangePasswordUser3 r;
10582 NTSTATUS status;
10583
10584 /* In parameters */
10585 r.in.server = server;
10586 r.in.account = account;
10587 r.in.nt_password = nt_password;
10588 r.in.nt_verifier = nt_verifier;
10589 r.in.lm_change = lm_change;
10590 r.in.lm_password = lm_password;
10591 r.in.lm_verifier = lm_verifier;
10592 r.in.password3 = password3;
10593
10594 if (DEBUGLEVEL >= 10) {
10595 NDR_PRINT_IN_DEBUG(samr_ChangePasswordUser3, &r);
10596 }
10597
10598 status = cli->dispatch(cli,
10599 mem_ctx,
10600 &ndr_table_samr,
10601 NDR_SAMR_CHANGEPASSWORDUSER3,
10602 &r);
10603
10604 if (!NT_STATUS_IS_OK(status)) {
10605 return status;
10606 }
10607
10608 if (DEBUGLEVEL >= 10) {
10609 NDR_PRINT_OUT_DEBUG(samr_ChangePasswordUser3, &r);
10610 }
10611
10612 if (NT_STATUS_IS_ERR(status)) {
10613 return status;
10614 }
10615
10616 /* Return variables */
10617 *dominfo = *r.out.dominfo;
10618 *reject = *r.out.reject;
10619
10620 /* Return result */
10621 return r.out.result;
10622 }
10623
10624 struct rpccli_samr_Connect5_state {
10625 struct samr_Connect5 orig;
10626 struct samr_Connect5 tmp;
10627 TALLOC_CTX *out_mem_ctx;
10628 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10629 };
10630
10631 static void rpccli_samr_Connect5_done(struct tevent_req *subreq);
10632
10633 struct tevent_req *rpccli_samr_Connect5_send(TALLOC_CTX *mem_ctx,
10634 struct tevent_context *ev,
10635 struct rpc_pipe_client *cli,
10636 const char *_system_name /* [in] [unique,charset(UTF16)] */,
10637 uint32_t _access_mask /* [in] */,
10638 uint32_t _level_in /* [in] */,
10639 union samr_ConnectInfo *_info_in /* [in] [ref,switch_is(level_in)] */,
10640 uint32_t *_level_out /* [out] [ref] */,
10641 union samr_ConnectInfo *_info_out /* [out] [ref,switch_is(*level_out)] */,
10642 struct policy_handle *_connect_handle /* [out] [ref] */)
10643 {
10644 struct tevent_req *req;
10645 struct rpccli_samr_Connect5_state *state;
10646 struct tevent_req *subreq;
10647
10648 req = tevent_req_create(mem_ctx, &state,
10649 struct rpccli_samr_Connect5_state);
10650 if (req == NULL) {
10651 return NULL;
10652 }
10653 state->out_mem_ctx = NULL;
10654 state->dispatch_recv = cli->dispatch_recv;
10655
10656 /* In parameters */
10657 state->orig.in.system_name = _system_name;
10658 state->orig.in.access_mask = _access_mask;
10659 state->orig.in.level_in = _level_in;
10660 state->orig.in.info_in = _info_in;
10661
10662 /* Out parameters */
10663 state->orig.out.level_out = _level_out;
10664 state->orig.out.info_out = _info_out;
10665 state->orig.out.connect_handle = _connect_handle;
10666
10667 /* Result */
10668 ZERO_STRUCT(state->orig.out.result);
10669
10670 if (DEBUGLEVEL >= 10) {
10671 NDR_PRINT_IN_DEBUG(samr_Connect5, &state->orig);
10672 }
10673
10674 state->out_mem_ctx = talloc_named_const(state, 0,
10675 "rpccli_samr_Connect5_out_memory");
10676 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10677 return tevent_req_post(req, ev);
10678 }
10679
10680 /* make a temporary copy, that we pass to the dispatch function */
10681 state->tmp = state->orig;
10682
10683 subreq = cli->dispatch_send(state, ev, cli,
10684 &ndr_table_samr,
10685 NDR_SAMR_CONNECT5,
10686 &state->tmp);
10687 if (tevent_req_nomem(subreq, req)) {
10688 return tevent_req_post(req, ev);
10689 }
10690 tevent_req_set_callback(subreq, rpccli_samr_Connect5_done, req);
10691 return req;
10692 }
10693
10694 static void rpccli_samr_Connect5_done(struct tevent_req *subreq)
10695 {
10696 struct tevent_req *req = tevent_req_callback_data(
10697 subreq, struct tevent_req);
10698 struct rpccli_samr_Connect5_state *state = tevent_req_data(
10699 req, struct rpccli_samr_Connect5_state);
10700 NTSTATUS status;
10701 TALLOC_CTX *mem_ctx;
10702
10703 if (state->out_mem_ctx) {
10704 mem_ctx = state->out_mem_ctx;
10705 } else {
10706 mem_ctx = state;
10707 }
10708
10709 status = state->dispatch_recv(subreq, mem_ctx);
10710 TALLOC_FREE(subreq);
10711 if (!NT_STATUS_IS_OK(status)) {
10712 tevent_req_nterror(req, status);
10713 return;
10714 }
10715
10716 /* Copy out parameters */
10717 *state->orig.out.level_out = *state->tmp.out.level_out;
10718 *state->orig.out.info_out = *state->tmp.out.info_out;
10719 *state->orig.out.connect_handle = *state->tmp.out.connect_handle;
10720
10721 /* Copy result */
10722 state->orig.out.result = state->tmp.out.result;
10723
10724 /* Reset temporary structure */
10725 ZERO_STRUCT(state->tmp);
10726
10727 if (DEBUGLEVEL >= 10) {
10728 NDR_PRINT_OUT_DEBUG(samr_Connect5, &state->orig);
10729 }
10730
10731 tevent_req_done(req);
10732 }
10733
10734 NTSTATUS rpccli_samr_Connect5_recv(struct tevent_req *req,
10735 TALLOC_CTX *mem_ctx,
10736 NTSTATUS *result)
10737 {
10738 struct rpccli_samr_Connect5_state *state = tevent_req_data(
10739 req, struct rpccli_samr_Connect5_state);
10740 NTSTATUS status;
10741
10742 if (tevent_req_is_nterror(req, &status)) {
10743 tevent_req_received(req);
10744 return status;
10745 }
10746
10747 /* Steal possbile out parameters to the callers context */
10748 talloc_steal(mem_ctx, state->out_mem_ctx);
10749
10750 /* Return result */
10751 *result = state->orig.out.result;
10752
10753 tevent_req_received(req);
10754 return NT_STATUS_OK;
10755 }
10756
10757 NTSTATUS rpccli_samr_Connect5(struct rpc_pipe_client *cli,
10758 TALLOC_CTX *mem_ctx,
10759 const char *system_name /* [in] [unique,charset(UTF16)] */,
10760 uint32_t access_mask /* [in] */,
10761 uint32_t level_in /* [in] */,
10762 union samr_ConnectInfo *info_in /* [in] [ref,switch_is(level_in)] */,
10763 uint32_t *level_out /* [out] [ref] */,
10764 union samr_ConnectInfo *info_out /* [out] [ref,switch_is(*level_out)] */,
10765 struct policy_handle *connect_handle /* [out] [ref] */)
10766 {
10767 struct samr_Connect5 r;
10768 NTSTATUS status;
10769
10770 /* In parameters */
10771 r.in.system_name = system_name;
10772 r.in.access_mask = access_mask;
10773 r.in.level_in = level_in;
10774 r.in.info_in = info_in;
10775
10776 if (DEBUGLEVEL >= 10) {
10777 NDR_PRINT_IN_DEBUG(samr_Connect5, &r);
10778 }
10779
10780 status = cli->dispatch(cli,
10781 mem_ctx,
10782 &ndr_table_samr,
10783 NDR_SAMR_CONNECT5,
10784 &r);
10785
10786 if (!NT_STATUS_IS_OK(status)) {
10787 return status;
10788 }
10789
10790 if (DEBUGLEVEL >= 10) {
10791 NDR_PRINT_OUT_DEBUG(samr_Connect5, &r);
10792 }
10793
10794 if (NT_STATUS_IS_ERR(status)) {
10795 return status;
10796 }
10797
10798 /* Return variables */
10799 *level_out = *r.out.level_out;
10800 *info_out = *r.out.info_out;
10801 *connect_handle = *r.out.connect_handle;
10802
10803 /* Return result */
10804 return r.out.result;
10805 }
10806
10807 struct rpccli_samr_RidToSid_state {
10808 struct samr_RidToSid orig;
10809 struct samr_RidToSid tmp;
10810 TALLOC_CTX *out_mem_ctx;
10811 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10812 };
10813
10814 static void rpccli_samr_RidToSid_done(struct tevent_req *subreq);
10815
10816 struct tevent_req *rpccli_samr_RidToSid_send(TALLOC_CTX *mem_ctx,
10817 struct tevent_context *ev,
10818 struct rpc_pipe_client *cli,
10819 struct policy_handle *_domain_handle /* [in] [ref] */,
10820 uint32_t _rid /* [in] */,
10821 struct dom_sid2 **_sid /* [out] [ref] */)
10822 {
10823 struct tevent_req *req;
10824 struct rpccli_samr_RidToSid_state *state;
10825 struct tevent_req *subreq;
10826
10827 req = tevent_req_create(mem_ctx, &state,
10828 struct rpccli_samr_RidToSid_state);
10829 if (req == NULL) {
10830 return NULL;
10831 }
10832 state->out_mem_ctx = NULL;
10833 state->dispatch_recv = cli->dispatch_recv;
10834
10835 /* In parameters */
10836 state->orig.in.domain_handle = _domain_handle;
10837 state->orig.in.rid = _rid;
10838
10839 /* Out parameters */
10840 state->orig.out.sid = _sid;
10841
10842 /* Result */
10843 ZERO_STRUCT(state->orig.out.result);
10844
10845 if (DEBUGLEVEL >= 10) {
10846 NDR_PRINT_IN_DEBUG(samr_RidToSid, &state->orig);
10847 }
10848
10849 state->out_mem_ctx = talloc_named_const(state, 0,
10850 "rpccli_samr_RidToSid_out_memory");
10851 if (tevent_req_nomem(state->out_mem_ctx, req)) {
10852 return tevent_req_post(req, ev);
10853 }
10854
10855 /* make a temporary copy, that we pass to the dispatch function */
10856 state->tmp = state->orig;
10857
10858 subreq = cli->dispatch_send(state, ev, cli,
10859 &ndr_table_samr,
10860 NDR_SAMR_RIDTOSID,
10861 &state->tmp);
10862 if (tevent_req_nomem(subreq, req)) {
10863 return tevent_req_post(req, ev);
10864 }
10865 tevent_req_set_callback(subreq, rpccli_samr_RidToSid_done, req);
10866 return req;
10867 }
10868
10869 static void rpccli_samr_RidToSid_done(struct tevent_req *subreq)
10870 {
10871 struct tevent_req *req = tevent_req_callback_data(
10872 subreq, struct tevent_req);
10873 struct rpccli_samr_RidToSid_state *state = tevent_req_data(
10874 req, struct rpccli_samr_RidToSid_state);
10875 NTSTATUS status;
10876 TALLOC_CTX *mem_ctx;
10877
10878 if (state->out_mem_ctx) {
10879 mem_ctx = state->out_mem_ctx;
10880 } else {
10881 mem_ctx = state;
10882 }
10883
10884 status = state->dispatch_recv(subreq, mem_ctx);
10885 TALLOC_FREE(subreq);
10886 if (!NT_STATUS_IS_OK(status)) {
10887 tevent_req_nterror(req, status);
10888 return;
10889 }
10890
10891 /* Copy out parameters */
10892 *state->orig.out.sid = *state->tmp.out.sid;
10893
10894 /* Copy result */
10895 state->orig.out.result = state->tmp.out.result;
10896
10897 /* Reset temporary structure */
10898 ZERO_STRUCT(state->tmp);
10899
10900 if (DEBUGLEVEL >= 10) {
10901 NDR_PRINT_OUT_DEBUG(samr_RidToSid, &state->orig);
10902 }
10903
10904 tevent_req_done(req);
10905 }
10906
10907 NTSTATUS rpccli_samr_RidToSid_recv(struct tevent_req *req,
10908 TALLOC_CTX *mem_ctx,
10909 NTSTATUS *result)
10910 {
10911 struct rpccli_samr_RidToSid_state *state = tevent_req_data(
10912 req, struct rpccli_samr_RidToSid_state);
10913 NTSTATUS status;
10914
10915 if (tevent_req_is_nterror(req, &status)) {
10916 tevent_req_received(req);
10917 return status;
10918 }
10919
10920 /* Steal possbile out parameters to the callers context */
10921 talloc_steal(mem_ctx, state->out_mem_ctx);
10922
10923 /* Return result */
10924 *result = state->orig.out.result;
10925
10926 tevent_req_received(req);
10927 return NT_STATUS_OK;
10928 }
10929
10930 NTSTATUS rpccli_samr_RidToSid(struct rpc_pipe_client *cli,
10931 TALLOC_CTX *mem_ctx,
10932 struct policy_handle *domain_handle /* [in] [ref] */,
10933 uint32_t rid /* [in] */,
10934 struct dom_sid2 **sid /* [out] [ref] */)
10935 {
10936 struct samr_RidToSid r;
10937 NTSTATUS status;
10938
10939 /* In parameters */
10940 r.in.domain_handle = domain_handle;
10941 r.in.rid = rid;
10942
10943 if (DEBUGLEVEL >= 10) {
10944 NDR_PRINT_IN_DEBUG(samr_RidToSid, &r);
10945 }
10946
10947 status = cli->dispatch(cli,
10948 mem_ctx,
10949 &ndr_table_samr,
10950 NDR_SAMR_RIDTOSID,
10951 &r);
10952
10953 if (!NT_STATUS_IS_OK(status)) {
10954 return status;
10955 }
10956
10957 if (DEBUGLEVEL >= 10) {
10958 NDR_PRINT_OUT_DEBUG(samr_RidToSid, &r);
10959 }
10960
10961 if (NT_STATUS_IS_ERR(status)) {
10962 return status;
10963 }
10964
10965 /* Return variables */
10966 *sid = *r.out.sid;
10967
10968 /* Return result */
10969 return r.out.result;
10970 }
10971
10972 struct rpccli_samr_SetDsrmPassword_state {
10973 struct samr_SetDsrmPassword orig;
10974 struct samr_SetDsrmPassword tmp;
10975 TALLOC_CTX *out_mem_ctx;
10976 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
10977 };
10978
10979 static void rpccli_samr_SetDsrmPassword_done(struct tevent_req *subreq);
10980
10981 struct tevent_req *rpccli_samr_SetDsrmPassword_send(TALLOC_CTX *mem_ctx,
10982 struct tevent_context *ev,
10983 struct rpc_pipe_client *cli,
10984 struct lsa_String *_name /* [in] [unique] */,
10985 uint32_t _unknown /* [in] */,
10986 struct samr_Password *_hash /* [in] [unique] */)
10987 {
10988 struct tevent_req *req;
10989 struct rpccli_samr_SetDsrmPassword_state *state;
10990 struct tevent_req *subreq;
10991
10992 req = tevent_req_create(mem_ctx, &state,
10993 struct rpccli_samr_SetDsrmPassword_state);
10994 if (req == NULL) {
10995 return NULL;
10996 }
10997 state->out_mem_ctx = NULL;
10998 state->dispatch_recv = cli->dispatch_recv;
10999
11000 /* In parameters */
11001 state->orig.in.name = _name;
11002 state->orig.in.unknown = _unknown;
11003 state->orig.in.hash = _hash;
11004
11005 /* Out parameters */
11006
11007 /* Result */
11008 ZERO_STRUCT(state->orig.out.result);
11009
11010 if (DEBUGLEVEL >= 10) {
11011 NDR_PRINT_IN_DEBUG(samr_SetDsrmPassword, &state->orig);
11012 }
11013
11014 /* make a temporary copy, that we pass to the dispatch function */
11015 state->tmp = state->orig;
11016
11017 subreq = cli->dispatch_send(state, ev, cli,
11018 &ndr_table_samr,
11019 NDR_SAMR_SETDSRMPASSWORD,
11020 &state->tmp);
11021 if (tevent_req_nomem(subreq, req)) {
11022 return tevent_req_post(req, ev);
11023 }
11024 tevent_req_set_callback(subreq, rpccli_samr_SetDsrmPassword_done, req);
11025 return req;
11026 }
11027
11028 static void rpccli_samr_SetDsrmPassword_done(struct tevent_req *subreq)
11029 {
11030 struct tevent_req *req = tevent_req_callback_data(
11031 subreq, struct tevent_req);
11032 struct rpccli_samr_SetDsrmPassword_state *state = tevent_req_data(
11033 req, struct rpccli_samr_SetDsrmPassword_state);
11034 NTSTATUS status;
11035 TALLOC_CTX *mem_ctx;
11036
11037 if (state->out_mem_ctx) {
11038 mem_ctx = state->out_mem_ctx;
11039 } else {
11040 mem_ctx = state;
11041 }
11042
11043 status = state->dispatch_recv(subreq, mem_ctx);
11044 TALLOC_FREE(subreq);
11045 if (!NT_STATUS_IS_OK(status)) {
11046 tevent_req_nterror(req, status);
11047 return;
11048 }
11049
11050 /* Copy out parameters */
11051
11052 /* Copy result */
11053 state->orig.out.result = state->tmp.out.result;
11054
11055 /* Reset temporary structure */
11056 ZERO_STRUCT(state->tmp);
11057
11058 if (DEBUGLEVEL >= 10) {
11059 NDR_PRINT_OUT_DEBUG(samr_SetDsrmPassword, &state->orig);
11060 }
11061
11062 tevent_req_done(req);
11063 }
11064
11065 NTSTATUS rpccli_samr_SetDsrmPassword_recv(struct tevent_req *req,
11066 TALLOC_CTX *mem_ctx,
11067 NTSTATUS *result)
11068 {
11069 struct rpccli_samr_SetDsrmPassword_state *state = tevent_req_data(
11070 req, struct rpccli_samr_SetDsrmPassword_state);
11071 NTSTATUS status;
11072
11073 if (tevent_req_is_nterror(req, &status)) {
11074 tevent_req_received(req);
11075 return status;
11076 }
11077
11078 /* Steal possbile out parameters to the callers context */
11079 talloc_steal(mem_ctx, state->out_mem_ctx);
11080
11081 /* Return result */
11082 *result = state->orig.out.result;
11083
11084 tevent_req_received(req);
11085 return NT_STATUS_OK;
11086 }
11087
11088 NTSTATUS rpccli_samr_SetDsrmPassword(struct rpc_pipe_client *cli,
11089 TALLOC_CTX *mem_ctx,
11090 struct lsa_String *name /* [in] [unique] */,
11091 uint32_t unknown /* [in] */,
11092 struct samr_Password *hash /* [in] [unique] */)
11093 {
11094 struct samr_SetDsrmPassword r;
11095 NTSTATUS status;
11096
11097 /* In parameters */
11098 r.in.name = name;
11099 r.in.unknown = unknown;
11100 r.in.hash = hash;
11101
11102 if (DEBUGLEVEL >= 10) {
11103 NDR_PRINT_IN_DEBUG(samr_SetDsrmPassword, &r);
11104 }
11105
11106 status = cli->dispatch(cli,
11107 mem_ctx,
11108 &ndr_table_samr,
11109 NDR_SAMR_SETDSRMPASSWORD,
11110 &r);
11111
11112 if (!NT_STATUS_IS_OK(status)) {
11113 return status;
11114 }
11115
11116 if (DEBUGLEVEL >= 10) {
11117 NDR_PRINT_OUT_DEBUG(samr_SetDsrmPassword, &r);
11118 }
11119
11120 if (NT_STATUS_IS_ERR(status)) {
11121 return status;
11122 }
11123
11124 /* Return variables */
11125
11126 /* Return result */
11127 return r.out.result;
11128 }
11129
11130 struct rpccli_samr_ValidatePassword_state {
11131 struct samr_ValidatePassword orig;
11132 struct samr_ValidatePassword tmp;
11133 TALLOC_CTX *out_mem_ctx;
11134 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
11135 };
11136
11137 static void rpccli_samr_ValidatePassword_done(struct tevent_req *subreq);
11138
11139 struct tevent_req *rpccli_samr_ValidatePassword_send(TALLOC_CTX *mem_ctx,
11140 struct tevent_context *ev,
11141 struct rpc_pipe_client *cli,
11142 enum samr_ValidatePasswordLevel _level /* [in] */,
11143 union samr_ValidatePasswordReq *_req /* [in] [ref,switch_is(level)] */,
11144 union samr_ValidatePasswordRep **_rep /* [out] [ref,switch_is(level)] */)
11145 {
11146 struct tevent_req *req;
11147 struct rpccli_samr_ValidatePassword_state *state;
11148 struct tevent_req *subreq;
11149
11150 req = tevent_req_create(mem_ctx, &state,
11151 struct rpccli_samr_ValidatePassword_state);
11152 if (req == NULL) {
11153 return NULL;
11154 }
11155 state->out_mem_ctx = NULL;
11156 state->dispatch_recv = cli->dispatch_recv;
11157
11158 /* In parameters */
11159 state->orig.in.level = _level;
11160 state->orig.in.req = _req;
11161
11162 /* Out parameters */
11163 state->orig.out.rep = _rep;
11164
11165 /* Result */
11166 ZERO_STRUCT(state->orig.out.result);
11167
11168 if (DEBUGLEVEL >= 10) {
11169 NDR_PRINT_IN_DEBUG(samr_ValidatePassword, &state->orig);
11170 }
11171
11172 state->out_mem_ctx = talloc_named_const(state, 0,
11173 "rpccli_samr_ValidatePassword_out_memory");
11174 if (tevent_req_nomem(state->out_mem_ctx, req)) {
11175 return tevent_req_post(req, ev);
11176 }
11177
11178 /* make a temporary copy, that we pass to the dispatch function */
11179 state->tmp = state->orig;
11180
11181 subreq = cli->dispatch_send(state, ev, cli,
11182 &ndr_table_samr,
11183 NDR_SAMR_VALIDATEPASSWORD,
11184 &state->tmp);
11185 if (tevent_req_nomem(subreq, req)) {
11186 return tevent_req_post(req, ev);
11187 }
11188 tevent_req_set_callback(subreq, rpccli_samr_ValidatePassword_done, req);
11189 return req;
11190 }
11191
11192 static void rpccli_samr_ValidatePassword_done(struct tevent_req *subreq)
11193 {
11194 struct tevent_req *req = tevent_req_callback_data(
11195 subreq, struct tevent_req);
11196 struct rpccli_samr_ValidatePassword_state *state = tevent_req_data(
11197 req, struct rpccli_samr_ValidatePassword_state);
11198 NTSTATUS status;
11199 TALLOC_CTX *mem_ctx;
11200
11201 if (state->out_mem_ctx) {
11202 mem_ctx = state->out_mem_ctx;
11203 } else {
11204 mem_ctx = state;
11205 }
11206
11207 status = state->dispatch_recv(subreq, mem_ctx);
11208 TALLOC_FREE(subreq);
11209 if (!NT_STATUS_IS_OK(status)) {
11210 tevent_req_nterror(req, status);
11211 return;
11212 }
11213
11214 /* Copy out parameters */
11215 *state->orig.out.rep = *state->tmp.out.rep;
11216
11217 /* Copy result */
11218 state->orig.out.result = state->tmp.out.result;
11219
11220 /* Reset temporary structure */
11221 ZERO_STRUCT(state->tmp);
11222
11223 if (DEBUGLEVEL >= 10) {
11224 NDR_PRINT_OUT_DEBUG(samr_ValidatePassword, &state->orig);
11225 }
11226
11227 tevent_req_done(req);
11228 }
11229
11230 NTSTATUS rpccli_samr_ValidatePassword_recv(struct tevent_req *req,
11231 TALLOC_CTX *mem_ctx,
11232 NTSTATUS *result)
11233 {
11234 struct rpccli_samr_ValidatePassword_state *state = tevent_req_data(
11235 req, struct rpccli_samr_ValidatePassword_state);
11236 NTSTATUS status;
11237
11238 if (tevent_req_is_nterror(req, &status)) {
11239 tevent_req_received(req);
11240 return status;
11241 }
11242
11243 /* Steal possbile out parameters to the callers context */
11244 talloc_steal(mem_ctx, state->out_mem_ctx);
11245
11246 /* Return result */
11247 *result = state->orig.out.result;
11248
11249 tevent_req_received(req);
11250 return NT_STATUS_OK;
11251 }
11252
11253 NTSTATUS rpccli_samr_ValidatePassword(struct rpc_pipe_client *cli,
11254 TALLOC_CTX *mem_ctx,
11255 enum samr_ValidatePasswordLevel level /* [in] */,
11256 union samr_ValidatePasswordReq *req /* [in] [ref,switch_is(level)] */,
11257 union samr_ValidatePasswordRep **rep /* [out] [ref,switch_is(level)] */)
11258 {
11259 struct samr_ValidatePassword r;
11260 NTSTATUS status;
11261
11262 /* In parameters */
11263 r.in.level = level;
11264 r.in.req = req;
11265
11266 if (DEBUGLEVEL >= 10) {
11267 NDR_PRINT_IN_DEBUG(samr_ValidatePassword, &r);
11268 }
11269
11270 status = cli->dispatch(cli,
11271 mem_ctx,
11272 &ndr_table_samr,
11273 NDR_SAMR_VALIDATEPASSWORD,
11274 &r);
11275
11276 if (!NT_STATUS_IS_OK(status)) {
11277 return status;
11278 }
11279
11280 if (DEBUGLEVEL >= 10) {
11281 NDR_PRINT_OUT_DEBUG(samr_ValidatePassword, &r);
11282 }
11283
11284 if (NT_STATUS_IS_ERR(status)) {
11285 return status;
11286 }
11287
11288 /* Return variables */
11289 *rep = *r.out.rep;
11290
11291 /* Return result */
11292 return r.out.result;
11293 }
11294
aatanasov's samba4 branch