Share RPC binding string utility functions.
[samba.git] / source3 / librpc / gen_ndr / srv_ntsvcs.c
1 /*
2  * Unix SMB/CIFS implementation.
3  * server auto-generated by pidl. DO NOT MODIFY!
4  */
5
6 #include "includes.h"
7 #include "librpc/gen_ndr/srv_ntsvcs.h"
8
9 static bool api_PNP_Disconnect(pipes_struct *p)
10 {
11         const struct ndr_interface_call *call;
12         struct ndr_pull *pull;
13         struct ndr_push *push;
14         enum ndr_err_code ndr_err;
15         DATA_BLOB blob;
16         struct PNP_Disconnect *r;
17
18         call = &ndr_table_ntsvcs.calls[NDR_PNP_DISCONNECT];
19
20         r = talloc(talloc_tos(), struct PNP_Disconnect);
21         if (r == NULL) {
22                 return false;
23         }
24
25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26                 talloc_free(r);
27                 return false;
28         }
29
30         pull = ndr_pull_init_blob(&blob, r, NULL);
31         if (pull == NULL) {
32                 talloc_free(r);
33                 return false;
34         }
35
36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39                 talloc_free(r);
40                 return false;
41         }
42
43         if (DEBUGLEVEL >= 10) {
44                 NDR_PRINT_IN_DEBUG(PNP_Disconnect, r);
45         }
46
47         r->out.result = _PNP_Disconnect(p, r);
48
49         if (p->rng_fault_state) {
50                 talloc_free(r);
51                 /* Return true here, srv_pipe_hnd.c will take care */
52                 return true;
53         }
54
55         if (DEBUGLEVEL >= 10) {
56                 NDR_PRINT_OUT_DEBUG(PNP_Disconnect, r);
57         }
58
59         push = ndr_push_init_ctx(r, NULL);
60         if (push == NULL) {
61                 talloc_free(r);
62                 return false;
63         }
64
65         ndr_err = call->ndr_push(push, NDR_OUT, r);
66         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
67                 talloc_free(r);
68                 return false;
69         }
70
71         blob = ndr_push_blob(push);
72         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
73                 talloc_free(r);
74                 return false;
75         }
76
77         talloc_free(r);
78
79         return true;
80 }
81
82 static bool api_PNP_Connect(pipes_struct *p)
83 {
84         const struct ndr_interface_call *call;
85         struct ndr_pull *pull;
86         struct ndr_push *push;
87         enum ndr_err_code ndr_err;
88         DATA_BLOB blob;
89         struct PNP_Connect *r;
90
91         call = &ndr_table_ntsvcs.calls[NDR_PNP_CONNECT];
92
93         r = talloc(talloc_tos(), struct PNP_Connect);
94         if (r == NULL) {
95                 return false;
96         }
97
98         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
99                 talloc_free(r);
100                 return false;
101         }
102
103         pull = ndr_pull_init_blob(&blob, r, NULL);
104         if (pull == NULL) {
105                 talloc_free(r);
106                 return false;
107         }
108
109         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
110         ndr_err = call->ndr_pull(pull, NDR_IN, r);
111         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
112                 talloc_free(r);
113                 return false;
114         }
115
116         if (DEBUGLEVEL >= 10) {
117                 NDR_PRINT_IN_DEBUG(PNP_Connect, r);
118         }
119
120         r->out.result = _PNP_Connect(p, r);
121
122         if (p->rng_fault_state) {
123                 talloc_free(r);
124                 /* Return true here, srv_pipe_hnd.c will take care */
125                 return true;
126         }
127
128         if (DEBUGLEVEL >= 10) {
129                 NDR_PRINT_OUT_DEBUG(PNP_Connect, r);
130         }
131
132         push = ndr_push_init_ctx(r, NULL);
133         if (push == NULL) {
134                 talloc_free(r);
135                 return false;
136         }
137
138         ndr_err = call->ndr_push(push, NDR_OUT, r);
139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
140                 talloc_free(r);
141                 return false;
142         }
143
144         blob = ndr_push_blob(push);
145         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
146                 talloc_free(r);
147                 return false;
148         }
149
150         talloc_free(r);
151
152         return true;
153 }
154
155 static bool api_PNP_GetVersion(pipes_struct *p)
156 {
157         const struct ndr_interface_call *call;
158         struct ndr_pull *pull;
159         struct ndr_push *push;
160         enum ndr_err_code ndr_err;
161         DATA_BLOB blob;
162         struct PNP_GetVersion *r;
163
164         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETVERSION];
165
166         r = talloc(talloc_tos(), struct PNP_GetVersion);
167         if (r == NULL) {
168                 return false;
169         }
170
171         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
172                 talloc_free(r);
173                 return false;
174         }
175
176         pull = ndr_pull_init_blob(&blob, r, NULL);
177         if (pull == NULL) {
178                 talloc_free(r);
179                 return false;
180         }
181
182         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
183         ndr_err = call->ndr_pull(pull, NDR_IN, r);
184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
185                 talloc_free(r);
186                 return false;
187         }
188
189         if (DEBUGLEVEL >= 10) {
190                 NDR_PRINT_IN_DEBUG(PNP_GetVersion, r);
191         }
192
193         ZERO_STRUCT(r->out);
194         r->out.version = talloc_zero(r, uint16_t);
195         if (r->out.version == NULL) {
196                 talloc_free(r);
197                 return false;
198         }
199
200         r->out.result = _PNP_GetVersion(p, r);
201
202         if (p->rng_fault_state) {
203                 talloc_free(r);
204                 /* Return true here, srv_pipe_hnd.c will take care */
205                 return true;
206         }
207
208         if (DEBUGLEVEL >= 10) {
209                 NDR_PRINT_OUT_DEBUG(PNP_GetVersion, r);
210         }
211
212         push = ndr_push_init_ctx(r, NULL);
213         if (push == NULL) {
214                 talloc_free(r);
215                 return false;
216         }
217
218         ndr_err = call->ndr_push(push, NDR_OUT, r);
219         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
220                 talloc_free(r);
221                 return false;
222         }
223
224         blob = ndr_push_blob(push);
225         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
226                 talloc_free(r);
227                 return false;
228         }
229
230         talloc_free(r);
231
232         return true;
233 }
234
235 static bool api_PNP_GetGlobalState(pipes_struct *p)
236 {
237         const struct ndr_interface_call *call;
238         struct ndr_pull *pull;
239         struct ndr_push *push;
240         enum ndr_err_code ndr_err;
241         DATA_BLOB blob;
242         struct PNP_GetGlobalState *r;
243
244         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETGLOBALSTATE];
245
246         r = talloc(talloc_tos(), struct PNP_GetGlobalState);
247         if (r == NULL) {
248                 return false;
249         }
250
251         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
252                 talloc_free(r);
253                 return false;
254         }
255
256         pull = ndr_pull_init_blob(&blob, r, NULL);
257         if (pull == NULL) {
258                 talloc_free(r);
259                 return false;
260         }
261
262         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
263         ndr_err = call->ndr_pull(pull, NDR_IN, r);
264         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
265                 talloc_free(r);
266                 return false;
267         }
268
269         if (DEBUGLEVEL >= 10) {
270                 NDR_PRINT_IN_DEBUG(PNP_GetGlobalState, r);
271         }
272
273         r->out.result = _PNP_GetGlobalState(p, r);
274
275         if (p->rng_fault_state) {
276                 talloc_free(r);
277                 /* Return true here, srv_pipe_hnd.c will take care */
278                 return true;
279         }
280
281         if (DEBUGLEVEL >= 10) {
282                 NDR_PRINT_OUT_DEBUG(PNP_GetGlobalState, r);
283         }
284
285         push = ndr_push_init_ctx(r, NULL);
286         if (push == NULL) {
287                 talloc_free(r);
288                 return false;
289         }
290
291         ndr_err = call->ndr_push(push, NDR_OUT, r);
292         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
293                 talloc_free(r);
294                 return false;
295         }
296
297         blob = ndr_push_blob(push);
298         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
299                 talloc_free(r);
300                 return false;
301         }
302
303         talloc_free(r);
304
305         return true;
306 }
307
308 static bool api_PNP_InitDetection(pipes_struct *p)
309 {
310         const struct ndr_interface_call *call;
311         struct ndr_pull *pull;
312         struct ndr_push *push;
313         enum ndr_err_code ndr_err;
314         DATA_BLOB blob;
315         struct PNP_InitDetection *r;
316
317         call = &ndr_table_ntsvcs.calls[NDR_PNP_INITDETECTION];
318
319         r = talloc(talloc_tos(), struct PNP_InitDetection);
320         if (r == NULL) {
321                 return false;
322         }
323
324         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
325                 talloc_free(r);
326                 return false;
327         }
328
329         pull = ndr_pull_init_blob(&blob, r, NULL);
330         if (pull == NULL) {
331                 talloc_free(r);
332                 return false;
333         }
334
335         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
336         ndr_err = call->ndr_pull(pull, NDR_IN, r);
337         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
338                 talloc_free(r);
339                 return false;
340         }
341
342         if (DEBUGLEVEL >= 10) {
343                 NDR_PRINT_IN_DEBUG(PNP_InitDetection, r);
344         }
345
346         r->out.result = _PNP_InitDetection(p, r);
347
348         if (p->rng_fault_state) {
349                 talloc_free(r);
350                 /* Return true here, srv_pipe_hnd.c will take care */
351                 return true;
352         }
353
354         if (DEBUGLEVEL >= 10) {
355                 NDR_PRINT_OUT_DEBUG(PNP_InitDetection, r);
356         }
357
358         push = ndr_push_init_ctx(r, NULL);
359         if (push == NULL) {
360                 talloc_free(r);
361                 return false;
362         }
363
364         ndr_err = call->ndr_push(push, NDR_OUT, r);
365         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
366                 talloc_free(r);
367                 return false;
368         }
369
370         blob = ndr_push_blob(push);
371         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
372                 talloc_free(r);
373                 return false;
374         }
375
376         talloc_free(r);
377
378         return true;
379 }
380
381 static bool api_PNP_ReportLogOn(pipes_struct *p)
382 {
383         const struct ndr_interface_call *call;
384         struct ndr_pull *pull;
385         struct ndr_push *push;
386         enum ndr_err_code ndr_err;
387         DATA_BLOB blob;
388         struct PNP_ReportLogOn *r;
389
390         call = &ndr_table_ntsvcs.calls[NDR_PNP_REPORTLOGON];
391
392         r = talloc(talloc_tos(), struct PNP_ReportLogOn);
393         if (r == NULL) {
394                 return false;
395         }
396
397         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
398                 talloc_free(r);
399                 return false;
400         }
401
402         pull = ndr_pull_init_blob(&blob, r, NULL);
403         if (pull == NULL) {
404                 talloc_free(r);
405                 return false;
406         }
407
408         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
409         ndr_err = call->ndr_pull(pull, NDR_IN, r);
410         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
411                 talloc_free(r);
412                 return false;
413         }
414
415         if (DEBUGLEVEL >= 10) {
416                 NDR_PRINT_IN_DEBUG(PNP_ReportLogOn, r);
417         }
418
419         r->out.result = _PNP_ReportLogOn(p, r);
420
421         if (p->rng_fault_state) {
422                 talloc_free(r);
423                 /* Return true here, srv_pipe_hnd.c will take care */
424                 return true;
425         }
426
427         if (DEBUGLEVEL >= 10) {
428                 NDR_PRINT_OUT_DEBUG(PNP_ReportLogOn, r);
429         }
430
431         push = ndr_push_init_ctx(r, NULL);
432         if (push == NULL) {
433                 talloc_free(r);
434                 return false;
435         }
436
437         ndr_err = call->ndr_push(push, NDR_OUT, r);
438         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
439                 talloc_free(r);
440                 return false;
441         }
442
443         blob = ndr_push_blob(push);
444         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
445                 talloc_free(r);
446                 return false;
447         }
448
449         talloc_free(r);
450
451         return true;
452 }
453
454 static bool api_PNP_ValidateDeviceInstance(pipes_struct *p)
455 {
456         const struct ndr_interface_call *call;
457         struct ndr_pull *pull;
458         struct ndr_push *push;
459         enum ndr_err_code ndr_err;
460         DATA_BLOB blob;
461         struct PNP_ValidateDeviceInstance *r;
462
463         call = &ndr_table_ntsvcs.calls[NDR_PNP_VALIDATEDEVICEINSTANCE];
464
465         r = talloc(talloc_tos(), struct PNP_ValidateDeviceInstance);
466         if (r == NULL) {
467                 return false;
468         }
469
470         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
471                 talloc_free(r);
472                 return false;
473         }
474
475         pull = ndr_pull_init_blob(&blob, r, NULL);
476         if (pull == NULL) {
477                 talloc_free(r);
478                 return false;
479         }
480
481         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
482         ndr_err = call->ndr_pull(pull, NDR_IN, r);
483         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
484                 talloc_free(r);
485                 return false;
486         }
487
488         if (DEBUGLEVEL >= 10) {
489                 NDR_PRINT_IN_DEBUG(PNP_ValidateDeviceInstance, r);
490         }
491
492         r->out.result = _PNP_ValidateDeviceInstance(p, r);
493
494         if (p->rng_fault_state) {
495                 talloc_free(r);
496                 /* Return true here, srv_pipe_hnd.c will take care */
497                 return true;
498         }
499
500         if (DEBUGLEVEL >= 10) {
501                 NDR_PRINT_OUT_DEBUG(PNP_ValidateDeviceInstance, r);
502         }
503
504         push = ndr_push_init_ctx(r, NULL);
505         if (push == NULL) {
506                 talloc_free(r);
507                 return false;
508         }
509
510         ndr_err = call->ndr_push(push, NDR_OUT, r);
511         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
512                 talloc_free(r);
513                 return false;
514         }
515
516         blob = ndr_push_blob(push);
517         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
518                 talloc_free(r);
519                 return false;
520         }
521
522         talloc_free(r);
523
524         return true;
525 }
526
527 static bool api_PNP_GetRootDeviceInstance(pipes_struct *p)
528 {
529         const struct ndr_interface_call *call;
530         struct ndr_pull *pull;
531         struct ndr_push *push;
532         enum ndr_err_code ndr_err;
533         DATA_BLOB blob;
534         struct PNP_GetRootDeviceInstance *r;
535
536         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETROOTDEVICEINSTANCE];
537
538         r = talloc(talloc_tos(), struct PNP_GetRootDeviceInstance);
539         if (r == NULL) {
540                 return false;
541         }
542
543         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
544                 talloc_free(r);
545                 return false;
546         }
547
548         pull = ndr_pull_init_blob(&blob, r, NULL);
549         if (pull == NULL) {
550                 talloc_free(r);
551                 return false;
552         }
553
554         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
555         ndr_err = call->ndr_pull(pull, NDR_IN, r);
556         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
557                 talloc_free(r);
558                 return false;
559         }
560
561         if (DEBUGLEVEL >= 10) {
562                 NDR_PRINT_IN_DEBUG(PNP_GetRootDeviceInstance, r);
563         }
564
565         r->out.result = _PNP_GetRootDeviceInstance(p, r);
566
567         if (p->rng_fault_state) {
568                 talloc_free(r);
569                 /* Return true here, srv_pipe_hnd.c will take care */
570                 return true;
571         }
572
573         if (DEBUGLEVEL >= 10) {
574                 NDR_PRINT_OUT_DEBUG(PNP_GetRootDeviceInstance, r);
575         }
576
577         push = ndr_push_init_ctx(r, NULL);
578         if (push == NULL) {
579                 talloc_free(r);
580                 return false;
581         }
582
583         ndr_err = call->ndr_push(push, NDR_OUT, r);
584         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
585                 talloc_free(r);
586                 return false;
587         }
588
589         blob = ndr_push_blob(push);
590         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
591                 talloc_free(r);
592                 return false;
593         }
594
595         talloc_free(r);
596
597         return true;
598 }
599
600 static bool api_PNP_GetRelatedDeviceInstance(pipes_struct *p)
601 {
602         const struct ndr_interface_call *call;
603         struct ndr_pull *pull;
604         struct ndr_push *push;
605         enum ndr_err_code ndr_err;
606         DATA_BLOB blob;
607         struct PNP_GetRelatedDeviceInstance *r;
608
609         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETRELATEDDEVICEINSTANCE];
610
611         r = talloc(talloc_tos(), struct PNP_GetRelatedDeviceInstance);
612         if (r == NULL) {
613                 return false;
614         }
615
616         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
617                 talloc_free(r);
618                 return false;
619         }
620
621         pull = ndr_pull_init_blob(&blob, r, NULL);
622         if (pull == NULL) {
623                 talloc_free(r);
624                 return false;
625         }
626
627         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
628         ndr_err = call->ndr_pull(pull, NDR_IN, r);
629         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
630                 talloc_free(r);
631                 return false;
632         }
633
634         if (DEBUGLEVEL >= 10) {
635                 NDR_PRINT_IN_DEBUG(PNP_GetRelatedDeviceInstance, r);
636         }
637
638         r->out.result = _PNP_GetRelatedDeviceInstance(p, r);
639
640         if (p->rng_fault_state) {
641                 talloc_free(r);
642                 /* Return true here, srv_pipe_hnd.c will take care */
643                 return true;
644         }
645
646         if (DEBUGLEVEL >= 10) {
647                 NDR_PRINT_OUT_DEBUG(PNP_GetRelatedDeviceInstance, r);
648         }
649
650         push = ndr_push_init_ctx(r, NULL);
651         if (push == NULL) {
652                 talloc_free(r);
653                 return false;
654         }
655
656         ndr_err = call->ndr_push(push, NDR_OUT, r);
657         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
658                 talloc_free(r);
659                 return false;
660         }
661
662         blob = ndr_push_blob(push);
663         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
664                 talloc_free(r);
665                 return false;
666         }
667
668         talloc_free(r);
669
670         return true;
671 }
672
673 static bool api_PNP_EnumerateSubKeys(pipes_struct *p)
674 {
675         const struct ndr_interface_call *call;
676         struct ndr_pull *pull;
677         struct ndr_push *push;
678         enum ndr_err_code ndr_err;
679         DATA_BLOB blob;
680         struct PNP_EnumerateSubKeys *r;
681
682         call = &ndr_table_ntsvcs.calls[NDR_PNP_ENUMERATESUBKEYS];
683
684         r = talloc(talloc_tos(), struct PNP_EnumerateSubKeys);
685         if (r == NULL) {
686                 return false;
687         }
688
689         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
690                 talloc_free(r);
691                 return false;
692         }
693
694         pull = ndr_pull_init_blob(&blob, r, NULL);
695         if (pull == NULL) {
696                 talloc_free(r);
697                 return false;
698         }
699
700         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
701         ndr_err = call->ndr_pull(pull, NDR_IN, r);
702         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
703                 talloc_free(r);
704                 return false;
705         }
706
707         if (DEBUGLEVEL >= 10) {
708                 NDR_PRINT_IN_DEBUG(PNP_EnumerateSubKeys, r);
709         }
710
711         r->out.result = _PNP_EnumerateSubKeys(p, r);
712
713         if (p->rng_fault_state) {
714                 talloc_free(r);
715                 /* Return true here, srv_pipe_hnd.c will take care */
716                 return true;
717         }
718
719         if (DEBUGLEVEL >= 10) {
720                 NDR_PRINT_OUT_DEBUG(PNP_EnumerateSubKeys, r);
721         }
722
723         push = ndr_push_init_ctx(r, NULL);
724         if (push == NULL) {
725                 talloc_free(r);
726                 return false;
727         }
728
729         ndr_err = call->ndr_push(push, NDR_OUT, r);
730         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
731                 talloc_free(r);
732                 return false;
733         }
734
735         blob = ndr_push_blob(push);
736         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
737                 talloc_free(r);
738                 return false;
739         }
740
741         talloc_free(r);
742
743         return true;
744 }
745
746 static bool api_PNP_GetDeviceList(pipes_struct *p)
747 {
748         const struct ndr_interface_call *call;
749         struct ndr_pull *pull;
750         struct ndr_push *push;
751         enum ndr_err_code ndr_err;
752         DATA_BLOB blob;
753         struct PNP_GetDeviceList *r;
754
755         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELIST];
756
757         r = talloc(talloc_tos(), struct PNP_GetDeviceList);
758         if (r == NULL) {
759                 return false;
760         }
761
762         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
763                 talloc_free(r);
764                 return false;
765         }
766
767         pull = ndr_pull_init_blob(&blob, r, NULL);
768         if (pull == NULL) {
769                 talloc_free(r);
770                 return false;
771         }
772
773         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
774         ndr_err = call->ndr_pull(pull, NDR_IN, r);
775         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
776                 talloc_free(r);
777                 return false;
778         }
779
780         if (DEBUGLEVEL >= 10) {
781                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceList, r);
782         }
783
784         r->out.result = _PNP_GetDeviceList(p, r);
785
786         if (p->rng_fault_state) {
787                 talloc_free(r);
788                 /* Return true here, srv_pipe_hnd.c will take care */
789                 return true;
790         }
791
792         if (DEBUGLEVEL >= 10) {
793                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceList, r);
794         }
795
796         push = ndr_push_init_ctx(r, NULL);
797         if (push == NULL) {
798                 talloc_free(r);
799                 return false;
800         }
801
802         ndr_err = call->ndr_push(push, NDR_OUT, r);
803         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
804                 talloc_free(r);
805                 return false;
806         }
807
808         blob = ndr_push_blob(push);
809         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
810                 talloc_free(r);
811                 return false;
812         }
813
814         talloc_free(r);
815
816         return true;
817 }
818
819 static bool api_PNP_GetDeviceListSize(pipes_struct *p)
820 {
821         const struct ndr_interface_call *call;
822         struct ndr_pull *pull;
823         struct ndr_push *push;
824         enum ndr_err_code ndr_err;
825         DATA_BLOB blob;
826         struct PNP_GetDeviceListSize *r;
827
828         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICELISTSIZE];
829
830         r = talloc(talloc_tos(), struct PNP_GetDeviceListSize);
831         if (r == NULL) {
832                 return false;
833         }
834
835         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
836                 talloc_free(r);
837                 return false;
838         }
839
840         pull = ndr_pull_init_blob(&blob, r, NULL);
841         if (pull == NULL) {
842                 talloc_free(r);
843                 return false;
844         }
845
846         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
847         ndr_err = call->ndr_pull(pull, NDR_IN, r);
848         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
849                 talloc_free(r);
850                 return false;
851         }
852
853         if (DEBUGLEVEL >= 10) {
854                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceListSize, r);
855         }
856
857         ZERO_STRUCT(r->out);
858         r->out.size = talloc_zero(r, uint32_t);
859         if (r->out.size == NULL) {
860                 talloc_free(r);
861                 return false;
862         }
863
864         r->out.result = _PNP_GetDeviceListSize(p, r);
865
866         if (p->rng_fault_state) {
867                 talloc_free(r);
868                 /* Return true here, srv_pipe_hnd.c will take care */
869                 return true;
870         }
871
872         if (DEBUGLEVEL >= 10) {
873                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceListSize, r);
874         }
875
876         push = ndr_push_init_ctx(r, NULL);
877         if (push == NULL) {
878                 talloc_free(r);
879                 return false;
880         }
881
882         ndr_err = call->ndr_push(push, NDR_OUT, r);
883         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
884                 talloc_free(r);
885                 return false;
886         }
887
888         blob = ndr_push_blob(push);
889         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
890                 talloc_free(r);
891                 return false;
892         }
893
894         talloc_free(r);
895
896         return true;
897 }
898
899 static bool api_PNP_GetDepth(pipes_struct *p)
900 {
901         const struct ndr_interface_call *call;
902         struct ndr_pull *pull;
903         struct ndr_push *push;
904         enum ndr_err_code ndr_err;
905         DATA_BLOB blob;
906         struct PNP_GetDepth *r;
907
908         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEPTH];
909
910         r = talloc(talloc_tos(), struct PNP_GetDepth);
911         if (r == NULL) {
912                 return false;
913         }
914
915         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
916                 talloc_free(r);
917                 return false;
918         }
919
920         pull = ndr_pull_init_blob(&blob, r, NULL);
921         if (pull == NULL) {
922                 talloc_free(r);
923                 return false;
924         }
925
926         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
927         ndr_err = call->ndr_pull(pull, NDR_IN, r);
928         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
929                 talloc_free(r);
930                 return false;
931         }
932
933         if (DEBUGLEVEL >= 10) {
934                 NDR_PRINT_IN_DEBUG(PNP_GetDepth, r);
935         }
936
937         r->out.result = _PNP_GetDepth(p, r);
938
939         if (p->rng_fault_state) {
940                 talloc_free(r);
941                 /* Return true here, srv_pipe_hnd.c will take care */
942                 return true;
943         }
944
945         if (DEBUGLEVEL >= 10) {
946                 NDR_PRINT_OUT_DEBUG(PNP_GetDepth, r);
947         }
948
949         push = ndr_push_init_ctx(r, NULL);
950         if (push == NULL) {
951                 talloc_free(r);
952                 return false;
953         }
954
955         ndr_err = call->ndr_push(push, NDR_OUT, r);
956         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
957                 talloc_free(r);
958                 return false;
959         }
960
961         blob = ndr_push_blob(push);
962         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
963                 talloc_free(r);
964                 return false;
965         }
966
967         talloc_free(r);
968
969         return true;
970 }
971
972 static bool api_PNP_GetDeviceRegProp(pipes_struct *p)
973 {
974         const struct ndr_interface_call *call;
975         struct ndr_pull *pull;
976         struct ndr_push *push;
977         enum ndr_err_code ndr_err;
978         DATA_BLOB blob;
979         struct PNP_GetDeviceRegProp *r;
980
981         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICEREGPROP];
982
983         r = talloc(talloc_tos(), struct PNP_GetDeviceRegProp);
984         if (r == NULL) {
985                 return false;
986         }
987
988         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
989                 talloc_free(r);
990                 return false;
991         }
992
993         pull = ndr_pull_init_blob(&blob, r, NULL);
994         if (pull == NULL) {
995                 talloc_free(r);
996                 return false;
997         }
998
999         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1000         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1001         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1002                 talloc_free(r);
1003                 return false;
1004         }
1005
1006         if (DEBUGLEVEL >= 10) {
1007                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, r);
1008         }
1009
1010         ZERO_STRUCT(r->out);
1011         r->out.unknown1 = r->in.unknown1;
1012         r->out.buffer = talloc_zero_array(r, uint8_t, *r->out.buffer_size);
1013         if (r->out.buffer == NULL) {
1014                 talloc_free(r);
1015                 return false;
1016         }
1017
1018         r->out.buffer_size = r->in.buffer_size;
1019         r->out.needed = r->in.needed;
1020         r->out.result = _PNP_GetDeviceRegProp(p, r);
1021
1022         if (p->rng_fault_state) {
1023                 talloc_free(r);
1024                 /* Return true here, srv_pipe_hnd.c will take care */
1025                 return true;
1026         }
1027
1028         if (DEBUGLEVEL >= 10) {
1029                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, r);
1030         }
1031
1032         push = ndr_push_init_ctx(r, NULL);
1033         if (push == NULL) {
1034                 talloc_free(r);
1035                 return false;
1036         }
1037
1038         ndr_err = call->ndr_push(push, NDR_OUT, r);
1039         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1040                 talloc_free(r);
1041                 return false;
1042         }
1043
1044         blob = ndr_push_blob(push);
1045         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1046                 talloc_free(r);
1047                 return false;
1048         }
1049
1050         talloc_free(r);
1051
1052         return true;
1053 }
1054
1055 static bool api_PNP_SetDeviceRegProp(pipes_struct *p)
1056 {
1057         const struct ndr_interface_call *call;
1058         struct ndr_pull *pull;
1059         struct ndr_push *push;
1060         enum ndr_err_code ndr_err;
1061         DATA_BLOB blob;
1062         struct PNP_SetDeviceRegProp *r;
1063
1064         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEREGPROP];
1065
1066         r = talloc(talloc_tos(), struct PNP_SetDeviceRegProp);
1067         if (r == NULL) {
1068                 return false;
1069         }
1070
1071         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1072                 talloc_free(r);
1073                 return false;
1074         }
1075
1076         pull = ndr_pull_init_blob(&blob, r, NULL);
1077         if (pull == NULL) {
1078                 talloc_free(r);
1079                 return false;
1080         }
1081
1082         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1083         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1084         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1085                 talloc_free(r);
1086                 return false;
1087         }
1088
1089         if (DEBUGLEVEL >= 10) {
1090                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceRegProp, r);
1091         }
1092
1093         r->out.result = _PNP_SetDeviceRegProp(p, r);
1094
1095         if (p->rng_fault_state) {
1096                 talloc_free(r);
1097                 /* Return true here, srv_pipe_hnd.c will take care */
1098                 return true;
1099         }
1100
1101         if (DEBUGLEVEL >= 10) {
1102                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceRegProp, r);
1103         }
1104
1105         push = ndr_push_init_ctx(r, NULL);
1106         if (push == NULL) {
1107                 talloc_free(r);
1108                 return false;
1109         }
1110
1111         ndr_err = call->ndr_push(push, NDR_OUT, r);
1112         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1113                 talloc_free(r);
1114                 return false;
1115         }
1116
1117         blob = ndr_push_blob(push);
1118         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1119                 talloc_free(r);
1120                 return false;
1121         }
1122
1123         talloc_free(r);
1124
1125         return true;
1126 }
1127
1128 static bool api_PNP_GetClassInstance(pipes_struct *p)
1129 {
1130         const struct ndr_interface_call *call;
1131         struct ndr_pull *pull;
1132         struct ndr_push *push;
1133         enum ndr_err_code ndr_err;
1134         DATA_BLOB blob;
1135         struct PNP_GetClassInstance *r;
1136
1137         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSINSTANCE];
1138
1139         r = talloc(talloc_tos(), struct PNP_GetClassInstance);
1140         if (r == NULL) {
1141                 return false;
1142         }
1143
1144         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1145                 talloc_free(r);
1146                 return false;
1147         }
1148
1149         pull = ndr_pull_init_blob(&blob, r, NULL);
1150         if (pull == NULL) {
1151                 talloc_free(r);
1152                 return false;
1153         }
1154
1155         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1156         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1157         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1158                 talloc_free(r);
1159                 return false;
1160         }
1161
1162         if (DEBUGLEVEL >= 10) {
1163                 NDR_PRINT_IN_DEBUG(PNP_GetClassInstance, r);
1164         }
1165
1166         r->out.result = _PNP_GetClassInstance(p, r);
1167
1168         if (p->rng_fault_state) {
1169                 talloc_free(r);
1170                 /* Return true here, srv_pipe_hnd.c will take care */
1171                 return true;
1172         }
1173
1174         if (DEBUGLEVEL >= 10) {
1175                 NDR_PRINT_OUT_DEBUG(PNP_GetClassInstance, r);
1176         }
1177
1178         push = ndr_push_init_ctx(r, NULL);
1179         if (push == NULL) {
1180                 talloc_free(r);
1181                 return false;
1182         }
1183
1184         ndr_err = call->ndr_push(push, NDR_OUT, r);
1185         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1186                 talloc_free(r);
1187                 return false;
1188         }
1189
1190         blob = ndr_push_blob(push);
1191         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1192                 talloc_free(r);
1193                 return false;
1194         }
1195
1196         talloc_free(r);
1197
1198         return true;
1199 }
1200
1201 static bool api_PNP_CreateKey(pipes_struct *p)
1202 {
1203         const struct ndr_interface_call *call;
1204         struct ndr_pull *pull;
1205         struct ndr_push *push;
1206         enum ndr_err_code ndr_err;
1207         DATA_BLOB blob;
1208         struct PNP_CreateKey *r;
1209
1210         call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEKEY];
1211
1212         r = talloc(talloc_tos(), struct PNP_CreateKey);
1213         if (r == NULL) {
1214                 return false;
1215         }
1216
1217         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1218                 talloc_free(r);
1219                 return false;
1220         }
1221
1222         pull = ndr_pull_init_blob(&blob, r, NULL);
1223         if (pull == NULL) {
1224                 talloc_free(r);
1225                 return false;
1226         }
1227
1228         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1229         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1230         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1231                 talloc_free(r);
1232                 return false;
1233         }
1234
1235         if (DEBUGLEVEL >= 10) {
1236                 NDR_PRINT_IN_DEBUG(PNP_CreateKey, r);
1237         }
1238
1239         r->out.result = _PNP_CreateKey(p, r);
1240
1241         if (p->rng_fault_state) {
1242                 talloc_free(r);
1243                 /* Return true here, srv_pipe_hnd.c will take care */
1244                 return true;
1245         }
1246
1247         if (DEBUGLEVEL >= 10) {
1248                 NDR_PRINT_OUT_DEBUG(PNP_CreateKey, r);
1249         }
1250
1251         push = ndr_push_init_ctx(r, NULL);
1252         if (push == NULL) {
1253                 talloc_free(r);
1254                 return false;
1255         }
1256
1257         ndr_err = call->ndr_push(push, NDR_OUT, r);
1258         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1259                 talloc_free(r);
1260                 return false;
1261         }
1262
1263         blob = ndr_push_blob(push);
1264         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1265                 talloc_free(r);
1266                 return false;
1267         }
1268
1269         talloc_free(r);
1270
1271         return true;
1272 }
1273
1274 static bool api_PNP_DeleteRegistryKey(pipes_struct *p)
1275 {
1276         const struct ndr_interface_call *call;
1277         struct ndr_pull *pull;
1278         struct ndr_push *push;
1279         enum ndr_err_code ndr_err;
1280         DATA_BLOB blob;
1281         struct PNP_DeleteRegistryKey *r;
1282
1283         call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETEREGISTRYKEY];
1284
1285         r = talloc(talloc_tos(), struct PNP_DeleteRegistryKey);
1286         if (r == NULL) {
1287                 return false;
1288         }
1289
1290         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1291                 talloc_free(r);
1292                 return false;
1293         }
1294
1295         pull = ndr_pull_init_blob(&blob, r, NULL);
1296         if (pull == NULL) {
1297                 talloc_free(r);
1298                 return false;
1299         }
1300
1301         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1302         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1303         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1304                 talloc_free(r);
1305                 return false;
1306         }
1307
1308         if (DEBUGLEVEL >= 10) {
1309                 NDR_PRINT_IN_DEBUG(PNP_DeleteRegistryKey, r);
1310         }
1311
1312         r->out.result = _PNP_DeleteRegistryKey(p, r);
1313
1314         if (p->rng_fault_state) {
1315                 talloc_free(r);
1316                 /* Return true here, srv_pipe_hnd.c will take care */
1317                 return true;
1318         }
1319
1320         if (DEBUGLEVEL >= 10) {
1321                 NDR_PRINT_OUT_DEBUG(PNP_DeleteRegistryKey, r);
1322         }
1323
1324         push = ndr_push_init_ctx(r, NULL);
1325         if (push == NULL) {
1326                 talloc_free(r);
1327                 return false;
1328         }
1329
1330         ndr_err = call->ndr_push(push, NDR_OUT, r);
1331         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1332                 talloc_free(r);
1333                 return false;
1334         }
1335
1336         blob = ndr_push_blob(push);
1337         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1338                 talloc_free(r);
1339                 return false;
1340         }
1341
1342         talloc_free(r);
1343
1344         return true;
1345 }
1346
1347 static bool api_PNP_GetClassCount(pipes_struct *p)
1348 {
1349         const struct ndr_interface_call *call;
1350         struct ndr_pull *pull;
1351         struct ndr_push *push;
1352         enum ndr_err_code ndr_err;
1353         DATA_BLOB blob;
1354         struct PNP_GetClassCount *r;
1355
1356         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSCOUNT];
1357
1358         r = talloc(talloc_tos(), struct PNP_GetClassCount);
1359         if (r == NULL) {
1360                 return false;
1361         }
1362
1363         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1364                 talloc_free(r);
1365                 return false;
1366         }
1367
1368         pull = ndr_pull_init_blob(&blob, r, NULL);
1369         if (pull == NULL) {
1370                 talloc_free(r);
1371                 return false;
1372         }
1373
1374         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1375         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1376         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1377                 talloc_free(r);
1378                 return false;
1379         }
1380
1381         if (DEBUGLEVEL >= 10) {
1382                 NDR_PRINT_IN_DEBUG(PNP_GetClassCount, r);
1383         }
1384
1385         r->out.result = _PNP_GetClassCount(p, r);
1386
1387         if (p->rng_fault_state) {
1388                 talloc_free(r);
1389                 /* Return true here, srv_pipe_hnd.c will take care */
1390                 return true;
1391         }
1392
1393         if (DEBUGLEVEL >= 10) {
1394                 NDR_PRINT_OUT_DEBUG(PNP_GetClassCount, r);
1395         }
1396
1397         push = ndr_push_init_ctx(r, NULL);
1398         if (push == NULL) {
1399                 talloc_free(r);
1400                 return false;
1401         }
1402
1403         ndr_err = call->ndr_push(push, NDR_OUT, r);
1404         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1405                 talloc_free(r);
1406                 return false;
1407         }
1408
1409         blob = ndr_push_blob(push);
1410         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1411                 talloc_free(r);
1412                 return false;
1413         }
1414
1415         talloc_free(r);
1416
1417         return true;
1418 }
1419
1420 static bool api_PNP_GetClassName(pipes_struct *p)
1421 {
1422         const struct ndr_interface_call *call;
1423         struct ndr_pull *pull;
1424         struct ndr_push *push;
1425         enum ndr_err_code ndr_err;
1426         DATA_BLOB blob;
1427         struct PNP_GetClassName *r;
1428
1429         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSNAME];
1430
1431         r = talloc(talloc_tos(), struct PNP_GetClassName);
1432         if (r == NULL) {
1433                 return false;
1434         }
1435
1436         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1437                 talloc_free(r);
1438                 return false;
1439         }
1440
1441         pull = ndr_pull_init_blob(&blob, r, NULL);
1442         if (pull == NULL) {
1443                 talloc_free(r);
1444                 return false;
1445         }
1446
1447         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1448         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1449         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1450                 talloc_free(r);
1451                 return false;
1452         }
1453
1454         if (DEBUGLEVEL >= 10) {
1455                 NDR_PRINT_IN_DEBUG(PNP_GetClassName, r);
1456         }
1457
1458         r->out.result = _PNP_GetClassName(p, r);
1459
1460         if (p->rng_fault_state) {
1461                 talloc_free(r);
1462                 /* Return true here, srv_pipe_hnd.c will take care */
1463                 return true;
1464         }
1465
1466         if (DEBUGLEVEL >= 10) {
1467                 NDR_PRINT_OUT_DEBUG(PNP_GetClassName, r);
1468         }
1469
1470         push = ndr_push_init_ctx(r, NULL);
1471         if (push == NULL) {
1472                 talloc_free(r);
1473                 return false;
1474         }
1475
1476         ndr_err = call->ndr_push(push, NDR_OUT, r);
1477         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1478                 talloc_free(r);
1479                 return false;
1480         }
1481
1482         blob = ndr_push_blob(push);
1483         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1484                 talloc_free(r);
1485                 return false;
1486         }
1487
1488         talloc_free(r);
1489
1490         return true;
1491 }
1492
1493 static bool api_PNP_DeleteClassKey(pipes_struct *p)
1494 {
1495         const struct ndr_interface_call *call;
1496         struct ndr_pull *pull;
1497         struct ndr_push *push;
1498         enum ndr_err_code ndr_err;
1499         DATA_BLOB blob;
1500         struct PNP_DeleteClassKey *r;
1501
1502         call = &ndr_table_ntsvcs.calls[NDR_PNP_DELETECLASSKEY];
1503
1504         r = talloc(talloc_tos(), struct PNP_DeleteClassKey);
1505         if (r == NULL) {
1506                 return false;
1507         }
1508
1509         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1510                 talloc_free(r);
1511                 return false;
1512         }
1513
1514         pull = ndr_pull_init_blob(&blob, r, NULL);
1515         if (pull == NULL) {
1516                 talloc_free(r);
1517                 return false;
1518         }
1519
1520         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1521         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1522         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1523                 talloc_free(r);
1524                 return false;
1525         }
1526
1527         if (DEBUGLEVEL >= 10) {
1528                 NDR_PRINT_IN_DEBUG(PNP_DeleteClassKey, r);
1529         }
1530
1531         r->out.result = _PNP_DeleteClassKey(p, r);
1532
1533         if (p->rng_fault_state) {
1534                 talloc_free(r);
1535                 /* Return true here, srv_pipe_hnd.c will take care */
1536                 return true;
1537         }
1538
1539         if (DEBUGLEVEL >= 10) {
1540                 NDR_PRINT_OUT_DEBUG(PNP_DeleteClassKey, r);
1541         }
1542
1543         push = ndr_push_init_ctx(r, NULL);
1544         if (push == NULL) {
1545                 talloc_free(r);
1546                 return false;
1547         }
1548
1549         ndr_err = call->ndr_push(push, NDR_OUT, r);
1550         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1551                 talloc_free(r);
1552                 return false;
1553         }
1554
1555         blob = ndr_push_blob(push);
1556         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1557                 talloc_free(r);
1558                 return false;
1559         }
1560
1561         talloc_free(r);
1562
1563         return true;
1564 }
1565
1566 static bool api_PNP_GetInterfaceDeviceAlias(pipes_struct *p)
1567 {
1568         const struct ndr_interface_call *call;
1569         struct ndr_pull *pull;
1570         struct ndr_push *push;
1571         enum ndr_err_code ndr_err;
1572         DATA_BLOB blob;
1573         struct PNP_GetInterfaceDeviceAlias *r;
1574
1575         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICEALIAS];
1576
1577         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceAlias);
1578         if (r == NULL) {
1579                 return false;
1580         }
1581
1582         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1583                 talloc_free(r);
1584                 return false;
1585         }
1586
1587         pull = ndr_pull_init_blob(&blob, r, NULL);
1588         if (pull == NULL) {
1589                 talloc_free(r);
1590                 return false;
1591         }
1592
1593         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1594         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1595         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1596                 talloc_free(r);
1597                 return false;
1598         }
1599
1600         if (DEBUGLEVEL >= 10) {
1601                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1602         }
1603
1604         r->out.result = _PNP_GetInterfaceDeviceAlias(p, r);
1605
1606         if (p->rng_fault_state) {
1607                 talloc_free(r);
1608                 /* Return true here, srv_pipe_hnd.c will take care */
1609                 return true;
1610         }
1611
1612         if (DEBUGLEVEL >= 10) {
1613                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceAlias, r);
1614         }
1615
1616         push = ndr_push_init_ctx(r, NULL);
1617         if (push == NULL) {
1618                 talloc_free(r);
1619                 return false;
1620         }
1621
1622         ndr_err = call->ndr_push(push, NDR_OUT, r);
1623         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1624                 talloc_free(r);
1625                 return false;
1626         }
1627
1628         blob = ndr_push_blob(push);
1629         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1630                 talloc_free(r);
1631                 return false;
1632         }
1633
1634         talloc_free(r);
1635
1636         return true;
1637 }
1638
1639 static bool api_PNP_GetInterfaceDeviceList(pipes_struct *p)
1640 {
1641         const struct ndr_interface_call *call;
1642         struct ndr_pull *pull;
1643         struct ndr_push *push;
1644         enum ndr_err_code ndr_err;
1645         DATA_BLOB blob;
1646         struct PNP_GetInterfaceDeviceList *r;
1647
1648         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELIST];
1649
1650         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceList);
1651         if (r == NULL) {
1652                 return false;
1653         }
1654
1655         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1656                 talloc_free(r);
1657                 return false;
1658         }
1659
1660         pull = ndr_pull_init_blob(&blob, r, NULL);
1661         if (pull == NULL) {
1662                 talloc_free(r);
1663                 return false;
1664         }
1665
1666         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1667         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1668         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1669                 talloc_free(r);
1670                 return false;
1671         }
1672
1673         if (DEBUGLEVEL >= 10) {
1674                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceList, r);
1675         }
1676
1677         r->out.result = _PNP_GetInterfaceDeviceList(p, r);
1678
1679         if (p->rng_fault_state) {
1680                 talloc_free(r);
1681                 /* Return true here, srv_pipe_hnd.c will take care */
1682                 return true;
1683         }
1684
1685         if (DEBUGLEVEL >= 10) {
1686                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceList, r);
1687         }
1688
1689         push = ndr_push_init_ctx(r, NULL);
1690         if (push == NULL) {
1691                 talloc_free(r);
1692                 return false;
1693         }
1694
1695         ndr_err = call->ndr_push(push, NDR_OUT, r);
1696         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1697                 talloc_free(r);
1698                 return false;
1699         }
1700
1701         blob = ndr_push_blob(push);
1702         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1703                 talloc_free(r);
1704                 return false;
1705         }
1706
1707         talloc_free(r);
1708
1709         return true;
1710 }
1711
1712 static bool api_PNP_GetInterfaceDeviceListSize(pipes_struct *p)
1713 {
1714         const struct ndr_interface_call *call;
1715         struct ndr_pull *pull;
1716         struct ndr_push *push;
1717         enum ndr_err_code ndr_err;
1718         DATA_BLOB blob;
1719         struct PNP_GetInterfaceDeviceListSize *r;
1720
1721         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETINTERFACEDEVICELISTSIZE];
1722
1723         r = talloc(talloc_tos(), struct PNP_GetInterfaceDeviceListSize);
1724         if (r == NULL) {
1725                 return false;
1726         }
1727
1728         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1729                 talloc_free(r);
1730                 return false;
1731         }
1732
1733         pull = ndr_pull_init_blob(&blob, r, NULL);
1734         if (pull == NULL) {
1735                 talloc_free(r);
1736                 return false;
1737         }
1738
1739         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1740         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1741         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1742                 talloc_free(r);
1743                 return false;
1744         }
1745
1746         if (DEBUGLEVEL >= 10) {
1747                 NDR_PRINT_IN_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1748         }
1749
1750         r->out.result = _PNP_GetInterfaceDeviceListSize(p, r);
1751
1752         if (p->rng_fault_state) {
1753                 talloc_free(r);
1754                 /* Return true here, srv_pipe_hnd.c will take care */
1755                 return true;
1756         }
1757
1758         if (DEBUGLEVEL >= 10) {
1759                 NDR_PRINT_OUT_DEBUG(PNP_GetInterfaceDeviceListSize, r);
1760         }
1761
1762         push = ndr_push_init_ctx(r, NULL);
1763         if (push == NULL) {
1764                 talloc_free(r);
1765                 return false;
1766         }
1767
1768         ndr_err = call->ndr_push(push, NDR_OUT, r);
1769         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1770                 talloc_free(r);
1771                 return false;
1772         }
1773
1774         blob = ndr_push_blob(push);
1775         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1776                 talloc_free(r);
1777                 return false;
1778         }
1779
1780         talloc_free(r);
1781
1782         return true;
1783 }
1784
1785 static bool api_PNP_RegisterDeviceClassAssociation(pipes_struct *p)
1786 {
1787         const struct ndr_interface_call *call;
1788         struct ndr_pull *pull;
1789         struct ndr_push *push;
1790         enum ndr_err_code ndr_err;
1791         DATA_BLOB blob;
1792         struct PNP_RegisterDeviceClassAssociation *r;
1793
1794         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDEVICECLASSASSOCIATION];
1795
1796         r = talloc(talloc_tos(), struct PNP_RegisterDeviceClassAssociation);
1797         if (r == NULL) {
1798                 return false;
1799         }
1800
1801         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1802                 talloc_free(r);
1803                 return false;
1804         }
1805
1806         pull = ndr_pull_init_blob(&blob, r, NULL);
1807         if (pull == NULL) {
1808                 talloc_free(r);
1809                 return false;
1810         }
1811
1812         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1813         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1814         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1815                 talloc_free(r);
1816                 return false;
1817         }
1818
1819         if (DEBUGLEVEL >= 10) {
1820                 NDR_PRINT_IN_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1821         }
1822
1823         r->out.result = _PNP_RegisterDeviceClassAssociation(p, r);
1824
1825         if (p->rng_fault_state) {
1826                 talloc_free(r);
1827                 /* Return true here, srv_pipe_hnd.c will take care */
1828                 return true;
1829         }
1830
1831         if (DEBUGLEVEL >= 10) {
1832                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDeviceClassAssociation, r);
1833         }
1834
1835         push = ndr_push_init_ctx(r, NULL);
1836         if (push == NULL) {
1837                 talloc_free(r);
1838                 return false;
1839         }
1840
1841         ndr_err = call->ndr_push(push, NDR_OUT, r);
1842         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1843                 talloc_free(r);
1844                 return false;
1845         }
1846
1847         blob = ndr_push_blob(push);
1848         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1849                 talloc_free(r);
1850                 return false;
1851         }
1852
1853         talloc_free(r);
1854
1855         return true;
1856 }
1857
1858 static bool api_PNP_UnregisterDeviceClassAssociation(pipes_struct *p)
1859 {
1860         const struct ndr_interface_call *call;
1861         struct ndr_pull *pull;
1862         struct ndr_push *push;
1863         enum ndr_err_code ndr_err;
1864         DATA_BLOB blob;
1865         struct PNP_UnregisterDeviceClassAssociation *r;
1866
1867         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNREGISTERDEVICECLASSASSOCIATION];
1868
1869         r = talloc(talloc_tos(), struct PNP_UnregisterDeviceClassAssociation);
1870         if (r == NULL) {
1871                 return false;
1872         }
1873
1874         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1875                 talloc_free(r);
1876                 return false;
1877         }
1878
1879         pull = ndr_pull_init_blob(&blob, r, NULL);
1880         if (pull == NULL) {
1881                 talloc_free(r);
1882                 return false;
1883         }
1884
1885         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1886         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1887         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1888                 talloc_free(r);
1889                 return false;
1890         }
1891
1892         if (DEBUGLEVEL >= 10) {
1893                 NDR_PRINT_IN_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1894         }
1895
1896         r->out.result = _PNP_UnregisterDeviceClassAssociation(p, r);
1897
1898         if (p->rng_fault_state) {
1899                 talloc_free(r);
1900                 /* Return true here, srv_pipe_hnd.c will take care */
1901                 return true;
1902         }
1903
1904         if (DEBUGLEVEL >= 10) {
1905                 NDR_PRINT_OUT_DEBUG(PNP_UnregisterDeviceClassAssociation, r);
1906         }
1907
1908         push = ndr_push_init_ctx(r, NULL);
1909         if (push == NULL) {
1910                 talloc_free(r);
1911                 return false;
1912         }
1913
1914         ndr_err = call->ndr_push(push, NDR_OUT, r);
1915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1916                 talloc_free(r);
1917                 return false;
1918         }
1919
1920         blob = ndr_push_blob(push);
1921         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1922                 talloc_free(r);
1923                 return false;
1924         }
1925
1926         talloc_free(r);
1927
1928         return true;
1929 }
1930
1931 static bool api_PNP_GetClassRegProp(pipes_struct *p)
1932 {
1933         const struct ndr_interface_call *call;
1934         struct ndr_pull *pull;
1935         struct ndr_push *push;
1936         enum ndr_err_code ndr_err;
1937         DATA_BLOB blob;
1938         struct PNP_GetClassRegProp *r;
1939
1940         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETCLASSREGPROP];
1941
1942         r = talloc(talloc_tos(), struct PNP_GetClassRegProp);
1943         if (r == NULL) {
1944                 return false;
1945         }
1946
1947         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1948                 talloc_free(r);
1949                 return false;
1950         }
1951
1952         pull = ndr_pull_init_blob(&blob, r, NULL);
1953         if (pull == NULL) {
1954                 talloc_free(r);
1955                 return false;
1956         }
1957
1958         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1959         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1960         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1961                 talloc_free(r);
1962                 return false;
1963         }
1964
1965         if (DEBUGLEVEL >= 10) {
1966                 NDR_PRINT_IN_DEBUG(PNP_GetClassRegProp, r);
1967         }
1968
1969         r->out.result = _PNP_GetClassRegProp(p, r);
1970
1971         if (p->rng_fault_state) {
1972                 talloc_free(r);
1973                 /* Return true here, srv_pipe_hnd.c will take care */
1974                 return true;
1975         }
1976
1977         if (DEBUGLEVEL >= 10) {
1978                 NDR_PRINT_OUT_DEBUG(PNP_GetClassRegProp, r);
1979         }
1980
1981         push = ndr_push_init_ctx(r, NULL);
1982         if (push == NULL) {
1983                 talloc_free(r);
1984                 return false;
1985         }
1986
1987         ndr_err = call->ndr_push(push, NDR_OUT, r);
1988         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1989                 talloc_free(r);
1990                 return false;
1991         }
1992
1993         blob = ndr_push_blob(push);
1994         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1995                 talloc_free(r);
1996                 return false;
1997         }
1998
1999         talloc_free(r);
2000
2001         return true;
2002 }
2003
2004 static bool api_PNP_SetClassRegProp(pipes_struct *p)
2005 {
2006         const struct ndr_interface_call *call;
2007         struct ndr_pull *pull;
2008         struct ndr_push *push;
2009         enum ndr_err_code ndr_err;
2010         DATA_BLOB blob;
2011         struct PNP_SetClassRegProp *r;
2012
2013         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETCLASSREGPROP];
2014
2015         r = talloc(talloc_tos(), struct PNP_SetClassRegProp);
2016         if (r == NULL) {
2017                 return false;
2018         }
2019
2020         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2021                 talloc_free(r);
2022                 return false;
2023         }
2024
2025         pull = ndr_pull_init_blob(&blob, r, NULL);
2026         if (pull == NULL) {
2027                 talloc_free(r);
2028                 return false;
2029         }
2030
2031         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2032         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2033         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2034                 talloc_free(r);
2035                 return false;
2036         }
2037
2038         if (DEBUGLEVEL >= 10) {
2039                 NDR_PRINT_IN_DEBUG(PNP_SetClassRegProp, r);
2040         }
2041
2042         r->out.result = _PNP_SetClassRegProp(p, r);
2043
2044         if (p->rng_fault_state) {
2045                 talloc_free(r);
2046                 /* Return true here, srv_pipe_hnd.c will take care */
2047                 return true;
2048         }
2049
2050         if (DEBUGLEVEL >= 10) {
2051                 NDR_PRINT_OUT_DEBUG(PNP_SetClassRegProp, r);
2052         }
2053
2054         push = ndr_push_init_ctx(r, NULL);
2055         if (push == NULL) {
2056                 talloc_free(r);
2057                 return false;
2058         }
2059
2060         ndr_err = call->ndr_push(push, NDR_OUT, r);
2061         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2062                 talloc_free(r);
2063                 return false;
2064         }
2065
2066         blob = ndr_push_blob(push);
2067         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2068                 talloc_free(r);
2069                 return false;
2070         }
2071
2072         talloc_free(r);
2073
2074         return true;
2075 }
2076
2077 static bool api_PNP_CreateDevInst(pipes_struct *p)
2078 {
2079         const struct ndr_interface_call *call;
2080         struct ndr_pull *pull;
2081         struct ndr_push *push;
2082         enum ndr_err_code ndr_err;
2083         DATA_BLOB blob;
2084         struct PNP_CreateDevInst *r;
2085
2086         call = &ndr_table_ntsvcs.calls[NDR_PNP_CREATEDEVINST];
2087
2088         r = talloc(talloc_tos(), struct PNP_CreateDevInst);
2089         if (r == NULL) {
2090                 return false;
2091         }
2092
2093         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2094                 talloc_free(r);
2095                 return false;
2096         }
2097
2098         pull = ndr_pull_init_blob(&blob, r, NULL);
2099         if (pull == NULL) {
2100                 talloc_free(r);
2101                 return false;
2102         }
2103
2104         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2105         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2106         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2107                 talloc_free(r);
2108                 return false;
2109         }
2110
2111         if (DEBUGLEVEL >= 10) {
2112                 NDR_PRINT_IN_DEBUG(PNP_CreateDevInst, r);
2113         }
2114
2115         r->out.result = _PNP_CreateDevInst(p, r);
2116
2117         if (p->rng_fault_state) {
2118                 talloc_free(r);
2119                 /* Return true here, srv_pipe_hnd.c will take care */
2120                 return true;
2121         }
2122
2123         if (DEBUGLEVEL >= 10) {
2124                 NDR_PRINT_OUT_DEBUG(PNP_CreateDevInst, r);
2125         }
2126
2127         push = ndr_push_init_ctx(r, NULL);
2128         if (push == NULL) {
2129                 talloc_free(r);
2130                 return false;
2131         }
2132
2133         ndr_err = call->ndr_push(push, NDR_OUT, r);
2134         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2135                 talloc_free(r);
2136                 return false;
2137         }
2138
2139         blob = ndr_push_blob(push);
2140         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2141                 talloc_free(r);
2142                 return false;
2143         }
2144
2145         talloc_free(r);
2146
2147         return true;
2148 }
2149
2150 static bool api_PNP_DeviceInstanceAction(pipes_struct *p)
2151 {
2152         const struct ndr_interface_call *call;
2153         struct ndr_pull *pull;
2154         struct ndr_push *push;
2155         enum ndr_err_code ndr_err;
2156         DATA_BLOB blob;
2157         struct PNP_DeviceInstanceAction *r;
2158
2159         call = &ndr_table_ntsvcs.calls[NDR_PNP_DEVICEINSTANCEACTION];
2160
2161         r = talloc(talloc_tos(), struct PNP_DeviceInstanceAction);
2162         if (r == NULL) {
2163                 return false;
2164         }
2165
2166         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2167                 talloc_free(r);
2168                 return false;
2169         }
2170
2171         pull = ndr_pull_init_blob(&blob, r, NULL);
2172         if (pull == NULL) {
2173                 talloc_free(r);
2174                 return false;
2175         }
2176
2177         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2178         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2179         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2180                 talloc_free(r);
2181                 return false;
2182         }
2183
2184         if (DEBUGLEVEL >= 10) {
2185                 NDR_PRINT_IN_DEBUG(PNP_DeviceInstanceAction, r);
2186         }
2187
2188         r->out.result = _PNP_DeviceInstanceAction(p, r);
2189
2190         if (p->rng_fault_state) {
2191                 talloc_free(r);
2192                 /* Return true here, srv_pipe_hnd.c will take care */
2193                 return true;
2194         }
2195
2196         if (DEBUGLEVEL >= 10) {
2197                 NDR_PRINT_OUT_DEBUG(PNP_DeviceInstanceAction, r);
2198         }
2199
2200         push = ndr_push_init_ctx(r, NULL);
2201         if (push == NULL) {
2202                 talloc_free(r);
2203                 return false;
2204         }
2205
2206         ndr_err = call->ndr_push(push, NDR_OUT, r);
2207         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2208                 talloc_free(r);
2209                 return false;
2210         }
2211
2212         blob = ndr_push_blob(push);
2213         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2214                 talloc_free(r);
2215                 return false;
2216         }
2217
2218         talloc_free(r);
2219
2220         return true;
2221 }
2222
2223 static bool api_PNP_GetDeviceStatus(pipes_struct *p)
2224 {
2225         const struct ndr_interface_call *call;
2226         struct ndr_pull *pull;
2227         struct ndr_push *push;
2228         enum ndr_err_code ndr_err;
2229         DATA_BLOB blob;
2230         struct PNP_GetDeviceStatus *r;
2231
2232         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETDEVICESTATUS];
2233
2234         r = talloc(talloc_tos(), struct PNP_GetDeviceStatus);
2235         if (r == NULL) {
2236                 return false;
2237         }
2238
2239         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2240                 talloc_free(r);
2241                 return false;
2242         }
2243
2244         pull = ndr_pull_init_blob(&blob, r, NULL);
2245         if (pull == NULL) {
2246                 talloc_free(r);
2247                 return false;
2248         }
2249
2250         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2251         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2252         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2253                 talloc_free(r);
2254                 return false;
2255         }
2256
2257         if (DEBUGLEVEL >= 10) {
2258                 NDR_PRINT_IN_DEBUG(PNP_GetDeviceStatus, r);
2259         }
2260
2261         r->out.result = _PNP_GetDeviceStatus(p, r);
2262
2263         if (p->rng_fault_state) {
2264                 talloc_free(r);
2265                 /* Return true here, srv_pipe_hnd.c will take care */
2266                 return true;
2267         }
2268
2269         if (DEBUGLEVEL >= 10) {
2270                 NDR_PRINT_OUT_DEBUG(PNP_GetDeviceStatus, r);
2271         }
2272
2273         push = ndr_push_init_ctx(r, NULL);
2274         if (push == NULL) {
2275                 talloc_free(r);
2276                 return false;
2277         }
2278
2279         ndr_err = call->ndr_push(push, NDR_OUT, r);
2280         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2281                 talloc_free(r);
2282                 return false;
2283         }
2284
2285         blob = ndr_push_blob(push);
2286         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2287                 talloc_free(r);
2288                 return false;
2289         }
2290
2291         talloc_free(r);
2292
2293         return true;
2294 }
2295
2296 static bool api_PNP_SetDeviceProblem(pipes_struct *p)
2297 {
2298         const struct ndr_interface_call *call;
2299         struct ndr_pull *pull;
2300         struct ndr_push *push;
2301         enum ndr_err_code ndr_err;
2302         DATA_BLOB blob;
2303         struct PNP_SetDeviceProblem *r;
2304
2305         call = &ndr_table_ntsvcs.calls[NDR_PNP_SETDEVICEPROBLEM];
2306
2307         r = talloc(talloc_tos(), struct PNP_SetDeviceProblem);
2308         if (r == NULL) {
2309                 return false;
2310         }
2311
2312         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2313                 talloc_free(r);
2314                 return false;
2315         }
2316
2317         pull = ndr_pull_init_blob(&blob, r, NULL);
2318         if (pull == NULL) {
2319                 talloc_free(r);
2320                 return false;
2321         }
2322
2323         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2324         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2325         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2326                 talloc_free(r);
2327                 return false;
2328         }
2329
2330         if (DEBUGLEVEL >= 10) {
2331                 NDR_PRINT_IN_DEBUG(PNP_SetDeviceProblem, r);
2332         }
2333
2334         r->out.result = _PNP_SetDeviceProblem(p, r);
2335
2336         if (p->rng_fault_state) {
2337                 talloc_free(r);
2338                 /* Return true here, srv_pipe_hnd.c will take care */
2339                 return true;
2340         }
2341
2342         if (DEBUGLEVEL >= 10) {
2343                 NDR_PRINT_OUT_DEBUG(PNP_SetDeviceProblem, r);
2344         }
2345
2346         push = ndr_push_init_ctx(r, NULL);
2347         if (push == NULL) {
2348                 talloc_free(r);
2349                 return false;
2350         }
2351
2352         ndr_err = call->ndr_push(push, NDR_OUT, r);
2353         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2354                 talloc_free(r);
2355                 return false;
2356         }
2357
2358         blob = ndr_push_blob(push);
2359         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2360                 talloc_free(r);
2361                 return false;
2362         }
2363
2364         talloc_free(r);
2365
2366         return true;
2367 }
2368
2369 static bool api_PNP_DisableDevInst(pipes_struct *p)
2370 {
2371         const struct ndr_interface_call *call;
2372         struct ndr_pull *pull;
2373         struct ndr_push *push;
2374         enum ndr_err_code ndr_err;
2375         DATA_BLOB blob;
2376         struct PNP_DisableDevInst *r;
2377
2378         call = &ndr_table_ntsvcs.calls[NDR_PNP_DISABLEDEVINST];
2379
2380         r = talloc(talloc_tos(), struct PNP_DisableDevInst);
2381         if (r == NULL) {
2382                 return false;
2383         }
2384
2385         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2386                 talloc_free(r);
2387                 return false;
2388         }
2389
2390         pull = ndr_pull_init_blob(&blob, r, NULL);
2391         if (pull == NULL) {
2392                 talloc_free(r);
2393                 return false;
2394         }
2395
2396         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2397         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2398         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2399                 talloc_free(r);
2400                 return false;
2401         }
2402
2403         if (DEBUGLEVEL >= 10) {
2404                 NDR_PRINT_IN_DEBUG(PNP_DisableDevInst, r);
2405         }
2406
2407         r->out.result = _PNP_DisableDevInst(p, r);
2408
2409         if (p->rng_fault_state) {
2410                 talloc_free(r);
2411                 /* Return true here, srv_pipe_hnd.c will take care */
2412                 return true;
2413         }
2414
2415         if (DEBUGLEVEL >= 10) {
2416                 NDR_PRINT_OUT_DEBUG(PNP_DisableDevInst, r);
2417         }
2418
2419         push = ndr_push_init_ctx(r, NULL);
2420         if (push == NULL) {
2421                 talloc_free(r);
2422                 return false;
2423         }
2424
2425         ndr_err = call->ndr_push(push, NDR_OUT, r);
2426         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2427                 talloc_free(r);
2428                 return false;
2429         }
2430
2431         blob = ndr_push_blob(push);
2432         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2433                 talloc_free(r);
2434                 return false;
2435         }
2436
2437         talloc_free(r);
2438
2439         return true;
2440 }
2441
2442 static bool api_PNP_UninstallDevInst(pipes_struct *p)
2443 {
2444         const struct ndr_interface_call *call;
2445         struct ndr_pull *pull;
2446         struct ndr_push *push;
2447         enum ndr_err_code ndr_err;
2448         DATA_BLOB blob;
2449         struct PNP_UninstallDevInst *r;
2450
2451         call = &ndr_table_ntsvcs.calls[NDR_PNP_UNINSTALLDEVINST];
2452
2453         r = talloc(talloc_tos(), struct PNP_UninstallDevInst);
2454         if (r == NULL) {
2455                 return false;
2456         }
2457
2458         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2459                 talloc_free(r);
2460                 return false;
2461         }
2462
2463         pull = ndr_pull_init_blob(&blob, r, NULL);
2464         if (pull == NULL) {
2465                 talloc_free(r);
2466                 return false;
2467         }
2468
2469         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2470         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2471         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2472                 talloc_free(r);
2473                 return false;
2474         }
2475
2476         if (DEBUGLEVEL >= 10) {
2477                 NDR_PRINT_IN_DEBUG(PNP_UninstallDevInst, r);
2478         }
2479
2480         r->out.result = _PNP_UninstallDevInst(p, r);
2481
2482         if (p->rng_fault_state) {
2483                 talloc_free(r);
2484                 /* Return true here, srv_pipe_hnd.c will take care */
2485                 return true;
2486         }
2487
2488         if (DEBUGLEVEL >= 10) {
2489                 NDR_PRINT_OUT_DEBUG(PNP_UninstallDevInst, r);
2490         }
2491
2492         push = ndr_push_init_ctx(r, NULL);
2493         if (push == NULL) {
2494                 talloc_free(r);
2495                 return false;
2496         }
2497
2498         ndr_err = call->ndr_push(push, NDR_OUT, r);
2499         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2500                 talloc_free(r);
2501                 return false;
2502         }
2503
2504         blob = ndr_push_blob(push);
2505         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2506                 talloc_free(r);
2507                 return false;
2508         }
2509
2510         talloc_free(r);
2511
2512         return true;
2513 }
2514
2515 static bool api_PNP_AddID(pipes_struct *p)
2516 {
2517         const struct ndr_interface_call *call;
2518         struct ndr_pull *pull;
2519         struct ndr_push *push;
2520         enum ndr_err_code ndr_err;
2521         DATA_BLOB blob;
2522         struct PNP_AddID *r;
2523
2524         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDID];
2525
2526         r = talloc(talloc_tos(), struct PNP_AddID);
2527         if (r == NULL) {
2528                 return false;
2529         }
2530
2531         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2532                 talloc_free(r);
2533                 return false;
2534         }
2535
2536         pull = ndr_pull_init_blob(&blob, r, NULL);
2537         if (pull == NULL) {
2538                 talloc_free(r);
2539                 return false;
2540         }
2541
2542         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2543         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2544         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2545                 talloc_free(r);
2546                 return false;
2547         }
2548
2549         if (DEBUGLEVEL >= 10) {
2550                 NDR_PRINT_IN_DEBUG(PNP_AddID, r);
2551         }
2552
2553         r->out.result = _PNP_AddID(p, r);
2554
2555         if (p->rng_fault_state) {
2556                 talloc_free(r);
2557                 /* Return true here, srv_pipe_hnd.c will take care */
2558                 return true;
2559         }
2560
2561         if (DEBUGLEVEL >= 10) {
2562                 NDR_PRINT_OUT_DEBUG(PNP_AddID, r);
2563         }
2564
2565         push = ndr_push_init_ctx(r, NULL);
2566         if (push == NULL) {
2567                 talloc_free(r);
2568                 return false;
2569         }
2570
2571         ndr_err = call->ndr_push(push, NDR_OUT, r);
2572         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2573                 talloc_free(r);
2574                 return false;
2575         }
2576
2577         blob = ndr_push_blob(push);
2578         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2579                 talloc_free(r);
2580                 return false;
2581         }
2582
2583         talloc_free(r);
2584
2585         return true;
2586 }
2587
2588 static bool api_PNP_RegisterDriver(pipes_struct *p)
2589 {
2590         const struct ndr_interface_call *call;
2591         struct ndr_pull *pull;
2592         struct ndr_push *push;
2593         enum ndr_err_code ndr_err;
2594         DATA_BLOB blob;
2595         struct PNP_RegisterDriver *r;
2596
2597         call = &ndr_table_ntsvcs.calls[NDR_PNP_REGISTERDRIVER];
2598
2599         r = talloc(talloc_tos(), struct PNP_RegisterDriver);
2600         if (r == NULL) {
2601                 return false;
2602         }
2603
2604         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2605                 talloc_free(r);
2606                 return false;
2607         }
2608
2609         pull = ndr_pull_init_blob(&blob, r, NULL);
2610         if (pull == NULL) {
2611                 talloc_free(r);
2612                 return false;
2613         }
2614
2615         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2616         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2617         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2618                 talloc_free(r);
2619                 return false;
2620         }
2621
2622         if (DEBUGLEVEL >= 10) {
2623                 NDR_PRINT_IN_DEBUG(PNP_RegisterDriver, r);
2624         }
2625
2626         r->out.result = _PNP_RegisterDriver(p, r);
2627
2628         if (p->rng_fault_state) {
2629                 talloc_free(r);
2630                 /* Return true here, srv_pipe_hnd.c will take care */
2631                 return true;
2632         }
2633
2634         if (DEBUGLEVEL >= 10) {
2635                 NDR_PRINT_OUT_DEBUG(PNP_RegisterDriver, r);
2636         }
2637
2638         push = ndr_push_init_ctx(r, NULL);
2639         if (push == NULL) {
2640                 talloc_free(r);
2641                 return false;
2642         }
2643
2644         ndr_err = call->ndr_push(push, NDR_OUT, r);
2645         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2646                 talloc_free(r);
2647                 return false;
2648         }
2649
2650         blob = ndr_push_blob(push);
2651         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2652                 talloc_free(r);
2653                 return false;
2654         }
2655
2656         talloc_free(r);
2657
2658         return true;
2659 }
2660
2661 static bool api_PNP_QueryRemove(pipes_struct *p)
2662 {
2663         const struct ndr_interface_call *call;
2664         struct ndr_pull *pull;
2665         struct ndr_push *push;
2666         enum ndr_err_code ndr_err;
2667         DATA_BLOB blob;
2668         struct PNP_QueryRemove *r;
2669
2670         call = &ndr_table_ntsvcs.calls[NDR_PNP_QUERYREMOVE];
2671
2672         r = talloc(talloc_tos(), struct PNP_QueryRemove);
2673         if (r == NULL) {
2674                 return false;
2675         }
2676
2677         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2678                 talloc_free(r);
2679                 return false;
2680         }
2681
2682         pull = ndr_pull_init_blob(&blob, r, NULL);
2683         if (pull == NULL) {
2684                 talloc_free(r);
2685                 return false;
2686         }
2687
2688         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2689         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2690         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2691                 talloc_free(r);
2692                 return false;
2693         }
2694
2695         if (DEBUGLEVEL >= 10) {
2696                 NDR_PRINT_IN_DEBUG(PNP_QueryRemove, r);
2697         }
2698
2699         r->out.result = _PNP_QueryRemove(p, r);
2700
2701         if (p->rng_fault_state) {
2702                 talloc_free(r);
2703                 /* Return true here, srv_pipe_hnd.c will take care */
2704                 return true;
2705         }
2706
2707         if (DEBUGLEVEL >= 10) {
2708                 NDR_PRINT_OUT_DEBUG(PNP_QueryRemove, r);
2709         }
2710
2711         push = ndr_push_init_ctx(r, NULL);
2712         if (push == NULL) {
2713                 talloc_free(r);
2714                 return false;
2715         }
2716
2717         ndr_err = call->ndr_push(push, NDR_OUT, r);
2718         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2719                 talloc_free(r);
2720                 return false;
2721         }
2722
2723         blob = ndr_push_blob(push);
2724         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2725                 talloc_free(r);
2726                 return false;
2727         }
2728
2729         talloc_free(r);
2730
2731         return true;
2732 }
2733
2734 static bool api_PNP_RequestDeviceEject(pipes_struct *p)
2735 {
2736         const struct ndr_interface_call *call;
2737         struct ndr_pull *pull;
2738         struct ndr_push *push;
2739         enum ndr_err_code ndr_err;
2740         DATA_BLOB blob;
2741         struct PNP_RequestDeviceEject *r;
2742
2743         call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTDEVICEEJECT];
2744
2745         r = talloc(talloc_tos(), struct PNP_RequestDeviceEject);
2746         if (r == NULL) {
2747                 return false;
2748         }
2749
2750         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2751                 talloc_free(r);
2752                 return false;
2753         }
2754
2755         pull = ndr_pull_init_blob(&blob, r, NULL);
2756         if (pull == NULL) {
2757                 talloc_free(r);
2758                 return false;
2759         }
2760
2761         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2762         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2763         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2764                 talloc_free(r);
2765                 return false;
2766         }
2767
2768         if (DEBUGLEVEL >= 10) {
2769                 NDR_PRINT_IN_DEBUG(PNP_RequestDeviceEject, r);
2770         }
2771
2772         r->out.result = _PNP_RequestDeviceEject(p, r);
2773
2774         if (p->rng_fault_state) {
2775                 talloc_free(r);
2776                 /* Return true here, srv_pipe_hnd.c will take care */
2777                 return true;
2778         }
2779
2780         if (DEBUGLEVEL >= 10) {
2781                 NDR_PRINT_OUT_DEBUG(PNP_RequestDeviceEject, r);
2782         }
2783
2784         push = ndr_push_init_ctx(r, NULL);
2785         if (push == NULL) {
2786                 talloc_free(r);
2787                 return false;
2788         }
2789
2790         ndr_err = call->ndr_push(push, NDR_OUT, r);
2791         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2792                 talloc_free(r);
2793                 return false;
2794         }
2795
2796         blob = ndr_push_blob(push);
2797         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2798                 talloc_free(r);
2799                 return false;
2800         }
2801
2802         talloc_free(r);
2803
2804         return true;
2805 }
2806
2807 static bool api_PNP_IsDockStationPresent(pipes_struct *p)
2808 {
2809         const struct ndr_interface_call *call;
2810         struct ndr_pull *pull;
2811         struct ndr_push *push;
2812         enum ndr_err_code ndr_err;
2813         DATA_BLOB blob;
2814         struct PNP_IsDockStationPresent *r;
2815
2816         call = &ndr_table_ntsvcs.calls[NDR_PNP_ISDOCKSTATIONPRESENT];
2817
2818         r = talloc(talloc_tos(), struct PNP_IsDockStationPresent);
2819         if (r == NULL) {
2820                 return false;
2821         }
2822
2823         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2824                 talloc_free(r);
2825                 return false;
2826         }
2827
2828         pull = ndr_pull_init_blob(&blob, r, NULL);
2829         if (pull == NULL) {
2830                 talloc_free(r);
2831                 return false;
2832         }
2833
2834         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2835         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2836         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2837                 talloc_free(r);
2838                 return false;
2839         }
2840
2841         if (DEBUGLEVEL >= 10) {
2842                 NDR_PRINT_IN_DEBUG(PNP_IsDockStationPresent, r);
2843         }
2844
2845         r->out.result = _PNP_IsDockStationPresent(p, r);
2846
2847         if (p->rng_fault_state) {
2848                 talloc_free(r);
2849                 /* Return true here, srv_pipe_hnd.c will take care */
2850                 return true;
2851         }
2852
2853         if (DEBUGLEVEL >= 10) {
2854                 NDR_PRINT_OUT_DEBUG(PNP_IsDockStationPresent, r);
2855         }
2856
2857         push = ndr_push_init_ctx(r, NULL);
2858         if (push == NULL) {
2859                 talloc_free(r);
2860                 return false;
2861         }
2862
2863         ndr_err = call->ndr_push(push, NDR_OUT, r);
2864         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2865                 talloc_free(r);
2866                 return false;
2867         }
2868
2869         blob = ndr_push_blob(push);
2870         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2871                 talloc_free(r);
2872                 return false;
2873         }
2874
2875         talloc_free(r);
2876
2877         return true;
2878 }
2879
2880 static bool api_PNP_RequestEjectPC(pipes_struct *p)
2881 {
2882         const struct ndr_interface_call *call;
2883         struct ndr_pull *pull;
2884         struct ndr_push *push;
2885         enum ndr_err_code ndr_err;
2886         DATA_BLOB blob;
2887         struct PNP_RequestEjectPC *r;
2888
2889         call = &ndr_table_ntsvcs.calls[NDR_PNP_REQUESTEJECTPC];
2890
2891         r = talloc(talloc_tos(), struct PNP_RequestEjectPC);
2892         if (r == NULL) {
2893                 return false;
2894         }
2895
2896         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2897                 talloc_free(r);
2898                 return false;
2899         }
2900
2901         pull = ndr_pull_init_blob(&blob, r, NULL);
2902         if (pull == NULL) {
2903                 talloc_free(r);
2904                 return false;
2905         }
2906
2907         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2908         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2909         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2910                 talloc_free(r);
2911                 return false;
2912         }
2913
2914         if (DEBUGLEVEL >= 10) {
2915                 NDR_PRINT_IN_DEBUG(PNP_RequestEjectPC, r);
2916         }
2917
2918         r->out.result = _PNP_RequestEjectPC(p, r);
2919
2920         if (p->rng_fault_state) {
2921                 talloc_free(r);
2922                 /* Return true here, srv_pipe_hnd.c will take care */
2923                 return true;
2924         }
2925
2926         if (DEBUGLEVEL >= 10) {
2927                 NDR_PRINT_OUT_DEBUG(PNP_RequestEjectPC, r);
2928         }
2929
2930         push = ndr_push_init_ctx(r, NULL);
2931         if (push == NULL) {
2932                 talloc_free(r);
2933                 return false;
2934         }
2935
2936         ndr_err = call->ndr_push(push, NDR_OUT, r);
2937         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2938                 talloc_free(r);
2939                 return false;
2940         }
2941
2942         blob = ndr_push_blob(push);
2943         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2944                 talloc_free(r);
2945                 return false;
2946         }
2947
2948         talloc_free(r);
2949
2950         return true;
2951 }
2952
2953 static bool api_PNP_HwProfFlags(pipes_struct *p)
2954 {
2955         const struct ndr_interface_call *call;
2956         struct ndr_pull *pull;
2957         struct ndr_push *push;
2958         enum ndr_err_code ndr_err;
2959         DATA_BLOB blob;
2960         struct PNP_HwProfFlags *r;
2961
2962         call = &ndr_table_ntsvcs.calls[NDR_PNP_HWPROFFLAGS];
2963
2964         r = talloc(talloc_tos(), struct PNP_HwProfFlags);
2965         if (r == NULL) {
2966                 return false;
2967         }
2968
2969         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2970                 talloc_free(r);
2971                 return false;
2972         }
2973
2974         pull = ndr_pull_init_blob(&blob, r, NULL);
2975         if (pull == NULL) {
2976                 talloc_free(r);
2977                 return false;
2978         }
2979
2980         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2981         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2982         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2983                 talloc_free(r);
2984                 return false;
2985         }
2986
2987         if (DEBUGLEVEL >= 10) {
2988                 NDR_PRINT_IN_DEBUG(PNP_HwProfFlags, r);
2989         }
2990
2991         ZERO_STRUCT(r->out);
2992         r->out.unknown3 = r->in.unknown3;
2993         r->out.unknown4 = r->in.unknown4;
2994         r->out.unknown5a = talloc_zero(r, const char *);
2995         if (r->out.unknown5a == NULL) {
2996                 talloc_free(r);
2997                 return false;
2998         }
2999
3000         r->out.result = _PNP_HwProfFlags(p, r);
3001
3002         if (p->rng_fault_state) {
3003                 talloc_free(r);
3004                 /* Return true here, srv_pipe_hnd.c will take care */
3005                 return true;
3006         }
3007
3008         if (DEBUGLEVEL >= 10) {
3009                 NDR_PRINT_OUT_DEBUG(PNP_HwProfFlags, r);
3010         }
3011
3012         push = ndr_push_init_ctx(r, NULL);
3013         if (push == NULL) {
3014                 talloc_free(r);
3015                 return false;
3016         }
3017
3018         ndr_err = call->ndr_push(push, NDR_OUT, r);
3019         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3020                 talloc_free(r);
3021                 return false;
3022         }
3023
3024         blob = ndr_push_blob(push);
3025         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3026                 talloc_free(r);
3027                 return false;
3028         }
3029
3030         talloc_free(r);
3031
3032         return true;
3033 }
3034
3035 static bool api_PNP_GetHwProfInfo(pipes_struct *p)
3036 {
3037         const struct ndr_interface_call *call;
3038         struct ndr_pull *pull;
3039         struct ndr_push *push;
3040         enum ndr_err_code ndr_err;
3041         DATA_BLOB blob;
3042         struct PNP_GetHwProfInfo *r;
3043
3044         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETHWPROFINFO];
3045
3046         r = talloc(talloc_tos(), struct PNP_GetHwProfInfo);
3047         if (r == NULL) {
3048                 return false;
3049         }
3050
3051         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3052                 talloc_free(r);
3053                 return false;
3054         }
3055
3056         pull = ndr_pull_init_blob(&blob, r, NULL);
3057         if (pull == NULL) {
3058                 talloc_free(r);
3059                 return false;
3060         }
3061
3062         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3063         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3064         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3065                 talloc_free(r);
3066                 return false;
3067         }
3068
3069         if (DEBUGLEVEL >= 10) {
3070                 NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, r);
3071         }
3072
3073         ZERO_STRUCT(r->out);
3074         r->out.info = r->in.info;
3075         r->out.result = _PNP_GetHwProfInfo(p, r);
3076
3077         if (p->rng_fault_state) {
3078                 talloc_free(r);
3079                 /* Return true here, srv_pipe_hnd.c will take care */
3080                 return true;
3081         }
3082
3083         if (DEBUGLEVEL >= 10) {
3084                 NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, r);
3085         }
3086
3087         push = ndr_push_init_ctx(r, NULL);
3088         if (push == NULL) {
3089                 talloc_free(r);
3090                 return false;
3091         }
3092
3093         ndr_err = call->ndr_push(push, NDR_OUT, r);
3094         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3095                 talloc_free(r);
3096                 return false;
3097         }
3098
3099         blob = ndr_push_blob(push);
3100         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3101                 talloc_free(r);
3102                 return false;
3103         }
3104
3105         talloc_free(r);
3106
3107         return true;
3108 }
3109
3110 static bool api_PNP_AddEmptyLogConf(pipes_struct *p)
3111 {
3112         const struct ndr_interface_call *call;
3113         struct ndr_pull *pull;
3114         struct ndr_push *push;
3115         enum ndr_err_code ndr_err;
3116         DATA_BLOB blob;
3117         struct PNP_AddEmptyLogConf *r;
3118
3119         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDEMPTYLOGCONF];
3120
3121         r = talloc(talloc_tos(), struct PNP_AddEmptyLogConf);
3122         if (r == NULL) {
3123                 return false;
3124         }
3125
3126         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3127                 talloc_free(r);
3128                 return false;
3129         }
3130
3131         pull = ndr_pull_init_blob(&blob, r, NULL);
3132         if (pull == NULL) {
3133                 talloc_free(r);
3134                 return false;
3135         }
3136
3137         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3138         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3140                 talloc_free(r);
3141                 return false;
3142         }
3143
3144         if (DEBUGLEVEL >= 10) {
3145                 NDR_PRINT_IN_DEBUG(PNP_AddEmptyLogConf, r);
3146         }
3147
3148         r->out.result = _PNP_AddEmptyLogConf(p, r);
3149
3150         if (p->rng_fault_state) {
3151                 talloc_free(r);
3152                 /* Return true here, srv_pipe_hnd.c will take care */
3153                 return true;
3154         }
3155
3156         if (DEBUGLEVEL >= 10) {
3157                 NDR_PRINT_OUT_DEBUG(PNP_AddEmptyLogConf, r);
3158         }
3159
3160         push = ndr_push_init_ctx(r, NULL);
3161         if (push == NULL) {
3162                 talloc_free(r);
3163                 return false;
3164         }
3165
3166         ndr_err = call->ndr_push(push, NDR_OUT, r);
3167         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3168                 talloc_free(r);
3169                 return false;
3170         }
3171
3172         blob = ndr_push_blob(push);
3173         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3174                 talloc_free(r);
3175                 return false;
3176         }
3177
3178         talloc_free(r);
3179
3180         return true;
3181 }
3182
3183 static bool api_PNP_FreeLogConf(pipes_struct *p)
3184 {
3185         const struct ndr_interface_call *call;
3186         struct ndr_pull *pull;
3187         struct ndr_push *push;
3188         enum ndr_err_code ndr_err;
3189         DATA_BLOB blob;
3190         struct PNP_FreeLogConf *r;
3191
3192         call = &ndr_table_ntsvcs.calls[NDR_PNP_FREELOGCONF];
3193
3194         r = talloc(talloc_tos(), struct PNP_FreeLogConf);
3195         if (r == NULL) {
3196                 return false;
3197         }
3198
3199         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3200                 talloc_free(r);
3201                 return false;
3202         }
3203
3204         pull = ndr_pull_init_blob(&blob, r, NULL);
3205         if (pull == NULL) {
3206                 talloc_free(r);
3207                 return false;
3208         }
3209
3210         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3211         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3212         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3213                 talloc_free(r);
3214                 return false;
3215         }
3216
3217         if (DEBUGLEVEL >= 10) {
3218                 NDR_PRINT_IN_DEBUG(PNP_FreeLogConf, r);
3219         }
3220
3221         r->out.result = _PNP_FreeLogConf(p, r);
3222
3223         if (p->rng_fault_state) {
3224                 talloc_free(r);
3225                 /* Return true here, srv_pipe_hnd.c will take care */
3226                 return true;
3227         }
3228
3229         if (DEBUGLEVEL >= 10) {
3230                 NDR_PRINT_OUT_DEBUG(PNP_FreeLogConf, r);
3231         }
3232
3233         push = ndr_push_init_ctx(r, NULL);
3234         if (push == NULL) {
3235                 talloc_free(r);
3236                 return false;
3237         }
3238
3239         ndr_err = call->ndr_push(push, NDR_OUT, r);
3240         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3241                 talloc_free(r);
3242                 return false;
3243         }
3244
3245         blob = ndr_push_blob(push);
3246         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3247                 talloc_free(r);
3248                 return false;
3249         }
3250
3251         talloc_free(r);
3252
3253         return true;
3254 }
3255
3256 static bool api_PNP_GetFirstLogConf(pipes_struct *p)
3257 {
3258         const struct ndr_interface_call *call;
3259         struct ndr_pull *pull;
3260         struct ndr_push *push;
3261         enum ndr_err_code ndr_err;
3262         DATA_BLOB blob;
3263         struct PNP_GetFirstLogConf *r;
3264
3265         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETFIRSTLOGCONF];
3266
3267         r = talloc(talloc_tos(), struct PNP_GetFirstLogConf);
3268         if (r == NULL) {
3269                 return false;
3270         }
3271
3272         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3273                 talloc_free(r);
3274                 return false;
3275         }
3276
3277         pull = ndr_pull_init_blob(&blob, r, NULL);
3278         if (pull == NULL) {
3279                 talloc_free(r);
3280                 return false;
3281         }
3282
3283         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3284         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3285         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3286                 talloc_free(r);
3287                 return false;
3288         }
3289
3290         if (DEBUGLEVEL >= 10) {
3291                 NDR_PRINT_IN_DEBUG(PNP_GetFirstLogConf, r);
3292         }
3293
3294         r->out.result = _PNP_GetFirstLogConf(p, r);
3295
3296         if (p->rng_fault_state) {
3297                 talloc_free(r);
3298                 /* Return true here, srv_pipe_hnd.c will take care */
3299                 return true;
3300         }
3301
3302         if (DEBUGLEVEL >= 10) {
3303                 NDR_PRINT_OUT_DEBUG(PNP_GetFirstLogConf, r);
3304         }
3305
3306         push = ndr_push_init_ctx(r, NULL);
3307         if (push == NULL) {
3308                 talloc_free(r);
3309                 return false;
3310         }
3311
3312         ndr_err = call->ndr_push(push, NDR_OUT, r);
3313         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3314                 talloc_free(r);
3315                 return false;
3316         }
3317
3318         blob = ndr_push_blob(push);
3319         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3320                 talloc_free(r);
3321                 return false;
3322         }
3323
3324         talloc_free(r);
3325
3326         return true;
3327 }
3328
3329 static bool api_PNP_GetNextLogConf(pipes_struct *p)
3330 {
3331         const struct ndr_interface_call *call;
3332         struct ndr_pull *pull;
3333         struct ndr_push *push;
3334         enum ndr_err_code ndr_err;
3335         DATA_BLOB blob;
3336         struct PNP_GetNextLogConf *r;
3337
3338         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETNEXTLOGCONF];
3339
3340         r = talloc(talloc_tos(), struct PNP_GetNextLogConf);
3341         if (r == NULL) {
3342                 return false;
3343         }
3344
3345         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3346                 talloc_free(r);
3347                 return false;
3348         }
3349
3350         pull = ndr_pull_init_blob(&blob, r, NULL);
3351         if (pull == NULL) {
3352                 talloc_free(r);
3353                 return false;
3354         }
3355
3356         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3357         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3358         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3359                 talloc_free(r);
3360                 return false;
3361         }
3362
3363         if (DEBUGLEVEL >= 10) {
3364                 NDR_PRINT_IN_DEBUG(PNP_GetNextLogConf, r);
3365         }
3366
3367         r->out.result = _PNP_GetNextLogConf(p, r);
3368
3369         if (p->rng_fault_state) {
3370                 talloc_free(r);
3371                 /* Return true here, srv_pipe_hnd.c will take care */
3372                 return true;
3373         }
3374
3375         if (DEBUGLEVEL >= 10) {
3376                 NDR_PRINT_OUT_DEBUG(PNP_GetNextLogConf, r);
3377         }
3378
3379         push = ndr_push_init_ctx(r, NULL);
3380         if (push == NULL) {
3381                 talloc_free(r);
3382                 return false;
3383         }
3384
3385         ndr_err = call->ndr_push(push, NDR_OUT, r);
3386         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3387                 talloc_free(r);
3388                 return false;
3389         }
3390
3391         blob = ndr_push_blob(push);
3392         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3393                 talloc_free(r);
3394                 return false;
3395         }
3396
3397         talloc_free(r);
3398
3399         return true;
3400 }
3401
3402 static bool api_PNP_GetLogConfPriority(pipes_struct *p)
3403 {
3404         const struct ndr_interface_call *call;
3405         struct ndr_pull *pull;
3406         struct ndr_push *push;
3407         enum ndr_err_code ndr_err;
3408         DATA_BLOB blob;
3409         struct PNP_GetLogConfPriority *r;
3410
3411         call = &ndr_table_ntsvcs.calls[NDR_PNP_GETLOGCONFPRIORITY];
3412
3413         r = talloc(talloc_tos(), struct PNP_GetLogConfPriority);
3414         if (r == NULL) {
3415                 return false;
3416         }
3417
3418         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3419                 talloc_free(r);
3420                 return false;
3421         }
3422
3423         pull = ndr_pull_init_blob(&blob, r, NULL);
3424         if (pull == NULL) {
3425                 talloc_free(r);
3426                 return false;
3427         }
3428
3429         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3430         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3431         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3432                 talloc_free(r);
3433                 return false;
3434         }
3435
3436         if (DEBUGLEVEL >= 10) {
3437                 NDR_PRINT_IN_DEBUG(PNP_GetLogConfPriority, r);
3438         }
3439
3440         r->out.result = _PNP_GetLogConfPriority(p, r);
3441
3442         if (p->rng_fault_state) {
3443                 talloc_free(r);
3444                 /* Return true here, srv_pipe_hnd.c will take care */
3445                 return true;
3446         }
3447
3448         if (DEBUGLEVEL >= 10) {
3449                 NDR_PRINT_OUT_DEBUG(PNP_GetLogConfPriority, r);
3450         }
3451
3452         push = ndr_push_init_ctx(r, NULL);
3453         if (push == NULL) {
3454                 talloc_free(r);
3455                 return false;
3456         }
3457
3458         ndr_err = call->ndr_push(push, NDR_OUT, r);
3459         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3460                 talloc_free(r);
3461                 return false;
3462         }
3463
3464         blob = ndr_push_blob(push);
3465         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3466                 talloc_free(r);
3467                 return false;
3468         }
3469
3470         talloc_free(r);
3471
3472         return true;
3473 }
3474
3475 static bool api_PNP_AddResDes(pipes_struct *p)
3476 {
3477         const struct ndr_interface_call *call;
3478         struct ndr_pull *pull;
3479         struct ndr_push *push;
3480         enum ndr_err_code ndr_err;
3481         DATA_BLOB blob;
3482         struct PNP_AddResDes *r;
3483
3484         call = &ndr_table_ntsvcs.calls[NDR_PNP_ADDRESDES];
3485
3486         r = talloc(talloc_tos(), struct PNP_AddResDes);
3487         if (r == NULL) {
3488                 return false;
3489         }
3490
3491         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3492                 talloc_free(r);
3493                 return false;
3494         }
3495
3496         pull = ndr_pull_init_blob(&blob, r, NULL);
3497         if (pull == NULL) {
3498                 talloc_free(r);
3499                 return false;
3500         }
3501
3502         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3503         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3504         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3505                 talloc_free(r);
3506                 return false;
3507         }
3508
3509         if (DEBUGLEVEL >= 10) {
3510                 NDR_PRINT_IN_DEBUG(PNP_AddResDes, r);
3511         }
3512
3513         r->out.result = _PNP_AddResDes(p, r);
3514
3515         if (p->rng_fault_state) {
3516                 talloc_free(r);
3517                 /* Return true here, srv_pipe_hnd.c will take care */
3518                 return true;
3519         }
3520
3521         if (DEBUGLEVEL >= 10) {
3522                 NDR_PRINT_OUT_DEBUG(PNP_AddResDes, r);
3523         }
3524
3525         push = ndr_push_init_ctx(r, NULL);
3526         if (push == NULL) {
3527                 talloc_free(r);
3528                 return false;
3529         }
3530
3531         ndr_err = call->ndr_push(push, NDR_OUT, r);
3532         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3533                 talloc_free(r);
3534                 return false;
3535         }
3536
3537         blob = ndr_push_blob(push);
3538         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3539                 talloc_free(r);
3540                 return false;
3541         }
3542
3543         talloc_free(r);
3544
3545         return true;
3546 }
3547
3548 static bool api_PNP_FreeResDes(pipes_struct *p)
3549 {
3550         const struct ndr_interface_call *call;
3551         struct ndr_pull *pull;
3552         struct ndr_push *push;
3553         enum ndr_err_code ndr_err;
355