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