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