Fix various build warnings
[ira/wip.git] / source3 / librpc / gen_ndr / cli_winreg.c
1 /*
2  * Unix SMB/CIFS implementation.
3  * client auto-generated by pidl. DO NOT MODIFY!
4  */
5
6 #include "includes.h"
7 #include "librpc/gen_ndr/cli_winreg.h"
8
9 NTSTATUS rpccli_winreg_OpenHKCR(struct rpc_pipe_client *cli,
10                                 TALLOC_CTX *mem_ctx,
11                                 uint16_t *system_name /* [in] [unique] */,
12                                 uint32_t access_mask /* [in]  */,
13                                 struct policy_handle *handle /* [out] [ref] */,
14                                 WERROR *werror)
15 {
16         struct winreg_OpenHKCR r;
17         NTSTATUS status;
18
19         /* In parameters */
20         r.in.system_name = system_name;
21         r.in.access_mask = access_mask;
22
23         if (DEBUGLEVEL >= 10) {
24                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &r);
25         }
26
27         status = cli_do_rpc_ndr(cli,
28                                 mem_ctx,
29                                 &ndr_table_winreg,
30                                 NDR_WINREG_OPENHKCR,
31                                 &r);
32
33         if (!NT_STATUS_IS_OK(status)) {
34                 return status;
35         }
36
37         if (DEBUGLEVEL >= 10) {
38                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
39         }
40
41         if (NT_STATUS_IS_ERR(status)) {
42                 return status;
43         }
44
45         /* Return variables */
46         *handle = *r.out.handle;
47
48         /* Return result */
49         if (werror) {
50                 *werror = r.out.result;
51         }
52
53         return werror_to_ntstatus(r.out.result);
54 }
55
56 NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli,
57                                 TALLOC_CTX *mem_ctx,
58                                 uint16_t *system_name /* [in] [unique] */,
59                                 uint32_t access_mask /* [in]  */,
60                                 struct policy_handle *handle /* [out] [ref] */,
61                                 WERROR *werror)
62 {
63         struct winreg_OpenHKCU r;
64         NTSTATUS status;
65
66         /* In parameters */
67         r.in.system_name = system_name;
68         r.in.access_mask = access_mask;
69
70         if (DEBUGLEVEL >= 10) {
71                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &r);
72         }
73
74         status = cli_do_rpc_ndr(cli,
75                                 mem_ctx,
76                                 &ndr_table_winreg,
77                                 NDR_WINREG_OPENHKCU,
78                                 &r);
79
80         if (!NT_STATUS_IS_OK(status)) {
81                 return status;
82         }
83
84         if (DEBUGLEVEL >= 10) {
85                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
86         }
87
88         if (NT_STATUS_IS_ERR(status)) {
89                 return status;
90         }
91
92         /* Return variables */
93         *handle = *r.out.handle;
94
95         /* Return result */
96         if (werror) {
97                 *werror = r.out.result;
98         }
99
100         return werror_to_ntstatus(r.out.result);
101 }
102
103 NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli,
104                                 TALLOC_CTX *mem_ctx,
105                                 uint16_t *system_name /* [in] [unique] */,
106                                 uint32_t access_mask /* [in]  */,
107                                 struct policy_handle *handle /* [out] [ref] */,
108                                 WERROR *werror)
109 {
110         struct winreg_OpenHKLM r;
111         NTSTATUS status;
112
113         /* In parameters */
114         r.in.system_name = system_name;
115         r.in.access_mask = access_mask;
116
117         if (DEBUGLEVEL >= 10) {
118                 NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &r);
119         }
120
121         status = cli_do_rpc_ndr(cli,
122                                 mem_ctx,
123                                 &ndr_table_winreg,
124                                 NDR_WINREG_OPENHKLM,
125                                 &r);
126
127         if (!NT_STATUS_IS_OK(status)) {
128                 return status;
129         }
130
131         if (DEBUGLEVEL >= 10) {
132                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
133         }
134
135         if (NT_STATUS_IS_ERR(status)) {
136                 return status;
137         }
138
139         /* Return variables */
140         *handle = *r.out.handle;
141
142         /* Return result */
143         if (werror) {
144                 *werror = r.out.result;
145         }
146
147         return werror_to_ntstatus(r.out.result);
148 }
149
150 NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli,
151                                 TALLOC_CTX *mem_ctx,
152                                 uint16_t *system_name /* [in] [unique] */,
153                                 uint32_t access_mask /* [in]  */,
154                                 struct policy_handle *handle /* [out] [ref] */,
155                                 WERROR *werror)
156 {
157         struct winreg_OpenHKPD r;
158         NTSTATUS status;
159
160         /* In parameters */
161         r.in.system_name = system_name;
162         r.in.access_mask = access_mask;
163
164         if (DEBUGLEVEL >= 10) {
165                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &r);
166         }
167
168         status = cli_do_rpc_ndr(cli,
169                                 mem_ctx,
170                                 &ndr_table_winreg,
171                                 NDR_WINREG_OPENHKPD,
172                                 &r);
173
174         if (!NT_STATUS_IS_OK(status)) {
175                 return status;
176         }
177
178         if (DEBUGLEVEL >= 10) {
179                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
180         }
181
182         if (NT_STATUS_IS_ERR(status)) {
183                 return status;
184         }
185
186         /* Return variables */
187         *handle = *r.out.handle;
188
189         /* Return result */
190         if (werror) {
191                 *werror = r.out.result;
192         }
193
194         return werror_to_ntstatus(r.out.result);
195 }
196
197 NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli,
198                                TALLOC_CTX *mem_ctx,
199                                uint16_t *system_name /* [in] [unique] */,
200                                uint32_t access_mask /* [in]  */,
201                                struct policy_handle *handle /* [out] [ref] */,
202                                WERROR *werror)
203 {
204         struct winreg_OpenHKU r;
205         NTSTATUS status;
206
207         /* In parameters */
208         r.in.system_name = system_name;
209         r.in.access_mask = access_mask;
210
211         if (DEBUGLEVEL >= 10) {
212                 NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &r);
213         }
214
215         status = cli_do_rpc_ndr(cli,
216                                 mem_ctx,
217                                 &ndr_table_winreg,
218                                 NDR_WINREG_OPENHKU,
219                                 &r);
220
221         if (!NT_STATUS_IS_OK(status)) {
222                 return status;
223         }
224
225         if (DEBUGLEVEL >= 10) {
226                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
227         }
228
229         if (NT_STATUS_IS_ERR(status)) {
230                 return status;
231         }
232
233         /* Return variables */
234         *handle = *r.out.handle;
235
236         /* Return result */
237         if (werror) {
238                 *werror = r.out.result;
239         }
240
241         return werror_to_ntstatus(r.out.result);
242 }
243
244 NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli,
245                                 TALLOC_CTX *mem_ctx,
246                                 struct policy_handle *handle /* [in,out] [ref] */,
247                                 WERROR *werror)
248 {
249         struct winreg_CloseKey r;
250         NTSTATUS status;
251
252         /* In parameters */
253         r.in.handle = handle;
254
255         if (DEBUGLEVEL >= 10) {
256                 NDR_PRINT_IN_DEBUG(winreg_CloseKey, &r);
257         }
258
259         status = cli_do_rpc_ndr(cli,
260                                 mem_ctx,
261                                 &ndr_table_winreg,
262                                 NDR_WINREG_CLOSEKEY,
263                                 &r);
264
265         if (!NT_STATUS_IS_OK(status)) {
266                 return status;
267         }
268
269         if (DEBUGLEVEL >= 10) {
270                 NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
271         }
272
273         if (NT_STATUS_IS_ERR(status)) {
274                 return status;
275         }
276
277         /* Return variables */
278         *handle = *r.out.handle;
279
280         /* Return result */
281         if (werror) {
282                 *werror = r.out.result;
283         }
284
285         return werror_to_ntstatus(r.out.result);
286 }
287
288 NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,
289                                  TALLOC_CTX *mem_ctx,
290                                  struct policy_handle *handle /* [in] [ref] */,
291                                  struct winreg_String name /* [in]  */,
292                                  struct winreg_String keyclass /* [in]  */,
293                                  uint32_t options /* [in]  */,
294                                  uint32_t access_mask /* [in]  */,
295                                  struct winreg_SecBuf *secdesc /* [in] [unique] */,
296                                  struct policy_handle *new_handle /* [out] [ref] */,
297                                  enum winreg_CreateAction *action_taken /* [in,out] [unique] */,
298                                  WERROR *werror)
299 {
300         struct winreg_CreateKey r;
301         NTSTATUS status;
302
303         /* In parameters */
304         r.in.handle = handle;
305         r.in.name = name;
306         r.in.keyclass = keyclass;
307         r.in.options = options;
308         r.in.access_mask = access_mask;
309         r.in.secdesc = secdesc;
310         r.in.action_taken = action_taken;
311
312         if (DEBUGLEVEL >= 10) {
313                 NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);
314         }
315
316         status = cli_do_rpc_ndr(cli,
317                                 mem_ctx,
318                                 &ndr_table_winreg,
319                                 NDR_WINREG_CREATEKEY,
320                                 &r);
321
322         if (!NT_STATUS_IS_OK(status)) {
323                 return status;
324         }
325
326         if (DEBUGLEVEL >= 10) {
327                 NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
328         }
329
330         if (NT_STATUS_IS_ERR(status)) {
331                 return status;
332         }
333
334         /* Return variables */
335         *new_handle = *r.out.new_handle;
336         if (action_taken && r.out.action_taken) {
337                 *action_taken = *r.out.action_taken;
338         }
339
340         /* Return result */
341         if (werror) {
342                 *werror = r.out.result;
343         }
344
345         return werror_to_ntstatus(r.out.result);
346 }
347
348 NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli,
349                                  TALLOC_CTX *mem_ctx,
350                                  struct policy_handle *handle /* [in] [ref] */,
351                                  struct winreg_String key /* [in]  */,
352                                  WERROR *werror)
353 {
354         struct winreg_DeleteKey r;
355         NTSTATUS status;
356
357         /* In parameters */
358         r.in.handle = handle;
359         r.in.key = key;
360
361         if (DEBUGLEVEL >= 10) {
362                 NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
363         }
364
365         status = cli_do_rpc_ndr(cli,
366                                 mem_ctx,
367                                 &ndr_table_winreg,
368                                 NDR_WINREG_DELETEKEY,
369                                 &r);
370
371         if (!NT_STATUS_IS_OK(status)) {
372                 return status;
373         }
374
375         if (DEBUGLEVEL >= 10) {
376                 NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
377         }
378
379         if (NT_STATUS_IS_ERR(status)) {
380                 return status;
381         }
382
383         /* Return variables */
384
385         /* Return result */
386         if (werror) {
387                 *werror = r.out.result;
388         }
389
390         return werror_to_ntstatus(r.out.result);
391 }
392
393 NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli,
394                                    TALLOC_CTX *mem_ctx,
395                                    struct policy_handle *handle /* [in] [ref] */,
396                                    struct winreg_String value /* [in]  */,
397                                    WERROR *werror)
398 {
399         struct winreg_DeleteValue r;
400         NTSTATUS status;
401
402         /* In parameters */
403         r.in.handle = handle;
404         r.in.value = value;
405
406         if (DEBUGLEVEL >= 10) {
407                 NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
408         }
409
410         status = cli_do_rpc_ndr(cli,
411                                 mem_ctx,
412                                 &ndr_table_winreg,
413                                 NDR_WINREG_DELETEVALUE,
414                                 &r);
415
416         if (!NT_STATUS_IS_OK(status)) {
417                 return status;
418         }
419
420         if (DEBUGLEVEL >= 10) {
421                 NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
422         }
423
424         if (NT_STATUS_IS_ERR(status)) {
425                 return status;
426         }
427
428         /* Return variables */
429
430         /* Return result */
431         if (werror) {
432                 *werror = r.out.result;
433         }
434
435         return werror_to_ntstatus(r.out.result);
436 }
437
438 NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,
439                                TALLOC_CTX *mem_ctx,
440                                struct policy_handle *handle /* [in] [ref] */,
441                                uint32_t enum_index /* [in]  */,
442                                struct winreg_StringBuf *name /* [in,out] [ref] */,
443                                struct winreg_StringBuf *keyclass /* [in,out] [unique] */,
444                                NTTIME *last_changed_time /* [in,out] [unique] */,
445                                WERROR *werror)
446 {
447         struct winreg_EnumKey r;
448         NTSTATUS status;
449
450         /* In parameters */
451         r.in.handle = handle;
452         r.in.enum_index = enum_index;
453         r.in.name = name;
454         r.in.keyclass = keyclass;
455         r.in.last_changed_time = last_changed_time;
456
457         if (DEBUGLEVEL >= 10) {
458                 NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);
459         }
460
461         status = cli_do_rpc_ndr(cli,
462                                 mem_ctx,
463                                 &ndr_table_winreg,
464                                 NDR_WINREG_ENUMKEY,
465                                 &r);
466
467         if (!NT_STATUS_IS_OK(status)) {
468                 return status;
469         }
470
471         if (DEBUGLEVEL >= 10) {
472                 NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
473         }
474
475         if (NT_STATUS_IS_ERR(status)) {
476                 return status;
477         }
478
479         /* Return variables */
480         *name = *r.out.name;
481         if (keyclass && r.out.keyclass) {
482                 *keyclass = *r.out.keyclass;
483         }
484         if (last_changed_time && r.out.last_changed_time) {
485                 *last_changed_time = *r.out.last_changed_time;
486         }
487
488         /* Return result */
489         if (werror) {
490                 *werror = r.out.result;
491         }
492
493         return werror_to_ntstatus(r.out.result);
494 }
495
496 NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli,
497                                  TALLOC_CTX *mem_ctx,
498                                  struct policy_handle *handle /* [in] [ref] */,
499                                  uint32_t enum_index /* [in]  */,
500                                  struct winreg_ValNameBuf *name /* [in,out] [ref] */,
501                                  enum winreg_Type *type /* [in,out] [unique] */,
502                                  uint8_t *value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
503                                  uint32_t *size /* [in,out] [unique] */,
504                                  uint32_t *length /* [in,out] [unique] */,
505                                  WERROR *werror)
506 {
507         struct winreg_EnumValue r;
508         NTSTATUS status;
509
510         /* In parameters */
511         r.in.handle = handle;
512         r.in.enum_index = enum_index;
513         r.in.name = name;
514         r.in.type = type;
515         r.in.value = value;
516         r.in.size = size;
517         r.in.length = length;
518
519         if (DEBUGLEVEL >= 10) {
520                 NDR_PRINT_IN_DEBUG(winreg_EnumValue, &r);
521         }
522
523         status = cli_do_rpc_ndr(cli,
524                                 mem_ctx,
525                                 &ndr_table_winreg,
526                                 NDR_WINREG_ENUMVALUE,
527                                 &r);
528
529         if (!NT_STATUS_IS_OK(status)) {
530                 return status;
531         }
532
533         if (DEBUGLEVEL >= 10) {
534                 NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
535         }
536
537         if (NT_STATUS_IS_ERR(status)) {
538                 return status;
539         }
540
541         /* Return variables */
542         *name = *r.out.name;
543         if (type && r.out.type) {
544                 *type = *r.out.type;
545         }
546         if (value && r.out.value) {
547                 memcpy(value, r.out.value, *r.in.size * sizeof(*value));
548         }
549         if (size && r.out.size) {
550                 *size = *r.out.size;
551         }
552         if (length && r.out.length) {
553                 *length = *r.out.length;
554         }
555
556         /* Return result */
557         if (werror) {
558                 *werror = r.out.result;
559         }
560
561         return werror_to_ntstatus(r.out.result);
562 }
563
564 NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli,
565                                 TALLOC_CTX *mem_ctx,
566                                 struct policy_handle *handle /* [in] [ref] */,
567                                 WERROR *werror)
568 {
569         struct winreg_FlushKey r;
570         NTSTATUS status;
571
572         /* In parameters */
573         r.in.handle = handle;
574
575         if (DEBUGLEVEL >= 10) {
576                 NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
577         }
578
579         status = cli_do_rpc_ndr(cli,
580                                 mem_ctx,
581                                 &ndr_table_winreg,
582                                 NDR_WINREG_FLUSHKEY,
583                                 &r);
584
585         if (!NT_STATUS_IS_OK(status)) {
586                 return status;
587         }
588
589         if (DEBUGLEVEL >= 10) {
590                 NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
591         }
592
593         if (NT_STATUS_IS_ERR(status)) {
594                 return status;
595         }
596
597         /* Return variables */
598
599         /* Return result */
600         if (werror) {
601                 *werror = r.out.result;
602         }
603
604         return werror_to_ntstatus(r.out.result);
605 }
606
607 NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli,
608                                       TALLOC_CTX *mem_ctx,
609                                       struct policy_handle *handle /* [in] [ref] */,
610                                       uint32_t sec_info /* [in]  */,
611                                       struct KeySecurityData *sd /* [in,out] [ref] */,
612                                       WERROR *werror)
613 {
614         struct winreg_GetKeySecurity r;
615         NTSTATUS status;
616
617         /* In parameters */
618         r.in.handle = handle;
619         r.in.sec_info = sec_info;
620         r.in.sd = sd;
621
622         if (DEBUGLEVEL >= 10) {
623                 NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &r);
624         }
625
626         status = cli_do_rpc_ndr(cli,
627                                 mem_ctx,
628                                 &ndr_table_winreg,
629                                 NDR_WINREG_GETKEYSECURITY,
630                                 &r);
631
632         if (!NT_STATUS_IS_OK(status)) {
633                 return status;
634         }
635
636         if (DEBUGLEVEL >= 10) {
637                 NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
638         }
639
640         if (NT_STATUS_IS_ERR(status)) {
641                 return status;
642         }
643
644         /* Return variables */
645         *sd = *r.out.sd;
646
647         /* Return result */
648         if (werror) {
649                 *werror = r.out.result;
650         }
651
652         return werror_to_ntstatus(r.out.result);
653 }
654
655 NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli,
656                                TALLOC_CTX *mem_ctx,
657                                struct policy_handle *handle /* [in] [ref] */,
658                                struct winreg_String *keyname /* [in] [unique] */,
659                                struct winreg_String *filename /* [in] [unique] */,
660                                WERROR *werror)
661 {
662         struct winreg_LoadKey r;
663         NTSTATUS status;
664
665         /* In parameters */
666         r.in.handle = handle;
667         r.in.keyname = keyname;
668         r.in.filename = filename;
669
670         if (DEBUGLEVEL >= 10) {
671                 NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
672         }
673
674         status = cli_do_rpc_ndr(cli,
675                                 mem_ctx,
676                                 &ndr_table_winreg,
677                                 NDR_WINREG_LOADKEY,
678                                 &r);
679
680         if (!NT_STATUS_IS_OK(status)) {
681                 return status;
682         }
683
684         if (DEBUGLEVEL >= 10) {
685                 NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
686         }
687
688         if (NT_STATUS_IS_ERR(status)) {
689                 return status;
690         }
691
692         /* Return variables */
693
694         /* Return result */
695         if (werror) {
696                 *werror = r.out.result;
697         }
698
699         return werror_to_ntstatus(r.out.result);
700 }
701
702 NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,
703                                             TALLOC_CTX *mem_ctx,
704                                             struct policy_handle *handle /* [in] [ref] */,
705                                             uint8_t watch_subtree /* [in]  */,
706                                             uint32_t notify_filter /* [in]  */,
707                                             uint32_t unknown /* [in]  */,
708                                             struct winreg_String string1 /* [in]  */,
709                                             struct winreg_String string2 /* [in]  */,
710                                             uint32_t unknown2 /* [in]  */,
711                                             WERROR *werror)
712 {
713         struct winreg_NotifyChangeKeyValue r;
714         NTSTATUS status;
715
716         /* In parameters */
717         r.in.handle = handle;
718         r.in.watch_subtree = watch_subtree;
719         r.in.notify_filter = notify_filter;
720         r.in.unknown = unknown;
721         r.in.string1 = string1;
722         r.in.string2 = string2;
723         r.in.unknown2 = unknown2;
724
725         if (DEBUGLEVEL >= 10) {
726                 NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
727         }
728
729         status = cli_do_rpc_ndr(cli,
730                                 mem_ctx,
731                                 &ndr_table_winreg,
732                                 NDR_WINREG_NOTIFYCHANGEKEYVALUE,
733                                 &r);
734
735         if (!NT_STATUS_IS_OK(status)) {
736                 return status;
737         }
738
739         if (DEBUGLEVEL >= 10) {
740                 NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
741         }
742
743         if (NT_STATUS_IS_ERR(status)) {
744                 return status;
745         }
746
747         /* Return variables */
748
749         /* Return result */
750         if (werror) {
751                 *werror = r.out.result;
752         }
753
754         return werror_to_ntstatus(r.out.result);
755 }
756
757 NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,
758                                TALLOC_CTX *mem_ctx,
759                                struct policy_handle *parent_handle /* [in] [ref] */,
760                                struct winreg_String keyname /* [in]  */,
761                                uint32_t unknown /* [in]  */,
762                                uint32_t access_mask /* [in]  */,
763                                struct policy_handle *handle /* [out] [ref] */,
764                                WERROR *werror)
765 {
766         struct winreg_OpenKey r;
767         NTSTATUS status;
768
769         /* In parameters */
770         r.in.parent_handle = parent_handle;
771         r.in.keyname = keyname;
772         r.in.unknown = unknown;
773         r.in.access_mask = access_mask;
774
775         if (DEBUGLEVEL >= 10) {
776                 NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);
777         }
778
779         status = cli_do_rpc_ndr(cli,
780                                 mem_ctx,
781                                 &ndr_table_winreg,
782                                 NDR_WINREG_OPENKEY,
783                                 &r);
784
785         if (!NT_STATUS_IS_OK(status)) {
786                 return status;
787         }
788
789         if (DEBUGLEVEL >= 10) {
790                 NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
791         }
792
793         if (NT_STATUS_IS_ERR(status)) {
794                 return status;
795         }
796
797         /* Return variables */
798         *handle = *r.out.handle;
799
800         /* Return result */
801         if (werror) {
802                 *werror = r.out.result;
803         }
804
805         return werror_to_ntstatus(r.out.result);
806 }
807
808 NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli,
809                                     TALLOC_CTX *mem_ctx,
810                                     struct policy_handle *handle /* [in] [ref] */,
811                                     struct winreg_String *classname /* [in,out] [ref] */,
812                                     uint32_t *num_subkeys /* [out] [ref] */,
813                                     uint32_t *max_subkeylen /* [out] [ref] */,
814                                     uint32_t *max_classlen /* [out] [ref] */,
815                                     uint32_t *num_values /* [out] [ref] */,
816                                     uint32_t *max_valnamelen /* [out] [ref] */,
817                                     uint32_t *max_valbufsize /* [out] [ref] */,
818                                     uint32_t *secdescsize /* [out] [ref] */,
819                                     NTTIME *last_changed_time /* [out] [ref] */,
820                                     WERROR *werror)
821 {
822         struct winreg_QueryInfoKey r;
823         NTSTATUS status;
824
825         /* In parameters */
826         r.in.handle = handle;
827         r.in.classname = classname;
828
829         if (DEBUGLEVEL >= 10) {
830                 NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &r);
831         }
832
833         status = cli_do_rpc_ndr(cli,
834                                 mem_ctx,
835                                 &ndr_table_winreg,
836                                 NDR_WINREG_QUERYINFOKEY,
837                                 &r);
838
839         if (!NT_STATUS_IS_OK(status)) {
840                 return status;
841         }
842
843         if (DEBUGLEVEL >= 10) {
844                 NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
845         }
846
847         if (NT_STATUS_IS_ERR(status)) {
848                 return status;
849         }
850
851         /* Return variables */
852         *classname = *r.out.classname;
853         *num_subkeys = *r.out.num_subkeys;
854         *max_subkeylen = *r.out.max_subkeylen;
855         *max_classlen = *r.out.max_classlen;
856         *num_values = *r.out.num_values;
857         *max_valnamelen = *r.out.max_valnamelen;
858         *max_valbufsize = *r.out.max_valbufsize;
859         *secdescsize = *r.out.secdescsize;
860         *last_changed_time = *r.out.last_changed_time;
861
862         /* Return result */
863         if (werror) {
864                 *werror = r.out.result;
865         }
866
867         return werror_to_ntstatus(r.out.result);
868 }
869
870 NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli,
871                                   TALLOC_CTX *mem_ctx,
872                                   struct policy_handle *handle /* [in] [ref] */,
873                                   struct winreg_String *value_name /* [in] [ref] */,
874                                   enum winreg_Type *type /* [in,out] [unique] */,
875                                   uint8_t *data /* [in,out] [unique,length_is(*value_length),size_is(*data_size)] */,
876                                   uint32_t *data_size /* [in,out] [unique] */,
877                                   uint32_t *value_length /* [in,out] [unique] */,
878                                   WERROR *werror)
879 {
880         struct winreg_QueryValue r;
881         NTSTATUS status;
882
883         /* In parameters */
884         r.in.handle = handle;
885         r.in.value_name = value_name;
886         r.in.type = type;
887         r.in.data = data;
888         r.in.data_size = data_size;
889         r.in.value_length = value_length;
890
891         if (DEBUGLEVEL >= 10) {
892                 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
893         }
894
895         status = cli_do_rpc_ndr(cli,
896                                 mem_ctx,
897                                 &ndr_table_winreg,
898                                 NDR_WINREG_QUERYVALUE,
899                                 &r);
900
901         if (!NT_STATUS_IS_OK(status)) {
902                 return status;
903         }
904
905         if (DEBUGLEVEL >= 10) {
906                 NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
907         }
908
909         if (NT_STATUS_IS_ERR(status)) {
910                 return status;
911         }
912
913         /* Return variables */
914         if (type && r.out.type) {
915                 *type = *r.out.type;
916         }
917         if (data && r.out.data) {
918                 memcpy(data, r.out.data, *r.in.data_size * sizeof(*data));
919         }
920         if (data_size && r.out.data_size) {
921                 *data_size = *r.out.data_size;
922         }
923         if (value_length && r.out.value_length) {
924                 *value_length = *r.out.value_length;
925         }
926
927         /* Return result */
928         if (werror) {
929                 *werror = r.out.result;
930         }
931
932         return werror_to_ntstatus(r.out.result);
933 }
934
935 NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
936                                   TALLOC_CTX *mem_ctx,
937                                   WERROR *werror)
938 {
939         struct winreg_ReplaceKey r;
940         NTSTATUS status;
941
942         /* In parameters */
943
944         if (DEBUGLEVEL >= 10) {
945                 NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
946         }
947
948         status = cli_do_rpc_ndr(cli,
949                                 mem_ctx,
950                                 &ndr_table_winreg,
951                                 NDR_WINREG_REPLACEKEY,
952                                 &r);
953
954         if (!NT_STATUS_IS_OK(status)) {
955                 return status;
956         }
957
958         if (DEBUGLEVEL >= 10) {
959                 NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
960         }
961
962         if (NT_STATUS_IS_ERR(status)) {
963                 return status;
964         }
965
966         /* Return variables */
967
968         /* Return result */
969         if (werror) {
970                 *werror = r.out.result;
971         }
972
973         return werror_to_ntstatus(r.out.result);
974 }
975
976 NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
977                                   TALLOC_CTX *mem_ctx,
978                                   struct policy_handle *handle /* [in] [ref] */,
979                                   struct winreg_String *filename /* [in] [ref] */,
980                                   uint32_t flags /* [in]  */,
981                                   WERROR *werror)
982 {
983         struct winreg_RestoreKey r;
984         NTSTATUS status;
985
986         /* In parameters */
987         r.in.handle = handle;
988         r.in.filename = filename;
989         r.in.flags = flags;
990
991         if (DEBUGLEVEL >= 10) {
992                 NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
993         }
994
995         status = cli_do_rpc_ndr(cli,
996                                 mem_ctx,
997                                 &ndr_table_winreg,
998                                 NDR_WINREG_RESTOREKEY,
999                                 &r);
1000
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 return status;
1003         }
1004
1005         if (DEBUGLEVEL >= 10) {
1006                 NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
1007         }
1008
1009         if (NT_STATUS_IS_ERR(status)) {
1010                 return status;
1011         }
1012
1013         /* Return variables */
1014
1015         /* Return result */
1016         if (werror) {
1017                 *werror = r.out.result;
1018         }
1019
1020         return werror_to_ntstatus(r.out.result);
1021 }
1022
1023 NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
1024                                TALLOC_CTX *mem_ctx,
1025                                struct policy_handle *handle /* [in] [ref] */,
1026                                struct winreg_String *filename /* [in] [ref] */,
1027                                struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
1028                                WERROR *werror)
1029 {
1030         struct winreg_SaveKey r;
1031         NTSTATUS status;
1032
1033         /* In parameters */
1034         r.in.handle = handle;
1035         r.in.filename = filename;
1036         r.in.sec_attrib = sec_attrib;
1037
1038         if (DEBUGLEVEL >= 10) {
1039                 NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
1040         }
1041
1042         status = cli_do_rpc_ndr(cli,
1043                                 mem_ctx,
1044                                 &ndr_table_winreg,
1045                                 NDR_WINREG_SAVEKEY,
1046                                 &r);
1047
1048         if (!NT_STATUS_IS_OK(status)) {
1049                 return status;
1050         }
1051
1052         if (DEBUGLEVEL >= 10) {
1053                 NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
1054         }
1055
1056         if (NT_STATUS_IS_ERR(status)) {
1057                 return status;
1058         }
1059
1060         /* Return variables */
1061
1062         /* Return result */
1063         if (werror) {
1064                 *werror = r.out.result;
1065         }
1066
1067         return werror_to_ntstatus(r.out.result);
1068 }
1069
1070 NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
1071                                       TALLOC_CTX *mem_ctx,
1072                                       struct policy_handle *handle /* [in] [ref] */,
1073                                       uint32_t access_mask /* [in]  */,
1074                                       struct KeySecurityData *sd /* [in] [ref] */,
1075                                       WERROR *werror)
1076 {
1077         struct winreg_SetKeySecurity r;
1078         NTSTATUS status;
1079
1080         /* In parameters */
1081         r.in.handle = handle;
1082         r.in.access_mask = access_mask;
1083         r.in.sd = sd;
1084
1085         if (DEBUGLEVEL >= 10) {
1086                 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
1087         }
1088
1089         status = cli_do_rpc_ndr(cli,
1090                                 mem_ctx,
1091                                 &ndr_table_winreg,
1092                                 NDR_WINREG_SETKEYSECURITY,
1093                                 &r);
1094
1095         if (!NT_STATUS_IS_OK(status)) {
1096                 return status;
1097         }
1098
1099         if (DEBUGLEVEL >= 10) {
1100                 NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
1101         }
1102
1103         if (NT_STATUS_IS_ERR(status)) {
1104                 return status;
1105         }
1106
1107         /* Return variables */
1108
1109         /* Return result */
1110         if (werror) {
1111                 *werror = r.out.result;
1112         }
1113
1114         return werror_to_ntstatus(r.out.result);
1115 }
1116
1117 NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
1118                                 TALLOC_CTX *mem_ctx,
1119                                 struct policy_handle *handle /* [in] [ref] */,
1120                                 struct winreg_String name /* [in]  */,
1121                                 enum winreg_Type type /* [in]  */,
1122                                 uint8_t *data /* [in] [ref,size_is(size)] */,
1123                                 uint32_t size /* [in]  */,
1124                                 WERROR *werror)
1125 {
1126         struct winreg_SetValue r;
1127         NTSTATUS status;
1128
1129         /* In parameters */
1130         r.in.handle = handle;
1131         r.in.name = name;
1132         r.in.type = type;
1133         r.in.data = data;
1134         r.in.size = size;
1135
1136         if (DEBUGLEVEL >= 10) {
1137                 NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
1138         }
1139
1140         status = cli_do_rpc_ndr(cli,
1141                                 mem_ctx,
1142                                 &ndr_table_winreg,
1143                                 NDR_WINREG_SETVALUE,
1144                                 &r);
1145
1146         if (!NT_STATUS_IS_OK(status)) {
1147                 return status;
1148         }
1149
1150         if (DEBUGLEVEL >= 10) {
1151                 NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
1152         }
1153
1154         if (NT_STATUS_IS_ERR(status)) {
1155                 return status;
1156         }
1157
1158         /* Return variables */
1159
1160         /* Return result */
1161         if (werror) {
1162                 *werror = r.out.result;
1163         }
1164
1165         return werror_to_ntstatus(r.out.result);
1166 }
1167
1168 NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
1169                                  TALLOC_CTX *mem_ctx,
1170                                  WERROR *werror)
1171 {
1172         struct winreg_UnLoadKey r;
1173         NTSTATUS status;
1174
1175         /* In parameters */
1176
1177         if (DEBUGLEVEL >= 10) {
1178                 NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
1179         }
1180
1181         status = cli_do_rpc_ndr(cli,
1182                                 mem_ctx,
1183                                 &ndr_table_winreg,
1184                                 NDR_WINREG_UNLOADKEY,
1185                                 &r);
1186
1187         if (!NT_STATUS_IS_OK(status)) {
1188                 return status;
1189         }
1190
1191         if (DEBUGLEVEL >= 10) {
1192                 NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
1193         }
1194
1195         if (NT_STATUS_IS_ERR(status)) {
1196                 return status;
1197         }
1198
1199         /* Return variables */
1200
1201         /* Return result */
1202         if (werror) {
1203                 *werror = r.out.result;
1204         }
1205
1206         return werror_to_ntstatus(r.out.result);
1207 }
1208
1209 NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
1210                                               TALLOC_CTX *mem_ctx,
1211                                               uint16_t *hostname /* [in] [unique] */,
1212                                               struct initshutdown_String *message /* [in] [unique] */,
1213                                               uint32_t timeout /* [in]  */,
1214                                               uint8_t force_apps /* [in]  */,
1215                                               uint8_t reboot /* [in]  */,
1216                                               WERROR *werror)
1217 {
1218         struct winreg_InitiateSystemShutdown r;
1219         NTSTATUS status;
1220
1221         /* In parameters */
1222         r.in.hostname = hostname;
1223         r.in.message = message;
1224         r.in.timeout = timeout;
1225         r.in.force_apps = force_apps;
1226         r.in.reboot = reboot;
1227
1228         if (DEBUGLEVEL >= 10) {
1229                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
1230         }
1231
1232         status = cli_do_rpc_ndr(cli,
1233                                 mem_ctx,
1234                                 &ndr_table_winreg,
1235                                 NDR_WINREG_INITIATESYSTEMSHUTDOWN,
1236                                 &r);
1237
1238         if (!NT_STATUS_IS_OK(status)) {
1239                 return status;
1240         }
1241
1242         if (DEBUGLEVEL >= 10) {
1243                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
1244         }
1245
1246         if (NT_STATUS_IS_ERR(status)) {
1247                 return status;
1248         }
1249
1250         /* Return variables */
1251
1252         /* Return result */
1253         if (werror) {
1254                 *werror = r.out.result;
1255         }
1256
1257         return werror_to_ntstatus(r.out.result);
1258 }
1259
1260 NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
1261                                            TALLOC_CTX *mem_ctx,
1262                                            uint16_t *server /* [in] [unique] */,
1263                                            WERROR *werror)
1264 {
1265         struct winreg_AbortSystemShutdown r;
1266         NTSTATUS status;
1267
1268         /* In parameters */
1269         r.in.server = server;
1270
1271         if (DEBUGLEVEL >= 10) {
1272                 NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
1273         }
1274
1275         status = cli_do_rpc_ndr(cli,
1276                                 mem_ctx,
1277                                 &ndr_table_winreg,
1278                                 NDR_WINREG_ABORTSYSTEMSHUTDOWN,
1279                                 &r);
1280
1281         if (!NT_STATUS_IS_OK(status)) {
1282                 return status;
1283         }
1284
1285         if (DEBUGLEVEL >= 10) {
1286                 NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
1287         }
1288
1289         if (NT_STATUS_IS_ERR(status)) {
1290                 return status;
1291         }
1292
1293         /* Return variables */
1294
1295         /* Return result */
1296         if (werror) {
1297                 *werror = r.out.result;
1298         }
1299
1300         return werror_to_ntstatus(r.out.result);
1301 }
1302
1303 NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
1304                                   TALLOC_CTX *mem_ctx,
1305                                   struct policy_handle *handle /* [in] [ref] */,
1306                                   uint32_t *version /* [out] [ref] */,
1307                                   WERROR *werror)
1308 {
1309         struct winreg_GetVersion r;
1310         NTSTATUS status;
1311
1312         /* In parameters */
1313         r.in.handle = handle;
1314
1315         if (DEBUGLEVEL >= 10) {
1316                 NDR_PRINT_IN_DEBUG(winreg_GetVersion, &r);
1317         }
1318
1319         status = cli_do_rpc_ndr(cli,
1320                                 mem_ctx,
1321                                 &ndr_table_winreg,
1322                                 NDR_WINREG_GETVERSION,
1323                                 &r);
1324
1325         if (!NT_STATUS_IS_OK(status)) {
1326                 return status;
1327         }
1328
1329         if (DEBUGLEVEL >= 10) {
1330                 NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
1331         }
1332
1333         if (NT_STATUS_IS_ERR(status)) {
1334                 return status;
1335         }
1336
1337         /* Return variables */
1338         *version = *r.out.version;
1339
1340         /* Return result */
1341         if (werror) {
1342                 *werror = r.out.result;
1343         }
1344
1345         return werror_to_ntstatus(r.out.result);
1346 }
1347
1348 NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
1349                                 TALLOC_CTX *mem_ctx,
1350                                 uint16_t *system_name /* [in] [unique] */,
1351                                 uint32_t access_mask /* [in]  */,
1352                                 struct policy_handle *handle /* [out] [ref] */,
1353                                 WERROR *werror)
1354 {
1355         struct winreg_OpenHKCC r;
1356         NTSTATUS status;
1357
1358         /* In parameters */
1359         r.in.system_name = system_name;
1360         r.in.access_mask = access_mask;
1361
1362         if (DEBUGLEVEL >= 10) {
1363                 NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &r);
1364         }
1365
1366         status = cli_do_rpc_ndr(cli,
1367                                 mem_ctx,
1368                                 &ndr_table_winreg,
1369                                 NDR_WINREG_OPENHKCC,
1370                                 &r);
1371
1372         if (!NT_STATUS_IS_OK(status)) {
1373                 return status;
1374         }
1375
1376         if (DEBUGLEVEL >= 10) {
1377                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
1378         }
1379
1380         if (NT_STATUS_IS_ERR(status)) {
1381                 return status;
1382         }
1383
1384         /* Return variables */
1385         *handle = *r.out.handle;
1386
1387         /* Return result */
1388         if (werror) {
1389                 *werror = r.out.result;
1390         }
1391
1392         return werror_to_ntstatus(r.out.result);
1393 }
1394
1395 NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
1396                                 TALLOC_CTX *mem_ctx,
1397                                 uint16_t *system_name /* [in] [unique] */,
1398                                 uint32_t access_mask /* [in]  */,
1399                                 struct policy_handle *handle /* [out] [ref] */,
1400                                 WERROR *werror)
1401 {
1402         struct winreg_OpenHKDD r;
1403         NTSTATUS status;
1404
1405         /* In parameters */
1406         r.in.system_name = system_name;
1407         r.in.access_mask = access_mask;
1408
1409         if (DEBUGLEVEL >= 10) {
1410                 NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &r);
1411         }
1412
1413         status = cli_do_rpc_ndr(cli,
1414                                 mem_ctx,
1415                                 &ndr_table_winreg,
1416                                 NDR_WINREG_OPENHKDD,
1417                                 &r);
1418
1419         if (!NT_STATUS_IS_OK(status)) {
1420                 return status;
1421         }
1422
1423         if (DEBUGLEVEL >= 10) {
1424                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
1425         }
1426
1427         if (NT_STATUS_IS_ERR(status)) {
1428                 return status;
1429         }
1430
1431         /* Return variables */
1432         *handle = *r.out.handle;
1433
1434         /* Return result */
1435         if (werror) {
1436                 *werror = r.out.result;
1437         }
1438
1439         return werror_to_ntstatus(r.out.result);
1440 }
1441
1442 NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
1443                                            TALLOC_CTX *mem_ctx,
1444                                            struct policy_handle *key_handle /* [in] [ref] */,
1445                                            struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
1446                                            uint32_t num_values /* [in]  */,
1447                                            uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
1448                                            uint32_t *buffer_size /* [in,out] [ref] */,
1449                                            WERROR *werror)
1450 {
1451         struct winreg_QueryMultipleValues r;
1452         NTSTATUS status;
1453
1454         /* In parameters */
1455         r.in.key_handle = key_handle;
1456         r.in.values = values;
1457         r.in.num_values = num_values;
1458         r.in.buffer = buffer;
1459         r.in.buffer_size = buffer_size;
1460
1461         if (DEBUGLEVEL >= 10) {
1462                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);
1463         }
1464
1465         status = cli_do_rpc_ndr(cli,
1466                                 mem_ctx,
1467                                 &ndr_table_winreg,
1468                                 NDR_WINREG_QUERYMULTIPLEVALUES,
1469                                 &r);
1470
1471         if (!NT_STATUS_IS_OK(status)) {
1472                 return status;
1473         }
1474
1475         if (DEBUGLEVEL >= 10) {
1476                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
1477         }
1478
1479         if (NT_STATUS_IS_ERR(status)) {
1480                 return status;
1481         }
1482
1483         /* Return variables */
1484         memcpy(values, r.out.values, r.in.num_values * sizeof(*values));
1485         if (buffer && r.out.buffer) {
1486                 memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));
1487         }
1488         *buffer_size = *r.out.buffer_size;
1489
1490         /* Return result */
1491         if (werror) {
1492                 *werror = r.out.result;
1493         }
1494
1495         return werror_to_ntstatus(r.out.result);
1496 }
1497
1498 NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
1499                                                 TALLOC_CTX *mem_ctx,
1500                                                 uint16_t *hostname /* [in] [unique] */,
1501                                                 struct initshutdown_String *message /* [in] [unique] */,
1502                                                 uint32_t timeout /* [in]  */,
1503                                                 uint8_t force_apps /* [in]  */,
1504                                                 uint8_t reboot /* [in]  */,
1505                                                 uint32_t reason /* [in]  */,
1506                                                 WERROR *werror)
1507 {
1508         struct winreg_InitiateSystemShutdownEx r;
1509         NTSTATUS status;
1510
1511         /* In parameters */
1512         r.in.hostname = hostname;
1513         r.in.message = message;
1514         r.in.timeout = timeout;
1515         r.in.force_apps = force_apps;
1516         r.in.reboot = reboot;
1517         r.in.reason = reason;
1518
1519         if (DEBUGLEVEL >= 10) {
1520                 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1521         }
1522
1523         status = cli_do_rpc_ndr(cli,
1524                                 mem_ctx,
1525                                 &ndr_table_winreg,
1526                                 NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
1527                                 &r);
1528
1529         if (!NT_STATUS_IS_OK(status)) {
1530                 return status;
1531         }
1532
1533         if (DEBUGLEVEL >= 10) {
1534                 NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1535         }
1536
1537         if (NT_STATUS_IS_ERR(status)) {
1538                 return status;
1539         }
1540
1541         /* Return variables */
1542
1543         /* Return result */
1544         if (werror) {
1545                 *werror = r.out.result;
1546         }
1547
1548         return werror_to_ntstatus(r.out.result);
1549 }
1550
1551 NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
1552                                  TALLOC_CTX *mem_ctx,
1553                                  WERROR *werror)
1554 {
1555         struct winreg_SaveKeyEx r;
1556         NTSTATUS status;
1557
1558         /* In parameters */
1559
1560         if (DEBUGLEVEL >= 10) {
1561                 NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
1562         }
1563
1564         status = cli_do_rpc_ndr(cli,
1565                                 mem_ctx,
1566                                 &ndr_table_winreg,
1567                                 NDR_WINREG_SAVEKEYEX,
1568                                 &r);
1569
1570         if (!NT_STATUS_IS_OK(status)) {
1571                 return status;
1572         }
1573
1574         if (DEBUGLEVEL >= 10) {
1575                 NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
1576         }
1577
1578         if (NT_STATUS_IS_ERR(status)) {
1579                 return status;
1580         }
1581
1582         /* Return variables */
1583
1584         /* Return result */
1585         if (werror) {
1586                 *werror = r.out.result;
1587         }
1588
1589         return werror_to_ntstatus(r.out.result);
1590 }
1591
1592 NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
1593                                 TALLOC_CTX *mem_ctx,
1594                                 uint16_t *system_name /* [in] [unique] */,
1595                                 uint32_t access_mask /* [in]  */,
1596                                 struct policy_handle *handle /* [out] [ref] */,
1597                                 WERROR *werror)
1598 {
1599         struct winreg_OpenHKPT r;
1600         NTSTATUS status;
1601
1602         /* In parameters */
1603         r.in.system_name = system_name;
1604         r.in.access_mask = access_mask;
1605
1606         if (DEBUGLEVEL >= 10) {
1607                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &r);
1608         }
1609
1610         status = cli_do_rpc_ndr(cli,
1611                                 mem_ctx,
1612                                 &ndr_table_winreg,
1613                                 NDR_WINREG_OPENHKPT,
1614                                 &r);
1615
1616         if (!NT_STATUS_IS_OK(status)) {
1617                 return status;
1618         }
1619
1620         if (DEBUGLEVEL >= 10) {
1621                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
1622         }
1623
1624         if (NT_STATUS_IS_ERR(status)) {
1625                 return status;
1626         }
1627
1628         /* Return variables */
1629         *handle = *r.out.handle;
1630
1631         /* Return result */
1632         if (werror) {
1633                 *werror = r.out.result;
1634         }
1635
1636         return werror_to_ntstatus(r.out.result);
1637 }
1638
1639 NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
1640                                 TALLOC_CTX *mem_ctx,
1641                                 uint16_t *system_name /* [in] [unique] */,
1642                                 uint32_t access_mask /* [in]  */,
1643                                 struct policy_handle *handle /* [out] [ref] */,
1644                                 WERROR *werror)
1645 {
1646         struct winreg_OpenHKPN r;
1647         NTSTATUS status;
1648
1649         /* In parameters */
1650         r.in.system_name = system_name;
1651         r.in.access_mask = access_mask;
1652
1653         if (DEBUGLEVEL >= 10) {
1654                 NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &r);
1655         }
1656
1657         status = cli_do_rpc_ndr(cli,
1658                                 mem_ctx,
1659                                 &ndr_table_winreg,
1660                                 NDR_WINREG_OPENHKPN,
1661                                 &r);
1662
1663         if (!NT_STATUS_IS_OK(status)) {
1664                 return status;
1665         }
1666
1667         if (DEBUGLEVEL >= 10) {
1668                 NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
1669         }
1670
1671         if (NT_STATUS_IS_ERR(status)) {
1672                 return status;
1673         }
1674
1675         /* Return variables */
1676         *handle = *r.out.handle;
1677
1678         /* Return result */
1679         if (werror) {
1680                 *werror = r.out.result;
1681         }
1682
1683         return werror_to_ntstatus(r.out.result);
1684 }
1685
1686 NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
1687                                             TALLOC_CTX *mem_ctx,
1688                                             WERROR *werror)
1689 {
1690         struct winreg_QueryMultipleValues2 r;
1691         NTSTATUS status;
1692
1693         /* In parameters */
1694
1695         if (DEBUGLEVEL >= 10) {
1696                 NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
1697         }
1698
1699         status = cli_do_rpc_ndr(cli,
1700                                 mem_ctx,
1701                                 &ndr_table_winreg,
1702                                 NDR_WINREG_QUERYMULTIPLEVALUES2,
1703                                 &r);
1704
1705         if (!NT_STATUS_IS_OK(status)) {
1706                 return status;
1707         }
1708
1709         if (DEBUGLEVEL >= 10) {
1710                 NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
1711         }
1712
1713         if (NT_STATUS_IS_ERR(status)) {
1714                 return status;
1715         }
1716
1717         /* Return variables */
1718
1719         /* Return result */
1720         if (werror) {
1721                 *werror = r.out.result;
1722         }
1723
1724         return werror_to_ntstatus(r.out.result);
1725 }
1726