source: branches/samba-3.5.x/librpc/gen_ndr/ndr_ntsvcs.c

Last change on this file was 734, checked in by Silvan Scherrer, 13 years ago

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