?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-passdb: Fix typo in debug message.
[Samba/gebeck_regimport.git] / librpc / gen_ndr / cli_ntsvcs.c
blob760ce53591d3d9fbcf12132694168c6f1a0117c1
1 /*
2 * Unix SMB/CIFS implementation.
3 * client auto-generated by pidl. DO NOT MODIFY!
4 */
5
6 #include "includes.h"
7 #include "../librpc/gen_ndr/cli_ntsvcs.h"
8
9 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);
14 };
15
16 static void rpccli_PNP_Disconnect_done(struct tevent_req *subreq);
17
18 struct tevent_req *rpccli_PNP_Disconnect_send(TALLOC_CTX *mem_ctx,
19 struct tevent_context *ev,
20 struct rpc_pipe_client *cli)
21 {
22 struct tevent_req *req;
23 struct rpccli_PNP_Disconnect_state *state;
24 struct tevent_req *subreq;
25
26 req = tevent_req_create(mem_ctx, &state,
27 struct rpccli_PNP_Disconnect_state);
28 if (req == NULL) {
29 return NULL;
30 }
31 state->out_mem_ctx = NULL;
32 state->dispatch_recv = cli->dispatch_recv;
33
34 /* In parameters */
35
36 /* Out parameters */
37
38 /* Result */
39 ZERO_STRUCT(state->orig.out.result);
40
41 /* make a temporary copy, that we pass to the dispatch function */
42 state->tmp = state->orig;
43
44 subreq = cli->dispatch_send(state, ev, cli,
45 &ndr_table_ntsvcs,
46 NDR_PNP_DISCONNECT,
47 &state->tmp);
48 if (tevent_req_nomem(subreq, req)) {
49 return tevent_req_post(req, ev);
50 }
51 tevent_req_set_callback(subreq, rpccli_PNP_Disconnect_done, req);
52 return req;
53 }
54
55 static void rpccli_PNP_Disconnect_done(struct tevent_req *subreq)
56 {
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);
61 NTSTATUS status;
62 TALLOC_CTX *mem_ctx;
63
64 if (state->out_mem_ctx) {
65 mem_ctx = state->out_mem_ctx;
66 } else {
67 mem_ctx = state;
68 }
69
70 status = state->dispatch_recv(subreq, mem_ctx);
71 TALLOC_FREE(subreq);
72 if (!NT_STATUS_IS_OK(status)) {
73 tevent_req_nterror(req, status);
74 return;
75 }
76
77 /* Copy out parameters */
78
79 /* Copy result */
80 state->orig.out.result = state->tmp.out.result;
81
82 /* Reset temporary structure */
83 ZERO_STRUCT(state->tmp);
84
85 tevent_req_done(req);
86 }
87
88 NTSTATUS rpccli_PNP_Disconnect_recv(struct tevent_req *req,
89 TALLOC_CTX *mem_ctx,
90 WERROR *result)
91 {
92 struct rpccli_PNP_Disconnect_state *state = tevent_req_data(
93 req, struct rpccli_PNP_Disconnect_state);
94 NTSTATUS status;
95
96 if (tevent_req_is_nterror(req, &status)) {
97 tevent_req_received(req);
98 return status;
99 }
100
101 /* Steal possbile out parameters to the callers context */
102 talloc_steal(mem_ctx, state->out_mem_ctx);
103
104 /* Return result */
105 *result = state->orig.out.result;
106
107 tevent_req_received(req);
108 return NT_STATUS_OK;
109 }
110
111 NTSTATUS rpccli_PNP_Disconnect(struct rpc_pipe_client *cli,
112 TALLOC_CTX *mem_ctx,
113 WERROR *werror)
114 {
115 struct PNP_Disconnect r;
116 NTSTATUS status;
117
118 /* In parameters */
119
120 status = cli->dispatch(cli,
121 mem_ctx,
122 &ndr_table_ntsvcs,
123 NDR_PNP_DISCONNECT,
124 &r);
125
126 if (!NT_STATUS_IS_OK(status)) {
127 return status;
128 }
129
130 if (NT_STATUS_IS_ERR(status)) {
131 return status;
132 }
133
134 /* Return variables */
135
136 /* Return result */
137 if (werror) {
138 *werror = r.out.result;
139 }
140
141 return werror_to_ntstatus(r.out.result);
142 }
143
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);
149 };
150
151 static void rpccli_PNP_Connect_done(struct tevent_req *subreq);
152
153 struct tevent_req *rpccli_PNP_Connect_send(TALLOC_CTX *mem_ctx,
154 struct tevent_context *ev,
155 struct rpc_pipe_client *cli)
156 {
157 struct tevent_req *req;
158 struct rpccli_PNP_Connect_state *state;
159 struct tevent_req *subreq;
160
161 req = tevent_req_create(mem_ctx, &state,
162 struct rpccli_PNP_Connect_state);
163 if (req == NULL) {
164 return NULL;
165 }
166 state->out_mem_ctx = NULL;
167 state->dispatch_recv = cli->dispatch_recv;
168
169 /* In parameters */
170
171 /* Out parameters */
172
173 /* Result */
174 ZERO_STRUCT(state->orig.out.result);
175
176 /* make a temporary copy, that we pass to the dispatch function */
177 state->tmp = state->orig;
178
179 subreq = cli->dispatch_send(state, ev, cli,
180 &ndr_table_ntsvcs,
181 NDR_PNP_CONNECT,
182 &state->tmp);
183 if (tevent_req_nomem(subreq, req)) {
184 return tevent_req_post(req, ev);
185 }
186 tevent_req_set_callback(subreq, rpccli_PNP_Connect_done, req);
187 return req;
188 }
189
190 static void rpccli_PNP_Connect_done(struct tevent_req *subreq)
191 {
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);
196 NTSTATUS status;
197 TALLOC_CTX *mem_ctx;
198
199 if (state->out_mem_ctx) {
200 mem_ctx = state->out_mem_ctx;
201 } else {
202 mem_ctx = state;
203 }
204
205 status = state->dispatch_recv(subreq, mem_ctx);
206 TALLOC_FREE(subreq);
207 if (!NT_STATUS_IS_OK(status)) {
208 tevent_req_nterror(req, status);
209 return;
210 }
211
212 /* Copy out parameters */
213
214 /* Copy result */
215 state->orig.out.result = state->tmp.out.result;
216
217 /* Reset temporary structure */
218 ZERO_STRUCT(state->tmp);
219
220 tevent_req_done(req);
221 }
222
223 NTSTATUS rpccli_PNP_Connect_recv(struct tevent_req *req,
224 TALLOC_CTX *mem_ctx,
225 WERROR *result)
226 {
227 struct rpccli_PNP_Connect_state *state = tevent_req_data(
228 req, struct rpccli_PNP_Connect_state);
229 NTSTATUS status;
230
231 if (tevent_req_is_nterror(req, &status)) {
232 tevent_req_received(req);
233 return status;
234 }
235
236 /* Steal possbile out parameters to the callers context */
237 talloc_steal(mem_ctx, state->out_mem_ctx);
238
239 /* Return result */
240 *result = state->orig.out.result;
241
242 tevent_req_received(req);
243 return NT_STATUS_OK;
244 }
245
246 NTSTATUS rpccli_PNP_Connect(struct rpc_pipe_client *cli,
247 TALLOC_CTX *mem_ctx,
248 WERROR *werror)
249 {
250 struct PNP_Connect r;
251 NTSTATUS status;
252
253 /* In parameters */
254
255 status = cli->dispatch(cli,
256 mem_ctx,
257 &ndr_table_ntsvcs,
258 NDR_PNP_CONNECT,
259 &r);
260
261 if (!NT_STATUS_IS_OK(status)) {
262 return status;
263 }
264
265 if (NT_STATUS_IS_ERR(status)) {
266 return status;
267 }
268
269 /* Return variables */
270
271 /* Return result */
272 if (werror) {
273 *werror = r.out.result;
274 }
275
276 return werror_to_ntstatus(r.out.result);
277 }
278
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);
284 };
285
286 static void rpccli_PNP_GetVersion_done(struct tevent_req *subreq);
287
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] */)
292 {
293 struct tevent_req *req;
294 struct rpccli_PNP_GetVersion_state *state;
295 struct tevent_req *subreq;
296
297 req = tevent_req_create(mem_ctx, &state,
298 struct rpccli_PNP_GetVersion_state);
299 if (req == NULL) {
300 return NULL;
301 }
302 state->out_mem_ctx = NULL;
303 state->dispatch_recv = cli->dispatch_recv;
304
305 /* In parameters */
306
307 /* Out parameters */
308 state->orig.out.version = _version;
309
310 /* Result */
311 ZERO_STRUCT(state->orig.out.result);
312
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);
317 }
318
319 /* make a temporary copy, that we pass to the dispatch function */
320 state->tmp = state->orig;
321
322 subreq = cli->dispatch_send(state, ev, cli,
323 &ndr_table_ntsvcs,
324 NDR_PNP_GETVERSION,
325 &state->tmp);
326 if (tevent_req_nomem(subreq, req)) {
327 return tevent_req_post(req, ev);
328 }
329 tevent_req_set_callback(subreq, rpccli_PNP_GetVersion_done, req);
330 return req;
331 }
332
333 static void rpccli_PNP_GetVersion_done(struct tevent_req *subreq)
334 {
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);
339 NTSTATUS status;
340 TALLOC_CTX *mem_ctx;
341
342 if (state->out_mem_ctx) {
343 mem_ctx = state->out_mem_ctx;
344 } else {
345 mem_ctx = state;
346 }
347
348 status = state->dispatch_recv(subreq, mem_ctx);
349 TALLOC_FREE(subreq);
350 if (!NT_STATUS_IS_OK(status)) {
351 tevent_req_nterror(req, status);
352 return;
353 }
354
355 /* Copy out parameters */
356 *state->orig.out.version = *state->tmp.out.version;
357
358 /* Copy result */
359 state->orig.out.result = state->tmp.out.result;
360
361 /* Reset temporary structure */
362 ZERO_STRUCT(state->tmp);
363
364 tevent_req_done(req);
365 }
366
367 NTSTATUS rpccli_PNP_GetVersion_recv(struct tevent_req *req,
368 TALLOC_CTX *mem_ctx,
369 WERROR *result)
370 {
371 struct rpccli_PNP_GetVersion_state *state = tevent_req_data(
372 req, struct rpccli_PNP_GetVersion_state);
373 NTSTATUS status;
374
375 if (tevent_req_is_nterror(req, &status)) {
376 tevent_req_received(req);
377 return status;
378 }
379
380 /* Steal possbile out parameters to the callers context */
381 talloc_steal(mem_ctx, state->out_mem_ctx);
382
383 /* Return result */
384 *result = state->orig.out.result;
385
386 tevent_req_received(req);
387 return NT_STATUS_OK;
388 }
389
390 NTSTATUS rpccli_PNP_GetVersion(struct rpc_pipe_client *cli,
391 TALLOC_CTX *mem_ctx,
392 uint16_t *version /* [out] [ref] */,
393 WERROR *werror)
394 {
395 struct PNP_GetVersion r;
396 NTSTATUS status;
397
398 /* In parameters */
399
400 status = cli->dispatch(cli,
401 mem_ctx,
402 &ndr_table_ntsvcs,
403 NDR_PNP_GETVERSION,
404 &r);
405
406 if (!NT_STATUS_IS_OK(status)) {
407 return status;
408 }
409
410 if (NT_STATUS_IS_ERR(status)) {
411 return status;
412 }
413
414 /* Return variables */
415 *version = *r.out.version;
416
417 /* Return result */
418 if (werror) {
419 *werror = r.out.result;
420 }
421
422 return werror_to_ntstatus(r.out.result);
423 }
424
425 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);
430 };
431
432 static void rpccli_PNP_GetGlobalState_done(struct tevent_req *subreq);
433
434 struct tevent_req *rpccli_PNP_GetGlobalState_send(TALLOC_CTX *mem_ctx,
435 struct tevent_context *ev,
436 struct rpc_pipe_client *cli)
437 {
438 struct tevent_req *req;
439 struct rpccli_PNP_GetGlobalState_state *state;
440 struct tevent_req *subreq;
441
442 req = tevent_req_create(mem_ctx, &state,
443 struct rpccli_PNP_GetGlobalState_state);
444 if (req == NULL) {
445 return NULL;
446 }
447 state->out_mem_ctx = NULL;
448 state->dispatch_recv = cli->dispatch_recv;
449
450 /* In parameters */
451
452 /* Out parameters */
453
454 /* Result */
455 ZERO_STRUCT(state->orig.out.result);
456
457 /* make a temporary copy, that we pass to the dispatch function */
458 state->tmp = state->orig;
459
460 subreq = cli->dispatch_send(state, ev, cli,
461 &ndr_table_ntsvcs,
462 NDR_PNP_GETGLOBALSTATE,
463 &state->tmp);
464 if (tevent_req_nomem(subreq, req)) {
465 return tevent_req_post(req, ev);
466 }
467 tevent_req_set_callback(subreq, rpccli_PNP_GetGlobalState_done, req);
468 return req;
469 }
470
471 static void rpccli_PNP_GetGlobalState_done(struct tevent_req *subreq)
472 {
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);
477 NTSTATUS status;
478 TALLOC_CTX *mem_ctx;
479
480 if (state->out_mem_ctx) {
481 mem_ctx = state->out_mem_ctx;
482 } else {
483 mem_ctx = state;
484 }
485
486 status = state->dispatch_recv(subreq, mem_ctx);
487 TALLOC_FREE(subreq);
488 if (!NT_STATUS_IS_OK(status)) {
489 tevent_req_nterror(req, status);
490 return;
491 }
492
493 /* Copy out parameters */
494
495 /* Copy result */
496 state->orig.out.result = state->tmp.out.result;
497
498 /* Reset temporary structure */
499 ZERO_STRUCT(state->tmp);
500
501 tevent_req_done(req);
502 }
503
504 NTSTATUS rpccli_PNP_GetGlobalState_recv(struct tevent_req *req,
505 TALLOC_CTX *mem_ctx,
506 WERROR *result)
507 {
508 struct rpccli_PNP_GetGlobalState_state *state = tevent_req_data(
509 req, struct rpccli_PNP_GetGlobalState_state);
510 NTSTATUS status;
511
512 if (tevent_req_is_nterror(req, &status)) {
513 tevent_req_received(req);
514 return status;
515 }
516
517 /* Steal possbile out parameters to the callers context */
518 talloc_steal(mem_ctx, state->out_mem_ctx);
519
520 /* Return result */
521 *result = state->orig.out.result;
522
523 tevent_req_received(req);
524 return NT_STATUS_OK;
525 }
526
527 NTSTATUS rpccli_PNP_GetGlobalState(struct rpc_pipe_client *cli,
528 TALLOC_CTX *mem_ctx,
529 WERROR *werror)
530 {
531 struct PNP_GetGlobalState r;
532 NTSTATUS status;
533
534 /* In parameters */
535
536 status = cli->dispatch(cli,
537 mem_ctx,
538 &ndr_table_ntsvcs,
539 NDR_PNP_GETGLOBALSTATE,
540 &r);
541
542 if (!NT_STATUS_IS_OK(status)) {
543 return status;
544 }
545
546 if (NT_STATUS_IS_ERR(status)) {
547 return status;
548 }
549
550 /* Return variables */
551
552 /* Return result */
553 if (werror) {
554 *werror = r.out.result;
555 }
556
557 return werror_to_ntstatus(r.out.result);
558 }
559
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);
565 };
566
567 static void rpccli_PNP_InitDetection_done(struct tevent_req *subreq);
568
569 struct tevent_req *rpccli_PNP_InitDetection_send(TALLOC_CTX *mem_ctx,
570 struct tevent_context *ev,
571 struct rpc_pipe_client *cli)
572 {
573 struct tevent_req *req;
574 struct rpccli_PNP_InitDetection_state *state;
575 struct tevent_req *subreq;
576
577 req = tevent_req_create(mem_ctx, &state,
578 struct rpccli_PNP_InitDetection_state);
579 if (req == NULL) {
580 return NULL;
581 }
582 state->out_mem_ctx = NULL;
583 state->dispatch_recv = cli->dispatch_recv;
584
585 /* In parameters */
586
587 /* Out parameters */
588
589 /* Result */
590 ZERO_STRUCT(state->orig.out.result);
591
592 /* make a temporary copy, that we pass to the dispatch function */
593 state->tmp = state->orig;
594
595 subreq = cli->dispatch_send(state, ev, cli,
596 &ndr_table_ntsvcs,
597 NDR_PNP_INITDETECTION,
598 &state->tmp);
599 if (tevent_req_nomem(subreq, req)) {
600 return tevent_req_post(req, ev);
601 }
602 tevent_req_set_callback(subreq, rpccli_PNP_InitDetection_done, req);
603 return req;
604 }
605
606 static void rpccli_PNP_InitDetection_done(struct tevent_req *subreq)
607 {
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);
612 NTSTATUS status;
613 TALLOC_CTX *mem_ctx;
614
615 if (state->out_mem_ctx) {
616 mem_ctx = state->out_mem_ctx;
617 } else {
618 mem_ctx = state;
619 }
620
621 status = state->dispatch_recv(subreq, mem_ctx);
622 TALLOC_FREE(subreq);
623 if (!NT_STATUS_IS_OK(status)) {
624 tevent_req_nterror(req, status);
625 return;
626 }
627
628 /* Copy out parameters */
629
630 /* Copy result */
631 state->orig.out.result = state->tmp.out.result;
632
633 /* Reset temporary structure */
634 ZERO_STRUCT(state->tmp);
635
636 tevent_req_done(req);
637 }
638
639 NTSTATUS rpccli_PNP_InitDetection_recv(struct tevent_req *req,
640 TALLOC_CTX *mem_ctx,
641 WERROR *result)
642 {
643 struct rpccli_PNP_InitDetection_state *state = tevent_req_data(
644 req, struct rpccli_PNP_InitDetection_state);
645 NTSTATUS status;
646
647 if (tevent_req_is_nterror(req, &status)) {
648 tevent_req_received(req);
649 return status;
650 }
651
652 /* Steal possbile out parameters to the callers context */
653 talloc_steal(mem_ctx, state->out_mem_ctx);
654
655 /* Return result */
656 *result = state->orig.out.result;
657
658 tevent_req_received(req);
659 return NT_STATUS_OK;
660 }
661
662 NTSTATUS rpccli_PNP_InitDetection(struct rpc_pipe_client *cli,
663 TALLOC_CTX *mem_ctx,
664 WERROR *werror)
665 {
666 struct PNP_InitDetection r;
667 NTSTATUS status;
668
669 /* In parameters */
670
671 status = cli->dispatch(cli,
672 mem_ctx,
673 &ndr_table_ntsvcs,
674 NDR_PNP_INITDETECTION,
675 &r);
676
677 if (!NT_STATUS_IS_OK(status)) {
678 return status;
679 }
680
681 if (NT_STATUS_IS_ERR(status)) {
682 return status;
683 }
684
685 /* Return variables */
686
687 /* Return result */
688 if (werror) {
689 *werror = r.out.result;
690 }
691
692 return werror_to_ntstatus(r.out.result);
693 }
694
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);
700 };
701
702 static void rpccli_PNP_ReportLogOn_done(struct tevent_req *subreq);
703
704 struct tevent_req *rpccli_PNP_ReportLogOn_send(TALLOC_CTX *mem_ctx,
705 struct tevent_context *ev,
706 struct rpc_pipe_client *cli)
707 {
708 struct tevent_req *req;
709 struct rpccli_PNP_ReportLogOn_state *state;
710 struct tevent_req *subreq;
711
712 req = tevent_req_create(mem_ctx, &state,
713 struct rpccli_PNP_ReportLogOn_state);
714 if (req == NULL) {
715 return NULL;
716 }
717 state->out_mem_ctx = NULL;
718 state->dispatch_recv = cli->dispatch_recv;
719
720 /* In parameters */
721
722 /* Out parameters */
723
724 /* Result */
725 ZERO_STRUCT(state->orig.out.result);
726
727 /* make a temporary copy, that we pass to the dispatch function */
728 state->tmp = state->orig;
729
730 subreq = cli->dispatch_send(state, ev, cli,
731 &ndr_table_ntsvcs,
732 NDR_PNP_REPORTLOGON,
733 &state->tmp);
734 if (tevent_req_nomem(subreq, req)) {
735 return tevent_req_post(req, ev);
736 }
737 tevent_req_set_callback(subreq, rpccli_PNP_ReportLogOn_done, req);
738 return req;
739 }
740
741 static void rpccli_PNP_ReportLogOn_done(struct tevent_req *subreq)
742 {
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);
747 NTSTATUS status;
748 TALLOC_CTX *mem_ctx;
749
750 if (state->out_mem_ctx) {
751 mem_ctx = state->out_mem_ctx;
752 } else {
753 mem_ctx = state;
754 }
755
756 status = state->dispatch_recv(subreq, mem_ctx);
757 TALLOC_FREE(subreq);
758 if (!NT_STATUS_IS_OK(status)) {
759 tevent_req_nterror(req, status);
760 return;
761 }
762
763 /* Copy out parameters */
764
765 /* Copy result */
766 state->orig.out.result = state->tmp.out.result;
767
768 /* Reset temporary structure */
769 ZERO_STRUCT(state->tmp);
770
771 tevent_req_done(req);
772 }
773
774 NTSTATUS rpccli_PNP_ReportLogOn_recv(struct tevent_req *req,
775 TALLOC_CTX *mem_ctx,
776 WERROR *result)
777 {
778 struct rpccli_PNP_ReportLogOn_state *state = tevent_req_data(
779 req, struct rpccli_PNP_ReportLogOn_state);
780 NTSTATUS status;
781
782 if (tevent_req_is_nterror(req, &status)) {
783 tevent_req_received(req);
784 return status;
785 }
786
787 /* Steal possbile out parameters to the callers context */
788 talloc_steal(mem_ctx, state->out_mem_ctx);
789
790 /* Return result */
791 *result = state->orig.out.result;
792
793 tevent_req_received(req);
794 return NT_STATUS_OK;
795 }
796
797 NTSTATUS rpccli_PNP_ReportLogOn(struct rpc_pipe_client *cli,
798 TALLOC_CTX *mem_ctx,
799 WERROR *werror)
800 {
801 struct PNP_ReportLogOn r;
802 NTSTATUS status;
803
804 /* In parameters */
805
806 status = cli->dispatch(cli,
807 mem_ctx,
808 &ndr_table_ntsvcs,
809 NDR_PNP_REPORTLOGON,
810 &r);
811
812 if (!NT_STATUS_IS_OK(status)) {
813 return status;
814 }
815
816 if (NT_STATUS_IS_ERR(status)) {
817 return status;
818 }
819
820 /* Return variables */
821
822 /* Return result */
823 if (werror) {
824 *werror = r.out.result;
825 }
826
827 return werror_to_ntstatus(r.out.result);
828 }
829
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);
835 };
836
837 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req *subreq);
838
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] */)
844 {
845 struct tevent_req *req;
846 struct rpccli_PNP_ValidateDeviceInstance_state *state;
847 struct tevent_req *subreq;
848
849 req = tevent_req_create(mem_ctx, &state,
850 struct rpccli_PNP_ValidateDeviceInstance_state);
851 if (req == NULL) {
852 return NULL;
853 }
854 state->out_mem_ctx = NULL;
855 state->dispatch_recv = cli->dispatch_recv;
856
857 /* In parameters */
858 state->orig.in.devicepath = _devicepath;
859 state->orig.in.flags = _flags;
860
861 /* Out parameters */
862
863 /* Result */
864 ZERO_STRUCT(state->orig.out.result);
865
866 /* make a temporary copy, that we pass to the dispatch function */
867 state->tmp = state->orig;
868
869 subreq = cli->dispatch_send(state, ev, cli,
870 &ndr_table_ntsvcs,
871 NDR_PNP_VALIDATEDEVICEINSTANCE,
872 &state->tmp);
873 if (tevent_req_nomem(subreq, req)) {
874 return tevent_req_post(req, ev);
875 }
876 tevent_req_set_callback(subreq, rpccli_PNP_ValidateDeviceInstance_done, req);
877 return req;
878 }
879
880 static void rpccli_PNP_ValidateDeviceInstance_done(struct tevent_req *subreq)
881 {
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);
886 NTSTATUS status;
887 TALLOC_CTX *mem_ctx;
888
889 if (state->out_mem_ctx) {
890 mem_ctx = state->out_mem_ctx;
891 } else {
892 mem_ctx = state;
893 }
894
895 status = state->dispatch_recv(subreq, mem_ctx);
896 TALLOC_FREE(subreq);
897 if (!NT_STATUS_IS_OK(status)) {
898 tevent_req_nterror(req, status);
899 return;
900 }
901
902 /* Copy out parameters */
903
904 /* Copy result */
905 state->orig.out.result = state->tmp.out.result;
906
907 /* Reset temporary structure */
908 ZERO_STRUCT(state->tmp);
909
910 tevent_req_done(req);
911 }
912
913 NTSTATUS rpccli_PNP_ValidateDeviceInstance_recv(struct tevent_req *req,
914 TALLOC_CTX *mem_ctx,
915 WERROR *result)
916 {
917 struct rpccli_PNP_ValidateDeviceInstance_state *state = tevent_req_data(
918 req, struct rpccli_PNP_ValidateDeviceInstance_state);
919 NTSTATUS status;
920
921 if (tevent_req_is_nterror(req, &status)) {
922 tevent_req_received(req);
923 return status;
924 }
925
926 /* Steal possbile out parameters to the callers context */
927 talloc_steal(mem_ctx, state->out_mem_ctx);
928
929 /* Return result */
930 *result = state->orig.out.result;
931
932 tevent_req_received(req);
933 return NT_STATUS_OK;
934 }
935
936 NTSTATUS rpccli_PNP_ValidateDeviceInstance(struct rpc_pipe_client *cli,
937 TALLOC_CTX *mem_ctx,
938 const char *devicepath /* [in] [ref,charset(UTF16)] */,
939 uint32_t flags /* [in] */,
940 WERROR *werror)
941 {
942 struct PNP_ValidateDeviceInstance r;
943 NTSTATUS status;
944
945 /* In parameters */
946 r.in.devicepath = devicepath;
947 r.in.flags = flags;
948
949 status = cli->dispatch(cli,
950 mem_ctx,
951 &ndr_table_ntsvcs,
952 NDR_PNP_VALIDATEDEVICEINSTANCE,
953 &r);
954
955 if (!NT_STATUS_IS_OK(status)) {
956 return status;
957 }
958
959 if (NT_STATUS_IS_ERR(status)) {
960 return status;
961 }
962
963 /* Return variables */
964
965 /* Return result */
966 if (werror) {
967 *werror = r.out.result;
968 }
969
970 return werror_to_ntstatus(r.out.result);
971 }
972
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);
978 };
979
980 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req *subreq);
981
982 struct tevent_req *rpccli_PNP_GetRootDeviceInstance_send(TALLOC_CTX *mem_ctx,
983 struct tevent_context *ev,
984 struct rpc_pipe_client *cli)
985 {
986 struct tevent_req *req;
987 struct rpccli_PNP_GetRootDeviceInstance_state *state;
988 struct tevent_req *subreq;
989
990 req = tevent_req_create(mem_ctx, &state,
991 struct rpccli_PNP_GetRootDeviceInstance_state);
992 if (req == NULL) {
993 return NULL;
994 }
995 state->out_mem_ctx = NULL;
996 state->dispatch_recv = cli->dispatch_recv;
997
998 /* In parameters */
999
1000 /* Out parameters */
1001
1002 /* Result */
1003 ZERO_STRUCT(state->orig.out.result);
1004
1005 /* make a temporary copy, that we pass to the dispatch function */
1006 state->tmp = state->orig;
1007
1008 subreq = cli->dispatch_send(state, ev, cli,
1009 &ndr_table_ntsvcs,
1010 NDR_PNP_GETROOTDEVICEINSTANCE,
1011 &state->tmp);
1012 if (tevent_req_nomem(subreq, req)) {
1013 return tevent_req_post(req, ev);
1014 }
1015 tevent_req_set_callback(subreq, rpccli_PNP_GetRootDeviceInstance_done, req);
1016 return req;
1017 }
1018
1019 static void rpccli_PNP_GetRootDeviceInstance_done(struct tevent_req *subreq)
1020 {
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);
1025 NTSTATUS status;
1026 TALLOC_CTX *mem_ctx;
1027
1028 if (state->out_mem_ctx) {
1029 mem_ctx = state->out_mem_ctx;
1030 } else {
1031 mem_ctx = state;
1032 }
1033
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);
1038 return;
1039 }
1040
1041 /* Copy out parameters */
1042
1043 /* Copy result */
1044 state->orig.out.result = state->tmp.out.result;
1045
1046 /* Reset temporary structure */
1047 ZERO_STRUCT(state->tmp);
1048
1049 tevent_req_done(req);
1050 }
1051
1052 NTSTATUS rpccli_PNP_GetRootDeviceInstance_recv(struct tevent_req *req,
1053 TALLOC_CTX *mem_ctx,
1054 WERROR *result)
1055 {
1056 struct rpccli_PNP_GetRootDeviceInstance_state *state = tevent_req_data(
1057 req, struct rpccli_PNP_GetRootDeviceInstance_state);
1058 NTSTATUS status;
1059
1060 if (tevent_req_is_nterror(req, &status)) {
1061 tevent_req_received(req);
1062 return status;
1063 }
1064
1065 /* Steal possbile out parameters to the callers context */
1066 talloc_steal(mem_ctx, state->out_mem_ctx);
1067
1068 /* Return result */
1069 *result = state->orig.out.result;
1070
1071 tevent_req_received(req);
1072 return NT_STATUS_OK;
1073 }
1074
1075 NTSTATUS rpccli_PNP_GetRootDeviceInstance(struct rpc_pipe_client *cli,
1076 TALLOC_CTX *mem_ctx,
1077 WERROR *werror)
1078 {
1079 struct PNP_GetRootDeviceInstance r;
1080 NTSTATUS status;
1081
1082 /* In parameters */
1083
1084 status = cli->dispatch(cli,
1085 mem_ctx,
1086 &ndr_table_ntsvcs,
1087 NDR_PNP_GETROOTDEVICEINSTANCE,
1088 &r);
1089
1090 if (!NT_STATUS_IS_OK(status)) {
1091 return status;
1092 }
1093
1094 if (NT_STATUS_IS_ERR(status)) {
1095 return status;
1096 }
1097
1098 /* Return variables */
1099
1100 /* Return result */
1101 if (werror) {
1102 *werror = r.out.result;
1103 }
1104
1105 return werror_to_ntstatus(r.out.result);
1106 }
1107
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);
1113 };
1114
1115 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req *subreq);
1116
1117 struct tevent_req *rpccli_PNP_GetRelatedDeviceInstance_send(TALLOC_CTX *mem_ctx,
1118 struct tevent_context *ev,
1119 struct rpc_pipe_client *cli)
1120 {
1121 struct tevent_req *req;
1122 struct rpccli_PNP_GetRelatedDeviceInstance_state *state;
1123 struct tevent_req *subreq;
1124
1125 req = tevent_req_create(mem_ctx, &state,
1126 struct rpccli_PNP_GetRelatedDeviceInstance_state);
1127 if (req == NULL) {
1128 return NULL;
1129 }
1130 state->out_mem_ctx = NULL;
1131 state->dispatch_recv = cli->dispatch_recv;
1132
1133 /* In parameters */
1134
1135 /* Out parameters */
1136
1137 /* Result */
1138 ZERO_STRUCT(state->orig.out.result);
1139
1140 /* make a temporary copy, that we pass to the dispatch function */
1141 state->tmp = state->orig;
1142
1143 subreq = cli->dispatch_send(state, ev, cli,
1144 &ndr_table_ntsvcs,
1145 NDR_PNP_GETRELATEDDEVICEINSTANCE,
1146 &state->tmp);
1147 if (tevent_req_nomem(subreq, req)) {
1148 return tevent_req_post(req, ev);
1149 }
1150 tevent_req_set_callback(subreq, rpccli_PNP_GetRelatedDeviceInstance_done, req);
1151 return req;
1152 }
1153
1154 static void rpccli_PNP_GetRelatedDeviceInstance_done(struct tevent_req *subreq)
1155 {
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);
1160 NTSTATUS status;
1161 TALLOC_CTX *mem_ctx;
1162
1163 if (state->out_mem_ctx) {
1164 mem_ctx = state->out_mem_ctx;
1165 } else {
1166 mem_ctx = state;
1167 }
1168
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);
1173 return;
1174 }
1175
1176 /* Copy out parameters */
1177
1178 /* Copy result */
1179 state->orig.out.result = state->tmp.out.result;
1180
1181 /* Reset temporary structure */
1182 ZERO_STRUCT(state->tmp);
1183
1184 tevent_req_done(req);
1185 }
1186
1187 NTSTATUS rpccli_PNP_GetRelatedDeviceInstance_recv(struct tevent_req *req,
1188 TALLOC_CTX *mem_ctx,
1189 WERROR *result)
1190 {
1191 struct rpccli_PNP_GetRelatedDeviceInstance_state *state = tevent_req_data(
1192 req, struct rpccli_PNP_GetRelatedDeviceInstance_state);
1193 NTSTATUS status;
1194
1195 if (tevent_req_is_nterror(req, &status)) {
1196 tevent_req_received(req);
1197 return status;
1198 }
1199
1200 /* Steal possbile out parameters to the callers context */
1201 talloc_steal(mem_ctx, state->out_mem_ctx);
1202
1203 /* Return result */
1204 *result = state->orig.out.result;
1205
1206 tevent_req_received(req);
1207 return NT_STATUS_OK;
1208 }
1209
1210 NTSTATUS rpccli_PNP_GetRelatedDeviceInstance(struct rpc_pipe_client *cli,
1211 TALLOC_CTX *mem_ctx,
1212 WERROR *werror)
1213 {
1214 struct PNP_GetRelatedDeviceInstance r;
1215 NTSTATUS status;
1216
1217 /* In parameters */
1218
1219 status = cli->dispatch(cli,
1220 mem_ctx,
1221 &ndr_table_ntsvcs,
1222 NDR_PNP_GETRELATEDDEVICEINSTANCE,
1223 &r);
1224
1225 if (!NT_STATUS_IS_OK(status)) {
1226 return status;
1227 }
1228
1229 if (NT_STATUS_IS_ERR(status)) {
1230 return status;
1231 }
1232
1233 /* Return variables */
1234
1235 /* Return result */
1236 if (werror) {
1237 *werror = r.out.result;
1238 }
1239
1240 return werror_to_ntstatus(r.out.result);
1241 }
1242
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);
1248 };
1249
1250 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req *subreq);
1251
1252 struct tevent_req *rpccli_PNP_EnumerateSubKeys_send(TALLOC_CTX *mem_ctx,
1253 struct tevent_context *ev,
1254 struct rpc_pipe_client *cli)
1255 {
1256 struct tevent_req *req;
1257 struct rpccli_PNP_EnumerateSubKeys_state *state;
1258 struct tevent_req *subreq;
1259
1260 req = tevent_req_create(mem_ctx, &state,
1261 struct rpccli_PNP_EnumerateSubKeys_state);
1262 if (req == NULL) {
1263 return NULL;
1264 }
1265 state->out_mem_ctx = NULL;
1266 state->dispatch_recv = cli->dispatch_recv;
1267
1268 /* In parameters */
1269
1270 /* Out parameters */
1271
1272 /* Result */
1273 ZERO_STRUCT(state->orig.out.result);
1274
1275 /* make a temporary copy, that we pass to the dispatch function */
1276 state->tmp = state->orig;
1277
1278 subreq = cli->dispatch_send(state, ev, cli,
1279 &ndr_table_ntsvcs,
1280 NDR_PNP_ENUMERATESUBKEYS,
1281 &state->tmp);
1282 if (tevent_req_nomem(subreq, req)) {
1283 return tevent_req_post(req, ev);
1284 }
1285 tevent_req_set_callback(subreq, rpccli_PNP_EnumerateSubKeys_done, req);
1286 return req;
1287 }
1288
1289 static void rpccli_PNP_EnumerateSubKeys_done(struct tevent_req *subreq)
1290 {
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);
1295 NTSTATUS status;
1296 TALLOC_CTX *mem_ctx;
1297
1298 if (state->out_mem_ctx) {
1299 mem_ctx = state->out_mem_ctx;
1300 } else {
1301 mem_ctx = state;
1302 }
1303
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);
1308 return;
1309 }
1310
1311 /* Copy out parameters */
1312
1313 /* Copy result */
1314 state->orig.out.result = state->tmp.out.result;
1315
1316 /* Reset temporary structure */
1317 ZERO_STRUCT(state->tmp);
1318
1319 tevent_req_done(req);
1320 }
1321
1322 NTSTATUS rpccli_PNP_EnumerateSubKeys_recv(struct tevent_req *req,
1323 TALLOC_CTX *mem_ctx,
1324 WERROR *result)
1325 {
1326 struct rpccli_PNP_EnumerateSubKeys_state *state = tevent_req_data(
1327 req, struct rpccli_PNP_EnumerateSubKeys_state);
1328 NTSTATUS status;
1329
1330 if (tevent_req_is_nterror(req, &status)) {
1331 tevent_req_received(req);
1332 return status;
1333 }
1334
1335 /* Steal possbile out parameters to the callers context */
1336 talloc_steal(mem_ctx, state->out_mem_ctx);
1337
1338 /* Return result */
1339 *result = state->orig.out.result;
1340
1341 tevent_req_received(req);
1342 return NT_STATUS_OK;
1343 }
1344
1345 NTSTATUS rpccli_PNP_EnumerateSubKeys(struct rpc_pipe_client *cli,
1346 TALLOC_CTX *mem_ctx,
1347 WERROR *werror)
1348 {
1349 struct PNP_EnumerateSubKeys r;
1350 NTSTATUS status;
1351
1352 /* In parameters */
1353
1354 status = cli->dispatch(cli,
1355 mem_ctx,
1356 &ndr_table_ntsvcs,
1357 NDR_PNP_ENUMERATESUBKEYS,
1358 &r);
1359
1360 if (!NT_STATUS_IS_OK(status)) {
1361 return status;
1362 }
1363
1364 if (NT_STATUS_IS_ERR(status)) {
1365 return status;
1366 }
1367
1368 /* Return variables */
1369
1370 /* Return result */
1371 if (werror) {
1372 *werror = r.out.result;
1373 }
1374
1375 return werror_to_ntstatus(r.out.result);
1376 }
1377
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);
1383 };
1384
1385 static void rpccli_PNP_GetDeviceList_done(struct tevent_req *subreq);
1386
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] */)
1394 {
1395 struct tevent_req *req;
1396 struct rpccli_PNP_GetDeviceList_state *state;
1397 struct tevent_req *subreq;
1398
1399 req = tevent_req_create(mem_ctx, &state,
1400 struct rpccli_PNP_GetDeviceList_state);
1401 if (req == NULL) {
1402 return NULL;
1403 }
1404 state->out_mem_ctx = NULL;
1405 state->dispatch_recv = cli->dispatch_recv;
1406
1407 /* In parameters */
1408 state->orig.in.filter = _filter;
1409 state->orig.in.length = _length;
1410 state->orig.in.flags = _flags;
1411
1412 /* Out parameters */
1413 state->orig.out.buffer = _buffer;
1414 state->orig.out.length = _length;
1415
1416 /* Result */
1417 ZERO_STRUCT(state->orig.out.result);
1418
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);
1423 }
1424
1425 /* make a temporary copy, that we pass to the dispatch function */
1426 state->tmp = state->orig;
1427
1428 subreq = cli->dispatch_send(state, ev, cli,
1429 &ndr_table_ntsvcs,
1430 NDR_PNP_GETDEVICELIST,
1431 &state->tmp);
1432 if (tevent_req_nomem(subreq, req)) {
1433 return tevent_req_post(req, ev);
1434 }
1435 tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceList_done, req);
1436 return req;
1437 }
1438
1439 static void rpccli_PNP_GetDeviceList_done(struct tevent_req *subreq)
1440 {
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);
1445 NTSTATUS status;
1446 TALLOC_CTX *mem_ctx;
1447
1448 if (state->out_mem_ctx) {
1449 mem_ctx = state->out_mem_ctx;
1450 } else {
1451 mem_ctx = state;
1452 }
1453
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);
1458 return;
1459 }
1460
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;
1464
1465 /* Copy result */
1466 state->orig.out.result = state->tmp.out.result;
1467
1468 /* Reset temporary structure */
1469 ZERO_STRUCT(state->tmp);
1470
1471 tevent_req_done(req);
1472 }
1473
1474 NTSTATUS rpccli_PNP_GetDeviceList_recv(struct tevent_req *req,
1475 TALLOC_CTX *mem_ctx,
1476 WERROR *result)
1477 {
1478 struct rpccli_PNP_GetDeviceList_state *state = tevent_req_data(
1479 req, struct rpccli_PNP_GetDeviceList_state);
1480 NTSTATUS status;
1481
1482 if (tevent_req_is_nterror(req, &status)) {
1483 tevent_req_received(req);
1484 return status;
1485 }
1486
1487 /* Steal possbile out parameters to the callers context */
1488 talloc_steal(mem_ctx, state->out_mem_ctx);
1489
1490 /* Return result */
1491 *result = state->orig.out.result;
1492
1493 tevent_req_received(req);
1494 return NT_STATUS_OK;
1495 }
1496
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] */,
1503 WERROR *werror)
1504 {
1505 struct PNP_GetDeviceList r;
1506 NTSTATUS status;
1507
1508 /* In parameters */
1509 r.in.filter = filter;
1510 r.in.length = length;
1511 r.in.flags = flags;
1512
1513 status = cli->dispatch(cli,
1514 mem_ctx,
1515 &ndr_table_ntsvcs,
1516 NDR_PNP_GETDEVICELIST,
1517 &r);
1518
1519 if (!NT_STATUS_IS_OK(status)) {
1520 return status;
1521 }
1522
1523 if (NT_STATUS_IS_ERR(status)) {
1524 return status;
1525 }
1526
1527 /* Return variables */
1528 memcpy(buffer, r.out.buffer, (*r.in.length) * sizeof(*buffer));
1529 *length = *r.out.length;
1530
1531 /* Return result */
1532 if (werror) {
1533 *werror = r.out.result;
1534 }
1535
1536 return werror_to_ntstatus(r.out.result);
1537 }
1538
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);
1544 };
1545
1546 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req *subreq);
1547
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] */)
1554 {
1555 struct tevent_req *req;
1556 struct rpccli_PNP_GetDeviceListSize_state *state;
1557 struct tevent_req *subreq;
1558
1559 req = tevent_req_create(mem_ctx, &state,
1560 struct rpccli_PNP_GetDeviceListSize_state);
1561 if (req == NULL) {
1562 return NULL;
1563 }
1564 state->out_mem_ctx = NULL;
1565 state->dispatch_recv = cli->dispatch_recv;
1566
1567 /* In parameters */
1568 state->orig.in.devicename = _devicename;
1569 state->orig.in.flags = _flags;
1570
1571 /* Out parameters */
1572 state->orig.out.size = _size;
1573
1574 /* Result */
1575 ZERO_STRUCT(state->orig.out.result);
1576
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);
1581 }
1582
1583 /* make a temporary copy, that we pass to the dispatch function */
1584 state->tmp = state->orig;
1585
1586 subreq = cli->dispatch_send(state, ev, cli,
1587 &ndr_table_ntsvcs,
1588 NDR_PNP_GETDEVICELISTSIZE,
1589 &state->tmp);
1590 if (tevent_req_nomem(subreq, req)) {
1591 return tevent_req_post(req, ev);
1592 }
1593 tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceListSize_done, req);
1594 return req;
1595 }
1596
1597 static void rpccli_PNP_GetDeviceListSize_done(struct tevent_req *subreq)
1598 {
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);
1603 NTSTATUS status;
1604 TALLOC_CTX *mem_ctx;
1605
1606 if (state->out_mem_ctx) {
1607 mem_ctx = state->out_mem_ctx;
1608 } else {
1609 mem_ctx = state;
1610 }
1611
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);
1616 return;
1617 }
1618
1619 /* Copy out parameters */
1620 *state->orig.out.size = *state->tmp.out.size;
1621
1622 /* Copy result */
1623 state->orig.out.result = state->tmp.out.result;
1624
1625 /* Reset temporary structure */
1626 ZERO_STRUCT(state->tmp);
1627
1628 tevent_req_done(req);
1629 }
1630
1631 NTSTATUS rpccli_PNP_GetDeviceListSize_recv(struct tevent_req *req,
1632 TALLOC_CTX *mem_ctx,
1633 WERROR *result)
1634 {
1635 struct rpccli_PNP_GetDeviceListSize_state *state = tevent_req_data(
1636 req, struct rpccli_PNP_GetDeviceListSize_state);
1637 NTSTATUS status;
1638
1639 if (tevent_req_is_nterror(req, &status)) {
1640 tevent_req_received(req);
1641 return status;
1642 }
1643
1644 /* Steal possbile out parameters to the callers context */
1645 talloc_steal(mem_ctx, state->out_mem_ctx);
1646
1647 /* Return result */
1648 *result = state->orig.out.result;
1649
1650 tevent_req_received(req);
1651 return NT_STATUS_OK;
1652 }
1653
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] */,
1659 WERROR *werror)
1660 {
1661 struct PNP_GetDeviceListSize r;
1662 NTSTATUS status;
1663
1664 /* In parameters */
1665 r.in.devicename = devicename;
1666 r.in.flags = flags;
1667
1668 status = cli->dispatch(cli,
1669 mem_ctx,
1670 &ndr_table_ntsvcs,
1671 NDR_PNP_GETDEVICELISTSIZE,
1672 &r);
1673
1674 if (!NT_STATUS_IS_OK(status)) {
1675 return status;
1676 }
1677
1678 if (NT_STATUS_IS_ERR(status)) {
1679 return status;
1680 }
1681
1682 /* Return variables */
1683 *size = *r.out.size;
1684
1685 /* Return result */
1686 if (werror) {
1687 *werror = r.out.result;
1688 }
1689
1690 return werror_to_ntstatus(r.out.result);
1691 }
1692
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);
1698 };
1699
1700 static void rpccli_PNP_GetDepth_done(struct tevent_req *subreq);
1701
1702 struct tevent_req *rpccli_PNP_GetDepth_send(TALLOC_CTX *mem_ctx,
1703 struct tevent_context *ev,
1704 struct rpc_pipe_client *cli)
1705 {
1706 struct tevent_req *req;
1707 struct rpccli_PNP_GetDepth_state *state;
1708 struct tevent_req *subreq;
1709
1710 req = tevent_req_create(mem_ctx, &state,
1711 struct rpccli_PNP_GetDepth_state);
1712 if (req == NULL) {
1713 return NULL;
1714 }
1715 state->out_mem_ctx = NULL;
1716 state->dispatch_recv = cli->dispatch_recv;
1717
1718 /* In parameters */
1719
1720 /* Out parameters */
1721
1722 /* Result */
1723 ZERO_STRUCT(state->orig.out.result);
1724
1725 /* make a temporary copy, that we pass to the dispatch function */
1726 state->tmp = state->orig;
1727
1728 subreq = cli->dispatch_send(state, ev, cli,
1729 &ndr_table_ntsvcs,
1730 NDR_PNP_GETDEPTH,
1731 &state->tmp);
1732 if (tevent_req_nomem(subreq, req)) {
1733 return tevent_req_post(req, ev);
1734 }
1735 tevent_req_set_callback(subreq, rpccli_PNP_GetDepth_done, req);
1736 return req;
1737 }
1738
1739 static void rpccli_PNP_GetDepth_done(struct tevent_req *subreq)
1740 {
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);
1745 NTSTATUS status;
1746 TALLOC_CTX *mem_ctx;
1747
1748 if (state->out_mem_ctx) {
1749 mem_ctx = state->out_mem_ctx;
1750 } else {
1751 mem_ctx = state;
1752 }
1753
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);
1758 return;
1759 }
1760
1761 /* Copy out parameters */
1762
1763 /* Copy result */
1764 state->orig.out.result = state->tmp.out.result;
1765
1766 /* Reset temporary structure */
1767 ZERO_STRUCT(state->tmp);
1768
1769 tevent_req_done(req);
1770 }
1771
1772 NTSTATUS rpccli_PNP_GetDepth_recv(struct tevent_req *req,
1773 TALLOC_CTX *mem_ctx,
1774 WERROR *result)
1775 {
1776 struct rpccli_PNP_GetDepth_state *state = tevent_req_data(
1777 req, struct rpccli_PNP_GetDepth_state);
1778 NTSTATUS status;
1779
1780 if (tevent_req_is_nterror(req, &status)) {
1781 tevent_req_received(req);
1782 return status;
1783 }
1784
1785 /* Steal possbile out parameters to the callers context */
1786 talloc_steal(mem_ctx, state->out_mem_ctx);
1787
1788 /* Return result */
1789 *result = state->orig.out.result;
1790
1791 tevent_req_received(req);
1792 return NT_STATUS_OK;
1793 }
1794
1795 NTSTATUS rpccli_PNP_GetDepth(struct rpc_pipe_client *cli,
1796 TALLOC_CTX *mem_ctx,
1797 WERROR *werror)
1798 {
1799 struct PNP_GetDepth r;
1800 NTSTATUS status;
1801
1802 /* In parameters */
1803
1804 status = cli->dispatch(cli,
1805 mem_ctx,
1806 &ndr_table_ntsvcs,
1807 NDR_PNP_GETDEPTH,
1808 &r);
1809
1810 if (!NT_STATUS_IS_OK(status)) {
1811 return status;
1812 }
1813
1814 if (NT_STATUS_IS_ERR(status)) {
1815 return status;
1816 }
1817
1818 /* Return variables */
1819
1820 /* Return result */
1821 if (werror) {
1822 *werror = r.out.result;
1823 }
1824
1825 return werror_to_ntstatus(r.out.result);
1826 }
1827
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);
1833 };
1834
1835 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req *subreq);
1836
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] */)
1847 {
1848 struct tevent_req *req;
1849 struct rpccli_PNP_GetDeviceRegProp_state *state;
1850 struct tevent_req *subreq;
1851
1852 req = tevent_req_create(mem_ctx, &state,
1853 struct rpccli_PNP_GetDeviceRegProp_state);
1854 if (req == NULL) {
1855 return NULL;
1856 }
1857 state->out_mem_ctx = NULL;
1858 state->dispatch_recv = cli->dispatch_recv;
1859
1860 /* In parameters */
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;
1867
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;
1873
1874 /* Result */
1875 ZERO_STRUCT(state->orig.out.result);
1876
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);
1881 }
1882
1883 /* make a temporary copy, that we pass to the dispatch function */
1884 state->tmp = state->orig;
1885
1886 subreq = cli->dispatch_send(state, ev, cli,
1887 &ndr_table_ntsvcs,
1888 NDR_PNP_GETDEVICEREGPROP,
1889 &state->tmp);
1890 if (tevent_req_nomem(subreq, req)) {
1891 return tevent_req_post(req, ev);
1892 }
1893 tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceRegProp_done, req);
1894 return req;
1895 }
1896
1897 static void rpccli_PNP_GetDeviceRegProp_done(struct tevent_req *subreq)
1898 {
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);
1903 NTSTATUS status;
1904 TALLOC_CTX *mem_ctx;
1905
1906 if (state->out_mem_ctx) {
1907 mem_ctx = state->out_mem_ctx;
1908 } else {
1909 mem_ctx = state;
1910 }
1911
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);
1916 return;
1917 }
1918
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;
1924
1925 /* Copy result */
1926 state->orig.out.result = state->tmp.out.result;
1927
1928 /* Reset temporary structure */
1929 ZERO_STRUCT(state->tmp);
1930
1931 tevent_req_done(req);
1932 }
1933
1934 NTSTATUS rpccli_PNP_GetDeviceRegProp_recv(struct tevent_req *req,
1935 TALLOC_CTX *mem_ctx,
1936 WERROR *result)
1937 {
1938 struct rpccli_PNP_GetDeviceRegProp_state *state = tevent_req_data(
1939 req, struct rpccli_PNP_GetDeviceRegProp_state);
1940 NTSTATUS status;
1941
1942 if (tevent_req_is_nterror(req, &status)) {
1943 tevent_req_received(req);
1944 return status;
1945 }
1946
1947 /* Steal possbile out parameters to the callers context */
1948 talloc_steal(mem_ctx, state->out_mem_ctx);
1949
1950 /* Return result */
1951 *result = state->orig.out.result;
1952
1953 tevent_req_received(req);
1954 return NT_STATUS_OK;
1955 }
1956
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] */,
1966 WERROR *werror)
1967 {
1968 struct PNP_GetDeviceRegProp r;
1969 NTSTATUS status;
1970
1971 /* In parameters */
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;
1977 r.in.flags = flags;
1978
1979 status = cli->dispatch(cli,
1980 mem_ctx,
1981 &ndr_table_ntsvcs,
1982 NDR_PNP_GETDEVICEREGPROP,
1983 &r);
1984
1985 if (!NT_STATUS_IS_OK(status)) {
1986 return status;
1987 }
1988
1989 if (NT_STATUS_IS_ERR(status)) {
1990 return status;
1991 }
1992
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;
1998
1999 /* Return result */
2000 if (werror) {
2001 *werror = r.out.result;
2002 }
2003
2004 return werror_to_ntstatus(r.out.result);
2005 }
2006
2007 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);
2012 };
2013
2014 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req *subreq);
2015
2016 struct tevent_req *rpccli_PNP_SetDeviceRegProp_send(TALLOC_CTX *mem_ctx,
2017 struct tevent_context *ev,
2018 struct rpc_pipe_client *cli)
2019 {
2020 struct tevent_req *req;
2021 struct rpccli_PNP_SetDeviceRegProp_state *state;
2022 struct tevent_req *subreq;
2023
2024 req = tevent_req_create(mem_ctx, &state,
2025 struct rpccli_PNP_SetDeviceRegProp_state);
2026 if (req == NULL) {
2027 return NULL;
2028 }
2029 state->out_mem_ctx = NULL;
2030 state->dispatch_recv = cli->dispatch_recv;
2031
2032 /* In parameters */
2033
2034 /* Out parameters */
2035
2036 /* Result */
2037 ZERO_STRUCT(state->orig.out.result);
2038
2039 /* make a temporary copy, that we pass to the dispatch function */
2040 state->tmp = state->orig;
2041
2042 subreq = cli->dispatch_send(state, ev, cli,
2043 &ndr_table_ntsvcs,
2044 NDR_PNP_SETDEVICEREGPROP,
2045 &state->tmp);
2046 if (tevent_req_nomem(subreq, req)) {
2047 return tevent_req_post(req, ev);
2048 }
2049 tevent_req_set_callback(subreq, rpccli_PNP_SetDeviceRegProp_done, req);
2050 return req;
2051 }
2052
2053 static void rpccli_PNP_SetDeviceRegProp_done(struct tevent_req *subreq)
2054 {
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);
2059 NTSTATUS status;
2060 TALLOC_CTX *mem_ctx;
2061
2062 if (state->out_mem_ctx) {
2063 mem_ctx = state->out_mem_ctx;
2064 } else {
2065 mem_ctx = state;
2066 }
2067
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);
2072 return;
2073 }
2074
2075 /* Copy out parameters */
2076
2077 /* Copy result */
2078 state->orig.out.result = state->tmp.out.result;
2079
2080 /* Reset temporary structure */
2081 ZERO_STRUCT(state->tmp);
2082
2083 tevent_req_done(req);
2084 }
2085
2086 NTSTATUS rpccli_PNP_SetDeviceRegProp_recv(struct tevent_req *req,
2087 TALLOC_CTX *mem_ctx,
2088 WERROR *result)
2089 {
2090 struct rpccli_PNP_SetDeviceRegProp_state *state = tevent_req_data(
2091 req, struct rpccli_PNP_SetDeviceRegProp_state);
2092 NTSTATUS status;
2093
2094 if (tevent_req_is_nterror(req, &status)) {
2095 tevent_req_received(req);
2096 return status;
2097 }
2098
2099 /* Steal possbile out parameters to the callers context */
2100 talloc_steal(mem_ctx, state->out_mem_ctx);
2101
2102 /* Return result */
2103 *result = state->orig.out.result;
2104
2105 tevent_req_received(req);
2106 return NT_STATUS_OK;
2107 }
2108
2109 NTSTATUS rpccli_PNP_SetDeviceRegProp(struct rpc_pipe_client *cli,
2110 TALLOC_CTX *mem_ctx,
2111 WERROR *werror)
2112 {
2113 struct PNP_SetDeviceRegProp r;
2114 NTSTATUS status;
2115
2116 /* In parameters */
2117
2118 status = cli->dispatch(cli,
2119 mem_ctx,
2120 &ndr_table_ntsvcs,
2121 NDR_PNP_SETDEVICEREGPROP,
2122 &r);
2123
2124 if (!NT_STATUS_IS_OK(status)) {
2125 return status;
2126 }
2127
2128 if (NT_STATUS_IS_ERR(status)) {
2129 return status;
2130 }
2131
2132 /* Return variables */
2133
2134 /* Return result */
2135 if (werror) {
2136 *werror = r.out.result;
2137 }
2138
2139 return werror_to_ntstatus(r.out.result);
2140 }
2141
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);
2147 };
2148
2149 static void rpccli_PNP_GetClassInstance_done(struct tevent_req *subreq);
2150
2151 struct tevent_req *rpccli_PNP_GetClassInstance_send(TALLOC_CTX *mem_ctx,
2152 struct tevent_context *ev,
2153 struct rpc_pipe_client *cli)
2154 {
2155 struct tevent_req *req;
2156 struct rpccli_PNP_GetClassInstance_state *state;
2157 struct tevent_req *subreq;
2158
2159 req = tevent_req_create(mem_ctx, &state,
2160 struct rpccli_PNP_GetClassInstance_state);
2161 if (req == NULL) {
2162 return NULL;
2163 }
2164 state->out_mem_ctx = NULL;
2165 state->dispatch_recv = cli->dispatch_recv;
2166
2167 /* In parameters */
2168
2169 /* Out parameters */
2170
2171 /* Result */
2172 ZERO_STRUCT(state->orig.out.result);
2173
2174 /* make a temporary copy, that we pass to the dispatch function */
2175 state->tmp = state->orig;
2176
2177 subreq = cli->dispatch_send(state, ev, cli,
2178 &ndr_table_ntsvcs,
2179 NDR_PNP_GETCLASSINSTANCE,
2180 &state->tmp);
2181 if (tevent_req_nomem(subreq, req)) {
2182 return tevent_req_post(req, ev);
2183 }
2184 tevent_req_set_callback(subreq, rpccli_PNP_GetClassInstance_done, req);
2185 return req;
2186 }
2187
2188 static void rpccli_PNP_GetClassInstance_done(struct tevent_req *subreq)
2189 {
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);
2194 NTSTATUS status;
2195 TALLOC_CTX *mem_ctx;
2196
2197 if (state->out_mem_ctx) {
2198 mem_ctx = state->out_mem_ctx;
2199 } else {
2200 mem_ctx = state;
2201 }
2202
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);
2207 return;
2208 }
2209
2210 /* Copy out parameters */
2211
2212 /* Copy result */
2213 state->orig.out.result = state->tmp.out.result;
2214
2215 /* Reset temporary structure */
2216 ZERO_STRUCT(state->tmp);
2217
2218 tevent_req_done(req);
2219 }
2220
2221 NTSTATUS rpccli_PNP_GetClassInstance_recv(struct tevent_req *req,
2222 TALLOC_CTX *mem_ctx,
2223 WERROR *result)
2224 {
2225 struct rpccli_PNP_GetClassInstance_state *state = tevent_req_data(
2226 req, struct rpccli_PNP_GetClassInstance_state);
2227 NTSTATUS status;
2228
2229 if (tevent_req_is_nterror(req, &status)) {
2230 tevent_req_received(req);
2231 return status;
2232 }
2233
2234 /* Steal possbile out parameters to the callers context */
2235 talloc_steal(mem_ctx, state->out_mem_ctx);
2236
2237 /* Return result */
2238 *result = state->orig.out.result;
2239
2240 tevent_req_received(req);
2241 return NT_STATUS_OK;
2242 }
2243
2244 NTSTATUS rpccli_PNP_GetClassInstance(struct rpc_pipe_client *cli,
2245 TALLOC_CTX *mem_ctx,
2246 WERROR *werror)
2247 {
2248 struct PNP_GetClassInstance r;
2249 NTSTATUS status;
2250
2251 /* In parameters */
2252
2253 status = cli->dispatch(cli,
2254 mem_ctx,
2255 &ndr_table_ntsvcs,
2256 NDR_PNP_GETCLASSINSTANCE,
2257 &r);
2258
2259 if (!NT_STATUS_IS_OK(status)) {
2260 return status;
2261 }
2262
2263 if (NT_STATUS_IS_ERR(status)) {
2264 return status;
2265 }
2266
2267 /* Return variables */
2268
2269 /* Return result */
2270 if (werror) {
2271 *werror = r.out.result;
2272 }
2273
2274 return werror_to_ntstatus(r.out.result);
2275 }
2276
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);
2282 };
2283
2284 static void rpccli_PNP_CreateKey_done(struct tevent_req *subreq);
2285
2286 struct tevent_req *rpccli_PNP_CreateKey_send(TALLOC_CTX *mem_ctx,
2287 struct tevent_context *ev,
2288 struct rpc_pipe_client *cli)
2289 {
2290 struct tevent_req *req;
2291 struct rpccli_PNP_CreateKey_state *state;
2292 struct tevent_req *subreq;
2293
2294 req = tevent_req_create(mem_ctx, &state,
2295 struct rpccli_PNP_CreateKey_state);
2296 if (req == NULL) {
2297 return NULL;
2298 }
2299 state->out_mem_ctx = NULL;
2300 state->dispatch_recv = cli->dispatch_recv;
2301
2302 /* In parameters */
2303
2304 /* Out parameters */
2305
2306 /* Result */
2307 ZERO_STRUCT(state->orig.out.result);
2308
2309 /* make a temporary copy, that we pass to the dispatch function */
2310 state->tmp = state->orig;
2311
2312 subreq = cli->dispatch_send(state, ev, cli,
2313 &ndr_table_ntsvcs,
2314 NDR_PNP_CREATEKEY,
2315 &state->tmp);
2316 if (tevent_req_nomem(subreq, req)) {
2317 return tevent_req_post(req, ev);
2318 }
2319 tevent_req_set_callback(subreq, rpccli_PNP_CreateKey_done, req);
2320 return req;
2321 }
2322
2323 static void rpccli_PNP_CreateKey_done(struct tevent_req *subreq)
2324 {
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);
2329 NTSTATUS status;
2330 TALLOC_CTX *mem_ctx;
2331
2332 if (state->out_mem_ctx) {
2333 mem_ctx = state->out_mem_ctx;
2334 } else {
2335 mem_ctx = state;
2336 }
2337
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);
2342 return;
2343 }
2344
2345 /* Copy out parameters */
2346
2347 /* Copy result */
2348 state->orig.out.result = state->tmp.out.result;
2349
2350 /* Reset temporary structure */
2351 ZERO_STRUCT(state->tmp);
2352
2353 tevent_req_done(req);
2354 }
2355
2356 NTSTATUS rpccli_PNP_CreateKey_recv(struct tevent_req *req,
2357 TALLOC_CTX *mem_ctx,
2358 WERROR *result)
2359 {
2360 struct rpccli_PNP_CreateKey_state *state = tevent_req_data(
2361 req, struct rpccli_PNP_CreateKey_state);
2362 NTSTATUS status;
2363
2364 if (tevent_req_is_nterror(req, &status)) {
2365 tevent_req_received(req);
2366 return status;
2367 }
2368
2369 /* Steal possbile out parameters to the callers context */
2370 talloc_steal(mem_ctx, state->out_mem_ctx);
2371
2372 /* Return result */
2373 *result = state->orig.out.result;
2374
2375 tevent_req_received(req);
2376 return NT_STATUS_OK;
2377 }
2378
2379 NTSTATUS rpccli_PNP_CreateKey(struct rpc_pipe_client *cli,
2380 TALLOC_CTX *mem_ctx,
2381 WERROR *werror)
2382 {
2383 struct PNP_CreateKey r;
2384 NTSTATUS status;
2385
2386 /* In parameters */
2387
2388 status = cli->dispatch(cli,
2389 mem_ctx,
2390 &ndr_table_ntsvcs,
2391 NDR_PNP_CREATEKEY,
2392 &r);
2393
2394 if (!NT_STATUS_IS_OK(status)) {
2395 return status;
2396 }
2397
2398 if (NT_STATUS_IS_ERR(status)) {
2399 return status;
2400 }
2401
2402 /* Return variables */
2403
2404 /* Return result */
2405 if (werror) {
2406 *werror = r.out.result;
2407 }
2408
2409 return werror_to_ntstatus(r.out.result);
2410 }
2411
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);
2417 };
2418
2419 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req *subreq);
2420
2421 struct tevent_req *rpccli_PNP_DeleteRegistryKey_send(TALLOC_CTX *mem_ctx,
2422 struct tevent_context *ev,
2423 struct rpc_pipe_client *cli)
2424 {
2425 struct tevent_req *req;
2426 struct rpccli_PNP_DeleteRegistryKey_state *state;
2427 struct tevent_req *subreq;
2428
2429 req = tevent_req_create(mem_ctx, &state,
2430 struct rpccli_PNP_DeleteRegistryKey_state);
2431 if (req == NULL) {
2432 return NULL;
2433 }
2434 state->out_mem_ctx = NULL;
2435 state->dispatch_recv = cli->dispatch_recv;
2436
2437 /* In parameters */
2438
2439 /* Out parameters */
2440
2441 /* Result */
2442 ZERO_STRUCT(state->orig.out.result);
2443
2444 /* make a temporary copy, that we pass to the dispatch function */
2445 state->tmp = state->orig;
2446
2447 subreq = cli->dispatch_send(state, ev, cli,
2448 &ndr_table_ntsvcs,
2449 NDR_PNP_DELETEREGISTRYKEY,
2450 &state->tmp);
2451 if (tevent_req_nomem(subreq, req)) {
2452 return tevent_req_post(req, ev);
2453 }
2454 tevent_req_set_callback(subreq, rpccli_PNP_DeleteRegistryKey_done, req);
2455 return req;
2456 }
2457
2458 static void rpccli_PNP_DeleteRegistryKey_done(struct tevent_req *subreq)
2459 {
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);
2464 NTSTATUS status;
2465 TALLOC_CTX *mem_ctx;
2466
2467 if (state->out_mem_ctx) {
2468 mem_ctx = state->out_mem_ctx;
2469 } else {
2470 mem_ctx = state;
2471 }
2472
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);
2477 return;
2478 }
2479
2480 /* Copy out parameters */
2481
2482 /* Copy result */
2483 state->orig.out.result = state->tmp.out.result;
2484
2485 /* Reset temporary structure */
2486 ZERO_STRUCT(state->tmp);
2487
2488 tevent_req_done(req);
2489 }
2490
2491 NTSTATUS rpccli_PNP_DeleteRegistryKey_recv(struct tevent_req *req,
2492 TALLOC_CTX *mem_ctx,
2493 WERROR *result)
2494 {
2495 struct rpccli_PNP_DeleteRegistryKey_state *state = tevent_req_data(
2496 req, struct rpccli_PNP_DeleteRegistryKey_state);
2497 NTSTATUS status;
2498
2499 if (tevent_req_is_nterror(req, &status)) {
2500 tevent_req_received(req);
2501 return status;
2502 }
2503
2504 /* Steal possbile out parameters to the callers context */
2505 talloc_steal(mem_ctx, state->out_mem_ctx);
2506
2507 /* Return result */
2508 *result = state->orig.out.result;
2509
2510 tevent_req_received(req);
2511 return NT_STATUS_OK;
2512 }
2513
2514 NTSTATUS rpccli_PNP_DeleteRegistryKey(struct rpc_pipe_client *cli,
2515 TALLOC_CTX *mem_ctx,
2516 WERROR *werror)
2517 {
2518 struct PNP_DeleteRegistryKey r;
2519 NTSTATUS status;
2520
2521 /* In parameters */
2522
2523 status = cli->dispatch(cli,
2524 mem_ctx,
2525 &ndr_table_ntsvcs,
2526 NDR_PNP_DELETEREGISTRYKEY,
2527 &r);
2528
2529 if (!NT_STATUS_IS_OK(status)) {
2530 return status;
2531 }
2532
2533 if (NT_STATUS_IS_ERR(status)) {
2534 return status;
2535 }
2536
2537 /* Return variables */
2538
2539 /* Return result */
2540 if (werror) {
2541 *werror = r.out.result;
2542 }
2543
2544 return werror_to_ntstatus(r.out.result);
2545 }
2546
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);
2552 };
2553
2554 static void rpccli_PNP_GetClassCount_done(struct tevent_req *subreq);
2555
2556 struct tevent_req *rpccli_PNP_GetClassCount_send(TALLOC_CTX *mem_ctx,
2557 struct tevent_context *ev,
2558 struct rpc_pipe_client *cli)
2559 {
2560 struct tevent_req *req;
2561 struct rpccli_PNP_GetClassCount_state *state;
2562 struct tevent_req *subreq;
2563
2564 req = tevent_req_create(mem_ctx, &state,
2565 struct rpccli_PNP_GetClassCount_state);
2566 if (req == NULL) {
2567 return NULL;
2568 }
2569 state->out_mem_ctx = NULL;
2570 state->dispatch_recv = cli->dispatch_recv;
2571
2572 /* In parameters */
2573
2574 /* Out parameters */
2575
2576 /* Result */
2577 ZERO_STRUCT(state->orig.out.result);
2578
2579 /* make a temporary copy, that we pass to the dispatch function */
2580 state->tmp = state->orig;
2581
2582 subreq = cli->dispatch_send(state, ev, cli,
2583 &ndr_table_ntsvcs,
2584 NDR_PNP_GETCLASSCOUNT,
2585 &state->tmp);
2586 if (tevent_req_nomem(subreq, req)) {
2587 return tevent_req_post(req, ev);
2588 }
2589 tevent_req_set_callback(subreq, rpccli_PNP_GetClassCount_done, req);
2590 return req;
2591 }
2592
2593 static void rpccli_PNP_GetClassCount_done(struct tevent_req *subreq)
2594 {
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);
2599 NTSTATUS status;
2600 TALLOC_CTX *mem_ctx;
2601
2602 if (state->out_mem_ctx) {
2603 mem_ctx = state->out_mem_ctx;
2604 } else {
2605 mem_ctx = state;
2606 }
2607
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);
2612 return;
2613 }
2614
2615 /* Copy out parameters */
2616
2617 /* Copy result */
2618 state->orig.out.result = state->tmp.out.result;
2619
2620 /* Reset temporary structure */
2621 ZERO_STRUCT(state->tmp);
2622
2623 tevent_req_done(req);
2624 }
2625
2626 NTSTATUS rpccli_PNP_GetClassCount_recv(struct tevent_req *req,
2627 TALLOC_CTX *mem_ctx,
2628 WERROR *result)
2629 {
2630 struct rpccli_PNP_GetClassCount_state *state = tevent_req_data(
2631 req, struct rpccli_PNP_GetClassCount_state);
2632 NTSTATUS status;
2633
2634 if (tevent_req_is_nterror(req, &status)) {
2635 tevent_req_received(req);
2636 return status;
2637 }
2638
2639 /* Steal possbile out parameters to the callers context */
2640 talloc_steal(mem_ctx, state->out_mem_ctx);
2641
2642 /* Return result */
2643 *result = state->orig.out.result;
2644
2645 tevent_req_received(req);
2646 return NT_STATUS_OK;
2647 }
2648
2649 NTSTATUS rpccli_PNP_GetClassCount(struct rpc_pipe_client *cli,
2650 TALLOC_CTX *mem_ctx,
2651 WERROR *werror)
2652 {
2653 struct PNP_GetClassCount r;
2654 NTSTATUS status;
2655
2656 /* In parameters */
2657
2658 status = cli->dispatch(cli,
2659 mem_ctx,
2660 &ndr_table_ntsvcs,
2661 NDR_PNP_GETCLASSCOUNT,
2662 &r);
2663
2664 if (!NT_STATUS_IS_OK(status)) {
2665 return status;
2666 }
2667
2668 if (NT_STATUS_IS_ERR(status)) {
2669 return status;
2670 }
2671
2672 /* Return variables */
2673
2674 /* Return result */
2675 if (werror) {
2676 *werror = r.out.result;
2677 }
2678
2679 return werror_to_ntstatus(r.out.result);
2680 }
2681
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);
2687 };
2688
2689 static void rpccli_PNP_GetClassName_done(struct tevent_req *subreq);
2690
2691 struct tevent_req *rpccli_PNP_GetClassName_send(TALLOC_CTX *mem_ctx,
2692 struct tevent_context *ev,
2693 struct rpc_pipe_client *cli)
2694 {
2695 struct tevent_req *req;
2696 struct rpccli_PNP_GetClassName_state *state;
2697 struct tevent_req *subreq;
2698
2699 req = tevent_req_create(mem_ctx, &state,
2700 struct rpccli_PNP_GetClassName_state);
2701 if (req == NULL) {
2702 return NULL;
2703 }
2704 state->out_mem_ctx = NULL;
2705 state->dispatch_recv = cli->dispatch_recv;
2706
2707 /* In parameters */
2708
2709 /* Out parameters */
2710
2711 /* Result */
2712 ZERO_STRUCT(state->orig.out.result);
2713
2714 /* make a temporary copy, that we pass to the dispatch function */
2715 state->tmp = state->orig;
2716
2717 subreq = cli->dispatch_send(state, ev, cli,
2718 &ndr_table_ntsvcs,
2719 NDR_PNP_GETCLASSNAME,
2720 &state->tmp);
2721 if (tevent_req_nomem(subreq, req)) {
2722 return tevent_req_post(req, ev);
2723 }
2724 tevent_req_set_callback(subreq, rpccli_PNP_GetClassName_done, req);
2725 return req;
2726 }
2727
2728 static void rpccli_PNP_GetClassName_done(struct tevent_req *subreq)
2729 {
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);
2734 NTSTATUS status;
2735 TALLOC_CTX *mem_ctx;
2736
2737 if (state->out_mem_ctx) {
2738 mem_ctx = state->out_mem_ctx;
2739 } else {
2740 mem_ctx = state;
2741 }
2742
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);
2747 return;
2748 }
2749
2750 /* Copy out parameters */
2751
2752 /* Copy result */
2753 state->orig.out.result = state->tmp.out.result;
2754
2755 /* Reset temporary structure */
2756 ZERO_STRUCT(state->tmp);
2757
2758 tevent_req_done(req);
2759 }
2760
2761 NTSTATUS rpccli_PNP_GetClassName_recv(struct tevent_req *req,
2762 TALLOC_CTX *mem_ctx,
2763 WERROR *result)
2764 {
2765 struct rpccli_PNP_GetClassName_state *state = tevent_req_data(
2766 req, struct rpccli_PNP_GetClassName_state);
2767 NTSTATUS status;
2768
2769 if (tevent_req_is_nterror(req, &status)) {
2770 tevent_req_received(req);
2771 return status;
2772 }
2773
2774 /* Steal possbile out parameters to the callers context */
2775 talloc_steal(mem_ctx, state->out_mem_ctx);
2776
2777 /* Return result */
2778 *result = state->orig.out.result;
2779
2780 tevent_req_received(req);
2781 return NT_STATUS_OK;
2782 }
2783
2784 NTSTATUS rpccli_PNP_GetClassName(struct rpc_pipe_client *cli,
2785 TALLOC_CTX *mem_ctx,
2786 WERROR *werror)
2787 {
2788 struct PNP_GetClassName r;
2789 NTSTATUS status;
2790
2791 /* In parameters */
2792
2793 status = cli->dispatch(cli,
2794 mem_ctx,
2795 &ndr_table_ntsvcs,
2796 NDR_PNP_GETCLASSNAME,
2797 &r);
2798
2799 if (!NT_STATUS_IS_OK(status)) {
2800 return status;
2801 }
2802
2803 if (NT_STATUS_IS_ERR(status)) {
2804 return status;
2805 }
2806
2807 /* Return variables */
2808
2809 /* Return result */
2810 if (werror) {
2811 *werror = r.out.result;
2812 }
2813
2814 return werror_to_ntstatus(r.out.result);
2815 }
2816
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);
2822 };
2823
2824 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req *subreq);
2825
2826 struct tevent_req *rpccli_PNP_DeleteClassKey_send(TALLOC_CTX *mem_ctx,
2827 struct tevent_context *ev,
2828 struct rpc_pipe_client *cli)
2829 {
2830 struct tevent_req *req;
2831 struct rpccli_PNP_DeleteClassKey_state *state;
2832 struct tevent_req *subreq;
2833
2834 req = tevent_req_create(mem_ctx, &state,
2835 struct rpccli_PNP_DeleteClassKey_state);
2836 if (req == NULL) {
2837 return NULL;
2838 }
2839 state->out_mem_ctx = NULL;
2840 state->dispatch_recv = cli->dispatch_recv;
2841
2842 /* In parameters */
2843
2844 /* Out parameters */
2845
2846 /* Result */
2847 ZERO_STRUCT(state->orig.out.result);
2848
2849 /* make a temporary copy, that we pass to the dispatch function */
2850 state->tmp = state->orig;
2851
2852 subreq = cli->dispatch_send(state, ev, cli,
2853 &ndr_table_ntsvcs,
2854 NDR_PNP_DELETECLASSKEY,
2855 &state->tmp);
2856 if (tevent_req_nomem(subreq, req)) {
2857 return tevent_req_post(req, ev);
2858 }
2859 tevent_req_set_callback(subreq, rpccli_PNP_DeleteClassKey_done, req);
2860 return req;
2861 }
2862
2863 static void rpccli_PNP_DeleteClassKey_done(struct tevent_req *subreq)
2864 {
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);
2869 NTSTATUS status;
2870 TALLOC_CTX *mem_ctx;
2871
2872 if (state->out_mem_ctx) {
2873 mem_ctx = state->out_mem_ctx;
2874 } else {
2875 mem_ctx = state;
2876 }
2877
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);
2882 return;
2883 }
2884
2885 /* Copy out parameters */
2886
2887 /* Copy result */
2888 state->orig.out.result = state->tmp.out.result;
2889
2890 /* Reset temporary structure */
2891 ZERO_STRUCT(state->tmp);
2892
2893 tevent_req_done(req);
2894 }
2895
2896 NTSTATUS rpccli_PNP_DeleteClassKey_recv(struct tevent_req *req,
2897 TALLOC_CTX *mem_ctx,
2898 WERROR *result)
2899 {
2900 struct rpccli_PNP_DeleteClassKey_state *state = tevent_req_data(
2901 req, struct rpccli_PNP_DeleteClassKey_state);
2902 NTSTATUS status;
2903
2904 if (tevent_req_is_nterror(req, &status)) {
2905 tevent_req_received(req);
2906 return status;
2907 }
2908
2909 /* Steal possbile out parameters to the callers context */
2910 talloc_steal(mem_ctx, state->out_mem_ctx);
2911
2912 /* Return result */
2913 *result = state->orig.out.result;
2914
2915 tevent_req_received(req);
2916 return NT_STATUS_OK;
2917 }
2918
2919 NTSTATUS rpccli_PNP_DeleteClassKey(struct rpc_pipe_client *cli,
2920 TALLOC_CTX *mem_ctx,
2921 WERROR *werror)
2922 {
2923 struct PNP_DeleteClassKey r;
2924 NTSTATUS status;
2925
2926 /* In parameters */
2927
2928 status = cli->dispatch(cli,
2929 mem_ctx,
2930 &ndr_table_ntsvcs,
2931 NDR_PNP_DELETECLASSKEY,
2932 &r);
2933
2934 if (!NT_STATUS_IS_OK(status)) {
2935 return status;
2936 }
2937
2938 if (NT_STATUS_IS_ERR(status)) {
2939 return status;
2940 }
2941
2942 /* Return variables */
2943
2944 /* Return result */
2945 if (werror) {
2946 *werror = r.out.result;
2947 }
2948
2949 return werror_to_ntstatus(r.out.result);
2950 }
2951
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);
2957 };
2958
2959 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req *subreq);
2960
2961 struct tevent_req *rpccli_PNP_GetInterfaceDeviceAlias_send(TALLOC_CTX *mem_ctx,
2962 struct tevent_context *ev,
2963 struct rpc_pipe_client *cli)
2964 {
2965 struct tevent_req *req;
2966 struct rpccli_PNP_GetInterfaceDeviceAlias_state *state;
2967 struct tevent_req *subreq;
2968
2969 req = tevent_req_create(mem_ctx, &state,
2970 struct rpccli_PNP_GetInterfaceDeviceAlias_state);
2971 if (req == NULL) {
2972 return NULL;
2973 }
2974 state->out_mem_ctx = NULL;
2975 state->dispatch_recv = cli->dispatch_recv;
2976
2977 /* In parameters */
2978
2979 /* Out parameters */
2980
2981 /* Result */
2982 ZERO_STRUCT(state->orig.out.result);
2983
2984 /* make a temporary copy, that we pass to the dispatch function */
2985 state->tmp = state->orig;
2986
2987 subreq = cli->dispatch_send(state, ev, cli,
2988 &ndr_table_ntsvcs,
2989 NDR_PNP_GETINTERFACEDEVICEALIAS,
2990 &state->tmp);
2991 if (tevent_req_nomem(subreq, req)) {
2992 return tevent_req_post(req, ev);
2993 }
2994 tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceAlias_done, req);
2995 return req;
2996 }
2997
2998 static void rpccli_PNP_GetInterfaceDeviceAlias_done(struct tevent_req *subreq)
2999 {
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);
3004 NTSTATUS status;
3005 TALLOC_CTX *mem_ctx;
3006
3007 if (state->out_mem_ctx) {
3008 mem_ctx = state->out_mem_ctx;
3009 } else {
3010 mem_ctx = state;
3011 }
3012
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);
3017 return;
3018 }
3019
3020 /* Copy out parameters */
3021
3022 /* Copy result */
3023 state->orig.out.result = state->tmp.out.result;
3024
3025 /* Reset temporary structure */
3026 ZERO_STRUCT(state->tmp);
3027
3028 tevent_req_done(req);
3029 }
3030
3031 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias_recv(struct tevent_req *req,
3032 TALLOC_CTX *mem_ctx,
3033 WERROR *result)
3034 {
3035 struct rpccli_PNP_GetInterfaceDeviceAlias_state *state = tevent_req_data(
3036 req, struct rpccli_PNP_GetInterfaceDeviceAlias_state);
3037 NTSTATUS status;
3038
3039 if (tevent_req_is_nterror(req, &status)) {
3040 tevent_req_received(req);
3041 return status;
3042 }
3043
3044 /* Steal possbile out parameters to the callers context */
3045 talloc_steal(mem_ctx, state->out_mem_ctx);
3046
3047 /* Return result */
3048 *result = state->orig.out.result;
3049
3050 tevent_req_received(req);
3051 return NT_STATUS_OK;
3052 }
3053
3054 NTSTATUS rpccli_PNP_GetInterfaceDeviceAlias(struct rpc_pipe_client *cli,
3055 TALLOC_CTX *mem_ctx,
3056 WERROR *werror)
3057 {
3058 struct PNP_GetInterfaceDeviceAlias r;
3059 NTSTATUS status;
3060
3061 /* In parameters */
3062
3063 status = cli->dispatch(cli,
3064 mem_ctx,
3065 &ndr_table_ntsvcs,
3066 NDR_PNP_GETINTERFACEDEVICEALIAS,
3067 &r);
3068
3069 if (!NT_STATUS_IS_OK(status)) {
3070 return status;
3071 }
3072
3073 if (NT_STATUS_IS_ERR(status)) {
3074 return status;
3075 }
3076
3077 /* Return variables */
3078
3079 /* Return result */
3080 if (werror) {
3081 *werror = r.out.result;
3082 }
3083
3084 return werror_to_ntstatus(r.out.result);
3085 }
3086
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);
3092 };
3093
3094 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req *subreq);
3095
3096 struct tevent_req *rpccli_PNP_GetInterfaceDeviceList_send(TALLOC_CTX *mem_ctx,
3097 struct tevent_context *ev,
3098 struct rpc_pipe_client *cli)
3099 {
3100 struct tevent_req *req;
3101 struct rpccli_PNP_GetInterfaceDeviceList_state *state;
3102 struct tevent_req *subreq;
3103
3104 req = tevent_req_create(mem_ctx, &state,
3105 struct rpccli_PNP_GetInterfaceDeviceList_state);
3106 if (req == NULL) {
3107 return NULL;
3108 }
3109 state->out_mem_ctx = NULL;
3110 state->dispatch_recv = cli->dispatch_recv;
3111
3112 /* In parameters */
3113
3114 /* Out parameters */
3115
3116 /* Result */
3117 ZERO_STRUCT(state->orig.out.result);
3118
3119 /* make a temporary copy, that we pass to the dispatch function */
3120 state->tmp = state->orig;
3121
3122 subreq = cli->dispatch_send(state, ev, cli,
3123 &ndr_table_ntsvcs,
3124 NDR_PNP_GETINTERFACEDEVICELIST,
3125 &state->tmp);
3126 if (tevent_req_nomem(subreq, req)) {
3127 return tevent_req_post(req, ev);
3128 }
3129 tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceList_done, req);
3130 return req;
3131 }
3132
3133 static void rpccli_PNP_GetInterfaceDeviceList_done(struct tevent_req *subreq)
3134 {
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);
3139 NTSTATUS status;
3140 TALLOC_CTX *mem_ctx;
3141
3142 if (state->out_mem_ctx) {
3143 mem_ctx = state->out_mem_ctx;
3144 } else {
3145 mem_ctx = state;
3146 }
3147
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);
3152 return;
3153 }
3154
3155 /* Copy out parameters */
3156
3157 /* Copy result */
3158 state->orig.out.result = state->tmp.out.result;
3159
3160 /* Reset temporary structure */
3161 ZERO_STRUCT(state->tmp);
3162
3163 tevent_req_done(req);
3164 }
3165
3166 NTSTATUS rpccli_PNP_GetInterfaceDeviceList_recv(struct tevent_req *req,
3167 TALLOC_CTX *mem_ctx,
3168 WERROR *result)
3169 {
3170 struct rpccli_PNP_GetInterfaceDeviceList_state *state = tevent_req_data(
3171 req, struct rpccli_PNP_GetInterfaceDeviceList_state);
3172 NTSTATUS status;
3173
3174 if (tevent_req_is_nterror(req, &status)) {
3175 tevent_req_received(req);
3176 return status;
3177 }
3178
3179 /* Steal possbile out parameters to the callers context */
3180 talloc_steal(mem_ctx, state->out_mem_ctx);
3181
3182 /* Return result */
3183 *result = state->orig.out.result;
3184
3185 tevent_req_received(req);
3186 return NT_STATUS_OK;
3187 }
3188
3189 NTSTATUS rpccli_PNP_GetInterfaceDeviceList(struct rpc_pipe_client *cli,
3190 TALLOC_CTX *mem_ctx,
3191 WERROR *werror)
3192 {
3193 struct PNP_GetInterfaceDeviceList r;
3194 NTSTATUS status;
3195
3196 /* In parameters */
3197
3198 status = cli->dispatch(cli,
3199 mem_ctx,
3200 &ndr_table_ntsvcs,
3201 NDR_PNP_GETINTERFACEDEVICELIST,
3202 &r);
3203
3204 if (!NT_STATUS_IS_OK(status)) {
3205 return status;
3206 }
3207
3208 if (NT_STATUS_IS_ERR(status)) {
3209 return status;
3210 }
3211
3212 /* Return variables */
3213
3214 /* Return result */
3215 if (werror) {
3216 *werror = r.out.result;
3217 }
3218
3219 return werror_to_ntstatus(r.out.result);
3220 }
3221
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);
3227 };
3228
3229 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req *subreq);
3230
3231 struct tevent_req *rpccli_PNP_GetInterfaceDeviceListSize_send(TALLOC_CTX *mem_ctx,
3232 struct tevent_context *ev,
3233 struct rpc_pipe_client *cli)
3234 {
3235 struct tevent_req *req;
3236 struct rpccli_PNP_GetInterfaceDeviceListSize_state *state;
3237 struct tevent_req *subreq;
3238
3239 req = tevent_req_create(mem_ctx, &state,
3240 struct rpccli_PNP_GetInterfaceDeviceListSize_state);
3241 if (req == NULL) {
3242 return NULL;
3243 }
3244 state->out_mem_ctx = NULL;
3245 state->dispatch_recv = cli->dispatch_recv;
3246
3247 /* In parameters */
3248
3249 /* Out parameters */
3250
3251 /* Result */
3252 ZERO_STRUCT(state->orig.out.result);
3253
3254 /* make a temporary copy, that we pass to the dispatch function */
3255 state->tmp = state->orig;
3256
3257 subreq = cli->dispatch_send(state, ev, cli,
3258 &ndr_table_ntsvcs,
3259 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
3260 &state->tmp);
3261 if (tevent_req_nomem(subreq, req)) {
3262 return tevent_req_post(req, ev);
3263 }
3264 tevent_req_set_callback(subreq, rpccli_PNP_GetInterfaceDeviceListSize_done, req);
3265 return req;
3266 }
3267
3268 static void rpccli_PNP_GetInterfaceDeviceListSize_done(struct tevent_req *subreq)
3269 {
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);
3274 NTSTATUS status;
3275 TALLOC_CTX *mem_ctx;
3276
3277 if (state->out_mem_ctx) {
3278 mem_ctx = state->out_mem_ctx;
3279 } else {
3280 mem_ctx = state;
3281 }
3282
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);
3287 return;
3288 }
3289
3290 /* Copy out parameters */
3291
3292 /* Copy result */
3293 state->orig.out.result = state->tmp.out.result;
3294
3295 /* Reset temporary structure */
3296 ZERO_STRUCT(state->tmp);
3297
3298 tevent_req_done(req);
3299 }
3300
3301 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize_recv(struct tevent_req *req,
3302 TALLOC_CTX *mem_ctx,
3303 WERROR *result)
3304 {
3305 struct rpccli_PNP_GetInterfaceDeviceListSize_state *state = tevent_req_data(
3306 req, struct rpccli_PNP_GetInterfaceDeviceListSize_state);
3307 NTSTATUS status;
3308
3309 if (tevent_req_is_nterror(req, &status)) {
3310 tevent_req_received(req);
3311 return status;
3312 }
3313
3314 /* Steal possbile out parameters to the callers context */
3315 talloc_steal(mem_ctx, state->out_mem_ctx);
3316
3317 /* Return result */
3318 *result = state->orig.out.result;
3319
3320 tevent_req_received(req);
3321 return NT_STATUS_OK;
3322 }
3323
3324 NTSTATUS rpccli_PNP_GetInterfaceDeviceListSize(struct rpc_pipe_client *cli,
3325 TALLOC_CTX *mem_ctx,
3326 WERROR *werror)
3327 {
3328 struct PNP_GetInterfaceDeviceListSize r;
3329 NTSTATUS status;
3330
3331 /* In parameters */
3332
3333 status = cli->dispatch(cli,
3334 mem_ctx,
3335 &ndr_table_ntsvcs,
3336 NDR_PNP_GETINTERFACEDEVICELISTSIZE,
3337 &r);
3338
3339 if (!NT_STATUS_IS_OK(status)) {
3340 return status;
3341 }
3342
3343 if (NT_STATUS_IS_ERR(status)) {
3344 return status;
3345 }
3346
3347 /* Return variables */
3348
3349 /* Return result */
3350 if (werror) {
3351 *werror = r.out.result;
3352 }
3353
3354 return werror_to_ntstatus(r.out.result);
3355 }
3356
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);
3362 };
3363
3364 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req *subreq);
3365
3366 struct tevent_req *rpccli_PNP_RegisterDeviceClassAssociation_send(TALLOC_CTX *mem_ctx,
3367 struct tevent_context *ev,
3368 struct rpc_pipe_client *cli)
3369 {
3370 struct tevent_req *req;
3371 struct rpccli_PNP_RegisterDeviceClassAssociation_state *state;
3372 struct tevent_req *subreq;
3373
3374 req = tevent_req_create(mem_ctx, &state,
3375 struct rpccli_PNP_RegisterDeviceClassAssociation_state);
3376 if (req == NULL) {
3377 return NULL;
3378 }
3379 state->out_mem_ctx = NULL;
3380 state->dispatch_recv = cli->dispatch_recv;
3381
3382 /* In parameters */
3383
3384 /* Out parameters */
3385
3386 /* Result */
3387 ZERO_STRUCT(state->orig.out.result);
3388
3389 /* make a temporary copy, that we pass to the dispatch function */
3390 state->tmp = state->orig;
3391
3392 subreq = cli->dispatch_send(state, ev, cli,
3393 &ndr_table_ntsvcs,
3394 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
3395 &state->tmp);
3396 if (tevent_req_nomem(subreq, req)) {
3397 return tevent_req_post(req, ev);
3398 }
3399 tevent_req_set_callback(subreq, rpccli_PNP_RegisterDeviceClassAssociation_done, req);
3400 return req;
3401 }
3402
3403 static void rpccli_PNP_RegisterDeviceClassAssociation_done(struct tevent_req *subreq)
3404 {
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);
3409 NTSTATUS status;
3410 TALLOC_CTX *mem_ctx;
3411
3412 if (state->out_mem_ctx) {
3413 mem_ctx = state->out_mem_ctx;
3414 } else {
3415 mem_ctx = state;
3416 }
3417
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);
3422 return;
3423 }
3424
3425 /* Copy out parameters */
3426
3427 /* Copy result */
3428 state->orig.out.result = state->tmp.out.result;
3429
3430 /* Reset temporary structure */
3431 ZERO_STRUCT(state->tmp);
3432
3433 tevent_req_done(req);
3434 }
3435
3436 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation_recv(struct tevent_req *req,
3437 TALLOC_CTX *mem_ctx,
3438 WERROR *result)
3439 {
3440 struct rpccli_PNP_RegisterDeviceClassAssociation_state *state = tevent_req_data(
3441 req, struct rpccli_PNP_RegisterDeviceClassAssociation_state);
3442 NTSTATUS status;
3443
3444 if (tevent_req_is_nterror(req, &status)) {
3445 tevent_req_received(req);
3446 return status;
3447 }
3448
3449 /* Steal possbile out parameters to the callers context */
3450 talloc_steal(mem_ctx, state->out_mem_ctx);
3451
3452 /* Return result */
3453 *result = state->orig.out.result;
3454
3455 tevent_req_received(req);
3456 return NT_STATUS_OK;
3457 }
3458
3459 NTSTATUS rpccli_PNP_RegisterDeviceClassAssociation(struct rpc_pipe_client *cli,
3460 TALLOC_CTX *mem_ctx,
3461 WERROR *werror)
3462 {
3463 struct PNP_RegisterDeviceClassAssociation r;
3464 NTSTATUS status;
3465
3466 /* In parameters */
3467
3468 status = cli->dispatch(cli,
3469 mem_ctx,
3470 &ndr_table_ntsvcs,
3471 NDR_PNP_REGISTERDEVICECLASSASSOCIATION,
3472 &r);
3473
3474 if (!NT_STATUS_IS_OK(status)) {
3475 return status;
3476 }
3477
3478 if (NT_STATUS_IS_ERR(status)) {
3479 return status;
3480 }
3481
3482 /* Return variables */
3483
3484 /* Return result */
3485 if (werror) {
3486 *werror = r.out.result;
3487 }
3488
3489 return werror_to_ntstatus(r.out.result);
3490 }
3491
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);
3497 };
3498
3499 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req *subreq);
3500
3501 struct tevent_req *rpccli_PNP_UnregisterDeviceClassAssociation_send(TALLOC_CTX *mem_ctx,
3502 struct tevent_context *ev,
3503 struct rpc_pipe_client *cli)
3504 {
3505 struct tevent_req *req;
3506 struct rpccli_PNP_UnregisterDeviceClassAssociation_state *state;
3507 struct tevent_req *subreq;
3508
3509 req = tevent_req_create(mem_ctx, &state,
3510 struct rpccli_PNP_UnregisterDeviceClassAssociation_state);
3511 if (req == NULL) {
3512 return NULL;
3513 }
3514 state->out_mem_ctx = NULL;
3515 state->dispatch_recv = cli->dispatch_recv;
3516
3517 /* In parameters */
3518
3519 /* Out parameters */
3520
3521 /* Result */
3522 ZERO_STRUCT(state->orig.out.result);
3523
3524 /* make a temporary copy, that we pass to the dispatch function */
3525 state->tmp = state->orig;
3526
3527 subreq = cli->dispatch_send(state, ev, cli,
3528 &ndr_table_ntsvcs,
3529 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
3530 &state->tmp);
3531 if (tevent_req_nomem(subreq, req)) {
3532 return tevent_req_post(req, ev);
3533 }
3534 tevent_req_set_callback(subreq, rpccli_PNP_UnregisterDeviceClassAssociation_done, req);
3535 return req;
3536 }
3537
3538 static void rpccli_PNP_UnregisterDeviceClassAssociation_done(struct tevent_req *subreq)
3539 {
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);
3544 NTSTATUS status;
3545 TALLOC_CTX *mem_ctx;
3546
3547 if (state->out_mem_ctx) {
3548 mem_ctx = state->out_mem_ctx;
3549 } else {
3550 mem_ctx = state;
3551 }
3552
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);
3557 return;
3558 }
3559
3560 /* Copy out parameters */
3561
3562 /* Copy result */
3563 state->orig.out.result = state->tmp.out.result;
3564
3565 /* Reset temporary structure */
3566 ZERO_STRUCT(state->tmp);
3567
3568 tevent_req_done(req);
3569 }
3570
3571 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation_recv(struct tevent_req *req,
3572 TALLOC_CTX *mem_ctx,
3573 WERROR *result)
3574 {
3575 struct rpccli_PNP_UnregisterDeviceClassAssociation_state *state = tevent_req_data(
3576 req, struct rpccli_PNP_UnregisterDeviceClassAssociation_state);
3577 NTSTATUS status;
3578
3579 if (tevent_req_is_nterror(req, &status)) {
3580 tevent_req_received(req);
3581 return status;
3582 }
3583
3584 /* Steal possbile out parameters to the callers context */
3585 talloc_steal(mem_ctx, state->out_mem_ctx);
3586
3587 /* Return result */
3588 *result = state->orig.out.result;
3589
3590 tevent_req_received(req);
3591 return NT_STATUS_OK;
3592 }
3593
3594 NTSTATUS rpccli_PNP_UnregisterDeviceClassAssociation(struct rpc_pipe_client *cli,
3595 TALLOC_CTX *mem_ctx,
3596 WERROR *werror)
3597 {
3598 struct PNP_UnregisterDeviceClassAssociation r;
3599 NTSTATUS status;
3600
3601 /* In parameters */
3602
3603 status = cli->dispatch(cli,
3604 mem_ctx,
3605 &ndr_table_ntsvcs,
3606 NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION,
3607 &r);
3608
3609 if (!NT_STATUS_IS_OK(status)) {
3610 return status;
3611 }
3612
3613 if (NT_STATUS_IS_ERR(status)) {
3614 return status;
3615 }
3616
3617 /* Return variables */
3618
3619 /* Return result */
3620 if (werror) {
3621 *werror = r.out.result;
3622 }
3623
3624 return werror_to_ntstatus(r.out.result);
3625 }
3626
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);
3632 };
3633
3634 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req *subreq);
3635
3636 struct tevent_req *rpccli_PNP_GetClassRegProp_send(TALLOC_CTX *mem_ctx,
3637 struct tevent_context *ev,
3638 struct rpc_pipe_client *cli)
3639 {
3640 struct tevent_req *req;
3641 struct rpccli_PNP_GetClassRegProp_state *state;
3642 struct tevent_req *subreq;
3643
3644 req = tevent_req_create(mem_ctx, &state,
3645 struct rpccli_PNP_GetClassRegProp_state);
3646 if (req == NULL) {
3647 return NULL;
3648 }
3649 state->out_mem_ctx = NULL;
3650 state->dispatch_recv = cli->dispatch_recv;
3651
3652 /* In parameters */
3653
3654 /* Out parameters */
3655
3656 /* Result */
3657 ZERO_STRUCT(state->orig.out.result);
3658
3659 /* make a temporary copy, that we pass to the dispatch function */
3660 state->tmp = state->orig;
3661
3662 subreq = cli->dispatch_send(state, ev, cli,
3663 &ndr_table_ntsvcs,
3664 NDR_PNP_GETCLASSREGPROP,
3665 &state->tmp);
3666 if (tevent_req_nomem(subreq, req)) {
3667 return tevent_req_post(req, ev);
3668 }
3669 tevent_req_set_callback(subreq, rpccli_PNP_GetClassRegProp_done, req);
3670 return req;
3671 }
3672
3673 static void rpccli_PNP_GetClassRegProp_done(struct tevent_req *subreq)
3674 {
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);
3679 NTSTATUS status;
3680 TALLOC_CTX *mem_ctx;
3681
3682 if (state->out_mem_ctx) {
3683 mem_ctx = state->out_mem_ctx;
3684 } else {
3685 mem_ctx = state;
3686 }
3687
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);
3692 return;
3693 }
3694
3695 /* Copy out parameters */
3696
3697 /* Copy result */
3698 state->orig.out.result = state->tmp.out.result;
3699
3700 /* Reset temporary structure */
3701 ZERO_STRUCT(state->tmp);
3702
3703 tevent_req_done(req);
3704 }
3705
3706 NTSTATUS rpccli_PNP_GetClassRegProp_recv(struct tevent_req *req,
3707 TALLOC_CTX *mem_ctx,
3708 WERROR *result)
3709 {
3710 struct rpccli_PNP_GetClassRegProp_state *state = tevent_req_data(
3711 req, struct rpccli_PNP_GetClassRegProp_state);
3712 NTSTATUS status;
3713
3714 if (tevent_req_is_nterror(req, &status)) {
3715 tevent_req_received(req);
3716 return status;
3717 }
3718
3719 /* Steal possbile out parameters to the callers context */
3720 talloc_steal(mem_ctx, state->out_mem_ctx);
3721
3722 /* Return result */
3723 *result = state->orig.out.result;
3724
3725 tevent_req_received(req);
3726 return NT_STATUS_OK;
3727 }
3728
3729 NTSTATUS rpccli_PNP_GetClassRegProp(struct rpc_pipe_client *cli,
3730 TALLOC_CTX *mem_ctx,
3731 WERROR *werror)
3732 {
3733 struct PNP_GetClassRegProp r;
3734 NTSTATUS status;
3735
3736 /* In parameters */
3737
3738 status = cli->dispatch(cli,
3739 mem_ctx,
3740 &ndr_table_ntsvcs,
3741 NDR_PNP_GETCLASSREGPROP,
3742 &r);
3743
3744 if (!NT_STATUS_IS_OK(status)) {
3745 return status;
3746 }
3747
3748 if (NT_STATUS_IS_ERR(status)) {
3749 return status;
3750 }
3751
3752 /* Return variables */
3753
3754 /* Return result */
3755 if (werror) {
3756 *werror = r.out.result;
3757 }
3758
3759 return werror_to_ntstatus(r.out.result);
3760 }
3761
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);
3767 };
3768
3769 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req *subreq);
3770
3771 struct tevent_req *rpccli_PNP_SetClassRegProp_send(TALLOC_CTX *mem_ctx,
3772 struct tevent_context *ev,
3773 struct rpc_pipe_client *cli)
3774 {
3775 struct tevent_req *req;
3776 struct rpccli_PNP_SetClassRegProp_state *state;
3777 struct tevent_req *subreq;
3778
3779 req = tevent_req_create(mem_ctx, &state,
3780 struct rpccli_PNP_SetClassRegProp_state);
3781 if (req == NULL) {
3782 return NULL;
3783 }
3784 state->out_mem_ctx = NULL;
3785 state->dispatch_recv = cli->dispatch_recv;
3786
3787 /* In parameters */
3788
3789 /* Out parameters */
3790
3791 /* Result */
3792 ZERO_STRUCT(state->orig.out.result);
3793
3794 /* make a temporary copy, that we pass to the dispatch function */
3795 state->tmp = state->orig;
3796
3797 subreq = cli->dispatch_send(state, ev, cli,
3798 &ndr_table_ntsvcs,
3799 NDR_PNP_SETCLASSREGPROP,
3800 &state->tmp);
3801 if (tevent_req_nomem(subreq, req)) {
3802 return tevent_req_post(req, ev);
3803 }
3804 tevent_req_set_callback(subreq, rpccli_PNP_SetClassRegProp_done, req);
3805 return req;
3806 }
3807
3808 static void rpccli_PNP_SetClassRegProp_done(struct tevent_req *subreq)
3809 {
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);
3814 NTSTATUS status;
3815 TALLOC_CTX *mem_ctx;
3816
3817 if (state->out_mem_ctx) {
3818 mem_ctx = state->out_mem_ctx;
3819 } else {
3820 mem_ctx = state;
3821 }
3822
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);
3827 return;
3828 }
3829
3830 /* Copy out parameters */
3831
3832 /* Copy result */
3833 state->orig.out.result = state->tmp.out.result;
3834
3835 /* Reset temporary structure */
3836 ZERO_STRUCT(state->tmp);
3837
3838 tevent_req_done(req);
3839 }
3840
3841 NTSTATUS rpccli_PNP_SetClassRegProp_recv(struct tevent_req *req,
3842 TALLOC_CTX *mem_ctx,
3843 WERROR *result)
3844 {
3845 struct rpccli_PNP_SetClassRegProp_state *state = tevent_req_data(
3846 req, struct rpccli_PNP_SetClassRegProp_state);
3847 NTSTATUS status;
3848
3849 if (tevent_req_is_nterror(req, &status)) {
3850 tevent_req_received(req);
3851 return status;
3852 }
3853
3854 /* Steal possbile out parameters to the callers context */
3855 talloc_steal(mem_ctx, state->out_mem_ctx);
3856
3857 /* Return result */
3858 *result = state->orig.out.result;
3859
3860 tevent_req_received(req);
3861 return NT_STATUS_OK;
3862 }
3863
3864 NTSTATUS rpccli_PNP_SetClassRegProp(struct rpc_pipe_client *cli,
3865 TALLOC_CTX *mem_ctx,
3866 WERROR *werror)
3867 {
3868 struct PNP_SetClassRegProp r;
3869 NTSTATUS status;
3870
3871 /* In parameters */
3872
3873 status = cli->dispatch(cli,
3874 mem_ctx,
3875 &ndr_table_ntsvcs,
3876 NDR_PNP_SETCLASSREGPROP,
3877 &r);
3878
3879 if (!NT_STATUS_IS_OK(status)) {
3880 return status;
3881 }
3882
3883 if (NT_STATUS_IS_ERR(status)) {
3884 return status;
3885 }
3886
3887 /* Return variables */
3888
3889 /* Return result */
3890 if (werror) {
3891 *werror = r.out.result;
3892 }
3893
3894 return werror_to_ntstatus(r.out.result);
3895 }
3896
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);
3902 };
3903
3904 static void rpccli_PNP_CreateDevInst_done(struct tevent_req *subreq);
3905
3906 struct tevent_req *rpccli_PNP_CreateDevInst_send(TALLOC_CTX *mem_ctx,
3907 struct tevent_context *ev,
3908 struct rpc_pipe_client *cli)
3909 {
3910 struct tevent_req *req;
3911 struct rpccli_PNP_CreateDevInst_state *state;
3912 struct tevent_req *subreq;
3913
3914 req = tevent_req_create(mem_ctx, &state,
3915 struct rpccli_PNP_CreateDevInst_state);
3916 if (req == NULL) {
3917 return NULL;
3918 }
3919 state->out_mem_ctx = NULL;
3920 state->dispatch_recv = cli->dispatch_recv;
3921
3922 /* In parameters */
3923
3924 /* Out parameters */
3925
3926 /* Result */
3927 ZERO_STRUCT(state->orig.out.result);
3928
3929 /* make a temporary copy, that we pass to the dispatch function */
3930 state->tmp = state->orig;
3931
3932 subreq = cli->dispatch_send(state, ev, cli,
3933 &ndr_table_ntsvcs,
3934 NDR_PNP_CREATEDEVINST,
3935 &state->tmp);
3936 if (tevent_req_nomem(subreq, req)) {
3937 return tevent_req_post(req, ev);
3938 }
3939 tevent_req_set_callback(subreq, rpccli_PNP_CreateDevInst_done, req);
3940 return req;
3941 }
3942
3943 static void rpccli_PNP_CreateDevInst_done(struct tevent_req *subreq)
3944 {
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);
3949 NTSTATUS status;
3950 TALLOC_CTX *mem_ctx;
3951
3952 if (state->out_mem_ctx) {
3953 mem_ctx = state->out_mem_ctx;
3954 } else {
3955 mem_ctx = state;
3956 }
3957
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);
3962 return;
3963 }
3964
3965 /* Copy out parameters */
3966
3967 /* Copy result */
3968 state->orig.out.result = state->tmp.out.result;
3969
3970 /* Reset temporary structure */
3971 ZERO_STRUCT(state->tmp);
3972
3973 tevent_req_done(req);
3974 }
3975
3976 NTSTATUS rpccli_PNP_CreateDevInst_recv(struct tevent_req *req,
3977 TALLOC_CTX *mem_ctx,
3978 WERROR *result)
3979 {
3980 struct rpccli_PNP_CreateDevInst_state *state = tevent_req_data(
3981 req, struct rpccli_PNP_CreateDevInst_state);
3982 NTSTATUS status;
3983
3984 if (tevent_req_is_nterror(req, &status)) {
3985 tevent_req_received(req);
3986 return status;
3987 }
3988
3989 /* Steal possbile out parameters to the callers context */
3990 talloc_steal(mem_ctx, state->out_mem_ctx);
3991
3992 /* Return result */
3993 *result = state->orig.out.result;
3994
3995 tevent_req_received(req);
3996 return NT_STATUS_OK;
3997 }
3998
3999 NTSTATUS rpccli_PNP_CreateDevInst(struct rpc_pipe_client *cli,
4000 TALLOC_CTX *mem_ctx,
4001 WERROR *werror)
4002 {
4003 struct PNP_CreateDevInst r;
4004 NTSTATUS status;
4005
4006 /* In parameters */
4007
4008 status = cli->dispatch(cli,
4009 mem_ctx,
4010 &ndr_table_ntsvcs,
4011 NDR_PNP_CREATEDEVINST,
4012 &r);
4013
4014 if (!NT_STATUS_IS_OK(status)) {
4015 return status;
4016 }
4017
4018 if (NT_STATUS_IS_ERR(status)) {
4019 return status;
4020 }
4021
4022 /* Return variables */
4023
4024 /* Return result */
4025 if (werror) {
4026 *werror = r.out.result;
4027 }
4028
4029 return werror_to_ntstatus(r.out.result);
4030 }
4031
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);
4037 };
4038
4039 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req *subreq);
4040
4041 struct tevent_req *rpccli_PNP_DeviceInstanceAction_send(TALLOC_CTX *mem_ctx,
4042 struct tevent_context *ev,
4043 struct rpc_pipe_client *cli)
4044 {
4045 struct tevent_req *req;
4046 struct rpccli_PNP_DeviceInstanceAction_state *state;
4047 struct tevent_req *subreq;
4048
4049 req = tevent_req_create(mem_ctx, &state,
4050 struct rpccli_PNP_DeviceInstanceAction_state);
4051 if (req == NULL) {
4052 return NULL;
4053 }
4054 state->out_mem_ctx = NULL;
4055 state->dispatch_recv = cli->dispatch_recv;
4056
4057 /* In parameters */
4058
4059 /* Out parameters */
4060
4061 /* Result */
4062 ZERO_STRUCT(state->orig.out.result);
4063
4064 /* make a temporary copy, that we pass to the dispatch function */
4065 state->tmp = state->orig;
4066
4067 subreq = cli->dispatch_send(state, ev, cli,
4068 &ndr_table_ntsvcs,
4069 NDR_PNP_DEVICEINSTANCEACTION,
4070 &state->tmp);
4071 if (tevent_req_nomem(subreq, req)) {
4072 return tevent_req_post(req, ev);
4073 }
4074 tevent_req_set_callback(subreq, rpccli_PNP_DeviceInstanceAction_done, req);
4075 return req;
4076 }
4077
4078 static void rpccli_PNP_DeviceInstanceAction_done(struct tevent_req *subreq)
4079 {
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);
4084 NTSTATUS status;
4085 TALLOC_CTX *mem_ctx;
4086
4087 if (state->out_mem_ctx) {
4088 mem_ctx = state->out_mem_ctx;
4089 } else {
4090 mem_ctx = state;
4091 }
4092
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);
4097 return;
4098 }
4099
4100 /* Copy out parameters */
4101
4102 /* Copy result */
4103 state->orig.out.result = state->tmp.out.result;
4104
4105 /* Reset temporary structure */
4106 ZERO_STRUCT(state->tmp);
4107
4108 tevent_req_done(req);
4109 }
4110
4111 NTSTATUS rpccli_PNP_DeviceInstanceAction_recv(struct tevent_req *req,
4112 TALLOC_CTX *mem_ctx,
4113 WERROR *result)
4114 {
4115 struct rpccli_PNP_DeviceInstanceAction_state *state = tevent_req_data(
4116 req, struct rpccli_PNP_DeviceInstanceAction_state);
4117 NTSTATUS status;
4118
4119 if (tevent_req_is_nterror(req, &status)) {
4120 tevent_req_received(req);
4121 return status;
4122 }
4123
4124 /* Steal possbile out parameters to the callers context */
4125 talloc_steal(mem_ctx, state->out_mem_ctx);
4126
4127 /* Return result */
4128 *result = state->orig.out.result;
4129
4130 tevent_req_received(req);
4131 return NT_STATUS_OK;
4132 }
4133
4134 NTSTATUS rpccli_PNP_DeviceInstanceAction(struct rpc_pipe_client *cli,
4135 TALLOC_CTX *mem_ctx,
4136 WERROR *werror)
4137 {
4138 struct PNP_DeviceInstanceAction r;
4139 NTSTATUS status;
4140
4141 /* In parameters */
4142
4143 status = cli->dispatch(cli,
4144 mem_ctx,
4145 &ndr_table_ntsvcs,
4146 NDR_PNP_DEVICEINSTANCEACTION,
4147 &r);
4148
4149 if (!NT_STATUS_IS_OK(status)) {
4150 return status;
4151 }
4152
4153 if (NT_STATUS_IS_ERR(status)) {
4154 return status;
4155 }
4156
4157 /* Return variables */
4158
4159 /* Return result */
4160 if (werror) {
4161 *werror = r.out.result;
4162 }
4163
4164 return werror_to_ntstatus(r.out.result);
4165 }
4166
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);
4172 };
4173
4174 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req *subreq);
4175
4176 struct tevent_req *rpccli_PNP_GetDeviceStatus_send(TALLOC_CTX *mem_ctx,
4177 struct tevent_context *ev,
4178 struct rpc_pipe_client *cli)
4179 {
4180 struct tevent_req *req;
4181 struct rpccli_PNP_GetDeviceStatus_state *state;
4182 struct tevent_req *subreq;
4183
4184 req = tevent_req_create(mem_ctx, &state,
4185 struct rpccli_PNP_GetDeviceStatus_state);
4186 if (req == NULL) {
4187 return NULL;
4188 }
4189 state->out_mem_ctx = NULL;
4190 state->dispatch_recv = cli->dispatch_recv;
4191
4192 /* In parameters */
4193
4194 /* Out parameters */
4195
4196 /* Result */
4197 ZERO_STRUCT(state->orig.out.result);
4198
4199 /* make a temporary copy, that we pass to the dispatch function */
4200 state->tmp = state->orig;
4201
4202 subreq = cli->dispatch_send(state, ev, cli,
4203 &ndr_table_ntsvcs,
4204 NDR_PNP_GETDEVICESTATUS,
4205 &state->tmp);
4206 if (tevent_req_nomem(subreq, req)) {
4207 return tevent_req_post(req, ev);
4208 }
4209 tevent_req_set_callback(subreq, rpccli_PNP_GetDeviceStatus_done, req);
4210 return req;
4211 }
4212
4213 static void rpccli_PNP_GetDeviceStatus_done(struct tevent_req *subreq)
4214 {
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);
4219 NTSTATUS status;
4220 TALLOC_CTX *mem_ctx;
4221
4222 if (state->out_mem_ctx) {
4223 mem_ctx = state->out_mem_ctx;
4224 } else {
4225 mem_ctx = state;
4226 }
4227
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);
4232 return;
4233 }
4234
4235 /* Copy out parameters */
4236
4237 /* Copy result */
4238 state->orig.out.result = state->tmp.out.result;
4239
4240 /* Reset temporary structure */
4241 ZERO_STRUCT(state->tmp);
4242
4243 tevent_req_done(req);
4244 }
4245
4246 NTSTATUS rpccli_PNP_GetDeviceStatus_recv(struct tevent_req *req,
4247 TALLOC_CTX *mem_ctx,
4248 WERROR *result)
4249 {
4250 struct rpccli_PNP_GetDeviceStatus_state *state = tevent_req_data(
4251 req, struct rpccli_PNP_GetDeviceStatus_state);
4252 NTSTATUS status;
4253
4254 if (tevent_req_is_nterror(req, &status)) {
4255 tevent_req_received(req);
4256 return status;
4257 }
4258
4259 /* Steal possbile out parameters to the callers context */
4260 talloc_steal(mem_ctx, state->out_mem_ctx);
4261
4262 /* Return result */
4263 *result = state->orig.out.result;
4264
4265 tevent_req_received(req);
4266 return NT_STATUS_OK;
4267 }
4268
4269 NTSTATUS rpccli_PNP_GetDeviceStatus(struct rpc_pipe_client *cli,
4270 TALLOC_CTX *mem_ctx,
4271 WERROR *werror)
4272 {
4273 struct PNP_GetDeviceStatus r;
4274 NTSTATUS status;
4275
4276 /* In parameters */
4277
4278 status = cli->dispatch(cli,
4279 mem_ctx,
4280 &ndr_table_ntsvcs,
4281 NDR_PNP_GETDEVICESTATUS,
4282 &r);
4283
4284 if (!NT_STATUS_IS_OK(status)) {
4285 return status;
4286 }
4287
4288 if (NT_STATUS_IS_ERR(status)) {
4289 return status;
4290 }
4291
4292 /* Return variables */
4293
4294 /* Return result */
4295 if (werror) {
4296 *werror = r.out.result;
4297 }
4298
4299 return werror_to_ntstatus(r.out.result);
4300 }
4301
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);
4307 };
4308
4309 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req *subreq);
4310
4311 struct tevent_req *rpccli_PNP_SetDeviceProblem_send(TALLOC_CTX *mem_ctx,
4312 struct tevent_context *ev,
4313 struct rpc_pipe_client *cli)
4314 {
4315 struct tevent_req *req;
4316 struct rpccli_PNP_SetDeviceProblem_state *state;
4317 struct tevent_req *subreq;
4318
4319 req = tevent_req_create(mem_ctx, &state,
4320 struct rpccli_PNP_SetDeviceProblem_state);
4321 if (req == NULL) {
4322 return NULL;
4323 }
4324 state->out_mem_ctx = NULL;
4325 state->dispatch_recv = cli->dispatch_recv;
4326
4327 /* In parameters */
4328
4329 /* Out parameters */
4330
4331 /* Result */
4332 ZERO_STRUCT(state->orig.out.result);
4333
4334 /* make a temporary copy, that we pass to the dispatch function */
4335 state->tmp = state->orig;
4336
4337 subreq = cli->dispatch_send(state, ev, cli,
4338 &ndr_table_ntsvcs,
4339 NDR_PNP_SETDEVICEPROBLEM,
4340 &state->tmp);
4341 if (tevent_req_nomem(subreq, req)) {
4342 return tevent_req_post(req, ev);
4343 }
4344 tevent_req_set_callback(subreq, rpccli_PNP_SetDeviceProblem_done, req);
4345 return req;
4346 }
4347
4348 static void rpccli_PNP_SetDeviceProblem_done(struct tevent_req *subreq)
4349 {
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);
4354 NTSTATUS status;
4355 TALLOC_CTX *mem_ctx;
4356
4357 if (state->out_mem_ctx) {
4358 mem_ctx = state->out_mem_ctx;
4359 } else {
4360 mem_ctx = state;
4361 }
4362
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);
4367 return;
4368 }
4369
4370 /* Copy out parameters */
4371
4372 /* Copy result */
4373 state->orig.out.result = state->tmp.out.result;
4374
4375 /* Reset temporary structure */
4376 ZERO_STRUCT(state->tmp);
4377
4378 tevent_req_done(req);
4379 }
4380
4381 NTSTATUS rpccli_PNP_SetDeviceProblem_recv(struct tevent_req *req,
4382 TALLOC_CTX *mem_ctx,
4383 WERROR *result)
4384 {
4385 struct rpccli_PNP_SetDeviceProblem_state *state = tevent_req_data(
4386 req, struct rpccli_PNP_SetDeviceProblem_state);
4387 NTSTATUS status;
4388
4389 if (tevent_req_is_nterror(req, &status)) {
4390 tevent_req_received(req);
4391 return status;
4392 }
4393
4394 /* Steal possbile out parameters to the callers context */
4395 talloc_steal(mem_ctx, state->out_mem_ctx);
4396
4397 /* Return result */
4398 *result = state->orig.out.result;
4399
4400 tevent_req_received(req);
4401 return NT_STATUS_OK;
4402 }
4403
4404 NTSTATUS rpccli_PNP_SetDeviceProblem(struct rpc_pipe_client *cli,
4405 TALLOC_CTX *mem_ctx,
4406 WERROR *werror)
4407 {
4408 struct PNP_SetDeviceProblem r;
4409 NTSTATUS status;
4410
4411 /* In parameters */
4412
4413 status = cli->dispatch(cli,
4414 mem_ctx,
4415 &ndr_table_ntsvcs,
4416 NDR_PNP_SETDEVICEPROBLEM,
4417 &r);
4418
4419 if (!NT_STATUS_IS_OK(status)) {
4420 return status;
4421 }
4422
4423 if (NT_STATUS_IS_ERR(status)) {
4424 return status;
4425 }
4426
4427 /* Return variables */
4428
4429 /* Return result */
4430 if (werror) {
4431 *werror = r.out.result;
4432 }
4433
4434 return werror_to_ntstatus(r.out.result);
4435 }
4436
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);
4442 };
4443
4444 static void rpccli_PNP_DisableDevInst_done(struct tevent_req *subreq);
4445
4446 struct tevent_req *rpccli_PNP_DisableDevInst_send(TALLOC_CTX *mem_ctx,
4447 struct tevent_context *ev,
4448 struct rpc_pipe_client *cli)
4449 {
4450 struct tevent_req *req;
4451 struct rpccli_PNP_DisableDevInst_state *state;
4452 struct tevent_req *subreq;
4453
4454 req = tevent_req_create(mem_ctx, &state,
4455 struct rpccli_PNP_DisableDevInst_state);
4456 if (req == NULL) {
4457 return NULL;
4458 }
4459 state->out_mem_ctx = NULL;
4460 state->dispatch_recv = cli->dispatch_recv;
4461
4462 /* In parameters */
4463
4464 /* Out parameters */
4465
4466 /* Result */
4467 ZERO_STRUCT(state->orig.out.result);
4468
4469 /* make a temporary copy, that we pass to the dispatch function */
4470 state->tmp = state->orig;
4471
4472 subreq = cli->dispatch_send(state, ev, cli,
4473 &ndr_table_ntsvcs,
4474 NDR_PNP_DISABLEDEVINST,
4475 &state->tmp);
4476 if (tevent_req_nomem(subreq, req)) {
4477 return tevent_req_post(req, ev);
4478 }
4479 tevent_req_set_callback(subreq, rpccli_PNP_DisableDevInst_done, req);
4480 return req;
4481 }
4482
4483 static void rpccli_PNP_DisableDevInst_done(struct tevent_req *subreq)
4484 {
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);
4489 NTSTATUS status;
4490 TALLOC_CTX *mem_ctx;
4491
4492 if (state->out_mem_ctx) {
4493 mem_ctx = state->out_mem_ctx;
4494 } else {
4495 mem_ctx = state;
4496 }
4497
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);
4502 return;
4503 }
4504
4505 /* Copy out parameters */
4506
4507 /* Copy result */
4508 state->orig.out.result = state->tmp.out.result;
4509
4510 /* Reset temporary structure */
4511 ZERO_STRUCT(state->tmp);
4512
4513 tevent_req_done(req);
4514 }
4515
4516 NTSTATUS rpccli_PNP_DisableDevInst_recv(struct tevent_req *req,
4517 TALLOC_CTX *mem_ctx,
4518 WERROR *result)
4519 {
4520 struct rpccli_PNP_DisableDevInst_state *state = tevent_req_data(
4521 req, struct rpccli_PNP_DisableDevInst_state);
4522 NTSTATUS status;
4523
4524 if (tevent_req_is_nterror(req, &status)) {
4525 tevent_req_received(req);
4526 return status;
4527 }
4528
4529 /* Steal possbile out parameters to the callers context */
4530 talloc_steal(mem_ctx, state->out_mem_ctx);
4531
4532 /* Return result */
4533 *result = state->orig.out.result;
4534
4535 tevent_req_received(req);
4536 return NT_STATUS_OK;
4537 }
4538
4539 NTSTATUS rpccli_PNP_DisableDevInst(struct rpc_pipe_client *cli,
4540 TALLOC_CTX *mem_ctx,
4541 WERROR *werror)
4542 {
4543 struct PNP_DisableDevInst r;
4544 NTSTATUS status;
4545
4546 /* In parameters */
4547
4548 status = cli->dispatch(cli,
4549 mem_ctx,
4550 &ndr_table_ntsvcs,
4551 NDR_PNP_DISABLEDEVINST,
4552 &r);
4553
4554 if (!NT_STATUS_IS_OK(status)) {
4555 return status;
4556 }
4557
4558 if (NT_STATUS_IS_ERR(status)) {
4559 return status;
4560 }
4561
4562 /* Return variables */
4563
4564 /* Return result */
4565 if (werror) {
4566 *werror = r.out.result;
4567 }
4568
4569 return werror_to_ntstatus(r.out.result);
4570 }
4571
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);
4577 };
4578
4579 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req *subreq);
4580
4581 struct tevent_req *rpccli_PNP_UninstallDevInst_send(TALLOC_CTX *mem_ctx,
4582 struct tevent_context *ev,
4583 struct rpc_pipe_client *cli)
4584 {
4585 struct tevent_req *req;
4586 struct rpccli_PNP_UninstallDevInst_state *state;
4587 struct tevent_req *subreq;
4588
4589 req = tevent_req_create(mem_ctx, &state,
4590 struct rpccli_PNP_UninstallDevInst_state);
4591 if (req == NULL) {
4592 return NULL;
4593 }
4594 state->out_mem_ctx = NULL;
4595 state->dispatch_recv = cli->dispatch_recv;
4596
4597 /* In parameters */
4598
4599 /* Out parameters */
4600
4601 /* Result */
4602 ZERO_STRUCT(state->orig.out.result);
4603
4604 /* make a temporary copy, that we pass to the dispatch function */
4605 state->tmp = state->orig;
4606
4607 subreq = cli->dispatch_send(state, ev, cli,
4608 &ndr_table_ntsvcs,
4609 NDR_PNP_UNINSTALLDEVINST,
4610 &state->tmp);
4611 if (tevent_req_nomem(subreq, req)) {
4612 return tevent_req_post(req, ev);
4613 }
4614 tevent_req_set_callback(subreq, rpccli_PNP_UninstallDevInst_done, req);
4615 return req;
4616 }
4617
4618 static void rpccli_PNP_UninstallDevInst_done(struct tevent_req *subreq)
4619 {
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);
4624 NTSTATUS status;
4625 TALLOC_CTX *mem_ctx;
4626
4627 if (state->out_mem_ctx) {
4628 mem_ctx = state->out_mem_ctx;
4629 } else {
4630 mem_ctx = state;
4631 }
4632
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);
4637 return;
4638 }
4639
4640 /* Copy out parameters */
4641
4642 /* Copy result */
4643 state->orig.out.result = state->tmp.out.result;
4644
4645 /* Reset temporary structure */
4646 ZERO_STRUCT(state->tmp);
4647
4648 tevent_req_done(req);
4649 }
4650
4651 NTSTATUS rpccli_PNP_UninstallDevInst_recv(struct tevent_req *req,
4652 TALLOC_CTX *mem_ctx,
4653 WERROR *result)
4654 {
4655 struct rpccli_PNP_UninstallDevInst_state *state = tevent_req_data(
4656 req, struct rpccli_PNP_UninstallDevInst_state);
4657 NTSTATUS status;
4658
4659 if (tevent_req_is_nterror(req, &status)) {
4660 tevent_req_received(req);
4661 return status;
4662 }
4663
4664 /* Steal possbile out parameters to the callers context */
4665 talloc_steal(mem_ctx, state->out_mem_ctx);
4666
4667 /* Return result */
4668 *result = state->orig.out.result;
4669
4670 tevent_req_received(req);
4671 return NT_STATUS_OK;
4672 }
4673
4674 NTSTATUS rpccli_PNP_UninstallDevInst(struct rpc_pipe_client *cli,
4675 TALLOC_CTX *mem_ctx,
4676 WERROR *werror)
4677 {
4678 struct PNP_UninstallDevInst r;
4679 NTSTATUS status;
4680
4681 /* In parameters */
4682
4683 status = cli->dispatch(cli,
4684 mem_ctx,
4685 &ndr_table_ntsvcs,
4686 NDR_PNP_UNINSTALLDEVINST,
4687 &r);
4688
4689 if (!NT_STATUS_IS_OK(status)) {
4690 return status;
4691 }
4692
4693 if (NT_STATUS_IS_ERR(status)) {
4694 return status;
4695 }
4696
4697 /* Return variables */
4698
4699 /* Return result */
4700 if (werror) {
4701 *werror = r.out.result;
4702 }
4703
4704 return werror_to_ntstatus(r.out.result);
4705 }
4706
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);
4712 };
4713
4714 static void rpccli_PNP_AddID_done(struct tevent_req *subreq);
4715
4716 struct tevent_req *rpccli_PNP_AddID_send(TALLOC_CTX *mem_ctx,
4717 struct tevent_context *ev,
4718 struct rpc_pipe_client *cli)
4719 {
4720 struct tevent_req *req;
4721 struct rpccli_PNP_AddID_state *state;
4722 struct tevent_req *subreq;
4723
4724 req = tevent_req_create(mem_ctx, &state,
4725 struct rpccli_PNP_AddID_state);
4726 if (req == NULL) {
4727 return NULL;
4728 }
4729 state->out_mem_ctx = NULL;
4730 state->dispatch_recv = cli->dispatch_recv;
4731
4732 /* In parameters */
4733
4734 /* Out parameters */
4735
4736 /* Result */
4737 ZERO_STRUCT(state->orig.out.result);
4738
4739 /* make a temporary copy, that we pass to the dispatch function */
4740 state->tmp = state->orig;
4741
4742 subreq = cli->dispatch_send(state, ev, cli,
4743 &ndr_table_ntsvcs,
4744 NDR_PNP_ADDID,
4745 &state->tmp);
4746 if (tevent_req_nomem(subreq, req)) {
4747 return tevent_req_post(req, ev);
4748 }
4749 tevent_req_set_callback(subreq, rpccli_PNP_AddID_done, req);
4750 return req;
4751 }
4752
4753 static void rpccli_PNP_AddID_done(struct tevent_req *subreq)
4754 {
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);
4759 NTSTATUS status;
4760 TALLOC_CTX *mem_ctx;
4761
4762 if (state->out_mem_ctx) {
4763 mem_ctx = state->out_mem_ctx;
4764 } else {
4765 mem_ctx = state;
4766 }
4767
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);
4772 return;
4773 }
4774
4775 /* Copy out parameters */
4776
4777 /* Copy result */
4778 state->orig.out.result = state->tmp.out.result;
4779
4780 /* Reset temporary structure */
4781 ZERO_STRUCT(state->tmp);
4782
4783 tevent_req_done(req);
4784 }
4785
4786 NTSTATUS rpccli_PNP_AddID_recv(struct tevent_req *req,
4787 TALLOC_CTX *mem_ctx,
4788 WERROR *result)
4789 {
4790 struct rpccli_PNP_AddID_state *state = tevent_req_data(
4791 req, struct rpccli_PNP_AddID_state);
4792 NTSTATUS status;
4793
4794 if (tevent_req_is_nterror(req, &status)) {
4795 tevent_req_received(req);
4796 return status;
4797 }
4798
4799 /* Steal possbile out parameters to the callers context */
4800 talloc_steal(mem_ctx, state->out_mem_ctx);
4801
4802 /* Return result */
4803 *result = state->orig.out.result;
4804
4805 tevent_req_received(req);
4806 return NT_STATUS_OK;
4807 }
4808
4809 NTSTATUS rpccli_PNP_AddID(struct rpc_pipe_client *cli,
4810 TALLOC_CTX *mem_ctx,
4811 WERROR *werror)
4812 {
4813 struct PNP_AddID r;
4814 NTSTATUS status;
4815
4816 /* In parameters */
4817
4818 status = cli->dispatch(cli,
4819 mem_ctx,
4820 &ndr_table_ntsvcs,
4821 NDR_PNP_ADDID,
4822 &r);
4823
4824 if (!NT_STATUS_IS_OK(status)) {
4825 return status;
4826 }
4827
4828 if (NT_STATUS_IS_ERR(status)) {
4829 return status;
4830 }
4831
4832 /* Return variables */
4833
4834 /* Return result */
4835 if (werror) {
4836 *werror = r.out.result;
4837 }
4838
4839 return werror_to_ntstatus(r.out.result);
4840 }
4841
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);
4847 };
4848
4849 static void rpccli_PNP_RegisterDriver_done(struct tevent_req *subreq);
4850
4851 struct tevent_req *rpccli_PNP_RegisterDriver_send(TALLOC_CTX *mem_ctx,
4852 struct tevent_context *ev,
4853 struct rpc_pipe_client *cli)
4854 {
4855 struct tevent_req *req;
4856 struct rpccli_PNP_RegisterDriver_state *state;
4857 struct tevent_req *subreq;
4858
4859 req = tevent_req_create(mem_ctx, &state,
4860 struct rpccli_PNP_RegisterDriver_state);
4861 if (req == NULL) {
4862 return NULL;
4863 }
4864 state->out_mem_ctx = NULL;
4865 state->dispatch_recv = cli->dispatch_recv;
4866
4867 /* In parameters */
4868
4869 /* Out parameters */
4870
4871 /* Result */
4872 ZERO_STRUCT(state->orig.out.result);
4873
4874 /* make a temporary copy, that we pass to the dispatch function */
4875 state->tmp = state->orig;
4876
4877 subreq = cli->dispatch_send(state, ev, cli,
4878 &ndr_table_ntsvcs,
4879 NDR_PNP_REGISTERDRIVER,
4880 &state->tmp);
4881 if (tevent_req_nomem(subreq, req)) {
4882 return tevent_req_post(req, ev);
4883 }
4884 tevent_req_set_callback(subreq, rpccli_PNP_RegisterDriver_done, req);
4885 return req;
4886 }
4887
4888 static void rpccli_PNP_RegisterDriver_done(struct tevent_req *subreq)
4889 {
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);
4894 NTSTATUS status;
4895 TALLOC_CTX *mem_ctx;
4896
4897 if (state->out_mem_ctx) {
4898 mem_ctx = state->out_mem_ctx;
4899 } else {
4900 mem_ctx = state;
4901 }
4902
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);
4907 return;
4908 }
4909
4910 /* Copy out parameters */
4911
4912 /* Copy result */
4913 state->orig.out.result = state->tmp.out.result;
4914
4915 /* Reset temporary structure */
4916 ZERO_STRUCT(state->tmp);
4917
4918 tevent_req_done(req);
4919 }
4920
4921 NTSTATUS rpccli_PNP_RegisterDriver_recv(struct tevent_req *req,
4922 TALLOC_CTX *mem_ctx,
4923 WERROR *result)
4924 {
4925 struct rpccli_PNP_RegisterDriver_state *state = tevent_req_data(
4926 req, struct rpccli_PNP_RegisterDriver_state);
4927 NTSTATUS status;
4928
4929 if (tevent_req_is_nterror(req, &status)) {
4930 tevent_req_received(req);
4931 return status;
4932 }
4933
4934 /* Steal possbile out parameters to the callers context */
4935 talloc_steal(mem_ctx, state->out_mem_ctx);
4936
4937 /* Return result */
4938 *result = state->orig.out.result;
4939
4940 tevent_req_received(req);
4941 return NT_STATUS_OK;
4942 }
4943
4944 NTSTATUS rpccli_PNP_RegisterDriver(struct rpc_pipe_client *cli,
4945 TALLOC_CTX *mem_ctx,
4946 WERROR *werror)
4947 {
4948 struct PNP_RegisterDriver r;
4949 NTSTATUS status;
4950
4951 /* In parameters */
4952
4953 status = cli->dispatch(cli,
4954 mem_ctx,
4955 &ndr_table_ntsvcs,
4956 NDR_PNP_REGISTERDRIVER,
4957 &r);
4958
4959 if (!NT_STATUS_IS_OK(status)) {
4960 return status;
4961 }
4962
4963 if (NT_STATUS_IS_ERR(status)) {
4964 return status;
4965 }
4966
4967 /* Return variables */
4968
4969 /* Return result */
4970 if (werror) {
4971 *werror = r.out.result;
4972 }
4973
4974 return werror_to_ntstatus(r.out.result);
4975 }
4976
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);
4982 };
4983
4984 static void rpccli_PNP_QueryRemove_done(struct tevent_req *subreq);
4985
4986 struct tevent_req *rpccli_PNP_QueryRemove_send(TALLOC_CTX *mem_ctx,
4987 struct tevent_context *ev,
4988 struct rpc_pipe_client *cli)
4989 {
4990 struct tevent_req *req;
4991 struct rpccli_PNP_QueryRemove_state *state;
4992 struct tevent_req *subreq;
4993
4994 req = tevent_req_create(mem_ctx, &state,
4995 struct rpccli_PNP_QueryRemove_state);
4996 if (req == NULL) {
4997 return NULL;
4998 }
4999 state->out_mem_ctx = NULL;
5000 state->dispatch_recv = cli->dispatch_recv;
5001
5002 /* In parameters */
5003
5004 /* Out parameters */
5005
5006 /* Result */
5007 ZERO_STRUCT(state->orig.out.result);
5008
5009 /* make a temporary copy, that we pass to the dispatch function */
5010 state->tmp = state->orig;
5011
5012 subreq = cli->dispatch_send(state, ev, cli,
5013 &ndr_table_ntsvcs,
5014 NDR_PNP_QUERYREMOVE,
5015 &state->tmp);
5016 if (tevent_req_nomem(subreq, req)) {
5017 return tevent_req_post(req, ev);
5018 }
5019 tevent_req_set_callback(subreq, rpccli_PNP_QueryRemove_done, req);
5020 return req;
5021 }
5022
5023 static void rpccli_PNP_QueryRemove_done(struct tevent_req *subreq)
5024 {
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);
5029 NTSTATUS status;
5030 TALLOC_CTX *mem_ctx;
5031
5032 if (state->out_mem_ctx) {
5033 mem_ctx = state->out_mem_ctx;
5034 } else {
5035 mem_ctx = state;
5036 }
5037
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);
5042 return;
5043 }
5044
5045 /* Copy out parameters */
5046
5047 /* Copy result */
5048 state->orig.out.result = state->tmp.out.result;
5049
5050 /* Reset temporary structure */
5051 ZERO_STRUCT(state->tmp);
5052
5053 tevent_req_done(req);
5054 }
5055
5056 NTSTATUS rpccli_PNP_QueryRemove_recv(struct tevent_req *req,
5057 TALLOC_CTX *mem_ctx,
5058 WERROR *result)
5059 {
5060 struct rpccli_PNP_QueryRemove_state *state = tevent_req_data(
5061 req, struct rpccli_PNP_QueryRemove_state);
5062 NTSTATUS status;
5063
5064 if (tevent_req_is_nterror(req, &status)) {
5065 tevent_req_received(req);
5066 return status;
5067 }
5068
5069 /* Steal possbile out parameters to the callers context */
5070 talloc_steal(mem_ctx, state->out_mem_ctx);
5071
5072 /* Return result */
5073 *result = state->orig.out.result;
5074
5075 tevent_req_received(req);
5076 return NT_STATUS_OK;
5077 }
5078
5079 NTSTATUS rpccli_PNP_QueryRemove(struct rpc_pipe_client *cli,
5080 TALLOC_CTX *mem_ctx,
5081 WERROR *werror)
5082 {
5083 struct PNP_QueryRemove r;
5084 NTSTATUS status;
5085
5086 /* In parameters */
5087
5088 status = cli->dispatch(cli,
5089 mem_ctx,
5090 &ndr_table_ntsvcs,
5091 NDR_PNP_QUERYREMOVE,
5092 &r);
5093
5094 if (!NT_STATUS_IS_OK(status)) {
5095 return status;
5096 }
5097
5098 if (NT_STATUS_IS_ERR(status)) {
5099 return status;
5100 }
5101
5102 /* Return variables */
5103
5104 /* Return result */
5105 if (werror) {
5106 *werror = r.out.result;
5107 }
5108
5109 return werror_to_ntstatus(r.out.result);
5110 }
5111
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);
5117 };
5118
5119 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req *subreq);
5120
5121 struct tevent_req *rpccli_PNP_RequestDeviceEject_send(TALLOC_CTX *mem_ctx,
5122 struct tevent_context *ev,
5123 struct rpc_pipe_client *cli)
5124 {
5125 struct tevent_req *req;
5126 struct rpccli_PNP_RequestDeviceEject_state *state;
5127 struct tevent_req *subreq;
5128
5129 req = tevent_req_create(mem_ctx, &state,
5130 struct rpccli_PNP_RequestDeviceEject_state);
5131 if (req == NULL) {
5132 return NULL;
5133 }
5134 state->out_mem_ctx = NULL;
5135 state->dispatch_recv = cli->dispatch_recv;
5136
5137 /* In parameters */
5138
5139 /* Out parameters */
5140
5141 /* Result */
5142 ZERO_STRUCT(state->orig.out.result);
5143
5144 /* make a temporary copy, that we pass to the dispatch function */
5145 state->tmp = state->orig;
5146
5147 subreq = cli->dispatch_send(state, ev, cli,
5148 &ndr_table_ntsvcs,
5149 NDR_PNP_REQUESTDEVICEEJECT,
5150 &state->tmp);
5151 if (tevent_req_nomem(subreq, req)) {
5152 return tevent_req_post(req, ev);
5153 }
5154 tevent_req_set_callback(subreq, rpccli_PNP_RequestDeviceEject_done, req);
5155 return req;
5156 }
5157
5158 static void rpccli_PNP_RequestDeviceEject_done(struct tevent_req *subreq)
5159 {
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);
5164 NTSTATUS status;
5165 TALLOC_CTX *mem_ctx;
5166
5167 if (state->out_mem_ctx) {
5168 mem_ctx = state->out_mem_ctx;
5169 } else {
5170 mem_ctx = state;
5171 }
5172
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);
5177 return;
5178 }
5179
5180 /* Copy out parameters */
5181
5182 /* Copy result */
5183 state->orig.out.result = state->tmp.out.result;
5184
5185 /* Reset temporary structure */
5186 ZERO_STRUCT(state->tmp);
5187
5188 tevent_req_done(req);
5189 }
5190
5191 NTSTATUS rpccli_PNP_RequestDeviceEject_recv(struct tevent_req *req,
5192 TALLOC_CTX *mem_ctx,
5193 WERROR *result)
5194 {
5195 struct rpccli_PNP_RequestDeviceEject_state *state = tevent_req_data(
5196 req, struct rpccli_PNP_RequestDeviceEject_state);
5197 NTSTATUS status;
5198
5199 if (tevent_req_is_nterror(req, &status)) {
5200 tevent_req_received(req);
5201 return status;
5202 }
5203
5204 /* Steal possbile out parameters to the callers context */
5205 talloc_steal(mem_ctx, state->out_mem_ctx);
5206
5207 /* Return result */
5208 *result = state->orig.out.result;
5209
5210 tevent_req_received(req);
5211 return NT_STATUS_OK;
5212 }
5213
5214 NTSTATUS rpccli_PNP_RequestDeviceEject(struct rpc_pipe_client *cli,
5215 TALLOC_CTX *mem_ctx,
5216 WERROR *werror)
5217 {
5218 struct PNP_RequestDeviceEject r;
5219 NTSTATUS status;
5220
5221 /* In parameters */
5222
5223 status = cli->dispatch(cli,
5224 mem_ctx,
5225 &ndr_table_ntsvcs,
5226 NDR_PNP_REQUESTDEVICEEJECT,
5227 &r);
5228
5229 if (!NT_STATUS_IS_OK(status)) {
5230 return status;
5231 }
5232
5233 if (NT_STATUS_IS_ERR(status)) {
5234 return status;
5235 }
5236
5237 /* Return variables */
5238
5239 /* Return result */
5240 if (werror) {
5241 *werror = r.out.result;
5242 }
5243
5244 return werror_to_ntstatus(r.out.result);
5245 }
5246
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);
5252 };
5253
5254 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req *subreq);
5255
5256 struct tevent_req *rpccli_PNP_IsDockStationPresent_send(TALLOC_CTX *mem_ctx,
5257 struct tevent_context *ev,
5258 struct rpc_pipe_client *cli)
5259 {
5260 struct tevent_req *req;
5261 struct rpccli_PNP_IsDockStationPresent_state *state;
5262 struct tevent_req *subreq;
5263
5264 req = tevent_req_create(mem_ctx, &state,
5265 struct rpccli_PNP_IsDockStationPresent_state);
5266 if (req == NULL) {
5267 return NULL;
5268 }
5269 state->out_mem_ctx = NULL;
5270 state->dispatch_recv = cli->dispatch_recv;
5271
5272 /* In parameters */
5273
5274 /* Out parameters */
5275
5276 /* Result */
5277 ZERO_STRUCT(state->orig.out.result);
5278
5279 /* make a temporary copy, that we pass to the dispatch function */
5280 state->tmp = state->orig;
5281
5282 subreq = cli->dispatch_send(state, ev, cli,
5283 &ndr_table_ntsvcs,
5284 NDR_PNP_ISDOCKSTATIONPRESENT,
5285 &state->tmp);
5286 if (tevent_req_nomem(subreq, req)) {
5287 return tevent_req_post(req, ev);
5288 }
5289 tevent_req_set_callback(subreq, rpccli_PNP_IsDockStationPresent_done, req);
5290 return req;
5291 }
5292
5293 static void rpccli_PNP_IsDockStationPresent_done(struct tevent_req *subreq)
5294 {
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);
5299 NTSTATUS status;
5300 TALLOC_CTX *mem_ctx;
5301
5302 if (state->out_mem_ctx) {
5303 mem_ctx = state->out_mem_ctx;
5304 } else {
5305 mem_ctx = state;
5306 }
5307
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);
5312 return;
5313 }
5314
5315 /* Copy out parameters */
5316
5317 /* Copy result */
5318 state->orig.out.result = state->tmp.out.result;
5319
5320 /* Reset temporary structure */
5321 ZERO_STRUCT(state->tmp);
5322
5323 tevent_req_done(req);
5324 }
5325
5326 NTSTATUS rpccli_PNP_IsDockStationPresent_recv(struct tevent_req *req,
5327 TALLOC_CTX *mem_ctx,
5328 WERROR *result)
5329 {
5330 struct rpccli_PNP_IsDockStationPresent_state *state = tevent_req_data(
5331 req, struct rpccli_PNP_IsDockStationPresent_state);
5332 NTSTATUS status;
5333
5334 if (tevent_req_is_nterror(req, &status)) {
5335 tevent_req_received(req);
5336 return status;
5337 }
5338
5339 /* Steal possbile out parameters to the callers context */
5340 talloc_steal(mem_ctx, state->out_mem_ctx);
5341
5342 /* Return result */
5343 *result = state->orig.out.result;
5344
5345 tevent_req_received(req);
5346 return NT_STATUS_OK;
5347 }
5348
5349 NTSTATUS rpccli_PNP_IsDockStationPresent(struct rpc_pipe_client *cli,
5350 TALLOC_CTX *mem_ctx,
5351 WERROR *werror)
5352 {
5353 struct PNP_IsDockStationPresent r;
5354 NTSTATUS status;
5355
5356 /* In parameters */
5357
5358 status = cli->dispatch(cli,
5359 mem_ctx,
5360 &ndr_table_ntsvcs,
5361 NDR_PNP_ISDOCKSTATIONPRESENT,
5362 &r);
5363
5364 if (!NT_STATUS_IS_OK(status)) {
5365 return status;
5366 }
5367
5368 if (NT_STATUS_IS_ERR(status)) {
5369 return status;
5370 }
5371
5372 /* Return variables */
5373
5374 /* Return result */
5375 if (werror) {
5376 *werror = r.out.result;
5377 }
5378
5379 return werror_to_ntstatus(r.out.result);
5380 }
5381
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);
5387 };
5388
5389 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req *subreq);
5390
5391 struct tevent_req *rpccli_PNP_RequestEjectPC_send(TALLOC_CTX *mem_ctx,
5392 struct tevent_context *ev,
5393 struct rpc_pipe_client *cli)
5394 {
5395 struct tevent_req *req;
5396 struct rpccli_PNP_RequestEjectPC_state *state;
5397 struct tevent_req *subreq;
5398
5399 req = tevent_req_create(mem_ctx, &state,
5400 struct rpccli_PNP_RequestEjectPC_state);
5401 if (req == NULL) {
5402 return NULL;
5403 }
5404 state->out_mem_ctx = NULL;
5405 state->dispatch_recv = cli->dispatch_recv;
5406
5407 /* In parameters */
5408
5409 /* Out parameters */
5410
5411 /* Result */
5412 ZERO_STRUCT(state->orig.out.result);
5413
5414 /* make a temporary copy, that we pass to the dispatch function */
5415 state->tmp = state->orig;
5416
5417 subreq = cli->dispatch_send(state, ev, cli,
5418 &ndr_table_ntsvcs,
5419 NDR_PNP_REQUESTEJECTPC,
5420 &state->tmp);
5421 if (tevent_req_nomem(subreq, req)) {
5422 return tevent_req_post(req, ev);
5423 }
5424 tevent_req_set_callback(subreq, rpccli_PNP_RequestEjectPC_done, req);
5425 return req;
5426 }
5427
5428 static void rpccli_PNP_RequestEjectPC_done(struct tevent_req *subreq)
5429 {
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);
5434 NTSTATUS status;
5435 TALLOC_CTX *mem_ctx;
5436
5437 if (state->out_mem_ctx) {
5438 mem_ctx = state->out_mem_ctx;
5439 } else {
5440 mem_ctx = state;
5441 }
5442
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);
5447 return;
5448 }
5449
5450 /* Copy out parameters */
5451
5452 /* Copy result */
5453 state->orig.out.result = state->tmp.out.result;
5454
5455 /* Reset temporary structure */
5456 ZERO_STRUCT(state->tmp);
5457
5458 tevent_req_done(req);
5459 }
5460
5461 NTSTATUS rpccli_PNP_RequestEjectPC_recv(struct tevent_req *req,
5462 TALLOC_CTX *mem_ctx,
5463 WERROR *result)
5464 {
5465 struct rpccli_PNP_RequestEjectPC_state *state = tevent_req_data(
5466 req, struct rpccli_PNP_RequestEjectPC_state);
5467 NTSTATUS status;
5468
5469 if (tevent_req_is_nterror(req, &status)) {
5470 tevent_req_received(req);
5471 return status;
5472 }
5473
5474 /* Steal possbile out parameters to the callers context */
5475 talloc_steal(mem_ctx, state->out_mem_ctx);
5476
5477 /* Return result */
5478 *result = state->orig.out.result;
5479
5480 tevent_req_received(req);
5481 return NT_STATUS_OK;
5482 }
5483
5484 NTSTATUS rpccli_PNP_RequestEjectPC(struct rpc_pipe_client *cli,
5485 TALLOC_CTX *mem_ctx,
5486 WERROR *werror)
5487 {
5488 struct PNP_RequestEjectPC r;
5489 NTSTATUS status;
5490
5491 /* In parameters */
5492
5493 status = cli->dispatch(cli,
5494 mem_ctx,
5495 &ndr_table_ntsvcs,
5496 NDR_PNP_REQUESTEJECTPC,
5497 &r);
5498
5499 if (!NT_STATUS_IS_OK(status)) {
5500 return status;
5501 }
5502
5503 if (NT_STATUS_IS_ERR(status)) {
5504 return status;
5505 }
5506
5507 /* Return variables */
5508
5509 /* Return result */
5510 if (werror) {
5511 *werror = r.out.result;
5512 }
5513
5514 return werror_to_ntstatus(r.out.result);
5515 }
5516
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);
5522 };
5523
5524 static void rpccli_PNP_HwProfFlags_done(struct tevent_req *subreq);
5525
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] */)
5538 {
5539 struct tevent_req *req;
5540 struct rpccli_PNP_HwProfFlags_state *state;
5541 struct tevent_req *subreq;
5542
5543 req = tevent_req_create(mem_ctx, &state,
5544 struct rpccli_PNP_HwProfFlags_state);
5545 if (req == NULL) {
5546 return NULL;
5547 }
5548 state->out_mem_ctx = NULL;
5549 state->dispatch_recv = cli->dispatch_recv;
5550
5551 /* In parameters */
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;
5560
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;
5565
5566 /* Result */
5567 ZERO_STRUCT(state->orig.out.result);
5568
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);
5573 }
5574
5575 /* make a temporary copy, that we pass to the dispatch function */
5576 state->tmp = state->orig;
5577
5578 subreq = cli->dispatch_send(state, ev, cli,
5579 &ndr_table_ntsvcs,
5580 NDR_PNP_HWPROFFLAGS,
5581 &state->tmp);
5582 if (tevent_req_nomem(subreq, req)) {
5583 return tevent_req_post(req, ev);
5584 }
5585 tevent_req_set_callback(subreq, rpccli_PNP_HwProfFlags_done, req);
5586 return req;
5587 }
5588
5589 static void rpccli_PNP_HwProfFlags_done(struct tevent_req *subreq)
5590 {
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);
5595 NTSTATUS status;
5596 TALLOC_CTX *mem_ctx;
5597
5598 if (state->out_mem_ctx) {
5599 mem_ctx = state->out_mem_ctx;
5600 } else {
5601 mem_ctx = state;
5602 }
5603
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);
5608 return;
5609 }
5610
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;
5615 }
5616 if (state->orig.out.unknown5a && state->tmp.out.unknown5a) {
5617 *state->orig.out.unknown5a = *state->tmp.out.unknown5a;
5618 }
5619
5620 /* Copy result */
5621 state->orig.out.result = state->tmp.out.result;
5622
5623 /* Reset temporary structure */
5624 ZERO_STRUCT(state->tmp);
5625
5626 tevent_req_done(req);
5627 }
5628
5629 NTSTATUS rpccli_PNP_HwProfFlags_recv(struct tevent_req *req,
5630 TALLOC_CTX *mem_ctx,
5631 WERROR *result)
5632 {
5633 struct rpccli_PNP_HwProfFlags_state *state = tevent_req_data(
5634 req, struct rpccli_PNP_HwProfFlags_state);
5635 NTSTATUS status;
5636
5637 if (tevent_req_is_nterror(req, &status)) {
5638 tevent_req_received(req);
5639 return status;
5640 }
5641
5642 /* Steal possbile out parameters to the callers context */
5643 talloc_steal(mem_ctx, state->out_mem_ctx);
5644
5645 /* Return result */
5646 *result = state->orig.out.result;
5647
5648 tevent_req_received(req);
5649 return NT_STATUS_OK;
5650 }
5651
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] */,
5663 WERROR *werror)
5664 {
5665 struct PNP_HwProfFlags r;
5666 NTSTATUS status;
5667
5668 /* In parameters */
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;
5676 r.in.flags = flags;
5677
5678 status = cli->dispatch(cli,
5679 mem_ctx,
5680 &ndr_table_ntsvcs,
5681 NDR_PNP_HWPROFFLAGS,
5682 &r);
5683
5684 if (!NT_STATUS_IS_OK(status)) {
5685 return status;
5686 }
5687
5688 if (NT_STATUS_IS_ERR(status)) {
5689 return status;
5690 }
5691
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;
5696 }
5697 if (unknown5a && r.out.unknown5a) {
5698 *unknown5a = *r.out.unknown5a;
5699 }
5700
5701 /* Return result */
5702 if (werror) {
5703 *werror = r.out.result;
5704 }
5705
5706 return werror_to_ntstatus(r.out.result);
5707 }
5708
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);
5714 };
5715
5716 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req *subreq);
5717
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] */)
5725 {
5726 struct tevent_req *req;
5727 struct rpccli_PNP_GetHwProfInfo_state *state;
5728 struct tevent_req *subreq;
5729
5730 req = tevent_req_create(mem_ctx, &state,
5731 struct rpccli_PNP_GetHwProfInfo_state);
5732 if (req == NULL) {
5733 return NULL;
5734 }
5735 state->out_mem_ctx = NULL;
5736 state->dispatch_recv = cli->dispatch_recv;
5737
5738 /* In parameters */
5739 state->orig.in.idx = _idx;
5740 state->orig.in.info = _info;
5741 state->orig.in.size = _size;
5742 state->orig.in.flags = _flags;
5743
5744 /* Out parameters */
5745 state->orig.out.info = _info;
5746
5747 /* Result */
5748 ZERO_STRUCT(state->orig.out.result);
5749
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);
5754 }
5755
5756 /* make a temporary copy, that we pass to the dispatch function */
5757 state->tmp = state->orig;
5758
5759 subreq = cli->dispatch_send(state, ev, cli,
5760 &ndr_table_ntsvcs,
5761 NDR_PNP_GETHWPROFINFO,
5762 &state->tmp);
5763 if (tevent_req_nomem(subreq, req)) {
5764 return tevent_req_post(req, ev);
5765 }
5766 tevent_req_set_callback(subreq, rpccli_PNP_GetHwProfInfo_done, req);
5767 return req;
5768 }
5769
5770 static void rpccli_PNP_GetHwProfInfo_done(struct tevent_req *subreq)
5771 {
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);
5776 NTSTATUS status;
5777 TALLOC_CTX *mem_ctx;
5778
5779 if (state->out_mem_ctx) {
5780 mem_ctx = state->out_mem_ctx;
5781 } else {
5782 mem_ctx = state;
5783 }
5784
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);
5789 return;
5790 }
5791
5792 /* Copy out parameters */
5793 *state->orig.out.info = *state->tmp.out.info;
5794
5795 /* Copy result */
5796 state->orig.out.result = state->tmp.out.result;
5797
5798 /* Reset temporary structure */
5799 ZERO_STRUCT(state->tmp);
5800
5801 tevent_req_done(req);
5802 }
5803
5804 NTSTATUS rpccli_PNP_GetHwProfInfo_recv(struct tevent_req *req,
5805 TALLOC_CTX *mem_ctx,
5806 WERROR *result)
5807 {
5808 struct rpccli_PNP_GetHwProfInfo_state *state = tevent_req_data(
5809 req, struct rpccli_PNP_GetHwProfInfo_state);
5810 NTSTATUS status;
5811
5812 if (tevent_req_is_nterror(req, &status)) {
5813 tevent_req_received(req);
5814 return status;
5815 }
5816
5817 /* Steal possbile out parameters to the callers context */
5818 talloc_steal(mem_ctx, state->out_mem_ctx);
5819
5820 /* Return result */
5821 *result = state->orig.out.result;
5822
5823 tevent_req_received(req);
5824 return NT_STATUS_OK;
5825 }
5826
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] */,
5833 WERROR *werror)
5834 {
5835 struct PNP_GetHwProfInfo r;
5836 NTSTATUS status;
5837
5838 /* In parameters */
5839 r.in.idx = idx;
5840 r.in.info = info;
5841 r.in.size = size;
5842 r.in.flags = flags;
5843
5844 status = cli->dispatch(cli,
5845 mem_ctx,
5846 &ndr_table_ntsvcs,
5847 NDR_PNP_GETHWPROFINFO,
5848 &r);
5849
5850 if (!NT_STATUS_IS_OK(status)) {
5851 return status;
5852 }
5853
5854 if (NT_STATUS_IS_ERR(status)) {
5855 return status;
5856 }
5857
5858 /* Return variables */
5859 *info = *r.out.info;
5860
5861 /* Return result */
5862 if (werror) {
5863 *werror = r.out.result;
5864 }
5865
5866 return werror_to_ntstatus(r.out.result);
5867 }
5868
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);
5874 };
5875
5876 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req *subreq);
5877
5878 struct tevent_req *rpccli_PNP_AddEmptyLogConf_send(TALLOC_CTX *mem_ctx,
5879 struct tevent_context *ev,
5880 struct rpc_pipe_client *cli)
5881 {
5882 struct tevent_req *req;
5883 struct rpccli_PNP_AddEmptyLogConf_state *state;
5884 struct tevent_req *subreq;
5885
5886 req = tevent_req_create(mem_ctx, &state,
5887 struct rpccli_PNP_AddEmptyLogConf_state);
5888 if (req == NULL) {
5889 return NULL;
5890 }
5891 state->out_mem_ctx = NULL;
5892 state->dispatch_recv = cli->dispatch_recv;
5893
5894 /* In parameters */
5895
5896 /* Out parameters */
5897
5898 /* Result */
5899 ZERO_STRUCT(state->orig.out.result);
5900
5901 /* make a temporary copy, that we pass to the dispatch function */
5902 state->tmp = state->orig;
5903
5904 subreq = cli->dispatch_send(state, ev, cli,
5905 &ndr_table_ntsvcs,
5906 NDR_PNP_ADDEMPTYLOGCONF,
5907 &state->tmp);
5908 if (tevent_req_nomem(subreq, req)) {
5909 return tevent_req_post(req, ev);
5910 }
5911 tevent_req_set_callback(subreq, rpccli_PNP_AddEmptyLogConf_done, req);
5912 return req;
5913 }
5914
5915 static void rpccli_PNP_AddEmptyLogConf_done(struct tevent_req *subreq)
5916 {
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);
5921 NTSTATUS status;
5922 TALLOC_CTX *mem_ctx;
5923
5924 if (state->out_mem_ctx) {
5925 mem_ctx = state->out_mem_ctx;
5926 } else {
5927 mem_ctx = state;
5928 }
5929
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);
5934 return;
5935 }
5936
5937 /* Copy out parameters */
5938
5939 /* Copy result */
5940 state->orig.out.result = state->tmp.out.result;
5941
5942 /* Reset temporary structure */
5943 ZERO_STRUCT(state->tmp);
5944
5945 tevent_req_done(req);
5946 }
5947
5948 NTSTATUS rpccli_PNP_AddEmptyLogConf_recv(struct tevent_req *req,
5949 TALLOC_CTX *mem_ctx,
5950 WERROR *result)
5951 {
5952 struct rpccli_PNP_AddEmptyLogConf_state *state = tevent_req_data(
5953 req, struct rpccli_PNP_AddEmptyLogConf_state);
5954 NTSTATUS status;
5955
5956 if (tevent_req_is_nterror(req, &status)) {
5957 tevent_req_received(req);
5958 return status;
5959 }
5960
5961 /* Steal possbile out parameters to the callers context */
5962 talloc_steal(mem_ctx, state->out_mem_ctx);
5963
5964 /* Return result */
5965 *result = state->orig.out.result;
5966
5967 tevent_req_received(req);
5968 return NT_STATUS_OK;
5969 }
5970
5971 NTSTATUS rpccli_PNP_AddEmptyLogConf(struct rpc_pipe_client *cli,
5972 TALLOC_CTX *mem_ctx,
5973 WERROR *werror)
5974 {
5975 struct PNP_AddEmptyLogConf r;
5976 NTSTATUS status;
5977
5978 /* In parameters */
5979
5980 status = cli->dispatch(cli,
5981 mem_ctx,
5982 &ndr_table_ntsvcs,
5983 NDR_PNP_ADDEMPTYLOGCONF,
5984 &r);
5985
5986 if (!NT_STATUS_IS_OK(status)) {
5987 return status;
5988 }
5989
5990 if (NT_STATUS_IS_ERR(status)) {
5991 return status;
5992 }
5993
5994 /* Return variables */
5995
5996 /* Return result */
5997 if (werror) {
5998 *werror = r.out.result;
5999 }
6000
6001 return werror_to_ntstatus(r.out.result);
6002 }
6003
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);
6009 };
6010
6011 static void rpccli_PNP_FreeLogConf_done(struct tevent_req *subreq);
6012
6013 struct tevent_req *rpccli_PNP_FreeLogConf_send(TALLOC_CTX *mem_ctx,
6014 struct tevent_context *ev,
6015 struct rpc_pipe_client *cli)
6016 {
6017 struct tevent_req *req;
6018 struct rpccli_PNP_FreeLogConf_state *state;
6019 struct tevent_req *subreq;
6020
6021 req = tevent_req_create(mem_ctx, &state,
6022 struct rpccli_PNP_FreeLogConf_state);
6023 if (req == NULL) {
6024 return NULL;
6025 }
6026 state->out_mem_ctx = NULL;
6027 state->dispatch_recv = cli->dispatch_recv;
6028
6029 /* In parameters */
6030
6031 /* Out parameters */
6032
6033 /* Result */
6034 ZERO_STRUCT(state->orig.out.result);
6035
6036 /* make a temporary copy, that we pass to the dispatch function */
6037 state->tmp = state->orig;
6038
6039 subreq = cli->dispatch_send(state, ev, cli,
6040 &ndr_table_ntsvcs,
6041 NDR_PNP_FREELOGCONF,
6042 &state->tmp);
6043 if (tevent_req_nomem(subreq, req)) {
6044 return tevent_req_post(req, ev);
6045 }
6046 tevent_req_set_callback(subreq, rpccli_PNP_FreeLogConf_done, req);
6047 return req;
6048 }
6049
6050 static void rpccli_PNP_FreeLogConf_done(struct tevent_req *subreq)
6051 {
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);
6056 NTSTATUS status;
6057 TALLOC_CTX *mem_ctx;
6058
6059 if (state->out_mem_ctx) {
6060 mem_ctx = state->out_mem_ctx;
6061 } else {
6062 mem_ctx = state;
6063 }
6064
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);
6069 return;
6070 }
6071
6072 /* Copy out parameters */
6073
6074 /* Copy result */
6075 state->orig.out.result = state->tmp.out.result;
6076
6077 /* Reset temporary structure */
6078 ZERO_STRUCT(state->tmp);
6079
6080 tevent_req_done(req);
6081 }
6082
6083 NTSTATUS rpccli_PNP_FreeLogConf_recv(struct tevent_req *req,
6084 TALLOC_CTX *mem_ctx,
6085 WERROR *result)
6086 {
6087 struct rpccli_PNP_FreeLogConf_state *state = tevent_req_data(
6088 req, struct rpccli_PNP_FreeLogConf_state);
6089 NTSTATUS status;
6090
6091 if (tevent_req_is_nterror(req, &status)) {
6092 tevent_req_received(req);
6093 return status;
6094 }
6095
6096 /* Steal possbile out parameters to the callers context */
6097 talloc_steal(mem_ctx, state->out_mem_ctx);
6098
6099 /* Return result */
6100 *result = state->orig.out.result;
6101
6102 tevent_req_received(req);
6103 return NT_STATUS_OK;
6104 }
6105
6106 NTSTATUS rpccli_PNP_FreeLogConf(struct rpc_pipe_client *cli,
6107 TALLOC_CTX *mem_ctx,
6108 WERROR *werror)
6109 {
6110 struct PNP_FreeLogConf r;
6111 NTSTATUS status;
6112
6113 /* In parameters */
6114
6115 status = cli->dispatch(cli,
6116 mem_ctx,
6117 &ndr_table_ntsvcs,
6118 NDR_PNP_FREELOGCONF,
6119 &r);
6120
6121 if (!NT_STATUS_IS_OK(status)) {
6122 return status;
6123 }
6124
6125 if (NT_STATUS_IS_ERR(status)) {
6126 return status;
6127 }
6128
6129 /* Return variables */
6130
6131 /* Return result */
6132 if (werror) {
6133 *werror = r.out.result;
6134 }
6135
6136 return werror_to_ntstatus(r.out.result);
6137 }
6138
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);
6144 };
6145
6146 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req *subreq);
6147
6148 struct tevent_req *rpccli_PNP_GetFirstLogConf_send(TALLOC_CTX *mem_ctx,
6149 struct tevent_context *ev,
6150 struct rpc_pipe_client *cli)
6151 {
6152 struct tevent_req *req;
6153 struct rpccli_PNP_GetFirstLogConf_state *state;
6154 struct tevent_req *subreq;
6155
6156 req = tevent_req_create(mem_ctx, &state,
6157 struct rpccli_PNP_GetFirstLogConf_state);
6158 if (req == NULL) {
6159 return NULL;
6160 }
6161 state->out_mem_ctx = NULL;
6162 state->dispatch_recv = cli->dispatch_recv;
6163
6164 /* In parameters */
6165
6166 /* Out parameters */
6167
6168 /* Result */
6169 ZERO_STRUCT(state->orig.out.result);
6170
6171 /* make a temporary copy, that we pass to the dispatch function */
6172 state->tmp = state->orig;
6173
6174 subreq = cli->dispatch_send(state, ev, cli,
6175 &ndr_table_ntsvcs,
6176 NDR_PNP_GETFIRSTLOGCONF,
6177 &state->tmp);
6178 if (tevent_req_nomem(subreq, req)) {
6179 return tevent_req_post(req, ev);
6180 }
6181 tevent_req_set_callback(subreq, rpccli_PNP_GetFirstLogConf_done, req);
6182 return req;
6183 }
6184
6185 static void rpccli_PNP_GetFirstLogConf_done(struct tevent_req *subreq)
6186 {
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);
6191 NTSTATUS status;
6192 TALLOC_CTX *mem_ctx;
6193
6194 if (state->out_mem_ctx) {
6195 mem_ctx = state->out_mem_ctx;
6196 } else {
6197 mem_ctx = state;
6198 }
6199
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);
6204 return;
6205 }
6206
6207 /* Copy out parameters */
6208
6209 /* Copy result */
6210 state->orig.out.result = state->tmp.out.result;
6211
6212 /* Reset temporary structure */
6213 ZERO_STRUCT(state->tmp);
6214
6215 tevent_req_done(req);
6216 }
6217
6218 NTSTATUS rpccli_PNP_GetFirstLogConf_recv(struct tevent_req *req,
6219 TALLOC_CTX *mem_ctx,
6220 WERROR *result)
6221 {
6222 struct rpccli_PNP_GetFirstLogConf_state *state = tevent_req_data(
6223 req, struct rpccli_PNP_GetFirstLogConf_state);
6224 NTSTATUS status;
6225
6226 if (tevent_req_is_nterror(req, &status)) {
6227 tevent_req_received(req);
6228 return status;
6229 }
6230
6231 /* Steal possbile out parameters to the callers context */
6232 talloc_steal(mem_ctx, state->out_mem_ctx);
6233
6234 /* Return result */
6235 *result = state->orig.out.result;
6236
6237 tevent_req_received(req);
6238 return NT_STATUS_OK;
6239 }
6240
6241 NTSTATUS rpccli_PNP_GetFirstLogConf(struct rpc_pipe_client *cli,
6242 TALLOC_CTX *mem_ctx,
6243 WERROR *werror)
6244 {
6245 struct PNP_GetFirstLogConf r;
6246 NTSTATUS status;
6247
6248 /* In parameters */
6249
6250 status = cli->dispatch(cli,
6251 mem_ctx,
6252 &ndr_table_ntsvcs,
6253 NDR_PNP_GETFIRSTLOGCONF,
6254 &r);
6255
6256 if (!NT_STATUS_IS_OK(status)) {
6257 return status;
6258 }
6259
6260 if (NT_STATUS_IS_ERR(status)) {
6261 return status;
6262 }
6263
6264 /* Return variables */
6265
6266 /* Return result */
6267 if (werror) {
6268 *werror = r.out.result;
6269 }
6270
6271 return werror_to_ntstatus(r.out.result);
6272 }
6273
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);
6279 };
6280
6281 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req *subreq);
6282
6283 struct tevent_req *rpccli_PNP_GetNextLogConf_send(TALLOC_CTX *mem_ctx,
6284 struct tevent_context *ev,
6285 struct rpc_pipe_client *cli)
6286 {
6287 struct tevent_req *req;
6288 struct rpccli_PNP_GetNextLogConf_state *state;
6289 struct tevent_req *subreq;
6290
6291 req = tevent_req_create(mem_ctx, &state,
6292 struct rpccli_PNP_GetNextLogConf_state);
6293 if (req == NULL) {
6294 return NULL;
6295 }
6296 state->out_mem_ctx = NULL;
6297 state->dispatch_recv = cli->dispatch_recv;
6298
6299 /* In parameters */
6300
6301 /* Out parameters */
6302
6303 /* Result */
6304 ZERO_STRUCT(state->orig.out.result);
6305
6306 /* make a temporary copy, that we pass to the dispatch function */
6307 state->tmp = state->orig;
6308
6309 subreq = cli->dispatch_send(state, ev, cli,
6310 &ndr_table_ntsvcs,
6311 NDR_PNP_GETNEXTLOGCONF,
6312 &state->tmp);
6313 if (tevent_req_nomem(subreq, req)) {
6314 return tevent_req_post(req, ev);
6315 }
6316 tevent_req_set_callback(subreq, rpccli_PNP_GetNextLogConf_done, req);
6317 return req;
6318 }
6319
6320 static void rpccli_PNP_GetNextLogConf_done(struct tevent_req *subreq)
6321 {
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);
6326 NTSTATUS status;
6327 TALLOC_CTX *mem_ctx;
6328
6329 if (state->out_mem_ctx) {
6330 mem_ctx = state->out_mem_ctx;
6331 } else {
6332 mem_ctx = state;
6333 }
6334
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);
6339 return;
6340 }
6341
6342 /* Copy out parameters */
6343
6344 /* Copy result */
6345 state->orig.out.result = state->tmp.out.result;
6346
6347 /* Reset temporary structure */
6348 ZERO_STRUCT(state->tmp);
6349
6350 tevent_req_done(req);
6351 }
6352
6353 NTSTATUS rpccli_PNP_GetNextLogConf_recv(struct tevent_req *req,
6354 TALLOC_CTX *mem_ctx,
6355 WERROR *result)
6356 {
6357 struct rpccli_PNP_GetNextLogConf_state *state = tevent_req_data(
6358 req, struct rpccli_PNP_GetNextLogConf_state);
6359 NTSTATUS status;
6360
6361 if (tevent_req_is_nterror(req, &status)) {
6362 tevent_req_received(req);
6363 return status;
6364 }
6365
6366 /* Steal possbile out parameters to the callers context */
6367 talloc_steal(mem_ctx, state->out_mem_ctx);
6368
6369 /* Return result */
6370 *result = state->orig.out.result;
6371
6372 tevent_req_received(req);
6373 return NT_STATUS_OK;
6374 }
6375
6376 NTSTATUS rpccli_PNP_GetNextLogConf(struct rpc_pipe_client *cli,
6377 TALLOC_CTX *mem_ctx,
6378 WERROR *werror)
6379 {
6380 struct PNP_GetNextLogConf r;
6381 NTSTATUS status;
6382
6383 /* In parameters */
6384
6385 status = cli->dispatch(cli,
6386 mem_ctx,
6387 &ndr_table_ntsvcs,
6388 NDR_PNP_GETNEXTLOGCONF,
6389 &r);
6390
6391 if (!NT_STATUS_IS_OK(status)) {
6392 return status;
6393 }
6394
6395 if (NT_STATUS_IS_ERR(status)) {
6396 return status;
6397 }
6398
6399 /* Return variables */
6400
6401 /* Return result */
6402 if (werror) {
6403 *werror = r.out.result;
6404 }
6405
6406 return werror_to_ntstatus(r.out.result);
6407 }
6408
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);
6414 };
6415
6416 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req *subreq);
6417
6418 struct tevent_req *rpccli_PNP_GetLogConfPriority_send(TALLOC_CTX *mem_ctx,
6419 struct tevent_context *ev,
6420 struct rpc_pipe_client *cli)
6421 {
6422 struct tevent_req *req;
6423 struct rpccli_PNP_GetLogConfPriority_state *state;
6424 struct tevent_req *subreq;
6425
6426 req = tevent_req_create(mem_ctx, &state,
6427 struct rpccli_PNP_GetLogConfPriority_state);
6428 if (req == NULL) {
6429 return NULL;
6430 }
6431 state->out_mem_ctx = NULL;
6432 state->dispatch_recv = cli->dispatch_recv;
6433
6434 /* In parameters */
6435
6436 /* Out parameters */
6437
6438 /* Result */
6439 ZERO_STRUCT(state->orig.out.result);
6440
6441 /* make a temporary copy, that we pass to the dispatch function */
6442 state->tmp = state->orig;
6443
6444 subreq = cli->dispatch_send(state, ev, cli,
6445 &ndr_table_ntsvcs,
6446 NDR_PNP_GETLOGCONFPRIORITY,
6447 &state->tmp);
6448 if (tevent_req_nomem(subreq, req)) {
6449 return tevent_req_post(req, ev);
6450 }
6451 tevent_req_set_callback(subreq, rpccli_PNP_GetLogConfPriority_done, req);
6452 return req;
6453 }
6454
6455 static void rpccli_PNP_GetLogConfPriority_done(struct tevent_req *subreq)
6456 {
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);
6461 NTSTATUS status;
6462 TALLOC_CTX *mem_ctx;
6463
6464 if (state->out_mem_ctx) {
6465 mem_ctx = state->out_mem_ctx;
6466 } else {
6467 mem_ctx = state;
6468 }
6469
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);
6474 return;
6475 }
6476
6477 /* Copy out parameters */
6478
6479 /* Copy result */
6480 state->orig.out.result = state->tmp.out.result;
6481
6482 /* Reset temporary structure */
6483 ZERO_STRUCT(state->tmp);
6484
6485 tevent_req_done(req);
6486 }
6487
6488 NTSTATUS rpccli_PNP_GetLogConfPriority_recv(struct tevent_req *req,
6489 TALLOC_CTX *mem_ctx,
6490 WERROR *result)
6491 {
6492 struct rpccli_PNP_GetLogConfPriority_state *state = tevent_req_data(
6493 req, struct rpccli_PNP_GetLogConfPriority_state);
6494 NTSTATUS status;
6495
6496 if (tevent_req_is_nterror(req, &status)) {
6497 tevent_req_received(req);
6498 return status;
6499 }
6500
6501 /* Steal possbile out parameters to the callers context */
6502 talloc_steal(mem_ctx, state->out_mem_ctx);
6503
6504 /* Return result */
6505 *result = state->orig.out.result;
6506
6507 tevent_req_received(req);
6508 return NT_STATUS_OK;
6509 }
6510
6511 NTSTATUS rpccli_PNP_GetLogConfPriority(struct rpc_pipe_client *cli,
6512 TALLOC_CTX *mem_ctx,
6513 WERROR *werror)
6514 {
6515 struct PNP_GetLogConfPriority r;
6516 NTSTATUS status;
6517
6518 /* In parameters */
6519
6520 status = cli->dispatch(cli,
6521 mem_ctx,
6522 &ndr_table_ntsvcs,
6523 NDR_PNP_GETLOGCONFPRIORITY,
6524 &r);
6525
6526 if (!NT_STATUS_IS_OK(status)) {
6527 return status;
6528 }
6529
6530 if (NT_STATUS_IS_ERR(status)) {
6531 return status;
6532 }
6533
6534 /* Return variables */
6535
6536 /* Return result */
6537 if (werror) {
6538 *werror = r.out.result;
6539 }
6540
6541 return werror_to_ntstatus(r.out.result);
6542 }
6543
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);
6549 };
6550
6551 static void rpccli_PNP_AddResDes_done(struct tevent_req *subreq);
6552
6553 struct tevent_req *rpccli_PNP_AddResDes_send(TALLOC_CTX *mem_ctx,
6554 struct tevent_context *ev,
6555 struct rpc_pipe_client *cli)
6556 {
6557 struct tevent_req *req;
6558 struct rpccli_PNP_AddResDes_state *state;
6559 struct tevent_req *subreq;
6560
6561 req = tevent_req_create(mem_ctx, &state,
6562 struct rpccli_PNP_AddResDes_state);
6563 if (req == NULL) {
6564 return NULL;
6565 }
6566 state->out_mem_ctx = NULL;
6567 state->dispatch_recv = cli->dispatch_recv;
6568
6569 /* In parameters */
6570
6571 /* Out parameters */
6572
6573 /* Result */
6574 ZERO_STRUCT(state->orig.out.result);
6575
6576 /* make a temporary copy, that we pass to the dispatch function */
6577 state->tmp = state->orig;
6578
6579 subreq = cli->dispatch_send(state, ev, cli,
6580 &ndr_table_ntsvcs,
6581 NDR_PNP_ADDRESDES,
6582 &state->tmp);
6583 if (tevent_req_nomem(subreq, req)) {
6584 return tevent_req_post(req, ev);
6585 }
6586 tevent_req_set_callback(subreq, rpccli_PNP_AddResDes_done, req);
6587 return req;
6588 }
6589
6590 static void rpccli_PNP_AddResDes_done(struct tevent_req *subreq)
6591 {
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);
6596 NTSTATUS status;
6597 TALLOC_CTX *mem_ctx;
6598
6599 if (state->out_mem_ctx) {
6600 mem_ctx = state->out_mem_ctx;
6601 } else {
6602 mem_ctx = state;
6603 }
6604
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);
6609 return;
6610 }
6611
6612 /* Copy out parameters */
6613
6614 /* Copy result */
6615 state->orig.out.result = state->tmp.out.result;
6616
6617 /* Reset temporary structure */
6618 ZERO_STRUCT(state->tmp);
6619
6620 tevent_req_done(req);
6621 }
6622
6623 NTSTATUS rpccli_PNP_AddResDes_recv(struct tevent_req *req,
6624 TALLOC_CTX *mem_ctx,
6625 WERROR *result)
6626 {
6627 struct rpccli_PNP_AddResDes_state *state = tevent_req_data(
6628 req, struct rpccli_PNP_AddResDes_state);
6629 NTSTATUS status;
6630
6631 if (tevent_req_is_nterror(req, &status)) {
6632 tevent_req_received(req);
6633 return status;
6634 }
6635
6636 /* Steal possbile out parameters to the callers context */
6637 talloc_steal(mem_ctx, state->out_mem_ctx);
6638
6639 /* Return result */
6640 *result = state->orig.out.result;
6641
6642 tevent_req_received(req);
6643 return NT_STATUS_OK;
6644 }
6645
6646 NTSTATUS rpccli_PNP_AddResDes(struct rpc_pipe_client *cli,
6647 TALLOC_CTX *mem_ctx,
6648 WERROR *werror)
6649 {
6650 struct PNP_AddResDes r;
6651 NTSTATUS status;
6652
6653 /* In parameters */
6654
6655 status = cli->dispatch(cli,
6656 mem_ctx,
6657 &ndr_table_ntsvcs,
6658 NDR_PNP_ADDRESDES,
6659 &r);
6660
6661 if (!NT_STATUS_IS_OK(status)) {
6662 return status;
6663 }
6664
6665 if (NT_STATUS_IS_ERR(status)) {
6666 return status;
6667 }
6668
6669 /* Return variables */
6670
6671 /* Return result */
6672 if (werror) {
6673 *werror = r.out.result;
6674 }
6675
6676 return werror_to_ntstatus(r.out.result);
6677 }
6678
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);
6684 };
6685
6686 static void rpccli_PNP_FreeResDes_done(struct tevent_req *subreq);
6687
6688 struct tevent_req *rpccli_PNP_FreeResDes_send(TALLOC_CTX *mem_ctx,
6689 struct tevent_context *ev,
6690 struct rpc_pipe_client *cli)
6691 {
6692 struct tevent_req *req;
6693 struct rpccli_PNP_FreeResDes_state *state;
6694 struct tevent_req *subreq;
6695
6696 req = tevent_req_create(mem_ctx, &state,
6697 struct rpccli_PNP_FreeResDes_state);
6698 if (req == NULL) {
6699 return NULL;
6700 }
6701 state->out_mem_ctx = NULL;
6702 state->dispatch_recv = cli->dispatch_recv;
6703
6704 /* In parameters */
6705
6706 /* Out parameters */
6707
6708 /* Result */
6709 ZERO_STRUCT(state->orig.out.result);
6710
6711 /* make a temporary copy, that we pass to the dispatch function */
6712 state->tmp = state->orig;
6713
6714 subreq = cli->dispatch_send(state, ev, cli,
6715 &ndr_table_ntsvcs,
6716 NDR_PNP_FREERESDES,
6717 &state->tmp);
6718 if (tevent_req_nomem(subreq, req)) {
6719 return tevent_req_post(req, ev);
6720 }
6721 tevent_req_set_callback(subreq, rpccli_PNP_FreeResDes_done, req);
6722 return req;
6723 }
6724
6725 static void rpccli_PNP_FreeResDes_done(struct tevent_req *subreq)
6726 {
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);
6731 NTSTATUS status;
6732 TALLOC_CTX *mem_ctx;
6733
6734 if (state->out_mem_ctx) {
6735 mem_ctx = state->out_mem_ctx;
6736 } else {
6737 mem_ctx = state;
6738 }
6739
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);
6744 return;
6745 }
6746
6747 /* Copy out parameters */
6748
6749 /* Copy result */
6750 state->orig.out.result = state->tmp.out.result;
6751
6752 /* Reset temporary structure */
6753 ZERO_STRUCT(state->tmp);
6754
6755 tevent_req_done(req);
6756 }
6757
6758 NTSTATUS rpccli_PNP_FreeResDes_recv(struct tevent_req *req,
6759 TALLOC_CTX *mem_ctx,
6760 WERROR *result)
6761 {
6762 struct rpccli_PNP_FreeResDes_state *state = tevent_req_data(
6763 req, struct rpccli_PNP_FreeResDes_state);
6764 NTSTATUS status;
6765
6766 if (tevent_req_is_nterror(req, &status)) {
6767 tevent_req_received(req);
6768 return status;
6769 }
6770
6771 /* Steal possbile out parameters to the callers context */
6772 talloc_steal(mem_ctx, state->out_mem_ctx);
6773
6774 /* Return result */
6775 *result = state->orig.out.result;
6776
6777 tevent_req_received(req);
6778 return NT_STATUS_OK;
6779 }
6780
6781 NTSTATUS rpccli_PNP_FreeResDes(struct rpc_pipe_client *cli,
6782 TALLOC_CTX *mem_ctx,
6783 WERROR *werror)
6784 {
6785 struct PNP_FreeResDes r;
6786 NTSTATUS status;
6787
6788 /* In parameters */
6789
6790 status = cli->dispatch(cli,
6791 mem_ctx,
6792 &ndr_table_ntsvcs,
6793 NDR_PNP_FREERESDES,
6794 &r);
6795
6796 if (!NT_STATUS_IS_OK(status)) {
6797 return status;
6798 }
6799
6800 if (NT_STATUS_IS_ERR(status)) {
6801 return status;
6802 }
6803
6804 /* Return variables */
6805
6806 /* Return result */
6807 if (werror) {
6808 *werror = r.out.result;
6809 }
6810
6811 return werror_to_ntstatus(r.out.result);
6812 }
6813
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);
6819 };
6820
6821 static void rpccli_PNP_GetNextResDes_done(struct tevent_req *subreq);
6822
6823 struct tevent_req *rpccli_PNP_GetNextResDes_send(TALLOC_CTX *mem_ctx,
6824 struct tevent_context *ev,
6825 struct rpc_pipe_client *cli)
6826 {
6827 struct tevent_req *req;
6828 struct rpccli_PNP_GetNextResDes_state *state;
6829 struct tevent_req *subreq;
6830
6831 req = tevent_req_create(mem_ctx, &state,
6832 struct rpccli_PNP_GetNextResDes_state);
6833 if (req == NULL) {
6834 return NULL;
6835 }
6836 state->out_mem_ctx = NULL;
6837 state->dispatch_recv = cli->dispatch_recv;
6838
6839 /* In parameters */
6840
6841 /* Out parameters */
6842
6843 /* Result */
6844 ZERO_STRUCT(state->orig.out.result);
6845
6846 /* make a temporary copy, that we pass to the dispatch function */
6847 state->tmp = state->orig;
6848
6849 subreq = cli->dispatch_send(state, ev, cli,
6850 &ndr_table_ntsvcs,
6851 NDR_PNP_GETNEXTRESDES,
6852 &state->tmp);
6853 if (tevent_req_nomem(subreq, req)) {
6854 return tevent_req_post(req, ev);
6855 }
6856 tevent_req_set_callback(subreq, rpccli_PNP_GetNextResDes_done, req);
6857 return req;
6858 }
6859
6860 static void rpccli_PNP_GetNextResDes_done(struct tevent_req *subreq)
6861 {
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);
6866 NTSTATUS status;
6867 TALLOC_CTX *mem_ctx;
6868
6869 if (state->out_mem_ctx) {
6870 mem_ctx = state->out_mem_ctx;
6871 } else {
6872 mem_ctx = state;
6873 }
6874
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);
6879 return;
6880 }
6881
6882 /* Copy out parameters */
6883
6884 /* Copy result */
6885 state->orig.out.result = state->tmp.out.result;
6886
6887 /* Reset temporary structure */
6888 ZERO_STRUCT(state->tmp);
6889
6890 tevent_req_done(req);
6891 }
6892
6893 NTSTATUS rpccli_PNP_GetNextResDes_recv(struct tevent_req *req,
6894 TALLOC_CTX *mem_ctx,
6895 WERROR *result)
6896 {
6897 struct rpccli_PNP_GetNextResDes_state *state = tevent_req_data(
6898 req, struct rpccli_PNP_GetNextResDes_state);
6899 NTSTATUS status;
6900
6901 if (tevent_req_is_nterror(req, &status)) {
6902 tevent_req_received(req);
6903 return status;
6904 }
6905
6906 /* Steal possbile out parameters to the callers context */
6907 talloc_steal(mem_ctx, state->out_mem_ctx);
6908
6909 /* Return result */
6910 *result = state->orig.out.result;
6911
6912 tevent_req_received(req);
6913 return NT_STATUS_OK;
6914 }
6915
6916 NTSTATUS rpccli_PNP_GetNextResDes(struct rpc_pipe_client *cli,
6917 TALLOC_CTX *mem_ctx,
6918 WERROR *werror)
6919 {
6920 struct PNP_GetNextResDes r;
6921 NTSTATUS status;
6922
6923 /* In parameters */
6924
6925 status = cli->dispatch(cli,
6926 mem_ctx,
6927 &ndr_table_ntsvcs,
6928 NDR_PNP_GETNEXTRESDES,
6929 &r);
6930
6931 if (!NT_STATUS_IS_OK(status)) {
6932 return status;
6933 }
6934
6935 if (NT_STATUS_IS_ERR(status)) {
6936 return status;
6937 }
6938
6939 /* Return variables */
6940
6941 /* Return result */
6942 if (werror) {
6943 *werror = r.out.result;
6944 }
6945
6946 return werror_to_ntstatus(r.out.result);
6947 }
6948
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);
6954 };
6955
6956 static void rpccli_PNP_GetResDesData_done(struct tevent_req *subreq);
6957
6958 struct tevent_req *rpccli_PNP_GetResDesData_send(TALLOC_CTX *mem_ctx,
6959 struct tevent_context *ev,
6960 struct rpc_pipe_client *cli)
6961 {
6962 struct tevent_req *req;
6963 struct rpccli_PNP_GetResDesData_state *state;
6964 struct tevent_req *subreq;
6965
6966 req = tevent_req_create(mem_ctx, &state,
6967 struct rpccli_PNP_GetResDesData_state);
6968 if (req == NULL) {
6969 return NULL;
6970 }
6971 state->out_mem_ctx = NULL;
6972 state->dispatch_recv = cli->dispatch_recv;
6973
6974 /* In parameters */
6975
6976 /* Out parameters */
6977
6978 /* Result */
6979 ZERO_STRUCT(state->orig.out.result);
6980
6981 /* make a temporary copy, that we pass to the dispatch function */
6982 state->tmp = state->orig;
6983
6984 subreq = cli->dispatch_send(state, ev, cli,
6985 &ndr_table_ntsvcs,
6986 NDR_PNP_GETRESDESDATA,
6987 &state->tmp);
6988 if (tevent_req_nomem(subreq, req)) {
6989 return tevent_req_post(req, ev);
6990 }
6991 tevent_req_set_callback(subreq, rpccli_PNP_GetResDesData_done, req);
6992 return req;
6993 }
6994
6995 static void rpccli_PNP_GetResDesData_done(struct tevent_req *subreq)
6996 {
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);
7001 NTSTATUS status;
7002 TALLOC_CTX *mem_ctx;
7003
7004 if (state->out_mem_ctx) {
7005 mem_ctx = state->out_mem_ctx;
7006 } else {
7007 mem_ctx = state;
7008 }
7009
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);
7014 return;
7015 }
7016
7017 /* Copy out parameters */
7018
7019 /* Copy result */
7020 state->orig.out.result = state->tmp.out.result;
7021
7022 /* Reset temporary structure */
7023 ZERO_STRUCT(state->tmp);
7024
7025 tevent_req_done(req);
7026 }
7027
7028 NTSTATUS rpccli_PNP_GetResDesData_recv(struct tevent_req *req,
7029 TALLOC_CTX *mem_ctx,
7030 WERROR *result)
7031 {
7032 struct rpccli_PNP_GetResDesData_state *state = tevent_req_data(
7033 req, struct rpccli_PNP_GetResDesData_state);
7034 NTSTATUS status;
7035
7036 if (tevent_req_is_nterror(req, &status)) {
7037 tevent_req_received(req);
7038 return status;
7039 }
7040
7041 /* Steal possbile out parameters to the callers context */
7042 talloc_steal(mem_ctx, state->out_mem_ctx);
7043
7044 /* Return result */
7045 *result = state->orig.out.result;
7046
7047 tevent_req_received(req);
7048 return NT_STATUS_OK;
7049 }
7050
7051 NTSTATUS rpccli_PNP_GetResDesData(struct rpc_pipe_client *cli,
7052 TALLOC_CTX *mem_ctx,
7053 WERROR *werror)
7054 {
7055 struct PNP_GetResDesData r;
7056 NTSTATUS status;
7057
7058 /* In parameters */
7059
7060 status = cli->dispatch(cli,
7061 mem_ctx,
7062 &ndr_table_ntsvcs,
7063 NDR_PNP_GETRESDESDATA,
7064 &r);
7065
7066 if (!NT_STATUS_IS_OK(status)) {
7067 return status;
7068 }
7069
7070 if (NT_STATUS_IS_ERR(status)) {
7071 return status;
7072 }
7073
7074 /* Return variables */
7075
7076 /* Return result */
7077 if (werror) {
7078 *werror = r.out.result;
7079 }
7080
7081 return werror_to_ntstatus(r.out.result);
7082 }
7083
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);
7089 };
7090
7091 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req *subreq);
7092
7093 struct tevent_req *rpccli_PNP_GetResDesDataSize_send(TALLOC_CTX *mem_ctx,
7094 struct tevent_context *ev,
7095 struct rpc_pipe_client *cli)
7096 {
7097 struct tevent_req *req;
7098 struct rpccli_PNP_GetResDesDataSize_state *state;
7099 struct tevent_req *subreq;
7100
7101 req = tevent_req_create(mem_ctx, &state,
7102 struct rpccli_PNP_GetResDesDataSize_state);
7103 if (req == NULL) {
7104 return NULL;
7105 }
7106 state->out_mem_ctx = NULL;
7107 state->dispatch_recv = cli->dispatch_recv;
7108
7109 /* In parameters */
7110
7111 /* Out parameters */
7112
7113 /* Result */
7114 ZERO_STRUCT(state->orig.out.result);
7115
7116 /* make a temporary copy, that we pass to the dispatch function */
7117 state->tmp = state->orig;
7118
7119 subreq = cli->dispatch_send(state, ev, cli,
7120 &ndr_table_ntsvcs,
7121 NDR_PNP_GETRESDESDATASIZE,
7122 &state->tmp);
7123 if (tevent_req_nomem(subreq, req)) {
7124 return tevent_req_post(req, ev);
7125 }
7126 tevent_req_set_callback(subreq, rpccli_PNP_GetResDesDataSize_done, req);
7127 return req;
7128 }
7129
7130 static void rpccli_PNP_GetResDesDataSize_done(struct tevent_req *subreq)
7131 {
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);
7136 NTSTATUS status;
7137 TALLOC_CTX *mem_ctx;
7138
7139 if (state->out_mem_ctx) {
7140 mem_ctx = state->out_mem_ctx;
7141 } else {
7142 mem_ctx = state;
7143 }
7144
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);
7149 return;
7150 }
7151
7152 /* Copy out parameters */
7153
7154 /* Copy result */
7155 state->orig.out.result = state->tmp.out.result;
7156
7157 /* Reset temporary structure */
7158 ZERO_STRUCT(state->tmp);
7159
7160 tevent_req_done(req);
7161 }
7162
7163 NTSTATUS rpccli_PNP_GetResDesDataSize_recv(struct tevent_req *req,
7164 TALLOC_CTX *mem_ctx,
7165 WERROR *result)
7166 {
7167 struct rpccli_PNP_GetResDesDataSize_state *state = tevent_req_data(
7168 req, struct rpccli_PNP_GetResDesDataSize_state);
7169 NTSTATUS status;
7170
7171 if (tevent_req_is_nterror(req, &status)) {
7172 tevent_req_received(req);
7173 return status;
7174 }
7175
7176 /* Steal possbile out parameters to the callers context */
7177 talloc_steal(mem_ctx, state->out_mem_ctx);
7178
7179 /* Return result */
7180 *result = state->orig.out.result;
7181
7182 tevent_req_received(req);
7183 return NT_STATUS_OK;
7184 }
7185
7186 NTSTATUS rpccli_PNP_GetResDesDataSize(struct rpc_pipe_client *cli,
7187 TALLOC_CTX *mem_ctx,
7188 WERROR *werror)
7189 {
7190 struct PNP_GetResDesDataSize r;
7191 NTSTATUS status;
7192
7193 /* In parameters */
7194
7195 status = cli->dispatch(cli,
7196 mem_ctx,
7197 &ndr_table_ntsvcs,
7198 NDR_PNP_GETRESDESDATASIZE,
7199 &r);
7200
7201 if (!NT_STATUS_IS_OK(status)) {
7202 return status;
7203 }
7204
7205 if (NT_STATUS_IS_ERR(status)) {
7206 return status;
7207 }
7208
7209 /* Return variables */
7210
7211 /* Return result */
7212 if (werror) {
7213 *werror = r.out.result;
7214 }
7215
7216 return werror_to_ntstatus(r.out.result);
7217 }
7218
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);
7224 };
7225
7226 static void rpccli_PNP_ModifyResDes_done(struct tevent_req *subreq);
7227
7228 struct tevent_req *rpccli_PNP_ModifyResDes_send(TALLOC_CTX *mem_ctx,
7229 struct tevent_context *ev,
7230 struct rpc_pipe_client *cli)
7231 {
7232 struct tevent_req *req;
7233 struct rpccli_PNP_ModifyResDes_state *state;
7234 struct tevent_req *subreq;
7235
7236 req = tevent_req_create(mem_ctx, &state,
7237 struct rpccli_PNP_ModifyResDes_state);
7238 if (req == NULL) {
7239 return NULL;
7240 }
7241 state->out_mem_ctx = NULL;
7242 state->dispatch_recv = cli->dispatch_recv;
7243
7244 /* In parameters */
7245
7246 /* Out parameters */
7247
7248 /* Result */
7249 ZERO_STRUCT(state->orig.out.result);
7250
7251 /* make a temporary copy, that we pass to the dispatch function */
7252 state->tmp = state->orig;
7253
7254 subreq = cli->dispatch_send(state, ev, cli,
7255 &ndr_table_ntsvcs,
7256 NDR_PNP_MODIFYRESDES,
7257 &state->tmp);
7258 if (tevent_req_nomem(subreq, req)) {
7259 return tevent_req_post(req, ev);
7260 }
7261 tevent_req_set_callback(subreq, rpccli_PNP_ModifyResDes_done, req);
7262 return req;
7263 }
7264
7265 static void rpccli_PNP_ModifyResDes_done(struct tevent_req *subreq)
7266 {
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);
7271 NTSTATUS status;
7272 TALLOC_CTX *mem_ctx;
7273
7274 if (state->out_mem_ctx) {
7275 mem_ctx = state->out_mem_ctx;
7276 } else {
7277 mem_ctx = state;
7278 }
7279
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);
7284 return;
7285 }
7286
7287 /* Copy out parameters */
7288
7289 /* Copy result */
7290 state->orig.out.result = state->tmp.out.result;
7291
7292 /* Reset temporary structure */
7293 ZERO_STRUCT(state->tmp);
7294
7295 tevent_req_done(req);
7296 }
7297
7298 NTSTATUS rpccli_PNP_ModifyResDes_recv(struct tevent_req *req,
7299 TALLOC_CTX *mem_ctx,
7300 WERROR *result)
7301 {
7302 struct rpccli_PNP_ModifyResDes_state *state = tevent_req_data(
7303 req, struct rpccli_PNP_ModifyResDes_state);
7304 NTSTATUS status;
7305
7306 if (tevent_req_is_nterror(req, &status)) {
7307 tevent_req_received(req);
7308 return status;
7309 }
7310
7311 /* Steal possbile out parameters to the callers context */
7312 talloc_steal(mem_ctx, state->out_mem_ctx);
7313
7314 /* Return result */
7315 *result = state->orig.out.result;
7316
7317 tevent_req_received(req);
7318 return NT_STATUS_OK;
7319 }
7320
7321 NTSTATUS rpccli_PNP_ModifyResDes(struct rpc_pipe_client *cli,
7322 TALLOC_CTX *mem_ctx,
7323 WERROR *werror)
7324 {
7325 struct PNP_ModifyResDes r;
7326 NTSTATUS status;
7327
7328 /* In parameters */
7329
7330 status = cli->dispatch(cli,
7331 mem_ctx,
7332 &ndr_table_ntsvcs,
7333 NDR_PNP_MODIFYRESDES,
7334 &r);
7335
7336 if (!NT_STATUS_IS_OK(status)) {
7337 return status;
7338 }
7339
7340 if (NT_STATUS_IS_ERR(status)) {
7341 return status;
7342 }
7343
7344 /* Return variables */
7345
7346 /* Return result */
7347 if (werror) {
7348 *werror = r.out.result;
7349 }
7350
7351 return werror_to_ntstatus(r.out.result);
7352 }
7353
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);
7359 };
7360
7361 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req *subreq);
7362
7363 struct tevent_req *rpccli_PNP_DetectResourceLimit_send(TALLOC_CTX *mem_ctx,
7364 struct tevent_context *ev,
7365 struct rpc_pipe_client *cli)
7366 {
7367 struct tevent_req *req;
7368 struct rpccli_PNP_DetectResourceLimit_state *state;
7369 struct tevent_req *subreq;
7370
7371 req = tevent_req_create(mem_ctx, &state,
7372 struct rpccli_PNP_DetectResourceLimit_state);
7373 if (req == NULL) {
7374 return NULL;
7375 }
7376 state->out_mem_ctx = NULL;
7377 state->dispatch_recv = cli->dispatch_recv;
7378
7379 /* In parameters */
7380
7381 /* Out parameters */
7382
7383 /* Result */
7384 ZERO_STRUCT(state->orig.out.result);
7385
7386 /* make a temporary copy, that we pass to the dispatch function */
7387 state->tmp = state->orig;
7388
7389 subreq = cli->dispatch_send(state, ev, cli,
7390 &ndr_table_ntsvcs,
7391 NDR_PNP_DETECTRESOURCELIMIT,
7392 &state->tmp);
7393 if (tevent_req_nomem(subreq, req)) {
7394 return tevent_req_post(req, ev);
7395 }
7396 tevent_req_set_callback(subreq, rpccli_PNP_DetectResourceLimit_done, req);
7397 return req;
7398 }
7399
7400 static void rpccli_PNP_DetectResourceLimit_done(struct tevent_req *subreq)
7401 {
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);
7406 NTSTATUS status;
7407 TALLOC_CTX *mem_ctx;
7408
7409 if (state->out_mem_ctx) {
7410 mem_ctx = state->out_mem_ctx;
7411 } else {
7412 mem_ctx = state;
7413 }
7414
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);
7419 return;
7420 }
7421
7422 /* Copy out parameters */
7423
7424 /* Copy result */
7425 state->orig.out.result = state->tmp.out.result;
7426
7427 /* Reset temporary structure */
7428 ZERO_STRUCT(state->tmp);
7429
7430 tevent_req_done(req);
7431 }
7432
7433 NTSTATUS rpccli_PNP_DetectResourceLimit_recv(struct tevent_req *req,
7434 TALLOC_CTX *mem_ctx,
7435 WERROR *result)
7436 {
7437 struct rpccli_PNP_DetectResourceLimit_state *state = tevent_req_data(
7438 req, struct rpccli_PNP_DetectResourceLimit_state);
7439 NTSTATUS status;
7440
7441 if (tevent_req_is_nterror(req, &status)) {
7442 tevent_req_received(req);
7443 return status;
7444 }
7445
7446 /* Steal possbile out parameters to the callers context */
7447 talloc_steal(mem_ctx, state->out_mem_ctx);
7448
7449 /* Return result */
7450 *result = state->orig.out.result;
7451
7452 tevent_req_received(req);
7453 return NT_STATUS_OK;
7454 }
7455
7456 NTSTATUS rpccli_PNP_DetectResourceLimit(struct rpc_pipe_client *cli,
7457 TALLOC_CTX *mem_ctx,
7458 WERROR *werror)
7459 {
7460 struct PNP_DetectResourceLimit r;
7461 NTSTATUS status;
7462
7463 /* In parameters */
7464
7465 status = cli->dispatch(cli,
7466 mem_ctx,
7467 &ndr_table_ntsvcs,
7468 NDR_PNP_DETECTRESOURCELIMIT,
7469 &r);
7470
7471 if (!NT_STATUS_IS_OK(status)) {
7472 return status;
7473 }
7474
7475 if (NT_STATUS_IS_ERR(status)) {
7476 return status;
7477 }
7478
7479 /* Return variables */
7480
7481 /* Return result */
7482 if (werror) {
7483 *werror = r.out.result;
7484 }
7485
7486 return werror_to_ntstatus(r.out.result);
7487 }
7488
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);
7494 };
7495
7496 static void rpccli_PNP_QueryResConfList_done(struct tevent_req *subreq);
7497
7498 struct tevent_req *rpccli_PNP_QueryResConfList_send(TALLOC_CTX *mem_ctx,
7499 struct tevent_context *ev,
7500 struct rpc_pipe_client *cli)
7501 {
7502 struct tevent_req *req;
7503 struct rpccli_PNP_QueryResConfList_state *state;
7504 struct tevent_req *subreq;
7505
7506 req = tevent_req_create(mem_ctx, &state,
7507 struct rpccli_PNP_QueryResConfList_state);
7508 if (req == NULL) {
7509 return NULL;
7510 }
7511 state->out_mem_ctx = NULL;
7512 state->dispatch_recv = cli->dispatch_recv;
7513
7514 /* In parameters */
7515
7516 /* Out parameters */
7517
7518 /* Result */
7519 ZERO_STRUCT(state->orig.out.result);
7520
7521 /* make a temporary copy, that we pass to the dispatch function */
7522 state->tmp = state->orig;
7523
7524 subreq = cli->dispatch_send(state, ev, cli,
7525 &ndr_table_ntsvcs,
7526 NDR_PNP_QUERYRESCONFLIST,
7527 &state->tmp);
7528 if (tevent_req_nomem(subreq, req)) {
7529 return tevent_req_post(req, ev);
7530 }
7531 tevent_req_set_callback(subreq, rpccli_PNP_QueryResConfList_done, req);
7532 return req;
7533 }
7534
7535 static void rpccli_PNP_QueryResConfList_done(struct tevent_req *subreq)
7536 {
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);
7541 NTSTATUS status;
7542 TALLOC_CTX *mem_ctx;
7543
7544 if (state->out_mem_ctx) {
7545 mem_ctx = state->out_mem_ctx;
7546 } else {
7547 mem_ctx = state;
7548 }
7549
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);
7554 return;
7555 }
7556
7557 /* Copy out parameters */
7558
7559 /* Copy result */
7560 state->orig.out.result = state->tmp.out.result;
7561
7562 /* Reset temporary structure */
7563 ZERO_STRUCT(state->tmp);
7564
7565 tevent_req_done(req);
7566 }
7567
7568 NTSTATUS rpccli_PNP_QueryResConfList_recv(struct tevent_req *req,
7569 TALLOC_CTX *mem_ctx,
7570 WERROR *result)
7571 {
7572 struct rpccli_PNP_QueryResConfList_state *state = tevent_req_data(
7573 req, struct rpccli_PNP_QueryResConfList_state);
7574 NTSTATUS status;
7575
7576 if (tevent_req_is_nterror(req, &status)) {
7577 tevent_req_received(req);
7578 return status;
7579 }
7580
7581 /* Steal possbile out parameters to the callers context */
7582 talloc_steal(mem_ctx, state->out_mem_ctx);
7583
7584 /* Return result */
7585 *result = state->orig.out.result;
7586
7587 tevent_req_received(req);
7588 return NT_STATUS_OK;
7589 }
7590
7591 NTSTATUS rpccli_PNP_QueryResConfList(struct rpc_pipe_client *cli,
7592 TALLOC_CTX *mem_ctx,
7593 WERROR *werror)
7594 {
7595 struct PNP_QueryResConfList r;
7596 NTSTATUS status;
7597
7598 /* In parameters */
7599
7600 status = cli->dispatch(cli,
7601 mem_ctx,
7602 &ndr_table_ntsvcs,
7603 NDR_PNP_QUERYRESCONFLIST,
7604 &r);
7605
7606 if (!NT_STATUS_IS_OK(status)) {
7607 return status;
7608 }
7609
7610 if (NT_STATUS_IS_ERR(status)) {
7611 return status;
7612 }
7613
7614 /* Return variables */
7615
7616 /* Return result */
7617 if (werror) {
7618 *werror = r.out.result;
7619 }
7620
7621 return werror_to_ntstatus(r.out.result);
7622 }
7623
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);
7629 };
7630
7631 static void rpccli_PNP_SetHwProf_done(struct tevent_req *subreq);
7632
7633 struct tevent_req *rpccli_PNP_SetHwProf_send(TALLOC_CTX *mem_ctx,
7634 struct tevent_context *ev,
7635 struct rpc_pipe_client *cli)
7636 {
7637 struct tevent_req *req;
7638 struct rpccli_PNP_SetHwProf_state *state;
7639 struct tevent_req *subreq;
7640
7641 req = tevent_req_create(mem_ctx, &state,
7642 struct rpccli_PNP_SetHwProf_state);
7643 if (req == NULL) {
7644 return NULL;
7645 }
7646 state->out_mem_ctx = NULL;
7647 state->dispatch_recv = cli->dispatch_recv;
7648
7649 /* In parameters */
7650
7651 /* Out parameters */
7652
7653 /* Result */
7654 ZERO_STRUCT(state->orig.out.result);
7655
7656 /* make a temporary copy, that we pass to the dispatch function */
7657 state->tmp = state->orig;
7658
7659 subreq = cli->dispatch_send(state, ev, cli,
7660 &ndr_table_ntsvcs,
7661 NDR_PNP_SETHWPROF,
7662 &state->tmp);
7663 if (tevent_req_nomem(subreq, req)) {
7664 return tevent_req_post(req, ev);
7665 }
7666 tevent_req_set_callback(subreq, rpccli_PNP_SetHwProf_done, req);
7667 return req;
7668 }
7669
7670 static void rpccli_PNP_SetHwProf_done(struct tevent_req *subreq)
7671 {
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);
7676 NTSTATUS status;
7677 TALLOC_CTX *mem_ctx;
7678
7679 if (state->out_mem_ctx) {
7680 mem_ctx = state->out_mem_ctx;
7681 } else {
7682 mem_ctx = state;
7683 }
7684
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);
7689 return;
7690 }
7691
7692 /* Copy out parameters */
7693
7694 /* Copy result */
7695 state->orig.out.result = state->tmp.out.result;
7696
7697 /* Reset temporary structure */
7698 ZERO_STRUCT(state->tmp);
7699
7700 tevent_req_done(req);
7701 }
7702
7703 NTSTATUS rpccli_PNP_SetHwProf_recv(struct tevent_req *req,
7704 TALLOC_CTX *mem_ctx,
7705 WERROR *result)
7706 {
7707 struct rpccli_PNP_SetHwProf_state *state = tevent_req_data(
7708 req, struct rpccli_PNP_SetHwProf_state);
7709 NTSTATUS status;
7710
7711 if (tevent_req_is_nterror(req, &status)) {
7712 tevent_req_received(req);
7713 return status;
7714 }
7715
7716 /* Steal possbile out parameters to the callers context */
7717 talloc_steal(mem_ctx, state->out_mem_ctx);
7718
7719 /* Return result */
7720 *result = state->orig.out.result;
7721
7722 tevent_req_received(req);
7723 return NT_STATUS_OK;
7724 }
7725
7726 NTSTATUS rpccli_PNP_SetHwProf(struct rpc_pipe_client *cli,
7727 TALLOC_CTX *mem_ctx,
7728 WERROR *werror)
7729 {
7730 struct PNP_SetHwProf r;
7731 NTSTATUS status;
7732
7733 /* In parameters */
7734
7735 status = cli->dispatch(cli,
7736 mem_ctx,
7737 &ndr_table_ntsvcs,
7738 NDR_PNP_SETHWPROF,
7739 &r);
7740
7741 if (!NT_STATUS_IS_OK(status)) {
7742 return status;
7743 }
7744
7745 if (NT_STATUS_IS_ERR(status)) {
7746 return status;
7747 }
7748
7749 /* Return variables */
7750
7751 /* Return result */
7752 if (werror) {
7753 *werror = r.out.result;
7754 }
7755
7756 return werror_to_ntstatus(r.out.result);
7757 }
7758
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);
7764 };
7765
7766 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req *subreq);
7767
7768 struct tevent_req *rpccli_PNP_QueryArbitratorFreeData_send(TALLOC_CTX *mem_ctx,
7769 struct tevent_context *ev,
7770 struct rpc_pipe_client *cli)
7771 {
7772 struct tevent_req *req;
7773 struct rpccli_PNP_QueryArbitratorFreeData_state *state;
7774 struct tevent_req *subreq;
7775
7776 req = tevent_req_create(mem_ctx, &state,
7777 struct rpccli_PNP_QueryArbitratorFreeData_state);
7778 if (req == NULL) {
7779 return NULL;
7780 }
7781 state->out_mem_ctx = NULL;
7782 state->dispatch_recv = cli->dispatch_recv;
7783
7784 /* In parameters */
7785
7786 /* Out parameters */
7787
7788 /* Result */
7789 ZERO_STRUCT(state->orig.out.result);
7790
7791 /* make a temporary copy, that we pass to the dispatch function */
7792 state->tmp = state->orig;
7793
7794 subreq = cli->dispatch_send(state, ev, cli,
7795 &ndr_table_ntsvcs,
7796 NDR_PNP_QUERYARBITRATORFREEDATA,
7797 &state->tmp);
7798 if (tevent_req_nomem(subreq, req)) {
7799 return tevent_req_post(req, ev);
7800 }
7801 tevent_req_set_callback(subreq, rpccli_PNP_QueryArbitratorFreeData_done, req);
7802 return req;
7803 }
7804
7805 static void rpccli_PNP_QueryArbitratorFreeData_done(struct tevent_req *subreq)
7806 {
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);
7811 NTSTATUS status;
7812 TALLOC_CTX *mem_ctx;
7813
7814 if (state->out_mem_ctx) {
7815 mem_ctx = state->out_mem_ctx;
7816 } else {
7817 mem_ctx = state;
7818 }
7819
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);
7824 return;
7825 }
7826
7827 /* Copy out parameters */
7828
7829 /* Copy result */
7830 state->orig.out.result = state->tmp.out.result;
7831
7832 /* Reset temporary structure */
7833 ZERO_STRUCT(state->tmp);
7834
7835 tevent_req_done(req);
7836 }
7837
7838 NTSTATUS rpccli_PNP_QueryArbitratorFreeData_recv(struct tevent_req *req,
7839 TALLOC_CTX *mem_ctx,
7840 WERROR *result)
7841 {
7842 struct rpccli_PNP_QueryArbitratorFreeData_state *state = tevent_req_data(
7843 req, struct rpccli_PNP_QueryArbitratorFreeData_state);
7844 NTSTATUS status;
7845
7846 if (tevent_req_is_nterror(req, &status)) {
7847 tevent_req_received(req);
7848 return status;
7849 }
7850
7851 /* Steal possbile out parameters to the callers context */
7852 talloc_steal(mem_ctx, state->out_mem_ctx);
7853
7854 /* Return result */
7855 *result = state->orig.out.result;
7856
7857 tevent_req_received(req);
7858 return NT_STATUS_OK;
7859 }
7860
7861 NTSTATUS rpccli_PNP_QueryArbitratorFreeData(struct rpc_pipe_client *cli,
7862 TALLOC_CTX *mem_ctx,
7863 WERROR *werror)
7864 {
7865 struct PNP_QueryArbitratorFreeData r;
7866 NTSTATUS status;
7867
7868 /* In parameters */
7869
7870 status = cli->dispatch(cli,
7871 mem_ctx,
7872 &ndr_table_ntsvcs,
7873 NDR_PNP_QUERYARBITRATORFREEDATA,
7874 &r);
7875
7876 if (!NT_STATUS_IS_OK(status)) {
7877 return status;
7878 }
7879
7880 if (NT_STATUS_IS_ERR(status)) {
7881 return status;
7882 }
7883
7884 /* Return variables */
7885
7886 /* Return result */
7887 if (werror) {
7888 *werror = r.out.result;
7889 }
7890
7891 return werror_to_ntstatus(r.out.result);
7892 }
7893
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);
7899 };
7900
7901 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req *subreq);
7902
7903 struct tevent_req *rpccli_PNP_QueryArbitratorFreeSize_send(TALLOC_CTX *mem_ctx,
7904 struct tevent_context *ev,
7905 struct rpc_pipe_client *cli)
7906 {
7907 struct tevent_req *req;
7908 struct rpccli_PNP_QueryArbitratorFreeSize_state *state;
7909 struct tevent_req *subreq;
7910
7911 req = tevent_req_create(mem_ctx, &state,
7912 struct rpccli_PNP_QueryArbitratorFreeSize_state);
7913 if (req == NULL) {
7914 return NULL;
7915 }
7916 state->out_mem_ctx = NULL;
7917 state->dispatch_recv = cli->dispatch_recv;
7918
7919 /* In parameters */
7920
7921 /* Out parameters */
7922
7923 /* Result */
7924 ZERO_STRUCT(state->orig.out.result);
7925
7926 /* make a temporary copy, that we pass to the dispatch function */
7927 state->tmp = state->orig;
7928
7929 subreq = cli->dispatch_send(state, ev, cli,
7930 &ndr_table_ntsvcs,
7931 NDR_PNP_QUERYARBITRATORFREESIZE,
7932 &state->tmp);
7933 if (tevent_req_nomem(subreq, req)) {
7934 return tevent_req_post(req, ev);
7935 }
7936 tevent_req_set_callback(subreq, rpccli_PNP_QueryArbitratorFreeSize_done, req);
7937 return req;
7938 }
7939
7940 static void rpccli_PNP_QueryArbitratorFreeSize_done(struct tevent_req *subreq)
7941 {
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);
7946 NTSTATUS status;
7947 TALLOC_CTX *mem_ctx;
7948
7949 if (state->out_mem_ctx) {
7950 mem_ctx = state->out_mem_ctx;
7951 } else {
7952 mem_ctx = state;
7953 }
7954
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);
7959 return;
7960 }
7961
7962 /* Copy out parameters */
7963
7964 /* Copy result */
7965 state->orig.out.result = state->tmp.out.result;
7966
7967 /* Reset temporary structure */
7968 ZERO_STRUCT(state->tmp);
7969
7970 tevent_req_done(req);
7971 }
7972
7973 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize_recv(struct tevent_req *req,
7974 TALLOC_CTX *mem_ctx,
7975 WERROR *result)
7976 {
7977 struct rpccli_PNP_QueryArbitratorFreeSize_state *state = tevent_req_data(
7978 req, struct rpccli_PNP_QueryArbitratorFreeSize_state);
7979 NTSTATUS status;
7980
7981 if (tevent_req_is_nterror(req, &status)) {
7982 tevent_req_received(req);
7983 return status;
7984 }
7985
7986 /* Steal possbile out parameters to the callers context */
7987 talloc_steal(mem_ctx, state->out_mem_ctx);
7988
7989 /* Return result */
7990 *result = state->orig.out.result;
7991
7992 tevent_req_received(req);
7993 return NT_STATUS_OK;
7994 }
7995
7996 NTSTATUS rpccli_PNP_QueryArbitratorFreeSize(struct rpc_pipe_client *cli,
7997 TALLOC_CTX *mem_ctx,
7998 WERROR *werror)
7999 {
8000 struct PNP_QueryArbitratorFreeSize r;
8001 NTSTATUS status;
8002
8003 /* In parameters */
8004
8005 status = cli->dispatch(cli,
8006 mem_ctx,
8007 &ndr_table_ntsvcs,
8008 NDR_PNP_QUERYARBITRATORFREESIZE,
8009 &r);
8010
8011 if (!NT_STATUS_IS_OK(status)) {
8012 return status;
8013 }
8014
8015 if (NT_STATUS_IS_ERR(status)) {
8016 return status;
8017 }
8018
8019 /* Return variables */
8020
8021 /* Return result */
8022 if (werror) {
8023 *werror = r.out.result;
8024 }
8025
8026 return werror_to_ntstatus(r.out.result);
8027 }
8028
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);
8034 };
8035
8036 static void rpccli_PNP_RunDetection_done(struct tevent_req *subreq);
8037
8038 struct tevent_req *rpccli_PNP_RunDetection_send(TALLOC_CTX *mem_ctx,
8039 struct tevent_context *ev,
8040 struct rpc_pipe_client *cli)
8041 {
8042 struct tevent_req *req;
8043 struct rpccli_PNP_RunDetection_state *state;
8044 struct tevent_req *subreq;
8045
8046 req = tevent_req_create(mem_ctx, &state,
8047 struct rpccli_PNP_RunDetection_state);
8048 if (req == NULL) {
8049 return NULL;
8050 }
8051 state->out_mem_ctx = NULL;
8052 state->dispatch_recv = cli->dispatch_recv;
8053
8054 /* In parameters */
8055
8056 /* Out parameters */
8057
8058 /* Result */
8059 ZERO_STRUCT(state->orig.out.result);
8060
8061 /* make a temporary copy, that we pass to the dispatch function */
8062 state->tmp = state->orig;
8063
8064 subreq = cli->dispatch_send(state, ev, cli,
8065 &ndr_table_ntsvcs,
8066 NDR_PNP_RUNDETECTION,
8067 &state->tmp);
8068 if (tevent_req_nomem(subreq, req)) {
8069 return tevent_req_post(req, ev);
8070 }
8071 tevent_req_set_callback(subreq, rpccli_PNP_RunDetection_done, req);
8072 return req;
8073 }
8074
8075 static void rpccli_PNP_RunDetection_done(struct tevent_req *subreq)
8076 {
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);
8081 NTSTATUS status;
8082 TALLOC_CTX *mem_ctx;
8083
8084 if (state->out_mem_ctx) {
8085 mem_ctx = state->out_mem_ctx;
8086 } else {
8087 mem_ctx = state;
8088 }
8089
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);
8094 return;
8095 }
8096
8097 /* Copy out parameters */
8098
8099 /* Copy result */
8100 state->orig.out.result = state->tmp.out.result;
8101
8102 /* Reset temporary structure */
8103 ZERO_STRUCT(state->tmp);
8104
8105 tevent_req_done(req);
8106 }
8107
8108 NTSTATUS rpccli_PNP_RunDetection_recv(struct tevent_req *req,
8109 TALLOC_CTX *mem_ctx,
8110 WERROR *result)
8111 {
8112 struct rpccli_PNP_RunDetection_state *state = tevent_req_data(
8113 req, struct rpccli_PNP_RunDetection_state);
8114 NTSTATUS status;
8115
8116 if (tevent_req_is_nterror(req, &status)) {
8117 tevent_req_received(req);
8118 return status;
8119 }
8120
8121 /* Steal possbile out parameters to the callers context */
8122 talloc_steal(mem_ctx, state->out_mem_ctx);
8123
8124 /* Return result */
8125 *result = state->orig.out.result;
8126
8127 tevent_req_received(req);
8128 return NT_STATUS_OK;
8129 }
8130
8131 NTSTATUS rpccli_PNP_RunDetection(struct rpc_pipe_client *cli,
8132 TALLOC_CTX *mem_ctx,
8133 WERROR *werror)
8134 {
8135 struct PNP_RunDetection r;
8136 NTSTATUS status;
8137
8138 /* In parameters */
8139
8140 status = cli->dispatch(cli,
8141 mem_ctx,
8142 &ndr_table_ntsvcs,
8143 NDR_PNP_RUNDETECTION,
8144 &r);
8145
8146 if (!NT_STATUS_IS_OK(status)) {
8147 return status;
8148 }
8149
8150 if (NT_STATUS_IS_ERR(status)) {
8151 return status;
8152 }
8153
8154 /* Return variables */
8155
8156 /* Return result */
8157 if (werror) {
8158 *werror = r.out.result;
8159 }
8160
8161 return werror_to_ntstatus(r.out.result);
8162 }
8163
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);
8169 };
8170
8171 static void rpccli_PNP_RegisterNotification_done(struct tevent_req *subreq);
8172
8173 struct tevent_req *rpccli_PNP_RegisterNotification_send(TALLOC_CTX *mem_ctx,
8174 struct tevent_context *ev,
8175 struct rpc_pipe_client *cli)
8176 {
8177 struct tevent_req *req;
8178 struct rpccli_PNP_RegisterNotification_state *state;
8179 struct tevent_req *subreq;
8180
8181 req = tevent_req_create(mem_ctx, &state,
8182 struct rpccli_PNP_RegisterNotification_state);
8183 if (req == NULL) {
8184 return NULL;
8185 }
8186 state->out_mem_ctx = NULL;
8187 state->dispatch_recv = cli->dispatch_recv;
8188
8189 /* In parameters */
8190
8191 /* Out parameters */
8192
8193 /* Result */
8194 ZERO_STRUCT(state->orig.out.result);
8195
8196 /* make a temporary copy, that we pass to the dispatch function */
8197 state->tmp = state->orig;
8198
8199 subreq = cli->dispatch_send(state, ev, cli,
8200 &ndr_table_ntsvcs,
8201 NDR_PNP_REGISTERNOTIFICATION,
8202 &state->tmp);
8203 if (tevent_req_nomem(subreq, req)) {
8204 return tevent_req_post(req, ev);
8205 }
8206 tevent_req_set_callback(subreq, rpccli_PNP_RegisterNotification_done, req);
8207 return req;
8208 }
8209
8210 static void rpccli_PNP_RegisterNotification_done(struct tevent_req *subreq)
8211 {
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);
8216 NTSTATUS status;
8217 TALLOC_CTX *mem_ctx;
8218
8219 if (state->out_mem_ctx) {
8220 mem_ctx = state->out_mem_ctx;
8221 } else {
8222 mem_ctx = state;
8223 }
8224
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);
8229 return;
8230 }
8231
8232 /* Copy out parameters */
8233
8234 /* Copy result */
8235 state->orig.out.result = state->tmp.out.result;
8236
8237 /* Reset temporary structure */
8238 ZERO_STRUCT(state->tmp);
8239
8240 tevent_req_done(req);
8241 }
8242
8243 NTSTATUS rpccli_PNP_RegisterNotification_recv(struct tevent_req *req,
8244 TALLOC_CTX *mem_ctx,
8245 WERROR *result)
8246 {
8247 struct rpccli_PNP_RegisterNotification_state *state = tevent_req_data(
8248 req, struct rpccli_PNP_RegisterNotification_state);
8249 NTSTATUS status;
8250
8251 if (tevent_req_is_nterror(req, &status)) {
8252 tevent_req_received(req);
8253 return status;
8254 }
8255
8256 /* Steal possbile out parameters to the callers context */
8257 talloc_steal(mem_ctx, state->out_mem_ctx);
8258
8259 /* Return result */
8260 *result = state->orig.out.result;
8261
8262 tevent_req_received(req);
8263 return NT_STATUS_OK;
8264 }
8265
8266 NTSTATUS rpccli_PNP_RegisterNotification(struct rpc_pipe_client *cli,
8267 TALLOC_CTX *mem_ctx,
8268 WERROR *werror)
8269 {
8270 struct PNP_RegisterNotification r;
8271 NTSTATUS status;
8272
8273 /* In parameters */
8274
8275 status = cli->dispatch(cli,
8276 mem_ctx,
8277 &ndr_table_ntsvcs,
8278 NDR_PNP_REGISTERNOTIFICATION,
8279 &r);
8280
8281 if (!NT_STATUS_IS_OK(status)) {
8282 return status;
8283 }
8284
8285 if (NT_STATUS_IS_ERR(status)) {
8286 return status;
8287 }
8288
8289 /* Return variables */
8290
8291 /* Return result */
8292 if (werror) {
8293 *werror = r.out.result;
8294 }
8295
8296 return werror_to_ntstatus(r.out.result);
8297 }
8298
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);
8304 };
8305
8306 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req *subreq);
8307
8308 struct tevent_req *rpccli_PNP_UnregisterNotification_send(TALLOC_CTX *mem_ctx,
8309 struct tevent_context *ev,
8310 struct rpc_pipe_client *cli)
8311 {
8312 struct tevent_req *req;
8313 struct rpccli_PNP_UnregisterNotification_state *state;
8314 struct tevent_req *subreq;
8315
8316 req = tevent_req_create(mem_ctx, &state,
8317 struct rpccli_PNP_UnregisterNotification_state);
8318 if (req == NULL) {
8319 return NULL;
8320 }
8321 state->out_mem_ctx = NULL;
8322 state->dispatch_recv = cli->dispatch_recv;
8323
8324 /* In parameters */
8325
8326 /* Out parameters */
8327
8328 /* Result */
8329 ZERO_STRUCT(state->orig.out.result);
8330
8331 /* make a temporary copy, that we pass to the dispatch function */
8332 state->tmp = state->orig;
8333
8334 subreq = cli->dispatch_send(state, ev, cli,
8335 &ndr_table_ntsvcs,
8336 NDR_PNP_UNREGISTERNOTIFICATION,
8337 &state->tmp);
8338 if (tevent_req_nomem(subreq, req)) {
8339 return tevent_req_post(req, ev);
8340 }
8341 tevent_req_set_callback(subreq, rpccli_PNP_UnregisterNotification_done, req);
8342 return req;
8343 }
8344
8345 static void rpccli_PNP_UnregisterNotification_done(struct tevent_req *subreq)
8346 {
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);
8351 NTSTATUS status;
8352 TALLOC_CTX *mem_ctx;
8353
8354 if (state->out_mem_ctx) {
8355 mem_ctx = state->out_mem_ctx;
8356 } else {
8357 mem_ctx = state;
8358 }
8359
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);
8364 return;
8365 }
8366
8367 /* Copy out parameters */
8368
8369 /* Copy result */
8370 state->orig.out.result = state->tmp.out.result;
8371
8372 /* Reset temporary structure */
8373 ZERO_STRUCT(state->tmp);
8374
8375 tevent_req_done(req);
8376 }
8377
8378 NTSTATUS rpccli_PNP_UnregisterNotification_recv(struct tevent_req *req,
8379 TALLOC_CTX *mem_ctx,
8380 WERROR *result)
8381 {
8382 struct rpccli_PNP_UnregisterNotification_state *state = tevent_req_data(
8383 req, struct rpccli_PNP_UnregisterNotification_state);
8384 NTSTATUS status;
8385
8386 if (tevent_req_is_nterror(req, &status)) {
8387 tevent_req_received(req);
8388 return status;
8389 }
8390
8391 /* Steal possbile out parameters to the callers context */
8392 talloc_steal(mem_ctx, state->out_mem_ctx);
8393
8394 /* Return result */
8395 *result = state->orig.out.result;
8396
8397 tevent_req_received(req);
8398 return NT_STATUS_OK;
8399 }
8400
8401 NTSTATUS rpccli_PNP_UnregisterNotification(struct rpc_pipe_client *cli,
8402 TALLOC_CTX *mem_ctx,
8403 WERROR *werror)
8404 {
8405 struct PNP_UnregisterNotification r;
8406 NTSTATUS status;
8407
8408 /* In parameters */
8409
8410 status = cli->dispatch(cli,
8411 mem_ctx,
8412 &ndr_table_ntsvcs,
8413 NDR_PNP_UNREGISTERNOTIFICATION,
8414 &r);
8415
8416 if (!NT_STATUS_IS_OK(status)) {
8417 return status;
8418 }
8419
8420 if (NT_STATUS_IS_ERR(status)) {
8421 return status;
8422 }
8423
8424 /* Return variables */
8425
8426 /* Return result */
8427 if (werror) {
8428 *werror = r.out.result;
8429 }
8430
8431 return werror_to_ntstatus(r.out.result);
8432 }
8433
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);
8439 };
8440
8441 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req *subreq);
8442
8443 struct tevent_req *rpccli_PNP_GetCustomDevProp_send(TALLOC_CTX *mem_ctx,
8444 struct tevent_context *ev,
8445 struct rpc_pipe_client *cli)
8446 {
8447 struct tevent_req *req;
8448 struct rpccli_PNP_GetCustomDevProp_state *state;
8449 struct tevent_req *subreq;
8450
8451 req = tevent_req_create(mem_ctx, &state,
8452 struct rpccli_PNP_GetCustomDevProp_state);
8453 if (req == NULL) {
8454 return NULL;
8455 }
8456 state->out_mem_ctx = NULL;
8457 state->dispatch_recv = cli->dispatch_recv;
8458
8459 /* In parameters */
8460
8461 /* Out parameters */
8462
8463 /* Result */
8464 ZERO_STRUCT(state->orig.out.result);
8465
8466 /* make a temporary copy, that we pass to the dispatch function */
8467 state->tmp = state->orig;
8468
8469 subreq = cli->dispatch_send(state, ev, cli,
8470 &ndr_table_ntsvcs,
8471 NDR_PNP_GETCUSTOMDEVPROP,
8472 &state->tmp);
8473 if (tevent_req_nomem(subreq, req)) {
8474 return tevent_req_post(req, ev);
8475 }
8476 tevent_req_set_callback(subreq, rpccli_PNP_GetCustomDevProp_done, req);
8477 return req;
8478 }
8479
8480 static void rpccli_PNP_GetCustomDevProp_done(struct tevent_req *subreq)
8481 {
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);
8486 NTSTATUS status;
8487 TALLOC_CTX *mem_ctx;
8488
8489 if (state->out_mem_ctx) {
8490 mem_ctx = state->out_mem_ctx;
8491 } else {
8492 mem_ctx = state;
8493 }
8494
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);
8499 return;
8500 }
8501
8502 /* Copy out parameters */
8503
8504 /* Copy result */
8505 state->orig.out.result = state->tmp.out.result;
8506
8507 /* Reset temporary structure */
8508 ZERO_STRUCT(state->tmp);
8509
8510 tevent_req_done(req);
8511 }
8512
8513 NTSTATUS rpccli_PNP_GetCustomDevProp_recv(struct tevent_req *req,
8514 TALLOC_CTX *mem_ctx,
8515 WERROR *result)
8516 {
8517 struct rpccli_PNP_GetCustomDevProp_state *state = tevent_req_data(
8518 req, struct rpccli_PNP_GetCustomDevProp_state);
8519 NTSTATUS status;
8520
8521 if (tevent_req_is_nterror(req, &status)) {
8522 tevent_req_received(req);
8523 return status;
8524 }
8525
8526 /* Steal possbile out parameters to the callers context */
8527 talloc_steal(mem_ctx, state->out_mem_ctx);
8528
8529 /* Return result */
8530 *result = state->orig.out.result;
8531
8532 tevent_req_received(req);
8533 return NT_STATUS_OK;
8534 }
8535
8536 NTSTATUS rpccli_PNP_GetCustomDevProp(struct rpc_pipe_client *cli,
8537 TALLOC_CTX *mem_ctx,
8538 WERROR *werror)
8539 {
8540 struct PNP_GetCustomDevProp r;
8541 NTSTATUS status;
8542
8543 /* In parameters */
8544
8545 status = cli->dispatch(cli,
8546 mem_ctx,
8547 &ndr_table_ntsvcs,
8548 NDR_PNP_GETCUSTOMDEVPROP,
8549 &r);
8550
8551 if (!NT_STATUS_IS_OK(status)) {
8552 return status;
8553 }
8554
8555 if (NT_STATUS_IS_ERR(status)) {
8556 return status;
8557 }
8558
8559 /* Return variables */
8560
8561 /* Return result */
8562 if (werror) {
8563 *werror = r.out.result;
8564 }
8565
8566 return werror_to_ntstatus(r.out.result);
8567 }
8568
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);
8574 };
8575
8576 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req *subreq);
8577
8578 struct tevent_req *rpccli_PNP_GetVersionInternal_send(TALLOC_CTX *mem_ctx,
8579 struct tevent_context *ev,
8580 struct rpc_pipe_client *cli)
8581 {
8582 struct tevent_req *req;
8583 struct rpccli_PNP_GetVersionInternal_state *state;
8584 struct tevent_req *subreq;
8585
8586 req = tevent_req_create(mem_ctx, &state,
8587 struct rpccli_PNP_GetVersionInternal_state);
8588 if (req == NULL) {
8589 return NULL;
8590 }
8591 state->out_mem_ctx = NULL;
8592 state->dispatch_recv = cli->dispatch_recv;
8593
8594 /* In parameters */
8595
8596 /* Out parameters */
8597
8598 /* Result */
8599 ZERO_STRUCT(state->orig.out.result);
8600
8601 /* make a temporary copy, that we pass to the dispatch function */
8602 state->tmp = state->orig;
8603
8604 subreq = cli->dispatch_send(state, ev, cli,
8605 &ndr_table_ntsvcs,
8606 NDR_PNP_GETVERSIONINTERNAL,
8607 &state->tmp);
8608 if (tevent_req_nomem(subreq, req)) {
8609 return tevent_req_post(req, ev);
8610 }
8611 tevent_req_set_callback(subreq, rpccli_PNP_GetVersionInternal_done, req);
8612 return req;
8613 }
8614
8615 static void rpccli_PNP_GetVersionInternal_done(struct tevent_req *subreq)
8616 {
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);
8621 NTSTATUS status;
8622 TALLOC_CTX *mem_ctx;
8623
8624 if (state->out_mem_ctx) {
8625 mem_ctx = state->out_mem_ctx;
8626 } else {
8627 mem_ctx = state;
8628 }
8629
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);
8634 return;
8635 }
8636
8637 /* Copy out parameters */
8638
8639 /* Copy result */
8640 state->orig.out.result = state->tmp.out.result;
8641
8642 /* Reset temporary structure */
8643 ZERO_STRUCT(state->tmp);
8644
8645 tevent_req_done(req);
8646 }
8647
8648 NTSTATUS rpccli_PNP_GetVersionInternal_recv(struct tevent_req *req,
8649 TALLOC_CTX *mem_ctx,
8650 WERROR *result)
8651 {
8652 struct rpccli_PNP_GetVersionInternal_state *state = tevent_req_data(
8653 req, struct rpccli_PNP_GetVersionInternal_state);
8654 NTSTATUS status;
8655
8656 if (tevent_req_is_nterror(req, &status)) {
8657 tevent_req_received(req);
8658 return status;
8659 }
8660
8661 /* Steal possbile out parameters to the callers context */
8662 talloc_steal(mem_ctx, state->out_mem_ctx);
8663
8664 /* Return result */
8665 *result = state->orig.out.result;
8666
8667 tevent_req_received(req);
8668 return NT_STATUS_OK;
8669 }
8670
8671 NTSTATUS rpccli_PNP_GetVersionInternal(struct rpc_pipe_client *cli,
8672 TALLOC_CTX *mem_ctx,
8673 WERROR *werror)
8674 {
8675 struct PNP_GetVersionInternal r;
8676 NTSTATUS status;
8677
8678 /* In parameters */
8679
8680 status = cli->dispatch(cli,
8681 mem_ctx,
8682 &ndr_table_ntsvcs,
8683 NDR_PNP_GETVERSIONINTERNAL,
8684 &r);
8685
8686 if (!NT_STATUS_IS_OK(status)) {
8687 return status;
8688 }
8689
8690 if (NT_STATUS_IS_ERR(status)) {
8691 return status;
8692 }
8693
8694 /* Return variables */
8695
8696 /* Return result */
8697 if (werror) {
8698 *werror = r.out.result;
8699 }
8700
8701 return werror_to_ntstatus(r.out.result);
8702 }
8703
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);
8709 };
8710
8711 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req *subreq);
8712
8713 struct tevent_req *rpccli_PNP_GetBlockedDriverInfo_send(TALLOC_CTX *mem_ctx,
8714 struct tevent_context *ev,
8715 struct rpc_pipe_client *cli)
8716 {
8717 struct tevent_req *req;
8718 struct rpccli_PNP_GetBlockedDriverInfo_state *state;
8719 struct tevent_req *subreq;
8720
8721 req = tevent_req_create(mem_ctx, &state,
8722 struct rpccli_PNP_GetBlockedDriverInfo_state);
8723 if (req == NULL) {
8724 return NULL;
8725 }
8726 state->out_mem_ctx = NULL;
8727 state->dispatch_recv = cli->dispatch_recv;
8728
8729 /* In parameters */
8730
8731 /* Out parameters */
8732
8733 /* Result */
8734 ZERO_STRUCT(state->orig.out.result);
8735
8736 /* make a temporary copy, that we pass to the dispatch function */
8737 state->tmp = state->orig;
8738
8739 subreq = cli->dispatch_send(state, ev, cli,
8740 &ndr_table_ntsvcs,
8741 NDR_PNP_GETBLOCKEDDRIVERINFO,
8742 &state->tmp);
8743 if (tevent_req_nomem(subreq, req)) {
8744 return tevent_req_post(req, ev);
8745 }
8746 tevent_req_set_callback(subreq, rpccli_PNP_GetBlockedDriverInfo_done, req);
8747 return req;
8748 }
8749
8750 static void rpccli_PNP_GetBlockedDriverInfo_done(struct tevent_req *subreq)
8751 {
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);
8756 NTSTATUS status;
8757 TALLOC_CTX *mem_ctx;
8758
8759 if (state->out_mem_ctx) {
8760 mem_ctx = state->out_mem_ctx;
8761 } else {
8762 mem_ctx = state;
8763 }
8764
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);
8769 return;
8770 }
8771
8772 /* Copy out parameters */
8773
8774 /* Copy result */
8775 state->orig.out.result = state->tmp.out.result;
8776
8777 /* Reset temporary structure */
8778 ZERO_STRUCT(state->tmp);
8779
8780 tevent_req_done(req);
8781 }
8782
8783 NTSTATUS rpccli_PNP_GetBlockedDriverInfo_recv(struct tevent_req *req,
8784 TALLOC_CTX *mem_ctx,
8785 WERROR *result)
8786 {
8787 struct rpccli_PNP_GetBlockedDriverInfo_state *state = tevent_req_data(
8788 req, struct rpccli_PNP_GetBlockedDriverInfo_state);
8789 NTSTATUS status;
8790
8791 if (tevent_req_is_nterror(req, &status)) {
8792 tevent_req_received(req);
8793 return status;
8794 }
8795
8796 /* Steal possbile out parameters to the callers context */
8797 talloc_steal(mem_ctx, state->out_mem_ctx);
8798
8799 /* Return result */
8800 *result = state->orig.out.result;
8801
8802 tevent_req_received(req);
8803 return NT_STATUS_OK;
8804 }
8805
8806 NTSTATUS rpccli_PNP_GetBlockedDriverInfo(struct rpc_pipe_client *cli,
8807 TALLOC_CTX *mem_ctx,
8808 WERROR *werror)
8809 {
8810 struct PNP_GetBlockedDriverInfo r;
8811 NTSTATUS status;
8812
8813 /* In parameters */
8814
8815 status = cli->dispatch(cli,
8816 mem_ctx,
8817 &ndr_table_ntsvcs,
8818 NDR_PNP_GETBLOCKEDDRIVERINFO,
8819 &r);
8820
8821 if (!NT_STATUS_IS_OK(status)) {
8822 return status;
8823 }
8824
8825 if (NT_STATUS_IS_ERR(status)) {
8826 return status;
8827 }
8828
8829 /* Return variables */
8830
8831 /* Return result */
8832 if (werror) {
8833 *werror = r.out.result;
8834 }
8835
8836 return werror_to_ntstatus(r.out.result);
8837 }
8838
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);
8844 };
8845
8846 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req *subreq);
8847
8848 struct tevent_req *rpccli_PNP_GetServerSideDeviceInstallFlags_send(TALLOC_CTX *mem_ctx,
8849 struct tevent_context *ev,
8850 struct rpc_pipe_client *cli)
8851 {
8852 struct tevent_req *req;
8853 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state *state;
8854 struct tevent_req *subreq;
8855
8856 req = tevent_req_create(mem_ctx, &state,
8857 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state);
8858 if (req == NULL) {
8859 return NULL;
8860 }
8861 state->out_mem_ctx = NULL;
8862 state->dispatch_recv = cli->dispatch_recv;
8863
8864 /* In parameters */
8865
8866 /* Out parameters */
8867
8868 /* Result */
8869 ZERO_STRUCT(state->orig.out.result);
8870
8871 /* make a temporary copy, that we pass to the dispatch function */
8872 state->tmp = state->orig;
8873
8874 subreq = cli->dispatch_send(state, ev, cli,
8875 &ndr_table_ntsvcs,
8876 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
8877 &state->tmp);
8878 if (tevent_req_nomem(subreq, req)) {
8879 return tevent_req_post(req, ev);
8880 }
8881 tevent_req_set_callback(subreq, rpccli_PNP_GetServerSideDeviceInstallFlags_done, req);
8882 return req;
8883 }
8884
8885 static void rpccli_PNP_GetServerSideDeviceInstallFlags_done(struct tevent_req *subreq)
8886 {
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);
8891 NTSTATUS status;
8892 TALLOC_CTX *mem_ctx;
8893
8894 if (state->out_mem_ctx) {
8895 mem_ctx = state->out_mem_ctx;
8896 } else {
8897 mem_ctx = state;
8898 }
8899
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);
8904 return;
8905 }
8906
8907 /* Copy out parameters */
8908
8909 /* Copy result */
8910 state->orig.out.result = state->tmp.out.result;
8911
8912 /* Reset temporary structure */
8913 ZERO_STRUCT(state->tmp);
8914
8915 tevent_req_done(req);
8916 }
8917
8918 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags_recv(struct tevent_req *req,
8919 TALLOC_CTX *mem_ctx,
8920 WERROR *result)
8921 {
8922 struct rpccli_PNP_GetServerSideDeviceInstallFlags_state *state = tevent_req_data(
8923 req, struct rpccli_PNP_GetServerSideDeviceInstallFlags_state);
8924 NTSTATUS status;
8925
8926 if (tevent_req_is_nterror(req, &status)) {
8927 tevent_req_received(req);
8928 return status;
8929 }
8930
8931 /* Steal possbile out parameters to the callers context */
8932 talloc_steal(mem_ctx, state->out_mem_ctx);
8933
8934 /* Return result */
8935 *result = state->orig.out.result;
8936
8937 tevent_req_received(req);
8938 return NT_STATUS_OK;
8939 }
8940
8941 NTSTATUS rpccli_PNP_GetServerSideDeviceInstallFlags(struct rpc_pipe_client *cli,
8942 TALLOC_CTX *mem_ctx,
8943 WERROR *werror)
8944 {
8945 struct PNP_GetServerSideDeviceInstallFlags r;
8946 NTSTATUS status;
8947
8948 /* In parameters */
8949
8950 status = cli->dispatch(cli,
8951 mem_ctx,
8952 &ndr_table_ntsvcs,
8953 NDR_PNP_GETSERVERSIDEDEVICEINSTALLFLAGS,
8954 &r);
8955
8956 if (!NT_STATUS_IS_OK(status)) {
8957 return status;
8958 }
8959
8960 if (NT_STATUS_IS_ERR(status)) {
8961 return status;
8962 }
8963
8964 /* Return variables */
8965
8966 /* Return result */
8967 if (werror) {
8968 *werror = r.out.result;
8969 }
8970
8971 return werror_to_ntstatus(r.out.result);
8972 }
8973
reg import