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);