2 * Unix SMB/CIFS implementation.
3 * server auto-generated by pidl. DO NOT MODIFY!
7 #include "librpc/gen_ndr/srv_ntsvcs.h"
9 static bool api_PNP_Disconnect(pipes_struct
*p
)
11 const struct ndr_interface_call
*call
;
12 struct ndr_pull
*pull
;
13 struct ndr_push
*push
;
14 enum ndr_err_code ndr_err
;
16 struct PNP_Disconnect
*r
;
18 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DISCONNECT
];
20 r
= talloc(talloc_tos(), struct PNP_Disconnect
);
25 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
30 pull
= ndr_pull_init_blob(&blob
, r
);
36 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
37 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
38 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
43 if (DEBUGLEVEL
>= 10) {
44 NDR_PRINT_IN_DEBUG(PNP_Disconnect
, r
);
47 r
->out
.result
= _PNP_Disconnect(p
, r
);
49 if (p
->rng_fault_state
) {
51 /* Return true here, srv_pipe_hnd.c will take care */
55 if (DEBUGLEVEL
>= 10) {
56 NDR_PRINT_OUT_DEBUG(PNP_Disconnect
, r
);
59 push
= ndr_push_init_ctx(r
);
65 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
66 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
71 blob
= ndr_push_blob(push
);
72 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
82 static bool api_PNP_Connect(pipes_struct
*p
)
84 const struct ndr_interface_call
*call
;
85 struct ndr_pull
*pull
;
86 struct ndr_push
*push
;
87 enum ndr_err_code ndr_err
;
89 struct PNP_Connect
*r
;
91 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_CONNECT
];
93 r
= talloc(talloc_tos(), struct PNP_Connect
);
98 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
103 pull
= ndr_pull_init_blob(&blob
, r
);
109 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
110 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
111 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
116 if (DEBUGLEVEL
>= 10) {
117 NDR_PRINT_IN_DEBUG(PNP_Connect
, r
);
120 r
->out
.result
= _PNP_Connect(p
, r
);
122 if (p
->rng_fault_state
) {
124 /* Return true here, srv_pipe_hnd.c will take care */
128 if (DEBUGLEVEL
>= 10) {
129 NDR_PRINT_OUT_DEBUG(PNP_Connect
, r
);
132 push
= ndr_push_init_ctx(r
);
138 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
139 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
144 blob
= ndr_push_blob(push
);
145 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
155 static bool api_PNP_GetVersion(pipes_struct
*p
)
157 const struct ndr_interface_call
*call
;
158 struct ndr_pull
*pull
;
159 struct ndr_push
*push
;
160 enum ndr_err_code ndr_err
;
162 struct PNP_GetVersion
*r
;
164 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETVERSION
];
166 r
= talloc(talloc_tos(), struct PNP_GetVersion
);
171 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
176 pull
= ndr_pull_init_blob(&blob
, r
);
182 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
183 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
184 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
189 if (DEBUGLEVEL
>= 10) {
190 NDR_PRINT_IN_DEBUG(PNP_GetVersion
, r
);
194 r
->out
.version
= talloc_zero(r
, uint16_t);
195 if (r
->out
.version
== NULL
) {
200 r
->out
.result
= _PNP_GetVersion(p
, r
);
202 if (p
->rng_fault_state
) {
204 /* Return true here, srv_pipe_hnd.c will take care */
208 if (DEBUGLEVEL
>= 10) {
209 NDR_PRINT_OUT_DEBUG(PNP_GetVersion
, r
);
212 push
= ndr_push_init_ctx(r
);
218 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
219 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
224 blob
= ndr_push_blob(push
);
225 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
235 static bool api_PNP_GetGlobalState(pipes_struct
*p
)
237 const struct ndr_interface_call
*call
;
238 struct ndr_pull
*pull
;
239 struct ndr_push
*push
;
240 enum ndr_err_code ndr_err
;
242 struct PNP_GetGlobalState
*r
;
244 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETGLOBALSTATE
];
246 r
= talloc(talloc_tos(), struct PNP_GetGlobalState
);
251 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
256 pull
= ndr_pull_init_blob(&blob
, r
);
262 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
263 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
264 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
269 if (DEBUGLEVEL
>= 10) {
270 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState
, r
);
273 r
->out
.result
= _PNP_GetGlobalState(p
, r
);
275 if (p
->rng_fault_state
) {
277 /* Return true here, srv_pipe_hnd.c will take care */
281 if (DEBUGLEVEL
>= 10) {
282 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState
, r
);
285 push
= ndr_push_init_ctx(r
);
291 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
292 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
297 blob
= ndr_push_blob(push
);
298 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
308 static bool api_PNP_InitDetection(pipes_struct
*p
)
310 const struct ndr_interface_call
*call
;
311 struct ndr_pull
*pull
;
312 struct ndr_push
*push
;
313 enum ndr_err_code ndr_err
;
315 struct PNP_InitDetection
*r
;
317 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_INITDETECTION
];
319 r
= talloc(talloc_tos(), struct PNP_InitDetection
);
324 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
329 pull
= ndr_pull_init_blob(&blob
, r
);
335 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
336 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
337 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
342 if (DEBUGLEVEL
>= 10) {
343 NDR_PRINT_IN_DEBUG(PNP_InitDetection
, r
);
346 r
->out
.result
= _PNP_InitDetection(p
, r
);
348 if (p
->rng_fault_state
) {
350 /* Return true here, srv_pipe_hnd.c will take care */
354 if (DEBUGLEVEL
>= 10) {
355 NDR_PRINT_OUT_DEBUG(PNP_InitDetection
, r
);
358 push
= ndr_push_init_ctx(r
);
364 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
365 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
370 blob
= ndr_push_blob(push
);
371 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
381 static bool api_PNP_ReportLogOn(pipes_struct
*p
)
383 const struct ndr_interface_call
*call
;
384 struct ndr_pull
*pull
;
385 struct ndr_push
*push
;
386 enum ndr_err_code ndr_err
;
388 struct PNP_ReportLogOn
*r
;
390 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REPORTLOGON
];
392 r
= talloc(talloc_tos(), struct PNP_ReportLogOn
);
397 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
402 pull
= ndr_pull_init_blob(&blob
, r
);
408 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
409 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
410 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
415 if (DEBUGLEVEL
>= 10) {
416 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn
, r
);
419 r
->out
.result
= _PNP_ReportLogOn(p
, r
);
421 if (p
->rng_fault_state
) {
423 /* Return true here, srv_pipe_hnd.c will take care */
427 if (DEBUGLEVEL
>= 10) {
428 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn
, r
);
431 push
= ndr_push_init_ctx(r
);
437 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
438 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
443 blob
= ndr_push_blob(push
);
444 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
454 static bool api_PNP_ValidateDeviceInstance(pipes_struct
*p
)
456 const struct ndr_interface_call
*call
;
457 struct ndr_pull
*pull
;
458 struct ndr_push
*push
;
459 enum ndr_err_code ndr_err
;
461 struct PNP_ValidateDeviceInstance
*r
;
463 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_VALIDATEDEVICEINSTANCE
];
465 r
= talloc(talloc_tos(), struct PNP_ValidateDeviceInstance
);
470 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
475 pull
= ndr_pull_init_blob(&blob
, r
);
481 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
482 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
483 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
488 if (DEBUGLEVEL
>= 10) {
489 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance
, r
);
492 r
->out
.result
= _PNP_ValidateDeviceInstance(p
, r
);
494 if (p
->rng_fault_state
) {
496 /* Return true here, srv_pipe_hnd.c will take care */
500 if (DEBUGLEVEL
>= 10) {
501 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance
, r
);
504 push
= ndr_push_init_ctx(r
);
510 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
511 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
516 blob
= ndr_push_blob(push
);
517 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
527 static bool api_PNP_GetRootDeviceInstance(pipes_struct
*p
)
529 const struct ndr_interface_call
*call
;
530 struct ndr_pull
*pull
;
531 struct ndr_push
*push
;
532 enum ndr_err_code ndr_err
;
534 struct PNP_GetRootDeviceInstance
*r
;
536 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETROOTDEVICEINSTANCE
];
538 r
= talloc(talloc_tos(), struct PNP_GetRootDeviceInstance
);
543 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
548 pull
= ndr_pull_init_blob(&blob
, r
);
554 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
555 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
556 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
561 if (DEBUGLEVEL
>= 10) {
562 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance
, r
);
565 r
->out
.result
= _PNP_GetRootDeviceInstance(p
, r
);
567 if (p
->rng_fault_state
) {
569 /* Return true here, srv_pipe_hnd.c will take care */
573 if (DEBUGLEVEL
>= 10) {
574 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance
, r
);
577 push
= ndr_push_init_ctx(r
);
583 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
584 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
589 blob
= ndr_push_blob(push
);
590 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
600 static bool api_PNP_GetRelatedDeviceInstance(pipes_struct
*p
)
602 const struct ndr_interface_call
*call
;
603 struct ndr_pull
*pull
;
604 struct ndr_push
*push
;
605 enum ndr_err_code ndr_err
;
607 struct PNP_GetRelatedDeviceInstance
*r
;
609 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETRELATEDDEVICEINSTANCE
];
611 r
= talloc(talloc_tos(), struct PNP_GetRelatedDeviceInstance
);
616 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
621 pull
= ndr_pull_init_blob(&blob
, r
);
627 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
628 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
629 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
634 if (DEBUGLEVEL
>= 10) {
635 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance
, r
);
638 r
->out
.result
= _PNP_GetRelatedDeviceInstance(p
, r
);
640 if (p
->rng_fault_state
) {
642 /* Return true here, srv_pipe_hnd.c will take care */
646 if (DEBUGLEVEL
>= 10) {
647 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance
, r
);
650 push
= ndr_push_init_ctx(r
);
656 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
657 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
662 blob
= ndr_push_blob(push
);
663 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
673 static bool api_PNP_EnumerateSubKeys(pipes_struct
*p
)
675 const struct ndr_interface_call
*call
;
676 struct ndr_pull
*pull
;
677 struct ndr_push
*push
;
678 enum ndr_err_code ndr_err
;
680 struct PNP_EnumerateSubKeys
*r
;
682 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_ENUMERATESUBKEYS
];
684 r
= talloc(talloc_tos(), struct PNP_EnumerateSubKeys
);
689 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
694 pull
= ndr_pull_init_blob(&blob
, r
);
700 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
701 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
702 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
707 if (DEBUGLEVEL
>= 10) {
708 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys
, r
);
711 r
->out
.result
= _PNP_EnumerateSubKeys(p
, r
);
713 if (p
->rng_fault_state
) {
715 /* Return true here, srv_pipe_hnd.c will take care */
719 if (DEBUGLEVEL
>= 10) {
720 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys
, r
);
723 push
= ndr_push_init_ctx(r
);
729 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
730 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
735 blob
= ndr_push_blob(push
);
736 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
746 static bool api_PNP_GetDeviceList(pipes_struct
*p
)
748 const struct ndr_interface_call
*call
;
749 struct ndr_pull
*pull
;
750 struct ndr_push
*push
;
751 enum ndr_err_code ndr_err
;
753 struct PNP_GetDeviceList
*r
;
755 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETDEVICELIST
];
757 r
= talloc(talloc_tos(), struct PNP_GetDeviceList
);
762 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
767 pull
= ndr_pull_init_blob(&blob
, r
);
773 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
774 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
775 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
780 if (DEBUGLEVEL
>= 10) {
781 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList
, r
);
784 r
->out
.result
= _PNP_GetDeviceList(p
, r
);
786 if (p
->rng_fault_state
) {
788 /* Return true here, srv_pipe_hnd.c will take care */
792 if (DEBUGLEVEL
>= 10) {
793 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList
, r
);
796 push
= ndr_push_init_ctx(r
);
802 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
803 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
808 blob
= ndr_push_blob(push
);
809 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
819 static bool api_PNP_GetDeviceListSize(pipes_struct
*p
)
821 const struct ndr_interface_call
*call
;
822 struct ndr_pull
*pull
;
823 struct ndr_push
*push
;
824 enum ndr_err_code ndr_err
;
826 struct PNP_GetDeviceListSize
*r
;
828 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETDEVICELISTSIZE
];
830 r
= talloc(talloc_tos(), struct PNP_GetDeviceListSize
);
835 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
840 pull
= ndr_pull_init_blob(&blob
, r
);
846 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
847 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
848 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
853 if (DEBUGLEVEL
>= 10) {
854 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize
, r
);
858 r
->out
.size
= talloc_zero(r
, uint32_t);
859 if (r
->out
.size
== NULL
) {
864 r
->out
.result
= _PNP_GetDeviceListSize(p
, r
);
866 if (p
->rng_fault_state
) {
868 /* Return true here, srv_pipe_hnd.c will take care */
872 if (DEBUGLEVEL
>= 10) {
873 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize
, r
);
876 push
= ndr_push_init_ctx(r
);
882 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
883 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
888 blob
= ndr_push_blob(push
);
889 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
899 static bool api_PNP_GetDepth(pipes_struct
*p
)
901 const struct ndr_interface_call
*call
;
902 struct ndr_pull
*pull
;
903 struct ndr_push
*push
;
904 enum ndr_err_code ndr_err
;
906 struct PNP_GetDepth
*r
;
908 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETDEPTH
];
910 r
= talloc(talloc_tos(), struct PNP_GetDepth
);
915 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
920 pull
= ndr_pull_init_blob(&blob
, r
);
926 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
927 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
928 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
933 if (DEBUGLEVEL
>= 10) {
934 NDR_PRINT_IN_DEBUG(PNP_GetDepth
, r
);
937 r
->out
.result
= _PNP_GetDepth(p
, r
);
939 if (p
->rng_fault_state
) {
941 /* Return true here, srv_pipe_hnd.c will take care */
945 if (DEBUGLEVEL
>= 10) {
946 NDR_PRINT_OUT_DEBUG(PNP_GetDepth
, r
);
949 push
= ndr_push_init_ctx(r
);
955 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
956 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
961 blob
= ndr_push_blob(push
);
962 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
972 static bool api_PNP_GetDeviceRegProp(pipes_struct
*p
)
974 const struct ndr_interface_call
*call
;
975 struct ndr_pull
*pull
;
976 struct ndr_push
*push
;
977 enum ndr_err_code ndr_err
;
979 struct PNP_GetDeviceRegProp
*r
;
981 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETDEVICEREGPROP
];
983 r
= talloc(talloc_tos(), struct PNP_GetDeviceRegProp
);
988 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
993 pull
= ndr_pull_init_blob(&blob
, r
);
999 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1000 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1001 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1006 if (DEBUGLEVEL
>= 10) {
1007 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp
, r
);
1010 r
->out
.result
= _PNP_GetDeviceRegProp(p
, r
);
1012 if (p
->rng_fault_state
) {
1014 /* Return true here, srv_pipe_hnd.c will take care */
1018 if (DEBUGLEVEL
>= 10) {
1019 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp
, r
);
1022 push
= ndr_push_init_ctx(r
);
1028 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1029 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1034 blob
= ndr_push_blob(push
);
1035 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1045 static bool api_PNP_SetDeviceRegProp(pipes_struct
*p
)
1047 const struct ndr_interface_call
*call
;
1048 struct ndr_pull
*pull
;
1049 struct ndr_push
*push
;
1050 enum ndr_err_code ndr_err
;
1052 struct PNP_SetDeviceRegProp
*r
;
1054 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_SETDEVICEREGPROP
];
1056 r
= talloc(talloc_tos(), struct PNP_SetDeviceRegProp
);
1061 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1066 pull
= ndr_pull_init_blob(&blob
, r
);
1072 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1073 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1074 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1079 if (DEBUGLEVEL
>= 10) {
1080 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp
, r
);
1083 r
->out
.result
= _PNP_SetDeviceRegProp(p
, r
);
1085 if (p
->rng_fault_state
) {
1087 /* Return true here, srv_pipe_hnd.c will take care */
1091 if (DEBUGLEVEL
>= 10) {
1092 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp
, r
);
1095 push
= ndr_push_init_ctx(r
);
1101 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1102 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1107 blob
= ndr_push_blob(push
);
1108 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1118 static bool api_PNP_GetClassInstance(pipes_struct
*p
)
1120 const struct ndr_interface_call
*call
;
1121 struct ndr_pull
*pull
;
1122 struct ndr_push
*push
;
1123 enum ndr_err_code ndr_err
;
1125 struct PNP_GetClassInstance
*r
;
1127 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETCLASSINSTANCE
];
1129 r
= talloc(talloc_tos(), struct PNP_GetClassInstance
);
1134 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1139 pull
= ndr_pull_init_blob(&blob
, r
);
1145 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1146 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1152 if (DEBUGLEVEL
>= 10) {
1153 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance
, r
);
1156 r
->out
.result
= _PNP_GetClassInstance(p
, r
);
1158 if (p
->rng_fault_state
) {
1160 /* Return true here, srv_pipe_hnd.c will take care */
1164 if (DEBUGLEVEL
>= 10) {
1165 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance
, r
);
1168 push
= ndr_push_init_ctx(r
);
1174 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1175 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1180 blob
= ndr_push_blob(push
);
1181 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1191 static bool api_PNP_CreateKey(pipes_struct
*p
)
1193 const struct ndr_interface_call
*call
;
1194 struct ndr_pull
*pull
;
1195 struct ndr_push
*push
;
1196 enum ndr_err_code ndr_err
;
1198 struct PNP_CreateKey
*r
;
1200 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_CREATEKEY
];
1202 r
= talloc(talloc_tos(), struct PNP_CreateKey
);
1207 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1212 pull
= ndr_pull_init_blob(&blob
, r
);
1218 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1219 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1225 if (DEBUGLEVEL
>= 10) {
1226 NDR_PRINT_IN_DEBUG(PNP_CreateKey
, r
);
1229 r
->out
.result
= _PNP_CreateKey(p
, r
);
1231 if (p
->rng_fault_state
) {
1233 /* Return true here, srv_pipe_hnd.c will take care */
1237 if (DEBUGLEVEL
>= 10) {
1238 NDR_PRINT_OUT_DEBUG(PNP_CreateKey
, r
);
1241 push
= ndr_push_init_ctx(r
);
1247 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1253 blob
= ndr_push_blob(push
);
1254 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1264 static bool api_PNP_DeleteRegistryKey(pipes_struct
*p
)
1266 const struct ndr_interface_call
*call
;
1267 struct ndr_pull
*pull
;
1268 struct ndr_push
*push
;
1269 enum ndr_err_code ndr_err
;
1271 struct PNP_DeleteRegistryKey
*r
;
1273 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DELETEREGISTRYKEY
];
1275 r
= talloc(talloc_tos(), struct PNP_DeleteRegistryKey
);
1280 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1285 pull
= ndr_pull_init_blob(&blob
, r
);
1291 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1292 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1293 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1298 if (DEBUGLEVEL
>= 10) {
1299 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey
, r
);
1302 r
->out
.result
= _PNP_DeleteRegistryKey(p
, r
);
1304 if (p
->rng_fault_state
) {
1306 /* Return true here, srv_pipe_hnd.c will take care */
1310 if (DEBUGLEVEL
>= 10) {
1311 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey
, r
);
1314 push
= ndr_push_init_ctx(r
);
1320 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1326 blob
= ndr_push_blob(push
);
1327 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1337 static bool api_PNP_GetClassCount(pipes_struct
*p
)
1339 const struct ndr_interface_call
*call
;
1340 struct ndr_pull
*pull
;
1341 struct ndr_push
*push
;
1342 enum ndr_err_code ndr_err
;
1344 struct PNP_GetClassCount
*r
;
1346 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETCLASSCOUNT
];
1348 r
= talloc(talloc_tos(), struct PNP_GetClassCount
);
1353 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1358 pull
= ndr_pull_init_blob(&blob
, r
);
1364 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1365 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1366 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1371 if (DEBUGLEVEL
>= 10) {
1372 NDR_PRINT_IN_DEBUG(PNP_GetClassCount
, r
);
1375 r
->out
.result
= _PNP_GetClassCount(p
, r
);
1377 if (p
->rng_fault_state
) {
1379 /* Return true here, srv_pipe_hnd.c will take care */
1383 if (DEBUGLEVEL
>= 10) {
1384 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount
, r
);
1387 push
= ndr_push_init_ctx(r
);
1393 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1399 blob
= ndr_push_blob(push
);
1400 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1410 static bool api_PNP_GetClassName(pipes_struct
*p
)
1412 const struct ndr_interface_call
*call
;
1413 struct ndr_pull
*pull
;
1414 struct ndr_push
*push
;
1415 enum ndr_err_code ndr_err
;
1417 struct PNP_GetClassName
*r
;
1419 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETCLASSNAME
];
1421 r
= talloc(talloc_tos(), struct PNP_GetClassName
);
1426 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1431 pull
= ndr_pull_init_blob(&blob
, r
);
1437 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1438 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1439 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1444 if (DEBUGLEVEL
>= 10) {
1445 NDR_PRINT_IN_DEBUG(PNP_GetClassName
, r
);
1448 r
->out
.result
= _PNP_GetClassName(p
, r
);
1450 if (p
->rng_fault_state
) {
1452 /* Return true here, srv_pipe_hnd.c will take care */
1456 if (DEBUGLEVEL
>= 10) {
1457 NDR_PRINT_OUT_DEBUG(PNP_GetClassName
, r
);
1460 push
= ndr_push_init_ctx(r
);
1466 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1472 blob
= ndr_push_blob(push
);
1473 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1483 static bool api_PNP_DeleteClassKey(pipes_struct
*p
)
1485 const struct ndr_interface_call
*call
;
1486 struct ndr_pull
*pull
;
1487 struct ndr_push
*push
;
1488 enum ndr_err_code ndr_err
;
1490 struct PNP_DeleteClassKey
*r
;
1492 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DELETECLASSKEY
];
1494 r
= talloc(talloc_tos(), struct PNP_DeleteClassKey
);
1499 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1504 pull
= ndr_pull_init_blob(&blob
, r
);
1510 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1511 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1512 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1517 if (DEBUGLEVEL
>= 10) {
1518 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey
, r
);
1521 r
->out
.result
= _PNP_DeleteClassKey(p
, r
);
1523 if (p
->rng_fault_state
) {
1525 /* Return true here, srv_pipe_hnd.c will take care */
1529 if (DEBUGLEVEL
>= 10) {
1530 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey
, r
);
1533 push
= ndr_push_init_ctx(r
);
1539 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1545 blob
= ndr_push_blob(push
);
1546 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1556 static bool api_PNP_GetInterfaceDeviceAlias(pipes_struct
*p
)
1558 const struct ndr_interface_call
*call
;
1559 struct ndr_pull
*pull
;
1560 struct ndr_push
*push
;
1561 enum ndr_err_code ndr_err
;
1563 struct PNP_GetInterfaceDeviceAlias
*r
;
1565 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETINTERFACEDEVICEALIAS
];
1567 r
= talloc(talloc_tos(), struct PNP_GetInterfaceDeviceAlias
);
1572 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1577 pull
= ndr_pull_init_blob(&blob
, r
);
1583 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1584 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1585 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1590 if (DEBUGLEVEL
>= 10) {
1591 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias
, r
);
1594 r
->out
.result
= _PNP_GetInterfaceDeviceAlias(p
, r
);
1596 if (p
->rng_fault_state
) {
1598 /* Return true here, srv_pipe_hnd.c will take care */
1602 if (DEBUGLEVEL
>= 10) {
1603 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias
, r
);
1606 push
= ndr_push_init_ctx(r
);
1612 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1613 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1618 blob
= ndr_push_blob(push
);
1619 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1629 static bool api_PNP_GetInterfaceDeviceList(pipes_struct
*p
)
1631 const struct ndr_interface_call
*call
;
1632 struct ndr_pull
*pull
;
1633 struct ndr_push
*push
;
1634 enum ndr_err_code ndr_err
;
1636 struct PNP_GetInterfaceDeviceList
*r
;
1638 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETINTERFACEDEVICELIST
];
1640 r
= talloc(talloc_tos(), struct PNP_GetInterfaceDeviceList
);
1645 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1650 pull
= ndr_pull_init_blob(&blob
, r
);
1656 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1657 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1658 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1663 if (DEBUGLEVEL
>= 10) {
1664 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList
, r
);
1667 r
->out
.result
= _PNP_GetInterfaceDeviceList(p
, r
);
1669 if (p
->rng_fault_state
) {
1671 /* Return true here, srv_pipe_hnd.c will take care */
1675 if (DEBUGLEVEL
>= 10) {
1676 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList
, r
);
1679 push
= ndr_push_init_ctx(r
);
1685 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1691 blob
= ndr_push_blob(push
);
1692 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1702 static bool api_PNP_GetInterfaceDeviceListSize(pipes_struct
*p
)
1704 const struct ndr_interface_call
*call
;
1705 struct ndr_pull
*pull
;
1706 struct ndr_push
*push
;
1707 enum ndr_err_code ndr_err
;
1709 struct PNP_GetInterfaceDeviceListSize
*r
;
1711 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETINTERFACEDEVICELISTSIZE
];
1713 r
= talloc(talloc_tos(), struct PNP_GetInterfaceDeviceListSize
);
1718 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1723 pull
= ndr_pull_init_blob(&blob
, r
);
1729 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1730 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1736 if (DEBUGLEVEL
>= 10) {
1737 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize
, r
);
1740 r
->out
.result
= _PNP_GetInterfaceDeviceListSize(p
, r
);
1742 if (p
->rng_fault_state
) {
1744 /* Return true here, srv_pipe_hnd.c will take care */
1748 if (DEBUGLEVEL
>= 10) {
1749 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize
, r
);
1752 push
= ndr_push_init_ctx(r
);
1758 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1759 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1764 blob
= ndr_push_blob(push
);
1765 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1775 static bool api_PNP_RegisterDeviceClassAssociation(pipes_struct
*p
)
1777 const struct ndr_interface_call
*call
;
1778 struct ndr_pull
*pull
;
1779 struct ndr_push
*push
;
1780 enum ndr_err_code ndr_err
;
1782 struct PNP_RegisterDeviceClassAssociation
*r
;
1784 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REGISTERDEVICECLASSASSOCIATION
];
1786 r
= talloc(talloc_tos(), struct PNP_RegisterDeviceClassAssociation
);
1791 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1796 pull
= ndr_pull_init_blob(&blob
, r
);
1802 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1803 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1804 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1809 if (DEBUGLEVEL
>= 10) {
1810 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation
, r
);
1813 r
->out
.result
= _PNP_RegisterDeviceClassAssociation(p
, r
);
1815 if (p
->rng_fault_state
) {
1817 /* Return true here, srv_pipe_hnd.c will take care */
1821 if (DEBUGLEVEL
>= 10) {
1822 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation
, r
);
1825 push
= ndr_push_init_ctx(r
);
1831 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1832 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1837 blob
= ndr_push_blob(push
);
1838 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1848 static bool api_PNP_UnregisterDeviceClassAssociation(pipes_struct
*p
)
1850 const struct ndr_interface_call
*call
;
1851 struct ndr_pull
*pull
;
1852 struct ndr_push
*push
;
1853 enum ndr_err_code ndr_err
;
1855 struct PNP_UnregisterDeviceClassAssociation
*r
;
1857 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION
];
1859 r
= talloc(talloc_tos(), struct PNP_UnregisterDeviceClassAssociation
);
1864 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1869 pull
= ndr_pull_init_blob(&blob
, r
);
1875 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1876 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1877 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1882 if (DEBUGLEVEL
>= 10) {
1883 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation
, r
);
1886 r
->out
.result
= _PNP_UnregisterDeviceClassAssociation(p
, r
);
1888 if (p
->rng_fault_state
) {
1890 /* Return true here, srv_pipe_hnd.c will take care */
1894 if (DEBUGLEVEL
>= 10) {
1895 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation
, r
);
1898 push
= ndr_push_init_ctx(r
);
1904 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1910 blob
= ndr_push_blob(push
);
1911 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1921 static bool api_PNP_GetClassRegProp(pipes_struct
*p
)
1923 const struct ndr_interface_call
*call
;
1924 struct ndr_pull
*pull
;
1925 struct ndr_push
*push
;
1926 enum ndr_err_code ndr_err
;
1928 struct PNP_GetClassRegProp
*r
;
1930 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETCLASSREGPROP
];
1932 r
= talloc(talloc_tos(), struct PNP_GetClassRegProp
);
1937 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
1942 pull
= ndr_pull_init_blob(&blob
, r
);
1948 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
1949 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
1950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1955 if (DEBUGLEVEL
>= 10) {
1956 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp
, r
);
1959 r
->out
.result
= _PNP_GetClassRegProp(p
, r
);
1961 if (p
->rng_fault_state
) {
1963 /* Return true here, srv_pipe_hnd.c will take care */
1967 if (DEBUGLEVEL
>= 10) {
1968 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp
, r
);
1971 push
= ndr_push_init_ctx(r
);
1977 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
1978 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1983 blob
= ndr_push_blob(push
);
1984 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
1994 static bool api_PNP_SetClassRegProp(pipes_struct
*p
)
1996 const struct ndr_interface_call
*call
;
1997 struct ndr_pull
*pull
;
1998 struct ndr_push
*push
;
1999 enum ndr_err_code ndr_err
;
2001 struct PNP_SetClassRegProp
*r
;
2003 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_SETCLASSREGPROP
];
2005 r
= talloc(talloc_tos(), struct PNP_SetClassRegProp
);
2010 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2015 pull
= ndr_pull_init_blob(&blob
, r
);
2021 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2022 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2023 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2028 if (DEBUGLEVEL
>= 10) {
2029 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp
, r
);
2032 r
->out
.result
= _PNP_SetClassRegProp(p
, r
);
2034 if (p
->rng_fault_state
) {
2036 /* Return true here, srv_pipe_hnd.c will take care */
2040 if (DEBUGLEVEL
>= 10) {
2041 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp
, r
);
2044 push
= ndr_push_init_ctx(r
);
2050 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2051 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2056 blob
= ndr_push_blob(push
);
2057 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2067 static bool api_PNP_CreateDevInst(pipes_struct
*p
)
2069 const struct ndr_interface_call
*call
;
2070 struct ndr_pull
*pull
;
2071 struct ndr_push
*push
;
2072 enum ndr_err_code ndr_err
;
2074 struct PNP_CreateDevInst
*r
;
2076 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_CREATEDEVINST
];
2078 r
= talloc(talloc_tos(), struct PNP_CreateDevInst
);
2083 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2088 pull
= ndr_pull_init_blob(&blob
, r
);
2094 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2095 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2101 if (DEBUGLEVEL
>= 10) {
2102 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst
, r
);
2105 r
->out
.result
= _PNP_CreateDevInst(p
, r
);
2107 if (p
->rng_fault_state
) {
2109 /* Return true here, srv_pipe_hnd.c will take care */
2113 if (DEBUGLEVEL
>= 10) {
2114 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst
, r
);
2117 push
= ndr_push_init_ctx(r
);
2123 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2124 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2129 blob
= ndr_push_blob(push
);
2130 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2140 static bool api_PNP_DeviceInstanceAction(pipes_struct
*p
)
2142 const struct ndr_interface_call
*call
;
2143 struct ndr_pull
*pull
;
2144 struct ndr_push
*push
;
2145 enum ndr_err_code ndr_err
;
2147 struct PNP_DeviceInstanceAction
*r
;
2149 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DEVICEINSTANCEACTION
];
2151 r
= talloc(talloc_tos(), struct PNP_DeviceInstanceAction
);
2156 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2161 pull
= ndr_pull_init_blob(&blob
, r
);
2167 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2168 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2174 if (DEBUGLEVEL
>= 10) {
2175 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction
, r
);
2178 r
->out
.result
= _PNP_DeviceInstanceAction(p
, r
);
2180 if (p
->rng_fault_state
) {
2182 /* Return true here, srv_pipe_hnd.c will take care */
2186 if (DEBUGLEVEL
>= 10) {
2187 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction
, r
);
2190 push
= ndr_push_init_ctx(r
);
2196 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2197 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2202 blob
= ndr_push_blob(push
);
2203 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2213 static bool api_PNP_GetDeviceStatus(pipes_struct
*p
)
2215 const struct ndr_interface_call
*call
;
2216 struct ndr_pull
*pull
;
2217 struct ndr_push
*push
;
2218 enum ndr_err_code ndr_err
;
2220 struct PNP_GetDeviceStatus
*r
;
2222 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETDEVICESTATUS
];
2224 r
= talloc(talloc_tos(), struct PNP_GetDeviceStatus
);
2229 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2234 pull
= ndr_pull_init_blob(&blob
, r
);
2240 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2241 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2247 if (DEBUGLEVEL
>= 10) {
2248 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus
, r
);
2251 r
->out
.result
= _PNP_GetDeviceStatus(p
, r
);
2253 if (p
->rng_fault_state
) {
2255 /* Return true here, srv_pipe_hnd.c will take care */
2259 if (DEBUGLEVEL
>= 10) {
2260 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus
, r
);
2263 push
= ndr_push_init_ctx(r
);
2269 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2270 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2275 blob
= ndr_push_blob(push
);
2276 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2286 static bool api_PNP_SetDeviceProblem(pipes_struct
*p
)
2288 const struct ndr_interface_call
*call
;
2289 struct ndr_pull
*pull
;
2290 struct ndr_push
*push
;
2291 enum ndr_err_code ndr_err
;
2293 struct PNP_SetDeviceProblem
*r
;
2295 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_SETDEVICEPROBLEM
];
2297 r
= talloc(talloc_tos(), struct PNP_SetDeviceProblem
);
2302 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2307 pull
= ndr_pull_init_blob(&blob
, r
);
2313 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2314 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2320 if (DEBUGLEVEL
>= 10) {
2321 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem
, r
);
2324 r
->out
.result
= _PNP_SetDeviceProblem(p
, r
);
2326 if (p
->rng_fault_state
) {
2328 /* Return true here, srv_pipe_hnd.c will take care */
2332 if (DEBUGLEVEL
>= 10) {
2333 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem
, r
);
2336 push
= ndr_push_init_ctx(r
);
2342 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2343 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2348 blob
= ndr_push_blob(push
);
2349 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2359 static bool api_PNP_DisableDevInst(pipes_struct
*p
)
2361 const struct ndr_interface_call
*call
;
2362 struct ndr_pull
*pull
;
2363 struct ndr_push
*push
;
2364 enum ndr_err_code ndr_err
;
2366 struct PNP_DisableDevInst
*r
;
2368 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DISABLEDEVINST
];
2370 r
= talloc(talloc_tos(), struct PNP_DisableDevInst
);
2375 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2380 pull
= ndr_pull_init_blob(&blob
, r
);
2386 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2387 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2388 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2393 if (DEBUGLEVEL
>= 10) {
2394 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst
, r
);
2397 r
->out
.result
= _PNP_DisableDevInst(p
, r
);
2399 if (p
->rng_fault_state
) {
2401 /* Return true here, srv_pipe_hnd.c will take care */
2405 if (DEBUGLEVEL
>= 10) {
2406 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst
, r
);
2409 push
= ndr_push_init_ctx(r
);
2415 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2421 blob
= ndr_push_blob(push
);
2422 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2432 static bool api_PNP_UninstallDevInst(pipes_struct
*p
)
2434 const struct ndr_interface_call
*call
;
2435 struct ndr_pull
*pull
;
2436 struct ndr_push
*push
;
2437 enum ndr_err_code ndr_err
;
2439 struct PNP_UninstallDevInst
*r
;
2441 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_UNINSTALLDEVINST
];
2443 r
= talloc(talloc_tos(), struct PNP_UninstallDevInst
);
2448 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2453 pull
= ndr_pull_init_blob(&blob
, r
);
2459 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2460 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2466 if (DEBUGLEVEL
>= 10) {
2467 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst
, r
);
2470 r
->out
.result
= _PNP_UninstallDevInst(p
, r
);
2472 if (p
->rng_fault_state
) {
2474 /* Return true here, srv_pipe_hnd.c will take care */
2478 if (DEBUGLEVEL
>= 10) {
2479 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst
, r
);
2482 push
= ndr_push_init_ctx(r
);
2488 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2489 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2494 blob
= ndr_push_blob(push
);
2495 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2505 static bool api_PNP_AddID(pipes_struct
*p
)
2507 const struct ndr_interface_call
*call
;
2508 struct ndr_pull
*pull
;
2509 struct ndr_push
*push
;
2510 enum ndr_err_code ndr_err
;
2512 struct PNP_AddID
*r
;
2514 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_ADDID
];
2516 r
= talloc(talloc_tos(), struct PNP_AddID
);
2521 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2526 pull
= ndr_pull_init_blob(&blob
, r
);
2532 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2533 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2534 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2539 if (DEBUGLEVEL
>= 10) {
2540 NDR_PRINT_IN_DEBUG(PNP_AddID
, r
);
2543 r
->out
.result
= _PNP_AddID(p
, r
);
2545 if (p
->rng_fault_state
) {
2547 /* Return true here, srv_pipe_hnd.c will take care */
2551 if (DEBUGLEVEL
>= 10) {
2552 NDR_PRINT_OUT_DEBUG(PNP_AddID
, r
);
2555 push
= ndr_push_init_ctx(r
);
2561 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2562 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2567 blob
= ndr_push_blob(push
);
2568 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2578 static bool api_PNP_RegisterDriver(pipes_struct
*p
)
2580 const struct ndr_interface_call
*call
;
2581 struct ndr_pull
*pull
;
2582 struct ndr_push
*push
;
2583 enum ndr_err_code ndr_err
;
2585 struct PNP_RegisterDriver
*r
;
2587 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REGISTERDRIVER
];
2589 r
= talloc(talloc_tos(), struct PNP_RegisterDriver
);
2594 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2599 pull
= ndr_pull_init_blob(&blob
, r
);
2605 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2606 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2607 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2612 if (DEBUGLEVEL
>= 10) {
2613 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver
, r
);
2616 r
->out
.result
= _PNP_RegisterDriver(p
, r
);
2618 if (p
->rng_fault_state
) {
2620 /* Return true here, srv_pipe_hnd.c will take care */
2624 if (DEBUGLEVEL
>= 10) {
2625 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver
, r
);
2628 push
= ndr_push_init_ctx(r
);
2634 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2640 blob
= ndr_push_blob(push
);
2641 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2651 static bool api_PNP_QueryRemove(pipes_struct
*p
)
2653 const struct ndr_interface_call
*call
;
2654 struct ndr_pull
*pull
;
2655 struct ndr_push
*push
;
2656 enum ndr_err_code ndr_err
;
2658 struct PNP_QueryRemove
*r
;
2660 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_QUERYREMOVE
];
2662 r
= talloc(talloc_tos(), struct PNP_QueryRemove
);
2667 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2672 pull
= ndr_pull_init_blob(&blob
, r
);
2678 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2679 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2680 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2685 if (DEBUGLEVEL
>= 10) {
2686 NDR_PRINT_IN_DEBUG(PNP_QueryRemove
, r
);
2689 r
->out
.result
= _PNP_QueryRemove(p
, r
);
2691 if (p
->rng_fault_state
) {
2693 /* Return true here, srv_pipe_hnd.c will take care */
2697 if (DEBUGLEVEL
>= 10) {
2698 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove
, r
);
2701 push
= ndr_push_init_ctx(r
);
2707 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2708 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2713 blob
= ndr_push_blob(push
);
2714 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2724 static bool api_PNP_RequestDeviceEject(pipes_struct
*p
)
2726 const struct ndr_interface_call
*call
;
2727 struct ndr_pull
*pull
;
2728 struct ndr_push
*push
;
2729 enum ndr_err_code ndr_err
;
2731 struct PNP_RequestDeviceEject
*r
;
2733 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REQUESTDEVICEEJECT
];
2735 r
= talloc(talloc_tos(), struct PNP_RequestDeviceEject
);
2740 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2745 pull
= ndr_pull_init_blob(&blob
, r
);
2751 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2752 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2753 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2758 if (DEBUGLEVEL
>= 10) {
2759 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject
, r
);
2762 r
->out
.result
= _PNP_RequestDeviceEject(p
, r
);
2764 if (p
->rng_fault_state
) {
2766 /* Return true here, srv_pipe_hnd.c will take care */
2770 if (DEBUGLEVEL
>= 10) {
2771 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject
, r
);
2774 push
= ndr_push_init_ctx(r
);
2780 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2781 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2786 blob
= ndr_push_blob(push
);
2787 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2797 static bool api_PNP_IsDockStationPresent(pipes_struct
*p
)
2799 const struct ndr_interface_call
*call
;
2800 struct ndr_pull
*pull
;
2801 struct ndr_push
*push
;
2802 enum ndr_err_code ndr_err
;
2804 struct PNP_IsDockStationPresent
*r
;
2806 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_ISDOCKSTATIONPRESENT
];
2808 r
= talloc(talloc_tos(), struct PNP_IsDockStationPresent
);
2813 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2818 pull
= ndr_pull_init_blob(&blob
, r
);
2824 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2825 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2826 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2831 if (DEBUGLEVEL
>= 10) {
2832 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent
, r
);
2835 r
->out
.result
= _PNP_IsDockStationPresent(p
, r
);
2837 if (p
->rng_fault_state
) {
2839 /* Return true here, srv_pipe_hnd.c will take care */
2843 if (DEBUGLEVEL
>= 10) {
2844 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent
, r
);
2847 push
= ndr_push_init_ctx(r
);
2853 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2854 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2859 blob
= ndr_push_blob(push
);
2860 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2870 static bool api_PNP_RequestEjectPC(pipes_struct
*p
)
2872 const struct ndr_interface_call
*call
;
2873 struct ndr_pull
*pull
;
2874 struct ndr_push
*push
;
2875 enum ndr_err_code ndr_err
;
2877 struct PNP_RequestEjectPC
*r
;
2879 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REQUESTEJECTPC
];
2881 r
= talloc(talloc_tos(), struct PNP_RequestEjectPC
);
2886 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2891 pull
= ndr_pull_init_blob(&blob
, r
);
2897 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2898 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2899 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2904 if (DEBUGLEVEL
>= 10) {
2905 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC
, r
);
2908 r
->out
.result
= _PNP_RequestEjectPC(p
, r
);
2910 if (p
->rng_fault_state
) {
2912 /* Return true here, srv_pipe_hnd.c will take care */
2916 if (DEBUGLEVEL
>= 10) {
2917 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC
, r
);
2920 push
= ndr_push_init_ctx(r
);
2926 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
2927 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2932 blob
= ndr_push_blob(push
);
2933 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
2943 static bool api_PNP_HwProfFlags(pipes_struct
*p
)
2945 const struct ndr_interface_call
*call
;
2946 struct ndr_pull
*pull
;
2947 struct ndr_push
*push
;
2948 enum ndr_err_code ndr_err
;
2950 struct PNP_HwProfFlags
*r
;
2952 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_HWPROFFLAGS
];
2954 r
= talloc(talloc_tos(), struct PNP_HwProfFlags
);
2959 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
2964 pull
= ndr_pull_init_blob(&blob
, r
);
2970 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
2971 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
2972 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
2977 if (DEBUGLEVEL
>= 10) {
2978 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags
, r
);
2981 ZERO_STRUCT(r
->out
);
2982 r
->out
.unknown3
= r
->in
.unknown3
;
2983 r
->out
.unknown4
= r
->in
.unknown4
;
2984 r
->out
.unknown5a
= talloc_zero(r
, const char *);
2985 if (r
->out
.unknown5a
== NULL
) {
2990 r
->out
.result
= _PNP_HwProfFlags(p
, r
);
2992 if (p
->rng_fault_state
) {
2994 /* Return true here, srv_pipe_hnd.c will take care */
2998 if (DEBUGLEVEL
>= 10) {
2999 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags
, r
);
3002 push
= ndr_push_init_ctx(r
);
3008 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3009 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3014 blob
= ndr_push_blob(push
);
3015 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3025 static bool api_PNP_GetHwProfInfo(pipes_struct
*p
)
3027 const struct ndr_interface_call
*call
;
3028 struct ndr_pull
*pull
;
3029 struct ndr_push
*push
;
3030 enum ndr_err_code ndr_err
;
3032 struct PNP_GetHwProfInfo
*r
;
3034 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETHWPROFINFO
];
3036 r
= talloc(talloc_tos(), struct PNP_GetHwProfInfo
);
3041 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3046 pull
= ndr_pull_init_blob(&blob
, r
);
3052 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3053 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3054 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3059 if (DEBUGLEVEL
>= 10) {
3060 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo
, r
);
3063 r
->out
.result
= _PNP_GetHwProfInfo(p
, r
);
3065 if (p
->rng_fault_state
) {
3067 /* Return true here, srv_pipe_hnd.c will take care */
3071 if (DEBUGLEVEL
>= 10) {
3072 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo
, r
);
3075 push
= ndr_push_init_ctx(r
);
3081 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3082 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3087 blob
= ndr_push_blob(push
);
3088 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3098 static bool api_PNP_AddEmptyLogConf(pipes_struct
*p
)
3100 const struct ndr_interface_call
*call
;
3101 struct ndr_pull
*pull
;
3102 struct ndr_push
*push
;
3103 enum ndr_err_code ndr_err
;
3105 struct PNP_AddEmptyLogConf
*r
;
3107 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_ADDEMPTYLOGCONF
];
3109 r
= talloc(talloc_tos(), struct PNP_AddEmptyLogConf
);
3114 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3119 pull
= ndr_pull_init_blob(&blob
, r
);
3125 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3126 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3127 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3132 if (DEBUGLEVEL
>= 10) {
3133 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf
, r
);
3136 r
->out
.result
= _PNP_AddEmptyLogConf(p
, r
);
3138 if (p
->rng_fault_state
) {
3140 /* Return true here, srv_pipe_hnd.c will take care */
3144 if (DEBUGLEVEL
>= 10) {
3145 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf
, r
);
3148 push
= ndr_push_init_ctx(r
);
3154 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3155 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3160 blob
= ndr_push_blob(push
);
3161 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3171 static bool api_PNP_FreeLogConf(pipes_struct
*p
)
3173 const struct ndr_interface_call
*call
;
3174 struct ndr_pull
*pull
;
3175 struct ndr_push
*push
;
3176 enum ndr_err_code ndr_err
;
3178 struct PNP_FreeLogConf
*r
;
3180 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_FREELOGCONF
];
3182 r
= talloc(talloc_tos(), struct PNP_FreeLogConf
);
3187 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3192 pull
= ndr_pull_init_blob(&blob
, r
);
3198 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3199 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3200 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3205 if (DEBUGLEVEL
>= 10) {
3206 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf
, r
);
3209 r
->out
.result
= _PNP_FreeLogConf(p
, r
);
3211 if (p
->rng_fault_state
) {
3213 /* Return true here, srv_pipe_hnd.c will take care */
3217 if (DEBUGLEVEL
>= 10) {
3218 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf
, r
);
3221 push
= ndr_push_init_ctx(r
);
3227 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3228 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3233 blob
= ndr_push_blob(push
);
3234 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3244 static bool api_PNP_GetFirstLogConf(pipes_struct
*p
)
3246 const struct ndr_interface_call
*call
;
3247 struct ndr_pull
*pull
;
3248 struct ndr_push
*push
;
3249 enum ndr_err_code ndr_err
;
3251 struct PNP_GetFirstLogConf
*r
;
3253 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETFIRSTLOGCONF
];
3255 r
= talloc(talloc_tos(), struct PNP_GetFirstLogConf
);
3260 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3265 pull
= ndr_pull_init_blob(&blob
, r
);
3271 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3272 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3273 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3278 if (DEBUGLEVEL
>= 10) {
3279 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf
, r
);
3282 r
->out
.result
= _PNP_GetFirstLogConf(p
, r
);
3284 if (p
->rng_fault_state
) {
3286 /* Return true here, srv_pipe_hnd.c will take care */
3290 if (DEBUGLEVEL
>= 10) {
3291 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf
, r
);
3294 push
= ndr_push_init_ctx(r
);
3300 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3301 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3306 blob
= ndr_push_blob(push
);
3307 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3317 static bool api_PNP_GetNextLogConf(pipes_struct
*p
)
3319 const struct ndr_interface_call
*call
;
3320 struct ndr_pull
*pull
;
3321 struct ndr_push
*push
;
3322 enum ndr_err_code ndr_err
;
3324 struct PNP_GetNextLogConf
*r
;
3326 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETNEXTLOGCONF
];
3328 r
= talloc(talloc_tos(), struct PNP_GetNextLogConf
);
3333 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3338 pull
= ndr_pull_init_blob(&blob
, r
);
3344 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3345 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3346 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3351 if (DEBUGLEVEL
>= 10) {
3352 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf
, r
);
3355 r
->out
.result
= _PNP_GetNextLogConf(p
, r
);
3357 if (p
->rng_fault_state
) {
3359 /* Return true here, srv_pipe_hnd.c will take care */
3363 if (DEBUGLEVEL
>= 10) {
3364 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf
, r
);
3367 push
= ndr_push_init_ctx(r
);
3373 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3374 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3379 blob
= ndr_push_blob(push
);
3380 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3390 static bool api_PNP_GetLogConfPriority(pipes_struct
*p
)
3392 const struct ndr_interface_call
*call
;
3393 struct ndr_pull
*pull
;
3394 struct ndr_push
*push
;
3395 enum ndr_err_code ndr_err
;
3397 struct PNP_GetLogConfPriority
*r
;
3399 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETLOGCONFPRIORITY
];
3401 r
= talloc(talloc_tos(), struct PNP_GetLogConfPriority
);
3406 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3411 pull
= ndr_pull_init_blob(&blob
, r
);
3417 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3418 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3419 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3424 if (DEBUGLEVEL
>= 10) {
3425 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority
, r
);
3428 r
->out
.result
= _PNP_GetLogConfPriority(p
, r
);
3430 if (p
->rng_fault_state
) {
3432 /* Return true here, srv_pipe_hnd.c will take care */
3436 if (DEBUGLEVEL
>= 10) {
3437 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority
, r
);
3440 push
= ndr_push_init_ctx(r
);
3446 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3447 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3452 blob
= ndr_push_blob(push
);
3453 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3463 static bool api_PNP_AddResDes(pipes_struct
*p
)
3465 const struct ndr_interface_call
*call
;
3466 struct ndr_pull
*pull
;
3467 struct ndr_push
*push
;
3468 enum ndr_err_code ndr_err
;
3470 struct PNP_AddResDes
*r
;
3472 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_ADDRESDES
];
3474 r
= talloc(talloc_tos(), struct PNP_AddResDes
);
3479 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3484 pull
= ndr_pull_init_blob(&blob
, r
);
3490 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3491 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3492 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3497 if (DEBUGLEVEL
>= 10) {
3498 NDR_PRINT_IN_DEBUG(PNP_AddResDes
, r
);
3501 r
->out
.result
= _PNP_AddResDes(p
, r
);
3503 if (p
->rng_fault_state
) {
3505 /* Return true here, srv_pipe_hnd.c will take care */
3509 if (DEBUGLEVEL
>= 10) {
3510 NDR_PRINT_OUT_DEBUG(PNP_AddResDes
, r
);
3513 push
= ndr_push_init_ctx(r
);
3519 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3520 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3525 blob
= ndr_push_blob(push
);
3526 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3536 static bool api_PNP_FreeResDes(pipes_struct
*p
)
3538 const struct ndr_interface_call
*call
;
3539 struct ndr_pull
*pull
;
3540 struct ndr_push
*push
;
3541 enum ndr_err_code ndr_err
;
3543 struct PNP_FreeResDes
*r
;
3545 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_FREERESDES
];
3547 r
= talloc(talloc_tos(), struct PNP_FreeResDes
);
3552 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3557 pull
= ndr_pull_init_blob(&blob
, r
);
3563 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3564 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3565 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3570 if (DEBUGLEVEL
>= 10) {
3571 NDR_PRINT_IN_DEBUG(PNP_FreeResDes
, r
);
3574 r
->out
.result
= _PNP_FreeResDes(p
, r
);
3576 if (p
->rng_fault_state
) {
3578 /* Return true here, srv_pipe_hnd.c will take care */
3582 if (DEBUGLEVEL
>= 10) {
3583 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes
, r
);
3586 push
= ndr_push_init_ctx(r
);
3592 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3593 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3598 blob
= ndr_push_blob(push
);
3599 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3609 static bool api_PNP_GetNextResDes(pipes_struct
*p
)
3611 const struct ndr_interface_call
*call
;
3612 struct ndr_pull
*pull
;
3613 struct ndr_push
*push
;
3614 enum ndr_err_code ndr_err
;
3616 struct PNP_GetNextResDes
*r
;
3618 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETNEXTRESDES
];
3620 r
= talloc(talloc_tos(), struct PNP_GetNextResDes
);
3625 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3630 pull
= ndr_pull_init_blob(&blob
, r
);
3636 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3637 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3638 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3643 if (DEBUGLEVEL
>= 10) {
3644 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes
, r
);
3647 r
->out
.result
= _PNP_GetNextResDes(p
, r
);
3649 if (p
->rng_fault_state
) {
3651 /* Return true here, srv_pipe_hnd.c will take care */
3655 if (DEBUGLEVEL
>= 10) {
3656 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes
, r
);
3659 push
= ndr_push_init_ctx(r
);
3665 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3666 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3671 blob
= ndr_push_blob(push
);
3672 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3682 static bool api_PNP_GetResDesData(pipes_struct
*p
)
3684 const struct ndr_interface_call
*call
;
3685 struct ndr_pull
*pull
;
3686 struct ndr_push
*push
;
3687 enum ndr_err_code ndr_err
;
3689 struct PNP_GetResDesData
*r
;
3691 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETRESDESDATA
];
3693 r
= talloc(talloc_tos(), struct PNP_GetResDesData
);
3698 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3703 pull
= ndr_pull_init_blob(&blob
, r
);
3709 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3710 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3711 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3716 if (DEBUGLEVEL
>= 10) {
3717 NDR_PRINT_IN_DEBUG(PNP_GetResDesData
, r
);
3720 r
->out
.result
= _PNP_GetResDesData(p
, r
);
3722 if (p
->rng_fault_state
) {
3724 /* Return true here, srv_pipe_hnd.c will take care */
3728 if (DEBUGLEVEL
>= 10) {
3729 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData
, r
);
3732 push
= ndr_push_init_ctx(r
);
3738 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3739 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3744 blob
= ndr_push_blob(push
);
3745 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3755 static bool api_PNP_GetResDesDataSize(pipes_struct
*p
)
3757 const struct ndr_interface_call
*call
;
3758 struct ndr_pull
*pull
;
3759 struct ndr_push
*push
;
3760 enum ndr_err_code ndr_err
;
3762 struct PNP_GetResDesDataSize
*r
;
3764 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETRESDESDATASIZE
];
3766 r
= talloc(talloc_tos(), struct PNP_GetResDesDataSize
);
3771 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3776 pull
= ndr_pull_init_blob(&blob
, r
);
3782 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3783 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3784 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3789 if (DEBUGLEVEL
>= 10) {
3790 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize
, r
);
3793 r
->out
.result
= _PNP_GetResDesDataSize(p
, r
);
3795 if (p
->rng_fault_state
) {
3797 /* Return true here, srv_pipe_hnd.c will take care */
3801 if (DEBUGLEVEL
>= 10) {
3802 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize
, r
);
3805 push
= ndr_push_init_ctx(r
);
3811 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3812 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3817 blob
= ndr_push_blob(push
);
3818 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3828 static bool api_PNP_ModifyResDes(pipes_struct
*p
)
3830 const struct ndr_interface_call
*call
;
3831 struct ndr_pull
*pull
;
3832 struct ndr_push
*push
;
3833 enum ndr_err_code ndr_err
;
3835 struct PNP_ModifyResDes
*r
;
3837 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_MODIFYRESDES
];
3839 r
= talloc(talloc_tos(), struct PNP_ModifyResDes
);
3844 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3849 pull
= ndr_pull_init_blob(&blob
, r
);
3855 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3856 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3857 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3862 if (DEBUGLEVEL
>= 10) {
3863 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes
, r
);
3866 r
->out
.result
= _PNP_ModifyResDes(p
, r
);
3868 if (p
->rng_fault_state
) {
3870 /* Return true here, srv_pipe_hnd.c will take care */
3874 if (DEBUGLEVEL
>= 10) {
3875 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes
, r
);
3878 push
= ndr_push_init_ctx(r
);
3884 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3885 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3890 blob
= ndr_push_blob(push
);
3891 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3901 static bool api_PNP_DetectResourceLimit(pipes_struct
*p
)
3903 const struct ndr_interface_call
*call
;
3904 struct ndr_pull
*pull
;
3905 struct ndr_push
*push
;
3906 enum ndr_err_code ndr_err
;
3908 struct PNP_DetectResourceLimit
*r
;
3910 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_DETECTRESOURCELIMIT
];
3912 r
= talloc(talloc_tos(), struct PNP_DetectResourceLimit
);
3917 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3922 pull
= ndr_pull_init_blob(&blob
, r
);
3928 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
3929 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
3930 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3935 if (DEBUGLEVEL
>= 10) {
3936 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit
, r
);
3939 r
->out
.result
= _PNP_DetectResourceLimit(p
, r
);
3941 if (p
->rng_fault_state
) {
3943 /* Return true here, srv_pipe_hnd.c will take care */
3947 if (DEBUGLEVEL
>= 10) {
3948 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit
, r
);
3951 push
= ndr_push_init_ctx(r
);
3957 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
3958 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
3963 blob
= ndr_push_blob(push
);
3964 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
3974 static bool api_PNP_QueryResConfList(pipes_struct
*p
)
3976 const struct ndr_interface_call
*call
;
3977 struct ndr_pull
*pull
;
3978 struct ndr_push
*push
;
3979 enum ndr_err_code ndr_err
;
3981 struct PNP_QueryResConfList
*r
;
3983 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_QUERYRESCONFLIST
];
3985 r
= talloc(talloc_tos(), struct PNP_QueryResConfList
);
3990 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
3995 pull
= ndr_pull_init_blob(&blob
, r
);
4001 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4002 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4003 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4008 if (DEBUGLEVEL
>= 10) {
4009 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList
, r
);
4012 r
->out
.result
= _PNP_QueryResConfList(p
, r
);
4014 if (p
->rng_fault_state
) {
4016 /* Return true here, srv_pipe_hnd.c will take care */
4020 if (DEBUGLEVEL
>= 10) {
4021 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList
, r
);
4024 push
= ndr_push_init_ctx(r
);
4030 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4031 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4036 blob
= ndr_push_blob(push
);
4037 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4047 static bool api_PNP_SetHwProf(pipes_struct
*p
)
4049 const struct ndr_interface_call
*call
;
4050 struct ndr_pull
*pull
;
4051 struct ndr_push
*push
;
4052 enum ndr_err_code ndr_err
;
4054 struct PNP_SetHwProf
*r
;
4056 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_SETHWPROF
];
4058 r
= talloc(talloc_tos(), struct PNP_SetHwProf
);
4063 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4068 pull
= ndr_pull_init_blob(&blob
, r
);
4074 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4075 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4076 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4081 if (DEBUGLEVEL
>= 10) {
4082 NDR_PRINT_IN_DEBUG(PNP_SetHwProf
, r
);
4085 r
->out
.result
= _PNP_SetHwProf(p
, r
);
4087 if (p
->rng_fault_state
) {
4089 /* Return true here, srv_pipe_hnd.c will take care */
4093 if (DEBUGLEVEL
>= 10) {
4094 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf
, r
);
4097 push
= ndr_push_init_ctx(r
);
4103 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4104 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4109 blob
= ndr_push_blob(push
);
4110 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4120 static bool api_PNP_QueryArbitratorFreeData(pipes_struct
*p
)
4122 const struct ndr_interface_call
*call
;
4123 struct ndr_pull
*pull
;
4124 struct ndr_push
*push
;
4125 enum ndr_err_code ndr_err
;
4127 struct PNP_QueryArbitratorFreeData
*r
;
4129 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_QUERYARBITRATORFREEDATA
];
4131 r
= talloc(talloc_tos(), struct PNP_QueryArbitratorFreeData
);
4136 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4141 pull
= ndr_pull_init_blob(&blob
, r
);
4147 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4148 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4149 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4154 if (DEBUGLEVEL
>= 10) {
4155 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData
, r
);
4158 r
->out
.result
= _PNP_QueryArbitratorFreeData(p
, r
);
4160 if (p
->rng_fault_state
) {
4162 /* Return true here, srv_pipe_hnd.c will take care */
4166 if (DEBUGLEVEL
>= 10) {
4167 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData
, r
);
4170 push
= ndr_push_init_ctx(r
);
4176 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4177 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4182 blob
= ndr_push_blob(push
);
4183 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4193 static bool api_PNP_QueryArbitratorFreeSize(pipes_struct
*p
)
4195 const struct ndr_interface_call
*call
;
4196 struct ndr_pull
*pull
;
4197 struct ndr_push
*push
;
4198 enum ndr_err_code ndr_err
;
4200 struct PNP_QueryArbitratorFreeSize
*r
;
4202 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_QUERYARBITRATORFREESIZE
];
4204 r
= talloc(talloc_tos(), struct PNP_QueryArbitratorFreeSize
);
4209 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4214 pull
= ndr_pull_init_blob(&blob
, r
);
4220 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4221 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4222 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4227 if (DEBUGLEVEL
>= 10) {
4228 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize
, r
);
4231 r
->out
.result
= _PNP_QueryArbitratorFreeSize(p
, r
);
4233 if (p
->rng_fault_state
) {
4235 /* Return true here, srv_pipe_hnd.c will take care */
4239 if (DEBUGLEVEL
>= 10) {
4240 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize
, r
);
4243 push
= ndr_push_init_ctx(r
);
4249 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4250 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4255 blob
= ndr_push_blob(push
);
4256 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4266 static bool api_PNP_RunDetection(pipes_struct
*p
)
4268 const struct ndr_interface_call
*call
;
4269 struct ndr_pull
*pull
;
4270 struct ndr_push
*push
;
4271 enum ndr_err_code ndr_err
;
4273 struct PNP_RunDetection
*r
;
4275 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_RUNDETECTION
];
4277 r
= talloc(talloc_tos(), struct PNP_RunDetection
);
4282 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4287 pull
= ndr_pull_init_blob(&blob
, r
);
4293 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4294 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4295 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4300 if (DEBUGLEVEL
>= 10) {
4301 NDR_PRINT_IN_DEBUG(PNP_RunDetection
, r
);
4304 r
->out
.result
= _PNP_RunDetection(p
, r
);
4306 if (p
->rng_fault_state
) {
4308 /* Return true here, srv_pipe_hnd.c will take care */
4312 if (DEBUGLEVEL
>= 10) {
4313 NDR_PRINT_OUT_DEBUG(PNP_RunDetection
, r
);
4316 push
= ndr_push_init_ctx(r
);
4322 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4323 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4328 blob
= ndr_push_blob(push
);
4329 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4339 static bool api_PNP_RegisterNotification(pipes_struct
*p
)
4341 const struct ndr_interface_call
*call
;
4342 struct ndr_pull
*pull
;
4343 struct ndr_push
*push
;
4344 enum ndr_err_code ndr_err
;
4346 struct PNP_RegisterNotification
*r
;
4348 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_REGISTERNOTIFICATION
];
4350 r
= talloc(talloc_tos(), struct PNP_RegisterNotification
);
4355 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4360 pull
= ndr_pull_init_blob(&blob
, r
);
4366 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4367 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4368 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4373 if (DEBUGLEVEL
>= 10) {
4374 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification
, r
);
4377 r
->out
.result
= _PNP_RegisterNotification(p
, r
);
4379 if (p
->rng_fault_state
) {
4381 /* Return true here, srv_pipe_hnd.c will take care */
4385 if (DEBUGLEVEL
>= 10) {
4386 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification
, r
);
4389 push
= ndr_push_init_ctx(r
);
4395 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4396 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4401 blob
= ndr_push_blob(push
);
4402 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4412 static bool api_PNP_UnregisterNotification(pipes_struct
*p
)
4414 const struct ndr_interface_call
*call
;
4415 struct ndr_pull
*pull
;
4416 struct ndr_push
*push
;
4417 enum ndr_err_code ndr_err
;
4419 struct PNP_UnregisterNotification
*r
;
4421 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_UNREGISTERNOTIFICATION
];
4423 r
= talloc(talloc_tos(), struct PNP_UnregisterNotification
);
4428 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4433 pull
= ndr_pull_init_blob(&blob
, r
);
4439 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4440 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4441 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4446 if (DEBUGLEVEL
>= 10) {
4447 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification
, r
);
4450 r
->out
.result
= _PNP_UnregisterNotification(p
, r
);
4452 if (p
->rng_fault_state
) {
4454 /* Return true here, srv_pipe_hnd.c will take care */
4458 if (DEBUGLEVEL
>= 10) {
4459 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification
, r
);
4462 push
= ndr_push_init_ctx(r
);
4468 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4469 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4474 blob
= ndr_push_blob(push
);
4475 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4485 static bool api_PNP_GetCustomDevProp(pipes_struct
*p
)
4487 const struct ndr_interface_call
*call
;
4488 struct ndr_pull
*pull
;
4489 struct ndr_push
*push
;
4490 enum ndr_err_code ndr_err
;
4492 struct PNP_GetCustomDevProp
*r
;
4494 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETCUSTOMDEVPROP
];
4496 r
= talloc(talloc_tos(), struct PNP_GetCustomDevProp
);
4501 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4506 pull
= ndr_pull_init_blob(&blob
, r
);
4512 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4513 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4514 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4519 if (DEBUGLEVEL
>= 10) {
4520 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp
, r
);
4523 r
->out
.result
= _PNP_GetCustomDevProp(p
, r
);
4525 if (p
->rng_fault_state
) {
4527 /* Return true here, srv_pipe_hnd.c will take care */
4531 if (DEBUGLEVEL
>= 10) {
4532 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp
, r
);
4535 push
= ndr_push_init_ctx(r
);
4541 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4542 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4547 blob
= ndr_push_blob(push
);
4548 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4558 static bool api_PNP_GetVersionInternal(pipes_struct
*p
)
4560 const struct ndr_interface_call
*call
;
4561 struct ndr_pull
*pull
;
4562 struct ndr_push
*push
;
4563 enum ndr_err_code ndr_err
;
4565 struct PNP_GetVersionInternal
*r
;
4567 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETVERSIONINTERNAL
];
4569 r
= talloc(talloc_tos(), struct PNP_GetVersionInternal
);
4574 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4579 pull
= ndr_pull_init_blob(&blob
, r
);
4585 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4586 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4587 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4592 if (DEBUGLEVEL
>= 10) {
4593 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal
, r
);
4596 r
->out
.result
= _PNP_GetVersionInternal(p
, r
);
4598 if (p
->rng_fault_state
) {
4600 /* Return true here, srv_pipe_hnd.c will take care */
4604 if (DEBUGLEVEL
>= 10) {
4605 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal
, r
);
4608 push
= ndr_push_init_ctx(r
);
4614 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4615 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4620 blob
= ndr_push_blob(push
);
4621 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4631 static bool api_PNP_GetBlockedDriverInfo(pipes_struct
*p
)
4633 const struct ndr_interface_call
*call
;
4634 struct ndr_pull
*pull
;
4635 struct ndr_push
*push
;
4636 enum ndr_err_code ndr_err
;
4638 struct PNP_GetBlockedDriverInfo
*r
;
4640 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETBLOCKEDDRIVERINFO
];
4642 r
= talloc(talloc_tos(), struct PNP_GetBlockedDriverInfo
);
4647 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4652 pull
= ndr_pull_init_blob(&blob
, r
);
4658 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4659 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4660 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4665 if (DEBUGLEVEL
>= 10) {
4666 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo
, r
);
4669 r
->out
.result
= _PNP_GetBlockedDriverInfo(p
, r
);
4671 if (p
->rng_fault_state
) {
4673 /* Return true here, srv_pipe_hnd.c will take care */
4677 if (DEBUGLEVEL
>= 10) {
4678 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo
, r
);
4681 push
= ndr_push_init_ctx(r
);
4687 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4688 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4693 blob
= ndr_push_blob(push
);
4694 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4704 static bool api_PNP_GetServerSideDeviceInstallFlags(pipes_struct
*p
)
4706 const struct ndr_interface_call
*call
;
4707 struct ndr_pull
*pull
;
4708 struct ndr_push
*push
;
4709 enum ndr_err_code ndr_err
;
4711 struct PNP_GetServerSideDeviceInstallFlags
*r
;
4713 call
= &ndr_table_ntsvcs
.calls
[NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS
];
4715 r
= talloc(talloc_tos(), struct PNP_GetServerSideDeviceInstallFlags
);
4720 if (!prs_data_blob(&p
->in_data
.data
, &blob
, r
)) {
4725 pull
= ndr_pull_init_blob(&blob
, r
);
4731 pull
->flags
|= LIBNDR_FLAG_REF_ALLOC
;
4732 ndr_err
= call
->ndr_pull(pull
, NDR_IN
, r
);
4733 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4738 if (DEBUGLEVEL
>= 10) {
4739 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags
, r
);
4742 r
->out
.result
= _PNP_GetServerSideDeviceInstallFlags(p
, r
);
4744 if (p
->rng_fault_state
) {
4746 /* Return true here, srv_pipe_hnd.c will take care */
4750 if (DEBUGLEVEL
>= 10) {
4751 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags
, r
);
4754 push
= ndr_push_init_ctx(r
);
4760 ndr_err
= call
->ndr_push(push
, NDR_OUT
, r
);
4761 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
4766 blob
= ndr_push_blob(push
);
4767 if (!prs_copy_data_in(&p
->out_data
.rdata
, (const char *)blob
.data
, (uint32_t)blob
.length
)) {
4779 static struct api_struct api_ntsvcs_cmds
[] =
4781 {"PNP_DISCONNECT", NDR_PNP_DISCONNECT
, api_PNP_Disconnect
},
4782 {"PNP_CONNECT", NDR_PNP_CONNECT
, api_PNP_Connect
},
4783 {"PNP_GETVERSION", NDR_PNP_GETVERSION
, api_PNP_GetVersion
},
4784 {"PNP_GETGLOBALSTATE", NDR_PNP_GETGLOBALSTATE
, api_PNP_GetGlobalState
},
4785 {"PNP_INITDETECTION", NDR_PNP_INITDETECTION
, api_PNP_InitDetection
},
4786 {"PNP_REPORTLOGON", NDR_PNP_REPORTLOGON
, api_PNP_ReportLogOn
},
4787 {"PNP_VALIDATEDEVICEINSTANCE", NDR_PNP_VALIDATEDEVICEINSTANCE
, api_PNP_ValidateDeviceInstance
},
4788 {"PNP_GETROOTDEVICEINSTANCE", NDR_PNP_GETROOTDEVICEINSTANCE
, api_PNP_GetRootDeviceInstance
},
4789 {"PNP_GETRELATEDDEVICEINSTANCE", NDR_PNP_GETRELATEDDEVICEINSTANCE
, api_PNP_GetRelatedDeviceInstance
},
4790 {"PNP_ENUMERATESUBKEYS", NDR_PNP_ENUMERATESUBKEYS
, api_PNP_EnumerateSubKeys
},
4791 {"PNP_GETDEVICELIST", NDR_PNP_GETDEVICELIST
, api_PNP_GetDeviceList
},
4792 {"PNP_GETDEVICELISTSIZE", NDR_PNP_GETDEVICELISTSIZE
, api_PNP_GetDeviceListSize
},
4793 {"PNP_GETDEPTH", NDR_PNP_GETDEPTH
, api_PNP_GetDepth
},
4794 {"PNP_GETDEVICEREGPROP", NDR_PNP_GETDEVICEREGPROP
, api_PNP_GetDeviceRegProp
},
4795 {"PNP_SETDEVICEREGPROP", NDR_PNP_SETDEVICEREGPROP
, api_PNP_SetDeviceRegProp
},
4796 {"PNP_GETCLASSINSTANCE", NDR_PNP_GETCLASSINSTANCE
, api_PNP_GetClassInstance
},
4797 {"PNP_CREATEKEY", NDR_PNP_CREATEKEY
, api_PNP_CreateKey
},
4798 {"PNP_DELETEREGISTRYKEY", NDR_PNP_DELETEREGISTRYKEY
, api_PNP_DeleteRegistryKey
},
4799 {"PNP_GETCLASSCOUNT", NDR_PNP_GETCLASSCOUNT
, api_PNP_GetClassCount
},
4800 {"PNP_GETCLASSNAME", NDR_PNP_GETCLASSNAME
, api_PNP_GetClassName
},
4801 {"PNP_DELETECLASSKEY", NDR_PNP_DELETECLASSKEY
, api_PNP_DeleteClassKey
},
4802 {"PNP_GETINTERFACEDEVICEALIAS", NDR_PNP_GETINTERFACEDEVICEALIAS
, api_PNP_GetInterfaceDeviceAlias
},
4803 {"PNP_GETINTERFACEDEVICELIST", NDR_PNP_GETINTERFACEDEVICELIST
, api_PNP_GetInterfaceDeviceList
},
4804 {"PNP_GETINTERFACEDEVICELISTSIZE", NDR_PNP_GETINTERFACEDEVICELISTSIZE
, api_PNP_GetInterfaceDeviceListSize
},
4805 {"PNP_REGISTERDEVICECLASSASSOCIATION", NDR_PNP_REGISTERDEVICECLASSASSOCIATION
, api_PNP_RegisterDeviceClassAssociation
},
4806 {"PNP_UNREGISTERDEVICECLASSASSOCIATION", NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION
, api_PNP_UnregisterDeviceClassAssociation
},
4807 {"PNP_GETCLASSREGPROP", NDR_PNP_GETCLASSREGPROP
, api_PNP_GetClassRegProp
},
4808 {"PNP_SETCLASSREGPROP", NDR_PNP_SETCLASSREGPROP
, api_PNP_SetClassRegProp
},
4809 {"PNP_CREATEDEVINST", NDR_PNP_CREATEDEVINST
, api_PNP_CreateDevInst
},
4810 {"PNP_DEVICEINSTANCEACTION", NDR_PNP_DEVICEINSTANCEACTION
, api_PNP_DeviceInstanceAction
},
4811 {"PNP_GETDEVICESTATUS", NDR_PNP_GETDEVICESTATUS
, api_PNP_GetDeviceStatus
},
4812 {"PNP_SETDEVICEPROBLEM", NDR_PNP_SETDEVICEPROBLEM
, api_PNP_SetDeviceProblem
},
4813 {"PNP_DISABLEDEVINST", NDR_PNP_DISABLEDEVINST
, api_PNP_DisableDevInst
},
4814 {"PNP_UNINSTALLDEVINST", NDR_PNP_UNINSTALLDEVINST
, api_PNP_UninstallDevInst
},
4815 {"PNP_ADDID", NDR_PNP_ADDID
, api_PNP_AddID
},
4816 {"PNP_REGISTERDRIVER", NDR_PNP_REGISTERDRIVER
, api_PNP_RegisterDriver
},
4817 {"PNP_QUERYREMOVE", NDR_PNP_QUERYREMOVE
, api_PNP_QueryRemove
},
4818 {"PNP_REQUESTDEVICEEJECT", NDR_PNP_REQUESTDEVICEEJECT
, api_PNP_RequestDeviceEject
},
4819 {"PNP_ISDOCKSTATIONPRESENT", NDR_PNP_ISDOCKSTATIONPRESENT
, api_PNP_IsDockStationPresent
},
4820 {"PNP_REQUESTEJECTPC", NDR_PNP_REQUESTEJECTPC
, api_PNP_RequestEjectPC
},
4821 {"PNP_HWPROFFLAGS", NDR_PNP_HWPROFFLAGS
, api_PNP_HwProfFlags
},
4822 {"PNP_GETHWPROFINFO", NDR_PNP_GETHWPROFINFO
, api_PNP_GetHwProfInfo
},
4823 {"PNP_ADDEMPTYLOGCONF", NDR_PNP_ADDEMPTYLOGCONF
, api_PNP_AddEmptyLogConf
},
4824 {"PNP_FREELOGCONF", NDR_PNP_FREELOGCONF
, api_PNP_FreeLogConf
},
4825 {"PNP_GETFIRSTLOGCONF", NDR_PNP_GETFIRSTLOGCONF
, api_PNP_GetFirstLogConf
},
4826 {"PNP_GETNEXTLOGCONF", NDR_PNP_GETNEXTLOGCONF
, api_PNP_GetNextLogConf
},
4827 {"PNP_GETLOGCONFPRIORITY", NDR_PNP_GETLOGCONFPRIORITY
, api_PNP_GetLogConfPriority
},
4828 {"PNP_ADDRESDES", NDR_PNP_ADDRESDES
, api_PNP_AddResDes
},
4829 {"PNP_FREERESDES", NDR_PNP_FREERESDES
, api_PNP_FreeResDes
},
4830 {"PNP_GETNEXTRESDES", NDR_PNP_GETNEXTRESDES
, api_PNP_GetNextResDes
},
4831 {"PNP_GETRESDESDATA", NDR_PNP_GETRESDESDATA
, api_PNP_GetResDesData
},
4832 {"PNP_GETRESDESDATASIZE", NDR_PNP_GETRESDESDATASIZE
, api_PNP_GetResDesDataSize
},
4833 {"PNP_MODIFYRESDES", NDR_PNP_MODIFYRESDES
, api_PNP_ModifyResDes
},
4834 {"PNP_DETECTRESOURCELIMIT", NDR_PNP_DETECTRESOURCELIMIT
, api_PNP_DetectResourceLimit
},
4835 {"PNP_QUERYRESCONFLIST", NDR_PNP_QUERYRESCONFLIST
, api_PNP_QueryResConfList
},
4836 {"PNP_SETHWPROF", NDR_PNP_SETHWPROF
, api_PNP_SetHwProf
},
4837 {"PNP_QUERYARBITRATORFREEDATA", NDR_PNP_QUERYARBITRATORFREEDATA
, api_PNP_QueryArbitratorFreeData
},
4838 {"PNP_QUERYARBITRATORFREESIZE", NDR_PNP_QUERYARBITRATORFREESIZE
, api_PNP_QueryArbitratorFreeSize
},
4839 {"PNP_RUNDETECTION", NDR_PNP_RUNDETECTION
, api_PNP_RunDetection
},
4840 {"PNP_REGISTERNOTIFICATION", NDR_PNP_REGISTERNOTIFICATION
, api_PNP_RegisterNotification
},
4841 {"PNP_UNREGISTERNOTIFICATION", NDR_PNP_UNREGISTERNOTIFICATION
, api_PNP_UnregisterNotification
},
4842 {"PNP_GETCUSTOMDEVPROP", NDR_PNP_GETCUSTOMDEVPROP
, api_PNP_GetCustomDevProp
},
4843 {"PNP_GETVERSIONINTERNAL", NDR_PNP_GETVERSIONINTERNAL
, api_PNP_GetVersionInternal
},
4844 {"PNP_GETBLOCKEDDRIVERINFO", NDR_PNP_GETBLOCKEDDRIVERINFO
, api_PNP_GetBlockedDriverInfo
},
4845 {"PNP_GETSERVERSIDEDEVICEINSTALLFLAGS", NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS
, api_PNP_GetServerSideDeviceInstallFlags
},
4848 void ntsvcs_get_pipe_fns(struct api_struct
**fns
, int *n_fns
)
4850 *fns
= api_ntsvcs_cmds
;
4851 *n_fns
= sizeof(api_ntsvcs_cmds
) / sizeof(struct api_struct
);
4854 NTSTATUS
rpc_ntsvcs_init(void)
4856 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION
, "ntsvcs", "ntsvcs", api_ntsvcs_cmds
, sizeof(api_ntsvcs_cmds
) / sizeof(struct api_struct
));