2162306322ac10f96ae8b7960846a3b019f4a95c
[samba.git] / source3 / librpc / gen_ndr / srv_winreg.c
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
9 static 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);
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
89 static 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);
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
169 static 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);
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
249 static 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);
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
329 static 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);
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
409 static 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);
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
484 static 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.new_handle = talloc_zero(r, struct policy_handle);
524         if (r->out.new_handle == NULL) {
525                 talloc_free(r);
526                 return false;
527         }
528
529         r->out.action_taken = r->in.action_taken;
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);
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
565 static 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);
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
638 static 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);
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
711 static 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);
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
788 static 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);
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
867 static 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);
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
940 static 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);
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
1015 static 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);
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
1088 static 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);
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
1161 static 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);
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
1241 static 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);
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
1364 static 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.value_length = r->in.value_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);
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
1442 static 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);
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
1515 static 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);
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
1588 static 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);
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
1661 static 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);
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
1734 static 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);
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
1807 static 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);
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
1880 static 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);
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
1953 static 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);
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
2026 static 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);
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
2106 static 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);
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
2186 static 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);
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
2266 static 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);
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
2343 static 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);
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
2416 static 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);
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
2489 static 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);
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
2569 static 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);
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
2649 static 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);
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 */
2724 static 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
2763 void 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
2769 NTSTATUS rpc_winreg_init(void)
2770 {
2771         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", &ndr_table_winreg.syntax_id, api_winreg_cmds, sizeof(api_winreg_cmds) / sizeof(struct api_struct));
2772 }