/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- rpccli_PNP_Disconnect
- rpccli_PNP_Connect
- rpccli_PNP_GetVersion
- rpccli_PNP_GetGlobalState
- rpccli_PNP_InitDetection
- rpccli_PNP_ReportLogOn
- rpccli_PNP_ValidateDeviceInstance
- rpccli_PNP_GetRootDeviceInstance
- rpccli_PNP_GetRelatedDeviceInstance
- rpccli_PNP_EnumerateSubKeys
- rpccli_PNP_GetDeviceList
- rpccli_PNP_GetDeviceListSize
- rpccli_PNP_GetDepth
- rpccli_PNP_GetDeviceRegProp
- rpccli_PNP_SetDeviceRegProp
- rpccli_PNP_GetClassInstance
- rpccli_PNP_CreateKey
- rpccli_PNP_DeleteRegistryKey
- rpccli_PNP_GetClassCount
- rpccli_PNP_GetClassName
- rpccli_PNP_DeleteClassKey
- rpccli_PNP_GetInterfaceDeviceAlias
- rpccli_PNP_GetInterfaceDeviceList
- rpccli_PNP_GetInterfaceDeviceListSize
- rpccli_PNP_RegisterDeviceClassAssociation
- rpccli_PNP_UnregisterDeviceClassAssociation
- rpccli_PNP_GetClassRegProp
- rpccli_PNP_SetClassRegProp
- rpccli_PNP_CreateDevInst
- rpccli_PNP_DeviceInstanceAction
- rpccli_PNP_GetDeviceStatus
- rpccli_PNP_SetDeviceProblem
- rpccli_PNP_DisableDevInst
- rpccli_PNP_UninstallDevInst
- rpccli_PNP_AddID
- rpccli_PNP_RegisterDriver
- rpccli_PNP_QueryRemove
- rpccli_PNP_RequestDeviceEject
- rpccli_PNP_IsDockStationPresent
- rpccli_PNP_RequestEjectPC
- rpccli_PNP_HwProfFlags
- rpccli_PNP_GetHwProfInfo
- rpccli_PNP_AddEmptyLogConf
- rpccli_PNP_FreeLogConf
- rpccli_PNP_GetFirstLogConf
- rpccli_PNP_GetNextLogConf
- rpccli_PNP_GetLogConfPriority
- rpccli_PNP_AddResDes
- rpccli_PNP_FreeResDes
- rpccli_PNP_GetNextResDes
- rpccli_PNP_GetResDesData
- rpccli_PNP_GetResDesDataSize
- rpccli_PNP_ModifyResDes
- rpccli_PNP_DetectResourceLimit
- rpccli_PNP_QueryResConfList
- rpccli_PNP_SetHwProf
- rpccli_PNP_QueryArbitratorFreeData
- rpccli_PNP_QueryArbitratorFreeSize
- rpccli_PNP_RunDetection
- rpccli_PNP_RegisterNotification
- rpccli_PNP_UnregisterNotification
- rpccli_PNP_GetCustomDevProp
- rpccli_PNP_GetVersionInternal
- rpccli_PNP_GetBlockedDriverInfo
- rpccli_PNP_GetServerSideDeviceInstallFlags
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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