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

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 66.7 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
4 */
5
6#include "includes.h"
7#include "../librpc/gen_ndr/srv_winreg.h"
8
9static bool api_winreg_OpenHKCR(pipes_struct *p)
10{
11 const struct ndr_interface_call *call;
12 struct ndr_pull *pull;
13 struct ndr_push *push;
14 enum ndr_err_code ndr_err;
15 DATA_BLOB blob;
16 struct winreg_OpenHKCR *r;
17
18 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCR];
19
20 r = talloc(talloc_tos(), struct winreg_OpenHKCR);
21 if (r == NULL) {
22 return false;
23 }
24
25 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26 talloc_free(r);
27 return false;
28 }
29
30 pull = ndr_pull_init_blob(&blob, r, NULL);
31 if (pull == NULL) {
32 talloc_free(r);
33 return false;
34 }
35
36 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37 ndr_err = call->ndr_pull(pull, NDR_IN, r);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39 talloc_free(r);
40 return false;
41 }
42
43 if (DEBUGLEVEL >= 10) {
44 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, r);
45 }
46
47 ZERO_STRUCT(r->out);
48 r->out.handle = talloc_zero(r, struct policy_handle);
49 if (r->out.handle == NULL) {
50 talloc_free(r);
51 return false;
52 }
53
54 r->out.result = _winreg_OpenHKCR(p, r);
55
56 if (p->rng_fault_state) {
57 talloc_free(r);
58 /* Return true here, srv_pipe_hnd.c will take care */
59 return true;
60 }
61
62 if (DEBUGLEVEL >= 10) {
63 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, r);
64 }
65
66 push = ndr_push_init_ctx(r, NULL);
67 if (push == NULL) {
68 talloc_free(r);
69 return false;
70 }
71
72 ndr_err = call->ndr_push(push, NDR_OUT, r);
73 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
74 talloc_free(r);
75 return false;
76 }
77
78 blob = ndr_push_blob(push);
79 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
80 talloc_free(r);
81 return false;
82 }
83
84 talloc_free(r);
85
86 return true;
87}
88
89static bool api_winreg_OpenHKCU(pipes_struct *p)
90{
91 const struct ndr_interface_call *call;
92 struct ndr_pull *pull;
93 struct ndr_push *push;
94 enum ndr_err_code ndr_err;
95 DATA_BLOB blob;
96 struct winreg_OpenHKCU *r;
97
98 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCU];
99
100 r = talloc(talloc_tos(), struct winreg_OpenHKCU);
101 if (r == NULL) {
102 return false;
103 }
104
105 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
106 talloc_free(r);
107 return false;
108 }
109
110 pull = ndr_pull_init_blob(&blob, r, NULL);
111 if (pull == NULL) {
112 talloc_free(r);
113 return false;
114 }
115
116 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
117 ndr_err = call->ndr_pull(pull, NDR_IN, r);
118 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
119 talloc_free(r);
120 return false;
121 }
122
123 if (DEBUGLEVEL >= 10) {
124 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, r);
125 }
126
127 ZERO_STRUCT(r->out);
128 r->out.handle = talloc_zero(r, struct policy_handle);
129 if (r->out.handle == NULL) {
130 talloc_free(r);
131 return false;
132 }
133
134 r->out.result = _winreg_OpenHKCU(p, r);
135
136 if (p->rng_fault_state) {
137 talloc_free(r);
138 /* Return true here, srv_pipe_hnd.c will take care */
139 return true;
140 }
141
142 if (DEBUGLEVEL >= 10) {
143 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, r);
144 }
145
146 push = ndr_push_init_ctx(r, NULL);
147 if (push == NULL) {
148 talloc_free(r);
149 return false;
150 }
151
152 ndr_err = call->ndr_push(push, NDR_OUT, r);
153 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
154 talloc_free(r);
155 return false;
156 }
157
158 blob = ndr_push_blob(push);
159 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
160 talloc_free(r);
161 return false;
162 }
163
164 talloc_free(r);
165
166 return true;
167}
168
169static bool api_winreg_OpenHKLM(pipes_struct *p)
170{
171 const struct ndr_interface_call *call;
172 struct ndr_pull *pull;
173 struct ndr_push *push;
174 enum ndr_err_code ndr_err;
175 DATA_BLOB blob;
176 struct winreg_OpenHKLM *r;
177
178 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKLM];
179
180 r = talloc(talloc_tos(), struct winreg_OpenHKLM);
181 if (r == NULL) {
182 return false;
183 }
184
185 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
186 talloc_free(r);
187 return false;
188 }
189
190 pull = ndr_pull_init_blob(&blob, r, NULL);
191 if (pull == NULL) {
192 talloc_free(r);
193 return false;
194 }
195
196 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
197 ndr_err = call->ndr_pull(pull, NDR_IN, r);
198 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
199 talloc_free(r);
200 return false;
201 }
202
203 if (DEBUGLEVEL >= 10) {
204 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, r);
205 }
206
207 ZERO_STRUCT(r->out);
208 r->out.handle = talloc_zero(r, struct policy_handle);
209 if (r->out.handle == NULL) {
210 talloc_free(r);
211 return false;
212 }
213
214 r->out.result = _winreg_OpenHKLM(p, r);
215
216 if (p->rng_fault_state) {
217 talloc_free(r);
218 /* Return true here, srv_pipe_hnd.c will take care */
219 return true;
220 }
221
222 if (DEBUGLEVEL >= 10) {
223 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, r);
224 }
225
226 push = ndr_push_init_ctx(r, NULL);
227 if (push == NULL) {
228 talloc_free(r);
229 return false;
230 }
231
232 ndr_err = call->ndr_push(push, NDR_OUT, r);
233 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
234 talloc_free(r);
235 return false;
236 }
237
238 blob = ndr_push_blob(push);
239 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
240 talloc_free(r);
241 return false;
242 }
243
244 talloc_free(r);
245
246 return true;
247}
248
249static bool api_winreg_OpenHKPD(pipes_struct *p)
250{
251 const struct ndr_interface_call *call;
252 struct ndr_pull *pull;
253 struct ndr_push *push;
254 enum ndr_err_code ndr_err;
255 DATA_BLOB blob;
256 struct winreg_OpenHKPD *r;
257
258 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPD];
259
260 r = talloc(talloc_tos(), struct winreg_OpenHKPD);
261 if (r == NULL) {
262 return false;
263 }
264
265 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
266 talloc_free(r);
267 return false;
268 }
269
270 pull = ndr_pull_init_blob(&blob, r, NULL);
271 if (pull == NULL) {
272 talloc_free(r);
273 return false;
274 }
275
276 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
277 ndr_err = call->ndr_pull(pull, NDR_IN, r);
278 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
279 talloc_free(r);
280 return false;
281 }
282
283 if (DEBUGLEVEL >= 10) {
284 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, r);
285 }
286
287 ZERO_STRUCT(r->out);
288 r->out.handle = talloc_zero(r, struct policy_handle);
289 if (r->out.handle == NULL) {
290 talloc_free(r);
291 return false;
292 }
293
294 r->out.result = _winreg_OpenHKPD(p, r);
295
296 if (p->rng_fault_state) {
297 talloc_free(r);
298 /* Return true here, srv_pipe_hnd.c will take care */
299 return true;
300 }
301
302 if (DEBUGLEVEL >= 10) {
303 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, r);
304 }
305
306 push = ndr_push_init_ctx(r, NULL);
307 if (push == NULL) {
308 talloc_free(r);
309 return false;
310 }
311
312 ndr_err = call->ndr_push(push, NDR_OUT, r);
313 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
314 talloc_free(r);
315 return false;
316 }
317
318 blob = ndr_push_blob(push);
319 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
320 talloc_free(r);
321 return false;
322 }
323
324 talloc_free(r);
325
326 return true;
327}
328
329static bool api_winreg_OpenHKU(pipes_struct *p)
330{
331 const struct ndr_interface_call *call;
332 struct ndr_pull *pull;
333 struct ndr_push *push;
334 enum ndr_err_code ndr_err;
335 DATA_BLOB blob;
336 struct winreg_OpenHKU *r;
337
338 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKU];
339
340 r = talloc(talloc_tos(), struct winreg_OpenHKU);
341 if (r == NULL) {
342 return false;
343 }
344
345 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
346 talloc_free(r);
347 return false;
348 }
349
350 pull = ndr_pull_init_blob(&blob, r, NULL);
351 if (pull == NULL) {
352 talloc_free(r);
353 return false;
354 }
355
356 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
357 ndr_err = call->ndr_pull(pull, NDR_IN, r);
358 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
359 talloc_free(r);
360 return false;
361 }
362
363 if (DEBUGLEVEL >= 10) {
364 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, r);
365 }
366
367 ZERO_STRUCT(r->out);
368 r->out.handle = talloc_zero(r, struct policy_handle);
369 if (r->out.handle == NULL) {
370 talloc_free(r);
371 return false;
372 }
373
374 r->out.result = _winreg_OpenHKU(p, r);
375
376 if (p->rng_fault_state) {
377 talloc_free(r);
378 /* Return true here, srv_pipe_hnd.c will take care */
379 return true;
380 }
381
382 if (DEBUGLEVEL >= 10) {
383 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, r);
384 }
385
386 push = ndr_push_init_ctx(r, NULL);
387 if (push == NULL) {
388 talloc_free(r);
389 return false;
390 }
391
392 ndr_err = call->ndr_push(push, NDR_OUT, r);
393 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
394 talloc_free(r);
395 return false;
396 }
397
398 blob = ndr_push_blob(push);
399 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
400 talloc_free(r);
401 return false;
402 }
403
404 talloc_free(r);
405
406 return true;
407}
408
409static bool api_winreg_CloseKey(pipes_struct *p)
410{
411 const struct ndr_interface_call *call;
412 struct ndr_pull *pull;
413 struct ndr_push *push;
414 enum ndr_err_code ndr_err;
415 DATA_BLOB blob;
416 struct winreg_CloseKey *r;
417
418 call = &ndr_table_winreg.calls[NDR_WINREG_CLOSEKEY];
419
420 r = talloc(talloc_tos(), struct winreg_CloseKey);
421 if (r == NULL) {
422 return false;
423 }
424
425 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
426 talloc_free(r);
427 return false;
428 }
429
430 pull = ndr_pull_init_blob(&blob, r, NULL);
431 if (pull == NULL) {
432 talloc_free(r);
433 return false;
434 }
435
436 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
437 ndr_err = call->ndr_pull(pull, NDR_IN, r);
438 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
439 talloc_free(r);
440 return false;
441 }
442
443 if (DEBUGLEVEL >= 10) {
444 NDR_PRINT_IN_DEBUG(winreg_CloseKey, r);
445 }
446
447 ZERO_STRUCT(r->out);
448 r->out.handle = r->in.handle;
449 r->out.result = _winreg_CloseKey(p, r);
450
451 if (p->rng_fault_state) {
452 talloc_free(r);
453 /* Return true here, srv_pipe_hnd.c will take care */
454 return true;
455 }
456
457 if (DEBUGLEVEL >= 10) {
458 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, r);
459 }
460
461 push = ndr_push_init_ctx(r, NULL);
462 if (push == NULL) {
463 talloc_free(r);
464 return false;
465 }
466
467 ndr_err = call->ndr_push(push, NDR_OUT, r);
468 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
469 talloc_free(r);
470 return false;
471 }
472
473 blob = ndr_push_blob(push);
474 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
475 talloc_free(r);
476 return false;
477 }
478
479 talloc_free(r);
480
481 return true;
482}
483
484static bool api_winreg_CreateKey(pipes_struct *p)
485{
486 const struct ndr_interface_call *call;
487 struct ndr_pull *pull;
488 struct ndr_push *push;
489 enum ndr_err_code ndr_err;
490 DATA_BLOB blob;
491 struct winreg_CreateKey *r;
492
493 call = &ndr_table_winreg.calls[NDR_WINREG_CREATEKEY];
494
495 r = talloc(talloc_tos(), struct winreg_CreateKey);
496 if (r == NULL) {
497 return false;
498 }
499
500 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
501 talloc_free(r);
502 return false;
503 }
504
505 pull = ndr_pull_init_blob(&blob, r, NULL);
506 if (pull == NULL) {
507 talloc_free(r);
508 return false;
509 }
510
511 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
512 ndr_err = call->ndr_pull(pull, NDR_IN, r);
513 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
514 talloc_free(r);
515 return false;
516 }
517
518 if (DEBUGLEVEL >= 10) {
519 NDR_PRINT_IN_DEBUG(winreg_CreateKey, r);
520 }
521
522 ZERO_STRUCT(r->out);
523 r->out.action_taken = r->in.action_taken;
524 r->out.new_handle = talloc_zero(r, struct policy_handle);
525 if (r->out.new_handle == NULL) {
526 talloc_free(r);
527 return false;
528 }
529
530 r->out.result = _winreg_CreateKey(p, r);
531
532 if (p->rng_fault_state) {
533 talloc_free(r);
534 /* Return true here, srv_pipe_hnd.c will take care */
535 return true;
536 }
537
538 if (DEBUGLEVEL >= 10) {
539 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, r);
540 }
541
542 push = ndr_push_init_ctx(r, NULL);
543 if (push == NULL) {
544 talloc_free(r);
545 return false;
546 }
547
548 ndr_err = call->ndr_push(push, NDR_OUT, r);
549 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
550 talloc_free(r);
551 return false;
552 }
553
554 blob = ndr_push_blob(push);
555 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
556 talloc_free(r);
557 return false;
558 }
559
560 talloc_free(r);
561
562 return true;
563}
564
565static bool api_winreg_DeleteKey(pipes_struct *p)
566{
567 const struct ndr_interface_call *call;
568 struct ndr_pull *pull;
569 struct ndr_push *push;
570 enum ndr_err_code ndr_err;
571 DATA_BLOB blob;
572 struct winreg_DeleteKey *r;
573
574 call = &ndr_table_winreg.calls[NDR_WINREG_DELETEKEY];
575
576 r = talloc(talloc_tos(), struct winreg_DeleteKey);
577 if (r == NULL) {
578 return false;
579 }
580
581 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
582 talloc_free(r);
583 return false;
584 }
585
586 pull = ndr_pull_init_blob(&blob, r, NULL);
587 if (pull == NULL) {
588 talloc_free(r);
589 return false;
590 }
591
592 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
593 ndr_err = call->ndr_pull(pull, NDR_IN, r);
594 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
595 talloc_free(r);
596 return false;
597 }
598
599 if (DEBUGLEVEL >= 10) {
600 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, r);
601 }
602
603 r->out.result = _winreg_DeleteKey(p, r);
604
605 if (p->rng_fault_state) {
606 talloc_free(r);
607 /* Return true here, srv_pipe_hnd.c will take care */
608 return true;
609 }
610
611 if (DEBUGLEVEL >= 10) {
612 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, r);
613 }
614
615 push = ndr_push_init_ctx(r, NULL);
616 if (push == NULL) {
617 talloc_free(r);
618 return false;
619 }
620
621 ndr_err = call->ndr_push(push, NDR_OUT, r);
622 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
623 talloc_free(r);
624 return false;
625 }
626
627 blob = ndr_push_blob(push);
628 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
629 talloc_free(r);
630 return false;
631 }
632
633 talloc_free(r);
634
635 return true;
636}
637
638static bool api_winreg_DeleteValue(pipes_struct *p)
639{
640 const struct ndr_interface_call *call;
641 struct ndr_pull *pull;
642 struct ndr_push *push;
643 enum ndr_err_code ndr_err;
644 DATA_BLOB blob;
645 struct winreg_DeleteValue *r;
646
647 call = &ndr_table_winreg.calls[NDR_WINREG_DELETEVALUE];
648
649 r = talloc(talloc_tos(), struct winreg_DeleteValue);
650 if (r == NULL) {
651 return false;
652 }
653
654 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
655 talloc_free(r);
656 return false;
657 }
658
659 pull = ndr_pull_init_blob(&blob, r, NULL);
660 if (pull == NULL) {
661 talloc_free(r);
662 return false;
663 }
664
665 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
666 ndr_err = call->ndr_pull(pull, NDR_IN, r);
667 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
668 talloc_free(r);
669 return false;
670 }
671
672 if (DEBUGLEVEL >= 10) {
673 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, r);
674 }
675
676 r->out.result = _winreg_DeleteValue(p, r);
677
678 if (p->rng_fault_state) {
679 talloc_free(r);
680 /* Return true here, srv_pipe_hnd.c will take care */
681 return true;
682 }
683
684 if (DEBUGLEVEL >= 10) {
685 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, r);
686 }
687
688 push = ndr_push_init_ctx(r, NULL);
689 if (push == NULL) {
690 talloc_free(r);
691 return false;
692 }
693
694 ndr_err = call->ndr_push(push, NDR_OUT, r);
695 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
696 talloc_free(r);
697 return false;
698 }
699
700 blob = ndr_push_blob(push);
701 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
702 talloc_free(r);
703 return false;
704 }
705
706 talloc_free(r);
707
708 return true;
709}
710
711static bool api_winreg_EnumKey(pipes_struct *p)
712{
713 const struct ndr_interface_call *call;
714 struct ndr_pull *pull;
715 struct ndr_push *push;
716 enum ndr_err_code ndr_err;
717 DATA_BLOB blob;
718 struct winreg_EnumKey *r;
719
720 call = &ndr_table_winreg.calls[NDR_WINREG_ENUMKEY];
721
722 r = talloc(talloc_tos(), struct winreg_EnumKey);
723 if (r == NULL) {
724 return false;
725 }
726
727 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
728 talloc_free(r);
729 return false;
730 }
731
732 pull = ndr_pull_init_blob(&blob, r, NULL);
733 if (pull == NULL) {
734 talloc_free(r);
735 return false;
736 }
737
738 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
739 ndr_err = call->ndr_pull(pull, NDR_IN, r);
740 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
741 talloc_free(r);
742 return false;
743 }
744
745 if (DEBUGLEVEL >= 10) {
746 NDR_PRINT_IN_DEBUG(winreg_EnumKey, r);
747 }
748
749 ZERO_STRUCT(r->out);
750 r->out.name = r->in.name;
751 r->out.keyclass = r->in.keyclass;
752 r->out.last_changed_time = r->in.last_changed_time;
753 r->out.result = _winreg_EnumKey(p, r);
754
755 if (p->rng_fault_state) {
756 talloc_free(r);
757 /* Return true here, srv_pipe_hnd.c will take care */
758 return true;
759 }
760
761 if (DEBUGLEVEL >= 10) {
762 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, r);
763 }
764
765 push = ndr_push_init_ctx(r, NULL);
766 if (push == NULL) {
767 talloc_free(r);
768 return false;
769 }
770
771 ndr_err = call->ndr_push(push, NDR_OUT, r);
772 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
773 talloc_free(r);
774 return false;
775 }
776
777 blob = ndr_push_blob(push);
778 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
779 talloc_free(r);
780 return false;
781 }
782
783 talloc_free(r);
784
785 return true;
786}
787
788static bool api_winreg_EnumValue(pipes_struct *p)
789{
790 const struct ndr_interface_call *call;
791 struct ndr_pull *pull;
792 struct ndr_push *push;
793 enum ndr_err_code ndr_err;
794 DATA_BLOB blob;
795 struct winreg_EnumValue *r;
796
797 call = &ndr_table_winreg.calls[NDR_WINREG_ENUMVALUE];
798
799 r = talloc(talloc_tos(), struct winreg_EnumValue);
800 if (r == NULL) {
801 return false;
802 }
803
804 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
805 talloc_free(r);
806 return false;
807 }
808
809 pull = ndr_pull_init_blob(&blob, r, NULL);
810 if (pull == NULL) {
811 talloc_free(r);
812 return false;
813 }
814
815 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
816 ndr_err = call->ndr_pull(pull, NDR_IN, r);
817 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
818 talloc_free(r);
819 return false;
820 }
821
822 if (DEBUGLEVEL >= 10) {
823 NDR_PRINT_IN_DEBUG(winreg_EnumValue, r);
824 }
825
826 ZERO_STRUCT(r->out);
827 r->out.name = r->in.name;
828 r->out.type = r->in.type;
829 r->out.value = r->in.value;
830 r->out.size = r->in.size;
831 r->out.length = r->in.length;
832 r->out.result = _winreg_EnumValue(p, r);
833
834 if (p->rng_fault_state) {
835 talloc_free(r);
836 /* Return true here, srv_pipe_hnd.c will take care */
837 return true;
838 }
839
840 if (DEBUGLEVEL >= 10) {
841 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, r);
842 }
843
844 push = ndr_push_init_ctx(r, NULL);
845 if (push == NULL) {
846 talloc_free(r);
847 return false;
848 }
849
850 ndr_err = call->ndr_push(push, NDR_OUT, r);
851 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
852 talloc_free(r);
853 return false;
854 }
855
856 blob = ndr_push_blob(push);
857 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
858 talloc_free(r);
859 return false;
860 }
861
862 talloc_free(r);
863
864 return true;
865}
866
867static bool api_winreg_FlushKey(pipes_struct *p)
868{
869 const struct ndr_interface_call *call;
870 struct ndr_pull *pull;
871 struct ndr_push *push;
872 enum ndr_err_code ndr_err;
873 DATA_BLOB blob;
874 struct winreg_FlushKey *r;
875
876 call = &ndr_table_winreg.calls[NDR_WINREG_FLUSHKEY];
877
878 r = talloc(talloc_tos(), struct winreg_FlushKey);
879 if (r == NULL) {
880 return false;
881 }
882
883 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
884 talloc_free(r);
885 return false;
886 }
887
888 pull = ndr_pull_init_blob(&blob, r, NULL);
889 if (pull == NULL) {
890 talloc_free(r);
891 return false;
892 }
893
894 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
895 ndr_err = call->ndr_pull(pull, NDR_IN, r);
896 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
897 talloc_free(r);
898 return false;
899 }
900
901 if (DEBUGLEVEL >= 10) {
902 NDR_PRINT_IN_DEBUG(winreg_FlushKey, r);
903 }
904
905 r->out.result = _winreg_FlushKey(p, r);
906
907 if (p->rng_fault_state) {
908 talloc_free(r);
909 /* Return true here, srv_pipe_hnd.c will take care */
910 return true;
911 }
912
913 if (DEBUGLEVEL >= 10) {
914 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, r);
915 }
916
917 push = ndr_push_init_ctx(r, NULL);
918 if (push == NULL) {
919 talloc_free(r);
920 return false;
921 }
922
923 ndr_err = call->ndr_push(push, NDR_OUT, r);
924 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
925 talloc_free(r);
926 return false;
927 }
928
929 blob = ndr_push_blob(push);
930 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
931 talloc_free(r);
932 return false;
933 }
934
935 talloc_free(r);
936
937 return true;
938}
939
940static bool api_winreg_GetKeySecurity(pipes_struct *p)
941{
942 const struct ndr_interface_call *call;
943 struct ndr_pull *pull;
944 struct ndr_push *push;
945 enum ndr_err_code ndr_err;
946 DATA_BLOB blob;
947 struct winreg_GetKeySecurity *r;
948
949 call = &ndr_table_winreg.calls[NDR_WINREG_GETKEYSECURITY];
950
951 r = talloc(talloc_tos(), struct winreg_GetKeySecurity);
952 if (r == NULL) {
953 return false;
954 }
955
956 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
957 talloc_free(r);
958 return false;
959 }
960
961 pull = ndr_pull_init_blob(&blob, r, NULL);
962 if (pull == NULL) {
963 talloc_free(r);
964 return false;
965 }
966
967 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
968 ndr_err = call->ndr_pull(pull, NDR_IN, r);
969 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
970 talloc_free(r);
971 return false;
972 }
973
974 if (DEBUGLEVEL >= 10) {
975 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, r);
976 }
977
978 ZERO_STRUCT(r->out);
979 r->out.sd = r->in.sd;
980 r->out.result = _winreg_GetKeySecurity(p, r);
981
982 if (p->rng_fault_state) {
983 talloc_free(r);
984 /* Return true here, srv_pipe_hnd.c will take care */
985 return true;
986 }
987
988 if (DEBUGLEVEL >= 10) {
989 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, r);
990 }
991
992 push = ndr_push_init_ctx(r, NULL);
993 if (push == NULL) {
994 talloc_free(r);
995 return false;
996 }
997
998 ndr_err = call->ndr_push(push, NDR_OUT, r);
999 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1000 talloc_free(r);
1001 return false;
1002 }
1003
1004 blob = ndr_push_blob(push);
1005 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1006 talloc_free(r);
1007 return false;
1008 }
1009
1010 talloc_free(r);
1011
1012 return true;
1013}
1014
1015static bool api_winreg_LoadKey(pipes_struct *p)
1016{
1017 const struct ndr_interface_call *call;
1018 struct ndr_pull *pull;
1019 struct ndr_push *push;
1020 enum ndr_err_code ndr_err;
1021 DATA_BLOB blob;
1022 struct winreg_LoadKey *r;
1023
1024 call = &ndr_table_winreg.calls[NDR_WINREG_LOADKEY];
1025
1026 r = talloc(talloc_tos(), struct winreg_LoadKey);
1027 if (r == NULL) {
1028 return false;
1029 }
1030
1031 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1032 talloc_free(r);
1033 return false;
1034 }
1035
1036 pull = ndr_pull_init_blob(&blob, r, NULL);
1037 if (pull == NULL) {
1038 talloc_free(r);
1039 return false;
1040 }
1041
1042 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1043 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1044 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1045 talloc_free(r);
1046 return false;
1047 }
1048
1049 if (DEBUGLEVEL >= 10) {
1050 NDR_PRINT_IN_DEBUG(winreg_LoadKey, r);
1051 }
1052
1053 r->out.result = _winreg_LoadKey(p, r);
1054
1055 if (p->rng_fault_state) {
1056 talloc_free(r);
1057 /* Return true here, srv_pipe_hnd.c will take care */
1058 return true;
1059 }
1060
1061 if (DEBUGLEVEL >= 10) {
1062 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, r);
1063 }
1064
1065 push = ndr_push_init_ctx(r, NULL);
1066 if (push == NULL) {
1067 talloc_free(r);
1068 return false;
1069 }
1070
1071 ndr_err = call->ndr_push(push, NDR_OUT, r);
1072 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1073 talloc_free(r);
1074 return false;
1075 }
1076
1077 blob = ndr_push_blob(push);
1078 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1079 talloc_free(r);
1080 return false;
1081 }
1082
1083 talloc_free(r);
1084
1085 return true;
1086}
1087
1088static bool api_winreg_NotifyChangeKeyValue(pipes_struct *p)
1089{
1090 const struct ndr_interface_call *call;
1091 struct ndr_pull *pull;
1092 struct ndr_push *push;
1093 enum ndr_err_code ndr_err;
1094 DATA_BLOB blob;
1095 struct winreg_NotifyChangeKeyValue *r;
1096
1097 call = &ndr_table_winreg.calls[NDR_WINREG_NOTIFYCHANGEKEYVALUE];
1098
1099 r = talloc(talloc_tos(), struct winreg_NotifyChangeKeyValue);
1100 if (r == NULL) {
1101 return false;
1102 }
1103
1104 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1105 talloc_free(r);
1106 return false;
1107 }
1108
1109 pull = ndr_pull_init_blob(&blob, r, NULL);
1110 if (pull == NULL) {
1111 talloc_free(r);
1112 return false;
1113 }
1114
1115 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1116 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1117 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1118 talloc_free(r);
1119 return false;
1120 }
1121
1122 if (DEBUGLEVEL >= 10) {
1123 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, r);
1124 }
1125
1126 r->out.result = _winreg_NotifyChangeKeyValue(p, r);
1127
1128 if (p->rng_fault_state) {
1129 talloc_free(r);
1130 /* Return true here, srv_pipe_hnd.c will take care */
1131 return true;
1132 }
1133
1134 if (DEBUGLEVEL >= 10) {
1135 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, r);
1136 }
1137
1138 push = ndr_push_init_ctx(r, NULL);
1139 if (push == NULL) {
1140 talloc_free(r);
1141 return false;
1142 }
1143
1144 ndr_err = call->ndr_push(push, NDR_OUT, r);
1145 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1146 talloc_free(r);
1147 return false;
1148 }
1149
1150 blob = ndr_push_blob(push);
1151 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1152 talloc_free(r);
1153 return false;
1154 }
1155
1156 talloc_free(r);
1157
1158 return true;
1159}
1160
1161static bool api_winreg_OpenKey(pipes_struct *p)
1162{
1163 const struct ndr_interface_call *call;
1164 struct ndr_pull *pull;
1165 struct ndr_push *push;
1166 enum ndr_err_code ndr_err;
1167 DATA_BLOB blob;
1168 struct winreg_OpenKey *r;
1169
1170 call = &ndr_table_winreg.calls[NDR_WINREG_OPENKEY];
1171
1172 r = talloc(talloc_tos(), struct winreg_OpenKey);
1173 if (r == NULL) {
1174 return false;
1175 }
1176
1177 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1178 talloc_free(r);
1179 return false;
1180 }
1181
1182 pull = ndr_pull_init_blob(&blob, r, NULL);
1183 if (pull == NULL) {
1184 talloc_free(r);
1185 return false;
1186 }
1187
1188 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1189 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1190 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1191 talloc_free(r);
1192 return false;
1193 }
1194
1195 if (DEBUGLEVEL >= 10) {
1196 NDR_PRINT_IN_DEBUG(winreg_OpenKey, r);
1197 }
1198
1199 ZERO_STRUCT(r->out);
1200 r->out.handle = talloc_zero(r, struct policy_handle);
1201 if (r->out.handle == NULL) {
1202 talloc_free(r);
1203 return false;
1204 }
1205
1206 r->out.result = _winreg_OpenKey(p, r);
1207
1208 if (p->rng_fault_state) {
1209 talloc_free(r);
1210 /* Return true here, srv_pipe_hnd.c will take care */
1211 return true;
1212 }
1213
1214 if (DEBUGLEVEL >= 10) {
1215 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, r);
1216 }
1217
1218 push = ndr_push_init_ctx(r, NULL);
1219 if (push == NULL) {
1220 talloc_free(r);
1221 return false;
1222 }
1223
1224 ndr_err = call->ndr_push(push, NDR_OUT, r);
1225 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1226 talloc_free(r);
1227 return false;
1228 }
1229
1230 blob = ndr_push_blob(push);
1231 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1232 talloc_free(r);
1233 return false;
1234 }
1235
1236 talloc_free(r);
1237
1238 return true;
1239}
1240
1241static bool api_winreg_QueryInfoKey(pipes_struct *p)
1242{
1243 const struct ndr_interface_call *call;
1244 struct ndr_pull *pull;
1245 struct ndr_push *push;
1246 enum ndr_err_code ndr_err;
1247 DATA_BLOB blob;
1248 struct winreg_QueryInfoKey *r;
1249
1250 call = &ndr_table_winreg.calls[NDR_WINREG_QUERYINFOKEY];
1251
1252 r = talloc(talloc_tos(), struct winreg_QueryInfoKey);
1253 if (r == NULL) {
1254 return false;
1255 }
1256
1257 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1258 talloc_free(r);
1259 return false;
1260 }
1261
1262 pull = ndr_pull_init_blob(&blob, r, NULL);
1263 if (pull == NULL) {
1264 talloc_free(r);
1265 return false;
1266 }
1267
1268 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1269 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1270 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1271 talloc_free(r);
1272 return false;
1273 }
1274
1275 if (DEBUGLEVEL >= 10) {
1276 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, r);
1277 }
1278
1279 ZERO_STRUCT(r->out);
1280 r->out.classname = r->in.classname;
1281 r->out.num_subkeys = talloc_zero(r, uint32_t);
1282 if (r->out.num_subkeys == NULL) {
1283 talloc_free(r);
1284 return false;
1285 }
1286
1287 r->out.max_subkeylen = talloc_zero(r, uint32_t);
1288 if (r->out.max_subkeylen == NULL) {
1289 talloc_free(r);
1290 return false;
1291 }
1292
1293 r->out.max_classlen = talloc_zero(r, uint32_t);
1294 if (r->out.max_classlen == NULL) {
1295 talloc_free(r);
1296 return false;
1297 }
1298
1299 r->out.num_values = talloc_zero(r, uint32_t);
1300 if (r->out.num_values == NULL) {
1301 talloc_free(r);
1302 return false;
1303 }
1304
1305 r->out.max_valnamelen = talloc_zero(r, uint32_t);
1306 if (r->out.max_valnamelen == NULL) {
1307 talloc_free(r);
1308 return false;
1309 }
1310
1311 r->out.max_valbufsize = talloc_zero(r, uint32_t);
1312 if (r->out.max_valbufsize == NULL) {
1313 talloc_free(r);
1314 return false;
1315 }
1316
1317 r->out.secdescsize = talloc_zero(r, uint32_t);
1318 if (r->out.secdescsize == NULL) {
1319 talloc_free(r);
1320 return false;
1321 }
1322
1323 r->out.last_changed_time = talloc_zero(r, NTTIME);
1324 if (r->out.last_changed_time == NULL) {
1325 talloc_free(r);
1326 return false;
1327 }
1328
1329 r->out.result = _winreg_QueryInfoKey(p, r);
1330
1331 if (p->rng_fault_state) {
1332 talloc_free(r);
1333 /* Return true here, srv_pipe_hnd.c will take care */
1334 return true;
1335 }
1336
1337 if (DEBUGLEVEL >= 10) {
1338 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, r);
1339 }
1340
1341 push = ndr_push_init_ctx(r, NULL);
1342 if (push == NULL) {
1343 talloc_free(r);
1344 return false;
1345 }
1346
1347 ndr_err = call->ndr_push(push, NDR_OUT, r);
1348 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1349 talloc_free(r);
1350 return false;
1351 }
1352
1353 blob = ndr_push_blob(push);
1354 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1355 talloc_free(r);
1356 return false;
1357 }
1358
1359 talloc_free(r);
1360
1361 return true;
1362}
1363
1364static bool api_winreg_QueryValue(pipes_struct *p)
1365{
1366 const struct ndr_interface_call *call;
1367 struct ndr_pull *pull;
1368 struct ndr_push *push;
1369 enum ndr_err_code ndr_err;
1370 DATA_BLOB blob;
1371 struct winreg_QueryValue *r;
1372
1373 call = &ndr_table_winreg.calls[NDR_WINREG_QUERYVALUE];
1374
1375 r = talloc(talloc_tos(), struct winreg_QueryValue);
1376 if (r == NULL) {
1377 return false;
1378 }
1379
1380 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1381 talloc_free(r);
1382 return false;
1383 }
1384
1385 pull = ndr_pull_init_blob(&blob, r, NULL);
1386 if (pull == NULL) {
1387 talloc_free(r);
1388 return false;
1389 }
1390
1391 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1392 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1393 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1394 talloc_free(r);
1395 return false;
1396 }
1397
1398 if (DEBUGLEVEL >= 10) {
1399 NDR_PRINT_IN_DEBUG(winreg_QueryValue, r);
1400 }
1401
1402 ZERO_STRUCT(r->out);
1403 r->out.type = r->in.type;
1404 r->out.data = r->in.data;
1405 r->out.data_size = r->in.data_size;
1406 r->out.data_length = r->in.data_length;
1407 r->out.result = _winreg_QueryValue(p, r);
1408
1409 if (p->rng_fault_state) {
1410 talloc_free(r);
1411 /* Return true here, srv_pipe_hnd.c will take care */
1412 return true;
1413 }
1414
1415 if (DEBUGLEVEL >= 10) {
1416 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, r);
1417 }
1418
1419 push = ndr_push_init_ctx(r, NULL);
1420 if (push == NULL) {
1421 talloc_free(r);
1422 return false;
1423 }
1424
1425 ndr_err = call->ndr_push(push, NDR_OUT, r);
1426 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1427 talloc_free(r);
1428 return false;
1429 }
1430
1431 blob = ndr_push_blob(push);
1432 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1433 talloc_free(r);
1434 return false;
1435 }
1436
1437 talloc_free(r);
1438
1439 return true;
1440}
1441
1442static bool api_winreg_ReplaceKey(pipes_struct *p)
1443{
1444 const struct ndr_interface_call *call;
1445 struct ndr_pull *pull;
1446 struct ndr_push *push;
1447 enum ndr_err_code ndr_err;
1448 DATA_BLOB blob;
1449 struct winreg_ReplaceKey *r;
1450
1451 call = &ndr_table_winreg.calls[NDR_WINREG_REPLACEKEY];
1452
1453 r = talloc(talloc_tos(), struct winreg_ReplaceKey);
1454 if (r == NULL) {
1455 return false;
1456 }
1457
1458 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1459 talloc_free(r);
1460 return false;
1461 }
1462
1463 pull = ndr_pull_init_blob(&blob, r, NULL);
1464 if (pull == NULL) {
1465 talloc_free(r);
1466 return false;
1467 }
1468
1469 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1470 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1471 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1472 talloc_free(r);
1473 return false;
1474 }
1475
1476 if (DEBUGLEVEL >= 10) {
1477 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, r);
1478 }
1479
1480 r->out.result = _winreg_ReplaceKey(p, r);
1481
1482 if (p->rng_fault_state) {
1483 talloc_free(r);
1484 /* Return true here, srv_pipe_hnd.c will take care */
1485 return true;
1486 }
1487
1488 if (DEBUGLEVEL >= 10) {
1489 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, r);
1490 }
1491
1492 push = ndr_push_init_ctx(r, NULL);
1493 if (push == NULL) {
1494 talloc_free(r);
1495 return false;
1496 }
1497
1498 ndr_err = call->ndr_push(push, NDR_OUT, r);
1499 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1500 talloc_free(r);
1501 return false;
1502 }
1503
1504 blob = ndr_push_blob(push);
1505 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1506 talloc_free(r);
1507 return false;
1508 }
1509
1510 talloc_free(r);
1511
1512 return true;
1513}
1514
1515static bool api_winreg_RestoreKey(pipes_struct *p)
1516{
1517 const struct ndr_interface_call *call;
1518 struct ndr_pull *pull;
1519 struct ndr_push *push;
1520 enum ndr_err_code ndr_err;
1521 DATA_BLOB blob;
1522 struct winreg_RestoreKey *r;
1523
1524 call = &ndr_table_winreg.calls[NDR_WINREG_RESTOREKEY];
1525
1526 r = talloc(talloc_tos(), struct winreg_RestoreKey);
1527 if (r == NULL) {
1528 return false;
1529 }
1530
1531 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1532 talloc_free(r);
1533 return false;
1534 }
1535
1536 pull = ndr_pull_init_blob(&blob, r, NULL);
1537 if (pull == NULL) {
1538 talloc_free(r);
1539 return false;
1540 }
1541
1542 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1543 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1544 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1545 talloc_free(r);
1546 return false;
1547 }
1548
1549 if (DEBUGLEVEL >= 10) {
1550 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, r);
1551 }
1552
1553 r->out.result = _winreg_RestoreKey(p, r);
1554
1555 if (p->rng_fault_state) {
1556 talloc_free(r);
1557 /* Return true here, srv_pipe_hnd.c will take care */
1558 return true;
1559 }
1560
1561 if (DEBUGLEVEL >= 10) {
1562 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, r);
1563 }
1564
1565 push = ndr_push_init_ctx(r, NULL);
1566 if (push == NULL) {
1567 talloc_free(r);
1568 return false;
1569 }
1570
1571 ndr_err = call->ndr_push(push, NDR_OUT, r);
1572 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1573 talloc_free(r);
1574 return false;
1575 }
1576
1577 blob = ndr_push_blob(push);
1578 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1579 talloc_free(r);
1580 return false;
1581 }
1582
1583 talloc_free(r);
1584
1585 return true;
1586}
1587
1588static bool api_winreg_SaveKey(pipes_struct *p)
1589{
1590 const struct ndr_interface_call *call;
1591 struct ndr_pull *pull;
1592 struct ndr_push *push;
1593 enum ndr_err_code ndr_err;
1594 DATA_BLOB blob;
1595 struct winreg_SaveKey *r;
1596
1597 call = &ndr_table_winreg.calls[NDR_WINREG_SAVEKEY];
1598
1599 r = talloc(talloc_tos(), struct winreg_SaveKey);
1600 if (r == NULL) {
1601 return false;
1602 }
1603
1604 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1605 talloc_free(r);
1606 return false;
1607 }
1608
1609 pull = ndr_pull_init_blob(&blob, r, NULL);
1610 if (pull == NULL) {
1611 talloc_free(r);
1612 return false;
1613 }
1614
1615 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1616 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1617 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1618 talloc_free(r);
1619 return false;
1620 }
1621
1622 if (DEBUGLEVEL >= 10) {
1623 NDR_PRINT_IN_DEBUG(winreg_SaveKey, r);
1624 }
1625
1626 r->out.result = _winreg_SaveKey(p, r);
1627
1628 if (p->rng_fault_state) {
1629 talloc_free(r);
1630 /* Return true here, srv_pipe_hnd.c will take care */
1631 return true;
1632 }
1633
1634 if (DEBUGLEVEL >= 10) {
1635 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, r);
1636 }
1637
1638 push = ndr_push_init_ctx(r, NULL);
1639 if (push == NULL) {
1640 talloc_free(r);
1641 return false;
1642 }
1643
1644 ndr_err = call->ndr_push(push, NDR_OUT, r);
1645 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1646 talloc_free(r);
1647 return false;
1648 }
1649
1650 blob = ndr_push_blob(push);
1651 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1652 talloc_free(r);
1653 return false;
1654 }
1655
1656 talloc_free(r);
1657
1658 return true;
1659}
1660
1661static bool api_winreg_SetKeySecurity(pipes_struct *p)
1662{
1663 const struct ndr_interface_call *call;
1664 struct ndr_pull *pull;
1665 struct ndr_push *push;
1666 enum ndr_err_code ndr_err;
1667 DATA_BLOB blob;
1668 struct winreg_SetKeySecurity *r;
1669
1670 call = &ndr_table_winreg.calls[NDR_WINREG_SETKEYSECURITY];
1671
1672 r = talloc(talloc_tos(), struct winreg_SetKeySecurity);
1673 if (r == NULL) {
1674 return false;
1675 }
1676
1677 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1678 talloc_free(r);
1679 return false;
1680 }
1681
1682 pull = ndr_pull_init_blob(&blob, r, NULL);
1683 if (pull == NULL) {
1684 talloc_free(r);
1685 return false;
1686 }
1687
1688 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1689 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1690 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1691 talloc_free(r);
1692 return false;
1693 }
1694
1695 if (DEBUGLEVEL >= 10) {
1696 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, r);
1697 }
1698
1699 r->out.result = _winreg_SetKeySecurity(p, r);
1700
1701 if (p->rng_fault_state) {
1702 talloc_free(r);
1703 /* Return true here, srv_pipe_hnd.c will take care */
1704 return true;
1705 }
1706
1707 if (DEBUGLEVEL >= 10) {
1708 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, r);
1709 }
1710
1711 push = ndr_push_init_ctx(r, NULL);
1712 if (push == NULL) {
1713 talloc_free(r);
1714 return false;
1715 }
1716
1717 ndr_err = call->ndr_push(push, NDR_OUT, r);
1718 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1719 talloc_free(r);
1720 return false;
1721 }
1722
1723 blob = ndr_push_blob(push);
1724 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1725 talloc_free(r);
1726 return false;
1727 }
1728
1729 talloc_free(r);
1730
1731 return true;
1732}
1733
1734static bool api_winreg_SetValue(pipes_struct *p)
1735{
1736 const struct ndr_interface_call *call;
1737 struct ndr_pull *pull;
1738 struct ndr_push *push;
1739 enum ndr_err_code ndr_err;
1740 DATA_BLOB blob;
1741 struct winreg_SetValue *r;
1742
1743 call = &ndr_table_winreg.calls[NDR_WINREG_SETVALUE];
1744
1745 r = talloc(talloc_tos(), struct winreg_SetValue);
1746 if (r == NULL) {
1747 return false;
1748 }
1749
1750 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1751 talloc_free(r);
1752 return false;
1753 }
1754
1755 pull = ndr_pull_init_blob(&blob, r, NULL);
1756 if (pull == NULL) {
1757 talloc_free(r);
1758 return false;
1759 }
1760
1761 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1762 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1763 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1764 talloc_free(r);
1765 return false;
1766 }
1767
1768 if (DEBUGLEVEL >= 10) {
1769 NDR_PRINT_IN_DEBUG(winreg_SetValue, r);
1770 }
1771
1772 r->out.result = _winreg_SetValue(p, r);
1773
1774 if (p->rng_fault_state) {
1775 talloc_free(r);
1776 /* Return true here, srv_pipe_hnd.c will take care */
1777 return true;
1778 }
1779
1780 if (DEBUGLEVEL >= 10) {
1781 NDR_PRINT_OUT_DEBUG(winreg_SetValue, r);
1782 }
1783
1784 push = ndr_push_init_ctx(r, NULL);
1785 if (push == NULL) {
1786 talloc_free(r);
1787 return false;
1788 }
1789
1790 ndr_err = call->ndr_push(push, NDR_OUT, r);
1791 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1792 talloc_free(r);
1793 return false;
1794 }
1795
1796 blob = ndr_push_blob(push);
1797 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1798 talloc_free(r);
1799 return false;
1800 }
1801
1802 talloc_free(r);
1803
1804 return true;
1805}
1806
1807static bool api_winreg_UnLoadKey(pipes_struct *p)
1808{
1809 const struct ndr_interface_call *call;
1810 struct ndr_pull *pull;
1811 struct ndr_push *push;
1812 enum ndr_err_code ndr_err;
1813 DATA_BLOB blob;
1814 struct winreg_UnLoadKey *r;
1815
1816 call = &ndr_table_winreg.calls[NDR_WINREG_UNLOADKEY];
1817
1818 r = talloc(talloc_tos(), struct winreg_UnLoadKey);
1819 if (r == NULL) {
1820 return false;
1821 }
1822
1823 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1824 talloc_free(r);
1825 return false;
1826 }
1827
1828 pull = ndr_pull_init_blob(&blob, r, NULL);
1829 if (pull == NULL) {
1830 talloc_free(r);
1831 return false;
1832 }
1833
1834 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1835 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1836 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1837 talloc_free(r);
1838 return false;
1839 }
1840
1841 if (DEBUGLEVEL >= 10) {
1842 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, r);
1843 }
1844
1845 r->out.result = _winreg_UnLoadKey(p, r);
1846
1847 if (p->rng_fault_state) {
1848 talloc_free(r);
1849 /* Return true here, srv_pipe_hnd.c will take care */
1850 return true;
1851 }
1852
1853 if (DEBUGLEVEL >= 10) {
1854 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, r);
1855 }
1856
1857 push = ndr_push_init_ctx(r, NULL);
1858 if (push == NULL) {
1859 talloc_free(r);
1860 return false;
1861 }
1862
1863 ndr_err = call->ndr_push(push, NDR_OUT, r);
1864 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1865 talloc_free(r);
1866 return false;
1867 }
1868
1869 blob = ndr_push_blob(push);
1870 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1871 talloc_free(r);
1872 return false;
1873 }
1874
1875 talloc_free(r);
1876
1877 return true;
1878}
1879
1880static bool api_winreg_InitiateSystemShutdown(pipes_struct *p)
1881{
1882 const struct ndr_interface_call *call;
1883 struct ndr_pull *pull;
1884 struct ndr_push *push;
1885 enum ndr_err_code ndr_err;
1886 DATA_BLOB blob;
1887 struct winreg_InitiateSystemShutdown *r;
1888
1889 call = &ndr_table_winreg.calls[NDR_WINREG_INITIATESYSTEMSHUTDOWN];
1890
1891 r = talloc(talloc_tos(), struct winreg_InitiateSystemShutdown);
1892 if (r == NULL) {
1893 return false;
1894 }
1895
1896 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1897 talloc_free(r);
1898 return false;
1899 }
1900
1901 pull = ndr_pull_init_blob(&blob, r, NULL);
1902 if (pull == NULL) {
1903 talloc_free(r);
1904 return false;
1905 }
1906
1907 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1908 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1909 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1910 talloc_free(r);
1911 return false;
1912 }
1913
1914 if (DEBUGLEVEL >= 10) {
1915 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, r);
1916 }
1917
1918 r->out.result = _winreg_InitiateSystemShutdown(p, r);
1919
1920 if (p->rng_fault_state) {
1921 talloc_free(r);
1922 /* Return true here, srv_pipe_hnd.c will take care */
1923 return true;
1924 }
1925
1926 if (DEBUGLEVEL >= 10) {
1927 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, r);
1928 }
1929
1930 push = ndr_push_init_ctx(r, NULL);
1931 if (push == NULL) {
1932 talloc_free(r);
1933 return false;
1934 }
1935
1936 ndr_err = call->ndr_push(push, NDR_OUT, r);
1937 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1938 talloc_free(r);
1939 return false;
1940 }
1941
1942 blob = ndr_push_blob(push);
1943 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1944 talloc_free(r);
1945 return false;
1946 }
1947
1948 talloc_free(r);
1949
1950 return true;
1951}
1952
1953static bool api_winreg_AbortSystemShutdown(pipes_struct *p)
1954{
1955 const struct ndr_interface_call *call;
1956 struct ndr_pull *pull;
1957 struct ndr_push *push;
1958 enum ndr_err_code ndr_err;
1959 DATA_BLOB blob;
1960 struct winreg_AbortSystemShutdown *r;
1961
1962 call = &ndr_table_winreg.calls[NDR_WINREG_ABORTSYSTEMSHUTDOWN];
1963
1964 r = talloc(talloc_tos(), struct winreg_AbortSystemShutdown);
1965 if (r == NULL) {
1966 return false;
1967 }
1968
1969 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1970 talloc_free(r);
1971 return false;
1972 }
1973
1974 pull = ndr_pull_init_blob(&blob, r, NULL);
1975 if (pull == NULL) {
1976 talloc_free(r);
1977 return false;
1978 }
1979
1980 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1981 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1982 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1983 talloc_free(r);
1984 return false;
1985 }
1986
1987 if (DEBUGLEVEL >= 10) {
1988 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, r);
1989 }
1990
1991 r->out.result = _winreg_AbortSystemShutdown(p, r);
1992
1993 if (p->rng_fault_state) {
1994 talloc_free(r);
1995 /* Return true here, srv_pipe_hnd.c will take care */
1996 return true;
1997 }
1998
1999 if (DEBUGLEVEL >= 10) {
2000 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, r);
2001 }
2002
2003 push = ndr_push_init_ctx(r, NULL);
2004 if (push == NULL) {
2005 talloc_free(r);
2006 return false;
2007 }
2008
2009 ndr_err = call->ndr_push(push, NDR_OUT, r);
2010 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2011 talloc_free(r);
2012 return false;
2013 }
2014
2015 blob = ndr_push_blob(push);
2016 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2017 talloc_free(r);
2018 return false;
2019 }
2020
2021 talloc_free(r);
2022
2023 return true;
2024}
2025
2026static bool api_winreg_GetVersion(pipes_struct *p)
2027{
2028 const struct ndr_interface_call *call;
2029 struct ndr_pull *pull;
2030 struct ndr_push *push;
2031 enum ndr_err_code ndr_err;
2032 DATA_BLOB blob;
2033 struct winreg_GetVersion *r;
2034
2035 call = &ndr_table_winreg.calls[NDR_WINREG_GETVERSION];
2036
2037 r = talloc(talloc_tos(), struct winreg_GetVersion);
2038 if (r == NULL) {
2039 return false;
2040 }
2041
2042 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2043 talloc_free(r);
2044 return false;
2045 }
2046
2047 pull = ndr_pull_init_blob(&blob, r, NULL);
2048 if (pull == NULL) {
2049 talloc_free(r);
2050 return false;
2051 }
2052
2053 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2054 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2055 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2056 talloc_free(r);
2057 return false;
2058 }
2059
2060 if (DEBUGLEVEL >= 10) {
2061 NDR_PRINT_IN_DEBUG(winreg_GetVersion, r);
2062 }
2063
2064 ZERO_STRUCT(r->out);
2065 r->out.version = talloc_zero(r, uint32_t);
2066 if (r->out.version == NULL) {
2067 talloc_free(r);
2068 return false;
2069 }
2070
2071 r->out.result = _winreg_GetVersion(p, r);
2072
2073 if (p->rng_fault_state) {
2074 talloc_free(r);
2075 /* Return true here, srv_pipe_hnd.c will take care */
2076 return true;
2077 }
2078
2079 if (DEBUGLEVEL >= 10) {
2080 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, r);
2081 }
2082
2083 push = ndr_push_init_ctx(r, NULL);
2084 if (push == NULL) {
2085 talloc_free(r);
2086 return false;
2087 }
2088
2089 ndr_err = call->ndr_push(push, NDR_OUT, r);
2090 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2091 talloc_free(r);
2092 return false;
2093 }
2094
2095 blob = ndr_push_blob(push);
2096 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2097 talloc_free(r);
2098 return false;
2099 }
2100
2101 talloc_free(r);
2102
2103 return true;
2104}
2105
2106static bool api_winreg_OpenHKCC(pipes_struct *p)
2107{
2108 const struct ndr_interface_call *call;
2109 struct ndr_pull *pull;
2110 struct ndr_push *push;
2111 enum ndr_err_code ndr_err;
2112 DATA_BLOB blob;
2113 struct winreg_OpenHKCC *r;
2114
2115 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKCC];
2116
2117 r = talloc(talloc_tos(), struct winreg_OpenHKCC);
2118 if (r == NULL) {
2119 return false;
2120 }
2121
2122 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2123 talloc_free(r);
2124 return false;
2125 }
2126
2127 pull = ndr_pull_init_blob(&blob, r, NULL);
2128 if (pull == NULL) {
2129 talloc_free(r);
2130 return false;
2131 }
2132
2133 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2134 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2135 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2136 talloc_free(r);
2137 return false;
2138 }
2139
2140 if (DEBUGLEVEL >= 10) {
2141 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, r);
2142 }
2143
2144 ZERO_STRUCT(r->out);
2145 r->out.handle = talloc_zero(r, struct policy_handle);
2146 if (r->out.handle == NULL) {
2147 talloc_free(r);
2148 return false;
2149 }
2150
2151 r->out.result = _winreg_OpenHKCC(p, r);
2152
2153 if (p->rng_fault_state) {
2154 talloc_free(r);
2155 /* Return true here, srv_pipe_hnd.c will take care */
2156 return true;
2157 }
2158
2159 if (DEBUGLEVEL >= 10) {
2160 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, r);
2161 }
2162
2163 push = ndr_push_init_ctx(r, NULL);
2164 if (push == NULL) {
2165 talloc_free(r);
2166 return false;
2167 }
2168
2169 ndr_err = call->ndr_push(push, NDR_OUT, r);
2170 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2171 talloc_free(r);
2172 return false;
2173 }
2174
2175 blob = ndr_push_blob(push);
2176 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2177 talloc_free(r);
2178 return false;
2179 }
2180
2181 talloc_free(r);
2182
2183 return true;
2184}
2185
2186static bool api_winreg_OpenHKDD(pipes_struct *p)
2187{
2188 const struct ndr_interface_call *call;
2189 struct ndr_pull *pull;
2190 struct ndr_push *push;
2191 enum ndr_err_code ndr_err;
2192 DATA_BLOB blob;
2193 struct winreg_OpenHKDD *r;
2194
2195 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKDD];
2196
2197 r = talloc(talloc_tos(), struct winreg_OpenHKDD);
2198 if (r == NULL) {
2199 return false;
2200 }
2201
2202 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2203 talloc_free(r);
2204 return false;
2205 }
2206
2207 pull = ndr_pull_init_blob(&blob, r, NULL);
2208 if (pull == NULL) {
2209 talloc_free(r);
2210 return false;
2211 }
2212
2213 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2214 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2215 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2216 talloc_free(r);
2217 return false;
2218 }
2219
2220 if (DEBUGLEVEL >= 10) {
2221 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, r);
2222 }
2223
2224 ZERO_STRUCT(r->out);
2225 r->out.handle = talloc_zero(r, struct policy_handle);
2226 if (r->out.handle == NULL) {
2227 talloc_free(r);
2228 return false;
2229 }
2230
2231 r->out.result = _winreg_OpenHKDD(p, r);
2232
2233 if (p->rng_fault_state) {
2234 talloc_free(r);
2235 /* Return true here, srv_pipe_hnd.c will take care */
2236 return true;
2237 }
2238
2239 if (DEBUGLEVEL >= 10) {
2240 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, r);
2241 }
2242
2243 push = ndr_push_init_ctx(r, NULL);
2244 if (push == NULL) {
2245 talloc_free(r);
2246 return false;
2247 }
2248
2249 ndr_err = call->ndr_push(push, NDR_OUT, r);
2250 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2251 talloc_free(r);
2252 return false;
2253 }
2254
2255 blob = ndr_push_blob(push);
2256 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2257 talloc_free(r);
2258 return false;
2259 }
2260
2261 talloc_free(r);
2262
2263 return true;
2264}
2265
2266static bool api_winreg_QueryMultipleValues(pipes_struct *p)
2267{
2268 const struct ndr_interface_call *call;
2269 struct ndr_pull *pull;
2270 struct ndr_push *push;
2271 enum ndr_err_code ndr_err;
2272 DATA_BLOB blob;
2273 struct winreg_QueryMultipleValues *r;
2274
2275 call = &ndr_table_winreg.calls[NDR_WINREG_QUERYMULTIPLEVALUES];
2276
2277 r = talloc(talloc_tos(), struct winreg_QueryMultipleValues);
2278 if (r == NULL) {
2279 return false;
2280 }
2281
2282 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2283 talloc_free(r);
2284 return false;
2285 }
2286
2287 pull = ndr_pull_init_blob(&blob, r, NULL);
2288 if (pull == NULL) {
2289 talloc_free(r);
2290 return false;
2291 }
2292
2293 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2294 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2295 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2296 talloc_free(r);
2297 return false;
2298 }
2299
2300 if (DEBUGLEVEL >= 10) {
2301 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, r);
2302 }
2303
2304 ZERO_STRUCT(r->out);
2305 r->out.values = r->in.values;
2306 r->out.buffer = r->in.buffer;
2307 r->out.buffer_size = r->in.buffer_size;
2308 r->out.result = _winreg_QueryMultipleValues(p, r);
2309
2310 if (p->rng_fault_state) {
2311 talloc_free(r);
2312 /* Return true here, srv_pipe_hnd.c will take care */
2313 return true;
2314 }
2315
2316 if (DEBUGLEVEL >= 10) {
2317 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, r);
2318 }
2319
2320 push = ndr_push_init_ctx(r, NULL);
2321 if (push == NULL) {
2322 talloc_free(r);
2323 return false;
2324 }
2325
2326 ndr_err = call->ndr_push(push, NDR_OUT, r);
2327 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2328 talloc_free(r);
2329 return false;
2330 }
2331
2332 blob = ndr_push_blob(push);
2333 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2334 talloc_free(r);
2335 return false;
2336 }
2337
2338 talloc_free(r);
2339
2340 return true;
2341}
2342
2343static bool api_winreg_InitiateSystemShutdownEx(pipes_struct *p)
2344{
2345 const struct ndr_interface_call *call;
2346 struct ndr_pull *pull;
2347 struct ndr_push *push;
2348 enum ndr_err_code ndr_err;
2349 DATA_BLOB blob;
2350 struct winreg_InitiateSystemShutdownEx *r;
2351
2352 call = &ndr_table_winreg.calls[NDR_WINREG_INITIATESYSTEMSHUTDOWNEX];
2353
2354 r = talloc(talloc_tos(), struct winreg_InitiateSystemShutdownEx);
2355 if (r == NULL) {
2356 return false;
2357 }
2358
2359 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2360 talloc_free(r);
2361 return false;
2362 }
2363
2364 pull = ndr_pull_init_blob(&blob, r, NULL);
2365 if (pull == NULL) {
2366 talloc_free(r);
2367 return false;
2368 }
2369
2370 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2371 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2372 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2373 talloc_free(r);
2374 return false;
2375 }
2376
2377 if (DEBUGLEVEL >= 10) {
2378 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, r);
2379 }
2380
2381 r->out.result = _winreg_InitiateSystemShutdownEx(p, r);
2382
2383 if (p->rng_fault_state) {
2384 talloc_free(r);
2385 /* Return true here, srv_pipe_hnd.c will take care */
2386 return true;
2387 }
2388
2389 if (DEBUGLEVEL >= 10) {
2390 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, r);
2391 }
2392
2393 push = ndr_push_init_ctx(r, NULL);
2394 if (push == NULL) {
2395 talloc_free(r);
2396 return false;
2397 }
2398
2399 ndr_err = call->ndr_push(push, NDR_OUT, r);
2400 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2401 talloc_free(r);
2402 return false;
2403 }
2404
2405 blob = ndr_push_blob(push);
2406 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2407 talloc_free(r);
2408 return false;
2409 }
2410
2411 talloc_free(r);
2412
2413 return true;
2414}
2415
2416static bool api_winreg_SaveKeyEx(pipes_struct *p)
2417{
2418 const struct ndr_interface_call *call;
2419 struct ndr_pull *pull;
2420 struct ndr_push *push;
2421 enum ndr_err_code ndr_err;
2422 DATA_BLOB blob;
2423 struct winreg_SaveKeyEx *r;
2424
2425 call = &ndr_table_winreg.calls[NDR_WINREG_SAVEKEYEX];
2426
2427 r = talloc(talloc_tos(), struct winreg_SaveKeyEx);
2428 if (r == NULL) {
2429 return false;
2430 }
2431
2432 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2433 talloc_free(r);
2434 return false;
2435 }
2436
2437 pull = ndr_pull_init_blob(&blob, r, NULL);
2438 if (pull == NULL) {
2439 talloc_free(r);
2440 return false;
2441 }
2442
2443 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2444 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2445 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2446 talloc_free(r);
2447 return false;
2448 }
2449
2450 if (DEBUGLEVEL >= 10) {
2451 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, r);
2452 }
2453
2454 r->out.result = _winreg_SaveKeyEx(p, r);
2455
2456 if (p->rng_fault_state) {
2457 talloc_free(r);
2458 /* Return true here, srv_pipe_hnd.c will take care */
2459 return true;
2460 }
2461
2462 if (DEBUGLEVEL >= 10) {
2463 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, r);
2464 }
2465
2466 push = ndr_push_init_ctx(r, NULL);
2467 if (push == NULL) {
2468 talloc_free(r);
2469 return false;
2470 }
2471
2472 ndr_err = call->ndr_push(push, NDR_OUT, r);
2473 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2474 talloc_free(r);
2475 return false;
2476 }
2477
2478 blob = ndr_push_blob(push);
2479 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2480 talloc_free(r);
2481 return false;
2482 }
2483
2484 talloc_free(r);
2485
2486 return true;
2487}
2488
2489static bool api_winreg_OpenHKPT(pipes_struct *p)
2490{
2491 const struct ndr_interface_call *call;
2492 struct ndr_pull *pull;
2493 struct ndr_push *push;
2494 enum ndr_err_code ndr_err;
2495 DATA_BLOB blob;
2496 struct winreg_OpenHKPT *r;
2497
2498 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPT];
2499
2500 r = talloc(talloc_tos(), struct winreg_OpenHKPT);
2501 if (r == NULL) {
2502 return false;
2503 }
2504
2505 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2506 talloc_free(r);
2507 return false;
2508 }
2509
2510 pull = ndr_pull_init_blob(&blob, r, NULL);
2511 if (pull == NULL) {
2512 talloc_free(r);
2513 return false;
2514 }
2515
2516 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2517 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2518 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2519 talloc_free(r);
2520 return false;
2521 }
2522
2523 if (DEBUGLEVEL >= 10) {
2524 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, r);
2525 }
2526
2527 ZERO_STRUCT(r->out);
2528 r->out.handle = talloc_zero(r, struct policy_handle);
2529 if (r->out.handle == NULL) {
2530 talloc_free(r);
2531 return false;
2532 }
2533
2534 r->out.result = _winreg_OpenHKPT(p, r);
2535
2536 if (p->rng_fault_state) {
2537 talloc_free(r);
2538 /* Return true here, srv_pipe_hnd.c will take care */
2539 return true;
2540 }
2541
2542 if (DEBUGLEVEL >= 10) {
2543 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, r);
2544 }
2545
2546 push = ndr_push_init_ctx(r, NULL);
2547 if (push == NULL) {
2548 talloc_free(r);
2549 return false;
2550 }
2551
2552 ndr_err = call->ndr_push(push, NDR_OUT, r);
2553 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2554 talloc_free(r);
2555 return false;
2556 }
2557
2558 blob = ndr_push_blob(push);
2559 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2560 talloc_free(r);
2561 return false;
2562 }
2563
2564 talloc_free(r);
2565
2566 return true;
2567}
2568
2569static bool api_winreg_OpenHKPN(pipes_struct *p)
2570{
2571 const struct ndr_interface_call *call;
2572 struct ndr_pull *pull;
2573 struct ndr_push *push;
2574 enum ndr_err_code ndr_err;
2575 DATA_BLOB blob;
2576 struct winreg_OpenHKPN *r;
2577
2578 call = &ndr_table_winreg.calls[NDR_WINREG_OPENHKPN];
2579
2580 r = talloc(talloc_tos(), struct winreg_OpenHKPN);
2581 if (r == NULL) {
2582 return false;
2583 }
2584
2585 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2586 talloc_free(r);
2587 return false;
2588 }
2589
2590 pull = ndr_pull_init_blob(&blob, r, NULL);
2591 if (pull == NULL) {
2592 talloc_free(r);
2593 return false;
2594 }
2595
2596 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2597 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2598 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2599 talloc_free(r);
2600 return false;
2601 }
2602
2603 if (DEBUGLEVEL >= 10) {
2604 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, r);
2605 }
2606
2607 ZERO_STRUCT(r->out);
2608 r->out.handle = talloc_zero(r, struct policy_handle);
2609 if (r->out.handle == NULL) {
2610 talloc_free(r);
2611 return false;
2612 }
2613
2614 r->out.result = _winreg_OpenHKPN(p, r);
2615
2616 if (p->rng_fault_state) {
2617 talloc_free(r);
2618 /* Return true here, srv_pipe_hnd.c will take care */
2619 return true;
2620 }
2621
2622 if (DEBUGLEVEL >= 10) {
2623 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, r);
2624 }
2625
2626 push = ndr_push_init_ctx(r, NULL);
2627 if (push == NULL) {
2628 talloc_free(r);
2629 return false;
2630 }
2631
2632 ndr_err = call->ndr_push(push, NDR_OUT, r);
2633 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2634 talloc_free(r);
2635 return false;
2636 }
2637
2638 blob = ndr_push_blob(push);
2639 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2640 talloc_free(r);
2641 return false;
2642 }
2643
2644 talloc_free(r);
2645
2646 return true;
2647}
2648
2649static bool api_winreg_QueryMultipleValues2(pipes_struct *p)
2650{
2651 const struct ndr_interface_call *call;
2652 struct ndr_pull *pull;
2653 struct ndr_push *push;
2654 enum ndr_err_code ndr_err;
2655 DATA_BLOB blob;
2656 struct winreg_QueryMultipleValues2 *r;
2657
2658 call = &ndr_table_winreg.calls[NDR_WINREG_QUERYMULTIPLEVALUES2];
2659
2660 r = talloc(talloc_tos(), struct winreg_QueryMultipleValues2);
2661 if (r == NULL) {
2662 return false;
2663 }
2664
2665 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2666 talloc_free(r);
2667 return false;
2668 }
2669
2670 pull = ndr_pull_init_blob(&blob, r, NULL);
2671 if (pull == NULL) {
2672 talloc_free(r);
2673 return false;
2674 }
2675
2676 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2677 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2678 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2679 talloc_free(r);
2680 return false;
2681 }
2682
2683 if (DEBUGLEVEL >= 10) {
2684 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, r);
2685 }
2686
2687 r->out.result = _winreg_QueryMultipleValues2(p, r);
2688
2689 if (p->rng_fault_state) {
2690 talloc_free(r);
2691 /* Return true here, srv_pipe_hnd.c will take care */
2692 return true;
2693 }
2694
2695 if (DEBUGLEVEL >= 10) {
2696 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, r);
2697 }
2698
2699 push = ndr_push_init_ctx(r, NULL);
2700 if (push == NULL) {
2701 talloc_free(r);
2702 return false;
2703 }
2704
2705 ndr_err = call->ndr_push(push, NDR_OUT, r);
2706 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2707 talloc_free(r);
2708 return false;
2709 }
2710
2711 blob = ndr_push_blob(push);
2712 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2713 talloc_free(r);
2714 return false;
2715 }
2716
2717 talloc_free(r);
2718
2719 return true;
2720}
2721
2722
2723/* Tables */
2724static struct api_struct api_winreg_cmds[] =
2725{
2726 {"WINREG_OPENHKCR", NDR_WINREG_OPENHKCR, api_winreg_OpenHKCR},
2727 {"WINREG_OPENHKCU", NDR_WINREG_OPENHKCU, api_winreg_OpenHKCU},
2728 {"WINREG_OPENHKLM", NDR_WINREG_OPENHKLM, api_winreg_OpenHKLM},
2729 {"WINREG_OPENHKPD", NDR_WINREG_OPENHKPD, api_winreg_OpenHKPD},
2730 {"WINREG_OPENHKU", NDR_WINREG_OPENHKU, api_winreg_OpenHKU},
2731 {"WINREG_CLOSEKEY", NDR_WINREG_CLOSEKEY, api_winreg_CloseKey},
2732 {"WINREG_CREATEKEY", NDR_WINREG_CREATEKEY, api_winreg_CreateKey},
2733 {"WINREG_DELETEKEY", NDR_WINREG_DELETEKEY, api_winreg_DeleteKey},
2734 {"WINREG_DELETEVALUE", NDR_WINREG_DELETEVALUE, api_winreg_DeleteValue},
2735 {"WINREG_ENUMKEY", NDR_WINREG_ENUMKEY, api_winreg_EnumKey},
2736 {"WINREG_ENUMVALUE", NDR_WINREG_ENUMVALUE, api_winreg_EnumValue},
2737 {"WINREG_FLUSHKEY", NDR_WINREG_FLUSHKEY, api_winreg_FlushKey},
2738 {"WINREG_GETKEYSECURITY", NDR_WINREG_GETKEYSECURITY, api_winreg_GetKeySecurity},
2739 {"WINREG_LOADKEY", NDR_WINREG_LOADKEY, api_winreg_LoadKey},
2740 {"WINREG_NOTIFYCHANGEKEYVALUE", NDR_WINREG_NOTIFYCHANGEKEYVALUE, api_winreg_NotifyChangeKeyValue},
2741 {"WINREG_OPENKEY", NDR_WINREG_OPENKEY, api_winreg_OpenKey},
2742 {"WINREG_QUERYINFOKEY", NDR_WINREG_QUERYINFOKEY, api_winreg_QueryInfoKey},
2743 {"WINREG_QUERYVALUE", NDR_WINREG_QUERYVALUE, api_winreg_QueryValue},
2744 {"WINREG_REPLACEKEY", NDR_WINREG_REPLACEKEY, api_winreg_ReplaceKey},
2745 {"WINREG_RESTOREKEY", NDR_WINREG_RESTOREKEY, api_winreg_RestoreKey},
2746 {"WINREG_SAVEKEY", NDR_WINREG_SAVEKEY, api_winreg_SaveKey},
2747 {"WINREG_SETKEYSECURITY", NDR_WINREG_SETKEYSECURITY, api_winreg_SetKeySecurity},
2748 {"WINREG_SETVALUE", NDR_WINREG_SETVALUE, api_winreg_SetValue},
2749 {"WINREG_UNLOADKEY", NDR_WINREG_UNLOADKEY, api_winreg_UnLoadKey},
2750 {"WINREG_INITIATESYSTEMSHUTDOWN", NDR_WINREG_INITIATESYSTEMSHUTDOWN, api_winreg_InitiateSystemShutdown},
2751 {"WINREG_ABORTSYSTEMSHUTDOWN", NDR_WINREG_ABORTSYSTEMSHUTDOWN, api_winreg_AbortSystemShutdown},
2752 {"WINREG_GETVERSION", NDR_WINREG_GETVERSION, api_winreg_GetVersion},
2753 {"WINREG_OPENHKCC", NDR_WINREG_OPENHKCC, api_winreg_OpenHKCC},
2754 {"WINREG_OPENHKDD", NDR_WINREG_OPENHKDD, api_winreg_OpenHKDD},
2755 {"WINREG_QUERYMULTIPLEVALUES", NDR_WINREG_QUERYMULTIPLEVALUES, api_winreg_QueryMultipleValues},
2756 {"WINREG_INITIATESYSTEMSHUTDOWNEX", NDR_WINREG_INITIATESYSTEMSHUTDOWNEX, api_winreg_InitiateSystemShutdownEx},
2757 {"WINREG_SAVEKEYEX", NDR_WINREG_SAVEKEYEX, api_winreg_SaveKeyEx},
2758 {"WINREG_OPENHKPT", NDR_WINREG_OPENHKPT, api_winreg_OpenHKPT},
2759 {"WINREG_OPENHKPN", NDR_WINREG_OPENHKPN, api_winreg_OpenHKPN},
2760 {"WINREG_QUERYMULTIPLEVALUES2", NDR_WINREG_QUERYMULTIPLEVALUES2, api_winreg_QueryMultipleValues2},
2761};
2762
2763void winreg_get_pipe_fns(struct api_struct **fns, int *n_fns)
2764{
2765 *fns = api_winreg_cmds;
2766 *n_fns = sizeof(api_winreg_cmds) / sizeof(struct api_struct);
2767}
2768
2769NTSTATUS rpc_winreg_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
2770{
2771 if (cli->pipes_struct == NULL) {
2772 return NT_STATUS_INVALID_PARAMETER;
2773 }
2774
2775 switch (opnum)
2776 {
2777 case NDR_WINREG_OPENHKCR: {
2778 struct winreg_OpenHKCR *r = (struct winreg_OpenHKCR *)_r;
2779 ZERO_STRUCT(r->out);
2780 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2781 if (r->out.handle == NULL) {
2782 return NT_STATUS_NO_MEMORY;
2783 }
2784
2785 r->out.result = _winreg_OpenHKCR(cli->pipes_struct, r);
2786 return NT_STATUS_OK;
2787 }
2788
2789 case NDR_WINREG_OPENHKCU: {
2790 struct winreg_OpenHKCU *r = (struct winreg_OpenHKCU *)_r;
2791 ZERO_STRUCT(r->out);
2792 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2793 if (r->out.handle == NULL) {
2794 return NT_STATUS_NO_MEMORY;
2795 }
2796
2797 r->out.result = _winreg_OpenHKCU(cli->pipes_struct, r);
2798 return NT_STATUS_OK;
2799 }
2800
2801 case NDR_WINREG_OPENHKLM: {
2802 struct winreg_OpenHKLM *r = (struct winreg_OpenHKLM *)_r;
2803 ZERO_STRUCT(r->out);
2804 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2805 if (r->out.handle == NULL) {
2806 return NT_STATUS_NO_MEMORY;
2807 }
2808
2809 r->out.result = _winreg_OpenHKLM(cli->pipes_struct, r);
2810 return NT_STATUS_OK;
2811 }
2812
2813 case NDR_WINREG_OPENHKPD: {
2814 struct winreg_OpenHKPD *r = (struct winreg_OpenHKPD *)_r;
2815 ZERO_STRUCT(r->out);
2816 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2817 if (r->out.handle == NULL) {
2818 return NT_STATUS_NO_MEMORY;
2819 }
2820
2821 r->out.result = _winreg_OpenHKPD(cli->pipes_struct, r);
2822 return NT_STATUS_OK;
2823 }
2824
2825 case NDR_WINREG_OPENHKU: {
2826 struct winreg_OpenHKU *r = (struct winreg_OpenHKU *)_r;
2827 ZERO_STRUCT(r->out);
2828 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2829 if (r->out.handle == NULL) {
2830 return NT_STATUS_NO_MEMORY;
2831 }
2832
2833 r->out.result = _winreg_OpenHKU(cli->pipes_struct, r);
2834 return NT_STATUS_OK;
2835 }
2836
2837 case NDR_WINREG_CLOSEKEY: {
2838 struct winreg_CloseKey *r = (struct winreg_CloseKey *)_r;
2839 ZERO_STRUCT(r->out);
2840 r->out.handle = r->in.handle;
2841 r->out.result = _winreg_CloseKey(cli->pipes_struct, r);
2842 return NT_STATUS_OK;
2843 }
2844
2845 case NDR_WINREG_CREATEKEY: {
2846 struct winreg_CreateKey *r = (struct winreg_CreateKey *)_r;
2847 ZERO_STRUCT(r->out);
2848 r->out.action_taken = r->in.action_taken;
2849 r->out.new_handle = talloc_zero(mem_ctx, struct policy_handle);
2850 if (r->out.new_handle == NULL) {
2851 return NT_STATUS_NO_MEMORY;
2852 }
2853
2854 r->out.result = _winreg_CreateKey(cli->pipes_struct, r);
2855 return NT_STATUS_OK;
2856 }
2857
2858 case NDR_WINREG_DELETEKEY: {
2859 struct winreg_DeleteKey *r = (struct winreg_DeleteKey *)_r;
2860 r->out.result = _winreg_DeleteKey(cli->pipes_struct, r);
2861 return NT_STATUS_OK;
2862 }
2863
2864 case NDR_WINREG_DELETEVALUE: {
2865 struct winreg_DeleteValue *r = (struct winreg_DeleteValue *)_r;
2866 r->out.result = _winreg_DeleteValue(cli->pipes_struct, r);
2867 return NT_STATUS_OK;
2868 }
2869
2870 case NDR_WINREG_ENUMKEY: {
2871 struct winreg_EnumKey *r = (struct winreg_EnumKey *)_r;
2872 ZERO_STRUCT(r->out);
2873 r->out.name = r->in.name;
2874 r->out.keyclass = r->in.keyclass;
2875 r->out.last_changed_time = r->in.last_changed_time;
2876 r->out.result = _winreg_EnumKey(cli->pipes_struct, r);
2877 return NT_STATUS_OK;
2878 }
2879
2880 case NDR_WINREG_ENUMVALUE: {
2881 struct winreg_EnumValue *r = (struct winreg_EnumValue *)_r;
2882 ZERO_STRUCT(r->out);
2883 r->out.name = r->in.name;
2884 r->out.type = r->in.type;
2885 r->out.value = r->in.value;
2886 r->out.size = r->in.size;
2887 r->out.length = r->in.length;
2888 r->out.result = _winreg_EnumValue(cli->pipes_struct, r);
2889 return NT_STATUS_OK;
2890 }
2891
2892 case NDR_WINREG_FLUSHKEY: {
2893 struct winreg_FlushKey *r = (struct winreg_FlushKey *)_r;
2894 r->out.result = _winreg_FlushKey(cli->pipes_struct, r);
2895 return NT_STATUS_OK;
2896 }
2897
2898 case NDR_WINREG_GETKEYSECURITY: {
2899 struct winreg_GetKeySecurity *r = (struct winreg_GetKeySecurity *)_r;
2900 ZERO_STRUCT(r->out);
2901 r->out.sd = r->in.sd;
2902 r->out.result = _winreg_GetKeySecurity(cli->pipes_struct, r);
2903 return NT_STATUS_OK;
2904 }
2905
2906 case NDR_WINREG_LOADKEY: {
2907 struct winreg_LoadKey *r = (struct winreg_LoadKey *)_r;
2908 r->out.result = _winreg_LoadKey(cli->pipes_struct, r);
2909 return NT_STATUS_OK;
2910 }
2911
2912 case NDR_WINREG_NOTIFYCHANGEKEYVALUE: {
2913 struct winreg_NotifyChangeKeyValue *r = (struct winreg_NotifyChangeKeyValue *)_r;
2914 r->out.result = _winreg_NotifyChangeKeyValue(cli->pipes_struct, r);
2915 return NT_STATUS_OK;
2916 }
2917
2918 case NDR_WINREG_OPENKEY: {
2919 struct winreg_OpenKey *r = (struct winreg_OpenKey *)_r;
2920 ZERO_STRUCT(r->out);
2921 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2922 if (r->out.handle == NULL) {
2923 return NT_STATUS_NO_MEMORY;
2924 }
2925
2926 r->out.result = _winreg_OpenKey(cli->pipes_struct, r);
2927 return NT_STATUS_OK;
2928 }
2929
2930 case NDR_WINREG_QUERYINFOKEY: {
2931 struct winreg_QueryInfoKey *r = (struct winreg_QueryInfoKey *)_r;
2932 ZERO_STRUCT(r->out);
2933 r->out.classname = r->in.classname;
2934 r->out.num_subkeys = talloc_zero(mem_ctx, uint32_t);
2935 if (r->out.num_subkeys == NULL) {
2936 return NT_STATUS_NO_MEMORY;
2937 }
2938
2939 r->out.max_subkeylen = talloc_zero(mem_ctx, uint32_t);
2940 if (r->out.max_subkeylen == NULL) {
2941 return NT_STATUS_NO_MEMORY;
2942 }
2943
2944 r->out.max_classlen = talloc_zero(mem_ctx, uint32_t);
2945 if (r->out.max_classlen == NULL) {
2946 return NT_STATUS_NO_MEMORY;
2947 }
2948
2949 r->out.num_values = talloc_zero(mem_ctx, uint32_t);
2950 if (r->out.num_values == NULL) {
2951 return NT_STATUS_NO_MEMORY;
2952 }
2953
2954 r->out.max_valnamelen = talloc_zero(mem_ctx, uint32_t);
2955 if (r->out.max_valnamelen == NULL) {
2956 return NT_STATUS_NO_MEMORY;
2957 }
2958
2959 r->out.max_valbufsize = talloc_zero(mem_ctx, uint32_t);
2960 if (r->out.max_valbufsize == NULL) {
2961 return NT_STATUS_NO_MEMORY;
2962 }
2963
2964 r->out.secdescsize = talloc_zero(mem_ctx, uint32_t);
2965 if (r->out.secdescsize == NULL) {
2966 return NT_STATUS_NO_MEMORY;
2967 }
2968
2969 r->out.last_changed_time = talloc_zero(mem_ctx, NTTIME);
2970 if (r->out.last_changed_time == NULL) {
2971 return NT_STATUS_NO_MEMORY;
2972 }
2973
2974 r->out.result = _winreg_QueryInfoKey(cli->pipes_struct, r);
2975 return NT_STATUS_OK;
2976 }
2977
2978 case NDR_WINREG_QUERYVALUE: {
2979 struct winreg_QueryValue *r = (struct winreg_QueryValue *)_r;
2980 ZERO_STRUCT(r->out);
2981 r->out.type = r->in.type;
2982 r->out.data = r->in.data;
2983 r->out.data_size = r->in.data_size;
2984 r->out.data_length = r->in.data_length;
2985 r->out.result = _winreg_QueryValue(cli->pipes_struct, r);
2986 return NT_STATUS_OK;
2987 }
2988
2989 case NDR_WINREG_REPLACEKEY: {
2990 struct winreg_ReplaceKey *r = (struct winreg_ReplaceKey *)_r;
2991 r->out.result = _winreg_ReplaceKey(cli->pipes_struct, r);
2992 return NT_STATUS_OK;
2993 }
2994
2995 case NDR_WINREG_RESTOREKEY: {
2996 struct winreg_RestoreKey *r = (struct winreg_RestoreKey *)_r;
2997 r->out.result = _winreg_RestoreKey(cli->pipes_struct, r);
2998 return NT_STATUS_OK;
2999 }
3000
3001 case NDR_WINREG_SAVEKEY: {
3002 struct winreg_SaveKey *r = (struct winreg_SaveKey *)_r;
3003 r->out.result = _winreg_SaveKey(cli->pipes_struct, r);
3004 return NT_STATUS_OK;
3005 }
3006
3007 case NDR_WINREG_SETKEYSECURITY: {
3008 struct winreg_SetKeySecurity *r = (struct winreg_SetKeySecurity *)_r;
3009 r->out.result = _winreg_SetKeySecurity(cli->pipes_struct, r);
3010 return NT_STATUS_OK;
3011 }
3012
3013 case NDR_WINREG_SETVALUE: {
3014 struct winreg_SetValue *r = (struct winreg_SetValue *)_r;
3015 r->out.result = _winreg_SetValue(cli->pipes_struct, r);
3016 return NT_STATUS_OK;
3017 }
3018
3019 case NDR_WINREG_UNLOADKEY: {
3020 struct winreg_UnLoadKey *r = (struct winreg_UnLoadKey *)_r;
3021 r->out.result = _winreg_UnLoadKey(cli->pipes_struct, r);
3022 return NT_STATUS_OK;
3023 }
3024
3025 case NDR_WINREG_INITIATESYSTEMSHUTDOWN: {
3026 struct winreg_InitiateSystemShutdown *r = (struct winreg_InitiateSystemShutdown *)_r;
3027 r->out.result = _winreg_InitiateSystemShutdown(cli->pipes_struct, r);
3028 return NT_STATUS_OK;
3029 }
3030
3031 case NDR_WINREG_ABORTSYSTEMSHUTDOWN: {
3032 struct winreg_AbortSystemShutdown *r = (struct winreg_AbortSystemShutdown *)_r;
3033 r->out.result = _winreg_AbortSystemShutdown(cli->pipes_struct, r);
3034 return NT_STATUS_OK;
3035 }
3036
3037 case NDR_WINREG_GETVERSION: {
3038 struct winreg_GetVersion *r = (struct winreg_GetVersion *)_r;
3039 ZERO_STRUCT(r->out);
3040 r->out.version = talloc_zero(mem_ctx, uint32_t);
3041 if (r->out.version == NULL) {
3042 return NT_STATUS_NO_MEMORY;
3043 }
3044
3045 r->out.result = _winreg_GetVersion(cli->pipes_struct, r);
3046 return NT_STATUS_OK;
3047 }
3048
3049 case NDR_WINREG_OPENHKCC: {
3050 struct winreg_OpenHKCC *r = (struct winreg_OpenHKCC *)_r;
3051 ZERO_STRUCT(r->out);
3052 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3053 if (r->out.handle == NULL) {
3054 return NT_STATUS_NO_MEMORY;
3055 }
3056
3057 r->out.result = _winreg_OpenHKCC(cli->pipes_struct, r);
3058 return NT_STATUS_OK;
3059 }
3060
3061 case NDR_WINREG_OPENHKDD: {
3062 struct winreg_OpenHKDD *r = (struct winreg_OpenHKDD *)_r;
3063 ZERO_STRUCT(r->out);
3064 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3065 if (r->out.handle == NULL) {
3066 return NT_STATUS_NO_MEMORY;
3067 }
3068
3069 r->out.result = _winreg_OpenHKDD(cli->pipes_struct, r);
3070 return NT_STATUS_OK;
3071 }
3072
3073 case NDR_WINREG_QUERYMULTIPLEVALUES: {
3074 struct winreg_QueryMultipleValues *r = (struct winreg_QueryMultipleValues *)_r;
3075 ZERO_STRUCT(r->out);
3076 r->out.values = r->in.values;
3077 r->out.buffer = r->in.buffer;
3078 r->out.buffer_size = r->in.buffer_size;
3079 r->out.result = _winreg_QueryMultipleValues(cli->pipes_struct, r);
3080 return NT_STATUS_OK;
3081 }
3082
3083 case NDR_WINREG_INITIATESYSTEMSHUTDOWNEX: {
3084 struct winreg_InitiateSystemShutdownEx *r = (struct winreg_InitiateSystemShutdownEx *)_r;
3085 r->out.result = _winreg_InitiateSystemShutdownEx(cli->pipes_struct, r);
3086 return NT_STATUS_OK;
3087 }
3088
3089 case NDR_WINREG_SAVEKEYEX: {
3090 struct winreg_SaveKeyEx *r = (struct winreg_SaveKeyEx *)_r;
3091 r->out.result = _winreg_SaveKeyEx(cli->pipes_struct, r);
3092 return NT_STATUS_OK;
3093 }
3094
3095 case NDR_WINREG_OPENHKPT: {
3096 struct winreg_OpenHKPT *r = (struct winreg_OpenHKPT *)_r;
3097 ZERO_STRUCT(r->out);
3098 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3099 if (r->out.handle == NULL) {
3100 return NT_STATUS_NO_MEMORY;
3101 }
3102
3103 r->out.result = _winreg_OpenHKPT(cli->pipes_struct, r);
3104 return NT_STATUS_OK;
3105 }
3106
3107 case NDR_WINREG_OPENHKPN: {
3108 struct winreg_OpenHKPN *r = (struct winreg_OpenHKPN *)_r;
3109 ZERO_STRUCT(r->out);
3110 r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
3111 if (r->out.handle == NULL) {
3112 return NT_STATUS_NO_MEMORY;
3113 }
3114
3115 r->out.result = _winreg_OpenHKPN(cli->pipes_struct, r);
3116 return NT_STATUS_OK;
3117 }
3118
3119 case NDR_WINREG_QUERYMULTIPLEVALUES2: {
3120 struct winreg_QueryMultipleValues2 *r = (struct winreg_QueryMultipleValues2 *)_r;
3121 r->out.result = _winreg_QueryMultipleValues2(cli->pipes_struct, r);
3122 return NT_STATUS_OK;
3123 }
3124
3125 default:
3126 return NT_STATUS_NOT_IMPLEMENTED;
3127 }
3128}
3129
3130NTSTATUS rpc_winreg_init(void)
3131{
3132 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", &ndr_table_winreg, api_winreg_cmds, sizeof(api_winreg_cmds) / sizeof(struct api_struct));
3133}
Note: See TracBrowser for help on using the repository browser.