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