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