Line data Source code
1 : /* parser auto-generated by pidl */
2 :
3 : #include "includes.h"
4 : #include "bin/default/librpc/gen_ndr/ndr_dcerpc.h"
5 :
6 : #include "librpc/gen_ndr/ndr_misc.h"
7 89961 : static enum ndr_err_code ndr_push_dcerpc_ctx_list(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ctx_list *r)
8 : {
9 1857 : uint32_t cntr_transfer_syntaxes_0;
10 89961 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
11 89961 : if (ndr_flags & NDR_SCALARS) {
12 89961 : NDR_CHECK(ndr_push_align(ndr, 4));
13 89961 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
14 89961 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_transfer_syntaxes));
15 89961 : NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
16 180078 : for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (r->num_transfer_syntaxes); cntr_transfer_syntaxes_0++) {
17 90117 : NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
18 : }
19 89961 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20 : }
21 89961 : if (ndr_flags & NDR_BUFFERS) {
22 1857 : }
23 89961 : return NDR_ERR_SUCCESS;
24 : }
25 :
26 118856 : static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ctx_list *r)
27 : {
28 118856 : uint32_t size_transfer_syntaxes_0 = 0;
29 1865 : uint32_t cntr_transfer_syntaxes_0;
30 118856 : TALLOC_CTX *_mem_save_transfer_syntaxes_0 = NULL;
31 118856 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
32 118856 : if (ndr_flags & NDR_SCALARS) {
33 118856 : NDR_CHECK(ndr_pull_align(ndr, 4));
34 118856 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
35 118856 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_transfer_syntaxes));
36 118856 : NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
37 118856 : size_transfer_syntaxes_0 = r->num_transfer_syntaxes;
38 118856 : NDR_PULL_ALLOC_N(ndr, r->transfer_syntaxes, size_transfer_syntaxes_0);
39 118856 : _mem_save_transfer_syntaxes_0 = NDR_PULL_GET_MEM_CTX(ndr);
40 118856 : NDR_PULL_SET_MEM_CTX(ndr, r->transfer_syntaxes, 0);
41 237826 : for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (size_transfer_syntaxes_0); cntr_transfer_syntaxes_0++) {
42 118970 : NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
43 : }
44 118856 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
45 118856 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
46 : }
47 118856 : if (ndr_flags & NDR_BUFFERS) {
48 1865 : }
49 118856 : return NDR_ERR_SUCCESS;
50 : }
51 :
52 4 : _PUBLIC_ void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r)
53 : {
54 0 : uint32_t cntr_transfer_syntaxes_0;
55 4 : ndr_print_struct(ndr, name, "dcerpc_ctx_list");
56 4 : if (r == NULL) { ndr_print_null(ndr); return; }
57 4 : ndr->depth++;
58 4 : ndr_print_uint16(ndr, "context_id", r->context_id);
59 4 : ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
60 4 : ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
61 4 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "transfer_syntaxes", (uint32_t)(r->num_transfer_syntaxes));
62 4 : ndr->depth++;
63 8 : for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < (r->num_transfer_syntaxes); cntr_transfer_syntaxes_0++) {
64 4 : ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
65 : }
66 4 : ndr->depth--;
67 4 : ndr->depth--;
68 : }
69 :
70 69794 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind *r)
71 : {
72 987 : uint32_t cntr_ctx_list_0;
73 69794 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
74 69794 : if (ndr_flags & NDR_SCALARS) {
75 69794 : NDR_CHECK(ndr_push_align(ndr, 4));
76 69794 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
77 69794 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
78 69794 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
79 69794 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
80 159755 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_contexts); cntr_ctx_list_0++) {
81 89961 : NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
82 : }
83 : {
84 69794 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
85 69794 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
86 69794 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
87 69794 : ndr->flags = _flags_save_DATA_BLOB;
88 : }
89 69794 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
90 : }
91 69794 : if (ndr_flags & NDR_BUFFERS) {
92 987 : }
93 69794 : return NDR_ERR_SUCCESS;
94 : }
95 :
96 97649 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind *r)
97 : {
98 97649 : uint32_t size_ctx_list_0 = 0;
99 995 : uint32_t cntr_ctx_list_0;
100 97649 : TALLOC_CTX *_mem_save_ctx_list_0 = NULL;
101 97649 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
102 97649 : if (ndr_flags & NDR_SCALARS) {
103 97649 : NDR_CHECK(ndr_pull_align(ndr, 4));
104 97649 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
105 97649 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
106 97649 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
107 97649 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
108 97649 : size_ctx_list_0 = r->num_contexts;
109 97649 : NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
110 97649 : _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
111 97649 : NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
112 216505 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (size_ctx_list_0); cntr_ctx_list_0++) {
113 118856 : NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
114 : }
115 97649 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
116 : {
117 97649 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
118 97649 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
119 97649 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
120 97649 : ndr->flags = _flags_save_DATA_BLOB;
121 : }
122 97649 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
123 : }
124 97649 : if (ndr_flags & NDR_BUFFERS) {
125 995 : }
126 97649 : return NDR_ERR_SUCCESS;
127 : }
128 :
129 0 : static void ndr_print_flags_dcerpc_bind(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind *r)
130 : {
131 0 : ndr_print_dcerpc_bind(ndr, name, r);
132 0 : }
133 :
134 4 : _PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
135 : {
136 0 : uint32_t cntr_ctx_list_0;
137 4 : ndr_print_struct(ndr, name, "dcerpc_bind");
138 4 : if (r == NULL) { ndr_print_null(ndr); return; }
139 4 : ndr->depth++;
140 4 : ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
141 4 : ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
142 4 : ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
143 4 : ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
144 4 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "ctx_list", (uint32_t)(r->num_contexts));
145 4 : ndr->depth++;
146 8 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_contexts); cntr_ctx_list_0++) {
147 4 : ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
148 : }
149 4 : ndr->depth--;
150 : {
151 4 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
152 4 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
153 4 : ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
154 4 : ndr->flags = _flags_save_DATA_BLOB;
155 : }
156 4 : ndr->depth--;
157 : }
158 :
159 868043 : static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_empty *r)
160 : {
161 868043 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
162 868043 : if (ndr_flags & NDR_SCALARS) {
163 868043 : NDR_CHECK(ndr_push_align(ndr, 1));
164 868043 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
165 : }
166 868043 : if (ndr_flags & NDR_BUFFERS) {
167 6825 : }
168 868043 : return NDR_ERR_SUCCESS;
169 : }
170 :
171 849657 : static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_empty *r)
172 : {
173 849657 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
174 849657 : if (ndr_flags & NDR_SCALARS) {
175 849657 : NDR_CHECK(ndr_pull_align(ndr, 1));
176 849657 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
177 : }
178 849657 : if (ndr_flags & NDR_BUFFERS) {
179 6854 : }
180 849657 : return NDR_ERR_SUCCESS;
181 : }
182 :
183 118 : _PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
184 : {
185 118 : ndr_print_struct(ndr, name, "dcerpc_empty");
186 118 : if (r == NULL) { ndr_print_null(ndr); return; }
187 118 : ndr->depth++;
188 118 : ndr->depth--;
189 : }
190 :
191 868718 : static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_object *r)
192 : {
193 6964 : uint32_t level;
194 868718 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
195 868718 : if (ndr_flags & NDR_SCALARS) {
196 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
197 868718 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
198 868718 : NDR_CHECK(ndr_push_union_align(ndr, 4));
199 868718 : switch (level) {
200 675 : default: {
201 675 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
202 536 : break; }
203 :
204 868043 : case false: {
205 868043 : NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
206 861218 : break; }
207 :
208 : }
209 : }
210 861754 : return NDR_ERR_SUCCESS;
211 : }
212 :
213 850332 : static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_object *r)
214 : {
215 6993 : uint32_t level;
216 850332 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
217 850332 : if (ndr_flags & NDR_SCALARS) {
218 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
219 850332 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
220 850332 : NDR_CHECK(ndr_pull_union_align(ndr, 4));
221 850332 : switch (level) {
222 675 : default: {
223 675 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
224 536 : break; }
225 :
226 849657 : case false: {
227 849657 : NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
228 842803 : break; }
229 :
230 : }
231 : }
232 843339 : return NDR_ERR_SUCCESS;
233 : }
234 :
235 118 : _PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
236 : {
237 0 : uint32_t level;
238 118 : level = ndr_print_steal_switch_value(ndr, r);
239 118 : ndr_print_union(ndr, name, level, "dcerpc_object");
240 118 : switch (level) {
241 0 : default:
242 0 : ndr_print_GUID(ndr, "object", &r->object);
243 0 : break;
244 :
245 118 : case false:
246 118 : ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
247 118 : break;
248 :
249 : }
250 118 : }
251 :
252 868718 : static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_request *r)
253 : {
254 868718 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
255 868718 : if (ndr_flags & NDR_SCALARS) {
256 868718 : NDR_CHECK(ndr_push_align(ndr, 4));
257 868718 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
258 868718 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
259 868718 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
260 868718 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT));
261 868718 : NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
262 : {
263 868718 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
264 868718 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
265 868718 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
266 868718 : ndr->flags = _flags_save_DATA_BLOB;
267 : }
268 868718 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
269 : }
270 868718 : if (ndr_flags & NDR_BUFFERS) {
271 6964 : }
272 868718 : return NDR_ERR_SUCCESS;
273 : }
274 :
275 850332 : static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_request *r)
276 : {
277 850332 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
278 850332 : if (ndr_flags & NDR_SCALARS) {
279 850332 : NDR_CHECK(ndr_pull_align(ndr, 4));
280 850332 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
281 850332 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
282 850332 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
283 850332 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT));
284 850332 : NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
285 : {
286 850332 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
287 850332 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
288 850332 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
289 850332 : ndr->flags = _flags_save_DATA_BLOB;
290 : }
291 850332 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
292 : }
293 850332 : if (ndr_flags & NDR_BUFFERS) {
294 6993 : }
295 850332 : return NDR_ERR_SUCCESS;
296 : }
297 :
298 118 : _PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
299 : {
300 118 : ndr_print_struct(ndr, name, "dcerpc_request");
301 118 : if (r == NULL) { ndr_print_null(ndr); return; }
302 118 : ndr->depth++;
303 118 : ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
304 118 : ndr_print_uint16(ndr, "context_id", r->context_id);
305 118 : ndr_print_uint16(ndr, "opnum", r->opnum);
306 118 : ndr_print_set_switch_value(ndr, &r->object, NDR_DCERPC_REQUEST_OBJECT_PRESENT);
307 118 : ndr_print_dcerpc_object(ndr, "object", &r->object);
308 : {
309 118 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
310 118 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
311 118 : ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
312 118 : ndr->flags = _flags_save_DATA_BLOB;
313 : }
314 118 : ndr->depth--;
315 : }
316 :
317 80560 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_result(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_result r)
318 : {
319 80560 : NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
320 78734 : return NDR_ERR_SUCCESS;
321 : }
322 :
323 134292 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_result(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_result *r)
324 : {
325 3636 : uint16_t v;
326 134292 : NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
327 134292 : *r = v;
328 134292 : return NDR_ERR_SUCCESS;
329 : }
330 :
331 4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_result(struct ndr_print *ndr, const char *name, enum dcerpc_bind_ack_result r)
332 : {
333 4 : const char *val = NULL;
334 :
335 4 : switch (r) {
336 4 : case DCERPC_BIND_ACK_RESULT_ACCEPTANCE: val = "DCERPC_BIND_ACK_RESULT_ACCEPTANCE"; break;
337 0 : case DCERPC_BIND_ACK_RESULT_USER_REJECTION: val = "DCERPC_BIND_ACK_RESULT_USER_REJECTION"; break;
338 0 : case DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION: val = "DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION"; break;
339 0 : case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: val = "DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK"; break;
340 : }
341 4 : ndr_print_enum(ndr, name, "ENUM", val, r);
342 4 : }
343 :
344 61363 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_reason_values(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_reason_values r)
345 : {
346 61363 : NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
347 60389 : return NDR_ERR_SUCCESS;
348 : }
349 :
350 94125 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_reason_values(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_ack_reason_values *r)
351 : {
352 1932 : uint16_t v;
353 94125 : NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
354 94125 : *r = v;
355 94125 : return NDR_ERR_SUCCESS;
356 : }
357 :
358 4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_reason_values(struct ndr_print *ndr, const char *name, enum dcerpc_bind_ack_reason_values r)
359 : {
360 4 : const char *val = NULL;
361 :
362 4 : switch (r) {
363 4 : case DCERPC_BIND_ACK_REASON_NOT_SPECIFIED: val = "DCERPC_BIND_ACK_REASON_NOT_SPECIFIED"; break;
364 0 : case DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED: val = "DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED"; break;
365 0 : case DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED: val = "DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED"; break;
366 0 : case DCERPC_BIND_ACK_REASON_LOCAL_LIMIT_EXCEEDED: val = "DCERPC_BIND_ACK_REASON_LOCAL_LIMIT_EXCEEDED"; break;
367 : }
368 4 : ndr_print_enum(ndr, name, "ENUM", val, r);
369 4 : }
370 :
371 19197 : static enum ndr_err_code ndr_push_dcerpc_bind_time_features(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
372 : {
373 19197 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
374 18345 : return NDR_ERR_SUCCESS;
375 : }
376 :
377 40167 : static enum ndr_err_code ndr_pull_dcerpc_bind_time_features(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
378 : {
379 1704 : uint16_t v;
380 40167 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
381 40167 : *r = v;
382 40167 : return NDR_ERR_SUCCESS;
383 : }
384 :
385 0 : _PUBLIC_ void ndr_print_dcerpc_bind_time_features(struct ndr_print *ndr, const char *name, uint16_t r)
386 : {
387 0 : ndr_print_uint16(ndr, name, r);
388 0 : ndr->depth++;
389 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING", DCERPC_BIND_TIME_SECURITY_CONTEXT_MULTIPLEXING, r);
390 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN", DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN, r);
391 0 : ndr->depth--;
392 0 : }
393 :
394 80560 : static enum ndr_err_code ndr_push_dcerpc_bind_ack_reason(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_bind_ack_reason *r)
395 : {
396 1826 : uint32_t level;
397 80560 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
398 80560 : if (ndr_flags & NDR_SCALARS) {
399 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
400 80560 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
401 80560 : NDR_CHECK(ndr_push_union_align(ndr, 2));
402 80560 : switch (level) {
403 19197 : case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: {
404 20049 : NDR_CHECK(ndr_push_dcerpc_bind_time_features(ndr, NDR_SCALARS, r->negotiate));
405 18345 : break; }
406 :
407 61363 : default: {
408 62337 : NDR_CHECK(ndr_push_dcerpc_bind_ack_reason_values(ndr, NDR_SCALARS, r->value));
409 60389 : break; }
410 :
411 : }
412 : }
413 78734 : return NDR_ERR_SUCCESS;
414 : }
415 :
416 134292 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack_reason(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_bind_ack_reason *r)
417 : {
418 3636 : uint32_t level;
419 134292 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
420 134292 : if (ndr_flags & NDR_SCALARS) {
421 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
422 134292 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
423 134292 : NDR_CHECK(ndr_pull_union_align(ndr, 2));
424 134292 : switch (level) {
425 40167 : case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK: {
426 41871 : NDR_CHECK(ndr_pull_dcerpc_bind_time_features(ndr, NDR_SCALARS, &r->negotiate));
427 38463 : break; }
428 :
429 94125 : default: {
430 96057 : NDR_CHECK(ndr_pull_dcerpc_bind_ack_reason_values(ndr, NDR_SCALARS, &r->value));
431 92193 : break; }
432 :
433 : }
434 : }
435 130656 : return NDR_ERR_SUCCESS;
436 : }
437 :
438 4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack_reason(struct ndr_print *ndr, const char *name, const union dcerpc_bind_ack_reason *r)
439 : {
440 0 : uint32_t level;
441 4 : level = ndr_print_steal_switch_value(ndr, r);
442 4 : ndr_print_union(ndr, name, level, "dcerpc_bind_ack_reason");
443 4 : switch (level) {
444 0 : case DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK:
445 0 : ndr_print_dcerpc_bind_time_features(ndr, "negotiate", r->negotiate);
446 0 : break;
447 :
448 4 : default:
449 4 : ndr_print_dcerpc_bind_ack_reason_values(ndr, "value", r->value);
450 4 : break;
451 :
452 : }
453 4 : }
454 :
455 80560 : static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ack_ctx *r)
456 : {
457 80560 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
458 80560 : if (ndr_flags & NDR_SCALARS) {
459 80560 : NDR_CHECK(ndr_push_align(ndr, 4));
460 82386 : NDR_CHECK(ndr_push_dcerpc_bind_ack_result(ndr, NDR_SCALARS, r->result));
461 80560 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->reason, r->result));
462 80560 : NDR_CHECK(ndr_push_dcerpc_bind_ack_reason(ndr, NDR_SCALARS, &r->reason));
463 80560 : NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
464 80560 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
465 : }
466 80560 : if (ndr_flags & NDR_BUFFERS) {
467 1826 : }
468 80560 : return NDR_ERR_SUCCESS;
469 : }
470 :
471 134292 : static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ack_ctx *r)
472 : {
473 134292 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
474 134292 : if (ndr_flags & NDR_SCALARS) {
475 134292 : NDR_CHECK(ndr_pull_align(ndr, 4));
476 137928 : NDR_CHECK(ndr_pull_dcerpc_bind_ack_result(ndr, NDR_SCALARS, &r->result));
477 134292 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->reason, r->result));
478 134292 : NDR_CHECK(ndr_pull_dcerpc_bind_ack_reason(ndr, NDR_SCALARS, &r->reason));
479 134292 : NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
480 134292 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
481 : }
482 134292 : if (ndr_flags & NDR_BUFFERS) {
483 3636 : }
484 134292 : return NDR_ERR_SUCCESS;
485 : }
486 :
487 4 : _PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
488 : {
489 4 : ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
490 4 : if (r == NULL) { ndr_print_null(ndr); return; }
491 4 : ndr->depth++;
492 4 : ndr_print_dcerpc_bind_ack_result(ndr, "result", r->result);
493 4 : ndr_print_set_switch_value(ndr, &r->reason, r->result);
494 4 : ndr_print_dcerpc_bind_ack_reason(ndr, "reason", &r->reason);
495 4 : ndr_print_ndr_syntax_id(ndr, "syntax", &r->syntax);
496 4 : ndr->depth--;
497 : }
498 :
499 61363 : static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_ack *r)
500 : {
501 974 : uint32_t cntr_ctx_list_0;
502 61363 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
503 61363 : if (ndr_flags & NDR_SCALARS) {
504 61363 : NDR_CHECK(ndr_push_align(ndr, 4));
505 61363 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
506 61363 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
507 61363 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
508 61363 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term_null(r->secondary_address)));
509 61363 : NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen_m_term_null(r->secondary_address), sizeof(uint8_t), CH_DOS));
510 : {
511 61363 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
512 61363 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
513 61363 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
514 61363 : ndr->flags = _flags_save_DATA_BLOB;
515 : }
516 61363 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
517 141923 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_results); cntr_ctx_list_0++) {
518 80560 : NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
519 : }
520 : {
521 61363 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
522 61363 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
523 61363 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
524 61363 : ndr->flags = _flags_save_DATA_BLOB;
525 : }
526 61363 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
527 : }
528 61363 : if (ndr_flags & NDR_BUFFERS) {
529 974 : }
530 61363 : return NDR_ERR_SUCCESS;
531 : }
532 :
533 94125 : static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind_ack *r)
534 : {
535 94125 : uint32_t size_secondary_address_0 = 0;
536 94125 : uint32_t size_ctx_list_0 = 0;
537 1932 : uint32_t cntr_ctx_list_0;
538 94125 : TALLOC_CTX *_mem_save_ctx_list_0 = NULL;
539 94125 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
540 94125 : if (ndr_flags & NDR_SCALARS) {
541 94125 : NDR_CHECK(ndr_pull_align(ndr, 4));
542 94125 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
543 94125 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
544 94125 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
545 94125 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
546 94125 : size_secondary_address_0 = r->secondary_address_size;
547 94125 : NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, size_secondary_address_0, sizeof(uint8_t), CH_DOS));
548 : {
549 94125 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
550 94125 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
551 94125 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
552 94125 : ndr->flags = _flags_save_DATA_BLOB;
553 : }
554 94125 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
555 94125 : size_ctx_list_0 = r->num_results;
556 94125 : NDR_PULL_ALLOC_N(ndr, r->ctx_list, size_ctx_list_0);
557 94125 : _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
558 94125 : NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
559 228417 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (size_ctx_list_0); cntr_ctx_list_0++) {
560 134292 : NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
561 : }
562 94125 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
563 : {
564 94125 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
565 94125 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
566 94125 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
567 94125 : ndr->flags = _flags_save_DATA_BLOB;
568 : }
569 94125 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
570 : }
571 94125 : if (ndr_flags & NDR_BUFFERS) {
572 1932 : }
573 94125 : return NDR_ERR_SUCCESS;
574 : }
575 :
576 4 : _PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
577 : {
578 0 : uint32_t cntr_ctx_list_0;
579 4 : ndr_print_struct(ndr, name, "dcerpc_bind_ack");
580 4 : if (r == NULL) { ndr_print_null(ndr); return; }
581 4 : ndr->depth++;
582 4 : ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
583 4 : ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
584 4 : ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
585 4 : ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term_null(r->secondary_address):r->secondary_address_size);
586 4 : ndr_print_string(ndr, "secondary_address", r->secondary_address);
587 : {
588 4 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
589 4 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
590 4 : ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
591 4 : ndr->flags = _flags_save_DATA_BLOB;
592 : }
593 4 : ndr_print_uint8(ndr, "num_results", r->num_results);
594 4 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "ctx_list", (uint32_t)(r->num_results));
595 4 : ndr->depth++;
596 8 : for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < (r->num_results); cntr_ctx_list_0++) {
597 4 : ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
598 : }
599 4 : ndr->depth--;
600 : {
601 4 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
602 4 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
603 4 : ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
604 4 : ndr->flags = _flags_save_DATA_BLOB;
605 : }
606 4 : ndr->depth--;
607 : }
608 :
609 149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak_reason(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_nak_reason r)
610 : {
611 149 : NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
612 131 : return NDR_ERR_SUCCESS;
613 : }
614 :
615 230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind_nak_reason(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_bind_nak_reason *r)
616 : {
617 36 : uint16_t v;
618 230 : NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
619 230 : *r = v;
620 230 : return NDR_ERR_SUCCESS;
621 : }
622 :
623 0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak_reason(struct ndr_print *ndr, const char *name, enum dcerpc_bind_nak_reason r)
624 : {
625 0 : const char *val = NULL;
626 :
627 0 : switch (r) {
628 0 : case DCERPC_BIND_NAK_REASON_NOT_SPECIFIED: val = "DCERPC_BIND_NAK_REASON_NOT_SPECIFIED"; break;
629 0 : case DCERPC_BIND_NAK_REASON_TEMPORARY_CONGESTION: val = "DCERPC_BIND_NAK_REASON_TEMPORARY_CONGESTION"; break;
630 0 : case DCERPC_BIND_NAK_REASON_LOCAL_LIMIT_EXCEEDED: val = "DCERPC_BIND_NAK_REASON_LOCAL_LIMIT_EXCEEDED"; break;
631 0 : case DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED: val = "DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED"; break;
632 0 : case DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE: val = "DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE"; break;
633 0 : case DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM: val = "DCERPC_BIND_NAK_REASON_INVALID_CHECKSUM"; break;
634 : }
635 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
636 0 : }
637 :
638 149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak_version(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_nak_version *r)
639 : {
640 149 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
641 149 : if (ndr_flags & NDR_SCALARS) {
642 149 : NDR_CHECK(ndr_push_align(ndr, 1));
643 149 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
644 149 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
645 149 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
646 : }
647 149 : if (ndr_flags & NDR_BUFFERS) {
648 18 : }
649 149 : return NDR_ERR_SUCCESS;
650 : }
651 :
652 230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind_nak_version(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_bind_nak_version *r)
653 : {
654 230 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
655 230 : if (ndr_flags & NDR_SCALARS) {
656 230 : NDR_CHECK(ndr_pull_align(ndr, 1));
657 230 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
658 230 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
659 230 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
660 : }
661 230 : if (ndr_flags & NDR_BUFFERS) {
662 36 : }
663 230 : return NDR_ERR_SUCCESS;
664 : }
665 :
666 0 : static void ndr_print_flags_dcerpc_bind_nak_version(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind_nak_version *r)
667 : {
668 0 : ndr_print_dcerpc_bind_nak_version(ndr, name, r);
669 0 : }
670 :
671 0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak_version(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_version *r)
672 : {
673 0 : ndr_print_struct(ndr, name, "dcerpc_bind_nak_version");
674 0 : if (r == NULL) { ndr_print_null(ndr); return; }
675 0 : ndr->depth++;
676 0 : ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
677 0 : ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
678 0 : ndr->depth--;
679 : }
680 :
681 149 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_bind_nak *r)
682 : {
683 18 : uint32_t cntr_versions_0;
684 149 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
685 149 : if (ndr_flags & NDR_SCALARS) {
686 149 : NDR_CHECK(ndr_push_align(ndr, 4));
687 149 : NDR_CHECK(ndr_push_dcerpc_bind_nak_reason(ndr, NDR_SCALARS, r->reject_reason));
688 149 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_versions));
689 298 : for (cntr_versions_0 = 0; cntr_versions_0 < (r->num_versions); cntr_versions_0++) {
690 149 : NDR_CHECK(ndr_push_dcerpc_bind_nak_version(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
691 : }
692 : {
693 149 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
694 149 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
695 149 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
696 149 : ndr->flags = _flags_save_DATA_BLOB;
697 : }
698 149 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
699 : }
700 149 : if (ndr_flags & NDR_BUFFERS) {
701 18 : }
702 149 : return NDR_ERR_SUCCESS;
703 : }
704 :
705 0 : static void ndr_print_flags_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_bind_nak *r)
706 : {
707 0 : ndr_print_dcerpc_bind_nak(ndr, name, r);
708 0 : }
709 :
710 0 : _PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
711 : {
712 0 : uint32_t cntr_versions_0;
713 0 : ndr_print_struct(ndr, name, "dcerpc_bind_nak");
714 0 : if (r == NULL) { ndr_print_null(ndr); return; }
715 0 : ndr->depth++;
716 0 : ndr_print_dcerpc_bind_nak_reason(ndr, "reject_reason", r->reject_reason);
717 0 : ndr_print_uint8(ndr, "num_versions", r->num_versions);
718 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "versions", (uint32_t)(r->num_versions));
719 0 : ndr->depth++;
720 0 : for (cntr_versions_0 = 0; cntr_versions_0 < (r->num_versions); cntr_versions_0++) {
721 0 : ndr_print_dcerpc_bind_nak_version(ndr, "versions", &r->versions[cntr_versions_0]);
722 : }
723 0 : ndr->depth--;
724 : {
725 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
726 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
727 0 : ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
728 0 : ndr->flags = _flags_save_DATA_BLOB;
729 : }
730 0 : ndr->depth--;
731 : }
732 :
733 1121923 : static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_response *r)
734 : {
735 1121923 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
736 1121923 : if (ndr_flags & NDR_SCALARS) {
737 1121923 : NDR_CHECK(ndr_push_align(ndr, 4));
738 1121923 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
739 1121923 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
740 1121923 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
741 1121923 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
742 : {
743 1121923 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
744 1121923 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
745 1121923 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
746 1121923 : ndr->flags = _flags_save_DATA_BLOB;
747 : }
748 1121923 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
749 : }
750 1121923 : if (ndr_flags & NDR_BUFFERS) {
751 6649 : }
752 1121923 : return NDR_ERR_SUCCESS;
753 : }
754 :
755 1722846 : static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_response *r)
756 : {
757 1722846 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
758 1722846 : if (ndr_flags & NDR_SCALARS) {
759 1722846 : NDR_CHECK(ndr_pull_align(ndr, 4));
760 1722846 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
761 1722846 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
762 1722846 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
763 1722846 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
764 : {
765 1722846 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
766 1722846 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
767 1722846 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
768 1722846 : ndr->flags = _flags_save_DATA_BLOB;
769 : }
770 1722846 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
771 : }
772 1722846 : if (ndr_flags & NDR_BUFFERS) {
773 13240 : }
774 1722846 : return NDR_ERR_SUCCESS;
775 : }
776 :
777 118 : _PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
778 : {
779 118 : ndr_print_struct(ndr, name, "dcerpc_response");
780 118 : if (r == NULL) { ndr_print_null(ndr); return; }
781 118 : ndr->depth++;
782 118 : ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
783 118 : ndr_print_uint16(ndr, "context_id", r->context_id);
784 118 : ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
785 118 : ndr_print_uint8(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
786 : {
787 118 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
788 118 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
789 118 : ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
790 118 : ndr->flags = _flags_save_DATA_BLOB;
791 : }
792 118 : ndr->depth--;
793 : }
794 :
795 2849 : static enum ndr_err_code ndr_push_dcerpc_nca_status(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_nca_status r)
796 : {
797 2849 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
798 2503 : return NDR_ERR_SUCCESS;
799 : }
800 :
801 5694 : static enum ndr_err_code ndr_pull_dcerpc_nca_status(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_nca_status *r)
802 : {
803 686 : uint32_t v;
804 5694 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
805 5694 : *r = v;
806 5694 : return NDR_ERR_SUCCESS;
807 : }
808 :
809 0 : _PUBLIC_ void ndr_print_dcerpc_nca_status(struct ndr_print *ndr, const char *name, enum dcerpc_nca_status r)
810 : {
811 0 : const char *val = NULL;
812 :
813 0 : switch (r) {
814 0 : case DCERPC_NCA_S_COMM_FAILURE: val = "DCERPC_NCA_S_COMM_FAILURE"; break;
815 0 : case DCERPC_NCA_S_OP_RNG_ERROR: val = "DCERPC_NCA_S_OP_RNG_ERROR"; break;
816 0 : case DCERPC_NCA_S_UNKNOWN_IF: val = "DCERPC_NCA_S_UNKNOWN_IF"; break;
817 0 : case DCERPC_NCA_S_WRONG_BOOT_TIME: val = "DCERPC_NCA_S_WRONG_BOOT_TIME"; break;
818 0 : case DCERPC_NCA_S_YOU_CRASHED: val = "DCERPC_NCA_S_YOU_CRASHED"; break;
819 0 : case DCERPC_NCA_S_PROTO_ERROR: val = "DCERPC_NCA_S_PROTO_ERROR"; break;
820 0 : case DCERPC_NCA_S_OUT_ARGS_TOO_BIG: val = "DCERPC_NCA_S_OUT_ARGS_TOO_BIG"; break;
821 0 : case DCERPC_NCA_S_SERVER_TOO_BUSY: val = "DCERPC_NCA_S_SERVER_TOO_BUSY"; break;
822 0 : case DCERPC_NCA_S_FAULT_STRING_TOO_LARGE: val = "DCERPC_NCA_S_FAULT_STRING_TOO_LARGE"; break;
823 0 : case DCERPC_NCA_S_UNSUPPORTED_TYPE: val = "DCERPC_NCA_S_UNSUPPORTED_TYPE"; break;
824 0 : case DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO"; break;
825 0 : case DCERPC_NCA_S_FAULT_ADDR_ERROR: val = "DCERPC_NCA_S_FAULT_ADDR_ERROR"; break;
826 0 : case DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO"; break;
827 0 : case DCERPC_NCA_S_FAULT_FP_UNDERFLOW: val = "DCERPC_NCA_S_FAULT_FP_UNDERFLOW"; break;
828 0 : case DCERPC_NCA_S_FAULT_FP_OVERRFLOW: val = "DCERPC_NCA_S_FAULT_FP_OVERRFLOW"; break;
829 0 : case DCERPC_NCA_S_FAULT_INVALID_TAG: val = "DCERPC_NCA_S_FAULT_INVALID_TAG"; break;
830 0 : case DCERPC_NCA_S_FAULT_INVALID_BOUND: val = "DCERPC_NCA_S_FAULT_INVALID_BOUND"; break;
831 0 : case DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH: val = "DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH"; break;
832 0 : case DCERPC_NCA_S_FAULT_UNSPEC_REJECT: val = "DCERPC_NCA_S_FAULT_UNSPEC_REJECT"; break;
833 0 : case DCERPC_NCA_S_FAULT_BAD_ACTID: val = "DCERPC_NCA_S_FAULT_BAD_ACTID"; break;
834 0 : case DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED: val = "DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED"; break;
835 0 : case DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED: val = "DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED"; break;
836 0 : case DCERPC_NCA_S_FAULT_CANCEL: val = "DCERPC_NCA_S_FAULT_CANCEL"; break;
837 0 : case DCERPC_NCA_S_FAULT_ILL_INST: val = "DCERPC_NCA_S_FAULT_ILL_INST"; break;
838 0 : case DCERPC_NCA_S_FAULT_FP_ERROR: val = "DCERPC_NCA_S_FAULT_FP_ERROR"; break;
839 0 : case DCERPC_NCA_S_FAULT_INT_OVERFLOW: val = "DCERPC_NCA_S_FAULT_INT_OVERFLOW"; break;
840 0 : case DCERPC_NCA_S_UNUSED_1C000011: val = "DCERPC_NCA_S_UNUSED_1C000011"; break;
841 0 : case DCERPC_NCA_S_FAULT_UNSPEC: val = "DCERPC_NCA_S_FAULT_UNSPEC"; break;
842 0 : case DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE: val = "DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE"; break;
843 0 : case DCERPC_NCA_S_FAULT_PIPE_EMPTY: val = "DCERPC_NCA_S_FAULT_PIPE_EMPTY"; break;
844 0 : case DCERPC_NCA_S_FAULT_PIPE_CLOSED: val = "DCERPC_NCA_S_FAULT_PIPE_CLOSED"; break;
845 0 : case DCERPC_NCA_S_FAULT_PIPE_ORDER: val = "DCERPC_NCA_S_FAULT_PIPE_ORDER"; break;
846 0 : case DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE: val = "DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE"; break;
847 0 : case DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR: val = "DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR"; break;
848 0 : case DCERPC_NCA_S_FAULT_PIPE_MEMORY: val = "DCERPC_NCA_S_FAULT_PIPE_MEMORY"; break;
849 0 : case DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH: val = "DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH"; break;
850 0 : case DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY: val = "DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY"; break;
851 0 : case DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID: val = "DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID"; break;
852 0 : case DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL: val = "DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL"; break;
853 0 : case DCERPC_NCA_S_UNUSED_1C00001E: val = "DCERPC_NCA_S_UNUSED_1C00001E"; break;
854 0 : case DCERPC_NCA_S_INVALID_CHECKSUM: val = "DCERPC_NCA_S_INVALID_CHECKSUM"; break;
855 0 : case DCERPC_NCA_S_INVALID_CRC: val = "DCERPC_NCA_S_INVALID_CRC"; break;
856 0 : case DCERPC_NCA_S_FAULT_USER_DEFINED: val = "DCERPC_NCA_S_FAULT_USER_DEFINED"; break;
857 0 : case DCERPC_NCA_S_FAULT_TX_OPEN_FAILED: val = "DCERPC_NCA_S_FAULT_TX_OPEN_FAILED"; break;
858 0 : case DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR: val = "DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR"; break;
859 0 : case DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND: val = "DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND"; break;
860 0 : case DCERPC_NCA_S_FAULT_NO_CLIENT_STUB: val = "DCERPC_NCA_S_FAULT_NO_CLIENT_STUB"; break;
861 0 : case DCERPC_FAULT_ACCESS_DENIED: val = "DCERPC_FAULT_ACCESS_DENIED"; break;
862 0 : case DCERPC_FAULT_SERVER_UNAVAILABLE: val = "DCERPC_FAULT_SERVER_UNAVAILABLE"; break;
863 0 : case DCERPC_FAULT_NO_CALL_ACTIVE: val = "DCERPC_FAULT_NO_CALL_ACTIVE"; break;
864 0 : case DCERPC_FAULT_CANT_PERFORM: val = "DCERPC_FAULT_CANT_PERFORM"; break;
865 0 : case DCERPC_FAULT_OUT_OF_RESOURCES: val = "DCERPC_FAULT_OUT_OF_RESOURCES"; break;
866 0 : case DCERPC_FAULT_BAD_STUB_DATA: val = "DCERPC_FAULT_BAD_STUB_DATA"; break;
867 0 : case DCERPC_FAULT_SEC_PKG_ERROR: val = "DCERPC_FAULT_SEC_PKG_ERROR"; break;
868 : }
869 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
870 0 : }
871 :
872 2849 : static enum ndr_err_code ndr_push_dcerpc_fault_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t r)
873 : {
874 2849 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
875 2503 : return NDR_ERR_SUCCESS;
876 : }
877 :
878 5694 : static enum ndr_err_code ndr_pull_dcerpc_fault_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *r)
879 : {
880 686 : uint8_t v;
881 5694 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
882 5694 : *r = v;
883 5694 : return NDR_ERR_SUCCESS;
884 : }
885 :
886 0 : _PUBLIC_ void ndr_print_dcerpc_fault_flags(struct ndr_print *ndr, const char *name, uint8_t r)
887 : {
888 0 : ndr_print_uint8(ndr, name, r);
889 0 : ndr->depth++;
890 0 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_FAULT_FLAG_EXTENDED_ERROR_INFORMATION", DCERPC_FAULT_FLAG_EXTENDED_ERROR_INFORMATION, r);
891 0 : ndr->depth--;
892 0 : }
893 :
894 2849 : static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_fault *r)
895 : {
896 2849 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
897 2849 : if (ndr_flags & NDR_SCALARS) {
898 2849 : NDR_CHECK(ndr_push_align(ndr, 4));
899 2849 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
900 2849 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
901 2849 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
902 3195 : NDR_CHECK(ndr_push_dcerpc_fault_flags(ndr, NDR_SCALARS, r->flags));
903 3195 : NDR_CHECK(ndr_push_dcerpc_nca_status(ndr, NDR_SCALARS, r->status));
904 2849 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
905 : {
906 2849 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
907 2849 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
908 2849 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->error_and_verifier));
909 2849 : ndr->flags = _flags_save_DATA_BLOB;
910 : }
911 2849 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
912 : }
913 2849 : if (ndr_flags & NDR_BUFFERS) {
914 346 : }
915 2849 : return NDR_ERR_SUCCESS;
916 : }
917 :
918 5694 : static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_fault *r)
919 : {
920 5694 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
921 5694 : if (ndr_flags & NDR_SCALARS) {
922 5694 : NDR_CHECK(ndr_pull_align(ndr, 4));
923 5694 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
924 5694 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
925 5694 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
926 6380 : NDR_CHECK(ndr_pull_dcerpc_fault_flags(ndr, NDR_SCALARS, &r->flags));
927 6380 : NDR_CHECK(ndr_pull_dcerpc_nca_status(ndr, NDR_SCALARS, &r->status));
928 5694 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
929 : {
930 5694 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
931 5694 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
932 5694 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->error_and_verifier));
933 5694 : ndr->flags = _flags_save_DATA_BLOB;
934 : }
935 5694 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
936 : }
937 5694 : if (ndr_flags & NDR_BUFFERS) {
938 686 : }
939 5694 : return NDR_ERR_SUCCESS;
940 : }
941 :
942 0 : _PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
943 : {
944 0 : ndr_print_struct(ndr, name, "dcerpc_fault");
945 0 : if (r == NULL) { ndr_print_null(ndr); return; }
946 0 : ndr->depth++;
947 0 : ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
948 0 : ndr_print_uint16(ndr, "context_id", r->context_id);
949 0 : ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
950 0 : ndr_print_dcerpc_fault_flags(ndr, "flags", r->flags);
951 0 : ndr_print_dcerpc_nca_status(ndr, "status", r->status);
952 0 : ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
953 : {
954 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
955 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
956 0 : ndr_print_DATA_BLOB(ndr, "error_and_verifier", r->error_and_verifier);
957 0 : ndr->flags = _flags_save_DATA_BLOB;
958 : }
959 0 : ndr->depth--;
960 : }
961 :
962 518119 : static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthType r)
963 : {
964 518119 : NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
965 510287 : return NDR_ERR_SUCCESS;
966 : }
967 :
968 517343 : static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthType *r)
969 : {
970 7825 : uint8_t v;
971 517343 : NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
972 517343 : *r = v;
973 517343 : return NDR_ERR_SUCCESS;
974 : }
975 :
976 0 : _PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
977 : {
978 0 : const char *val = NULL;
979 :
980 0 : switch (r) {
981 0 : case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
982 0 : case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
983 0 : case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
984 0 : case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
985 0 : case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
986 0 : case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
987 0 : case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
988 0 : case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
989 0 : case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
990 0 : case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
991 0 : case DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM: val = "DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM"; break;
992 : }
993 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
994 0 : }
995 :
996 518119 : static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthLevel r)
997 : {
998 518119 : NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
999 510287 : return NDR_ERR_SUCCESS;
1000 : }
1001 :
1002 517343 : static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_AuthLevel *r)
1003 : {
1004 7825 : uint8_t v;
1005 517343 : NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
1006 517343 : *r = v;
1007 517343 : return NDR_ERR_SUCCESS;
1008 : }
1009 :
1010 0 : _PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
1011 : {
1012 0 : const char *val = NULL;
1013 :
1014 0 : switch (r) {
1015 0 : case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
1016 0 : case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
1017 0 : case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
1018 0 : case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
1019 0 : case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
1020 0 : case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
1021 : }
1022 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
1023 0 : }
1024 :
1025 518119 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_auth *r)
1026 : {
1027 518119 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1028 518119 : if (ndr_flags & NDR_SCALARS) {
1029 518119 : NDR_CHECK(ndr_push_align(ndr, 4));
1030 525951 : NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
1031 525951 : NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
1032 518119 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
1033 518119 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
1034 518119 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
1035 : {
1036 518119 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1037 518119 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1038 518119 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
1039 518119 : ndr->flags = _flags_save_DATA_BLOB;
1040 : }
1041 518119 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1042 : }
1043 518119 : if (ndr_flags & NDR_BUFFERS) {
1044 7832 : }
1045 518119 : return NDR_ERR_SUCCESS;
1046 : }
1047 :
1048 517343 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_auth *r)
1049 : {
1050 517343 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1051 517343 : if (ndr_flags & NDR_SCALARS) {
1052 517343 : NDR_CHECK(ndr_pull_align(ndr, 4));
1053 525168 : NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
1054 525168 : NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
1055 517343 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
1056 517343 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
1057 517343 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
1058 : {
1059 517343 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1060 517343 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1061 517343 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
1062 517343 : ndr->flags = _flags_save_DATA_BLOB;
1063 : }
1064 517343 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1065 : }
1066 517343 : if (ndr_flags & NDR_BUFFERS) {
1067 7825 : }
1068 517343 : return NDR_ERR_SUCCESS;
1069 : }
1070 :
1071 0 : static void ndr_print_flags_dcerpc_auth(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_auth *r)
1072 : {
1073 0 : ndr_print_dcerpc_auth(ndr, name, r);
1074 0 : }
1075 :
1076 0 : _PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
1077 : {
1078 0 : ndr_print_struct(ndr, name, "dcerpc_auth");
1079 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1080 0 : ndr->depth++;
1081 0 : ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
1082 0 : ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
1083 0 : ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
1084 0 : ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
1085 0 : ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
1086 : {
1087 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1088 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1089 0 : ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
1090 0 : ndr->flags = _flags_save_DATA_BLOB;
1091 : }
1092 0 : ndr->depth--;
1093 : }
1094 :
1095 289 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_auth3 *r)
1096 : {
1097 289 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1098 289 : if (ndr_flags & NDR_SCALARS) {
1099 289 : NDR_CHECK(ndr_push_align(ndr, 4));
1100 289 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1101 : {
1102 289 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1103 289 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1104 289 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
1105 289 : ndr->flags = _flags_save_DATA_BLOB;
1106 : }
1107 289 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1108 : }
1109 289 : if (ndr_flags & NDR_BUFFERS) {
1110 0 : }
1111 289 : return NDR_ERR_SUCCESS;
1112 : }
1113 :
1114 230 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_auth3 *r)
1115 : {
1116 230 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1117 230 : if (ndr_flags & NDR_SCALARS) {
1118 230 : NDR_CHECK(ndr_pull_align(ndr, 4));
1119 230 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
1120 : {
1121 230 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1122 230 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1123 230 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
1124 230 : ndr->flags = _flags_save_DATA_BLOB;
1125 : }
1126 230 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1127 : }
1128 230 : if (ndr_flags & NDR_BUFFERS) {
1129 0 : }
1130 230 : return NDR_ERR_SUCCESS;
1131 : }
1132 :
1133 0 : static void ndr_print_flags_dcerpc_auth3(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_auth3 *r)
1134 : {
1135 0 : ndr_print_dcerpc_auth3(ndr, name, r);
1136 0 : }
1137 :
1138 0 : _PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
1139 : {
1140 0 : ndr_print_struct(ndr, name, "dcerpc_auth3");
1141 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1142 0 : ndr->depth++;
1143 0 : ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
1144 : {
1145 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1146 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1147 0 : ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1148 0 : ndr->flags = _flags_save_DATA_BLOB;
1149 : }
1150 0 : ndr->depth--;
1151 : }
1152 :
1153 32 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_orphaned *r)
1154 : {
1155 32 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1156 32 : if (ndr_flags & NDR_SCALARS) {
1157 32 : NDR_CHECK(ndr_push_align(ndr, 4));
1158 : {
1159 32 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1160 32 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1161 32 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
1162 32 : ndr->flags = _flags_save_DATA_BLOB;
1163 : }
1164 32 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1165 : }
1166 32 : if (ndr_flags & NDR_BUFFERS) {
1167 2 : }
1168 32 : return NDR_ERR_SUCCESS;
1169 : }
1170 :
1171 17 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_orphaned *r)
1172 : {
1173 17 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1174 17 : if (ndr_flags & NDR_SCALARS) {
1175 17 : NDR_CHECK(ndr_pull_align(ndr, 4));
1176 : {
1177 17 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1178 17 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1179 17 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
1180 17 : ndr->flags = _flags_save_DATA_BLOB;
1181 : }
1182 17 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1183 : }
1184 17 : if (ndr_flags & NDR_BUFFERS) {
1185 2 : }
1186 17 : return NDR_ERR_SUCCESS;
1187 : }
1188 :
1189 0 : static void ndr_print_flags_dcerpc_orphaned(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_orphaned *r)
1190 : {
1191 0 : ndr_print_dcerpc_orphaned(ndr, name, r);
1192 0 : }
1193 :
1194 2 : _PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
1195 : {
1196 2 : ndr_print_struct(ndr, name, "dcerpc_orphaned");
1197 2 : if (r == NULL) { ndr_print_null(ndr); return; }
1198 2 : ndr->depth++;
1199 : {
1200 2 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1201 2 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1202 2 : ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1203 2 : ndr->flags = _flags_save_DATA_BLOB;
1204 : }
1205 2 : ndr->depth--;
1206 : }
1207 :
1208 14 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_co_cancel *r)
1209 : {
1210 14 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1211 14 : if (ndr_flags & NDR_SCALARS) {
1212 14 : NDR_CHECK(ndr_push_align(ndr, 4));
1213 : {
1214 14 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1215 14 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1216 14 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
1217 14 : ndr->flags = _flags_save_DATA_BLOB;
1218 : }
1219 14 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1220 : }
1221 14 : if (ndr_flags & NDR_BUFFERS) {
1222 2 : }
1223 14 : return NDR_ERR_SUCCESS;
1224 : }
1225 :
1226 8 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_co_cancel *r)
1227 : {
1228 8 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1229 8 : if (ndr_flags & NDR_SCALARS) {
1230 8 : NDR_CHECK(ndr_pull_align(ndr, 4));
1231 : {
1232 8 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1233 8 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1234 8 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
1235 8 : ndr->flags = _flags_save_DATA_BLOB;
1236 : }
1237 8 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1238 : }
1239 8 : if (ndr_flags & NDR_BUFFERS) {
1240 2 : }
1241 8 : return NDR_ERR_SUCCESS;
1242 : }
1243 :
1244 0 : static void ndr_print_flags_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_co_cancel *r)
1245 : {
1246 0 : ndr_print_dcerpc_co_cancel(ndr, name, r);
1247 0 : }
1248 :
1249 2 : _PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
1250 : {
1251 2 : ndr_print_struct(ndr, name, "dcerpc_co_cancel");
1252 2 : if (r == NULL) { ndr_print_null(ndr); return; }
1253 2 : ndr->depth++;
1254 : {
1255 2 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
1256 2 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1257 2 : ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1258 2 : ndr->flags = _flags_save_DATA_BLOB;
1259 : }
1260 2 : ndr->depth--;
1261 : }
1262 :
1263 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_cl_cancel *r)
1264 : {
1265 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1266 0 : if (ndr_flags & NDR_SCALARS) {
1267 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1268 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1269 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1270 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1271 : }
1272 0 : if (ndr_flags & NDR_BUFFERS) {
1273 0 : }
1274 0 : return NDR_ERR_SUCCESS;
1275 : }
1276 :
1277 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_cl_cancel *r)
1278 : {
1279 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1280 0 : if (ndr_flags & NDR_SCALARS) {
1281 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1282 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1283 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1284 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1285 : }
1286 0 : if (ndr_flags & NDR_BUFFERS) {
1287 0 : }
1288 0 : return NDR_ERR_SUCCESS;
1289 : }
1290 :
1291 0 : static void ndr_print_flags_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_cl_cancel *r)
1292 : {
1293 0 : ndr_print_dcerpc_cl_cancel(ndr, name, r);
1294 0 : }
1295 :
1296 0 : _PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
1297 : {
1298 0 : ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
1299 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1300 0 : ndr->depth++;
1301 0 : ndr_print_uint32(ndr, "version", r->version);
1302 0 : ndr_print_uint32(ndr, "id", r->id);
1303 0 : ndr->depth--;
1304 : }
1305 :
1306 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_cancel_ack *r)
1307 : {
1308 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1309 0 : if (ndr_flags & NDR_SCALARS) {
1310 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1311 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1312 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1313 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
1314 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1315 : }
1316 0 : if (ndr_flags & NDR_BUFFERS) {
1317 0 : }
1318 0 : return NDR_ERR_SUCCESS;
1319 : }
1320 :
1321 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_cancel_ack *r)
1322 : {
1323 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1324 0 : if (ndr_flags & NDR_SCALARS) {
1325 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1326 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1327 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1328 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
1329 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1330 : }
1331 0 : if (ndr_flags & NDR_BUFFERS) {
1332 0 : }
1333 0 : return NDR_ERR_SUCCESS;
1334 : }
1335 :
1336 0 : static void ndr_print_flags_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_cancel_ack *r)
1337 : {
1338 0 : ndr_print_dcerpc_cancel_ack(ndr, name, r);
1339 0 : }
1340 :
1341 0 : _PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
1342 : {
1343 0 : ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
1344 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1345 0 : ndr->depth++;
1346 0 : ndr_print_uint32(ndr, "version", r->version);
1347 0 : ndr_print_uint32(ndr, "id", r->id);
1348 0 : ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
1349 0 : ndr->depth--;
1350 : }
1351 :
1352 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_fack *r)
1353 : {
1354 0 : uint32_t cntr_selack_0;
1355 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1356 0 : if (ndr_flags & NDR_SCALARS) {
1357 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1358 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1359 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
1360 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
1361 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
1362 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
1363 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
1364 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
1365 0 : for (cntr_selack_0 = 0; cntr_selack_0 < (r->selack_size); cntr_selack_0++) {
1366 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
1367 : }
1368 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1369 : }
1370 0 : if (ndr_flags & NDR_BUFFERS) {
1371 0 : }
1372 0 : return NDR_ERR_SUCCESS;
1373 : }
1374 :
1375 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_fack *r)
1376 : {
1377 0 : uint32_t size_selack_0 = 0;
1378 0 : uint32_t cntr_selack_0;
1379 0 : TALLOC_CTX *_mem_save_selack_0 = NULL;
1380 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1381 0 : if (ndr_flags & NDR_SCALARS) {
1382 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1383 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1384 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
1385 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
1386 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
1387 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
1388 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
1389 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
1390 0 : size_selack_0 = r->selack_size;
1391 0 : NDR_PULL_ALLOC_N(ndr, r->selack, size_selack_0);
1392 0 : _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
1393 0 : NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
1394 0 : for (cntr_selack_0 = 0; cntr_selack_0 < (size_selack_0); cntr_selack_0++) {
1395 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
1396 : }
1397 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
1398 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1399 : }
1400 0 : if (ndr_flags & NDR_BUFFERS) {
1401 0 : }
1402 0 : return NDR_ERR_SUCCESS;
1403 : }
1404 :
1405 0 : static void ndr_print_flags_dcerpc_fack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_fack *r)
1406 : {
1407 0 : ndr_print_dcerpc_fack(ndr, name, r);
1408 0 : }
1409 :
1410 0 : _PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
1411 : {
1412 0 : uint32_t cntr_selack_0;
1413 0 : ndr_print_struct(ndr, name, "dcerpc_fack");
1414 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1415 0 : ndr->depth++;
1416 0 : ndr_print_uint32(ndr, "version", r->version);
1417 0 : ndr_print_uint8(ndr, "_pad1", r->_pad1);
1418 0 : ndr_print_uint16(ndr, "window_size", r->window_size);
1419 0 : ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
1420 0 : ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
1421 0 : ndr_print_uint16(ndr, "serial_no", r->serial_no);
1422 0 : ndr_print_uint16(ndr, "selack_size", r->selack_size);
1423 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "selack", (uint32_t)(r->selack_size));
1424 0 : ndr->depth++;
1425 0 : for (cntr_selack_0 = 0; cntr_selack_0 < (r->selack_size); cntr_selack_0++) {
1426 0 : ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
1427 : }
1428 0 : ndr->depth--;
1429 0 : ndr->depth--;
1430 : }
1431 :
1432 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ack *r)
1433 : {
1434 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1435 0 : if (ndr_flags & NDR_SCALARS) {
1436 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1437 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1438 : }
1439 0 : if (ndr_flags & NDR_BUFFERS) {
1440 0 : }
1441 0 : return NDR_ERR_SUCCESS;
1442 : }
1443 :
1444 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ack *r)
1445 : {
1446 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1447 0 : if (ndr_flags & NDR_SCALARS) {
1448 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1449 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1450 : }
1451 0 : if (ndr_flags & NDR_BUFFERS) {
1452 0 : }
1453 0 : return NDR_ERR_SUCCESS;
1454 : }
1455 :
1456 0 : static void ndr_print_flags_dcerpc_ack(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_ack *r)
1457 : {
1458 0 : ndr_print_dcerpc_ack(ndr, name, r);
1459 0 : }
1460 :
1461 0 : _PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
1462 : {
1463 0 : ndr_print_struct(ndr, name, "dcerpc_ack");
1464 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1465 0 : ndr->depth++;
1466 0 : ndr->depth--;
1467 : }
1468 :
1469 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_ping *r)
1470 : {
1471 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1472 0 : if (ndr_flags & NDR_SCALARS) {
1473 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1474 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1475 : }
1476 0 : if (ndr_flags & NDR_BUFFERS) {
1477 0 : }
1478 0 : return NDR_ERR_SUCCESS;
1479 : }
1480 :
1481 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_ping *r)
1482 : {
1483 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1484 0 : if (ndr_flags & NDR_SCALARS) {
1485 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1486 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1487 : }
1488 0 : if (ndr_flags & NDR_BUFFERS) {
1489 0 : }
1490 0 : return NDR_ERR_SUCCESS;
1491 : }
1492 :
1493 0 : static void ndr_print_flags_dcerpc_ping(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_ping *r)
1494 : {
1495 0 : ndr_print_dcerpc_ping(ndr, name, r);
1496 0 : }
1497 :
1498 0 : _PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
1499 : {
1500 0 : ndr_print_struct(ndr, name, "dcerpc_ping");
1501 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1502 0 : ndr->depth++;
1503 0 : ndr->depth--;
1504 : }
1505 :
1506 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_shutdown *r)
1507 : {
1508 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1509 0 : if (ndr_flags & NDR_SCALARS) {
1510 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1511 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1512 : }
1513 0 : if (ndr_flags & NDR_BUFFERS) {
1514 0 : }
1515 0 : return NDR_ERR_SUCCESS;
1516 : }
1517 :
1518 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_shutdown *r)
1519 : {
1520 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1521 0 : if (ndr_flags & NDR_SCALARS) {
1522 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1523 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1524 : }
1525 0 : if (ndr_flags & NDR_BUFFERS) {
1526 0 : }
1527 0 : return NDR_ERR_SUCCESS;
1528 : }
1529 :
1530 0 : static void ndr_print_flags_dcerpc_shutdown(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_shutdown *r)
1531 : {
1532 0 : ndr_print_dcerpc_shutdown(ndr, name, r);
1533 0 : }
1534 :
1535 0 : _PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
1536 : {
1537 0 : ndr_print_struct(ndr, name, "dcerpc_shutdown");
1538 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1539 0 : ndr->depth++;
1540 0 : ndr->depth--;
1541 : }
1542 :
1543 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_working *r)
1544 : {
1545 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1546 0 : if (ndr_flags & NDR_SCALARS) {
1547 0 : NDR_CHECK(ndr_push_align(ndr, 1));
1548 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1549 : }
1550 0 : if (ndr_flags & NDR_BUFFERS) {
1551 0 : }
1552 0 : return NDR_ERR_SUCCESS;
1553 : }
1554 :
1555 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_working *r)
1556 : {
1557 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1558 0 : if (ndr_flags & NDR_SCALARS) {
1559 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
1560 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1561 : }
1562 0 : if (ndr_flags & NDR_BUFFERS) {
1563 0 : }
1564 0 : return NDR_ERR_SUCCESS;
1565 : }
1566 :
1567 0 : static void ndr_print_flags_dcerpc_working(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_working *r)
1568 : {
1569 0 : ndr_print_dcerpc_working(ndr, name, r);
1570 0 : }
1571 :
1572 0 : _PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
1573 : {
1574 0 : ndr_print_struct(ndr, name, "dcerpc_working");
1575 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1576 0 : ndr->depth++;
1577 0 : ndr->depth--;
1578 : }
1579 :
1580 0 : _PUBLIC_ enum ndr_err_code ndr_push_RTSCookie(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct RTSCookie *r)
1581 : {
1582 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1583 0 : if (ndr_flags & NDR_SCALARS) {
1584 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1585 0 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->Cookie));
1586 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1587 : }
1588 0 : if (ndr_flags & NDR_BUFFERS) {
1589 0 : }
1590 0 : return NDR_ERR_SUCCESS;
1591 : }
1592 :
1593 0 : _PUBLIC_ enum ndr_err_code ndr_pull_RTSCookie(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct RTSCookie *r)
1594 : {
1595 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1596 0 : if (ndr_flags & NDR_SCALARS) {
1597 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1598 0 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->Cookie));
1599 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1600 : }
1601 0 : if (ndr_flags & NDR_BUFFERS) {
1602 0 : }
1603 0 : return NDR_ERR_SUCCESS;
1604 : }
1605 :
1606 0 : static void ndr_print_flags_RTSCookie(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct RTSCookie *r)
1607 : {
1608 0 : ndr_print_RTSCookie(ndr, name, r);
1609 0 : }
1610 :
1611 0 : _PUBLIC_ void ndr_print_RTSCookie(struct ndr_print *ndr, const char *name, const struct RTSCookie *r)
1612 : {
1613 0 : ndr_print_struct(ndr, name, "RTSCookie");
1614 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1615 0 : ndr->depth++;
1616 0 : ndr_print_GUID(ndr, "Cookie", &r->Cookie);
1617 0 : ndr->depth--;
1618 : }
1619 :
1620 0 : _PUBLIC_ enum ndr_err_code ndr_push_AddressType(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum AddressType r)
1621 : {
1622 0 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1623 0 : return NDR_ERR_SUCCESS;
1624 : }
1625 :
1626 0 : _PUBLIC_ enum ndr_err_code ndr_pull_AddressType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum AddressType *r)
1627 : {
1628 0 : uint32_t v;
1629 0 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1630 0 : *r = v;
1631 0 : return NDR_ERR_SUCCESS;
1632 : }
1633 :
1634 0 : _PUBLIC_ void ndr_print_AddressType(struct ndr_print *ndr, const char *name, enum AddressType r)
1635 : {
1636 0 : const char *val = NULL;
1637 :
1638 0 : switch (r) {
1639 0 : case RTS_IPV4: val = "RTS_IPV4"; break;
1640 0 : case RTS_IPV6: val = "RTS_IPV6"; break;
1641 : }
1642 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
1643 0 : }
1644 :
1645 0 : static enum ndr_err_code ndr_push_ClientAddressType(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union ClientAddressType *r)
1646 : {
1647 0 : uint32_t level;
1648 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1649 0 : if (ndr_flags & NDR_SCALARS) {
1650 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1651 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
1652 0 : NDR_CHECK(ndr_push_union_align(ndr, 4));
1653 0 : switch (level) {
1654 0 : case RTS_IPV4: {
1655 0 : NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ClientAddressIPV4));
1656 0 : break; }
1657 :
1658 0 : case RTS_IPV6: {
1659 0 : NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ClientAddressIPV6));
1660 0 : break; }
1661 :
1662 0 : default:
1663 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
1664 : }
1665 : }
1666 0 : if (ndr_flags & NDR_BUFFERS) {
1667 0 : if (!(ndr_flags & NDR_SCALARS)) {
1668 : /* We didn't get it above, and the token is not needed after this. */
1669 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
1670 : }
1671 0 : switch (level) {
1672 0 : case RTS_IPV4:
1673 0 : break;
1674 :
1675 0 : case RTS_IPV6:
1676 0 : break;
1677 :
1678 0 : default:
1679 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
1680 : }
1681 : }
1682 0 : return NDR_ERR_SUCCESS;
1683 : }
1684 :
1685 0 : static enum ndr_err_code ndr_pull_ClientAddressType(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union ClientAddressType *r)
1686 : {
1687 0 : uint32_t level;
1688 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1689 0 : if (ndr_flags & NDR_SCALARS) {
1690 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
1691 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
1692 0 : NDR_CHECK(ndr_pull_union_align(ndr, 4));
1693 0 : switch (level) {
1694 0 : case RTS_IPV4: {
1695 0 : NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ClientAddressIPV4));
1696 0 : break; }
1697 :
1698 0 : case RTS_IPV6: {
1699 0 : NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ClientAddressIPV6));
1700 0 : break; }
1701 :
1702 0 : default:
1703 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
1704 : }
1705 : }
1706 0 : if (ndr_flags & NDR_BUFFERS) {
1707 0 : if (!(ndr_flags & NDR_SCALARS)) {
1708 : /* We didn't get it above, and the token is not needed after this. */
1709 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
1710 : }
1711 0 : switch (level) {
1712 0 : case RTS_IPV4:
1713 0 : break;
1714 :
1715 0 : case RTS_IPV6:
1716 0 : break;
1717 :
1718 0 : default:
1719 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
1720 : }
1721 : }
1722 0 : return NDR_ERR_SUCCESS;
1723 : }
1724 :
1725 0 : _PUBLIC_ void ndr_print_ClientAddressType(struct ndr_print *ndr, const char *name, const union ClientAddressType *r)
1726 : {
1727 0 : uint32_t level;
1728 0 : level = ndr_print_steal_switch_value(ndr, r);
1729 0 : ndr_print_union(ndr, name, level, "ClientAddressType");
1730 0 : switch (level) {
1731 0 : case RTS_IPV4:
1732 0 : ndr_print_ipv4address(ndr, "ClientAddressIPV4", r->ClientAddressIPV4);
1733 0 : break;
1734 :
1735 0 : case RTS_IPV6:
1736 0 : ndr_print_ipv6address(ndr, "ClientAddressIPV6", r->ClientAddressIPV6);
1737 0 : break;
1738 :
1739 0 : default:
1740 0 : ndr_print_bad_level(ndr, name, level);
1741 : }
1742 0 : }
1743 :
1744 0 : _PUBLIC_ enum ndr_err_code ndr_push_ClientAddress(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct ClientAddress *r)
1745 : {
1746 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1747 0 : if (ndr_flags & NDR_SCALARS) {
1748 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1749 0 : NDR_CHECK(ndr_push_AddressType(ndr, NDR_SCALARS, r->AddressType));
1750 0 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
1751 0 : NDR_CHECK(ndr_push_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
1752 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, 12));
1753 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1754 : }
1755 0 : if (ndr_flags & NDR_BUFFERS) {
1756 0 : }
1757 0 : return NDR_ERR_SUCCESS;
1758 : }
1759 :
1760 0 : _PUBLIC_ enum ndr_err_code ndr_pull_ClientAddress(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct ClientAddress *r)
1761 : {
1762 0 : uint32_t size_Padding_0 = 0;
1763 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1764 0 : if (ndr_flags & NDR_SCALARS) {
1765 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1766 0 : NDR_CHECK(ndr_pull_AddressType(ndr, NDR_SCALARS, &r->AddressType));
1767 0 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
1768 0 : NDR_CHECK(ndr_pull_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
1769 0 : size_Padding_0 = 12;
1770 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
1771 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1772 : }
1773 0 : if (ndr_flags & NDR_BUFFERS) {
1774 0 : }
1775 0 : return NDR_ERR_SUCCESS;
1776 : }
1777 :
1778 0 : static void ndr_print_flags_ClientAddress(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ClientAddress *r)
1779 : {
1780 0 : ndr_print_ClientAddress(ndr, name, r);
1781 0 : }
1782 :
1783 0 : _PUBLIC_ void ndr_print_ClientAddress(struct ndr_print *ndr, const char *name, const struct ClientAddress *r)
1784 : {
1785 0 : ndr_print_struct(ndr, name, "ClientAddress");
1786 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1787 0 : ndr->depth++;
1788 0 : ndr_print_AddressType(ndr, "AddressType", r->AddressType);
1789 0 : ndr_print_set_switch_value(ndr, &r->ClientAddress, r->AddressType);
1790 0 : ndr_print_ClientAddressType(ndr, "ClientAddress", &r->ClientAddress);
1791 0 : ndr_print_array_uint8(ndr, "Padding", r->Padding, 12);
1792 0 : ndr->depth--;
1793 : }
1794 :
1795 0 : _PUBLIC_ enum ndr_err_code ndr_push_ForwardDestination(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum ForwardDestination r)
1796 : {
1797 0 : NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1798 0 : return NDR_ERR_SUCCESS;
1799 : }
1800 :
1801 0 : _PUBLIC_ enum ndr_err_code ndr_pull_ForwardDestination(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum ForwardDestination *r)
1802 : {
1803 0 : uint32_t v;
1804 0 : NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1805 0 : *r = v;
1806 0 : return NDR_ERR_SUCCESS;
1807 : }
1808 :
1809 0 : _PUBLIC_ void ndr_print_ForwardDestination(struct ndr_print *ndr, const char *name, enum ForwardDestination r)
1810 : {
1811 0 : const char *val = NULL;
1812 :
1813 0 : switch (r) {
1814 0 : case FDClient: val = "FDClient"; break;
1815 0 : case FDInProxy: val = "FDInProxy"; break;
1816 0 : case FDServer: val = "FDServer"; break;
1817 0 : case FDOutProxy: val = "FDOutProxy"; break;
1818 : }
1819 0 : ndr_print_enum(ndr, name, "ENUM", val, r);
1820 0 : }
1821 :
1822 0 : _PUBLIC_ enum ndr_err_code ndr_push_FlowControlAcknowledgment(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct FlowControlAcknowledgment *r)
1823 : {
1824 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1825 0 : if (ndr_flags & NDR_SCALARS) {
1826 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1827 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BytesReceived));
1828 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->AvailableWindow));
1829 0 : NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
1830 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1831 : }
1832 0 : if (ndr_flags & NDR_BUFFERS) {
1833 0 : }
1834 0 : return NDR_ERR_SUCCESS;
1835 : }
1836 :
1837 0 : _PUBLIC_ enum ndr_err_code ndr_pull_FlowControlAcknowledgment(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct FlowControlAcknowledgment *r)
1838 : {
1839 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1840 0 : if (ndr_flags & NDR_SCALARS) {
1841 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1842 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BytesReceived));
1843 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->AvailableWindow));
1844 0 : NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
1845 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1846 : }
1847 0 : if (ndr_flags & NDR_BUFFERS) {
1848 0 : }
1849 0 : return NDR_ERR_SUCCESS;
1850 : }
1851 :
1852 0 : static void ndr_print_flags_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct FlowControlAcknowledgment *r)
1853 : {
1854 0 : ndr_print_FlowControlAcknowledgment(ndr, name, r);
1855 0 : }
1856 :
1857 0 : _PUBLIC_ void ndr_print_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, const struct FlowControlAcknowledgment *r)
1858 : {
1859 0 : ndr_print_struct(ndr, name, "FlowControlAcknowledgment");
1860 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1861 0 : ndr->depth++;
1862 0 : ndr_print_uint32(ndr, "BytesReceived", r->BytesReceived);
1863 0 : ndr_print_uint32(ndr, "AvailableWindow", r->AvailableWindow);
1864 0 : ndr_print_RTSCookie(ndr, "ChannelCookie", &r->ChannelCookie);
1865 0 : ndr->depth--;
1866 : }
1867 :
1868 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1869 : {
1870 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1871 0 : if (ndr_flags & NDR_SCALARS) {
1872 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1873 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ReceiveWindowSize));
1874 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1875 : }
1876 0 : if (ndr_flags & NDR_BUFFERS) {
1877 0 : }
1878 0 : return NDR_ERR_SUCCESS;
1879 : }
1880 :
1881 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1882 : {
1883 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1884 0 : if (ndr_flags & NDR_SCALARS) {
1885 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1886 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
1887 0 : if (r->ReceiveWindowSize < 8192 || r->ReceiveWindowSize > 262144) {
1888 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ReceiveWindowSize), (uint32_t)(8192), (uint32_t)(262144));
1889 : }
1890 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1891 : }
1892 0 : if (ndr_flags & NDR_BUFFERS) {
1893 0 : }
1894 0 : return NDR_ERR_SUCCESS;
1895 : }
1896 :
1897 0 : static void ndr_print_flags_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1898 : {
1899 0 : ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, name, r);
1900 0 : }
1901 :
1902 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
1903 : {
1904 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ReceiveWindowSize");
1905 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1906 0 : ndr->depth++;
1907 0 : ndr_print_uint32(ndr, "ReceiveWindowSize", r->ReceiveWindowSize);
1908 0 : ndr->depth--;
1909 : }
1910 :
1911 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_FlowControlAck(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_FlowControlAck *r)
1912 : {
1913 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1914 0 : if (ndr_flags & NDR_SCALARS) {
1915 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1916 0 : NDR_CHECK(ndr_push_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
1917 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1918 : }
1919 0 : if (ndr_flags & NDR_BUFFERS) {
1920 0 : }
1921 0 : return NDR_ERR_SUCCESS;
1922 : }
1923 :
1924 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_FlowControlAck(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_FlowControlAck *r)
1925 : {
1926 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1927 0 : if (ndr_flags & NDR_SCALARS) {
1928 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1929 0 : NDR_CHECK(ndr_pull_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
1930 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1931 : }
1932 0 : if (ndr_flags & NDR_BUFFERS) {
1933 0 : }
1934 0 : return NDR_ERR_SUCCESS;
1935 : }
1936 :
1937 0 : static void ndr_print_flags_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_FlowControlAck *r)
1938 : {
1939 0 : ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, name, r);
1940 0 : }
1941 :
1942 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_FlowControlAck *r)
1943 : {
1944 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_FlowControlAck");
1945 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1946 0 : ndr->depth++;
1947 0 : ndr_print_FlowControlAcknowledgment(ndr, "Ack", &r->Ack);
1948 0 : ndr->depth--;
1949 : }
1950 :
1951 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
1952 : {
1953 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1954 0 : if (ndr_flags & NDR_SCALARS) {
1955 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1956 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConnectionTimeout));
1957 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1958 : }
1959 0 : if (ndr_flags & NDR_BUFFERS) {
1960 0 : }
1961 0 : return NDR_ERR_SUCCESS;
1962 : }
1963 :
1964 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ConnectionTimeout *r)
1965 : {
1966 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1967 0 : if (ndr_flags & NDR_SCALARS) {
1968 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
1969 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConnectionTimeout));
1970 0 : if (r->ConnectionTimeout < 120000 || r->ConnectionTimeout > 14400000) {
1971 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ConnectionTimeout), (uint32_t)(120000), (uint32_t)(14400000));
1972 : }
1973 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1974 : }
1975 0 : if (ndr_flags & NDR_BUFFERS) {
1976 0 : }
1977 0 : return NDR_ERR_SUCCESS;
1978 : }
1979 :
1980 0 : static void ndr_print_flags_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
1981 : {
1982 0 : ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, name, r);
1983 0 : }
1984 :
1985 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
1986 : {
1987 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ConnectionTimeout");
1988 0 : if (r == NULL) { ndr_print_null(ndr); return; }
1989 0 : ndr->depth++;
1990 0 : ndr_print_uint32(ndr, "ConnectionTimeout", r->ConnectionTimeout);
1991 0 : ndr->depth--;
1992 : }
1993 :
1994 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Cookie(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Cookie *r)
1995 : {
1996 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1997 0 : if (ndr_flags & NDR_SCALARS) {
1998 0 : NDR_CHECK(ndr_push_align(ndr, 4));
1999 0 : NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
2000 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2001 : }
2002 0 : if (ndr_flags & NDR_BUFFERS) {
2003 0 : }
2004 0 : return NDR_ERR_SUCCESS;
2005 : }
2006 :
2007 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Cookie(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Cookie *r)
2008 : {
2009 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2010 0 : if (ndr_flags & NDR_SCALARS) {
2011 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2012 0 : NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
2013 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2014 : }
2015 0 : if (ndr_flags & NDR_BUFFERS) {
2016 0 : }
2017 0 : return NDR_ERR_SUCCESS;
2018 : }
2019 :
2020 0 : static void ndr_print_flags_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Cookie *r)
2021 : {
2022 0 : ndr_print_dcerpc_rts_cmd_Cookie(ndr, name, r);
2023 0 : }
2024 :
2025 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Cookie *r)
2026 : {
2027 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Cookie");
2028 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2029 0 : ndr->depth++;
2030 0 : ndr_print_RTSCookie(ndr, "Cookie", &r->Cookie);
2031 0 : ndr->depth--;
2032 : }
2033 :
2034 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ChannelLifetime(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ChannelLifetime *r)
2035 : {
2036 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2037 0 : if (ndr_flags & NDR_SCALARS) {
2038 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2039 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChannelLifetime));
2040 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2041 : }
2042 0 : if (ndr_flags & NDR_BUFFERS) {
2043 0 : }
2044 0 : return NDR_ERR_SUCCESS;
2045 : }
2046 :
2047 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ChannelLifetime(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ChannelLifetime *r)
2048 : {
2049 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2050 0 : if (ndr_flags & NDR_SCALARS) {
2051 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2052 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChannelLifetime));
2053 0 : if (r->ChannelLifetime < 131072 || r->ChannelLifetime > 2147483648) {
2054 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ChannelLifetime), (uint32_t)(131072), (uint32_t)(2147483648));
2055 : }
2056 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2057 : }
2058 0 : if (ndr_flags & NDR_BUFFERS) {
2059 0 : }
2060 0 : return NDR_ERR_SUCCESS;
2061 : }
2062 :
2063 0 : static void ndr_print_flags_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ChannelLifetime *r)
2064 : {
2065 0 : ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, name, r);
2066 0 : }
2067 :
2068 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ChannelLifetime *r)
2069 : {
2070 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ChannelLifetime");
2071 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2072 0 : ndr->depth++;
2073 0 : ndr_print_uint32(ndr, "ChannelLifetime", r->ChannelLifetime);
2074 0 : ndr->depth--;
2075 : }
2076 :
2077 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientKeepalive(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ClientKeepalive *r)
2078 : {
2079 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2080 0 : if (ndr_flags & NDR_SCALARS) {
2081 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2082 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClientKeepalive));
2083 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2084 : }
2085 0 : if (ndr_flags & NDR_BUFFERS) {
2086 0 : }
2087 0 : return NDR_ERR_SUCCESS;
2088 : }
2089 :
2090 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientKeepalive(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ClientKeepalive *r)
2091 : {
2092 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2093 0 : if (ndr_flags & NDR_SCALARS) {
2094 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2095 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClientKeepalive));
2096 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2097 : }
2098 0 : if (ndr_flags & NDR_BUFFERS) {
2099 0 : }
2100 0 : return NDR_ERR_SUCCESS;
2101 : }
2102 :
2103 0 : static void ndr_print_flags_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ClientKeepalive *r)
2104 : {
2105 0 : ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, name, r);
2106 0 : }
2107 :
2108 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientKeepalive *r)
2109 : {
2110 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientKeepalive");
2111 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2112 0 : ndr->depth++;
2113 0 : ndr_print_uint32(ndr, "ClientKeepalive", r->ClientKeepalive);
2114 0 : ndr->depth--;
2115 : }
2116 :
2117 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Version(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Version *r)
2118 : {
2119 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2120 0 : if (ndr_flags & NDR_SCALARS) {
2121 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2122 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Version));
2123 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2124 : }
2125 0 : if (ndr_flags & NDR_BUFFERS) {
2126 0 : }
2127 0 : return NDR_ERR_SUCCESS;
2128 : }
2129 :
2130 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Version(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Version *r)
2131 : {
2132 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2133 0 : if (ndr_flags & NDR_SCALARS) {
2134 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2135 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
2136 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2137 : }
2138 0 : if (ndr_flags & NDR_BUFFERS) {
2139 0 : }
2140 0 : return NDR_ERR_SUCCESS;
2141 : }
2142 :
2143 0 : static void ndr_print_flags_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Version *r)
2144 : {
2145 0 : ndr_print_dcerpc_rts_cmd_Version(ndr, name, r);
2146 0 : }
2147 :
2148 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Version *r)
2149 : {
2150 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Version");
2151 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2152 0 : ndr->depth++;
2153 0 : ndr_print_uint32(ndr, "Version", r->Version);
2154 0 : ndr->depth--;
2155 : }
2156 :
2157 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Empty(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Empty *r)
2158 : {
2159 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2160 0 : if (ndr_flags & NDR_SCALARS) {
2161 0 : NDR_CHECK(ndr_push_align(ndr, 1));
2162 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2163 : }
2164 0 : if (ndr_flags & NDR_BUFFERS) {
2165 0 : }
2166 0 : return NDR_ERR_SUCCESS;
2167 : }
2168 :
2169 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Empty(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Empty *r)
2170 : {
2171 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2172 0 : if (ndr_flags & NDR_SCALARS) {
2173 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2174 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2175 : }
2176 0 : if (ndr_flags & NDR_BUFFERS) {
2177 0 : }
2178 0 : return NDR_ERR_SUCCESS;
2179 : }
2180 :
2181 0 : static void ndr_print_flags_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Empty *r)
2182 : {
2183 0 : ndr_print_dcerpc_rts_cmd_Empty(ndr, name, r);
2184 0 : }
2185 :
2186 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Empty *r)
2187 : {
2188 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Empty");
2189 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2190 0 : ndr->depth++;
2191 0 : ndr->depth--;
2192 : }
2193 :
2194 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Padding(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Padding *r)
2195 : {
2196 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2197 0 : if (ndr_flags & NDR_SCALARS) {
2198 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2199 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConformanceCount));
2200 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, r->ConformanceCount));
2201 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2202 : }
2203 0 : if (ndr_flags & NDR_BUFFERS) {
2204 0 : }
2205 0 : return NDR_ERR_SUCCESS;
2206 : }
2207 :
2208 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Padding(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Padding *r)
2209 : {
2210 0 : uint32_t size_Padding_0 = 0;
2211 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2212 0 : if (ndr_flags & NDR_SCALARS) {
2213 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2214 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConformanceCount));
2215 0 : if (r->ConformanceCount > 65535) {
2216 0 : return ndr_pull_error(ndr, NDR_ERR_RANGE, "value (%"PRIu32") out of range (%"PRIu32" - %"PRIu32")", (uint32_t)(r->ConformanceCount), (uint32_t)(0), (uint32_t)(65535));
2217 : }
2218 0 : size_Padding_0 = r->ConformanceCount;
2219 0 : NDR_PULL_ALLOC_N(ndr, r->Padding, size_Padding_0);
2220 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, size_Padding_0));
2221 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2222 : }
2223 0 : if (ndr_flags & NDR_BUFFERS) {
2224 0 : }
2225 0 : return NDR_ERR_SUCCESS;
2226 : }
2227 :
2228 0 : static void ndr_print_flags_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Padding *r)
2229 : {
2230 0 : ndr_print_dcerpc_rts_cmd_Padding(ndr, name, r);
2231 0 : }
2232 :
2233 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Padding *r)
2234 : {
2235 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Padding");
2236 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2237 0 : ndr->depth++;
2238 0 : ndr_print_uint32(ndr, "ConformanceCount", r->ConformanceCount);
2239 0 : ndr_print_array_uint8(ndr, "Padding", r->Padding, r->ConformanceCount);
2240 0 : ndr->depth--;
2241 : }
2242 :
2243 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_NegativeANCE(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_NegativeANCE *r)
2244 : {
2245 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2246 0 : if (ndr_flags & NDR_SCALARS) {
2247 0 : NDR_CHECK(ndr_push_align(ndr, 1));
2248 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2249 : }
2250 0 : if (ndr_flags & NDR_BUFFERS) {
2251 0 : }
2252 0 : return NDR_ERR_SUCCESS;
2253 : }
2254 :
2255 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_NegativeANCE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_NegativeANCE *r)
2256 : {
2257 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2258 0 : if (ndr_flags & NDR_SCALARS) {
2259 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2260 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2261 : }
2262 0 : if (ndr_flags & NDR_BUFFERS) {
2263 0 : }
2264 0 : return NDR_ERR_SUCCESS;
2265 : }
2266 :
2267 0 : static void ndr_print_flags_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_NegativeANCE *r)
2268 : {
2269 0 : ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, name, r);
2270 0 : }
2271 :
2272 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_NegativeANCE *r)
2273 : {
2274 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_NegativeANCE");
2275 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2276 0 : ndr->depth++;
2277 0 : ndr->depth--;
2278 : }
2279 :
2280 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ANCE(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ANCE *r)
2281 : {
2282 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2283 0 : if (ndr_flags & NDR_SCALARS) {
2284 0 : NDR_CHECK(ndr_push_align(ndr, 1));
2285 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2286 : }
2287 0 : if (ndr_flags & NDR_BUFFERS) {
2288 0 : }
2289 0 : return NDR_ERR_SUCCESS;
2290 : }
2291 :
2292 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ANCE(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ANCE *r)
2293 : {
2294 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2295 0 : if (ndr_flags & NDR_SCALARS) {
2296 0 : NDR_CHECK(ndr_pull_align(ndr, 1));
2297 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2298 : }
2299 0 : if (ndr_flags & NDR_BUFFERS) {
2300 0 : }
2301 0 : return NDR_ERR_SUCCESS;
2302 : }
2303 :
2304 0 : static void ndr_print_flags_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ANCE *r)
2305 : {
2306 0 : ndr_print_dcerpc_rts_cmd_ANCE(ndr, name, r);
2307 0 : }
2308 :
2309 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ANCE *r)
2310 : {
2311 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ANCE");
2312 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2313 0 : ndr->depth++;
2314 0 : ndr->depth--;
2315 : }
2316 :
2317 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientAddress(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_ClientAddress *r)
2318 : {
2319 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2320 0 : if (ndr_flags & NDR_SCALARS) {
2321 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2322 0 : NDR_CHECK(ndr_push_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2323 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2324 : }
2325 0 : if (ndr_flags & NDR_BUFFERS) {
2326 0 : }
2327 0 : return NDR_ERR_SUCCESS;
2328 : }
2329 :
2330 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientAddress(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_ClientAddress *r)
2331 : {
2332 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2333 0 : if (ndr_flags & NDR_SCALARS) {
2334 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2335 0 : NDR_CHECK(ndr_pull_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2336 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2337 : }
2338 0 : if (ndr_flags & NDR_BUFFERS) {
2339 0 : }
2340 0 : return NDR_ERR_SUCCESS;
2341 : }
2342 :
2343 0 : static void ndr_print_flags_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_ClientAddress *r)
2344 : {
2345 0 : ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, name, r);
2346 0 : }
2347 :
2348 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientAddress *r)
2349 : {
2350 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientAddress");
2351 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2352 0 : ndr->depth++;
2353 0 : ndr_print_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
2354 0 : ndr->depth--;
2355 : }
2356 :
2357 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_AssociationGroupId(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_AssociationGroupId *r)
2358 : {
2359 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2360 0 : if (ndr_flags & NDR_SCALARS) {
2361 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2362 0 : NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
2363 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2364 : }
2365 0 : if (ndr_flags & NDR_BUFFERS) {
2366 0 : }
2367 0 : return NDR_ERR_SUCCESS;
2368 : }
2369 :
2370 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_AssociationGroupId(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_AssociationGroupId *r)
2371 : {
2372 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2373 0 : if (ndr_flags & NDR_SCALARS) {
2374 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2375 0 : NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
2376 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2377 : }
2378 0 : if (ndr_flags & NDR_BUFFERS) {
2379 0 : }
2380 0 : return NDR_ERR_SUCCESS;
2381 : }
2382 :
2383 0 : static void ndr_print_flags_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_AssociationGroupId *r)
2384 : {
2385 0 : ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, name, r);
2386 0 : }
2387 :
2388 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_AssociationGroupId *r)
2389 : {
2390 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_AssociationGroupId");
2391 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2392 0 : ndr->depth++;
2393 0 : ndr_print_RTSCookie(ndr, "AssociationGroupId", &r->AssociationGroupId);
2394 0 : ndr->depth--;
2395 : }
2396 :
2397 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Destination(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_Destination *r)
2398 : {
2399 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2400 0 : if (ndr_flags & NDR_SCALARS) {
2401 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2402 0 : NDR_CHECK(ndr_push_ForwardDestination(ndr, NDR_SCALARS, r->ForwardDestination));
2403 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2404 : }
2405 0 : if (ndr_flags & NDR_BUFFERS) {
2406 0 : }
2407 0 : return NDR_ERR_SUCCESS;
2408 : }
2409 :
2410 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Destination(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_Destination *r)
2411 : {
2412 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2413 0 : if (ndr_flags & NDR_SCALARS) {
2414 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2415 0 : NDR_CHECK(ndr_pull_ForwardDestination(ndr, NDR_SCALARS, &r->ForwardDestination));
2416 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2417 : }
2418 0 : if (ndr_flags & NDR_BUFFERS) {
2419 0 : }
2420 0 : return NDR_ERR_SUCCESS;
2421 : }
2422 :
2423 0 : static void ndr_print_flags_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_Destination *r)
2424 : {
2425 0 : ndr_print_dcerpc_rts_cmd_Destination(ndr, name, r);
2426 0 : }
2427 :
2428 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Destination *r)
2429 : {
2430 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Destination");
2431 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2432 0 : ndr->depth++;
2433 0 : ndr_print_ForwardDestination(ndr, "ForwardDestination", r->ForwardDestination);
2434 0 : ndr->depth--;
2435 : }
2436 :
2437 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2438 : {
2439 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2440 0 : if (ndr_flags & NDR_SCALARS) {
2441 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2442 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->PingTrafficSent));
2443 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2444 : }
2445 0 : if (ndr_flags & NDR_BUFFERS) {
2446 0 : }
2447 0 : return NDR_ERR_SUCCESS;
2448 : }
2449 :
2450 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2451 : {
2452 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2453 0 : if (ndr_flags & NDR_SCALARS) {
2454 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2455 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->PingTrafficSent));
2456 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2457 : }
2458 0 : if (ndr_flags & NDR_BUFFERS) {
2459 0 : }
2460 0 : return NDR_ERR_SUCCESS;
2461 : }
2462 :
2463 0 : static void ndr_print_flags_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2464 : {
2465 0 : ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, name, r);
2466 0 : }
2467 :
2468 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
2469 : {
2470 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd_PingTrafficSentNotify");
2471 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2472 0 : ndr->depth++;
2473 0 : ndr_print_uint32(ndr, "PingTrafficSent", r->PingTrafficSent);
2474 0 : ndr->depth--;
2475 : }
2476 :
2477 0 : static enum ndr_err_code ndr_push_dcerpc_rts_cmds(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_rts_cmds *r)
2478 : {
2479 0 : uint32_t level;
2480 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2481 0 : if (ndr_flags & NDR_SCALARS) {
2482 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
2483 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2484 0 : NDR_CHECK(ndr_push_union_align(ndr, 4));
2485 0 : switch (level) {
2486 0 : case 0x0: {
2487 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
2488 0 : break; }
2489 :
2490 0 : case 0x1: {
2491 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
2492 0 : break; }
2493 :
2494 0 : case 0x2: {
2495 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
2496 0 : break; }
2497 :
2498 0 : case 0x3: {
2499 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
2500 0 : break; }
2501 :
2502 0 : case 0x4: {
2503 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
2504 0 : break; }
2505 :
2506 0 : case 0x5: {
2507 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
2508 0 : break; }
2509 :
2510 0 : case 0x6: {
2511 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
2512 0 : break; }
2513 :
2514 0 : case 0x7: {
2515 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
2516 0 : break; }
2517 :
2518 0 : case 0x8: {
2519 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
2520 0 : break; }
2521 :
2522 0 : case 0x9: {
2523 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
2524 0 : break; }
2525 :
2526 0 : case 0xA: {
2527 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
2528 0 : break; }
2529 :
2530 0 : case 0xB: {
2531 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2532 0 : break; }
2533 :
2534 0 : case 0xC: {
2535 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
2536 0 : break; }
2537 :
2538 0 : case 0xD: {
2539 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
2540 0 : break; }
2541 :
2542 0 : case 0xE: {
2543 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
2544 0 : break; }
2545 :
2546 0 : default:
2547 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
2548 : }
2549 : }
2550 0 : if (ndr_flags & NDR_BUFFERS) {
2551 0 : if (!(ndr_flags & NDR_SCALARS)) {
2552 : /* We didn't get it above, and the token is not needed after this. */
2553 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
2554 : }
2555 0 : switch (level) {
2556 0 : case 0x0:
2557 0 : break;
2558 :
2559 0 : case 0x1:
2560 0 : break;
2561 :
2562 0 : case 0x2:
2563 0 : break;
2564 :
2565 0 : case 0x3:
2566 0 : break;
2567 :
2568 0 : case 0x4:
2569 0 : break;
2570 :
2571 0 : case 0x5:
2572 0 : break;
2573 :
2574 0 : case 0x6:
2575 0 : break;
2576 :
2577 0 : case 0x7:
2578 0 : break;
2579 :
2580 0 : case 0x8:
2581 0 : break;
2582 :
2583 0 : case 0x9:
2584 0 : break;
2585 :
2586 0 : case 0xA:
2587 0 : break;
2588 :
2589 0 : case 0xB:
2590 0 : break;
2591 :
2592 0 : case 0xC:
2593 0 : break;
2594 :
2595 0 : case 0xD:
2596 0 : break;
2597 :
2598 0 : case 0xE:
2599 0 : break;
2600 :
2601 0 : default:
2602 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
2603 : }
2604 : }
2605 0 : return NDR_ERR_SUCCESS;
2606 : }
2607 :
2608 0 : static enum ndr_err_code ndr_pull_dcerpc_rts_cmds(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_rts_cmds *r)
2609 : {
2610 0 : uint32_t level;
2611 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2612 0 : if (ndr_flags & NDR_SCALARS) {
2613 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
2614 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
2615 0 : NDR_CHECK(ndr_pull_union_align(ndr, 4));
2616 0 : switch (level) {
2617 0 : case 0x0: {
2618 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
2619 0 : break; }
2620 :
2621 0 : case 0x1: {
2622 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
2623 0 : break; }
2624 :
2625 0 : case 0x2: {
2626 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
2627 0 : break; }
2628 :
2629 0 : case 0x3: {
2630 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
2631 0 : break; }
2632 :
2633 0 : case 0x4: {
2634 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
2635 0 : break; }
2636 :
2637 0 : case 0x5: {
2638 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
2639 0 : break; }
2640 :
2641 0 : case 0x6: {
2642 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
2643 0 : break; }
2644 :
2645 0 : case 0x7: {
2646 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
2647 0 : break; }
2648 :
2649 0 : case 0x8: {
2650 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
2651 0 : break; }
2652 :
2653 0 : case 0x9: {
2654 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
2655 0 : break; }
2656 :
2657 0 : case 0xA: {
2658 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
2659 0 : break; }
2660 :
2661 0 : case 0xB: {
2662 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
2663 0 : break; }
2664 :
2665 0 : case 0xC: {
2666 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
2667 0 : break; }
2668 :
2669 0 : case 0xD: {
2670 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
2671 0 : break; }
2672 :
2673 0 : case 0xE: {
2674 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
2675 0 : break; }
2676 :
2677 0 : default:
2678 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
2679 : }
2680 : }
2681 0 : if (ndr_flags & NDR_BUFFERS) {
2682 0 : if (!(ndr_flags & NDR_SCALARS)) {
2683 : /* We didn't get it above, and the token is not needed after this. */
2684 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
2685 : }
2686 0 : switch (level) {
2687 0 : case 0x0:
2688 0 : break;
2689 :
2690 0 : case 0x1:
2691 0 : break;
2692 :
2693 0 : case 0x2:
2694 0 : break;
2695 :
2696 0 : case 0x3:
2697 0 : break;
2698 :
2699 0 : case 0x4:
2700 0 : break;
2701 :
2702 0 : case 0x5:
2703 0 : break;
2704 :
2705 0 : case 0x6:
2706 0 : break;
2707 :
2708 0 : case 0x7:
2709 0 : break;
2710 :
2711 0 : case 0x8:
2712 0 : break;
2713 :
2714 0 : case 0x9:
2715 0 : break;
2716 :
2717 0 : case 0xA:
2718 0 : break;
2719 :
2720 0 : case 0xB:
2721 0 : break;
2722 :
2723 0 : case 0xC:
2724 0 : break;
2725 :
2726 0 : case 0xD:
2727 0 : break;
2728 :
2729 0 : case 0xE:
2730 0 : break;
2731 :
2732 0 : default:
2733 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
2734 : }
2735 : }
2736 0 : return NDR_ERR_SUCCESS;
2737 : }
2738 :
2739 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmds(struct ndr_print *ndr, const char *name, const union dcerpc_rts_cmds *r)
2740 : {
2741 0 : uint32_t level;
2742 0 : level = ndr_print_steal_switch_value(ndr, r);
2743 0 : ndr_print_union(ndr, name, level, "dcerpc_rts_cmds");
2744 0 : switch (level) {
2745 0 : case 0x0:
2746 0 : ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, "ReceiveWindowSize", &r->ReceiveWindowSize);
2747 0 : break;
2748 :
2749 0 : case 0x1:
2750 0 : ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, "FlowControlAck", &r->FlowControlAck);
2751 0 : break;
2752 :
2753 0 : case 0x2:
2754 0 : ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, "ConnectionTimeout", &r->ConnectionTimeout);
2755 0 : break;
2756 :
2757 0 : case 0x3:
2758 0 : ndr_print_dcerpc_rts_cmd_Cookie(ndr, "Cookie", &r->Cookie);
2759 0 : break;
2760 :
2761 0 : case 0x4:
2762 0 : ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, "ChannelLifetime", &r->ChannelLifetime);
2763 0 : break;
2764 :
2765 0 : case 0x5:
2766 0 : ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, "ClientKeepalive", &r->ClientKeepalive);
2767 0 : break;
2768 :
2769 0 : case 0x6:
2770 0 : ndr_print_dcerpc_rts_cmd_Version(ndr, "Version", &r->Version);
2771 0 : break;
2772 :
2773 0 : case 0x7:
2774 0 : ndr_print_dcerpc_rts_cmd_Empty(ndr, "Empty", &r->Empty);
2775 0 : break;
2776 :
2777 0 : case 0x8:
2778 0 : ndr_print_dcerpc_rts_cmd_Padding(ndr, "Padding", &r->Padding);
2779 0 : break;
2780 :
2781 0 : case 0x9:
2782 0 : ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, "NegativeANCE", &r->NegativeANCE);
2783 0 : break;
2784 :
2785 0 : case 0xA:
2786 0 : ndr_print_dcerpc_rts_cmd_ANCE(ndr, "ANCE", &r->ANCE);
2787 0 : break;
2788 :
2789 0 : case 0xB:
2790 0 : ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
2791 0 : break;
2792 :
2793 0 : case 0xC:
2794 0 : ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, "AssociationGroupId", &r->AssociationGroupId);
2795 0 : break;
2796 :
2797 0 : case 0xD:
2798 0 : ndr_print_dcerpc_rts_cmd_Destination(ndr, "Destination", &r->Destination);
2799 0 : break;
2800 :
2801 0 : case 0xE:
2802 0 : ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, "PingTrafficSentNotify", &r->PingTrafficSentNotify);
2803 0 : break;
2804 :
2805 0 : default:
2806 0 : ndr_print_bad_level(ndr, name, level);
2807 : }
2808 0 : }
2809 :
2810 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts_cmd *r)
2811 : {
2812 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2813 0 : if (ndr_flags & NDR_SCALARS) {
2814 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2815 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CommandType));
2816 0 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Command, r->CommandType));
2817 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
2818 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2819 : }
2820 0 : if (ndr_flags & NDR_BUFFERS) {
2821 0 : }
2822 0 : return NDR_ERR_SUCCESS;
2823 : }
2824 :
2825 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts_cmd *r)
2826 : {
2827 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2828 0 : if (ndr_flags & NDR_SCALARS) {
2829 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2830 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CommandType));
2831 0 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Command, r->CommandType));
2832 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
2833 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2834 : }
2835 0 : if (ndr_flags & NDR_BUFFERS) {
2836 0 : }
2837 0 : return NDR_ERR_SUCCESS;
2838 : }
2839 :
2840 0 : static void ndr_print_flags_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts_cmd *r)
2841 : {
2842 0 : ndr_print_dcerpc_rts_cmd(ndr, name, r);
2843 0 : }
2844 :
2845 0 : _PUBLIC_ void ndr_print_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd *r)
2846 : {
2847 0 : ndr_print_struct(ndr, name, "dcerpc_rts_cmd");
2848 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2849 0 : ndr->depth++;
2850 0 : ndr_print_uint32(ndr, "CommandType", r->CommandType);
2851 0 : ndr_print_set_switch_value(ndr, &r->Command, r->CommandType);
2852 0 : ndr_print_dcerpc_rts_cmds(ndr, "Command", &r->Command);
2853 0 : ndr->depth--;
2854 : }
2855 :
2856 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
2857 : {
2858 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
2859 0 : return NDR_ERR_SUCCESS;
2860 : }
2861 :
2862 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
2863 : {
2864 0 : uint16_t v;
2865 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
2866 0 : *r = v;
2867 0 : return NDR_ERR_SUCCESS;
2868 : }
2869 :
2870 0 : _PUBLIC_ void ndr_print_dcerpc_rts_flags(struct ndr_print *ndr, const char *name, uint16_t r)
2871 : {
2872 0 : ndr_print_uint16(ndr, name, r);
2873 0 : ndr->depth++;
2874 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_NONE", RTS_FLAG_NONE, r);
2875 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_PING", RTS_FLAG_PING, r);
2876 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OTHER_CMD", RTS_FLAG_OTHER_CMD, r);
2877 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_RECYCLE_CHANNEL", RTS_FLAG_RECYCLE_CHANNEL, r);
2878 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_IN_CHANNEL", RTS_FLAG_IN_CHANNEL, r);
2879 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OUT_CHANNEL", RTS_FLAG_OUT_CHANNEL, r);
2880 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_EOF", RTS_FLAG_EOF, r);
2881 0 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_ECHO", RTS_FLAG_ECHO, r);
2882 0 : ndr->depth--;
2883 0 : }
2884 :
2885 0 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_rts *r)
2886 : {
2887 0 : uint32_t cntr_Commands_0;
2888 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2889 0 : if (ndr_flags & NDR_SCALARS) {
2890 0 : NDR_CHECK(ndr_push_align(ndr, 4));
2891 0 : NDR_CHECK(ndr_push_dcerpc_rts_flags(ndr, NDR_SCALARS, r->Flags));
2892 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumberOfCommands));
2893 0 : for (cntr_Commands_0 = 0; cntr_Commands_0 < (r->NumberOfCommands); cntr_Commands_0++) {
2894 0 : NDR_CHECK(ndr_push_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
2895 : }
2896 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2897 : }
2898 0 : if (ndr_flags & NDR_BUFFERS) {
2899 0 : }
2900 0 : return NDR_ERR_SUCCESS;
2901 : }
2902 :
2903 0 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_rts *r)
2904 : {
2905 0 : uint32_t size_Commands_0 = 0;
2906 0 : uint32_t cntr_Commands_0;
2907 0 : TALLOC_CTX *_mem_save_Commands_0 = NULL;
2908 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
2909 0 : if (ndr_flags & NDR_SCALARS) {
2910 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
2911 0 : NDR_CHECK(ndr_pull_dcerpc_rts_flags(ndr, NDR_SCALARS, &r->Flags));
2912 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumberOfCommands));
2913 0 : size_Commands_0 = r->NumberOfCommands;
2914 0 : NDR_PULL_ALLOC_N(ndr, r->Commands, size_Commands_0);
2915 0 : _mem_save_Commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
2916 0 : NDR_PULL_SET_MEM_CTX(ndr, r->Commands, 0);
2917 0 : for (cntr_Commands_0 = 0; cntr_Commands_0 < (size_Commands_0); cntr_Commands_0++) {
2918 0 : NDR_CHECK(ndr_pull_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
2919 : }
2920 0 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Commands_0, 0);
2921 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2922 : }
2923 0 : if (ndr_flags & NDR_BUFFERS) {
2924 0 : }
2925 0 : return NDR_ERR_SUCCESS;
2926 : }
2927 :
2928 0 : static void ndr_print_flags_dcerpc_rts(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_rts *r)
2929 : {
2930 0 : ndr_print_dcerpc_rts(ndr, name, r);
2931 0 : }
2932 :
2933 0 : _PUBLIC_ void ndr_print_dcerpc_rts(struct ndr_print *ndr, const char *name, const struct dcerpc_rts *r)
2934 : {
2935 0 : uint32_t cntr_Commands_0;
2936 0 : ndr_print_struct(ndr, name, "dcerpc_rts");
2937 0 : if (r == NULL) { ndr_print_null(ndr); return; }
2938 0 : ndr->depth++;
2939 0 : ndr_print_dcerpc_rts_flags(ndr, "Flags", r->Flags);
2940 0 : ndr_print_uint16(ndr, "NumberOfCommands", r->NumberOfCommands);
2941 0 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "Commands", (uint32_t)(r->NumberOfCommands));
2942 0 : ndr->depth++;
2943 0 : for (cntr_Commands_0 = 0; cntr_Commands_0 < (r->NumberOfCommands); cntr_Commands_0++) {
2944 0 : ndr_print_dcerpc_rts_cmd(ndr, "Commands", &r->Commands[cntr_Commands_0]);
2945 : }
2946 0 : ndr->depth--;
2947 0 : ndr->depth--;
2948 : }
2949 :
2950 2133297 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, ndr_flags_type ndr_flags, enum dcerpc_pkt_type r)
2951 : {
2952 2133297 : NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
2953 2117355 : return NDR_ERR_SUCCESS;
2954 : }
2955 :
2956 2779399 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, ndr_flags_type ndr_flags, enum dcerpc_pkt_type *r)
2957 : {
2958 23886 : uint8_t v;
2959 2779399 : NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
2960 2779399 : *r = v;
2961 2779399 : return NDR_ERR_SUCCESS;
2962 : }
2963 :
2964 248 : _PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
2965 : {
2966 248 : const char *val = NULL;
2967 :
2968 248 : switch (r) {
2969 118 : case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
2970 0 : case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
2971 118 : case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
2972 0 : case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
2973 0 : case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
2974 0 : case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
2975 0 : case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
2976 0 : case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
2977 0 : case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
2978 0 : case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
2979 0 : case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
2980 4 : case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
2981 4 : case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
2982 0 : case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
2983 0 : case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
2984 0 : case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
2985 0 : case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
2986 0 : case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
2987 2 : case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
2988 2 : case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
2989 0 : case DCERPC_PKT_RTS: val = "DCERPC_PKT_RTS"; break;
2990 : }
2991 248 : ndr_print_enum(ndr, name, "ENUM", val, r);
2992 248 : }
2993 :
2994 2125131 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_payload *r)
2995 : {
2996 15942 : uint32_t level;
2997 2125131 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
2998 2125131 : if (ndr_flags & NDR_SCALARS) {
2999 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
3000 2125131 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
3001 2125131 : NDR_CHECK(ndr_push_union_align(ndr, 4));
3002 2125131 : switch (level) {
3003 868718 : case DCERPC_PKT_REQUEST: {
3004 868718 : NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
3005 861754 : break; }
3006 :
3007 0 : case DCERPC_PKT_PING: {
3008 0 : NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
3009 0 : break; }
3010 :
3011 1121923 : case DCERPC_PKT_RESPONSE: {
3012 1121923 : NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
3013 1115274 : break; }
3014 :
3015 2849 : case DCERPC_PKT_FAULT: {
3016 2849 : NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
3017 2503 : break; }
3018 :
3019 0 : case DCERPC_PKT_WORKING: {
3020 0 : NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
3021 0 : break; }
3022 :
3023 0 : case DCERPC_PKT_NOCALL: {
3024 0 : NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
3025 0 : break; }
3026 :
3027 0 : case DCERPC_PKT_REJECT: {
3028 0 : NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
3029 0 : break; }
3030 :
3031 0 : case DCERPC_PKT_ACK: {
3032 0 : NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
3033 0 : break; }
3034 :
3035 0 : case DCERPC_PKT_CL_CANCEL: {
3036 0 : NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
3037 0 : break; }
3038 :
3039 0 : case DCERPC_PKT_FACK: {
3040 0 : NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
3041 0 : break; }
3042 :
3043 0 : case DCERPC_PKT_CANCEL_ACK: {
3044 0 : NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
3045 0 : break; }
3046 :
3047 62381 : case DCERPC_PKT_BIND: {
3048 62381 : NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
3049 61511 : break; }
3050 :
3051 55082 : case DCERPC_PKT_BIND_ACK: {
3052 55082 : NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
3053 54222 : break; }
3054 :
3055 149 : case DCERPC_PKT_BIND_NAK: {
3056 149 : NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
3057 131 : break; }
3058 :
3059 7413 : case DCERPC_PKT_ALTER: {
3060 7413 : NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
3061 7296 : break; }
3062 :
3063 6281 : case DCERPC_PKT_ALTER_RESP: {
3064 6281 : NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
3065 6167 : break; }
3066 :
3067 0 : case DCERPC_PKT_SHUTDOWN: {
3068 0 : NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
3069 0 : break; }
3070 :
3071 14 : case DCERPC_PKT_CO_CANCEL: {
3072 14 : NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
3073 12 : break; }
3074 :
3075 32 : case DCERPC_PKT_ORPHANED: {
3076 32 : NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
3077 30 : break; }
3078 :
3079 289 : case DCERPC_PKT_AUTH3: {
3080 289 : NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
3081 289 : break; }
3082 :
3083 0 : case DCERPC_PKT_RTS: {
3084 0 : NDR_CHECK(ndr_push_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
3085 0 : break; }
3086 :
3087 0 : default:
3088 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
3089 : }
3090 : }
3091 2125131 : if (ndr_flags & NDR_BUFFERS) {
3092 0 : if (!(ndr_flags & NDR_SCALARS)) {
3093 : /* We didn't get it above, and the token is not needed after this. */
3094 0 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
3095 : }
3096 0 : switch (level) {
3097 0 : case DCERPC_PKT_REQUEST:
3098 0 : break;
3099 :
3100 0 : case DCERPC_PKT_PING:
3101 0 : break;
3102 :
3103 0 : case DCERPC_PKT_RESPONSE:
3104 0 : break;
3105 :
3106 0 : case DCERPC_PKT_FAULT:
3107 0 : break;
3108 :
3109 0 : case DCERPC_PKT_WORKING:
3110 0 : break;
3111 :
3112 0 : case DCERPC_PKT_NOCALL:
3113 0 : break;
3114 :
3115 0 : case DCERPC_PKT_REJECT:
3116 0 : break;
3117 :
3118 0 : case DCERPC_PKT_ACK:
3119 0 : break;
3120 :
3121 0 : case DCERPC_PKT_CL_CANCEL:
3122 0 : break;
3123 :
3124 0 : case DCERPC_PKT_FACK:
3125 0 : break;
3126 :
3127 0 : case DCERPC_PKT_CANCEL_ACK:
3128 0 : break;
3129 :
3130 0 : case DCERPC_PKT_BIND:
3131 0 : break;
3132 :
3133 0 : case DCERPC_PKT_BIND_ACK:
3134 0 : break;
3135 :
3136 0 : case DCERPC_PKT_BIND_NAK:
3137 0 : break;
3138 :
3139 0 : case DCERPC_PKT_ALTER:
3140 0 : break;
3141 :
3142 0 : case DCERPC_PKT_ALTER_RESP:
3143 0 : break;
3144 :
3145 0 : case DCERPC_PKT_SHUTDOWN:
3146 0 : break;
3147 :
3148 0 : case DCERPC_PKT_CO_CANCEL:
3149 0 : break;
3150 :
3151 0 : case DCERPC_PKT_ORPHANED:
3152 0 : break;
3153 :
3154 0 : case DCERPC_PKT_AUTH3:
3155 0 : break;
3156 :
3157 0 : case DCERPC_PKT_RTS:
3158 0 : break;
3159 :
3160 0 : default:
3161 0 : return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32, level);
3162 : }
3163 : }
3164 2109189 : return NDR_ERR_SUCCESS;
3165 : }
3166 :
3167 2771131 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_payload *r)
3168 : {
3169 23886 : uint32_t level;
3170 2771131 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3171 2771131 : if (ndr_flags & NDR_SCALARS) {
3172 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
3173 2771131 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
3174 2771131 : NDR_CHECK(ndr_pull_union_align(ndr, 4));
3175 2771131 : switch (level) {
3176 850332 : case DCERPC_PKT_REQUEST: {
3177 850332 : NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
3178 843339 : break; }
3179 :
3180 0 : case DCERPC_PKT_PING: {
3181 0 : NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
3182 0 : break; }
3183 :
3184 1722846 : case DCERPC_PKT_RESPONSE: {
3185 1722846 : NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
3186 1709606 : break; }
3187 :
3188 5694 : case DCERPC_PKT_FAULT: {
3189 5694 : NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
3190 5008 : break; }
3191 :
3192 0 : case DCERPC_PKT_WORKING: {
3193 0 : NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
3194 0 : break; }
3195 :
3196 0 : case DCERPC_PKT_NOCALL: {
3197 0 : NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
3198 0 : break; }
3199 :
3200 0 : case DCERPC_PKT_REJECT: {
3201 0 : NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
3202 0 : break; }
3203 :
3204 0 : case DCERPC_PKT_ACK: {
3205 0 : NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
3206 0 : break; }
3207 :
3208 0 : case DCERPC_PKT_CL_CANCEL: {
3209 0 : NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
3210 0 : break; }
3211 :
3212 0 : case DCERPC_PKT_FACK: {
3213 0 : NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
3214 0 : break; }
3215 :
3216 0 : case DCERPC_PKT_CANCEL_ACK: {
3217 0 : NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
3218 0 : break; }
3219 :
3220 91314 : case DCERPC_PKT_BIND: {
3221 91314 : NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
3222 90436 : break; }
3223 :
3224 81657 : case DCERPC_PKT_BIND_ACK: {
3225 81657 : NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
3226 79953 : break; }
3227 :
3228 230 : case DCERPC_PKT_BIND_NAK: {
3229 230 : NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
3230 194 : break; }
3231 :
3232 6335 : case DCERPC_PKT_ALTER: {
3233 6335 : NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
3234 6218 : break; }
3235 :
3236 12468 : case DCERPC_PKT_ALTER_RESP: {
3237 12468 : NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
3238 12240 : break; }
3239 :
3240 0 : case DCERPC_PKT_SHUTDOWN: {
3241 0 : NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
3242 0 : break; }
3243 :
3244 8 : case DCERPC_PKT_CO_CANCEL: {
3245 8 : NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
3246 6 : break; }
3247 :
3248 17 : case DCERPC_PKT_ORPHANED: {
3249 17 : NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
3250 15 : break; }
3251 :
3252 230 : case DCERPC_PKT_AUTH3: {
3253 230 : NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
3254 230 : break; }
3255 :
3256 0 : case DCERPC_PKT_RTS: {
3257 0 : NDR_CHECK(ndr_pull_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
3258 0 : break; }
3259 :
3260 0 : default:
3261 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
3262 : }
3263 : }
3264 2771131 : if (ndr_flags & NDR_BUFFERS) {
3265 0 : if (!(ndr_flags & NDR_SCALARS)) {
3266 : /* We didn't get it above, and the token is not needed after this. */
3267 0 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
3268 : }
3269 0 : switch (level) {
3270 0 : case DCERPC_PKT_REQUEST:
3271 0 : break;
3272 :
3273 0 : case DCERPC_PKT_PING:
3274 0 : break;
3275 :
3276 0 : case DCERPC_PKT_RESPONSE:
3277 0 : break;
3278 :
3279 0 : case DCERPC_PKT_FAULT:
3280 0 : break;
3281 :
3282 0 : case DCERPC_PKT_WORKING:
3283 0 : break;
3284 :
3285 0 : case DCERPC_PKT_NOCALL:
3286 0 : break;
3287 :
3288 0 : case DCERPC_PKT_REJECT:
3289 0 : break;
3290 :
3291 0 : case DCERPC_PKT_ACK:
3292 0 : break;
3293 :
3294 0 : case DCERPC_PKT_CL_CANCEL:
3295 0 : break;
3296 :
3297 0 : case DCERPC_PKT_FACK:
3298 0 : break;
3299 :
3300 0 : case DCERPC_PKT_CANCEL_ACK:
3301 0 : break;
3302 :
3303 0 : case DCERPC_PKT_BIND:
3304 0 : break;
3305 :
3306 0 : case DCERPC_PKT_BIND_ACK:
3307 0 : break;
3308 :
3309 0 : case DCERPC_PKT_BIND_NAK:
3310 0 : break;
3311 :
3312 0 : case DCERPC_PKT_ALTER:
3313 0 : break;
3314 :
3315 0 : case DCERPC_PKT_ALTER_RESP:
3316 0 : break;
3317 :
3318 0 : case DCERPC_PKT_SHUTDOWN:
3319 0 : break;
3320 :
3321 0 : case DCERPC_PKT_CO_CANCEL:
3322 0 : break;
3323 :
3324 0 : case DCERPC_PKT_ORPHANED:
3325 0 : break;
3326 :
3327 0 : case DCERPC_PKT_AUTH3:
3328 0 : break;
3329 :
3330 0 : case DCERPC_PKT_RTS:
3331 0 : break;
3332 :
3333 0 : default:
3334 0 : return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %"PRIu32" at %s", level, __location__);
3335 : }
3336 : }
3337 2747245 : return NDR_ERR_SUCCESS;
3338 : }
3339 :
3340 248 : _PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
3341 : {
3342 4 : uint32_t level;
3343 248 : level = ndr_print_steal_switch_value(ndr, r);
3344 248 : ndr_print_union(ndr, name, level, "dcerpc_payload");
3345 248 : switch (level) {
3346 118 : case DCERPC_PKT_REQUEST:
3347 118 : ndr_print_dcerpc_request(ndr, "request", &r->request);
3348 118 : break;
3349 :
3350 0 : case DCERPC_PKT_PING:
3351 0 : ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
3352 0 : break;
3353 :
3354 118 : case DCERPC_PKT_RESPONSE:
3355 118 : ndr_print_dcerpc_response(ndr, "response", &r->response);
3356 118 : break;
3357 :
3358 0 : case DCERPC_PKT_FAULT:
3359 0 : ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
3360 0 : break;
3361 :
3362 0 : case DCERPC_PKT_WORKING:
3363 0 : ndr_print_dcerpc_working(ndr, "working", &r->working);
3364 0 : break;
3365 :
3366 0 : case DCERPC_PKT_NOCALL:
3367 0 : ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
3368 0 : break;
3369 :
3370 0 : case DCERPC_PKT_REJECT:
3371 0 : ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
3372 0 : break;
3373 :
3374 0 : case DCERPC_PKT_ACK:
3375 0 : ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
3376 0 : break;
3377 :
3378 0 : case DCERPC_PKT_CL_CANCEL:
3379 0 : ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
3380 0 : break;
3381 :
3382 0 : case DCERPC_PKT_FACK:
3383 0 : ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
3384 0 : break;
3385 :
3386 0 : case DCERPC_PKT_CANCEL_ACK:
3387 0 : ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
3388 0 : break;
3389 :
3390 4 : case DCERPC_PKT_BIND:
3391 4 : ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
3392 4 : break;
3393 :
3394 4 : case DCERPC_PKT_BIND_ACK:
3395 4 : ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
3396 4 : break;
3397 :
3398 0 : case DCERPC_PKT_BIND_NAK:
3399 0 : ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
3400 0 : break;
3401 :
3402 0 : case DCERPC_PKT_ALTER:
3403 0 : ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
3404 0 : break;
3405 :
3406 0 : case DCERPC_PKT_ALTER_RESP:
3407 0 : ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
3408 0 : break;
3409 :
3410 0 : case DCERPC_PKT_SHUTDOWN:
3411 0 : ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
3412 0 : break;
3413 :
3414 2 : case DCERPC_PKT_CO_CANCEL:
3415 2 : ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
3416 2 : break;
3417 :
3418 2 : case DCERPC_PKT_ORPHANED:
3419 2 : ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
3420 2 : break;
3421 :
3422 0 : case DCERPC_PKT_AUTH3:
3423 0 : ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
3424 0 : break;
3425 :
3426 0 : case DCERPC_PKT_RTS:
3427 0 : ndr_print_dcerpc_rts(ndr, "rts", &r->rts);
3428 0 : break;
3429 :
3430 0 : default:
3431 0 : ndr_print_bad_level(ndr, name, level);
3432 : }
3433 248 : }
3434 :
3435 2125131 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_pfc_flags(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t r)
3436 : {
3437 2125131 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
3438 2109189 : return NDR_ERR_SUCCESS;
3439 : }
3440 :
3441 2771131 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_pfc_flags(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *r)
3442 : {
3443 23886 : uint8_t v;
3444 2771131 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
3445 2771131 : *r = v;
3446 2771131 : return NDR_ERR_SUCCESS;
3447 : }
3448 :
3449 248 : _PUBLIC_ void ndr_print_dcerpc_pfc_flags(struct ndr_print *ndr, const char *name, uint8_t r)
3450 : {
3451 248 : ndr_print_uint8(ndr, name, r);
3452 248 : ndr->depth++;
3453 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_FIRST", DCERPC_PFC_FLAG_FIRST, r);
3454 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_LAST", DCERPC_PFC_FLAG_LAST, r);
3455 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING", DCERPC_PFC_FLAG_PENDING_CANCEL_OR_HDR_SIGNING, r);
3456 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_CONC_MPX", DCERPC_PFC_FLAG_CONC_MPX, r);
3457 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_DID_NOT_EXECUTE", DCERPC_PFC_FLAG_DID_NOT_EXECUTE, r);
3458 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_MAYBE", DCERPC_PFC_FLAG_MAYBE, r);
3459 248 : ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "DCERPC_PFC_FLAG_OBJECT_UUID", DCERPC_PFC_FLAG_OBJECT_UUID, r);
3460 248 : ndr->depth--;
3461 248 : }
3462 :
3463 0 : static void ndr_print_flags_ncacn_packet(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ncacn_packet *r)
3464 : {
3465 0 : ndr_print_ncacn_packet(ndr, name, r);
3466 0 : }
3467 :
3468 0 : _PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct ncadg_packet *r)
3469 : {
3470 0 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3471 0 : if (ndr_flags & NDR_SCALARS) {
3472 0 : NDR_CHECK(ndr_push_align(ndr, 4));
3473 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
3474 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
3475 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
3476 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
3477 0 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
3478 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
3479 0 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
3480 0 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
3481 0 : NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
3482 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
3483 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
3484 0 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
3485 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
3486 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
3487 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
3488 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
3489 0 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
3490 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
3491 0 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
3492 0 : NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
3493 0 : NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3494 0 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3495 : }
3496 0 : if (ndr_flags & NDR_BUFFERS) {
3497 0 : }
3498 0 : return NDR_ERR_SUCCESS;
3499 : }
3500 :
3501 0 : _PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct ncadg_packet *r)
3502 : {
3503 0 : uint32_t size_drep_0 = 0;
3504 0 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3505 0 : if (ndr_flags & NDR_SCALARS) {
3506 0 : NDR_CHECK(ndr_pull_align(ndr, 4));
3507 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
3508 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
3509 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
3510 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
3511 0 : size_drep_0 = 3;
3512 0 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
3513 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
3514 0 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
3515 0 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
3516 0 : NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
3517 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
3518 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
3519 0 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
3520 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
3521 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
3522 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
3523 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
3524 0 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
3525 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
3526 0 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
3527 0 : NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
3528 0 : NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
3529 0 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3530 : }
3531 0 : if (ndr_flags & NDR_BUFFERS) {
3532 0 : }
3533 0 : return NDR_ERR_SUCCESS;
3534 : }
3535 :
3536 0 : static void ndr_print_flags_ncadg_packet(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct ncadg_packet *r)
3537 : {
3538 0 : ndr_print_ncadg_packet(ndr, name, r);
3539 0 : }
3540 :
3541 0 : _PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
3542 : {
3543 0 : ndr_print_struct(ndr, name, "ncadg_packet");
3544 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3545 0 : ndr->depth++;
3546 0 : ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
3547 0 : ndr_print_uint8(ndr, "ptype", r->ptype);
3548 0 : ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
3549 0 : ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
3550 0 : ndr_print_array_uint8(ndr, "drep", r->drep, 3);
3551 0 : ndr_print_uint8(ndr, "serial_high", r->serial_high);
3552 0 : ndr_print_GUID(ndr, "object", &r->object);
3553 0 : ndr_print_GUID(ndr, "iface", &r->iface);
3554 0 : ndr_print_GUID(ndr, "activity", &r->activity);
3555 0 : ndr_print_uint32(ndr, "server_boot", r->server_boot);
3556 0 : ndr_print_uint32(ndr, "iface_version", r->iface_version);
3557 0 : ndr_print_uint32(ndr, "seq_num", r->seq_num);
3558 0 : ndr_print_uint16(ndr, "opnum", r->opnum);
3559 0 : ndr_print_uint16(ndr, "ihint", r->ihint);
3560 0 : ndr_print_uint16(ndr, "ahint", r->ahint);
3561 0 : ndr_print_uint16(ndr, "len", r->len);
3562 0 : ndr_print_uint16(ndr, "fragnum", r->fragnum);
3563 0 : ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
3564 0 : ndr_print_uint8(ndr, "serial_low", r->serial_low);
3565 0 : ndr_print_set_switch_value(ndr, &r->u, r->ptype);
3566 0 : ndr_print_dcerpc_payload(ndr, "u", &r->u);
3567 0 : ndr->depth--;
3568 : }
3569 :
3570 27205 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_command(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t r)
3571 : {
3572 27205 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
3573 25990 : return NDR_ERR_SUCCESS;
3574 : }
3575 :
3576 26814 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_command(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *r)
3577 : {
3578 1216 : uint16_t v;
3579 26814 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
3580 26814 : *r = v;
3581 26814 : return NDR_ERR_SUCCESS;
3582 : }
3583 :
3584 1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_command(struct ndr_print *ndr, const char *name, uint16_t r)
3585 : {
3586 1 : ndr_print_uint16(ndr, name, r);
3587 1 : ndr->depth++;
3588 1 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_COMMAND_ENUM", DCERPC_SEC_VT_COMMAND_ENUM, r);
3589 1 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_COMMAND_END", DCERPC_SEC_VT_COMMAND_END, r);
3590 1 : ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "DCERPC_SEC_VT_MUST_PROCESS", DCERPC_SEC_VT_MUST_PROCESS, r);
3591 1 : ndr->depth--;
3592 1 : }
3593 :
3594 9516 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_bitmask1(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t r)
3595 : {
3596 9516 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3597 8909 : return NDR_ERR_SUCCESS;
3598 : }
3599 :
3600 9269 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_bitmask1(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *r)
3601 : {
3602 607 : uint32_t v;
3603 9269 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3604 9269 : *r = v;
3605 9269 : return NDR_ERR_SUCCESS;
3606 : }
3607 :
3608 0 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_bitmask1(struct ndr_print *ndr, const char *name, uint32_t r)
3609 : {
3610 0 : ndr_print_uint32(ndr, name, r);
3611 0 : ndr->depth++;
3612 0 : ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING", DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING, r);
3613 0 : ndr->depth--;
3614 0 : }
3615 :
3616 9523 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_pcontext(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt_pcontext *r)
3617 : {
3618 9523 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3619 9523 : if (ndr_flags & NDR_SCALARS) {
3620 9523 : NDR_CHECK(ndr_push_align(ndr, 4));
3621 9523 : NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
3622 9523 : NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntax));
3623 9523 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3624 : }
3625 9523 : if (ndr_flags & NDR_BUFFERS) {
3626 608 : }
3627 9523 : return NDR_ERR_SUCCESS;
3628 : }
3629 :
3630 9277 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_pcontext(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt_pcontext *r)
3631 : {
3632 9277 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3633 9277 : if (ndr_flags & NDR_SCALARS) {
3634 9277 : NDR_CHECK(ndr_pull_align(ndr, 4));
3635 9277 : NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
3636 9277 : NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntax));
3637 9277 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3638 : }
3639 9277 : if (ndr_flags & NDR_BUFFERS) {
3640 609 : }
3641 9277 : return NDR_ERR_SUCCESS;
3642 : }
3643 :
3644 1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_pcontext(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_pcontext *r)
3645 : {
3646 1 : ndr_print_struct(ndr, name, "dcerpc_sec_vt_pcontext");
3647 1 : if (r == NULL) { ndr_print_null(ndr); return; }
3648 1 : ndr->depth++;
3649 1 : ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
3650 1 : ndr_print_ndr_syntax_id(ndr, "transfer_syntax", &r->transfer_syntax);
3651 1 : ndr->depth--;
3652 : }
3653 :
3654 8166 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_header2(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt_header2 *r)
3655 : {
3656 8166 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3657 8166 : if (ndr_flags & NDR_SCALARS) {
3658 8166 : NDR_CHECK(ndr_push_align(ndr, 4));
3659 8166 : NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
3660 8166 : NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
3661 8166 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
3662 8166 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
3663 8166 : NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
3664 8166 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
3665 8166 : NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
3666 8166 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3667 : }
3668 8166 : if (ndr_flags & NDR_BUFFERS) {
3669 0 : }
3670 8166 : return NDR_ERR_SUCCESS;
3671 : }
3672 :
3673 8268 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_header2(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt_header2 *r)
3674 : {
3675 8268 : uint32_t size_drep_0 = 0;
3676 8268 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3677 8268 : if (ndr_flags & NDR_SCALARS) {
3678 8268 : NDR_CHECK(ndr_pull_align(ndr, 4));
3679 8268 : NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
3680 8268 : NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved1));
3681 8268 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
3682 8268 : size_drep_0 = 4;
3683 8268 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, size_drep_0));
3684 8268 : NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
3685 8268 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
3686 8268 : NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
3687 8268 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3688 : }
3689 8268 : if (ndr_flags & NDR_BUFFERS) {
3690 0 : }
3691 8268 : return NDR_ERR_SUCCESS;
3692 : }
3693 :
3694 0 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_header2(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_header2 *r)
3695 : {
3696 0 : ndr_print_struct(ndr, name, "dcerpc_sec_vt_header2");
3697 0 : if (r == NULL) { ndr_print_null(ndr); return; }
3698 0 : ndr->depth++;
3699 0 : ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
3700 0 : ndr_print_uint8(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
3701 0 : ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
3702 0 : ndr_print_array_uint8(ndr, "drep", r->drep, 4);
3703 0 : ndr_print_uint32(ndr, "call_id", r->call_id);
3704 0 : ndr_print_uint16(ndr, "context_id", r->context_id);
3705 0 : ndr_print_uint16(ndr, "opnum", r->opnum);
3706 0 : ndr->depth--;
3707 : }
3708 :
3709 27205 : static enum ndr_err_code ndr_push_dcerpc_sec_vt_union(struct ndr_push *ndr, ndr_flags_type ndr_flags, const union dcerpc_sec_vt_union *r)
3710 : {
3711 1215 : uint32_t level;
3712 27205 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3713 27205 : if (ndr_flags & NDR_SCALARS) {
3714 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
3715 27205 : NDR_CHECK(ndr_push_steal_switch_value(ndr, r, &level));
3716 27205 : NDR_CHECK(ndr_push_union_align(ndr, 4));
3717 27205 : switch (level) {
3718 9516 : case DCERPC_SEC_VT_COMMAND_BITMASK1: {
3719 10123 : NDR_CHECK(ndr_push_dcerpc_sec_vt_bitmask1(ndr, NDR_SCALARS, r->bitmask1));
3720 8909 : break; }
3721 :
3722 9523 : case DCERPC_SEC_VT_COMMAND_PCONTEXT: {
3723 9523 : NDR_CHECK(ndr_push_dcerpc_sec_vt_pcontext(ndr, NDR_SCALARS, &r->pcontext));
3724 8915 : break; }
3725 :
3726 8166 : case DCERPC_SEC_VT_COMMAND_HEADER2: {
3727 8166 : NDR_CHECK(ndr_push_dcerpc_sec_vt_header2(ndr, NDR_SCALARS, &r->header2));
3728 8166 : break; }
3729 :
3730 0 : default: {
3731 : {
3732 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3733 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3734 0 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_unknown));
3735 0 : ndr->flags = _flags_save_DATA_BLOB;
3736 : }
3737 0 : break; }
3738 :
3739 : }
3740 : }
3741 25990 : return NDR_ERR_SUCCESS;
3742 : }
3743 :
3744 26814 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt_union(struct ndr_pull *ndr, ndr_flags_type ndr_flags, union dcerpc_sec_vt_union *r)
3745 : {
3746 1216 : uint32_t level;
3747 26814 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3748 26814 : if (ndr_flags & NDR_SCALARS) {
3749 : /* This token is not used again (except perhaps below in the NDR_BUFFERS case) */
3750 26814 : NDR_CHECK(ndr_pull_steal_switch_value(ndr, r, &level));
3751 26814 : NDR_CHECK(ndr_pull_union_align(ndr, 4));
3752 26814 : switch (level) {
3753 9269 : case DCERPC_SEC_VT_COMMAND_BITMASK1: {
3754 9876 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_bitmask1(ndr, NDR_SCALARS, &r->bitmask1));
3755 8662 : break; }
3756 :
3757 9277 : case DCERPC_SEC_VT_COMMAND_PCONTEXT: {
3758 9277 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_pcontext(ndr, NDR_SCALARS, &r->pcontext));
3759 8668 : break; }
3760 :
3761 8268 : case DCERPC_SEC_VT_COMMAND_HEADER2: {
3762 8268 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_header2(ndr, NDR_SCALARS, &r->header2));
3763 8268 : break; }
3764 :
3765 0 : default: {
3766 : {
3767 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3768 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3769 0 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_unknown));
3770 0 : ndr->flags = _flags_save_DATA_BLOB;
3771 : }
3772 0 : break; }
3773 :
3774 : }
3775 : }
3776 25598 : return NDR_ERR_SUCCESS;
3777 : }
3778 :
3779 1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_union(struct ndr_print *ndr, const char *name, const union dcerpc_sec_vt_union *r)
3780 : {
3781 1 : uint32_t level;
3782 1 : level = ndr_print_steal_switch_value(ndr, r);
3783 1 : ndr_print_union(ndr, name, level, "dcerpc_sec_vt_union");
3784 1 : switch (level) {
3785 0 : case DCERPC_SEC_VT_COMMAND_BITMASK1:
3786 0 : ndr_print_dcerpc_sec_vt_bitmask1(ndr, "bitmask1", r->bitmask1);
3787 0 : break;
3788 :
3789 1 : case DCERPC_SEC_VT_COMMAND_PCONTEXT:
3790 1 : ndr_print_dcerpc_sec_vt_pcontext(ndr, "pcontext", &r->pcontext);
3791 1 : break;
3792 :
3793 0 : case DCERPC_SEC_VT_COMMAND_HEADER2:
3794 0 : ndr_print_dcerpc_sec_vt_header2(ndr, "header2", &r->header2);
3795 0 : break;
3796 :
3797 0 : default:
3798 : {
3799 0 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3800 0 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3801 0 : ndr_print_DATA_BLOB(ndr, "_unknown", r->_unknown);
3802 0 : ndr->flags = _flags_save_DATA_BLOB;
3803 : }
3804 0 : break;
3805 :
3806 : }
3807 1 : }
3808 :
3809 27205 : static enum ndr_err_code ndr_push_dcerpc_sec_vt(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_vt *r)
3810 : {
3811 27205 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3812 27205 : if (ndr_flags & NDR_SCALARS) {
3813 27205 : NDR_CHECK(ndr_push_align(ndr, 2));
3814 28420 : NDR_CHECK(ndr_push_dcerpc_sec_vt_command(ndr, NDR_SCALARS, r->command));
3815 : {
3816 27205 : libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
3817 27205 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
3818 : {
3819 1215 : struct ndr_push *_ndr_u;
3820 27205 : NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_u, 2, -1));
3821 27205 : NDR_CHECK(ndr_push_set_switch_value(_ndr_u, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM));
3822 27205 : NDR_CHECK(ndr_push_dcerpc_sec_vt_union(_ndr_u, NDR_SCALARS, &r->u));
3823 27205 : NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_u, 2, -1));
3824 : }
3825 27205 : ndr->flags = _flags_save_dcerpc_sec_vt_union;
3826 : }
3827 27205 : NDR_CHECK(ndr_push_trailer_align(ndr, 2));
3828 : }
3829 27205 : if (ndr_flags & NDR_BUFFERS) {
3830 1215 : }
3831 27205 : return NDR_ERR_SUCCESS;
3832 : }
3833 :
3834 26814 : static enum ndr_err_code ndr_pull_dcerpc_sec_vt(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_vt *r)
3835 : {
3836 26814 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3837 26814 : if (ndr_flags & NDR_SCALARS) {
3838 26814 : NDR_CHECK(ndr_pull_align(ndr, 2));
3839 28030 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_command(ndr, NDR_SCALARS, &r->command));
3840 : {
3841 26814 : libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
3842 26814 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
3843 : {
3844 1216 : struct ndr_pull *_ndr_u;
3845 26814 : ssize_t sub_size = -1;
3846 26814 : NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_u, 2, sub_size));
3847 26814 : NDR_CHECK(ndr_pull_set_switch_value(_ndr_u, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM));
3848 26814 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_union(_ndr_u, NDR_SCALARS, &r->u));
3849 26814 : NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_u, 2, sub_size));
3850 : }
3851 26814 : ndr->flags = _flags_save_dcerpc_sec_vt_union;
3852 : }
3853 26814 : NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
3854 : }
3855 26814 : if (ndr_flags & NDR_BUFFERS) {
3856 1216 : }
3857 26814 : return NDR_ERR_SUCCESS;
3858 : }
3859 :
3860 1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt *r)
3861 : {
3862 1 : ndr_print_struct(ndr, name, "dcerpc_sec_vt");
3863 1 : if (r == NULL) { ndr_print_null(ndr); return; }
3864 1 : ndr->depth++;
3865 1 : ndr_print_dcerpc_sec_vt_command(ndr, "command", r->command);
3866 : {
3867 1 : libndr_flags _flags_save_dcerpc_sec_vt_union = ndr->flags;
3868 1 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES);
3869 1 : ndr_print_set_switch_value(ndr, &r->u, r->command & DCERPC_SEC_VT_COMMAND_ENUM);
3870 1 : ndr_print_dcerpc_sec_vt_union(ndr, "u", &r->u);
3871 1 : ndr->flags = _flags_save_dcerpc_sec_vt_union;
3872 : }
3873 1 : ndr->depth--;
3874 : }
3875 :
3876 0 : static void ndr_print_flags_dcerpc_sec_vt_count(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_sec_vt_count *r)
3877 : {
3878 0 : ndr_print_dcerpc_sec_vt_count(ndr, name, r);
3879 0 : }
3880 :
3881 1 : _PUBLIC_ void ndr_print_dcerpc_sec_vt_count(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_vt_count *r)
3882 : {
3883 1 : ndr_print_struct(ndr, name, "dcerpc_sec_vt_count");
3884 1 : if (r == NULL) { ndr_print_null(ndr); return; }
3885 1 : ndr->depth++;
3886 1 : ndr_print_uint16(ndr, "count", r->count);
3887 1 : ndr->depth--;
3888 : }
3889 :
3890 17187 : _PUBLIC_ enum ndr_err_code ndr_push_dcerpc_sec_verification_trailer(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dcerpc_sec_verification_trailer *r)
3891 : {
3892 608 : uint32_t cntr_commands_0;
3893 : {
3894 17187 : libndr_flags _flags_save_STRUCT = ndr->flags;
3895 17187 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3896 17187 : NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
3897 17187 : if (ndr_flags & NDR_SCALARS) {
3898 17187 : NDR_CHECK(ndr_push_align(ndr, 4));
3899 : {
3900 17187 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3901 17187 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3902 17187 : NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
3903 17187 : ndr->flags = _flags_save_DATA_BLOB;
3904 : }
3905 17187 : NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, DCERPC_SEC_VT_MAGIC, 8));
3906 17187 : NDR_CHECK(ndr_push_dcerpc_sec_vt_count(ndr, NDR_SCALARS, &r->count));
3907 44392 : for (cntr_commands_0 = 0; cntr_commands_0 < (r->count.count); cntr_commands_0++) {
3908 27205 : NDR_CHECK(ndr_push_dcerpc_sec_vt(ndr, NDR_SCALARS, &r->commands[cntr_commands_0]));
3909 : }
3910 17187 : NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3911 : }
3912 17187 : if (ndr_flags & NDR_BUFFERS) {
3913 608 : }
3914 17187 : ndr->flags = _flags_save_STRUCT;
3915 : }
3916 17187 : return NDR_ERR_SUCCESS;
3917 : }
3918 :
3919 17029 : _PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_sec_verification_trailer(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dcerpc_sec_verification_trailer *r)
3920 : {
3921 17029 : uint32_t size_magic_0 = 0;
3922 17029 : uint32_t size_commands_0 = 0;
3923 609 : uint32_t cntr_commands_0;
3924 17029 : TALLOC_CTX *_mem_save_commands_0 = NULL;
3925 : {
3926 17029 : libndr_flags _flags_save_STRUCT = ndr->flags;
3927 17029 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3928 17029 : NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
3929 17029 : if (ndr_flags & NDR_SCALARS) {
3930 17029 : NDR_CHECK(ndr_pull_align(ndr, 4));
3931 : {
3932 17029 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3933 17029 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3934 17029 : NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
3935 17029 : ndr->flags = _flags_save_DATA_BLOB;
3936 : }
3937 17029 : size_magic_0 = 8;
3938 17029 : NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->magic, size_magic_0));
3939 17029 : NDR_CHECK(ndr_pull_dcerpc_sec_vt_count(ndr, NDR_SCALARS, &r->count));
3940 17029 : size_commands_0 = r->count.count;
3941 17029 : NDR_PULL_ALLOC_N(ndr, r->commands, size_commands_0);
3942 17029 : _mem_save_commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
3943 17029 : NDR_PULL_SET_MEM_CTX(ndr, r->commands, 0);
3944 43843 : for (cntr_commands_0 = 0; cntr_commands_0 < (size_commands_0); cntr_commands_0++) {
3945 26814 : NDR_CHECK(ndr_pull_dcerpc_sec_vt(ndr, NDR_SCALARS, &r->commands[cntr_commands_0]));
3946 : }
3947 17029 : NDR_PULL_SET_MEM_CTX(ndr, _mem_save_commands_0, 0);
3948 17029 : NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3949 : }
3950 17029 : if (ndr_flags & NDR_BUFFERS) {
3951 609 : }
3952 17029 : ndr->flags = _flags_save_STRUCT;
3953 : }
3954 17029 : return NDR_ERR_SUCCESS;
3955 : }
3956 :
3957 0 : static void ndr_print_flags_dcerpc_sec_verification_trailer(struct ndr_print *ndr, const char *name, ndr_flags_type unused, const struct dcerpc_sec_verification_trailer *r)
3958 : {
3959 0 : ndr_print_dcerpc_sec_verification_trailer(ndr, name, r);
3960 0 : }
3961 :
3962 1 : _PUBLIC_ void ndr_print_dcerpc_sec_verification_trailer(struct ndr_print *ndr, const char *name, const struct dcerpc_sec_verification_trailer *r)
3963 : {
3964 1 : uint32_t cntr_commands_0;
3965 1 : ndr_print_struct(ndr, name, "dcerpc_sec_verification_trailer");
3966 1 : if (r == NULL) { ndr_print_null(ndr); return; }
3967 : {
3968 1 : libndr_flags _flags_save_STRUCT = ndr->flags;
3969 1 : ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3970 1 : ndr->depth++;
3971 : {
3972 1 : libndr_flags _flags_save_DATA_BLOB = ndr->flags;
3973 1 : ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3974 1 : ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
3975 1 : ndr->flags = _flags_save_DATA_BLOB;
3976 : }
3977 1 : ndr_print_array_uint8(ndr, "magic", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?DCERPC_SEC_VT_MAGIC:r->magic, 8);
3978 1 : ndr_print_dcerpc_sec_vt_count(ndr, "count", &r->count);
3979 1 : ndr->print(ndr, "%s: ARRAY(%"PRIu32")", "commands", (uint32_t)(r->count.count));
3980 1 : ndr->depth++;
3981 2 : for (cntr_commands_0 = 0; cntr_commands_0 < (r->count.count); cntr_commands_0++) {
3982 1 : ndr_print_dcerpc_sec_vt(ndr, "commands", &r->commands[cntr_commands_0]);
3983 : }
3984 1 : ndr->depth--;
3985 1 : ndr->depth--;
3986 1 : ndr->flags = _flags_save_STRUCT;
3987 : }
3988 : }
3989 :
3990 : #ifndef SKIP_NDR_TABLE_dcerpc
3991 : static const struct ndr_interface_public_struct dcerpc_public_structs[] = {
3992 : {
3993 : .name = "dcerpc_bind",
3994 : .struct_size = sizeof(struct dcerpc_bind ),
3995 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind,
3996 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind,
3997 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind,
3998 : },
3999 : {
4000 : .name = "dcerpc_bind_nak_version",
4001 : .struct_size = sizeof(struct dcerpc_bind_nak_version ),
4002 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind_nak_version,
4003 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind_nak_version,
4004 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind_nak_version,
4005 : },
4006 : {
4007 : .name = "dcerpc_bind_nak",
4008 : .struct_size = sizeof(struct dcerpc_bind_nak ),
4009 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_bind_nak,
4010 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_bind_nak,
4011 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_bind_nak,
4012 : },
4013 : {
4014 : .name = "dcerpc_auth",
4015 : .struct_size = sizeof(struct dcerpc_auth ),
4016 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_auth,
4017 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_auth,
4018 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_auth,
4019 : },
4020 : {
4021 : .name = "dcerpc_auth3",
4022 : .struct_size = sizeof(struct dcerpc_auth3 ),
4023 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_auth3,
4024 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_auth3,
4025 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_auth3,
4026 : },
4027 : {
4028 : .name = "dcerpc_orphaned",
4029 : .struct_size = sizeof(struct dcerpc_orphaned ),
4030 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_orphaned,
4031 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_orphaned,
4032 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_orphaned,
4033 : },
4034 : {
4035 : .name = "dcerpc_co_cancel",
4036 : .struct_size = sizeof(struct dcerpc_co_cancel ),
4037 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_co_cancel,
4038 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_co_cancel,
4039 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_co_cancel,
4040 : },
4041 : {
4042 : .name = "dcerpc_cl_cancel",
4043 : .struct_size = sizeof(struct dcerpc_cl_cancel ),
4044 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_cl_cancel,
4045 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_cl_cancel,
4046 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_cl_cancel,
4047 : },
4048 : {
4049 : .name = "dcerpc_cancel_ack",
4050 : .struct_size = sizeof(struct dcerpc_cancel_ack ),
4051 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_cancel_ack,
4052 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_cancel_ack,
4053 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_cancel_ack,
4054 : },
4055 : {
4056 : .name = "dcerpc_fack",
4057 : .struct_size = sizeof(struct dcerpc_fack ),
4058 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_fack,
4059 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_fack,
4060 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_fack,
4061 : },
4062 : {
4063 : .name = "dcerpc_ack",
4064 : .struct_size = sizeof(struct dcerpc_ack ),
4065 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_ack,
4066 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_ack,
4067 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_ack,
4068 : },
4069 : {
4070 : .name = "dcerpc_ping",
4071 : .struct_size = sizeof(struct dcerpc_ping ),
4072 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_ping,
4073 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_ping,
4074 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_ping,
4075 : },
4076 : {
4077 : .name = "dcerpc_shutdown",
4078 : .struct_size = sizeof(struct dcerpc_shutdown ),
4079 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_shutdown,
4080 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_shutdown,
4081 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_shutdown,
4082 : },
4083 : {
4084 : .name = "dcerpc_working",
4085 : .struct_size = sizeof(struct dcerpc_working ),
4086 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_working,
4087 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_working,
4088 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_working,
4089 : },
4090 : {
4091 : .name = "RTSCookie",
4092 : .struct_size = sizeof(struct RTSCookie ),
4093 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_RTSCookie,
4094 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_RTSCookie,
4095 : .ndr_print = (ndr_print_function_t) ndr_print_flags_RTSCookie,
4096 : },
4097 : {
4098 : .name = "ClientAddress",
4099 : .struct_size = sizeof(struct ClientAddress ),
4100 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ClientAddress,
4101 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ClientAddress,
4102 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ClientAddress,
4103 : },
4104 : {
4105 : .name = "FlowControlAcknowledgment",
4106 : .struct_size = sizeof(struct FlowControlAcknowledgment ),
4107 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_FlowControlAcknowledgment,
4108 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_FlowControlAcknowledgment,
4109 : .ndr_print = (ndr_print_function_t) ndr_print_flags_FlowControlAcknowledgment,
4110 : },
4111 : {
4112 : .name = "dcerpc_rts_cmd_ReceiveWindowSize",
4113 : .struct_size = sizeof(struct dcerpc_rts_cmd_ReceiveWindowSize ),
4114 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ReceiveWindowSize,
4115 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize,
4116 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ReceiveWindowSize,
4117 : },
4118 : {
4119 : .name = "dcerpc_rts_cmd_FlowControlAck",
4120 : .struct_size = sizeof(struct dcerpc_rts_cmd_FlowControlAck ),
4121 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_FlowControlAck,
4122 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_FlowControlAck,
4123 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_FlowControlAck,
4124 : },
4125 : {
4126 : .name = "dcerpc_rts_cmd_ConnectionTimeout",
4127 : .struct_size = sizeof(struct dcerpc_rts_cmd_ConnectionTimeout ),
4128 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ConnectionTimeout,
4129 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ConnectionTimeout,
4130 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ConnectionTimeout,
4131 : },
4132 : {
4133 : .name = "dcerpc_rts_cmd_Cookie",
4134 : .struct_size = sizeof(struct dcerpc_rts_cmd_Cookie ),
4135 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Cookie,
4136 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Cookie,
4137 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Cookie,
4138 : },
4139 : {
4140 : .name = "dcerpc_rts_cmd_ChannelLifetime",
4141 : .struct_size = sizeof(struct dcerpc_rts_cmd_ChannelLifetime ),
4142 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ChannelLifetime,
4143 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ChannelLifetime,
4144 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ChannelLifetime,
4145 : },
4146 : {
4147 : .name = "dcerpc_rts_cmd_ClientKeepalive",
4148 : .struct_size = sizeof(struct dcerpc_rts_cmd_ClientKeepalive ),
4149 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ClientKeepalive,
4150 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ClientKeepalive,
4151 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ClientKeepalive,
4152 : },
4153 : {
4154 : .name = "dcerpc_rts_cmd_Version",
4155 : .struct_size = sizeof(struct dcerpc_rts_cmd_Version ),
4156 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Version,
4157 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Version,
4158 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Version,
4159 : },
4160 : {
4161 : .name = "dcerpc_rts_cmd_Empty",
4162 : .struct_size = sizeof(struct dcerpc_rts_cmd_Empty ),
4163 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Empty,
4164 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Empty,
4165 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Empty,
4166 : },
4167 : {
4168 : .name = "dcerpc_rts_cmd_Padding",
4169 : .struct_size = sizeof(struct dcerpc_rts_cmd_Padding ),
4170 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Padding,
4171 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Padding,
4172 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Padding,
4173 : },
4174 : {
4175 : .name = "dcerpc_rts_cmd_NegativeANCE",
4176 : .struct_size = sizeof(struct dcerpc_rts_cmd_NegativeANCE ),
4177 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_NegativeANCE,
4178 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_NegativeANCE,
4179 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_NegativeANCE,
4180 : },
4181 : {
4182 : .name = "dcerpc_rts_cmd_ANCE",
4183 : .struct_size = sizeof(struct dcerpc_rts_cmd_ANCE ),
4184 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ANCE,
4185 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ANCE,
4186 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ANCE,
4187 : },
4188 : {
4189 : .name = "dcerpc_rts_cmd_ClientAddress",
4190 : .struct_size = sizeof(struct dcerpc_rts_cmd_ClientAddress ),
4191 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_ClientAddress,
4192 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_ClientAddress,
4193 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_ClientAddress,
4194 : },
4195 : {
4196 : .name = "dcerpc_rts_cmd_AssociationGroupId",
4197 : .struct_size = sizeof(struct dcerpc_rts_cmd_AssociationGroupId ),
4198 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_AssociationGroupId,
4199 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_AssociationGroupId,
4200 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_AssociationGroupId,
4201 : },
4202 : {
4203 : .name = "dcerpc_rts_cmd_Destination",
4204 : .struct_size = sizeof(struct dcerpc_rts_cmd_Destination ),
4205 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_Destination,
4206 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_Destination,
4207 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_Destination,
4208 : },
4209 : {
4210 : .name = "dcerpc_rts_cmd_PingTrafficSentNotify",
4211 : .struct_size = sizeof(struct dcerpc_rts_cmd_PingTrafficSentNotify ),
4212 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify,
4213 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify,
4214 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd_PingTrafficSentNotify,
4215 : },
4216 : {
4217 : .name = "dcerpc_rts_cmd",
4218 : .struct_size = sizeof(struct dcerpc_rts_cmd ),
4219 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts_cmd,
4220 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts_cmd,
4221 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts_cmd,
4222 : },
4223 : {
4224 : .name = "dcerpc_rts",
4225 : .struct_size = sizeof(struct dcerpc_rts ),
4226 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_rts,
4227 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_rts,
4228 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_rts,
4229 : },
4230 : {
4231 : .name = "ncacn_packet",
4232 : .struct_size = sizeof(struct ncacn_packet ),
4233 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ncacn_packet,
4234 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ncacn_packet,
4235 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ncacn_packet,
4236 : },
4237 : {
4238 : .name = "ncadg_packet",
4239 : .struct_size = sizeof(struct ncadg_packet ),
4240 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_ncadg_packet,
4241 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_ncadg_packet,
4242 : .ndr_print = (ndr_print_function_t) ndr_print_flags_ncadg_packet,
4243 : },
4244 : {
4245 : .name = "dcerpc_sec_vt_count",
4246 : .struct_size = sizeof(struct dcerpc_sec_vt_count ),
4247 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_sec_vt_count,
4248 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_sec_vt_count,
4249 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_sec_vt_count,
4250 : },
4251 : {
4252 : .name = "dcerpc_sec_verification_trailer",
4253 : .struct_size = sizeof(struct dcerpc_sec_verification_trailer ),
4254 : .ndr_push = (ndr_push_flags_fn_t) ndr_push_dcerpc_sec_verification_trailer,
4255 : .ndr_pull = (ndr_pull_flags_fn_t) ndr_pull_dcerpc_sec_verification_trailer,
4256 : .ndr_print = (ndr_print_function_t) ndr_print_flags_dcerpc_sec_verification_trailer,
4257 : },
4258 : { .name = NULL }
4259 : };
4260 :
4261 : static const struct ndr_interface_call dcerpc_calls[] = {
4262 : { .name = NULL }
4263 : };
4264 :
4265 : static const char * const dcerpc_endpoint_strings[] = {
4266 : "ncacn_np:[\\pipe\\dcerpc]",
4267 : };
4268 :
4269 : static const struct ndr_interface_string_array dcerpc_endpoints = {
4270 : .count = 1,
4271 : .names = dcerpc_endpoint_strings
4272 : };
4273 :
4274 : static const char * const dcerpc_authservice_strings[] = {
4275 : "host",
4276 : };
4277 :
4278 : static const struct ndr_interface_string_array dcerpc_authservices = {
4279 : .count = 1,
4280 : .names = dcerpc_authservice_strings
4281 : };
4282 :
4283 :
4284 : const struct ndr_interface_table ndr_table_dcerpc = {
4285 : .name = "dcerpc",
4286 : .num_calls = 0,
4287 : .calls = dcerpc_calls,
4288 : .num_public_structs = 38,
4289 : .public_structs = dcerpc_public_structs,
4290 : .endpoints = &dcerpc_endpoints,
4291 : .authservices = &dcerpc_authservices
4292 : };
4293 :
4294 : #endif /* SKIP_NDR_TABLE_dcerpc */
|
