?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-idmap: Fix bug #6286: Call init function for builtin idmap modules before probing...
[Samba.git] / librpc / gen_ndr / cli_winreg.c
blobb18554e63e11ee6f1ceaec5b27b7cccd8c8f6daa
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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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(*data_length),size_is(*data_size)] */,
876 uint32_t *data_size /* [in,out] [unique] */,
877 uint32_t *data_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.data_length = data_length;
890
891 if (DEBUGLEVEL >= 10) {
892 NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
893 }
894
895 status = cli->dispatch(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 (data_length && r.out.data_length) {
924 *data_length = *r.out.data_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->dispatch(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->dispatch(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->dispatch(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 sec_info /* [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.sec_info = sec_info;
1083 r.in.sd = sd;
1084
1085 if (DEBUGLEVEL >= 10) {
1086 NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
1087 }
1088
1089 status = cli->dispatch(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->dispatch(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->dispatch(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 lsa_StringLarge *message /* [in] [unique] */,
1213 uint32_t timeout /* [in] */,
1214 uint8_t force_apps /* [in] */,
1215 uint8_t do_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.do_reboot = do_reboot;
1227
1228 if (DEBUGLEVEL >= 10) {
1229 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
1230 }
1231
1232 status = cli->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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 lsa_StringLarge *message /* [in] [unique] */,
1502 uint32_t timeout /* [in] */,
1503 uint8_t force_apps /* [in] */,
1504 uint8_t do_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.do_reboot = do_reboot;
1517 r.in.reason = reason;
1518
1519 if (DEBUGLEVEL >= 10) {
1520 NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
1521 }
1522
1523 status = cli->dispatch(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->dispatch(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->dispatch(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->dispatch(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->dispatch(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
Samba GIT mirror