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