?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/named_pipe_auth: we need to hide length of the message mode header from the...
[Samba/gebeck_regimport.git] / librpc / gen_ndr / cli_winreg.c
blob5eb7fb9ccc9310d9ba27cebbbc49a30b93e577b0
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 _options /* [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.options = _options;
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 options /* [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.options = options;
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,range(0,0x4000000),length_is(data_length?*data_length:0),size_is(data_size?*data_size:0)] */,
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?*state->tmp.in.data_size:0) * 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,range(0,0x4000000),length_is(data_length?*data_length:0),size_is(data_size?*data_size:0)] */,
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?*r.in.data_size:0) * 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 struct policy_handle *_handle /* [in] [ref] */,
2937 struct winreg_String *_subkey /* [in] [ref] */,
2938 struct winreg_String *_new_file /* [in] [ref] */,
2939 struct winreg_String *_old_file /* [in] [ref] */)
2940 {
2941 struct tevent_req *req;
2942 struct rpccli_winreg_ReplaceKey_state *state;
2943 struct tevent_req *subreq;
2944
2945 req = tevent_req_create(mem_ctx, &state,
2946 struct rpccli_winreg_ReplaceKey_state);
2947 if (req == NULL) {
2948 return NULL;
2949 }
2950 state->out_mem_ctx = NULL;
2951 state->dispatch_recv = cli->dispatch_recv;
2952
2953 /* In parameters */
2954 state->orig.in.handle = _handle;
2955 state->orig.in.subkey = _subkey;
2956 state->orig.in.new_file = _new_file;
2957 state->orig.in.old_file = _old_file;
2958
2959 /* Out parameters */
2960
2961 /* Result */
2962 ZERO_STRUCT(state->orig.out.result);
2963
2964 /* make a temporary copy, that we pass to the dispatch function */
2965 state->tmp = state->orig;
2966
2967 subreq = cli->dispatch_send(state, ev, cli,
2968 &ndr_table_winreg,
2969 NDR_WINREG_REPLACEKEY,
2970 &state->tmp);
2971 if (tevent_req_nomem(subreq, req)) {
2972 return tevent_req_post(req, ev);
2973 }
2974 tevent_req_set_callback(subreq, rpccli_winreg_ReplaceKey_done, req);
2975 return req;
2976 }
2977
2978 static void rpccli_winreg_ReplaceKey_done(struct tevent_req *subreq)
2979 {
2980 struct tevent_req *req = tevent_req_callback_data(
2981 subreq, struct tevent_req);
2982 struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
2983 req, struct rpccli_winreg_ReplaceKey_state);
2984 NTSTATUS status;
2985 TALLOC_CTX *mem_ctx;
2986
2987 if (state->out_mem_ctx) {
2988 mem_ctx = state->out_mem_ctx;
2989 } else {
2990 mem_ctx = state;
2991 }
2992
2993 status = state->dispatch_recv(subreq, mem_ctx);
2994 TALLOC_FREE(subreq);
2995 if (!NT_STATUS_IS_OK(status)) {
2996 tevent_req_nterror(req, status);
2997 return;
2998 }
2999
3000 /* Copy out parameters */
3001
3002 /* Copy result */
3003 state->orig.out.result = state->tmp.out.result;
3004
3005 /* Reset temporary structure */
3006 ZERO_STRUCT(state->tmp);
3007
3008 tevent_req_done(req);
3009 }
3010
3011 NTSTATUS rpccli_winreg_ReplaceKey_recv(struct tevent_req *req,
3012 TALLOC_CTX *mem_ctx,
3013 WERROR *result)
3014 {
3015 struct rpccli_winreg_ReplaceKey_state *state = tevent_req_data(
3016 req, struct rpccli_winreg_ReplaceKey_state);
3017 NTSTATUS status;
3018
3019 if (tevent_req_is_nterror(req, &status)) {
3020 tevent_req_received(req);
3021 return status;
3022 }
3023
3024 /* Steal possbile out parameters to the callers context */
3025 talloc_steal(mem_ctx, state->out_mem_ctx);
3026
3027 /* Return result */
3028 *result = state->orig.out.result;
3029
3030 tevent_req_received(req);
3031 return NT_STATUS_OK;
3032 }
3033
3034 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
3035 TALLOC_CTX *mem_ctx,
3036 struct policy_handle *handle /* [in] [ref] */,
3037 struct winreg_String *subkey /* [in] [ref] */,
3038 struct winreg_String *new_file /* [in] [ref] */,
3039 struct winreg_String *old_file /* [in] [ref] */,
3040 WERROR *werror)
3041 {
3042 struct winreg_ReplaceKey r;
3043 NTSTATUS status;
3044
3045 /* In parameters */
3046 r.in.handle = handle;
3047 r.in.subkey = subkey;
3048 r.in.new_file = new_file;
3049 r.in.old_file = old_file;
3050
3051 status = cli->dispatch(cli,
3052 mem_ctx,
3053 &ndr_table_winreg,
3054 NDR_WINREG_REPLACEKEY,
3055 &r);
3056
3057 if (!NT_STATUS_IS_OK(status)) {
3058 return status;
3059 }
3060
3061 if (NT_STATUS_IS_ERR(status)) {
3062 return status;
3063 }
3064
3065 /* Return variables */
3066
3067 /* Return result */
3068 if (werror) {
3069 *werror = r.out.result;
3070 }
3071
3072 return werror_to_ntstatus(r.out.result);
3073 }
3074
3075 struct rpccli_winreg_RestoreKey_state {
3076 struct winreg_RestoreKey orig;
3077 struct winreg_RestoreKey tmp;
3078 TALLOC_CTX *out_mem_ctx;
3079 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3080 };
3081
3082 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq);
3083
3084 struct tevent_req *rpccli_winreg_RestoreKey_send(TALLOC_CTX *mem_ctx,
3085 struct tevent_context *ev,
3086 struct rpc_pipe_client *cli,
3087 struct policy_handle *_handle /* [in] [ref] */,
3088 struct winreg_String *_filename /* [in] [ref] */,
3089 uint32_t _flags /* [in] */)
3090 {
3091 struct tevent_req *req;
3092 struct rpccli_winreg_RestoreKey_state *state;
3093 struct tevent_req *subreq;
3094
3095 req = tevent_req_create(mem_ctx, &state,
3096 struct rpccli_winreg_RestoreKey_state);
3097 if (req == NULL) {
3098 return NULL;
3099 }
3100 state->out_mem_ctx = NULL;
3101 state->dispatch_recv = cli->dispatch_recv;
3102
3103 /* In parameters */
3104 state->orig.in.handle = _handle;
3105 state->orig.in.filename = _filename;
3106 state->orig.in.flags = _flags;
3107
3108 /* Out parameters */
3109
3110 /* Result */
3111 ZERO_STRUCT(state->orig.out.result);
3112
3113 /* make a temporary copy, that we pass to the dispatch function */
3114 state->tmp = state->orig;
3115
3116 subreq = cli->dispatch_send(state, ev, cli,
3117 &ndr_table_winreg,
3118 NDR_WINREG_RESTOREKEY,
3119 &state->tmp);
3120 if (tevent_req_nomem(subreq, req)) {
3121 return tevent_req_post(req, ev);
3122 }
3123 tevent_req_set_callback(subreq, rpccli_winreg_RestoreKey_done, req);
3124 return req;
3125 }
3126
3127 static void rpccli_winreg_RestoreKey_done(struct tevent_req *subreq)
3128 {
3129 struct tevent_req *req = tevent_req_callback_data(
3130 subreq, struct tevent_req);
3131 struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3132 req, struct rpccli_winreg_RestoreKey_state);
3133 NTSTATUS status;
3134 TALLOC_CTX *mem_ctx;
3135
3136 if (state->out_mem_ctx) {
3137 mem_ctx = state->out_mem_ctx;
3138 } else {
3139 mem_ctx = state;
3140 }
3141
3142 status = state->dispatch_recv(subreq, mem_ctx);
3143 TALLOC_FREE(subreq);
3144 if (!NT_STATUS_IS_OK(status)) {
3145 tevent_req_nterror(req, status);
3146 return;
3147 }
3148
3149 /* Copy out parameters */
3150
3151 /* Copy result */
3152 state->orig.out.result = state->tmp.out.result;
3153
3154 /* Reset temporary structure */
3155 ZERO_STRUCT(state->tmp);
3156
3157 tevent_req_done(req);
3158 }
3159
3160 NTSTATUS rpccli_winreg_RestoreKey_recv(struct tevent_req *req,
3161 TALLOC_CTX *mem_ctx,
3162 WERROR *result)
3163 {
3164 struct rpccli_winreg_RestoreKey_state *state = tevent_req_data(
3165 req, struct rpccli_winreg_RestoreKey_state);
3166 NTSTATUS status;
3167
3168 if (tevent_req_is_nterror(req, &status)) {
3169 tevent_req_received(req);
3170 return status;
3171 }
3172
3173 /* Steal possbile out parameters to the callers context */
3174 talloc_steal(mem_ctx, state->out_mem_ctx);
3175
3176 /* Return result */
3177 *result = state->orig.out.result;
3178
3179 tevent_req_received(req);
3180 return NT_STATUS_OK;
3181 }
3182
3183 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
3184 TALLOC_CTX *mem_ctx,
3185 struct policy_handle *handle /* [in] [ref] */,
3186 struct winreg_String *filename /* [in] [ref] */,
3187 uint32_t flags /* [in] */,
3188 WERROR *werror)
3189 {
3190 struct winreg_RestoreKey r;
3191 NTSTATUS status;
3192
3193 /* In parameters */
3194 r.in.handle = handle;
3195 r.in.filename = filename;
3196 r.in.flags = flags;
3197
3198 status = cli->dispatch(cli,
3199 mem_ctx,
3200 &ndr_table_winreg,
3201 NDR_WINREG_RESTOREKEY,
3202 &r);
3203
3204 if (!NT_STATUS_IS_OK(status)) {
3205 return status;
3206 }
3207
3208 if (NT_STATUS_IS_ERR(status)) {
3209 return status;
3210 }
3211
3212 /* Return variables */
3213
3214 /* Return result */
3215 if (werror) {
3216 *werror = r.out.result;
3217 }
3218
3219 return werror_to_ntstatus(r.out.result);
3220 }
3221
3222 struct rpccli_winreg_SaveKey_state {
3223 struct winreg_SaveKey orig;
3224 struct winreg_SaveKey tmp;
3225 TALLOC_CTX *out_mem_ctx;
3226 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3227 };
3228
3229 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq);
3230
3231 struct tevent_req *rpccli_winreg_SaveKey_send(TALLOC_CTX *mem_ctx,
3232 struct tevent_context *ev,
3233 struct rpc_pipe_client *cli,
3234 struct policy_handle *_handle /* [in] [ref] */,
3235 struct winreg_String *_filename /* [in] [ref] */,
3236 struct KeySecurityAttribute *_sec_attrib /* [in] [unique] */)
3237 {
3238 struct tevent_req *req;
3239 struct rpccli_winreg_SaveKey_state *state;
3240 struct tevent_req *subreq;
3241
3242 req = tevent_req_create(mem_ctx, &state,
3243 struct rpccli_winreg_SaveKey_state);
3244 if (req == NULL) {
3245 return NULL;
3246 }
3247 state->out_mem_ctx = NULL;
3248 state->dispatch_recv = cli->dispatch_recv;
3249
3250 /* In parameters */
3251 state->orig.in.handle = _handle;
3252 state->orig.in.filename = _filename;
3253 state->orig.in.sec_attrib = _sec_attrib;
3254
3255 /* Out parameters */
3256
3257 /* Result */
3258 ZERO_STRUCT(state->orig.out.result);
3259
3260 /* make a temporary copy, that we pass to the dispatch function */
3261 state->tmp = state->orig;
3262
3263 subreq = cli->dispatch_send(state, ev, cli,
3264 &ndr_table_winreg,
3265 NDR_WINREG_SAVEKEY,
3266 &state->tmp);
3267 if (tevent_req_nomem(subreq, req)) {
3268 return tevent_req_post(req, ev);
3269 }
3270 tevent_req_set_callback(subreq, rpccli_winreg_SaveKey_done, req);
3271 return req;
3272 }
3273
3274 static void rpccli_winreg_SaveKey_done(struct tevent_req *subreq)
3275 {
3276 struct tevent_req *req = tevent_req_callback_data(
3277 subreq, struct tevent_req);
3278 struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3279 req, struct rpccli_winreg_SaveKey_state);
3280 NTSTATUS status;
3281 TALLOC_CTX *mem_ctx;
3282
3283 if (state->out_mem_ctx) {
3284 mem_ctx = state->out_mem_ctx;
3285 } else {
3286 mem_ctx = state;
3287 }
3288
3289 status = state->dispatch_recv(subreq, mem_ctx);
3290 TALLOC_FREE(subreq);
3291 if (!NT_STATUS_IS_OK(status)) {
3292 tevent_req_nterror(req, status);
3293 return;
3294 }
3295
3296 /* Copy out parameters */
3297
3298 /* Copy result */
3299 state->orig.out.result = state->tmp.out.result;
3300
3301 /* Reset temporary structure */
3302 ZERO_STRUCT(state->tmp);
3303
3304 tevent_req_done(req);
3305 }
3306
3307 NTSTATUS rpccli_winreg_SaveKey_recv(struct tevent_req *req,
3308 TALLOC_CTX *mem_ctx,
3309 WERROR *result)
3310 {
3311 struct rpccli_winreg_SaveKey_state *state = tevent_req_data(
3312 req, struct rpccli_winreg_SaveKey_state);
3313 NTSTATUS status;
3314
3315 if (tevent_req_is_nterror(req, &status)) {
3316 tevent_req_received(req);
3317 return status;
3318 }
3319
3320 /* Steal possbile out parameters to the callers context */
3321 talloc_steal(mem_ctx, state->out_mem_ctx);
3322
3323 /* Return result */
3324 *result = state->orig.out.result;
3325
3326 tevent_req_received(req);
3327 return NT_STATUS_OK;
3328 }
3329
3330 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
3331 TALLOC_CTX *mem_ctx,
3332 struct policy_handle *handle /* [in] [ref] */,
3333 struct winreg_String *filename /* [in] [ref] */,
3334 struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
3335 WERROR *werror)
3336 {
3337 struct winreg_SaveKey r;
3338 NTSTATUS status;
3339
3340 /* In parameters */
3341 r.in.handle = handle;
3342 r.in.filename = filename;
3343 r.in.sec_attrib = sec_attrib;
3344
3345 status = cli->dispatch(cli,
3346 mem_ctx,
3347 &ndr_table_winreg,
3348 NDR_WINREG_SAVEKEY,
3349 &r);
3350
3351 if (!NT_STATUS_IS_OK(status)) {
3352 return status;
3353 }
3354
3355 if (NT_STATUS_IS_ERR(status)) {
3356 return status;
3357 }
3358
3359 /* Return variables */
3360
3361 /* Return result */
3362 if (werror) {
3363 *werror = r.out.result;
3364 }
3365
3366 return werror_to_ntstatus(r.out.result);
3367 }
3368
3369 struct rpccli_winreg_SetKeySecurity_state {
3370 struct winreg_SetKeySecurity orig;
3371 struct winreg_SetKeySecurity tmp;
3372 TALLOC_CTX *out_mem_ctx;
3373 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3374 };
3375
3376 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq);
3377
3378 struct tevent_req *rpccli_winreg_SetKeySecurity_send(TALLOC_CTX *mem_ctx,
3379 struct tevent_context *ev,
3380 struct rpc_pipe_client *cli,
3381 struct policy_handle *_handle /* [in] [ref] */,
3382 uint32_t _sec_info /* [in] */,
3383 struct KeySecurityData *_sd /* [in] [ref] */)
3384 {
3385 struct tevent_req *req;
3386 struct rpccli_winreg_SetKeySecurity_state *state;
3387 struct tevent_req *subreq;
3388
3389 req = tevent_req_create(mem_ctx, &state,
3390 struct rpccli_winreg_SetKeySecurity_state);
3391 if (req == NULL) {
3392 return NULL;
3393 }
3394 state->out_mem_ctx = NULL;
3395 state->dispatch_recv = cli->dispatch_recv;
3396
3397 /* In parameters */
3398 state->orig.in.handle = _handle;
3399 state->orig.in.sec_info = _sec_info;
3400 state->orig.in.sd = _sd;
3401
3402 /* Out parameters */
3403
3404 /* Result */
3405 ZERO_STRUCT(state->orig.out.result);
3406
3407 /* make a temporary copy, that we pass to the dispatch function */
3408 state->tmp = state->orig;
3409
3410 subreq = cli->dispatch_send(state, ev, cli,
3411 &ndr_table_winreg,
3412 NDR_WINREG_SETKEYSECURITY,
3413 &state->tmp);
3414 if (tevent_req_nomem(subreq, req)) {
3415 return tevent_req_post(req, ev);
3416 }
3417 tevent_req_set_callback(subreq, rpccli_winreg_SetKeySecurity_done, req);
3418 return req;
3419 }
3420
3421 static void rpccli_winreg_SetKeySecurity_done(struct tevent_req *subreq)
3422 {
3423 struct tevent_req *req = tevent_req_callback_data(
3424 subreq, struct tevent_req);
3425 struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3426 req, struct rpccli_winreg_SetKeySecurity_state);
3427 NTSTATUS status;
3428 TALLOC_CTX *mem_ctx;
3429
3430 if (state->out_mem_ctx) {
3431 mem_ctx = state->out_mem_ctx;
3432 } else {
3433 mem_ctx = state;
3434 }
3435
3436 status = state->dispatch_recv(subreq, mem_ctx);
3437 TALLOC_FREE(subreq);
3438 if (!NT_STATUS_IS_OK(status)) {
3439 tevent_req_nterror(req, status);
3440 return;
3441 }
3442
3443 /* Copy out parameters */
3444
3445 /* Copy result */
3446 state->orig.out.result = state->tmp.out.result;
3447
3448 /* Reset temporary structure */
3449 ZERO_STRUCT(state->tmp);
3450
3451 tevent_req_done(req);
3452 }
3453
3454 NTSTATUS rpccli_winreg_SetKeySecurity_recv(struct tevent_req *req,
3455 TALLOC_CTX *mem_ctx,
3456 WERROR *result)
3457 {
3458 struct rpccli_winreg_SetKeySecurity_state *state = tevent_req_data(
3459 req, struct rpccli_winreg_SetKeySecurity_state);
3460 NTSTATUS status;
3461
3462 if (tevent_req_is_nterror(req, &status)) {
3463 tevent_req_received(req);
3464 return status;
3465 }
3466
3467 /* Steal possbile out parameters to the callers context */
3468 talloc_steal(mem_ctx, state->out_mem_ctx);
3469
3470 /* Return result */
3471 *result = state->orig.out.result;
3472
3473 tevent_req_received(req);
3474 return NT_STATUS_OK;
3475 }
3476
3477 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
3478 TALLOC_CTX *mem_ctx,
3479 struct policy_handle *handle /* [in] [ref] */,
3480 uint32_t sec_info /* [in] */,
3481 struct KeySecurityData *sd /* [in] [ref] */,
3482 WERROR *werror)
3483 {
3484 struct winreg_SetKeySecurity r;
3485 NTSTATUS status;
3486
3487 /* In parameters */
3488 r.in.handle = handle;
3489 r.in.sec_info = sec_info;
3490 r.in.sd = sd;
3491
3492 status = cli->dispatch(cli,
3493 mem_ctx,
3494 &ndr_table_winreg,
3495 NDR_WINREG_SETKEYSECURITY,
3496 &r);
3497
3498 if (!NT_STATUS_IS_OK(status)) {
3499 return status;
3500 }
3501
3502 if (NT_STATUS_IS_ERR(status)) {
3503 return status;
3504 }
3505
3506 /* Return variables */
3507
3508 /* Return result */
3509 if (werror) {
3510 *werror = r.out.result;
3511 }
3512
3513 return werror_to_ntstatus(r.out.result);
3514 }
3515
3516 struct rpccli_winreg_SetValue_state {
3517 struct winreg_SetValue orig;
3518 struct winreg_SetValue tmp;
3519 TALLOC_CTX *out_mem_ctx;
3520 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3521 };
3522
3523 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq);
3524
3525 struct tevent_req *rpccli_winreg_SetValue_send(TALLOC_CTX *mem_ctx,
3526 struct tevent_context *ev,
3527 struct rpc_pipe_client *cli,
3528 struct policy_handle *_handle /* [in] [ref] */,
3529 struct winreg_String _name /* [in] */,
3530 enum winreg_Type _type /* [in] */,
3531 uint8_t *_data /* [in] [ref,size_is(size)] */,
3532 uint32_t _size /* [in] */)
3533 {
3534 struct tevent_req *req;
3535 struct rpccli_winreg_SetValue_state *state;
3536 struct tevent_req *subreq;
3537
3538 req = tevent_req_create(mem_ctx, &state,
3539 struct rpccli_winreg_SetValue_state);
3540 if (req == NULL) {
3541 return NULL;
3542 }
3543 state->out_mem_ctx = NULL;
3544 state->dispatch_recv = cli->dispatch_recv;
3545
3546 /* In parameters */
3547 state->orig.in.handle = _handle;
3548 state->orig.in.name = _name;
3549 state->orig.in.type = _type;
3550 state->orig.in.data = _data;
3551 state->orig.in.size = _size;
3552
3553 /* Out parameters */
3554
3555 /* Result */
3556 ZERO_STRUCT(state->orig.out.result);
3557
3558 /* make a temporary copy, that we pass to the dispatch function */
3559 state->tmp = state->orig;
3560
3561 subreq = cli->dispatch_send(state, ev, cli,
3562 &ndr_table_winreg,
3563 NDR_WINREG_SETVALUE,
3564 &state->tmp);
3565 if (tevent_req_nomem(subreq, req)) {
3566 return tevent_req_post(req, ev);
3567 }
3568 tevent_req_set_callback(subreq, rpccli_winreg_SetValue_done, req);
3569 return req;
3570 }
3571
3572 static void rpccli_winreg_SetValue_done(struct tevent_req *subreq)
3573 {
3574 struct tevent_req *req = tevent_req_callback_data(
3575 subreq, struct tevent_req);
3576 struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3577 req, struct rpccli_winreg_SetValue_state);
3578 NTSTATUS status;
3579 TALLOC_CTX *mem_ctx;
3580
3581 if (state->out_mem_ctx) {
3582 mem_ctx = state->out_mem_ctx;
3583 } else {
3584 mem_ctx = state;
3585 }
3586
3587 status = state->dispatch_recv(subreq, mem_ctx);
3588 TALLOC_FREE(subreq);
3589 if (!NT_STATUS_IS_OK(status)) {
3590 tevent_req_nterror(req, status);
3591 return;
3592 }
3593
3594 /* Copy out parameters */
3595
3596 /* Copy result */
3597 state->orig.out.result = state->tmp.out.result;
3598
3599 /* Reset temporary structure */
3600 ZERO_STRUCT(state->tmp);
3601
3602 tevent_req_done(req);
3603 }
3604
3605 NTSTATUS rpccli_winreg_SetValue_recv(struct tevent_req *req,
3606 TALLOC_CTX *mem_ctx,
3607 WERROR *result)
3608 {
3609 struct rpccli_winreg_SetValue_state *state = tevent_req_data(
3610 req, struct rpccli_winreg_SetValue_state);
3611 NTSTATUS status;
3612
3613 if (tevent_req_is_nterror(req, &status)) {
3614 tevent_req_received(req);
3615 return status;
3616 }
3617
3618 /* Steal possbile out parameters to the callers context */
3619 talloc_steal(mem_ctx, state->out_mem_ctx);
3620
3621 /* Return result */
3622 *result = state->orig.out.result;
3623
3624 tevent_req_received(req);
3625 return NT_STATUS_OK;
3626 }
3627
3628 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
3629 TALLOC_CTX *mem_ctx,
3630 struct policy_handle *handle /* [in] [ref] */,
3631 struct winreg_String name /* [in] */,
3632 enum winreg_Type type /* [in] */,
3633 uint8_t *data /* [in] [ref,size_is(size)] */,
3634 uint32_t size /* [in] */,
3635 WERROR *werror)
3636 {
3637 struct winreg_SetValue r;
3638 NTSTATUS status;
3639
3640 /* In parameters */
3641 r.in.handle = handle;
3642 r.in.name = name;
3643 r.in.type = type;
3644 r.in.data = data;
3645 r.in.size = size;
3646
3647 status = cli->dispatch(cli,
3648 mem_ctx,
3649 &ndr_table_winreg,
3650 NDR_WINREG_SETVALUE,
3651 &r);
3652
3653 if (!NT_STATUS_IS_OK(status)) {
3654 return status;
3655 }
3656
3657 if (NT_STATUS_IS_ERR(status)) {
3658 return status;
3659 }
3660
3661 /* Return variables */
3662
3663 /* Return result */
3664 if (werror) {
3665 *werror = r.out.result;
3666 }
3667
3668 return werror_to_ntstatus(r.out.result);
3669 }
3670
3671 struct rpccli_winreg_UnLoadKey_state {
3672 struct winreg_UnLoadKey orig;
3673 struct winreg_UnLoadKey tmp;
3674 TALLOC_CTX *out_mem_ctx;
3675 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3676 };
3677
3678 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq);
3679
3680 struct tevent_req *rpccli_winreg_UnLoadKey_send(TALLOC_CTX *mem_ctx,
3681 struct tevent_context *ev,
3682 struct rpc_pipe_client *cli,
3683 struct policy_handle *_handle /* [in] [ref] */,
3684 struct winreg_String *_subkey /* [in] [ref] */)
3685 {
3686 struct tevent_req *req;
3687 struct rpccli_winreg_UnLoadKey_state *state;
3688 struct tevent_req *subreq;
3689
3690 req = tevent_req_create(mem_ctx, &state,
3691 struct rpccli_winreg_UnLoadKey_state);
3692 if (req == NULL) {
3693 return NULL;
3694 }
3695 state->out_mem_ctx = NULL;
3696 state->dispatch_recv = cli->dispatch_recv;
3697
3698 /* In parameters */
3699 state->orig.in.handle = _handle;
3700 state->orig.in.subkey = _subkey;
3701
3702 /* Out parameters */
3703
3704 /* Result */
3705 ZERO_STRUCT(state->orig.out.result);
3706
3707 /* make a temporary copy, that we pass to the dispatch function */
3708 state->tmp = state->orig;
3709
3710 subreq = cli->dispatch_send(state, ev, cli,
3711 &ndr_table_winreg,
3712 NDR_WINREG_UNLOADKEY,
3713 &state->tmp);
3714 if (tevent_req_nomem(subreq, req)) {
3715 return tevent_req_post(req, ev);
3716 }
3717 tevent_req_set_callback(subreq, rpccli_winreg_UnLoadKey_done, req);
3718 return req;
3719 }
3720
3721 static void rpccli_winreg_UnLoadKey_done(struct tevent_req *subreq)
3722 {
3723 struct tevent_req *req = tevent_req_callback_data(
3724 subreq, struct tevent_req);
3725 struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
3726 req, struct rpccli_winreg_UnLoadKey_state);
3727 NTSTATUS status;
3728 TALLOC_CTX *mem_ctx;
3729
3730 if (state->out_mem_ctx) {
3731 mem_ctx = state->out_mem_ctx;
3732 } else {
3733 mem_ctx = state;
3734 }
3735
3736 status = state->dispatch_recv(subreq, mem_ctx);
3737 TALLOC_FREE(subreq);
3738 if (!NT_STATUS_IS_OK(status)) {
3739 tevent_req_nterror(req, status);
3740 return;
3741 }
3742
3743 /* Copy out parameters */
3744
3745 /* Copy result */
3746 state->orig.out.result = state->tmp.out.result;
3747
3748 /* Reset temporary structure */
3749 ZERO_STRUCT(state->tmp);
3750
3751 tevent_req_done(req);
3752 }
3753
3754 NTSTATUS rpccli_winreg_UnLoadKey_recv(struct tevent_req *req,
3755 TALLOC_CTX *mem_ctx,
3756 WERROR *result)
3757 {
3758 struct rpccli_winreg_UnLoadKey_state *state = tevent_req_data(
3759 req, struct rpccli_winreg_UnLoadKey_state);
3760 NTSTATUS status;
3761
3762 if (tevent_req_is_nterror(req, &status)) {
3763 tevent_req_received(req);
3764 return status;
3765 }
3766
3767 /* Steal possbile out parameters to the callers context */
3768 talloc_steal(mem_ctx, state->out_mem_ctx);
3769
3770 /* Return result */
3771 *result = state->orig.out.result;
3772
3773 tevent_req_received(req);
3774 return NT_STATUS_OK;
3775 }
3776
3777 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
3778 TALLOC_CTX *mem_ctx,
3779 struct policy_handle *handle /* [in] [ref] */,
3780 struct winreg_String *subkey /* [in] [ref] */,
3781 WERROR *werror)
3782 {
3783 struct winreg_UnLoadKey r;
3784 NTSTATUS status;
3785
3786 /* In parameters */
3787 r.in.handle = handle;
3788 r.in.subkey = subkey;
3789
3790 status = cli->dispatch(cli,
3791 mem_ctx,
3792 &ndr_table_winreg,
3793 NDR_WINREG_UNLOADKEY,
3794 &r);
3795
3796 if (!NT_STATUS_IS_OK(status)) {
3797 return status;
3798 }
3799
3800 if (NT_STATUS_IS_ERR(status)) {
3801 return status;
3802 }
3803
3804 /* Return variables */
3805
3806 /* Return result */
3807 if (werror) {
3808 *werror = r.out.result;
3809 }
3810
3811 return werror_to_ntstatus(r.out.result);
3812 }
3813
3814 struct rpccli_winreg_InitiateSystemShutdown_state {
3815 struct winreg_InitiateSystemShutdown orig;
3816 struct winreg_InitiateSystemShutdown tmp;
3817 TALLOC_CTX *out_mem_ctx;
3818 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3819 };
3820
3821 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq);
3822
3823 struct tevent_req *rpccli_winreg_InitiateSystemShutdown_send(TALLOC_CTX *mem_ctx,
3824 struct tevent_context *ev,
3825 struct rpc_pipe_client *cli,
3826 uint16_t *_hostname /* [in] [unique] */,
3827 struct lsa_StringLarge *_message /* [in] [unique] */,
3828 uint32_t _timeout /* [in] */,
3829 uint8_t _force_apps /* [in] */,
3830 uint8_t _do_reboot /* [in] */)
3831 {
3832 struct tevent_req *req;
3833 struct rpccli_winreg_InitiateSystemShutdown_state *state;
3834 struct tevent_req *subreq;
3835
3836 req = tevent_req_create(mem_ctx, &state,
3837 struct rpccli_winreg_InitiateSystemShutdown_state);
3838 if (req == NULL) {
3839 return NULL;
3840 }
3841 state->out_mem_ctx = NULL;
3842 state->dispatch_recv = cli->dispatch_recv;
3843
3844 /* In parameters */
3845 state->orig.in.hostname = _hostname;
3846 state->orig.in.message = _message;
3847 state->orig.in.timeout = _timeout;
3848 state->orig.in.force_apps = _force_apps;
3849 state->orig.in.do_reboot = _do_reboot;
3850
3851 /* Out parameters */
3852
3853 /* Result */
3854 ZERO_STRUCT(state->orig.out.result);
3855
3856 /* make a temporary copy, that we pass to the dispatch function */
3857 state->tmp = state->orig;
3858
3859 subreq = cli->dispatch_send(state, ev, cli,
3860 &ndr_table_winreg,
3861 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
3862 &state->tmp);
3863 if (tevent_req_nomem(subreq, req)) {
3864 return tevent_req_post(req, ev);
3865 }
3866 tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdown_done, req);
3867 return req;
3868 }
3869
3870 static void rpccli_winreg_InitiateSystemShutdown_done(struct tevent_req *subreq)
3871 {
3872 struct tevent_req *req = tevent_req_callback_data(
3873 subreq, struct tevent_req);
3874 struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
3875 req, struct rpccli_winreg_InitiateSystemShutdown_state);
3876 NTSTATUS status;
3877 TALLOC_CTX *mem_ctx;
3878
3879 if (state->out_mem_ctx) {
3880 mem_ctx = state->out_mem_ctx;
3881 } else {
3882 mem_ctx = state;
3883 }
3884
3885 status = state->dispatch_recv(subreq, mem_ctx);
3886 TALLOC_FREE(subreq);
3887 if (!NT_STATUS_IS_OK(status)) {
3888 tevent_req_nterror(req, status);
3889 return;
3890 }
3891
3892 /* Copy out parameters */
3893
3894 /* Copy result */
3895 state->orig.out.result = state->tmp.out.result;
3896
3897 /* Reset temporary structure */
3898 ZERO_STRUCT(state->tmp);
3899
3900 tevent_req_done(req);
3901 }
3902
3903 NTSTATUS rpccli_winreg_InitiateSystemShutdown_recv(struct tevent_req *req,
3904 TALLOC_CTX *mem_ctx,
3905 WERROR *result)
3906 {
3907 struct rpccli_winreg_InitiateSystemShutdown_state *state = tevent_req_data(
3908 req, struct rpccli_winreg_InitiateSystemShutdown_state);
3909 NTSTATUS status;
3910
3911 if (tevent_req_is_nterror(req, &status)) {
3912 tevent_req_received(req);
3913 return status;
3914 }
3915
3916 /* Steal possbile out parameters to the callers context */
3917 talloc_steal(mem_ctx, state->out_mem_ctx);
3918
3919 /* Return result */
3920 *result = state->orig.out.result;
3921
3922 tevent_req_received(req);
3923 return NT_STATUS_OK;
3924 }
3925
3926 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
3927 TALLOC_CTX *mem_ctx,
3928 uint16_t *hostname /* [in] [unique] */,
3929 struct lsa_StringLarge *message /* [in] [unique] */,
3930 uint32_t timeout /* [in] */,
3931 uint8_t force_apps /* [in] */,
3932 uint8_t do_reboot /* [in] */,
3933 WERROR *werror)
3934 {
3935 struct winreg_InitiateSystemShutdown r;
3936 NTSTATUS status;
3937
3938 /* In parameters */
3939 r.in.hostname = hostname;
3940 r.in.message = message;
3941 r.in.timeout = timeout;
3942 r.in.force_apps = force_apps;
3943 r.in.do_reboot = do_reboot;
3944
3945 status = cli->dispatch(cli,
3946 mem_ctx,
3947 &ndr_table_winreg,
3948 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
3949 &r);
3950
3951 if (!NT_STATUS_IS_OK(status)) {
3952 return status;
3953 }
3954
3955 if (NT_STATUS_IS_ERR(status)) {
3956 return status;
3957 }
3958
3959 /* Return variables */
3960
3961 /* Return result */
3962 if (werror) {
3963 *werror = r.out.result;
3964 }
3965
3966 return werror_to_ntstatus(r.out.result);
3967 }
3968
3969 struct rpccli_winreg_AbortSystemShutdown_state {
3970 struct winreg_AbortSystemShutdown orig;
3971 struct winreg_AbortSystemShutdown tmp;
3972 TALLOC_CTX *out_mem_ctx;
3973 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
3974 };
3975
3976 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq);
3977
3978 struct tevent_req *rpccli_winreg_AbortSystemShutdown_send(TALLOC_CTX *mem_ctx,
3979 struct tevent_context *ev,
3980 struct rpc_pipe_client *cli,
3981 uint16_t *_server /* [in] [unique] */)
3982 {
3983 struct tevent_req *req;
3984 struct rpccli_winreg_AbortSystemShutdown_state *state;
3985 struct tevent_req *subreq;
3986
3987 req = tevent_req_create(mem_ctx, &state,
3988 struct rpccli_winreg_AbortSystemShutdown_state);
3989 if (req == NULL) {
3990 return NULL;
3991 }
3992 state->out_mem_ctx = NULL;
3993 state->dispatch_recv = cli->dispatch_recv;
3994
3995 /* In parameters */
3996 state->orig.in.server = _server;
3997
3998 /* Out parameters */
3999
4000 /* Result */
4001 ZERO_STRUCT(state->orig.out.result);
4002
4003 /* make a temporary copy, that we pass to the dispatch function */
4004 state->tmp = state->orig;
4005
4006 subreq = cli->dispatch_send(state, ev, cli,
4007 &ndr_table_winreg,
4008 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
4009 &state->tmp);
4010 if (tevent_req_nomem(subreq, req)) {
4011 return tevent_req_post(req, ev);
4012 }
4013 tevent_req_set_callback(subreq, rpccli_winreg_AbortSystemShutdown_done, req);
4014 return req;
4015 }
4016
4017 static void rpccli_winreg_AbortSystemShutdown_done(struct tevent_req *subreq)
4018 {
4019 struct tevent_req *req = tevent_req_callback_data(
4020 subreq, struct tevent_req);
4021 struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
4022 req, struct rpccli_winreg_AbortSystemShutdown_state);
4023 NTSTATUS status;
4024 TALLOC_CTX *mem_ctx;
4025
4026 if (state->out_mem_ctx) {
4027 mem_ctx = state->out_mem_ctx;
4028 } else {
4029 mem_ctx = state;
4030 }
4031
4032 status = state->dispatch_recv(subreq, mem_ctx);
4033 TALLOC_FREE(subreq);
4034 if (!NT_STATUS_IS_OK(status)) {
4035 tevent_req_nterror(req, status);
4036 return;
4037 }
4038
4039 /* Copy out parameters */
4040
4041 /* Copy result */
4042 state->orig.out.result = state->tmp.out.result;
4043
4044 /* Reset temporary structure */
4045 ZERO_STRUCT(state->tmp);
4046
4047 tevent_req_done(req);
4048 }
4049
4050 NTSTATUS rpccli_winreg_AbortSystemShutdown_recv(struct tevent_req *req,
4051 TALLOC_CTX *mem_ctx,
4052 WERROR *result)
4053 {
4054 struct rpccli_winreg_AbortSystemShutdown_state *state = tevent_req_data(
4055 req, struct rpccli_winreg_AbortSystemShutdown_state);
4056 NTSTATUS status;
4057
4058 if (tevent_req_is_nterror(req, &status)) {
4059 tevent_req_received(req);
4060 return status;
4061 }
4062
4063 /* Steal possbile out parameters to the callers context */
4064 talloc_steal(mem_ctx, state->out_mem_ctx);
4065
4066 /* Return result */
4067 *result = state->orig.out.result;
4068
4069 tevent_req_received(req);
4070 return NT_STATUS_OK;
4071 }
4072
4073 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
4074 TALLOC_CTX *mem_ctx,
4075 uint16_t *server /* [in] [unique] */,
4076 WERROR *werror)
4077 {
4078 struct winreg_AbortSystemShutdown r;
4079 NTSTATUS status;
4080
4081 /* In parameters */
4082 r.in.server = server;
4083
4084 status = cli->dispatch(cli,
4085 mem_ctx,
4086 &ndr_table_winreg,
4087 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
4088 &r);
4089
4090 if (!NT_STATUS_IS_OK(status)) {
4091 return status;
4092 }
4093
4094 if (NT_STATUS_IS_ERR(status)) {
4095 return status;
4096 }
4097
4098 /* Return variables */
4099
4100 /* Return result */
4101 if (werror) {
4102 *werror = r.out.result;
4103 }
4104
4105 return werror_to_ntstatus(r.out.result);
4106 }
4107
4108 struct rpccli_winreg_GetVersion_state {
4109 struct winreg_GetVersion orig;
4110 struct winreg_GetVersion tmp;
4111 TALLOC_CTX *out_mem_ctx;
4112 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4113 };
4114
4115 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq);
4116
4117 struct tevent_req *rpccli_winreg_GetVersion_send(TALLOC_CTX *mem_ctx,
4118 struct tevent_context *ev,
4119 struct rpc_pipe_client *cli,
4120 struct policy_handle *_handle /* [in] [ref] */,
4121 uint32_t *_version /* [out] [ref] */)
4122 {
4123 struct tevent_req *req;
4124 struct rpccli_winreg_GetVersion_state *state;
4125 struct tevent_req *subreq;
4126
4127 req = tevent_req_create(mem_ctx, &state,
4128 struct rpccli_winreg_GetVersion_state);
4129 if (req == NULL) {
4130 return NULL;
4131 }
4132 state->out_mem_ctx = NULL;
4133 state->dispatch_recv = cli->dispatch_recv;
4134
4135 /* In parameters */
4136 state->orig.in.handle = _handle;
4137
4138 /* Out parameters */
4139 state->orig.out.version = _version;
4140
4141 /* Result */
4142 ZERO_STRUCT(state->orig.out.result);
4143
4144 state->out_mem_ctx = talloc_named_const(state, 0,
4145 "rpccli_winreg_GetVersion_out_memory");
4146 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4147 return tevent_req_post(req, ev);
4148 }
4149
4150 /* make a temporary copy, that we pass to the dispatch function */
4151 state->tmp = state->orig;
4152
4153 subreq = cli->dispatch_send(state, ev, cli,
4154 &ndr_table_winreg,
4155 NDR_WINREG_GETVERSION,
4156 &state->tmp);
4157 if (tevent_req_nomem(subreq, req)) {
4158 return tevent_req_post(req, ev);
4159 }
4160 tevent_req_set_callback(subreq, rpccli_winreg_GetVersion_done, req);
4161 return req;
4162 }
4163
4164 static void rpccli_winreg_GetVersion_done(struct tevent_req *subreq)
4165 {
4166 struct tevent_req *req = tevent_req_callback_data(
4167 subreq, struct tevent_req);
4168 struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4169 req, struct rpccli_winreg_GetVersion_state);
4170 NTSTATUS status;
4171 TALLOC_CTX *mem_ctx;
4172
4173 if (state->out_mem_ctx) {
4174 mem_ctx = state->out_mem_ctx;
4175 } else {
4176 mem_ctx = state;
4177 }
4178
4179 status = state->dispatch_recv(subreq, mem_ctx);
4180 TALLOC_FREE(subreq);
4181 if (!NT_STATUS_IS_OK(status)) {
4182 tevent_req_nterror(req, status);
4183 return;
4184 }
4185
4186 /* Copy out parameters */
4187 *state->orig.out.version = *state->tmp.out.version;
4188
4189 /* Copy result */
4190 state->orig.out.result = state->tmp.out.result;
4191
4192 /* Reset temporary structure */
4193 ZERO_STRUCT(state->tmp);
4194
4195 tevent_req_done(req);
4196 }
4197
4198 NTSTATUS rpccli_winreg_GetVersion_recv(struct tevent_req *req,
4199 TALLOC_CTX *mem_ctx,
4200 WERROR *result)
4201 {
4202 struct rpccli_winreg_GetVersion_state *state = tevent_req_data(
4203 req, struct rpccli_winreg_GetVersion_state);
4204 NTSTATUS status;
4205
4206 if (tevent_req_is_nterror(req, &status)) {
4207 tevent_req_received(req);
4208 return status;
4209 }
4210
4211 /* Steal possbile out parameters to the callers context */
4212 talloc_steal(mem_ctx, state->out_mem_ctx);
4213
4214 /* Return result */
4215 *result = state->orig.out.result;
4216
4217 tevent_req_received(req);
4218 return NT_STATUS_OK;
4219 }
4220
4221 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
4222 TALLOC_CTX *mem_ctx,
4223 struct policy_handle *handle /* [in] [ref] */,
4224 uint32_t *version /* [out] [ref] */,
4225 WERROR *werror)
4226 {
4227 struct winreg_GetVersion r;
4228 NTSTATUS status;
4229
4230 /* In parameters */
4231 r.in.handle = handle;
4232
4233 status = cli->dispatch(cli,
4234 mem_ctx,
4235 &ndr_table_winreg,
4236 NDR_WINREG_GETVERSION,
4237 &r);
4238
4239 if (!NT_STATUS_IS_OK(status)) {
4240 return status;
4241 }
4242
4243 if (NT_STATUS_IS_ERR(status)) {
4244 return status;
4245 }
4246
4247 /* Return variables */
4248 *version = *r.out.version;
4249
4250 /* Return result */
4251 if (werror) {
4252 *werror = r.out.result;
4253 }
4254
4255 return werror_to_ntstatus(r.out.result);
4256 }
4257
4258 struct rpccli_winreg_OpenHKCC_state {
4259 struct winreg_OpenHKCC orig;
4260 struct winreg_OpenHKCC tmp;
4261 TALLOC_CTX *out_mem_ctx;
4262 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4263 };
4264
4265 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq);
4266
4267 struct tevent_req *rpccli_winreg_OpenHKCC_send(TALLOC_CTX *mem_ctx,
4268 struct tevent_context *ev,
4269 struct rpc_pipe_client *cli,
4270 uint16_t *_system_name /* [in] [unique] */,
4271 uint32_t _access_mask /* [in] */,
4272 struct policy_handle *_handle /* [out] [ref] */)
4273 {
4274 struct tevent_req *req;
4275 struct rpccli_winreg_OpenHKCC_state *state;
4276 struct tevent_req *subreq;
4277
4278 req = tevent_req_create(mem_ctx, &state,
4279 struct rpccli_winreg_OpenHKCC_state);
4280 if (req == NULL) {
4281 return NULL;
4282 }
4283 state->out_mem_ctx = NULL;
4284 state->dispatch_recv = cli->dispatch_recv;
4285
4286 /* In parameters */
4287 state->orig.in.system_name = _system_name;
4288 state->orig.in.access_mask = _access_mask;
4289
4290 /* Out parameters */
4291 state->orig.out.handle = _handle;
4292
4293 /* Result */
4294 ZERO_STRUCT(state->orig.out.result);
4295
4296 state->out_mem_ctx = talloc_named_const(state, 0,
4297 "rpccli_winreg_OpenHKCC_out_memory");
4298 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4299 return tevent_req_post(req, ev);
4300 }
4301
4302 /* make a temporary copy, that we pass to the dispatch function */
4303 state->tmp = state->orig;
4304
4305 subreq = cli->dispatch_send(state, ev, cli,
4306 &ndr_table_winreg,
4307 NDR_WINREG_OPENHKCC,
4308 &state->tmp);
4309 if (tevent_req_nomem(subreq, req)) {
4310 return tevent_req_post(req, ev);
4311 }
4312 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKCC_done, req);
4313 return req;
4314 }
4315
4316 static void rpccli_winreg_OpenHKCC_done(struct tevent_req *subreq)
4317 {
4318 struct tevent_req *req = tevent_req_callback_data(
4319 subreq, struct tevent_req);
4320 struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4321 req, struct rpccli_winreg_OpenHKCC_state);
4322 NTSTATUS status;
4323 TALLOC_CTX *mem_ctx;
4324
4325 if (state->out_mem_ctx) {
4326 mem_ctx = state->out_mem_ctx;
4327 } else {
4328 mem_ctx = state;
4329 }
4330
4331 status = state->dispatch_recv(subreq, mem_ctx);
4332 TALLOC_FREE(subreq);
4333 if (!NT_STATUS_IS_OK(status)) {
4334 tevent_req_nterror(req, status);
4335 return;
4336 }
4337
4338 /* Copy out parameters */
4339 *state->orig.out.handle = *state->tmp.out.handle;
4340
4341 /* Copy result */
4342 state->orig.out.result = state->tmp.out.result;
4343
4344 /* Reset temporary structure */
4345 ZERO_STRUCT(state->tmp);
4346
4347 tevent_req_done(req);
4348 }
4349
4350 NTSTATUS rpccli_winreg_OpenHKCC_recv(struct tevent_req *req,
4351 TALLOC_CTX *mem_ctx,
4352 WERROR *result)
4353 {
4354 struct rpccli_winreg_OpenHKCC_state *state = tevent_req_data(
4355 req, struct rpccli_winreg_OpenHKCC_state);
4356 NTSTATUS status;
4357
4358 if (tevent_req_is_nterror(req, &status)) {
4359 tevent_req_received(req);
4360 return status;
4361 }
4362
4363 /* Steal possbile out parameters to the callers context */
4364 talloc_steal(mem_ctx, state->out_mem_ctx);
4365
4366 /* Return result */
4367 *result = state->orig.out.result;
4368
4369 tevent_req_received(req);
4370 return NT_STATUS_OK;
4371 }
4372
4373 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
4374 TALLOC_CTX *mem_ctx,
4375 uint16_t *system_name /* [in] [unique] */,
4376 uint32_t access_mask /* [in] */,
4377 struct policy_handle *handle /* [out] [ref] */,
4378 WERROR *werror)
4379 {
4380 struct winreg_OpenHKCC r;
4381 NTSTATUS status;
4382
4383 /* In parameters */
4384 r.in.system_name = system_name;
4385 r.in.access_mask = access_mask;
4386
4387 status = cli->dispatch(cli,
4388 mem_ctx,
4389 &ndr_table_winreg,
4390 NDR_WINREG_OPENHKCC,
4391 &r);
4392
4393 if (!NT_STATUS_IS_OK(status)) {
4394 return status;
4395 }
4396
4397 if (NT_STATUS_IS_ERR(status)) {
4398 return status;
4399 }
4400
4401 /* Return variables */
4402 *handle = *r.out.handle;
4403
4404 /* Return result */
4405 if (werror) {
4406 *werror = r.out.result;
4407 }
4408
4409 return werror_to_ntstatus(r.out.result);
4410 }
4411
4412 struct rpccli_winreg_OpenHKDD_state {
4413 struct winreg_OpenHKDD orig;
4414 struct winreg_OpenHKDD tmp;
4415 TALLOC_CTX *out_mem_ctx;
4416 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4417 };
4418
4419 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq);
4420
4421 struct tevent_req *rpccli_winreg_OpenHKDD_send(TALLOC_CTX *mem_ctx,
4422 struct tevent_context *ev,
4423 struct rpc_pipe_client *cli,
4424 uint16_t *_system_name /* [in] [unique] */,
4425 uint32_t _access_mask /* [in] */,
4426 struct policy_handle *_handle /* [out] [ref] */)
4427 {
4428 struct tevent_req *req;
4429 struct rpccli_winreg_OpenHKDD_state *state;
4430 struct tevent_req *subreq;
4431
4432 req = tevent_req_create(mem_ctx, &state,
4433 struct rpccli_winreg_OpenHKDD_state);
4434 if (req == NULL) {
4435 return NULL;
4436 }
4437 state->out_mem_ctx = NULL;
4438 state->dispatch_recv = cli->dispatch_recv;
4439
4440 /* In parameters */
4441 state->orig.in.system_name = _system_name;
4442 state->orig.in.access_mask = _access_mask;
4443
4444 /* Out parameters */
4445 state->orig.out.handle = _handle;
4446
4447 /* Result */
4448 ZERO_STRUCT(state->orig.out.result);
4449
4450 state->out_mem_ctx = talloc_named_const(state, 0,
4451 "rpccli_winreg_OpenHKDD_out_memory");
4452 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4453 return tevent_req_post(req, ev);
4454 }
4455
4456 /* make a temporary copy, that we pass to the dispatch function */
4457 state->tmp = state->orig;
4458
4459 subreq = cli->dispatch_send(state, ev, cli,
4460 &ndr_table_winreg,
4461 NDR_WINREG_OPENHKDD,
4462 &state->tmp);
4463 if (tevent_req_nomem(subreq, req)) {
4464 return tevent_req_post(req, ev);
4465 }
4466 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKDD_done, req);
4467 return req;
4468 }
4469
4470 static void rpccli_winreg_OpenHKDD_done(struct tevent_req *subreq)
4471 {
4472 struct tevent_req *req = tevent_req_callback_data(
4473 subreq, struct tevent_req);
4474 struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4475 req, struct rpccli_winreg_OpenHKDD_state);
4476 NTSTATUS status;
4477 TALLOC_CTX *mem_ctx;
4478
4479 if (state->out_mem_ctx) {
4480 mem_ctx = state->out_mem_ctx;
4481 } else {
4482 mem_ctx = state;
4483 }
4484
4485 status = state->dispatch_recv(subreq, mem_ctx);
4486 TALLOC_FREE(subreq);
4487 if (!NT_STATUS_IS_OK(status)) {
4488 tevent_req_nterror(req, status);
4489 return;
4490 }
4491
4492 /* Copy out parameters */
4493 *state->orig.out.handle = *state->tmp.out.handle;
4494
4495 /* Copy result */
4496 state->orig.out.result = state->tmp.out.result;
4497
4498 /* Reset temporary structure */
4499 ZERO_STRUCT(state->tmp);
4500
4501 tevent_req_done(req);
4502 }
4503
4504 NTSTATUS rpccli_winreg_OpenHKDD_recv(struct tevent_req *req,
4505 TALLOC_CTX *mem_ctx,
4506 WERROR *result)
4507 {
4508 struct rpccli_winreg_OpenHKDD_state *state = tevent_req_data(
4509 req, struct rpccli_winreg_OpenHKDD_state);
4510 NTSTATUS status;
4511
4512 if (tevent_req_is_nterror(req, &status)) {
4513 tevent_req_received(req);
4514 return status;
4515 }
4516
4517 /* Steal possbile out parameters to the callers context */
4518 talloc_steal(mem_ctx, state->out_mem_ctx);
4519
4520 /* Return result */
4521 *result = state->orig.out.result;
4522
4523 tevent_req_received(req);
4524 return NT_STATUS_OK;
4525 }
4526
4527 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
4528 TALLOC_CTX *mem_ctx,
4529 uint16_t *system_name /* [in] [unique] */,
4530 uint32_t access_mask /* [in] */,
4531 struct policy_handle *handle /* [out] [ref] */,
4532 WERROR *werror)
4533 {
4534 struct winreg_OpenHKDD r;
4535 NTSTATUS status;
4536
4537 /* In parameters */
4538 r.in.system_name = system_name;
4539 r.in.access_mask = access_mask;
4540
4541 status = cli->dispatch(cli,
4542 mem_ctx,
4543 &ndr_table_winreg,
4544 NDR_WINREG_OPENHKDD,
4545 &r);
4546
4547 if (!NT_STATUS_IS_OK(status)) {
4548 return status;
4549 }
4550
4551 if (NT_STATUS_IS_ERR(status)) {
4552 return status;
4553 }
4554
4555 /* Return variables */
4556 *handle = *r.out.handle;
4557
4558 /* Return result */
4559 if (werror) {
4560 *werror = r.out.result;
4561 }
4562
4563 return werror_to_ntstatus(r.out.result);
4564 }
4565
4566 struct rpccli_winreg_QueryMultipleValues_state {
4567 struct winreg_QueryMultipleValues orig;
4568 struct winreg_QueryMultipleValues tmp;
4569 TALLOC_CTX *out_mem_ctx;
4570 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4571 };
4572
4573 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq);
4574
4575 struct tevent_req *rpccli_winreg_QueryMultipleValues_send(TALLOC_CTX *mem_ctx,
4576 struct tevent_context *ev,
4577 struct rpc_pipe_client *cli,
4578 struct policy_handle *_key_handle /* [in] [ref] */,
4579 struct QueryMultipleValue *_values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
4580 uint32_t _num_values /* [in] */,
4581 uint8_t *_buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
4582 uint32_t *_buffer_size /* [in,out] [ref] */)
4583 {
4584 struct tevent_req *req;
4585 struct rpccli_winreg_QueryMultipleValues_state *state;
4586 struct tevent_req *subreq;
4587
4588 req = tevent_req_create(mem_ctx, &state,
4589 struct rpccli_winreg_QueryMultipleValues_state);
4590 if (req == NULL) {
4591 return NULL;
4592 }
4593 state->out_mem_ctx = NULL;
4594 state->dispatch_recv = cli->dispatch_recv;
4595
4596 /* In parameters */
4597 state->orig.in.key_handle = _key_handle;
4598 state->orig.in.values = _values;
4599 state->orig.in.num_values = _num_values;
4600 state->orig.in.buffer = _buffer;
4601 state->orig.in.buffer_size = _buffer_size;
4602
4603 /* Out parameters */
4604 state->orig.out.values = _values;
4605 state->orig.out.buffer = _buffer;
4606 state->orig.out.buffer_size = _buffer_size;
4607
4608 /* Result */
4609 ZERO_STRUCT(state->orig.out.result);
4610
4611 state->out_mem_ctx = talloc_named_const(state, 0,
4612 "rpccli_winreg_QueryMultipleValues_out_memory");
4613 if (tevent_req_nomem(state->out_mem_ctx, req)) {
4614 return tevent_req_post(req, ev);
4615 }
4616
4617 /* make a temporary copy, that we pass to the dispatch function */
4618 state->tmp = state->orig;
4619
4620 subreq = cli->dispatch_send(state, ev, cli,
4621 &ndr_table_winreg,
4622 NDR_WINREG_QUERYMULTIPLEVALUES,
4623 &state->tmp);
4624 if (tevent_req_nomem(subreq, req)) {
4625 return tevent_req_post(req, ev);
4626 }
4627 tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues_done, req);
4628 return req;
4629 }
4630
4631 static void rpccli_winreg_QueryMultipleValues_done(struct tevent_req *subreq)
4632 {
4633 struct tevent_req *req = tevent_req_callback_data(
4634 subreq, struct tevent_req);
4635 struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
4636 req, struct rpccli_winreg_QueryMultipleValues_state);
4637 NTSTATUS status;
4638 TALLOC_CTX *mem_ctx;
4639
4640 if (state->out_mem_ctx) {
4641 mem_ctx = state->out_mem_ctx;
4642 } else {
4643 mem_ctx = state;
4644 }
4645
4646 status = state->dispatch_recv(subreq, mem_ctx);
4647 TALLOC_FREE(subreq);
4648 if (!NT_STATUS_IS_OK(status)) {
4649 tevent_req_nterror(req, status);
4650 return;
4651 }
4652
4653 /* Copy out parameters */
4654 memcpy(state->orig.out.values, state->tmp.out.values, (state->tmp.in.num_values) * sizeof(*state->orig.out.values));
4655 if (state->orig.out.buffer && state->tmp.out.buffer) {
4656 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (*state->tmp.in.buffer_size) * sizeof(*state->orig.out.buffer));
4657 }
4658 *state->orig.out.buffer_size = *state->tmp.out.buffer_size;
4659
4660 /* Copy result */
4661 state->orig.out.result = state->tmp.out.result;
4662
4663 /* Reset temporary structure */
4664 ZERO_STRUCT(state->tmp);
4665
4666 tevent_req_done(req);
4667 }
4668
4669 NTSTATUS rpccli_winreg_QueryMultipleValues_recv(struct tevent_req *req,
4670 TALLOC_CTX *mem_ctx,
4671 WERROR *result)
4672 {
4673 struct rpccli_winreg_QueryMultipleValues_state *state = tevent_req_data(
4674 req, struct rpccli_winreg_QueryMultipleValues_state);
4675 NTSTATUS status;
4676
4677 if (tevent_req_is_nterror(req, &status)) {
4678 tevent_req_received(req);
4679 return status;
4680 }
4681
4682 /* Steal possbile out parameters to the callers context */
4683 talloc_steal(mem_ctx, state->out_mem_ctx);
4684
4685 /* Return result */
4686 *result = state->orig.out.result;
4687
4688 tevent_req_received(req);
4689 return NT_STATUS_OK;
4690 }
4691
4692 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
4693 TALLOC_CTX *mem_ctx,
4694 struct policy_handle *key_handle /* [in] [ref] */,
4695 struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
4696 uint32_t num_values /* [in] */,
4697 uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
4698 uint32_t *buffer_size /* [in,out] [ref] */,
4699 WERROR *werror)
4700 {
4701 struct winreg_QueryMultipleValues r;
4702 NTSTATUS status;
4703
4704 /* In parameters */
4705 r.in.key_handle = key_handle;
4706 r.in.values = values;
4707 r.in.num_values = num_values;
4708 r.in.buffer = buffer;
4709 r.in.buffer_size = buffer_size;
4710
4711 status = cli->dispatch(cli,
4712 mem_ctx,
4713 &ndr_table_winreg,
4714 NDR_WINREG_QUERYMULTIPLEVALUES,
4715 &r);
4716
4717 if (!NT_STATUS_IS_OK(status)) {
4718 return status;
4719 }
4720
4721 if (NT_STATUS_IS_ERR(status)) {
4722 return status;
4723 }
4724
4725 /* Return variables */
4726 memcpy(values, r.out.values, (r.in.num_values) * sizeof(*values));
4727 if (buffer && r.out.buffer) {
4728 memcpy(buffer, r.out.buffer, (*r.in.buffer_size) * sizeof(*buffer));
4729 }
4730 *buffer_size = *r.out.buffer_size;
4731
4732 /* Return result */
4733 if (werror) {
4734 *werror = r.out.result;
4735 }
4736
4737 return werror_to_ntstatus(r.out.result);
4738 }
4739
4740 struct rpccli_winreg_InitiateSystemShutdownEx_state {
4741 struct winreg_InitiateSystemShutdownEx orig;
4742 struct winreg_InitiateSystemShutdownEx tmp;
4743 TALLOC_CTX *out_mem_ctx;
4744 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4745 };
4746
4747 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq);
4748
4749 struct tevent_req *rpccli_winreg_InitiateSystemShutdownEx_send(TALLOC_CTX *mem_ctx,
4750 struct tevent_context *ev,
4751 struct rpc_pipe_client *cli,
4752 uint16_t *_hostname /* [in] [unique] */,
4753 struct lsa_StringLarge *_message /* [in] [unique] */,
4754 uint32_t _timeout /* [in] */,
4755 uint8_t _force_apps /* [in] */,
4756 uint8_t _do_reboot /* [in] */,
4757 uint32_t _reason /* [in] */)
4758 {
4759 struct tevent_req *req;
4760 struct rpccli_winreg_InitiateSystemShutdownEx_state *state;
4761 struct tevent_req *subreq;
4762
4763 req = tevent_req_create(mem_ctx, &state,
4764 struct rpccli_winreg_InitiateSystemShutdownEx_state);
4765 if (req == NULL) {
4766 return NULL;
4767 }
4768 state->out_mem_ctx = NULL;
4769 state->dispatch_recv = cli->dispatch_recv;
4770
4771 /* In parameters */
4772 state->orig.in.hostname = _hostname;
4773 state->orig.in.message = _message;
4774 state->orig.in.timeout = _timeout;
4775 state->orig.in.force_apps = _force_apps;
4776 state->orig.in.do_reboot = _do_reboot;
4777 state->orig.in.reason = _reason;
4778
4779 /* Out parameters */
4780
4781 /* Result */
4782 ZERO_STRUCT(state->orig.out.result);
4783
4784 /* make a temporary copy, that we pass to the dispatch function */
4785 state->tmp = state->orig;
4786
4787 subreq = cli->dispatch_send(state, ev, cli,
4788 &ndr_table_winreg,
4789 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
4790 &state->tmp);
4791 if (tevent_req_nomem(subreq, req)) {
4792 return tevent_req_post(req, ev);
4793 }
4794 tevent_req_set_callback(subreq, rpccli_winreg_InitiateSystemShutdownEx_done, req);
4795 return req;
4796 }
4797
4798 static void rpccli_winreg_InitiateSystemShutdownEx_done(struct tevent_req *subreq)
4799 {
4800 struct tevent_req *req = tevent_req_callback_data(
4801 subreq, struct tevent_req);
4802 struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
4803 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
4804 NTSTATUS status;
4805 TALLOC_CTX *mem_ctx;
4806
4807 if (state->out_mem_ctx) {
4808 mem_ctx = state->out_mem_ctx;
4809 } else {
4810 mem_ctx = state;
4811 }
4812
4813 status = state->dispatch_recv(subreq, mem_ctx);
4814 TALLOC_FREE(subreq);
4815 if (!NT_STATUS_IS_OK(status)) {
4816 tevent_req_nterror(req, status);
4817 return;
4818 }
4819
4820 /* Copy out parameters */
4821
4822 /* Copy result */
4823 state->orig.out.result = state->tmp.out.result;
4824
4825 /* Reset temporary structure */
4826 ZERO_STRUCT(state->tmp);
4827
4828 tevent_req_done(req);
4829 }
4830
4831 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx_recv(struct tevent_req *req,
4832 TALLOC_CTX *mem_ctx,
4833 WERROR *result)
4834 {
4835 struct rpccli_winreg_InitiateSystemShutdownEx_state *state = tevent_req_data(
4836 req, struct rpccli_winreg_InitiateSystemShutdownEx_state);
4837 NTSTATUS status;
4838
4839 if (tevent_req_is_nterror(req, &status)) {
4840 tevent_req_received(req);
4841 return status;
4842 }
4843
4844 /* Steal possbile out parameters to the callers context */
4845 talloc_steal(mem_ctx, state->out_mem_ctx);
4846
4847 /* Return result */
4848 *result = state->orig.out.result;
4849
4850 tevent_req_received(req);
4851 return NT_STATUS_OK;
4852 }
4853
4854 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
4855 TALLOC_CTX *mem_ctx,
4856 uint16_t *hostname /* [in] [unique] */,
4857 struct lsa_StringLarge *message /* [in] [unique] */,
4858 uint32_t timeout /* [in] */,
4859 uint8_t force_apps /* [in] */,
4860 uint8_t do_reboot /* [in] */,
4861 uint32_t reason /* [in] */,
4862 WERROR *werror)
4863 {
4864 struct winreg_InitiateSystemShutdownEx r;
4865 NTSTATUS status;
4866
4867 /* In parameters */
4868 r.in.hostname = hostname;
4869 r.in.message = message;
4870 r.in.timeout = timeout;
4871 r.in.force_apps = force_apps;
4872 r.in.do_reboot = do_reboot;
4873 r.in.reason = reason;
4874
4875 status = cli->dispatch(cli,
4876 mem_ctx,
4877 &ndr_table_winreg,
4878 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
4879 &r);
4880
4881 if (!NT_STATUS_IS_OK(status)) {
4882 return status;
4883 }
4884
4885 if (NT_STATUS_IS_ERR(status)) {
4886 return status;
4887 }
4888
4889 /* Return variables */
4890
4891 /* Return result */
4892 if (werror) {
4893 *werror = r.out.result;
4894 }
4895
4896 return werror_to_ntstatus(r.out.result);
4897 }
4898
4899 struct rpccli_winreg_SaveKeyEx_state {
4900 struct winreg_SaveKeyEx orig;
4901 struct winreg_SaveKeyEx tmp;
4902 TALLOC_CTX *out_mem_ctx;
4903 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
4904 };
4905
4906 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq);
4907
4908 struct tevent_req *rpccli_winreg_SaveKeyEx_send(TALLOC_CTX *mem_ctx,
4909 struct tevent_context *ev,
4910 struct rpc_pipe_client *cli,
4911 struct policy_handle *_handle /* [in] [ref] */,
4912 struct winreg_String *_filename /* [in] [ref] */,
4913 struct KeySecurityAttribute *_sec_attrib /* [in] [unique] */,
4914 uint32_t _flags /* [in] */)
4915 {
4916 struct tevent_req *req;
4917 struct rpccli_winreg_SaveKeyEx_state *state;
4918 struct tevent_req *subreq;
4919
4920 req = tevent_req_create(mem_ctx, &state,
4921 struct rpccli_winreg_SaveKeyEx_state);
4922 if (req == NULL) {
4923 return NULL;
4924 }
4925 state->out_mem_ctx = NULL;
4926 state->dispatch_recv = cli->dispatch_recv;
4927
4928 /* In parameters */
4929 state->orig.in.handle = _handle;
4930 state->orig.in.filename = _filename;
4931 state->orig.in.sec_attrib = _sec_attrib;
4932 state->orig.in.flags = _flags;
4933
4934 /* Out parameters */
4935
4936 /* Result */
4937 ZERO_STRUCT(state->orig.out.result);
4938
4939 /* make a temporary copy, that we pass to the dispatch function */
4940 state->tmp = state->orig;
4941
4942 subreq = cli->dispatch_send(state, ev, cli,
4943 &ndr_table_winreg,
4944 NDR_WINREG_SAVEKEYEX,
4945 &state->tmp);
4946 if (tevent_req_nomem(subreq, req)) {
4947 return tevent_req_post(req, ev);
4948 }
4949 tevent_req_set_callback(subreq, rpccli_winreg_SaveKeyEx_done, req);
4950 return req;
4951 }
4952
4953 static void rpccli_winreg_SaveKeyEx_done(struct tevent_req *subreq)
4954 {
4955 struct tevent_req *req = tevent_req_callback_data(
4956 subreq, struct tevent_req);
4957 struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
4958 req, struct rpccli_winreg_SaveKeyEx_state);
4959 NTSTATUS status;
4960 TALLOC_CTX *mem_ctx;
4961
4962 if (state->out_mem_ctx) {
4963 mem_ctx = state->out_mem_ctx;
4964 } else {
4965 mem_ctx = state;
4966 }
4967
4968 status = state->dispatch_recv(subreq, mem_ctx);
4969 TALLOC_FREE(subreq);
4970 if (!NT_STATUS_IS_OK(status)) {
4971 tevent_req_nterror(req, status);
4972 return;
4973 }
4974
4975 /* Copy out parameters */
4976
4977 /* Copy result */
4978 state->orig.out.result = state->tmp.out.result;
4979
4980 /* Reset temporary structure */
4981 ZERO_STRUCT(state->tmp);
4982
4983 tevent_req_done(req);
4984 }
4985
4986 NTSTATUS rpccli_winreg_SaveKeyEx_recv(struct tevent_req *req,
4987 TALLOC_CTX *mem_ctx,
4988 WERROR *result)
4989 {
4990 struct rpccli_winreg_SaveKeyEx_state *state = tevent_req_data(
4991 req, struct rpccli_winreg_SaveKeyEx_state);
4992 NTSTATUS status;
4993
4994 if (tevent_req_is_nterror(req, &status)) {
4995 tevent_req_received(req);
4996 return status;
4997 }
4998
4999 /* Steal possbile out parameters to the callers context */
5000 talloc_steal(mem_ctx, state->out_mem_ctx);
5001
5002 /* Return result */
5003 *result = state->orig.out.result;
5004
5005 tevent_req_received(req);
5006 return NT_STATUS_OK;
5007 }
5008
5009 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
5010 TALLOC_CTX *mem_ctx,
5011 struct policy_handle *handle /* [in] [ref] */,
5012 struct winreg_String *filename /* [in] [ref] */,
5013 struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
5014 uint32_t flags /* [in] */,
5015 WERROR *werror)
5016 {
5017 struct winreg_SaveKeyEx r;
5018 NTSTATUS status;
5019
5020 /* In parameters */
5021 r.in.handle = handle;
5022 r.in.filename = filename;
5023 r.in.sec_attrib = sec_attrib;
5024 r.in.flags = flags;
5025
5026 status = cli->dispatch(cli,
5027 mem_ctx,
5028 &ndr_table_winreg,
5029 NDR_WINREG_SAVEKEYEX,
5030 &r);
5031
5032 if (!NT_STATUS_IS_OK(status)) {
5033 return status;
5034 }
5035
5036 if (NT_STATUS_IS_ERR(status)) {
5037 return status;
5038 }
5039
5040 /* Return variables */
5041
5042 /* Return result */
5043 if (werror) {
5044 *werror = r.out.result;
5045 }
5046
5047 return werror_to_ntstatus(r.out.result);
5048 }
5049
5050 struct rpccli_winreg_OpenHKPT_state {
5051 struct winreg_OpenHKPT orig;
5052 struct winreg_OpenHKPT tmp;
5053 TALLOC_CTX *out_mem_ctx;
5054 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5055 };
5056
5057 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq);
5058
5059 struct tevent_req *rpccli_winreg_OpenHKPT_send(TALLOC_CTX *mem_ctx,
5060 struct tevent_context *ev,
5061 struct rpc_pipe_client *cli,
5062 uint16_t *_system_name /* [in] [unique] */,
5063 uint32_t _access_mask /* [in] */,
5064 struct policy_handle *_handle /* [out] [ref] */)
5065 {
5066 struct tevent_req *req;
5067 struct rpccli_winreg_OpenHKPT_state *state;
5068 struct tevent_req *subreq;
5069
5070 req = tevent_req_create(mem_ctx, &state,
5071 struct rpccli_winreg_OpenHKPT_state);
5072 if (req == NULL) {
5073 return NULL;
5074 }
5075 state->out_mem_ctx = NULL;
5076 state->dispatch_recv = cli->dispatch_recv;
5077
5078 /* In parameters */
5079 state->orig.in.system_name = _system_name;
5080 state->orig.in.access_mask = _access_mask;
5081
5082 /* Out parameters */
5083 state->orig.out.handle = _handle;
5084
5085 /* Result */
5086 ZERO_STRUCT(state->orig.out.result);
5087
5088 state->out_mem_ctx = talloc_named_const(state, 0,
5089 "rpccli_winreg_OpenHKPT_out_memory");
5090 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5091 return tevent_req_post(req, ev);
5092 }
5093
5094 /* make a temporary copy, that we pass to the dispatch function */
5095 state->tmp = state->orig;
5096
5097 subreq = cli->dispatch_send(state, ev, cli,
5098 &ndr_table_winreg,
5099 NDR_WINREG_OPENHKPT,
5100 &state->tmp);
5101 if (tevent_req_nomem(subreq, req)) {
5102 return tevent_req_post(req, ev);
5103 }
5104 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPT_done, req);
5105 return req;
5106 }
5107
5108 static void rpccli_winreg_OpenHKPT_done(struct tevent_req *subreq)
5109 {
5110 struct tevent_req *req = tevent_req_callback_data(
5111 subreq, struct tevent_req);
5112 struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5113 req, struct rpccli_winreg_OpenHKPT_state);
5114 NTSTATUS status;
5115 TALLOC_CTX *mem_ctx;
5116
5117 if (state->out_mem_ctx) {
5118 mem_ctx = state->out_mem_ctx;
5119 } else {
5120 mem_ctx = state;
5121 }
5122
5123 status = state->dispatch_recv(subreq, mem_ctx);
5124 TALLOC_FREE(subreq);
5125 if (!NT_STATUS_IS_OK(status)) {
5126 tevent_req_nterror(req, status);
5127 return;
5128 }
5129
5130 /* Copy out parameters */
5131 *state->orig.out.handle = *state->tmp.out.handle;
5132
5133 /* Copy result */
5134 state->orig.out.result = state->tmp.out.result;
5135
5136 /* Reset temporary structure */
5137 ZERO_STRUCT(state->tmp);
5138
5139 tevent_req_done(req);
5140 }
5141
5142 NTSTATUS rpccli_winreg_OpenHKPT_recv(struct tevent_req *req,
5143 TALLOC_CTX *mem_ctx,
5144 WERROR *result)
5145 {
5146 struct rpccli_winreg_OpenHKPT_state *state = tevent_req_data(
5147 req, struct rpccli_winreg_OpenHKPT_state);
5148 NTSTATUS status;
5149
5150 if (tevent_req_is_nterror(req, &status)) {
5151 tevent_req_received(req);
5152 return status;
5153 }
5154
5155 /* Steal possbile out parameters to the callers context */
5156 talloc_steal(mem_ctx, state->out_mem_ctx);
5157
5158 /* Return result */
5159 *result = state->orig.out.result;
5160
5161 tevent_req_received(req);
5162 return NT_STATUS_OK;
5163 }
5164
5165 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
5166 TALLOC_CTX *mem_ctx,
5167 uint16_t *system_name /* [in] [unique] */,
5168 uint32_t access_mask /* [in] */,
5169 struct policy_handle *handle /* [out] [ref] */,
5170 WERROR *werror)
5171 {
5172 struct winreg_OpenHKPT r;
5173 NTSTATUS status;
5174
5175 /* In parameters */
5176 r.in.system_name = system_name;
5177 r.in.access_mask = access_mask;
5178
5179 status = cli->dispatch(cli,
5180 mem_ctx,
5181 &ndr_table_winreg,
5182 NDR_WINREG_OPENHKPT,
5183 &r);
5184
5185 if (!NT_STATUS_IS_OK(status)) {
5186 return status;
5187 }
5188
5189 if (NT_STATUS_IS_ERR(status)) {
5190 return status;
5191 }
5192
5193 /* Return variables */
5194 *handle = *r.out.handle;
5195
5196 /* Return result */
5197 if (werror) {
5198 *werror = r.out.result;
5199 }
5200
5201 return werror_to_ntstatus(r.out.result);
5202 }
5203
5204 struct rpccli_winreg_OpenHKPN_state {
5205 struct winreg_OpenHKPN orig;
5206 struct winreg_OpenHKPN tmp;
5207 TALLOC_CTX *out_mem_ctx;
5208 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5209 };
5210
5211 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq);
5212
5213 struct tevent_req *rpccli_winreg_OpenHKPN_send(TALLOC_CTX *mem_ctx,
5214 struct tevent_context *ev,
5215 struct rpc_pipe_client *cli,
5216 uint16_t *_system_name /* [in] [unique] */,
5217 uint32_t _access_mask /* [in] */,
5218 struct policy_handle *_handle /* [out] [ref] */)
5219 {
5220 struct tevent_req *req;
5221 struct rpccli_winreg_OpenHKPN_state *state;
5222 struct tevent_req *subreq;
5223
5224 req = tevent_req_create(mem_ctx, &state,
5225 struct rpccli_winreg_OpenHKPN_state);
5226 if (req == NULL) {
5227 return NULL;
5228 }
5229 state->out_mem_ctx = NULL;
5230 state->dispatch_recv = cli->dispatch_recv;
5231
5232 /* In parameters */
5233 state->orig.in.system_name = _system_name;
5234 state->orig.in.access_mask = _access_mask;
5235
5236 /* Out parameters */
5237 state->orig.out.handle = _handle;
5238
5239 /* Result */
5240 ZERO_STRUCT(state->orig.out.result);
5241
5242 state->out_mem_ctx = talloc_named_const(state, 0,
5243 "rpccli_winreg_OpenHKPN_out_memory");
5244 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5245 return tevent_req_post(req, ev);
5246 }
5247
5248 /* make a temporary copy, that we pass to the dispatch function */
5249 state->tmp = state->orig;
5250
5251 subreq = cli->dispatch_send(state, ev, cli,
5252 &ndr_table_winreg,
5253 NDR_WINREG_OPENHKPN,
5254 &state->tmp);
5255 if (tevent_req_nomem(subreq, req)) {
5256 return tevent_req_post(req, ev);
5257 }
5258 tevent_req_set_callback(subreq, rpccli_winreg_OpenHKPN_done, req);
5259 return req;
5260 }
5261
5262 static void rpccli_winreg_OpenHKPN_done(struct tevent_req *subreq)
5263 {
5264 struct tevent_req *req = tevent_req_callback_data(
5265 subreq, struct tevent_req);
5266 struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5267 req, struct rpccli_winreg_OpenHKPN_state);
5268 NTSTATUS status;
5269 TALLOC_CTX *mem_ctx;
5270
5271 if (state->out_mem_ctx) {
5272 mem_ctx = state->out_mem_ctx;
5273 } else {
5274 mem_ctx = state;
5275 }
5276
5277 status = state->dispatch_recv(subreq, mem_ctx);
5278 TALLOC_FREE(subreq);
5279 if (!NT_STATUS_IS_OK(status)) {
5280 tevent_req_nterror(req, status);
5281 return;
5282 }
5283
5284 /* Copy out parameters */
5285 *state->orig.out.handle = *state->tmp.out.handle;
5286
5287 /* Copy result */
5288 state->orig.out.result = state->tmp.out.result;
5289
5290 /* Reset temporary structure */
5291 ZERO_STRUCT(state->tmp);
5292
5293 tevent_req_done(req);
5294 }
5295
5296 NTSTATUS rpccli_winreg_OpenHKPN_recv(struct tevent_req *req,
5297 TALLOC_CTX *mem_ctx,
5298 WERROR *result)
5299 {
5300 struct rpccli_winreg_OpenHKPN_state *state = tevent_req_data(
5301 req, struct rpccli_winreg_OpenHKPN_state);
5302 NTSTATUS status;
5303
5304 if (tevent_req_is_nterror(req, &status)) {
5305 tevent_req_received(req);
5306 return status;
5307 }
5308
5309 /* Steal possbile out parameters to the callers context */
5310 talloc_steal(mem_ctx, state->out_mem_ctx);
5311
5312 /* Return result */
5313 *result = state->orig.out.result;
5314
5315 tevent_req_received(req);
5316 return NT_STATUS_OK;
5317 }
5318
5319 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
5320 TALLOC_CTX *mem_ctx,
5321 uint16_t *system_name /* [in] [unique] */,
5322 uint32_t access_mask /* [in] */,
5323 struct policy_handle *handle /* [out] [ref] */,
5324 WERROR *werror)
5325 {
5326 struct winreg_OpenHKPN r;
5327 NTSTATUS status;
5328
5329 /* In parameters */
5330 r.in.system_name = system_name;
5331 r.in.access_mask = access_mask;
5332
5333 status = cli->dispatch(cli,
5334 mem_ctx,
5335 &ndr_table_winreg,
5336 NDR_WINREG_OPENHKPN,
5337 &r);
5338
5339 if (!NT_STATUS_IS_OK(status)) {
5340 return status;
5341 }
5342
5343 if (NT_STATUS_IS_ERR(status)) {
5344 return status;
5345 }
5346
5347 /* Return variables */
5348 *handle = *r.out.handle;
5349
5350 /* Return result */
5351 if (werror) {
5352 *werror = r.out.result;
5353 }
5354
5355 return werror_to_ntstatus(r.out.result);
5356 }
5357
5358 struct rpccli_winreg_QueryMultipleValues2_state {
5359 struct winreg_QueryMultipleValues2 orig;
5360 struct winreg_QueryMultipleValues2 tmp;
5361 TALLOC_CTX *out_mem_ctx;
5362 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5363 };
5364
5365 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq);
5366
5367 struct tevent_req *rpccli_winreg_QueryMultipleValues2_send(TALLOC_CTX *mem_ctx,
5368 struct tevent_context *ev,
5369 struct rpc_pipe_client *cli,
5370 struct policy_handle *_key_handle /* [in] [ref] */,
5371 struct QueryMultipleValue *_values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
5372 uint32_t _num_values /* [in] */,
5373 uint8_t *_buffer /* [in,out] [unique,length_is(offered),size_is(offered)] */,
5374 uint32_t _offered /* [in] */,
5375 uint32_t *_needed /* [out] [ref] */)
5376 {
5377 struct tevent_req *req;
5378 struct rpccli_winreg_QueryMultipleValues2_state *state;
5379 struct tevent_req *subreq;
5380
5381 req = tevent_req_create(mem_ctx, &state,
5382 struct rpccli_winreg_QueryMultipleValues2_state);
5383 if (req == NULL) {
5384 return NULL;
5385 }
5386 state->out_mem_ctx = NULL;
5387 state->dispatch_recv = cli->dispatch_recv;
5388
5389 /* In parameters */
5390 state->orig.in.key_handle = _key_handle;
5391 state->orig.in.values = _values;
5392 state->orig.in.num_values = _num_values;
5393 state->orig.in.buffer = _buffer;
5394 state->orig.in.offered = _offered;
5395
5396 /* Out parameters */
5397 state->orig.out.values = _values;
5398 state->orig.out.buffer = _buffer;
5399 state->orig.out.needed = _needed;
5400
5401 /* Result */
5402 ZERO_STRUCT(state->orig.out.result);
5403
5404 state->out_mem_ctx = talloc_named_const(state, 0,
5405 "rpccli_winreg_QueryMultipleValues2_out_memory");
5406 if (tevent_req_nomem(state->out_mem_ctx, req)) {
5407 return tevent_req_post(req, ev);
5408 }
5409
5410 /* make a temporary copy, that we pass to the dispatch function */
5411 state->tmp = state->orig;
5412
5413 subreq = cli->dispatch_send(state, ev, cli,
5414 &ndr_table_winreg,
5415 NDR_WINREG_QUERYMULTIPLEVALUES2,
5416 &state->tmp);
5417 if (tevent_req_nomem(subreq, req)) {
5418 return tevent_req_post(req, ev);
5419 }
5420 tevent_req_set_callback(subreq, rpccli_winreg_QueryMultipleValues2_done, req);
5421 return req;
5422 }
5423
5424 static void rpccli_winreg_QueryMultipleValues2_done(struct tevent_req *subreq)
5425 {
5426 struct tevent_req *req = tevent_req_callback_data(
5427 subreq, struct tevent_req);
5428 struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5429 req, struct rpccli_winreg_QueryMultipleValues2_state);
5430 NTSTATUS status;
5431 TALLOC_CTX *mem_ctx;
5432
5433 if (state->out_mem_ctx) {
5434 mem_ctx = state->out_mem_ctx;
5435 } else {
5436 mem_ctx = state;
5437 }
5438
5439 status = state->dispatch_recv(subreq, mem_ctx);
5440 TALLOC_FREE(subreq);
5441 if (!NT_STATUS_IS_OK(status)) {
5442 tevent_req_nterror(req, status);
5443 return;
5444 }
5445
5446 /* Copy out parameters */
5447 memcpy(state->orig.out.values, state->tmp.out.values, (state->tmp.in.num_values) * sizeof(*state->orig.out.values));
5448 if (state->orig.out.buffer && state->tmp.out.buffer) {
5449 memcpy(state->orig.out.buffer, state->tmp.out.buffer, (state->tmp.in.offered) * sizeof(*state->orig.out.buffer));
5450 }
5451 *state->orig.out.needed = *state->tmp.out.needed;
5452
5453 /* Copy result */
5454 state->orig.out.result = state->tmp.out.result;
5455
5456 /* Reset temporary structure */
5457 ZERO_STRUCT(state->tmp);
5458
5459 tevent_req_done(req);
5460 }
5461
5462 NTSTATUS rpccli_winreg_QueryMultipleValues2_recv(struct tevent_req *req,
5463 TALLOC_CTX *mem_ctx,
5464 WERROR *result)
5465 {
5466 struct rpccli_winreg_QueryMultipleValues2_state *state = tevent_req_data(
5467 req, struct rpccli_winreg_QueryMultipleValues2_state);
5468 NTSTATUS status;
5469
5470 if (tevent_req_is_nterror(req, &status)) {
5471 tevent_req_received(req);
5472 return status;
5473 }
5474
5475 /* Steal possbile out parameters to the callers context */
5476 talloc_steal(mem_ctx, state->out_mem_ctx);
5477
5478 /* Return result */
5479 *result = state->orig.out.result;
5480
5481 tevent_req_received(req);
5482 return NT_STATUS_OK;
5483 }
5484
5485 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
5486 TALLOC_CTX *mem_ctx,
5487 struct policy_handle *key_handle /* [in] [ref] */,
5488 struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
5489 uint32_t num_values /* [in] */,
5490 uint8_t *buffer /* [in,out] [unique,length_is(offered),size_is(offered)] */,
5491 uint32_t offered /* [in] */,
5492 uint32_t *needed /* [out] [ref] */,
5493 WERROR *werror)
5494 {
5495 struct winreg_QueryMultipleValues2 r;
5496 NTSTATUS status;
5497
5498 /* In parameters */
5499 r.in.key_handle = key_handle;
5500 r.in.values = values;
5501 r.in.num_values = num_values;
5502 r.in.buffer = buffer;
5503 r.in.offered = offered;
5504
5505 status = cli->dispatch(cli,
5506 mem_ctx,
5507 &ndr_table_winreg,
5508 NDR_WINREG_QUERYMULTIPLEVALUES2,
5509 &r);
5510
5511 if (!NT_STATUS_IS_OK(status)) {
5512 return status;
5513 }
5514
5515 if (NT_STATUS_IS_ERR(status)) {
5516 return status;
5517 }
5518
5519 /* Return variables */
5520 memcpy(values, r.out.values, (r.in.num_values) * sizeof(*values));
5521 if (buffer && r.out.buffer) {
5522 memcpy(buffer, r.out.buffer, (r.in.offered) * sizeof(*buffer));
5523 }
5524 *needed = *r.out.needed;
5525
5526 /* Return result */
5527 if (werror) {
5528 *werror = r.out.result;
5529 }
5530
5531 return werror_to_ntstatus(r.out.result);
5532 }
5533
5534 struct rpccli_winreg_DeleteKeyEx_state {
5535 struct winreg_DeleteKeyEx orig;
5536 struct winreg_DeleteKeyEx tmp;
5537 TALLOC_CTX *out_mem_ctx;
5538 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
5539 };
5540
5541 static void rpccli_winreg_DeleteKeyEx_done(struct tevent_req *subreq);
5542
5543 struct tevent_req *rpccli_winreg_DeleteKeyEx_send(TALLOC_CTX *mem_ctx,
5544 struct tevent_context *ev,
5545 struct rpc_pipe_client *cli,
5546 struct policy_handle *_handle /* [in] [ref] */,
5547 struct winreg_String *_key /* [in] [ref] */,
5548 uint32_t _access_mask /* [in] */,
5549 uint32_t _reserved /* [in] */)
5550 {
5551 struct tevent_req *req;
5552 struct rpccli_winreg_DeleteKeyEx_state *state;
5553 struct tevent_req *subreq;
5554
5555 req = tevent_req_create(mem_ctx, &state,
5556 struct rpccli_winreg_DeleteKeyEx_state);
5557 if (req == NULL) {
5558 return NULL;
5559 }
5560 state->out_mem_ctx = NULL;
5561 state->dispatch_recv = cli->dispatch_recv;
5562
5563 /* In parameters */
5564 state->orig.in.handle = _handle;
5565 state->orig.in.key = _key;
5566 state->orig.in.access_mask = _access_mask;
5567 state->orig.in.reserved = _reserved;
5568
5569 /* Out parameters */
5570
5571 /* Result */
5572 ZERO_STRUCT(state->orig.out.result);
5573
5574 /* make a temporary copy, that we pass to the dispatch function */
5575 state->tmp = state->orig;
5576
5577 subreq = cli->dispatch_send(state, ev, cli,
5578 &ndr_table_winreg,
5579 NDR_WINREG_DELETEKEYEX,
5580 &state->tmp);
5581 if (tevent_req_nomem(subreq, req)) {
5582 return tevent_req_post(req, ev);
5583 }
5584 tevent_req_set_callback(subreq, rpccli_winreg_DeleteKeyEx_done, req);
5585 return req;
5586 }
5587
5588 static void rpccli_winreg_DeleteKeyEx_done(struct tevent_req *subreq)
5589 {
5590 struct tevent_req *req = tevent_req_callback_data(
5591 subreq, struct tevent_req);
5592 struct rpccli_winreg_DeleteKeyEx_state *state = tevent_req_data(
5593 req, struct rpccli_winreg_DeleteKeyEx_state);
5594 NTSTATUS status;
5595 TALLOC_CTX *mem_ctx;
5596
5597 if (state->out_mem_ctx) {
5598 mem_ctx = state->out_mem_ctx;
5599 } else {
5600 mem_ctx = state;
5601 }
5602
5603 status = state->dispatch_recv(subreq, mem_ctx);
5604 TALLOC_FREE(subreq);
5605 if (!NT_STATUS_IS_OK(status)) {
5606 tevent_req_nterror(req, status);
5607 return;
5608 }
5609
5610 /* Copy out parameters */
5611
5612 /* Copy result */
5613 state->orig.out.result = state->tmp.out.result;
5614
5615 /* Reset temporary structure */
5616 ZERO_STRUCT(state->tmp);
5617
5618 tevent_req_done(req);
5619 }
5620
5621 NTSTATUS rpccli_winreg_DeleteKeyEx_recv(struct tevent_req *req,
5622 TALLOC_CTX *mem_ctx,
5623 WERROR *result)
5624 {
5625 struct rpccli_winreg_DeleteKeyEx_state *state = tevent_req_data(
5626 req, struct rpccli_winreg_DeleteKeyEx_state);
5627 NTSTATUS status;
5628
5629 if (tevent_req_is_nterror(req, &status)) {
5630 tevent_req_received(req);
5631 return status;
5632 }
5633
5634 /* Steal possbile out parameters to the callers context */
5635 talloc_steal(mem_ctx, state->out_mem_ctx);
5636
5637 /* Return result */
5638 *result = state->orig.out.result;
5639
5640 tevent_req_received(req);
5641 return NT_STATUS_OK;
5642 }
5643
5644 NTSTATUS rpccli_winreg_DeleteKeyEx(struct rpc_pipe_client *cli,
5645 TALLOC_CTX *mem_ctx,
5646 struct policy_handle *handle /* [in] [ref] */,
5647 struct winreg_String *key /* [in] [ref] */,
5648 uint32_t access_mask /* [in] */,
5649 uint32_t reserved /* [in] */,
5650 WERROR *werror)
5651 {
5652 struct winreg_DeleteKeyEx r;
5653 NTSTATUS status;
5654
5655 /* In parameters */
5656 r.in.handle = handle;
5657 r.in.key = key;
5658 r.in.access_mask = access_mask;
5659 r.in.reserved = reserved;
5660
5661 status = cli->dispatch(cli,
5662 mem_ctx,
5663 &ndr_table_winreg,
5664 NDR_WINREG_DELETEKEYEX,
5665 &r);
5666
5667 if (!NT_STATUS_IS_OK(status)) {
5668 return status;
5669 }
5670
5671 if (NT_STATUS_IS_ERR(status)) {
5672 return status;
5673 }
5674
5675 /* Return variables */
5676
5677 /* Return result */
5678 if (werror) {
5679 *werror = r.out.result;
5680 }
5681
5682 return werror_to_ntstatus(r.out.result);
5683 }
5684
reg import