source: branches/samba-3.2.x/source/librpc/gen_ndr/cli_ntsvcs.c

Last change on this file was 228, checked in by Herwig Bauernfeind, 17 years ago

Update 3.2 branch to 3.2.6
File size: 49.6 KB
Line 
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_ntsvcs.h"
8
9NTSTATUS rpccli_PNP_Disconnect(struct rpc_pipe_client *cli,
10 TALLOC_CTX *mem_ctx,
11 WERROR *werror)
12{
13 struct PNP_Disconnect r;
14 NTSTATUS status;
15
16 /* In parameters */
17
18 if (DEBUGLEVEL >= 10) {
19 NDR_PRINT_IN_DEBUG(PNP_Disconnect, &r);
20 }
21
22 status = cli_do_rpc_ndr(cli,
23 mem_ctx,
24 PI_NTSVCS,
25 &ndr_table_ntsvcs,
26 NDR_PNP_DISCONNECT,
27 &r);
28
29 if (!NT_STATUS_IS_OK(status)) {
30 return status;
31 }
32
33 if (DEBUGLEVEL >= 10) {
34 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, &r);
35 }
36
37 if (NT_STATUS_IS_ERR(status)) {
38 return status;
39 }
40
41 /* Return variables */
42
43 /* Return result */
44 if (werror) {
45 *werror = r.out.result;
46 }
47
48 return werror_to_ntstatus(r.out.result);
49}
50
51NTSTATUS rpccli_PNP_Connect(struct rpc_pipe_client *cli,
52 TALLOC_CTX *mem_ctx,
53 WERROR *werror)
54{
55 struct PNP_Connect r;
56 NTSTATUS status;
57
58 /* In parameters */
59
60 if (DEBUGLEVEL >= 10) {
61 NDR_PRINT_IN_DEBUG(PNP_Connect, &r);
62 }
63
64 status = cli_do_rpc_ndr(cli,
65 mem_ctx,
66 PI_NTSVCS,
67 &ndr_table_ntsvcs,
68 NDR_PNP_CONNECT,
69 &r);
70
71 if (!NT_STATUS_IS_OK(status)) {
72 return status;
73 }
74
75 if (DEBUGLEVEL >= 10) {
76 NDR_PRINT_OUT_DEBUG(PNP_Connect, &r);
77 }
78
79 if (NT_STATUS_IS_ERR(status)) {
80 return status;
81 }
82
83 /* Return variables */
84
85 /* Return result */
86 if (werror) {
87 *werror = r.out.result;
88 }
89
90 return werror_to_ntstatus(r.out.result);
91}
92
93NTSTATUS rpccli_PNP_GetVersion(struct rpc_pipe_client *cli,
94 TALLOC_CTX *mem_ctx,
95 uint16_t *version /* [out] [ref] */,
96 WERROR *werror)
97{
98 struct PNP_GetVersion r;
99 NTSTATUS status;
100
101 /* In parameters */
102
103 if (DEBUGLEVEL >= 10) {
104 NDR_PRINT_IN_DEBUG(PNP_GetVersion, &r);
105 }
106
107 status = cli_do_rpc_ndr(cli,
108 mem_ctx,
109 PI_NTSVCS,
110 &ndr_table_ntsvcs,
111 NDR_PNP_GETVERSION,
112 &r);
113
114 if (!NT_STATUS_IS_OK(status)) {
115 return status;
116 }
117
118 if (DEBUGLEVEL >= 10) {
119 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, &r);
120 }
121
122 if (NT_STATUS_IS_ERR(status)) {
123 return status;
124 }
125
126 /* Return variables */
127 *version = *r.out.version;
128
129 /* Return result */
130 if (werror) {
131 *werror = r.out.result;
132 }
133
134 return werror_to_ntstatus(r.out.result);
135}
136
137NTSTATUS rpccli_PNP_GetGlobalState(struct rpc_pipe_client *cli,
138 TALLOC_CTX *mem_ctx,
139 WERROR *werror)
140{
141 struct PNP_GetGlobalState r;
142 NTSTATUS status;
143
144 /* In parameters */
145
146 if (DEBUGLEVEL >= 10) {
147 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, &r);
148 }
149
150 status = cli_do_rpc_ndr(cli,
151 mem_ctx,
152 PI_NTSVCS,
153 &ndr_table_ntsvcs,
154 NDR_PNP_GETGLOBALSTATE,
155 &r);
156
157 if (!NT_STATUS_IS_OK(status)) {
158 return status;
159 }
160
161 if (DEBUGLEVEL >= 10) {
162 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, &r);
163 }
164
165 if (NT_STATUS_IS_ERR(status)) {
166 return status;
167 }
168
169 /* Return variables */
170
171 /* Return result */
172 if (werror) {
173 *werror = r.out.result;
174 }
175
176 return werror_to_ntstatus(r.out.result);
177}
178
179NTSTATUS rpccli_PNP_InitDetection(struct rpc_pipe_client *cli,
180 TALLOC_CTX *mem_ctx,
181 WERROR *werror)
182{
183 struct PNP_InitDetection r;
184 NTSTATUS status;
185
186 /* In parameters */
187
188 if (DEBUGLEVEL >= 10) {
189 NDR_PRINT_IN_DEBUG(PNP_InitDetection, &r);
190 }
191
192 status = cli_do_rpc_ndr(cli,
193 mem_ctx,
194 PI_NTSVCS,
195 &ndr_table_ntsvcs,
196 NDR_PNP_INITDETECTION,
197 &r);
198
199 if (!NT_STATUS_IS_OK(status)) {
200 return status;
201 }
202
203 if (DEBUGLEVEL >= 10) {
204 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, &r);
205 }
206
207 if (NT_STATUS_IS_ERR(status)) {
208 return status;
209 }
210
211 /* Return variables */
212
213 /* Return result */
214 if (werror) {
215 *werror = r.out.result;
216 }
217
218 return werror_to_ntstatus(r.out.result);
219}
220
221NTSTATUS rpccli_PNP_ReportLogOn(struct rpc_pipe_client *cli,
222 TALLOC_CTX *mem_ctx,
223 WERROR *werror)
224{
225 struct PNP_ReportLogOn r;
226 NTSTATUS status;
227
228 /* In parameters */
229
230 if (DEBUGLEVEL >= 10) {
231 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, &r);
232 }
233
234 status = cli_do_rpc_ndr(cli,
235 mem_ctx,
236 PI_NTSVCS,
237 &ndr_table_ntsvcs,
238 NDR_PNP_REPORTLOGON,
239 &r);
240
241 if (!NT_STATUS_IS_OK(status)) {
242 return status;
243 }
244
245 if (DEBUGLEVEL >= 10) {
246 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, &r);
247 }
248
249 if (NT_STATUS_IS_ERR(status)) {
250 return status;
251 }
252
253 /* Return variables */
254
255 /* Return result */
256 if (werror) {
257 *werror = r.out.result;
258 }
259
260 return werror_to_ntstatus(r.out.result);
261}
262
263NTSTATUS rpccli_PNP_ValidateDeviceInstance(struct rpc_pipe_client *cli,
264 TALLOC_CTX *mem_ctx,
265 const char *devicepath /* [in] [ref,charset(UTF16)] */,
266 uint32_t flags /* [in] */,
267 WERROR *werror)
268{
269 struct PNP_ValidateDeviceInstance r;
270 NTSTATUS status;
271
272 /* In parameters */
273 r.in.devicepath = devicepath;
274 r.in.flags = flags;
275
276 if (DEBUGLEVEL >= 10) {
277 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, &r);
278 }
279
280 status = cli_do_rpc_ndr(cli,
281 mem_ctx,
282 PI_NTSVCS,
283 &ndr_table_ntsvcs,
284 NDR_PNP_VALIDATEDEVICEINSTANCE,
285 &r);
286
287 if (!NT_STATUS_IS_OK(status)) {
288 return status;
289 }
290
291 if (DEBUGLEVEL >= 10) {
292 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, &r);
293 }
294
295 if (NT_STATUS_IS_ERR(status)) {
296 return status;
297 }
298
299 /* Return variables */
300
301 /* Return result */
302 if (werror) {
303 *werror = r.out.result;
304 }
305
306 return werror_to_ntstatus(r.out.result);
307}
308
309NTSTATUS rpccli_PNP_GetRootDeviceInstance(struct rpc_pipe_client *cli,
310 TALLOC_CTX *mem_ctx,
311 WERROR *werror)
312{
313 struct PNP_GetRootDeviceInstance r;
314 NTSTATUS status;
315
316 /* In parameters */
317
318 if (DEBUGLEVEL >= 10) {
319 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, &r);
320 }
321
322 status = cli_do_rpc_ndr(cli,
323 mem_ctx,
324 PI_NTSVCS,
325 &ndr_table_ntsvcs,
326 NDR_PNP_GETROOTDEVICEINSTANCE,
327 &r);
328
329 if (!NT_STATUS_IS_OK(status)) {
330 return status;
331 }
332
333 if (DEBUGLEVEL >= 10) {
334 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, &r);
335 }
336
337 if (NT_STATUS_IS_ERR(status)) {
338 return status;
339 }
340
341 /* Return variables */
342
343 /* Return result */
344 if (werror) {
345 *werror = r.out.result;
346 }
347
348 return werror_to_ntstatus(r.out.result);
349}
350
351NTSTATUS rpccli_PNP_GetRelatedDeviceInstance(struct rpc_pipe_client *cli,
352 TALLOC_CTX *mem_ctx,
353 WERROR *werror)
354{
355 struct PNP_GetRelatedDeviceInstance r;
356 NTSTATUS status;
357
358 /* In parameters */
359
360 if (DEBUGLEVEL >= 10) {
361 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, &r);
362 }
363
364 status = cli_do_rpc_ndr(cli,
365 mem_ctx,
366 PI_NTSVCS,
367 &ndr_table_ntsvcs,
368 NDR_PNP_GETRELATEDDEVICEINSTANCE,
369 &r);
370
371 if (!NT_STATUS_IS_OK(status)) {
372 return status;
373 }
374
375 if (DEBUGLEVEL >= 10) {
376 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, &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
393NTSTATUS rpccli_PNP_EnumerateSubKeys(struct rpc_pipe_client *cli,
394 TALLOC_CTX *mem_ctx,
395 WERROR *werror)
396{
397 struct PNP_EnumerateSubKeys r;
398 NTSTATUS status;
399
400 /* In parameters */
401
402 if (DEBUGLEVEL >= 10) {
403 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, &r);
404 }
405
406 status = cli_do_rpc_ndr(cli,
407 mem_ctx,
408 PI_NTSVCS,
409 &ndr_table_ntsvcs,
410 NDR_PNP_ENUMERATESUBKEYS,
411 &r);
412
413 if (!NT_STATUS_IS_OK(status)) {
414 return status;
415 }
416
417 if (DEBUGLEVEL >= 10) {
418 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, &r);
419 }
420
421 if (NT_STATUS_IS_ERR(status)) {
422 return status;
423 }
424
425 /* Return variables */
426
427 /* Return result */
428 if (werror) {
429 *werror = r.out.result;
430 }
431
432 return werror_to_ntstatus(r.out.result);
433}
434
435NTSTATUS rpccli_PNP_GetDeviceList(struct rpc_pipe_client *cli,
436 TALLOC_CTX *mem_ctx,
437 WERROR *werror)
438{
439 struct PNP_GetDeviceList r;
440 NTSTATUS status;
441
442 /* In parameters */
443
444 if (DEBUGLEVEL >= 10) {
445 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, &r);
446 }
447
448 status = cli_do_rpc_ndr(cli,
449 mem_ctx,
450 PI_NTSVCS,
451 &ndr_table_ntsvcs,
452 NDR_PNP_GETDEVICELIST,
453 &r);
454
455 if (!NT_STATUS_IS_OK(status)) {
456 return status;
457 }
458
459 if (DEBUGLEVEL >= 10) {
460 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, &r);
461 }
462
463 if (NT_STATUS_IS_ERR(status)) {
464 return status;
465 }
466
467 /* Return variables */
468
469 /* Return result */
470 if (werror) {
471 *werror = r.out.result;
472 }
473
474 return werror_to_ntstatus(r.out.result);
475}
476
477NTSTATUS rpccli_PNP_GetDeviceListSize(struct rpc_pipe_client *cli,
478 TALLOC_CTX *mem_ctx,
479 const char *devicename /* [in] [unique,charset(UTF16)] */,
480 uint32_t *size /* [out] [ref] */,
481 uint32_t flags /* [in] */,
482 WERROR *werror)
483{
484 struct PNP_GetDeviceListSize r;
485 NTSTATUS status;
486
487 /* In parameters */
488 r.in.devicename = devicename;
489 r.in.flags = flags;
490
491 if (DEBUGLEVEL >= 10) {
492 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, &r);
493 }
494
495 status = cli_do_rpc_ndr(cli,
496 mem_ctx,
497 PI_NTSVCS,
498 &ndr_table_ntsvcs,
499 NDR_PNP_GETDEVICELISTSIZE,
500 &r);
501
502 if (!NT_STATUS_IS_OK(status)) {
503 return status;
504 }
505
506 if (DEBUGLEVEL >= 10) {
507 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, &r);
508 }
509
510 if (NT_STATUS_IS_ERR(status)) {
511 return status;
512 }
513
514 /* Return variables */
515 *size = *r.out.size;
516
517 /* Return result */
518 if (werror) {
519 *werror = r.out.result;
520 }
521
522 return werror_to_ntstatus(r.out.result);
523}
524
525NTSTATUS rpccli_PNP_GetDepth(struct rpc_pipe_client *cli,
526 TALLOC_CTX *mem_ctx,
527 WERROR *werror)
528{
529 struct PNP_GetDepth r;
530 NTSTATUS status;
531
532 /* In parameters */
533
534 if (DEBUGLEVEL >= 10) {
535 NDR_PRINT_IN_DEBUG(PNP_GetDepth, &r);
536 }
537
538 status = cli_do_rpc_ndr(cli,
539 mem_ctx,
540 PI_NTSVCS,
541 &ndr_table_ntsvcs,
542 NDR_PNP_GETDEPTH,
543 &r);
544
545 if (!NT_STATUS_IS_OK(status)) {
546 return status;
547 }
548
549 if (DEBUGLEVEL >= 10) {
550 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, &r);
551 }
552
553 if (NT_STATUS_IS_ERR(status)) {
554 return status;
555 }
556
557 /* Return variables */
558
559 /* Return result */
560 if (werror) {
561 *werror = r.out.result;
562 }
563
564 return werror_to_ntstatus(r.out.result);
565}
566
567NTSTATUS rpccli_PNP_GetDeviceRegProp(struct rpc_pipe_client *cli,
568 TALLOC_CTX *mem_ctx,
569 WERROR *werror)
570{
571 struct PNP_GetDeviceRegProp r;
572 NTSTATUS status;
573
574 /* In parameters */
575
576 if (DEBUGLEVEL >= 10) {
577 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &r);
578 }
579
580 status = cli_do_rpc_ndr(cli,
581 mem_ctx,
582 PI_NTSVCS,
583 &ndr_table_ntsvcs,
584 NDR_PNP_GETDEVICEREGPROP,
585 &r);
586
587 if (!NT_STATUS_IS_OK(status)) {
588 return status;
589 }
590
591 if (DEBUGLEVEL >= 10) {
592 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &r);
593 }
594
595 if (NT_STATUS_IS_ERR(status)) {
596 return status;
597 }
598
599 /* Return variables */
600
601 /* Return result */
602 if (werror) {
603 *werror = r.out.result;
604 }
605
606 return werror_to_ntstatus(r.out.result);
607}
608
609NTSTATUS rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client *cli,
610 TALLOC_CTX *mem_ctx,
611 WERROR *werror)
612{
613 struct PNP_SetDeviceRegProp r;
614 NTSTATUS status;
615
616 /* In parameters */
617
618 if (DEBUGLEVEL >= 10) {
619 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, &r);
620 }
621
622 status = cli_do_rpc_ndr(cli,
623 mem_ctx,
624 PI_NTSVCS,
625 &ndr_table_ntsvcs,
626 NDR_PNP_SETDEVICEREGPROP,
627 &r);
628
629 if (!NT_STATUS_IS_OK(status)) {
630 return status;
631 }
632
633 if (DEBUGLEVEL >= 10) {
634 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, &r);
635 }
636
637 if (NT_STATUS_IS_ERR(status)) {
638 return status;
639 }
640
641 /* Return variables */
642
643 /* Return result */
644 if (werror) {
645 *werror = r.out.result;
646 }
647
648 return werror_to_ntstatus(r.out.result);
649}
650
651NTSTATUS rpccli_PNP_GetClassInstance(struct rpc_pipe_client *cli,
652 TALLOC_CTX *mem_ctx,
653 WERROR *werror)
654{
655 struct PNP_GetClassInstance r;
656 NTSTATUS status;
657
658 /* In parameters */
659
660 if (DEBUGLEVEL >= 10) {
661 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, &r);
662 }
663
664 status = cli_do_rpc_ndr(cli,
665 mem_ctx,
666 PI_NTSVCS,
667 &ndr_table_ntsvcs,
668 NDR_PNP_GETCLASSINSTANCE,
669 &r);
670
671 if (!NT_STATUS_IS_OK(status)) {
672 return status;
673 }
674
675 if (DEBUGLEVEL >= 10) {
676 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, &r);
677 }
678
679 if (NT_STATUS_IS_ERR(status)) {
680 return status;
681 }
682
683 /* Return variables */
684
685 /* Return result */
686 if (werror) {
687 *werror = r.out.result;
688 }
689
690 return werror_to_ntstatus(r.out.result);
691}
692
693NTSTATUS rpccli_PNP_CreateKey(struct rpc_pipe_client *cli,
694 TALLOC_CTX *mem_ctx,
695 WERROR *werror)
696{
697 struct PNP_CreateKey r;
698 NTSTATUS status;
699
700 /* In parameters */
701
702 if (DEBUGLEVEL >= 10) {
703 NDR_PRINT_IN_DEBUG(PNP_CreateKey, &r);
704 }
705
706 status = cli_do_rpc_ndr(cli,
707 mem_ctx,
708 PI_NTSVCS,
709 &ndr_table_ntsvcs,
710 NDR_PNP_CREATEKEY,
711 &r);
712
713 if (!NT_STATUS_IS_OK(status)) {
714 return status;
715 }
716
717 if (DEBUGLEVEL >= 10) {
718 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, &r);
719 }
720
721 if (NT_STATUS_IS_ERR(status)) {
722 return status;
723 }
724
725 /* Return variables */
726
727 /* Return result */
728 if (werror) {
729 *werror = r.out.result;
730 }
731
732 return werror_to_ntstatus(r.out.result);
733}
734
735NTSTATUS rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client *cli,
736 TALLOC_CTX *mem_ctx,
737 WERROR *werror)
738{
739 struct PNP_DeleteRegistryKey r;
740 NTSTATUS status;
741
742 /* In parameters */
743
744 if (DEBUGLEVEL >= 10) {
745 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, &r);
746 }
747
748 status = cli_do_rpc_ndr(cli,
749 mem_ctx,
750 PI_NTSVCS,
751 &ndr_table_ntsvcs,
752 NDR_PNP_DELETEREGISTRYKEY,
753 &r);
754
755 if (!NT_STATUS_IS_OK(status)) {
756 return status;
757 }
758
759 if (DEBUGLEVEL >= 10) {
760 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, &r);
761 }
762
763 if (NT_STATUS_IS_ERR(status)) {
764 return status;
765 }
766
767 /* Return variables */
768
769 /* Return result */
770 if (werror) {
771 *werror = r.out.result;
772 }
773
774 return werror_to_ntstatus(r.out.result);
775}
776
777NTSTATUS rpccli_PNP_GetClassCount(struct rpc_pipe_client *cli,
778 TALLOC_CTX *mem_ctx,
779 WERROR *werror)
780{
781 struct PNP_GetClassCount r;
782 NTSTATUS status;
783
784 /* In parameters */
785
786 if (DEBUGLEVEL >= 10) {
787 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, &r);
788 }
789
790 status = cli_do_rpc_ndr(cli,
791 mem_ctx,
792 PI_NTSVCS,
793 &ndr_table_ntsvcs,
794 NDR_PNP_GETCLASSCOUNT,
795 &r);
796
797 if (!NT_STATUS_IS_OK(status)) {
798 return status;
799 }
800
801 if (DEBUGLEVEL >= 10) {
802 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, &r);
803 }
804
805 if (NT_STATUS_IS_ERR(status)) {
806 return status;
807 }
808
809 /* Return variables */
810
811 /* Return result */
812 if (werror) {
813 *werror = r.out.result;
814 }
815
816 return werror_to_ntstatus(r.out.result);
817}
818
819NTSTATUS rpccli_PNP_GetClassName(struct rpc_pipe_client *cli,
820 TALLOC_CTX *mem_ctx,
821 WERROR *werror)
822{
823 struct PNP_GetClassName r;
824 NTSTATUS status;
825
826 /* In parameters */
827
828 if (DEBUGLEVEL >= 10) {
829 NDR_PRINT_IN_DEBUG(PNP_GetClassName, &r);
830 }
831
832 status = cli_do_rpc_ndr(cli,
833 mem_ctx,
834 PI_NTSVCS,
835 &ndr_table_ntsvcs,
836 NDR_PNP_GETCLASSNAME,
837 &r);
838
839 if (!NT_STATUS_IS_OK(status)) {
840 return status;
841 }
842
843 if (DEBUGLEVEL >= 10) {
844 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, &r);
845 }
846
847 if (NT_STATUS_IS_ERR(status)) {
848 return status;
849 }
850
851 /* Return variables */
852
853 /* Return result */
854 if (werror) {
855 *werror = r.out.result;
856 }
857
858 return werror_to_ntstatus(r.out.result);
859}
860
861NTSTATUS rpccli_PNP_DeleteClassKey(struct rpc_pipe_client *cli,
862 TALLOC_CTX *mem_ctx,
863 WERROR *werror)
864{
865 struct PNP_DeleteClassKey r;
866 NTSTATUS status;
867
868 /* In parameters */
869
870 if (DEBUGLEVEL >= 10) {
871 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, &r);
872 }
873
874 status = cli_do_rpc_ndr(cli,
875 mem_ctx,
876 PI_NTSVCS,
877 &ndr_table_ntsvcs,
878 NDR_PNP_DELETECLASSKEY,
879 &r);
880
881 if (!NT_STATUS_IS_OK(status)) {
882 return status;
883 }
884
885 if (DEBUGLEVEL >= 10) {
886 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, &r);
887 }
888
889 if (NT_STATUS_IS_ERR(status)) {
890 return status;
891 }
892
893 /* Return variables */
894
895 /* Return result */
896 if (werror) {
897 *werror = r.out.result;
898 }
899
900 return werror_to_ntstatus(r.out.result);
901}
902
903NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client *cli,
904 TALLOC_CTX *mem_ctx,
905 WERROR *werror)
906{
907 struct PNP_GetInterfaceDeviceAlias r;
908 NTSTATUS status;
909
910 /* In parameters */
911
912 if (DEBUGLEVEL >= 10) {
913 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
914 }
915
916 status = cli_do_rpc_ndr(cli,
917 mem_ctx,
918 PI_NTSVCS,
919 &ndr_table_ntsvcs,
920 NDR_PNP_GETINTERFACEDEVICEALIAS,
921 &r);
922
923 if (!NT_STATUS_IS_OK(status)) {
924 return status;
925 }
926
927 if (DEBUGLEVEL >= 10) {
928 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, &r);
929 }
930
931 if (NT_STATUS_IS_ERR(status)) {
932 return status;
933 }
934
935 /* Return variables */
936
937 /* Return result */
938 if (werror) {
939 *werror = r.out.result;
940 }
941
942 return werror_to_ntstatus(r.out.result);
943}
944
945NTSTATUS rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client *cli,
946 TALLOC_CTX *mem_ctx,
947 WERROR *werror)
948{
949 struct PNP_GetInterfaceDeviceList r;
950 NTSTATUS status;
951
952 /* In parameters */
953
954 if (DEBUGLEVEL >= 10) {
955 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, &r);
956 }
957
958 status = cli_do_rpc_ndr(cli,
959 mem_ctx,
960 PI_NTSVCS,
961 &ndr_table_ntsvcs,
962 NDR_PNP_GETINTERFACEDEVICELIST,
963 &r);
964
965 if (!NT_STATUS_IS_OK(status)) {
966 return status;
967 }
968
969 if (DEBUGLEVEL >= 10) {
970 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, &r);
971 }
972
973 if (NT_STATUS_IS_ERR(status)) {
974 return status;
975 }
976
977 /* Return variables */
978
979 /* Return result */
980 if (werror) {
981 *werror = r.out.result;
982 }
983
984 return werror_to_ntstatus(r.out.result);
985}
986
987NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client *cli,
988 TALLOC_CTX *mem_ctx,
989 WERROR *werror)
990{
991 struct PNP_GetInterfaceDeviceListSize r;
992 NTSTATUS status;
993
994 /* In parameters */
995
996 if (DEBUGLEVEL >= 10) {
997 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
998 }
999
1000 status = cli_do_rpc_ndr(cli,
1001 mem_ctx,
1002 PI_NTSVCS,
1003 &ndr_table_ntsvcs,
1004 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
1005 &r);
1006
1007 if (!NT_STATUS_IS_OK(status)) {
1008 return status;
1009 }
1010
1011 if (DEBUGLEVEL >= 10) {
1012 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, &r);
1013 }
1014
1015 if (NT_STATUS_IS_ERR(status)) {
1016 return status;
1017 }
1018
1019 /* Return variables */
1020
1021 /* Return result */
1022 if (werror) {
1023 *werror = r.out.result;
1024 }
1025
1026 return werror_to_ntstatus(r.out.result);
1027}
1028
1029NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1030 TALLOC_CTX *mem_ctx,
1031 WERROR *werror)
1032{
1033 struct PNP_RegisterDeviceClassAssociation r;
1034 NTSTATUS status;
1035
1036 /* In parameters */
1037
1038 if (DEBUGLEVEL >= 10) {
1039 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1040 }
1041
1042 status = cli_do_rpc_ndr(cli,
1043 mem_ctx,
1044 PI_NTSVCS,
1045 &ndr_table_ntsvcs,
1046 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
1047 &r);
1048
1049 if (!NT_STATUS_IS_OK(status)) {
1050 return status;
1051 }
1052
1053 if (DEBUGLEVEL >= 10) {
1054 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, &r);
1055 }
1056
1057 if (NT_STATUS_IS_ERR(status)) {
1058 return status;
1059 }
1060
1061 /* Return variables */
1062
1063 /* Return result */
1064 if (werror) {
1065 *werror = r.out.result;
1066 }
1067
1068 return werror_to_ntstatus(r.out.result);
1069}
1070
1071NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client *cli,
1072 TALLOC_CTX *mem_ctx,
1073 WERROR *werror)
1074{
1075 struct PNP_UnregisterDeviceClassAssociation r;
1076 NTSTATUS status;
1077
1078 /* In parameters */
1079
1080 if (DEBUGLEVEL >= 10) {
1081 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
1082 }
1083
1084 status = cli_do_rpc_ndr(cli,
1085 mem_ctx,
1086 PI_NTSVCS,
1087 &ndr_table_ntsvcs,
1088 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
1089 &r);
1090
1091 if (!NT_STATUS_IS_OK(status)) {
1092 return status;
1093 }
1094
1095 if (DEBUGLEVEL >= 10) {
1096 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, &r);
1097 }
1098
1099 if (NT_STATUS_IS_ERR(status)) {
1100 return status;
1101 }
1102
1103 /* Return variables */
1104
1105 /* Return result */
1106 if (werror) {
1107 *werror = r.out.result;
1108 }
1109
1110 return werror_to_ntstatus(r.out.result);
1111}
1112
1113NTSTATUS rpccli_PNP_GetClassRegProp(struct rpc_pipe_client *cli,
1114 TALLOC_CTX *mem_ctx,
1115 WERROR *werror)
1116{
1117 struct PNP_GetClassRegProp r;
1118 NTSTATUS status;
1119
1120 /* In parameters */
1121
1122 if (DEBUGLEVEL >= 10) {
1123 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, &r);
1124 }
1125
1126 status = cli_do_rpc_ndr(cli,
1127 mem_ctx,
1128 PI_NTSVCS,
1129 &ndr_table_ntsvcs,
1130 NDR_PNP_GETCLASSREGPROP,
1131 &r);
1132
1133 if (!NT_STATUS_IS_OK(status)) {
1134 return status;
1135 }
1136
1137 if (DEBUGLEVEL >= 10) {
1138 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, &r);
1139 }
1140
1141 if (NT_STATUS_IS_ERR(status)) {
1142 return status;
1143 }
1144
1145 /* Return variables */
1146
1147 /* Return result */
1148 if (werror) {
1149 *werror = r.out.result;
1150 }
1151
1152 return werror_to_ntstatus(r.out.result);
1153}
1154
1155NTSTATUS rpccli_PNP_SetClassRegProp(struct rpc_pipe_client *cli,
1156 TALLOC_CTX *mem_ctx,
1157 WERROR *werror)
1158{
1159 struct PNP_SetClassRegProp r;
1160 NTSTATUS status;
1161
1162 /* In parameters */
1163
1164 if (DEBUGLEVEL >= 10) {
1165 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, &r);
1166 }
1167
1168 status = cli_do_rpc_ndr(cli,
1169 mem_ctx,
1170 PI_NTSVCS,
1171 &ndr_table_ntsvcs,
1172 NDR_PNP_SETCLASSREGPROP,
1173 &r);
1174
1175 if (!NT_STATUS_IS_OK(status)) {
1176 return status;
1177 }
1178
1179 if (DEBUGLEVEL >= 10) {
1180 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, &r);
1181 }
1182
1183 if (NT_STATUS_IS_ERR(status)) {
1184 return status;
1185 }
1186
1187 /* Return variables */
1188
1189 /* Return result */
1190 if (werror) {
1191 *werror = r.out.result;
1192 }
1193
1194 return werror_to_ntstatus(r.out.result);
1195}
1196
1197NTSTATUS rpccli_PNP_CreateDevInst(struct rpc_pipe_client *cli,
1198 TALLOC_CTX *mem_ctx,
1199 WERROR *werror)
1200{
1201 struct PNP_CreateDevInst r;
1202 NTSTATUS status;
1203
1204 /* In parameters */
1205
1206 if (DEBUGLEVEL >= 10) {
1207 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, &r);
1208 }
1209
1210 status = cli_do_rpc_ndr(cli,
1211 mem_ctx,
1212 PI_NTSVCS,
1213 &ndr_table_ntsvcs,
1214 NDR_PNP_CREATEDEVINST,
1215 &r);
1216
1217 if (!NT_STATUS_IS_OK(status)) {
1218 return status;
1219 }
1220
1221 if (DEBUGLEVEL >= 10) {
1222 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, &r);
1223 }
1224
1225 if (NT_STATUS_IS_ERR(status)) {
1226 return status;
1227 }
1228
1229 /* Return variables */
1230
1231 /* Return result */
1232 if (werror) {
1233 *werror = r.out.result;
1234 }
1235
1236 return werror_to_ntstatus(r.out.result);
1237}
1238
1239NTSTATUS rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client *cli,
1240 TALLOC_CTX *mem_ctx,
1241 WERROR *werror)
1242{
1243 struct PNP_DeviceInstanceAction r;
1244 NTSTATUS status;
1245
1246 /* In parameters */
1247
1248 if (DEBUGLEVEL >= 10) {
1249 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, &r);
1250 }
1251
1252 status = cli_do_rpc_ndr(cli,
1253 mem_ctx,
1254 PI_NTSVCS,
1255 &ndr_table_ntsvcs,
1256 NDR_PNP_DEVICEINSTANCEACTION,
1257 &r);
1258
1259 if (!NT_STATUS_IS_OK(status)) {
1260 return status;
1261 }
1262
1263 if (DEBUGLEVEL >= 10) {
1264 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, &r);
1265 }
1266
1267 if (NT_STATUS_IS_ERR(status)) {
1268 return status;
1269 }
1270
1271 /* Return variables */
1272
1273 /* Return result */
1274 if (werror) {
1275 *werror = r.out.result;
1276 }
1277
1278 return werror_to_ntstatus(r.out.result);
1279}
1280
1281NTSTATUS rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client *cli,
1282 TALLOC_CTX *mem_ctx,
1283 WERROR *werror)
1284{
1285 struct PNP_GetDeviceStatus r;
1286 NTSTATUS status;
1287
1288 /* In parameters */
1289
1290 if (DEBUGLEVEL >= 10) {
1291 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, &r);
1292 }
1293
1294 status = cli_do_rpc_ndr(cli,
1295 mem_ctx,
1296 PI_NTSVCS,
1297 &ndr_table_ntsvcs,
1298 NDR_PNP_GETDEVICESTATUS,
1299 &r);
1300
1301 if (!NT_STATUS_IS_OK(status)) {
1302 return status;
1303 }
1304
1305 if (DEBUGLEVEL >= 10) {
1306 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, &r);
1307 }
1308
1309 if (NT_STATUS_IS_ERR(status)) {
1310 return status;
1311 }
1312
1313 /* Return variables */
1314
1315 /* Return result */
1316 if (werror) {
1317 *werror = r.out.result;
1318 }
1319
1320 return werror_to_ntstatus(r.out.result);
1321}
1322
1323NTSTATUS rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client *cli,
1324 TALLOC_CTX *mem_ctx,
1325 WERROR *werror)
1326{
1327 struct PNP_SetDeviceProblem r;
1328 NTSTATUS status;
1329
1330 /* In parameters */
1331
1332 if (DEBUGLEVEL >= 10) {
1333 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, &r);
1334 }
1335
1336 status = cli_do_rpc_ndr(cli,
1337 mem_ctx,
1338 PI_NTSVCS,
1339 &ndr_table_ntsvcs,
1340 NDR_PNP_SETDEVICEPROBLEM,
1341 &r);
1342
1343 if (!NT_STATUS_IS_OK(status)) {
1344 return status;
1345 }
1346
1347 if (DEBUGLEVEL >= 10) {
1348 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, &r);
1349 }
1350
1351 if (NT_STATUS_IS_ERR(status)) {
1352 return status;
1353 }
1354
1355 /* Return variables */
1356
1357 /* Return result */
1358 if (werror) {
1359 *werror = r.out.result;
1360 }
1361
1362 return werror_to_ntstatus(r.out.result);
1363}
1364
1365NTSTATUS rpccli_PNP_DisableDevInst(struct rpc_pipe_client *cli,
1366 TALLOC_CTX *mem_ctx,
1367 WERROR *werror)
1368{
1369 struct PNP_DisableDevInst r;
1370 NTSTATUS status;
1371
1372 /* In parameters */
1373
1374 if (DEBUGLEVEL >= 10) {
1375 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, &r);
1376 }
1377
1378 status = cli_do_rpc_ndr(cli,
1379 mem_ctx,
1380 PI_NTSVCS,
1381 &ndr_table_ntsvcs,
1382 NDR_PNP_DISABLEDEVINST,
1383 &r);
1384
1385 if (!NT_STATUS_IS_OK(status)) {
1386 return status;
1387 }
1388
1389 if (DEBUGLEVEL >= 10) {
1390 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, &r);
1391 }
1392
1393 if (NT_STATUS_IS_ERR(status)) {
1394 return status;
1395 }
1396
1397 /* Return variables */
1398
1399 /* Return result */
1400 if (werror) {
1401 *werror = r.out.result;
1402 }
1403
1404 return werror_to_ntstatus(r.out.result);
1405}
1406
1407NTSTATUS rpccli_PNP_UninstallDevInst(struct rpc_pipe_client *cli,
1408 TALLOC_CTX *mem_ctx,
1409 WERROR *werror)
1410{
1411 struct PNP_UninstallDevInst r;
1412 NTSTATUS status;
1413
1414 /* In parameters */
1415
1416 if (DEBUGLEVEL >= 10) {
1417 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, &r);
1418 }
1419
1420 status = cli_do_rpc_ndr(cli,
1421 mem_ctx,
1422 PI_NTSVCS,
1423 &ndr_table_ntsvcs,
1424 NDR_PNP_UNINSTALLDEVINST,
1425 &r);
1426
1427 if (!NT_STATUS_IS_OK(status)) {
1428 return status;
1429 }
1430
1431 if (DEBUGLEVEL >= 10) {
1432 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, &r);
1433 }
1434
1435 if (NT_STATUS_IS_ERR(status)) {
1436 return status;
1437 }
1438
1439 /* Return variables */
1440
1441 /* Return result */
1442 if (werror) {
1443 *werror = r.out.result;
1444 }
1445
1446 return werror_to_ntstatus(r.out.result);
1447}
1448
1449NTSTATUS rpccli_PNP_AddID(struct rpc_pipe_client *cli,
1450 TALLOC_CTX *mem_ctx,
1451 WERROR *werror)
1452{
1453 struct PNP_AddID r;
1454 NTSTATUS status;
1455
1456 /* In parameters */
1457
1458 if (DEBUGLEVEL >= 10) {
1459 NDR_PRINT_IN_DEBUG(PNP_AddID, &r);
1460 }
1461
1462 status = cli_do_rpc_ndr(cli,
1463 mem_ctx,
1464 PI_NTSVCS,
1465 &ndr_table_ntsvcs,
1466 NDR_PNP_ADDID,
1467 &r);
1468
1469 if (!NT_STATUS_IS_OK(status)) {
1470 return status;
1471 }
1472
1473 if (DEBUGLEVEL >= 10) {
1474 NDR_PRINT_OUT_DEBUG(PNP_AddID, &r);
1475 }
1476
1477 if (NT_STATUS_IS_ERR(status)) {
1478 return status;
1479 }
1480
1481 /* Return variables */
1482
1483 /* Return result */
1484 if (werror) {
1485 *werror = r.out.result;
1486 }
1487
1488 return werror_to_ntstatus(r.out.result);
1489}
1490
1491NTSTATUS rpccli_PNP_RegisterDriver(struct rpc_pipe_client *cli,
1492 TALLOC_CTX *mem_ctx,
1493 WERROR *werror)
1494{
1495 struct PNP_RegisterDriver r;
1496 NTSTATUS status;
1497
1498 /* In parameters */
1499
1500 if (DEBUGLEVEL >= 10) {
1501 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, &r);
1502 }
1503
1504 status = cli_do_rpc_ndr(cli,
1505 mem_ctx,
1506 PI_NTSVCS,
1507 &ndr_table_ntsvcs,
1508 NDR_PNP_REGISTERDRIVER,
1509 &r);
1510
1511 if (!NT_STATUS_IS_OK(status)) {
1512 return status;
1513 }
1514
1515 if (DEBUGLEVEL >= 10) {
1516 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, &r);
1517 }
1518
1519 if (NT_STATUS_IS_ERR(status)) {
1520 return status;
1521 }
1522
1523 /* Return variables */
1524
1525 /* Return result */
1526 if (werror) {
1527 *werror = r.out.result;
1528 }
1529
1530 return werror_to_ntstatus(r.out.result);
1531}
1532
1533NTSTATUS rpccli_PNP_QueryRemove(struct rpc_pipe_client *cli,
1534 TALLOC_CTX *mem_ctx,
1535 WERROR *werror)
1536{
1537 struct PNP_QueryRemove r;
1538 NTSTATUS status;
1539
1540 /* In parameters */
1541
1542 if (DEBUGLEVEL >= 10) {
1543 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, &r);
1544 }
1545
1546 status = cli_do_rpc_ndr(cli,
1547 mem_ctx,
1548 PI_NTSVCS,
1549 &ndr_table_ntsvcs,
1550 NDR_PNP_QUERYREMOVE,
1551 &r);
1552
1553 if (!NT_STATUS_IS_OK(status)) {
1554 return status;
1555 }
1556
1557 if (DEBUGLEVEL >= 10) {
1558 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, &r);
1559 }
1560
1561 if (NT_STATUS_IS_ERR(status)) {
1562 return status;
1563 }
1564
1565 /* Return variables */
1566
1567 /* Return result */
1568 if (werror) {
1569 *werror = r.out.result;
1570 }
1571
1572 return werror_to_ntstatus(r.out.result);
1573}
1574
1575NTSTATUS rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client *cli,
1576 TALLOC_CTX *mem_ctx,
1577 WERROR *werror)
1578{
1579 struct PNP_RequestDeviceEject r;
1580 NTSTATUS status;
1581
1582 /* In parameters */
1583
1584 if (DEBUGLEVEL >= 10) {
1585 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, &r);
1586 }
1587
1588 status = cli_do_rpc_ndr(cli,
1589 mem_ctx,
1590 PI_NTSVCS,
1591 &ndr_table_ntsvcs,
1592 NDR_PNP_REQUESTDEVICEEJECT,
1593 &r);
1594
1595 if (!NT_STATUS_IS_OK(status)) {
1596 return status;
1597 }
1598
1599 if (DEBUGLEVEL >= 10) {
1600 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, &r);
1601 }
1602
1603 if (NT_STATUS_IS_ERR(status)) {
1604 return status;
1605 }
1606
1607 /* Return variables */
1608
1609 /* Return result */
1610 if (werror) {
1611 *werror = r.out.result;
1612 }
1613
1614 return werror_to_ntstatus(r.out.result);
1615}
1616
1617NTSTATUS rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client *cli,
1618 TALLOC_CTX *mem_ctx,
1619 WERROR *werror)
1620{
1621 struct PNP_IsDockStationPresent r;
1622 NTSTATUS status;
1623
1624 /* In parameters */
1625
1626 if (DEBUGLEVEL >= 10) {
1627 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, &r);
1628 }
1629
1630 status = cli_do_rpc_ndr(cli,
1631 mem_ctx,
1632 PI_NTSVCS,
1633 &ndr_table_ntsvcs,
1634 NDR_PNP_ISDOCKSTATIONPRESENT,
1635 &r);
1636
1637 if (!NT_STATUS_IS_OK(status)) {
1638 return status;
1639 }
1640
1641 if (DEBUGLEVEL >= 10) {
1642 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, &r);
1643 }
1644
1645 if (NT_STATUS_IS_ERR(status)) {
1646 return status;
1647 }
1648
1649 /* Return variables */
1650
1651 /* Return result */
1652 if (werror) {
1653 *werror = r.out.result;
1654 }
1655
1656 return werror_to_ntstatus(r.out.result);
1657}
1658
1659NTSTATUS rpccli_PNP_RequestEjectPC(struct rpc_pipe_client *cli,
1660 TALLOC_CTX *mem_ctx,
1661 WERROR *werror)
1662{
1663 struct PNP_RequestEjectPC r;
1664 NTSTATUS status;
1665
1666 /* In parameters */
1667
1668 if (DEBUGLEVEL >= 10) {
1669 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, &r);
1670 }
1671
1672 status = cli_do_rpc_ndr(cli,
1673 mem_ctx,
1674 PI_NTSVCS,
1675 &ndr_table_ntsvcs,
1676 NDR_PNP_REQUESTEJECTPC,
1677 &r);
1678
1679 if (!NT_STATUS_IS_OK(status)) {
1680 return status;
1681 }
1682
1683 if (DEBUGLEVEL >= 10) {
1684 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, &r);
1685 }
1686
1687 if (NT_STATUS_IS_ERR(status)) {
1688 return status;
1689 }
1690
1691 /* Return variables */
1692
1693 /* Return result */
1694 if (werror) {
1695 *werror = r.out.result;
1696 }
1697
1698 return werror_to_ntstatus(r.out.result);
1699}
1700
1701NTSTATUS rpccli_PNP_HwProfFlags(struct rpc_pipe_client *cli,
1702 TALLOC_CTX *mem_ctx,
1703 uint32_t unknown1 /* [in] */,
1704 const char *devicepath /* [in] [ref,charset(UTF16)] */,
1705 uint32_t unknown2 /* [in] */,
1706 uint32_t *unknown3 /* [in,out] [ref] */,
1707 uint16_t *unknown4 /* [in,out] [unique] */,
1708 const char *unknown5 /* [in] [unique,charset(UTF16)] */,
1709 const char **unknown5a /* [out] [unique,charset(UTF16)] */,
1710 uint32_t unknown6 /* [in] */,
1711 uint32_t unknown7 /* [in] */,
1712 WERROR *werror)
1713{
1714 struct PNP_HwProfFlags r;
1715 NTSTATUS status;
1716
1717 /* In parameters */
1718 r.in.unknown1 = unknown1;
1719 r.in.devicepath = devicepath;
1720 r.in.unknown2 = unknown2;
1721 r.in.unknown3 = unknown3;
1722 r.in.unknown4 = unknown4;
1723 r.in.unknown5 = unknown5;
1724 r.in.unknown6 = unknown6;
1725 r.in.unknown7 = unknown7;
1726
1727 if (DEBUGLEVEL >= 10) {
1728 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, &r);
1729 }
1730
1731 status = cli_do_rpc_ndr(cli,
1732 mem_ctx,
1733 PI_NTSVCS,
1734 &ndr_table_ntsvcs,
1735 NDR_PNP_HWPROFFLAGS,
1736 &r);
1737
1738 if (!NT_STATUS_IS_OK(status)) {
1739 return status;
1740 }
1741
1742 if (DEBUGLEVEL >= 10) {
1743 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, &r);
1744 }
1745
1746 if (NT_STATUS_IS_ERR(status)) {
1747 return status;
1748 }
1749
1750 /* Return variables */
1751 *unknown3 = *r.out.unknown3;
1752 if (unknown4 && r.out.unknown4) {
1753 *unknown4 = *r.out.unknown4;
1754 }
1755 if (unknown5a && r.out.unknown5a) {
1756 *unknown5a = *r.out.unknown5a;
1757 }
1758
1759 /* Return result */
1760 if (werror) {
1761 *werror = r.out.result;
1762 }
1763
1764 return werror_to_ntstatus(r.out.result);
1765}
1766
1767NTSTATUS rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client *cli,
1768 TALLOC_CTX *mem_ctx,
1769 uint32_t idx /* [in] */,
1770 struct PNP_HwProfInfo *info /* [in,out] [ref] */,
1771 uint32_t size /* [in] */,
1772 uint32_t flags /* [in] */,
1773 WERROR *werror)
1774{
1775 struct PNP_GetHwProfInfo r;
1776 NTSTATUS status;
1777
1778 /* In parameters */
1779 r.in.idx = idx;
1780 r.in.info = info;
1781 r.in.size = size;
1782 r.in.flags = flags;
1783
1784 if (DEBUGLEVEL >= 10) {
1785 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &r);
1786 }
1787
1788 status = cli_do_rpc_ndr(cli,
1789 mem_ctx,
1790 PI_NTSVCS,
1791 &ndr_table_ntsvcs,
1792 NDR_PNP_GETHWPROFINFO,
1793 &r);
1794
1795 if (!NT_STATUS_IS_OK(status)) {
1796 return status;
1797 }
1798
1799 if (DEBUGLEVEL >= 10) {
1800 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &r);
1801 }
1802
1803 if (NT_STATUS_IS_ERR(status)) {
1804 return status;
1805 }
1806
1807 /* Return variables */
1808 *info = *r.out.info;
1809
1810 /* Return result */
1811 if (werror) {
1812 *werror = r.out.result;
1813 }
1814
1815 return werror_to_ntstatus(r.out.result);
1816}
1817
1818NTSTATUS rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client *cli,
1819 TALLOC_CTX *mem_ctx,
1820 WERROR *werror)
1821{
1822 struct PNP_AddEmptyLogConf r;
1823 NTSTATUS status;
1824
1825 /* In parameters */
1826
1827 if (DEBUGLEVEL >= 10) {
1828 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, &r);
1829 }
1830
1831 status = cli_do_rpc_ndr(cli,
1832 mem_ctx,
1833 PI_NTSVCS,
1834 &ndr_table_ntsvcs,
1835 NDR_PNP_ADDEMPTYLOGCONF,
1836 &r);
1837
1838 if (!NT_STATUS_IS_OK(status)) {
1839 return status;
1840 }
1841
1842 if (DEBUGLEVEL >= 10) {
1843 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, &r);
1844 }
1845
1846 if (NT_STATUS_IS_ERR(status)) {
1847 return status;
1848 }
1849
1850 /* Return variables */
1851
1852 /* Return result */
1853 if (werror) {
1854 *werror = r.out.result;
1855 }
1856
1857 return werror_to_ntstatus(r.out.result);
1858}
1859
1860NTSTATUS rpccli_PNP_FreeLogConf(struct rpc_pipe_client *cli,
1861 TALLOC_CTX *mem_ctx,
1862 WERROR *werror)
1863{
1864 struct PNP_FreeLogConf r;
1865 NTSTATUS status;
1866
1867 /* In parameters */
1868
1869 if (DEBUGLEVEL >= 10) {
1870 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, &r);
1871 }
1872
1873 status = cli_do_rpc_ndr(cli,
1874 mem_ctx,
1875 PI_NTSVCS,
1876 &ndr_table_ntsvcs,
1877 NDR_PNP_FREELOGCONF,
1878 &r);
1879
1880 if (!NT_STATUS_IS_OK(status)) {
1881 return status;
1882 }
1883
1884 if (DEBUGLEVEL >= 10) {
1885 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, &r);
1886 }
1887
1888 if (NT_STATUS_IS_ERR(status)) {
1889 return status;
1890 }
1891
1892 /* Return variables */
1893
1894 /* Return result */
1895 if (werror) {
1896 *werror = r.out.result;
1897 }
1898
1899 return werror_to_ntstatus(r.out.result);
1900}
1901
1902NTSTATUS rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client *cli,
1903 TALLOC_CTX *mem_ctx,
1904 WERROR *werror)
1905{
1906 struct PNP_GetFirstLogConf r;
1907 NTSTATUS status;
1908
1909 /* In parameters */
1910
1911 if (DEBUGLEVEL >= 10) {
1912 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, &r);
1913 }
1914
1915 status = cli_do_rpc_ndr(cli,
1916 mem_ctx,
1917 PI_NTSVCS,
1918 &ndr_table_ntsvcs,
1919 NDR_PNP_GETFIRSTLOGCONF,
1920 &r);
1921
1922 if (!NT_STATUS_IS_OK(status)) {
1923 return status;
1924 }
1925
1926 if (DEBUGLEVEL >= 10) {
1927 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, &r);
1928 }
1929
1930 if (NT_STATUS_IS_ERR(status)) {
1931 return status;
1932 }
1933
1934 /* Return variables */
1935
1936 /* Return result */
1937 if (werror) {
1938 *werror = r.out.result;
1939 }
1940
1941 return werror_to_ntstatus(r.out.result);
1942}
1943
1944NTSTATUS rpccli_PNP_GetNextLogConf(struct rpc_pipe_client *cli,
1945 TALLOC_CTX *mem_ctx,
1946 WERROR *werror)
1947{
1948 struct PNP_GetNextLogConf r;
1949 NTSTATUS status;
1950
1951 /* In parameters */
1952
1953 if (DEBUGLEVEL >= 10) {
1954 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, &r);
1955 }
1956
1957 status = cli_do_rpc_ndr(cli,
1958 mem_ctx,
1959 PI_NTSVCS,
1960 &ndr_table_ntsvcs,
1961 NDR_PNP_GETNEXTLOGCONF,
1962 &r);
1963
1964 if (!NT_STATUS_IS_OK(status)) {
1965 return status;
1966 }
1967
1968 if (DEBUGLEVEL >= 10) {
1969 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, &r);
1970 }
1971
1972 if (NT_STATUS_IS_ERR(status)) {
1973 return status;
1974 }
1975
1976 /* Return variables */
1977
1978 /* Return result */
1979 if (werror) {
1980 *werror = r.out.result;
1981 }
1982
1983 return werror_to_ntstatus(r.out.result);
1984}
1985
1986NTSTATUS rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client *cli,
1987 TALLOC_CTX *mem_ctx,
1988 WERROR *werror)
1989{
1990 struct PNP_GetLogConfPriority r;
1991 NTSTATUS status;
1992
1993 /* In parameters */
1994
1995 if (DEBUGLEVEL >= 10) {
1996 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, &r);
1997 }
1998
1999 status = cli_do_rpc_ndr(cli,
2000 mem_ctx,
2001 PI_NTSVCS,
2002 &ndr_table_ntsvcs,
2003 NDR_PNP_GETLOGCONFPRIORITY,
2004 &r);
2005
2006 if (!NT_STATUS_IS_OK(status)) {
2007 return status;
2008 }
2009
2010 if (DEBUGLEVEL >= 10) {
2011 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, &r);
2012 }
2013
2014 if (NT_STATUS_IS_ERR(status)) {
2015 return status;
2016 }
2017
2018 /* Return variables */
2019
2020 /* Return result */
2021 if (werror) {
2022 *werror = r.out.result;
2023 }
2024
2025 return werror_to_ntstatus(r.out.result);
2026}
2027
2028NTSTATUS rpccli_PNP_AddResDes(struct rpc_pipe_client *cli,
2029 TALLOC_CTX *mem_ctx,
2030 WERROR *werror)
2031{
2032 struct PNP_AddResDes r;
2033 NTSTATUS status;
2034
2035 /* In parameters */
2036
2037 if (DEBUGLEVEL >= 10) {
2038 NDR_PRINT_IN_DEBUG(PNP_AddResDes, &r);
2039 }
2040
2041 status = cli_do_rpc_ndr(cli,
2042 mem_ctx,
2043 PI_NTSVCS,
2044 &ndr_table_ntsvcs,
2045 NDR_PNP_ADDRESDES,
2046 &r);
2047
2048 if (!NT_STATUS_IS_OK(status)) {
2049 return status;
2050 }
2051
2052 if (DEBUGLEVEL >= 10) {
2053 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, &r);
2054 }
2055
2056 if (NT_STATUS_IS_ERR(status)) {
2057 return status;
2058 }
2059
2060 /* Return variables */
2061
2062 /* Return result */
2063 if (werror) {
2064 *werror = r.out.result;
2065 }
2066
2067 return werror_to_ntstatus(r.out.result);
2068}
2069
2070NTSTATUS rpccli_PNP_FreeResDes(struct rpc_pipe_client *cli,
2071 TALLOC_CTX *mem_ctx,
2072 WERROR *werror)
2073{
2074 struct PNP_FreeResDes r;
2075 NTSTATUS status;
2076
2077 /* In parameters */
2078
2079 if (DEBUGLEVEL >= 10) {
2080 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, &r);
2081 }
2082
2083 status = cli_do_rpc_ndr(cli,
2084 mem_ctx,
2085 PI_NTSVCS,
2086 &ndr_table_ntsvcs,
2087 NDR_PNP_FREERESDES,
2088 &r);
2089
2090 if (!NT_STATUS_IS_OK(status)) {
2091 return status;
2092 }
2093
2094 if (DEBUGLEVEL >= 10) {
2095 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, &r);
2096 }
2097
2098 if (NT_STATUS_IS_ERR(status)) {
2099 return status;
2100 }
2101
2102 /* Return variables */
2103
2104 /* Return result */
2105 if (werror) {
2106 *werror = r.out.result;
2107 }
2108
2109 return werror_to_ntstatus(r.out.result);
2110}
2111
2112NTSTATUS rpccli_PNP_GetNextResDes(struct rpc_pipe_client *cli,
2113 TALLOC_CTX *mem_ctx,
2114 WERROR *werror)
2115{
2116 struct PNP_GetNextResDes r;
2117 NTSTATUS status;
2118
2119 /* In parameters */
2120
2121 if (DEBUGLEVEL >= 10) {
2122 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, &r);
2123 }
2124
2125 status = cli_do_rpc_ndr(cli,
2126 mem_ctx,
2127 PI_NTSVCS,
2128 &ndr_table_ntsvcs,
2129 NDR_PNP_GETNEXTRESDES,
2130 &r);
2131
2132 if (!NT_STATUS_IS_OK(status)) {
2133 return status;
2134 }
2135
2136 if (DEBUGLEVEL >= 10) {
2137 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, &r);
2138 }
2139
2140 if (NT_STATUS_IS_ERR(status)) {
2141 return status;
2142 }
2143
2144 /* Return variables */
2145
2146 /* Return result */
2147 if (werror) {
2148 *werror = r.out.result;
2149 }
2150
2151 return werror_to_ntstatus(r.out.result);
2152}
2153
2154NTSTATUS rpccli_PNP_GetResDesData(struct rpc_pipe_client *cli,
2155 TALLOC_CTX *mem_ctx,
2156 WERROR *werror)
2157{
2158 struct PNP_GetResDesData r;
2159 NTSTATUS status;
2160
2161 /* In parameters */
2162
2163 if (DEBUGLEVEL >= 10) {
2164 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, &r);
2165 }
2166
2167 status = cli_do_rpc_ndr(cli,
2168 mem_ctx,
2169 PI_NTSVCS,
2170 &ndr_table_ntsvcs,
2171 NDR_PNP_GETRESDESDATA,
2172 &r);
2173
2174 if (!NT_STATUS_IS_OK(status)) {
2175 return status;
2176 }
2177
2178 if (DEBUGLEVEL >= 10) {
2179 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, &r);
2180 }
2181
2182 if (NT_STATUS_IS_ERR(status)) {
2183 return status;
2184 }
2185
2186 /* Return variables */
2187
2188 /* Return result */
2189 if (werror) {
2190 *werror = r.out.result;
2191 }
2192
2193 return werror_to_ntstatus(r.out.result);
2194}
2195
2196NTSTATUS rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client *cli,
2197 TALLOC_CTX *mem_ctx,
2198 WERROR *werror)
2199{
2200 struct PNP_GetResDesDataSize r;
2201 NTSTATUS status;
2202
2203 /* In parameters */
2204
2205 if (DEBUGLEVEL >= 10) {
2206 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, &r);
2207 }
2208
2209 status = cli_do_rpc_ndr(cli,
2210 mem_ctx,
2211 PI_NTSVCS,
2212 &ndr_table_ntsvcs,
2213 NDR_PNP_GETRESDESDATASIZE,
2214 &r);
2215
2216 if (!NT_STATUS_IS_OK(status)) {
2217 return status;
2218 }
2219
2220 if (DEBUGLEVEL >= 10) {
2221 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, &r);
2222 }
2223
2224 if (NT_STATUS_IS_ERR(status)) {
2225 return status;
2226 }
2227
2228 /* Return variables */
2229
2230 /* Return result */
2231 if (werror) {
2232 *werror = r.out.result;
2233 }
2234
2235 return werror_to_ntstatus(r.out.result);
2236}
2237
2238NTSTATUS rpccli_PNP_ModifyResDes(struct rpc_pipe_client *cli,
2239 TALLOC_CTX *mem_ctx,
2240 WERROR *werror)
2241{
2242 struct PNP_ModifyResDes r;
2243 NTSTATUS status;
2244
2245 /* In parameters */
2246
2247 if (DEBUGLEVEL >= 10) {
2248 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, &r);
2249 }
2250
2251 status = cli_do_rpc_ndr(cli,
2252 mem_ctx,
2253 PI_NTSVCS,
2254 &ndr_table_ntsvcs,
2255 NDR_PNP_MODIFYRESDES,
2256 &r);
2257
2258 if (!NT_STATUS_IS_OK(status)) {
2259 return status;
2260 }
2261
2262 if (DEBUGLEVEL >= 10) {
2263 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, &r);
2264 }
2265
2266 if (NT_STATUS_IS_ERR(status)) {
2267 return status;
2268 }
2269
2270 /* Return variables */
2271
2272 /* Return result */
2273 if (werror) {
2274 *werror = r.out.result;
2275 }
2276
2277 return werror_to_ntstatus(r.out.result);
2278}
2279
2280NTSTATUS rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client *cli,
2281 TALLOC_CTX *mem_ctx,
2282 WERROR *werror)
2283{
2284 struct PNP_DetectResourceLimit r;
2285 NTSTATUS status;
2286
2287 /* In parameters */
2288
2289 if (DEBUGLEVEL >= 10) {
2290 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, &r);
2291 }
2292
2293 status = cli_do_rpc_ndr(cli,
2294 mem_ctx,
2295 PI_NTSVCS,
2296 &ndr_table_ntsvcs,
2297 NDR_PNP_DETECTRESOURCELIMIT,
2298 &r);
2299
2300 if (!NT_STATUS_IS_OK(status)) {
2301 return status;
2302 }
2303
2304 if (DEBUGLEVEL >= 10) {
2305 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, &r);
2306 }
2307
2308 if (NT_STATUS_IS_ERR(status)) {
2309 return status;
2310 }
2311
2312 /* Return variables */
2313
2314 /* Return result */
2315 if (werror) {
2316 *werror = r.out.result;
2317 }
2318
2319 return werror_to_ntstatus(r.out.result);
2320}
2321
2322NTSTATUS rpccli_PNP_QueryResConfList(struct rpc_pipe_client *cli,
2323 TALLOC_CTX *mem_ctx,
2324 WERROR *werror)
2325{
2326 struct PNP_QueryResConfList r;
2327 NTSTATUS status;
2328
2329 /* In parameters */
2330
2331 if (DEBUGLEVEL >= 10) {
2332 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, &r);
2333 }
2334
2335 status = cli_do_rpc_ndr(cli,
2336 mem_ctx,
2337 PI_NTSVCS,
2338 &ndr_table_ntsvcs,
2339 NDR_PNP_QUERYRESCONFLIST,
2340 &r);
2341
2342 if (!NT_STATUS_IS_OK(status)) {
2343 return status;
2344 }
2345
2346 if (DEBUGLEVEL >= 10) {
2347 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, &r);
2348 }
2349
2350 if (NT_STATUS_IS_ERR(status)) {
2351 return status;
2352 }
2353
2354 /* Return variables */
2355
2356 /* Return result */
2357 if (werror) {
2358 *werror = r.out.result;
2359 }
2360
2361 return werror_to_ntstatus(r.out.result);
2362}
2363
2364NTSTATUS rpccli_PNP_SetHwProf(struct rpc_pipe_client *cli,
2365 TALLOC_CTX *mem_ctx,
2366 WERROR *werror)
2367{
2368 struct PNP_SetHwProf r;
2369 NTSTATUS status;
2370
2371 /* In parameters */
2372
2373 if (DEBUGLEVEL >= 10) {
2374 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, &r);
2375 }
2376
2377 status = cli_do_rpc_ndr(cli,
2378 mem_ctx,
2379 PI_NTSVCS,
2380 &ndr_table_ntsvcs,
2381 NDR_PNP_SETHWPROF,
2382 &r);
2383
2384 if (!NT_STATUS_IS_OK(status)) {
2385 return status;
2386 }
2387
2388 if (DEBUGLEVEL >= 10) {
2389 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, &r);
2390 }
2391
2392 if (NT_STATUS_IS_ERR(status)) {
2393 return status;
2394 }
2395
2396 /* Return variables */
2397
2398 /* Return result */
2399 if (werror) {
2400 *werror = r.out.result;
2401 }
2402
2403 return werror_to_ntstatus(r.out.result);
2404}
2405
2406NTSTATUS rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client *cli,
2407 TALLOC_CTX *mem_ctx,
2408 WERROR *werror)
2409{
2410 struct PNP_QueryArbitratorFreeData r;
2411 NTSTATUS status;
2412
2413 /* In parameters */
2414
2415 if (DEBUGLEVEL >= 10) {
2416 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, &r);
2417 }
2418
2419 status = cli_do_rpc_ndr(cli,
2420 mem_ctx,
2421 PI_NTSVCS,
2422 &ndr_table_ntsvcs,
2423 NDR_PNP_QUERYARBITRATORFREEDATA,
2424 &r);
2425
2426 if (!NT_STATUS_IS_OK(status)) {
2427 return status;
2428 }
2429
2430 if (DEBUGLEVEL >= 10) {
2431 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, &r);
2432 }
2433
2434 if (NT_STATUS_IS_ERR(status)) {
2435 return status;
2436 }
2437
2438 /* Return variables */
2439
2440 /* Return result */
2441 if (werror) {
2442 *werror = r.out.result;
2443 }
2444
2445 return werror_to_ntstatus(r.out.result);
2446}
2447
2448NTSTATUS rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client *cli,
2449 TALLOC_CTX *mem_ctx,
2450 WERROR *werror)
2451{
2452 struct PNP_QueryArbitratorFreeSize r;
2453 NTSTATUS status;
2454
2455 /* In parameters */
2456
2457 if (DEBUGLEVEL >= 10) {
2458 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2459 }
2460
2461 status = cli_do_rpc_ndr(cli,
2462 mem_ctx,
2463 PI_NTSVCS,
2464 &ndr_table_ntsvcs,
2465 NDR_PNP_QUERYARBITRATORFREESIZE,
2466 &r);
2467
2468 if (!NT_STATUS_IS_OK(status)) {
2469 return status;
2470 }
2471
2472 if (DEBUGLEVEL >= 10) {
2473 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, &r);
2474 }
2475
2476 if (NT_STATUS_IS_ERR(status)) {
2477 return status;
2478 }
2479
2480 /* Return variables */
2481
2482 /* Return result */
2483 if (werror) {
2484 *werror = r.out.result;
2485 }
2486
2487 return werror_to_ntstatus(r.out.result);
2488}
2489
2490NTSTATUS rpccli_PNP_RunDetection(struct rpc_pipe_client *cli,
2491 TALLOC_CTX *mem_ctx,
2492 WERROR *werror)
2493{
2494 struct PNP_RunDetection r;
2495 NTSTATUS status;
2496
2497 /* In parameters */
2498
2499 if (DEBUGLEVEL >= 10) {
2500 NDR_PRINT_IN_DEBUG(PNP_RunDetection, &r);
2501 }
2502
2503 status = cli_do_rpc_ndr(cli,
2504 mem_ctx,
2505 PI_NTSVCS,
2506 &ndr_table_ntsvcs,
2507 NDR_PNP_RUNDETECTION,
2508 &r);
2509
2510 if (!NT_STATUS_IS_OK(status)) {
2511 return status;
2512 }
2513
2514 if (DEBUGLEVEL >= 10) {
2515 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, &r);
2516 }
2517
2518 if (NT_STATUS_IS_ERR(status)) {
2519 return status;
2520 }
2521
2522 /* Return variables */
2523
2524 /* Return result */
2525 if (werror) {
2526 *werror = r.out.result;
2527 }
2528
2529 return werror_to_ntstatus(r.out.result);
2530}
2531
2532NTSTATUS rpccli_PNP_RegisterNotification(struct rpc_pipe_client *cli,
2533 TALLOC_CTX *mem_ctx,
2534 WERROR *werror)
2535{
2536 struct PNP_RegisterNotification r;
2537 NTSTATUS status;
2538
2539 /* In parameters */
2540
2541 if (DEBUGLEVEL >= 10) {
2542 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, &r);
2543 }
2544
2545 status = cli_do_rpc_ndr(cli,
2546 mem_ctx,
2547 PI_NTSVCS,
2548 &ndr_table_ntsvcs,
2549 NDR_PNP_REGISTERNOTIFICATION,
2550 &r);
2551
2552 if (!NT_STATUS_IS_OK(status)) {
2553 return status;
2554 }
2555
2556 if (DEBUGLEVEL >= 10) {
2557 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, &r);
2558 }
2559
2560 if (NT_STATUS_IS_ERR(status)) {
2561 return status;
2562 }
2563
2564 /* Return variables */
2565
2566 /* Return result */
2567 if (werror) {
2568 *werror = r.out.result;
2569 }
2570
2571 return werror_to_ntstatus(r.out.result);
2572}
2573
2574NTSTATUS rpccli_PNP_UnregisterNotification(struct rpc_pipe_client *cli,
2575 TALLOC_CTX *mem_ctx,
2576 WERROR *werror)
2577{
2578 struct PNP_UnregisterNotification r;
2579 NTSTATUS status;
2580
2581 /* In parameters */
2582
2583 if (DEBUGLEVEL >= 10) {
2584 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, &r);
2585 }
2586
2587 status = cli_do_rpc_ndr(cli,
2588 mem_ctx,
2589 PI_NTSVCS,
2590 &ndr_table_ntsvcs,
2591 NDR_PNP_UNREGISTERNOTIFICATION,
2592 &r);
2593
2594 if (!NT_STATUS_IS_OK(status)) {
2595 return status;
2596 }
2597
2598 if (DEBUGLEVEL >= 10) {
2599 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, &r);
2600 }
2601
2602 if (NT_STATUS_IS_ERR(status)) {
2603 return status;
2604 }
2605
2606 /* Return variables */
2607
2608 /* Return result */
2609 if (werror) {
2610 *werror = r.out.result;
2611 }
2612
2613 return werror_to_ntstatus(r.out.result);
2614}
2615
2616NTSTATUS rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client *cli,
2617 TALLOC_CTX *mem_ctx,
2618 WERROR *werror)
2619{
2620 struct PNP_GetCustomDevProp r;
2621 NTSTATUS status;
2622
2623 /* In parameters */
2624
2625 if (DEBUGLEVEL >= 10) {
2626 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, &r);
2627 }
2628
2629 status = cli_do_rpc_ndr(cli,
2630 mem_ctx,
2631 PI_NTSVCS,
2632 &ndr_table_ntsvcs,
2633 NDR_PNP_GETCUSTOMDEVPROP,
2634 &r);
2635
2636 if (!NT_STATUS_IS_OK(status)) {
2637 return status;
2638 }
2639
2640 if (DEBUGLEVEL >= 10) {
2641 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, &r);
2642 }
2643
2644 if (NT_STATUS_IS_ERR(status)) {
2645 return status;
2646 }
2647
2648 /* Return variables */
2649
2650 /* Return result */
2651 if (werror) {
2652 *werror = r.out.result;
2653 }
2654
2655 return werror_to_ntstatus(r.out.result);
2656}
2657
2658NTSTATUS rpccli_PNP_GetVersionInternal(struct rpc_pipe_client *cli,
2659 TALLOC_CTX *mem_ctx,
2660 WERROR *werror)
2661{
2662 struct PNP_GetVersionInternal r;
2663 NTSTATUS status;
2664
2665 /* In parameters */
2666
2667 if (DEBUGLEVEL >= 10) {
2668 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, &r);
2669 }
2670
2671 status = cli_do_rpc_ndr(cli,
2672 mem_ctx,
2673 PI_NTSVCS,
2674 &ndr_table_ntsvcs,
2675 NDR_PNP_GETVERSIONINTERNAL,
2676 &r);
2677
2678 if (!NT_STATUS_IS_OK(status)) {
2679 return status;
2680 }
2681
2682 if (DEBUGLEVEL >= 10) {
2683 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, &r);
2684 }
2685
2686 if (NT_STATUS_IS_ERR(status)) {
2687 return status;
2688 }
2689
2690 /* Return variables */
2691
2692 /* Return result */
2693 if (werror) {
2694 *werror = r.out.result;
2695 }
2696
2697 return werror_to_ntstatus(r.out.result);
2698}
2699
2700NTSTATUS rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client *cli,
2701 TALLOC_CTX *mem_ctx,
2702 WERROR *werror)
2703{
2704 struct PNP_GetBlockedDriverInfo r;
2705 NTSTATUS status;
2706
2707 /* In parameters */
2708
2709 if (DEBUGLEVEL >= 10) {
2710 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, &r);
2711 }
2712
2713 status = cli_do_rpc_ndr(cli,
2714 mem_ctx,
2715 PI_NTSVCS,
2716 &ndr_table_ntsvcs,
2717 NDR_PNP_GETBLOCKEDDRIVERINFO,
2718 &r);
2719
2720 if (!NT_STATUS_IS_OK(status)) {
2721 return status;
2722 }
2723
2724 if (DEBUGLEVEL >= 10) {
2725 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, &r);
2726 }
2727
2728 if (NT_STATUS_IS_ERR(status)) {
2729 return status;
2730 }
2731
2732 /* Return variables */
2733
2734 /* Return result */
2735 if (werror) {
2736 *werror = r.out.result;
2737 }
2738
2739 return werror_to_ntstatus(r.out.result);
2740}
2741
2742NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client *cli,
2743 TALLOC_CTX *mem_ctx,
2744 WERROR *werror)
2745{
2746 struct PNP_GetServerSideDeviceInstallFlags r;
2747 NTSTATUS status;
2748
2749 /* In parameters */
2750
2751 if (DEBUGLEVEL >= 10) {
2752 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2753 }
2754
2755 status = cli_do_rpc_ndr(cli,
2756 mem_ctx,
2757 PI_NTSVCS,
2758 &ndr_table_ntsvcs,
2759 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
2760 &r);
2761
2762 if (!NT_STATUS_IS_OK(status)) {
2763 return status;
2764 }
2765
2766 if (DEBUGLEVEL >= 10) {
2767 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, &r);
2768 }
2769
2770 if (NT_STATUS_IS_ERR(status)) {
2771 return status;
2772 }
2773
2774 /* Return variables */
2775
2776 /* Return result */
2777 if (werror) {
2778 *werror = r.out.result;
2779 }
2780
2781 return werror_to_ntstatus(r.out.result);
2782}
2783
Note: See TracBrowser for help on using the repository browser.