2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
7 #include "../librpc/gen_ndr/cli_ntsvcs.h"
9 struct rpccli_PNP_Disconnect_state
{
10 struct PNP_Disconnect orig
;
11 struct PNP_Disconnect tmp
;
12 TALLOC_CTX
*out_mem_ctx
;
13 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
16 static void rpccli_PNP_Disconnect_done(struct tevent_req
*subreq
);
18 struct tevent_req
*rpccli_PNP_Disconnect_send(TALLOC_CTX
*mem_ctx
,
19 struct tevent_context
*ev
,
20 struct rpc_pipe_client
*cli
)
22 struct tevent_req
*req
;
23 struct rpccli_PNP_Disconnect_state
*state
;
24 struct tevent_req
*subreq
;
26 req
= tevent_req_create(mem_ctx
, &state
,
27 struct rpccli_PNP_Disconnect_state
);
31 state
->out_mem_ctx
= NULL
;
32 state
->dispatch_recv
= cli
->dispatch_recv
;
39 ZERO_STRUCT(state
->orig
.out
.result
);
41 /* make a temporary copy, that we pass to the dispatch function */
42 state
->tmp
= state
->orig
;
44 subreq
= cli
->dispatch_send(state
, ev
, cli
,
48 if (tevent_req_nomem(subreq
, req
)) {
49 return tevent_req_post(req
, ev
);
51 tevent_req_set_callback(subreq
, rpccli_PNP_Disconnect_done
, req
);
55 static void rpccli_PNP_Disconnect_done(struct tevent_req
*subreq
)
57 struct tevent_req
*req
= tevent_req_callback_data(
58 subreq
, struct tevent_req
);
59 struct rpccli_PNP_Disconnect_state
*state
= tevent_req_data(
60 req
, struct rpccli_PNP_Disconnect_state
);
64 if (state
->out_mem_ctx
) {
65 mem_ctx
= state
->out_mem_ctx
;
70 status
= state
->dispatch_recv(subreq
, mem_ctx
);
72 if (!NT_STATUS_IS_OK(status
)) {
73 tevent_req_nterror(req
, status
);
77 /* Copy out parameters */
80 state
->orig
.out
.result
= state
->tmp
.out
.result
;
82 /* Reset temporary structure */
83 ZERO_STRUCT(state
->tmp
);
88 NTSTATUS
rpccli_PNP_Disconnect_recv(struct tevent_req
*req
,
92 struct rpccli_PNP_Disconnect_state
*state
= tevent_req_data(
93 req
, struct rpccli_PNP_Disconnect_state
);
96 if (tevent_req_is_nterror(req
, &status
)) {
97 tevent_req_received(req
);
101 /* Steal possbile out parameters to the callers context */
102 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
105 *result
= state
->orig
.out
.result
;
107 tevent_req_received(req
);
111 NTSTATUS
rpccli_PNP_Disconnect(struct rpc_pipe_client
*cli
,
115 struct PNP_Disconnect r
;
120 status
= cli
->dispatch(cli
,
126 if (!NT_STATUS_IS_OK(status
)) {
130 if (NT_STATUS_IS_ERR(status
)) {
134 /* Return variables */
138 *werror
= r
.out
.result
;
141 return werror_to_ntstatus(r
.out
.result
);
144 struct rpccli_PNP_Connect_state
{
145 struct PNP_Connect orig
;
146 struct PNP_Connect tmp
;
147 TALLOC_CTX
*out_mem_ctx
;
148 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
151 static void rpccli_PNP_Connect_done(struct tevent_req
*subreq
);
153 struct tevent_req
*rpccli_PNP_Connect_send(TALLOC_CTX
*mem_ctx
,
154 struct tevent_context
*ev
,
155 struct rpc_pipe_client
*cli
)
157 struct tevent_req
*req
;
158 struct rpccli_PNP_Connect_state
*state
;
159 struct tevent_req
*subreq
;
161 req
= tevent_req_create(mem_ctx
, &state
,
162 struct rpccli_PNP_Connect_state
);
166 state
->out_mem_ctx
= NULL
;
167 state
->dispatch_recv
= cli
->dispatch_recv
;
174 ZERO_STRUCT(state
->orig
.out
.result
);
176 /* make a temporary copy, that we pass to the dispatch function */
177 state
->tmp
= state
->orig
;
179 subreq
= cli
->dispatch_send(state
, ev
, cli
,
183 if (tevent_req_nomem(subreq
, req
)) {
184 return tevent_req_post(req
, ev
);
186 tevent_req_set_callback(subreq
, rpccli_PNP_Connect_done
, req
);
190 static void rpccli_PNP_Connect_done(struct tevent_req
*subreq
)
192 struct tevent_req
*req
= tevent_req_callback_data(
193 subreq
, struct tevent_req
);
194 struct rpccli_PNP_Connect_state
*state
= tevent_req_data(
195 req
, struct rpccli_PNP_Connect_state
);
199 if (state
->out_mem_ctx
) {
200 mem_ctx
= state
->out_mem_ctx
;
205 status
= state
->dispatch_recv(subreq
, mem_ctx
);
207 if (!NT_STATUS_IS_OK(status
)) {
208 tevent_req_nterror(req
, status
);
212 /* Copy out parameters */
215 state
->orig
.out
.result
= state
->tmp
.out
.result
;
217 /* Reset temporary structure */
218 ZERO_STRUCT(state
->tmp
);
220 tevent_req_done(req
);
223 NTSTATUS
rpccli_PNP_Connect_recv(struct tevent_req
*req
,
227 struct rpccli_PNP_Connect_state
*state
= tevent_req_data(
228 req
, struct rpccli_PNP_Connect_state
);
231 if (tevent_req_is_nterror(req
, &status
)) {
232 tevent_req_received(req
);
236 /* Steal possbile out parameters to the callers context */
237 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
240 *result
= state
->orig
.out
.result
;
242 tevent_req_received(req
);
246 NTSTATUS
rpccli_PNP_Connect(struct rpc_pipe_client
*cli
,
250 struct PNP_Connect r
;
255 status
= cli
->dispatch(cli
,
261 if (!NT_STATUS_IS_OK(status
)) {
265 if (NT_STATUS_IS_ERR(status
)) {
269 /* Return variables */
273 *werror
= r
.out
.result
;
276 return werror_to_ntstatus(r
.out
.result
);
279 struct rpccli_PNP_GetVersion_state
{
280 struct PNP_GetVersion orig
;
281 struct PNP_GetVersion tmp
;
282 TALLOC_CTX
*out_mem_ctx
;
283 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
286 static void rpccli_PNP_GetVersion_done(struct tevent_req
*subreq
);
288 struct tevent_req
*rpccli_PNP_GetVersion_send(TALLOC_CTX
*mem_ctx
,
289 struct tevent_context
*ev
,
290 struct rpc_pipe_client
*cli
,
291 uint16_t *_version
/* [out] [ref] */)
293 struct tevent_req
*req
;
294 struct rpccli_PNP_GetVersion_state
*state
;
295 struct tevent_req
*subreq
;
297 req
= tevent_req_create(mem_ctx
, &state
,
298 struct rpccli_PNP_GetVersion_state
);
302 state
->out_mem_ctx
= NULL
;
303 state
->dispatch_recv
= cli
->dispatch_recv
;
308 state
->orig
.out
.version
= _version
;
311 ZERO_STRUCT(state
->orig
.out
.result
);
313 state
->out_mem_ctx
= talloc_named_const(state
, 0,
314 "rpccli_PNP_GetVersion_out_memory");
315 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
316 return tevent_req_post(req
, ev
);
319 /* make a temporary copy, that we pass to the dispatch function */
320 state
->tmp
= state
->orig
;
322 subreq
= cli
->dispatch_send(state
, ev
, cli
,
326 if (tevent_req_nomem(subreq
, req
)) {
327 return tevent_req_post(req
, ev
);
329 tevent_req_set_callback(subreq
, rpccli_PNP_GetVersion_done
, req
);
333 static void rpccli_PNP_GetVersion_done(struct tevent_req
*subreq
)
335 struct tevent_req
*req
= tevent_req_callback_data(
336 subreq
, struct tevent_req
);
337 struct rpccli_PNP_GetVersion_state
*state
= tevent_req_data(
338 req
, struct rpccli_PNP_GetVersion_state
);
342 if (state
->out_mem_ctx
) {
343 mem_ctx
= state
->out_mem_ctx
;
348 status
= state
->dispatch_recv(subreq
, mem_ctx
);
350 if (!NT_STATUS_IS_OK(status
)) {
351 tevent_req_nterror(req
, status
);
355 /* Copy out parameters */
356 *state
->orig
.out
.version
= *state
->tmp
.out
.version
;
359 state
->orig
.out
.result
= state
->tmp
.out
.result
;
361 /* Reset temporary structure */
362 ZERO_STRUCT(state
->tmp
);
364 tevent_req_done(req
);
367 NTSTATUS
rpccli_PNP_GetVersion_recv(struct tevent_req
*req
,
371 struct rpccli_PNP_GetVersion_state
*state
= tevent_req_data(
372 req
, struct rpccli_PNP_GetVersion_state
);
375 if (tevent_req_is_nterror(req
, &status
)) {
376 tevent_req_received(req
);
380 /* Steal possbile out parameters to the callers context */
381 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
384 *result
= state
->orig
.out
.result
;
386 tevent_req_received(req
);
390 NTSTATUS
rpccli_PNP_GetVersion(struct rpc_pipe_client
*cli
,
392 uint16_t *version
/* [out] [ref] */,
395 struct PNP_GetVersion r
;
400 status
= cli
->dispatch(cli
,
406 if (!NT_STATUS_IS_OK(status
)) {
410 if (NT_STATUS_IS_ERR(status
)) {
414 /* Return variables */
415 *version
= *r
.out
.version
;
419 *werror
= r
.out
.result
;
422 return werror_to_ntstatus(r
.out
.result
);
425 struct rpccli_PNP_GetGlobalState_state
{
426 struct PNP_GetGlobalState orig
;
427 struct PNP_GetGlobalState tmp
;
428 TALLOC_CTX
*out_mem_ctx
;
429 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
432 static void rpccli_PNP_GetGlobalState_done(struct tevent_req
*subreq
);
434 struct tevent_req
*rpccli_PNP_GetGlobalState_send(TALLOC_CTX
*mem_ctx
,
435 struct tevent_context
*ev
,
436 struct rpc_pipe_client
*cli
)
438 struct tevent_req
*req
;
439 struct rpccli_PNP_GetGlobalState_state
*state
;
440 struct tevent_req
*subreq
;
442 req
= tevent_req_create(mem_ctx
, &state
,
443 struct rpccli_PNP_GetGlobalState_state
);
447 state
->out_mem_ctx
= NULL
;
448 state
->dispatch_recv
= cli
->dispatch_recv
;
455 ZERO_STRUCT(state
->orig
.out
.result
);
457 /* make a temporary copy, that we pass to the dispatch function */
458 state
->tmp
= state
->orig
;
460 subreq
= cli
->dispatch_send(state
, ev
, cli
,
462 NDR_PNP_GETGLOBALSTATE
,
464 if (tevent_req_nomem(subreq
, req
)) {
465 return tevent_req_post(req
, ev
);
467 tevent_req_set_callback(subreq
, rpccli_PNP_GetGlobalState_done
, req
);
471 static void rpccli_PNP_GetGlobalState_done(struct tevent_req
*subreq
)
473 struct tevent_req
*req
= tevent_req_callback_data(
474 subreq
, struct tevent_req
);
475 struct rpccli_PNP_GetGlobalState_state
*state
= tevent_req_data(
476 req
, struct rpccli_PNP_GetGlobalState_state
);
480 if (state
->out_mem_ctx
) {
481 mem_ctx
= state
->out_mem_ctx
;
486 status
= state
->dispatch_recv(subreq
, mem_ctx
);
488 if (!NT_STATUS_IS_OK(status
)) {
489 tevent_req_nterror(req
, status
);
493 /* Copy out parameters */
496 state
->orig
.out
.result
= state
->tmp
.out
.result
;
498 /* Reset temporary structure */
499 ZERO_STRUCT(state
->tmp
);
501 tevent_req_done(req
);
504 NTSTATUS
rpccli_PNP_GetGlobalState_recv(struct tevent_req
*req
,
508 struct rpccli_PNP_GetGlobalState_state
*state
= tevent_req_data(
509 req
, struct rpccli_PNP_GetGlobalState_state
);
512 if (tevent_req_is_nterror(req
, &status
)) {
513 tevent_req_received(req
);
517 /* Steal possbile out parameters to the callers context */
518 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
521 *result
= state
->orig
.out
.result
;
523 tevent_req_received(req
);
527 NTSTATUS
rpccli_PNP_GetGlobalState(struct rpc_pipe_client
*cli
,
531 struct PNP_GetGlobalState r
;
536 status
= cli
->dispatch(cli
,
539 NDR_PNP_GETGLOBALSTATE
,
542 if (!NT_STATUS_IS_OK(status
)) {
546 if (NT_STATUS_IS_ERR(status
)) {
550 /* Return variables */
554 *werror
= r
.out
.result
;
557 return werror_to_ntstatus(r
.out
.result
);
560 struct rpccli_PNP_InitDetection_state
{
561 struct PNP_InitDetection orig
;
562 struct PNP_InitDetection tmp
;
563 TALLOC_CTX
*out_mem_ctx
;
564 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
567 static void rpccli_PNP_InitDetection_done(struct tevent_req
*subreq
);
569 struct tevent_req
*rpccli_PNP_InitDetection_send(TALLOC_CTX
*mem_ctx
,
570 struct tevent_context
*ev
,
571 struct rpc_pipe_client
*cli
)
573 struct tevent_req
*req
;
574 struct rpccli_PNP_InitDetection_state
*state
;
575 struct tevent_req
*subreq
;
577 req
= tevent_req_create(mem_ctx
, &state
,
578 struct rpccli_PNP_InitDetection_state
);
582 state
->out_mem_ctx
= NULL
;
583 state
->dispatch_recv
= cli
->dispatch_recv
;
590 ZERO_STRUCT(state
->orig
.out
.result
);
592 /* make a temporary copy, that we pass to the dispatch function */
593 state
->tmp
= state
->orig
;
595 subreq
= cli
->dispatch_send(state
, ev
, cli
,
597 NDR_PNP_INITDETECTION
,
599 if (tevent_req_nomem(subreq
, req
)) {
600 return tevent_req_post(req
, ev
);
602 tevent_req_set_callback(subreq
, rpccli_PNP_InitDetection_done
, req
);
606 static void rpccli_PNP_InitDetection_done(struct tevent_req
*subreq
)
608 struct tevent_req
*req
= tevent_req_callback_data(
609 subreq
, struct tevent_req
);
610 struct rpccli_PNP_InitDetection_state
*state
= tevent_req_data(
611 req
, struct rpccli_PNP_InitDetection_state
);
615 if (state
->out_mem_ctx
) {
616 mem_ctx
= state
->out_mem_ctx
;
621 status
= state
->dispatch_recv(subreq
, mem_ctx
);
623 if (!NT_STATUS_IS_OK(status
)) {
624 tevent_req_nterror(req
, status
);
628 /* Copy out parameters */
631 state
->orig
.out
.result
= state
->tmp
.out
.result
;
633 /* Reset temporary structure */
634 ZERO_STRUCT(state
->tmp
);
636 tevent_req_done(req
);
639 NTSTATUS
rpccli_PNP_InitDetection_recv(struct tevent_req
*req
,
643 struct rpccli_PNP_InitDetection_state
*state
= tevent_req_data(
644 req
, struct rpccli_PNP_InitDetection_state
);
647 if (tevent_req_is_nterror(req
, &status
)) {
648 tevent_req_received(req
);
652 /* Steal possbile out parameters to the callers context */
653 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
656 *result
= state
->orig
.out
.result
;
658 tevent_req_received(req
);
662 NTSTATUS
rpccli_PNP_InitDetection(struct rpc_pipe_client
*cli
,
666 struct PNP_InitDetection r
;
671 status
= cli
->dispatch(cli
,
674 NDR_PNP_INITDETECTION
,
677 if (!NT_STATUS_IS_OK(status
)) {
681 if (NT_STATUS_IS_ERR(status
)) {
685 /* Return variables */
689 *werror
= r
.out
.result
;
692 return werror_to_ntstatus(r
.out
.result
);
695 struct rpccli_PNP_ReportLogOn_state
{
696 struct PNP_ReportLogOn orig
;
697 struct PNP_ReportLogOn tmp
;
698 TALLOC_CTX
*out_mem_ctx
;
699 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
702 static void rpccli_PNP_ReportLogOn_done(struct tevent_req
*subreq
);
704 struct tevent_req
*rpccli_PNP_ReportLogOn_send(TALLOC_CTX
*mem_ctx
,
705 struct tevent_context
*ev
,
706 struct rpc_pipe_client
*cli
)
708 struct tevent_req
*req
;
709 struct rpccli_PNP_ReportLogOn_state
*state
;
710 struct tevent_req
*subreq
;
712 req
= tevent_req_create(mem_ctx
, &state
,
713 struct rpccli_PNP_ReportLogOn_state
);
717 state
->out_mem_ctx
= NULL
;
718 state
->dispatch_recv
= cli
->dispatch_recv
;
725 ZERO_STRUCT(state
->orig
.out
.result
);
727 /* make a temporary copy, that we pass to the dispatch function */
728 state
->tmp
= state
->orig
;
730 subreq
= cli
->dispatch_send(state
, ev
, cli
,
734 if (tevent_req_nomem(subreq
, req
)) {
735 return tevent_req_post(req
, ev
);
737 tevent_req_set_callback(subreq
, rpccli_PNP_ReportLogOn_done
, req
);
741 static void rpccli_PNP_ReportLogOn_done(struct tevent_req
*subreq
)
743 struct tevent_req
*req
= tevent_req_callback_data(
744 subreq
, struct tevent_req
);
745 struct rpccli_PNP_ReportLogOn_state
*state
= tevent_req_data(
746 req
, struct rpccli_PNP_ReportLogOn_state
);
750 if (state
->out_mem_ctx
) {
751 mem_ctx
= state
->out_mem_ctx
;
756 status
= state
->dispatch_recv(subreq
, mem_ctx
);
758 if (!NT_STATUS_IS_OK(status
)) {
759 tevent_req_nterror(req
, status
);
763 /* Copy out parameters */
766 state
->orig
.out
.result
= state
->tmp
.out
.result
;
768 /* Reset temporary structure */
769 ZERO_STRUCT(state
->tmp
);
771 tevent_req_done(req
);
774 NTSTATUS
rpccli_PNP_ReportLogOn_recv(struct tevent_req
*req
,
778 struct rpccli_PNP_ReportLogOn_state
*state
= tevent_req_data(
779 req
, struct rpccli_PNP_ReportLogOn_state
);
782 if (tevent_req_is_nterror(req
, &status
)) {
783 tevent_req_received(req
);
787 /* Steal possbile out parameters to the callers context */
788 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
791 *result
= state
->orig
.out
.result
;
793 tevent_req_received(req
);
797 NTSTATUS
rpccli_PNP_ReportLogOn(struct rpc_pipe_client
*cli
,
801 struct PNP_ReportLogOn r
;
806 status
= cli
->dispatch(cli
,
812 if (!NT_STATUS_IS_OK(status
)) {
816 if (NT_STATUS_IS_ERR(status
)) {
820 /* Return variables */
824 *werror
= r
.out
.result
;
827 return werror_to_ntstatus(r
.out
.result
);
830 struct rpccli_PNP_ValidateDeviceInstance_state
{
831 struct PNP_ValidateDeviceInstance orig
;
832 struct PNP_ValidateDeviceInstance tmp
;
833 TALLOC_CTX
*out_mem_ctx
;
834 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
837 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req
*subreq
);
839 struct tevent_req
*rpccli_PNP_ValidateDeviceInstance_send(TALLOC_CTX
*mem_ctx
,
840 struct tevent_context
*ev
,
841 struct rpc_pipe_client
*cli
,
842 const char *_devicepath
/* [in] [ref,charset(UTF16)] */,
843 uint32_t _flags
/* [in] */)
845 struct tevent_req
*req
;
846 struct rpccli_PNP_ValidateDeviceInstance_state
*state
;
847 struct tevent_req
*subreq
;
849 req
= tevent_req_create(mem_ctx
, &state
,
850 struct rpccli_PNP_ValidateDeviceInstance_state
);
854 state
->out_mem_ctx
= NULL
;
855 state
->dispatch_recv
= cli
->dispatch_recv
;
858 state
->orig
.in
.devicepath
= _devicepath
;
859 state
->orig
.in
.flags
= _flags
;
864 ZERO_STRUCT(state
->orig
.out
.result
);
866 /* make a temporary copy, that we pass to the dispatch function */
867 state
->tmp
= state
->orig
;
869 subreq
= cli
->dispatch_send(state
, ev
, cli
,
871 NDR_PNP_VALIDATEDEVICEINSTANCE
,
873 if (tevent_req_nomem(subreq
, req
)) {
874 return tevent_req_post(req
, ev
);
876 tevent_req_set_callback(subreq
, rpccli_PNP_ValidateDeviceInstance_done
, req
);
880 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req
*subreq
)
882 struct tevent_req
*req
= tevent_req_callback_data(
883 subreq
, struct tevent_req
);
884 struct rpccli_PNP_ValidateDeviceInstance_state
*state
= tevent_req_data(
885 req
, struct rpccli_PNP_ValidateDeviceInstance_state
);
889 if (state
->out_mem_ctx
) {
890 mem_ctx
= state
->out_mem_ctx
;
895 status
= state
->dispatch_recv(subreq
, mem_ctx
);
897 if (!NT_STATUS_IS_OK(status
)) {
898 tevent_req_nterror(req
, status
);
902 /* Copy out parameters */
905 state
->orig
.out
.result
= state
->tmp
.out
.result
;
907 /* Reset temporary structure */
908 ZERO_STRUCT(state
->tmp
);
910 tevent_req_done(req
);
913 NTSTATUS
rpccli_PNP_ValidateDeviceInstance_recv(struct tevent_req
*req
,
917 struct rpccli_PNP_ValidateDeviceInstance_state
*state
= tevent_req_data(
918 req
, struct rpccli_PNP_ValidateDeviceInstance_state
);
921 if (tevent_req_is_nterror(req
, &status
)) {
922 tevent_req_received(req
);
926 /* Steal possbile out parameters to the callers context */
927 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
930 *result
= state
->orig
.out
.result
;
932 tevent_req_received(req
);
936 NTSTATUS
rpccli_PNP_ValidateDeviceInstance(struct rpc_pipe_client
*cli
,
938 const char *devicepath
/* [in] [ref,charset(UTF16)] */,
939 uint32_t flags
/* [in] */,
942 struct PNP_ValidateDeviceInstance r
;
946 r
.in
.devicepath
= devicepath
;
949 status
= cli
->dispatch(cli
,
952 NDR_PNP_VALIDATEDEVICEINSTANCE
,
955 if (!NT_STATUS_IS_OK(status
)) {
959 if (NT_STATUS_IS_ERR(status
)) {
963 /* Return variables */
967 *werror
= r
.out
.result
;
970 return werror_to_ntstatus(r
.out
.result
);
973 struct rpccli_PNP_GetRootDeviceInstance_state
{
974 struct PNP_GetRootDeviceInstance orig
;
975 struct PNP_GetRootDeviceInstance tmp
;
976 TALLOC_CTX
*out_mem_ctx
;
977 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
980 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req
*subreq
);
982 struct tevent_req
*rpccli_PNP_GetRootDeviceInstance_send(TALLOC_CTX
*mem_ctx
,
983 struct tevent_context
*ev
,
984 struct rpc_pipe_client
*cli
)
986 struct tevent_req
*req
;
987 struct rpccli_PNP_GetRootDeviceInstance_state
*state
;
988 struct tevent_req
*subreq
;
990 req
= tevent_req_create(mem_ctx
, &state
,
991 struct rpccli_PNP_GetRootDeviceInstance_state
);
995 state
->out_mem_ctx
= NULL
;
996 state
->dispatch_recv
= cli
->dispatch_recv
;
1000 /* Out parameters */
1003 ZERO_STRUCT(state
->orig
.out
.result
);
1005 /* make a temporary copy, that we pass to the dispatch function */
1006 state
->tmp
= state
->orig
;
1008 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1010 NDR_PNP_GETROOTDEVICEINSTANCE
,
1012 if (tevent_req_nomem(subreq
, req
)) {
1013 return tevent_req_post(req
, ev
);
1015 tevent_req_set_callback(subreq
, rpccli_PNP_GetRootDeviceInstance_done
, req
);
1019 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req
*subreq
)
1021 struct tevent_req
*req
= tevent_req_callback_data(
1022 subreq
, struct tevent_req
);
1023 struct rpccli_PNP_GetRootDeviceInstance_state
*state
= tevent_req_data(
1024 req
, struct rpccli_PNP_GetRootDeviceInstance_state
);
1026 TALLOC_CTX
*mem_ctx
;
1028 if (state
->out_mem_ctx
) {
1029 mem_ctx
= state
->out_mem_ctx
;
1034 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1035 TALLOC_FREE(subreq
);
1036 if (!NT_STATUS_IS_OK(status
)) {
1037 tevent_req_nterror(req
, status
);
1041 /* Copy out parameters */
1044 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1046 /* Reset temporary structure */
1047 ZERO_STRUCT(state
->tmp
);
1049 tevent_req_done(req
);
1052 NTSTATUS
rpccli_PNP_GetRootDeviceInstance_recv(struct tevent_req
*req
,
1053 TALLOC_CTX
*mem_ctx
,
1056 struct rpccli_PNP_GetRootDeviceInstance_state
*state
= tevent_req_data(
1057 req
, struct rpccli_PNP_GetRootDeviceInstance_state
);
1060 if (tevent_req_is_nterror(req
, &status
)) {
1061 tevent_req_received(req
);
1065 /* Steal possbile out parameters to the callers context */
1066 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1069 *result
= state
->orig
.out
.result
;
1071 tevent_req_received(req
);
1072 return NT_STATUS_OK
;
1075 NTSTATUS
rpccli_PNP_GetRootDeviceInstance(struct rpc_pipe_client
*cli
,
1076 TALLOC_CTX
*mem_ctx
,
1079 struct PNP_GetRootDeviceInstance r
;
1084 status
= cli
->dispatch(cli
,
1087 NDR_PNP_GETROOTDEVICEINSTANCE
,
1090 if (!NT_STATUS_IS_OK(status
)) {
1094 if (NT_STATUS_IS_ERR(status
)) {
1098 /* Return variables */
1102 *werror
= r
.out
.result
;
1105 return werror_to_ntstatus(r
.out
.result
);
1108 struct rpccli_PNP_GetRelatedDeviceInstance_state
{
1109 struct PNP_GetRelatedDeviceInstance orig
;
1110 struct PNP_GetRelatedDeviceInstance tmp
;
1111 TALLOC_CTX
*out_mem_ctx
;
1112 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1115 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req
*subreq
);
1117 struct tevent_req
*rpccli_PNP_GetRelatedDeviceInstance_send(TALLOC_CTX
*mem_ctx
,
1118 struct tevent_context
*ev
,
1119 struct rpc_pipe_client
*cli
)
1121 struct tevent_req
*req
;
1122 struct rpccli_PNP_GetRelatedDeviceInstance_state
*state
;
1123 struct tevent_req
*subreq
;
1125 req
= tevent_req_create(mem_ctx
, &state
,
1126 struct rpccli_PNP_GetRelatedDeviceInstance_state
);
1130 state
->out_mem_ctx
= NULL
;
1131 state
->dispatch_recv
= cli
->dispatch_recv
;
1135 /* Out parameters */
1138 ZERO_STRUCT(state
->orig
.out
.result
);
1140 /* make a temporary copy, that we pass to the dispatch function */
1141 state
->tmp
= state
->orig
;
1143 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1145 NDR_PNP_GETRELATEDDEVICEINSTANCE
,
1147 if (tevent_req_nomem(subreq
, req
)) {
1148 return tevent_req_post(req
, ev
);
1150 tevent_req_set_callback(subreq
, rpccli_PNP_GetRelatedDeviceInstance_done
, req
);
1154 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req
*subreq
)
1156 struct tevent_req
*req
= tevent_req_callback_data(
1157 subreq
, struct tevent_req
);
1158 struct rpccli_PNP_GetRelatedDeviceInstance_state
*state
= tevent_req_data(
1159 req
, struct rpccli_PNP_GetRelatedDeviceInstance_state
);
1161 TALLOC_CTX
*mem_ctx
;
1163 if (state
->out_mem_ctx
) {
1164 mem_ctx
= state
->out_mem_ctx
;
1169 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1170 TALLOC_FREE(subreq
);
1171 if (!NT_STATUS_IS_OK(status
)) {
1172 tevent_req_nterror(req
, status
);
1176 /* Copy out parameters */
1179 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1181 /* Reset temporary structure */
1182 ZERO_STRUCT(state
->tmp
);
1184 tevent_req_done(req
);
1187 NTSTATUS
rpccli_PNP_GetRelatedDeviceInstance_recv(struct tevent_req
*req
,
1188 TALLOC_CTX
*mem_ctx
,
1191 struct rpccli_PNP_GetRelatedDeviceInstance_state
*state
= tevent_req_data(
1192 req
, struct rpccli_PNP_GetRelatedDeviceInstance_state
);
1195 if (tevent_req_is_nterror(req
, &status
)) {
1196 tevent_req_received(req
);
1200 /* Steal possbile out parameters to the callers context */
1201 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1204 *result
= state
->orig
.out
.result
;
1206 tevent_req_received(req
);
1207 return NT_STATUS_OK
;
1210 NTSTATUS
rpccli_PNP_GetRelatedDeviceInstance(struct rpc_pipe_client
*cli
,
1211 TALLOC_CTX
*mem_ctx
,
1214 struct PNP_GetRelatedDeviceInstance r
;
1219 status
= cli
->dispatch(cli
,
1222 NDR_PNP_GETRELATEDDEVICEINSTANCE
,
1225 if (!NT_STATUS_IS_OK(status
)) {
1229 if (NT_STATUS_IS_ERR(status
)) {
1233 /* Return variables */
1237 *werror
= r
.out
.result
;
1240 return werror_to_ntstatus(r
.out
.result
);
1243 struct rpccli_PNP_EnumerateSubKeys_state
{
1244 struct PNP_EnumerateSubKeys orig
;
1245 struct PNP_EnumerateSubKeys tmp
;
1246 TALLOC_CTX
*out_mem_ctx
;
1247 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1250 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req
*subreq
);
1252 struct tevent_req
*rpccli_PNP_EnumerateSubKeys_send(TALLOC_CTX
*mem_ctx
,
1253 struct tevent_context
*ev
,
1254 struct rpc_pipe_client
*cli
)
1256 struct tevent_req
*req
;
1257 struct rpccli_PNP_EnumerateSubKeys_state
*state
;
1258 struct tevent_req
*subreq
;
1260 req
= tevent_req_create(mem_ctx
, &state
,
1261 struct rpccli_PNP_EnumerateSubKeys_state
);
1265 state
->out_mem_ctx
= NULL
;
1266 state
->dispatch_recv
= cli
->dispatch_recv
;
1270 /* Out parameters */
1273 ZERO_STRUCT(state
->orig
.out
.result
);
1275 /* make a temporary copy, that we pass to the dispatch function */
1276 state
->tmp
= state
->orig
;
1278 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1280 NDR_PNP_ENUMERATESUBKEYS
,
1282 if (tevent_req_nomem(subreq
, req
)) {
1283 return tevent_req_post(req
, ev
);
1285 tevent_req_set_callback(subreq
, rpccli_PNP_EnumerateSubKeys_done
, req
);
1289 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req
*subreq
)
1291 struct tevent_req
*req
= tevent_req_callback_data(
1292 subreq
, struct tevent_req
);
1293 struct rpccli_PNP_EnumerateSubKeys_state
*state
= tevent_req_data(
1294 req
, struct rpccli_PNP_EnumerateSubKeys_state
);
1296 TALLOC_CTX
*mem_ctx
;
1298 if (state
->out_mem_ctx
) {
1299 mem_ctx
= state
->out_mem_ctx
;
1304 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1305 TALLOC_FREE(subreq
);
1306 if (!NT_STATUS_IS_OK(status
)) {
1307 tevent_req_nterror(req
, status
);
1311 /* Copy out parameters */
1314 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1316 /* Reset temporary structure */
1317 ZERO_STRUCT(state
->tmp
);
1319 tevent_req_done(req
);
1322 NTSTATUS
rpccli_PNP_EnumerateSubKeys_recv(struct tevent_req
*req
,
1323 TALLOC_CTX
*mem_ctx
,
1326 struct rpccli_PNP_EnumerateSubKeys_state
*state
= tevent_req_data(
1327 req
, struct rpccli_PNP_EnumerateSubKeys_state
);
1330 if (tevent_req_is_nterror(req
, &status
)) {
1331 tevent_req_received(req
);
1335 /* Steal possbile out parameters to the callers context */
1336 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1339 *result
= state
->orig
.out
.result
;
1341 tevent_req_received(req
);
1342 return NT_STATUS_OK
;
1345 NTSTATUS
rpccli_PNP_EnumerateSubKeys(struct rpc_pipe_client
*cli
,
1346 TALLOC_CTX
*mem_ctx
,
1349 struct PNP_EnumerateSubKeys r
;
1354 status
= cli
->dispatch(cli
,
1357 NDR_PNP_ENUMERATESUBKEYS
,
1360 if (!NT_STATUS_IS_OK(status
)) {
1364 if (NT_STATUS_IS_ERR(status
)) {
1368 /* Return variables */
1372 *werror
= r
.out
.result
;
1375 return werror_to_ntstatus(r
.out
.result
);
1378 struct rpccli_PNP_GetDeviceList_state
{
1379 struct PNP_GetDeviceList orig
;
1380 struct PNP_GetDeviceList tmp
;
1381 TALLOC_CTX
*out_mem_ctx
;
1382 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1385 static void rpccli_PNP_GetDeviceList_done(struct tevent_req
*subreq
);
1387 struct tevent_req
*rpccli_PNP_GetDeviceList_send(TALLOC_CTX
*mem_ctx
,
1388 struct tevent_context
*ev
,
1389 struct rpc_pipe_client
*cli
,
1390 const char *_filter
/* [in] [unique,charset(UTF16)] */,
1391 uint16_t *_buffer
/* [out] [ref,length_is(*length),size_is(*length)] */,
1392 uint32_t *_length
/* [in,out] [ref] */,
1393 uint32_t _flags
/* [in] */)
1395 struct tevent_req
*req
;
1396 struct rpccli_PNP_GetDeviceList_state
*state
;
1397 struct tevent_req
*subreq
;
1399 req
= tevent_req_create(mem_ctx
, &state
,
1400 struct rpccli_PNP_GetDeviceList_state
);
1404 state
->out_mem_ctx
= NULL
;
1405 state
->dispatch_recv
= cli
->dispatch_recv
;
1408 state
->orig
.in
.filter
= _filter
;
1409 state
->orig
.in
.length
= _length
;
1410 state
->orig
.in
.flags
= _flags
;
1412 /* Out parameters */
1413 state
->orig
.out
.buffer
= _buffer
;
1414 state
->orig
.out
.length
= _length
;
1417 ZERO_STRUCT(state
->orig
.out
.result
);
1419 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1420 "rpccli_PNP_GetDeviceList_out_memory");
1421 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1422 return tevent_req_post(req
, ev
);
1425 /* make a temporary copy, that we pass to the dispatch function */
1426 state
->tmp
= state
->orig
;
1428 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1430 NDR_PNP_GETDEVICELIST
,
1432 if (tevent_req_nomem(subreq
, req
)) {
1433 return tevent_req_post(req
, ev
);
1435 tevent_req_set_callback(subreq
, rpccli_PNP_GetDeviceList_done
, req
);
1439 static void rpccli_PNP_GetDeviceList_done(struct tevent_req
*subreq
)
1441 struct tevent_req
*req
= tevent_req_callback_data(
1442 subreq
, struct tevent_req
);
1443 struct rpccli_PNP_GetDeviceList_state
*state
= tevent_req_data(
1444 req
, struct rpccli_PNP_GetDeviceList_state
);
1446 TALLOC_CTX
*mem_ctx
;
1448 if (state
->out_mem_ctx
) {
1449 mem_ctx
= state
->out_mem_ctx
;
1454 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1455 TALLOC_FREE(subreq
);
1456 if (!NT_STATUS_IS_OK(status
)) {
1457 tevent_req_nterror(req
, status
);
1461 /* Copy out parameters */
1462 memcpy(state
->orig
.out
.buffer
, state
->tmp
.out
.buffer
, *state
->tmp
.in
.length
* sizeof(*state
->orig
.out
.buffer
));
1463 *state
->orig
.out
.length
= *state
->tmp
.out
.length
;
1466 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1468 /* Reset temporary structure */
1469 ZERO_STRUCT(state
->tmp
);
1471 tevent_req_done(req
);
1474 NTSTATUS
rpccli_PNP_GetDeviceList_recv(struct tevent_req
*req
,
1475 TALLOC_CTX
*mem_ctx
,
1478 struct rpccli_PNP_GetDeviceList_state
*state
= tevent_req_data(
1479 req
, struct rpccli_PNP_GetDeviceList_state
);
1482 if (tevent_req_is_nterror(req
, &status
)) {
1483 tevent_req_received(req
);
1487 /* Steal possbile out parameters to the callers context */
1488 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1491 *result
= state
->orig
.out
.result
;
1493 tevent_req_received(req
);
1494 return NT_STATUS_OK
;
1497 NTSTATUS
rpccli_PNP_GetDeviceList(struct rpc_pipe_client
*cli
,
1498 TALLOC_CTX
*mem_ctx
,
1499 const char *filter
/* [in] [unique,charset(UTF16)] */,
1500 uint16_t *buffer
/* [out] [ref,length_is(*length),size_is(*length)] */,
1501 uint32_t *length
/* [in,out] [ref] */,
1502 uint32_t flags
/* [in] */,
1505 struct PNP_GetDeviceList r
;
1509 r
.in
.filter
= filter
;
1510 r
.in
.length
= length
;
1513 status
= cli
->dispatch(cli
,
1516 NDR_PNP_GETDEVICELIST
,
1519 if (!NT_STATUS_IS_OK(status
)) {
1523 if (NT_STATUS_IS_ERR(status
)) {
1527 /* Return variables */
1528 memcpy(buffer
, r
.out
.buffer
, *r
.in
.length
* sizeof(*buffer
));
1529 *length
= *r
.out
.length
;
1533 *werror
= r
.out
.result
;
1536 return werror_to_ntstatus(r
.out
.result
);
1539 struct rpccli_PNP_GetDeviceListSize_state
{
1540 struct PNP_GetDeviceListSize orig
;
1541 struct PNP_GetDeviceListSize tmp
;
1542 TALLOC_CTX
*out_mem_ctx
;
1543 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1546 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req
*subreq
);
1548 struct tevent_req
*rpccli_PNP_GetDeviceListSize_send(TALLOC_CTX
*mem_ctx
,
1549 struct tevent_context
*ev
,
1550 struct rpc_pipe_client
*cli
,
1551 const char *_devicename
/* [in] [unique,charset(UTF16)] */,
1552 uint32_t *_size
/* [out] [ref] */,
1553 uint32_t _flags
/* [in] */)
1555 struct tevent_req
*req
;
1556 struct rpccli_PNP_GetDeviceListSize_state
*state
;
1557 struct tevent_req
*subreq
;
1559 req
= tevent_req_create(mem_ctx
, &state
,
1560 struct rpccli_PNP_GetDeviceListSize_state
);
1564 state
->out_mem_ctx
= NULL
;
1565 state
->dispatch_recv
= cli
->dispatch_recv
;
1568 state
->orig
.in
.devicename
= _devicename
;
1569 state
->orig
.in
.flags
= _flags
;
1571 /* Out parameters */
1572 state
->orig
.out
.size
= _size
;
1575 ZERO_STRUCT(state
->orig
.out
.result
);
1577 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1578 "rpccli_PNP_GetDeviceListSize_out_memory");
1579 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1580 return tevent_req_post(req
, ev
);
1583 /* make a temporary copy, that we pass to the dispatch function */
1584 state
->tmp
= state
->orig
;
1586 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1588 NDR_PNP_GETDEVICELISTSIZE
,
1590 if (tevent_req_nomem(subreq
, req
)) {
1591 return tevent_req_post(req
, ev
);
1593 tevent_req_set_callback(subreq
, rpccli_PNP_GetDeviceListSize_done
, req
);
1597 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req
*subreq
)
1599 struct tevent_req
*req
= tevent_req_callback_data(
1600 subreq
, struct tevent_req
);
1601 struct rpccli_PNP_GetDeviceListSize_state
*state
= tevent_req_data(
1602 req
, struct rpccli_PNP_GetDeviceListSize_state
);
1604 TALLOC_CTX
*mem_ctx
;
1606 if (state
->out_mem_ctx
) {
1607 mem_ctx
= state
->out_mem_ctx
;
1612 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1613 TALLOC_FREE(subreq
);
1614 if (!NT_STATUS_IS_OK(status
)) {
1615 tevent_req_nterror(req
, status
);
1619 /* Copy out parameters */
1620 *state
->orig
.out
.size
= *state
->tmp
.out
.size
;
1623 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1625 /* Reset temporary structure */
1626 ZERO_STRUCT(state
->tmp
);
1628 tevent_req_done(req
);
1631 NTSTATUS
rpccli_PNP_GetDeviceListSize_recv(struct tevent_req
*req
,
1632 TALLOC_CTX
*mem_ctx
,
1635 struct rpccli_PNP_GetDeviceListSize_state
*state
= tevent_req_data(
1636 req
, struct rpccli_PNP_GetDeviceListSize_state
);
1639 if (tevent_req_is_nterror(req
, &status
)) {
1640 tevent_req_received(req
);
1644 /* Steal possbile out parameters to the callers context */
1645 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1648 *result
= state
->orig
.out
.result
;
1650 tevent_req_received(req
);
1651 return NT_STATUS_OK
;
1654 NTSTATUS
rpccli_PNP_GetDeviceListSize(struct rpc_pipe_client
*cli
,
1655 TALLOC_CTX
*mem_ctx
,
1656 const char *devicename
/* [in] [unique,charset(UTF16)] */,
1657 uint32_t *size
/* [out] [ref] */,
1658 uint32_t flags
/* [in] */,
1661 struct PNP_GetDeviceListSize r
;
1665 r
.in
.devicename
= devicename
;
1668 status
= cli
->dispatch(cli
,
1671 NDR_PNP_GETDEVICELISTSIZE
,
1674 if (!NT_STATUS_IS_OK(status
)) {
1678 if (NT_STATUS_IS_ERR(status
)) {
1682 /* Return variables */
1683 *size
= *r
.out
.size
;
1687 *werror
= r
.out
.result
;
1690 return werror_to_ntstatus(r
.out
.result
);
1693 struct rpccli_PNP_GetDepth_state
{
1694 struct PNP_GetDepth orig
;
1695 struct PNP_GetDepth tmp
;
1696 TALLOC_CTX
*out_mem_ctx
;
1697 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1700 static void rpccli_PNP_GetDepth_done(struct tevent_req
*subreq
);
1702 struct tevent_req
*rpccli_PNP_GetDepth_send(TALLOC_CTX
*mem_ctx
,
1703 struct tevent_context
*ev
,
1704 struct rpc_pipe_client
*cli
)
1706 struct tevent_req
*req
;
1707 struct rpccli_PNP_GetDepth_state
*state
;
1708 struct tevent_req
*subreq
;
1710 req
= tevent_req_create(mem_ctx
, &state
,
1711 struct rpccli_PNP_GetDepth_state
);
1715 state
->out_mem_ctx
= NULL
;
1716 state
->dispatch_recv
= cli
->dispatch_recv
;
1720 /* Out parameters */
1723 ZERO_STRUCT(state
->orig
.out
.result
);
1725 /* make a temporary copy, that we pass to the dispatch function */
1726 state
->tmp
= state
->orig
;
1728 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1732 if (tevent_req_nomem(subreq
, req
)) {
1733 return tevent_req_post(req
, ev
);
1735 tevent_req_set_callback(subreq
, rpccli_PNP_GetDepth_done
, req
);
1739 static void rpccli_PNP_GetDepth_done(struct tevent_req
*subreq
)
1741 struct tevent_req
*req
= tevent_req_callback_data(
1742 subreq
, struct tevent_req
);
1743 struct rpccli_PNP_GetDepth_state
*state
= tevent_req_data(
1744 req
, struct rpccli_PNP_GetDepth_state
);
1746 TALLOC_CTX
*mem_ctx
;
1748 if (state
->out_mem_ctx
) {
1749 mem_ctx
= state
->out_mem_ctx
;
1754 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1755 TALLOC_FREE(subreq
);
1756 if (!NT_STATUS_IS_OK(status
)) {
1757 tevent_req_nterror(req
, status
);
1761 /* Copy out parameters */
1764 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1766 /* Reset temporary structure */
1767 ZERO_STRUCT(state
->tmp
);
1769 tevent_req_done(req
);
1772 NTSTATUS
rpccli_PNP_GetDepth_recv(struct tevent_req
*req
,
1773 TALLOC_CTX
*mem_ctx
,
1776 struct rpccli_PNP_GetDepth_state
*state
= tevent_req_data(
1777 req
, struct rpccli_PNP_GetDepth_state
);
1780 if (tevent_req_is_nterror(req
, &status
)) {
1781 tevent_req_received(req
);
1785 /* Steal possbile out parameters to the callers context */
1786 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1789 *result
= state
->orig
.out
.result
;
1791 tevent_req_received(req
);
1792 return NT_STATUS_OK
;
1795 NTSTATUS
rpccli_PNP_GetDepth(struct rpc_pipe_client
*cli
,
1796 TALLOC_CTX
*mem_ctx
,
1799 struct PNP_GetDepth r
;
1804 status
= cli
->dispatch(cli
,
1810 if (!NT_STATUS_IS_OK(status
)) {
1814 if (NT_STATUS_IS_ERR(status
)) {
1818 /* Return variables */
1822 *werror
= r
.out
.result
;
1825 return werror_to_ntstatus(r
.out
.result
);
1828 struct rpccli_PNP_GetDeviceRegProp_state
{
1829 struct PNP_GetDeviceRegProp orig
;
1830 struct PNP_GetDeviceRegProp tmp
;
1831 TALLOC_CTX
*out_mem_ctx
;
1832 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
1835 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req
*subreq
);
1837 struct tevent_req
*rpccli_PNP_GetDeviceRegProp_send(TALLOC_CTX
*mem_ctx
,
1838 struct tevent_context
*ev
,
1839 struct rpc_pipe_client
*cli
,
1840 const char *_devicepath
/* [in] [ref,charset(UTF16)] */,
1841 uint32_t _property
/* [in] */,
1842 enum winreg_Type
*_reg_data_type
/* [in,out] [ref] */,
1843 uint8_t *_buffer
/* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,
1844 uint32_t *_buffer_size
/* [in,out] [ref] */,
1845 uint32_t *_needed
/* [in,out] [ref] */,
1846 uint32_t _flags
/* [in] */)
1848 struct tevent_req
*req
;
1849 struct rpccli_PNP_GetDeviceRegProp_state
*state
;
1850 struct tevent_req
*subreq
;
1852 req
= tevent_req_create(mem_ctx
, &state
,
1853 struct rpccli_PNP_GetDeviceRegProp_state
);
1857 state
->out_mem_ctx
= NULL
;
1858 state
->dispatch_recv
= cli
->dispatch_recv
;
1861 state
->orig
.in
.devicepath
= _devicepath
;
1862 state
->orig
.in
.property
= _property
;
1863 state
->orig
.in
.reg_data_type
= _reg_data_type
;
1864 state
->orig
.in
.buffer_size
= _buffer_size
;
1865 state
->orig
.in
.needed
= _needed
;
1866 state
->orig
.in
.flags
= _flags
;
1868 /* Out parameters */
1869 state
->orig
.out
.reg_data_type
= _reg_data_type
;
1870 state
->orig
.out
.buffer
= _buffer
;
1871 state
->orig
.out
.buffer_size
= _buffer_size
;
1872 state
->orig
.out
.needed
= _needed
;
1875 ZERO_STRUCT(state
->orig
.out
.result
);
1877 state
->out_mem_ctx
= talloc_named_const(state
, 0,
1878 "rpccli_PNP_GetDeviceRegProp_out_memory");
1879 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
1880 return tevent_req_post(req
, ev
);
1883 /* make a temporary copy, that we pass to the dispatch function */
1884 state
->tmp
= state
->orig
;
1886 subreq
= cli
->dispatch_send(state
, ev
, cli
,
1888 NDR_PNP_GETDEVICEREGPROP
,
1890 if (tevent_req_nomem(subreq
, req
)) {
1891 return tevent_req_post(req
, ev
);
1893 tevent_req_set_callback(subreq
, rpccli_PNP_GetDeviceRegProp_done
, req
);
1897 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req
*subreq
)
1899 struct tevent_req
*req
= tevent_req_callback_data(
1900 subreq
, struct tevent_req
);
1901 struct rpccli_PNP_GetDeviceRegProp_state
*state
= tevent_req_data(
1902 req
, struct rpccli_PNP_GetDeviceRegProp_state
);
1904 TALLOC_CTX
*mem_ctx
;
1906 if (state
->out_mem_ctx
) {
1907 mem_ctx
= state
->out_mem_ctx
;
1912 status
= state
->dispatch_recv(subreq
, mem_ctx
);
1913 TALLOC_FREE(subreq
);
1914 if (!NT_STATUS_IS_OK(status
)) {
1915 tevent_req_nterror(req
, status
);
1919 /* Copy out parameters */
1920 *state
->orig
.out
.reg_data_type
= *state
->tmp
.out
.reg_data_type
;
1921 memcpy(state
->orig
.out
.buffer
, state
->tmp
.out
.buffer
, *state
->tmp
.in
.buffer_size
* sizeof(*state
->orig
.out
.buffer
));
1922 *state
->orig
.out
.buffer_size
= *state
->tmp
.out
.buffer_size
;
1923 *state
->orig
.out
.needed
= *state
->tmp
.out
.needed
;
1926 state
->orig
.out
.result
= state
->tmp
.out
.result
;
1928 /* Reset temporary structure */
1929 ZERO_STRUCT(state
->tmp
);
1931 tevent_req_done(req
);
1934 NTSTATUS
rpccli_PNP_GetDeviceRegProp_recv(struct tevent_req
*req
,
1935 TALLOC_CTX
*mem_ctx
,
1938 struct rpccli_PNP_GetDeviceRegProp_state
*state
= tevent_req_data(
1939 req
, struct rpccli_PNP_GetDeviceRegProp_state
);
1942 if (tevent_req_is_nterror(req
, &status
)) {
1943 tevent_req_received(req
);
1947 /* Steal possbile out parameters to the callers context */
1948 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
1951 *result
= state
->orig
.out
.result
;
1953 tevent_req_received(req
);
1954 return NT_STATUS_OK
;
1957 NTSTATUS
rpccli_PNP_GetDeviceRegProp(struct rpc_pipe_client
*cli
,
1958 TALLOC_CTX
*mem_ctx
,
1959 const char *devicepath
/* [in] [ref,charset(UTF16)] */,
1960 uint32_t property
/* [in] */,
1961 enum winreg_Type
*reg_data_type
/* [in,out] [ref] */,
1962 uint8_t *buffer
/* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,
1963 uint32_t *buffer_size
/* [in,out] [ref] */,
1964 uint32_t *needed
/* [in,out] [ref] */,
1965 uint32_t flags
/* [in] */,
1968 struct PNP_GetDeviceRegProp r
;
1972 r
.in
.devicepath
= devicepath
;
1973 r
.in
.property
= property
;
1974 r
.in
.reg_data_type
= reg_data_type
;
1975 r
.in
.buffer_size
= buffer_size
;
1976 r
.in
.needed
= needed
;
1979 status
= cli
->dispatch(cli
,
1982 NDR_PNP_GETDEVICEREGPROP
,
1985 if (!NT_STATUS_IS_OK(status
)) {
1989 if (NT_STATUS_IS_ERR(status
)) {
1993 /* Return variables */
1994 *reg_data_type
= *r
.out
.reg_data_type
;
1995 memcpy(buffer
, r
.out
.buffer
, *r
.in
.buffer_size
* sizeof(*buffer
));
1996 *buffer_size
= *r
.out
.buffer_size
;
1997 *needed
= *r
.out
.needed
;
2001 *werror
= r
.out
.result
;
2004 return werror_to_ntstatus(r
.out
.result
);
2007 struct rpccli_PNP_SetDeviceRegProp_state
{
2008 struct PNP_SetDeviceRegProp orig
;
2009 struct PNP_SetDeviceRegProp tmp
;
2010 TALLOC_CTX
*out_mem_ctx
;
2011 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2014 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req
*subreq
);
2016 struct tevent_req
*rpccli_PNP_SetDeviceRegProp_send(TALLOC_CTX
*mem_ctx
,
2017 struct tevent_context
*ev
,
2018 struct rpc_pipe_client
*cli
)
2020 struct tevent_req
*req
;
2021 struct rpccli_PNP_SetDeviceRegProp_state
*state
;
2022 struct tevent_req
*subreq
;
2024 req
= tevent_req_create(mem_ctx
, &state
,
2025 struct rpccli_PNP_SetDeviceRegProp_state
);
2029 state
->out_mem_ctx
= NULL
;
2030 state
->dispatch_recv
= cli
->dispatch_recv
;
2034 /* Out parameters */
2037 ZERO_STRUCT(state
->orig
.out
.result
);
2039 /* make a temporary copy, that we pass to the dispatch function */
2040 state
->tmp
= state
->orig
;
2042 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2044 NDR_PNP_SETDEVICEREGPROP
,
2046 if (tevent_req_nomem(subreq
, req
)) {
2047 return tevent_req_post(req
, ev
);
2049 tevent_req_set_callback(subreq
, rpccli_PNP_SetDeviceRegProp_done
, req
);
2053 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req
*subreq
)
2055 struct tevent_req
*req
= tevent_req_callback_data(
2056 subreq
, struct tevent_req
);
2057 struct rpccli_PNP_SetDeviceRegProp_state
*state
= tevent_req_data(
2058 req
, struct rpccli_PNP_SetDeviceRegProp_state
);
2060 TALLOC_CTX
*mem_ctx
;
2062 if (state
->out_mem_ctx
) {
2063 mem_ctx
= state
->out_mem_ctx
;
2068 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2069 TALLOC_FREE(subreq
);
2070 if (!NT_STATUS_IS_OK(status
)) {
2071 tevent_req_nterror(req
, status
);
2075 /* Copy out parameters */
2078 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2080 /* Reset temporary structure */
2081 ZERO_STRUCT(state
->tmp
);
2083 tevent_req_done(req
);
2086 NTSTATUS
rpccli_PNP_SetDeviceRegProp_recv(struct tevent_req
*req
,
2087 TALLOC_CTX
*mem_ctx
,
2090 struct rpccli_PNP_SetDeviceRegProp_state
*state
= tevent_req_data(
2091 req
, struct rpccli_PNP_SetDeviceRegProp_state
);
2094 if (tevent_req_is_nterror(req
, &status
)) {
2095 tevent_req_received(req
);
2099 /* Steal possbile out parameters to the callers context */
2100 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2103 *result
= state
->orig
.out
.result
;
2105 tevent_req_received(req
);
2106 return NT_STATUS_OK
;
2109 NTSTATUS
rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client
*cli
,
2110 TALLOC_CTX
*mem_ctx
,
2113 struct PNP_SetDeviceRegProp r
;
2118 status
= cli
->dispatch(cli
,
2121 NDR_PNP_SETDEVICEREGPROP
,
2124 if (!NT_STATUS_IS_OK(status
)) {
2128 if (NT_STATUS_IS_ERR(status
)) {
2132 /* Return variables */
2136 *werror
= r
.out
.result
;
2139 return werror_to_ntstatus(r
.out
.result
);
2142 struct rpccli_PNP_GetClassInstance_state
{
2143 struct PNP_GetClassInstance orig
;
2144 struct PNP_GetClassInstance tmp
;
2145 TALLOC_CTX
*out_mem_ctx
;
2146 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2149 static void rpccli_PNP_GetClassInstance_done(struct tevent_req
*subreq
);
2151 struct tevent_req
*rpccli_PNP_GetClassInstance_send(TALLOC_CTX
*mem_ctx
,
2152 struct tevent_context
*ev
,
2153 struct rpc_pipe_client
*cli
)
2155 struct tevent_req
*req
;
2156 struct rpccli_PNP_GetClassInstance_state
*state
;
2157 struct tevent_req
*subreq
;
2159 req
= tevent_req_create(mem_ctx
, &state
,
2160 struct rpccli_PNP_GetClassInstance_state
);
2164 state
->out_mem_ctx
= NULL
;
2165 state
->dispatch_recv
= cli
->dispatch_recv
;
2169 /* Out parameters */
2172 ZERO_STRUCT(state
->orig
.out
.result
);
2174 /* make a temporary copy, that we pass to the dispatch function */
2175 state
->tmp
= state
->orig
;
2177 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2179 NDR_PNP_GETCLASSINSTANCE
,
2181 if (tevent_req_nomem(subreq
, req
)) {
2182 return tevent_req_post(req
, ev
);
2184 tevent_req_set_callback(subreq
, rpccli_PNP_GetClassInstance_done
, req
);
2188 static void rpccli_PNP_GetClassInstance_done(struct tevent_req
*subreq
)
2190 struct tevent_req
*req
= tevent_req_callback_data(
2191 subreq
, struct tevent_req
);
2192 struct rpccli_PNP_GetClassInstance_state
*state
= tevent_req_data(
2193 req
, struct rpccli_PNP_GetClassInstance_state
);
2195 TALLOC_CTX
*mem_ctx
;
2197 if (state
->out_mem_ctx
) {
2198 mem_ctx
= state
->out_mem_ctx
;
2203 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2204 TALLOC_FREE(subreq
);
2205 if (!NT_STATUS_IS_OK(status
)) {
2206 tevent_req_nterror(req
, status
);
2210 /* Copy out parameters */
2213 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2215 /* Reset temporary structure */
2216 ZERO_STRUCT(state
->tmp
);
2218 tevent_req_done(req
);
2221 NTSTATUS
rpccli_PNP_GetClassInstance_recv(struct tevent_req
*req
,
2222 TALLOC_CTX
*mem_ctx
,
2225 struct rpccli_PNP_GetClassInstance_state
*state
= tevent_req_data(
2226 req
, struct rpccli_PNP_GetClassInstance_state
);
2229 if (tevent_req_is_nterror(req
, &status
)) {
2230 tevent_req_received(req
);
2234 /* Steal possbile out parameters to the callers context */
2235 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2238 *result
= state
->orig
.out
.result
;
2240 tevent_req_received(req
);
2241 return NT_STATUS_OK
;
2244 NTSTATUS
rpccli_PNP_GetClassInstance(struct rpc_pipe_client
*cli
,
2245 TALLOC_CTX
*mem_ctx
,
2248 struct PNP_GetClassInstance r
;
2253 status
= cli
->dispatch(cli
,
2256 NDR_PNP_GETCLASSINSTANCE
,
2259 if (!NT_STATUS_IS_OK(status
)) {
2263 if (NT_STATUS_IS_ERR(status
)) {
2267 /* Return variables */
2271 *werror
= r
.out
.result
;
2274 return werror_to_ntstatus(r
.out
.result
);
2277 struct rpccli_PNP_CreateKey_state
{
2278 struct PNP_CreateKey orig
;
2279 struct PNP_CreateKey tmp
;
2280 TALLOC_CTX
*out_mem_ctx
;
2281 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2284 static void rpccli_PNP_CreateKey_done(struct tevent_req
*subreq
);
2286 struct tevent_req
*rpccli_PNP_CreateKey_send(TALLOC_CTX
*mem_ctx
,
2287 struct tevent_context
*ev
,
2288 struct rpc_pipe_client
*cli
)
2290 struct tevent_req
*req
;
2291 struct rpccli_PNP_CreateKey_state
*state
;
2292 struct tevent_req
*subreq
;
2294 req
= tevent_req_create(mem_ctx
, &state
,
2295 struct rpccli_PNP_CreateKey_state
);
2299 state
->out_mem_ctx
= NULL
;
2300 state
->dispatch_recv
= cli
->dispatch_recv
;
2304 /* Out parameters */
2307 ZERO_STRUCT(state
->orig
.out
.result
);
2309 /* make a temporary copy, that we pass to the dispatch function */
2310 state
->tmp
= state
->orig
;
2312 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2316 if (tevent_req_nomem(subreq
, req
)) {
2317 return tevent_req_post(req
, ev
);
2319 tevent_req_set_callback(subreq
, rpccli_PNP_CreateKey_done
, req
);
2323 static void rpccli_PNP_CreateKey_done(struct tevent_req
*subreq
)
2325 struct tevent_req
*req
= tevent_req_callback_data(
2326 subreq
, struct tevent_req
);
2327 struct rpccli_PNP_CreateKey_state
*state
= tevent_req_data(
2328 req
, struct rpccli_PNP_CreateKey_state
);
2330 TALLOC_CTX
*mem_ctx
;
2332 if (state
->out_mem_ctx
) {
2333 mem_ctx
= state
->out_mem_ctx
;
2338 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2339 TALLOC_FREE(subreq
);
2340 if (!NT_STATUS_IS_OK(status
)) {
2341 tevent_req_nterror(req
, status
);
2345 /* Copy out parameters */
2348 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2350 /* Reset temporary structure */
2351 ZERO_STRUCT(state
->tmp
);
2353 tevent_req_done(req
);
2356 NTSTATUS
rpccli_PNP_CreateKey_recv(struct tevent_req
*req
,
2357 TALLOC_CTX
*mem_ctx
,
2360 struct rpccli_PNP_CreateKey_state
*state
= tevent_req_data(
2361 req
, struct rpccli_PNP_CreateKey_state
);
2364 if (tevent_req_is_nterror(req
, &status
)) {
2365 tevent_req_received(req
);
2369 /* Steal possbile out parameters to the callers context */
2370 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2373 *result
= state
->orig
.out
.result
;
2375 tevent_req_received(req
);
2376 return NT_STATUS_OK
;
2379 NTSTATUS
rpccli_PNP_CreateKey(struct rpc_pipe_client
*cli
,
2380 TALLOC_CTX
*mem_ctx
,
2383 struct PNP_CreateKey r
;
2388 status
= cli
->dispatch(cli
,
2394 if (!NT_STATUS_IS_OK(status
)) {
2398 if (NT_STATUS_IS_ERR(status
)) {
2402 /* Return variables */
2406 *werror
= r
.out
.result
;
2409 return werror_to_ntstatus(r
.out
.result
);
2412 struct rpccli_PNP_DeleteRegistryKey_state
{
2413 struct PNP_DeleteRegistryKey orig
;
2414 struct PNP_DeleteRegistryKey tmp
;
2415 TALLOC_CTX
*out_mem_ctx
;
2416 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2419 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req
*subreq
);
2421 struct tevent_req
*rpccli_PNP_DeleteRegistryKey_send(TALLOC_CTX
*mem_ctx
,
2422 struct tevent_context
*ev
,
2423 struct rpc_pipe_client
*cli
)
2425 struct tevent_req
*req
;
2426 struct rpccli_PNP_DeleteRegistryKey_state
*state
;
2427 struct tevent_req
*subreq
;
2429 req
= tevent_req_create(mem_ctx
, &state
,
2430 struct rpccli_PNP_DeleteRegistryKey_state
);
2434 state
->out_mem_ctx
= NULL
;
2435 state
->dispatch_recv
= cli
->dispatch_recv
;
2439 /* Out parameters */
2442 ZERO_STRUCT(state
->orig
.out
.result
);
2444 /* make a temporary copy, that we pass to the dispatch function */
2445 state
->tmp
= state
->orig
;
2447 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2449 NDR_PNP_DELETEREGISTRYKEY
,
2451 if (tevent_req_nomem(subreq
, req
)) {
2452 return tevent_req_post(req
, ev
);
2454 tevent_req_set_callback(subreq
, rpccli_PNP_DeleteRegistryKey_done
, req
);
2458 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req
*subreq
)
2460 struct tevent_req
*req
= tevent_req_callback_data(
2461 subreq
, struct tevent_req
);
2462 struct rpccli_PNP_DeleteRegistryKey_state
*state
= tevent_req_data(
2463 req
, struct rpccli_PNP_DeleteRegistryKey_state
);
2465 TALLOC_CTX
*mem_ctx
;
2467 if (state
->out_mem_ctx
) {
2468 mem_ctx
= state
->out_mem_ctx
;
2473 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2474 TALLOC_FREE(subreq
);
2475 if (!NT_STATUS_IS_OK(status
)) {
2476 tevent_req_nterror(req
, status
);
2480 /* Copy out parameters */
2483 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2485 /* Reset temporary structure */
2486 ZERO_STRUCT(state
->tmp
);
2488 tevent_req_done(req
);
2491 NTSTATUS
rpccli_PNP_DeleteRegistryKey_recv(struct tevent_req
*req
,
2492 TALLOC_CTX
*mem_ctx
,
2495 struct rpccli_PNP_DeleteRegistryKey_state
*state
= tevent_req_data(
2496 req
, struct rpccli_PNP_DeleteRegistryKey_state
);
2499 if (tevent_req_is_nterror(req
, &status
)) {
2500 tevent_req_received(req
);
2504 /* Steal possbile out parameters to the callers context */
2505 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2508 *result
= state
->orig
.out
.result
;
2510 tevent_req_received(req
);
2511 return NT_STATUS_OK
;
2514 NTSTATUS
rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client
*cli
,
2515 TALLOC_CTX
*mem_ctx
,
2518 struct PNP_DeleteRegistryKey r
;
2523 status
= cli
->dispatch(cli
,
2526 NDR_PNP_DELETEREGISTRYKEY
,
2529 if (!NT_STATUS_IS_OK(status
)) {
2533 if (NT_STATUS_IS_ERR(status
)) {
2537 /* Return variables */
2541 *werror
= r
.out
.result
;
2544 return werror_to_ntstatus(r
.out
.result
);
2547 struct rpccli_PNP_GetClassCount_state
{
2548 struct PNP_GetClassCount orig
;
2549 struct PNP_GetClassCount tmp
;
2550 TALLOC_CTX
*out_mem_ctx
;
2551 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2554 static void rpccli_PNP_GetClassCount_done(struct tevent_req
*subreq
);
2556 struct tevent_req
*rpccli_PNP_GetClassCount_send(TALLOC_CTX
*mem_ctx
,
2557 struct tevent_context
*ev
,
2558 struct rpc_pipe_client
*cli
)
2560 struct tevent_req
*req
;
2561 struct rpccli_PNP_GetClassCount_state
*state
;
2562 struct tevent_req
*subreq
;
2564 req
= tevent_req_create(mem_ctx
, &state
,
2565 struct rpccli_PNP_GetClassCount_state
);
2569 state
->out_mem_ctx
= NULL
;
2570 state
->dispatch_recv
= cli
->dispatch_recv
;
2574 /* Out parameters */
2577 ZERO_STRUCT(state
->orig
.out
.result
);
2579 /* make a temporary copy, that we pass to the dispatch function */
2580 state
->tmp
= state
->orig
;
2582 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2584 NDR_PNP_GETCLASSCOUNT
,
2586 if (tevent_req_nomem(subreq
, req
)) {
2587 return tevent_req_post(req
, ev
);
2589 tevent_req_set_callback(subreq
, rpccli_PNP_GetClassCount_done
, req
);
2593 static void rpccli_PNP_GetClassCount_done(struct tevent_req
*subreq
)
2595 struct tevent_req
*req
= tevent_req_callback_data(
2596 subreq
, struct tevent_req
);
2597 struct rpccli_PNP_GetClassCount_state
*state
= tevent_req_data(
2598 req
, struct rpccli_PNP_GetClassCount_state
);
2600 TALLOC_CTX
*mem_ctx
;
2602 if (state
->out_mem_ctx
) {
2603 mem_ctx
= state
->out_mem_ctx
;
2608 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2609 TALLOC_FREE(subreq
);
2610 if (!NT_STATUS_IS_OK(status
)) {
2611 tevent_req_nterror(req
, status
);
2615 /* Copy out parameters */
2618 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2620 /* Reset temporary structure */
2621 ZERO_STRUCT(state
->tmp
);
2623 tevent_req_done(req
);
2626 NTSTATUS
rpccli_PNP_GetClassCount_recv(struct tevent_req
*req
,
2627 TALLOC_CTX
*mem_ctx
,
2630 struct rpccli_PNP_GetClassCount_state
*state
= tevent_req_data(
2631 req
, struct rpccli_PNP_GetClassCount_state
);
2634 if (tevent_req_is_nterror(req
, &status
)) {
2635 tevent_req_received(req
);
2639 /* Steal possbile out parameters to the callers context */
2640 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2643 *result
= state
->orig
.out
.result
;
2645 tevent_req_received(req
);
2646 return NT_STATUS_OK
;
2649 NTSTATUS
rpccli_PNP_GetClassCount(struct rpc_pipe_client
*cli
,
2650 TALLOC_CTX
*mem_ctx
,
2653 struct PNP_GetClassCount r
;
2658 status
= cli
->dispatch(cli
,
2661 NDR_PNP_GETCLASSCOUNT
,
2664 if (!NT_STATUS_IS_OK(status
)) {
2668 if (NT_STATUS_IS_ERR(status
)) {
2672 /* Return variables */
2676 *werror
= r
.out
.result
;
2679 return werror_to_ntstatus(r
.out
.result
);
2682 struct rpccli_PNP_GetClassName_state
{
2683 struct PNP_GetClassName orig
;
2684 struct PNP_GetClassName tmp
;
2685 TALLOC_CTX
*out_mem_ctx
;
2686 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2689 static void rpccli_PNP_GetClassName_done(struct tevent_req
*subreq
);
2691 struct tevent_req
*rpccli_PNP_GetClassName_send(TALLOC_CTX
*mem_ctx
,
2692 struct tevent_context
*ev
,
2693 struct rpc_pipe_client
*cli
)
2695 struct tevent_req
*req
;
2696 struct rpccli_PNP_GetClassName_state
*state
;
2697 struct tevent_req
*subreq
;
2699 req
= tevent_req_create(mem_ctx
, &state
,
2700 struct rpccli_PNP_GetClassName_state
);
2704 state
->out_mem_ctx
= NULL
;
2705 state
->dispatch_recv
= cli
->dispatch_recv
;
2709 /* Out parameters */
2712 ZERO_STRUCT(state
->orig
.out
.result
);
2714 /* make a temporary copy, that we pass to the dispatch function */
2715 state
->tmp
= state
->orig
;
2717 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2719 NDR_PNP_GETCLASSNAME
,
2721 if (tevent_req_nomem(subreq
, req
)) {
2722 return tevent_req_post(req
, ev
);
2724 tevent_req_set_callback(subreq
, rpccli_PNP_GetClassName_done
, req
);
2728 static void rpccli_PNP_GetClassName_done(struct tevent_req
*subreq
)
2730 struct tevent_req
*req
= tevent_req_callback_data(
2731 subreq
, struct tevent_req
);
2732 struct rpccli_PNP_GetClassName_state
*state
= tevent_req_data(
2733 req
, struct rpccli_PNP_GetClassName_state
);
2735 TALLOC_CTX
*mem_ctx
;
2737 if (state
->out_mem_ctx
) {
2738 mem_ctx
= state
->out_mem_ctx
;
2743 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2744 TALLOC_FREE(subreq
);
2745 if (!NT_STATUS_IS_OK(status
)) {
2746 tevent_req_nterror(req
, status
);
2750 /* Copy out parameters */
2753 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2755 /* Reset temporary structure */
2756 ZERO_STRUCT(state
->tmp
);
2758 tevent_req_done(req
);
2761 NTSTATUS
rpccli_PNP_GetClassName_recv(struct tevent_req
*req
,
2762 TALLOC_CTX
*mem_ctx
,
2765 struct rpccli_PNP_GetClassName_state
*state
= tevent_req_data(
2766 req
, struct rpccli_PNP_GetClassName_state
);
2769 if (tevent_req_is_nterror(req
, &status
)) {
2770 tevent_req_received(req
);
2774 /* Steal possbile out parameters to the callers context */
2775 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2778 *result
= state
->orig
.out
.result
;
2780 tevent_req_received(req
);
2781 return NT_STATUS_OK
;
2784 NTSTATUS
rpccli_PNP_GetClassName(struct rpc_pipe_client
*cli
,
2785 TALLOC_CTX
*mem_ctx
,
2788 struct PNP_GetClassName r
;
2793 status
= cli
->dispatch(cli
,
2796 NDR_PNP_GETCLASSNAME
,
2799 if (!NT_STATUS_IS_OK(status
)) {
2803 if (NT_STATUS_IS_ERR(status
)) {
2807 /* Return variables */
2811 *werror
= r
.out
.result
;
2814 return werror_to_ntstatus(r
.out
.result
);
2817 struct rpccli_PNP_DeleteClassKey_state
{
2818 struct PNP_DeleteClassKey orig
;
2819 struct PNP_DeleteClassKey tmp
;
2820 TALLOC_CTX
*out_mem_ctx
;
2821 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2824 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req
*subreq
);
2826 struct tevent_req
*rpccli_PNP_DeleteClassKey_send(TALLOC_CTX
*mem_ctx
,
2827 struct tevent_context
*ev
,
2828 struct rpc_pipe_client
*cli
)
2830 struct tevent_req
*req
;
2831 struct rpccli_PNP_DeleteClassKey_state
*state
;
2832 struct tevent_req
*subreq
;
2834 req
= tevent_req_create(mem_ctx
, &state
,
2835 struct rpccli_PNP_DeleteClassKey_state
);
2839 state
->out_mem_ctx
= NULL
;
2840 state
->dispatch_recv
= cli
->dispatch_recv
;
2844 /* Out parameters */
2847 ZERO_STRUCT(state
->orig
.out
.result
);
2849 /* make a temporary copy, that we pass to the dispatch function */
2850 state
->tmp
= state
->orig
;
2852 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2854 NDR_PNP_DELETECLASSKEY
,
2856 if (tevent_req_nomem(subreq
, req
)) {
2857 return tevent_req_post(req
, ev
);
2859 tevent_req_set_callback(subreq
, rpccli_PNP_DeleteClassKey_done
, req
);
2863 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req
*subreq
)
2865 struct tevent_req
*req
= tevent_req_callback_data(
2866 subreq
, struct tevent_req
);
2867 struct rpccli_PNP_DeleteClassKey_state
*state
= tevent_req_data(
2868 req
, struct rpccli_PNP_DeleteClassKey_state
);
2870 TALLOC_CTX
*mem_ctx
;
2872 if (state
->out_mem_ctx
) {
2873 mem_ctx
= state
->out_mem_ctx
;
2878 status
= state
->dispatch_recv(subreq
, mem_ctx
);
2879 TALLOC_FREE(subreq
);
2880 if (!NT_STATUS_IS_OK(status
)) {
2881 tevent_req_nterror(req
, status
);
2885 /* Copy out parameters */
2888 state
->orig
.out
.result
= state
->tmp
.out
.result
;
2890 /* Reset temporary structure */
2891 ZERO_STRUCT(state
->tmp
);
2893 tevent_req_done(req
);
2896 NTSTATUS
rpccli_PNP_DeleteClassKey_recv(struct tevent_req
*req
,
2897 TALLOC_CTX
*mem_ctx
,
2900 struct rpccli_PNP_DeleteClassKey_state
*state
= tevent_req_data(
2901 req
, struct rpccli_PNP_DeleteClassKey_state
);
2904 if (tevent_req_is_nterror(req
, &status
)) {
2905 tevent_req_received(req
);
2909 /* Steal possbile out parameters to the callers context */
2910 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
2913 *result
= state
->orig
.out
.result
;
2915 tevent_req_received(req
);
2916 return NT_STATUS_OK
;
2919 NTSTATUS
rpccli_PNP_DeleteClassKey(struct rpc_pipe_client
*cli
,
2920 TALLOC_CTX
*mem_ctx
,
2923 struct PNP_DeleteClassKey r
;
2928 status
= cli
->dispatch(cli
,
2931 NDR_PNP_DELETECLASSKEY
,
2934 if (!NT_STATUS_IS_OK(status
)) {
2938 if (NT_STATUS_IS_ERR(status
)) {
2942 /* Return variables */
2946 *werror
= r
.out
.result
;
2949 return werror_to_ntstatus(r
.out
.result
);
2952 struct rpccli_PNP_GetInterfaceDeviceAlias_state
{
2953 struct PNP_GetInterfaceDeviceAlias orig
;
2954 struct PNP_GetInterfaceDeviceAlias tmp
;
2955 TALLOC_CTX
*out_mem_ctx
;
2956 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
2959 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req
*subreq
);
2961 struct tevent_req
*rpccli_PNP_GetInterfaceDeviceAlias_send(TALLOC_CTX
*mem_ctx
,
2962 struct tevent_context
*ev
,
2963 struct rpc_pipe_client
*cli
)
2965 struct tevent_req
*req
;
2966 struct rpccli_PNP_GetInterfaceDeviceAlias_state
*state
;
2967 struct tevent_req
*subreq
;
2969 req
= tevent_req_create(mem_ctx
, &state
,
2970 struct rpccli_PNP_GetInterfaceDeviceAlias_state
);
2974 state
->out_mem_ctx
= NULL
;
2975 state
->dispatch_recv
= cli
->dispatch_recv
;
2979 /* Out parameters */
2982 ZERO_STRUCT(state
->orig
.out
.result
);
2984 /* make a temporary copy, that we pass to the dispatch function */
2985 state
->tmp
= state
->orig
;
2987 subreq
= cli
->dispatch_send(state
, ev
, cli
,
2989 NDR_PNP_GETINTERFACEDEVICEALIAS
,
2991 if (tevent_req_nomem(subreq
, req
)) {
2992 return tevent_req_post(req
, ev
);
2994 tevent_req_set_callback(subreq
, rpccli_PNP_GetInterfaceDeviceAlias_done
, req
);
2998 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req
*subreq
)
3000 struct tevent_req
*req
= tevent_req_callback_data(
3001 subreq
, struct tevent_req
);
3002 struct rpccli_PNP_GetInterfaceDeviceAlias_state
*state
= tevent_req_data(
3003 req
, struct rpccli_PNP_GetInterfaceDeviceAlias_state
);
3005 TALLOC_CTX
*mem_ctx
;
3007 if (state
->out_mem_ctx
) {
3008 mem_ctx
= state
->out_mem_ctx
;
3013 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3014 TALLOC_FREE(subreq
);
3015 if (!NT_STATUS_IS_OK(status
)) {
3016 tevent_req_nterror(req
, status
);
3020 /* Copy out parameters */
3023 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3025 /* Reset temporary structure */
3026 ZERO_STRUCT(state
->tmp
);
3028 tevent_req_done(req
);
3031 NTSTATUS
rpccli_PNP_GetInterfaceDeviceAlias_recv(struct tevent_req
*req
,
3032 TALLOC_CTX
*mem_ctx
,
3035 struct rpccli_PNP_GetInterfaceDeviceAlias_state
*state
= tevent_req_data(
3036 req
, struct rpccli_PNP_GetInterfaceDeviceAlias_state
);
3039 if (tevent_req_is_nterror(req
, &status
)) {
3040 tevent_req_received(req
);
3044 /* Steal possbile out parameters to the callers context */
3045 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3048 *result
= state
->orig
.out
.result
;
3050 tevent_req_received(req
);
3051 return NT_STATUS_OK
;
3054 NTSTATUS
rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client
*cli
,
3055 TALLOC_CTX
*mem_ctx
,
3058 struct PNP_GetInterfaceDeviceAlias r
;
3063 status
= cli
->dispatch(cli
,
3066 NDR_PNP_GETINTERFACEDEVICEALIAS
,
3069 if (!NT_STATUS_IS_OK(status
)) {
3073 if (NT_STATUS_IS_ERR(status
)) {
3077 /* Return variables */
3081 *werror
= r
.out
.result
;
3084 return werror_to_ntstatus(r
.out
.result
);
3087 struct rpccli_PNP_GetInterfaceDeviceList_state
{
3088 struct PNP_GetInterfaceDeviceList orig
;
3089 struct PNP_GetInterfaceDeviceList tmp
;
3090 TALLOC_CTX
*out_mem_ctx
;
3091 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3094 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req
*subreq
);
3096 struct tevent_req
*rpccli_PNP_GetInterfaceDeviceList_send(TALLOC_CTX
*mem_ctx
,
3097 struct tevent_context
*ev
,
3098 struct rpc_pipe_client
*cli
)
3100 struct tevent_req
*req
;
3101 struct rpccli_PNP_GetInterfaceDeviceList_state
*state
;
3102 struct tevent_req
*subreq
;
3104 req
= tevent_req_create(mem_ctx
, &state
,
3105 struct rpccli_PNP_GetInterfaceDeviceList_state
);
3109 state
->out_mem_ctx
= NULL
;
3110 state
->dispatch_recv
= cli
->dispatch_recv
;
3114 /* Out parameters */
3117 ZERO_STRUCT(state
->orig
.out
.result
);
3119 /* make a temporary copy, that we pass to the dispatch function */
3120 state
->tmp
= state
->orig
;
3122 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3124 NDR_PNP_GETINTERFACEDEVICELIST
,
3126 if (tevent_req_nomem(subreq
, req
)) {
3127 return tevent_req_post(req
, ev
);
3129 tevent_req_set_callback(subreq
, rpccli_PNP_GetInterfaceDeviceList_done
, req
);
3133 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req
*subreq
)
3135 struct tevent_req
*req
= tevent_req_callback_data(
3136 subreq
, struct tevent_req
);
3137 struct rpccli_PNP_GetInterfaceDeviceList_state
*state
= tevent_req_data(
3138 req
, struct rpccli_PNP_GetInterfaceDeviceList_state
);
3140 TALLOC_CTX
*mem_ctx
;
3142 if (state
->out_mem_ctx
) {
3143 mem_ctx
= state
->out_mem_ctx
;
3148 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3149 TALLOC_FREE(subreq
);
3150 if (!NT_STATUS_IS_OK(status
)) {
3151 tevent_req_nterror(req
, status
);
3155 /* Copy out parameters */
3158 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3160 /* Reset temporary structure */
3161 ZERO_STRUCT(state
->tmp
);
3163 tevent_req_done(req
);
3166 NTSTATUS
rpccli_PNP_GetInterfaceDeviceList_recv(struct tevent_req
*req
,
3167 TALLOC_CTX
*mem_ctx
,
3170 struct rpccli_PNP_GetInterfaceDeviceList_state
*state
= tevent_req_data(
3171 req
, struct rpccli_PNP_GetInterfaceDeviceList_state
);
3174 if (tevent_req_is_nterror(req
, &status
)) {
3175 tevent_req_received(req
);
3179 /* Steal possbile out parameters to the callers context */
3180 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3183 *result
= state
->orig
.out
.result
;
3185 tevent_req_received(req
);
3186 return NT_STATUS_OK
;
3189 NTSTATUS
rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client
*cli
,
3190 TALLOC_CTX
*mem_ctx
,
3193 struct PNP_GetInterfaceDeviceList r
;
3198 status
= cli
->dispatch(cli
,
3201 NDR_PNP_GETINTERFACEDEVICELIST
,
3204 if (!NT_STATUS_IS_OK(status
)) {
3208 if (NT_STATUS_IS_ERR(status
)) {
3212 /* Return variables */
3216 *werror
= r
.out
.result
;
3219 return werror_to_ntstatus(r
.out
.result
);
3222 struct rpccli_PNP_GetInterfaceDeviceListSize_state
{
3223 struct PNP_GetInterfaceDeviceListSize orig
;
3224 struct PNP_GetInterfaceDeviceListSize tmp
;
3225 TALLOC_CTX
*out_mem_ctx
;
3226 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3229 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req
*subreq
);
3231 struct tevent_req
*rpccli_PNP_GetInterfaceDeviceListSize_send(TALLOC_CTX
*mem_ctx
,
3232 struct tevent_context
*ev
,
3233 struct rpc_pipe_client
*cli
)
3235 struct tevent_req
*req
;
3236 struct rpccli_PNP_GetInterfaceDeviceListSize_state
*state
;
3237 struct tevent_req
*subreq
;
3239 req
= tevent_req_create(mem_ctx
, &state
,
3240 struct rpccli_PNP_GetInterfaceDeviceListSize_state
);
3244 state
->out_mem_ctx
= NULL
;
3245 state
->dispatch_recv
= cli
->dispatch_recv
;
3249 /* Out parameters */
3252 ZERO_STRUCT(state
->orig
.out
.result
);
3254 /* make a temporary copy, that we pass to the dispatch function */
3255 state
->tmp
= state
->orig
;
3257 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3259 NDR_PNP_GETINTERFACEDEVICELISTSIZE
,
3261 if (tevent_req_nomem(subreq
, req
)) {
3262 return tevent_req_post(req
, ev
);
3264 tevent_req_set_callback(subreq
, rpccli_PNP_GetInterfaceDeviceListSize_done
, req
);
3268 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req
*subreq
)
3270 struct tevent_req
*req
= tevent_req_callback_data(
3271 subreq
, struct tevent_req
);
3272 struct rpccli_PNP_GetInterfaceDeviceListSize_state
*state
= tevent_req_data(
3273 req
, struct rpccli_PNP_GetInterfaceDeviceListSize_state
);
3275 TALLOC_CTX
*mem_ctx
;
3277 if (state
->out_mem_ctx
) {
3278 mem_ctx
= state
->out_mem_ctx
;
3283 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3284 TALLOC_FREE(subreq
);
3285 if (!NT_STATUS_IS_OK(status
)) {
3286 tevent_req_nterror(req
, status
);
3290 /* Copy out parameters */
3293 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3295 /* Reset temporary structure */
3296 ZERO_STRUCT(state
->tmp
);
3298 tevent_req_done(req
);
3301 NTSTATUS
rpccli_PNP_GetInterfaceDeviceListSize_recv(struct tevent_req
*req
,
3302 TALLOC_CTX
*mem_ctx
,
3305 struct rpccli_PNP_GetInterfaceDeviceListSize_state
*state
= tevent_req_data(
3306 req
, struct rpccli_PNP_GetInterfaceDeviceListSize_state
);
3309 if (tevent_req_is_nterror(req
, &status
)) {
3310 tevent_req_received(req
);
3314 /* Steal possbile out parameters to the callers context */
3315 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3318 *result
= state
->orig
.out
.result
;
3320 tevent_req_received(req
);
3321 return NT_STATUS_OK
;
3324 NTSTATUS
rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client
*cli
,
3325 TALLOC_CTX
*mem_ctx
,
3328 struct PNP_GetInterfaceDeviceListSize r
;
3333 status
= cli
->dispatch(cli
,
3336 NDR_PNP_GETINTERFACEDEVICELISTSIZE
,
3339 if (!NT_STATUS_IS_OK(status
)) {
3343 if (NT_STATUS_IS_ERR(status
)) {
3347 /* Return variables */
3351 *werror
= r
.out
.result
;
3354 return werror_to_ntstatus(r
.out
.result
);
3357 struct rpccli_PNP_RegisterDeviceClassAssociation_state
{
3358 struct PNP_RegisterDeviceClassAssociation orig
;
3359 struct PNP_RegisterDeviceClassAssociation tmp
;
3360 TALLOC_CTX
*out_mem_ctx
;
3361 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3364 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req
*subreq
);
3366 struct tevent_req
*rpccli_PNP_RegisterDeviceClassAssociation_send(TALLOC_CTX
*mem_ctx
,
3367 struct tevent_context
*ev
,
3368 struct rpc_pipe_client
*cli
)
3370 struct tevent_req
*req
;
3371 struct rpccli_PNP_RegisterDeviceClassAssociation_state
*state
;
3372 struct tevent_req
*subreq
;
3374 req
= tevent_req_create(mem_ctx
, &state
,
3375 struct rpccli_PNP_RegisterDeviceClassAssociation_state
);
3379 state
->out_mem_ctx
= NULL
;
3380 state
->dispatch_recv
= cli
->dispatch_recv
;
3384 /* Out parameters */
3387 ZERO_STRUCT(state
->orig
.out
.result
);
3389 /* make a temporary copy, that we pass to the dispatch function */
3390 state
->tmp
= state
->orig
;
3392 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3394 NDR_PNP_REGISTERDEVICECLASSASSOCIATION
,
3396 if (tevent_req_nomem(subreq
, req
)) {
3397 return tevent_req_post(req
, ev
);
3399 tevent_req_set_callback(subreq
, rpccli_PNP_RegisterDeviceClassAssociation_done
, req
);
3403 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req
*subreq
)
3405 struct tevent_req
*req
= tevent_req_callback_data(
3406 subreq
, struct tevent_req
);
3407 struct rpccli_PNP_RegisterDeviceClassAssociation_state
*state
= tevent_req_data(
3408 req
, struct rpccli_PNP_RegisterDeviceClassAssociation_state
);
3410 TALLOC_CTX
*mem_ctx
;
3412 if (state
->out_mem_ctx
) {
3413 mem_ctx
= state
->out_mem_ctx
;
3418 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3419 TALLOC_FREE(subreq
);
3420 if (!NT_STATUS_IS_OK(status
)) {
3421 tevent_req_nterror(req
, status
);
3425 /* Copy out parameters */
3428 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3430 /* Reset temporary structure */
3431 ZERO_STRUCT(state
->tmp
);
3433 tevent_req_done(req
);
3436 NTSTATUS
rpccli_PNP_RegisterDeviceClassAssociation_recv(struct tevent_req
*req
,
3437 TALLOC_CTX
*mem_ctx
,
3440 struct rpccli_PNP_RegisterDeviceClassAssociation_state
*state
= tevent_req_data(
3441 req
, struct rpccli_PNP_RegisterDeviceClassAssociation_state
);
3444 if (tevent_req_is_nterror(req
, &status
)) {
3445 tevent_req_received(req
);
3449 /* Steal possbile out parameters to the callers context */
3450 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3453 *result
= state
->orig
.out
.result
;
3455 tevent_req_received(req
);
3456 return NT_STATUS_OK
;
3459 NTSTATUS
rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client
*cli
,
3460 TALLOC_CTX
*mem_ctx
,
3463 struct PNP_RegisterDeviceClassAssociation r
;
3468 status
= cli
->dispatch(cli
,
3471 NDR_PNP_REGISTERDEVICECLASSASSOCIATION
,
3474 if (!NT_STATUS_IS_OK(status
)) {
3478 if (NT_STATUS_IS_ERR(status
)) {
3482 /* Return variables */
3486 *werror
= r
.out
.result
;
3489 return werror_to_ntstatus(r
.out
.result
);
3492 struct rpccli_PNP_UnregisterDeviceClassAssociation_state
{
3493 struct PNP_UnregisterDeviceClassAssociation orig
;
3494 struct PNP_UnregisterDeviceClassAssociation tmp
;
3495 TALLOC_CTX
*out_mem_ctx
;
3496 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3499 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req
*subreq
);
3501 struct tevent_req
*rpccli_PNP_UnregisterDeviceClassAssociation_send(TALLOC_CTX
*mem_ctx
,
3502 struct tevent_context
*ev
,
3503 struct rpc_pipe_client
*cli
)
3505 struct tevent_req
*req
;
3506 struct rpccli_PNP_UnregisterDeviceClassAssociation_state
*state
;
3507 struct tevent_req
*subreq
;
3509 req
= tevent_req_create(mem_ctx
, &state
,
3510 struct rpccli_PNP_UnregisterDeviceClassAssociation_state
);
3514 state
->out_mem_ctx
= NULL
;
3515 state
->dispatch_recv
= cli
->dispatch_recv
;
3519 /* Out parameters */
3522 ZERO_STRUCT(state
->orig
.out
.result
);
3524 /* make a temporary copy, that we pass to the dispatch function */
3525 state
->tmp
= state
->orig
;
3527 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3529 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION
,
3531 if (tevent_req_nomem(subreq
, req
)) {
3532 return tevent_req_post(req
, ev
);
3534 tevent_req_set_callback(subreq
, rpccli_PNP_UnregisterDeviceClassAssociation_done
, req
);
3538 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req
*subreq
)
3540 struct tevent_req
*req
= tevent_req_callback_data(
3541 subreq
, struct tevent_req
);
3542 struct rpccli_PNP_UnregisterDeviceClassAssociation_state
*state
= tevent_req_data(
3543 req
, struct rpccli_PNP_UnregisterDeviceClassAssociation_state
);
3545 TALLOC_CTX
*mem_ctx
;
3547 if (state
->out_mem_ctx
) {
3548 mem_ctx
= state
->out_mem_ctx
;
3553 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3554 TALLOC_FREE(subreq
);
3555 if (!NT_STATUS_IS_OK(status
)) {
3556 tevent_req_nterror(req
, status
);
3560 /* Copy out parameters */
3563 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3565 /* Reset temporary structure */
3566 ZERO_STRUCT(state
->tmp
);
3568 tevent_req_done(req
);
3571 NTSTATUS
rpccli_PNP_UnregisterDeviceClassAssociation_recv(struct tevent_req
*req
,
3572 TALLOC_CTX
*mem_ctx
,
3575 struct rpccli_PNP_UnregisterDeviceClassAssociation_state
*state
= tevent_req_data(
3576 req
, struct rpccli_PNP_UnregisterDeviceClassAssociation_state
);
3579 if (tevent_req_is_nterror(req
, &status
)) {
3580 tevent_req_received(req
);
3584 /* Steal possbile out parameters to the callers context */
3585 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3588 *result
= state
->orig
.out
.result
;
3590 tevent_req_received(req
);
3591 return NT_STATUS_OK
;
3594 NTSTATUS
rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client
*cli
,
3595 TALLOC_CTX
*mem_ctx
,
3598 struct PNP_UnregisterDeviceClassAssociation r
;
3603 status
= cli
->dispatch(cli
,
3606 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION
,
3609 if (!NT_STATUS_IS_OK(status
)) {
3613 if (NT_STATUS_IS_ERR(status
)) {
3617 /* Return variables */
3621 *werror
= r
.out
.result
;
3624 return werror_to_ntstatus(r
.out
.result
);
3627 struct rpccli_PNP_GetClassRegProp_state
{
3628 struct PNP_GetClassRegProp orig
;
3629 struct PNP_GetClassRegProp tmp
;
3630 TALLOC_CTX
*out_mem_ctx
;
3631 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3634 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req
*subreq
);
3636 struct tevent_req
*rpccli_PNP_GetClassRegProp_send(TALLOC_CTX
*mem_ctx
,
3637 struct tevent_context
*ev
,
3638 struct rpc_pipe_client
*cli
)
3640 struct tevent_req
*req
;
3641 struct rpccli_PNP_GetClassRegProp_state
*state
;
3642 struct tevent_req
*subreq
;
3644 req
= tevent_req_create(mem_ctx
, &state
,
3645 struct rpccli_PNP_GetClassRegProp_state
);
3649 state
->out_mem_ctx
= NULL
;
3650 state
->dispatch_recv
= cli
->dispatch_recv
;
3654 /* Out parameters */
3657 ZERO_STRUCT(state
->orig
.out
.result
);
3659 /* make a temporary copy, that we pass to the dispatch function */
3660 state
->tmp
= state
->orig
;
3662 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3664 NDR_PNP_GETCLASSREGPROP
,
3666 if (tevent_req_nomem(subreq
, req
)) {
3667 return tevent_req_post(req
, ev
);
3669 tevent_req_set_callback(subreq
, rpccli_PNP_GetClassRegProp_done
, req
);
3673 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req
*subreq
)
3675 struct tevent_req
*req
= tevent_req_callback_data(
3676 subreq
, struct tevent_req
);
3677 struct rpccli_PNP_GetClassRegProp_state
*state
= tevent_req_data(
3678 req
, struct rpccli_PNP_GetClassRegProp_state
);
3680 TALLOC_CTX
*mem_ctx
;
3682 if (state
->out_mem_ctx
) {
3683 mem_ctx
= state
->out_mem_ctx
;
3688 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3689 TALLOC_FREE(subreq
);
3690 if (!NT_STATUS_IS_OK(status
)) {
3691 tevent_req_nterror(req
, status
);
3695 /* Copy out parameters */
3698 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3700 /* Reset temporary structure */
3701 ZERO_STRUCT(state
->tmp
);
3703 tevent_req_done(req
);
3706 NTSTATUS
rpccli_PNP_GetClassRegProp_recv(struct tevent_req
*req
,
3707 TALLOC_CTX
*mem_ctx
,
3710 struct rpccli_PNP_GetClassRegProp_state
*state
= tevent_req_data(
3711 req
, struct rpccli_PNP_GetClassRegProp_state
);
3714 if (tevent_req_is_nterror(req
, &status
)) {
3715 tevent_req_received(req
);
3719 /* Steal possbile out parameters to the callers context */
3720 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3723 *result
= state
->orig
.out
.result
;
3725 tevent_req_received(req
);
3726 return NT_STATUS_OK
;
3729 NTSTATUS
rpccli_PNP_GetClassRegProp(struct rpc_pipe_client
*cli
,
3730 TALLOC_CTX
*mem_ctx
,
3733 struct PNP_GetClassRegProp r
;
3738 status
= cli
->dispatch(cli
,
3741 NDR_PNP_GETCLASSREGPROP
,
3744 if (!NT_STATUS_IS_OK(status
)) {
3748 if (NT_STATUS_IS_ERR(status
)) {
3752 /* Return variables */
3756 *werror
= r
.out
.result
;
3759 return werror_to_ntstatus(r
.out
.result
);
3762 struct rpccli_PNP_SetClassRegProp_state
{
3763 struct PNP_SetClassRegProp orig
;
3764 struct PNP_SetClassRegProp tmp
;
3765 TALLOC_CTX
*out_mem_ctx
;
3766 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3769 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req
*subreq
);
3771 struct tevent_req
*rpccli_PNP_SetClassRegProp_send(TALLOC_CTX
*mem_ctx
,
3772 struct tevent_context
*ev
,
3773 struct rpc_pipe_client
*cli
)
3775 struct tevent_req
*req
;
3776 struct rpccli_PNP_SetClassRegProp_state
*state
;
3777 struct tevent_req
*subreq
;
3779 req
= tevent_req_create(mem_ctx
, &state
,
3780 struct rpccli_PNP_SetClassRegProp_state
);
3784 state
->out_mem_ctx
= NULL
;
3785 state
->dispatch_recv
= cli
->dispatch_recv
;
3789 /* Out parameters */
3792 ZERO_STRUCT(state
->orig
.out
.result
);
3794 /* make a temporary copy, that we pass to the dispatch function */
3795 state
->tmp
= state
->orig
;
3797 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3799 NDR_PNP_SETCLASSREGPROP
,
3801 if (tevent_req_nomem(subreq
, req
)) {
3802 return tevent_req_post(req
, ev
);
3804 tevent_req_set_callback(subreq
, rpccli_PNP_SetClassRegProp_done
, req
);
3808 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req
*subreq
)
3810 struct tevent_req
*req
= tevent_req_callback_data(
3811 subreq
, struct tevent_req
);
3812 struct rpccli_PNP_SetClassRegProp_state
*state
= tevent_req_data(
3813 req
, struct rpccli_PNP_SetClassRegProp_state
);
3815 TALLOC_CTX
*mem_ctx
;
3817 if (state
->out_mem_ctx
) {
3818 mem_ctx
= state
->out_mem_ctx
;
3823 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3824 TALLOC_FREE(subreq
);
3825 if (!NT_STATUS_IS_OK(status
)) {
3826 tevent_req_nterror(req
, status
);
3830 /* Copy out parameters */
3833 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3835 /* Reset temporary structure */
3836 ZERO_STRUCT(state
->tmp
);
3838 tevent_req_done(req
);
3841 NTSTATUS
rpccli_PNP_SetClassRegProp_recv(struct tevent_req
*req
,
3842 TALLOC_CTX
*mem_ctx
,
3845 struct rpccli_PNP_SetClassRegProp_state
*state
= tevent_req_data(
3846 req
, struct rpccli_PNP_SetClassRegProp_state
);
3849 if (tevent_req_is_nterror(req
, &status
)) {
3850 tevent_req_received(req
);
3854 /* Steal possbile out parameters to the callers context */
3855 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3858 *result
= state
->orig
.out
.result
;
3860 tevent_req_received(req
);
3861 return NT_STATUS_OK
;
3864 NTSTATUS
rpccli_PNP_SetClassRegProp(struct rpc_pipe_client
*cli
,
3865 TALLOC_CTX
*mem_ctx
,
3868 struct PNP_SetClassRegProp r
;
3873 status
= cli
->dispatch(cli
,
3876 NDR_PNP_SETCLASSREGPROP
,
3879 if (!NT_STATUS_IS_OK(status
)) {
3883 if (NT_STATUS_IS_ERR(status
)) {
3887 /* Return variables */
3891 *werror
= r
.out
.result
;
3894 return werror_to_ntstatus(r
.out
.result
);
3897 struct rpccli_PNP_CreateDevInst_state
{
3898 struct PNP_CreateDevInst orig
;
3899 struct PNP_CreateDevInst tmp
;
3900 TALLOC_CTX
*out_mem_ctx
;
3901 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
3904 static void rpccli_PNP_CreateDevInst_done(struct tevent_req
*subreq
);
3906 struct tevent_req
*rpccli_PNP_CreateDevInst_send(TALLOC_CTX
*mem_ctx
,
3907 struct tevent_context
*ev
,
3908 struct rpc_pipe_client
*cli
)
3910 struct tevent_req
*req
;
3911 struct rpccli_PNP_CreateDevInst_state
*state
;
3912 struct tevent_req
*subreq
;
3914 req
= tevent_req_create(mem_ctx
, &state
,
3915 struct rpccli_PNP_CreateDevInst_state
);
3919 state
->out_mem_ctx
= NULL
;
3920 state
->dispatch_recv
= cli
->dispatch_recv
;
3924 /* Out parameters */
3927 ZERO_STRUCT(state
->orig
.out
.result
);
3929 /* make a temporary copy, that we pass to the dispatch function */
3930 state
->tmp
= state
->orig
;
3932 subreq
= cli
->dispatch_send(state
, ev
, cli
,
3934 NDR_PNP_CREATEDEVINST
,
3936 if (tevent_req_nomem(subreq
, req
)) {
3937 return tevent_req_post(req
, ev
);
3939 tevent_req_set_callback(subreq
, rpccli_PNP_CreateDevInst_done
, req
);
3943 static void rpccli_PNP_CreateDevInst_done(struct tevent_req
*subreq
)
3945 struct tevent_req
*req
= tevent_req_callback_data(
3946 subreq
, struct tevent_req
);
3947 struct rpccli_PNP_CreateDevInst_state
*state
= tevent_req_data(
3948 req
, struct rpccli_PNP_CreateDevInst_state
);
3950 TALLOC_CTX
*mem_ctx
;
3952 if (state
->out_mem_ctx
) {
3953 mem_ctx
= state
->out_mem_ctx
;
3958 status
= state
->dispatch_recv(subreq
, mem_ctx
);
3959 TALLOC_FREE(subreq
);
3960 if (!NT_STATUS_IS_OK(status
)) {
3961 tevent_req_nterror(req
, status
);
3965 /* Copy out parameters */
3968 state
->orig
.out
.result
= state
->tmp
.out
.result
;
3970 /* Reset temporary structure */
3971 ZERO_STRUCT(state
->tmp
);
3973 tevent_req_done(req
);
3976 NTSTATUS
rpccli_PNP_CreateDevInst_recv(struct tevent_req
*req
,
3977 TALLOC_CTX
*mem_ctx
,
3980 struct rpccli_PNP_CreateDevInst_state
*state
= tevent_req_data(
3981 req
, struct rpccli_PNP_CreateDevInst_state
);
3984 if (tevent_req_is_nterror(req
, &status
)) {
3985 tevent_req_received(req
);
3989 /* Steal possbile out parameters to the callers context */
3990 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
3993 *result
= state
->orig
.out
.result
;
3995 tevent_req_received(req
);
3996 return NT_STATUS_OK
;
3999 NTSTATUS
rpccli_PNP_CreateDevInst(struct rpc_pipe_client
*cli
,
4000 TALLOC_CTX
*mem_ctx
,
4003 struct PNP_CreateDevInst r
;
4008 status
= cli
->dispatch(cli
,
4011 NDR_PNP_CREATEDEVINST
,
4014 if (!NT_STATUS_IS_OK(status
)) {
4018 if (NT_STATUS_IS_ERR(status
)) {
4022 /* Return variables */
4026 *werror
= r
.out
.result
;
4029 return werror_to_ntstatus(r
.out
.result
);
4032 struct rpccli_PNP_DeviceInstanceAction_state
{
4033 struct PNP_DeviceInstanceAction orig
;
4034 struct PNP_DeviceInstanceAction tmp
;
4035 TALLOC_CTX
*out_mem_ctx
;
4036 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4039 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req
*subreq
);
4041 struct tevent_req
*rpccli_PNP_DeviceInstanceAction_send(TALLOC_CTX
*mem_ctx
,
4042 struct tevent_context
*ev
,
4043 struct rpc_pipe_client
*cli
)
4045 struct tevent_req
*req
;
4046 struct rpccli_PNP_DeviceInstanceAction_state
*state
;
4047 struct tevent_req
*subreq
;
4049 req
= tevent_req_create(mem_ctx
, &state
,
4050 struct rpccli_PNP_DeviceInstanceAction_state
);
4054 state
->out_mem_ctx
= NULL
;
4055 state
->dispatch_recv
= cli
->dispatch_recv
;
4059 /* Out parameters */
4062 ZERO_STRUCT(state
->orig
.out
.result
);
4064 /* make a temporary copy, that we pass to the dispatch function */
4065 state
->tmp
= state
->orig
;
4067 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4069 NDR_PNP_DEVICEINSTANCEACTION
,
4071 if (tevent_req_nomem(subreq
, req
)) {
4072 return tevent_req_post(req
, ev
);
4074 tevent_req_set_callback(subreq
, rpccli_PNP_DeviceInstanceAction_done
, req
);
4078 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req
*subreq
)
4080 struct tevent_req
*req
= tevent_req_callback_data(
4081 subreq
, struct tevent_req
);
4082 struct rpccli_PNP_DeviceInstanceAction_state
*state
= tevent_req_data(
4083 req
, struct rpccli_PNP_DeviceInstanceAction_state
);
4085 TALLOC_CTX
*mem_ctx
;
4087 if (state
->out_mem_ctx
) {
4088 mem_ctx
= state
->out_mem_ctx
;
4093 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4094 TALLOC_FREE(subreq
);
4095 if (!NT_STATUS_IS_OK(status
)) {
4096 tevent_req_nterror(req
, status
);
4100 /* Copy out parameters */
4103 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4105 /* Reset temporary structure */
4106 ZERO_STRUCT(state
->tmp
);
4108 tevent_req_done(req
);
4111 NTSTATUS
rpccli_PNP_DeviceInstanceAction_recv(struct tevent_req
*req
,
4112 TALLOC_CTX
*mem_ctx
,
4115 struct rpccli_PNP_DeviceInstanceAction_state
*state
= tevent_req_data(
4116 req
, struct rpccli_PNP_DeviceInstanceAction_state
);
4119 if (tevent_req_is_nterror(req
, &status
)) {
4120 tevent_req_received(req
);
4124 /* Steal possbile out parameters to the callers context */
4125 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4128 *result
= state
->orig
.out
.result
;
4130 tevent_req_received(req
);
4131 return NT_STATUS_OK
;
4134 NTSTATUS
rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client
*cli
,
4135 TALLOC_CTX
*mem_ctx
,
4138 struct PNP_DeviceInstanceAction r
;
4143 status
= cli
->dispatch(cli
,
4146 NDR_PNP_DEVICEINSTANCEACTION
,
4149 if (!NT_STATUS_IS_OK(status
)) {
4153 if (NT_STATUS_IS_ERR(status
)) {
4157 /* Return variables */
4161 *werror
= r
.out
.result
;
4164 return werror_to_ntstatus(r
.out
.result
);
4167 struct rpccli_PNP_GetDeviceStatus_state
{
4168 struct PNP_GetDeviceStatus orig
;
4169 struct PNP_GetDeviceStatus tmp
;
4170 TALLOC_CTX
*out_mem_ctx
;
4171 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4174 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req
*subreq
);
4176 struct tevent_req
*rpccli_PNP_GetDeviceStatus_send(TALLOC_CTX
*mem_ctx
,
4177 struct tevent_context
*ev
,
4178 struct rpc_pipe_client
*cli
)
4180 struct tevent_req
*req
;
4181 struct rpccli_PNP_GetDeviceStatus_state
*state
;
4182 struct tevent_req
*subreq
;
4184 req
= tevent_req_create(mem_ctx
, &state
,
4185 struct rpccli_PNP_GetDeviceStatus_state
);
4189 state
->out_mem_ctx
= NULL
;
4190 state
->dispatch_recv
= cli
->dispatch_recv
;
4194 /* Out parameters */
4197 ZERO_STRUCT(state
->orig
.out
.result
);
4199 /* make a temporary copy, that we pass to the dispatch function */
4200 state
->tmp
= state
->orig
;
4202 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4204 NDR_PNP_GETDEVICESTATUS
,
4206 if (tevent_req_nomem(subreq
, req
)) {
4207 return tevent_req_post(req
, ev
);
4209 tevent_req_set_callback(subreq
, rpccli_PNP_GetDeviceStatus_done
, req
);
4213 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req
*subreq
)
4215 struct tevent_req
*req
= tevent_req_callback_data(
4216 subreq
, struct tevent_req
);
4217 struct rpccli_PNP_GetDeviceStatus_state
*state
= tevent_req_data(
4218 req
, struct rpccli_PNP_GetDeviceStatus_state
);
4220 TALLOC_CTX
*mem_ctx
;
4222 if (state
->out_mem_ctx
) {
4223 mem_ctx
= state
->out_mem_ctx
;
4228 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4229 TALLOC_FREE(subreq
);
4230 if (!NT_STATUS_IS_OK(status
)) {
4231 tevent_req_nterror(req
, status
);
4235 /* Copy out parameters */
4238 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4240 /* Reset temporary structure */
4241 ZERO_STRUCT(state
->tmp
);
4243 tevent_req_done(req
);
4246 NTSTATUS
rpccli_PNP_GetDeviceStatus_recv(struct tevent_req
*req
,
4247 TALLOC_CTX
*mem_ctx
,
4250 struct rpccli_PNP_GetDeviceStatus_state
*state
= tevent_req_data(
4251 req
, struct rpccli_PNP_GetDeviceStatus_state
);
4254 if (tevent_req_is_nterror(req
, &status
)) {
4255 tevent_req_received(req
);
4259 /* Steal possbile out parameters to the callers context */
4260 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4263 *result
= state
->orig
.out
.result
;
4265 tevent_req_received(req
);
4266 return NT_STATUS_OK
;
4269 NTSTATUS
rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client
*cli
,
4270 TALLOC_CTX
*mem_ctx
,
4273 struct PNP_GetDeviceStatus r
;
4278 status
= cli
->dispatch(cli
,
4281 NDR_PNP_GETDEVICESTATUS
,
4284 if (!NT_STATUS_IS_OK(status
)) {
4288 if (NT_STATUS_IS_ERR(status
)) {
4292 /* Return variables */
4296 *werror
= r
.out
.result
;
4299 return werror_to_ntstatus(r
.out
.result
);
4302 struct rpccli_PNP_SetDeviceProblem_state
{
4303 struct PNP_SetDeviceProblem orig
;
4304 struct PNP_SetDeviceProblem tmp
;
4305 TALLOC_CTX
*out_mem_ctx
;
4306 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4309 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req
*subreq
);
4311 struct tevent_req
*rpccli_PNP_SetDeviceProblem_send(TALLOC_CTX
*mem_ctx
,
4312 struct tevent_context
*ev
,
4313 struct rpc_pipe_client
*cli
)
4315 struct tevent_req
*req
;
4316 struct rpccli_PNP_SetDeviceProblem_state
*state
;
4317 struct tevent_req
*subreq
;
4319 req
= tevent_req_create(mem_ctx
, &state
,
4320 struct rpccli_PNP_SetDeviceProblem_state
);
4324 state
->out_mem_ctx
= NULL
;
4325 state
->dispatch_recv
= cli
->dispatch_recv
;
4329 /* Out parameters */
4332 ZERO_STRUCT(state
->orig
.out
.result
);
4334 /* make a temporary copy, that we pass to the dispatch function */
4335 state
->tmp
= state
->orig
;
4337 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4339 NDR_PNP_SETDEVICEPROBLEM
,
4341 if (tevent_req_nomem(subreq
, req
)) {
4342 return tevent_req_post(req
, ev
);
4344 tevent_req_set_callback(subreq
, rpccli_PNP_SetDeviceProblem_done
, req
);
4348 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req
*subreq
)
4350 struct tevent_req
*req
= tevent_req_callback_data(
4351 subreq
, struct tevent_req
);
4352 struct rpccli_PNP_SetDeviceProblem_state
*state
= tevent_req_data(
4353 req
, struct rpccli_PNP_SetDeviceProblem_state
);
4355 TALLOC_CTX
*mem_ctx
;
4357 if (state
->out_mem_ctx
) {
4358 mem_ctx
= state
->out_mem_ctx
;
4363 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4364 TALLOC_FREE(subreq
);
4365 if (!NT_STATUS_IS_OK(status
)) {
4366 tevent_req_nterror(req
, status
);
4370 /* Copy out parameters */
4373 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4375 /* Reset temporary structure */
4376 ZERO_STRUCT(state
->tmp
);
4378 tevent_req_done(req
);
4381 NTSTATUS
rpccli_PNP_SetDeviceProblem_recv(struct tevent_req
*req
,
4382 TALLOC_CTX
*mem_ctx
,
4385 struct rpccli_PNP_SetDeviceProblem_state
*state
= tevent_req_data(
4386 req
, struct rpccli_PNP_SetDeviceProblem_state
);
4389 if (tevent_req_is_nterror(req
, &status
)) {
4390 tevent_req_received(req
);
4394 /* Steal possbile out parameters to the callers context */
4395 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4398 *result
= state
->orig
.out
.result
;
4400 tevent_req_received(req
);
4401 return NT_STATUS_OK
;
4404 NTSTATUS
rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client
*cli
,
4405 TALLOC_CTX
*mem_ctx
,
4408 struct PNP_SetDeviceProblem r
;
4413 status
= cli
->dispatch(cli
,
4416 NDR_PNP_SETDEVICEPROBLEM
,
4419 if (!NT_STATUS_IS_OK(status
)) {
4423 if (NT_STATUS_IS_ERR(status
)) {
4427 /* Return variables */
4431 *werror
= r
.out
.result
;
4434 return werror_to_ntstatus(r
.out
.result
);
4437 struct rpccli_PNP_DisableDevInst_state
{
4438 struct PNP_DisableDevInst orig
;
4439 struct PNP_DisableDevInst tmp
;
4440 TALLOC_CTX
*out_mem_ctx
;
4441 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4444 static void rpccli_PNP_DisableDevInst_done(struct tevent_req
*subreq
);
4446 struct tevent_req
*rpccli_PNP_DisableDevInst_send(TALLOC_CTX
*mem_ctx
,
4447 struct tevent_context
*ev
,
4448 struct rpc_pipe_client
*cli
)
4450 struct tevent_req
*req
;
4451 struct rpccli_PNP_DisableDevInst_state
*state
;
4452 struct tevent_req
*subreq
;
4454 req
= tevent_req_create(mem_ctx
, &state
,
4455 struct rpccli_PNP_DisableDevInst_state
);
4459 state
->out_mem_ctx
= NULL
;
4460 state
->dispatch_recv
= cli
->dispatch_recv
;
4464 /* Out parameters */
4467 ZERO_STRUCT(state
->orig
.out
.result
);
4469 /* make a temporary copy, that we pass to the dispatch function */
4470 state
->tmp
= state
->orig
;
4472 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4474 NDR_PNP_DISABLEDEVINST
,
4476 if (tevent_req_nomem(subreq
, req
)) {
4477 return tevent_req_post(req
, ev
);
4479 tevent_req_set_callback(subreq
, rpccli_PNP_DisableDevInst_done
, req
);
4483 static void rpccli_PNP_DisableDevInst_done(struct tevent_req
*subreq
)
4485 struct tevent_req
*req
= tevent_req_callback_data(
4486 subreq
, struct tevent_req
);
4487 struct rpccli_PNP_DisableDevInst_state
*state
= tevent_req_data(
4488 req
, struct rpccli_PNP_DisableDevInst_state
);
4490 TALLOC_CTX
*mem_ctx
;
4492 if (state
->out_mem_ctx
) {
4493 mem_ctx
= state
->out_mem_ctx
;
4498 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4499 TALLOC_FREE(subreq
);
4500 if (!NT_STATUS_IS_OK(status
)) {
4501 tevent_req_nterror(req
, status
);
4505 /* Copy out parameters */
4508 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4510 /* Reset temporary structure */
4511 ZERO_STRUCT(state
->tmp
);
4513 tevent_req_done(req
);
4516 NTSTATUS
rpccli_PNP_DisableDevInst_recv(struct tevent_req
*req
,
4517 TALLOC_CTX
*mem_ctx
,
4520 struct rpccli_PNP_DisableDevInst_state
*state
= tevent_req_data(
4521 req
, struct rpccli_PNP_DisableDevInst_state
);
4524 if (tevent_req_is_nterror(req
, &status
)) {
4525 tevent_req_received(req
);
4529 /* Steal possbile out parameters to the callers context */
4530 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4533 *result
= state
->orig
.out
.result
;
4535 tevent_req_received(req
);
4536 return NT_STATUS_OK
;
4539 NTSTATUS
rpccli_PNP_DisableDevInst(struct rpc_pipe_client
*cli
,
4540 TALLOC_CTX
*mem_ctx
,
4543 struct PNP_DisableDevInst r
;
4548 status
= cli
->dispatch(cli
,
4551 NDR_PNP_DISABLEDEVINST
,
4554 if (!NT_STATUS_IS_OK(status
)) {
4558 if (NT_STATUS_IS_ERR(status
)) {
4562 /* Return variables */
4566 *werror
= r
.out
.result
;
4569 return werror_to_ntstatus(r
.out
.result
);
4572 struct rpccli_PNP_UninstallDevInst_state
{
4573 struct PNP_UninstallDevInst orig
;
4574 struct PNP_UninstallDevInst tmp
;
4575 TALLOC_CTX
*out_mem_ctx
;
4576 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4579 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req
*subreq
);
4581 struct tevent_req
*rpccli_PNP_UninstallDevInst_send(TALLOC_CTX
*mem_ctx
,
4582 struct tevent_context
*ev
,
4583 struct rpc_pipe_client
*cli
)
4585 struct tevent_req
*req
;
4586 struct rpccli_PNP_UninstallDevInst_state
*state
;
4587 struct tevent_req
*subreq
;
4589 req
= tevent_req_create(mem_ctx
, &state
,
4590 struct rpccli_PNP_UninstallDevInst_state
);
4594 state
->out_mem_ctx
= NULL
;
4595 state
->dispatch_recv
= cli
->dispatch_recv
;
4599 /* Out parameters */
4602 ZERO_STRUCT(state
->orig
.out
.result
);
4604 /* make a temporary copy, that we pass to the dispatch function */
4605 state
->tmp
= state
->orig
;
4607 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4609 NDR_PNP_UNINSTALLDEVINST
,
4611 if (tevent_req_nomem(subreq
, req
)) {
4612 return tevent_req_post(req
, ev
);
4614 tevent_req_set_callback(subreq
, rpccli_PNP_UninstallDevInst_done
, req
);
4618 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req
*subreq
)
4620 struct tevent_req
*req
= tevent_req_callback_data(
4621 subreq
, struct tevent_req
);
4622 struct rpccli_PNP_UninstallDevInst_state
*state
= tevent_req_data(
4623 req
, struct rpccli_PNP_UninstallDevInst_state
);
4625 TALLOC_CTX
*mem_ctx
;
4627 if (state
->out_mem_ctx
) {
4628 mem_ctx
= state
->out_mem_ctx
;
4633 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4634 TALLOC_FREE(subreq
);
4635 if (!NT_STATUS_IS_OK(status
)) {
4636 tevent_req_nterror(req
, status
);
4640 /* Copy out parameters */
4643 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4645 /* Reset temporary structure */
4646 ZERO_STRUCT(state
->tmp
);
4648 tevent_req_done(req
);
4651 NTSTATUS
rpccli_PNP_UninstallDevInst_recv(struct tevent_req
*req
,
4652 TALLOC_CTX
*mem_ctx
,
4655 struct rpccli_PNP_UninstallDevInst_state
*state
= tevent_req_data(
4656 req
, struct rpccli_PNP_UninstallDevInst_state
);
4659 if (tevent_req_is_nterror(req
, &status
)) {
4660 tevent_req_received(req
);
4664 /* Steal possbile out parameters to the callers context */
4665 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4668 *result
= state
->orig
.out
.result
;
4670 tevent_req_received(req
);
4671 return NT_STATUS_OK
;
4674 NTSTATUS
rpccli_PNP_UninstallDevInst(struct rpc_pipe_client
*cli
,
4675 TALLOC_CTX
*mem_ctx
,
4678 struct PNP_UninstallDevInst r
;
4683 status
= cli
->dispatch(cli
,
4686 NDR_PNP_UNINSTALLDEVINST
,
4689 if (!NT_STATUS_IS_OK(status
)) {
4693 if (NT_STATUS_IS_ERR(status
)) {
4697 /* Return variables */
4701 *werror
= r
.out
.result
;
4704 return werror_to_ntstatus(r
.out
.result
);
4707 struct rpccli_PNP_AddID_state
{
4708 struct PNP_AddID orig
;
4709 struct PNP_AddID tmp
;
4710 TALLOC_CTX
*out_mem_ctx
;
4711 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4714 static void rpccli_PNP_AddID_done(struct tevent_req
*subreq
);
4716 struct tevent_req
*rpccli_PNP_AddID_send(TALLOC_CTX
*mem_ctx
,
4717 struct tevent_context
*ev
,
4718 struct rpc_pipe_client
*cli
)
4720 struct tevent_req
*req
;
4721 struct rpccli_PNP_AddID_state
*state
;
4722 struct tevent_req
*subreq
;
4724 req
= tevent_req_create(mem_ctx
, &state
,
4725 struct rpccli_PNP_AddID_state
);
4729 state
->out_mem_ctx
= NULL
;
4730 state
->dispatch_recv
= cli
->dispatch_recv
;
4734 /* Out parameters */
4737 ZERO_STRUCT(state
->orig
.out
.result
);
4739 /* make a temporary copy, that we pass to the dispatch function */
4740 state
->tmp
= state
->orig
;
4742 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4746 if (tevent_req_nomem(subreq
, req
)) {
4747 return tevent_req_post(req
, ev
);
4749 tevent_req_set_callback(subreq
, rpccli_PNP_AddID_done
, req
);
4753 static void rpccli_PNP_AddID_done(struct tevent_req
*subreq
)
4755 struct tevent_req
*req
= tevent_req_callback_data(
4756 subreq
, struct tevent_req
);
4757 struct rpccli_PNP_AddID_state
*state
= tevent_req_data(
4758 req
, struct rpccli_PNP_AddID_state
);
4760 TALLOC_CTX
*mem_ctx
;
4762 if (state
->out_mem_ctx
) {
4763 mem_ctx
= state
->out_mem_ctx
;
4768 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4769 TALLOC_FREE(subreq
);
4770 if (!NT_STATUS_IS_OK(status
)) {
4771 tevent_req_nterror(req
, status
);
4775 /* Copy out parameters */
4778 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4780 /* Reset temporary structure */
4781 ZERO_STRUCT(state
->tmp
);
4783 tevent_req_done(req
);
4786 NTSTATUS
rpccli_PNP_AddID_recv(struct tevent_req
*req
,
4787 TALLOC_CTX
*mem_ctx
,
4790 struct rpccli_PNP_AddID_state
*state
= tevent_req_data(
4791 req
, struct rpccli_PNP_AddID_state
);
4794 if (tevent_req_is_nterror(req
, &status
)) {
4795 tevent_req_received(req
);
4799 /* Steal possbile out parameters to the callers context */
4800 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4803 *result
= state
->orig
.out
.result
;
4805 tevent_req_received(req
);
4806 return NT_STATUS_OK
;
4809 NTSTATUS
rpccli_PNP_AddID(struct rpc_pipe_client
*cli
,
4810 TALLOC_CTX
*mem_ctx
,
4818 status
= cli
->dispatch(cli
,
4824 if (!NT_STATUS_IS_OK(status
)) {
4828 if (NT_STATUS_IS_ERR(status
)) {
4832 /* Return variables */
4836 *werror
= r
.out
.result
;
4839 return werror_to_ntstatus(r
.out
.result
);
4842 struct rpccli_PNP_RegisterDriver_state
{
4843 struct PNP_RegisterDriver orig
;
4844 struct PNP_RegisterDriver tmp
;
4845 TALLOC_CTX
*out_mem_ctx
;
4846 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4849 static void rpccli_PNP_RegisterDriver_done(struct tevent_req
*subreq
);
4851 struct tevent_req
*rpccli_PNP_RegisterDriver_send(TALLOC_CTX
*mem_ctx
,
4852 struct tevent_context
*ev
,
4853 struct rpc_pipe_client
*cli
)
4855 struct tevent_req
*req
;
4856 struct rpccli_PNP_RegisterDriver_state
*state
;
4857 struct tevent_req
*subreq
;
4859 req
= tevent_req_create(mem_ctx
, &state
,
4860 struct rpccli_PNP_RegisterDriver_state
);
4864 state
->out_mem_ctx
= NULL
;
4865 state
->dispatch_recv
= cli
->dispatch_recv
;
4869 /* Out parameters */
4872 ZERO_STRUCT(state
->orig
.out
.result
);
4874 /* make a temporary copy, that we pass to the dispatch function */
4875 state
->tmp
= state
->orig
;
4877 subreq
= cli
->dispatch_send(state
, ev
, cli
,
4879 NDR_PNP_REGISTERDRIVER
,
4881 if (tevent_req_nomem(subreq
, req
)) {
4882 return tevent_req_post(req
, ev
);
4884 tevent_req_set_callback(subreq
, rpccli_PNP_RegisterDriver_done
, req
);
4888 static void rpccli_PNP_RegisterDriver_done(struct tevent_req
*subreq
)
4890 struct tevent_req
*req
= tevent_req_callback_data(
4891 subreq
, struct tevent_req
);
4892 struct rpccli_PNP_RegisterDriver_state
*state
= tevent_req_data(
4893 req
, struct rpccli_PNP_RegisterDriver_state
);
4895 TALLOC_CTX
*mem_ctx
;
4897 if (state
->out_mem_ctx
) {
4898 mem_ctx
= state
->out_mem_ctx
;
4903 status
= state
->dispatch_recv(subreq
, mem_ctx
);
4904 TALLOC_FREE(subreq
);
4905 if (!NT_STATUS_IS_OK(status
)) {
4906 tevent_req_nterror(req
, status
);
4910 /* Copy out parameters */
4913 state
->orig
.out
.result
= state
->tmp
.out
.result
;
4915 /* Reset temporary structure */
4916 ZERO_STRUCT(state
->tmp
);
4918 tevent_req_done(req
);
4921 NTSTATUS
rpccli_PNP_RegisterDriver_recv(struct tevent_req
*req
,
4922 TALLOC_CTX
*mem_ctx
,
4925 struct rpccli_PNP_RegisterDriver_state
*state
= tevent_req_data(
4926 req
, struct rpccli_PNP_RegisterDriver_state
);
4929 if (tevent_req_is_nterror(req
, &status
)) {
4930 tevent_req_received(req
);
4934 /* Steal possbile out parameters to the callers context */
4935 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
4938 *result
= state
->orig
.out
.result
;
4940 tevent_req_received(req
);
4941 return NT_STATUS_OK
;
4944 NTSTATUS
rpccli_PNP_RegisterDriver(struct rpc_pipe_client
*cli
,
4945 TALLOC_CTX
*mem_ctx
,
4948 struct PNP_RegisterDriver r
;
4953 status
= cli
->dispatch(cli
,
4956 NDR_PNP_REGISTERDRIVER
,
4959 if (!NT_STATUS_IS_OK(status
)) {
4963 if (NT_STATUS_IS_ERR(status
)) {
4967 /* Return variables */
4971 *werror
= r
.out
.result
;
4974 return werror_to_ntstatus(r
.out
.result
);
4977 struct rpccli_PNP_QueryRemove_state
{
4978 struct PNP_QueryRemove orig
;
4979 struct PNP_QueryRemove tmp
;
4980 TALLOC_CTX
*out_mem_ctx
;
4981 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
4984 static void rpccli_PNP_QueryRemove_done(struct tevent_req
*subreq
);
4986 struct tevent_req
*rpccli_PNP_QueryRemove_send(TALLOC_CTX
*mem_ctx
,
4987 struct tevent_context
*ev
,
4988 struct rpc_pipe_client
*cli
)
4990 struct tevent_req
*req
;
4991 struct rpccli_PNP_QueryRemove_state
*state
;
4992 struct tevent_req
*subreq
;
4994 req
= tevent_req_create(mem_ctx
, &state
,
4995 struct rpccli_PNP_QueryRemove_state
);
4999 state
->out_mem_ctx
= NULL
;
5000 state
->dispatch_recv
= cli
->dispatch_recv
;
5004 /* Out parameters */
5007 ZERO_STRUCT(state
->orig
.out
.result
);
5009 /* make a temporary copy, that we pass to the dispatch function */
5010 state
->tmp
= state
->orig
;
5012 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5014 NDR_PNP_QUERYREMOVE
,
5016 if (tevent_req_nomem(subreq
, req
)) {
5017 return tevent_req_post(req
, ev
);
5019 tevent_req_set_callback(subreq
, rpccli_PNP_QueryRemove_done
, req
);
5023 static void rpccli_PNP_QueryRemove_done(struct tevent_req
*subreq
)
5025 struct tevent_req
*req
= tevent_req_callback_data(
5026 subreq
, struct tevent_req
);
5027 struct rpccli_PNP_QueryRemove_state
*state
= tevent_req_data(
5028 req
, struct rpccli_PNP_QueryRemove_state
);
5030 TALLOC_CTX
*mem_ctx
;
5032 if (state
->out_mem_ctx
) {
5033 mem_ctx
= state
->out_mem_ctx
;
5038 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5039 TALLOC_FREE(subreq
);
5040 if (!NT_STATUS_IS_OK(status
)) {
5041 tevent_req_nterror(req
, status
);
5045 /* Copy out parameters */
5048 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5050 /* Reset temporary structure */
5051 ZERO_STRUCT(state
->tmp
);
5053 tevent_req_done(req
);
5056 NTSTATUS
rpccli_PNP_QueryRemove_recv(struct tevent_req
*req
,
5057 TALLOC_CTX
*mem_ctx
,
5060 struct rpccli_PNP_QueryRemove_state
*state
= tevent_req_data(
5061 req
, struct rpccli_PNP_QueryRemove_state
);
5064 if (tevent_req_is_nterror(req
, &status
)) {
5065 tevent_req_received(req
);
5069 /* Steal possbile out parameters to the callers context */
5070 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5073 *result
= state
->orig
.out
.result
;
5075 tevent_req_received(req
);
5076 return NT_STATUS_OK
;
5079 NTSTATUS
rpccli_PNP_QueryRemove(struct rpc_pipe_client
*cli
,
5080 TALLOC_CTX
*mem_ctx
,
5083 struct PNP_QueryRemove r
;
5088 status
= cli
->dispatch(cli
,
5091 NDR_PNP_QUERYREMOVE
,
5094 if (!NT_STATUS_IS_OK(status
)) {
5098 if (NT_STATUS_IS_ERR(status
)) {
5102 /* Return variables */
5106 *werror
= r
.out
.result
;
5109 return werror_to_ntstatus(r
.out
.result
);
5112 struct rpccli_PNP_RequestDeviceEject_state
{
5113 struct PNP_RequestDeviceEject orig
;
5114 struct PNP_RequestDeviceEject tmp
;
5115 TALLOC_CTX
*out_mem_ctx
;
5116 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5119 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req
*subreq
);
5121 struct tevent_req
*rpccli_PNP_RequestDeviceEject_send(TALLOC_CTX
*mem_ctx
,
5122 struct tevent_context
*ev
,
5123 struct rpc_pipe_client
*cli
)
5125 struct tevent_req
*req
;
5126 struct rpccli_PNP_RequestDeviceEject_state
*state
;
5127 struct tevent_req
*subreq
;
5129 req
= tevent_req_create(mem_ctx
, &state
,
5130 struct rpccli_PNP_RequestDeviceEject_state
);
5134 state
->out_mem_ctx
= NULL
;
5135 state
->dispatch_recv
= cli
->dispatch_recv
;
5139 /* Out parameters */
5142 ZERO_STRUCT(state
->orig
.out
.result
);
5144 /* make a temporary copy, that we pass to the dispatch function */
5145 state
->tmp
= state
->orig
;
5147 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5149 NDR_PNP_REQUESTDEVICEEJECT
,
5151 if (tevent_req_nomem(subreq
, req
)) {
5152 return tevent_req_post(req
, ev
);
5154 tevent_req_set_callback(subreq
, rpccli_PNP_RequestDeviceEject_done
, req
);
5158 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req
*subreq
)
5160 struct tevent_req
*req
= tevent_req_callback_data(
5161 subreq
, struct tevent_req
);
5162 struct rpccli_PNP_RequestDeviceEject_state
*state
= tevent_req_data(
5163 req
, struct rpccli_PNP_RequestDeviceEject_state
);
5165 TALLOC_CTX
*mem_ctx
;
5167 if (state
->out_mem_ctx
) {
5168 mem_ctx
= state
->out_mem_ctx
;
5173 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5174 TALLOC_FREE(subreq
);
5175 if (!NT_STATUS_IS_OK(status
)) {
5176 tevent_req_nterror(req
, status
);
5180 /* Copy out parameters */
5183 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5185 /* Reset temporary structure */
5186 ZERO_STRUCT(state
->tmp
);
5188 tevent_req_done(req
);
5191 NTSTATUS
rpccli_PNP_RequestDeviceEject_recv(struct tevent_req
*req
,
5192 TALLOC_CTX
*mem_ctx
,
5195 struct rpccli_PNP_RequestDeviceEject_state
*state
= tevent_req_data(
5196 req
, struct rpccli_PNP_RequestDeviceEject_state
);
5199 if (tevent_req_is_nterror(req
, &status
)) {
5200 tevent_req_received(req
);
5204 /* Steal possbile out parameters to the callers context */
5205 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5208 *result
= state
->orig
.out
.result
;
5210 tevent_req_received(req
);
5211 return NT_STATUS_OK
;
5214 NTSTATUS
rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client
*cli
,
5215 TALLOC_CTX
*mem_ctx
,
5218 struct PNP_RequestDeviceEject r
;
5223 status
= cli
->dispatch(cli
,
5226 NDR_PNP_REQUESTDEVICEEJECT
,
5229 if (!NT_STATUS_IS_OK(status
)) {
5233 if (NT_STATUS_IS_ERR(status
)) {
5237 /* Return variables */
5241 *werror
= r
.out
.result
;
5244 return werror_to_ntstatus(r
.out
.result
);
5247 struct rpccli_PNP_IsDockStationPresent_state
{
5248 struct PNP_IsDockStationPresent orig
;
5249 struct PNP_IsDockStationPresent tmp
;
5250 TALLOC_CTX
*out_mem_ctx
;
5251 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5254 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req
*subreq
);
5256 struct tevent_req
*rpccli_PNP_IsDockStationPresent_send(TALLOC_CTX
*mem_ctx
,
5257 struct tevent_context
*ev
,
5258 struct rpc_pipe_client
*cli
)
5260 struct tevent_req
*req
;
5261 struct rpccli_PNP_IsDockStationPresent_state
*state
;
5262 struct tevent_req
*subreq
;
5264 req
= tevent_req_create(mem_ctx
, &state
,
5265 struct rpccli_PNP_IsDockStationPresent_state
);
5269 state
->out_mem_ctx
= NULL
;
5270 state
->dispatch_recv
= cli
->dispatch_recv
;
5274 /* Out parameters */
5277 ZERO_STRUCT(state
->orig
.out
.result
);
5279 /* make a temporary copy, that we pass to the dispatch function */
5280 state
->tmp
= state
->orig
;
5282 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5284 NDR_PNP_ISDOCKSTATIONPRESENT
,
5286 if (tevent_req_nomem(subreq
, req
)) {
5287 return tevent_req_post(req
, ev
);
5289 tevent_req_set_callback(subreq
, rpccli_PNP_IsDockStationPresent_done
, req
);
5293 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req
*subreq
)
5295 struct tevent_req
*req
= tevent_req_callback_data(
5296 subreq
, struct tevent_req
);
5297 struct rpccli_PNP_IsDockStationPresent_state
*state
= tevent_req_data(
5298 req
, struct rpccli_PNP_IsDockStationPresent_state
);
5300 TALLOC_CTX
*mem_ctx
;
5302 if (state
->out_mem_ctx
) {
5303 mem_ctx
= state
->out_mem_ctx
;
5308 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5309 TALLOC_FREE(subreq
);
5310 if (!NT_STATUS_IS_OK(status
)) {
5311 tevent_req_nterror(req
, status
);
5315 /* Copy out parameters */
5318 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5320 /* Reset temporary structure */
5321 ZERO_STRUCT(state
->tmp
);
5323 tevent_req_done(req
);
5326 NTSTATUS
rpccli_PNP_IsDockStationPresent_recv(struct tevent_req
*req
,
5327 TALLOC_CTX
*mem_ctx
,
5330 struct rpccli_PNP_IsDockStationPresent_state
*state
= tevent_req_data(
5331 req
, struct rpccli_PNP_IsDockStationPresent_state
);
5334 if (tevent_req_is_nterror(req
, &status
)) {
5335 tevent_req_received(req
);
5339 /* Steal possbile out parameters to the callers context */
5340 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5343 *result
= state
->orig
.out
.result
;
5345 tevent_req_received(req
);
5346 return NT_STATUS_OK
;
5349 NTSTATUS
rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client
*cli
,
5350 TALLOC_CTX
*mem_ctx
,
5353 struct PNP_IsDockStationPresent r
;
5358 status
= cli
->dispatch(cli
,
5361 NDR_PNP_ISDOCKSTATIONPRESENT
,
5364 if (!NT_STATUS_IS_OK(status
)) {
5368 if (NT_STATUS_IS_ERR(status
)) {
5372 /* Return variables */
5376 *werror
= r
.out
.result
;
5379 return werror_to_ntstatus(r
.out
.result
);
5382 struct rpccli_PNP_RequestEjectPC_state
{
5383 struct PNP_RequestEjectPC orig
;
5384 struct PNP_RequestEjectPC tmp
;
5385 TALLOC_CTX
*out_mem_ctx
;
5386 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5389 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req
*subreq
);
5391 struct tevent_req
*rpccli_PNP_RequestEjectPC_send(TALLOC_CTX
*mem_ctx
,
5392 struct tevent_context
*ev
,
5393 struct rpc_pipe_client
*cli
)
5395 struct tevent_req
*req
;
5396 struct rpccli_PNP_RequestEjectPC_state
*state
;
5397 struct tevent_req
*subreq
;
5399 req
= tevent_req_create(mem_ctx
, &state
,
5400 struct rpccli_PNP_RequestEjectPC_state
);
5404 state
->out_mem_ctx
= NULL
;
5405 state
->dispatch_recv
= cli
->dispatch_recv
;
5409 /* Out parameters */
5412 ZERO_STRUCT(state
->orig
.out
.result
);
5414 /* make a temporary copy, that we pass to the dispatch function */
5415 state
->tmp
= state
->orig
;
5417 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5419 NDR_PNP_REQUESTEJECTPC
,
5421 if (tevent_req_nomem(subreq
, req
)) {
5422 return tevent_req_post(req
, ev
);
5424 tevent_req_set_callback(subreq
, rpccli_PNP_RequestEjectPC_done
, req
);
5428 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req
*subreq
)
5430 struct tevent_req
*req
= tevent_req_callback_data(
5431 subreq
, struct tevent_req
);
5432 struct rpccli_PNP_RequestEjectPC_state
*state
= tevent_req_data(
5433 req
, struct rpccli_PNP_RequestEjectPC_state
);
5435 TALLOC_CTX
*mem_ctx
;
5437 if (state
->out_mem_ctx
) {
5438 mem_ctx
= state
->out_mem_ctx
;
5443 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5444 TALLOC_FREE(subreq
);
5445 if (!NT_STATUS_IS_OK(status
)) {
5446 tevent_req_nterror(req
, status
);
5450 /* Copy out parameters */
5453 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5455 /* Reset temporary structure */
5456 ZERO_STRUCT(state
->tmp
);
5458 tevent_req_done(req
);
5461 NTSTATUS
rpccli_PNP_RequestEjectPC_recv(struct tevent_req
*req
,
5462 TALLOC_CTX
*mem_ctx
,
5465 struct rpccli_PNP_RequestEjectPC_state
*state
= tevent_req_data(
5466 req
, struct rpccli_PNP_RequestEjectPC_state
);
5469 if (tevent_req_is_nterror(req
, &status
)) {
5470 tevent_req_received(req
);
5474 /* Steal possbile out parameters to the callers context */
5475 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5478 *result
= state
->orig
.out
.result
;
5480 tevent_req_received(req
);
5481 return NT_STATUS_OK
;
5484 NTSTATUS
rpccli_PNP_RequestEjectPC(struct rpc_pipe_client
*cli
,
5485 TALLOC_CTX
*mem_ctx
,
5488 struct PNP_RequestEjectPC r
;
5493 status
= cli
->dispatch(cli
,
5496 NDR_PNP_REQUESTEJECTPC
,
5499 if (!NT_STATUS_IS_OK(status
)) {
5503 if (NT_STATUS_IS_ERR(status
)) {
5507 /* Return variables */
5511 *werror
= r
.out
.result
;
5514 return werror_to_ntstatus(r
.out
.result
);
5517 struct rpccli_PNP_HwProfFlags_state
{
5518 struct PNP_HwProfFlags orig
;
5519 struct PNP_HwProfFlags tmp
;
5520 TALLOC_CTX
*out_mem_ctx
;
5521 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5524 static void rpccli_PNP_HwProfFlags_done(struct tevent_req
*subreq
);
5526 struct tevent_req
*rpccli_PNP_HwProfFlags_send(TALLOC_CTX
*mem_ctx
,
5527 struct tevent_context
*ev
,
5528 struct rpc_pipe_client
*cli
,
5529 uint32_t _action
/* [in] */,
5530 const char *_devicepath
/* [in] [ref,charset(UTF16)] */,
5531 uint32_t _config
/* [in] */,
5532 uint32_t *_profile_flags
/* [in,out] [ref] */,
5533 uint16_t *_veto_type
/* [in,out] [unique] */,
5534 const char *_unknown5
/* [in] [unique,charset(UTF16)] */,
5535 const char **_unknown5a
/* [out] [unique,charset(UTF16)] */,
5536 uint32_t _name_length
/* [in] */,
5537 uint32_t _flags
/* [in] */)
5539 struct tevent_req
*req
;
5540 struct rpccli_PNP_HwProfFlags_state
*state
;
5541 struct tevent_req
*subreq
;
5543 req
= tevent_req_create(mem_ctx
, &state
,
5544 struct rpccli_PNP_HwProfFlags_state
);
5548 state
->out_mem_ctx
= NULL
;
5549 state
->dispatch_recv
= cli
->dispatch_recv
;
5552 state
->orig
.in
.action
= _action
;
5553 state
->orig
.in
.devicepath
= _devicepath
;
5554 state
->orig
.in
.config
= _config
;
5555 state
->orig
.in
.profile_flags
= _profile_flags
;
5556 state
->orig
.in
.veto_type
= _veto_type
;
5557 state
->orig
.in
.unknown5
= _unknown5
;
5558 state
->orig
.in
.name_length
= _name_length
;
5559 state
->orig
.in
.flags
= _flags
;
5561 /* Out parameters */
5562 state
->orig
.out
.profile_flags
= _profile_flags
;
5563 state
->orig
.out
.veto_type
= _veto_type
;
5564 state
->orig
.out
.unknown5a
= _unknown5a
;
5567 ZERO_STRUCT(state
->orig
.out
.result
);
5569 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5570 "rpccli_PNP_HwProfFlags_out_memory");
5571 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5572 return tevent_req_post(req
, ev
);
5575 /* make a temporary copy, that we pass to the dispatch function */
5576 state
->tmp
= state
->orig
;
5578 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5580 NDR_PNP_HWPROFFLAGS
,
5582 if (tevent_req_nomem(subreq
, req
)) {
5583 return tevent_req_post(req
, ev
);
5585 tevent_req_set_callback(subreq
, rpccli_PNP_HwProfFlags_done
, req
);
5589 static void rpccli_PNP_HwProfFlags_done(struct tevent_req
*subreq
)
5591 struct tevent_req
*req
= tevent_req_callback_data(
5592 subreq
, struct tevent_req
);
5593 struct rpccli_PNP_HwProfFlags_state
*state
= tevent_req_data(
5594 req
, struct rpccli_PNP_HwProfFlags_state
);
5596 TALLOC_CTX
*mem_ctx
;
5598 if (state
->out_mem_ctx
) {
5599 mem_ctx
= state
->out_mem_ctx
;
5604 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5605 TALLOC_FREE(subreq
);
5606 if (!NT_STATUS_IS_OK(status
)) {
5607 tevent_req_nterror(req
, status
);
5611 /* Copy out parameters */
5612 *state
->orig
.out
.profile_flags
= *state
->tmp
.out
.profile_flags
;
5613 if (state
->orig
.out
.veto_type
&& state
->tmp
.out
.veto_type
) {
5614 *state
->orig
.out
.veto_type
= *state
->tmp
.out
.veto_type
;
5616 if (state
->orig
.out
.unknown5a
&& state
->tmp
.out
.unknown5a
) {
5617 *state
->orig
.out
.unknown5a
= *state
->tmp
.out
.unknown5a
;
5621 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5623 /* Reset temporary structure */
5624 ZERO_STRUCT(state
->tmp
);
5626 tevent_req_done(req
);
5629 NTSTATUS
rpccli_PNP_HwProfFlags_recv(struct tevent_req
*req
,
5630 TALLOC_CTX
*mem_ctx
,
5633 struct rpccli_PNP_HwProfFlags_state
*state
= tevent_req_data(
5634 req
, struct rpccli_PNP_HwProfFlags_state
);
5637 if (tevent_req_is_nterror(req
, &status
)) {
5638 tevent_req_received(req
);
5642 /* Steal possbile out parameters to the callers context */
5643 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5646 *result
= state
->orig
.out
.result
;
5648 tevent_req_received(req
);
5649 return NT_STATUS_OK
;
5652 NTSTATUS
rpccli_PNP_HwProfFlags(struct rpc_pipe_client
*cli
,
5653 TALLOC_CTX
*mem_ctx
,
5654 uint32_t action
/* [in] */,
5655 const char *devicepath
/* [in] [ref,charset(UTF16)] */,
5656 uint32_t config
/* [in] */,
5657 uint32_t *profile_flags
/* [in,out] [ref] */,
5658 uint16_t *veto_type
/* [in,out] [unique] */,
5659 const char *unknown5
/* [in] [unique,charset(UTF16)] */,
5660 const char **unknown5a
/* [out] [unique,charset(UTF16)] */,
5661 uint32_t name_length
/* [in] */,
5662 uint32_t flags
/* [in] */,
5665 struct PNP_HwProfFlags r
;
5669 r
.in
.action
= action
;
5670 r
.in
.devicepath
= devicepath
;
5671 r
.in
.config
= config
;
5672 r
.in
.profile_flags
= profile_flags
;
5673 r
.in
.veto_type
= veto_type
;
5674 r
.in
.unknown5
= unknown5
;
5675 r
.in
.name_length
= name_length
;
5678 status
= cli
->dispatch(cli
,
5681 NDR_PNP_HWPROFFLAGS
,
5684 if (!NT_STATUS_IS_OK(status
)) {
5688 if (NT_STATUS_IS_ERR(status
)) {
5692 /* Return variables */
5693 *profile_flags
= *r
.out
.profile_flags
;
5694 if (veto_type
&& r
.out
.veto_type
) {
5695 *veto_type
= *r
.out
.veto_type
;
5697 if (unknown5a
&& r
.out
.unknown5a
) {
5698 *unknown5a
= *r
.out
.unknown5a
;
5703 *werror
= r
.out
.result
;
5706 return werror_to_ntstatus(r
.out
.result
);
5709 struct rpccli_PNP_GetHwProfInfo_state
{
5710 struct PNP_GetHwProfInfo orig
;
5711 struct PNP_GetHwProfInfo tmp
;
5712 TALLOC_CTX
*out_mem_ctx
;
5713 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5716 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req
*subreq
);
5718 struct tevent_req
*rpccli_PNP_GetHwProfInfo_send(TALLOC_CTX
*mem_ctx
,
5719 struct tevent_context
*ev
,
5720 struct rpc_pipe_client
*cli
,
5721 uint32_t _idx
/* [in] */,
5722 struct PNP_HwProfInfo
*_info
/* [in,out] [ref] */,
5723 uint32_t _size
/* [in] */,
5724 uint32_t _flags
/* [in] */)
5726 struct tevent_req
*req
;
5727 struct rpccli_PNP_GetHwProfInfo_state
*state
;
5728 struct tevent_req
*subreq
;
5730 req
= tevent_req_create(mem_ctx
, &state
,
5731 struct rpccli_PNP_GetHwProfInfo_state
);
5735 state
->out_mem_ctx
= NULL
;
5736 state
->dispatch_recv
= cli
->dispatch_recv
;
5739 state
->orig
.in
.idx
= _idx
;
5740 state
->orig
.in
.info
= _info
;
5741 state
->orig
.in
.size
= _size
;
5742 state
->orig
.in
.flags
= _flags
;
5744 /* Out parameters */
5745 state
->orig
.out
.info
= _info
;
5748 ZERO_STRUCT(state
->orig
.out
.result
);
5750 state
->out_mem_ctx
= talloc_named_const(state
, 0,
5751 "rpccli_PNP_GetHwProfInfo_out_memory");
5752 if (tevent_req_nomem(state
->out_mem_ctx
, req
)) {
5753 return tevent_req_post(req
, ev
);
5756 /* make a temporary copy, that we pass to the dispatch function */
5757 state
->tmp
= state
->orig
;
5759 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5761 NDR_PNP_GETHWPROFINFO
,
5763 if (tevent_req_nomem(subreq
, req
)) {
5764 return tevent_req_post(req
, ev
);
5766 tevent_req_set_callback(subreq
, rpccli_PNP_GetHwProfInfo_done
, req
);
5770 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req
*subreq
)
5772 struct tevent_req
*req
= tevent_req_callback_data(
5773 subreq
, struct tevent_req
);
5774 struct rpccli_PNP_GetHwProfInfo_state
*state
= tevent_req_data(
5775 req
, struct rpccli_PNP_GetHwProfInfo_state
);
5777 TALLOC_CTX
*mem_ctx
;
5779 if (state
->out_mem_ctx
) {
5780 mem_ctx
= state
->out_mem_ctx
;
5785 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5786 TALLOC_FREE(subreq
);
5787 if (!NT_STATUS_IS_OK(status
)) {
5788 tevent_req_nterror(req
, status
);
5792 /* Copy out parameters */
5793 *state
->orig
.out
.info
= *state
->tmp
.out
.info
;
5796 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5798 /* Reset temporary structure */
5799 ZERO_STRUCT(state
->tmp
);
5801 tevent_req_done(req
);
5804 NTSTATUS
rpccli_PNP_GetHwProfInfo_recv(struct tevent_req
*req
,
5805 TALLOC_CTX
*mem_ctx
,
5808 struct rpccli_PNP_GetHwProfInfo_state
*state
= tevent_req_data(
5809 req
, struct rpccli_PNP_GetHwProfInfo_state
);
5812 if (tevent_req_is_nterror(req
, &status
)) {
5813 tevent_req_received(req
);
5817 /* Steal possbile out parameters to the callers context */
5818 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5821 *result
= state
->orig
.out
.result
;
5823 tevent_req_received(req
);
5824 return NT_STATUS_OK
;
5827 NTSTATUS
rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client
*cli
,
5828 TALLOC_CTX
*mem_ctx
,
5829 uint32_t idx
/* [in] */,
5830 struct PNP_HwProfInfo
*info
/* [in,out] [ref] */,
5831 uint32_t size
/* [in] */,
5832 uint32_t flags
/* [in] */,
5835 struct PNP_GetHwProfInfo r
;
5844 status
= cli
->dispatch(cli
,
5847 NDR_PNP_GETHWPROFINFO
,
5850 if (!NT_STATUS_IS_OK(status
)) {
5854 if (NT_STATUS_IS_ERR(status
)) {
5858 /* Return variables */
5859 *info
= *r
.out
.info
;
5863 *werror
= r
.out
.result
;
5866 return werror_to_ntstatus(r
.out
.result
);
5869 struct rpccli_PNP_AddEmptyLogConf_state
{
5870 struct PNP_AddEmptyLogConf orig
;
5871 struct PNP_AddEmptyLogConf tmp
;
5872 TALLOC_CTX
*out_mem_ctx
;
5873 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
5876 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req
*subreq
);
5878 struct tevent_req
*rpccli_PNP_AddEmptyLogConf_send(TALLOC_CTX
*mem_ctx
,
5879 struct tevent_context
*ev
,
5880 struct rpc_pipe_client
*cli
)
5882 struct tevent_req
*req
;
5883 struct rpccli_PNP_AddEmptyLogConf_state
*state
;
5884 struct tevent_req
*subreq
;
5886 req
= tevent_req_create(mem_ctx
, &state
,
5887 struct rpccli_PNP_AddEmptyLogConf_state
);
5891 state
->out_mem_ctx
= NULL
;
5892 state
->dispatch_recv
= cli
->dispatch_recv
;
5896 /* Out parameters */
5899 ZERO_STRUCT(state
->orig
.out
.result
);
5901 /* make a temporary copy, that we pass to the dispatch function */
5902 state
->tmp
= state
->orig
;
5904 subreq
= cli
->dispatch_send(state
, ev
, cli
,
5906 NDR_PNP_ADDEMPTYLOGCONF
,
5908 if (tevent_req_nomem(subreq
, req
)) {
5909 return tevent_req_post(req
, ev
);
5911 tevent_req_set_callback(subreq
, rpccli_PNP_AddEmptyLogConf_done
, req
);
5915 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req
*subreq
)
5917 struct tevent_req
*req
= tevent_req_callback_data(
5918 subreq
, struct tevent_req
);
5919 struct rpccli_PNP_AddEmptyLogConf_state
*state
= tevent_req_data(
5920 req
, struct rpccli_PNP_AddEmptyLogConf_state
);
5922 TALLOC_CTX
*mem_ctx
;
5924 if (state
->out_mem_ctx
) {
5925 mem_ctx
= state
->out_mem_ctx
;
5930 status
= state
->dispatch_recv(subreq
, mem_ctx
);
5931 TALLOC_FREE(subreq
);
5932 if (!NT_STATUS_IS_OK(status
)) {
5933 tevent_req_nterror(req
, status
);
5937 /* Copy out parameters */
5940 state
->orig
.out
.result
= state
->tmp
.out
.result
;
5942 /* Reset temporary structure */
5943 ZERO_STRUCT(state
->tmp
);
5945 tevent_req_done(req
);
5948 NTSTATUS
rpccli_PNP_AddEmptyLogConf_recv(struct tevent_req
*req
,
5949 TALLOC_CTX
*mem_ctx
,
5952 struct rpccli_PNP_AddEmptyLogConf_state
*state
= tevent_req_data(
5953 req
, struct rpccli_PNP_AddEmptyLogConf_state
);
5956 if (tevent_req_is_nterror(req
, &status
)) {
5957 tevent_req_received(req
);
5961 /* Steal possbile out parameters to the callers context */
5962 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
5965 *result
= state
->orig
.out
.result
;
5967 tevent_req_received(req
);
5968 return NT_STATUS_OK
;
5971 NTSTATUS
rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client
*cli
,
5972 TALLOC_CTX
*mem_ctx
,
5975 struct PNP_AddEmptyLogConf r
;
5980 status
= cli
->dispatch(cli
,
5983 NDR_PNP_ADDEMPTYLOGCONF
,
5986 if (!NT_STATUS_IS_OK(status
)) {
5990 if (NT_STATUS_IS_ERR(status
)) {
5994 /* Return variables */
5998 *werror
= r
.out
.result
;
6001 return werror_to_ntstatus(r
.out
.result
);
6004 struct rpccli_PNP_FreeLogConf_state
{
6005 struct PNP_FreeLogConf orig
;
6006 struct PNP_FreeLogConf tmp
;
6007 TALLOC_CTX
*out_mem_ctx
;
6008 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6011 static void rpccli_PNP_FreeLogConf_done(struct tevent_req
*subreq
);
6013 struct tevent_req
*rpccli_PNP_FreeLogConf_send(TALLOC_CTX
*mem_ctx
,
6014 struct tevent_context
*ev
,
6015 struct rpc_pipe_client
*cli
)
6017 struct tevent_req
*req
;
6018 struct rpccli_PNP_FreeLogConf_state
*state
;
6019 struct tevent_req
*subreq
;
6021 req
= tevent_req_create(mem_ctx
, &state
,
6022 struct rpccli_PNP_FreeLogConf_state
);
6026 state
->out_mem_ctx
= NULL
;
6027 state
->dispatch_recv
= cli
->dispatch_recv
;
6031 /* Out parameters */
6034 ZERO_STRUCT(state
->orig
.out
.result
);
6036 /* make a temporary copy, that we pass to the dispatch function */
6037 state
->tmp
= state
->orig
;
6039 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6041 NDR_PNP_FREELOGCONF
,
6043 if (tevent_req_nomem(subreq
, req
)) {
6044 return tevent_req_post(req
, ev
);
6046 tevent_req_set_callback(subreq
, rpccli_PNP_FreeLogConf_done
, req
);
6050 static void rpccli_PNP_FreeLogConf_done(struct tevent_req
*subreq
)
6052 struct tevent_req
*req
= tevent_req_callback_data(
6053 subreq
, struct tevent_req
);
6054 struct rpccli_PNP_FreeLogConf_state
*state
= tevent_req_data(
6055 req
, struct rpccli_PNP_FreeLogConf_state
);
6057 TALLOC_CTX
*mem_ctx
;
6059 if (state
->out_mem_ctx
) {
6060 mem_ctx
= state
->out_mem_ctx
;
6065 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6066 TALLOC_FREE(subreq
);
6067 if (!NT_STATUS_IS_OK(status
)) {
6068 tevent_req_nterror(req
, status
);
6072 /* Copy out parameters */
6075 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6077 /* Reset temporary structure */
6078 ZERO_STRUCT(state
->tmp
);
6080 tevent_req_done(req
);
6083 NTSTATUS
rpccli_PNP_FreeLogConf_recv(struct tevent_req
*req
,
6084 TALLOC_CTX
*mem_ctx
,
6087 struct rpccli_PNP_FreeLogConf_state
*state
= tevent_req_data(
6088 req
, struct rpccli_PNP_FreeLogConf_state
);
6091 if (tevent_req_is_nterror(req
, &status
)) {
6092 tevent_req_received(req
);
6096 /* Steal possbile out parameters to the callers context */
6097 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6100 *result
= state
->orig
.out
.result
;
6102 tevent_req_received(req
);
6103 return NT_STATUS_OK
;
6106 NTSTATUS
rpccli_PNP_FreeLogConf(struct rpc_pipe_client
*cli
,
6107 TALLOC_CTX
*mem_ctx
,
6110 struct PNP_FreeLogConf r
;
6115 status
= cli
->dispatch(cli
,
6118 NDR_PNP_FREELOGCONF
,
6121 if (!NT_STATUS_IS_OK(status
)) {
6125 if (NT_STATUS_IS_ERR(status
)) {
6129 /* Return variables */
6133 *werror
= r
.out
.result
;
6136 return werror_to_ntstatus(r
.out
.result
);
6139 struct rpccli_PNP_GetFirstLogConf_state
{
6140 struct PNP_GetFirstLogConf orig
;
6141 struct PNP_GetFirstLogConf tmp
;
6142 TALLOC_CTX
*out_mem_ctx
;
6143 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6146 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req
*subreq
);
6148 struct tevent_req
*rpccli_PNP_GetFirstLogConf_send(TALLOC_CTX
*mem_ctx
,
6149 struct tevent_context
*ev
,
6150 struct rpc_pipe_client
*cli
)
6152 struct tevent_req
*req
;
6153 struct rpccli_PNP_GetFirstLogConf_state
*state
;
6154 struct tevent_req
*subreq
;
6156 req
= tevent_req_create(mem_ctx
, &state
,
6157 struct rpccli_PNP_GetFirstLogConf_state
);
6161 state
->out_mem_ctx
= NULL
;
6162 state
->dispatch_recv
= cli
->dispatch_recv
;
6166 /* Out parameters */
6169 ZERO_STRUCT(state
->orig
.out
.result
);
6171 /* make a temporary copy, that we pass to the dispatch function */
6172 state
->tmp
= state
->orig
;
6174 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6176 NDR_PNP_GETFIRSTLOGCONF
,
6178 if (tevent_req_nomem(subreq
, req
)) {
6179 return tevent_req_post(req
, ev
);
6181 tevent_req_set_callback(subreq
, rpccli_PNP_GetFirstLogConf_done
, req
);
6185 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req
*subreq
)
6187 struct tevent_req
*req
= tevent_req_callback_data(
6188 subreq
, struct tevent_req
);
6189 struct rpccli_PNP_GetFirstLogConf_state
*state
= tevent_req_data(
6190 req
, struct rpccli_PNP_GetFirstLogConf_state
);
6192 TALLOC_CTX
*mem_ctx
;
6194 if (state
->out_mem_ctx
) {
6195 mem_ctx
= state
->out_mem_ctx
;
6200 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6201 TALLOC_FREE(subreq
);
6202 if (!NT_STATUS_IS_OK(status
)) {
6203 tevent_req_nterror(req
, status
);
6207 /* Copy out parameters */
6210 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6212 /* Reset temporary structure */
6213 ZERO_STRUCT(state
->tmp
);
6215 tevent_req_done(req
);
6218 NTSTATUS
rpccli_PNP_GetFirstLogConf_recv(struct tevent_req
*req
,
6219 TALLOC_CTX
*mem_ctx
,
6222 struct rpccli_PNP_GetFirstLogConf_state
*state
= tevent_req_data(
6223 req
, struct rpccli_PNP_GetFirstLogConf_state
);
6226 if (tevent_req_is_nterror(req
, &status
)) {
6227 tevent_req_received(req
);
6231 /* Steal possbile out parameters to the callers context */
6232 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6235 *result
= state
->orig
.out
.result
;
6237 tevent_req_received(req
);
6238 return NT_STATUS_OK
;
6241 NTSTATUS
rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client
*cli
,
6242 TALLOC_CTX
*mem_ctx
,
6245 struct PNP_GetFirstLogConf r
;
6250 status
= cli
->dispatch(cli
,
6253 NDR_PNP_GETFIRSTLOGCONF
,
6256 if (!NT_STATUS_IS_OK(status
)) {
6260 if (NT_STATUS_IS_ERR(status
)) {
6264 /* Return variables */
6268 *werror
= r
.out
.result
;
6271 return werror_to_ntstatus(r
.out
.result
);
6274 struct rpccli_PNP_GetNextLogConf_state
{
6275 struct PNP_GetNextLogConf orig
;
6276 struct PNP_GetNextLogConf tmp
;
6277 TALLOC_CTX
*out_mem_ctx
;
6278 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6281 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req
*subreq
);
6283 struct tevent_req
*rpccli_PNP_GetNextLogConf_send(TALLOC_CTX
*mem_ctx
,
6284 struct tevent_context
*ev
,
6285 struct rpc_pipe_client
*cli
)
6287 struct tevent_req
*req
;
6288 struct rpccli_PNP_GetNextLogConf_state
*state
;
6289 struct tevent_req
*subreq
;
6291 req
= tevent_req_create(mem_ctx
, &state
,
6292 struct rpccli_PNP_GetNextLogConf_state
);
6296 state
->out_mem_ctx
= NULL
;
6297 state
->dispatch_recv
= cli
->dispatch_recv
;
6301 /* Out parameters */
6304 ZERO_STRUCT(state
->orig
.out
.result
);
6306 /* make a temporary copy, that we pass to the dispatch function */
6307 state
->tmp
= state
->orig
;
6309 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6311 NDR_PNP_GETNEXTLOGCONF
,
6313 if (tevent_req_nomem(subreq
, req
)) {
6314 return tevent_req_post(req
, ev
);
6316 tevent_req_set_callback(subreq
, rpccli_PNP_GetNextLogConf_done
, req
);
6320 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req
*subreq
)
6322 struct tevent_req
*req
= tevent_req_callback_data(
6323 subreq
, struct tevent_req
);
6324 struct rpccli_PNP_GetNextLogConf_state
*state
= tevent_req_data(
6325 req
, struct rpccli_PNP_GetNextLogConf_state
);
6327 TALLOC_CTX
*mem_ctx
;
6329 if (state
->out_mem_ctx
) {
6330 mem_ctx
= state
->out_mem_ctx
;
6335 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6336 TALLOC_FREE(subreq
);
6337 if (!NT_STATUS_IS_OK(status
)) {
6338 tevent_req_nterror(req
, status
);
6342 /* Copy out parameters */
6345 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6347 /* Reset temporary structure */
6348 ZERO_STRUCT(state
->tmp
);
6350 tevent_req_done(req
);
6353 NTSTATUS
rpccli_PNP_GetNextLogConf_recv(struct tevent_req
*req
,
6354 TALLOC_CTX
*mem_ctx
,
6357 struct rpccli_PNP_GetNextLogConf_state
*state
= tevent_req_data(
6358 req
, struct rpccli_PNP_GetNextLogConf_state
);
6361 if (tevent_req_is_nterror(req
, &status
)) {
6362 tevent_req_received(req
);
6366 /* Steal possbile out parameters to the callers context */
6367 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6370 *result
= state
->orig
.out
.result
;
6372 tevent_req_received(req
);
6373 return NT_STATUS_OK
;
6376 NTSTATUS
rpccli_PNP_GetNextLogConf(struct rpc_pipe_client
*cli
,
6377 TALLOC_CTX
*mem_ctx
,
6380 struct PNP_GetNextLogConf r
;
6385 status
= cli
->dispatch(cli
,
6388 NDR_PNP_GETNEXTLOGCONF
,
6391 if (!NT_STATUS_IS_OK(status
)) {
6395 if (NT_STATUS_IS_ERR(status
)) {
6399 /* Return variables */
6403 *werror
= r
.out
.result
;
6406 return werror_to_ntstatus(r
.out
.result
);
6409 struct rpccli_PNP_GetLogConfPriority_state
{
6410 struct PNP_GetLogConfPriority orig
;
6411 struct PNP_GetLogConfPriority tmp
;
6412 TALLOC_CTX
*out_mem_ctx
;
6413 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6416 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req
*subreq
);
6418 struct tevent_req
*rpccli_PNP_GetLogConfPriority_send(TALLOC_CTX
*mem_ctx
,
6419 struct tevent_context
*ev
,
6420 struct rpc_pipe_client
*cli
)
6422 struct tevent_req
*req
;
6423 struct rpccli_PNP_GetLogConfPriority_state
*state
;
6424 struct tevent_req
*subreq
;
6426 req
= tevent_req_create(mem_ctx
, &state
,
6427 struct rpccli_PNP_GetLogConfPriority_state
);
6431 state
->out_mem_ctx
= NULL
;
6432 state
->dispatch_recv
= cli
->dispatch_recv
;
6436 /* Out parameters */
6439 ZERO_STRUCT(state
->orig
.out
.result
);
6441 /* make a temporary copy, that we pass to the dispatch function */
6442 state
->tmp
= state
->orig
;
6444 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6446 NDR_PNP_GETLOGCONFPRIORITY
,
6448 if (tevent_req_nomem(subreq
, req
)) {
6449 return tevent_req_post(req
, ev
);
6451 tevent_req_set_callback(subreq
, rpccli_PNP_GetLogConfPriority_done
, req
);
6455 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req
*subreq
)
6457 struct tevent_req
*req
= tevent_req_callback_data(
6458 subreq
, struct tevent_req
);
6459 struct rpccli_PNP_GetLogConfPriority_state
*state
= tevent_req_data(
6460 req
, struct rpccli_PNP_GetLogConfPriority_state
);
6462 TALLOC_CTX
*mem_ctx
;
6464 if (state
->out_mem_ctx
) {
6465 mem_ctx
= state
->out_mem_ctx
;
6470 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6471 TALLOC_FREE(subreq
);
6472 if (!NT_STATUS_IS_OK(status
)) {
6473 tevent_req_nterror(req
, status
);
6477 /* Copy out parameters */
6480 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6482 /* Reset temporary structure */
6483 ZERO_STRUCT(state
->tmp
);
6485 tevent_req_done(req
);
6488 NTSTATUS
rpccli_PNP_GetLogConfPriority_recv(struct tevent_req
*req
,
6489 TALLOC_CTX
*mem_ctx
,
6492 struct rpccli_PNP_GetLogConfPriority_state
*state
= tevent_req_data(
6493 req
, struct rpccli_PNP_GetLogConfPriority_state
);
6496 if (tevent_req_is_nterror(req
, &status
)) {
6497 tevent_req_received(req
);
6501 /* Steal possbile out parameters to the callers context */
6502 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6505 *result
= state
->orig
.out
.result
;
6507 tevent_req_received(req
);
6508 return NT_STATUS_OK
;
6511 NTSTATUS
rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client
*cli
,
6512 TALLOC_CTX
*mem_ctx
,
6515 struct PNP_GetLogConfPriority r
;
6520 status
= cli
->dispatch(cli
,
6523 NDR_PNP_GETLOGCONFPRIORITY
,
6526 if (!NT_STATUS_IS_OK(status
)) {
6530 if (NT_STATUS_IS_ERR(status
)) {
6534 /* Return variables */
6538 *werror
= r
.out
.result
;
6541 return werror_to_ntstatus(r
.out
.result
);
6544 struct rpccli_PNP_AddResDes_state
{
6545 struct PNP_AddResDes orig
;
6546 struct PNP_AddResDes tmp
;
6547 TALLOC_CTX
*out_mem_ctx
;
6548 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6551 static void rpccli_PNP_AddResDes_done(struct tevent_req
*subreq
);
6553 struct tevent_req
*rpccli_PNP_AddResDes_send(TALLOC_CTX
*mem_ctx
,
6554 struct tevent_context
*ev
,
6555 struct rpc_pipe_client
*cli
)
6557 struct tevent_req
*req
;
6558 struct rpccli_PNP_AddResDes_state
*state
;
6559 struct tevent_req
*subreq
;
6561 req
= tevent_req_create(mem_ctx
, &state
,
6562 struct rpccli_PNP_AddResDes_state
);
6566 state
->out_mem_ctx
= NULL
;
6567 state
->dispatch_recv
= cli
->dispatch_recv
;
6571 /* Out parameters */
6574 ZERO_STRUCT(state
->orig
.out
.result
);
6576 /* make a temporary copy, that we pass to the dispatch function */
6577 state
->tmp
= state
->orig
;
6579 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6583 if (tevent_req_nomem(subreq
, req
)) {
6584 return tevent_req_post(req
, ev
);
6586 tevent_req_set_callback(subreq
, rpccli_PNP_AddResDes_done
, req
);
6590 static void rpccli_PNP_AddResDes_done(struct tevent_req
*subreq
)
6592 struct tevent_req
*req
= tevent_req_callback_data(
6593 subreq
, struct tevent_req
);
6594 struct rpccli_PNP_AddResDes_state
*state
= tevent_req_data(
6595 req
, struct rpccli_PNP_AddResDes_state
);
6597 TALLOC_CTX
*mem_ctx
;
6599 if (state
->out_mem_ctx
) {
6600 mem_ctx
= state
->out_mem_ctx
;
6605 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6606 TALLOC_FREE(subreq
);
6607 if (!NT_STATUS_IS_OK(status
)) {
6608 tevent_req_nterror(req
, status
);
6612 /* Copy out parameters */
6615 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6617 /* Reset temporary structure */
6618 ZERO_STRUCT(state
->tmp
);
6620 tevent_req_done(req
);
6623 NTSTATUS
rpccli_PNP_AddResDes_recv(struct tevent_req
*req
,
6624 TALLOC_CTX
*mem_ctx
,
6627 struct rpccli_PNP_AddResDes_state
*state
= tevent_req_data(
6628 req
, struct rpccli_PNP_AddResDes_state
);
6631 if (tevent_req_is_nterror(req
, &status
)) {
6632 tevent_req_received(req
);
6636 /* Steal possbile out parameters to the callers context */
6637 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6640 *result
= state
->orig
.out
.result
;
6642 tevent_req_received(req
);
6643 return NT_STATUS_OK
;
6646 NTSTATUS
rpccli_PNP_AddResDes(struct rpc_pipe_client
*cli
,
6647 TALLOC_CTX
*mem_ctx
,
6650 struct PNP_AddResDes r
;
6655 status
= cli
->dispatch(cli
,
6661 if (!NT_STATUS_IS_OK(status
)) {
6665 if (NT_STATUS_IS_ERR(status
)) {
6669 /* Return variables */
6673 *werror
= r
.out
.result
;
6676 return werror_to_ntstatus(r
.out
.result
);
6679 struct rpccli_PNP_FreeResDes_state
{
6680 struct PNP_FreeResDes orig
;
6681 struct PNP_FreeResDes tmp
;
6682 TALLOC_CTX
*out_mem_ctx
;
6683 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6686 static void rpccli_PNP_FreeResDes_done(struct tevent_req
*subreq
);
6688 struct tevent_req
*rpccli_PNP_FreeResDes_send(TALLOC_CTX
*mem_ctx
,
6689 struct tevent_context
*ev
,
6690 struct rpc_pipe_client
*cli
)
6692 struct tevent_req
*req
;
6693 struct rpccli_PNP_FreeResDes_state
*state
;
6694 struct tevent_req
*subreq
;
6696 req
= tevent_req_create(mem_ctx
, &state
,
6697 struct rpccli_PNP_FreeResDes_state
);
6701 state
->out_mem_ctx
= NULL
;
6702 state
->dispatch_recv
= cli
->dispatch_recv
;
6706 /* Out parameters */
6709 ZERO_STRUCT(state
->orig
.out
.result
);
6711 /* make a temporary copy, that we pass to the dispatch function */
6712 state
->tmp
= state
->orig
;
6714 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6718 if (tevent_req_nomem(subreq
, req
)) {
6719 return tevent_req_post(req
, ev
);
6721 tevent_req_set_callback(subreq
, rpccli_PNP_FreeResDes_done
, req
);
6725 static void rpccli_PNP_FreeResDes_done(struct tevent_req
*subreq
)
6727 struct tevent_req
*req
= tevent_req_callback_data(
6728 subreq
, struct tevent_req
);
6729 struct rpccli_PNP_FreeResDes_state
*state
= tevent_req_data(
6730 req
, struct rpccli_PNP_FreeResDes_state
);
6732 TALLOC_CTX
*mem_ctx
;
6734 if (state
->out_mem_ctx
) {
6735 mem_ctx
= state
->out_mem_ctx
;
6740 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6741 TALLOC_FREE(subreq
);
6742 if (!NT_STATUS_IS_OK(status
)) {
6743 tevent_req_nterror(req
, status
);
6747 /* Copy out parameters */
6750 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6752 /* Reset temporary structure */
6753 ZERO_STRUCT(state
->tmp
);
6755 tevent_req_done(req
);
6758 NTSTATUS
rpccli_PNP_FreeResDes_recv(struct tevent_req
*req
,
6759 TALLOC_CTX
*mem_ctx
,
6762 struct rpccli_PNP_FreeResDes_state
*state
= tevent_req_data(
6763 req
, struct rpccli_PNP_FreeResDes_state
);
6766 if (tevent_req_is_nterror(req
, &status
)) {
6767 tevent_req_received(req
);
6771 /* Steal possbile out parameters to the callers context */
6772 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6775 *result
= state
->orig
.out
.result
;
6777 tevent_req_received(req
);
6778 return NT_STATUS_OK
;
6781 NTSTATUS
rpccli_PNP_FreeResDes(struct rpc_pipe_client
*cli
,
6782 TALLOC_CTX
*mem_ctx
,
6785 struct PNP_FreeResDes r
;
6790 status
= cli
->dispatch(cli
,
6796 if (!NT_STATUS_IS_OK(status
)) {
6800 if (NT_STATUS_IS_ERR(status
)) {
6804 /* Return variables */
6808 *werror
= r
.out
.result
;
6811 return werror_to_ntstatus(r
.out
.result
);
6814 struct rpccli_PNP_GetNextResDes_state
{
6815 struct PNP_GetNextResDes orig
;
6816 struct PNP_GetNextResDes tmp
;
6817 TALLOC_CTX
*out_mem_ctx
;
6818 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6821 static void rpccli_PNP_GetNextResDes_done(struct tevent_req
*subreq
);
6823 struct tevent_req
*rpccli_PNP_GetNextResDes_send(TALLOC_CTX
*mem_ctx
,
6824 struct tevent_context
*ev
,
6825 struct rpc_pipe_client
*cli
)
6827 struct tevent_req
*req
;
6828 struct rpccli_PNP_GetNextResDes_state
*state
;
6829 struct tevent_req
*subreq
;
6831 req
= tevent_req_create(mem_ctx
, &state
,
6832 struct rpccli_PNP_GetNextResDes_state
);
6836 state
->out_mem_ctx
= NULL
;
6837 state
->dispatch_recv
= cli
->dispatch_recv
;
6841 /* Out parameters */
6844 ZERO_STRUCT(state
->orig
.out
.result
);
6846 /* make a temporary copy, that we pass to the dispatch function */
6847 state
->tmp
= state
->orig
;
6849 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6851 NDR_PNP_GETNEXTRESDES
,
6853 if (tevent_req_nomem(subreq
, req
)) {
6854 return tevent_req_post(req
, ev
);
6856 tevent_req_set_callback(subreq
, rpccli_PNP_GetNextResDes_done
, req
);
6860 static void rpccli_PNP_GetNextResDes_done(struct tevent_req
*subreq
)
6862 struct tevent_req
*req
= tevent_req_callback_data(
6863 subreq
, struct tevent_req
);
6864 struct rpccli_PNP_GetNextResDes_state
*state
= tevent_req_data(
6865 req
, struct rpccli_PNP_GetNextResDes_state
);
6867 TALLOC_CTX
*mem_ctx
;
6869 if (state
->out_mem_ctx
) {
6870 mem_ctx
= state
->out_mem_ctx
;
6875 status
= state
->dispatch_recv(subreq
, mem_ctx
);
6876 TALLOC_FREE(subreq
);
6877 if (!NT_STATUS_IS_OK(status
)) {
6878 tevent_req_nterror(req
, status
);
6882 /* Copy out parameters */
6885 state
->orig
.out
.result
= state
->tmp
.out
.result
;
6887 /* Reset temporary structure */
6888 ZERO_STRUCT(state
->tmp
);
6890 tevent_req_done(req
);
6893 NTSTATUS
rpccli_PNP_GetNextResDes_recv(struct tevent_req
*req
,
6894 TALLOC_CTX
*mem_ctx
,
6897 struct rpccli_PNP_GetNextResDes_state
*state
= tevent_req_data(
6898 req
, struct rpccli_PNP_GetNextResDes_state
);
6901 if (tevent_req_is_nterror(req
, &status
)) {
6902 tevent_req_received(req
);
6906 /* Steal possbile out parameters to the callers context */
6907 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
6910 *result
= state
->orig
.out
.result
;
6912 tevent_req_received(req
);
6913 return NT_STATUS_OK
;
6916 NTSTATUS
rpccli_PNP_GetNextResDes(struct rpc_pipe_client
*cli
,
6917 TALLOC_CTX
*mem_ctx
,
6920 struct PNP_GetNextResDes r
;
6925 status
= cli
->dispatch(cli
,
6928 NDR_PNP_GETNEXTRESDES
,
6931 if (!NT_STATUS_IS_OK(status
)) {
6935 if (NT_STATUS_IS_ERR(status
)) {
6939 /* Return variables */
6943 *werror
= r
.out
.result
;
6946 return werror_to_ntstatus(r
.out
.result
);
6949 struct rpccli_PNP_GetResDesData_state
{
6950 struct PNP_GetResDesData orig
;
6951 struct PNP_GetResDesData tmp
;
6952 TALLOC_CTX
*out_mem_ctx
;
6953 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
6956 static void rpccli_PNP_GetResDesData_done(struct tevent_req
*subreq
);
6958 struct tevent_req
*rpccli_PNP_GetResDesData_send(TALLOC_CTX
*mem_ctx
,
6959 struct tevent_context
*ev
,
6960 struct rpc_pipe_client
*cli
)
6962 struct tevent_req
*req
;
6963 struct rpccli_PNP_GetResDesData_state
*state
;
6964 struct tevent_req
*subreq
;
6966 req
= tevent_req_create(mem_ctx
, &state
,
6967 struct rpccli_PNP_GetResDesData_state
);
6971 state
->out_mem_ctx
= NULL
;
6972 state
->dispatch_recv
= cli
->dispatch_recv
;
6976 /* Out parameters */
6979 ZERO_STRUCT(state
->orig
.out
.result
);
6981 /* make a temporary copy, that we pass to the dispatch function */
6982 state
->tmp
= state
->orig
;
6984 subreq
= cli
->dispatch_send(state
, ev
, cli
,
6986 NDR_PNP_GETRESDESDATA
,
6988 if (tevent_req_nomem(subreq
, req
)) {
6989 return tevent_req_post(req
, ev
);
6991 tevent_req_set_callback(subreq
, rpccli_PNP_GetResDesData_done
, req
);
6995 static void rpccli_PNP_GetResDesData_done(struct tevent_req
*subreq
)
6997 struct tevent_req
*req
= tevent_req_callback_data(
6998 subreq
, struct tevent_req
);
6999 struct rpccli_PNP_GetResDesData_state
*state
= tevent_req_data(
7000 req
, struct rpccli_PNP_GetResDesData_state
);
7002 TALLOC_CTX
*mem_ctx
;
7004 if (state
->out_mem_ctx
) {
7005 mem_ctx
= state
->out_mem_ctx
;
7010 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7011 TALLOC_FREE(subreq
);
7012 if (!NT_STATUS_IS_OK(status
)) {
7013 tevent_req_nterror(req
, status
);
7017 /* Copy out parameters */
7020 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7022 /* Reset temporary structure */
7023 ZERO_STRUCT(state
->tmp
);
7025 tevent_req_done(req
);
7028 NTSTATUS
rpccli_PNP_GetResDesData_recv(struct tevent_req
*req
,
7029 TALLOC_CTX
*mem_ctx
,
7032 struct rpccli_PNP_GetResDesData_state
*state
= tevent_req_data(
7033 req
, struct rpccli_PNP_GetResDesData_state
);
7036 if (tevent_req_is_nterror(req
, &status
)) {
7037 tevent_req_received(req
);
7041 /* Steal possbile out parameters to the callers context */
7042 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7045 *result
= state
->orig
.out
.result
;
7047 tevent_req_received(req
);
7048 return NT_STATUS_OK
;
7051 NTSTATUS
rpccli_PNP_GetResDesData(struct rpc_pipe_client
*cli
,
7052 TALLOC_CTX
*mem_ctx
,
7055 struct PNP_GetResDesData r
;
7060 status
= cli
->dispatch(cli
,
7063 NDR_PNP_GETRESDESDATA
,
7066 if (!NT_STATUS_IS_OK(status
)) {
7070 if (NT_STATUS_IS_ERR(status
)) {
7074 /* Return variables */
7078 *werror
= r
.out
.result
;
7081 return werror_to_ntstatus(r
.out
.result
);
7084 struct rpccli_PNP_GetResDesDataSize_state
{
7085 struct PNP_GetResDesDataSize orig
;
7086 struct PNP_GetResDesDataSize tmp
;
7087 TALLOC_CTX
*out_mem_ctx
;
7088 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7091 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req
*subreq
);
7093 struct tevent_req
*rpccli_PNP_GetResDesDataSize_send(TALLOC_CTX
*mem_ctx
,
7094 struct tevent_context
*ev
,
7095 struct rpc_pipe_client
*cli
)
7097 struct tevent_req
*req
;
7098 struct rpccli_PNP_GetResDesDataSize_state
*state
;
7099 struct tevent_req
*subreq
;
7101 req
= tevent_req_create(mem_ctx
, &state
,
7102 struct rpccli_PNP_GetResDesDataSize_state
);
7106 state
->out_mem_ctx
= NULL
;
7107 state
->dispatch_recv
= cli
->dispatch_recv
;
7111 /* Out parameters */
7114 ZERO_STRUCT(state
->orig
.out
.result
);
7116 /* make a temporary copy, that we pass to the dispatch function */
7117 state
->tmp
= state
->orig
;
7119 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7121 NDR_PNP_GETRESDESDATASIZE
,
7123 if (tevent_req_nomem(subreq
, req
)) {
7124 return tevent_req_post(req
, ev
);
7126 tevent_req_set_callback(subreq
, rpccli_PNP_GetResDesDataSize_done
, req
);
7130 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req
*subreq
)
7132 struct tevent_req
*req
= tevent_req_callback_data(
7133 subreq
, struct tevent_req
);
7134 struct rpccli_PNP_GetResDesDataSize_state
*state
= tevent_req_data(
7135 req
, struct rpccli_PNP_GetResDesDataSize_state
);
7137 TALLOC_CTX
*mem_ctx
;
7139 if (state
->out_mem_ctx
) {
7140 mem_ctx
= state
->out_mem_ctx
;
7145 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7146 TALLOC_FREE(subreq
);
7147 if (!NT_STATUS_IS_OK(status
)) {
7148 tevent_req_nterror(req
, status
);
7152 /* Copy out parameters */
7155 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7157 /* Reset temporary structure */
7158 ZERO_STRUCT(state
->tmp
);
7160 tevent_req_done(req
);
7163 NTSTATUS
rpccli_PNP_GetResDesDataSize_recv(struct tevent_req
*req
,
7164 TALLOC_CTX
*mem_ctx
,
7167 struct rpccli_PNP_GetResDesDataSize_state
*state
= tevent_req_data(
7168 req
, struct rpccli_PNP_GetResDesDataSize_state
);
7171 if (tevent_req_is_nterror(req
, &status
)) {
7172 tevent_req_received(req
);
7176 /* Steal possbile out parameters to the callers context */
7177 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7180 *result
= state
->orig
.out
.result
;
7182 tevent_req_received(req
);
7183 return NT_STATUS_OK
;
7186 NTSTATUS
rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client
*cli
,
7187 TALLOC_CTX
*mem_ctx
,
7190 struct PNP_GetResDesDataSize r
;
7195 status
= cli
->dispatch(cli
,
7198 NDR_PNP_GETRESDESDATASIZE
,
7201 if (!NT_STATUS_IS_OK(status
)) {
7205 if (NT_STATUS_IS_ERR(status
)) {
7209 /* Return variables */
7213 *werror
= r
.out
.result
;
7216 return werror_to_ntstatus(r
.out
.result
);
7219 struct rpccli_PNP_ModifyResDes_state
{
7220 struct PNP_ModifyResDes orig
;
7221 struct PNP_ModifyResDes tmp
;
7222 TALLOC_CTX
*out_mem_ctx
;
7223 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7226 static void rpccli_PNP_ModifyResDes_done(struct tevent_req
*subreq
);
7228 struct tevent_req
*rpccli_PNP_ModifyResDes_send(TALLOC_CTX
*mem_ctx
,
7229 struct tevent_context
*ev
,
7230 struct rpc_pipe_client
*cli
)
7232 struct tevent_req
*req
;
7233 struct rpccli_PNP_ModifyResDes_state
*state
;
7234 struct tevent_req
*subreq
;
7236 req
= tevent_req_create(mem_ctx
, &state
,
7237 struct rpccli_PNP_ModifyResDes_state
);
7241 state
->out_mem_ctx
= NULL
;
7242 state
->dispatch_recv
= cli
->dispatch_recv
;
7246 /* Out parameters */
7249 ZERO_STRUCT(state
->orig
.out
.result
);
7251 /* make a temporary copy, that we pass to the dispatch function */
7252 state
->tmp
= state
->orig
;
7254 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7256 NDR_PNP_MODIFYRESDES
,
7258 if (tevent_req_nomem(subreq
, req
)) {
7259 return tevent_req_post(req
, ev
);
7261 tevent_req_set_callback(subreq
, rpccli_PNP_ModifyResDes_done
, req
);
7265 static void rpccli_PNP_ModifyResDes_done(struct tevent_req
*subreq
)
7267 struct tevent_req
*req
= tevent_req_callback_data(
7268 subreq
, struct tevent_req
);
7269 struct rpccli_PNP_ModifyResDes_state
*state
= tevent_req_data(
7270 req
, struct rpccli_PNP_ModifyResDes_state
);
7272 TALLOC_CTX
*mem_ctx
;
7274 if (state
->out_mem_ctx
) {
7275 mem_ctx
= state
->out_mem_ctx
;
7280 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7281 TALLOC_FREE(subreq
);
7282 if (!NT_STATUS_IS_OK(status
)) {
7283 tevent_req_nterror(req
, status
);
7287 /* Copy out parameters */
7290 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7292 /* Reset temporary structure */
7293 ZERO_STRUCT(state
->tmp
);
7295 tevent_req_done(req
);
7298 NTSTATUS
rpccli_PNP_ModifyResDes_recv(struct tevent_req
*req
,
7299 TALLOC_CTX
*mem_ctx
,
7302 struct rpccli_PNP_ModifyResDes_state
*state
= tevent_req_data(
7303 req
, struct rpccli_PNP_ModifyResDes_state
);
7306 if (tevent_req_is_nterror(req
, &status
)) {
7307 tevent_req_received(req
);
7311 /* Steal possbile out parameters to the callers context */
7312 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7315 *result
= state
->orig
.out
.result
;
7317 tevent_req_received(req
);
7318 return NT_STATUS_OK
;
7321 NTSTATUS
rpccli_PNP_ModifyResDes(struct rpc_pipe_client
*cli
,
7322 TALLOC_CTX
*mem_ctx
,
7325 struct PNP_ModifyResDes r
;
7330 status
= cli
->dispatch(cli
,
7333 NDR_PNP_MODIFYRESDES
,
7336 if (!NT_STATUS_IS_OK(status
)) {
7340 if (NT_STATUS_IS_ERR(status
)) {
7344 /* Return variables */
7348 *werror
= r
.out
.result
;
7351 return werror_to_ntstatus(r
.out
.result
);
7354 struct rpccli_PNP_DetectResourceLimit_state
{
7355 struct PNP_DetectResourceLimit orig
;
7356 struct PNP_DetectResourceLimit tmp
;
7357 TALLOC_CTX
*out_mem_ctx
;
7358 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7361 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req
*subreq
);
7363 struct tevent_req
*rpccli_PNP_DetectResourceLimit_send(TALLOC_CTX
*mem_ctx
,
7364 struct tevent_context
*ev
,
7365 struct rpc_pipe_client
*cli
)
7367 struct tevent_req
*req
;
7368 struct rpccli_PNP_DetectResourceLimit_state
*state
;
7369 struct tevent_req
*subreq
;
7371 req
= tevent_req_create(mem_ctx
, &state
,
7372 struct rpccli_PNP_DetectResourceLimit_state
);
7376 state
->out_mem_ctx
= NULL
;
7377 state
->dispatch_recv
= cli
->dispatch_recv
;
7381 /* Out parameters */
7384 ZERO_STRUCT(state
->orig
.out
.result
);
7386 /* make a temporary copy, that we pass to the dispatch function */
7387 state
->tmp
= state
->orig
;
7389 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7391 NDR_PNP_DETECTRESOURCELIMIT
,
7393 if (tevent_req_nomem(subreq
, req
)) {
7394 return tevent_req_post(req
, ev
);
7396 tevent_req_set_callback(subreq
, rpccli_PNP_DetectResourceLimit_done
, req
);
7400 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req
*subreq
)
7402 struct tevent_req
*req
= tevent_req_callback_data(
7403 subreq
, struct tevent_req
);
7404 struct rpccli_PNP_DetectResourceLimit_state
*state
= tevent_req_data(
7405 req
, struct rpccli_PNP_DetectResourceLimit_state
);
7407 TALLOC_CTX
*mem_ctx
;
7409 if (state
->out_mem_ctx
) {
7410 mem_ctx
= state
->out_mem_ctx
;
7415 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7416 TALLOC_FREE(subreq
);
7417 if (!NT_STATUS_IS_OK(status
)) {
7418 tevent_req_nterror(req
, status
);
7422 /* Copy out parameters */
7425 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7427 /* Reset temporary structure */
7428 ZERO_STRUCT(state
->tmp
);
7430 tevent_req_done(req
);
7433 NTSTATUS
rpccli_PNP_DetectResourceLimit_recv(struct tevent_req
*req
,
7434 TALLOC_CTX
*mem_ctx
,
7437 struct rpccli_PNP_DetectResourceLimit_state
*state
= tevent_req_data(
7438 req
, struct rpccli_PNP_DetectResourceLimit_state
);
7441 if (tevent_req_is_nterror(req
, &status
)) {
7442 tevent_req_received(req
);
7446 /* Steal possbile out parameters to the callers context */
7447 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7450 *result
= state
->orig
.out
.result
;
7452 tevent_req_received(req
);
7453 return NT_STATUS_OK
;
7456 NTSTATUS
rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client
*cli
,
7457 TALLOC_CTX
*mem_ctx
,
7460 struct PNP_DetectResourceLimit r
;
7465 status
= cli
->dispatch(cli
,
7468 NDR_PNP_DETECTRESOURCELIMIT
,
7471 if (!NT_STATUS_IS_OK(status
)) {
7475 if (NT_STATUS_IS_ERR(status
)) {
7479 /* Return variables */
7483 *werror
= r
.out
.result
;
7486 return werror_to_ntstatus(r
.out
.result
);
7489 struct rpccli_PNP_QueryResConfList_state
{
7490 struct PNP_QueryResConfList orig
;
7491 struct PNP_QueryResConfList tmp
;
7492 TALLOC_CTX
*out_mem_ctx
;
7493 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7496 static void rpccli_PNP_QueryResConfList_done(struct tevent_req
*subreq
);
7498 struct tevent_req
*rpccli_PNP_QueryResConfList_send(TALLOC_CTX
*mem_ctx
,
7499 struct tevent_context
*ev
,
7500 struct rpc_pipe_client
*cli
)
7502 struct tevent_req
*req
;
7503 struct rpccli_PNP_QueryResConfList_state
*state
;
7504 struct tevent_req
*subreq
;
7506 req
= tevent_req_create(mem_ctx
, &state
,
7507 struct rpccli_PNP_QueryResConfList_state
);
7511 state
->out_mem_ctx
= NULL
;
7512 state
->dispatch_recv
= cli
->dispatch_recv
;
7516 /* Out parameters */
7519 ZERO_STRUCT(state
->orig
.out
.result
);
7521 /* make a temporary copy, that we pass to the dispatch function */
7522 state
->tmp
= state
->orig
;
7524 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7526 NDR_PNP_QUERYRESCONFLIST
,
7528 if (tevent_req_nomem(subreq
, req
)) {
7529 return tevent_req_post(req
, ev
);
7531 tevent_req_set_callback(subreq
, rpccli_PNP_QueryResConfList_done
, req
);
7535 static void rpccli_PNP_QueryResConfList_done(struct tevent_req
*subreq
)
7537 struct tevent_req
*req
= tevent_req_callback_data(
7538 subreq
, struct tevent_req
);
7539 struct rpccli_PNP_QueryResConfList_state
*state
= tevent_req_data(
7540 req
, struct rpccli_PNP_QueryResConfList_state
);
7542 TALLOC_CTX
*mem_ctx
;
7544 if (state
->out_mem_ctx
) {
7545 mem_ctx
= state
->out_mem_ctx
;
7550 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7551 TALLOC_FREE(subreq
);
7552 if (!NT_STATUS_IS_OK(status
)) {
7553 tevent_req_nterror(req
, status
);
7557 /* Copy out parameters */
7560 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7562 /* Reset temporary structure */
7563 ZERO_STRUCT(state
->tmp
);
7565 tevent_req_done(req
);
7568 NTSTATUS
rpccli_PNP_QueryResConfList_recv(struct tevent_req
*req
,
7569 TALLOC_CTX
*mem_ctx
,
7572 struct rpccli_PNP_QueryResConfList_state
*state
= tevent_req_data(
7573 req
, struct rpccli_PNP_QueryResConfList_state
);
7576 if (tevent_req_is_nterror(req
, &status
)) {
7577 tevent_req_received(req
);
7581 /* Steal possbile out parameters to the callers context */
7582 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7585 *result
= state
->orig
.out
.result
;
7587 tevent_req_received(req
);
7588 return NT_STATUS_OK
;
7591 NTSTATUS
rpccli_PNP_QueryResConfList(struct rpc_pipe_client
*cli
,
7592 TALLOC_CTX
*mem_ctx
,
7595 struct PNP_QueryResConfList r
;
7600 status
= cli
->dispatch(cli
,
7603 NDR_PNP_QUERYRESCONFLIST
,
7606 if (!NT_STATUS_IS_OK(status
)) {
7610 if (NT_STATUS_IS_ERR(status
)) {
7614 /* Return variables */
7618 *werror
= r
.out
.result
;
7621 return werror_to_ntstatus(r
.out
.result
);
7624 struct rpccli_PNP_SetHwProf_state
{
7625 struct PNP_SetHwProf orig
;
7626 struct PNP_SetHwProf tmp
;
7627 TALLOC_CTX
*out_mem_ctx
;
7628 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7631 static void rpccli_PNP_SetHwProf_done(struct tevent_req
*subreq
);
7633 struct tevent_req
*rpccli_PNP_SetHwProf_send(TALLOC_CTX
*mem_ctx
,
7634 struct tevent_context
*ev
,
7635 struct rpc_pipe_client
*cli
)
7637 struct tevent_req
*req
;
7638 struct rpccli_PNP_SetHwProf_state
*state
;
7639 struct tevent_req
*subreq
;
7641 req
= tevent_req_create(mem_ctx
, &state
,
7642 struct rpccli_PNP_SetHwProf_state
);
7646 state
->out_mem_ctx
= NULL
;
7647 state
->dispatch_recv
= cli
->dispatch_recv
;
7651 /* Out parameters */
7654 ZERO_STRUCT(state
->orig
.out
.result
);
7656 /* make a temporary copy, that we pass to the dispatch function */
7657 state
->tmp
= state
->orig
;
7659 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7663 if (tevent_req_nomem(subreq
, req
)) {
7664 return tevent_req_post(req
, ev
);
7666 tevent_req_set_callback(subreq
, rpccli_PNP_SetHwProf_done
, req
);
7670 static void rpccli_PNP_SetHwProf_done(struct tevent_req
*subreq
)
7672 struct tevent_req
*req
= tevent_req_callback_data(
7673 subreq
, struct tevent_req
);
7674 struct rpccli_PNP_SetHwProf_state
*state
= tevent_req_data(
7675 req
, struct rpccli_PNP_SetHwProf_state
);
7677 TALLOC_CTX
*mem_ctx
;
7679 if (state
->out_mem_ctx
) {
7680 mem_ctx
= state
->out_mem_ctx
;
7685 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7686 TALLOC_FREE(subreq
);
7687 if (!NT_STATUS_IS_OK(status
)) {
7688 tevent_req_nterror(req
, status
);
7692 /* Copy out parameters */
7695 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7697 /* Reset temporary structure */
7698 ZERO_STRUCT(state
->tmp
);
7700 tevent_req_done(req
);
7703 NTSTATUS
rpccli_PNP_SetHwProf_recv(struct tevent_req
*req
,
7704 TALLOC_CTX
*mem_ctx
,
7707 struct rpccli_PNP_SetHwProf_state
*state
= tevent_req_data(
7708 req
, struct rpccli_PNP_SetHwProf_state
);
7711 if (tevent_req_is_nterror(req
, &status
)) {
7712 tevent_req_received(req
);
7716 /* Steal possbile out parameters to the callers context */
7717 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7720 *result
= state
->orig
.out
.result
;
7722 tevent_req_received(req
);
7723 return NT_STATUS_OK
;
7726 NTSTATUS
rpccli_PNP_SetHwProf(struct rpc_pipe_client
*cli
,
7727 TALLOC_CTX
*mem_ctx
,
7730 struct PNP_SetHwProf r
;
7735 status
= cli
->dispatch(cli
,
7741 if (!NT_STATUS_IS_OK(status
)) {
7745 if (NT_STATUS_IS_ERR(status
)) {
7749 /* Return variables */
7753 *werror
= r
.out
.result
;
7756 return werror_to_ntstatus(r
.out
.result
);
7759 struct rpccli_PNP_QueryArbitratorFreeData_state
{
7760 struct PNP_QueryArbitratorFreeData orig
;
7761 struct PNP_QueryArbitratorFreeData tmp
;
7762 TALLOC_CTX
*out_mem_ctx
;
7763 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7766 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req
*subreq
);
7768 struct tevent_req
*rpccli_PNP_QueryArbitratorFreeData_send(TALLOC_CTX
*mem_ctx
,
7769 struct tevent_context
*ev
,
7770 struct rpc_pipe_client
*cli
)
7772 struct tevent_req
*req
;
7773 struct rpccli_PNP_QueryArbitratorFreeData_state
*state
;
7774 struct tevent_req
*subreq
;
7776 req
= tevent_req_create(mem_ctx
, &state
,
7777 struct rpccli_PNP_QueryArbitratorFreeData_state
);
7781 state
->out_mem_ctx
= NULL
;
7782 state
->dispatch_recv
= cli
->dispatch_recv
;
7786 /* Out parameters */
7789 ZERO_STRUCT(state
->orig
.out
.result
);
7791 /* make a temporary copy, that we pass to the dispatch function */
7792 state
->tmp
= state
->orig
;
7794 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7796 NDR_PNP_QUERYARBITRATORFREEDATA
,
7798 if (tevent_req_nomem(subreq
, req
)) {
7799 return tevent_req_post(req
, ev
);
7801 tevent_req_set_callback(subreq
, rpccli_PNP_QueryArbitratorFreeData_done
, req
);
7805 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req
*subreq
)
7807 struct tevent_req
*req
= tevent_req_callback_data(
7808 subreq
, struct tevent_req
);
7809 struct rpccli_PNP_QueryArbitratorFreeData_state
*state
= tevent_req_data(
7810 req
, struct rpccli_PNP_QueryArbitratorFreeData_state
);
7812 TALLOC_CTX
*mem_ctx
;
7814 if (state
->out_mem_ctx
) {
7815 mem_ctx
= state
->out_mem_ctx
;
7820 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7821 TALLOC_FREE(subreq
);
7822 if (!NT_STATUS_IS_OK(status
)) {
7823 tevent_req_nterror(req
, status
);
7827 /* Copy out parameters */
7830 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7832 /* Reset temporary structure */
7833 ZERO_STRUCT(state
->tmp
);
7835 tevent_req_done(req
);
7838 NTSTATUS
rpccli_PNP_QueryArbitratorFreeData_recv(struct tevent_req
*req
,
7839 TALLOC_CTX
*mem_ctx
,
7842 struct rpccli_PNP_QueryArbitratorFreeData_state
*state
= tevent_req_data(
7843 req
, struct rpccli_PNP_QueryArbitratorFreeData_state
);
7846 if (tevent_req_is_nterror(req
, &status
)) {
7847 tevent_req_received(req
);
7851 /* Steal possbile out parameters to the callers context */
7852 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7855 *result
= state
->orig
.out
.result
;
7857 tevent_req_received(req
);
7858 return NT_STATUS_OK
;
7861 NTSTATUS
rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client
*cli
,
7862 TALLOC_CTX
*mem_ctx
,
7865 struct PNP_QueryArbitratorFreeData r
;
7870 status
= cli
->dispatch(cli
,
7873 NDR_PNP_QUERYARBITRATORFREEDATA
,
7876 if (!NT_STATUS_IS_OK(status
)) {
7880 if (NT_STATUS_IS_ERR(status
)) {
7884 /* Return variables */
7888 *werror
= r
.out
.result
;
7891 return werror_to_ntstatus(r
.out
.result
);
7894 struct rpccli_PNP_QueryArbitratorFreeSize_state
{
7895 struct PNP_QueryArbitratorFreeSize orig
;
7896 struct PNP_QueryArbitratorFreeSize tmp
;
7897 TALLOC_CTX
*out_mem_ctx
;
7898 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
7901 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req
*subreq
);
7903 struct tevent_req
*rpccli_PNP_QueryArbitratorFreeSize_send(TALLOC_CTX
*mem_ctx
,
7904 struct tevent_context
*ev
,
7905 struct rpc_pipe_client
*cli
)
7907 struct tevent_req
*req
;
7908 struct rpccli_PNP_QueryArbitratorFreeSize_state
*state
;
7909 struct tevent_req
*subreq
;
7911 req
= tevent_req_create(mem_ctx
, &state
,
7912 struct rpccli_PNP_QueryArbitratorFreeSize_state
);
7916 state
->out_mem_ctx
= NULL
;
7917 state
->dispatch_recv
= cli
->dispatch_recv
;
7921 /* Out parameters */
7924 ZERO_STRUCT(state
->orig
.out
.result
);
7926 /* make a temporary copy, that we pass to the dispatch function */
7927 state
->tmp
= state
->orig
;
7929 subreq
= cli
->dispatch_send(state
, ev
, cli
,
7931 NDR_PNP_QUERYARBITRATORFREESIZE
,
7933 if (tevent_req_nomem(subreq
, req
)) {
7934 return tevent_req_post(req
, ev
);
7936 tevent_req_set_callback(subreq
, rpccli_PNP_QueryArbitratorFreeSize_done
, req
);
7940 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req
*subreq
)
7942 struct tevent_req
*req
= tevent_req_callback_data(
7943 subreq
, struct tevent_req
);
7944 struct rpccli_PNP_QueryArbitratorFreeSize_state
*state
= tevent_req_data(
7945 req
, struct rpccli_PNP_QueryArbitratorFreeSize_state
);
7947 TALLOC_CTX
*mem_ctx
;
7949 if (state
->out_mem_ctx
) {
7950 mem_ctx
= state
->out_mem_ctx
;
7955 status
= state
->dispatch_recv(subreq
, mem_ctx
);
7956 TALLOC_FREE(subreq
);
7957 if (!NT_STATUS_IS_OK(status
)) {
7958 tevent_req_nterror(req
, status
);
7962 /* Copy out parameters */
7965 state
->orig
.out
.result
= state
->tmp
.out
.result
;
7967 /* Reset temporary structure */
7968 ZERO_STRUCT(state
->tmp
);
7970 tevent_req_done(req
);
7973 NTSTATUS
rpccli_PNP_QueryArbitratorFreeSize_recv(struct tevent_req
*req
,
7974 TALLOC_CTX
*mem_ctx
,
7977 struct rpccli_PNP_QueryArbitratorFreeSize_state
*state
= tevent_req_data(
7978 req
, struct rpccli_PNP_QueryArbitratorFreeSize_state
);
7981 if (tevent_req_is_nterror(req
, &status
)) {
7982 tevent_req_received(req
);
7986 /* Steal possbile out parameters to the callers context */
7987 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
7990 *result
= state
->orig
.out
.result
;
7992 tevent_req_received(req
);
7993 return NT_STATUS_OK
;
7996 NTSTATUS
rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client
*cli
,
7997 TALLOC_CTX
*mem_ctx
,
8000 struct PNP_QueryArbitratorFreeSize r
;
8005 status
= cli
->dispatch(cli
,
8008 NDR_PNP_QUERYARBITRATORFREESIZE
,
8011 if (!NT_STATUS_IS_OK(status
)) {
8015 if (NT_STATUS_IS_ERR(status
)) {
8019 /* Return variables */
8023 *werror
= r
.out
.result
;
8026 return werror_to_ntstatus(r
.out
.result
);
8029 struct rpccli_PNP_RunDetection_state
{
8030 struct PNP_RunDetection orig
;
8031 struct PNP_RunDetection tmp
;
8032 TALLOC_CTX
*out_mem_ctx
;
8033 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8036 static void rpccli_PNP_RunDetection_done(struct tevent_req
*subreq
);
8038 struct tevent_req
*rpccli_PNP_RunDetection_send(TALLOC_CTX
*mem_ctx
,
8039 struct tevent_context
*ev
,
8040 struct rpc_pipe_client
*cli
)
8042 struct tevent_req
*req
;
8043 struct rpccli_PNP_RunDetection_state
*state
;
8044 struct tevent_req
*subreq
;
8046 req
= tevent_req_create(mem_ctx
, &state
,
8047 struct rpccli_PNP_RunDetection_state
);
8051 state
->out_mem_ctx
= NULL
;
8052 state
->dispatch_recv
= cli
->dispatch_recv
;
8056 /* Out parameters */
8059 ZERO_STRUCT(state
->orig
.out
.result
);
8061 /* make a temporary copy, that we pass to the dispatch function */
8062 state
->tmp
= state
->orig
;
8064 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8066 NDR_PNP_RUNDETECTION
,
8068 if (tevent_req_nomem(subreq
, req
)) {
8069 return tevent_req_post(req
, ev
);
8071 tevent_req_set_callback(subreq
, rpccli_PNP_RunDetection_done
, req
);
8075 static void rpccli_PNP_RunDetection_done(struct tevent_req
*subreq
)
8077 struct tevent_req
*req
= tevent_req_callback_data(
8078 subreq
, struct tevent_req
);
8079 struct rpccli_PNP_RunDetection_state
*state
= tevent_req_data(
8080 req
, struct rpccli_PNP_RunDetection_state
);
8082 TALLOC_CTX
*mem_ctx
;
8084 if (state
->out_mem_ctx
) {
8085 mem_ctx
= state
->out_mem_ctx
;
8090 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8091 TALLOC_FREE(subreq
);
8092 if (!NT_STATUS_IS_OK(status
)) {
8093 tevent_req_nterror(req
, status
);
8097 /* Copy out parameters */
8100 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8102 /* Reset temporary structure */
8103 ZERO_STRUCT(state
->tmp
);
8105 tevent_req_done(req
);
8108 NTSTATUS
rpccli_PNP_RunDetection_recv(struct tevent_req
*req
,
8109 TALLOC_CTX
*mem_ctx
,
8112 struct rpccli_PNP_RunDetection_state
*state
= tevent_req_data(
8113 req
, struct rpccli_PNP_RunDetection_state
);
8116 if (tevent_req_is_nterror(req
, &status
)) {
8117 tevent_req_received(req
);
8121 /* Steal possbile out parameters to the callers context */
8122 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8125 *result
= state
->orig
.out
.result
;
8127 tevent_req_received(req
);
8128 return NT_STATUS_OK
;
8131 NTSTATUS
rpccli_PNP_RunDetection(struct rpc_pipe_client
*cli
,
8132 TALLOC_CTX
*mem_ctx
,
8135 struct PNP_RunDetection r
;
8140 status
= cli
->dispatch(cli
,
8143 NDR_PNP_RUNDETECTION
,
8146 if (!NT_STATUS_IS_OK(status
)) {
8150 if (NT_STATUS_IS_ERR(status
)) {
8154 /* Return variables */
8158 *werror
= r
.out
.result
;
8161 return werror_to_ntstatus(r
.out
.result
);
8164 struct rpccli_PNP_RegisterNotification_state
{
8165 struct PNP_RegisterNotification orig
;
8166 struct PNP_RegisterNotification tmp
;
8167 TALLOC_CTX
*out_mem_ctx
;
8168 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8171 static void rpccli_PNP_RegisterNotification_done(struct tevent_req
*subreq
);
8173 struct tevent_req
*rpccli_PNP_RegisterNotification_send(TALLOC_CTX
*mem_ctx
,
8174 struct tevent_context
*ev
,
8175 struct rpc_pipe_client
*cli
)
8177 struct tevent_req
*req
;
8178 struct rpccli_PNP_RegisterNotification_state
*state
;
8179 struct tevent_req
*subreq
;
8181 req
= tevent_req_create(mem_ctx
, &state
,
8182 struct rpccli_PNP_RegisterNotification_state
);
8186 state
->out_mem_ctx
= NULL
;
8187 state
->dispatch_recv
= cli
->dispatch_recv
;
8191 /* Out parameters */
8194 ZERO_STRUCT(state
->orig
.out
.result
);
8196 /* make a temporary copy, that we pass to the dispatch function */
8197 state
->tmp
= state
->orig
;
8199 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8201 NDR_PNP_REGISTERNOTIFICATION
,
8203 if (tevent_req_nomem(subreq
, req
)) {
8204 return tevent_req_post(req
, ev
);
8206 tevent_req_set_callback(subreq
, rpccli_PNP_RegisterNotification_done
, req
);
8210 static void rpccli_PNP_RegisterNotification_done(struct tevent_req
*subreq
)
8212 struct tevent_req
*req
= tevent_req_callback_data(
8213 subreq
, struct tevent_req
);
8214 struct rpccli_PNP_RegisterNotification_state
*state
= tevent_req_data(
8215 req
, struct rpccli_PNP_RegisterNotification_state
);
8217 TALLOC_CTX
*mem_ctx
;
8219 if (state
->out_mem_ctx
) {
8220 mem_ctx
= state
->out_mem_ctx
;
8225 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8226 TALLOC_FREE(subreq
);
8227 if (!NT_STATUS_IS_OK(status
)) {
8228 tevent_req_nterror(req
, status
);
8232 /* Copy out parameters */
8235 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8237 /* Reset temporary structure */
8238 ZERO_STRUCT(state
->tmp
);
8240 tevent_req_done(req
);
8243 NTSTATUS
rpccli_PNP_RegisterNotification_recv(struct tevent_req
*req
,
8244 TALLOC_CTX
*mem_ctx
,
8247 struct rpccli_PNP_RegisterNotification_state
*state
= tevent_req_data(
8248 req
, struct rpccli_PNP_RegisterNotification_state
);
8251 if (tevent_req_is_nterror(req
, &status
)) {
8252 tevent_req_received(req
);
8256 /* Steal possbile out parameters to the callers context */
8257 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8260 *result
= state
->orig
.out
.result
;
8262 tevent_req_received(req
);
8263 return NT_STATUS_OK
;
8266 NTSTATUS
rpccli_PNP_RegisterNotification(struct rpc_pipe_client
*cli
,
8267 TALLOC_CTX
*mem_ctx
,
8270 struct PNP_RegisterNotification r
;
8275 status
= cli
->dispatch(cli
,
8278 NDR_PNP_REGISTERNOTIFICATION
,
8281 if (!NT_STATUS_IS_OK(status
)) {
8285 if (NT_STATUS_IS_ERR(status
)) {
8289 /* Return variables */
8293 *werror
= r
.out
.result
;
8296 return werror_to_ntstatus(r
.out
.result
);
8299 struct rpccli_PNP_UnregisterNotification_state
{
8300 struct PNP_UnregisterNotification orig
;
8301 struct PNP_UnregisterNotification tmp
;
8302 TALLOC_CTX
*out_mem_ctx
;
8303 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8306 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req
*subreq
);
8308 struct tevent_req
*rpccli_PNP_UnregisterNotification_send(TALLOC_CTX
*mem_ctx
,
8309 struct tevent_context
*ev
,
8310 struct rpc_pipe_client
*cli
)
8312 struct tevent_req
*req
;
8313 struct rpccli_PNP_UnregisterNotification_state
*state
;
8314 struct tevent_req
*subreq
;
8316 req
= tevent_req_create(mem_ctx
, &state
,
8317 struct rpccli_PNP_UnregisterNotification_state
);
8321 state
->out_mem_ctx
= NULL
;
8322 state
->dispatch_recv
= cli
->dispatch_recv
;
8326 /* Out parameters */
8329 ZERO_STRUCT(state
->orig
.out
.result
);
8331 /* make a temporary copy, that we pass to the dispatch function */
8332 state
->tmp
= state
->orig
;
8334 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8336 NDR_PNP_UNREGISTERNOTIFICATION
,
8338 if (tevent_req_nomem(subreq
, req
)) {
8339 return tevent_req_post(req
, ev
);
8341 tevent_req_set_callback(subreq
, rpccli_PNP_UnregisterNotification_done
, req
);
8345 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req
*subreq
)
8347 struct tevent_req
*req
= tevent_req_callback_data(
8348 subreq
, struct tevent_req
);
8349 struct rpccli_PNP_UnregisterNotification_state
*state
= tevent_req_data(
8350 req
, struct rpccli_PNP_UnregisterNotification_state
);
8352 TALLOC_CTX
*mem_ctx
;
8354 if (state
->out_mem_ctx
) {
8355 mem_ctx
= state
->out_mem_ctx
;
8360 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8361 TALLOC_FREE(subreq
);
8362 if (!NT_STATUS_IS_OK(status
)) {
8363 tevent_req_nterror(req
, status
);
8367 /* Copy out parameters */
8370 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8372 /* Reset temporary structure */
8373 ZERO_STRUCT(state
->tmp
);
8375 tevent_req_done(req
);
8378 NTSTATUS
rpccli_PNP_UnregisterNotification_recv(struct tevent_req
*req
,
8379 TALLOC_CTX
*mem_ctx
,
8382 struct rpccli_PNP_UnregisterNotification_state
*state
= tevent_req_data(
8383 req
, struct rpccli_PNP_UnregisterNotification_state
);
8386 if (tevent_req_is_nterror(req
, &status
)) {
8387 tevent_req_received(req
);
8391 /* Steal possbile out parameters to the callers context */
8392 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8395 *result
= state
->orig
.out
.result
;
8397 tevent_req_received(req
);
8398 return NT_STATUS_OK
;
8401 NTSTATUS
rpccli_PNP_UnregisterNotification(struct rpc_pipe_client
*cli
,
8402 TALLOC_CTX
*mem_ctx
,
8405 struct PNP_UnregisterNotification r
;
8410 status
= cli
->dispatch(cli
,
8413 NDR_PNP_UNREGISTERNOTIFICATION
,
8416 if (!NT_STATUS_IS_OK(status
)) {
8420 if (NT_STATUS_IS_ERR(status
)) {
8424 /* Return variables */
8428 *werror
= r
.out
.result
;
8431 return werror_to_ntstatus(r
.out
.result
);
8434 struct rpccli_PNP_GetCustomDevProp_state
{
8435 struct PNP_GetCustomDevProp orig
;
8436 struct PNP_GetCustomDevProp tmp
;
8437 TALLOC_CTX
*out_mem_ctx
;
8438 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8441 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req
*subreq
);
8443 struct tevent_req
*rpccli_PNP_GetCustomDevProp_send(TALLOC_CTX
*mem_ctx
,
8444 struct tevent_context
*ev
,
8445 struct rpc_pipe_client
*cli
)
8447 struct tevent_req
*req
;
8448 struct rpccli_PNP_GetCustomDevProp_state
*state
;
8449 struct tevent_req
*subreq
;
8451 req
= tevent_req_create(mem_ctx
, &state
,
8452 struct rpccli_PNP_GetCustomDevProp_state
);
8456 state
->out_mem_ctx
= NULL
;
8457 state
->dispatch_recv
= cli
->dispatch_recv
;
8461 /* Out parameters */
8464 ZERO_STRUCT(state
->orig
.out
.result
);
8466 /* make a temporary copy, that we pass to the dispatch function */
8467 state
->tmp
= state
->orig
;
8469 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8471 NDR_PNP_GETCUSTOMDEVPROP
,
8473 if (tevent_req_nomem(subreq
, req
)) {
8474 return tevent_req_post(req
, ev
);
8476 tevent_req_set_callback(subreq
, rpccli_PNP_GetCustomDevProp_done
, req
);
8480 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req
*subreq
)
8482 struct tevent_req
*req
= tevent_req_callback_data(
8483 subreq
, struct tevent_req
);
8484 struct rpccli_PNP_GetCustomDevProp_state
*state
= tevent_req_data(
8485 req
, struct rpccli_PNP_GetCustomDevProp_state
);
8487 TALLOC_CTX
*mem_ctx
;
8489 if (state
->out_mem_ctx
) {
8490 mem_ctx
= state
->out_mem_ctx
;
8495 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8496 TALLOC_FREE(subreq
);
8497 if (!NT_STATUS_IS_OK(status
)) {
8498 tevent_req_nterror(req
, status
);
8502 /* Copy out parameters */
8505 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8507 /* Reset temporary structure */
8508 ZERO_STRUCT(state
->tmp
);
8510 tevent_req_done(req
);
8513 NTSTATUS
rpccli_PNP_GetCustomDevProp_recv(struct tevent_req
*req
,
8514 TALLOC_CTX
*mem_ctx
,
8517 struct rpccli_PNP_GetCustomDevProp_state
*state
= tevent_req_data(
8518 req
, struct rpccli_PNP_GetCustomDevProp_state
);
8521 if (tevent_req_is_nterror(req
, &status
)) {
8522 tevent_req_received(req
);
8526 /* Steal possbile out parameters to the callers context */
8527 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8530 *result
= state
->orig
.out
.result
;
8532 tevent_req_received(req
);
8533 return NT_STATUS_OK
;
8536 NTSTATUS
rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client
*cli
,
8537 TALLOC_CTX
*mem_ctx
,
8540 struct PNP_GetCustomDevProp r
;
8545 status
= cli
->dispatch(cli
,
8548 NDR_PNP_GETCUSTOMDEVPROP
,
8551 if (!NT_STATUS_IS_OK(status
)) {
8555 if (NT_STATUS_IS_ERR(status
)) {
8559 /* Return variables */
8563 *werror
= r
.out
.result
;
8566 return werror_to_ntstatus(r
.out
.result
);
8569 struct rpccli_PNP_GetVersionInternal_state
{
8570 struct PNP_GetVersionInternal orig
;
8571 struct PNP_GetVersionInternal tmp
;
8572 TALLOC_CTX
*out_mem_ctx
;
8573 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8576 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req
*subreq
);
8578 struct tevent_req
*rpccli_PNP_GetVersionInternal_send(TALLOC_CTX
*mem_ctx
,
8579 struct tevent_context
*ev
,
8580 struct rpc_pipe_client
*cli
)
8582 struct tevent_req
*req
;
8583 struct rpccli_PNP_GetVersionInternal_state
*state
;
8584 struct tevent_req
*subreq
;
8586 req
= tevent_req_create(mem_ctx
, &state
,
8587 struct rpccli_PNP_GetVersionInternal_state
);
8591 state
->out_mem_ctx
= NULL
;
8592 state
->dispatch_recv
= cli
->dispatch_recv
;
8596 /* Out parameters */
8599 ZERO_STRUCT(state
->orig
.out
.result
);
8601 /* make a temporary copy, that we pass to the dispatch function */
8602 state
->tmp
= state
->orig
;
8604 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8606 NDR_PNP_GETVERSIONINTERNAL
,
8608 if (tevent_req_nomem(subreq
, req
)) {
8609 return tevent_req_post(req
, ev
);
8611 tevent_req_set_callback(subreq
, rpccli_PNP_GetVersionInternal_done
, req
);
8615 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req
*subreq
)
8617 struct tevent_req
*req
= tevent_req_callback_data(
8618 subreq
, struct tevent_req
);
8619 struct rpccli_PNP_GetVersionInternal_state
*state
= tevent_req_data(
8620 req
, struct rpccli_PNP_GetVersionInternal_state
);
8622 TALLOC_CTX
*mem_ctx
;
8624 if (state
->out_mem_ctx
) {
8625 mem_ctx
= state
->out_mem_ctx
;
8630 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8631 TALLOC_FREE(subreq
);
8632 if (!NT_STATUS_IS_OK(status
)) {
8633 tevent_req_nterror(req
, status
);
8637 /* Copy out parameters */
8640 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8642 /* Reset temporary structure */
8643 ZERO_STRUCT(state
->tmp
);
8645 tevent_req_done(req
);
8648 NTSTATUS
rpccli_PNP_GetVersionInternal_recv(struct tevent_req
*req
,
8649 TALLOC_CTX
*mem_ctx
,
8652 struct rpccli_PNP_GetVersionInternal_state
*state
= tevent_req_data(
8653 req
, struct rpccli_PNP_GetVersionInternal_state
);
8656 if (tevent_req_is_nterror(req
, &status
)) {
8657 tevent_req_received(req
);
8661 /* Steal possbile out parameters to the callers context */
8662 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8665 *result
= state
->orig
.out
.result
;
8667 tevent_req_received(req
);
8668 return NT_STATUS_OK
;
8671 NTSTATUS
rpccli_PNP_GetVersionInternal(struct rpc_pipe_client
*cli
,
8672 TALLOC_CTX
*mem_ctx
,
8675 struct PNP_GetVersionInternal r
;
8680 status
= cli
->dispatch(cli
,
8683 NDR_PNP_GETVERSIONINTERNAL
,
8686 if (!NT_STATUS_IS_OK(status
)) {
8690 if (NT_STATUS_IS_ERR(status
)) {
8694 /* Return variables */
8698 *werror
= r
.out
.result
;
8701 return werror_to_ntstatus(r
.out
.result
);
8704 struct rpccli_PNP_GetBlockedDriverInfo_state
{
8705 struct PNP_GetBlockedDriverInfo orig
;
8706 struct PNP_GetBlockedDriverInfo tmp
;
8707 TALLOC_CTX
*out_mem_ctx
;
8708 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8711 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req
*subreq
);
8713 struct tevent_req
*rpccli_PNP_GetBlockedDriverInfo_send(TALLOC_CTX
*mem_ctx
,
8714 struct tevent_context
*ev
,
8715 struct rpc_pipe_client
*cli
)
8717 struct tevent_req
*req
;
8718 struct rpccli_PNP_GetBlockedDriverInfo_state
*state
;
8719 struct tevent_req
*subreq
;
8721 req
= tevent_req_create(mem_ctx
, &state
,
8722 struct rpccli_PNP_GetBlockedDriverInfo_state
);
8726 state
->out_mem_ctx
= NULL
;
8727 state
->dispatch_recv
= cli
->dispatch_recv
;
8731 /* Out parameters */
8734 ZERO_STRUCT(state
->orig
.out
.result
);
8736 /* make a temporary copy, that we pass to the dispatch function */
8737 state
->tmp
= state
->orig
;
8739 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8741 NDR_PNP_GETBLOCKEDDRIVERINFO
,
8743 if (tevent_req_nomem(subreq
, req
)) {
8744 return tevent_req_post(req
, ev
);
8746 tevent_req_set_callback(subreq
, rpccli_PNP_GetBlockedDriverInfo_done
, req
);
8750 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req
*subreq
)
8752 struct tevent_req
*req
= tevent_req_callback_data(
8753 subreq
, struct tevent_req
);
8754 struct rpccli_PNP_GetBlockedDriverInfo_state
*state
= tevent_req_data(
8755 req
, struct rpccli_PNP_GetBlockedDriverInfo_state
);
8757 TALLOC_CTX
*mem_ctx
;
8759 if (state
->out_mem_ctx
) {
8760 mem_ctx
= state
->out_mem_ctx
;
8765 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8766 TALLOC_FREE(subreq
);
8767 if (!NT_STATUS_IS_OK(status
)) {
8768 tevent_req_nterror(req
, status
);
8772 /* Copy out parameters */
8775 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8777 /* Reset temporary structure */
8778 ZERO_STRUCT(state
->tmp
);
8780 tevent_req_done(req
);
8783 NTSTATUS
rpccli_PNP_GetBlockedDriverInfo_recv(struct tevent_req
*req
,
8784 TALLOC_CTX
*mem_ctx
,
8787 struct rpccli_PNP_GetBlockedDriverInfo_state
*state
= tevent_req_data(
8788 req
, struct rpccli_PNP_GetBlockedDriverInfo_state
);
8791 if (tevent_req_is_nterror(req
, &status
)) {
8792 tevent_req_received(req
);
8796 /* Steal possbile out parameters to the callers context */
8797 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8800 *result
= state
->orig
.out
.result
;
8802 tevent_req_received(req
);
8803 return NT_STATUS_OK
;
8806 NTSTATUS
rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client
*cli
,
8807 TALLOC_CTX
*mem_ctx
,
8810 struct PNP_GetBlockedDriverInfo r
;
8815 status
= cli
->dispatch(cli
,
8818 NDR_PNP_GETBLOCKEDDRIVERINFO
,
8821 if (!NT_STATUS_IS_OK(status
)) {
8825 if (NT_STATUS_IS_ERR(status
)) {
8829 /* Return variables */
8833 *werror
= r
.out
.result
;
8836 return werror_to_ntstatus(r
.out
.result
);
8839 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
{
8840 struct PNP_GetServerSideDeviceInstallFlags orig
;
8841 struct PNP_GetServerSideDeviceInstallFlags tmp
;
8842 TALLOC_CTX
*out_mem_ctx
;
8843 NTSTATUS (*dispatch_recv
)(struct tevent_req
*req
, TALLOC_CTX
*mem_ctx
);
8846 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req
*subreq
);
8848 struct tevent_req
*rpccli_PNP_GetServerSideDeviceInstallFlags_send(TALLOC_CTX
*mem_ctx
,
8849 struct tevent_context
*ev
,
8850 struct rpc_pipe_client
*cli
)
8852 struct tevent_req
*req
;
8853 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
*state
;
8854 struct tevent_req
*subreq
;
8856 req
= tevent_req_create(mem_ctx
, &state
,
8857 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
);
8861 state
->out_mem_ctx
= NULL
;
8862 state
->dispatch_recv
= cli
->dispatch_recv
;
8866 /* Out parameters */
8869 ZERO_STRUCT(state
->orig
.out
.result
);
8871 /* make a temporary copy, that we pass to the dispatch function */
8872 state
->tmp
= state
->orig
;
8874 subreq
= cli
->dispatch_send(state
, ev
, cli
,
8876 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS
,
8878 if (tevent_req_nomem(subreq
, req
)) {
8879 return tevent_req_post(req
, ev
);
8881 tevent_req_set_callback(subreq
, rpccli_PNP_GetServerSideDeviceInstallFlags_done
, req
);
8885 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req
*subreq
)
8887 struct tevent_req
*req
= tevent_req_callback_data(
8888 subreq
, struct tevent_req
);
8889 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
*state
= tevent_req_data(
8890 req
, struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
);
8892 TALLOC_CTX
*mem_ctx
;
8894 if (state
->out_mem_ctx
) {
8895 mem_ctx
= state
->out_mem_ctx
;
8900 status
= state
->dispatch_recv(subreq
, mem_ctx
);
8901 TALLOC_FREE(subreq
);
8902 if (!NT_STATUS_IS_OK(status
)) {
8903 tevent_req_nterror(req
, status
);
8907 /* Copy out parameters */
8910 state
->orig
.out
.result
= state
->tmp
.out
.result
;
8912 /* Reset temporary structure */
8913 ZERO_STRUCT(state
->tmp
);
8915 tevent_req_done(req
);
8918 NTSTATUS
rpccli_PNP_GetServerSideDeviceInstallFlags_recv(struct tevent_req
*req
,
8919 TALLOC_CTX
*mem_ctx
,
8922 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
*state
= tevent_req_data(
8923 req
, struct rpccli_PNP_GetServerSideDeviceInstallFlags_state
);
8926 if (tevent_req_is_nterror(req
, &status
)) {
8927 tevent_req_received(req
);
8931 /* Steal possbile out parameters to the callers context */
8932 talloc_steal(mem_ctx
, state
->out_mem_ctx
);
8935 *result
= state
->orig
.out
.result
;
8937 tevent_req_received(req
);
8938 return NT_STATUS_OK
;
8941 NTSTATUS
rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client
*cli
,
8942 TALLOC_CTX
*mem_ctx
,
8945 struct PNP_GetServerSideDeviceInstallFlags r
;
8950 status
= cli
->dispatch(cli
,
8953 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS
,
8956 if (!NT_STATUS_IS_OK(status
)) {
8960 if (NT_STATUS_IS_ERR(status
)) {
8964 /* Return variables */
8968 *werror
= r
.out
.result
;
8971 return werror_to_ntstatus(r
.out
.result
);