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