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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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, NULL);
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);
785 r->out.length = r->in.length;
786 r->out.buffer = talloc_zero_array(r, uint16_t, *r->out.length);
787 if (r->out.buffer == NULL) {
792 r->out.result = _PNP_GetDeviceList(p, r);
794 if (p->rng_fault_state) {
796 /* Return true here, srv_pipe_hnd.c will take care */
800 if (DEBUGLEVEL >= 10) {
801 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, r);
804 push = ndr_push_init_ctx(r, NULL);
810 ndr_err = call->ndr_push(push, NDR_OUT, r);
811 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
816 blob = ndr_push_blob(push);
817 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
827 static bool api_PNP_GetDeviceListSize(pipes_struct *p)
829 const struct ndr_interface_call *call;
830 struct ndr_pull *pull;
831 struct ndr_push *push;
832 enum ndr_err_code ndr_err;
834 struct PNP_GetDeviceListSize *r;
836 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELISTSIZE];
838 r = talloc(talloc_tos(), struct PNP_GetDeviceListSize);
843 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
848 pull = ndr_pull_init_blob(&blob, r, NULL);
854 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
855 ndr_err = call->ndr_pull(pull, NDR_IN, r);
856 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
861 if (DEBUGLEVEL >= 10) {
862 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, r);
866 r->out.size = talloc_zero(r, uint32_t);
867 if (r->out.size == NULL) {
872 r->out.result = _PNP_GetDeviceListSize(p, r);
874 if (p->rng_fault_state) {
876 /* Return true here, srv_pipe_hnd.c will take care */
880 if (DEBUGLEVEL >= 10) {
881 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, r);
884 push = ndr_push_init_ctx(r, NULL);
890 ndr_err = call->ndr_push(push, NDR_OUT, r);
891 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
896 blob = ndr_push_blob(push);
897 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
907 static bool api_PNP_GetDepth(pipes_struct *p)
909 const struct ndr_interface_call *call;
910 struct ndr_pull *pull;
911 struct ndr_push *push;
912 enum ndr_err_code ndr_err;
914 struct PNP_GetDepth *r;
916 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEPTH];
918 r = talloc(talloc_tos(), struct PNP_GetDepth);
923 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
928 pull = ndr_pull_init_blob(&blob, r, NULL);
934 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
935 ndr_err = call->ndr_pull(pull, NDR_IN, r);
936 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
941 if (DEBUGLEVEL >= 10) {
942 NDR_PRINT_IN_DEBUG(PNP_GetDepth, r);
945 r->out.result = _PNP_GetDepth(p, r);
947 if (p->rng_fault_state) {
949 /* Return true here, srv_pipe_hnd.c will take care */
953 if (DEBUGLEVEL >= 10) {
954 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, r);
957 push = ndr_push_init_ctx(r, NULL);
963 ndr_err = call->ndr_push(push, NDR_OUT, r);
964 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
969 blob = ndr_push_blob(push);
970 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
980 static bool api_PNP_GetDeviceRegProp(pipes_struct *p)
982 const struct ndr_interface_call *call;
983 struct ndr_pull *pull;
984 struct ndr_push *push;
985 enum ndr_err_code ndr_err;
987 struct PNP_GetDeviceRegProp *r;
989 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICEREGPROP];
991 r = talloc(talloc_tos(), struct PNP_GetDeviceRegProp);
996 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1001 pull = ndr_pull_init_blob(&blob, r, NULL);
1007 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1008 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1009 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1014 if (DEBUGLEVEL >= 10) {
1015 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, r);
1018 ZERO_STRUCT(r->out);
1019 r->out.reg_data_type = r->in.reg_data_type;
1020 r->out.buffer_size = r->in.buffer_size;
1021 r->out.needed = r->in.needed;
1022 r->out.buffer = talloc_zero_array(r, uint8_t, *r->out.buffer_size);
1023 if (r->out.buffer == NULL) {
1028 r->out.result = _PNP_GetDeviceRegProp(p, r);
1030 if (p->rng_fault_state) {
1032 /* Return true here, srv_pipe_hnd.c will take care */
1036 if (DEBUGLEVEL >= 10) {
1037 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, r);
1040 push = ndr_push_init_ctx(r, NULL);
1046 ndr_err = call->ndr_push(push, NDR_OUT, r);
1047 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1052 blob = ndr_push_blob(push);
1053 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1063 static bool api_PNP_SetDeviceRegProp(pipes_struct *p)
1065 const struct ndr_interface_call *call;
1066 struct ndr_pull *pull;
1067 struct ndr_push *push;
1068 enum ndr_err_code ndr_err;
1070 struct PNP_SetDeviceRegProp *r;
1072 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEREGPROP];
1074 r = talloc(talloc_tos(), struct PNP_SetDeviceRegProp);
1079 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1084 pull = ndr_pull_init_blob(&blob, r, NULL);
1090 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1091 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1092 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1097 if (DEBUGLEVEL >= 10) {
1098 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, r);
1101 r->out.result = _PNP_SetDeviceRegProp(p, r);
1103 if (p->rng_fault_state) {
1105 /* Return true here, srv_pipe_hnd.c will take care */
1109 if (DEBUGLEVEL >= 10) {
1110 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, r);
1113 push = ndr_push_init_ctx(r, NULL);
1119 ndr_err = call->ndr_push(push, NDR_OUT, r);
1120 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1125 blob = ndr_push_blob(push);
1126 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1136 static bool api_PNP_GetClassInstance(pipes_struct *p)
1138 const struct ndr_interface_call *call;
1139 struct ndr_pull *pull;
1140 struct ndr_push *push;
1141 enum ndr_err_code ndr_err;
1143 struct PNP_GetClassInstance *r;
1145 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSINSTANCE];
1147 r = talloc(talloc_tos(), struct PNP_GetClassInstance);
1152 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1157 pull = ndr_pull_init_blob(&blob, r, NULL);
1163 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1164 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1165 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1170 if (DEBUGLEVEL >= 10) {
1171 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, r);
1174 r->out.result = _PNP_GetClassInstance(p, r);
1176 if (p->rng_fault_state) {
1178 /* Return true here, srv_pipe_hnd.c will take care */
1182 if (DEBUGLEVEL >= 10) {
1183 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, r);
1186 push = ndr_push_init_ctx(r, NULL);
1192 ndr_err = call->ndr_push(push, NDR_OUT, r);
1193 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1198 blob = ndr_push_blob(push);
1199 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1209 static bool api_PNP_CreateKey(pipes_struct *p)
1211 const struct ndr_interface_call *call;
1212 struct ndr_pull *pull;
1213 struct ndr_push *push;
1214 enum ndr_err_code ndr_err;
1216 struct PNP_CreateKey *r;
1218 call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEKEY];
1220 r = talloc(talloc_tos(), struct PNP_CreateKey);
1225 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1230 pull = ndr_pull_init_blob(&blob, r, NULL);
1236 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1237 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1238 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1243 if (DEBUGLEVEL >= 10) {
1244 NDR_PRINT_IN_DEBUG(PNP_CreateKey, r);
1247 r->out.result = _PNP_CreateKey(p, r);
1249 if (p->rng_fault_state) {
1251 /* Return true here, srv_pipe_hnd.c will take care */
1255 if (DEBUGLEVEL >= 10) {
1256 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, r);
1259 push = ndr_push_init_ctx(r, NULL);
1265 ndr_err = call->ndr_push(push, NDR_OUT, r);
1266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1271 blob = ndr_push_blob(push);
1272 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1282 static bool api_PNP_DeleteRegistryKey(pipes_struct *p)
1284 const struct ndr_interface_call *call;
1285 struct ndr_pull *pull;
1286 struct ndr_push *push;
1287 enum ndr_err_code ndr_err;
1289 struct PNP_DeleteRegistryKey *r;
1291 call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETEREGISTRYKEY];
1293 r = talloc(talloc_tos(), struct PNP_DeleteRegistryKey);
1298 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1303 pull = ndr_pull_init_blob(&blob, r, NULL);
1309 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1310 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1311 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1316 if (DEBUGLEVEL >= 10) {
1317 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, r);
1320 r->out.result = _PNP_DeleteRegistryKey(p, r);
1322 if (p->rng_fault_state) {
1324 /* Return true here, srv_pipe_hnd.c will take care */
1328 if (DEBUGLEVEL >= 10) {
1329 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, r);
1332 push = ndr_push_init_ctx(r, NULL);
1338 ndr_err = call->ndr_push(push, NDR_OUT, r);
1339 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1344 blob = ndr_push_blob(push);
1345 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1355 static bool api_PNP_GetClassCount(pipes_struct *p)
1357 const struct ndr_interface_call *call;
1358 struct ndr_pull *pull;
1359 struct ndr_push *push;
1360 enum ndr_err_code ndr_err;
1362 struct PNP_GetClassCount *r;
1364 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSCOUNT];
1366 r = talloc(talloc_tos(), struct PNP_GetClassCount);
1371 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1376 pull = ndr_pull_init_blob(&blob, r, NULL);
1382 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1383 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1384 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1389 if (DEBUGLEVEL >= 10) {
1390 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, r);
1393 r->out.result = _PNP_GetClassCount(p, r);
1395 if (p->rng_fault_state) {
1397 /* Return true here, srv_pipe_hnd.c will take care */
1401 if (DEBUGLEVEL >= 10) {
1402 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, r);
1405 push = ndr_push_init_ctx(r, NULL);
1411 ndr_err = call->ndr_push(push, NDR_OUT, r);
1412 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1417 blob = ndr_push_blob(push);
1418 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1428 static bool api_PNP_GetClassName(pipes_struct *p)
1430 const struct ndr_interface_call *call;
1431 struct ndr_pull *pull;
1432 struct ndr_push *push;
1433 enum ndr_err_code ndr_err;
1435 struct PNP_GetClassName *r;
1437 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSNAME];
1439 r = talloc(talloc_tos(), struct PNP_GetClassName);
1444 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1449 pull = ndr_pull_init_blob(&blob, r, NULL);
1455 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1456 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1457 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1462 if (DEBUGLEVEL >= 10) {
1463 NDR_PRINT_IN_DEBUG(PNP_GetClassName, r);
1466 r->out.result = _PNP_GetClassName(p, r);
1468 if (p->rng_fault_state) {
1470 /* Return true here, srv_pipe_hnd.c will take care */
1474 if (DEBUGLEVEL >= 10) {
1475 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, r);
1478 push = ndr_push_init_ctx(r, NULL);
1484 ndr_err = call->ndr_push(push, NDR_OUT, r);
1485 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1490 blob = ndr_push_blob(push);
1491 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1501 static bool api_PNP_DeleteClassKey(pipes_struct *p)
1503 const struct ndr_interface_call *call;
1504 struct ndr_pull *pull;
1505 struct ndr_push *push;
1506 enum ndr_err_code ndr_err;
1508 struct PNP_DeleteClassKey *r;
1510 call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETECLASSKEY];
1512 r = talloc(talloc_tos(), struct PNP_DeleteClassKey);
1517 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1522 pull = ndr_pull_init_blob(&blob, r, NULL);
1528 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1529 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1530 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1535 if (DEBUGLEVEL >= 10) {
1536 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, r);
1539 r->out.result = _PNP_DeleteClassKey(p, r);
1541 if (p->rng_fault_state) {
1543 /* Return true here, srv_pipe_hnd.c will take care */
1547 if (DEBUGLEVEL >= 10) {
1548 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, r);
1551 push = ndr_push_init_ctx(r, NULL);
1557 ndr_err = call->ndr_push(push, NDR_OUT, r);
1558 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1563 blob = ndr_push_blob(push);
1564 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1574 static bool api_PNP_GetInterfaceDeviceAlias(pipes_struct *p)
1576 const struct ndr_interface_call *call;
1577 struct ndr_pull *pull;
1578 struct ndr_push *push;
1579 enum ndr_err_code ndr_err;
1581 struct PNP_GetInterfaceDeviceAlias *r;
1583 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICEALIAS];
1585 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceAlias);
1590 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1595 pull = ndr_pull_init_blob(&blob, r, NULL);
1601 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1602 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1603 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1608 if (DEBUGLEVEL >= 10) {
1609 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1612 r->out.result = _PNP_GetInterfaceDeviceAlias(p, r);
1614 if (p->rng_fault_state) {
1616 /* Return true here, srv_pipe_hnd.c will take care */
1620 if (DEBUGLEVEL >= 10) {
1621 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1624 push = ndr_push_init_ctx(r, NULL);
1630 ndr_err = call->ndr_push(push, NDR_OUT, r);
1631 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1636 blob = ndr_push_blob(push);
1637 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1647 static bool api_PNP_GetInterfaceDeviceList(pipes_struct *p)
1649 const struct ndr_interface_call *call;
1650 struct ndr_pull *pull;
1651 struct ndr_push *push;
1652 enum ndr_err_code ndr_err;
1654 struct PNP_GetInterfaceDeviceList *r;
1656 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELIST];
1658 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceList);
1663 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1668 pull = ndr_pull_init_blob(&blob, r, NULL);
1674 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1675 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1676 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1681 if (DEBUGLEVEL >= 10) {
1682 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, r);
1685 r->out.result = _PNP_GetInterfaceDeviceList(p, r);
1687 if (p->rng_fault_state) {
1689 /* Return true here, srv_pipe_hnd.c will take care */
1693 if (DEBUGLEVEL >= 10) {
1694 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, r);
1697 push = ndr_push_init_ctx(r, NULL);
1703 ndr_err = call->ndr_push(push, NDR_OUT, r);
1704 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1709 blob = ndr_push_blob(push);
1710 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1720 static bool api_PNP_GetInterfaceDeviceListSize(pipes_struct *p)
1722 const struct ndr_interface_call *call;
1723 struct ndr_pull *pull;
1724 struct ndr_push *push;
1725 enum ndr_err_code ndr_err;
1727 struct PNP_GetInterfaceDeviceListSize *r;
1729 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELISTSIZE];
1731 r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceListSize);
1736 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1741 pull = ndr_pull_init_blob(&blob, r, NULL);
1747 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1748 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1749 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1754 if (DEBUGLEVEL >= 10) {
1755 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1758 r->out.result = _PNP_GetInterfaceDeviceListSize(p, r);
1760 if (p->rng_fault_state) {
1762 /* Return true here, srv_pipe_hnd.c will take care */
1766 if (DEBUGLEVEL >= 10) {
1767 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1770 push = ndr_push_init_ctx(r, NULL);
1776 ndr_err = call->ndr_push(push, NDR_OUT, r);
1777 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1782 blob = ndr_push_blob(push);
1783 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1793 static bool api_PNP_RegisterDeviceClassAssociation(pipes_struct *p)
1795 const struct ndr_interface_call *call;
1796 struct ndr_pull *pull;
1797 struct ndr_push *push;
1798 enum ndr_err_code ndr_err;
1800 struct PNP_RegisterDeviceClassAssociation *r;
1802 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDEVICECLASSASSOCIATION];
1804 r = talloc(talloc_tos(), struct PNP_RegisterDeviceClassAssociation);
1809 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1814 pull = ndr_pull_init_blob(&blob, r, NULL);
1820 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1821 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1822 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1827 if (DEBUGLEVEL >= 10) {
1828 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1831 r->out.result = _PNP_RegisterDeviceClassAssociation(p, r);
1833 if (p->rng_fault_state) {
1835 /* Return true here, srv_pipe_hnd.c will take care */
1839 if (DEBUGLEVEL >= 10) {
1840 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1843 push = ndr_push_init_ctx(r, NULL);
1849 ndr_err = call->ndr_push(push, NDR_OUT, r);
1850 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1855 blob = ndr_push_blob(push);
1856 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1866 static bool api_PNP_UnregisterDeviceClassAssociation(pipes_struct *p)
1868 const struct ndr_interface_call *call;
1869 struct ndr_pull *pull;
1870 struct ndr_push *push;
1871 enum ndr_err_code ndr_err;
1873 struct PNP_UnregisterDeviceClassAssociation *r;
1875 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION];
1877 r = talloc(talloc_tos(), struct PNP_UnregisterDeviceClassAssociation);
1882 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1887 pull = ndr_pull_init_blob(&blob, r, NULL);
1893 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1894 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1895 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1900 if (DEBUGLEVEL >= 10) {
1901 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1904 r->out.result = _PNP_UnregisterDeviceClassAssociation(p, r);
1906 if (p->rng_fault_state) {
1908 /* Return true here, srv_pipe_hnd.c will take care */
1912 if (DEBUGLEVEL >= 10) {
1913 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1916 push = ndr_push_init_ctx(r, NULL);
1922 ndr_err = call->ndr_push(push, NDR_OUT, r);
1923 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1928 blob = ndr_push_blob(push);
1929 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1939 static bool api_PNP_GetClassRegProp(pipes_struct *p)
1941 const struct ndr_interface_call *call;
1942 struct ndr_pull *pull;
1943 struct ndr_push *push;
1944 enum ndr_err_code ndr_err;
1946 struct PNP_GetClassRegProp *r;
1948 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSREGPROP];
1950 r = talloc(talloc_tos(), struct PNP_GetClassRegProp);
1955 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1960 pull = ndr_pull_init_blob(&blob, r, NULL);
1966 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1967 ndr_err = call->ndr_pull(pull, NDR_IN, r);
1968 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1973 if (DEBUGLEVEL >= 10) {
1974 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, r);
1977 r->out.result = _PNP_GetClassRegProp(p, r);
1979 if (p->rng_fault_state) {
1981 /* Return true here, srv_pipe_hnd.c will take care */
1985 if (DEBUGLEVEL >= 10) {
1986 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, r);
1989 push = ndr_push_init_ctx(r, NULL);
1995 ndr_err = call->ndr_push(push, NDR_OUT, r);
1996 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2001 blob = ndr_push_blob(push);
2002 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2012 static bool api_PNP_SetClassRegProp(pipes_struct *p)
2014 const struct ndr_interface_call *call;
2015 struct ndr_pull *pull;
2016 struct ndr_push *push;
2017 enum ndr_err_code ndr_err;
2019 struct PNP_SetClassRegProp *r;
2021 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETCLASSREGPROP];
2023 r = talloc(talloc_tos(), struct PNP_SetClassRegProp);
2028 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2033 pull = ndr_pull_init_blob(&blob, r, NULL);
2039 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2040 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2041 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2046 if (DEBUGLEVEL >= 10) {
2047 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, r);
2050 r->out.result = _PNP_SetClassRegProp(p, r);
2052 if (p->rng_fault_state) {
2054 /* Return true here, srv_pipe_hnd.c will take care */
2058 if (DEBUGLEVEL >= 10) {
2059 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, r);
2062 push = ndr_push_init_ctx(r, NULL);
2068 ndr_err = call->ndr_push(push, NDR_OUT, r);
2069 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2074 blob = ndr_push_blob(push);
2075 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2085 static bool api_PNP_CreateDevInst(pipes_struct *p)
2087 const struct ndr_interface_call *call;
2088 struct ndr_pull *pull;
2089 struct ndr_push *push;
2090 enum ndr_err_code ndr_err;
2092 struct PNP_CreateDevInst *r;
2094 call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEDEVINST];
2096 r = talloc(talloc_tos(), struct PNP_CreateDevInst);
2101 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2106 pull = ndr_pull_init_blob(&blob, r, NULL);
2112 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2113 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2114 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2119 if (DEBUGLEVEL >= 10) {
2120 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, r);
2123 r->out.result = _PNP_CreateDevInst(p, r);
2125 if (p->rng_fault_state) {
2127 /* Return true here, srv_pipe_hnd.c will take care */
2131 if (DEBUGLEVEL >= 10) {
2132 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, r);
2135 push = ndr_push_init_ctx(r, NULL);
2141 ndr_err = call->ndr_push(push, NDR_OUT, r);
2142 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2147 blob = ndr_push_blob(push);
2148 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2158 static bool api_PNP_DeviceInstanceAction(pipes_struct *p)
2160 const struct ndr_interface_call *call;
2161 struct ndr_pull *pull;
2162 struct ndr_push *push;
2163 enum ndr_err_code ndr_err;
2165 struct PNP_DeviceInstanceAction *r;
2167 call = &ndr_table_ntsvcs.calls[NDR_PNP_DEVICEINSTANCEACTION];
2169 r = talloc(talloc_tos(), struct PNP_DeviceInstanceAction);
2174 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2179 pull = ndr_pull_init_blob(&blob, r, NULL);
2185 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2186 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2187 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2192 if (DEBUGLEVEL >= 10) {
2193 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, r);
2196 r->out.result = _PNP_DeviceInstanceAction(p, r);
2198 if (p->rng_fault_state) {
2200 /* Return true here, srv_pipe_hnd.c will take care */
2204 if (DEBUGLEVEL >= 10) {
2205 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, r);
2208 push = ndr_push_init_ctx(r, NULL);
2214 ndr_err = call->ndr_push(push, NDR_OUT, r);
2215 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2220 blob = ndr_push_blob(push);
2221 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2231 static bool api_PNP_GetDeviceStatus(pipes_struct *p)
2233 const struct ndr_interface_call *call;
2234 struct ndr_pull *pull;
2235 struct ndr_push *push;
2236 enum ndr_err_code ndr_err;
2238 struct PNP_GetDeviceStatus *r;
2240 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICESTATUS];
2242 r = talloc(talloc_tos(), struct PNP_GetDeviceStatus);
2247 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2252 pull = ndr_pull_init_blob(&blob, r, NULL);
2258 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2259 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2260 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2265 if (DEBUGLEVEL >= 10) {
2266 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, r);
2269 r->out.result = _PNP_GetDeviceStatus(p, r);
2271 if (p->rng_fault_state) {
2273 /* Return true here, srv_pipe_hnd.c will take care */
2277 if (DEBUGLEVEL >= 10) {
2278 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, r);
2281 push = ndr_push_init_ctx(r, NULL);
2287 ndr_err = call->ndr_push(push, NDR_OUT, r);
2288 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2293 blob = ndr_push_blob(push);
2294 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2304 static bool api_PNP_SetDeviceProblem(pipes_struct *p)
2306 const struct ndr_interface_call *call;
2307 struct ndr_pull *pull;
2308 struct ndr_push *push;
2309 enum ndr_err_code ndr_err;
2311 struct PNP_SetDeviceProblem *r;
2313 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEPROBLEM];
2315 r = talloc(talloc_tos(), struct PNP_SetDeviceProblem);
2320 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2325 pull = ndr_pull_init_blob(&blob, r, NULL);
2331 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2332 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2333 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2338 if (DEBUGLEVEL >= 10) {
2339 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, r);
2342 r->out.result = _PNP_SetDeviceProblem(p, r);
2344 if (p->rng_fault_state) {
2346 /* Return true here, srv_pipe_hnd.c will take care */
2350 if (DEBUGLEVEL >= 10) {
2351 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, r);
2354 push = ndr_push_init_ctx(r, NULL);
2360 ndr_err = call->ndr_push(push, NDR_OUT, r);
2361 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2366 blob = ndr_push_blob(push);
2367 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2377 static bool api_PNP_DisableDevInst(pipes_struct *p)
2379 const struct ndr_interface_call *call;
2380 struct ndr_pull *pull;
2381 struct ndr_push *push;
2382 enum ndr_err_code ndr_err;
2384 struct PNP_DisableDevInst *r;
2386 call = &ndr_table_ntsvcs.calls[NDR_PNP_DISABLEDEVINST];
2388 r = talloc(talloc_tos(), struct PNP_DisableDevInst);
2393 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2398 pull = ndr_pull_init_blob(&blob, r, NULL);
2404 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2405 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2406 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2411 if (DEBUGLEVEL >= 10) {
2412 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, r);
2415 r->out.result = _PNP_DisableDevInst(p, r);
2417 if (p->rng_fault_state) {
2419 /* Return true here, srv_pipe_hnd.c will take care */
2423 if (DEBUGLEVEL >= 10) {
2424 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, r);
2427 push = ndr_push_init_ctx(r, NULL);
2433 ndr_err = call->ndr_push(push, NDR_OUT, r);
2434 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2439 blob = ndr_push_blob(push);
2440 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2450 static bool api_PNP_UninstallDevInst(pipes_struct *p)
2452 const struct ndr_interface_call *call;
2453 struct ndr_pull *pull;
2454 struct ndr_push *push;
2455 enum ndr_err_code ndr_err;
2457 struct PNP_UninstallDevInst *r;
2459 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNINSTALLDEVINST];
2461 r = talloc(talloc_tos(), struct PNP_UninstallDevInst);
2466 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2471 pull = ndr_pull_init_blob(&blob, r, NULL);
2477 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2478 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2479 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2484 if (DEBUGLEVEL >= 10) {
2485 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, r);
2488 r->out.result = _PNP_UninstallDevInst(p, r);
2490 if (p->rng_fault_state) {
2492 /* Return true here, srv_pipe_hnd.c will take care */
2496 if (DEBUGLEVEL >= 10) {
2497 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, r);
2500 push = ndr_push_init_ctx(r, NULL);
2506 ndr_err = call->ndr_push(push, NDR_OUT, r);
2507 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2512 blob = ndr_push_blob(push);
2513 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2523 static bool api_PNP_AddID(pipes_struct *p)
2525 const struct ndr_interface_call *call;
2526 struct ndr_pull *pull;
2527 struct ndr_push *push;
2528 enum ndr_err_code ndr_err;
2530 struct PNP_AddID *r;
2532 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDID];
2534 r = talloc(talloc_tos(), struct PNP_AddID);
2539 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2544 pull = ndr_pull_init_blob(&blob, r, NULL);
2550 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2551 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2552 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2557 if (DEBUGLEVEL >= 10) {
2558 NDR_PRINT_IN_DEBUG(PNP_AddID, r);
2561 r->out.result = _PNP_AddID(p, r);
2563 if (p->rng_fault_state) {
2565 /* Return true here, srv_pipe_hnd.c will take care */
2569 if (DEBUGLEVEL >= 10) {
2570 NDR_PRINT_OUT_DEBUG(PNP_AddID, r);
2573 push = ndr_push_init_ctx(r, NULL);
2579 ndr_err = call->ndr_push(push, NDR_OUT, r);
2580 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2585 blob = ndr_push_blob(push);
2586 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2596 static bool api_PNP_RegisterDriver(pipes_struct *p)
2598 const struct ndr_interface_call *call;
2599 struct ndr_pull *pull;
2600 struct ndr_push *push;
2601 enum ndr_err_code ndr_err;
2603 struct PNP_RegisterDriver *r;
2605 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDRIVER];
2607 r = talloc(talloc_tos(), struct PNP_RegisterDriver);
2612 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2617 pull = ndr_pull_init_blob(&blob, r, NULL);
2623 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2624 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2625 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2630 if (DEBUGLEVEL >= 10) {
2631 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, r);
2634 r->out.result = _PNP_RegisterDriver(p, r);
2636 if (p->rng_fault_state) {
2638 /* Return true here, srv_pipe_hnd.c will take care */
2642 if (DEBUGLEVEL >= 10) {
2643 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, r);
2646 push = ndr_push_init_ctx(r, NULL);
2652 ndr_err = call->ndr_push(push, NDR_OUT, r);
2653 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2658 blob = ndr_push_blob(push);
2659 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2669 static bool api_PNP_QueryRemove(pipes_struct *p)
2671 const struct ndr_interface_call *call;
2672 struct ndr_pull *pull;
2673 struct ndr_push *push;
2674 enum ndr_err_code ndr_err;
2676 struct PNP_QueryRemove *r;
2678 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYREMOVE];
2680 r = talloc(talloc_tos(), struct PNP_QueryRemove);
2685 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2690 pull = ndr_pull_init_blob(&blob, r, NULL);
2696 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2697 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2698 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2703 if (DEBUGLEVEL >= 10) {
2704 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, r);
2707 r->out.result = _PNP_QueryRemove(p, r);
2709 if (p->rng_fault_state) {
2711 /* Return true here, srv_pipe_hnd.c will take care */
2715 if (DEBUGLEVEL >= 10) {
2716 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, r);
2719 push = ndr_push_init_ctx(r, NULL);
2725 ndr_err = call->ndr_push(push, NDR_OUT, r);
2726 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2731 blob = ndr_push_blob(push);
2732 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2742 static bool api_PNP_RequestDeviceEject(pipes_struct *p)
2744 const struct ndr_interface_call *call;
2745 struct ndr_pull *pull;
2746 struct ndr_push *push;
2747 enum ndr_err_code ndr_err;
2749 struct PNP_RequestDeviceEject *r;
2751 call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTDEVICEEJECT];
2753 r = talloc(talloc_tos(), struct PNP_RequestDeviceEject);
2758 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2763 pull = ndr_pull_init_blob(&blob, r, NULL);
2769 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2770 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2771 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2776 if (DEBUGLEVEL >= 10) {
2777 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, r);
2780 r->out.result = _PNP_RequestDeviceEject(p, r);
2782 if (p->rng_fault_state) {
2784 /* Return true here, srv_pipe_hnd.c will take care */
2788 if (DEBUGLEVEL >= 10) {
2789 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, r);
2792 push = ndr_push_init_ctx(r, NULL);
2798 ndr_err = call->ndr_push(push, NDR_OUT, r);
2799 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2804 blob = ndr_push_blob(push);
2805 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2815 static bool api_PNP_IsDockStationPresent(pipes_struct *p)
2817 const struct ndr_interface_call *call;
2818 struct ndr_pull *pull;
2819 struct ndr_push *push;
2820 enum ndr_err_code ndr_err;
2822 struct PNP_IsDockStationPresent *r;
2824 call = &ndr_table_ntsvcs.calls[NDR_PNP_ISDOCKSTATIONPRESENT];
2826 r = talloc(talloc_tos(), struct PNP_IsDockStationPresent);
2831 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2836 pull = ndr_pull_init_blob(&blob, r, NULL);
2842 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2843 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2844 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2849 if (DEBUGLEVEL >= 10) {
2850 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, r);
2853 r->out.result = _PNP_IsDockStationPresent(p, r);
2855 if (p->rng_fault_state) {
2857 /* Return true here, srv_pipe_hnd.c will take care */
2861 if (DEBUGLEVEL >= 10) {
2862 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, r);
2865 push = ndr_push_init_ctx(r, NULL);
2871 ndr_err = call->ndr_push(push, NDR_OUT, r);
2872 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2877 blob = ndr_push_blob(push);
2878 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2888 static bool api_PNP_RequestEjectPC(pipes_struct *p)
2890 const struct ndr_interface_call *call;
2891 struct ndr_pull *pull;
2892 struct ndr_push *push;
2893 enum ndr_err_code ndr_err;
2895 struct PNP_RequestEjectPC *r;
2897 call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTEJECTPC];
2899 r = talloc(talloc_tos(), struct PNP_RequestEjectPC);
2904 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2909 pull = ndr_pull_init_blob(&blob, r, NULL);
2915 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2916 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2917 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2922 if (DEBUGLEVEL >= 10) {
2923 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, r);
2926 r->out.result = _PNP_RequestEjectPC(p, r);
2928 if (p->rng_fault_state) {
2930 /* Return true here, srv_pipe_hnd.c will take care */
2934 if (DEBUGLEVEL >= 10) {
2935 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, r);
2938 push = ndr_push_init_ctx(r, NULL);
2944 ndr_err = call->ndr_push(push, NDR_OUT, r);
2945 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2950 blob = ndr_push_blob(push);
2951 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2961 static bool api_PNP_HwProfFlags(pipes_struct *p)
2963 const struct ndr_interface_call *call;
2964 struct ndr_pull *pull;
2965 struct ndr_push *push;
2966 enum ndr_err_code ndr_err;
2968 struct PNP_HwProfFlags *r;
2970 call = &ndr_table_ntsvcs.calls[NDR_PNP_HWPROFFLAGS];
2972 r = talloc(talloc_tos(), struct PNP_HwProfFlags);
2977 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2982 pull = ndr_pull_init_blob(&blob, r, NULL);
2988 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2989 ndr_err = call->ndr_pull(pull, NDR_IN, r);
2990 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2995 if (DEBUGLEVEL >= 10) {
2996 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, r);
2999 ZERO_STRUCT(r->out);
3000 r->out.profile_flags = r->in.profile_flags;
3001 r->out.veto_type = r->in.veto_type;
3002 r->out.unknown5a = talloc_zero(r, const char *);
3003 if (r->out.unknown5a == NULL) {
3008 r->out.result = _PNP_HwProfFlags(p, r);
3010 if (p->rng_fault_state) {
3012 /* Return true here, srv_pipe_hnd.c will take care */
3016 if (DEBUGLEVEL >= 10) {
3017 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, r);
3020 push = ndr_push_init_ctx(r, NULL);
3026 ndr_err = call->ndr_push(push, NDR_OUT, r);
3027 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3032 blob = ndr_push_blob(push);
3033 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3043 static bool api_PNP_GetHwProfInfo(pipes_struct *p)
3045 const struct ndr_interface_call *call;
3046 struct ndr_pull *pull;
3047 struct ndr_push *push;
3048 enum ndr_err_code ndr_err;
3050 struct PNP_GetHwProfInfo *r;
3052 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETHWPROFINFO];
3054 r = talloc(talloc_tos(), struct PNP_GetHwProfInfo);
3059 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3064 pull = ndr_pull_init_blob(&blob, r, NULL);
3070 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3071 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3072 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3077 if (DEBUGLEVEL >= 10) {
3078 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, r);
3081 ZERO_STRUCT(r->out);
3082 r->out.info = r->in.info;
3083 r->out.result = _PNP_GetHwProfInfo(p, r);
3085 if (p->rng_fault_state) {
3087 /* Return true here, srv_pipe_hnd.c will take care */
3091 if (DEBUGLEVEL >= 10) {
3092 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, r);
3095 push = ndr_push_init_ctx(r, NULL);
3101 ndr_err = call->ndr_push(push, NDR_OUT, r);
3102 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3107 blob = ndr_push_blob(push);
3108 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3118 static bool api_PNP_AddEmptyLogConf(pipes_struct *p)
3120 const struct ndr_interface_call *call;
3121 struct ndr_pull *pull;
3122 struct ndr_push *push;
3123 enum ndr_err_code ndr_err;
3125 struct PNP_AddEmptyLogConf *r;
3127 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDEMPTYLOGCONF];
3129 r = talloc(talloc_tos(), struct PNP_AddEmptyLogConf);
3134 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3139 pull = ndr_pull_init_blob(&blob, r, NULL);
3145 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3146 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3147 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3152 if (DEBUGLEVEL >= 10) {
3153 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, r);
3156 r->out.result = _PNP_AddEmptyLogConf(p, r);
3158 if (p->rng_fault_state) {
3160 /* Return true here, srv_pipe_hnd.c will take care */
3164 if (DEBUGLEVEL >= 10) {
3165 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, r);
3168 push = ndr_push_init_ctx(r, NULL);
3174 ndr_err = call->ndr_push(push, NDR_OUT, r);
3175 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3180 blob = ndr_push_blob(push);
3181 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3191 static bool api_PNP_FreeLogConf(pipes_struct *p)
3193 const struct ndr_interface_call *call;
3194 struct ndr_pull *pull;
3195 struct ndr_push *push;
3196 enum ndr_err_code ndr_err;
3198 struct PNP_FreeLogConf *r;
3200 call = &ndr_table_ntsvcs.calls[NDR_PNP_FREELOGCONF];
3202 r = talloc(talloc_tos(), struct PNP_FreeLogConf);
3207 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3212 pull = ndr_pull_init_blob(&blob, r, NULL);
3218 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3219 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3220 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3225 if (DEBUGLEVEL >= 10) {
3226 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, r);
3229 r->out.result = _PNP_FreeLogConf(p, r);
3231 if (p->rng_fault_state) {
3233 /* Return true here, srv_pipe_hnd.c will take care */
3237 if (DEBUGLEVEL >= 10) {
3238 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, r);
3241 push = ndr_push_init_ctx(r, NULL);
3247 ndr_err = call->ndr_push(push, NDR_OUT, r);
3248 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3253 blob = ndr_push_blob(push);
3254 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3264 static bool api_PNP_GetFirstLogConf(pipes_struct *p)
3266 const struct ndr_interface_call *call;
3267 struct ndr_pull *pull;
3268 struct ndr_push *push;
3269 enum ndr_err_code ndr_err;
3271 struct PNP_GetFirstLogConf *r;
3273 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETFIRSTLOGCONF];
3275 r = talloc(talloc_tos(), struct PNP_GetFirstLogConf);
3280 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3285 pull = ndr_pull_init_blob(&blob, r, NULL);
3291 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3292 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3293 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3298 if (DEBUGLEVEL >= 10) {
3299 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, r);
3302 r->out.result = _PNP_GetFirstLogConf(p, r);
3304 if (p->rng_fault_state) {
3306 /* Return true here, srv_pipe_hnd.c will take care */
3310 if (DEBUGLEVEL >= 10) {
3311 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, r);
3314 push = ndr_push_init_ctx(r, NULL);
3320 ndr_err = call->ndr_push(push, NDR_OUT, r);
3321 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3326 blob = ndr_push_blob(push);
3327 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3337 static bool api_PNP_GetNextLogConf(pipes_struct *p)
3339 const struct ndr_interface_call *call;
3340 struct ndr_pull *pull;
3341 struct ndr_push *push;
3342 enum ndr_err_code ndr_err;
3344 struct PNP_GetNextLogConf *r;
3346 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTLOGCONF];
3348 r = talloc(talloc_tos(), struct PNP_GetNextLogConf);
3353 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3358 pull = ndr_pull_init_blob(&blob, r, NULL);
3364 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3365 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3366 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3371 if (DEBUGLEVEL >= 10) {
3372 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, r);
3375 r->out.result = _PNP_GetNextLogConf(p, r);
3377 if (p->rng_fault_state) {
3379 /* Return true here, srv_pipe_hnd.c will take care */
3383 if (DEBUGLEVEL >= 10) {
3384 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, r);
3387 push = ndr_push_init_ctx(r, NULL);
3393 ndr_err = call->ndr_push(push, NDR_OUT, r);
3394 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3399 blob = ndr_push_blob(push);
3400 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3410 static bool api_PNP_GetLogConfPriority(pipes_struct *p)
3412 const struct ndr_interface_call *call;
3413 struct ndr_pull *pull;
3414 struct ndr_push *push;
3415 enum ndr_err_code ndr_err;
3417 struct PNP_GetLogConfPriority *r;
3419 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETLOGCONFPRIORITY];
3421 r = talloc(talloc_tos(), struct PNP_GetLogConfPriority);
3426 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3431 pull = ndr_pull_init_blob(&blob, r, NULL);
3437 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3438 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3439 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3444 if (DEBUGLEVEL >= 10) {
3445 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, r);
3448 r->out.result = _PNP_GetLogConfPriority(p, r);
3450 if (p->rng_fault_state) {
3452 /* Return true here, srv_pipe_hnd.c will take care */
3456 if (DEBUGLEVEL >= 10) {
3457 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, r);
3460 push = ndr_push_init_ctx(r, NULL);
3466 ndr_err = call->ndr_push(push, NDR_OUT, r);
3467 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3472 blob = ndr_push_blob(push);
3473 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3483 static bool api_PNP_AddResDes(pipes_struct *p)
3485 const struct ndr_interface_call *call;
3486 struct ndr_pull *pull;
3487 struct ndr_push *push;
3488 enum ndr_err_code ndr_err;
3490 struct PNP_AddResDes *r;
3492 call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDRESDES];
3494 r = talloc(talloc_tos(), struct PNP_AddResDes);
3499 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3504 pull = ndr_pull_init_blob(&blob, r, NULL);
3510 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3511 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3512 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3517 if (DEBUGLEVEL >= 10) {
3518 NDR_PRINT_IN_DEBUG(PNP_AddResDes, r);
3521 r->out.result = _PNP_AddResDes(p, r);
3523 if (p->rng_fault_state) {
3525 /* Return true here, srv_pipe_hnd.c will take care */
3529 if (DEBUGLEVEL >= 10) {
3530 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, r);
3533 push = ndr_push_init_ctx(r, NULL);
3539 ndr_err = call->ndr_push(push, NDR_OUT, r);
3540 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3545 blob = ndr_push_blob(push);
3546 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3556 static bool api_PNP_FreeResDes(pipes_struct *p)
3558 const struct ndr_interface_call *call;
3559 struct ndr_pull *pull;
3560 struct ndr_push *push;
3561 enum ndr_err_code ndr_err;
3563 struct PNP_FreeResDes *r;
3565 call = &ndr_table_ntsvcs.calls[NDR_PNP_FREERESDES];
3567 r = talloc(talloc_tos(), struct PNP_FreeResDes);
3572 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3577 pull = ndr_pull_init_blob(&blob, r, NULL);
3583 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3584 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3585 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3590 if (DEBUGLEVEL >= 10) {
3591 NDR_PRINT_IN_DEBUG(PNP_FreeResDes, r);
3594 r->out.result = _PNP_FreeResDes(p, r);
3596 if (p->rng_fault_state) {
3598 /* Return true here, srv_pipe_hnd.c will take care */
3602 if (DEBUGLEVEL >= 10) {
3603 NDR_PRINT_OUT_DEBUG(PNP_FreeResDes, r);
3606 push = ndr_push_init_ctx(r, NULL);
3612 ndr_err = call->ndr_push(push, NDR_OUT, r);
3613 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3618 blob = ndr_push_blob(push);
3619 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3629 static bool api_PNP_GetNextResDes(pipes_struct *p)
3631 const struct ndr_interface_call *call;
3632 struct ndr_pull *pull;
3633 struct ndr_push *push;
3634 enum ndr_err_code ndr_err;
3636 struct PNP_GetNextResDes *r;
3638 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTRESDES];
3640 r = talloc(talloc_tos(), struct PNP_GetNextResDes);
3645 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3650 pull = ndr_pull_init_blob(&blob, r, NULL);
3656 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3657 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3658 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3663 if (DEBUGLEVEL >= 10) {
3664 NDR_PRINT_IN_DEBUG(PNP_GetNextResDes, r);
3667 r->out.result = _PNP_GetNextResDes(p, r);
3669 if (p->rng_fault_state) {
3671 /* Return true here, srv_pipe_hnd.c will take care */
3675 if (DEBUGLEVEL >= 10) {
3676 NDR_PRINT_OUT_DEBUG(PNP_GetNextResDes, r);
3679 push = ndr_push_init_ctx(r, NULL);
3685 ndr_err = call->ndr_push(push, NDR_OUT, r);
3686 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3691 blob = ndr_push_blob(push);
3692 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3702 static bool api_PNP_GetResDesData(pipes_struct *p)
3704 const struct ndr_interface_call *call;
3705 struct ndr_pull *pull;
3706 struct ndr_push *push;
3707 enum ndr_err_code ndr_err;
3709 struct PNP_GetResDesData *r;
3711 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATA];
3713 r = talloc(talloc_tos(), struct PNP_GetResDesData);
3718 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3723 pull = ndr_pull_init_blob(&blob, r, NULL);
3729 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3730 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3736 if (DEBUGLEVEL >= 10) {
3737 NDR_PRINT_IN_DEBUG(PNP_GetResDesData, r);
3740 r->out.result = _PNP_GetResDesData(p, r);
3742 if (p->rng_fault_state) {
3744 /* Return true here, srv_pipe_hnd.c will take care */
3748 if (DEBUGLEVEL >= 10) {
3749 NDR_PRINT_OUT_DEBUG(PNP_GetResDesData, r);
3752 push = ndr_push_init_ctx(r, NULL);
3758 ndr_err = call->ndr_push(push, NDR_OUT, r);
3759 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3764 blob = ndr_push_blob(push);
3765 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3775 static bool api_PNP_GetResDesDataSize(pipes_struct *p)
3777 const struct ndr_interface_call *call;
3778 struct ndr_pull *pull;
3779 struct ndr_push *push;
3780 enum ndr_err_code ndr_err;
3782 struct PNP_GetResDesDataSize *r;
3784 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRESDESDATASIZE];
3786 r = talloc(talloc_tos(), struct PNP_GetResDesDataSize);
3791 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3796 pull = ndr_pull_init_blob(&blob, r, NULL);
3802 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3803 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3804 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3809 if (DEBUGLEVEL >= 10) {
3810 NDR_PRINT_IN_DEBUG(PNP_GetResDesDataSize, r);
3813 r->out.result = _PNP_GetResDesDataSize(p, r);
3815 if (p->rng_fault_state) {
3817 /* Return true here, srv_pipe_hnd.c will take care */
3821 if (DEBUGLEVEL >= 10) {
3822 NDR_PRINT_OUT_DEBUG(PNP_GetResDesDataSize, r);
3825 push = ndr_push_init_ctx(r, NULL);
3831 ndr_err = call->ndr_push(push, NDR_OUT, r);
3832 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3837 blob = ndr_push_blob(push);
3838 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3848 static bool api_PNP_ModifyResDes(pipes_struct *p)
3850 const struct ndr_interface_call *call;
3851 struct ndr_pull *pull;
3852 struct ndr_push *push;
3853 enum ndr_err_code ndr_err;
3855 struct PNP_ModifyResDes *r;
3857 call = &ndr_table_ntsvcs.calls[NDR_PNP_MODIFYRESDES];
3859 r = talloc(talloc_tos(), struct PNP_ModifyResDes);
3864 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3869 pull = ndr_pull_init_blob(&blob, r, NULL);
3875 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3876 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3877 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3882 if (DEBUGLEVEL >= 10) {
3883 NDR_PRINT_IN_DEBUG(PNP_ModifyResDes, r);
3886 r->out.result = _PNP_ModifyResDes(p, r);
3888 if (p->rng_fault_state) {
3890 /* Return true here, srv_pipe_hnd.c will take care */
3894 if (DEBUGLEVEL >= 10) {
3895 NDR_PRINT_OUT_DEBUG(PNP_ModifyResDes, r);
3898 push = ndr_push_init_ctx(r, NULL);
3904 ndr_err = call->ndr_push(push, NDR_OUT, r);
3905 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3910 blob = ndr_push_blob(push);
3911 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3921 static bool api_PNP_DetectResourceLimit(pipes_struct *p)
3923 const struct ndr_interface_call *call;
3924 struct ndr_pull *pull;
3925 struct ndr_push *push;
3926 enum ndr_err_code ndr_err;
3928 struct PNP_DetectResourceLimit *r;
3930 call = &ndr_table_ntsvcs.calls[NDR_PNP_DETECTRESOURCELIMIT];
3932 r = talloc(talloc_tos(), struct PNP_DetectResourceLimit);
3937 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3942 pull = ndr_pull_init_blob(&blob, r, NULL);
3948 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3949 ndr_err = call->ndr_pull(pull, NDR_IN, r);
3950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3955 if (DEBUGLEVEL >= 10) {
3956 NDR_PRINT_IN_DEBUG(PNP_DetectResourceLimit, r);
3959 r->out.result = _PNP_DetectResourceLimit(p, r);
3961 if (p->rng_fault_state) {
3963 /* Return true here, srv_pipe_hnd.c will take care */
3967 if (DEBUGLEVEL >= 10) {
3968 NDR_PRINT_OUT_DEBUG(PNP_DetectResourceLimit, r);
3971 push = ndr_push_init_ctx(r, NULL);
3977 ndr_err = call->ndr_push(push, NDR_OUT, r);
3978 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3983 blob = ndr_push_blob(push);
3984 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3994 static bool api_PNP_QueryResConfList(pipes_struct *p)
3996 const struct ndr_interface_call *call;
3997 struct ndr_pull *pull;
3998 struct ndr_push *push;
3999 enum ndr_err_code ndr_err;
4001 struct PNP_QueryResConfList *r;
4003 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYRESCONFLIST];
4005 r = talloc(talloc_tos(), struct PNP_QueryResConfList);
4010 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4015 pull = ndr_pull_init_blob(&blob, r, NULL);
4021 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4022 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4023 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4028 if (DEBUGLEVEL >= 10) {
4029 NDR_PRINT_IN_DEBUG(PNP_QueryResConfList, r);
4032 r->out.result = _PNP_QueryResConfList(p, r);
4034 if (p->rng_fault_state) {
4036 /* Return true here, srv_pipe_hnd.c will take care */
4040 if (DEBUGLEVEL >= 10) {
4041 NDR_PRINT_OUT_DEBUG(PNP_QueryResConfList, r);
4044 push = ndr_push_init_ctx(r, NULL);
4050 ndr_err = call->ndr_push(push, NDR_OUT, r);
4051 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4056 blob = ndr_push_blob(push);
4057 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4067 static bool api_PNP_SetHwProf(pipes_struct *p)
4069 const struct ndr_interface_call *call;
4070 struct ndr_pull *pull;
4071 struct ndr_push *push;
4072 enum ndr_err_code ndr_err;
4074 struct PNP_SetHwProf *r;
4076 call = &ndr_table_ntsvcs.calls[NDR_PNP_SETHWPROF];
4078 r = talloc(talloc_tos(), struct PNP_SetHwProf);
4083 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4088 pull = ndr_pull_init_blob(&blob, r, NULL);
4094 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4095 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4096 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4101 if (DEBUGLEVEL >= 10) {
4102 NDR_PRINT_IN_DEBUG(PNP_SetHwProf, r);
4105 r->out.result = _PNP_SetHwProf(p, r);
4107 if (p->rng_fault_state) {
4109 /* Return true here, srv_pipe_hnd.c will take care */
4113 if (DEBUGLEVEL >= 10) {
4114 NDR_PRINT_OUT_DEBUG(PNP_SetHwProf, r);
4117 push = ndr_push_init_ctx(r, NULL);
4123 ndr_err = call->ndr_push(push, NDR_OUT, r);
4124 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4129 blob = ndr_push_blob(push);
4130 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4140 static bool api_PNP_QueryArbitratorFreeData(pipes_struct *p)
4142 const struct ndr_interface_call *call;
4143 struct ndr_pull *pull;
4144 struct ndr_push *push;
4145 enum ndr_err_code ndr_err;
4147 struct PNP_QueryArbitratorFreeData *r;
4149 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREEDATA];
4151 r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeData);
4156 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4161 pull = ndr_pull_init_blob(&blob, r, NULL);
4167 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4168 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4169 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4174 if (DEBUGLEVEL >= 10) {
4175 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeData, r);
4178 r->out.result = _PNP_QueryArbitratorFreeData(p, r);
4180 if (p->rng_fault_state) {
4182 /* Return true here, srv_pipe_hnd.c will take care */
4186 if (DEBUGLEVEL >= 10) {
4187 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeData, r);
4190 push = ndr_push_init_ctx(r, NULL);
4196 ndr_err = call->ndr_push(push, NDR_OUT, r);
4197 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4202 blob = ndr_push_blob(push);
4203 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4213 static bool api_PNP_QueryArbitratorFreeSize(pipes_struct *p)
4215 const struct ndr_interface_call *call;
4216 struct ndr_pull *pull;
4217 struct ndr_push *push;
4218 enum ndr_err_code ndr_err;
4220 struct PNP_QueryArbitratorFreeSize *r;
4222 call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYARBITRATORFREESIZE];
4224 r = talloc(talloc_tos(), struct PNP_QueryArbitratorFreeSize);
4229 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4234 pull = ndr_pull_init_blob(&blob, r, NULL);
4240 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4241 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4242 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4247 if (DEBUGLEVEL >= 10) {
4248 NDR_PRINT_IN_DEBUG(PNP_QueryArbitratorFreeSize, r);
4251 r->out.result = _PNP_QueryArbitratorFreeSize(p, r);
4253 if (p->rng_fault_state) {
4255 /* Return true here, srv_pipe_hnd.c will take care */
4259 if (DEBUGLEVEL >= 10) {
4260 NDR_PRINT_OUT_DEBUG(PNP_QueryArbitratorFreeSize, r);
4263 push = ndr_push_init_ctx(r, NULL);
4269 ndr_err = call->ndr_push(push, NDR_OUT, r);
4270 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4275 blob = ndr_push_blob(push);
4276 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4286 static bool api_PNP_RunDetection(pipes_struct *p)
4288 const struct ndr_interface_call *call;
4289 struct ndr_pull *pull;
4290 struct ndr_push *push;
4291 enum ndr_err_code ndr_err;
4293 struct PNP_RunDetection *r;
4295 call = &ndr_table_ntsvcs.calls[NDR_PNP_RUNDETECTION];
4297 r = talloc(talloc_tos(), struct PNP_RunDetection);
4302 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4307 pull = ndr_pull_init_blob(&blob, r, NULL);
4313 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4314 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4315 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4320 if (DEBUGLEVEL >= 10) {
4321 NDR_PRINT_IN_DEBUG(PNP_RunDetection, r);
4324 r->out.result = _PNP_RunDetection(p, r);
4326 if (p->rng_fault_state) {
4328 /* Return true here, srv_pipe_hnd.c will take care */
4332 if (DEBUGLEVEL >= 10) {
4333 NDR_PRINT_OUT_DEBUG(PNP_RunDetection, r);
4336 push = ndr_push_init_ctx(r, NULL);
4342 ndr_err = call->ndr_push(push, NDR_OUT, r);
4343 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4348 blob = ndr_push_blob(push);
4349 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4359 static bool api_PNP_RegisterNotification(pipes_struct *p)
4361 const struct ndr_interface_call *call;
4362 struct ndr_pull *pull;
4363 struct ndr_push *push;
4364 enum ndr_err_code ndr_err;
4366 struct PNP_RegisterNotification *r;
4368 call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERNOTIFICATION];
4370 r = talloc(talloc_tos(), struct PNP_RegisterNotification);
4375 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4380 pull = ndr_pull_init_blob(&blob, r, NULL);
4386 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4387 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4388 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4393 if (DEBUGLEVEL >= 10) {
4394 NDR_PRINT_IN_DEBUG(PNP_RegisterNotification, r);
4397 r->out.result = _PNP_RegisterNotification(p, r);
4399 if (p->rng_fault_state) {
4401 /* Return true here, srv_pipe_hnd.c will take care */
4405 if (DEBUGLEVEL >= 10) {
4406 NDR_PRINT_OUT_DEBUG(PNP_RegisterNotification, r);
4409 push = ndr_push_init_ctx(r, NULL);
4415 ndr_err = call->ndr_push(push, NDR_OUT, r);
4416 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4421 blob = ndr_push_blob(push);
4422 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4432 static bool api_PNP_UnregisterNotification(pipes_struct *p)
4434 const struct ndr_interface_call *call;
4435 struct ndr_pull *pull;
4436 struct ndr_push *push;
4437 enum ndr_err_code ndr_err;
4439 struct PNP_UnregisterNotification *r;
4441 call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERNOTIFICATION];
4443 r = talloc(talloc_tos(), struct PNP_UnregisterNotification);
4448 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4453 pull = ndr_pull_init_blob(&blob, r, NULL);
4459 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4460 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4461 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4466 if (DEBUGLEVEL >= 10) {
4467 NDR_PRINT_IN_DEBUG(PNP_UnregisterNotification, r);
4470 r->out.result = _PNP_UnregisterNotification(p, r);
4472 if (p->rng_fault_state) {
4474 /* Return true here, srv_pipe_hnd.c will take care */
4478 if (DEBUGLEVEL >= 10) {
4479 NDR_PRINT_OUT_DEBUG(PNP_UnregisterNotification, r);
4482 push = ndr_push_init_ctx(r, NULL);
4488 ndr_err = call->ndr_push(push, NDR_OUT, r);
4489 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4494 blob = ndr_push_blob(push);
4495 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4505 static bool api_PNP_GetCustomDevProp(pipes_struct *p)
4507 const struct ndr_interface_call *call;
4508 struct ndr_pull *pull;
4509 struct ndr_push *push;
4510 enum ndr_err_code ndr_err;
4512 struct PNP_GetCustomDevProp *r;
4514 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCUSTOMDEVPROP];
4516 r = talloc(talloc_tos(), struct PNP_GetCustomDevProp);
4521 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4526 pull = ndr_pull_init_blob(&blob, r, NULL);
4532 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4533 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4534 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4539 if (DEBUGLEVEL >= 10) {
4540 NDR_PRINT_IN_DEBUG(PNP_GetCustomDevProp, r);
4543 r->out.result = _PNP_GetCustomDevProp(p, r);
4545 if (p->rng_fault_state) {
4547 /* Return true here, srv_pipe_hnd.c will take care */
4551 if (DEBUGLEVEL >= 10) {
4552 NDR_PRINT_OUT_DEBUG(PNP_GetCustomDevProp, r);
4555 push = ndr_push_init_ctx(r, NULL);
4561 ndr_err = call->ndr_push(push, NDR_OUT, r);
4562 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4567 blob = ndr_push_blob(push);
4568 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4578 static bool api_PNP_GetVersionInternal(pipes_struct *p)
4580 const struct ndr_interface_call *call;
4581 struct ndr_pull *pull;
4582 struct ndr_push *push;
4583 enum ndr_err_code ndr_err;
4585 struct PNP_GetVersionInternal *r;
4587 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSIONINTERNAL];
4589 r = talloc(talloc_tos(), struct PNP_GetVersionInternal);
4594 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4599 pull = ndr_pull_init_blob(&blob, r, NULL);
4605 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4606 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4607 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4612 if (DEBUGLEVEL >= 10) {
4613 NDR_PRINT_IN_DEBUG(PNP_GetVersionInternal, r);
4616 r->out.result = _PNP_GetVersionInternal(p, r);
4618 if (p->rng_fault_state) {
4620 /* Return true here, srv_pipe_hnd.c will take care */
4624 if (DEBUGLEVEL >= 10) {
4625 NDR_PRINT_OUT_DEBUG(PNP_GetVersionInternal, r);
4628 push = ndr_push_init_ctx(r, NULL);
4634 ndr_err = call->ndr_push(push, NDR_OUT, r);
4635 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4640 blob = ndr_push_blob(push);
4641 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4651 static bool api_PNP_GetBlockedDriverInfo(pipes_struct *p)
4653 const struct ndr_interface_call *call;
4654 struct ndr_pull *pull;
4655 struct ndr_push *push;
4656 enum ndr_err_code ndr_err;
4658 struct PNP_GetBlockedDriverInfo *r;
4660 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETBLOCKEDDRIVERINFO];
4662 r = talloc(talloc_tos(), struct PNP_GetBlockedDriverInfo);
4667 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4672 pull = ndr_pull_init_blob(&blob, r, NULL);
4678 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4679 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4680 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4685 if (DEBUGLEVEL >= 10) {
4686 NDR_PRINT_IN_DEBUG(PNP_GetBlockedDriverInfo, r);
4689 r->out.result = _PNP_GetBlockedDriverInfo(p, r);
4691 if (p->rng_fault_state) {
4693 /* Return true here, srv_pipe_hnd.c will take care */
4697 if (DEBUGLEVEL >= 10) {
4698 NDR_PRINT_OUT_DEBUG(PNP_GetBlockedDriverInfo, r);
4701 push = ndr_push_init_ctx(r, NULL);
4707 ndr_err = call->ndr_push(push, NDR_OUT, r);
4708 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4713 blob = ndr_push_blob(push);
4714 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4724 static bool api_PNP_GetServerSideDeviceInstallFlags(pipes_struct *p)
4726 const struct ndr_interface_call *call;
4727 struct ndr_pull *pull;
4728 struct ndr_push *push;
4729 enum ndr_err_code ndr_err;
4731 struct PNP_GetServerSideDeviceInstallFlags *r;
4733 call = &ndr_table_ntsvcs.calls[NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS];
4735 r = talloc(talloc_tos(), struct PNP_GetServerSideDeviceInstallFlags);
4740 if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4745 pull = ndr_pull_init_blob(&blob, r, NULL);
4751 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4752 ndr_err = call->ndr_pull(pull, NDR_IN, r);
4753 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4758 if (DEBUGLEVEL >= 10) {
4759 NDR_PRINT_IN_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4762 r->out.result = _PNP_GetServerSideDeviceInstallFlags(p, r);
4764 if (p->rng_fault_state) {
4766 /* Return true here, srv_pipe_hnd.c will take care */
4770 if (DEBUGLEVEL >= 10) {
4771 NDR_PRINT_OUT_DEBUG(PNP_GetServerSideDeviceInstallFlags, r);
4774 push = ndr_push_init_ctx(r, NULL);
4780 ndr_err = call->ndr_push(push, NDR_OUT, r);
4781 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4786 blob = ndr_push_blob(push);
4787 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4799 static struct api_struct api_ntsvcs_cmds[] =
4801 {"PNP_DISCONNECT", NDR_PNP_DISCONNECT, api_PNP_Disconnect},
4802 {"PNP_CONNECT", NDR_PNP_CONNECT, api_PNP_Connect},
4803 {"PNP_GETVERSION", NDR_PNP_GETVERSION, api_PNP_GetVersion},
4804 {"PNP_GETGLOBALSTATE", NDR_PNP_GETGLOBALSTATE, api_PNP_GetGlobalState},
4805 {"PNP_INITDETECTION", NDR_PNP_INITDETECTION, api_PNP_InitDetection},
4806 {"PNP_REPORTLOGON", NDR_PNP_REPORTLOGON, api_PNP_ReportLogOn},
4807 {"PNP_VALIDATEDEVICEINSTANCE", NDR_PNP_VALIDATEDEVICEINSTANCE, api_PNP_ValidateDeviceInstance},
4808 {"PNP_GETROOTDEVICEINSTANCE", NDR_PNP_GETROOTDEVICEINSTANCE, api_PNP_GetRootDeviceInstance},
4809 {"PNP_GETRELATEDDEVICEINSTANCE", NDR_PNP_GETRELATEDDEVICEINSTANCE, api_PNP_GetRelatedDeviceInstance},
4810 {"PNP_ENUMERATESUBKEYS", NDR_PNP_ENUMERATESUBKEYS, api_PNP_EnumerateSubKeys},
4811 {"PNP_GETDEVICELIST", NDR_PNP_GETDEVICELIST, api_PNP_GetDeviceList},
4812 {"PNP_GETDEVICELISTSIZE", NDR_PNP_GETDEVICELISTSIZE, api_PNP_GetDeviceListSize},
4813 {"PNP_GETDEPTH", NDR_PNP_GETDEPTH, api_PNP_GetDepth},
4814 {"PNP_GETDEVICEREGPROP", NDR_PNP_GETDEVICEREGPROP, api_PNP_GetDeviceRegProp},
4815 {"PNP_SETDEVICEREGPROP", NDR_PNP_SETDEVICEREGPROP, api_PNP_SetDeviceRegProp},
4816 {"PNP_GETCLASSINSTANCE", NDR_PNP_GETCLASSINSTANCE, api_PNP_GetClassInstance},
4817 {"PNP_CREATEKEY", NDR_PNP_CREATEKEY, api_PNP_CreateKey},
4818 {"PNP_DELETEREGISTRYKEY", NDR_PNP_DELETEREGISTRYKEY, api_PNP_DeleteRegistryKey},
4819 {"PNP_GETCLASSCOUNT", NDR_PNP_GETCLASSCOUNT, api_PNP_GetClassCount},
4820 {"PNP_GETCLASSNAME", NDR_PNP_GETCLASSNAME, api_PNP_GetClassName},
4821 {"PNP_DELETECLASSKEY", NDR_PNP_DELETECLASSKEY, api_PNP_DeleteClassKey},
4822 {"PNP_GETINTERFACEDEVICEALIAS", NDR_PNP_GETINTERFACEDEVICEALIAS, api_PNP_GetInterfaceDeviceAlias},
4823 {"PNP_GETINTERFACEDEVICELIST", NDR_PNP_GETINTERFACEDEVICELIST, api_PNP_GetInterfaceDeviceList},
4824 {"PNP_GETINTERFACEDEVICELISTSIZE", NDR_PNP_GETINTERFACEDEVICELISTSIZE, api_PNP_GetInterfaceDeviceListSize},
4825 {"PNP_REGISTERDEVICECLASSASSOCIATION", NDR_PNP_REGISTERDEVICECLASSASSOCIATION, api_PNP_RegisterDeviceClassAssociation},
4826 {"PNP_UNREGISTERDEVICECLASSASSOCIATION", NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION, api_PNP_UnregisterDeviceClassAssociation},
4827 {"PNP_GETCLASSREGPROP", NDR_PNP_GETCLASSREGPROP, api_PNP_GetClassRegProp},
4828 {"PNP_SETCLASSREGPROP", NDR_PNP_SETCLASSREGPROP, api_PNP_SetClassRegProp},
4829 {"PNP_CREATEDEVINST", NDR_PNP_CREATEDEVINST, api_PNP_CreateDevInst},
4830 {"PNP_DEVICEINSTANCEACTION", NDR_PNP_DEVICEINSTANCEACTION, api_PNP_DeviceInstanceAction},
4831 {"PNP_GETDEVICESTATUS", NDR_PNP_GETDEVICESTATUS, api_PNP_GetDeviceStatus},
4832 {"PNP_SETDEVICEPROBLEM", NDR_PNP_SETDEVICEPROBLEM, api_PNP_SetDeviceProblem},
4833 {"PNP_DISABLEDEVINST", NDR_PNP_DISABLEDEVINST, api_PNP_DisableDevInst},
4834 {"PNP_UNINSTALLDEVINST", NDR_PNP_UNINSTALLDEVINST, api_PNP_UninstallDevInst},
4835 {"PNP_ADDID", NDR_PNP_ADDID, api_PNP_AddID},
4836 {"PNP_REGISTERDRIVER", NDR_PNP_REGISTERDRIVER, api_PNP_RegisterDriver},
4837 {"PNP_QUERYREMOVE", NDR_PNP_QUERYREMOVE, api_PNP_QueryRemove},
4838 {"PNP_REQUESTDEVICEEJECT", NDR_PNP_REQUESTDEVICEEJECT, api_PNP_RequestDeviceEject},
4839 {"PNP_ISDOCKSTATIONPRESENT", NDR_PNP_ISDOCKSTATIONPRESENT, api_PNP_IsDockStationPresent},
4840 {"PNP_REQUESTEJECTPC", NDR_PNP_REQUESTEJECTPC, api_PNP_RequestEjectPC},
4841 {"PNP_HWPROFFLAGS", NDR_PNP_HWPROFFLAGS, api_PNP_HwProfFlags},
4842 {"PNP_GETHWPROFINFO", NDR_PNP_GETHWPROFINFO, api_PNP_GetHwProfInfo},
4843 {"PNP_ADDEMPTYLOGCONF", NDR_PNP_ADDEMPTYLOGCONF, api_PNP_AddEmptyLogConf},
4844 {"PNP_FREELOGCONF", NDR_PNP_FREELOGCONF, api_PNP_FreeLogConf},
4845 {"PNP_GETFIRSTLOGCONF", NDR_PNP_GETFIRSTLOGCONF, api_PNP_GetFirstLogConf},
4846 {"PNP_GETNEXTLOGCONF", NDR_PNP_GETNEXTLOGCONF, api_PNP_GetNextLogConf},
4847 {"PNP_GETLOGCONFPRIORITY", NDR_PNP_GETLOGCONFPRIORITY, api_PNP_GetLogConfPriority},
4848 {"PNP_ADDRESDES", NDR_PNP_ADDRESDES, api_PNP_AddResDes},
4849 {"PNP_FREERESDES", NDR_PNP_FREERESDES, api_PNP_FreeResDes},
4850 {"PNP_GETNEXTRESDES", NDR_PNP_GETNEXTRESDES, api_PNP_GetNextResDes},
4851 {"PNP_GETRESDESDATA", NDR_PNP_GETRESDESDATA, api_PNP_GetResDesData},
4852 {"PNP_GETRESDESDATASIZE", NDR_PNP_GETRESDESDATASIZE, api_PNP_GetResDesDataSize},
4853 {"PNP_MODIFYRESDES", NDR_PNP_MODIFYRESDES, api_PNP_ModifyResDes},
4854 {"PNP_DETECTRESOURCELIMIT", NDR_PNP_DETECTRESOURCELIMIT, api_PNP_DetectResourceLimit},
4855 {"PNP_QUERYRESCONFLIST", NDR_PNP_QUERYRESCONFLIST, api_PNP_QueryResConfList},
4856 {"PNP_SETHWPROF", NDR_PNP_SETHWPROF, api_PNP_SetHwProf},
4857 {"PNP_QUERYARBITRATORFREEDATA", NDR_PNP_QUERYARBITRATORFREEDATA, api_PNP_QueryArbitratorFreeData},
4858 {"PNP_QUERYARBITRATORFREESIZE", NDR_PNP_QUERYARBITRATORFREESIZE, api_PNP_QueryArbitratorFreeSize},
4859 {"PNP_RUNDETECTION", NDR_PNP_RUNDETECTION, api_PNP_RunDetection},
4860 {"PNP_REGISTERNOTIFICATION", NDR_PNP_REGISTERNOTIFICATION, api_PNP_RegisterNotification},
4861 {"PNP_UNREGISTERNOTIFICATION", NDR_PNP_UNREGISTERNOTIFICATION, api_PNP_UnregisterNotification},
4862 {"PNP_GETCUSTOMDEVPROP", NDR_PNP_GETCUSTOMDEVPROP, api_PNP_GetCustomDevProp},
4863 {"PNP_GETVERSIONINTERNAL", NDR_PNP_GETVERSIONINTERNAL, api_PNP_GetVersionInternal},
4864 {"PNP_GETBLOCKEDDRIVERINFO", NDR_PNP_GETBLOCKEDDRIVERINFO, api_PNP_GetBlockedDriverInfo},
4865 {"PNP_GETSERVERSIDEDEVICEINSTALLFLAGS", NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS, api_PNP_GetServerSideDeviceInstallFlags},
4868 void ntsvcs_get_pipe_fns(struct api_struct **fns, int *n_fns)
4870 *fns = api_ntsvcs_cmds;
4871 *n_fns = sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct);
4874 NTSTATUS rpc_ntsvcs_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
4876 if (cli->pipes_struct == NULL) {
4877 return NT_STATUS_INVALID_PARAMETER;
4882 case NDR_PNP_DISCONNECT: {
4883 struct PNP_Disconnect *r = (struct PNP_Disconnect *)_r;
4884 r->out.result = _PNP_Disconnect(cli->pipes_struct, r);
4885 return NT_STATUS_OK;
4888 case NDR_PNP_CONNECT: {
4889 struct PNP_Connect *r = (struct PNP_Connect *)_r;
4890 r->out.result = _PNP_Connect(cli->pipes_struct, r);
4891 return NT_STATUS_OK;
4894 case NDR_PNP_GETVERSION: {
4895 struct PNP_GetVersion *r = (struct PNP_GetVersion *)_r;
4896 ZERO_STRUCT(r->out);
4897 r->out.version = talloc_zero(mem_ctx, uint16_t);
4898 if (r->out.version == NULL) {
4899 return NT_STATUS_NO_MEMORY;
4902 r->out.result = _PNP_GetVersion(cli->pipes_struct, r);
4903 return NT_STATUS_OK;
4906 case NDR_PNP_GETGLOBALSTATE: {
4907 struct PNP_GetGlobalState *r = (struct PNP_GetGlobalState *)_r;
4908 r->out.result = _PNP_GetGlobalState(cli->pipes_struct, r);
4909 return NT_STATUS_OK;
4912 case NDR_PNP_INITDETECTION: {
4913 struct PNP_InitDetection *r = (struct PNP_InitDetection *)_r;
4914 r->out.result = _PNP_InitDetection(cli->pipes_struct, r);
4915 return NT_STATUS_OK;
4918 case NDR_PNP_REPORTLOGON: {
4919 struct PNP_ReportLogOn *r = (struct PNP_ReportLogOn *)_r;
4920 r->out.result = _PNP_ReportLogOn(cli->pipes_struct, r);
4921 return NT_STATUS_OK;
4924 case NDR_PNP_VALIDATEDEVICEINSTANCE: {
4925 struct PNP_ValidateDeviceInstance *r = (struct PNP_ValidateDeviceInstance *)_r;
4926 r->out.result = _PNP_ValidateDeviceInstance(cli->pipes_struct, r);
4927 return NT_STATUS_OK;
4930 case NDR_PNP_GETROOTDEVICEINSTANCE: {
4931 struct PNP_GetRootDeviceInstance *r = (struct PNP_GetRootDeviceInstance *)_r;
4932 r->out.result = _PNP_GetRootDeviceInstance(cli->pipes_struct, r);
4933 return NT_STATUS_OK;
4936 case NDR_PNP_GETRELATEDDEVICEINSTANCE: {
4937 struct PNP_GetRelatedDeviceInstance *r = (struct PNP_GetRelatedDeviceInstance *)_r;
4938 r->out.result = _PNP_GetRelatedDeviceInstance(cli->pipes_struct, r);
4939 return NT_STATUS_OK;
4942 case NDR_PNP_ENUMERATESUBKEYS: {
4943 struct PNP_EnumerateSubKeys *r = (struct PNP_EnumerateSubKeys *)_r;
4944 r->out.result = _PNP_EnumerateSubKeys(cli->pipes_struct, r);
4945 return NT_STATUS_OK;
4948 case NDR_PNP_GETDEVICELIST: {
4949 struct PNP_GetDeviceList *r = (struct PNP_GetDeviceList *)_r;
4950 ZERO_STRUCT(r->out);
4951 r->out.length = r->in.length;
4952 r->out.buffer = talloc_zero_array(mem_ctx, uint16_t, *r->out.length);
4953 if (r->out.buffer == NULL) {
4954 return NT_STATUS_NO_MEMORY;
4957 r->out.result = _PNP_GetDeviceList(cli->pipes_struct, r);
4958 return NT_STATUS_OK;
4961 case NDR_PNP_GETDEVICELISTSIZE: {
4962 struct PNP_GetDeviceListSize *r = (struct PNP_GetDeviceListSize *)_r;
4963 ZERO_STRUCT(r->out);
4964 r->out.size = talloc_zero(mem_ctx, uint32_t);
4965 if (r->out.size == NULL) {
4966 return NT_STATUS_NO_MEMORY;
4969 r->out.result = _PNP_GetDeviceListSize(cli->pipes_struct, r);
4970 return NT_STATUS_OK;
4973 case NDR_PNP_GETDEPTH: {
4974 struct PNP_GetDepth *r = (struct PNP_GetDepth *)_r;
4975 r->out.result = _PNP_GetDepth(cli->pipes_struct, r);
4976 return NT_STATUS_OK;
4979 case NDR_PNP_GETDEVICEREGPROP: {
4980 struct PNP_GetDeviceRegProp *r = (struct PNP_GetDeviceRegProp *)_r;
4981 ZERO_STRUCT(r->out);
4982 r->out.reg_data_type = r->in.reg_data_type;
4983 r->out.buffer_size = r->in.buffer_size;
4984 r->out.needed = r->in.needed;
4985 r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, *r->out.buffer_size);
4986 if (r->out.buffer == NULL) {
4987 return NT_STATUS_NO_MEMORY;
4990 r->out.result = _PNP_GetDeviceRegProp(cli->pipes_struct, r);
4991 return NT_STATUS_OK;
4994 case NDR_PNP_SETDEVICEREGPROP: {
4995 struct PNP_SetDeviceRegProp *r = (struct PNP_SetDeviceRegProp *)_r;
4996 r->out.result = _PNP_SetDeviceRegProp(cli->pipes_struct, r);
4997 return NT_STATUS_OK;
5000 case NDR_PNP_GETCLASSINSTANCE: {
5001 struct PNP_GetClassInstance *r = (struct PNP_GetClassInstance *)_r;
5002 r->out.result = _PNP_GetClassInstance(cli->pipes_struct, r);
5003 return NT_STATUS_OK;
5006 case NDR_PNP_CREATEKEY: {
5007 struct PNP_CreateKey *r = (struct PNP_CreateKey *)_r;
5008 r->out.result = _PNP_CreateKey(cli->pipes_struct, r);
5009 return NT_STATUS_OK;
5012 case NDR_PNP_DELETEREGISTRYKEY: {
5013 struct PNP_DeleteRegistryKey *r = (struct PNP_DeleteRegistryKey *)_r;
5014 r->out.result = _PNP_DeleteRegistryKey(cli->pipes_struct, r);
5015 return NT_STATUS_OK;
5018 case NDR_PNP_GETCLASSCOUNT: {
5019 struct PNP_GetClassCount *r = (struct PNP_GetClassCount *)_r;
5020 r->out.result = _PNP_GetClassCount(cli->pipes_struct, r);
5021 return NT_STATUS_OK;
5024 case NDR_PNP_GETCLASSNAME: {
5025 struct PNP_GetClassName *r = (struct PNP_GetClassName *)_r;
5026 r->out.result = _PNP_GetClassName(cli->pipes_struct, r);
5027 return NT_STATUS_OK;
5030 case NDR_PNP_DELETECLASSKEY: {
5031 struct PNP_DeleteClassKey *r = (struct PNP_DeleteClassKey *)_r;
5032 r->out.result = _PNP_DeleteClassKey(cli->pipes_struct, r);
5033 return NT_STATUS_OK;
5036 case NDR_PNP_GETINTERFACEDEVICEALIAS: {
5037 struct PNP_GetInterfaceDeviceAlias *r = (struct PNP_GetInterfaceDeviceAlias *)_r;
5038 r->out.result = _PNP_GetInterfaceDeviceAlias(cli->pipes_struct, r);
5039 return NT_STATUS_OK;
5042 case NDR_PNP_GETINTERFACEDEVICELIST: {
5043 struct PNP_GetInterfaceDeviceList *r = (struct PNP_GetInterfaceDeviceList *)_r;
5044 r->out.result = _PNP_GetInterfaceDeviceList(cli->pipes_struct, r);
5045 return NT_STATUS_OK;
5048 case NDR_PNP_GETINTERFACEDEVICELISTSIZE: {
5049 struct PNP_GetInterfaceDeviceListSize *r = (struct PNP_GetInterfaceDeviceListSize *)_r;
5050 r->out.result = _PNP_GetInterfaceDeviceListSize(cli->pipes_struct, r);
5051 return NT_STATUS_OK;
5054 case NDR_PNP_REGISTERDEVICECLASSASSOCIATION: {
5055 struct PNP_RegisterDeviceClassAssociation *r = (struct PNP_RegisterDeviceClassAssociation *)_r;
5056 r->out.result = _PNP_RegisterDeviceClassAssociation(cli->pipes_struct, r);
5057 return NT_STATUS_OK;
5060 case NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION: {
5061 struct PNP_UnregisterDeviceClassAssociation *r = (struct PNP_UnregisterDeviceClassAssociation *)_r;
5062 r->out.result = _PNP_UnregisterDeviceClassAssociation(cli->pipes_struct, r);
5063 return NT_STATUS_OK;
5066 case NDR_PNP_GETCLASSREGPROP: {
5067 struct PNP_GetClassRegProp *r = (struct PNP_GetClassRegProp *)_r;
5068 r->out.result = _PNP_GetClassRegProp(cli->pipes_struct, r);
5069 return NT_STATUS_OK;
5072 case NDR_PNP_SETCLASSREGPROP: {
5073 struct PNP_SetClassRegProp *r = (struct PNP_SetClassRegProp *)_r;
5074 r->out.result = _PNP_SetClassRegProp(cli->pipes_struct, r);
5075 return NT_STATUS_OK;
5078 case NDR_PNP_CREATEDEVINST: {
5079 struct PNP_CreateDevInst *r = (struct PNP_CreateDevInst *)_r;
5080 r->out.result = _PNP_CreateDevInst(cli->pipes_struct, r);
5081 return NT_STATUS_OK;
5084 case NDR_PNP_DEVICEINSTANCEACTION: {
5085 struct PNP_DeviceInstanceAction *r = (struct PNP_DeviceInstanceAction *)_r;
5086 r->out.result = _PNP_DeviceInstanceAction(cli->pipes_struct, r);
5087 return NT_STATUS_OK;
5090 case NDR_PNP_GETDEVICESTATUS: {
5091 struct PNP_GetDeviceStatus *r = (struct PNP_GetDeviceStatus *)_r;
5092 r->out.result = _PNP_GetDeviceStatus(cli->pipes_struct, r);
5093 return NT_STATUS_OK;
5096 case NDR_PNP_SETDEVICEPROBLEM: {
5097 struct PNP_SetDeviceProblem *r = (struct PNP_SetDeviceProblem *)_r;
5098 r->out.result = _PNP_SetDeviceProblem(cli->pipes_struct, r);
5099 return NT_STATUS_OK;
5102 case NDR_PNP_DISABLEDEVINST: {
5103 struct PNP_DisableDevInst *r = (struct PNP_DisableDevInst *)_r;
5104 r->out.result = _PNP_DisableDevInst(cli->pipes_struct, r);
5105 return NT_STATUS_OK;
5108 case NDR_PNP_UNINSTALLDEVINST: {
5109 struct PNP_UninstallDevInst *r = (struct PNP_UninstallDevInst *)_r;
5110 r->out.result = _PNP_UninstallDevInst(cli->pipes_struct, r);
5111 return NT_STATUS_OK;
5114 case NDR_PNP_ADDID: {
5115 struct PNP_AddID *r = (struct PNP_AddID *)_r;
5116 r->out.result = _PNP_AddID(cli->pipes_struct, r);
5117 return NT_STATUS_OK;
5120 case NDR_PNP_REGISTERDRIVER: {
5121 struct PNP_RegisterDriver *r = (struct PNP_RegisterDriver *)_r;
5122 r->out.result = _PNP_RegisterDriver(cli->pipes_struct, r);
5123 return NT_STATUS_OK;
5126 case NDR_PNP_QUERYREMOVE: {
5127 struct PNP_QueryRemove *r = (struct PNP_QueryRemove *)_r;
5128 r->out.result = _PNP_QueryRemove(cli->pipes_struct, r);
5129 return NT_STATUS_OK;
5132 case NDR_PNP_REQUESTDEVICEEJECT: {
5133 struct PNP_RequestDeviceEject *r = (struct PNP_RequestDeviceEject *)_r;
5134 r->out.result = _PNP_RequestDeviceEject(cli->pipes_struct, r);
5135 return NT_STATUS_OK;
5138 case NDR_PNP_ISDOCKSTATIONPRESENT: {
5139 struct PNP_IsDockStationPresent *r = (struct PNP_IsDockStationPresent *)_r;
5140 r->out.result = _PNP_IsDockStationPresent(cli->pipes_struct, r);
5141 return NT_STATUS_OK;
5144 case NDR_PNP_REQUESTEJECTPC: {
5145 struct PNP_RequestEjectPC *r = (struct PNP_RequestEjectPC *)_r;
5146 r->out.result = _PNP_RequestEjectPC(cli->pipes_struct, r);
5147 return NT_STATUS_OK;
5150 case NDR_PNP_HWPROFFLAGS: {
5151 struct PNP_HwProfFlags *r = (struct PNP_HwProfFlags *)_r;
5152 ZERO_STRUCT(r->out);
5153 r->out.profile_flags = r->in.profile_flags;
5154 r->out.veto_type = r->in.veto_type;
5155 r->out.unknown5a = talloc_zero(mem_ctx, const char *);
5156 if (r->out.unknown5a == NULL) {
5157 return NT_STATUS_NO_MEMORY;
5160 r->out.result = _PNP_HwProfFlags(cli->pipes_struct, r);
5161 return NT_STATUS_OK;
5164 case NDR_PNP_GETHWPROFINFO: {
5165 struct PNP_GetHwProfInfo *r = (struct PNP_GetHwProfInfo *)_r;
5166 ZERO_STRUCT(r->out);
5167 r->out.info = r->in.info;
5168 r->out.result = _PNP_GetHwProfInfo(cli->pipes_struct, r);
5169 return NT_STATUS_OK;
5172 case NDR_PNP_ADDEMPTYLOGCONF: {
5173 struct PNP_AddEmptyLogConf *r = (struct PNP_AddEmptyLogConf *)_r;
5174 r->out.result = _PNP_AddEmptyLogConf(cli->pipes_struct, r);
5175 return NT_STATUS_OK;
5178 case NDR_PNP_FREELOGCONF: {
5179 struct PNP_FreeLogConf *r = (struct PNP_FreeLogConf *)_r;
5180 r->out.result = _PNP_FreeLogConf(cli->pipes_struct, r);
5181 return NT_STATUS_OK;
5184 case NDR_PNP_GETFIRSTLOGCONF: {
5185 struct PNP_GetFirstLogConf *r = (struct PNP_GetFirstLogConf *)_r;
5186 r->out.result = _PNP_GetFirstLogConf(cli->pipes_struct, r);
5187 return NT_STATUS_OK;
5190 case NDR_PNP_GETNEXTLOGCONF: {
5191 struct PNP_GetNextLogConf *r = (struct PNP_GetNextLogConf *)_r;
5192 r->out.result = _PNP_GetNextLogConf(cli->pipes_struct, r);
5193 return NT_STATUS_OK;
5196 case NDR_PNP_GETLOGCONFPRIORITY: {
5197 struct PNP_GetLogConfPriority *r = (struct PNP_GetLogConfPriority *)_r;
5198 r->out.result = _PNP_GetLogConfPriority(cli->pipes_struct, r);
5199 return NT_STATUS_OK;
5202 case NDR_PNP_ADDRESDES: {
5203 struct PNP_AddResDes *r = (struct PNP_AddResDes *)_r;
5204 r->out.result = _PNP_AddResDes(cli->pipes_struct, r);
5205 return NT_STATUS_OK;
5208 case NDR_PNP_FREERESDES: {
5209 struct PNP_FreeResDes *r = (struct PNP_FreeResDes *)_r;
5210 r->out.result = _PNP_FreeResDes(cli->pipes_struct, r);
5211 return NT_STATUS_OK;
5214 case NDR_PNP_GETNEXTRESDES: {
5215 struct PNP_GetNextResDes *r = (struct PNP_GetNextResDes *)_r;
5216 r->out.result = _PNP_GetNextResDes(cli->pipes_struct, r);
5217 return NT_STATUS_OK;
5220 case NDR_PNP_GETRESDESDATA: {
5221 struct PNP_GetResDesData *r = (struct PNP_GetResDesData *)_r;
5222 r->out.result = _PNP_GetResDesData(cli->pipes_struct, r);
5223 return NT_STATUS_OK;
5226 case NDR_PNP_GETRESDESDATASIZE: {
5227 struct PNP_GetResDesDataSize *r = (struct PNP_GetResDesDataSize *)_r;
5228 r->out.result = _PNP_GetResDesDataSize(cli->pipes_struct, r);
5229 return NT_STATUS_OK;
5232 case NDR_PNP_MODIFYRESDES: {
5233 struct PNP_ModifyResDes *r = (struct PNP_ModifyResDes *)_r;
5234 r->out.result = _PNP_ModifyResDes(cli->pipes_struct, r);
5235 return NT_STATUS_OK;
5238 case NDR_PNP_DETECTRESOURCELIMIT: {
5239 struct PNP_DetectResourceLimit *r = (struct PNP_DetectResourceLimit *)_r;
5240 r->out.result = _PNP_DetectResourceLimit(cli->pipes_struct, r);
5241 return NT_STATUS_OK;
5244 case NDR_PNP_QUERYRESCONFLIST: {
5245 struct PNP_QueryResConfList *r = (struct PNP_QueryResConfList *)_r;
5246 r->out.result = _PNP_QueryResConfList(cli->pipes_struct, r);
5247 return NT_STATUS_OK;
5250 case NDR_PNP_SETHWPROF: {
5251 struct PNP_SetHwProf *r = (struct PNP_SetHwProf *)_r;
5252 r->out.result = _PNP_SetHwProf(cli->pipes_struct, r);
5253 return NT_STATUS_OK;
5256 case NDR_PNP_QUERYARBITRATORFREEDATA: {
5257 struct PNP_QueryArbitratorFreeData *r = (struct PNP_QueryArbitratorFreeData *)_r;
5258 r->out.result = _PNP_QueryArbitratorFreeData(cli->pipes_struct, r);
5259 return NT_STATUS_OK;
5262 case NDR_PNP_QUERYARBITRATORFREESIZE: {
5263 struct PNP_QueryArbitratorFreeSize *r = (struct PNP_QueryArbitratorFreeSize *)_r;
5264 r->out.result = _PNP_QueryArbitratorFreeSize(cli->pipes_struct, r);
5265 return NT_STATUS_OK;
5268 case NDR_PNP_RUNDETECTION: {
5269 struct PNP_RunDetection *r = (struct PNP_RunDetection *)_r;
5270 r->out.result = _PNP_RunDetection(cli->pipes_struct, r);
5271 return NT_STATUS_OK;
5274 case NDR_PNP_REGISTERNOTIFICATION: {
5275 struct PNP_RegisterNotification *r = (struct PNP_RegisterNotification *)_r;
5276 r->out.result = _PNP_RegisterNotification(cli->pipes_struct, r);
5277 return NT_STATUS_OK;
5280 case NDR_PNP_UNREGISTERNOTIFICATION: {
5281 struct PNP_UnregisterNotification *r = (struct PNP_UnregisterNotification *)_r;
5282 r->out.result = _PNP_UnregisterNotification(cli->pipes_struct, r);
5283 return NT_STATUS_OK;
5286 case NDR_PNP_GETCUSTOMDEVPROP: {
5287 struct PNP_GetCustomDevProp *r = (struct PNP_GetCustomDevProp *)_r;
5288 r->out.result = _PNP_GetCustomDevProp(cli->pipes_struct, r);
5289 return NT_STATUS_OK;
5292 case NDR_PNP_GETVERSIONINTERNAL: {
5293 struct PNP_GetVersionInternal *r = (struct PNP_GetVersionInternal *)_r;
5294 r->out.result = _PNP_GetVersionInternal(cli->pipes_struct, r);
5295 return NT_STATUS_OK;
5298 case NDR_PNP_GETBLOCKEDDRIVERINFO: {
5299 struct PNP_GetBlockedDriverInfo *r = (struct PNP_GetBlockedDriverInfo *)_r;
5300 r->out.result = _PNP_GetBlockedDriverInfo(cli->pipes_struct, r);
5301 return NT_STATUS_OK;
5304 case NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS: {
5305 struct PNP_GetServerSideDeviceInstallFlags *r = (struct PNP_GetServerSideDeviceInstallFlags *)_r;
5306 r->out.result = _PNP_GetServerSideDeviceInstallFlags(cli->pipes_struct, r);
5307 return NT_STATUS_OK;
5311 return NT_STATUS_NOT_IMPLEMENTED;
5315 NTSTATUS rpc_ntsvcs_init(void)
5317 return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "ntsvcs", "ntsvcs", &ndr_table_ntsvcs, api_ntsvcs_cmds, sizeof(api_ntsvcs_cmds) / sizeof(struct api_struct));