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