?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:dsdb/schema: add inftrastructure for dsdb_validate_ldb()
[Samba/gebeck_regimport.git] / librpc / gen_ndr / cli_winreg.c
blob426454292ecbc13978daf7f2afe8bb001dd20863
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_winreg.h"
8
9 struct rpccli_winreg_OpenHKCR_state {
10 struct winreg_OpenHKCR orig;
11 struct winreg_OpenHKCR 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_winreg_OpenHKCR_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_winreg_OpenHKCR_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 *_handle /* [out] [ref] */)
24 {
25 struct tevent_req *req;
26 struct rpccli_winreg_OpenHKCR_state *state;
27 struct tevent_req *subreq;
28
29 req = tevent_req_create(mem_ctx, &state,
30 struct rpccli_winreg_OpenHKCR_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.handle = _handle;
43
44 /* Result */
45 ZERO_STRUCT(state->orig.out.result);
46
47 state->out_mem_ctx = talloc_named_const(state, 0,
48 "rpccli_winreg_OpenHKCR_out_memory");
49 if (tevent_req_nomem(state->out_mem_ctx, req)) {
50 return tevent_req_post(req, ev);
51 }
52
53 /* make a temporary copy, that we pass to the dispatch function */
54 state->tmp = state->orig;
55
56 subreq = cli->dispatch_send(state, ev, cli,
57 &ndr_table_winreg,
58 NDR_WINREG_OPENHKCR,
59 &state->tmp);
60 if (tevent_req_nomem(subreq, req)) {
61 return tevent_req_post(req, ev);
62 }
63 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCR_done, req);
64 return req;
65 }
66
67 static void rpccli_winreg_OpenHKCR_done(struct tevent_req *subreq)
68 {
69 struct tevent_req *req = tevent_req_callback_data(
70 subreq, struct tevent_req);
71 struct rpccli_winreg_OpenHKCR_state *state = tevent_req_data(
72 req, struct rpccli_winreg_OpenHKCR_state);
73 NTSTATUS status;
74 TALLOC_CTX *mem_ctx;
75
76 if (state->out_mem_ctx) {
77 mem_ctx = state->out_mem_ctx;
78 } else {
79 mem_ctx = state;
80 }
81
82 status = state->dispatch_recv(subreq, mem_ctx);
83 TALLOC_FREE(subreq);
84 if (!NT_STATUS_IS_OK(status)) {
85 tevent_req_nterror(req, status);
86 return;
87 }
88
89 /* Copy out parameters */
90 *state->orig.out.handle = *state->tmp.out.handle;
91
92 /* Copy result */
93 state->orig.out.result = state->tmp.out.result;
94
95 /* Reset temporary structure */
96 ZERO_STRUCT(state->tmp);
97
98 tevent_req_done(req);
99 }
100
101 NTSTATUS rpccli_winreg_OpenHKCR_recv(struct tevent_req *req,
102 TALLOC_CTX *mem_ctx,
103 WERROR *result)
104 {
105 struct rpccli_winreg_OpenHKCR_state *state = tevent_req_data(
106 req, struct rpccli_winreg_OpenHKCR_state);
107 NTSTATUS status;
108
109 if (tevent_req_is_nterror(req, &status)) {
110 tevent_req_received(req);
111 return status;
112 }
113
114 /* Steal possbile out parameters to the callers context */
115 talloc_steal(mem_ctx, state->out_mem_ctx);
116
117 /* Return result */
118 *result = state->orig.out.result;
119
120 tevent_req_received(req);
121 return NT_STATUS_OK;
122 }
123
124 NTSTATUS rpccli_winreg_OpenHKCR(struct rpc_pipe_client *cli,
125 TALLOC_CTX *mem_ctx,
126 uint16_t *system_name /* [in] [unique] */,
127 uint32_t access_mask /* [in] */,
128 struct policy_handle *handle /* [out] [ref] */,
129 WERROR *werror)
130 {
131 struct winreg_OpenHKCR r;
132 NTSTATUS status;
133
134 /* In parameters */
135 r.in.system_name = system_name;
136 r.in.access_mask = access_mask;
137
138 status = cli->dispatch(cli,
139 mem_ctx,
140 &ndr_table_winreg,
141 NDR_WINREG_OPENHKCR,
142 &r);
143
144 if (!NT_STATUS_IS_OK(status)) {
145 return status;
146 }
147
148 if (NT_STATUS_IS_ERR(status)) {
149 return status;
150 }
151
152 /* Return variables */
153 *handle = *r.out.handle;
154
155 /* Return result */
156 if (werror) {
157 *werror = r.out.result;
158 }
159
160 return werror_to_ntstatus(r.out.result);
161 }
162
163 struct rpccli_winreg_OpenHKCU_state {
164 struct winreg_OpenHKCU orig;
165 struct winreg_OpenHKCU tmp;
166 TALLOC_CTX *out_mem_ctx;
167 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
168 };
169
170 static void rpccli_winreg_OpenHKCU_done(struct tevent_req *subreq);
171
172 struct tevent_req *rpccli_winreg_OpenHKCU_send(TALLOC_CTX *mem_ctx,
173 struct tevent_context *ev,
174 struct rpc_pipe_client *cli,
175 uint16_t *_system_name /* [in] [unique] */,
176 uint32_t _access_mask /* [in] */,
177 struct policy_handle *_handle /* [out] [ref] */)
178 {
179 struct tevent_req *req;
180 struct rpccli_winreg_OpenHKCU_state *state;
181 struct tevent_req *subreq;
182
183 req = tevent_req_create(mem_ctx, &state,
184 struct rpccli_winreg_OpenHKCU_state);
185 if (req == NULL) {
186 return NULL;
187 }
188 state->out_mem_ctx = NULL;
189 state->dispatch_recv = cli->dispatch_recv;
190
191 /* In parameters */
192 state->orig.in.system_name = _system_name;
193 state->orig.in.access_mask = _access_mask;
194
195 /* Out parameters */
196 state->orig.out.handle = _handle;
197
198 /* Result */
199 ZERO_STRUCT(state->orig.out.result);
200
201 state->out_mem_ctx = talloc_named_const(state, 0,
202 "rpccli_winreg_OpenHKCU_out_memory");
203 if (tevent_req_nomem(state->out_mem_ctx, req)) {
204 return tevent_req_post(req, ev);
205 }
206
207 /* make a temporary copy, that we pass to the dispatch function */
208 state->tmp = state->orig;
209
210 subreq = cli->dispatch_send(state, ev, cli,
211 &ndr_table_winreg,
212 NDR_WINREG_OPENHKCU,
213 &state->tmp);
214 if (tevent_req_nomem(subreq, req)) {
215 return tevent_req_post(req, ev);
216 }
217 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCU_done, req);
218 return req;
219 }
220
221 static void rpccli_winreg_OpenHKCU_done(struct tevent_req *subreq)
222 {
223 struct tevent_req *req = tevent_req_callback_data(
224 subreq, struct tevent_req);
225 struct rpccli_winreg_OpenHKCU_state *state = tevent_req_data(
226 req, struct rpccli_winreg_OpenHKCU_state);
227 NTSTATUS status;
228 TALLOC_CTX *mem_ctx;
229
230 if (state->out_mem_ctx) {
231 mem_ctx = state->out_mem_ctx;
232 } else {
233 mem_ctx = state;
234 }
235
236 status = state->dispatch_recv(subreq, mem_ctx);
237 TALLOC_FREE(subreq);
238 if (!NT_STATUS_IS_OK(status)) {
239 tevent_req_nterror(req, status);
240 return;
241 }
242
243 /* Copy out parameters */
244 *state->orig.out.handle = *state->tmp.out.handle;
245
246 /* Copy result */
247 state->orig.out.result = state->tmp.out.result;
248
249 /* Reset temporary structure */
250 ZERO_STRUCT(state->tmp);
251
252 tevent_req_done(req);
253 }
254
255 NTSTATUS rpccli_winreg_OpenHKCU_recv(struct tevent_req *req,
256 TALLOC_CTX *mem_ctx,
257 WERROR *result)
258 {
259 struct rpccli_winreg_OpenHKCU_state *state = tevent_req_data(
260 req, struct rpccli_winreg_OpenHKCU_state);
261 NTSTATUS status;
262
263 if (tevent_req_is_nterror(req, &status)) {
264 tevent_req_received(req);
265 return status;
266 }
267
268 /* Steal possbile out parameters to the callers context */
269 talloc_steal(mem_ctx, state->out_mem_ctx);
270
271 /* Return result */
272 *result = state->orig.out.result;
273
274 tevent_req_received(req);
275 return NT_STATUS_OK;
276 }
277
278 NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli,
279 TALLOC_CTX *mem_ctx,
280 uint16_t *system_name /* [in] [unique] */,
281 uint32_t access_mask /* [in] */,
282 struct policy_handle *handle /* [out] [ref] */,
283 WERROR *werror)
284 {
285 struct winreg_OpenHKCU r;
286 NTSTATUS status;
287
288 /* In parameters */
289 r.in.system_name = system_name;
290 r.in.access_mask = access_mask;
291
292 status = cli->dispatch(cli,
293 mem_ctx,
294 &ndr_table_winreg,
295 NDR_WINREG_OPENHKCU,
296 &r);
297
298 if (!NT_STATUS_IS_OK(status)) {
299 return status;
300 }
301
302 if (NT_STATUS_IS_ERR(status)) {
303 return status;
304 }
305
306 /* Return variables */
307 *handle = *r.out.handle;
308
309 /* Return result */
310 if (werror) {
311 *werror = r.out.result;
312 }
313
314 return werror_to_ntstatus(r.out.result);
315 }
316
317 struct rpccli_winreg_OpenHKLM_state {
318 struct winreg_OpenHKLM orig;
319 struct winreg_OpenHKLM tmp;
320 TALLOC_CTX *out_mem_ctx;
321 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
322 };
323
324 static void rpccli_winreg_OpenHKLM_done(struct tevent_req *subreq);
325
326 struct tevent_req *rpccli_winreg_OpenHKLM_send(TALLOC_CTX *mem_ctx,
327 struct tevent_context *ev,
328 struct rpc_pipe_client *cli,
329 uint16_t *_system_name /* [in] [unique] */,
330 uint32_t _access_mask /* [in] */,
331 struct policy_handle *_handle /* [out] [ref] */)
332 {
333 struct tevent_req *req;
334 struct rpccli_winreg_OpenHKLM_state *state;
335 struct tevent_req *subreq;
336
337 req = tevent_req_create(mem_ctx, &state,
338 struct rpccli_winreg_OpenHKLM_state);
339 if (req == NULL) {
340 return NULL;
341 }
342 state->out_mem_ctx = NULL;
343 state->dispatch_recv = cli->dispatch_recv;
344
345 /* In parameters */
346 state->orig.in.system_name = _system_name;
347 state->orig.in.access_mask = _access_mask;
348
349 /* Out parameters */
350 state->orig.out.handle = _handle;
351
352 /* Result */
353 ZERO_STRUCT(state->orig.out.result);
354
355 state->out_mem_ctx = talloc_named_const(state, 0,
356 "rpccli_winreg_OpenHKLM_out_memory");
357 if (tevent_req_nomem(state->out_mem_ctx, req)) {
358 return tevent_req_post(req, ev);
359 }
360
361 /* make a temporary copy, that we pass to the dispatch function */
362 state->tmp = state->orig;
363
364 subreq = cli->dispatch_send(state, ev, cli,
365 &ndr_table_winreg,
366 NDR_WINREG_OPENHKLM,
367 &state->tmp);
368 if (tevent_req_nomem(subreq, req)) {
369 return tevent_req_post(req, ev);
370 }
371 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKLM_done, req);
372 return req;
373 }
374
375 static void rpccli_winreg_OpenHKLM_done(struct tevent_req *subreq)
376 {
377 struct tevent_req *req = tevent_req_callback_data(
378 subreq, struct tevent_req);
379 struct rpccli_winreg_OpenHKLM_state *state = tevent_req_data(
380 req, struct rpccli_winreg_OpenHKLM_state);
381 NTSTATUS status;
382 TALLOC_CTX *mem_ctx;
383
384 if (state->out_mem_ctx) {
385 mem_ctx = state->out_mem_ctx;
386 } else {
387 mem_ctx = state;
388 }
389
390 status = state->dispatch_recv(subreq, mem_ctx);
391 TALLOC_FREE(subreq);
392 if (!NT_STATUS_IS_OK(status)) {
393 tevent_req_nterror(req, status);
394 return;
395 }
396
397 /* Copy out parameters */
398 *state->orig.out.handle = *state->tmp.out.handle;
399
400 /* Copy result */
401 state->orig.out.result = state->tmp.out.result;
402
403 /* Reset temporary structure */
404 ZERO_STRUCT(state->tmp);
405
406 tevent_req_done(req);
407 }
408
409 NTSTATUS rpccli_winreg_OpenHKLM_recv(struct tevent_req *req,
410 TALLOC_CTX *mem_ctx,
411 WERROR *result)
412 {
413 struct rpccli_winreg_OpenHKLM_state *state = tevent_req_data(
414 req, struct rpccli_winreg_OpenHKLM_state);
415 NTSTATUS status;
416
417 if (tevent_req_is_nterror(req, &status)) {
418 tevent_req_received(req);
419 return status;
420 }
421
422 /* Steal possbile out parameters to the callers context */
423 talloc_steal(mem_ctx, state->out_mem_ctx);
424
425 /* Return result */
426 *result = state->orig.out.result;
427
428 tevent_req_received(req);
429 return NT_STATUS_OK;
430 }
431
432 NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli,
433 TALLOC_CTX *mem_ctx,
434 uint16_t *system_name /* [in] [unique] */,
435 uint32_t access_mask /* [in] */,
436 struct policy_handle *handle /* [out] [ref] */,
437 WERROR *werror)
438 {
439 struct winreg_OpenHKLM r;
440 NTSTATUS status;
441
442 /* In parameters */
443 r.in.system_name = system_name;
444 r.in.access_mask = access_mask;
445
446 status = cli->dispatch(cli,
447 mem_ctx,
448 &ndr_table_winreg,
449 NDR_WINREG_OPENHKLM,
450 &r);
451
452 if (!NT_STATUS_IS_OK(status)) {
453 return status;
454 }
455
456 if (NT_STATUS_IS_ERR(status)) {
457 return status;
458 }
459
460 /* Return variables */
461 *handle = *r.out.handle;
462
463 /* Return result */
464 if (werror) {
465 *werror = r.out.result;
466 }
467
468 return werror_to_ntstatus(r.out.result);
469 }
470
471 struct rpccli_winreg_OpenHKPD_state {
472 struct winreg_OpenHKPD orig;
473 struct winreg_OpenHKPD tmp;
474 TALLOC_CTX *out_mem_ctx;
475 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
476 };
477
478 static void rpccli_winreg_OpenHKPD_done(struct tevent_req *subreq);
479
480 struct tevent_req *rpccli_winreg_OpenHKPD_send(TALLOC_CTX *mem_ctx,
481 struct tevent_context *ev,
482 struct rpc_pipe_client *cli,
483 uint16_t *_system_name /* [in] [unique] */,
484 uint32_t _access_mask /* [in] */,
485 struct policy_handle *_handle /* [out] [ref] */)
486 {
487 struct tevent_req *req;
488 struct rpccli_winreg_OpenHKPD_state *state;
489 struct tevent_req *subreq;
490
491 req = tevent_req_create(mem_ctx, &state,
492 struct rpccli_winreg_OpenHKPD_state);
493 if (req == NULL) {
494 return NULL;
495 }
496 state->out_mem_ctx = NULL;
497 state->dispatch_recv = cli->dispatch_recv;
498
499 /* In parameters */
500 state->orig.in.system_name = _system_name;
501 state->orig.in.access_mask = _access_mask;
502
503 /* Out parameters */
504 state->orig.out.handle = _handle;
505
506 /* Result */
507 ZERO_STRUCT(state->orig.out.result);
508
509 state->out_mem_ctx = talloc_named_const(state, 0,
510 "rpccli_winreg_OpenHKPD_out_memory");
511 if (tevent_req_nomem(state->out_mem_ctx, req)) {
512 return tevent_req_post(req, ev);
513 }
514
515 /* make a temporary copy, that we pass to the dispatch function */
516 state->tmp = state->orig;
517
518 subreq = cli->dispatch_send(state, ev, cli,
519 &ndr_table_winreg,
520 NDR_WINREG_OPENHKPD,
521 &state->tmp);
522 if (tevent_req_nomem(subreq, req)) {
523 return tevent_req_post(req, ev);
524 }
525 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPD_done, req);
526 return req;
527 }
528
529 static void rpccli_winreg_OpenHKPD_done(struct tevent_req *subreq)
530 {
531 struct tevent_req *req = tevent_req_callback_data(
532 subreq, struct tevent_req);
533 struct rpccli_winreg_OpenHKPD_state *state = tevent_req_data(
534 req, struct rpccli_winreg_OpenHKPD_state);
535 NTSTATUS status;
536 TALLOC_CTX *mem_ctx;
537
538 if (state->out_mem_ctx) {
539 mem_ctx = state->out_mem_ctx;
540 } else {
541 mem_ctx = state;
542 }
543
544 status = state->dispatch_recv(subreq, mem_ctx);
545 TALLOC_FREE(subreq);
546 if (!NT_STATUS_IS_OK(status)) {
547 tevent_req_nterror(req, status);
548 return;
549 }
550
551 /* Copy out parameters */
552 *state->orig.out.handle = *state->tmp.out.handle;
553
554 /* Copy result */
555 state->orig.out.result = state->tmp.out.result;
556
557 /* Reset temporary structure */
558 ZERO_STRUCT(state->tmp);
559
560 tevent_req_done(req);
561 }
562
563 NTSTATUS rpccli_winreg_OpenHKPD_recv(struct tevent_req *req,
564 TALLOC_CTX *mem_ctx,
565 WERROR *result)
566 {
567 struct rpccli_winreg_OpenHKPD_state *state = tevent_req_data(
568 req, struct rpccli_winreg_OpenHKPD_state);
569 NTSTATUS status;
570
571 if (tevent_req_is_nterror(req, &status)) {
572 tevent_req_received(req);
573 return status;
574 }
575
576 /* Steal possbile out parameters to the callers context */
577 talloc_steal(mem_ctx, state->out_mem_ctx);
578
579 /* Return result */
580 *result = state->orig.out.result;
581
582 tevent_req_received(req);
583 return NT_STATUS_OK;
584 }
585
586 NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli,
587 TALLOC_CTX *mem_ctx,
588 uint16_t *system_name /* [in] [unique] */,
589 uint32_t access_mask /* [in] */,
590 struct policy_handle *handle /* [out] [ref] */,
591 WERROR *werror)
592 {
593 struct winreg_OpenHKPD r;
594 NTSTATUS status;
595
596 /* In parameters */
597 r.in.system_name = system_name;
598 r.in.access_mask = access_mask;
599
600 status = cli->dispatch(cli,
601 mem_ctx,
602 &ndr_table_winreg,
603 NDR_WINREG_OPENHKPD,
604 &r);
605
606 if (!NT_STATUS_IS_OK(status)) {
607 return status;
608 }
609
610 if (NT_STATUS_IS_ERR(status)) {
611 return status;
612 }
613
614 /* Return variables */
615 *handle = *r.out.handle;
616
617 /* Return result */
618 if (werror) {
619 *werror = r.out.result;
620 }
621
622 return werror_to_ntstatus(r.out.result);
623 }
624
625 struct rpccli_winreg_OpenHKU_state {
626 struct winreg_OpenHKU orig;
627 struct winreg_OpenHKU tmp;
628 TALLOC_CTX *out_mem_ctx;
629 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
630 };
631
632 static void rpccli_winreg_OpenHKU_done(struct tevent_req *subreq);
633
634 struct tevent_req *rpccli_winreg_OpenHKU_send(TALLOC_CTX *mem_ctx,
635 struct tevent_context *ev,
636 struct rpc_pipe_client *cli,
637 uint16_t *_system_name /* [in] [unique] */,
638 uint32_t _access_mask /* [in] */,
639 struct policy_handle *_handle /* [out] [ref] */)
640 {
641 struct tevent_req *req;
642 struct rpccli_winreg_OpenHKU_state *state;
643 struct tevent_req *subreq;
644
645 req = tevent_req_create(mem_ctx, &state,
646 struct rpccli_winreg_OpenHKU_state);
647 if (req == NULL) {
648 return NULL;
649 }
650 state->out_mem_ctx = NULL;
651 state->dispatch_recv = cli->dispatch_recv;
652
653 /* In parameters */
654 state->orig.in.system_name = _system_name;
655 state->orig.in.access_mask = _access_mask;
656
657 /* Out parameters */
658 state->orig.out.handle = _handle;
659
660 /* Result */
661 ZERO_STRUCT(state->orig.out.result);
662
663 state->out_mem_ctx = talloc_named_const(state, 0,
664 "rpccli_winreg_OpenHKU_out_memory");
665 if (tevent_req_nomem(state->out_mem_ctx, req)) {
666 return tevent_req_post(req, ev);
667 }
668
669 /* make a temporary copy, that we pass to the dispatch function */
670 state->tmp = state->orig;
671
672 subreq = cli->dispatch_send(state, ev, cli,
673 &ndr_table_winreg,
674 NDR_WINREG_OPENHKU,
675 &state->tmp);
676 if (tevent_req_nomem(subreq, req)) {
677 return tevent_req_post(req, ev);
678 }
679 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKU_done, req);
680 return req;
681 }
682
683 static void rpccli_winreg_OpenHKU_done(struct tevent_req *subreq)
684 {
685 struct tevent_req *req = tevent_req_callback_data(
686 subreq, struct tevent_req);
687 struct rpccli_winreg_OpenHKU_state *state = tevent_req_data(
688 req, struct rpccli_winreg_OpenHKU_state);
689 NTSTATUS status;
690 TALLOC_CTX *mem_ctx;
691
692 if (state->out_mem_ctx) {
693 mem_ctx = state->out_mem_ctx;
694 } else {
695 mem_ctx = state;
696 }
697
698 status = state->dispatch_recv(subreq, mem_ctx);
699 TALLOC_FREE(subreq);
700 if (!NT_STATUS_IS_OK(status)) {
701 tevent_req_nterror(req, status);
702 return;
703 }
704
705 /* Copy out parameters */
706 *state->orig.out.handle = *state->tmp.out.handle;
707
708 /* Copy result */
709 state->orig.out.result = state->tmp.out.result;
710
711 /* Reset temporary structure */
712 ZERO_STRUCT(state->tmp);
713
714 tevent_req_done(req);
715 }
716
717 NTSTATUS rpccli_winreg_OpenHKU_recv(struct tevent_req *req,
718 TALLOC_CTX *mem_ctx,
719 WERROR *result)
720 {
721 struct rpccli_winreg_OpenHKU_state *state = tevent_req_data(
722 req, struct rpccli_winreg_OpenHKU_state);
723 NTSTATUS status;
724
725 if (tevent_req_is_nterror(req, &status)) {
726 tevent_req_received(req);
727 return status;
728 }
729
730 /* Steal possbile out parameters to the callers context */
731 talloc_steal(mem_ctx, state->out_mem_ctx);
732
733 /* Return result */
734 *result = state->orig.out.result;
735
736 tevent_req_received(req);
737 return NT_STATUS_OK;
738 }
739
740 NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli,
741 TALLOC_CTX *mem_ctx,
742 uint16_t *system_name /* [in] [unique] */,
743 uint32_t access_mask /* [in] */,
744 struct policy_handle *handle /* [out] [ref] */,
745 WERROR *werror)
746 {
747 struct winreg_OpenHKU r;
748 NTSTATUS status;
749
750 /* In parameters */
751 r.in.system_name = system_name;
752 r.in.access_mask = access_mask;
753
754 status = cli->dispatch(cli,
755 mem_ctx,
756 &ndr_table_winreg,
757 NDR_WINREG_OPENHKU,
758 &r);
759
760 if (!NT_STATUS_IS_OK(status)) {
761 return status;
762 }
763
764 if (NT_STATUS_IS_ERR(status)) {
765 return status;
766 }
767
768 /* Return variables */
769 *handle = *r.out.handle;
770
771 /* Return result */
772 if (werror) {
773 *werror = r.out.result;
774 }
775
776 return werror_to_ntstatus(r.out.result);
777 }
778
779 struct rpccli_winreg_CloseKey_state {
780 struct winreg_CloseKey orig;
781 struct winreg_CloseKey tmp;
782 TALLOC_CTX *out_mem_ctx;
783 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
784 };
785
786 static void rpccli_winreg_CloseKey_done(struct tevent_req *subreq);
787
788 struct tevent_req *rpccli_winreg_CloseKey_send(TALLOC_CTX *mem_ctx,
789 struct tevent_context *ev,
790 struct rpc_pipe_client *cli,
791 struct policy_handle *_handle /* [in,out] [ref] */)
792 {
793 struct tevent_req *req;
794 struct rpccli_winreg_CloseKey_state *state;
795 struct tevent_req *subreq;
796
797 req = tevent_req_create(mem_ctx, &state,
798 struct rpccli_winreg_CloseKey_state);
799 if (req == NULL) {
800 return NULL;
801 }
802 state->out_mem_ctx = NULL;
803 state->dispatch_recv = cli->dispatch_recv;
804
805 /* In parameters */
806 state->orig.in.handle = _handle;
807
808 /* Out parameters */
809 state->orig.out.handle = _handle;
810
811 /* Result */
812 ZERO_STRUCT(state->orig.out.result);
813
814 state->out_mem_ctx = talloc_named_const(state, 0,
815 "rpccli_winreg_CloseKey_out_memory");
816 if (tevent_req_nomem(state->out_mem_ctx, req)) {
817 return tevent_req_post(req, ev);
818 }
819
820 /* make a temporary copy, that we pass to the dispatch function */
821 state->tmp = state->orig;
822
823 subreq = cli->dispatch_send(state, ev, cli,
824 &ndr_table_winreg,
825 NDR_WINREG_CLOSEKEY,
826 &state->tmp);
827 if (tevent_req_nomem(subreq, req)) {
828 return tevent_req_post(req, ev);
829 }
830 tevent_req_set_callback(subreq, rpccli_winreg_CloseKey_done, req);
831 return req;
832 }
833
834 static void rpccli_winreg_CloseKey_done(struct tevent_req *subreq)
835 {
836 struct tevent_req *req = tevent_req_callback_data(
837 subreq, struct tevent_req);
838 struct rpccli_winreg_CloseKey_state *state = tevent_req_data(
839 req, struct rpccli_winreg_CloseKey_state);
840 NTSTATUS status;
841 TALLOC_CTX *mem_ctx;
842
843 if (state->out_mem_ctx) {
844 mem_ctx = state->out_mem_ctx;
845 } else {
846 mem_ctx = state;
847 }
848
849 status = state->dispatch_recv(subreq, mem_ctx);
850 TALLOC_FREE(subreq);
851 if (!NT_STATUS_IS_OK(status)) {
852 tevent_req_nterror(req, status);
853 return;
854 }
855
856 /* Copy out parameters */
857 *state->orig.out.handle = *state->tmp.out.handle;
858
859 /* Copy result */
860 state->orig.out.result = state->tmp.out.result;
861
862 /* Reset temporary structure */
863 ZERO_STRUCT(state->tmp);
864
865 tevent_req_done(req);
866 }
867
868 NTSTATUS rpccli_winreg_CloseKey_recv(struct tevent_req *req,
869 TALLOC_CTX *mem_ctx,
870 WERROR *result)
871 {
872 struct rpccli_winreg_CloseKey_state *state = tevent_req_data(
873 req, struct rpccli_winreg_CloseKey_state);
874 NTSTATUS status;
875
876 if (tevent_req_is_nterror(req, &status)) {
877 tevent_req_received(req);
878 return status;
879 }
880
881 /* Steal possbile out parameters to the callers context */
882 talloc_steal(mem_ctx, state->out_mem_ctx);
883
884 /* Return result */
885 *result = state->orig.out.result;
886
887 tevent_req_received(req);
888 return NT_STATUS_OK;
889 }
890
891 NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli,
892 TALLOC_CTX *mem_ctx,
893 struct policy_handle *handle /* [in,out] [ref] */,
894 WERROR *werror)
895 {
896 struct winreg_CloseKey r;
897 NTSTATUS status;
898
899 /* In parameters */
900 r.in.handle = handle;
901
902 status = cli->dispatch(cli,
903 mem_ctx,
904 &ndr_table_winreg,
905 NDR_WINREG_CLOSEKEY,
906 &r);
907
908 if (!NT_STATUS_IS_OK(status)) {
909 return status;
910 }
911
912 if (NT_STATUS_IS_ERR(status)) {
913 return status;
914 }
915
916 /* Return variables */
917 *handle = *r.out.handle;
918
919 /* Return result */
920 if (werror) {
921 *werror = r.out.result;
922 }
923
924 return werror_to_ntstatus(r.out.result);
925 }
926
927 struct rpccli_winreg_CreateKey_state {
928 struct winreg_CreateKey orig;
929 struct winreg_CreateKey tmp;
930 TALLOC_CTX *out_mem_ctx;
931 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
932 };
933
934 static void rpccli_winreg_CreateKey_done(struct tevent_req *subreq);
935
936 struct tevent_req *rpccli_winreg_CreateKey_send(TALLOC_CTX *mem_ctx,
937 struct tevent_context *ev,
938 struct rpc_pipe_client *cli,
939 struct policy_handle *_handle /* [in] [ref] */,
940 struct winreg_String _name /* [in] */,
941 struct winreg_String _keyclass /* [in] */,
942 uint32_t _options /* [in] */,
943 uint32_t _access_mask /* [in] */,
944 struct winreg_SecBuf *_secdesc /* [in] [unique] */,
945 struct policy_handle *_new_handle /* [out] [ref] */,
946 enum winreg_CreateAction *_action_taken /* [in,out] [unique] */)
947 {
948 struct tevent_req *req;
949 struct rpccli_winreg_CreateKey_state *state;
950 struct tevent_req *subreq;
951
952 req = tevent_req_create(mem_ctx, &state,
953 struct rpccli_winreg_CreateKey_state);
954 if (req == NULL) {
955 return NULL;
956 }
957 state->out_mem_ctx = NULL;
958 state->dispatch_recv = cli->dispatch_recv;
959
960 /* In parameters */
961 state->orig.in.handle = _handle;
962 state->orig.in.name = _name;
963 state->orig.in.keyclass = _keyclass;
964 state->orig.in.options = _options;
965 state->orig.in.access_mask = _access_mask;
966 state->orig.in.secdesc = _secdesc;
967 state->orig.in.action_taken = _action_taken;
968
969 /* Out parameters */
970 state->orig.out.new_handle = _new_handle;
971 state->orig.out.action_taken = _action_taken;
972
973 /* Result */
974 ZERO_STRUCT(state->orig.out.result);
975
976 state->out_mem_ctx = talloc_named_const(state, 0,
977 "rpccli_winreg_CreateKey_out_memory");
978 if (tevent_req_nomem(state->out_mem_ctx, req)) {
979 return tevent_req_post(req, ev);
980 }
981
982 /* make a temporary copy, that we pass to the dispatch function */
983 state->tmp = state->orig;
984
985 subreq = cli->dispatch_send(state, ev, cli,
986 &ndr_table_winreg,
987 NDR_WINREG_CREATEKEY,
988 &state->tmp);
989 if (tevent_req_nomem(subreq, req)) {
990 return tevent_req_post(req, ev);
991 }
992 tevent_req_set_callback(subreq, rpccli_winreg_CreateKey_done, req);
993 return req;
994 }
995
996 static void rpccli_winreg_CreateKey_done(struct tevent_req *subreq)
997 {
998 struct tevent_req *req = tevent_req_callback_data(
999 subreq, struct tevent_req);
1000 struct rpccli_winreg_CreateKey_state *state = tevent_req_data(
1001 req, struct rpccli_winreg_CreateKey_state);
1002 NTSTATUS status;
1003 TALLOC_CTX *mem_ctx;
1004
1005 if (state->out_mem_ctx) {
1006 mem_ctx = state->out_mem_ctx;
1007 } else {
1008 mem_ctx = state;
1009 }
1010
1011 status = state->dispatch_recv(subreq, mem_ctx);
1012 TALLOC_FREE(subreq);
1013 if (!NT_STATUS_IS_OK(status)) {
1014 tevent_req_nterror(req, status);
1015 return;
1016 }
1017
1018 /* Copy out parameters */
1019 *state->orig.out.new_handle = *state->tmp.out.new_handle;
1020 if (state->orig.out.action_taken && state->tmp.out.action_taken) {
1021 *state->orig.out.action_taken = *state->tmp.out.action_taken;
1022 }
1023
1024 /* Copy result */
1025 state->orig.out.result = state->tmp.out.result;
1026
1027 /* Reset temporary structure */
1028 ZERO_STRUCT(state->tmp);
1029
1030 tevent_req_done(req);
1031 }
1032
1033 NTSTATUS rpccli_winreg_CreateKey_recv(struct tevent_req *req,
1034 TALLOC_CTX *mem_ctx,
1035 WERROR *result)
1036 {
1037 struct rpccli_winreg_CreateKey_state *state = tevent_req_data(
1038 req, struct rpccli_winreg_CreateKey_state);
1039 NTSTATUS status;
1040
1041 if (tevent_req_is_nterror(req, &status)) {
1042 tevent_req_received(req);
1043 return status;
1044 }
1045
1046 /* Steal possbile out parameters to the callers context */
1047 talloc_steal(mem_ctx, state->out_mem_ctx);
1048
1049 /* Return result */
1050 *result = state->orig.out.result;
1051
1052 tevent_req_received(req);
1053 return NT_STATUS_OK;
1054 }
1055
1056 NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,
1057 TALLOC_CTX *mem_ctx,
1058 struct policy_handle *handle /* [in] [ref] */,
1059 struct winreg_String name /* [in] */,
1060 struct winreg_String keyclass /* [in] */,
1061 uint32_t options /* [in] */,
1062 uint32_t access_mask /* [in] */,
1063 struct winreg_SecBuf *secdesc /* [in] [unique] */,
1064 struct policy_handle *new_handle /* [out] [ref] */,
1065 enum winreg_CreateAction *action_taken /* [in,out] [unique] */,
1066 WERROR *werror)
1067 {
1068 struct winreg_CreateKey r;
1069 NTSTATUS status;
1070
1071 /* In parameters */
1072 r.in.handle = handle;
1073 r.in.name = name;
1074 r.in.keyclass = keyclass;
1075 r.in.options = options;
1076 r.in.access_mask = access_mask;
1077 r.in.secdesc = secdesc;
1078 r.in.action_taken = action_taken;
1079
1080 status = cli->dispatch(cli,
1081 mem_ctx,
1082 &ndr_table_winreg,
1083 NDR_WINREG_CREATEKEY,
1084 &r);
1085
1086 if (!NT_STATUS_IS_OK(status)) {
1087 return status;
1088 }
1089
1090 if (NT_STATUS_IS_ERR(status)) {
1091 return status;
1092 }
1093
1094 /* Return variables */
1095 *new_handle = *r.out.new_handle;
1096 if (action_taken && r.out.action_taken) {
1097 *action_taken = *r.out.action_taken;
1098 }
1099
1100 /* Return result */
1101 if (werror) {
1102 *werror = r.out.result;
1103 }
1104
1105 return werror_to_ntstatus(r.out.result);
1106 }
1107
1108 struct rpccli_winreg_DeleteKey_state {
1109 struct winreg_DeleteKey orig;
1110 struct winreg_DeleteKey tmp;
1111 TALLOC_CTX *out_mem_ctx;
1112 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1113 };
1114
1115 static void rpccli_winreg_DeleteKey_done(struct tevent_req *subreq);
1116
1117 struct tevent_req *rpccli_winreg_DeleteKey_send(TALLOC_CTX *mem_ctx,
1118 struct tevent_context *ev,
1119 struct rpc_pipe_client *cli,
1120 struct policy_handle *_handle /* [in] [ref] */,
1121 struct winreg_String _key /* [in] */)
1122 {
1123 struct tevent_req *req;
1124 struct rpccli_winreg_DeleteKey_state *state;
1125 struct tevent_req *subreq;
1126
1127 req = tevent_req_create(mem_ctx, &state,
1128 struct rpccli_winreg_DeleteKey_state);
1129 if (req == NULL) {
1130 return NULL;
1131 }
1132 state->out_mem_ctx = NULL;
1133 state->dispatch_recv = cli->dispatch_recv;
1134
1135 /* In parameters */
1136 state->orig.in.handle = _handle;
1137 state->orig.in.key = _key;
1138
1139 /* Out parameters */
1140
1141 /* Result */
1142 ZERO_STRUCT(state->orig.out.result);
1143
1144 /* make a temporary copy, that we pass to the dispatch function */
1145 state->tmp = state->orig;
1146
1147 subreq = cli->dispatch_send(state, ev, cli,
1148 &ndr_table_winreg,
1149 NDR_WINREG_DELETEKEY,
1150 &state->tmp);
1151 if (tevent_req_nomem(subreq, req)) {
1152 return tevent_req_post(req, ev);
1153 }
1154 tevent_req_set_callback(subreq, rpccli_winreg_DeleteKey_done, req);
1155 return req;
1156 }
1157
1158 static void rpccli_winreg_DeleteKey_done(struct tevent_req *subreq)
1159 {
1160 struct tevent_req *req = tevent_req_callback_data(
1161 subreq, struct tevent_req);
1162 struct rpccli_winreg_DeleteKey_state *state = tevent_req_data(
1163 req, struct rpccli_winreg_DeleteKey_state);
1164 NTSTATUS status;
1165 TALLOC_CTX *mem_ctx;
1166
1167 if (state->out_mem_ctx) {
1168 mem_ctx = state->out_mem_ctx;
1169 } else {
1170 mem_ctx = state;
1171 }
1172
1173 status = state->dispatch_recv(subreq, mem_ctx);
1174 TALLOC_FREE(subreq);
1175 if (!NT_STATUS_IS_OK(status)) {
1176 tevent_req_nterror(req, status);
1177 return;
1178 }
1179
1180 /* Copy out parameters */
1181
1182 /* Copy result */
1183 state->orig.out.result = state->tmp.out.result;
1184
1185 /* Reset temporary structure */
1186 ZERO_STRUCT(state->tmp);
1187
1188 tevent_req_done(req);
1189 }
1190
1191 NTSTATUS rpccli_winreg_DeleteKey_recv(struct tevent_req *req,
1192 TALLOC_CTX *mem_ctx,
1193 WERROR *result)
1194 {
1195 struct rpccli_winreg_DeleteKey_state *state = tevent_req_data(
1196 req, struct rpccli_winreg_DeleteKey_state);
1197 NTSTATUS status;
1198
1199 if (tevent_req_is_nterror(req, &status)) {
1200 tevent_req_received(req);
1201 return status;
1202 }
1203
1204 /* Steal possbile out parameters to the callers context */
1205 talloc_steal(mem_ctx, state->out_mem_ctx);
1206
1207 /* Return result */
1208 *result = state->orig.out.result;
1209
1210 tevent_req_received(req);
1211 return NT_STATUS_OK;
1212 }
1213
1214 NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli,
1215 TALLOC_CTX *mem_ctx,
1216 struct policy_handle *handle /* [in] [ref] */,
1217 struct winreg_String key /* [in] */,
1218 WERROR *werror)
1219 {
1220 struct winreg_DeleteKey r;
1221 NTSTATUS status;
1222
1223 /* In parameters */
1224 r.in.handle = handle;
1225 r.in.key = key;
1226
1227 status = cli->dispatch(cli,
1228 mem_ctx,
1229 &ndr_table_winreg,
1230 NDR_WINREG_DELETEKEY,
1231 &r);
1232
1233 if (!NT_STATUS_IS_OK(status)) {
1234 return status;
1235 }
1236
1237 if (NT_STATUS_IS_ERR(status)) {
1238 return status;
1239 }
1240
1241 /* Return variables */
1242
1243 /* Return result */
1244 if (werror) {
1245 *werror = r.out.result;
1246 }
1247
1248 return werror_to_ntstatus(r.out.result);
1249 }
1250
1251 struct rpccli_winreg_DeleteValue_state {
1252 struct winreg_DeleteValue orig;
1253 struct winreg_DeleteValue tmp;
1254 TALLOC_CTX *out_mem_ctx;
1255 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1256 };
1257
1258 static void rpccli_winreg_DeleteValue_done(struct tevent_req *subreq);
1259
1260 struct tevent_req *rpccli_winreg_DeleteValue_send(TALLOC_CTX *mem_ctx,
1261 struct tevent_context *ev,
1262 struct rpc_pipe_client *cli,
1263 struct policy_handle *_handle /* [in] [ref] */,
1264 struct winreg_String _value /* [in] */)
1265 {
1266 struct tevent_req *req;
1267 struct rpccli_winreg_DeleteValue_state *state;
1268 struct tevent_req *subreq;
1269
1270 req = tevent_req_create(mem_ctx, &state,
1271 struct rpccli_winreg_DeleteValue_state);
1272 if (req == NULL) {
1273 return NULL;
1274 }
1275 state->out_mem_ctx = NULL;
1276 state->dispatch_recv = cli->dispatch_recv;
1277
1278 /* In parameters */
1279 state->orig.in.handle = _handle;
1280 state->orig.in.value = _value;
1281
1282 /* Out parameters */
1283
1284 /* Result */
1285 ZERO_STRUCT(state->orig.out.result);
1286
1287 /* make a temporary copy, that we pass to the dispatch function */
1288 state->tmp = state->orig;
1289
1290 subreq = cli->dispatch_send(state, ev, cli,
1291 &ndr_table_winreg,
1292 NDR_WINREG_DELETEVALUE,
1293 &state->tmp);
1294 if (tevent_req_nomem(subreq, req)) {
1295 return tevent_req_post(req, ev);
1296 }
1297 tevent_req_set_callback(subreq, rpccli_winreg_DeleteValue_done, req);
1298 return req;
1299 }
1300
1301 static void rpccli_winreg_DeleteValue_done(struct tevent_req *subreq)
1302 {
1303 struct tevent_req *req = tevent_req_callback_data(
1304 subreq, struct tevent_req);
1305 struct rpccli_winreg_DeleteValue_state *state = tevent_req_data(
1306 req, struct rpccli_winreg_DeleteValue_state);
1307 NTSTATUS status;
1308 TALLOC_CTX *mem_ctx;
1309
1310 if (state->out_mem_ctx) {
1311 mem_ctx = state->out_mem_ctx;
1312 } else {
1313 mem_ctx = state;
1314 }
1315
1316 status = state->dispatch_recv(subreq, mem_ctx);
1317 TALLOC_FREE(subreq);
1318 if (!NT_STATUS_IS_OK(status)) {
1319 tevent_req_nterror(req, status);
1320 return;
1321 }
1322
1323 /* Copy out parameters */
1324
1325 /* Copy result */
1326 state->orig.out.result = state->tmp.out.result;
1327
1328 /* Reset temporary structure */
1329 ZERO_STRUCT(state->tmp);
1330
1331 tevent_req_done(req);
1332 }
1333
1334 NTSTATUS rpccli_winreg_DeleteValue_recv(struct tevent_req *req,
1335 TALLOC_CTX *mem_ctx,
1336 WERROR *result)
1337 {
1338 struct rpccli_winreg_DeleteValue_state *state = tevent_req_data(
1339 req, struct rpccli_winreg_DeleteValue_state);
1340 NTSTATUS status;
1341
1342 if (tevent_req_is_nterror(req, &status)) {
1343 tevent_req_received(req);
1344 return status;
1345 }
1346
1347 /* Steal possbile out parameters to the callers context */
1348 talloc_steal(mem_ctx, state->out_mem_ctx);
1349
1350 /* Return result */
1351 *result = state->orig.out.result;
1352
1353 tevent_req_received(req);
1354 return NT_STATUS_OK;
1355 }
1356
1357 NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli,
1358 TALLOC_CTX *mem_ctx,
1359 struct policy_handle *handle /* [in] [ref] */,
1360 struct winreg_String value /* [in] */,
1361 WERROR *werror)
1362 {
1363 struct winreg_DeleteValue r;
1364 NTSTATUS status;
1365
1366 /* In parameters */
1367 r.in.handle = handle;
1368 r.in.value = value;
1369
1370 status = cli->dispatch(cli,
1371 mem_ctx,
1372 &ndr_table_winreg,
1373 NDR_WINREG_DELETEVALUE,
1374 &r);
1375
1376 if (!NT_STATUS_IS_OK(status)) {
1377 return status;
1378 }
1379
1380 if (NT_STATUS_IS_ERR(status)) {
1381 return status;
1382 }
1383
1384 /* Return variables */
1385
1386 /* Return result */
1387 if (werror) {
1388 *werror = r.out.result;
1389 }
1390
1391 return werror_to_ntstatus(r.out.result);
1392 }
1393
1394 struct rpccli_winreg_EnumKey_state {
1395 struct winreg_EnumKey orig;
1396 struct winreg_EnumKey tmp;
1397 TALLOC_CTX *out_mem_ctx;
1398 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1399 };
1400
1401 static void rpccli_winreg_EnumKey_done(struct tevent_req *subreq);
1402
1403 struct tevent_req *rpccli_winreg_EnumKey_send(TALLOC_CTX *mem_ctx,
1404 struct tevent_context *ev,
1405 struct rpc_pipe_client *cli,
1406 struct policy_handle *_handle /* [in] [ref] */,
1407 uint32_t _enum_index /* [in] */,
1408 struct winreg_StringBuf *_name /* [in,out] [ref] */,
1409 struct winreg_StringBuf *_keyclass /* [in,out] [unique] */,
1410 NTTIME *_last_changed_time /* [in,out] [unique] */)
1411 {
1412 struct tevent_req *req;
1413 struct rpccli_winreg_EnumKey_state *state;
1414 struct tevent_req *subreq;
1415
1416 req = tevent_req_create(mem_ctx, &state,
1417 struct rpccli_winreg_EnumKey_state);
1418 if (req == NULL) {
1419 return NULL;
1420 }
1421 state->out_mem_ctx = NULL;
1422 state->dispatch_recv = cli->dispatch_recv;
1423
1424 /* In parameters */
1425 state->orig.in.handle = _handle;
1426 state->orig.in.enum_index = _enum_index;
1427 state->orig.in.name = _name;
1428 state->orig.in.keyclass = _keyclass;
1429 state->orig.in.last_changed_time = _last_changed_time;
1430
1431 /* Out parameters */
1432 state->orig.out.name = _name;
1433 state->orig.out.keyclass = _keyclass;
1434 state->orig.out.last_changed_time = _last_changed_time;
1435
1436 /* Result */
1437 ZERO_STRUCT(state->orig.out.result);
1438
1439 state->out_mem_ctx = talloc_named_const(state, 0,
1440 "rpccli_winreg_EnumKey_out_memory");
1441 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1442 return tevent_req_post(req, ev);
1443 }
1444
1445 /* make a temporary copy, that we pass to the dispatch function */
1446 state->tmp = state->orig;
1447
1448 subreq = cli->dispatch_send(state, ev, cli,
1449 &ndr_table_winreg,
1450 NDR_WINREG_ENUMKEY,
1451 &state->tmp);
1452 if (tevent_req_nomem(subreq, req)) {
1453 return tevent_req_post(req, ev);
1454 }
1455 tevent_req_set_callback(subreq, rpccli_winreg_EnumKey_done, req);
1456 return req;
1457 }
1458
1459 static void rpccli_winreg_EnumKey_done(struct tevent_req *subreq)
1460 {
1461 struct tevent_req *req = tevent_req_callback_data(
1462 subreq, struct tevent_req);
1463 struct rpccli_winreg_EnumKey_state *state = tevent_req_data(
1464 req, struct rpccli_winreg_EnumKey_state);
1465 NTSTATUS status;
1466 TALLOC_CTX *mem_ctx;
1467
1468 if (state->out_mem_ctx) {
1469 mem_ctx = state->out_mem_ctx;
1470 } else {
1471 mem_ctx = state;
1472 }
1473
1474 status = state->dispatch_recv(subreq, mem_ctx);
1475 TALLOC_FREE(subreq);
1476 if (!NT_STATUS_IS_OK(status)) {
1477 tevent_req_nterror(req, status);
1478 return;
1479 }
1480
1481 /* Copy out parameters */
1482 *state->orig.out.name = *state->tmp.out.name;
1483 if (state->orig.out.keyclass && state->tmp.out.keyclass) {
1484 *state->orig.out.keyclass = *state->tmp.out.keyclass;
1485 }
1486 if (state->orig.out.last_changed_time && state->tmp.out.last_changed_time) {
1487 *state->orig.out.last_changed_time = *state->tmp.out.last_changed_time;
1488 }
1489
1490 /* Copy result */
1491 state->orig.out.result = state->tmp.out.result;
1492
1493 /* Reset temporary structure */
1494 ZERO_STRUCT(state->tmp);
1495
1496 tevent_req_done(req);
1497 }
1498
1499 NTSTATUS rpccli_winreg_EnumKey_recv(struct tevent_req *req,
1500 TALLOC_CTX *mem_ctx,
1501 WERROR *result)
1502 {
1503 struct rpccli_winreg_EnumKey_state *state = tevent_req_data(
1504 req, struct rpccli_winreg_EnumKey_state);
1505 NTSTATUS status;
1506
1507 if (tevent_req_is_nterror(req, &status)) {
1508 tevent_req_received(req);
1509 return status;
1510 }
1511
1512 /* Steal possbile out parameters to the callers context */
1513 talloc_steal(mem_ctx, state->out_mem_ctx);
1514
1515 /* Return result */
1516 *result = state->orig.out.result;
1517
1518 tevent_req_received(req);
1519 return NT_STATUS_OK;
1520 }
1521
1522 NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,
1523 TALLOC_CTX *mem_ctx,
1524 struct policy_handle *handle /* [in] [ref] */,
1525 uint32_t enum_index /* [in] */,
1526 struct winreg_StringBuf *name /* [in,out] [ref] */,
1527 struct winreg_StringBuf *keyclass /* [in,out] [unique] */,
1528 NTTIME *last_changed_time /* [in,out] [unique] */,
1529 WERROR *werror)
1530 {
1531 struct winreg_EnumKey r;
1532 NTSTATUS status;
1533
1534 /* In parameters */
1535 r.in.handle = handle;
1536 r.in.enum_index = enum_index;
1537 r.in.name = name;
1538 r.in.keyclass = keyclass;
1539 r.in.last_changed_time = last_changed_time;
1540
1541 status = cli->dispatch(cli,
1542 mem_ctx,
1543 &ndr_table_winreg,
1544 NDR_WINREG_ENUMKEY,
1545 &r);
1546
1547 if (!NT_STATUS_IS_OK(status)) {
1548 return status;
1549 }
1550
1551 if (NT_STATUS_IS_ERR(status)) {
1552 return status;
1553 }
1554
1555 /* Return variables */
1556 *name = *r.out.name;
1557 if (keyclass && r.out.keyclass) {
1558 *keyclass = *r.out.keyclass;
1559 }
1560 if (last_changed_time && r.out.last_changed_time) {
1561 *last_changed_time = *r.out.last_changed_time;
1562 }
1563
1564 /* Return result */
1565 if (werror) {
1566 *werror = r.out.result;
1567 }
1568
1569 return werror_to_ntstatus(r.out.result);
1570 }
1571
1572 struct rpccli_winreg_EnumValue_state {
1573 struct winreg_EnumValue orig;
1574 struct winreg_EnumValue tmp;
1575 TALLOC_CTX *out_mem_ctx;
1576 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1577 };
1578
1579 static void rpccli_winreg_EnumValue_done(struct tevent_req *subreq);
1580
1581 struct tevent_req *rpccli_winreg_EnumValue_send(TALLOC_CTX *mem_ctx,
1582 struct tevent_context *ev,
1583 struct rpc_pipe_client *cli,
1584 struct policy_handle *_handle /* [in] [ref] */,
1585 uint32_t _enum_index /* [in] */,
1586 struct winreg_ValNameBuf *_name /* [in,out] [ref] */,
1587 enum winreg_Type *_type /* [in,out] [unique] */,
1588 uint8_t *_value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
1589 uint32_t *_size /* [in,out] [unique] */,
1590 uint32_t *_length /* [in,out] [unique] */)
1591 {
1592 struct tevent_req *req;
1593 struct rpccli_winreg_EnumValue_state *state;
1594 struct tevent_req *subreq;
1595
1596 req = tevent_req_create(mem_ctx, &state,
1597 struct rpccli_winreg_EnumValue_state);
1598 if (req == NULL) {
1599 return NULL;
1600 }
1601 state->out_mem_ctx = NULL;
1602 state->dispatch_recv = cli->dispatch_recv;
1603
1604 /* In parameters */
1605 state->orig.in.handle = _handle;
1606 state->orig.in.enum_index = _enum_index;
1607 state->orig.in.name = _name;
1608 state->orig.in.type = _type;
1609 state->orig.in.value = _value;
1610 state->orig.in.size = _size;
1611 state->orig.in.length = _length;
1612
1613 /* Out parameters */
1614 state->orig.out.name = _name;
1615 state->orig.out.type = _type;
1616 state->orig.out.value = _value;
1617 state->orig.out.size = _size;
1618 state->orig.out.length = _length;
1619
1620 /* Result */
1621 ZERO_STRUCT(state->orig.out.result);
1622
1623 state->out_mem_ctx = talloc_named_const(state, 0,
1624 "rpccli_winreg_EnumValue_out_memory");
1625 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1626 return tevent_req_post(req, ev);
1627 }
1628
1629 /* make a temporary copy, that we pass to the dispatch function */
1630 state->tmp = state->orig;
1631
1632 subreq = cli->dispatch_send(state, ev, cli,
1633 &ndr_table_winreg,
1634 NDR_WINREG_ENUMVALUE,
1635 &state->tmp);
1636 if (tevent_req_nomem(subreq, req)) {
1637 return tevent_req_post(req, ev);
1638 }
1639 tevent_req_set_callback(subreq, rpccli_winreg_EnumValue_done, req);
1640 return req;
1641 }
1642
1643 static void rpccli_winreg_EnumValue_done(struct tevent_req *subreq)
1644 {
1645 struct tevent_req *req = tevent_req_callback_data(
1646 subreq, struct tevent_req);
1647 struct rpccli_winreg_EnumValue_state *state = tevent_req_data(
1648 req, struct rpccli_winreg_EnumValue_state);
1649 NTSTATUS status;
1650 TALLOC_CTX *mem_ctx;
1651
1652 if (state->out_mem_ctx) {
1653 mem_ctx = state->out_mem_ctx;
1654 } else {
1655 mem_ctx = state;
1656 }
1657
1658 status = state->dispatch_recv(subreq, mem_ctx);
1659 TALLOC_FREE(subreq);
1660 if (!NT_STATUS_IS_OK(status)) {
1661 tevent_req_nterror(req, status);
1662 return;
1663 }
1664
1665 /* Copy out parameters */
1666 *state->orig.out.name = *state->tmp.out.name;
1667 if (state->orig.out.type && state->tmp.out.type) {
1668 *state->orig.out.type = *state->tmp.out.type;
1669 }
1670 if (state->orig.out.value && state->tmp.out.value) {
1671 memcpy(state->orig.out.value, state->tmp.out.value, (*state->tmp.in.size) * sizeof(*state->orig.out.value));
1672 }
1673 if (state->orig.out.size && state->tmp.out.size) {
1674 *state->orig.out.size = *state->tmp.out.size;
1675 }
1676 if (state->orig.out.length && state->tmp.out.length) {
1677 *state->orig.out.length = *state->tmp.out.length;
1678 }
1679
1680 /* Copy result */
1681 state->orig.out.result = state->tmp.out.result;
1682
1683 /* Reset temporary structure */
1684 ZERO_STRUCT(state->tmp);
1685
1686 tevent_req_done(req);
1687 }
1688
1689 NTSTATUS rpccli_winreg_EnumValue_recv(struct tevent_req *req,
1690 TALLOC_CTX *mem_ctx,
1691 WERROR *result)
1692 {
1693 struct rpccli_winreg_EnumValue_state *state = tevent_req_data(
1694 req, struct rpccli_winreg_EnumValue_state);
1695 NTSTATUS status;
1696
1697 if (tevent_req_is_nterror(req, &status)) {
1698 tevent_req_received(req);
1699 return status;
1700 }
1701
1702 /* Steal possbile out parameters to the callers context */
1703 talloc_steal(mem_ctx, state->out_mem_ctx);
1704
1705 /* Return result */
1706 *result = state->orig.out.result;
1707
1708 tevent_req_received(req);
1709 return NT_STATUS_OK;
1710 }
1711
1712 NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli,
1713 TALLOC_CTX *mem_ctx,
1714 struct policy_handle *handle /* [in] [ref] */,
1715 uint32_t enum_index /* [in] */,
1716 struct winreg_ValNameBuf *name /* [in,out] [ref] */,
1717 enum winreg_Type *type /* [in,out] [unique] */,
1718 uint8_t *value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
1719 uint32_t *size /* [in,out] [unique] */,
1720 uint32_t *length /* [in,out] [unique] */,
1721 WERROR *werror)
1722 {
1723 struct winreg_EnumValue r;
1724 NTSTATUS status;
1725
1726 /* In parameters */
1727 r.in.handle = handle;
1728 r.in.enum_index = enum_index;
1729 r.in.name = name;
1730 r.in.type = type;
1731 r.in.value = value;
1732 r.in.size = size;
1733 r.in.length = length;
1734
1735 status = cli->dispatch(cli,
1736 mem_ctx,
1737 &ndr_table_winreg,
1738 NDR_WINREG_ENUMVALUE,
1739 &r);
1740
1741 if (!NT_STATUS_IS_OK(status)) {
1742 return status;
1743 }
1744
1745 if (NT_STATUS_IS_ERR(status)) {
1746 return status;
1747 }
1748
1749 /* Return variables */
1750 *name = *r.out.name;
1751 if (type && r.out.type) {
1752 *type = *r.out.type;
1753 }
1754 if (value && r.out.value) {
1755 memcpy(value, r.out.value, (*r.in.size) * sizeof(*value));
1756 }
1757 if (size && r.out.size) {
1758 *size = *r.out.size;
1759 }
1760 if (length && r.out.length) {
1761 *length = *r.out.length;
1762 }
1763
1764 /* Return result */
1765 if (werror) {
1766 *werror = r.out.result;
1767 }
1768
1769 return werror_to_ntstatus(r.out.result);
1770 }
1771
1772 struct rpccli_winreg_FlushKey_state {
1773 struct winreg_FlushKey orig;
1774 struct winreg_FlushKey tmp;
1775 TALLOC_CTX *out_mem_ctx;
1776 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1777 };
1778
1779 static void rpccli_winreg_FlushKey_done(struct tevent_req *subreq);
1780
1781 struct tevent_req *rpccli_winreg_FlushKey_send(TALLOC_CTX *mem_ctx,
1782 struct tevent_context *ev,
1783 struct rpc_pipe_client *cli,
1784 struct policy_handle *_handle /* [in] [ref] */)
1785 {
1786 struct tevent_req *req;
1787 struct rpccli_winreg_FlushKey_state *state;
1788 struct tevent_req *subreq;
1789
1790 req = tevent_req_create(mem_ctx, &state,
1791 struct rpccli_winreg_FlushKey_state);
1792 if (req == NULL) {
1793 return NULL;
1794 }
1795 state->out_mem_ctx = NULL;
1796 state->dispatch_recv = cli->dispatch_recv;
1797
1798 /* In parameters */
1799 state->orig.in.handle = _handle;
1800
1801 /* Out parameters */
1802
1803 /* Result */
1804 ZERO_STRUCT(state->orig.out.result);
1805
1806 /* make a temporary copy, that we pass to the dispatch function */
1807 state->tmp = state->orig;
1808
1809 subreq = cli->dispatch_send(state, ev, cli,
1810 &ndr_table_winreg,
1811 NDR_WINREG_FLUSHKEY,
1812 &state->tmp);
1813 if (tevent_req_nomem(subreq, req)) {
1814 return tevent_req_post(req, ev);
1815 }
1816 tevent_req_set_callback(subreq, rpccli_winreg_FlushKey_done, req);
1817 return req;
1818 }
1819
1820 static void rpccli_winreg_FlushKey_done(struct tevent_req *subreq)
1821 {
1822 struct tevent_req *req = tevent_req_callback_data(
1823 subreq, struct tevent_req);
1824 struct rpccli_winreg_FlushKey_state *state = tevent_req_data(
1825 req, struct rpccli_winreg_FlushKey_state);
1826 NTSTATUS status;
1827 TALLOC_CTX *mem_ctx;
1828
1829 if (state->out_mem_ctx) {
1830 mem_ctx = state->out_mem_ctx;
1831 } else {
1832 mem_ctx = state;
1833 }
1834
1835 status = state->dispatch_recv(subreq, mem_ctx);
1836 TALLOC_FREE(subreq);
1837 if (!NT_STATUS_IS_OK(status)) {
1838 tevent_req_nterror(req, status);
1839 return;
1840 }
1841
1842 /* Copy out parameters */
1843
1844 /* Copy result */
1845 state->orig.out.result = state->tmp.out.result;
1846
1847 /* Reset temporary structure */
1848 ZERO_STRUCT(state->tmp);
1849
1850 tevent_req_done(req);
1851 }
1852
1853 NTSTATUS rpccli_winreg_FlushKey_recv(struct tevent_req *req,
1854 TALLOC_CTX *mem_ctx,
1855 WERROR *result)
1856 {
1857 struct rpccli_winreg_FlushKey_state *state = tevent_req_data(
1858 req, struct rpccli_winreg_FlushKey_state);
1859 NTSTATUS status;
1860
1861 if (tevent_req_is_nterror(req, &status)) {
1862 tevent_req_received(req);
1863 return status;
1864 }
1865
1866 /* Steal possbile out parameters to the callers context */
1867 talloc_steal(mem_ctx, state->out_mem_ctx);
1868
1869 /* Return result */
1870 *result = state->orig.out.result;
1871
1872 tevent_req_received(req);
1873 return NT_STATUS_OK;
1874 }
1875
1876 NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli,
1877 TALLOC_CTX *mem_ctx,
1878 struct policy_handle *handle /* [in] [ref] */,
1879 WERROR *werror)
1880 {
1881 struct winreg_FlushKey r;
1882 NTSTATUS status;
1883
1884 /* In parameters */
1885 r.in.handle = handle;
1886
1887 status = cli->dispatch(cli,
1888 mem_ctx,
1889 &ndr_table_winreg,
1890 NDR_WINREG_FLUSHKEY,
1891 &r);
1892
1893 if (!NT_STATUS_IS_OK(status)) {
1894 return status;
1895 }
1896
1897 if (NT_STATUS_IS_ERR(status)) {
1898 return status;
1899 }
1900
1901 /* Return variables */
1902
1903 /* Return result */
1904 if (werror) {
1905 *werror = r.out.result;
1906 }
1907
1908 return werror_to_ntstatus(r.out.result);
1909 }
1910
1911 struct rpccli_winreg_GetKeySecurity_state {
1912 struct winreg_GetKeySecurity orig;
1913 struct winreg_GetKeySecurity tmp;
1914 TALLOC_CTX *out_mem_ctx;
1915 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1916 };
1917
1918 static void rpccli_winreg_GetKeySecurity_done(struct tevent_req *subreq);
1919
1920 struct tevent_req *rpccli_winreg_GetKeySecurity_send(TALLOC_CTX *mem_ctx,
1921 struct tevent_context *ev,
1922 struct rpc_pipe_client *cli,
1923 struct policy_handle *_handle /* [in] [ref] */,
1924 uint32_t _sec_info /* [in] */,
1925 struct KeySecurityData *_sd /* [in,out] [ref] */)
1926 {
1927 struct tevent_req *req;
1928 struct rpccli_winreg_GetKeySecurity_state *state;
1929 struct tevent_req *subreq;
1930
1931 req = tevent_req_create(mem_ctx, &state,
1932 struct rpccli_winreg_GetKeySecurity_state);
1933 if (req == NULL) {
1934 return NULL;
1935 }
1936 state->out_mem_ctx = NULL;
1937 state->dispatch_recv = cli->dispatch_recv;
1938
1939 /* In parameters */
1940 state->orig.in.handle = _handle;
1941 state->orig.in.sec_info = _sec_info;
1942 state->orig.in.sd = _sd;
1943
1944 /* Out parameters */
1945 state->orig.out.sd = _sd;
1946
1947 /* Result */
1948 ZERO_STRUCT(state->orig.out.result);
1949
1950 state->out_mem_ctx = talloc_named_const(state, 0,
1951 "rpccli_winreg_GetKeySecurity_out_memory");
1952 if (tevent_req_nomem(state->out_mem_ctx, req)) {
1953 return tevent_req_post(req, ev);
1954 }
1955
1956 /* make a temporary copy, that we pass to the dispatch function */
1957 state->tmp = state->orig;
1958
1959 subreq = cli->dispatch_send(state, ev, cli,
1960 &ndr_table_winreg,
1961 NDR_WINREG_GETKEYSECURITY,
1962 &state->tmp);
1963 if (tevent_req_nomem(subreq, req)) {
1964 return tevent_req_post(req, ev);
1965 }
1966 tevent_req_set_callback(subreq, rpccli_winreg_GetKeySecurity_done, req);
1967 return req;
1968 }
1969
1970 static void rpccli_winreg_GetKeySecurity_done(struct tevent_req *subreq)
1971 {
1972 struct tevent_req *req = tevent_req_callback_data(
1973 subreq, struct tevent_req);
1974 struct rpccli_winreg_GetKeySecurity_state *state = tevent_req_data(
1975 req, struct rpccli_winreg_GetKeySecurity_state);
1976 NTSTATUS status;
1977 TALLOC_CTX *mem_ctx;
1978
1979 if (state->out_mem_ctx) {
1980 mem_ctx = state->out_mem_ctx;
1981 } else {
1982 mem_ctx = state;
1983 }
1984
1985 status = state->dispatch_recv(subreq, mem_ctx);
1986 TALLOC_FREE(subreq);
1987 if (!NT_STATUS_IS_OK(status)) {
1988 tevent_req_nterror(req, status);
1989 return;
1990 }
1991
1992 /* Copy out parameters */
1993 *state->orig.out.sd = *state->tmp.out.sd;
1994
1995 /* Copy result */
1996 state->orig.out.result = state->tmp.out.result;
1997
1998 /* Reset temporary structure */
1999 ZERO_STRUCT(state->tmp);
2000
2001 tevent_req_done(req);
2002 }
2003
2004 NTSTATUS rpccli_winreg_GetKeySecurity_recv(struct tevent_req *req,
2005 TALLOC_CTX *mem_ctx,
2006 WERROR *result)
2007 {
2008 struct rpccli_winreg_GetKeySecurity_state *state = tevent_req_data(
2009 req, struct rpccli_winreg_GetKeySecurity_state);
2010 NTSTATUS status;
2011
2012 if (tevent_req_is_nterror(req, &status)) {
2013 tevent_req_received(req);
2014 return status;
2015 }
2016
2017 /* Steal possbile out parameters to the callers context */
2018 talloc_steal(mem_ctx, state->out_mem_ctx);
2019
2020 /* Return result */
2021 *result = state->orig.out.result;
2022
2023 tevent_req_received(req);
2024 return NT_STATUS_OK;
2025 }
2026
2027 NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli,
2028 TALLOC_CTX *mem_ctx,
2029 struct policy_handle *handle /* [in] [ref] */,
2030 uint32_t sec_info /* [in] */,
2031 struct KeySecurityData *sd /* [in,out] [ref] */,
2032 WERROR *werror)
2033 {
2034 struct winreg_GetKeySecurity r;
2035 NTSTATUS status;
2036
2037 /* In parameters */
2038 r.in.handle = handle;
2039 r.in.sec_info = sec_info;
2040 r.in.sd = sd;
2041
2042 status = cli->dispatch(cli,
2043 mem_ctx,
2044 &ndr_table_winreg,
2045 NDR_WINREG_GETKEYSECURITY,
2046 &r);
2047
2048 if (!NT_STATUS_IS_OK(status)) {
2049 return status;
2050 }
2051
2052 if (NT_STATUS_IS_ERR(status)) {
2053 return status;
2054 }
2055
2056 /* Return variables */
2057 *sd = *r.out.sd;
2058
2059 /* Return result */
2060 if (werror) {
2061 *werror = r.out.result;
2062 }
2063
2064 return werror_to_ntstatus(r.out.result);
2065 }
2066
2067 struct rpccli_winreg_LoadKey_state {
2068 struct winreg_LoadKey orig;
2069 struct winreg_LoadKey tmp;
2070 TALLOC_CTX *out_mem_ctx;
2071 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2072 };
2073
2074 static void rpccli_winreg_LoadKey_done(struct tevent_req *subreq);
2075
2076 struct tevent_req *rpccli_winreg_LoadKey_send(TALLOC_CTX *mem_ctx,
2077 struct tevent_context *ev,
2078 struct rpc_pipe_client *cli,
2079 struct policy_handle *_handle /* [in] [ref] */,
2080 struct winreg_String *_keyname /* [in] [unique] */,
2081 struct winreg_String *_filename /* [in] [unique] */)
2082 {
2083 struct tevent_req *req;
2084 struct rpccli_winreg_LoadKey_state *state;
2085 struct tevent_req *subreq;
2086
2087 req = tevent_req_create(mem_ctx, &state,
2088 struct rpccli_winreg_LoadKey_state);
2089 if (req == NULL) {
2090 return NULL;
2091 }
2092 state->out_mem_ctx = NULL;
2093 state->dispatch_recv = cli->dispatch_recv;
2094
2095 /* In parameters */
2096 state->orig.in.handle = _handle;
2097 state->orig.in.keyname = _keyname;
2098 state->orig.in.filename = _filename;
2099
2100 /* Out parameters */
2101
2102 /* Result */
2103 ZERO_STRUCT(state->orig.out.result);
2104
2105 /* make a temporary copy, that we pass to the dispatch function */
2106 state->tmp = state->orig;
2107
2108 subreq = cli->dispatch_send(state, ev, cli,
2109 &ndr_table_winreg,
2110 NDR_WINREG_LOADKEY,
2111 &state->tmp);
2112 if (tevent_req_nomem(subreq, req)) {
2113 return tevent_req_post(req, ev);
2114 }
2115 tevent_req_set_callback(subreq, rpccli_winreg_LoadKey_done, req);
2116 return req;
2117 }
2118
2119 static void rpccli_winreg_LoadKey_done(struct tevent_req *subreq)
2120 {
2121 struct tevent_req *req = tevent_req_callback_data(
2122 subreq, struct tevent_req);
2123 struct rpccli_winreg_LoadKey_state *state = tevent_req_data(
2124 req, struct rpccli_winreg_LoadKey_state);
2125 NTSTATUS status;
2126 TALLOC_CTX *mem_ctx;
2127
2128 if (state->out_mem_ctx) {
2129 mem_ctx = state->out_mem_ctx;
2130 } else {
2131 mem_ctx = state;
2132 }
2133
2134 status = state->dispatch_recv(subreq, mem_ctx);
2135 TALLOC_FREE(subreq);
2136 if (!NT_STATUS_IS_OK(status)) {
2137 tevent_req_nterror(req, status);
2138 return;
2139 }
2140
2141 /* Copy out parameters */
2142
2143 /* Copy result */
2144 state->orig.out.result = state->tmp.out.result;
2145
2146 /* Reset temporary structure */
2147 ZERO_STRUCT(state->tmp);
2148
2149 tevent_req_done(req);
2150 }
2151
2152 NTSTATUS rpccli_winreg_LoadKey_recv(struct tevent_req *req,
2153 TALLOC_CTX *mem_ctx,
2154 WERROR *result)
2155 {
2156 struct rpccli_winreg_LoadKey_state *state = tevent_req_data(
2157 req, struct rpccli_winreg_LoadKey_state);
2158 NTSTATUS status;
2159
2160 if (tevent_req_is_nterror(req, &status)) {
2161 tevent_req_received(req);
2162 return status;
2163 }
2164
2165 /* Steal possbile out parameters to the callers context */
2166 talloc_steal(mem_ctx, state->out_mem_ctx);
2167
2168 /* Return result */
2169 *result = state->orig.out.result;
2170
2171 tevent_req_received(req);
2172 return NT_STATUS_OK;
2173 }
2174
2175 NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli,
2176 TALLOC_CTX *mem_ctx,
2177 struct policy_handle *handle /* [in] [ref] */,
2178 struct winreg_String *keyname /* [in] [unique] */,
2179 struct winreg_String *filename /* [in] [unique] */,
2180 WERROR *werror)
2181 {
2182 struct winreg_LoadKey r;
2183 NTSTATUS status;
2184
2185 /* In parameters */
2186 r.in.handle = handle;
2187 r.in.keyname = keyname;
2188 r.in.filename = filename;
2189
2190 status = cli->dispatch(cli,
2191 mem_ctx,
2192 &ndr_table_winreg,
2193 NDR_WINREG_LOADKEY,
2194 &r);
2195
2196 if (!NT_STATUS_IS_OK(status)) {
2197 return status;
2198 }
2199
2200 if (NT_STATUS_IS_ERR(status)) {
2201 return status;
2202 }
2203
2204 /* Return variables */
2205
2206 /* Return result */
2207 if (werror) {
2208 *werror = r.out.result;
2209 }
2210
2211 return werror_to_ntstatus(r.out.result);
2212 }
2213
2214 struct rpccli_winreg_NotifyChangeKeyValue_state {
2215 struct winreg_NotifyChangeKeyValue orig;
2216 struct winreg_NotifyChangeKeyValue tmp;
2217 TALLOC_CTX *out_mem_ctx;
2218 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2219 };
2220
2221 static void rpccli_winreg_NotifyChangeKeyValue_done(struct tevent_req *subreq);
2222
2223 struct tevent_req *rpccli_winreg_NotifyChangeKeyValue_send(TALLOC_CTX *mem_ctx,
2224 struct tevent_context *ev,
2225 struct rpc_pipe_client *cli,
2226 struct policy_handle *_handle /* [in] [ref] */,
2227 uint8_t _watch_subtree /* [in] */,
2228 uint32_t _notify_filter /* [in] */,
2229 uint32_t _unknown /* [in] */,
2230 struct winreg_String _string1 /* [in] */,
2231 struct winreg_String _string2 /* [in] */,
2232 uint32_t _unknown2 /* [in] */)
2233 {
2234 struct tevent_req *req;
2235 struct rpccli_winreg_NotifyChangeKeyValue_state *state;
2236 struct tevent_req *subreq;
2237
2238 req = tevent_req_create(mem_ctx, &state,
2239 struct rpccli_winreg_NotifyChangeKeyValue_state);
2240 if (req == NULL) {
2241 return NULL;
2242 }
2243 state->out_mem_ctx = NULL;
2244 state->dispatch_recv = cli->dispatch_recv;
2245
2246 /* In parameters */
2247 state->orig.in.handle = _handle;
2248 state->orig.in.watch_subtree = _watch_subtree;
2249 state->orig.in.notify_filter = _notify_filter;
2250 state->orig.in.unknown = _unknown;
2251 state->orig.in.string1 = _string1;
2252 state->orig.in.string2 = _string2;
2253 state->orig.in.unknown2 = _unknown2;
2254
2255 /* Out parameters */
2256
2257 /* Result */
2258 ZERO_STRUCT(state->orig.out.result);
2259
2260 /* make a temporary copy, that we pass to the dispatch function */
2261 state->tmp = state->orig;
2262
2263 subreq = cli->dispatch_send(state, ev, cli,
2264 &ndr_table_winreg,
2265 NDR_WINREG_NOTIFYCHANGEKEYVALUE,
2266 &state->tmp);
2267 if (tevent_req_nomem(subreq, req)) {
2268 return tevent_req_post(req, ev);
2269 }
2270 tevent_req_set_callback(subreq, rpccli_winreg_NotifyChangeKeyValue_done, req);
2271 return req;
2272 }
2273
2274 static void rpccli_winreg_NotifyChangeKeyValue_done(struct tevent_req *subreq)
2275 {
2276 struct tevent_req *req = tevent_req_callback_data(
2277 subreq, struct tevent_req);
2278 struct rpccli_winreg_NotifyChangeKeyValue_state *state = tevent_req_data(
2279 req, struct rpccli_winreg_NotifyChangeKeyValue_state);
2280 NTSTATUS status;
2281 TALLOC_CTX *mem_ctx;
2282
2283 if (state->out_mem_ctx) {
2284 mem_ctx = state->out_mem_ctx;
2285 } else {
2286 mem_ctx = state;
2287 }
2288
2289 status = state->dispatch_recv(subreq, mem_ctx);
2290 TALLOC_FREE(subreq);
2291 if (!NT_STATUS_IS_OK(status)) {
2292 tevent_req_nterror(req, status);
2293 return;
2294 }
2295
2296 /* Copy out parameters */
2297
2298 /* Copy result */
2299 state->orig.out.result = state->tmp.out.result;
2300
2301 /* Reset temporary structure */
2302 ZERO_STRUCT(state->tmp);
2303
2304 tevent_req_done(req);
2305 }
2306
2307 NTSTATUS rpccli_winreg_NotifyChangeKeyValue_recv(struct tevent_req *req,
2308 TALLOC_CTX *mem_ctx,
2309 WERROR *result)
2310 {
2311 struct rpccli_winreg_NotifyChangeKeyValue_state *state = tevent_req_data(
2312 req, struct rpccli_winreg_NotifyChangeKeyValue_state);
2313 NTSTATUS status;
2314
2315 if (tevent_req_is_nterror(req, &status)) {
2316 tevent_req_received(req);
2317 return status;
2318 }
2319
2320 /* Steal possbile out parameters to the callers context */
2321 talloc_steal(mem_ctx, state->out_mem_ctx);
2322
2323 /* Return result */
2324 *result = state->orig.out.result;
2325
2326 tevent_req_received(req);
2327 return NT_STATUS_OK;
2328 }
2329
2330 NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,
2331 TALLOC_CTX *mem_ctx,
2332 struct policy_handle *handle /* [in] [ref] */,
2333 uint8_t watch_subtree /* [in] */,
2334 uint32_t notify_filter /* [in] */,
2335 uint32_t unknown /* [in] */,
2336 struct winreg_String string1 /* [in] */,
2337 struct winreg_String string2 /* [in] */,
2338 uint32_t unknown2 /* [in] */,
2339 WERROR *werror)
2340 {
2341 struct winreg_NotifyChangeKeyValue r;
2342 NTSTATUS status;
2343
2344 /* In parameters */
2345 r.in.handle = handle;
2346 r.in.watch_subtree = watch_subtree;
2347 r.in.notify_filter = notify_filter;
2348 r.in.unknown = unknown;
2349 r.in.string1 = string1;
2350 r.in.string2 = string2;
2351 r.in.unknown2 = unknown2;
2352
2353 status = cli->dispatch(cli,
2354 mem_ctx,
2355 &ndr_table_winreg,
2356 NDR_WINREG_NOTIFYCHANGEKEYVALUE,
2357 &r);
2358
2359 if (!NT_STATUS_IS_OK(status)) {
2360 return status;
2361 }
2362
2363 if (NT_STATUS_IS_ERR(status)) {
2364 return status;
2365 }
2366
2367 /* Return variables */
2368
2369 /* Return result */
2370 if (werror) {
2371 *werror = r.out.result;
2372 }
2373
2374 return werror_to_ntstatus(r.out.result);
2375 }
2376
2377 struct rpccli_winreg_OpenKey_state {
2378 struct winreg_OpenKey orig;
2379 struct winreg_OpenKey tmp;
2380 TALLOC_CTX *out_mem_ctx;
2381 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2382 };
2383
2384 static void rpccli_winreg_OpenKey_done(struct tevent_req *subreq);
2385
2386 struct tevent_req *rpccli_winreg_OpenKey_send(TALLOC_CTX *mem_ctx,
2387 struct tevent_context *ev,
2388 struct rpc_pipe_client *cli,
2389 struct policy_handle *_parent_handle /* [in] [ref] */,
2390 struct winreg_String _keyname /* [in] */,
2391 uint32_t _unknown /* [in] */,
2392 uint32_t _access_mask /* [in] */,
2393 struct policy_handle *_handle /* [out] [ref] */)
2394 {
2395 struct tevent_req *req;
2396 struct rpccli_winreg_OpenKey_state *state;
2397 struct tevent_req *subreq;
2398
2399 req = tevent_req_create(mem_ctx, &state,
2400 struct rpccli_winreg_OpenKey_state);
2401 if (req == NULL) {
2402 return NULL;
2403 }
2404 state->out_mem_ctx = NULL;
2405 state->dispatch_recv = cli->dispatch_recv;
2406
2407 /* In parameters */
2408 state->orig.in.parent_handle = _parent_handle;
2409 state->orig.in.keyname = _keyname;
2410 state->orig.in.unknown = _unknown;
2411 state->orig.in.access_mask = _access_mask;
2412
2413 /* Out parameters */
2414 state->orig.out.handle = _handle;
2415
2416 /* Result */
2417 ZERO_STRUCT(state->orig.out.result);
2418
2419 state->out_mem_ctx = talloc_named_const(state, 0,
2420 "rpccli_winreg_OpenKey_out_memory");
2421 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2422 return tevent_req_post(req, ev);
2423 }
2424
2425 /* make a temporary copy, that we pass to the dispatch function */
2426 state->tmp = state->orig;
2427
2428 subreq = cli->dispatch_send(state, ev, cli,
2429 &ndr_table_winreg,
2430 NDR_WINREG_OPENKEY,
2431 &state->tmp);
2432 if (tevent_req_nomem(subreq, req)) {
2433 return tevent_req_post(req, ev);
2434 }
2435 tevent_req_set_callback(subreq, rpccli_winreg_OpenKey_done, req);
2436 return req;
2437 }
2438
2439 static void rpccli_winreg_OpenKey_done(struct tevent_req *subreq)
2440 {
2441 struct tevent_req *req = tevent_req_callback_data(
2442 subreq, struct tevent_req);
2443 struct rpccli_winreg_OpenKey_state *state = tevent_req_data(
2444 req, struct rpccli_winreg_OpenKey_state);
2445 NTSTATUS status;
2446 TALLOC_CTX *mem_ctx;
2447
2448 if (state->out_mem_ctx) {
2449 mem_ctx = state->out_mem_ctx;
2450 } else {
2451 mem_ctx = state;
2452 }
2453
2454 status = state->dispatch_recv(subreq, mem_ctx);
2455 TALLOC_FREE(subreq);
2456 if (!NT_STATUS_IS_OK(status)) {
2457 tevent_req_nterror(req, status);
2458 return;
2459 }
2460
2461 /* Copy out parameters */
2462 *state->orig.out.handle = *state->tmp.out.handle;
2463
2464 /* Copy result */
2465 state->orig.out.result = state->tmp.out.result;
2466
2467 /* Reset temporary structure */
2468 ZERO_STRUCT(state->tmp);
2469
2470 tevent_req_done(req);
2471 }
2472
2473 NTSTATUS rpccli_winreg_OpenKey_recv(struct tevent_req *req,
2474 TALLOC_CTX *mem_ctx,
2475 WERROR *result)
2476 {
2477 struct rpccli_winreg_OpenKey_state *state = tevent_req_data(
2478 req, struct rpccli_winreg_OpenKey_state);
2479 NTSTATUS status;
2480
2481 if (tevent_req_is_nterror(req, &status)) {
2482 tevent_req_received(req);
2483 return status;
2484 }
2485
2486 /* Steal possbile out parameters to the callers context */
2487 talloc_steal(mem_ctx, state->out_mem_ctx);
2488
2489 /* Return result */
2490 *result = state->orig.out.result;
2491
2492 tevent_req_received(req);
2493 return NT_STATUS_OK;
2494 }
2495
2496 NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,
2497 TALLOC_CTX *mem_ctx,
2498 struct policy_handle *parent_handle /* [in] [ref] */,
2499 struct winreg_String keyname /* [in] */,
2500 uint32_t unknown /* [in] */,
2501 uint32_t access_mask /* [in] */,
2502 struct policy_handle *handle /* [out] [ref] */,
2503 WERROR *werror)
2504 {
2505 struct winreg_OpenKey r;
2506 NTSTATUS status;
2507
2508 /* In parameters */
2509 r.in.parent_handle = parent_handle;
2510 r.in.keyname = keyname;
2511 r.in.unknown = unknown;
2512 r.in.access_mask = access_mask;
2513
2514 status = cli->dispatch(cli,
2515 mem_ctx,
2516 &ndr_table_winreg,
2517 NDR_WINREG_OPENKEY,
2518 &r);
2519
2520 if (!NT_STATUS_IS_OK(status)) {
2521 return status;
2522 }
2523
2524 if (NT_STATUS_IS_ERR(status)) {
2525 return status;
2526 }
2527
2528 /* Return variables */
2529 *handle = *r.out.handle;
2530
2531 /* Return result */
2532 if (werror) {
2533 *werror = r.out.result;
2534 }
2535
2536 return werror_to_ntstatus(r.out.result);
2537 }
2538
2539 struct rpccli_winreg_QueryInfoKey_state {
2540 struct winreg_QueryInfoKey orig;
2541 struct winreg_QueryInfoKey tmp;
2542 TALLOC_CTX *out_mem_ctx;
2543 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2544 };
2545
2546 static void rpccli_winreg_QueryInfoKey_done(struct tevent_req *subreq);
2547
2548 struct tevent_req *rpccli_winreg_QueryInfoKey_send(TALLOC_CTX *mem_ctx,
2549 struct tevent_context *ev,
2550 struct rpc_pipe_client *cli,
2551 struct policy_handle *_handle /* [in] [ref] */,
2552 struct winreg_String *_classname /* [in,out] [ref] */,
2553 uint32_t *_num_subkeys /* [out] [ref] */,
2554 uint32_t *_max_subkeylen /* [out] [ref] */,
2555 uint32_t *_max_classlen /* [out] [ref] */,
2556 uint32_t *_num_values /* [out] [ref] */,
2557 uint32_t *_max_valnamelen /* [out] [ref] */,
2558 uint32_t *_max_valbufsize /* [out] [ref] */,
2559 uint32_t *_secdescsize /* [out] [ref] */,
2560 NTTIME *_last_changed_time /* [out] [ref] */)
2561 {
2562 struct tevent_req *req;
2563 struct rpccli_winreg_QueryInfoKey_state *state;
2564 struct tevent_req *subreq;
2565
2566 req = tevent_req_create(mem_ctx, &state,
2567 struct rpccli_winreg_QueryInfoKey_state);
2568 if (req == NULL) {
2569 return NULL;
2570 }
2571 state->out_mem_ctx = NULL;
2572 state->dispatch_recv = cli->dispatch_recv;
2573
2574 /* In parameters */
2575 state->orig.in.handle = _handle;
2576 state->orig.in.classname = _classname;
2577
2578 /* Out parameters */
2579 state->orig.out.classname = _classname;
2580 state->orig.out.num_subkeys = _num_subkeys;
2581 state->orig.out.max_subkeylen = _max_subkeylen;
2582 state->orig.out.max_classlen = _max_classlen;
2583 state->orig.out.num_values = _num_values;
2584 state->orig.out.max_valnamelen = _max_valnamelen;
2585 state->orig.out.max_valbufsize = _max_valbufsize;
2586 state->orig.out.secdescsize = _secdescsize;
2587 state->orig.out.last_changed_time = _last_changed_time;
2588
2589 /* Result */
2590 ZERO_STRUCT(state->orig.out.result);
2591
2592 state->out_mem_ctx = talloc_named_const(state, 0,
2593 "rpccli_winreg_QueryInfoKey_out_memory");
2594 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2595 return tevent_req_post(req, ev);
2596 }
2597
2598 /* make a temporary copy, that we pass to the dispatch function */
2599 state->tmp = state->orig;
2600
2601 subreq = cli->dispatch_send(state, ev, cli,
2602 &ndr_table_winreg,
2603 NDR_WINREG_QUERYINFOKEY,
2604 &state->tmp);
2605 if (tevent_req_nomem(subreq, req)) {
2606 return tevent_req_post(req, ev);
2607 }
2608 tevent_req_set_callback(subreq, rpccli_winreg_QueryInfoKey_done, req);
2609 return req;
2610 }
2611
2612 static void rpccli_winreg_QueryInfoKey_done(struct tevent_req *subreq)
2613 {
2614 struct tevent_req *req = tevent_req_callback_data(
2615 subreq, struct tevent_req);
2616 struct rpccli_winreg_QueryInfoKey_state *state = tevent_req_data(
2617 req, struct rpccli_winreg_QueryInfoKey_state);
2618 NTSTATUS status;
2619 TALLOC_CTX *mem_ctx;
2620
2621 if (state->out_mem_ctx) {
2622 mem_ctx = state->out_mem_ctx;
2623 } else {
2624 mem_ctx = state;
2625 }
2626
2627 status = state->dispatch_recv(subreq, mem_ctx);
2628 TALLOC_FREE(subreq);
2629 if (!NT_STATUS_IS_OK(status)) {
2630 tevent_req_nterror(req, status);
2631 return;
2632 }
2633
2634 /* Copy out parameters */
2635 *state->orig.out.classname = *state->tmp.out.classname;
2636 *state->orig.out.num_subkeys = *state->tmp.out.num_subkeys;
2637 *state->orig.out.max_subkeylen = *state->tmp.out.max_subkeylen;
2638 *state->orig.out.max_classlen = *state->tmp.out.max_classlen;
2639 *state->orig.out.num_values = *state->tmp.out.num_values;
2640 *state->orig.out.max_valnamelen = *state->tmp.out.max_valnamelen;
2641 *state->orig.out.max_valbufsize = *state->tmp.out.max_valbufsize;
2642 *state->orig.out.secdescsize = *state->tmp.out.secdescsize;
2643 *state->orig.out.last_changed_time = *state->tmp.out.last_changed_time;
2644
2645 /* Copy result */
2646 state->orig.out.result = state->tmp.out.result;
2647
2648 /* Reset temporary structure */
2649 ZERO_STRUCT(state->tmp);
2650
2651 tevent_req_done(req);
2652 }
2653
2654 NTSTATUS rpccli_winreg_QueryInfoKey_recv(struct tevent_req *req,
2655 TALLOC_CTX *mem_ctx,
2656 WERROR *result)
2657 {
2658 struct rpccli_winreg_QueryInfoKey_state *state = tevent_req_data(
2659 req, struct rpccli_winreg_QueryInfoKey_state);
2660 NTSTATUS status;
2661
2662 if (tevent_req_is_nterror(req, &status)) {
2663 tevent_req_received(req);
2664 return status;
2665 }
2666
2667 /* Steal possbile out parameters to the callers context */
2668 talloc_steal(mem_ctx, state->out_mem_ctx);
2669
2670 /* Return result */
2671 *result = state->orig.out.result;
2672
2673 tevent_req_received(req);
2674 return NT_STATUS_OK;
2675 }
2676
2677 NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli,
2678 TALLOC_CTX *mem_ctx,
2679 struct policy_handle *handle /* [in] [ref] */,
2680 struct winreg_String *classname /* [in,out] [ref] */,
2681 uint32_t *num_subkeys /* [out] [ref] */,
2682 uint32_t *max_subkeylen /* [out] [ref] */,
2683 uint32_t *max_classlen /* [out] [ref] */,
2684 uint32_t *num_values /* [out] [ref] */,
2685 uint32_t *max_valnamelen /* [out] [ref] */,
2686 uint32_t *max_valbufsize /* [out] [ref] */,
2687 uint32_t *secdescsize /* [out] [ref] */,
2688 NTTIME *last_changed_time /* [out] [ref] */,
2689 WERROR *werror)
2690 {
2691 struct winreg_QueryInfoKey r;
2692 NTSTATUS status;
2693
2694 /* In parameters */
2695 r.in.handle = handle;
2696 r.in.classname = classname;
2697
2698 status = cli->dispatch(cli,
2699 mem_ctx,
2700 &ndr_table_winreg,
2701 NDR_WINREG_QUERYINFOKEY,
2702 &r);
2703
2704 if (!NT_STATUS_IS_OK(status)) {
2705 return status;
2706 }
2707
2708 if (NT_STATUS_IS_ERR(status)) {
2709 return status;
2710 }
2711
2712 /* Return variables */
2713 *classname = *r.out.classname;
2714 *num_subkeys = *r.out.num_subkeys;
2715 *max_subkeylen = *r.out.max_subkeylen;
2716 *max_classlen = *r.out.max_classlen;
2717 *num_values = *r.out.num_values;
2718 *max_valnamelen = *r.out.max_valnamelen;
2719 *max_valbufsize = *r.out.max_valbufsize;
2720 *secdescsize = *r.out.secdescsize;
2721 *last_changed_time = *r.out.last_changed_time;
2722
2723 /* Return result */
2724 if (werror) {
2725 *werror = r.out.result;
2726 }
2727
2728 return werror_to_ntstatus(r.out.result);
2729 }
2730
2731 struct rpccli_winreg_QueryValue_state {
2732 struct winreg_QueryValue orig;
2733 struct winreg_QueryValue tmp;
2734 TALLOC_CTX *out_mem_ctx;
2735 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2736 };
2737
2738 static void rpccli_winreg_QueryValue_done(struct tevent_req *subreq);
2739
2740 struct tevent_req *rpccli_winreg_QueryValue_send(TALLOC_CTX *mem_ctx,
2741 struct tevent_context *ev,
2742 struct rpc_pipe_client *cli,
2743 struct policy_handle *_handle /* [in] [ref] */,
2744 struct winreg_String *_value_name /* [in] [ref] */,
2745 enum winreg_Type *_type /* [in,out] [unique] */,
2746 uint8_t *_data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
2747 uint32_t *_data_size /* [in,out] [unique] */,
2748 uint32_t *_data_length /* [in,out] [unique] */)
2749 {
2750 struct tevent_req *req;
2751 struct rpccli_winreg_QueryValue_state *state;
2752 struct tevent_req *subreq;
2753
2754 req = tevent_req_create(mem_ctx, &state,
2755 struct rpccli_winreg_QueryValue_state);
2756 if (req == NULL) {
2757 return NULL;
2758 }
2759 state->out_mem_ctx = NULL;
2760 state->dispatch_recv = cli->dispatch_recv;
2761
2762 /* In parameters */
2763 state->orig.in.handle = _handle;
2764 state->orig.in.value_name = _value_name;
2765 state->orig.in.type = _type;
2766 state->orig.in.data = _data;
2767 state->orig.in.data_size = _data_size;
2768 state->orig.in.data_length = _data_length;
2769
2770 /* Out parameters */
2771 state->orig.out.type = _type;
2772 state->orig.out.data = _data;
2773 state->orig.out.data_size = _data_size;
2774 state->orig.out.data_length = _data_length;
2775
2776 /* Result */
2777 ZERO_STRUCT(state->orig.out.result);
2778
2779 state->out_mem_ctx = talloc_named_const(state, 0,
2780 "rpccli_winreg_QueryValue_out_memory");
2781 if (tevent_req_nomem(state->out_mem_ctx, req)) {
2782 return tevent_req_post(req, ev);
2783 }
2784
2785 /* make a temporary copy, that we pass to the dispatch function */
2786 state->tmp = state->orig;
2787
2788 subreq = cli->dispatch_send(state, ev, cli,
2789 &ndr_table_winreg,
2790 NDR_WINREG_QUERYVALUE,
2791 &state->tmp);
2792 if (tevent_req_nomem(subreq, req)) {
2793 return tevent_req_post(req, ev);
2794 }
2795 tevent_req_set_callback(subreq, rpccli_winreg_QueryValue_done, req);
2796 return req;
2797 }
2798
2799 static void rpccli_winreg_QueryValue_done(struct tevent_req *subreq)
2800 {
2801 struct tevent_req *req = tevent_req_callback_data(
2802 subreq, struct tevent_req);
2803 struct rpccli_winreg_QueryValue_state *state = tevent_req_data(
2804 req, struct rpccli_winreg_QueryValue_state);
2805 NTSTATUS status;
2806 TALLOC_CTX *mem_ctx;
2807
2808 if (state->out_mem_ctx) {
2809 mem_ctx = state->out_mem_ctx;
2810 } else {
2811 mem_ctx = state;
2812 }
2813
2814 status = state->dispatch_recv(subreq, mem_ctx);
2815 TALLOC_FREE(subreq);
2816 if (!NT_STATUS_IS_OK(status)) {
2817 tevent_req_nterror(req, status);
2818 return;
2819 }
2820
2821 /* Copy out parameters */
2822 if (state->orig.out.type && state->tmp.out.type) {
2823 *state->orig.out.type = *state->tmp.out.type;
2824 }
2825 if (state->orig.out.data && state->tmp.out.data) {
2826 memcpy(state->orig.out.data, state->tmp.out.data, (*state->tmp.in.data_size) * sizeof(*state->orig.out.data));
2827 }
2828 if (state->orig.out.data_size && state->tmp.out.data_size) {
2829 *state->orig.out.data_size = *state->tmp.out.data_size;
2830 }
2831 if (state->orig.out.data_length && state->tmp.out.data_length) {
2832 *state->orig.out.data_length = *state->tmp.out.data_length;
2833 }
2834
2835 /* Copy result */
2836 state->orig.out.result = state->tmp.out.result;
2837
2838 /* Reset temporary structure */
2839 ZERO_STRUCT(state->tmp);
2840
2841 tevent_req_done(req);
2842 }
2843
2844 NTSTATUS rpccli_winreg_QueryValue_recv(struct tevent_req *req,
2845 TALLOC_CTX *mem_ctx,
2846 WERROR *result)
2847 {
2848 struct rpccli_winreg_QueryValue_state *state = tevent_req_data(
2849 req, struct rpccli_winreg_QueryValue_state);
2850 NTSTATUS status;
2851
2852 if (tevent_req_is_nterror(req, &status)) {
2853 tevent_req_received(req);
2854 return status;
2855 }
2856
2857 /* Steal possbile out parameters to the callers context */
2858 talloc_steal(mem_ctx, state->out_mem_ctx);
2859
2860 /* Return result */
2861 *result = state->orig.out.result;
2862
2863 tevent_req_received(req);
2864 return NT_STATUS_OK;
2865 }
2866
2867 NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli,
2868 TALLOC_CTX *mem_ctx,
2869 struct policy_handle *handle /* [in] [ref] */,
2870 struct winreg_String *value_name /* [in] [ref] */,
2871 enum winreg_Type *type /* [in,out] [unique] */,
2872 uint8_t *data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
2873 uint32_t *data_size /* [in,out] [unique] */,
2874 uint32_t *data_length /* [in,out] [unique] */,
2875 WERROR *werror)
2876 {
2877 struct winreg_QueryValue r;
2878 NTSTATUS status;
2879
2880 /* In parameters */
2881 r.in.handle = handle;
2882 r.in.value_name = value_name;
2883 r.in.type = type;
2884 r.in.data = data;
2885 r.in.data_size = data_size;
2886 r.in.data_length = data_length;
2887
2888 status = cli->dispatch(cli,
2889 mem_ctx,
2890 &ndr_table_winreg,
2891 NDR_WINREG_QUERYVALUE,
2892 &r);
2893
2894 if (!NT_STATUS_IS_OK(status)) {
2895 return status;
2896 }
2897
2898 if (NT_STATUS_IS_ERR(status)) {
2899 return status;
2900 }
2901
2902 /* Return variables */
2903 if (type && r.out.type) {
2904 *type = *r.out.type;
2905 }
2906 if (data && r.out.data) {
2907 memcpy(data, r.out.data, (*r.in.data_size) * sizeof(*data));
2908 }
2909 if (data_size && r.out.data_size) {
2910 *data_size = *r.out.data_size;
2911 }
2912 if (data_length && r.out.data_length) {
2913 *data_length = *r.out.data_length;
2914 }
2915
2916 /* Return result */
2917 if (werror) {
2918 *werror = r.out.result;
2919 }
2920
2921 return werror_to_ntstatus(r.out.result);
2922 }
2923
2924 struct rpccli_winreg_ReplaceKey_state {
2925 struct winreg_ReplaceKey orig;
2926 struct winreg_ReplaceKey tmp;
2927 TALLOC_CTX *out_mem_ctx;
2928 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
2929 };
2930
2931 static void rpccli_winreg_ReplaceKey_done(struct tevent_req *subreq);
2932
2933 struct tevent_req *rpccli_winreg_ReplaceKey_send(TALLOC_CTX *mem_ctx,
2934 struct tevent_context *ev,
2935 struct rpc_pipe_client *cli)
2936 {
2937 struct tevent_req *req;
2938 struct rpccli_winreg_ReplaceKey_state *state;
2939 struct tevent_req *subreq;
2940
2941 req = tevent_req_create(mem_ctx, &state,
2942 struct rpccli_winreg_ReplaceKey_state);
2943 if (req == NULL) {
2944 return NULL;
2945 }
2946 state->out_mem_ctx = NULL;
2947 state->dispatch_recv = cli->dispatch_recv;
2948
2949 /* In parameters */
2950
2951 /* Out parameters */
2952
2953 /* Result */
2954 ZERO_STRUCT(state->orig.out.result);
2955
2956 /* make a temporary copy, that we pass to the dispatch function */
2957 state->tmp = state->orig;
2958
2959 subreq = cli->dispatch_send(state, ev, cli,
2960 &ndr_table_winreg,
2961 NDR_WINREG_REPLACEKEY,
2962 &state->tmp);
2963 if (tevent_req_nomem(subreq, req)) {
2964 return tevent_req_post(req, ev);
2965 }
2966 tevent_req_set_callback(subreq, rpccli_winreg_ReplaceKey_done, req);
2967 return req;
2968 }
2969
2970 static void rpccli_winreg_ReplaceKey_done(struct tevent_req *subreq)
2971 {
2972 struct tevent_req *req = tevent_req_callback_data(
2973 subreq, struct tevent_req);
2974 struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
2975 req, struct rpccli_winreg_ReplaceKey_state);
2976 NTSTATUS status;
2977 TALLOC_CTX *mem_ctx;
2978
2979 if (state->out_mem_ctx) {
2980 mem_ctx = state->out_mem_ctx;
2981 } else {
2982 mem_ctx = state;
2983 }
2984
2985 status = state->dispatch_recv(subreq, mem_ctx);
2986 TALLOC_FREE(subreq);
2987 if (!NT_STATUS_IS_OK(status)) {
2988 tevent_req_nterror(req, status);
2989 return;
2990 }
2991
2992 /* Copy out parameters */
2993
2994 /* Copy result */
2995 state->orig.out.result = state->tmp.out.result;
2996
2997 /* Reset temporary structure */
2998 ZERO_STRUCT(state->tmp);
2999
3000 tevent_req_done(req);
3001 }
3002
3003 NTSTATUS rpccli_winreg_ReplaceKey_recv(struct tevent_req *req,
3004 TALLOC_CTX *mem_ctx,
3005 WERROR *result)
3006 {
3007 struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
3008 req, struct rpccli_winreg_ReplaceKey_state);
3009 NTSTATUS status;
3010
3011 if (tevent_req_is_nterror(req, &status)) {
3012 tevent_req_received(req);
3013 return status;
3014 }
3015
3016 /* Steal possbile out parameters to the callers context */
3017 talloc_steal(mem_ctx, state->out_mem_ctx);
3018
3019 /* Return result */
3020 *result = state->orig.out.result;
3021
3022 tevent_req_received(req);
3023 return NT_STATUS_OK;
3024 }
3025
3026 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
3027 TALLOC_CTX *mem_ctx,
3028 WERROR *werror)
3029 {
3030 struct winreg_ReplaceKey r;
3031 NTSTATUS status;
3032
3033 /* In parameters */
3034
3035 status = cli->dispatch(cli,
3036 mem_ctx,
3037 &ndr_table_winreg,
3038 NDR_WINREG_REPLACEKEY,
3039 &r);
3040
3041 if (!NT_STATUS_IS_OK(status)) {
3042 return status;
3043 }
3044
3045 if (NT_STATUS_IS_ERR(status)) {
3046 return status;
3047 }
3048
3049 /* Return variables */
3050
3051 /* Return result */
3052 if (werror) {
3053 *werror = r.out.result;
3054 }
3055
3056 return werror_to_ntstatus(r.out.result);
3057 }
3058
3059 struct rpccli_winreg_RestoreKey_state {
3060 struct winreg_RestoreKey orig;
3061 struct winreg_RestoreKey tmp;
3062 TALLOC_CTX *out_mem_ctx;
3063 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3064 };
3065
3066 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq);
3067
3068 struct tevent_req *rpccli_winreg_RestoreKey_send(TALLOC_CTX *mem_ctx,
3069 struct tevent_context *ev,
3070 struct rpc_pipe_client *cli,
3071 struct policy_handle *_handle /* [in] [ref] */,
3072 struct winreg_String *_filename /* [in] [ref] */,
3073 uint32_t _flags /* [in] */)
3074 {
3075 struct tevent_req *req;
3076 struct rpccli_winreg_RestoreKey_state *state;
3077 struct tevent_req *subreq;
3078
3079 req = tevent_req_create(mem_ctx, &state,
3080 struct rpccli_winreg_RestoreKey_state);
3081 if (req == NULL) {
3082 return NULL;
3083 }
3084 state->out_mem_ctx = NULL;
3085 state->dispatch_recv = cli->dispatch_recv;
3086
3087 /* In parameters */
3088 state->orig.in.handle = _handle;
3089 state->orig.in.filename = _filename;
3090 state->orig.in.flags = _flags;
3091
3092 /* Out parameters */
3093
3094 /* Result */
3095 ZERO_STRUCT(state->orig.out.result);
3096
3097 /* make a temporary copy, that we pass to the dispatch function */
3098 state->tmp = state->orig;
3099
3100 subreq = cli->dispatch_send(state, ev, cli,
3101 &ndr_table_winreg,
3102 NDR_WINREG_RESTOREKEY,
3103 &state->tmp);
3104 if (tevent_req_nomem(subreq, req)) {
3105 return tevent_req_post(req, ev);
3106 }
3107 tevent_req_set_callback(subreq, rpccli_winreg_RestoreKey_done, req);
3108 return req;
3109 }
3110
3111 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq)
3112 {
3113 struct tevent_req *req = tevent_req_callback_data(
3114 subreq, struct tevent_req);
3115 struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3116 req, struct rpccli_winreg_RestoreKey_state);
3117 NTSTATUS status;
3118 TALLOC_CTX *mem_ctx;
3119
3120 if (state->out_mem_ctx) {
3121 mem_ctx = state->out_mem_ctx;
3122 } else {
3123 mem_ctx = state;
3124 }
3125
3126 status = state->dispatch_recv(subreq, mem_ctx);
3127 TALLOC_FREE(subreq);
3128 if (!NT_STATUS_IS_OK(status)) {
3129 tevent_req_nterror(req, status);
3130 return;
3131 }
3132
3133 /* Copy out parameters */
3134
3135 /* Copy result */
3136 state->orig.out.result = state->tmp.out.result;
3137
3138 /* Reset temporary structure */
3139 ZERO_STRUCT(state->tmp);
3140
3141 tevent_req_done(req);
3142 }
3143
3144 NTSTATUS rpccli_winreg_RestoreKey_recv(struct tevent_req *req,
3145 TALLOC_CTX *mem_ctx,
3146 WERROR *result)
3147 {
3148 struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3149 req, struct rpccli_winreg_RestoreKey_state);
3150 NTSTATUS status;
3151
3152 if (tevent_req_is_nterror(req, &status)) {
3153 tevent_req_received(req);
3154 return status;
3155 }
3156
3157 /* Steal possbile out parameters to the callers context */
3158 talloc_steal(mem_ctx, state->out_mem_ctx);
3159
3160 /* Return result */
3161 *result = state->orig.out.result;
3162
3163 tevent_req_received(req);
3164 return NT_STATUS_OK;
3165 }
3166
3167 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
3168 TALLOC_CTX *mem_ctx,
3169 struct policy_handle *handle /* [in] [ref] */,
3170 struct winreg_String *filename /* [in] [ref] */,
3171 uint32_t flags /* [in] */,
3172 WERROR *werror)
3173 {
3174 struct winreg_RestoreKey r;
3175 NTSTATUS status;
3176
3177 /* In parameters */
3178 r.in.handle = handle;
3179 r.in.filename = filename;
3180 r.in.flags = flags;
3181
3182 status = cli->dispatch(cli,
3183 mem_ctx,
3184 &ndr_table_winreg,
3185 NDR_WINREG_RESTOREKEY,
3186 &r);
3187
3188 if (!NT_STATUS_IS_OK(status)) {
3189 return status;
3190 }
3191
3192 if (NT_STATUS_IS_ERR(status)) {
3193 return status;
3194 }
3195
3196 /* Return variables */
3197
3198 /* Return result */
3199 if (werror) {
3200 *werror = r.out.result;
3201 }
3202
3203 return werror_to_ntstatus(r.out.result);
3204 }
3205
3206 struct rpccli_winreg_SaveKey_state {
3207 struct winreg_SaveKey orig;
3208 struct winreg_SaveKey tmp;
3209 TALLOC_CTX *out_mem_ctx;
3210 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3211 };
3212
3213 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq);
3214
3215 struct tevent_req *rpccli_winreg_SaveKey_send(TALLOC_CTX *mem_ctx,
3216 struct tevent_context *ev,
3217 struct rpc_pipe_client *cli,
3218 struct policy_handle *_handle /* [in] [ref] */,
3219 struct winreg_String *_filename /* [in] [ref] */,
3220 struct KeySecurityAttribute *_sec_attrib /* [in] [unique] */)
3221 {
3222 struct tevent_req *req;
3223 struct rpccli_winreg_SaveKey_state *state;
3224 struct tevent_req *subreq;
3225
3226 req = tevent_req_create(mem_ctx, &state,
3227 struct rpccli_winreg_SaveKey_state);
3228 if (req == NULL) {
3229 return NULL;
3230 }
3231 state->out_mem_ctx = NULL;
3232 state->dispatch_recv = cli->dispatch_recv;
3233
3234 /* In parameters */
3235 state->orig.in.handle = _handle;
3236 state->orig.in.filename = _filename;
3237 state->orig.in.sec_attrib = _sec_attrib;
3238
3239 /* Out parameters */
3240
3241 /* Result */
3242 ZERO_STRUCT(state->orig.out.result);
3243
3244 /* make a temporary copy, that we pass to the dispatch function */
3245 state->tmp = state->orig;
3246
3247 subreq = cli->dispatch_send(state, ev, cli,
3248 &ndr_table_winreg,
3249 NDR_WINREG_SAVEKEY,
3250 &state->tmp);
3251 if (tevent_req_nomem(subreq, req)) {
3252 return tevent_req_post(req, ev);
3253 }
3254 tevent_req_set_callback(subreq, rpccli_winreg_SaveKey_done, req);
3255 return req;
3256 }
3257
3258 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq)
3259 {
3260 struct tevent_req *req = tevent_req_callback_data(
3261 subreq, struct tevent_req);
3262 struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3263 req, struct rpccli_winreg_SaveKey_state);
3264 NTSTATUS status;
3265 TALLOC_CTX *mem_ctx;
3266
3267 if (state->out_mem_ctx) {
3268 mem_ctx = state->out_mem_ctx;
3269 } else {
3270 mem_ctx = state;
3271 }
3272
3273 status = state->dispatch_recv(subreq, mem_ctx);
3274 TALLOC_FREE(subreq);
3275 if (!NT_STATUS_IS_OK(status)) {
3276 tevent_req_nterror(req, status);
3277 return;
3278 }
3279
3280 /* Copy out parameters */
3281
3282 /* Copy result */
3283 state->orig.out.result = state->tmp.out.result;
3284
3285 /* Reset temporary structure */
3286 ZERO_STRUCT(state->tmp);
3287
3288 tevent_req_done(req);
3289 }
3290
3291 NTSTATUS rpccli_winreg_SaveKey_recv(struct tevent_req *req,
3292 TALLOC_CTX *mem_ctx,
3293 WERROR *result)
3294 {
3295 struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3296 req, struct rpccli_winreg_SaveKey_state);
3297 NTSTATUS status;
3298
3299 if (tevent_req_is_nterror(req, &status)) {
3300 tevent_req_received(req);
3301 return status;
3302 }
3303
3304 /* Steal possbile out parameters to the callers context */
3305 talloc_steal(mem_ctx, state->out_mem_ctx);
3306
3307 /* Return result */
3308 *result = state->orig.out.result;
3309
3310 tevent_req_received(req);
3311 return NT_STATUS_OK;
3312 }
3313
3314 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
3315 TALLOC_CTX *mem_ctx,
3316 struct policy_handle *handle /* [in] [ref] */,
3317 struct winreg_String *filename /* [in] [ref] */,
3318 struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
3319 WERROR *werror)
3320 {
3321 struct winreg_SaveKey r;
3322 NTSTATUS status;
3323
3324 /* In parameters */
3325 r.in.handle = handle;
3326 r.in.filename = filename;
3327 r.in.sec_attrib = sec_attrib;
3328
3329 status = cli->dispatch(cli,
3330 mem_ctx,
3331 &ndr_table_winreg,
3332 NDR_WINREG_SAVEKEY,
3333 &r);
3334
3335 if (!NT_STATUS_IS_OK(status)) {
3336 return status;
3337 }
3338
3339 if (NT_STATUS_IS_ERR(status)) {
3340 return status;
3341 }
3342
3343 /* Return variables */
3344
3345 /* Return result */
3346 if (werror) {
3347 *werror = r.out.result;
3348 }
3349
3350 return werror_to_ntstatus(r.out.result);
3351 }
3352
3353 struct rpccli_winreg_SetKeySecurity_state {
3354 struct winreg_SetKeySecurity orig;
3355 struct winreg_SetKeySecurity tmp;
3356 TALLOC_CTX *out_mem_ctx;
3357 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3358 };
3359
3360 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq);
3361
3362 struct tevent_req *rpccli_winreg_SetKeySecurity_send(TALLOC_CTX *mem_ctx,
3363 struct tevent_context *ev,
3364 struct rpc_pipe_client *cli,
3365 struct policy_handle *_handle /* [in] [ref] */,
3366 uint32_t _sec_info /* [in] */,
3367 struct KeySecurityData *_sd /* [in] [ref] */)
3368 {
3369 struct tevent_req *req;
3370 struct rpccli_winreg_SetKeySecurity_state *state;
3371 struct tevent_req *subreq;
3372
3373 req = tevent_req_create(mem_ctx, &state,
3374 struct rpccli_winreg_SetKeySecurity_state);
3375 if (req == NULL) {
3376 return NULL;
3377 }
3378 state->out_mem_ctx = NULL;
3379 state->dispatch_recv = cli->dispatch_recv;
3380
3381 /* In parameters */
3382 state->orig.in.handle = _handle;
3383 state->orig.in.sec_info = _sec_info;
3384 state->orig.in.sd = _sd;
3385
3386 /* Out parameters */
3387
3388 /* Result */
3389 ZERO_STRUCT(state->orig.out.result);
3390
3391 /* make a temporary copy, that we pass to the dispatch function */
3392 state->tmp = state->orig;
3393
3394 subreq = cli->dispatch_send(state, ev, cli,
3395 &ndr_table_winreg,
3396 NDR_WINREG_SETKEYSECURITY,
3397 &state->tmp);
3398 if (tevent_req_nomem(subreq, req)) {
3399 return tevent_req_post(req, ev);
3400 }
3401 tevent_req_set_callback(subreq, rpccli_winreg_SetKeySecurity_done, req);
3402 return req;
3403 }
3404
3405 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq)
3406 {
3407 struct tevent_req *req = tevent_req_callback_data(
3408 subreq, struct tevent_req);
3409 struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3410 req, struct rpccli_winreg_SetKeySecurity_state);
3411 NTSTATUS status;
3412 TALLOC_CTX *mem_ctx;
3413
3414 if (state->out_mem_ctx) {
3415 mem_ctx = state->out_mem_ctx;
3416 } else {
3417 mem_ctx = state;
3418 }
3419
3420 status = state->dispatch_recv(subreq, mem_ctx);
3421 TALLOC_FREE(subreq);
3422 if (!NT_STATUS_IS_OK(status)) {
3423 tevent_req_nterror(req, status);
3424 return;
3425 }
3426
3427 /* Copy out parameters */
3428
3429 /* Copy result */
3430 state->orig.out.result = state->tmp.out.result;
3431
3432 /* Reset temporary structure */
3433 ZERO_STRUCT(state->tmp);
3434
3435 tevent_req_done(req);
3436 }
3437
3438 NTSTATUS rpccli_winreg_SetKeySecurity_recv(struct tevent_req *req,
3439 TALLOC_CTX *mem_ctx,
3440 WERROR *result)
3441 {
3442 struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3443 req, struct rpccli_winreg_SetKeySecurity_state);
3444 NTSTATUS status;
3445
3446 if (tevent_req_is_nterror(req, &status)) {
3447 tevent_req_received(req);
3448 return status;
3449 }
3450
3451 /* Steal possbile out parameters to the callers context */
3452 talloc_steal(mem_ctx, state->out_mem_ctx);
3453
3454 /* Return result */
3455 *result = state->orig.out.result;
3456
3457 tevent_req_received(req);
3458 return NT_STATUS_OK;
3459 }
3460
3461 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
3462 TALLOC_CTX *mem_ctx,
3463 struct policy_handle *handle /* [in] [ref] */,
3464 uint32_t sec_info /* [in] */,
3465 struct KeySecurityData *sd /* [in] [ref] */,
3466 WERROR *werror)
3467 {
3468 struct winreg_SetKeySecurity r;
3469 NTSTATUS status;
3470
3471 /* In parameters */
3472 r.in.handle = handle;
3473 r.in.sec_info = sec_info;
3474 r.in.sd = sd;
3475
3476 status = cli->dispatch(cli,
3477 mem_ctx,
3478 &ndr_table_winreg,
3479 NDR_WINREG_SETKEYSECURITY,
3480 &r);
3481
3482 if (!NT_STATUS_IS_OK(status)) {
3483 return status;
3484 }
3485
3486 if (NT_STATUS_IS_ERR(status)) {
3487 return status;
3488 }
3489
3490 /* Return variables */
3491
3492 /* Return result */
3493 if (werror) {
3494 *werror = r.out.result;
3495 }
3496
3497 return werror_to_ntstatus(r.out.result);
3498 }
3499
3500 struct rpccli_winreg_SetValue_state {
3501 struct winreg_SetValue orig;
3502 struct winreg_SetValue tmp;
3503 TALLOC_CTX *out_mem_ctx;
3504 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3505 };
3506
3507 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq);
3508
3509 struct tevent_req *rpccli_winreg_SetValue_send(TALLOC_CTX *mem_ctx,
3510 struct tevent_context *ev,
3511 struct rpc_pipe_client *cli,
3512 struct policy_handle *_handle /* [in] [ref] */,
3513 struct winreg_String _name /* [in] */,
3514 enum winreg_Type _type /* [in] */,
3515 uint8_t *_data /* [in] [ref,size_is(size)] */,
3516 uint32_t _size /* [in] */)
3517 {
3518 struct tevent_req *req;
3519 struct rpccli_winreg_SetValue_state *state;
3520 struct tevent_req *subreq;
3521
3522 req = tevent_req_create(mem_ctx, &state,
3523 struct rpccli_winreg_SetValue_state);
3524 if (req == NULL) {
3525 return NULL;
3526 }
3527 state->out_mem_ctx = NULL;
3528 state->dispatch_recv = cli->dispatch_recv;
3529
3530 /* In parameters */
3531 state->orig.in.handle = _handle;
3532 state->orig.in.name = _name;
3533 state->orig.in.type = _type;
3534 state->orig.in.data = _data;
3535 state->orig.in.size = _size;
3536
3537 /* Out parameters */
3538
3539 /* Result */
3540 ZERO_STRUCT(state->orig.out.result);
3541
3542 /* make a temporary copy, that we pass to the dispatch function */
3543 state->tmp = state->orig;
3544
3545 subreq = cli->dispatch_send(state, ev, cli,
3546 &ndr_table_winreg,
3547 NDR_WINREG_SETVALUE,
3548 &state->tmp);
3549 if (tevent_req_nomem(subreq, req)) {
3550 return tevent_req_post(req, ev);
3551 }
3552 tevent_req_set_callback(subreq, rpccli_winreg_SetValue_done, req);
3553 return req;
3554 }
3555
3556 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq)
3557 {
3558 struct tevent_req *req = tevent_req_callback_data(
3559 subreq, struct tevent_req);
3560 struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3561 req, struct rpccli_winreg_SetValue_state);
3562 NTSTATUS status;
3563 TALLOC_CTX *mem_ctx;
3564
3565 if (state->out_mem_ctx) {
3566 mem_ctx = state->out_mem_ctx;
3567 } else {
3568 mem_ctx = state;
3569 }
3570
3571 status = state->dispatch_recv(subreq, mem_ctx);
3572 TALLOC_FREE(subreq);
3573 if (!NT_STATUS_IS_OK(status)) {
3574 tevent_req_nterror(req, status);
3575 return;
3576 }
3577
3578 /* Copy out parameters */
3579
3580 /* Copy result */
3581 state->orig.out.result = state->tmp.out.result;
3582
3583 /* Reset temporary structure */
3584 ZERO_STRUCT(state->tmp);
3585
3586 tevent_req_done(req);
3587 }
3588
3589 NTSTATUS rpccli_winreg_SetValue_recv(struct tevent_req *req,
3590 TALLOC_CTX *mem_ctx,
3591 WERROR *result)
3592 {
3593 struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3594 req, struct rpccli_winreg_SetValue_state);
3595 NTSTATUS status;
3596
3597 if (tevent_req_is_nterror(req, &status)) {
3598 tevent_req_received(req);
3599 return status;
3600 }
3601
3602 /* Steal possbile out parameters to the callers context */
3603 talloc_steal(mem_ctx, state->out_mem_ctx);
3604
3605 /* Return result */
3606 *result = state->orig.out.result;
3607
3608 tevent_req_received(req);
3609 return NT_STATUS_OK;
3610 }
3611
3612 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
3613 TALLOC_CTX *mem_ctx,
3614 struct policy_handle *handle /* [in] [ref] */,
3615 struct winreg_String name /* [in] */,
3616 enum winreg_Type type /* [in] */,
3617 uint8_t *data /* [in] [ref,size_is(size)] */,
3618 uint32_t size /* [in] */,
3619 WERROR *werror)
3620 {
3621 struct winreg_SetValue r;
3622 NTSTATUS status;
3623
3624 /* In parameters */
3625 r.in.handle = handle;
3626 r.in.name = name;
3627 r.in.type = type;
3628 r.in.data = data;
3629 r.in.size = size;
3630
3631 status = cli->dispatch(cli,
3632 mem_ctx,
3633 &ndr_table_winreg,
3634 NDR_WINREG_SETVALUE,
3635 &r);
3636
3637 if (!NT_STATUS_IS_OK(status)) {
3638 return status;
3639 }
3640
3641 if (NT_STATUS_IS_ERR(status)) {
3642 return status;
3643 }
3644
3645 /* Return variables */
3646
3647 /* Return result */
3648 if (werror) {
3649 *werror = r.out.result;
3650 }
3651
3652 return werror_to_ntstatus(r.out.result);
3653 }
3654
3655 struct rpccli_winreg_UnLoadKey_state {
3656 struct winreg_UnLoadKey orig;
3657 struct winreg_UnLoadKey tmp;
3658 TALLOC_CTX *out_mem_ctx;
3659 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3660 };
3661
3662 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq);
3663
3664 struct tevent_req *rpccli_winreg_UnLoadKey_send(TALLOC_CTX *mem_ctx,
3665 struct tevent_context *ev,
3666 struct rpc_pipe_client *cli)
3667 {
3668 struct tevent_req *req;
3669 struct rpccli_winreg_UnLoadKey_state *state;
3670 struct tevent_req *subreq;
3671
3672 req = tevent_req_create(mem_ctx, &state,
3673 struct rpccli_winreg_UnLoadKey_state);
3674 if (req == NULL) {
3675 return NULL;
3676 }
3677 state->out_mem_ctx = NULL;
3678 state->dispatch_recv = cli->dispatch_recv;
3679
3680 /* In parameters */
3681
3682 /* Out parameters */
3683
3684 /* Result */
3685 ZERO_STRUCT(state->orig.out.result);
3686
3687 /* make a temporary copy, that we pass to the dispatch function */
3688 state->tmp = state->orig;
3689
3690 subreq = cli->dispatch_send(state, ev, cli,
3691 &ndr_table_winreg,
3692 NDR_WINREG_UNLOADKEY,
3693 &state->tmp);
3694 if (tevent_req_nomem(subreq, req)) {
3695 return tevent_req_post(req, ev);
3696 }
3697 tevent_req_set_callback(subreq, rpccli_winreg_UnLoadKey_done, req);
3698 return req;
3699 }
3700
3701 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq)
3702 {
3703 struct tevent_req *req = tevent_req_callback_data(
3704 subreq, struct tevent_req);
3705 struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
3706 req, struct rpccli_winreg_UnLoadKey_state);
3707 NTSTATUS status;
3708 TALLOC_CTX *mem_ctx;
3709
3710 if (state->out_mem_ctx) {
3711 mem_ctx = state->out_mem_ctx;
3712 } else {
3713 mem_ctx = state;
3714 }
3715
3716 status = state->dispatch_recv(subreq, mem_ctx);
3717 TALLOC_FREE(subreq);
3718 if (!NT_STATUS_IS_OK(status)) {
3719 tevent_req_nterror(req, status);
3720 return;
3721 }
3722
3723 /* Copy out parameters */
3724
3725 /* Copy result */
3726 state->orig.out.result = state->tmp.out.result;
3727
3728 /* Reset temporary structure */
3729 ZERO_STRUCT(state->tmp);
3730
3731 tevent_req_done(req);
3732 }
3733
3734 NTSTATUS rpccli_winreg_UnLoadKey_recv(struct tevent_req *req,
3735 TALLOC_CTX *mem_ctx,
3736 WERROR *result)
3737 {
3738 struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
3739 req, struct rpccli_winreg_UnLoadKey_state);
3740 NTSTATUS status;
3741
3742 if (tevent_req_is_nterror(req, &status)) {
3743 tevent_req_received(req);
3744 return status;
3745 }
3746
3747 /* Steal possbile out parameters to the callers context */
3748 talloc_steal(mem_ctx, state->out_mem_ctx);
3749
3750 /* Return result */
3751 *result = state->orig.out.result;
3752
3753 tevent_req_received(req);
3754 return NT_STATUS_OK;
3755 }
3756
3757 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
3758 TALLOC_CTX *mem_ctx,
3759 WERROR *werror)
3760 {
3761 struct winreg_UnLoadKey r;
3762 NTSTATUS status;
3763
3764 /* In parameters */
3765
3766 status = cli->dispatch(cli,
3767 mem_ctx,
3768 &ndr_table_winreg,
3769 NDR_WINREG_UNLOADKEY,
3770 &r);
3771
3772 if (!NT_STATUS_IS_OK(status)) {
3773 return status;
3774 }
3775
3776 if (NT_STATUS_IS_ERR(status)) {
3777 return status;
3778 }
3779
3780 /* Return variables */
3781
3782 /* Return result */
3783 if (werror) {
3784 *werror = r.out.result;
3785 }
3786
3787 return werror_to_ntstatus(r.out.result);
3788 }
3789
3790 struct rpccli_winreg_InitiateSystemShutdown_state {
3791 struct winreg_InitiateSystemShutdown orig;
3792 struct winreg_InitiateSystemShutdown tmp;
3793 TALLOC_CTX *out_mem_ctx;
3794 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3795 };
3796
3797 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq);
3798
3799 struct tevent_req *rpccli_winreg_InitiateSystemShutdown_send(TALLOC_CTX *mem_ctx,
3800 struct tevent_context *ev,
3801 struct rpc_pipe_client *cli,
3802 uint16_t *_hostname /* [in] [unique] */,
3803 struct lsa_StringLarge *_message /* [in] [unique] */,
3804 uint32_t _timeout /* [in] */,
3805 uint8_t _force_apps /* [in] */,
3806 uint8_t _do_reboot /* [in] */)
3807 {
3808 struct tevent_req *req;
3809 struct rpccli_winreg_InitiateSystemShutdown_state *state;
3810 struct tevent_req *subreq;
3811
3812 req = tevent_req_create(mem_ctx, &state,
3813 struct rpccli_winreg_InitiateSystemShutdown_state);
3814 if (req == NULL) {
3815 return NULL;
3816 }
3817 state->out_mem_ctx = NULL;
3818 state->dispatch_recv = cli->dispatch_recv;
3819
3820 /* In parameters */
3821 state->orig.in.hostname = _hostname;
3822 state->orig.in.message = _message;
3823 state->orig.in.timeout = _timeout;
3824 state->orig.in.force_apps = _force_apps;
3825 state->orig.in.do_reboot = _do_reboot;
3826
3827 /* Out parameters */
3828
3829 /* Result */
3830 ZERO_STRUCT(state->orig.out.result);
3831
3832 /* make a temporary copy, that we pass to the dispatch function */
3833 state->tmp = state->orig;
3834
3835 subreq = cli->dispatch_send(state, ev, cli,
3836 &ndr_table_winreg,
3837 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
3838 &state->tmp);
3839 if (tevent_req_nomem(subreq, req)) {
3840 return tevent_req_post(req, ev);
3841 }
3842 tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdown_done, req);
3843 return req;
3844 }
3845
3846 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq)
3847 {
3848 struct tevent_req *req = tevent_req_callback_data(
3849 subreq, struct tevent_req);
3850 struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
3851 req, struct rpccli_winreg_InitiateSystemShutdown_state);
3852 NTSTATUS status;
3853 TALLOC_CTX *mem_ctx;
3854
3855 if (state->out_mem_ctx) {
3856 mem_ctx = state->out_mem_ctx;
3857 } else {
3858 mem_ctx = state;
3859 }
3860
3861 status = state->dispatch_recv(subreq, mem_ctx);
3862 TALLOC_FREE(subreq);
3863 if (!NT_STATUS_IS_OK(status)) {
3864 tevent_req_nterror(req, status);
3865 return;
3866 }
3867
3868 /* Copy out parameters */
3869
3870 /* Copy result */
3871 state->orig.out.result = state->tmp.out.result;
3872
3873 /* Reset temporary structure */
3874 ZERO_STRUCT(state->tmp);
3875
3876 tevent_req_done(req);
3877 }
3878
3879 NTSTATUS rpccli_winreg_InitiateSystemShutdown_recv(struct tevent_req *req,
3880 TALLOC_CTX *mem_ctx,
3881 WERROR *result)
3882 {
3883 struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
3884 req, struct rpccli_winreg_InitiateSystemShutdown_state);
3885 NTSTATUS status;
3886
3887 if (tevent_req_is_nterror(req, &status)) {
3888 tevent_req_received(req);
3889 return status;
3890 }
3891
3892 /* Steal possbile out parameters to the callers context */
3893 talloc_steal(mem_ctx, state->out_mem_ctx);
3894
3895 /* Return result */
3896 *result = state->orig.out.result;
3897
3898 tevent_req_received(req);
3899 return NT_STATUS_OK;
3900 }
3901
3902 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
3903 TALLOC_CTX *mem_ctx,
3904 uint16_t *hostname /* [in] [unique] */,
3905 struct lsa_StringLarge *message /* [in] [unique] */,
3906 uint32_t timeout /* [in] */,
3907 uint8_t force_apps /* [in] */,
3908 uint8_t do_reboot /* [in] */,
3909 WERROR *werror)
3910 {
3911 struct winreg_InitiateSystemShutdown r;
3912 NTSTATUS status;
3913
3914 /* In parameters */
3915 r.in.hostname = hostname;
3916 r.in.message = message;
3917 r.in.timeout = timeout;
3918 r.in.force_apps = force_apps;
3919 r.in.do_reboot = do_reboot;
3920
3921 status = cli->dispatch(cli,
3922 mem_ctx,
3923 &ndr_table_winreg,
3924 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
3925 &r);
3926
3927 if (!NT_STATUS_IS_OK(status)) {
3928 return status;
3929 }
3930
3931 if (NT_STATUS_IS_ERR(status)) {
3932 return status;
3933 }
3934
3935 /* Return variables */
3936
3937 /* Return result */
3938 if (werror) {
3939 *werror = r.out.result;
3940 }
3941
3942 return werror_to_ntstatus(r.out.result);
3943 }
3944
3945 struct rpccli_winreg_AbortSystemShutdown_state {
3946 struct winreg_AbortSystemShutdown orig;
3947 struct winreg_AbortSystemShutdown tmp;
3948 TALLOC_CTX *out_mem_ctx;
3949 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3950 };
3951
3952 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq);
3953
3954 struct tevent_req *rpccli_winreg_AbortSystemShutdown_send(TALLOC_CTX *mem_ctx,
3955 struct tevent_context *ev,
3956 struct rpc_pipe_client *cli,
3957 uint16_t *_server /* [in] [unique] */)
3958 {
3959 struct tevent_req *req;
3960 struct rpccli_winreg_AbortSystemShutdown_state *state;
3961 struct tevent_req *subreq;
3962
3963 req = tevent_req_create(mem_ctx, &state,
3964 struct rpccli_winreg_AbortSystemShutdown_state);
3965 if (req == NULL) {
3966 return NULL;
3967 }
3968 state->out_mem_ctx = NULL;
3969 state->dispatch_recv = cli->dispatch_recv;
3970
3971 /* In parameters */
3972 state->orig.in.server = _server;
3973
3974 /* Out parameters */
3975
3976 /* Result */
3977 ZERO_STRUCT(state->orig.out.result);
3978
3979 /* make a temporary copy, that we pass to the dispatch function */
3980 state->tmp = state->orig;
3981
3982 subreq = cli->dispatch_send(state, ev, cli,
3983 &ndr_table_winreg,
3984 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
3985 &state->tmp);
3986 if (tevent_req_nomem(subreq, req)) {
3987 return tevent_req_post(req, ev);
3988 }
3989 tevent_req_set_callback(subreq, rpccli_winreg_AbortSystemShutdown_done, req);
3990 return req;
3991 }
3992
3993 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq)
3994 {
3995 struct tevent_req *req = tevent_req_callback_data(
3996 subreq, struct tevent_req);
3997 struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
3998 req, struct rpccli_winreg_AbortSystemShutdown_state);
3999 NTSTATUS status;
4000 TALLOC_CTX *mem_ctx;
4001
4002 if (state->out_mem_ctx) {
4003 mem_ctx = state->out_mem_ctx;
4004 } else {
4005 mem_ctx = state;
4006 }
4007
4008 status = state->dispatch_recv(subreq, mem_ctx);
4009 TALLOC_FREE(subreq);
4010 if (!NT_STATUS_IS_OK(status)) {
4011 tevent_req_nterror(req, status);
4012 return;
4013 }
4014
4015 /* Copy out parameters */
4016
4017 /* Copy result */
4018 state->orig.out.result = state->tmp.out.result;
4019
4020 /* Reset temporary structure */
4021 ZERO_STRUCT(state->tmp);
4022
4023 tevent_req_done(req);
4024 }
4025
4026 NTSTATUS rpccli_winreg_AbortSystemShutdown_recv(struct tevent_req *req,
4027 TALLOC_CTX *mem_ctx,
4028 WERROR *result)
4029 {
4030 struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
4031 req, struct rpccli_winreg_AbortSystemShutdown_state);
4032 NTSTATUS status;
4033
4034 if (tevent_req_is_nterror(req, &status)) {
4035 tevent_req_received(req);
4036 return status;
4037 }
4038
4039 /* Steal possbile out parameters to the callers context */
4040 talloc_steal(mem_ctx, state->out_mem_ctx);
4041
4042 /* Return result */
4043 *result = state->orig.out.result;
4044
4045 tevent_req_received(req);
4046 return NT_STATUS_OK;
4047 }
4048
4049 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
4050 TALLOC_CTX *mem_ctx,
4051 uint16_t *server /* [in] [unique] */,
4052 WERROR *werror)
4053 {
4054 struct winreg_AbortSystemShutdown r;
4055 NTSTATUS status;
4056
4057 /* In parameters */
4058 r.in.server = server;
4059
4060 status = cli->dispatch(cli,
4061 mem_ctx,
4062 &ndr_table_winreg,
4063 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
4064 &r);
4065
4066 if (!NT_STATUS_IS_OK(status)) {
4067 return status;
4068 }
4069
4070 if (NT_STATUS_IS_ERR(status)) {
4071 return status;
4072 }
4073
4074 /* Return variables */
4075
4076 /* Return result */
4077 if (werror) {
4078 *werror = r.out.result;
4079 }
4080
4081 return werror_to_ntstatus(r.out.result);
4082 }
4083
4084 struct rpccli_winreg_GetVersion_state {
4085 struct winreg_GetVersion orig;
4086 struct winreg_GetVersion tmp;
4087 TALLOC_CTX *out_mem_ctx;
4088 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4089 };
4090
4091 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq);
4092
4093 struct tevent_req *rpccli_winreg_GetVersion_send(TALLOC_CTX *mem_ctx,
4094 struct tevent_context *ev,
4095 struct rpc_pipe_client *cli,
4096 struct policy_handle *_handle /* [in] [ref] */,
4097 uint32_t *_version /* [out] [ref] */)
4098 {
4099 struct tevent_req *req;
4100 struct rpccli_winreg_GetVersion_state *state;
4101 struct tevent_req *subreq;
4102
4103 req = tevent_req_create(mem_ctx, &state,
4104 struct rpccli_winreg_GetVersion_state);
4105 if (req == NULL) {
4106 return NULL;
4107 }
4108 state->out_mem_ctx = NULL;
4109 state->dispatch_recv = cli->dispatch_recv;
4110
4111 /* In parameters */
4112 state->orig.in.handle = _handle;
4113
4114 /* Out parameters */
4115 state->orig.out.version = _version;
4116
4117 /* Result */
4118 ZERO_STRUCT(state->orig.out.result);
4119
4120 state->out_mem_ctx = talloc_named_const(state, 0,
4121 "rpccli_winreg_GetVersion_out_memory");
4122 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4123 return tevent_req_post(req, ev);
4124 }
4125
4126 /* make a temporary copy, that we pass to the dispatch function */
4127 state->tmp = state->orig;
4128
4129 subreq = cli->dispatch_send(state, ev, cli,
4130 &ndr_table_winreg,
4131 NDR_WINREG_GETVERSION,
4132 &state->tmp);
4133 if (tevent_req_nomem(subreq, req)) {
4134 return tevent_req_post(req, ev);
4135 }
4136 tevent_req_set_callback(subreq, rpccli_winreg_GetVersion_done, req);
4137 return req;
4138 }
4139
4140 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq)
4141 {
4142 struct tevent_req *req = tevent_req_callback_data(
4143 subreq, struct tevent_req);
4144 struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4145 req, struct rpccli_winreg_GetVersion_state);
4146 NTSTATUS status;
4147 TALLOC_CTX *mem_ctx;
4148
4149 if (state->out_mem_ctx) {
4150 mem_ctx = state->out_mem_ctx;
4151 } else {
4152 mem_ctx = state;
4153 }
4154
4155 status = state->dispatch_recv(subreq, mem_ctx);
4156 TALLOC_FREE(subreq);
4157 if (!NT_STATUS_IS_OK(status)) {
4158 tevent_req_nterror(req, status);
4159 return;
4160 }
4161
4162 /* Copy out parameters */
4163 *state->orig.out.version = *state->tmp.out.version;
4164
4165 /* Copy result */
4166 state->orig.out.result = state->tmp.out.result;
4167
4168 /* Reset temporary structure */
4169 ZERO_STRUCT(state->tmp);
4170
4171 tevent_req_done(req);
4172 }
4173
4174 NTSTATUS rpccli_winreg_GetVersion_recv(struct tevent_req *req,
4175 TALLOC_CTX *mem_ctx,
4176 WERROR *result)
4177 {
4178 struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4179 req, struct rpccli_winreg_GetVersion_state);
4180 NTSTATUS status;
4181
4182 if (tevent_req_is_nterror(req, &status)) {
4183 tevent_req_received(req);
4184 return status;
4185 }
4186
4187 /* Steal possbile out parameters to the callers context */
4188 talloc_steal(mem_ctx, state->out_mem_ctx);
4189
4190 /* Return result */
4191 *result = state->orig.out.result;
4192
4193 tevent_req_received(req);
4194 return NT_STATUS_OK;
4195 }
4196
4197 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
4198 TALLOC_CTX *mem_ctx,
4199 struct policy_handle *handle /* [in] [ref] */,
4200 uint32_t *version /* [out] [ref] */,
4201 WERROR *werror)
4202 {
4203 struct winreg_GetVersion r;
4204 NTSTATUS status;
4205
4206 /* In parameters */
4207 r.in.handle = handle;
4208
4209 status = cli->dispatch(cli,
4210 mem_ctx,
4211 &ndr_table_winreg,
4212 NDR_WINREG_GETVERSION,
4213 &r);
4214
4215 if (!NT_STATUS_IS_OK(status)) {
4216 return status;
4217 }
4218
4219 if (NT_STATUS_IS_ERR(status)) {
4220 return status;
4221 }
4222
4223 /* Return variables */
4224 *version = *r.out.version;
4225
4226 /* Return result */
4227 if (werror) {
4228 *werror = r.out.result;
4229 }
4230
4231 return werror_to_ntstatus(r.out.result);
4232 }
4233
4234 struct rpccli_winreg_OpenHKCC_state {
4235 struct winreg_OpenHKCC orig;
4236 struct winreg_OpenHKCC tmp;
4237 TALLOC_CTX *out_mem_ctx;
4238 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4239 };
4240
4241 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq);
4242
4243 struct tevent_req *rpccli_winreg_OpenHKCC_send(TALLOC_CTX *mem_ctx,
4244 struct tevent_context *ev,
4245 struct rpc_pipe_client *cli,
4246 uint16_t *_system_name /* [in] [unique] */,
4247 uint32_t _access_mask /* [in] */,
4248 struct policy_handle *_handle /* [out] [ref] */)
4249 {
4250 struct tevent_req *req;
4251 struct rpccli_winreg_OpenHKCC_state *state;
4252 struct tevent_req *subreq;
4253
4254 req = tevent_req_create(mem_ctx, &state,
4255 struct rpccli_winreg_OpenHKCC_state);
4256 if (req == NULL) {
4257 return NULL;
4258 }
4259 state->out_mem_ctx = NULL;
4260 state->dispatch_recv = cli->dispatch_recv;
4261
4262 /* In parameters */
4263 state->orig.in.system_name = _system_name;
4264 state->orig.in.access_mask = _access_mask;
4265
4266 /* Out parameters */
4267 state->orig.out.handle = _handle;
4268
4269 /* Result */
4270 ZERO_STRUCT(state->orig.out.result);
4271
4272 state->out_mem_ctx = talloc_named_const(state, 0,
4273 "rpccli_winreg_OpenHKCC_out_memory");
4274 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4275 return tevent_req_post(req, ev);
4276 }
4277
4278 /* make a temporary copy, that we pass to the dispatch function */
4279 state->tmp = state->orig;
4280
4281 subreq = cli->dispatch_send(state, ev, cli,
4282 &ndr_table_winreg,
4283 NDR_WINREG_OPENHKCC,
4284 &state->tmp);
4285 if (tevent_req_nomem(subreq, req)) {
4286 return tevent_req_post(req, ev);
4287 }
4288 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCC_done, req);
4289 return req;
4290 }
4291
4292 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq)
4293 {
4294 struct tevent_req *req = tevent_req_callback_data(
4295 subreq, struct tevent_req);
4296 struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4297 req, struct rpccli_winreg_OpenHKCC_state);
4298 NTSTATUS status;
4299 TALLOC_CTX *mem_ctx;
4300
4301 if (state->out_mem_ctx) {
4302 mem_ctx = state->out_mem_ctx;
4303 } else {
4304 mem_ctx = state;
4305 }
4306
4307 status = state->dispatch_recv(subreq, mem_ctx);
4308 TALLOC_FREE(subreq);
4309 if (!NT_STATUS_IS_OK(status)) {
4310 tevent_req_nterror(req, status);
4311 return;
4312 }
4313
4314 /* Copy out parameters */
4315 *state->orig.out.handle = *state->tmp.out.handle;
4316
4317 /* Copy result */
4318 state->orig.out.result = state->tmp.out.result;
4319
4320 /* Reset temporary structure */
4321 ZERO_STRUCT(state->tmp);
4322
4323 tevent_req_done(req);
4324 }
4325
4326 NTSTATUS rpccli_winreg_OpenHKCC_recv(struct tevent_req *req,
4327 TALLOC_CTX *mem_ctx,
4328 WERROR *result)
4329 {
4330 struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4331 req, struct rpccli_winreg_OpenHKCC_state);
4332 NTSTATUS status;
4333
4334 if (tevent_req_is_nterror(req, &status)) {
4335 tevent_req_received(req);
4336 return status;
4337 }
4338
4339 /* Steal possbile out parameters to the callers context */
4340 talloc_steal(mem_ctx, state->out_mem_ctx);
4341
4342 /* Return result */
4343 *result = state->orig.out.result;
4344
4345 tevent_req_received(req);
4346 return NT_STATUS_OK;
4347 }
4348
4349 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
4350 TALLOC_CTX *mem_ctx,
4351 uint16_t *system_name /* [in] [unique] */,
4352 uint32_t access_mask /* [in] */,
4353 struct policy_handle *handle /* [out] [ref] */,
4354 WERROR *werror)
4355 {
4356 struct winreg_OpenHKCC r;
4357 NTSTATUS status;
4358
4359 /* In parameters */
4360 r.in.system_name = system_name;
4361 r.in.access_mask = access_mask;
4362
4363 status = cli->dispatch(cli,
4364 mem_ctx,
4365 &ndr_table_winreg,
4366 NDR_WINREG_OPENHKCC,
4367 &r);
4368
4369 if (!NT_STATUS_IS_OK(status)) {
4370 return status;
4371 }
4372
4373 if (NT_STATUS_IS_ERR(status)) {
4374 return status;
4375 }
4376
4377 /* Return variables */
4378 *handle = *r.out.handle;
4379
4380 /* Return result */
4381 if (werror) {
4382 *werror = r.out.result;
4383 }
4384
4385 return werror_to_ntstatus(r.out.result);
4386 }
4387
4388 struct rpccli_winreg_OpenHKDD_state {
4389 struct winreg_OpenHKDD orig;
4390 struct winreg_OpenHKDD tmp;
4391 TALLOC_CTX *out_mem_ctx;
4392 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4393 };
4394
4395 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq);
4396
4397 struct tevent_req *rpccli_winreg_OpenHKDD_send(TALLOC_CTX *mem_ctx,
4398 struct tevent_context *ev,
4399 struct rpc_pipe_client *cli,
4400 uint16_t *_system_name /* [in] [unique] */,
4401 uint32_t _access_mask /* [in] */,
4402 struct policy_handle *_handle /* [out] [ref] */)
4403 {
4404 struct tevent_req *req;
4405 struct rpccli_winreg_OpenHKDD_state *state;
4406 struct tevent_req *subreq;
4407
4408 req = tevent_req_create(mem_ctx, &state,
4409 struct rpccli_winreg_OpenHKDD_state);
4410 if (req == NULL) {
4411 return NULL;
4412 }
4413 state->out_mem_ctx = NULL;
4414 state->dispatch_recv = cli->dispatch_recv;
4415
4416 /* In parameters */
4417 state->orig.in.system_name = _system_name;
4418 state->orig.in.access_mask = _access_mask;
4419
4420 /* Out parameters */
4421 state->orig.out.handle = _handle;
4422
4423 /* Result */
4424 ZERO_STRUCT(state->orig.out.result);
4425
4426 state->out_mem_ctx = talloc_named_const(state, 0,
4427 "rpccli_winreg_OpenHKDD_out_memory");
4428 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4429 return tevent_req_post(req, ev);
4430 }
4431
4432 /* make a temporary copy, that we pass to the dispatch function */
4433 state->tmp = state->orig;
4434
4435 subreq = cli->dispatch_send(state, ev, cli,
4436 &ndr_table_winreg,
4437 NDR_WINREG_OPENHKDD,
4438 &state->tmp);
4439 if (tevent_req_nomem(subreq, req)) {
4440 return tevent_req_post(req, ev);
4441 }
4442 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKDD_done, req);
4443 return req;
4444 }
4445
4446 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq)
4447 {
4448 struct tevent_req *req = tevent_req_callback_data(
4449 subreq, struct tevent_req);
4450 struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4451 req, struct rpccli_winreg_OpenHKDD_state);
4452 NTSTATUS status;
4453 TALLOC_CTX *mem_ctx;
4454
4455 if (state->out_mem_ctx) {
4456 mem_ctx = state->out_mem_ctx;
4457 } else {
4458 mem_ctx = state;
4459 }
4460
4461 status = state->dispatch_recv(subreq, mem_ctx);
4462 TALLOC_FREE(subreq);
4463 if (!NT_STATUS_IS_OK(status)) {
4464 tevent_req_nterror(req, status);
4465 return;
4466 }
4467
4468 /* Copy out parameters */
4469 *state->orig.out.handle = *state->tmp.out.handle;
4470
4471 /* Copy result */
4472 state->orig.out.result = state->tmp.out.result;
4473
4474 /* Reset temporary structure */
4475 ZERO_STRUCT(state->tmp);
4476
4477 tevent_req_done(req);
4478 }
4479
4480 NTSTATUS rpccli_winreg_OpenHKDD_recv(struct tevent_req *req,
4481 TALLOC_CTX *mem_ctx,
4482 WERROR *result)
4483 {
4484 struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4485 req, struct rpccli_winreg_OpenHKDD_state);
4486 NTSTATUS status;
4487
4488 if (tevent_req_is_nterror(req, &status)) {
4489 tevent_req_received(req);
4490 return status;
4491 }
4492
4493 /* Steal possbile out parameters to the callers context */
4494 talloc_steal(mem_ctx, state->out_mem_ctx);
4495
4496 /* Return result */
4497 *result = state->orig.out.result;
4498
4499 tevent_req_received(req);
4500 return NT_STATUS_OK;
4501 }
4502
4503 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
4504 TALLOC_CTX *mem_ctx,
4505 uint16_t *system_name /* [in] [unique] */,
4506 uint32_t access_mask /* [in] */,
4507 struct policy_handle *handle /* [out] [ref] */,
4508 WERROR *werror)
4509 {
4510 struct winreg_OpenHKDD r;
4511 NTSTATUS status;
4512
4513 /* In parameters */
4514 r.in.system_name = system_name;
4515 r.in.access_mask = access_mask;
4516
4517 status = cli->dispatch(cli,
4518 mem_ctx,
4519 &ndr_table_winreg,
4520 NDR_WINREG_OPENHKDD,
4521 &r);
4522
4523 if (!NT_STATUS_IS_OK(status)) {
4524 return status;
4525 }
4526
4527 if (NT_STATUS_IS_ERR(status)) {
4528 return status;
4529 }
4530
4531 /* Return variables */
4532 *handle = *r.out.handle;
4533
4534 /* Return result */
4535 if (werror) {
4536 *werror = r.out.result;
4537 }
4538
4539 return werror_to_ntstatus(r.out.result);
4540 }
4541
4542 struct rpccli_winreg_QueryMultipleValues_state {
4543 struct winreg_QueryMultipleValues orig;
4544 struct winreg_QueryMultipleValues tmp;
4545 TALLOC_CTX *out_mem_ctx;
4546 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4547 };
4548
4549 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq);
4550
4551 struct tevent_req *rpccli_winreg_QueryMultipleValues_send(TALLOC_CTX *mem_ctx,
4552 struct tevent_context *ev,
4553 struct rpc_pipe_client *cli,
4554 struct policy_handle *_key_handle /* [in] [ref] */,
4555 struct QueryMultipleValue *_values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
4556 uint32_t _num_values /* [in] */,
4557 uint8_t *_buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
4558 uint32_t *_buffer_size /* [in,out] [ref] */)
4559 {
4560 struct tevent_req *req;
4561 struct rpccli_winreg_QueryMultipleValues_state *state;
4562 struct tevent_req *subreq;
4563
4564 req = tevent_req_create(mem_ctx, &state,
4565 struct rpccli_winreg_QueryMultipleValues_state);
4566 if (req == NULL) {
4567 return NULL;
4568 }
4569 state->out_mem_ctx = NULL;
4570 state->dispatch_recv = cli->dispatch_recv;
4571
4572 /* In parameters */
4573 state->orig.in.key_handle = _key_handle;
4574 state->orig.in.values = _values;
4575 state->orig.in.num_values = _num_values;
4576 state->orig.in.buffer = _buffer;
4577 state->orig.in.buffer_size = _buffer_size;
4578
4579 /* Out parameters */
4580 state->orig.out.values = _values;
4581 state->orig.out.buffer = _buffer;
4582 state->orig.out.buffer_size = _buffer_size;
4583
4584 /* Result */
4585 ZERO_STRUCT(state->orig.out.result);
4586
4587 state->out_mem_ctx = talloc_named_const(state, 0,
4588 "rpccli_winreg_QueryMultipleValues_out_memory");
4589 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4590 return tevent_req_post(req, ev);
4591 }
4592
4593 /* make a temporary copy, that we pass to the dispatch function */
4594 state->tmp = state->orig;
4595
4596 subreq = cli->dispatch_send(state, ev, cli,
4597 &ndr_table_winreg,
4598 NDR_WINREG_QUERYMULTIPLEVALUES,
4599 &state->tmp);
4600 if (tevent_req_nomem(subreq, req)) {
4601 return tevent_req_post(req, ev);
4602 }
4603 tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues_done, req);
4604 return req;
4605 }
4606
4607 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq)
4608 {
4609 struct tevent_req *req = tevent_req_callback_data(
4610 subreq, struct tevent_req);
4611 struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
4612 req, struct rpccli_winreg_QueryMultipleValues_state);
4613 NTSTATUS status;
4614 TALLOC_CTX *mem_ctx;
4615
4616 if (state->out_mem_ctx) {
4617 mem_ctx = state->out_mem_ctx;
4618 } else {
4619 mem_ctx = state;
4620 }
4621
4622 status = state->dispatch_recv(subreq, mem_ctx);
4623 TALLOC_FREE(subreq);
4624 if (!NT_STATUS_IS_OK(status)) {
4625 tevent_req_nterror(req, status);
4626 return;
4627 }
4628
4629 /* Copy out parameters */
4630 memcpy(state->orig.out.values, state->tmp.out.values, (state->tmp.in.num_values) * sizeof(*state->orig.out.values));
4631 if (state->orig.out.buffer && state->tmp.out.buffer) {
4632 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (*state->tmp.in.buffer_size) * sizeof(*state->orig.out.buffer));
4633 }
4634 *state->orig.out.buffer_size = *state->tmp.out.buffer_size;
4635
4636 /* Copy result */
4637 state->orig.out.result = state->tmp.out.result;
4638
4639 /* Reset temporary structure */
4640 ZERO_STRUCT(state->tmp);
4641
4642 tevent_req_done(req);
4643 }
4644
4645 NTSTATUS rpccli_winreg_QueryMultipleValues_recv(struct tevent_req *req,
4646 TALLOC_CTX *mem_ctx,
4647 WERROR *result)
4648 {
4649 struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
4650 req, struct rpccli_winreg_QueryMultipleValues_state);
4651 NTSTATUS status;
4652
4653 if (tevent_req_is_nterror(req, &status)) {
4654 tevent_req_received(req);
4655 return status;
4656 }
4657
4658 /* Steal possbile out parameters to the callers context */
4659 talloc_steal(mem_ctx, state->out_mem_ctx);
4660
4661 /* Return result */
4662 *result = state->orig.out.result;
4663
4664 tevent_req_received(req);
4665 return NT_STATUS_OK;
4666 }
4667
4668 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
4669 TALLOC_CTX *mem_ctx,
4670 struct policy_handle *key_handle /* [in] [ref] */,
4671 struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
4672 uint32_t num_values /* [in] */,
4673 uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
4674 uint32_t *buffer_size /* [in,out] [ref] */,
4675 WERROR *werror)
4676 {
4677 struct winreg_QueryMultipleValues r;
4678 NTSTATUS status;
4679
4680 /* In parameters */
4681 r.in.key_handle = key_handle;
4682 r.in.values = values;
4683 r.in.num_values = num_values;
4684 r.in.buffer = buffer;
4685 r.in.buffer_size = buffer_size;
4686
4687 status = cli->dispatch(cli,
4688 mem_ctx,
4689 &ndr_table_winreg,
4690 NDR_WINREG_QUERYMULTIPLEVALUES,
4691 &r);
4692
4693 if (!NT_STATUS_IS_OK(status)) {
4694 return status;
4695 }
4696
4697 if (NT_STATUS_IS_ERR(status)) {
4698 return status;
4699 }
4700
4701 /* Return variables */
4702 memcpy(values, r.out.values, (r.in.num_values) * sizeof(*values));
4703 if (buffer && r.out.buffer) {
4704 memcpy(buffer, r.out.buffer, (*r.in.buffer_size) * sizeof(*buffer));
4705 }
4706 *buffer_size = *r.out.buffer_size;
4707
4708 /* Return result */
4709 if (werror) {
4710 *werror = r.out.result;
4711 }
4712
4713 return werror_to_ntstatus(r.out.result);
4714 }
4715
4716 struct rpccli_winreg_InitiateSystemShutdownEx_state {
4717 struct winreg_InitiateSystemShutdownEx orig;
4718 struct winreg_InitiateSystemShutdownEx tmp;
4719 TALLOC_CTX *out_mem_ctx;
4720 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4721 };
4722
4723 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq);
4724
4725 struct tevent_req *rpccli_winreg_InitiateSystemShutdownEx_send(TALLOC_CTX *mem_ctx,
4726 struct tevent_context *ev,
4727 struct rpc_pipe_client *cli,
4728 uint16_t *_hostname /* [in] [unique] */,
4729 struct lsa_StringLarge *_message /* [in] [unique] */,
4730 uint32_t _timeout /* [in] */,
4731 uint8_t _force_apps /* [in] */,
4732 uint8_t _do_reboot /* [in] */,
4733 uint32_t _reason /* [in] */)
4734 {
4735 struct tevent_req *req;
4736 struct rpccli_winreg_InitiateSystemShutdownEx_state *state;
4737 struct tevent_req *subreq;
4738
4739 req = tevent_req_create(mem_ctx, &state,
4740 struct rpccli_winreg_InitiateSystemShutdownEx_state);
4741 if (req == NULL) {
4742 return NULL;
4743 }
4744 state->out_mem_ctx = NULL;
4745 state->dispatch_recv = cli->dispatch_recv;
4746
4747 /* In parameters */
4748 state->orig.in.hostname = _hostname;
4749 state->orig.in.message = _message;
4750 state->orig.in.timeout = _timeout;
4751 state->orig.in.force_apps = _force_apps;
4752 state->orig.in.do_reboot = _do_reboot;
4753 state->orig.in.reason = _reason;
4754
4755 /* Out parameters */
4756
4757 /* Result */
4758 ZERO_STRUCT(state->orig.out.result);
4759
4760 /* make a temporary copy, that we pass to the dispatch function */
4761 state->tmp = state->orig;
4762
4763 subreq = cli->dispatch_send(state, ev, cli,
4764 &ndr_table_winreg,
4765 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
4766 &state->tmp);
4767 if (tevent_req_nomem(subreq, req)) {
4768 return tevent_req_post(req, ev);
4769 }
4770 tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdownEx_done, req);
4771 return req;
4772 }
4773
4774 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq)
4775 {
4776 struct tevent_req *req = tevent_req_callback_data(
4777 subreq, struct tevent_req);
4778 struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
4779 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
4780 NTSTATUS status;
4781 TALLOC_CTX *mem_ctx;
4782
4783 if (state->out_mem_ctx) {
4784 mem_ctx = state->out_mem_ctx;
4785 } else {
4786 mem_ctx = state;
4787 }
4788
4789 status = state->dispatch_recv(subreq, mem_ctx);
4790 TALLOC_FREE(subreq);
4791 if (!NT_STATUS_IS_OK(status)) {
4792 tevent_req_nterror(req, status);
4793 return;
4794 }
4795
4796 /* Copy out parameters */
4797
4798 /* Copy result */
4799 state->orig.out.result = state->tmp.out.result;
4800
4801 /* Reset temporary structure */
4802 ZERO_STRUCT(state->tmp);
4803
4804 tevent_req_done(req);
4805 }
4806
4807 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx_recv(struct tevent_req *req,
4808 TALLOC_CTX *mem_ctx,
4809 WERROR *result)
4810 {
4811 struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
4812 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
4813 NTSTATUS status;
4814
4815 if (tevent_req_is_nterror(req, &status)) {
4816 tevent_req_received(req);
4817 return status;
4818 }
4819
4820 /* Steal possbile out parameters to the callers context */
4821 talloc_steal(mem_ctx, state->out_mem_ctx);
4822
4823 /* Return result */
4824 *result = state->orig.out.result;
4825
4826 tevent_req_received(req);
4827 return NT_STATUS_OK;
4828 }
4829
4830 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
4831 TALLOC_CTX *mem_ctx,
4832 uint16_t *hostname /* [in] [unique] */,
4833 struct lsa_StringLarge *message /* [in] [unique] */,
4834 uint32_t timeout /* [in] */,
4835 uint8_t force_apps /* [in] */,
4836 uint8_t do_reboot /* [in] */,
4837 uint32_t reason /* [in] */,
4838 WERROR *werror)
4839 {
4840 struct winreg_InitiateSystemShutdownEx r;
4841 NTSTATUS status;
4842
4843 /* In parameters */
4844 r.in.hostname = hostname;
4845 r.in.message = message;
4846 r.in.timeout = timeout;
4847 r.in.force_apps = force_apps;
4848 r.in.do_reboot = do_reboot;
4849 r.in.reason = reason;
4850
4851 status = cli->dispatch(cli,
4852 mem_ctx,
4853 &ndr_table_winreg,
4854 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
4855 &r);
4856
4857 if (!NT_STATUS_IS_OK(status)) {
4858 return status;
4859 }
4860
4861 if (NT_STATUS_IS_ERR(status)) {
4862 return status;
4863 }
4864
4865 /* Return variables */
4866
4867 /* Return result */
4868 if (werror) {
4869 *werror = r.out.result;
4870 }
4871
4872 return werror_to_ntstatus(r.out.result);
4873 }
4874
4875 struct rpccli_winreg_SaveKeyEx_state {
4876 struct winreg_SaveKeyEx orig;
4877 struct winreg_SaveKeyEx tmp;
4878 TALLOC_CTX *out_mem_ctx;
4879 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4880 };
4881
4882 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq);
4883
4884 struct tevent_req *rpccli_winreg_SaveKeyEx_send(TALLOC_CTX *mem_ctx,
4885 struct tevent_context *ev,
4886 struct rpc_pipe_client *cli)
4887 {
4888 struct tevent_req *req;
4889 struct rpccli_winreg_SaveKeyEx_state *state;
4890 struct tevent_req *subreq;
4891
4892 req = tevent_req_create(mem_ctx, &state,
4893 struct rpccli_winreg_SaveKeyEx_state);
4894 if (req == NULL) {
4895 return NULL;
4896 }
4897 state->out_mem_ctx = NULL;
4898 state->dispatch_recv = cli->dispatch_recv;
4899
4900 /* In parameters */
4901
4902 /* Out parameters */
4903
4904 /* Result */
4905 ZERO_STRUCT(state->orig.out.result);
4906
4907 /* make a temporary copy, that we pass to the dispatch function */
4908 state->tmp = state->orig;
4909
4910 subreq = cli->dispatch_send(state, ev, cli,
4911 &ndr_table_winreg,
4912 NDR_WINREG_SAVEKEYEX,
4913 &state->tmp);
4914 if (tevent_req_nomem(subreq, req)) {
4915 return tevent_req_post(req, ev);
4916 }
4917 tevent_req_set_callback(subreq, rpccli_winreg_SaveKeyEx_done, req);
4918 return req;
4919 }
4920
4921 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq)
4922 {
4923 struct tevent_req *req = tevent_req_callback_data(
4924 subreq, struct tevent_req);
4925 struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
4926 req, struct rpccli_winreg_SaveKeyEx_state);
4927 NTSTATUS status;
4928 TALLOC_CTX *mem_ctx;
4929
4930 if (state->out_mem_ctx) {
4931 mem_ctx = state->out_mem_ctx;
4932 } else {
4933 mem_ctx = state;
4934 }
4935
4936 status = state->dispatch_recv(subreq, mem_ctx);
4937 TALLOC_FREE(subreq);
4938 if (!NT_STATUS_IS_OK(status)) {
4939 tevent_req_nterror(req, status);
4940 return;
4941 }
4942
4943 /* Copy out parameters */
4944
4945 /* Copy result */
4946 state->orig.out.result = state->tmp.out.result;
4947
4948 /* Reset temporary structure */
4949 ZERO_STRUCT(state->tmp);
4950
4951 tevent_req_done(req);
4952 }
4953
4954 NTSTATUS rpccli_winreg_SaveKeyEx_recv(struct tevent_req *req,
4955 TALLOC_CTX *mem_ctx,
4956 WERROR *result)
4957 {
4958 struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
4959 req, struct rpccli_winreg_SaveKeyEx_state);
4960 NTSTATUS status;
4961
4962 if (tevent_req_is_nterror(req, &status)) {
4963 tevent_req_received(req);
4964 return status;
4965 }
4966
4967 /* Steal possbile out parameters to the callers context */
4968 talloc_steal(mem_ctx, state->out_mem_ctx);
4969
4970 /* Return result */
4971 *result = state->orig.out.result;
4972
4973 tevent_req_received(req);
4974 return NT_STATUS_OK;
4975 }
4976
4977 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
4978 TALLOC_CTX *mem_ctx,
4979 WERROR *werror)
4980 {
4981 struct winreg_SaveKeyEx r;
4982 NTSTATUS status;
4983
4984 /* In parameters */
4985
4986 status = cli->dispatch(cli,
4987 mem_ctx,
4988 &ndr_table_winreg,
4989 NDR_WINREG_SAVEKEYEX,
4990 &r);
4991
4992 if (!NT_STATUS_IS_OK(status)) {
4993 return status;
4994 }
4995
4996 if (NT_STATUS_IS_ERR(status)) {
4997 return status;
4998 }
4999
5000 /* Return variables */
5001
5002 /* Return result */
5003 if (werror) {
5004 *werror = r.out.result;
5005 }
5006
5007 return werror_to_ntstatus(r.out.result);
5008 }
5009
5010 struct rpccli_winreg_OpenHKPT_state {
5011 struct winreg_OpenHKPT orig;
5012 struct winreg_OpenHKPT tmp;
5013 TALLOC_CTX *out_mem_ctx;
5014 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5015 };
5016
5017 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq);
5018
5019 struct tevent_req *rpccli_winreg_OpenHKPT_send(TALLOC_CTX *mem_ctx,
5020 struct tevent_context *ev,
5021 struct rpc_pipe_client *cli,
5022 uint16_t *_system_name /* [in] [unique] */,
5023 uint32_t _access_mask /* [in] */,
5024 struct policy_handle *_handle /* [out] [ref] */)
5025 {
5026 struct tevent_req *req;
5027 struct rpccli_winreg_OpenHKPT_state *state;
5028 struct tevent_req *subreq;
5029
5030 req = tevent_req_create(mem_ctx, &state,
5031 struct rpccli_winreg_OpenHKPT_state);
5032 if (req == NULL) {
5033 return NULL;
5034 }
5035 state->out_mem_ctx = NULL;
5036 state->dispatch_recv = cli->dispatch_recv;
5037
5038 /* In parameters */
5039 state->orig.in.system_name = _system_name;
5040 state->orig.in.access_mask = _access_mask;
5041
5042 /* Out parameters */
5043 state->orig.out.handle = _handle;
5044
5045 /* Result */
5046 ZERO_STRUCT(state->orig.out.result);
5047
5048 state->out_mem_ctx = talloc_named_const(state, 0,
5049 "rpccli_winreg_OpenHKPT_out_memory");
5050 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5051 return tevent_req_post(req, ev);
5052 }
5053
5054 /* make a temporary copy, that we pass to the dispatch function */
5055 state->tmp = state->orig;
5056
5057 subreq = cli->dispatch_send(state, ev, cli,
5058 &ndr_table_winreg,
5059 NDR_WINREG_OPENHKPT,
5060 &state->tmp);
5061 if (tevent_req_nomem(subreq, req)) {
5062 return tevent_req_post(req, ev);
5063 }
5064 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPT_done, req);
5065 return req;
5066 }
5067
5068 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq)
5069 {
5070 struct tevent_req *req = tevent_req_callback_data(
5071 subreq, struct tevent_req);
5072 struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5073 req, struct rpccli_winreg_OpenHKPT_state);
5074 NTSTATUS status;
5075 TALLOC_CTX *mem_ctx;
5076
5077 if (state->out_mem_ctx) {
5078 mem_ctx = state->out_mem_ctx;
5079 } else {
5080 mem_ctx = state;
5081 }
5082
5083 status = state->dispatch_recv(subreq, mem_ctx);
5084 TALLOC_FREE(subreq);
5085 if (!NT_STATUS_IS_OK(status)) {
5086 tevent_req_nterror(req, status);
5087 return;
5088 }
5089
5090 /* Copy out parameters */
5091 *state->orig.out.handle = *state->tmp.out.handle;
5092
5093 /* Copy result */
5094 state->orig.out.result = state->tmp.out.result;
5095
5096 /* Reset temporary structure */
5097 ZERO_STRUCT(state->tmp);
5098
5099 tevent_req_done(req);
5100 }
5101
5102 NTSTATUS rpccli_winreg_OpenHKPT_recv(struct tevent_req *req,
5103 TALLOC_CTX *mem_ctx,
5104 WERROR *result)
5105 {
5106 struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5107 req, struct rpccli_winreg_OpenHKPT_state);
5108 NTSTATUS status;
5109
5110 if (tevent_req_is_nterror(req, &status)) {
5111 tevent_req_received(req);
5112 return status;
5113 }
5114
5115 /* Steal possbile out parameters to the callers context */
5116 talloc_steal(mem_ctx, state->out_mem_ctx);
5117
5118 /* Return result */
5119 *result = state->orig.out.result;
5120
5121 tevent_req_received(req);
5122 return NT_STATUS_OK;
5123 }
5124
5125 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
5126 TALLOC_CTX *mem_ctx,
5127 uint16_t *system_name /* [in] [unique] */,
5128 uint32_t access_mask /* [in] */,
5129 struct policy_handle *handle /* [out] [ref] */,
5130 WERROR *werror)
5131 {
5132 struct winreg_OpenHKPT r;
5133 NTSTATUS status;
5134
5135 /* In parameters */
5136 r.in.system_name = system_name;
5137 r.in.access_mask = access_mask;
5138
5139 status = cli->dispatch(cli,
5140 mem_ctx,
5141 &ndr_table_winreg,
5142 NDR_WINREG_OPENHKPT,
5143 &r);
5144
5145 if (!NT_STATUS_IS_OK(status)) {
5146 return status;
5147 }
5148
5149 if (NT_STATUS_IS_ERR(status)) {
5150 return status;
5151 }
5152
5153 /* Return variables */
5154 *handle = *r.out.handle;
5155
5156 /* Return result */
5157 if (werror) {
5158 *werror = r.out.result;
5159 }
5160
5161 return werror_to_ntstatus(r.out.result);
5162 }
5163
5164 struct rpccli_winreg_OpenHKPN_state {
5165 struct winreg_OpenHKPN orig;
5166 struct winreg_OpenHKPN tmp;
5167 TALLOC_CTX *out_mem_ctx;
5168 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5169 };
5170
5171 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq);
5172
5173 struct tevent_req *rpccli_winreg_OpenHKPN_send(TALLOC_CTX *mem_ctx,
5174 struct tevent_context *ev,
5175 struct rpc_pipe_client *cli,
5176 uint16_t *_system_name /* [in] [unique] */,
5177 uint32_t _access_mask /* [in] */,
5178 struct policy_handle *_handle /* [out] [ref] */)
5179 {
5180 struct tevent_req *req;
5181 struct rpccli_winreg_OpenHKPN_state *state;
5182 struct tevent_req *subreq;
5183
5184 req = tevent_req_create(mem_ctx, &state,
5185 struct rpccli_winreg_OpenHKPN_state);
5186 if (req == NULL) {
5187 return NULL;
5188 }
5189 state->out_mem_ctx = NULL;
5190 state->dispatch_recv = cli->dispatch_recv;
5191
5192 /* In parameters */
5193 state->orig.in.system_name = _system_name;
5194 state->orig.in.access_mask = _access_mask;
5195
5196 /* Out parameters */
5197 state->orig.out.handle = _handle;
5198
5199 /* Result */
5200 ZERO_STRUCT(state->orig.out.result);
5201
5202 state->out_mem_ctx = talloc_named_const(state, 0,
5203 "rpccli_winreg_OpenHKPN_out_memory");
5204 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5205 return tevent_req_post(req, ev);
5206 }
5207
5208 /* make a temporary copy, that we pass to the dispatch function */
5209 state->tmp = state->orig;
5210
5211 subreq = cli->dispatch_send(state, ev, cli,
5212 &ndr_table_winreg,
5213 NDR_WINREG_OPENHKPN,
5214 &state->tmp);
5215 if (tevent_req_nomem(subreq, req)) {
5216 return tevent_req_post(req, ev);
5217 }
5218 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPN_done, req);
5219 return req;
5220 }
5221
5222 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq)
5223 {
5224 struct tevent_req *req = tevent_req_callback_data(
5225 subreq, struct tevent_req);
5226 struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5227 req, struct rpccli_winreg_OpenHKPN_state);
5228 NTSTATUS status;
5229 TALLOC_CTX *mem_ctx;
5230
5231 if (state->out_mem_ctx) {
5232 mem_ctx = state->out_mem_ctx;
5233 } else {
5234 mem_ctx = state;
5235 }
5236
5237 status = state->dispatch_recv(subreq, mem_ctx);
5238 TALLOC_FREE(subreq);
5239 if (!NT_STATUS_IS_OK(status)) {
5240 tevent_req_nterror(req, status);
5241 return;
5242 }
5243
5244 /* Copy out parameters */
5245 *state->orig.out.handle = *state->tmp.out.handle;
5246
5247 /* Copy result */
5248 state->orig.out.result = state->tmp.out.result;
5249
5250 /* Reset temporary structure */
5251 ZERO_STRUCT(state->tmp);
5252
5253 tevent_req_done(req);
5254 }
5255
5256 NTSTATUS rpccli_winreg_OpenHKPN_recv(struct tevent_req *req,
5257 TALLOC_CTX *mem_ctx,
5258 WERROR *result)
5259 {
5260 struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5261 req, struct rpccli_winreg_OpenHKPN_state);
5262 NTSTATUS status;
5263
5264 if (tevent_req_is_nterror(req, &status)) {
5265 tevent_req_received(req);
5266 return status;
5267 }
5268
5269 /* Steal possbile out parameters to the callers context */
5270 talloc_steal(mem_ctx, state->out_mem_ctx);
5271
5272 /* Return result */
5273 *result = state->orig.out.result;
5274
5275 tevent_req_received(req);
5276 return NT_STATUS_OK;
5277 }
5278
5279 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
5280 TALLOC_CTX *mem_ctx,
5281 uint16_t *system_name /* [in] [unique] */,
5282 uint32_t access_mask /* [in] */,
5283 struct policy_handle *handle /* [out] [ref] */,
5284 WERROR *werror)
5285 {
5286 struct winreg_OpenHKPN r;
5287 NTSTATUS status;
5288
5289 /* In parameters */
5290 r.in.system_name = system_name;
5291 r.in.access_mask = access_mask;
5292
5293 status = cli->dispatch(cli,
5294 mem_ctx,
5295 &ndr_table_winreg,
5296 NDR_WINREG_OPENHKPN,
5297 &r);
5298
5299 if (!NT_STATUS_IS_OK(status)) {
5300 return status;
5301 }
5302
5303 if (NT_STATUS_IS_ERR(status)) {
5304 return status;
5305 }
5306
5307 /* Return variables */
5308 *handle = *r.out.handle;
5309
5310 /* Return result */
5311 if (werror) {
5312 *werror = r.out.result;
5313 }
5314
5315 return werror_to_ntstatus(r.out.result);
5316 }
5317
5318 struct rpccli_winreg_QueryMultipleValues2_state {
5319 struct winreg_QueryMultipleValues2 orig;
5320 struct winreg_QueryMultipleValues2 tmp;
5321 TALLOC_CTX *out_mem_ctx;
5322 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5323 };
5324
5325 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq);
5326
5327 struct tevent_req *rpccli_winreg_QueryMultipleValues2_send(TALLOC_CTX *mem_ctx,
5328 struct tevent_context *ev,
5329 struct rpc_pipe_client *cli)
5330 {
5331 struct tevent_req *req;
5332 struct rpccli_winreg_QueryMultipleValues2_state *state;
5333 struct tevent_req *subreq;
5334
5335 req = tevent_req_create(mem_ctx, &state,
5336 struct rpccli_winreg_QueryMultipleValues2_state);
5337 if (req == NULL) {
5338 return NULL;
5339 }
5340 state->out_mem_ctx = NULL;
5341 state->dispatch_recv = cli->dispatch_recv;
5342
5343 /* In parameters */
5344
5345 /* Out parameters */
5346
5347 /* Result */
5348 ZERO_STRUCT(state->orig.out.result);
5349
5350 /* make a temporary copy, that we pass to the dispatch function */
5351 state->tmp = state->orig;
5352
5353 subreq = cli->dispatch_send(state, ev, cli,
5354 &ndr_table_winreg,
5355 NDR_WINREG_QUERYMULTIPLEVALUES2,
5356 &state->tmp);
5357 if (tevent_req_nomem(subreq, req)) {
5358 return tevent_req_post(req, ev);
5359 }
5360 tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues2_done, req);
5361 return req;
5362 }
5363
5364 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq)
5365 {
5366 struct tevent_req *req = tevent_req_callback_data(
5367 subreq, struct tevent_req);
5368 struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5369 req, struct rpccli_winreg_QueryMultipleValues2_state);
5370 NTSTATUS status;
5371 TALLOC_CTX *mem_ctx;
5372
5373 if (state->out_mem_ctx) {
5374 mem_ctx = state->out_mem_ctx;
5375 } else {
5376 mem_ctx = state;
5377 }
5378
5379 status = state->dispatch_recv(subreq, mem_ctx);
5380 TALLOC_FREE(subreq);
5381 if (!NT_STATUS_IS_OK(status)) {
5382 tevent_req_nterror(req, status);
5383 return;
5384 }
5385
5386 /* Copy out parameters */
5387
5388 /* Copy result */
5389 state->orig.out.result = state->tmp.out.result;
5390
5391 /* Reset temporary structure */
5392 ZERO_STRUCT(state->tmp);
5393
5394 tevent_req_done(req);
5395 }
5396
5397 NTSTATUS rpccli_winreg_QueryMultipleValues2_recv(struct tevent_req *req,
5398 TALLOC_CTX *mem_ctx,
5399 WERROR *result)
5400 {
5401 struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5402 req, struct rpccli_winreg_QueryMultipleValues2_state);
5403 NTSTATUS status;
5404
5405 if (tevent_req_is_nterror(req, &status)) {
5406 tevent_req_received(req);
5407 return status;
5408 }
5409
5410 /* Steal possbile out parameters to the callers context */
5411 talloc_steal(mem_ctx, state->out_mem_ctx);
5412
5413 /* Return result */
5414 *result = state->orig.out.result;
5415
5416 tevent_req_received(req);
5417 return NT_STATUS_OK;
5418 }
5419
5420 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
5421 TALLOC_CTX *mem_ctx,
5422 WERROR *werror)
5423 {
5424 struct winreg_QueryMultipleValues2 r;
5425 NTSTATUS status;
5426
5427 /* In parameters */
5428
5429 status = cli->dispatch(cli,
5430 mem_ctx,
5431 &ndr_table_winreg,
5432 NDR_WINREG_QUERYMULTIPLEVALUES2,
5433 &r);
5434
5435 if (!NT_STATUS_IS_OK(status)) {
5436 return status;
5437 }
5438
5439 if (NT_STATUS_IS_ERR(status)) {
5440 return status;
5441 }
5442
5443 /* Return variables */
5444
5445 /* Return result */
5446 if (werror) {
5447 *werror = r.out.result;
5448 }
5449
5450 return werror_to_ntstatus(r.out.result);
5451 }
5452
reg import