?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3/smbldap: add option to disable following LDAP refs
[Samba.git] / librpc / gen_ndr / ndr_epmapper.c
blob94dbcfd6478d2cfc345c5489460c6205ebf99722
1 /* parser auto-generated by pidl */
2
3 #include "includes.h"
4 #include "../librpc/gen_ndr/ndr_epmapper.h"
5
6 #include "librpc/gen_ndr/ndr_misc.h"
7 static enum ndr_err_code ndr_push_epm_protocol(struct ndr_push *ndr, int ndr_flags, enum epm_protocol r)
8 {
9 NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
10 return NDR_ERR_SUCCESS;
11 }
12
13 static enum ndr_err_code ndr_pull_epm_protocol(struct ndr_pull *ndr, int ndr_flags, enum epm_protocol *r)
14 {
15 uint8_t v;
16 NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
17 *r = v;
18 return NDR_ERR_SUCCESS;
19 }
20
21 _PUBLIC_ void ndr_print_epm_protocol(struct ndr_print *ndr, const char *name, enum epm_protocol r)
22 {
23 const char *val = NULL;
24
25 switch (r) {
26 case EPM_PROTOCOL_DNET_NSP: val = "EPM_PROTOCOL_DNET_NSP"; break;
27 case EPM_PROTOCOL_OSI_TP4: val = "EPM_PROTOCOL_OSI_TP4"; break;
28 case EPM_PROTOCOL_OSI_CLNS: val = "EPM_PROTOCOL_OSI_CLNS"; break;
29 case EPM_PROTOCOL_TCP: val = "EPM_PROTOCOL_TCP"; break;
30 case EPM_PROTOCOL_UDP: val = "EPM_PROTOCOL_UDP"; break;
31 case EPM_PROTOCOL_IP: val = "EPM_PROTOCOL_IP"; break;
32 case EPM_PROTOCOL_NCADG: val = "EPM_PROTOCOL_NCADG"; break;
33 case EPM_PROTOCOL_NCACN: val = "EPM_PROTOCOL_NCACN"; break;
34 case EPM_PROTOCOL_NCALRPC: val = "EPM_PROTOCOL_NCALRPC"; break;
35 case EPM_PROTOCOL_UUID: val = "EPM_PROTOCOL_UUID"; break;
36 case EPM_PROTOCOL_IPX: val = "EPM_PROTOCOL_IPX"; break;
37 case EPM_PROTOCOL_SMB: val = "EPM_PROTOCOL_SMB"; break;
38 case EPM_PROTOCOL_NAMED_PIPE: val = "EPM_PROTOCOL_NAMED_PIPE"; break;
39 case EPM_PROTOCOL_NETBIOS: val = "EPM_PROTOCOL_NETBIOS"; break;
40 case EPM_PROTOCOL_NETBEUI: val = "EPM_PROTOCOL_NETBEUI"; break;
41 case EPM_PROTOCOL_SPX: val = "EPM_PROTOCOL_SPX"; break;
42 case EPM_PROTOCOL_NB_IPX: val = "EPM_PROTOCOL_NB_IPX"; break;
43 case EPM_PROTOCOL_DSP: val = "EPM_PROTOCOL_DSP"; break;
44 case EPM_PROTOCOL_DDP: val = "EPM_PROTOCOL_DDP"; break;
45 case EPM_PROTOCOL_APPLETALK: val = "EPM_PROTOCOL_APPLETALK"; break;
46 case EPM_PROTOCOL_VINES_SPP: val = "EPM_PROTOCOL_VINES_SPP"; break;
47 case EPM_PROTOCOL_VINES_IPC: val = "EPM_PROTOCOL_VINES_IPC"; break;
48 case EPM_PROTOCOL_STREETTALK: val = "EPM_PROTOCOL_STREETTALK"; break;
49 case EPM_PROTOCOL_HTTP: val = "EPM_PROTOCOL_HTTP"; break;
50 case EPM_PROTOCOL_UNIX_DS: val = "EPM_PROTOCOL_UNIX_DS"; break;
51 case EPM_PROTOCOL_NULL: val = "EPM_PROTOCOL_NULL"; break;
52 }
53 ndr_print_enum(ndr, name, "ENUM", val, r);
54 }
55
56 static enum ndr_err_code ndr_push_epm_rhs_dnet_nsp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_dnet_nsp *r)
57 {
58 if (ndr_flags & NDR_SCALARS) {
59 NDR_CHECK(ndr_push_align(ndr, 1));
60 }
61 if (ndr_flags & NDR_BUFFERS) {
62 }
63 return NDR_ERR_SUCCESS;
64 }
65
66 static enum ndr_err_code ndr_pull_epm_rhs_dnet_nsp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_dnet_nsp *r)
67 {
68 if (ndr_flags & NDR_SCALARS) {
69 NDR_CHECK(ndr_pull_align(ndr, 1));
70 }
71 if (ndr_flags & NDR_BUFFERS) {
72 }
73 return NDR_ERR_SUCCESS;
74 }
75
76 _PUBLIC_ void ndr_print_epm_rhs_dnet_nsp(struct ndr_print *ndr, const char *name, const struct epm_rhs_dnet_nsp *r)
77 {
78 ndr_print_struct(ndr, name, "epm_rhs_dnet_nsp");
79 ndr->depth++;
80 ndr->depth--;
81 }
82
83 static enum ndr_err_code ndr_push_epm_rhs_osi_tp4(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_tp4 *r)
84 {
85 if (ndr_flags & NDR_SCALARS) {
86 NDR_CHECK(ndr_push_align(ndr, 1));
87 }
88 if (ndr_flags & NDR_BUFFERS) {
89 }
90 return NDR_ERR_SUCCESS;
91 }
92
93 static enum ndr_err_code ndr_pull_epm_rhs_osi_tp4(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_tp4 *r)
94 {
95 if (ndr_flags & NDR_SCALARS) {
96 NDR_CHECK(ndr_pull_align(ndr, 1));
97 }
98 if (ndr_flags & NDR_BUFFERS) {
99 }
100 return NDR_ERR_SUCCESS;
101 }
102
103 _PUBLIC_ void ndr_print_epm_rhs_osi_tp4(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_tp4 *r)
104 {
105 ndr_print_struct(ndr, name, "epm_rhs_osi_tp4");
106 ndr->depth++;
107 ndr->depth--;
108 }
109
110 static enum ndr_err_code ndr_push_epm_rhs_osi_clns(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_osi_clns *r)
111 {
112 if (ndr_flags & NDR_SCALARS) {
113 NDR_CHECK(ndr_push_align(ndr, 1));
114 }
115 if (ndr_flags & NDR_BUFFERS) {
116 }
117 return NDR_ERR_SUCCESS;
118 }
119
120 static enum ndr_err_code ndr_pull_epm_rhs_osi_clns(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_osi_clns *r)
121 {
122 if (ndr_flags & NDR_SCALARS) {
123 NDR_CHECK(ndr_pull_align(ndr, 1));
124 }
125 if (ndr_flags & NDR_BUFFERS) {
126 }
127 return NDR_ERR_SUCCESS;
128 }
129
130 _PUBLIC_ void ndr_print_epm_rhs_osi_clns(struct ndr_print *ndr, const char *name, const struct epm_rhs_osi_clns *r)
131 {
132 ndr_print_struct(ndr, name, "epm_rhs_osi_clns");
133 ndr->depth++;
134 ndr->depth--;
135 }
136
137 static enum ndr_err_code ndr_push_epm_rhs_udp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_udp *r)
138 {
139 if (ndr_flags & NDR_SCALARS) {
140 NDR_CHECK(ndr_push_align(ndr, 2));
141 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
142 }
143 if (ndr_flags & NDR_BUFFERS) {
144 }
145 return NDR_ERR_SUCCESS;
146 }
147
148 static enum ndr_err_code ndr_pull_epm_rhs_udp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_udp *r)
149 {
150 if (ndr_flags & NDR_SCALARS) {
151 NDR_CHECK(ndr_pull_align(ndr, 2));
152 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
153 }
154 if (ndr_flags & NDR_BUFFERS) {
155 }
156 return NDR_ERR_SUCCESS;
157 }
158
159 _PUBLIC_ void ndr_print_epm_rhs_udp(struct ndr_print *ndr, const char *name, const struct epm_rhs_udp *r)
160 {
161 ndr_print_struct(ndr, name, "epm_rhs_udp");
162 ndr->depth++;
163 ndr_print_uint16(ndr, "port", r->port);
164 ndr->depth--;
165 }
166
167 static enum ndr_err_code ndr_push_epm_rhs_tcp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_tcp *r)
168 {
169 if (ndr_flags & NDR_SCALARS) {
170 NDR_CHECK(ndr_push_align(ndr, 2));
171 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
172 }
173 if (ndr_flags & NDR_BUFFERS) {
174 }
175 return NDR_ERR_SUCCESS;
176 }
177
178 static enum ndr_err_code ndr_pull_epm_rhs_tcp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_tcp *r)
179 {
180 if (ndr_flags & NDR_SCALARS) {
181 NDR_CHECK(ndr_pull_align(ndr, 2));
182 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
183 }
184 if (ndr_flags & NDR_BUFFERS) {
185 }
186 return NDR_ERR_SUCCESS;
187 }
188
189 _PUBLIC_ void ndr_print_epm_rhs_tcp(struct ndr_print *ndr, const char *name, const struct epm_rhs_tcp *r)
190 {
191 ndr_print_struct(ndr, name, "epm_rhs_tcp");
192 ndr->depth++;
193 ndr_print_uint16(ndr, "port", r->port);
194 ndr->depth--;
195 }
196
197 static enum ndr_err_code ndr_push_epm_rhs_ip(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ip *r)
198 {
199 if (ndr_flags & NDR_SCALARS) {
200 NDR_CHECK(ndr_push_align(ndr, 4));
201 NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ipaddr));
202 }
203 if (ndr_flags & NDR_BUFFERS) {
204 }
205 return NDR_ERR_SUCCESS;
206 }
207
208 static enum ndr_err_code ndr_pull_epm_rhs_ip(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ip *r)
209 {
210 if (ndr_flags & NDR_SCALARS) {
211 NDR_CHECK(ndr_pull_align(ndr, 4));
212 NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ipaddr));
213 }
214 if (ndr_flags & NDR_BUFFERS) {
215 }
216 return NDR_ERR_SUCCESS;
217 }
218
219 _PUBLIC_ void ndr_print_epm_rhs_ip(struct ndr_print *ndr, const char *name, const struct epm_rhs_ip *r)
220 {
221 ndr_print_struct(ndr, name, "epm_rhs_ip");
222 ndr->depth++;
223 ndr_print_ipv4address(ndr, "ipaddr", r->ipaddr);
224 ndr->depth--;
225 }
226
227 static enum ndr_err_code ndr_push_epm_rhs_ncadg(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncadg *r)
228 {
229 if (ndr_flags & NDR_SCALARS) {
230 NDR_CHECK(ndr_push_align(ndr, 2));
231 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
232 }
233 if (ndr_flags & NDR_BUFFERS) {
234 }
235 return NDR_ERR_SUCCESS;
236 }
237
238 static enum ndr_err_code ndr_pull_epm_rhs_ncadg(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncadg *r)
239 {
240 if (ndr_flags & NDR_SCALARS) {
241 NDR_CHECK(ndr_pull_align(ndr, 2));
242 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
243 }
244 if (ndr_flags & NDR_BUFFERS) {
245 }
246 return NDR_ERR_SUCCESS;
247 }
248
249 _PUBLIC_ void ndr_print_epm_rhs_ncadg(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncadg *r)
250 {
251 ndr_print_struct(ndr, name, "epm_rhs_ncadg");
252 ndr->depth++;
253 ndr_print_uint16(ndr, "minor_version", r->minor_version);
254 ndr->depth--;
255 }
256
257 static enum ndr_err_code ndr_push_epm_rhs_ncacn(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncacn *r)
258 {
259 if (ndr_flags & NDR_SCALARS) {
260 NDR_CHECK(ndr_push_align(ndr, 2));
261 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
262 }
263 if (ndr_flags & NDR_BUFFERS) {
264 }
265 return NDR_ERR_SUCCESS;
266 }
267
268 static enum ndr_err_code ndr_pull_epm_rhs_ncacn(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncacn *r)
269 {
270 if (ndr_flags & NDR_SCALARS) {
271 NDR_CHECK(ndr_pull_align(ndr, 2));
272 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
273 }
274 if (ndr_flags & NDR_BUFFERS) {
275 }
276 return NDR_ERR_SUCCESS;
277 }
278
279 _PUBLIC_ void ndr_print_epm_rhs_ncacn(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncacn *r)
280 {
281 ndr_print_struct(ndr, name, "epm_rhs_ncacn");
282 ndr->depth++;
283 ndr_print_uint16(ndr, "minor_version", r->minor_version);
284 ndr->depth--;
285 }
286
287 static enum ndr_err_code ndr_push_epm_rhs_uuid(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_uuid *r)
288 {
289 if (ndr_flags & NDR_SCALARS) {
290 NDR_CHECK(ndr_push_align(ndr, 4));
291 {
292 uint32_t _flags_save_DATA_BLOB = ndr->flags;
293 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
294 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
295 ndr->flags = _flags_save_DATA_BLOB;
296 }
297 }
298 if (ndr_flags & NDR_BUFFERS) {
299 }
300 return NDR_ERR_SUCCESS;
301 }
302
303 static enum ndr_err_code ndr_pull_epm_rhs_uuid(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_uuid *r)
304 {
305 if (ndr_flags & NDR_SCALARS) {
306 NDR_CHECK(ndr_pull_align(ndr, 4));
307 {
308 uint32_t _flags_save_DATA_BLOB = ndr->flags;
309 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
310 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
311 ndr->flags = _flags_save_DATA_BLOB;
312 }
313 }
314 if (ndr_flags & NDR_BUFFERS) {
315 }
316 return NDR_ERR_SUCCESS;
317 }
318
319 _PUBLIC_ void ndr_print_epm_rhs_uuid(struct ndr_print *ndr, const char *name, const struct epm_rhs_uuid *r)
320 {
321 ndr_print_struct(ndr, name, "epm_rhs_uuid");
322 ndr->depth++;
323 ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
324 ndr->depth--;
325 }
326
327 static enum ndr_err_code ndr_push_epm_rhs_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ipx *r)
328 {
329 if (ndr_flags & NDR_SCALARS) {
330 NDR_CHECK(ndr_push_align(ndr, 1));
331 }
332 if (ndr_flags & NDR_BUFFERS) {
333 }
334 return NDR_ERR_SUCCESS;
335 }
336
337 static enum ndr_err_code ndr_pull_epm_rhs_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ipx *r)
338 {
339 if (ndr_flags & NDR_SCALARS) {
340 NDR_CHECK(ndr_pull_align(ndr, 1));
341 }
342 if (ndr_flags & NDR_BUFFERS) {
343 }
344 return NDR_ERR_SUCCESS;
345 }
346
347 _PUBLIC_ void ndr_print_epm_rhs_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_ipx *r)
348 {
349 ndr_print_struct(ndr, name, "epm_rhs_ipx");
350 ndr->depth++;
351 ndr->depth--;
352 }
353
354 static enum ndr_err_code ndr_push_epm_rhs_smb(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_smb *r)
355 {
356 if (ndr_flags & NDR_SCALARS) {
357 NDR_CHECK(ndr_push_align(ndr, 4));
358 {
359 uint32_t _flags_save_string = ndr->flags;
360 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
361 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->unc));
362 ndr->flags = _flags_save_string;
363 }
364 }
365 if (ndr_flags & NDR_BUFFERS) {
366 }
367 return NDR_ERR_SUCCESS;
368 }
369
370 static enum ndr_err_code ndr_pull_epm_rhs_smb(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_smb *r)
371 {
372 if (ndr_flags & NDR_SCALARS) {
373 NDR_CHECK(ndr_pull_align(ndr, 4));
374 {
375 uint32_t _flags_save_string = ndr->flags;
376 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
377 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->unc));
378 ndr->flags = _flags_save_string;
379 }
380 }
381 if (ndr_flags & NDR_BUFFERS) {
382 }
383 return NDR_ERR_SUCCESS;
384 }
385
386 _PUBLIC_ void ndr_print_epm_rhs_smb(struct ndr_print *ndr, const char *name, const struct epm_rhs_smb *r)
387 {
388 ndr_print_struct(ndr, name, "epm_rhs_smb");
389 ndr->depth++;
390 ndr_print_string(ndr, "unc", r->unc);
391 ndr->depth--;
392 }
393
394 static enum ndr_err_code ndr_push_epm_rhs_named_pipe(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_named_pipe *r)
395 {
396 if (ndr_flags & NDR_SCALARS) {
397 NDR_CHECK(ndr_push_align(ndr, 4));
398 {
399 uint32_t _flags_save_string = ndr->flags;
400 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
401 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
402 ndr->flags = _flags_save_string;
403 }
404 }
405 if (ndr_flags & NDR_BUFFERS) {
406 }
407 return NDR_ERR_SUCCESS;
408 }
409
410 static enum ndr_err_code ndr_pull_epm_rhs_named_pipe(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_named_pipe *r)
411 {
412 if (ndr_flags & NDR_SCALARS) {
413 NDR_CHECK(ndr_pull_align(ndr, 4));
414 {
415 uint32_t _flags_save_string = ndr->flags;
416 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
417 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
418 ndr->flags = _flags_save_string;
419 }
420 }
421 if (ndr_flags & NDR_BUFFERS) {
422 }
423 return NDR_ERR_SUCCESS;
424 }
425
426 _PUBLIC_ void ndr_print_epm_rhs_named_pipe(struct ndr_print *ndr, const char *name, const struct epm_rhs_named_pipe *r)
427 {
428 ndr_print_struct(ndr, name, "epm_rhs_named_pipe");
429 ndr->depth++;
430 ndr_print_string(ndr, "path", r->path);
431 ndr->depth--;
432 }
433
434 static enum ndr_err_code ndr_push_epm_rhs_netbios(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbios *r)
435 {
436 if (ndr_flags & NDR_SCALARS) {
437 NDR_CHECK(ndr_push_align(ndr, 4));
438 {
439 uint32_t _flags_save_string = ndr->flags;
440 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
441 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
442 ndr->flags = _flags_save_string;
443 }
444 }
445 if (ndr_flags & NDR_BUFFERS) {
446 }
447 return NDR_ERR_SUCCESS;
448 }
449
450 static enum ndr_err_code ndr_pull_epm_rhs_netbios(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbios *r)
451 {
452 if (ndr_flags & NDR_SCALARS) {
453 NDR_CHECK(ndr_pull_align(ndr, 4));
454 {
455 uint32_t _flags_save_string = ndr->flags;
456 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
457 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
458 ndr->flags = _flags_save_string;
459 }
460 }
461 if (ndr_flags & NDR_BUFFERS) {
462 }
463 return NDR_ERR_SUCCESS;
464 }
465
466 _PUBLIC_ void ndr_print_epm_rhs_netbios(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbios *r)
467 {
468 ndr_print_struct(ndr, name, "epm_rhs_netbios");
469 ndr->depth++;
470 ndr_print_string(ndr, "name", r->name);
471 ndr->depth--;
472 }
473
474 static enum ndr_err_code ndr_push_epm_rhs_netbeui(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_netbeui *r)
475 {
476 if (ndr_flags & NDR_SCALARS) {
477 NDR_CHECK(ndr_push_align(ndr, 1));
478 }
479 if (ndr_flags & NDR_BUFFERS) {
480 }
481 return NDR_ERR_SUCCESS;
482 }
483
484 static enum ndr_err_code ndr_pull_epm_rhs_netbeui(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_netbeui *r)
485 {
486 if (ndr_flags & NDR_SCALARS) {
487 NDR_CHECK(ndr_pull_align(ndr, 1));
488 }
489 if (ndr_flags & NDR_BUFFERS) {
490 }
491 return NDR_ERR_SUCCESS;
492 }
493
494 _PUBLIC_ void ndr_print_epm_rhs_netbeui(struct ndr_print *ndr, const char *name, const struct epm_rhs_netbeui *r)
495 {
496 ndr_print_struct(ndr, name, "epm_rhs_netbeui");
497 ndr->depth++;
498 ndr->depth--;
499 }
500
501 static enum ndr_err_code ndr_push_epm_rhs_spx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_spx *r)
502 {
503 if (ndr_flags & NDR_SCALARS) {
504 NDR_CHECK(ndr_push_align(ndr, 1));
505 }
506 if (ndr_flags & NDR_BUFFERS) {
507 }
508 return NDR_ERR_SUCCESS;
509 }
510
511 static enum ndr_err_code ndr_pull_epm_rhs_spx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_spx *r)
512 {
513 if (ndr_flags & NDR_SCALARS) {
514 NDR_CHECK(ndr_pull_align(ndr, 1));
515 }
516 if (ndr_flags & NDR_BUFFERS) {
517 }
518 return NDR_ERR_SUCCESS;
519 }
520
521 _PUBLIC_ void ndr_print_epm_rhs_spx(struct ndr_print *ndr, const char *name, const struct epm_rhs_spx *r)
522 {
523 ndr_print_struct(ndr, name, "epm_rhs_spx");
524 ndr->depth++;
525 ndr->depth--;
526 }
527
528 static enum ndr_err_code ndr_push_epm_rhs_nb_ipx(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_nb_ipx *r)
529 {
530 if (ndr_flags & NDR_SCALARS) {
531 NDR_CHECK(ndr_push_align(ndr, 1));
532 }
533 if (ndr_flags & NDR_BUFFERS) {
534 }
535 return NDR_ERR_SUCCESS;
536 }
537
538 static enum ndr_err_code ndr_pull_epm_rhs_nb_ipx(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_nb_ipx *r)
539 {
540 if (ndr_flags & NDR_SCALARS) {
541 NDR_CHECK(ndr_pull_align(ndr, 1));
542 }
543 if (ndr_flags & NDR_BUFFERS) {
544 }
545 return NDR_ERR_SUCCESS;
546 }
547
548 _PUBLIC_ void ndr_print_epm_rhs_nb_ipx(struct ndr_print *ndr, const char *name, const struct epm_rhs_nb_ipx *r)
549 {
550 ndr_print_struct(ndr, name, "epm_rhs_nb_ipx");
551 ndr->depth++;
552 ndr->depth--;
553 }
554
555 static enum ndr_err_code ndr_push_epm_rhs_http(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_http *r)
556 {
557 if (ndr_flags & NDR_SCALARS) {
558 NDR_CHECK(ndr_push_align(ndr, 2));
559 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
560 }
561 if (ndr_flags & NDR_BUFFERS) {
562 }
563 return NDR_ERR_SUCCESS;
564 }
565
566 static enum ndr_err_code ndr_pull_epm_rhs_http(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_http *r)
567 {
568 if (ndr_flags & NDR_SCALARS) {
569 NDR_CHECK(ndr_pull_align(ndr, 2));
570 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
571 }
572 if (ndr_flags & NDR_BUFFERS) {
573 }
574 return NDR_ERR_SUCCESS;
575 }
576
577 _PUBLIC_ void ndr_print_epm_rhs_http(struct ndr_print *ndr, const char *name, const struct epm_rhs_http *r)
578 {
579 ndr_print_struct(ndr, name, "epm_rhs_http");
580 ndr->depth++;
581 ndr_print_uint16(ndr, "port", r->port);
582 ndr->depth--;
583 }
584
585 static enum ndr_err_code ndr_push_epm_rhs_unix_ds(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_unix_ds *r)
586 {
587 if (ndr_flags & NDR_SCALARS) {
588 NDR_CHECK(ndr_push_align(ndr, 4));
589 {
590 uint32_t _flags_save_string = ndr->flags;
591 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
592 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->path));
593 ndr->flags = _flags_save_string;
594 }
595 }
596 if (ndr_flags & NDR_BUFFERS) {
597 }
598 return NDR_ERR_SUCCESS;
599 }
600
601 static enum ndr_err_code ndr_pull_epm_rhs_unix_ds(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_unix_ds *r)
602 {
603 if (ndr_flags & NDR_SCALARS) {
604 NDR_CHECK(ndr_pull_align(ndr, 4));
605 {
606 uint32_t _flags_save_string = ndr->flags;
607 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
608 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->path));
609 ndr->flags = _flags_save_string;
610 }
611 }
612 if (ndr_flags & NDR_BUFFERS) {
613 }
614 return NDR_ERR_SUCCESS;
615 }
616
617 _PUBLIC_ void ndr_print_epm_rhs_unix_ds(struct ndr_print *ndr, const char *name, const struct epm_rhs_unix_ds *r)
618 {
619 ndr_print_struct(ndr, name, "epm_rhs_unix_ds");
620 ndr->depth++;
621 ndr_print_string(ndr, "path", r->path);
622 ndr->depth--;
623 }
624
625 static enum ndr_err_code ndr_push_epm_rhs_null(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_null *r)
626 {
627 if (ndr_flags & NDR_SCALARS) {
628 NDR_CHECK(ndr_push_align(ndr, 1));
629 }
630 if (ndr_flags & NDR_BUFFERS) {
631 }
632 return NDR_ERR_SUCCESS;
633 }
634
635 static enum ndr_err_code ndr_pull_epm_rhs_null(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_null *r)
636 {
637 if (ndr_flags & NDR_SCALARS) {
638 NDR_CHECK(ndr_pull_align(ndr, 1));
639 }
640 if (ndr_flags & NDR_BUFFERS) {
641 }
642 return NDR_ERR_SUCCESS;
643 }
644
645 _PUBLIC_ void ndr_print_epm_rhs_null(struct ndr_print *ndr, const char *name, const struct epm_rhs_null *r)
646 {
647 ndr_print_struct(ndr, name, "epm_rhs_null");
648 ndr->depth++;
649 ndr->depth--;
650 }
651
652 static enum ndr_err_code ndr_push_epm_rhs_ncalrpc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_ncalrpc *r)
653 {
654 if (ndr_flags & NDR_SCALARS) {
655 NDR_CHECK(ndr_push_align(ndr, 2));
656 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minor_version));
657 }
658 if (ndr_flags & NDR_BUFFERS) {
659 }
660 return NDR_ERR_SUCCESS;
661 }
662
663 static enum ndr_err_code ndr_pull_epm_rhs_ncalrpc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_ncalrpc *r)
664 {
665 if (ndr_flags & NDR_SCALARS) {
666 NDR_CHECK(ndr_pull_align(ndr, 2));
667 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minor_version));
668 }
669 if (ndr_flags & NDR_BUFFERS) {
670 }
671 return NDR_ERR_SUCCESS;
672 }
673
674 _PUBLIC_ void ndr_print_epm_rhs_ncalrpc(struct ndr_print *ndr, const char *name, const struct epm_rhs_ncalrpc *r)
675 {
676 ndr_print_struct(ndr, name, "epm_rhs_ncalrpc");
677 ndr->depth++;
678 ndr_print_uint16(ndr, "minor_version", r->minor_version);
679 ndr->depth--;
680 }
681
682 static enum ndr_err_code ndr_push_epm_rhs_appletalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_appletalk *r)
683 {
684 if (ndr_flags & NDR_SCALARS) {
685 NDR_CHECK(ndr_push_align(ndr, 1));
686 }
687 if (ndr_flags & NDR_BUFFERS) {
688 }
689 return NDR_ERR_SUCCESS;
690 }
691
692 static enum ndr_err_code ndr_pull_epm_rhs_appletalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_appletalk *r)
693 {
694 if (ndr_flags & NDR_SCALARS) {
695 NDR_CHECK(ndr_pull_align(ndr, 1));
696 }
697 if (ndr_flags & NDR_BUFFERS) {
698 }
699 return NDR_ERR_SUCCESS;
700 }
701
702 _PUBLIC_ void ndr_print_epm_rhs_appletalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_appletalk *r)
703 {
704 ndr_print_struct(ndr, name, "epm_rhs_appletalk");
705 ndr->depth++;
706 ndr->depth--;
707 }
708
709 static enum ndr_err_code ndr_push_epm_rhs_atalk_stream(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_stream *r)
710 {
711 if (ndr_flags & NDR_SCALARS) {
712 NDR_CHECK(ndr_push_align(ndr, 1));
713 }
714 if (ndr_flags & NDR_BUFFERS) {
715 }
716 return NDR_ERR_SUCCESS;
717 }
718
719 static enum ndr_err_code ndr_pull_epm_rhs_atalk_stream(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_stream *r)
720 {
721 if (ndr_flags & NDR_SCALARS) {
722 NDR_CHECK(ndr_pull_align(ndr, 1));
723 }
724 if (ndr_flags & NDR_BUFFERS) {
725 }
726 return NDR_ERR_SUCCESS;
727 }
728
729 _PUBLIC_ void ndr_print_epm_rhs_atalk_stream(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_stream *r)
730 {
731 ndr_print_struct(ndr, name, "epm_rhs_atalk_stream");
732 ndr->depth++;
733 ndr->depth--;
734 }
735
736 static enum ndr_err_code ndr_push_epm_rhs_atalk_datagram(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_atalk_datagram *r)
737 {
738 if (ndr_flags & NDR_SCALARS) {
739 NDR_CHECK(ndr_push_align(ndr, 1));
740 }
741 if (ndr_flags & NDR_BUFFERS) {
742 }
743 return NDR_ERR_SUCCESS;
744 }
745
746 static enum ndr_err_code ndr_pull_epm_rhs_atalk_datagram(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_atalk_datagram *r)
747 {
748 if (ndr_flags & NDR_SCALARS) {
749 NDR_CHECK(ndr_pull_align(ndr, 1));
750 }
751 if (ndr_flags & NDR_BUFFERS) {
752 }
753 return NDR_ERR_SUCCESS;
754 }
755
756 _PUBLIC_ void ndr_print_epm_rhs_atalk_datagram(struct ndr_print *ndr, const char *name, const struct epm_rhs_atalk_datagram *r)
757 {
758 ndr_print_struct(ndr, name, "epm_rhs_atalk_datagram");
759 ndr->depth++;
760 ndr->depth--;
761 }
762
763 static enum ndr_err_code ndr_push_epm_rhs_vines_spp(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_spp *r)
764 {
765 if (ndr_flags & NDR_SCALARS) {
766 NDR_CHECK(ndr_push_align(ndr, 2));
767 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
768 }
769 if (ndr_flags & NDR_BUFFERS) {
770 }
771 return NDR_ERR_SUCCESS;
772 }
773
774 static enum ndr_err_code ndr_pull_epm_rhs_vines_spp(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_spp *r)
775 {
776 if (ndr_flags & NDR_SCALARS) {
777 NDR_CHECK(ndr_pull_align(ndr, 2));
778 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
779 }
780 if (ndr_flags & NDR_BUFFERS) {
781 }
782 return NDR_ERR_SUCCESS;
783 }
784
785 _PUBLIC_ void ndr_print_epm_rhs_vines_spp(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_spp *r)
786 {
787 ndr_print_struct(ndr, name, "epm_rhs_vines_spp");
788 ndr->depth++;
789 ndr_print_uint16(ndr, "port", r->port);
790 ndr->depth--;
791 }
792
793 static enum ndr_err_code ndr_push_epm_rhs_vines_ipc(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_vines_ipc *r)
794 {
795 if (ndr_flags & NDR_SCALARS) {
796 NDR_CHECK(ndr_push_align(ndr, 2));
797 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->port));
798 }
799 if (ndr_flags & NDR_BUFFERS) {
800 }
801 return NDR_ERR_SUCCESS;
802 }
803
804 static enum ndr_err_code ndr_pull_epm_rhs_vines_ipc(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_vines_ipc *r)
805 {
806 if (ndr_flags & NDR_SCALARS) {
807 NDR_CHECK(ndr_pull_align(ndr, 2));
808 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->port));
809 }
810 if (ndr_flags & NDR_BUFFERS) {
811 }
812 return NDR_ERR_SUCCESS;
813 }
814
815 _PUBLIC_ void ndr_print_epm_rhs_vines_ipc(struct ndr_print *ndr, const char *name, const struct epm_rhs_vines_ipc *r)
816 {
817 ndr_print_struct(ndr, name, "epm_rhs_vines_ipc");
818 ndr->depth++;
819 ndr_print_uint16(ndr, "port", r->port);
820 ndr->depth--;
821 }
822
823 static enum ndr_err_code ndr_push_epm_rhs_streettalk(struct ndr_push *ndr, int ndr_flags, const struct epm_rhs_streettalk *r)
824 {
825 if (ndr_flags & NDR_SCALARS) {
826 NDR_CHECK(ndr_push_align(ndr, 4));
827 {
828 uint32_t _flags_save_string = ndr->flags;
829 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
830 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->streettalk));
831 ndr->flags = _flags_save_string;
832 }
833 }
834 if (ndr_flags & NDR_BUFFERS) {
835 }
836 return NDR_ERR_SUCCESS;
837 }
838
839 static enum ndr_err_code ndr_pull_epm_rhs_streettalk(struct ndr_pull *ndr, int ndr_flags, struct epm_rhs_streettalk *r)
840 {
841 if (ndr_flags & NDR_SCALARS) {
842 NDR_CHECK(ndr_pull_align(ndr, 4));
843 {
844 uint32_t _flags_save_string = ndr->flags;
845 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
846 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->streettalk));
847 ndr->flags = _flags_save_string;
848 }
849 }
850 if (ndr_flags & NDR_BUFFERS) {
851 }
852 return NDR_ERR_SUCCESS;
853 }
854
855 _PUBLIC_ void ndr_print_epm_rhs_streettalk(struct ndr_print *ndr, const char *name, const struct epm_rhs_streettalk *r)
856 {
857 ndr_print_struct(ndr, name, "epm_rhs_streettalk");
858 ndr->depth++;
859 ndr_print_string(ndr, "streettalk", r->streettalk);
860 ndr->depth--;
861 }
862
863 static enum ndr_err_code ndr_push_epm_rhs(struct ndr_push *ndr, int ndr_flags, const union epm_rhs *r)
864 {
865 {
866 uint32_t _flags_save_UNION = ndr->flags;
867 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
868 if (ndr_flags & NDR_SCALARS) {
869 int level = ndr_push_get_switch_value(ndr, r);
870 NDR_CHECK(ndr_push_union_align(ndr, 4));
871 switch (level) {
872 case EPM_PROTOCOL_DNET_NSP: {
873 NDR_CHECK(ndr_push_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
874 break; }
875
876 case EPM_PROTOCOL_OSI_TP4: {
877 NDR_CHECK(ndr_push_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
878 break; }
879
880 case EPM_PROTOCOL_OSI_CLNS: {
881 NDR_CHECK(ndr_push_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
882 break; }
883
884 case EPM_PROTOCOL_TCP: {
885 NDR_CHECK(ndr_push_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
886 break; }
887
888 case EPM_PROTOCOL_UDP: {
889 NDR_CHECK(ndr_push_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
890 break; }
891
892 case EPM_PROTOCOL_IP: {
893 NDR_CHECK(ndr_push_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
894 break; }
895
896 case EPM_PROTOCOL_NCADG: {
897 NDR_CHECK(ndr_push_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
898 break; }
899
900 case EPM_PROTOCOL_NCACN: {
901 NDR_CHECK(ndr_push_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
902 break; }
903
904 case EPM_PROTOCOL_NCALRPC: {
905 NDR_CHECK(ndr_push_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
906 break; }
907
908 case EPM_PROTOCOL_UUID: {
909 NDR_CHECK(ndr_push_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
910 break; }
911
912 case EPM_PROTOCOL_IPX: {
913 NDR_CHECK(ndr_push_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
914 break; }
915
916 case EPM_PROTOCOL_SMB: {
917 NDR_CHECK(ndr_push_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
918 break; }
919
920 case EPM_PROTOCOL_NAMED_PIPE: {
921 NDR_CHECK(ndr_push_epm_rhs_named_pipe(ndr, NDR_SCALARS, &r->named_pipe));
922 break; }
923
924 case EPM_PROTOCOL_NETBIOS: {
925 NDR_CHECK(ndr_push_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
926 break; }
927
928 case EPM_PROTOCOL_NETBEUI: {
929 NDR_CHECK(ndr_push_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
930 break; }
931
932 case EPM_PROTOCOL_SPX: {
933 NDR_CHECK(ndr_push_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
934 break; }
935
936 case EPM_PROTOCOL_NB_IPX: {
937 NDR_CHECK(ndr_push_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
938 break; }
939
940 case EPM_PROTOCOL_DSP: {
941 NDR_CHECK(ndr_push_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
942 break; }
943
944 case EPM_PROTOCOL_DDP: {
945 NDR_CHECK(ndr_push_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
946 break; }
947
948 case EPM_PROTOCOL_APPLETALK: {
949 NDR_CHECK(ndr_push_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
950 break; }
951
952 case EPM_PROTOCOL_VINES_SPP: {
953 NDR_CHECK(ndr_push_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
954 break; }
955
956 case EPM_PROTOCOL_VINES_IPC: {
957 NDR_CHECK(ndr_push_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
958 break; }
959
960 case EPM_PROTOCOL_STREETTALK: {
961 NDR_CHECK(ndr_push_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
962 break; }
963
964 case EPM_PROTOCOL_HTTP: {
965 NDR_CHECK(ndr_push_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
966 break; }
967
968 case EPM_PROTOCOL_UNIX_DS: {
969 NDR_CHECK(ndr_push_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
970 break; }
971
972 case EPM_PROTOCOL_NULL: {
973 NDR_CHECK(ndr_push_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
974 break; }
975
976 default: {
977 {
978 uint32_t _flags_save_DATA_BLOB = ndr->flags;
979 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
980 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->unknown));
981 ndr->flags = _flags_save_DATA_BLOB;
982 }
983 break; }
984
985 }
986 }
987 if (ndr_flags & NDR_BUFFERS) {
988 int level = ndr_push_get_switch_value(ndr, r);
989 switch (level) {
990 case EPM_PROTOCOL_DNET_NSP:
991 break;
992
993 case EPM_PROTOCOL_OSI_TP4:
994 break;
995
996 case EPM_PROTOCOL_OSI_CLNS:
997 break;
998
999 case EPM_PROTOCOL_TCP:
1000 break;
1001
1002 case EPM_PROTOCOL_UDP:
1003 break;
1004
1005 case EPM_PROTOCOL_IP:
1006 break;
1007
1008 case EPM_PROTOCOL_NCADG:
1009 break;
1010
1011 case EPM_PROTOCOL_NCACN:
1012 break;
1013
1014 case EPM_PROTOCOL_NCALRPC:
1015 break;
1016
1017 case EPM_PROTOCOL_UUID:
1018 break;
1019
1020 case EPM_PROTOCOL_IPX:
1021 break;
1022
1023 case EPM_PROTOCOL_SMB:
1024 break;
1025
1026 case EPM_PROTOCOL_NAMED_PIPE:
1027 break;
1028
1029 case EPM_PROTOCOL_NETBIOS:
1030 break;
1031
1032 case EPM_PROTOCOL_NETBEUI:
1033 break;
1034
1035 case EPM_PROTOCOL_SPX:
1036 break;
1037
1038 case EPM_PROTOCOL_NB_IPX:
1039 break;
1040
1041 case EPM_PROTOCOL_DSP:
1042 break;
1043
1044 case EPM_PROTOCOL_DDP:
1045 break;
1046
1047 case EPM_PROTOCOL_APPLETALK:
1048 break;
1049
1050 case EPM_PROTOCOL_VINES_SPP:
1051 break;
1052
1053 case EPM_PROTOCOL_VINES_IPC:
1054 break;
1055
1056 case EPM_PROTOCOL_STREETTALK:
1057 break;
1058
1059 case EPM_PROTOCOL_HTTP:
1060 break;
1061
1062 case EPM_PROTOCOL_UNIX_DS:
1063 break;
1064
1065 case EPM_PROTOCOL_NULL:
1066 break;
1067
1068 default:
1069 break;
1070
1071 }
1072 }
1073 ndr->flags = _flags_save_UNION;
1074 }
1075 return NDR_ERR_SUCCESS;
1076 }
1077
1078 static enum ndr_err_code ndr_pull_epm_rhs(struct ndr_pull *ndr, int ndr_flags, union epm_rhs *r)
1079 {
1080 int level;
1081 {
1082 uint32_t _flags_save_UNION = ndr->flags;
1083 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1084 level = ndr_pull_get_switch_value(ndr, r);
1085 if (ndr_flags & NDR_SCALARS) {
1086 NDR_CHECK(ndr_pull_union_align(ndr, 4));
1087 switch (level) {
1088 case EPM_PROTOCOL_DNET_NSP: {
1089 NDR_CHECK(ndr_pull_epm_rhs_dnet_nsp(ndr, NDR_SCALARS, &r->dnet_nsp));
1090 break; }
1091
1092 case EPM_PROTOCOL_OSI_TP4: {
1093 NDR_CHECK(ndr_pull_epm_rhs_osi_tp4(ndr, NDR_SCALARS, &r->osi_tp4));
1094 break; }
1095
1096 case EPM_PROTOCOL_OSI_CLNS: {
1097 NDR_CHECK(ndr_pull_epm_rhs_osi_clns(ndr, NDR_SCALARS, &r->osi_clns));
1098 break; }
1099
1100 case EPM_PROTOCOL_TCP: {
1101 NDR_CHECK(ndr_pull_epm_rhs_tcp(ndr, NDR_SCALARS, &r->tcp));
1102 break; }
1103
1104 case EPM_PROTOCOL_UDP: {
1105 NDR_CHECK(ndr_pull_epm_rhs_udp(ndr, NDR_SCALARS, &r->udp));
1106 break; }
1107
1108 case EPM_PROTOCOL_IP: {
1109 NDR_CHECK(ndr_pull_epm_rhs_ip(ndr, NDR_SCALARS, &r->ip));
1110 break; }
1111
1112 case EPM_PROTOCOL_NCADG: {
1113 NDR_CHECK(ndr_pull_epm_rhs_ncadg(ndr, NDR_SCALARS, &r->ncadg));
1114 break; }
1115
1116 case EPM_PROTOCOL_NCACN: {
1117 NDR_CHECK(ndr_pull_epm_rhs_ncacn(ndr, NDR_SCALARS, &r->ncacn));
1118 break; }
1119
1120 case EPM_PROTOCOL_NCALRPC: {
1121 NDR_CHECK(ndr_pull_epm_rhs_ncalrpc(ndr, NDR_SCALARS, &r->ncalrpc));
1122 break; }
1123
1124 case EPM_PROTOCOL_UUID: {
1125 NDR_CHECK(ndr_pull_epm_rhs_uuid(ndr, NDR_SCALARS, &r->uuid));
1126 break; }
1127
1128 case EPM_PROTOCOL_IPX: {
1129 NDR_CHECK(ndr_pull_epm_rhs_ipx(ndr, NDR_SCALARS, &r->ipx));
1130 break; }
1131
1132 case EPM_PROTOCOL_SMB: {
1133 NDR_CHECK(ndr_pull_epm_rhs_smb(ndr, NDR_SCALARS, &r->smb));
1134 break; }
1135
1136 case EPM_PROTOCOL_NAMED_PIPE: {
1137 NDR_CHECK(ndr_pull_epm_rhs_named_pipe(ndr, NDR_SCALARS, &r->named_pipe));
1138 break; }
1139
1140 case EPM_PROTOCOL_NETBIOS: {
1141 NDR_CHECK(ndr_pull_epm_rhs_netbios(ndr, NDR_SCALARS, &r->netbios));
1142 break; }
1143
1144 case EPM_PROTOCOL_NETBEUI: {
1145 NDR_CHECK(ndr_pull_epm_rhs_netbeui(ndr, NDR_SCALARS, &r->netbeui));
1146 break; }
1147
1148 case EPM_PROTOCOL_SPX: {
1149 NDR_CHECK(ndr_pull_epm_rhs_spx(ndr, NDR_SCALARS, &r->spx));
1150 break; }
1151
1152 case EPM_PROTOCOL_NB_IPX: {
1153 NDR_CHECK(ndr_pull_epm_rhs_nb_ipx(ndr, NDR_SCALARS, &r->nb_ipx));
1154 break; }
1155
1156 case EPM_PROTOCOL_DSP: {
1157 NDR_CHECK(ndr_pull_epm_rhs_atalk_stream(ndr, NDR_SCALARS, &r->atalk_stream));
1158 break; }
1159
1160 case EPM_PROTOCOL_DDP: {
1161 NDR_CHECK(ndr_pull_epm_rhs_atalk_datagram(ndr, NDR_SCALARS, &r->atalk_datagram));
1162 break; }
1163
1164 case EPM_PROTOCOL_APPLETALK: {
1165 NDR_CHECK(ndr_pull_epm_rhs_appletalk(ndr, NDR_SCALARS, &r->appletalk));
1166 break; }
1167
1168 case EPM_PROTOCOL_VINES_SPP: {
1169 NDR_CHECK(ndr_pull_epm_rhs_vines_spp(ndr, NDR_SCALARS, &r->vines_spp));
1170 break; }
1171
1172 case EPM_PROTOCOL_VINES_IPC: {
1173 NDR_CHECK(ndr_pull_epm_rhs_vines_ipc(ndr, NDR_SCALARS, &r->vines_ipc));
1174 break; }
1175
1176 case EPM_PROTOCOL_STREETTALK: {
1177 NDR_CHECK(ndr_pull_epm_rhs_streettalk(ndr, NDR_SCALARS, &r->streettalk));
1178 break; }
1179
1180 case EPM_PROTOCOL_HTTP: {
1181 NDR_CHECK(ndr_pull_epm_rhs_http(ndr, NDR_SCALARS, &r->http));
1182 break; }
1183
1184 case EPM_PROTOCOL_UNIX_DS: {
1185 NDR_CHECK(ndr_pull_epm_rhs_unix_ds(ndr, NDR_SCALARS, &r->unix_ds));
1186 break; }
1187
1188 case EPM_PROTOCOL_NULL: {
1189 NDR_CHECK(ndr_pull_epm_rhs_null(ndr, NDR_SCALARS, &r->null));
1190 break; }
1191
1192 default: {
1193 {
1194 uint32_t _flags_save_DATA_BLOB = ndr->flags;
1195 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1196 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->unknown));
1197 ndr->flags = _flags_save_DATA_BLOB;
1198 }
1199 break; }
1200
1201 }
1202 }
1203 if (ndr_flags & NDR_BUFFERS) {
1204 switch (level) {
1205 case EPM_PROTOCOL_DNET_NSP:
1206 break;
1207
1208 case EPM_PROTOCOL_OSI_TP4:
1209 break;
1210
1211 case EPM_PROTOCOL_OSI_CLNS:
1212 break;
1213
1214 case EPM_PROTOCOL_TCP:
1215 break;
1216
1217 case EPM_PROTOCOL_UDP:
1218 break;
1219
1220 case EPM_PROTOCOL_IP:
1221 break;
1222
1223 case EPM_PROTOCOL_NCADG:
1224 break;
1225
1226 case EPM_PROTOCOL_NCACN:
1227 break;
1228
1229 case EPM_PROTOCOL_NCALRPC:
1230 break;
1231
1232 case EPM_PROTOCOL_UUID:
1233 break;
1234
1235 case EPM_PROTOCOL_IPX:
1236 break;
1237
1238 case EPM_PROTOCOL_SMB:
1239 break;
1240
1241 case EPM_PROTOCOL_NAMED_PIPE:
1242 break;
1243
1244 case EPM_PROTOCOL_NETBIOS:
1245 break;
1246
1247 case EPM_PROTOCOL_NETBEUI:
1248 break;
1249
1250 case EPM_PROTOCOL_SPX:
1251 break;
1252
1253 case EPM_PROTOCOL_NB_IPX:
1254 break;
1255
1256 case EPM_PROTOCOL_DSP:
1257 break;
1258
1259 case EPM_PROTOCOL_DDP:
1260 break;
1261
1262 case EPM_PROTOCOL_APPLETALK:
1263 break;
1264
1265 case EPM_PROTOCOL_VINES_SPP:
1266 break;
1267
1268 case EPM_PROTOCOL_VINES_IPC:
1269 break;
1270
1271 case EPM_PROTOCOL_STREETTALK:
1272 break;
1273
1274 case EPM_PROTOCOL_HTTP:
1275 break;
1276
1277 case EPM_PROTOCOL_UNIX_DS:
1278 break;
1279
1280 case EPM_PROTOCOL_NULL:
1281 break;
1282
1283 default:
1284 break;
1285
1286 }
1287 }
1288 ndr->flags = _flags_save_UNION;
1289 }
1290 return NDR_ERR_SUCCESS;
1291 }
1292
1293 _PUBLIC_ void ndr_print_epm_rhs(struct ndr_print *ndr, const char *name, const union epm_rhs *r)
1294 {
1295 int level;
1296 {
1297 uint32_t _flags_save_UNION = ndr->flags;
1298 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1299 level = ndr_print_get_switch_value(ndr, r);
1300 ndr_print_union(ndr, name, level, "epm_rhs");
1301 switch (level) {
1302 case EPM_PROTOCOL_DNET_NSP:
1303 ndr_print_epm_rhs_dnet_nsp(ndr, "dnet_nsp", &r->dnet_nsp);
1304 break;
1305
1306 case EPM_PROTOCOL_OSI_TP4:
1307 ndr_print_epm_rhs_osi_tp4(ndr, "osi_tp4", &r->osi_tp4);
1308 break;
1309
1310 case EPM_PROTOCOL_OSI_CLNS:
1311 ndr_print_epm_rhs_osi_clns(ndr, "osi_clns", &r->osi_clns);
1312 break;
1313
1314 case EPM_PROTOCOL_TCP:
1315 ndr_print_epm_rhs_tcp(ndr, "tcp", &r->tcp);
1316 break;
1317
1318 case EPM_PROTOCOL_UDP:
1319 ndr_print_epm_rhs_udp(ndr, "udp", &r->udp);
1320 break;
1321
1322 case EPM_PROTOCOL_IP:
1323 ndr_print_epm_rhs_ip(ndr, "ip", &r->ip);
1324 break;
1325
1326 case EPM_PROTOCOL_NCADG:
1327 ndr_print_epm_rhs_ncadg(ndr, "ncadg", &r->ncadg);
1328 break;
1329
1330 case EPM_PROTOCOL_NCACN:
1331 ndr_print_epm_rhs_ncacn(ndr, "ncacn", &r->ncacn);
1332 break;
1333
1334 case EPM_PROTOCOL_NCALRPC:
1335 ndr_print_epm_rhs_ncalrpc(ndr, "ncalrpc", &r->ncalrpc);
1336 break;
1337
1338 case EPM_PROTOCOL_UUID:
1339 ndr_print_epm_rhs_uuid(ndr, "uuid", &r->uuid);
1340 break;
1341
1342 case EPM_PROTOCOL_IPX:
1343 ndr_print_epm_rhs_ipx(ndr, "ipx", &r->ipx);
1344 break;
1345
1346 case EPM_PROTOCOL_SMB:
1347 ndr_print_epm_rhs_smb(ndr, "smb", &r->smb);
1348 break;
1349
1350 case EPM_PROTOCOL_NAMED_PIPE:
1351 ndr_print_epm_rhs_named_pipe(ndr, "named_pipe", &r->named_pipe);
1352 break;
1353
1354 case EPM_PROTOCOL_NETBIOS:
1355 ndr_print_epm_rhs_netbios(ndr, "netbios", &r->netbios);
1356 break;
1357
1358 case EPM_PROTOCOL_NETBEUI:
1359 ndr_print_epm_rhs_netbeui(ndr, "netbeui", &r->netbeui);
1360 break;
1361
1362 case EPM_PROTOCOL_SPX:
1363 ndr_print_epm_rhs_spx(ndr, "spx", &r->spx);
1364 break;
1365
1366 case EPM_PROTOCOL_NB_IPX:
1367 ndr_print_epm_rhs_nb_ipx(ndr, "nb_ipx", &r->nb_ipx);
1368 break;
1369
1370 case EPM_PROTOCOL_DSP:
1371 ndr_print_epm_rhs_atalk_stream(ndr, "atalk_stream", &r->atalk_stream);
1372 break;
1373
1374 case EPM_PROTOCOL_DDP:
1375 ndr_print_epm_rhs_atalk_datagram(ndr, "atalk_datagram", &r->atalk_datagram);
1376 break;
1377
1378 case EPM_PROTOCOL_APPLETALK:
1379 ndr_print_epm_rhs_appletalk(ndr, "appletalk", &r->appletalk);
1380 break;
1381
1382 case EPM_PROTOCOL_VINES_SPP:
1383 ndr_print_epm_rhs_vines_spp(ndr, "vines_spp", &r->vines_spp);
1384 break;
1385
1386 case EPM_PROTOCOL_VINES_IPC:
1387 ndr_print_epm_rhs_vines_ipc(ndr, "vines_ipc", &r->vines_ipc);
1388 break;
1389
1390 case EPM_PROTOCOL_STREETTALK:
1391 ndr_print_epm_rhs_streettalk(ndr, "streettalk", &r->streettalk);
1392 break;
1393
1394 case EPM_PROTOCOL_HTTP:
1395 ndr_print_epm_rhs_http(ndr, "http", &r->http);
1396 break;
1397
1398 case EPM_PROTOCOL_UNIX_DS:
1399 ndr_print_epm_rhs_unix_ds(ndr, "unix_ds", &r->unix_ds);
1400 break;
1401
1402 case EPM_PROTOCOL_NULL:
1403 ndr_print_epm_rhs_null(ndr, "null", &r->null);
1404 break;
1405
1406 default:
1407 ndr_print_DATA_BLOB(ndr, "unknown", r->unknown);
1408 break;
1409
1410 }
1411 ndr->flags = _flags_save_UNION;
1412 }
1413 }
1414
1415 static enum ndr_err_code ndr_push_epm_lhs(struct ndr_push *ndr, int ndr_flags, const struct epm_lhs *r)
1416 {
1417 if (ndr_flags & NDR_SCALARS) {
1418 NDR_CHECK(ndr_push_align(ndr, 4));
1419 NDR_CHECK(ndr_push_epm_protocol(ndr, NDR_SCALARS, r->protocol));
1420 {
1421 uint32_t _flags_save_DATA_BLOB = ndr->flags;
1422 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1423 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->lhs_data));
1424 ndr->flags = _flags_save_DATA_BLOB;
1425 }
1426 }
1427 if (ndr_flags & NDR_BUFFERS) {
1428 }
1429 return NDR_ERR_SUCCESS;
1430 }
1431
1432 static enum ndr_err_code ndr_pull_epm_lhs(struct ndr_pull *ndr, int ndr_flags, struct epm_lhs *r)
1433 {
1434 if (ndr_flags & NDR_SCALARS) {
1435 NDR_CHECK(ndr_pull_align(ndr, 4));
1436 NDR_CHECK(ndr_pull_epm_protocol(ndr, NDR_SCALARS, &r->protocol));
1437 {
1438 uint32_t _flags_save_DATA_BLOB = ndr->flags;
1439 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1440 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->lhs_data));
1441 ndr->flags = _flags_save_DATA_BLOB;
1442 }
1443 }
1444 if (ndr_flags & NDR_BUFFERS) {
1445 }
1446 return NDR_ERR_SUCCESS;
1447 }
1448
1449 _PUBLIC_ void ndr_print_epm_lhs(struct ndr_print *ndr, const char *name, const struct epm_lhs *r)
1450 {
1451 ndr_print_struct(ndr, name, "epm_lhs");
1452 ndr->depth++;
1453 ndr_print_epm_protocol(ndr, "protocol", r->protocol);
1454 ndr_print_DATA_BLOB(ndr, "lhs_data", r->lhs_data);
1455 ndr->depth--;
1456 }
1457
1458 static enum ndr_err_code ndr_push_epm_floor(struct ndr_push *ndr, int ndr_flags, const struct epm_floor *r)
1459 {
1460 if (ndr_flags & NDR_SCALARS) {
1461 NDR_CHECK(ndr_push_align(ndr, 1));
1462 {
1463 struct ndr_push *_ndr_lhs;
1464 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_lhs, 2, -1));
1465 NDR_CHECK(ndr_push_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
1466 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_lhs, 2, -1));
1467 }
1468 {
1469 struct ndr_push *_ndr_rhs;
1470 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_rhs, 2, -1));
1471 NDR_CHECK(ndr_push_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
1472 NDR_CHECK(ndr_push_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
1473 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_rhs, 2, -1));
1474 }
1475 }
1476 if (ndr_flags & NDR_BUFFERS) {
1477 }
1478 return NDR_ERR_SUCCESS;
1479 }
1480
1481 static enum ndr_err_code ndr_pull_epm_floor(struct ndr_pull *ndr, int ndr_flags, struct epm_floor *r)
1482 {
1483 if (ndr_flags & NDR_SCALARS) {
1484 NDR_CHECK(ndr_pull_align(ndr, 1));
1485 {
1486 struct ndr_pull *_ndr_lhs;
1487 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_lhs, 2, -1));
1488 NDR_CHECK(ndr_pull_epm_lhs(_ndr_lhs, NDR_SCALARS, &r->lhs));
1489 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_lhs, 2, -1));
1490 }
1491 {
1492 struct ndr_pull *_ndr_rhs;
1493 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_rhs, 2, -1));
1494 NDR_CHECK(ndr_pull_set_switch_value(_ndr_rhs, &r->rhs, r->lhs.protocol));
1495 NDR_CHECK(ndr_pull_epm_rhs(_ndr_rhs, NDR_SCALARS, &r->rhs));
1496 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_rhs, 2, -1));
1497 }
1498 }
1499 if (ndr_flags & NDR_BUFFERS) {
1500 }
1501 return NDR_ERR_SUCCESS;
1502 }
1503
1504 _PUBLIC_ void ndr_print_epm_floor(struct ndr_print *ndr, const char *name, const struct epm_floor *r)
1505 {
1506 ndr_print_struct(ndr, name, "epm_floor");
1507 ndr->depth++;
1508 ndr_print_epm_lhs(ndr, "lhs", &r->lhs);
1509 ndr_print_set_switch_value(ndr, &r->rhs, r->lhs.protocol);
1510 ndr_print_epm_rhs(ndr, "rhs", &r->rhs);
1511 ndr->depth--;
1512 }
1513
1514 static enum ndr_err_code ndr_push_epm_tower(struct ndr_push *ndr, int ndr_flags, const struct epm_tower *r)
1515 {
1516 uint32_t cntr_floors_0;
1517 {
1518 uint32_t _flags_save_STRUCT = ndr->flags;
1519 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1520 if (ndr_flags & NDR_SCALARS) {
1521 NDR_CHECK(ndr_push_align(ndr, 2));
1522 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_floors));
1523 for (cntr_floors_0 = 0; cntr_floors_0 < r->num_floors; cntr_floors_0++) {
1524 NDR_CHECK(ndr_push_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
1525 }
1526 }
1527 if (ndr_flags & NDR_BUFFERS) {
1528 }
1529 ndr->flags = _flags_save_STRUCT;
1530 }
1531 return NDR_ERR_SUCCESS;
1532 }
1533
1534 static enum ndr_err_code ndr_pull_epm_tower(struct ndr_pull *ndr, int ndr_flags, struct epm_tower *r)
1535 {
1536 uint32_t cntr_floors_0;
1537 TALLOC_CTX *_mem_save_floors_0;
1538 {
1539 uint32_t _flags_save_STRUCT = ndr->flags;
1540 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1541 if (ndr_flags & NDR_SCALARS) {
1542 NDR_CHECK(ndr_pull_align(ndr, 2));
1543 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_floors));
1544 NDR_PULL_ALLOC_N(ndr, r->floors, r->num_floors);
1545 _mem_save_floors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1546 NDR_PULL_SET_MEM_CTX(ndr, r->floors, 0);
1547 for (cntr_floors_0 = 0; cntr_floors_0 < r->num_floors; cntr_floors_0++) {
1548 NDR_CHECK(ndr_pull_epm_floor(ndr, NDR_SCALARS, &r->floors[cntr_floors_0]));
1549 }
1550 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_floors_0, 0);
1551 }
1552 if (ndr_flags & NDR_BUFFERS) {
1553 }
1554 ndr->flags = _flags_save_STRUCT;
1555 }
1556 return NDR_ERR_SUCCESS;
1557 }
1558
1559 _PUBLIC_ void ndr_print_epm_tower(struct ndr_print *ndr, const char *name, const struct epm_tower *r)
1560 {
1561 uint32_t cntr_floors_0;
1562 ndr_print_struct(ndr, name, "epm_tower");
1563 {
1564 uint32_t _flags_save_STRUCT = ndr->flags;
1565 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN);
1566 ndr->depth++;
1567 ndr_print_uint16(ndr, "num_floors", r->num_floors);
1568 ndr->print(ndr, "%s: ARRAY(%d)", "floors", (int)r->num_floors);
1569 ndr->depth++;
1570 for (cntr_floors_0=0;cntr_floors_0<r->num_floors;cntr_floors_0++) {
1571 char *idx_0=NULL;
1572 if (asprintf(&idx_0, "[%d]", cntr_floors_0) != -1) {
1573 ndr_print_epm_floor(ndr, "floors", &r->floors[cntr_floors_0]);
1574 free(idx_0);
1575 }
1576 }
1577 ndr->depth--;
1578 ndr->depth--;
1579 ndr->flags = _flags_save_STRUCT;
1580 }
1581 }
1582
1583 static size_t ndr_size_epm_tower(const struct epm_tower *r, struct smb_iconv_convenience *ic, int flags)
1584 {
1585 flags |= LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_LITTLE_ENDIAN;
1586 return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_epm_tower, ic);
1587 }
1588
1589 static enum ndr_err_code ndr_push_epm_twr_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_t *r)
1590 {
1591 if (ndr_flags & NDR_SCALARS) {
1592 NDR_CHECK(ndr_push_align(ndr, 4));
1593 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_epm_tower(&r->tower, ndr->iconv_convenience, ndr->flags)));
1594 {
1595 struct ndr_push *_ndr_tower;
1596 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_tower, 4, -1));
1597 NDR_CHECK(ndr_push_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1598 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_tower, 4, -1));
1599 }
1600 }
1601 if (ndr_flags & NDR_BUFFERS) {
1602 }
1603 return NDR_ERR_SUCCESS;
1604 }
1605
1606 static enum ndr_err_code ndr_pull_epm_twr_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_t *r)
1607 {
1608 if (ndr_flags & NDR_SCALARS) {
1609 NDR_CHECK(ndr_pull_align(ndr, 4));
1610 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tower_length));
1611 {
1612 struct ndr_pull *_ndr_tower;
1613 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_tower, 4, -1));
1614 NDR_CHECK(ndr_pull_epm_tower(_ndr_tower, NDR_SCALARS, &r->tower));
1615 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_tower, 4, -1));
1616 }
1617 }
1618 if (ndr_flags & NDR_BUFFERS) {
1619 }
1620 return NDR_ERR_SUCCESS;
1621 }
1622
1623 _PUBLIC_ void ndr_print_epm_twr_t(struct ndr_print *ndr, const char *name, const struct epm_twr_t *r)
1624 {
1625 ndr_print_struct(ndr, name, "epm_twr_t");
1626 ndr->depth++;
1627 ndr_print_uint32(ndr, "tower_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_epm_tower(&r->tower, ndr->iconv_convenience, ndr->flags):r->tower_length);
1628 ndr_print_epm_tower(ndr, "tower", &r->tower);
1629 ndr->depth--;
1630 }
1631
1632 static enum ndr_err_code ndr_push_epm_entry_t(struct ndr_push *ndr, int ndr_flags, const struct epm_entry_t *r)
1633 {
1634 if (ndr_flags & NDR_SCALARS) {
1635 NDR_CHECK(ndr_push_align(ndr, 5));
1636 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
1637 NDR_CHECK(ndr_push_full_ptr(ndr, r->tower));
1638 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1639 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->annotation) + 1));
1640 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->annotation, strlen(r->annotation) + 1, sizeof(uint8_t), CH_DOS));
1641 }
1642 if (ndr_flags & NDR_BUFFERS) {
1643 if (r->tower) {
1644 NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1645 }
1646 }
1647 return NDR_ERR_SUCCESS;
1648 }
1649
1650 static enum ndr_err_code ndr_pull_epm_entry_t(struct ndr_pull *ndr, int ndr_flags, struct epm_entry_t *r)
1651 {
1652 uint32_t _ptr_tower;
1653 TALLOC_CTX *_mem_save_tower_0;
1654 if (ndr_flags & NDR_SCALARS) {
1655 NDR_CHECK(ndr_pull_align(ndr, 5));
1656 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
1657 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
1658 if (_ptr_tower) {
1659 NDR_PULL_ALLOC(ndr, r->tower);
1660 } else {
1661 r->tower = NULL;
1662 }
1663 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_offset));
1664 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__annotation_length));
1665 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->annotation, r->__annotation_length, sizeof(uint8_t), CH_DOS));
1666 }
1667 if (ndr_flags & NDR_BUFFERS) {
1668 if (r->tower) {
1669 _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
1670 NDR_PULL_SET_MEM_CTX(ndr, r->tower, 0);
1671 NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->tower));
1672 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
1673 }
1674 }
1675 return NDR_ERR_SUCCESS;
1676 }
1677
1678 _PUBLIC_ void ndr_print_epm_entry_t(struct ndr_print *ndr, const char *name, const struct epm_entry_t *r)
1679 {
1680 ndr_print_struct(ndr, name, "epm_entry_t");
1681 ndr->depth++;
1682 ndr_print_GUID(ndr, "object", &r->object);
1683 ndr_print_ptr(ndr, "tower", r->tower);
1684 ndr->depth++;
1685 if (r->tower) {
1686 ndr_print_epm_twr_t(ndr, "tower", r->tower);
1687 }
1688 ndr->depth--;
1689 ndr_print_uint32(ndr, "__annotation_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->__annotation_offset);
1690 ndr_print_uint32(ndr, "__annotation_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->annotation) + 1:r->__annotation_length);
1691 ndr_print_string(ndr, "annotation", r->annotation);
1692 ndr->depth--;
1693 }
1694
1695 static enum ndr_err_code ndr_push_rpc_if_id_t(struct ndr_push *ndr, int ndr_flags, const struct rpc_if_id_t *r)
1696 {
1697 if (ndr_flags & NDR_SCALARS) {
1698 NDR_CHECK(ndr_push_align(ndr, 4));
1699 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
1700 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_major));
1701 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->vers_minor));
1702 }
1703 if (ndr_flags & NDR_BUFFERS) {
1704 }
1705 return NDR_ERR_SUCCESS;
1706 }
1707
1708 static enum ndr_err_code ndr_pull_rpc_if_id_t(struct ndr_pull *ndr, int ndr_flags, struct rpc_if_id_t *r)
1709 {
1710 if (ndr_flags & NDR_SCALARS) {
1711 NDR_CHECK(ndr_pull_align(ndr, 4));
1712 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
1713 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_major));
1714 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->vers_minor));
1715 }
1716 if (ndr_flags & NDR_BUFFERS) {
1717 }
1718 return NDR_ERR_SUCCESS;
1719 }
1720
1721 _PUBLIC_ void ndr_print_rpc_if_id_t(struct ndr_print *ndr, const char *name, const struct rpc_if_id_t *r)
1722 {
1723 ndr_print_struct(ndr, name, "rpc_if_id_t");
1724 ndr->depth++;
1725 ndr_print_GUID(ndr, "uuid", &r->uuid);
1726 ndr_print_uint16(ndr, "vers_major", r->vers_major);
1727 ndr_print_uint16(ndr, "vers_minor", r->vers_minor);
1728 ndr->depth--;
1729 }
1730
1731 static enum ndr_err_code ndr_push_epm_twr_p_t(struct ndr_push *ndr, int ndr_flags, const struct epm_twr_p_t *r)
1732 {
1733 if (ndr_flags & NDR_SCALARS) {
1734 NDR_CHECK(ndr_push_align(ndr, 5));
1735 NDR_CHECK(ndr_push_full_ptr(ndr, r->twr));
1736 }
1737 if (ndr_flags & NDR_BUFFERS) {
1738 if (r->twr) {
1739 NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1740 }
1741 }
1742 return NDR_ERR_SUCCESS;
1743 }
1744
1745 static enum ndr_err_code ndr_pull_epm_twr_p_t(struct ndr_pull *ndr, int ndr_flags, struct epm_twr_p_t *r)
1746 {
1747 uint32_t _ptr_twr;
1748 TALLOC_CTX *_mem_save_twr_0;
1749 if (ndr_flags & NDR_SCALARS) {
1750 NDR_CHECK(ndr_pull_align(ndr, 5));
1751 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_twr));
1752 if (_ptr_twr) {
1753 NDR_PULL_ALLOC(ndr, r->twr);
1754 } else {
1755 r->twr = NULL;
1756 }
1757 }
1758 if (ndr_flags & NDR_BUFFERS) {
1759 if (r->twr) {
1760 _mem_save_twr_0 = NDR_PULL_GET_MEM_CTX(ndr);
1761 NDR_PULL_SET_MEM_CTX(ndr, r->twr, 0);
1762 NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->twr));
1763 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_twr_0, 0);
1764 }
1765 }
1766 return NDR_ERR_SUCCESS;
1767 }
1768
1769 _PUBLIC_ void ndr_print_epm_twr_p_t(struct ndr_print *ndr, const char *name, const struct epm_twr_p_t *r)
1770 {
1771 ndr_print_struct(ndr, name, "epm_twr_p_t");
1772 ndr->depth++;
1773 ndr_print_ptr(ndr, "twr", r->twr);
1774 ndr->depth++;
1775 if (r->twr) {
1776 ndr_print_epm_twr_t(ndr, "twr", r->twr);
1777 }
1778 ndr->depth--;
1779 ndr->depth--;
1780 }
1781
1782 static enum ndr_err_code ndr_push_epm_Insert(struct ndr_push *ndr, int flags, const struct epm_Insert *r)
1783 {
1784 uint32_t cntr_entries_0;
1785 if (flags & NDR_IN) {
1786 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1787 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_ents));
1788 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1789 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1790 }
1791 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1792 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1793 }
1794 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.replace));
1795 }
1796 if (flags & NDR_OUT) {
1797 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1798 }
1799 return NDR_ERR_SUCCESS;
1800 }
1801
1802 static enum ndr_err_code ndr_pull_epm_Insert(struct ndr_pull *ndr, int flags, struct epm_Insert *r)
1803 {
1804 uint32_t cntr_entries_0;
1805 TALLOC_CTX *_mem_save_entries_0;
1806 if (flags & NDR_IN) {
1807 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1808 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1809 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1810 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1811 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1812 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1813 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1814 }
1815 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1816 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1817 }
1818 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1819 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.replace));
1820 if (r->in.entries) {
1821 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1822 }
1823 }
1824 if (flags & NDR_OUT) {
1825 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1826 }
1827 return NDR_ERR_SUCCESS;
1828 }
1829
1830 _PUBLIC_ void ndr_print_epm_Insert(struct ndr_print *ndr, const char *name, int flags, const struct epm_Insert *r)
1831 {
1832 uint32_t cntr_entries_0;
1833 ndr_print_struct(ndr, name, "epm_Insert");
1834 ndr->depth++;
1835 if (flags & NDR_SET_VALUES) {
1836 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1837 }
1838 if (flags & NDR_IN) {
1839 ndr_print_struct(ndr, "in", "epm_Insert");
1840 ndr->depth++;
1841 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1842 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
1843 ndr->depth++;
1844 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1845 char *idx_0=NULL;
1846 if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1847 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1848 free(idx_0);
1849 }
1850 }
1851 ndr->depth--;
1852 ndr_print_uint32(ndr, "replace", r->in.replace);
1853 ndr->depth--;
1854 }
1855 if (flags & NDR_OUT) {
1856 ndr_print_struct(ndr, "out", "epm_Insert");
1857 ndr->depth++;
1858 ndr_print_uint32(ndr, "result", r->out.result);
1859 ndr->depth--;
1860 }
1861 ndr->depth--;
1862 }
1863
1864 static enum ndr_err_code ndr_push_epm_Delete(struct ndr_push *ndr, int flags, const struct epm_Delete *r)
1865 {
1866 uint32_t cntr_entries_0;
1867 if (flags & NDR_IN) {
1868 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_ents));
1869 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.num_ents));
1870 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1871 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1872 }
1873 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1874 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1875 }
1876 }
1877 if (flags & NDR_OUT) {
1878 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1879 }
1880 return NDR_ERR_SUCCESS;
1881 }
1882
1883 static enum ndr_err_code ndr_pull_epm_Delete(struct ndr_pull *ndr, int flags, struct epm_Delete *r)
1884 {
1885 uint32_t cntr_entries_0;
1886 TALLOC_CTX *_mem_save_entries_0;
1887 if (flags & NDR_IN) {
1888 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.num_ents));
1889 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.entries));
1890 NDR_PULL_ALLOC_N(ndr, r->in.entries, ndr_get_array_size(ndr, &r->in.entries));
1891 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1892 NDR_PULL_SET_MEM_CTX(ndr, r->in.entries, 0);
1893 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1894 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->in.entries[cntr_entries_0]));
1895 }
1896 for (cntr_entries_0 = 0; cntr_entries_0 < r->in.num_ents; cntr_entries_0++) {
1897 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->in.entries[cntr_entries_0]));
1898 }
1899 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1900 if (r->in.entries) {
1901 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.entries, r->in.num_ents));
1902 }
1903 }
1904 if (flags & NDR_OUT) {
1905 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
1906 }
1907 return NDR_ERR_SUCCESS;
1908 }
1909
1910 _PUBLIC_ void ndr_print_epm_Delete(struct ndr_print *ndr, const char *name, int flags, const struct epm_Delete *r)
1911 {
1912 uint32_t cntr_entries_0;
1913 ndr_print_struct(ndr, name, "epm_Delete");
1914 ndr->depth++;
1915 if (flags & NDR_SET_VALUES) {
1916 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1917 }
1918 if (flags & NDR_IN) {
1919 ndr_print_struct(ndr, "in", "epm_Delete");
1920 ndr->depth++;
1921 ndr_print_uint32(ndr, "num_ents", r->in.num_ents);
1922 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->in.num_ents);
1923 ndr->depth++;
1924 for (cntr_entries_0=0;cntr_entries_0<r->in.num_ents;cntr_entries_0++) {
1925 char *idx_0=NULL;
1926 if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
1927 ndr_print_epm_entry_t(ndr, "entries", &r->in.entries[cntr_entries_0]);
1928 free(idx_0);
1929 }
1930 }
1931 ndr->depth--;
1932 ndr->depth--;
1933 }
1934 if (flags & NDR_OUT) {
1935 ndr_print_struct(ndr, "out", "epm_Delete");
1936 ndr->depth++;
1937 ndr_print_uint32(ndr, "result", r->out.result);
1938 ndr->depth--;
1939 }
1940 ndr->depth--;
1941 }
1942
1943 static enum ndr_err_code ndr_push_epm_Lookup(struct ndr_push *ndr, int flags, const struct epm_Lookup *r)
1944 {
1945 uint32_t cntr_entries_0;
1946 if (flags & NDR_IN) {
1947 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.inquiry_type));
1948 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
1949 if (r->in.object) {
1950 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
1951 }
1952 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.interface_id));
1953 if (r->in.interface_id) {
1954 NDR_CHECK(ndr_push_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
1955 }
1956 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.vers_option));
1957 if (r->in.entry_handle == NULL) {
1958 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1959 }
1960 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
1961 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_ents));
1962 }
1963 if (flags & NDR_OUT) {
1964 if (r->out.entry_handle == NULL) {
1965 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1966 }
1967 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
1968 if (r->out.num_ents == NULL) {
1969 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1970 }
1971 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_ents));
1972 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.max_ents));
1973 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
1974 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_ents));
1975 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1976 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
1977 }
1978 for (cntr_entries_0 = 0; cntr_entries_0 < *r->out.num_ents; cntr_entries_0++) {
1979 NDR_CHECK(ndr_push_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
1980 }
1981 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
1982 }
1983 return NDR_ERR_SUCCESS;
1984 }
1985
1986 static enum ndr_err_code ndr_pull_epm_Lookup(struct ndr_pull *ndr, int flags, struct epm_Lookup *r)
1987 {
1988 uint32_t _ptr_object;
1989 uint32_t _ptr_interface_id;
1990 uint32_t cntr_entries_0;
1991 TALLOC_CTX *_mem_save_object_0;
1992 TALLOC_CTX *_mem_save_interface_id_0;
1993 TALLOC_CTX *_mem_save_entry_handle_0;
1994 TALLOC_CTX *_mem_save_num_ents_0;
1995 TALLOC_CTX *_mem_save_entries_0;
1996 if (flags & NDR_IN) {
1997 ZERO_STRUCT(r->out);
1998
1999 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.inquiry_type));
2000 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2001 if (_ptr_object) {
2002 NDR_PULL_ALLOC(ndr, r->in.object);
2003 } else {
2004 r->in.object = NULL;
2005 }
2006 if (r->in.object) {
2007 _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2008 NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2009 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2010 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2011 }
2012 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_interface_id));
2013 if (_ptr_interface_id) {
2014 NDR_PULL_ALLOC(ndr, r->in.interface_id);
2015 } else {
2016 r->in.interface_id = NULL;
2017 }
2018 if (r->in.interface_id) {
2019 _mem_save_interface_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2020 NDR_PULL_SET_MEM_CTX(ndr, r->in.interface_id, 0);
2021 NDR_CHECK(ndr_pull_rpc_if_id_t(ndr, NDR_SCALARS, r->in.interface_id));
2022 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_interface_id_0, 0);
2023 }
2024 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.vers_option));
2025 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2026 NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2027 }
2028 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2029 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2030 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2031 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2032 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_ents));
2033 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2034 *r->out.entry_handle = *r->in.entry_handle;
2035 NDR_PULL_ALLOC(ndr, r->out.num_ents);
2036 ZERO_STRUCTP(r->out.num_ents);
2037 }
2038 if (flags & NDR_OUT) {
2039 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2040 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2041 }
2042 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2043 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2044 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2045 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2046 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2047 NDR_PULL_ALLOC(ndr, r->out.num_ents);
2048 }
2049 _mem_save_num_ents_0 = NDR_PULL_GET_MEM_CTX(ndr);
2050 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_ents, LIBNDR_FLAG_REF_ALLOC);
2051 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_ents));
2052 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_ents_0, LIBNDR_FLAG_REF_ALLOC);
2053 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.entries));
2054 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.entries));
2055 if (ndr_get_array_length(ndr, &r->out.entries) > ndr_get_array_size(ndr, &r->out.entries)) {
2056 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.entries), ndr_get_array_length(ndr, &r->out.entries));
2057 }
2058 NDR_PULL_ALLOC_N(ndr, r->out.entries, ndr_get_array_size(ndr, &r->out.entries));
2059 _mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
2060 NDR_PULL_SET_MEM_CTX(ndr, r->out.entries, 0);
2061 for (cntr_entries_0 = 0; cntr_entries_0 < ndr_get_array_length(ndr, &r->out.entries); cntr_entries_0++) {
2062 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_SCALARS, &r->out.entries[cntr_entries_0]));
2063 }
2064 for (cntr_entries_0 = 0; cntr_entries_0 < ndr_get_array_length(ndr, &r->out.entries); cntr_entries_0++) {
2065 NDR_CHECK(ndr_pull_epm_entry_t(ndr, NDR_BUFFERS, &r->out.entries[cntr_entries_0]));
2066 }
2067 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
2068 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2069 if (r->out.entries) {
2070 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.entries, r->in.max_ents));
2071 }
2072 if (r->out.entries) {
2073 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.entries, *r->out.num_ents));
2074 }
2075 }
2076 return NDR_ERR_SUCCESS;
2077 }
2078
2079 _PUBLIC_ void ndr_print_epm_Lookup(struct ndr_print *ndr, const char *name, int flags, const struct epm_Lookup *r)
2080 {
2081 uint32_t cntr_entries_0;
2082 ndr_print_struct(ndr, name, "epm_Lookup");
2083 ndr->depth++;
2084 if (flags & NDR_SET_VALUES) {
2085 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2086 }
2087 if (flags & NDR_IN) {
2088 ndr_print_struct(ndr, "in", "epm_Lookup");
2089 ndr->depth++;
2090 ndr_print_uint32(ndr, "inquiry_type", r->in.inquiry_type);
2091 ndr_print_ptr(ndr, "object", r->in.object);
2092 ndr->depth++;
2093 if (r->in.object) {
2094 ndr_print_GUID(ndr, "object", r->in.object);
2095 }
2096 ndr->depth--;
2097 ndr_print_ptr(ndr, "interface_id", r->in.interface_id);
2098 ndr->depth++;
2099 if (r->in.interface_id) {
2100 ndr_print_rpc_if_id_t(ndr, "interface_id", r->in.interface_id);
2101 }
2102 ndr->depth--;
2103 ndr_print_uint32(ndr, "vers_option", r->in.vers_option);
2104 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2105 ndr->depth++;
2106 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2107 ndr->depth--;
2108 ndr_print_uint32(ndr, "max_ents", r->in.max_ents);
2109 ndr->depth--;
2110 }
2111 if (flags & NDR_OUT) {
2112 ndr_print_struct(ndr, "out", "epm_Lookup");
2113 ndr->depth++;
2114 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2115 ndr->depth++;
2116 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2117 ndr->depth--;
2118 ndr_print_ptr(ndr, "num_ents", r->out.num_ents);
2119 ndr->depth++;
2120 ndr_print_uint32(ndr, "num_ents", *r->out.num_ents);
2121 ndr->depth--;
2122 ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)*r->out.num_ents);
2123 ndr->depth++;
2124 for (cntr_entries_0=0;cntr_entries_0<*r->out.num_ents;cntr_entries_0++) {
2125 char *idx_0=NULL;
2126 if (asprintf(&idx_0, "[%d]", cntr_entries_0) != -1) {
2127 ndr_print_epm_entry_t(ndr, "entries", &r->out.entries[cntr_entries_0]);
2128 free(idx_0);
2129 }
2130 }
2131 ndr->depth--;
2132 ndr_print_uint32(ndr, "result", r->out.result);
2133 ndr->depth--;
2134 }
2135 ndr->depth--;
2136 }
2137
2138 _PUBLIC_ enum ndr_err_code ndr_push_epm_Map(struct ndr_push *ndr, int flags, const struct epm_Map *r)
2139 {
2140 uint32_t cntr_towers_0;
2141 if (flags & NDR_IN) {
2142 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2143 if (r->in.object) {
2144 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
2145 }
2146 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.map_tower));
2147 if (r->in.map_tower) {
2148 NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2149 }
2150 if (r->in.entry_handle == NULL) {
2151 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2152 }
2153 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2154 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.max_towers));
2155 }
2156 if (flags & NDR_OUT) {
2157 if (r->out.entry_handle == NULL) {
2158 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2159 }
2160 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2161 if (r->out.num_towers == NULL) {
2162 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2163 }
2164 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_towers));
2165 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.max_towers));
2166 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2167 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.num_towers));
2168 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2169 NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2170 }
2171 for (cntr_towers_0 = 0; cntr_towers_0 < *r->out.num_towers; cntr_towers_0++) {
2172 NDR_CHECK(ndr_push_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2173 }
2174 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2175 }
2176 return NDR_ERR_SUCCESS;
2177 }
2178
2179 _PUBLIC_ enum ndr_err_code ndr_pull_epm_Map(struct ndr_pull *ndr, int flags, struct epm_Map *r)
2180 {
2181 uint32_t _ptr_object;
2182 uint32_t _ptr_map_tower;
2183 uint32_t cntr_towers_0;
2184 TALLOC_CTX *_mem_save_object_0;
2185 TALLOC_CTX *_mem_save_map_tower_0;
2186 TALLOC_CTX *_mem_save_entry_handle_0;
2187 TALLOC_CTX *_mem_save_num_towers_0;
2188 TALLOC_CTX *_mem_save_towers_0;
2189 if (flags & NDR_IN) {
2190 ZERO_STRUCT(r->out);
2191
2192 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2193 if (_ptr_object) {
2194 NDR_PULL_ALLOC(ndr, r->in.object);
2195 } else {
2196 r->in.object = NULL;
2197 }
2198 if (r->in.object) {
2199 _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2200 NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2201 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2202 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2203 }
2204 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_map_tower));
2205 if (_ptr_map_tower) {
2206 NDR_PULL_ALLOC(ndr, r->in.map_tower);
2207 } else {
2208 r->in.map_tower = NULL;
2209 }
2210 if (r->in.map_tower) {
2211 _mem_save_map_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2212 NDR_PULL_SET_MEM_CTX(ndr, r->in.map_tower, 0);
2213 NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.map_tower));
2214 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_map_tower_0, 0);
2215 }
2216 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2217 NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2218 }
2219 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2220 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2221 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2222 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2223 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.max_towers));
2224 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2225 *r->out.entry_handle = *r->in.entry_handle;
2226 NDR_PULL_ALLOC(ndr, r->out.num_towers);
2227 ZERO_STRUCTP(r->out.num_towers);
2228 }
2229 if (flags & NDR_OUT) {
2230 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2231 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2232 }
2233 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2234 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2235 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2236 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2237 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2238 NDR_PULL_ALLOC(ndr, r->out.num_towers);
2239 }
2240 _mem_save_num_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2241 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_towers, LIBNDR_FLAG_REF_ALLOC);
2242 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_towers));
2243 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_towers_0, LIBNDR_FLAG_REF_ALLOC);
2244 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.towers));
2245 NDR_CHECK(ndr_pull_array_length(ndr, &r->out.towers));
2246 if (ndr_get_array_length(ndr, &r->out.towers) > ndr_get_array_size(ndr, &r->out.towers)) {
2247 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.towers), ndr_get_array_length(ndr, &r->out.towers));
2248 }
2249 NDR_PULL_ALLOC_N(ndr, r->out.towers, ndr_get_array_size(ndr, &r->out.towers));
2250 _mem_save_towers_0 = NDR_PULL_GET_MEM_CTX(ndr);
2251 NDR_PULL_SET_MEM_CTX(ndr, r->out.towers, 0);
2252 for (cntr_towers_0 = 0; cntr_towers_0 < ndr_get_array_length(ndr, &r->out.towers); cntr_towers_0++) {
2253 NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_SCALARS, &r->out.towers[cntr_towers_0]));
2254 }
2255 for (cntr_towers_0 = 0; cntr_towers_0 < ndr_get_array_length(ndr, &r->out.towers); cntr_towers_0++) {
2256 NDR_CHECK(ndr_pull_epm_twr_p_t(ndr, NDR_BUFFERS, &r->out.towers[cntr_towers_0]));
2257 }
2258 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_towers_0, 0);
2259 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2260 if (r->out.towers) {
2261 NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.towers, r->in.max_towers));
2262 }
2263 if (r->out.towers) {
2264 NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.towers, *r->out.num_towers));
2265 }
2266 }
2267 return NDR_ERR_SUCCESS;
2268 }
2269
2270 _PUBLIC_ void ndr_print_epm_Map(struct ndr_print *ndr, const char *name, int flags, const struct epm_Map *r)
2271 {
2272 uint32_t cntr_towers_0;
2273 ndr_print_struct(ndr, name, "epm_Map");
2274 ndr->depth++;
2275 if (flags & NDR_SET_VALUES) {
2276 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2277 }
2278 if (flags & NDR_IN) {
2279 ndr_print_struct(ndr, "in", "epm_Map");
2280 ndr->depth++;
2281 ndr_print_ptr(ndr, "object", r->in.object);
2282 ndr->depth++;
2283 if (r->in.object) {
2284 ndr_print_GUID(ndr, "object", r->in.object);
2285 }
2286 ndr->depth--;
2287 ndr_print_ptr(ndr, "map_tower", r->in.map_tower);
2288 ndr->depth++;
2289 if (r->in.map_tower) {
2290 ndr_print_epm_twr_t(ndr, "map_tower", r->in.map_tower);
2291 }
2292 ndr->depth--;
2293 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2294 ndr->depth++;
2295 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2296 ndr->depth--;
2297 ndr_print_uint32(ndr, "max_towers", r->in.max_towers);
2298 ndr->depth--;
2299 }
2300 if (flags & NDR_OUT) {
2301 ndr_print_struct(ndr, "out", "epm_Map");
2302 ndr->depth++;
2303 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2304 ndr->depth++;
2305 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2306 ndr->depth--;
2307 ndr_print_ptr(ndr, "num_towers", r->out.num_towers);
2308 ndr->depth++;
2309 ndr_print_uint32(ndr, "num_towers", *r->out.num_towers);
2310 ndr->depth--;
2311 ndr->print(ndr, "%s: ARRAY(%d)", "towers", (int)*r->out.num_towers);
2312 ndr->depth++;
2313 for (cntr_towers_0=0;cntr_towers_0<*r->out.num_towers;cntr_towers_0++) {
2314 char *idx_0=NULL;
2315 if (asprintf(&idx_0, "[%d]", cntr_towers_0) != -1) {
2316 ndr_print_epm_twr_p_t(ndr, "towers", &r->out.towers[cntr_towers_0]);
2317 free(idx_0);
2318 }
2319 }
2320 ndr->depth--;
2321 ndr_print_uint32(ndr, "result", r->out.result);
2322 ndr->depth--;
2323 }
2324 ndr->depth--;
2325 }
2326
2327 static enum ndr_err_code ndr_push_epm_LookupHandleFree(struct ndr_push *ndr, int flags, const struct epm_LookupHandleFree *r)
2328 {
2329 if (flags & NDR_IN) {
2330 if (r->in.entry_handle == NULL) {
2331 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2332 }
2333 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2334 }
2335 if (flags & NDR_OUT) {
2336 if (r->out.entry_handle == NULL) {
2337 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2338 }
2339 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2340 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2341 }
2342 return NDR_ERR_SUCCESS;
2343 }
2344
2345 static enum ndr_err_code ndr_pull_epm_LookupHandleFree(struct ndr_pull *ndr, int flags, struct epm_LookupHandleFree *r)
2346 {
2347 TALLOC_CTX *_mem_save_entry_handle_0;
2348 if (flags & NDR_IN) {
2349 ZERO_STRUCT(r->out);
2350
2351 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2352 NDR_PULL_ALLOC(ndr, r->in.entry_handle);
2353 }
2354 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355 NDR_PULL_SET_MEM_CTX(ndr, r->in.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2356 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.entry_handle));
2357 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2358 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2359 *r->out.entry_handle = *r->in.entry_handle;
2360 }
2361 if (flags & NDR_OUT) {
2362 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2363 NDR_PULL_ALLOC(ndr, r->out.entry_handle);
2364 }
2365 _mem_save_entry_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2366 NDR_PULL_SET_MEM_CTX(ndr, r->out.entry_handle, LIBNDR_FLAG_REF_ALLOC);
2367 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.entry_handle));
2368 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entry_handle_0, LIBNDR_FLAG_REF_ALLOC);
2369 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2370 }
2371 return NDR_ERR_SUCCESS;
2372 }
2373
2374 _PUBLIC_ void ndr_print_epm_LookupHandleFree(struct ndr_print *ndr, const char *name, int flags, const struct epm_LookupHandleFree *r)
2375 {
2376 ndr_print_struct(ndr, name, "epm_LookupHandleFree");
2377 ndr->depth++;
2378 if (flags & NDR_SET_VALUES) {
2379 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2380 }
2381 if (flags & NDR_IN) {
2382 ndr_print_struct(ndr, "in", "epm_LookupHandleFree");
2383 ndr->depth++;
2384 ndr_print_ptr(ndr, "entry_handle", r->in.entry_handle);
2385 ndr->depth++;
2386 ndr_print_policy_handle(ndr, "entry_handle", r->in.entry_handle);
2387 ndr->depth--;
2388 ndr->depth--;
2389 }
2390 if (flags & NDR_OUT) {
2391 ndr_print_struct(ndr, "out", "epm_LookupHandleFree");
2392 ndr->depth++;
2393 ndr_print_ptr(ndr, "entry_handle", r->out.entry_handle);
2394 ndr->depth++;
2395 ndr_print_policy_handle(ndr, "entry_handle", r->out.entry_handle);
2396 ndr->depth--;
2397 ndr_print_uint32(ndr, "result", r->out.result);
2398 ndr->depth--;
2399 }
2400 ndr->depth--;
2401 }
2402
2403 static enum ndr_err_code ndr_push_epm_InqObject(struct ndr_push *ndr, int flags, const struct epm_InqObject *r)
2404 {
2405 if (flags & NDR_IN) {
2406 if (r->in.epm_object == NULL) {
2407 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2408 }
2409 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.epm_object));
2410 }
2411 if (flags & NDR_OUT) {
2412 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2413 }
2414 return NDR_ERR_SUCCESS;
2415 }
2416
2417 static enum ndr_err_code ndr_pull_epm_InqObject(struct ndr_pull *ndr, int flags, struct epm_InqObject *r)
2418 {
2419 TALLOC_CTX *_mem_save_epm_object_0;
2420 if (flags & NDR_IN) {
2421 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2422 NDR_PULL_ALLOC(ndr, r->in.epm_object);
2423 }
2424 _mem_save_epm_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2425 NDR_PULL_SET_MEM_CTX(ndr, r->in.epm_object, LIBNDR_FLAG_REF_ALLOC);
2426 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.epm_object));
2427 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epm_object_0, LIBNDR_FLAG_REF_ALLOC);
2428 }
2429 if (flags & NDR_OUT) {
2430 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2431 }
2432 return NDR_ERR_SUCCESS;
2433 }
2434
2435 _PUBLIC_ void ndr_print_epm_InqObject(struct ndr_print *ndr, const char *name, int flags, const struct epm_InqObject *r)
2436 {
2437 ndr_print_struct(ndr, name, "epm_InqObject");
2438 ndr->depth++;
2439 if (flags & NDR_SET_VALUES) {
2440 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2441 }
2442 if (flags & NDR_IN) {
2443 ndr_print_struct(ndr, "in", "epm_InqObject");
2444 ndr->depth++;
2445 ndr_print_ptr(ndr, "epm_object", r->in.epm_object);
2446 ndr->depth++;
2447 ndr_print_GUID(ndr, "epm_object", r->in.epm_object);
2448 ndr->depth--;
2449 ndr->depth--;
2450 }
2451 if (flags & NDR_OUT) {
2452 ndr_print_struct(ndr, "out", "epm_InqObject");
2453 ndr->depth++;
2454 ndr_print_uint32(ndr, "result", r->out.result);
2455 ndr->depth--;
2456 }
2457 ndr->depth--;
2458 }
2459
2460 static enum ndr_err_code ndr_push_epm_MgmtDelete(struct ndr_push *ndr, int flags, const struct epm_MgmtDelete *r)
2461 {
2462 if (flags & NDR_IN) {
2463 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.object_speced));
2464 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.object));
2465 if (r->in.object) {
2466 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.object));
2467 }
2468 NDR_CHECK(ndr_push_full_ptr(ndr, r->in.tower));
2469 if (r->in.tower) {
2470 NDR_CHECK(ndr_push_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2471 }
2472 }
2473 if (flags & NDR_OUT) {
2474 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2475 }
2476 return NDR_ERR_SUCCESS;
2477 }
2478
2479 static enum ndr_err_code ndr_pull_epm_MgmtDelete(struct ndr_pull *ndr, int flags, struct epm_MgmtDelete *r)
2480 {
2481 uint32_t _ptr_object;
2482 uint32_t _ptr_tower;
2483 TALLOC_CTX *_mem_save_object_0;
2484 TALLOC_CTX *_mem_save_tower_0;
2485 if (flags & NDR_IN) {
2486 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.object_speced));
2487 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object));
2488 if (_ptr_object) {
2489 NDR_PULL_ALLOC(ndr, r->in.object);
2490 } else {
2491 r->in.object = NULL;
2492 }
2493 if (r->in.object) {
2494 _mem_save_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2495 NDR_PULL_SET_MEM_CTX(ndr, r->in.object, 0);
2496 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.object));
2497 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_0, 0);
2498 }
2499 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_tower));
2500 if (_ptr_tower) {
2501 NDR_PULL_ALLOC(ndr, r->in.tower);
2502 } else {
2503 r->in.tower = NULL;
2504 }
2505 if (r->in.tower) {
2506 _mem_save_tower_0 = NDR_PULL_GET_MEM_CTX(ndr);
2507 NDR_PULL_SET_MEM_CTX(ndr, r->in.tower, 0);
2508 NDR_CHECK(ndr_pull_epm_twr_t(ndr, NDR_SCALARS, r->in.tower));
2509 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tower_0, 0);
2510 }
2511 }
2512 if (flags & NDR_OUT) {
2513 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2514 }
2515 return NDR_ERR_SUCCESS;
2516 }
2517
2518 _PUBLIC_ void ndr_print_epm_MgmtDelete(struct ndr_print *ndr, const char *name, int flags, const struct epm_MgmtDelete *r)
2519 {
2520 ndr_print_struct(ndr, name, "epm_MgmtDelete");
2521 ndr->depth++;
2522 if (flags & NDR_SET_VALUES) {
2523 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2524 }
2525 if (flags & NDR_IN) {
2526 ndr_print_struct(ndr, "in", "epm_MgmtDelete");
2527 ndr->depth++;
2528 ndr_print_uint32(ndr, "object_speced", r->in.object_speced);
2529 ndr_print_ptr(ndr, "object", r->in.object);
2530 ndr->depth++;
2531 if (r->in.object) {
2532 ndr_print_GUID(ndr, "object", r->in.object);
2533 }
2534 ndr->depth--;
2535 ndr_print_ptr(ndr, "tower", r->in.tower);
2536 ndr->depth++;
2537 if (r->in.tower) {
2538 ndr_print_epm_twr_t(ndr, "tower", r->in.tower);
2539 }
2540 ndr->depth--;
2541 ndr->depth--;
2542 }
2543 if (flags & NDR_OUT) {
2544 ndr_print_struct(ndr, "out", "epm_MgmtDelete");
2545 ndr->depth++;
2546 ndr_print_uint32(ndr, "result", r->out.result);
2547 ndr->depth--;
2548 }
2549 ndr->depth--;
2550 }
2551
2552 static enum ndr_err_code ndr_push_epm_MapAuth(struct ndr_push *ndr, int flags, const struct epm_MapAuth *r)
2553 {
2554 if (flags & NDR_IN) {
2555 }
2556 if (flags & NDR_OUT) {
2557 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.result));
2558 }
2559 return NDR_ERR_SUCCESS;
2560 }
2561
2562 static enum ndr_err_code ndr_pull_epm_MapAuth(struct ndr_pull *ndr, int flags, struct epm_MapAuth *r)
2563 {
2564 if (flags & NDR_IN) {
2565 }
2566 if (flags & NDR_OUT) {
2567 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.result));
2568 }
2569 return NDR_ERR_SUCCESS;
2570 }
2571
2572 _PUBLIC_ void ndr_print_epm_MapAuth(struct ndr_print *ndr, const char *name, int flags, const struct epm_MapAuth *r)
2573 {
2574 ndr_print_struct(ndr, name, "epm_MapAuth");
2575 ndr->depth++;
2576 if (flags & NDR_SET_VALUES) {
2577 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2578 }
2579 if (flags & NDR_IN) {
2580 ndr_print_struct(ndr, "in", "epm_MapAuth");
2581 ndr->depth++;
2582 ndr->depth--;
2583 }
2584 if (flags & NDR_OUT) {
2585 ndr_print_struct(ndr, "out", "epm_MapAuth");
2586 ndr->depth++;
2587 ndr_print_uint32(ndr, "result", r->out.result);
2588 ndr->depth--;
2589 }
2590 ndr->depth--;
2591 }
2592
2593 static const struct ndr_interface_call epmapper_calls[] = {
2594 {
2595 "epm_Insert",
2596 sizeof(struct epm_Insert),
2597 (ndr_push_flags_fn_t) ndr_push_epm_Insert,
2598 (ndr_pull_flags_fn_t) ndr_pull_epm_Insert,
2599 (ndr_print_function_t) ndr_print_epm_Insert,
2600 false,
2601 },
2602 {
2603 "epm_Delete",
2604 sizeof(struct epm_Delete),
2605 (ndr_push_flags_fn_t) ndr_push_epm_Delete,
2606 (ndr_pull_flags_fn_t) ndr_pull_epm_Delete,
2607 (ndr_print_function_t) ndr_print_epm_Delete,
2608 false,
2609 },
2610 {
2611 "epm_Lookup",
2612 sizeof(struct epm_Lookup),
2613 (ndr_push_flags_fn_t) ndr_push_epm_Lookup,
2614 (ndr_pull_flags_fn_t) ndr_pull_epm_Lookup,
2615 (ndr_print_function_t) ndr_print_epm_Lookup,
2616 false,
2617 },
2618 {
2619 "epm_Map",
2620 sizeof(struct epm_Map),
2621 (ndr_push_flags_fn_t) ndr_push_epm_Map,
2622 (ndr_pull_flags_fn_t) ndr_pull_epm_Map,
2623 (ndr_print_function_t) ndr_print_epm_Map,
2624 false,
2625 },
2626 {
2627 "epm_LookupHandleFree",
2628 sizeof(struct epm_LookupHandleFree),
2629 (ndr_push_flags_fn_t) ndr_push_epm_LookupHandleFree,
2630 (ndr_pull_flags_fn_t) ndr_pull_epm_LookupHandleFree,
2631 (ndr_print_function_t) ndr_print_epm_LookupHandleFree,
2632 false,
2633 },
2634 {
2635 "epm_InqObject",
2636 sizeof(struct epm_InqObject),
2637 (ndr_push_flags_fn_t) ndr_push_epm_InqObject,
2638 (ndr_pull_flags_fn_t) ndr_pull_epm_InqObject,
2639 (ndr_print_function_t) ndr_print_epm_InqObject,
2640 false,
2641 },
2642 {
2643 "epm_MgmtDelete",
2644 sizeof(struct epm_MgmtDelete),
2645 (ndr_push_flags_fn_t) ndr_push_epm_MgmtDelete,
2646 (ndr_pull_flags_fn_t) ndr_pull_epm_MgmtDelete,
2647 (ndr_print_function_t) ndr_print_epm_MgmtDelete,
2648 false,
2649 },
2650 {
2651 "epm_MapAuth",
2652 sizeof(struct epm_MapAuth),
2653 (ndr_push_flags_fn_t) ndr_push_epm_MapAuth,
2654 (ndr_pull_flags_fn_t) ndr_pull_epm_MapAuth,
2655 (ndr_print_function_t) ndr_print_epm_MapAuth,
2656 false,
2657 },
2658 { NULL, 0, NULL, NULL, NULL, false }
2659 };
2660
2661 static const char * const epmapper_endpoint_strings[] = {
2662 "ncacn_np:[\\pipe\\epmapper]",
2663 "ncacn_ip_tcp:[135]",
2664 "ncalrpc:[EPMAPPER]",
2665 };
2666
2667 static const struct ndr_interface_string_array epmapper_endpoints = {
2668 .count = 3,
2669 .names = epmapper_endpoint_strings
2670 };
2671
2672 static const char * const epmapper_authservice_strings[] = {
2673 "host",
2674 };
2675
2676 static const struct ndr_interface_string_array epmapper_authservices = {
2677 .count = 1,
2678 .names = epmapper_authservice_strings
2679 };
2680
2681
2682 const struct ndr_interface_table ndr_table_epmapper = {
2683 .name = "epmapper",
2684 .syntax_id = {
2685 {0xe1af8308,0x5d1f,0x11c9,{0x91,0xa4},{0x08,0x00,0x2b,0x14,0xa0,0xfa}},
2686 NDR_EPMAPPER_VERSION
2687 },
2688 .helpstring = NDR_EPMAPPER_HELPSTRING,
2689 .num_calls = 8,
2690 .calls = epmapper_calls,
2691 .endpoints = &epmapper_endpoints,
2692 .authservices = &epmapper_authservices
2693 };
2694
Samba GIT mirror