← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/ndr_dcerpc.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/librpc/gen_ndr/ndr_dcerpc.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "librpc/gen_ndr/ndr_dcerpc.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
static enum ndr_err_code ndr_push_dcerpc_ctx_list(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ctx_list *r)
 
8
{
 
9
        uint32_t cntr_transfer_syntaxes_0;
 
10
        if (ndr_flags & NDR_SCALARS) {
 
11
                NDR_CHECK(ndr_push_align(ndr, 4));
 
12
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 
13
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_transfer_syntaxes));
 
14
                NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
 
15
                for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
 
16
                        NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
 
17
                }
 
18
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
19
        }
 
20
        if (ndr_flags & NDR_BUFFERS) {
 
21
        }
 
22
        return NDR_ERR_SUCCESS;
 
23
}
 
24
 
 
25
static enum ndr_err_code ndr_pull_dcerpc_ctx_list(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ctx_list *r)
 
26
{
 
27
        uint32_t cntr_transfer_syntaxes_0;
 
28
        TALLOC_CTX *_mem_save_transfer_syntaxes_0;
 
29
        if (ndr_flags & NDR_SCALARS) {
 
30
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
31
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 
32
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_transfer_syntaxes));
 
33
                NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->abstract_syntax));
 
34
                NDR_PULL_ALLOC_N(ndr, r->transfer_syntaxes, r->num_transfer_syntaxes);
 
35
                _mem_save_transfer_syntaxes_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
36
                NDR_PULL_SET_MEM_CTX(ndr, r->transfer_syntaxes, 0);
 
37
                for (cntr_transfer_syntaxes_0 = 0; cntr_transfer_syntaxes_0 < r->num_transfer_syntaxes; cntr_transfer_syntaxes_0++) {
 
38
                        NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->transfer_syntaxes[cntr_transfer_syntaxes_0]));
 
39
                }
 
40
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transfer_syntaxes_0, 0);
 
41
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
42
        }
 
43
        if (ndr_flags & NDR_BUFFERS) {
 
44
        }
 
45
        return NDR_ERR_SUCCESS;
 
46
}
 
47
 
 
48
_PUBLIC_ void ndr_print_dcerpc_ctx_list(struct ndr_print *ndr, const char *name, const struct dcerpc_ctx_list *r)
 
49
{
 
50
        uint32_t cntr_transfer_syntaxes_0;
 
51
        ndr_print_struct(ndr, name, "dcerpc_ctx_list");
 
52
        if (r == NULL) { ndr_print_null(ndr); return; }
 
53
        ndr->depth++;
 
54
        ndr_print_uint16(ndr, "context_id", r->context_id);
 
55
        ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
 
56
        ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
 
57
        ndr->print(ndr, "%s: ARRAY(%d)", "transfer_syntaxes", (int)r->num_transfer_syntaxes);
 
58
        ndr->depth++;
 
59
        for (cntr_transfer_syntaxes_0=0;cntr_transfer_syntaxes_0<r->num_transfer_syntaxes;cntr_transfer_syntaxes_0++) {
 
60
                ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
 
61
        }
 
62
        ndr->depth--;
 
63
        ndr->depth--;
 
64
}
 
65
 
 
66
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind *r)
 
67
{
 
68
        uint32_t cntr_ctx_list_0;
 
69
        if (ndr_flags & NDR_SCALARS) {
 
70
                NDR_CHECK(ndr_push_align(ndr, 4));
 
71
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
 
72
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
 
73
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
 
74
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
 
75
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
 
76
                        NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 
77
                }
 
78
                {
 
79
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
80
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
81
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 
82
                        ndr->flags = _flags_save_DATA_BLOB;
 
83
                }
 
84
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
85
        }
 
86
        if (ndr_flags & NDR_BUFFERS) {
 
87
        }
 
88
        return NDR_ERR_SUCCESS;
 
89
}
 
90
 
 
91
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind *r)
 
92
{
 
93
        uint32_t cntr_ctx_list_0;
 
94
        TALLOC_CTX *_mem_save_ctx_list_0;
 
95
        if (ndr_flags & NDR_SCALARS) {
 
96
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
97
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 
98
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 
99
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 
100
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
 
101
                NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_contexts);
 
102
                _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
103
                NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 
104
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
 
105
                        NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 
106
                }
 
107
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 
108
                {
 
109
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
110
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
111
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 
112
                        ndr->flags = _flags_save_DATA_BLOB;
 
113
                }
 
114
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
115
        }
 
116
        if (ndr_flags & NDR_BUFFERS) {
 
117
        }
 
118
        return NDR_ERR_SUCCESS;
 
119
}
 
120
 
 
121
_PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
 
122
{
 
123
        uint32_t cntr_ctx_list_0;
 
124
        ndr_print_struct(ndr, name, "dcerpc_bind");
 
125
        if (r == NULL) { ndr_print_null(ndr); return; }
 
126
        ndr->depth++;
 
127
        ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 
128
        ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 
129
        ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 
130
        ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
 
131
        ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_contexts);
 
132
        ndr->depth++;
 
133
        for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_contexts;cntr_ctx_list_0++) {
 
134
                ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 
135
        }
 
136
        ndr->depth--;
 
137
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 
138
        ndr->depth--;
 
139
}
 
140
 
 
141
static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_empty *r)
 
142
{
 
143
        if (ndr_flags & NDR_SCALARS) {
 
144
                NDR_CHECK(ndr_push_align(ndr, 1));
 
145
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
146
        }
 
147
        if (ndr_flags & NDR_BUFFERS) {
 
148
        }
 
149
        return NDR_ERR_SUCCESS;
 
150
}
 
151
 
 
152
static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_empty *r)
 
153
{
 
154
        if (ndr_flags & NDR_SCALARS) {
 
155
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
156
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
157
        }
 
158
        if (ndr_flags & NDR_BUFFERS) {
 
159
        }
 
160
        return NDR_ERR_SUCCESS;
 
161
}
 
162
 
 
163
_PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
 
164
{
 
165
        ndr_print_struct(ndr, name, "dcerpc_empty");
 
166
        if (r == NULL) { ndr_print_null(ndr); return; }
 
167
        ndr->depth++;
 
168
        ndr->depth--;
 
169
}
 
170
 
 
171
static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, int ndr_flags, const union dcerpc_object *r)
 
172
{
 
173
        if (ndr_flags & NDR_SCALARS) {
 
174
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
175
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
176
                switch (level) {
 
177
                        default: {
 
178
                                NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 
179
                        break; }
 
180
 
 
181
                        case LIBNDR_FLAG_OBJECT_PRESENT: {
 
182
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
 
183
                        break; }
 
184
 
 
185
                }
 
186
        }
 
187
        if (ndr_flags & NDR_BUFFERS) {
 
188
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
189
                switch (level) {
 
190
                        default:
 
191
                        break;
 
192
 
 
193
                        case LIBNDR_FLAG_OBJECT_PRESENT:
 
194
                        break;
 
195
 
 
196
                }
 
197
        }
 
198
        return NDR_ERR_SUCCESS;
 
199
}
 
200
 
 
201
static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, int ndr_flags, union dcerpc_object *r)
 
202
{
 
203
        uint32_t level;
 
204
        level = ndr_pull_get_switch_value(ndr, r);
 
205
        if (ndr_flags & NDR_SCALARS) {
 
206
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
207
                switch (level) {
 
208
                        default: {
 
209
                                NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
 
210
                        break; }
 
211
 
 
212
                        case LIBNDR_FLAG_OBJECT_PRESENT: {
 
213
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
 
214
                        break; }
 
215
 
 
216
                }
 
217
        }
 
218
        if (ndr_flags & NDR_BUFFERS) {
 
219
                switch (level) {
 
220
                        default:
 
221
                        break;
 
222
 
 
223
                        case LIBNDR_FLAG_OBJECT_PRESENT:
 
224
                        break;
 
225
 
 
226
                }
 
227
        }
 
228
        return NDR_ERR_SUCCESS;
 
229
}
 
230
 
 
231
_PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
 
232
{
 
233
        uint32_t level;
 
234
        level = ndr_print_get_switch_value(ndr, r);
 
235
        ndr_print_union(ndr, name, level, "dcerpc_object");
 
236
        switch (level) {
 
237
                default:
 
238
                        ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
 
239
                break;
 
240
 
 
241
                case LIBNDR_FLAG_OBJECT_PRESENT:
 
242
                        ndr_print_GUID(ndr, "object", &r->object);
 
243
                break;
 
244
 
 
245
        }
 
246
}
 
247
 
 
248
static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_request *r)
 
249
{
 
250
        if (ndr_flags & NDR_SCALARS) {
 
251
                NDR_CHECK(ndr_push_align(ndr, 4));
 
252
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 
253
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 
254
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
 
255
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 
256
                NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 
257
                {
 
258
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
259
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 
260
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
261
                        ndr->flags = _flags_save_DATA_BLOB;
 
262
                }
 
263
                {
 
264
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
265
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
266
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 
267
                        ndr->flags = _flags_save_DATA_BLOB;
 
268
                }
 
269
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
270
        }
 
271
        if (ndr_flags & NDR_BUFFERS) {
 
272
        }
 
273
        return NDR_ERR_SUCCESS;
 
274
}
 
275
 
 
276
static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_request *r)
 
277
{
 
278
        if (ndr_flags & NDR_SCALARS) {
 
279
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
280
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 
281
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 
282
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 
283
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
 
284
                NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
 
285
                {
 
286
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
287
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 
288
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
289
                        ndr->flags = _flags_save_DATA_BLOB;
 
290
                }
 
291
                {
 
292
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
293
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
294
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 
295
                        ndr->flags = _flags_save_DATA_BLOB;
 
296
                }
 
297
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
298
        }
 
299
        if (ndr_flags & NDR_BUFFERS) {
 
300
        }
 
301
        return NDR_ERR_SUCCESS;
 
302
}
 
303
 
 
304
_PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
 
305
{
 
306
        ndr_print_struct(ndr, name, "dcerpc_request");
 
307
        if (r == NULL) { ndr_print_null(ndr); return; }
 
308
        ndr->depth++;
 
309
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 
310
        ndr_print_uint16(ndr, "context_id", r->context_id);
 
311
        ndr_print_uint16(ndr, "opnum", r->opnum);
 
312
        ndr_print_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT);
 
313
        ndr_print_dcerpc_object(ndr, "object", &r->object);
 
314
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
315
        ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 
316
        ndr->depth--;
 
317
}
 
318
 
 
319
static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack_ctx *r)
 
320
{
 
321
        if (ndr_flags & NDR_SCALARS) {
 
322
                NDR_CHECK(ndr_push_align(ndr, 4));
 
323
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->result));
 
324
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reason));
 
325
                NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 
326
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
327
        }
 
328
        if (ndr_flags & NDR_BUFFERS) {
 
329
        }
 
330
        return NDR_ERR_SUCCESS;
 
331
}
 
332
 
 
333
static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack_ctx *r)
 
334
{
 
335
        if (ndr_flags & NDR_SCALARS) {
 
336
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
337
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->result));
 
338
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reason));
 
339
                NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
 
340
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
341
        }
 
342
        if (ndr_flags & NDR_BUFFERS) {
 
343
        }
 
344
        return NDR_ERR_SUCCESS;
 
345
}
 
346
 
 
347
_PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
 
348
{
 
349
        ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
 
350
        if (r == NULL) { ndr_print_null(ndr); return; }
 
351
        ndr->depth++;
 
352
        ndr_print_uint16(ndr, "result", r->result);
 
353
        ndr_print_uint16(ndr, "reason", r->reason);
 
354
        ndr_print_ndr_syntax_id(ndr, "syntax", &r->syntax);
 
355
        ndr->depth--;
 
356
}
 
357
 
 
358
static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_ack *r)
 
359
{
 
360
        uint32_t cntr_ctx_list_0;
 
361
        if (ndr_flags & NDR_SCALARS) {
 
362
                NDR_CHECK(ndr_push_align(ndr, 4));
 
363
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
 
364
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
 
365
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
 
366
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->secondary_address) + 1));
 
367
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen(r->secondary_address) + 1, sizeof(uint8_t), CH_DOS));
 
368
                {
 
369
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
370
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 
371
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
 
372
                        ndr->flags = _flags_save_DATA_BLOB;
 
373
                }
 
374
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
 
375
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
 
376
                        NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 
377
                }
 
378
                {
 
379
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
380
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
381
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 
382
                        ndr->flags = _flags_save_DATA_BLOB;
 
383
                }
 
384
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
385
        }
 
386
        if (ndr_flags & NDR_BUFFERS) {
 
387
        }
 
388
        return NDR_ERR_SUCCESS;
 
389
}
 
390
 
 
391
static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_ack *r)
 
392
{
 
393
        uint32_t cntr_ctx_list_0;
 
394
        TALLOC_CTX *_mem_save_ctx_list_0;
 
395
        if (ndr_flags & NDR_SCALARS) {
 
396
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
397
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
 
398
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
 
399
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
 
400
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
 
401
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, r->secondary_address_size, sizeof(uint8_t), CH_DOS));
 
402
                {
 
403
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
404
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
 
405
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
 
406
                        ndr->flags = _flags_save_DATA_BLOB;
 
407
                }
 
408
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
 
409
                NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_results);
 
410
                _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
411
                NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
 
412
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
 
413
                        NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
 
414
                }
 
415
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
 
416
                {
 
417
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
418
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
419
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 
420
                        ndr->flags = _flags_save_DATA_BLOB;
 
421
                }
 
422
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
423
        }
 
424
        if (ndr_flags & NDR_BUFFERS) {
 
425
        }
 
426
        return NDR_ERR_SUCCESS;
 
427
}
 
428
 
 
429
_PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
 
430
{
 
431
        uint32_t cntr_ctx_list_0;
 
432
        ndr_print_struct(ndr, name, "dcerpc_bind_ack");
 
433
        if (r == NULL) { ndr_print_null(ndr); return; }
 
434
        ndr->depth++;
 
435
        ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
 
436
        ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
 
437
        ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
 
438
        ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->secondary_address) + 1:r->secondary_address_size);
 
439
        ndr_print_string(ndr, "secondary_address", r->secondary_address);
 
440
        ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
 
441
        ndr_print_uint8(ndr, "num_results", r->num_results);
 
442
        ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_results);
 
443
        ndr->depth++;
 
444
        for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_results;cntr_ctx_list_0++) {
 
445
                ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
 
446
        }
 
447
        ndr->depth--;
 
448
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 
449
        ndr->depth--;
 
450
}
 
451
 
 
452
static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak_versions *r)
 
453
{
 
454
        uint32_t cntr_versions_0;
 
455
        if (ndr_flags & NDR_SCALARS) {
 
456
                NDR_CHECK(ndr_push_align(ndr, 4));
 
457
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_versions));
 
458
                for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
 
459
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->versions[cntr_versions_0]));
 
460
                }
 
461
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
462
        }
 
463
        if (ndr_flags & NDR_BUFFERS) {
 
464
        }
 
465
        return NDR_ERR_SUCCESS;
 
466
}
 
467
 
 
468
static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak_versions *r)
 
469
{
 
470
        uint32_t cntr_versions_0;
 
471
        TALLOC_CTX *_mem_save_versions_0;
 
472
        if (ndr_flags & NDR_SCALARS) {
 
473
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
474
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_versions));
 
475
                NDR_PULL_ALLOC_N(ndr, r->versions, r->num_versions);
 
476
                _mem_save_versions_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
477
                NDR_PULL_SET_MEM_CTX(ndr, r->versions, 0);
 
478
                for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
 
479
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
 
480
                }
 
481
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
 
482
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
483
        }
 
484
        if (ndr_flags & NDR_BUFFERS) {
 
485
        }
 
486
        return NDR_ERR_SUCCESS;
 
487
}
 
488
 
 
489
_PUBLIC_ void ndr_print_dcerpc_bind_nak_versions(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_versions *r)
 
490
{
 
491
        uint32_t cntr_versions_0;
 
492
        ndr_print_struct(ndr, name, "dcerpc_bind_nak_versions");
 
493
        if (r == NULL) { ndr_print_null(ndr); return; }
 
494
        ndr->depth++;
 
495
        ndr_print_uint32(ndr, "num_versions", r->num_versions);
 
496
        ndr->print(ndr, "%s: ARRAY(%d)", "versions", (int)r->num_versions);
 
497
        ndr->depth++;
 
498
        for (cntr_versions_0=0;cntr_versions_0<r->num_versions;cntr_versions_0++) {
 
499
                ndr_print_uint32(ndr, "versions", r->versions[cntr_versions_0]);
 
500
        }
 
501
        ndr->depth--;
 
502
        ndr->depth--;
 
503
}
 
504
 
 
505
static enum ndr_err_code ndr_push_dcerpc_bind_nak_versions_ctr(struct ndr_push *ndr, int ndr_flags, const union dcerpc_bind_nak_versions_ctr *r)
 
506
{
 
507
        if (ndr_flags & NDR_SCALARS) {
 
508
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
509
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
510
                switch (level) {
 
511
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 
512
                                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 
513
                        break; }
 
514
 
 
515
                        default: {
 
516
                        break; }
 
517
 
 
518
                }
 
519
        }
 
520
        if (ndr_flags & NDR_BUFFERS) {
 
521
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
522
                switch (level) {
 
523
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 
524
                        break;
 
525
 
 
526
                        default:
 
527
                        break;
 
528
 
 
529
                }
 
530
        }
 
531
        return NDR_ERR_SUCCESS;
 
532
}
 
533
 
 
534
static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions_ctr(struct ndr_pull *ndr, int ndr_flags, union dcerpc_bind_nak_versions_ctr *r)
 
535
{
 
536
        uint32_t level;
 
537
        level = ndr_pull_get_switch_value(ndr, r);
 
538
        if (ndr_flags & NDR_SCALARS) {
 
539
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
540
                switch (level) {
 
541
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
 
542
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
 
543
                        break; }
 
544
 
 
545
                        default: {
 
546
                        break; }
 
547
 
 
548
                }
 
549
        }
 
550
        if (ndr_flags & NDR_BUFFERS) {
 
551
                switch (level) {
 
552
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 
553
                        break;
 
554
 
 
555
                        default:
 
556
                        break;
 
557
 
 
558
                }
 
559
        }
 
560
        return NDR_ERR_SUCCESS;
 
561
}
 
562
 
 
563
_PUBLIC_ void ndr_print_dcerpc_bind_nak_versions_ctr(struct ndr_print *ndr, const char *name, const union dcerpc_bind_nak_versions_ctr *r)
 
564
{
 
565
        uint32_t level;
 
566
        level = ndr_print_get_switch_value(ndr, r);
 
567
        ndr_print_union(ndr, name, level, "dcerpc_bind_nak_versions_ctr");
 
568
        switch (level) {
 
569
                case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
 
570
                        ndr_print_dcerpc_bind_nak_versions(ndr, "v", &r->v);
 
571
                break;
 
572
 
 
573
                default:
 
574
                break;
 
575
 
 
576
        }
 
577
}
 
578
 
 
579
static enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak *r)
 
580
{
 
581
        if (ndr_flags & NDR_SCALARS) {
 
582
                NDR_CHECK(ndr_push_align(ndr, 4));
 
583
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reject_reason));
 
584
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->versions, r->reject_reason));
 
585
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 
586
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
587
        }
 
588
        if (ndr_flags & NDR_BUFFERS) {
 
589
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 
590
        }
 
591
        return NDR_ERR_SUCCESS;
 
592
}
 
593
 
 
594
static enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak *r)
 
595
{
 
596
        if (ndr_flags & NDR_SCALARS) {
 
597
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
598
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reject_reason));
 
599
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->versions, r->reject_reason));
 
600
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
 
601
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
602
        }
 
603
        if (ndr_flags & NDR_BUFFERS) {
 
604
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
 
605
        }
 
606
        return NDR_ERR_SUCCESS;
 
607
}
 
608
 
 
609
_PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
 
610
{
 
611
        ndr_print_struct(ndr, name, "dcerpc_bind_nak");
 
612
        if (r == NULL) { ndr_print_null(ndr); return; }
 
613
        ndr->depth++;
 
614
        ndr_print_uint16(ndr, "reject_reason", r->reject_reason);
 
615
        ndr_print_set_switch_value(ndr, &r->versions, r->reject_reason);
 
616
        ndr_print_dcerpc_bind_nak_versions_ctr(ndr, "versions", &r->versions);
 
617
        ndr->depth--;
 
618
}
 
619
 
 
620
static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_response *r)
 
621
{
 
622
        if (ndr_flags & NDR_SCALARS) {
 
623
                NDR_CHECK(ndr_push_align(ndr, 4));
 
624
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 
625
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 
626
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 
627
                {
 
628
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
629
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 
630
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
631
                        ndr->flags = _flags_save_DATA_BLOB;
 
632
                }
 
633
                {
 
634
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
635
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
636
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
 
637
                        ndr->flags = _flags_save_DATA_BLOB;
 
638
                }
 
639
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
640
        }
 
641
        if (ndr_flags & NDR_BUFFERS) {
 
642
        }
 
643
        return NDR_ERR_SUCCESS;
 
644
}
 
645
 
 
646
static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_response *r)
 
647
{
 
648
        if (ndr_flags & NDR_SCALARS) {
 
649
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
650
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 
651
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 
652
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 
653
                {
 
654
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
655
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
 
656
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
657
                        ndr->flags = _flags_save_DATA_BLOB;
 
658
                }
 
659
                {
 
660
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
661
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
662
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
 
663
                        ndr->flags = _flags_save_DATA_BLOB;
 
664
                }
 
665
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
666
        }
 
667
        if (ndr_flags & NDR_BUFFERS) {
 
668
        }
 
669
        return NDR_ERR_SUCCESS;
 
670
}
 
671
 
 
672
_PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
 
673
{
 
674
        ndr_print_struct(ndr, name, "dcerpc_response");
 
675
        if (r == NULL) { ndr_print_null(ndr); return; }
 
676
        ndr->depth++;
 
677
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 
678
        ndr_print_uint16(ndr, "context_id", r->context_id);
 
679
        ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 
680
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
681
        ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
 
682
        ndr->depth--;
 
683
}
 
684
 
 
685
static enum ndr_err_code ndr_push_dcerpc_nca_status(struct ndr_push *ndr, int ndr_flags, enum dcerpc_nca_status r)
 
686
{
 
687
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
688
        return NDR_ERR_SUCCESS;
 
689
}
 
690
 
 
691
static enum ndr_err_code ndr_pull_dcerpc_nca_status(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_nca_status *r)
 
692
{
 
693
        uint32_t v;
 
694
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
695
        *r = v;
 
696
        return NDR_ERR_SUCCESS;
 
697
}
 
698
 
 
699
_PUBLIC_ void ndr_print_dcerpc_nca_status(struct ndr_print *ndr, const char *name, enum dcerpc_nca_status r)
 
700
{
 
701
        const char *val = NULL;
 
702
 
 
703
        switch (r) {
 
704
                case DCERPC_NCA_S_COMM_FAILURE: val = "DCERPC_NCA_S_COMM_FAILURE"; break;
 
705
                case DCERPC_NCA_S_OP_RNG_ERROR: val = "DCERPC_NCA_S_OP_RNG_ERROR"; break;
 
706
                case DCERPC_NCA_S_UNKNOWN_IF: val = "DCERPC_NCA_S_UNKNOWN_IF"; break;
 
707
                case DCERPC_NCA_S_WRONG_BOOT_TIME: val = "DCERPC_NCA_S_WRONG_BOOT_TIME"; break;
 
708
                case DCERPC_NCA_S_YOU_CRASHED: val = "DCERPC_NCA_S_YOU_CRASHED"; break;
 
709
                case DCERPC_NCA_S_PROTO_ERROR: val = "DCERPC_NCA_S_PROTO_ERROR"; break;
 
710
                case DCERPC_NCA_S_OUT_ARGS_TOO_BIG: val = "DCERPC_NCA_S_OUT_ARGS_TOO_BIG"; break;
 
711
                case DCERPC_NCA_S_SERVER_TOO_BUSY: val = "DCERPC_NCA_S_SERVER_TOO_BUSY"; break;
 
712
                case DCERPC_NCA_S_FAULT_STRING_TOO_LARGE: val = "DCERPC_NCA_S_FAULT_STRING_TOO_LARGE"; break;
 
713
                case DCERPC_NCA_S_UNSUPPORTED_TYPE: val = "DCERPC_NCA_S_UNSUPPORTED_TYPE"; break;
 
714
                case DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO"; break;
 
715
                case DCERPC_NCA_S_FAULT_ADDR_ERROR: val = "DCERPC_NCA_S_FAULT_ADDR_ERROR"; break;
 
716
                case DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO: val = "DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO"; break;
 
717
                case DCERPC_NCA_S_FAULT_FP_UNDERFLOW: val = "DCERPC_NCA_S_FAULT_FP_UNDERFLOW"; break;
 
718
                case DCERPC_NCA_S_FAULT_FP_OVERRFLOW: val = "DCERPC_NCA_S_FAULT_FP_OVERRFLOW"; break;
 
719
                case DCERPC_NCA_S_FAULT_INVALID_TAG: val = "DCERPC_NCA_S_FAULT_INVALID_TAG"; break;
 
720
                case DCERPC_NCA_S_FAULT_INVALID_BOUND: val = "DCERPC_NCA_S_FAULT_INVALID_BOUND"; break;
 
721
                case DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH: val = "DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH"; break;
 
722
                case DCERPC_NCA_S_FAULT_UNSPEC_REJECT: val = "DCERPC_NCA_S_FAULT_UNSPEC_REJECT"; break;
 
723
                case DCERPC_NCA_S_FAULT_BAD_ACTID: val = "DCERPC_NCA_S_FAULT_BAD_ACTID"; break;
 
724
                case DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED: val = "DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED"; break;
 
725
                case DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED: val = "DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED"; break;
 
726
                case DCERPC_NCA_S_FAULT_CANCEL: val = "DCERPC_NCA_S_FAULT_CANCEL"; break;
 
727
                case DCERPC_NCA_S_FAULT_ILL_INST: val = "DCERPC_NCA_S_FAULT_ILL_INST"; break;
 
728
                case DCERPC_NCA_S_FAULT_FP_ERROR: val = "DCERPC_NCA_S_FAULT_FP_ERROR"; break;
 
729
                case DCERPC_NCA_S_FAULT_INT_OVERFLOW: val = "DCERPC_NCA_S_FAULT_INT_OVERFLOW"; break;
 
730
                case DCERPC_NCA_S_UNUSED_1C000011: val = "DCERPC_NCA_S_UNUSED_1C000011"; break;
 
731
                case DCERPC_NCA_S_FAULT_UNSPEC: val = "DCERPC_NCA_S_FAULT_UNSPEC"; break;
 
732
                case DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE: val = "DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE"; break;
 
733
                case DCERPC_NCA_S_FAULT_PIPE_EMPTY: val = "DCERPC_NCA_S_FAULT_PIPE_EMPTY"; break;
 
734
                case DCERPC_NCA_S_FAULT_PIPE_CLOSED: val = "DCERPC_NCA_S_FAULT_PIPE_CLOSED"; break;
 
735
                case DCERPC_NCA_S_FAULT_PIPE_ORDER: val = "DCERPC_NCA_S_FAULT_PIPE_ORDER"; break;
 
736
                case DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE: val = "DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE"; break;
 
737
                case DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR: val = "DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR"; break;
 
738
                case DCERPC_NCA_S_FAULT_PIPE_MEMORY: val = "DCERPC_NCA_S_FAULT_PIPE_MEMORY"; break;
 
739
                case DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH: val = "DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH"; break;
 
740
                case DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY: val = "DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY"; break;
 
741
                case DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID: val = "DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID"; break;
 
742
                case DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL: val = "DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL"; break;
 
743
                case DCERPC_NCA_S_UNUSED_1C00001E: val = "DCERPC_NCA_S_UNUSED_1C00001E"; break;
 
744
                case DCERPC_NCA_S_INVALID_CHECKSUM: val = "DCERPC_NCA_S_INVALID_CHECKSUM"; break;
 
745
                case DCERPC_NCA_S_INVALID_CRC: val = "DCERPC_NCA_S_INVALID_CRC"; break;
 
746
                case DCERPC_NCA_S_FAULT_USER_DEFINED: val = "DCERPC_NCA_S_FAULT_USER_DEFINED"; break;
 
747
                case DCERPC_NCA_S_FAULT_TX_OPEN_FAILED: val = "DCERPC_NCA_S_FAULT_TX_OPEN_FAILED"; break;
 
748
                case DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR: val = "DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR"; break;
 
749
                case DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND: val = "DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND"; break;
 
750
                case DCERPC_NCA_S_FAULT_NO_CLIENT_STUB: val = "DCERPC_NCA_S_FAULT_NO_CLIENT_STUB"; break;
 
751
        }
 
752
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
753
}
 
754
 
 
755
static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fault *r)
 
756
{
 
757
        if (ndr_flags & NDR_SCALARS) {
 
758
                NDR_CHECK(ndr_push_align(ndr, 4));
 
759
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
 
760
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
 
761
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
 
762
                NDR_CHECK(ndr_push_dcerpc_nca_status(ndr, NDR_SCALARS, r->status));
 
763
                {
 
764
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
765
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
766
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
 
767
                        ndr->flags = _flags_save_DATA_BLOB;
 
768
                }
 
769
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
770
        }
 
771
        if (ndr_flags & NDR_BUFFERS) {
 
772
        }
 
773
        return NDR_ERR_SUCCESS;
 
774
}
 
775
 
 
776
static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fault *r)
 
777
{
 
778
        if (ndr_flags & NDR_SCALARS) {
 
779
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
780
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
 
781
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
 
782
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
 
783
                NDR_CHECK(ndr_pull_dcerpc_nca_status(ndr, NDR_SCALARS, &r->status));
 
784
                {
 
785
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
786
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
787
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
 
788
                        ndr->flags = _flags_save_DATA_BLOB;
 
789
                }
 
790
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
791
        }
 
792
        if (ndr_flags & NDR_BUFFERS) {
 
793
        }
 
794
        return NDR_ERR_SUCCESS;
 
795
}
 
796
 
 
797
_PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
 
798
{
 
799
        ndr_print_struct(ndr, name, "dcerpc_fault");
 
800
        if (r == NULL) { ndr_print_null(ndr); return; }
 
801
        ndr->depth++;
 
802
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
 
803
        ndr_print_uint16(ndr, "context_id", r->context_id);
 
804
        ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
 
805
        ndr_print_dcerpc_nca_status(ndr, "status", r->status);
 
806
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
 
807
        ndr->depth--;
 
808
}
 
809
 
 
810
static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthType r)
 
811
{
 
812
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 
813
        return NDR_ERR_SUCCESS;
 
814
}
 
815
 
 
816
static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthType *r)
 
817
{
 
818
        uint8_t v;
 
819
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 
820
        *r = v;
 
821
        return NDR_ERR_SUCCESS;
 
822
}
 
823
 
 
824
_PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
 
825
{
 
826
        const char *val = NULL;
 
827
 
 
828
        switch (r) {
 
829
                case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
 
830
                case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
 
831
                case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
 
832
                case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
 
833
                case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
 
834
                case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
 
835
                case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
 
836
                case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
 
837
                case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
 
838
                case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
 
839
                case DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM: val = "DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM"; break;
 
840
        }
 
841
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
842
}
 
843
 
 
844
static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthLevel r)
 
845
{
 
846
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 
847
        return NDR_ERR_SUCCESS;
 
848
}
 
849
 
 
850
static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthLevel *r)
 
851
{
 
852
        uint8_t v;
 
853
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 
854
        *r = v;
 
855
        return NDR_ERR_SUCCESS;
 
856
}
 
857
 
 
858
_PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
 
859
{
 
860
        const char *val = NULL;
 
861
 
 
862
        switch (r) {
 
863
                case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
 
864
                case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
 
865
                case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
 
866
                case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
 
867
                case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
 
868
                case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
 
869
        }
 
870
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
871
}
 
872
 
 
873
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth *r)
 
874
{
 
875
        if (ndr_flags & NDR_SCALARS) {
 
876
                NDR_CHECK(ndr_push_align(ndr, 4));
 
877
                NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
 
878
                NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
 
879
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
 
880
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
 
881
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
 
882
                {
 
883
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
884
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
885
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
 
886
                        ndr->flags = _flags_save_DATA_BLOB;
 
887
                }
 
888
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
889
        }
 
890
        if (ndr_flags & NDR_BUFFERS) {
 
891
        }
 
892
        return NDR_ERR_SUCCESS;
 
893
}
 
894
 
 
895
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth *r)
 
896
{
 
897
        if (ndr_flags & NDR_SCALARS) {
 
898
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
899
                NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
 
900
                NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
 
901
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
 
902
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
 
903
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
 
904
                {
 
905
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
906
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
907
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
 
908
                        ndr->flags = _flags_save_DATA_BLOB;
 
909
                }
 
910
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
911
        }
 
912
        if (ndr_flags & NDR_BUFFERS) {
 
913
        }
 
914
        return NDR_ERR_SUCCESS;
 
915
}
 
916
 
 
917
_PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
 
918
{
 
919
        ndr_print_struct(ndr, name, "dcerpc_auth");
 
920
        if (r == NULL) { ndr_print_null(ndr); return; }
 
921
        ndr->depth++;
 
922
        ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
 
923
        ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
 
924
        ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
 
925
        ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
 
926
        ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
 
927
        ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
 
928
        ndr->depth--;
 
929
}
 
930
 
 
931
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth3 *r)
 
932
{
 
933
        if (ndr_flags & NDR_SCALARS) {
 
934
                NDR_CHECK(ndr_push_align(ndr, 4));
 
935
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
936
                {
 
937
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
938
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
939
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 
940
                        ndr->flags = _flags_save_DATA_BLOB;
 
941
                }
 
942
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
943
        }
 
944
        if (ndr_flags & NDR_BUFFERS) {
 
945
        }
 
946
        return NDR_ERR_SUCCESS;
 
947
}
 
948
 
 
949
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth3 *r)
 
950
{
 
951
        if (ndr_flags & NDR_SCALARS) {
 
952
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
953
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 
954
                {
 
955
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
956
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
957
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 
958
                        ndr->flags = _flags_save_DATA_BLOB;
 
959
                }
 
960
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
961
        }
 
962
        if (ndr_flags & NDR_BUFFERS) {
 
963
        }
 
964
        return NDR_ERR_SUCCESS;
 
965
}
 
966
 
 
967
_PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
 
968
{
 
969
        ndr_print_struct(ndr, name, "dcerpc_auth3");
 
970
        if (r == NULL) { ndr_print_null(ndr); return; }
 
971
        ndr->depth++;
 
972
        ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
 
973
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 
974
        ndr->depth--;
 
975
}
 
976
 
 
977
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_orphaned *r)
 
978
{
 
979
        if (ndr_flags & NDR_SCALARS) {
 
980
                NDR_CHECK(ndr_push_align(ndr, 4));
 
981
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
982
                {
 
983
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
984
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
985
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 
986
                        ndr->flags = _flags_save_DATA_BLOB;
 
987
                }
 
988
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
989
        }
 
990
        if (ndr_flags & NDR_BUFFERS) {
 
991
        }
 
992
        return NDR_ERR_SUCCESS;
 
993
}
 
994
 
 
995
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_orphaned *r)
 
996
{
 
997
        if (ndr_flags & NDR_SCALARS) {
 
998
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
999
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 
1000
                {
 
1001
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
1002
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
1003
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 
1004
                        ndr->flags = _flags_save_DATA_BLOB;
 
1005
                }
 
1006
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1007
        }
 
1008
        if (ndr_flags & NDR_BUFFERS) {
 
1009
        }
 
1010
        return NDR_ERR_SUCCESS;
 
1011
}
 
1012
 
 
1013
_PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
 
1014
{
 
1015
        ndr_print_struct(ndr, name, "dcerpc_orphaned");
 
1016
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1017
        ndr->depth++;
 
1018
        ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
 
1019
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 
1020
        ndr->depth--;
 
1021
}
 
1022
 
 
1023
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_co_cancel *r)
 
1024
{
 
1025
        if (ndr_flags & NDR_SCALARS) {
 
1026
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1027
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 
1028
                {
 
1029
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
1030
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
1031
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
 
1032
                        ndr->flags = _flags_save_DATA_BLOB;
 
1033
                }
 
1034
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1035
        }
 
1036
        if (ndr_flags & NDR_BUFFERS) {
 
1037
        }
 
1038
        return NDR_ERR_SUCCESS;
 
1039
}
 
1040
 
 
1041
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_co_cancel *r)
 
1042
{
 
1043
        if (ndr_flags & NDR_SCALARS) {
 
1044
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1045
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
 
1046
                {
 
1047
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
1048
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
1049
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
 
1050
                        ndr->flags = _flags_save_DATA_BLOB;
 
1051
                }
 
1052
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1053
        }
 
1054
        if (ndr_flags & NDR_BUFFERS) {
 
1055
        }
 
1056
        return NDR_ERR_SUCCESS;
 
1057
}
 
1058
 
 
1059
_PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
 
1060
{
 
1061
        ndr_print_struct(ndr, name, "dcerpc_co_cancel");
 
1062
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1063
        ndr->depth++;
 
1064
        ndr_print_uint32(ndr, "_pad", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->_pad);
 
1065
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
 
1066
        ndr->depth--;
 
1067
}
 
1068
 
 
1069
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cl_cancel *r)
 
1070
{
 
1071
        if (ndr_flags & NDR_SCALARS) {
 
1072
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1073
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 
1074
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
 
1075
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1076
        }
 
1077
        if (ndr_flags & NDR_BUFFERS) {
 
1078
        }
 
1079
        return NDR_ERR_SUCCESS;
 
1080
}
 
1081
 
 
1082
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cl_cancel *r)
 
1083
{
 
1084
        if (ndr_flags & NDR_SCALARS) {
 
1085
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1086
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 
1087
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
 
1088
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1089
        }
 
1090
        if (ndr_flags & NDR_BUFFERS) {
 
1091
        }
 
1092
        return NDR_ERR_SUCCESS;
 
1093
}
 
1094
 
 
1095
_PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
 
1096
{
 
1097
        ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
 
1098
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1099
        ndr->depth++;
 
1100
        ndr_print_uint32(ndr, "version", r->version);
 
1101
        ndr_print_uint32(ndr, "id", r->id);
 
1102
        ndr->depth--;
 
1103
}
 
1104
 
 
1105
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cancel_ack *r)
 
1106
{
 
1107
        if (ndr_flags & NDR_SCALARS) {
 
1108
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1109
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 
1110
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
 
1111
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
 
1112
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1113
        }
 
1114
        if (ndr_flags & NDR_BUFFERS) {
 
1115
        }
 
1116
        return NDR_ERR_SUCCESS;
 
1117
}
 
1118
 
 
1119
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cancel_ack *r)
 
1120
{
 
1121
        if (ndr_flags & NDR_SCALARS) {
 
1122
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1123
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 
1124
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
 
1125
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
 
1126
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1127
        }
 
1128
        if (ndr_flags & NDR_BUFFERS) {
 
1129
        }
 
1130
        return NDR_ERR_SUCCESS;
 
1131
}
 
1132
 
 
1133
_PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
 
1134
{
 
1135
        ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
 
1136
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1137
        ndr->depth++;
 
1138
        ndr_print_uint32(ndr, "version", r->version);
 
1139
        ndr_print_uint32(ndr, "id", r->id);
 
1140
        ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
 
1141
        ndr->depth--;
 
1142
}
 
1143
 
 
1144
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fack *r)
 
1145
{
 
1146
        uint32_t cntr_selack_0;
 
1147
        if (ndr_flags & NDR_SCALARS) {
 
1148
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1149
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 
1150
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
 
1151
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
 
1152
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
 
1153
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
 
1154
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
 
1155
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
 
1156
                for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
 
1157
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
 
1158
                }
 
1159
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1160
        }
 
1161
        if (ndr_flags & NDR_BUFFERS) {
 
1162
        }
 
1163
        return NDR_ERR_SUCCESS;
 
1164
}
 
1165
 
 
1166
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fack *r)
 
1167
{
 
1168
        uint32_t cntr_selack_0;
 
1169
        TALLOC_CTX *_mem_save_selack_0;
 
1170
        if (ndr_flags & NDR_SCALARS) {
 
1171
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1172
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 
1173
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
 
1174
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
 
1175
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
 
1176
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
 
1177
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
 
1178
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
 
1179
                NDR_PULL_ALLOC_N(ndr, r->selack, r->selack_size);
 
1180
                _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1181
                NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
 
1182
                for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
 
1183
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
 
1184
                }
 
1185
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
 
1186
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1187
        }
 
1188
        if (ndr_flags & NDR_BUFFERS) {
 
1189
        }
 
1190
        return NDR_ERR_SUCCESS;
 
1191
}
 
1192
 
 
1193
_PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
 
1194
{
 
1195
        uint32_t cntr_selack_0;
 
1196
        ndr_print_struct(ndr, name, "dcerpc_fack");
 
1197
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1198
        ndr->depth++;
 
1199
        ndr_print_uint32(ndr, "version", r->version);
 
1200
        ndr_print_uint8(ndr, "_pad1", r->_pad1);
 
1201
        ndr_print_uint16(ndr, "window_size", r->window_size);
 
1202
        ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
 
1203
        ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
 
1204
        ndr_print_uint16(ndr, "serial_no", r->serial_no);
 
1205
        ndr_print_uint16(ndr, "selack_size", r->selack_size);
 
1206
        ndr->print(ndr, "%s: ARRAY(%d)", "selack", (int)r->selack_size);
 
1207
        ndr->depth++;
 
1208
        for (cntr_selack_0=0;cntr_selack_0<r->selack_size;cntr_selack_0++) {
 
1209
                ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
 
1210
        }
 
1211
        ndr->depth--;
 
1212
        ndr->depth--;
 
1213
}
 
1214
 
 
1215
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack *r)
 
1216
{
 
1217
        if (ndr_flags & NDR_SCALARS) {
 
1218
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1219
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1220
        }
 
1221
        if (ndr_flags & NDR_BUFFERS) {
 
1222
        }
 
1223
        return NDR_ERR_SUCCESS;
 
1224
}
 
1225
 
 
1226
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack *r)
 
1227
{
 
1228
        if (ndr_flags & NDR_SCALARS) {
 
1229
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1230
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1231
        }
 
1232
        if (ndr_flags & NDR_BUFFERS) {
 
1233
        }
 
1234
        return NDR_ERR_SUCCESS;
 
1235
}
 
1236
 
 
1237
_PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
 
1238
{
 
1239
        ndr_print_struct(ndr, name, "dcerpc_ack");
 
1240
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1241
        ndr->depth++;
 
1242
        ndr->depth--;
 
1243
}
 
1244
 
 
1245
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ping *r)
 
1246
{
 
1247
        if (ndr_flags & NDR_SCALARS) {
 
1248
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1249
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1250
        }
 
1251
        if (ndr_flags & NDR_BUFFERS) {
 
1252
        }
 
1253
        return NDR_ERR_SUCCESS;
 
1254
}
 
1255
 
 
1256
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ping *r)
 
1257
{
 
1258
        if (ndr_flags & NDR_SCALARS) {
 
1259
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1260
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1261
        }
 
1262
        if (ndr_flags & NDR_BUFFERS) {
 
1263
        }
 
1264
        return NDR_ERR_SUCCESS;
 
1265
}
 
1266
 
 
1267
_PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
 
1268
{
 
1269
        ndr_print_struct(ndr, name, "dcerpc_ping");
 
1270
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1271
        ndr->depth++;
 
1272
        ndr->depth--;
 
1273
}
 
1274
 
 
1275
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_shutdown *r)
 
1276
{
 
1277
        if (ndr_flags & NDR_SCALARS) {
 
1278
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1279
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1280
        }
 
1281
        if (ndr_flags & NDR_BUFFERS) {
 
1282
        }
 
1283
        return NDR_ERR_SUCCESS;
 
1284
}
 
1285
 
 
1286
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_shutdown *r)
 
1287
{
 
1288
        if (ndr_flags & NDR_SCALARS) {
 
1289
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1290
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1291
        }
 
1292
        if (ndr_flags & NDR_BUFFERS) {
 
1293
        }
 
1294
        return NDR_ERR_SUCCESS;
 
1295
}
 
1296
 
 
1297
_PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
 
1298
{
 
1299
        ndr_print_struct(ndr, name, "dcerpc_shutdown");
 
1300
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1301
        ndr->depth++;
 
1302
        ndr->depth--;
 
1303
}
 
1304
 
 
1305
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_working *r)
 
1306
{
 
1307
        if (ndr_flags & NDR_SCALARS) {
 
1308
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1309
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1310
        }
 
1311
        if (ndr_flags & NDR_BUFFERS) {
 
1312
        }
 
1313
        return NDR_ERR_SUCCESS;
 
1314
}
 
1315
 
 
1316
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_working *r)
 
1317
{
 
1318
        if (ndr_flags & NDR_SCALARS) {
 
1319
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1320
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1321
        }
 
1322
        if (ndr_flags & NDR_BUFFERS) {
 
1323
        }
 
1324
        return NDR_ERR_SUCCESS;
 
1325
}
 
1326
 
 
1327
_PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
 
1328
{
 
1329
        ndr_print_struct(ndr, name, "dcerpc_working");
 
1330
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1331
        ndr->depth++;
 
1332
        ndr->depth--;
 
1333
}
 
1334
 
 
1335
_PUBLIC_ enum ndr_err_code ndr_push_RTSCookie(struct ndr_push *ndr, int ndr_flags, const struct RTSCookie *r)
 
1336
{
 
1337
        if (ndr_flags & NDR_SCALARS) {
 
1338
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1339
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->Cookie));
 
1340
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1341
        }
 
1342
        if (ndr_flags & NDR_BUFFERS) {
 
1343
        }
 
1344
        return NDR_ERR_SUCCESS;
 
1345
}
 
1346
 
 
1347
_PUBLIC_ enum ndr_err_code ndr_pull_RTSCookie(struct ndr_pull *ndr, int ndr_flags, struct RTSCookie *r)
 
1348
{
 
1349
        if (ndr_flags & NDR_SCALARS) {
 
1350
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1351
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->Cookie));
 
1352
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1353
        }
 
1354
        if (ndr_flags & NDR_BUFFERS) {
 
1355
        }
 
1356
        return NDR_ERR_SUCCESS;
 
1357
}
 
1358
 
 
1359
_PUBLIC_ void ndr_print_RTSCookie(struct ndr_print *ndr, const char *name, const struct RTSCookie *r)
 
1360
{
 
1361
        ndr_print_struct(ndr, name, "RTSCookie");
 
1362
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1363
        ndr->depth++;
 
1364
        ndr_print_GUID(ndr, "Cookie", &r->Cookie);
 
1365
        ndr->depth--;
 
1366
}
 
1367
 
 
1368
_PUBLIC_ enum ndr_err_code ndr_push_AddressType(struct ndr_push *ndr, int ndr_flags, enum AddressType r)
 
1369
{
 
1370
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
1371
        return NDR_ERR_SUCCESS;
 
1372
}
 
1373
 
 
1374
_PUBLIC_ enum ndr_err_code ndr_pull_AddressType(struct ndr_pull *ndr, int ndr_flags, enum AddressType *r)
 
1375
{
 
1376
        uint32_t v;
 
1377
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
1378
        *r = v;
 
1379
        return NDR_ERR_SUCCESS;
 
1380
}
 
1381
 
 
1382
_PUBLIC_ void ndr_print_AddressType(struct ndr_print *ndr, const char *name, enum AddressType r)
 
1383
{
 
1384
        const char *val = NULL;
 
1385
 
 
1386
        switch (r) {
 
1387
                case RTS_IPV4: val = "RTS_IPV4"; break;
 
1388
                case RTS_IPV6: val = "RTS_IPV6"; break;
 
1389
        }
 
1390
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1391
}
 
1392
 
 
1393
static enum ndr_err_code ndr_push_ClientAddressType(struct ndr_push *ndr, int ndr_flags, const union ClientAddressType *r)
 
1394
{
 
1395
        if (ndr_flags & NDR_SCALARS) {
 
1396
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1397
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
1398
                switch (level) {
 
1399
                        case RTS_IPV4: {
 
1400
                                NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->ClientAddressIPV4));
 
1401
                        break; }
 
1402
 
 
1403
                        case RTS_IPV6: {
 
1404
                                NDR_CHECK(ndr_push_ipv6address(ndr, NDR_SCALARS, r->ClientAddressIPV6));
 
1405
                        break; }
 
1406
 
 
1407
                        default:
 
1408
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1409
                }
 
1410
        }
 
1411
        if (ndr_flags & NDR_BUFFERS) {
 
1412
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
1413
                switch (level) {
 
1414
                        case RTS_IPV4:
 
1415
                        break;
 
1416
 
 
1417
                        case RTS_IPV6:
 
1418
                        break;
 
1419
 
 
1420
                        default:
 
1421
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1422
                }
 
1423
        }
 
1424
        return NDR_ERR_SUCCESS;
 
1425
}
 
1426
 
 
1427
static enum ndr_err_code ndr_pull_ClientAddressType(struct ndr_pull *ndr, int ndr_flags, union ClientAddressType *r)
 
1428
{
 
1429
        uint32_t level;
 
1430
        level = ndr_pull_get_switch_value(ndr, r);
 
1431
        if (ndr_flags & NDR_SCALARS) {
 
1432
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
1433
                switch (level) {
 
1434
                        case RTS_IPV4: {
 
1435
                                NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->ClientAddressIPV4));
 
1436
                        break; }
 
1437
 
 
1438
                        case RTS_IPV6: {
 
1439
                                NDR_CHECK(ndr_pull_ipv6address(ndr, NDR_SCALARS, &r->ClientAddressIPV6));
 
1440
                        break; }
 
1441
 
 
1442
                        default:
 
1443
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1444
                }
 
1445
        }
 
1446
        if (ndr_flags & NDR_BUFFERS) {
 
1447
                switch (level) {
 
1448
                        case RTS_IPV4:
 
1449
                        break;
 
1450
 
 
1451
                        case RTS_IPV6:
 
1452
                        break;
 
1453
 
 
1454
                        default:
 
1455
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
1456
                }
 
1457
        }
 
1458
        return NDR_ERR_SUCCESS;
 
1459
}
 
1460
 
 
1461
_PUBLIC_ void ndr_print_ClientAddressType(struct ndr_print *ndr, const char *name, const union ClientAddressType *r)
 
1462
{
 
1463
        uint32_t level;
 
1464
        level = ndr_print_get_switch_value(ndr, r);
 
1465
        ndr_print_union(ndr, name, level, "ClientAddressType");
 
1466
        switch (level) {
 
1467
                case RTS_IPV4:
 
1468
                        ndr_print_ipv4address(ndr, "ClientAddressIPV4", r->ClientAddressIPV4);
 
1469
                break;
 
1470
 
 
1471
                case RTS_IPV6:
 
1472
                        ndr_print_ipv6address(ndr, "ClientAddressIPV6", r->ClientAddressIPV6);
 
1473
                break;
 
1474
 
 
1475
                default:
 
1476
                        ndr_print_bad_level(ndr, name, level);
 
1477
        }
 
1478
}
 
1479
 
 
1480
_PUBLIC_ enum ndr_err_code ndr_push_ClientAddress(struct ndr_push *ndr, int ndr_flags, const struct ClientAddress *r)
 
1481
{
 
1482
        if (ndr_flags & NDR_SCALARS) {
 
1483
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1484
                NDR_CHECK(ndr_push_AddressType(ndr, NDR_SCALARS, r->AddressType));
 
1485
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
 
1486
                NDR_CHECK(ndr_push_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
 
1487
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, 12));
 
1488
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1489
        }
 
1490
        if (ndr_flags & NDR_BUFFERS) {
 
1491
        }
 
1492
        return NDR_ERR_SUCCESS;
 
1493
}
 
1494
 
 
1495
_PUBLIC_ enum ndr_err_code ndr_pull_ClientAddress(struct ndr_pull *ndr, int ndr_flags, struct ClientAddress *r)
 
1496
{
 
1497
        if (ndr_flags & NDR_SCALARS) {
 
1498
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1499
                NDR_CHECK(ndr_pull_AddressType(ndr, NDR_SCALARS, &r->AddressType));
 
1500
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ClientAddress, r->AddressType));
 
1501
                NDR_CHECK(ndr_pull_ClientAddressType(ndr, NDR_SCALARS, &r->ClientAddress));
 
1502
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, 12));
 
1503
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1504
        }
 
1505
        if (ndr_flags & NDR_BUFFERS) {
 
1506
        }
 
1507
        return NDR_ERR_SUCCESS;
 
1508
}
 
1509
 
 
1510
_PUBLIC_ void ndr_print_ClientAddress(struct ndr_print *ndr, const char *name, const struct ClientAddress *r)
 
1511
{
 
1512
        ndr_print_struct(ndr, name, "ClientAddress");
 
1513
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1514
        ndr->depth++;
 
1515
        ndr_print_AddressType(ndr, "AddressType", r->AddressType);
 
1516
        ndr_print_set_switch_value(ndr, &r->ClientAddress, r->AddressType);
 
1517
        ndr_print_ClientAddressType(ndr, "ClientAddress", &r->ClientAddress);
 
1518
        ndr_print_array_uint8(ndr, "Padding", r->Padding, 12);
 
1519
        ndr->depth--;
 
1520
}
 
1521
 
 
1522
_PUBLIC_ enum ndr_err_code ndr_push_ForwardDestination(struct ndr_push *ndr, int ndr_flags, enum ForwardDestination r)
 
1523
{
 
1524
        NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
1525
        return NDR_ERR_SUCCESS;
 
1526
}
 
1527
 
 
1528
_PUBLIC_ enum ndr_err_code ndr_pull_ForwardDestination(struct ndr_pull *ndr, int ndr_flags, enum ForwardDestination *r)
 
1529
{
 
1530
        uint32_t v;
 
1531
        NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
1532
        *r = v;
 
1533
        return NDR_ERR_SUCCESS;
 
1534
}
 
1535
 
 
1536
_PUBLIC_ void ndr_print_ForwardDestination(struct ndr_print *ndr, const char *name, enum ForwardDestination r)
 
1537
{
 
1538
        const char *val = NULL;
 
1539
 
 
1540
        switch (r) {
 
1541
                case FDClient: val = "FDClient"; break;
 
1542
                case FDInProxy: val = "FDInProxy"; break;
 
1543
                case FDServer: val = "FDServer"; break;
 
1544
                case FDOutProxy: val = "FDOutProxy"; break;
 
1545
        }
 
1546
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
1547
}
 
1548
 
 
1549
_PUBLIC_ enum ndr_err_code ndr_push_FlowControlAcknowledgment(struct ndr_push *ndr, int ndr_flags, const struct FlowControlAcknowledgment *r)
 
1550
{
 
1551
        if (ndr_flags & NDR_SCALARS) {
 
1552
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1553
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BytesReceived));
 
1554
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->AvailableWindow));
 
1555
                NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
 
1556
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1557
        }
 
1558
        if (ndr_flags & NDR_BUFFERS) {
 
1559
        }
 
1560
        return NDR_ERR_SUCCESS;
 
1561
}
 
1562
 
 
1563
_PUBLIC_ enum ndr_err_code ndr_pull_FlowControlAcknowledgment(struct ndr_pull *ndr, int ndr_flags, struct FlowControlAcknowledgment *r)
 
1564
{
 
1565
        if (ndr_flags & NDR_SCALARS) {
 
1566
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1567
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BytesReceived));
 
1568
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->AvailableWindow));
 
1569
                NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->ChannelCookie));
 
1570
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1571
        }
 
1572
        if (ndr_flags & NDR_BUFFERS) {
 
1573
        }
 
1574
        return NDR_ERR_SUCCESS;
 
1575
}
 
1576
 
 
1577
_PUBLIC_ void ndr_print_FlowControlAcknowledgment(struct ndr_print *ndr, const char *name, const struct FlowControlAcknowledgment *r)
 
1578
{
 
1579
        ndr_print_struct(ndr, name, "FlowControlAcknowledgment");
 
1580
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1581
        ndr->depth++;
 
1582
        ndr_print_uint32(ndr, "BytesReceived", r->BytesReceived);
 
1583
        ndr_print_uint32(ndr, "AvailableWindow", r->AvailableWindow);
 
1584
        ndr_print_RTSCookie(ndr, "ChannelCookie", &r->ChannelCookie);
 
1585
        ndr->depth--;
 
1586
}
 
1587
 
 
1588
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
 
1589
{
 
1590
        if (ndr_flags & NDR_SCALARS) {
 
1591
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1592
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ReceiveWindowSize));
 
1593
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1594
        }
 
1595
        if (ndr_flags & NDR_BUFFERS) {
 
1596
        }
 
1597
        return NDR_ERR_SUCCESS;
 
1598
}
 
1599
 
 
1600
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ReceiveWindowSize *r)
 
1601
{
 
1602
        if (ndr_flags & NDR_SCALARS) {
 
1603
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1604
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
 
1605
                if (r->ReceiveWindowSize > 0x40000) {
 
1606
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1607
                }
 
1608
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1609
        }
 
1610
        if (ndr_flags & NDR_BUFFERS) {
 
1611
        }
 
1612
        return NDR_ERR_SUCCESS;
 
1613
}
 
1614
 
 
1615
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ReceiveWindowSize *r)
 
1616
{
 
1617
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ReceiveWindowSize");
 
1618
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1619
        ndr->depth++;
 
1620
        ndr_print_uint32(ndr, "ReceiveWindowSize", r->ReceiveWindowSize);
 
1621
        ndr->depth--;
 
1622
}
 
1623
 
 
1624
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_FlowControlAck(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_FlowControlAck *r)
 
1625
{
 
1626
        if (ndr_flags & NDR_SCALARS) {
 
1627
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1628
                NDR_CHECK(ndr_push_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
 
1629
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1630
        }
 
1631
        if (ndr_flags & NDR_BUFFERS) {
 
1632
        }
 
1633
        return NDR_ERR_SUCCESS;
 
1634
}
 
1635
 
 
1636
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_FlowControlAck(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_FlowControlAck *r)
 
1637
{
 
1638
        if (ndr_flags & NDR_SCALARS) {
 
1639
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1640
                NDR_CHECK(ndr_pull_FlowControlAcknowledgment(ndr, NDR_SCALARS, &r->Ack));
 
1641
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1642
        }
 
1643
        if (ndr_flags & NDR_BUFFERS) {
 
1644
        }
 
1645
        return NDR_ERR_SUCCESS;
 
1646
}
 
1647
 
 
1648
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_FlowControlAck(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_FlowControlAck *r)
 
1649
{
 
1650
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_FlowControlAck");
 
1651
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1652
        ndr->depth++;
 
1653
        ndr_print_FlowControlAcknowledgment(ndr, "Ack", &r->Ack);
 
1654
        ndr->depth--;
 
1655
}
 
1656
 
 
1657
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
 
1658
{
 
1659
        if (ndr_flags & NDR_SCALARS) {
 
1660
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1661
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConnectionTimeout));
 
1662
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1663
        }
 
1664
        if (ndr_flags & NDR_BUFFERS) {
 
1665
        }
 
1666
        return NDR_ERR_SUCCESS;
 
1667
}
 
1668
 
 
1669
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ConnectionTimeout *r)
 
1670
{
 
1671
        if (ndr_flags & NDR_SCALARS) {
 
1672
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1673
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConnectionTimeout));
 
1674
                if (r->ConnectionTimeout > 0xDBBA00) {
 
1675
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1676
                }
 
1677
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1678
        }
 
1679
        if (ndr_flags & NDR_BUFFERS) {
 
1680
        }
 
1681
        return NDR_ERR_SUCCESS;
 
1682
}
 
1683
 
 
1684
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ConnectionTimeout(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ConnectionTimeout *r)
 
1685
{
 
1686
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ConnectionTimeout");
 
1687
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1688
        ndr->depth++;
 
1689
        ndr_print_uint32(ndr, "ConnectionTimeout", r->ConnectionTimeout);
 
1690
        ndr->depth--;
 
1691
}
 
1692
 
 
1693
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Cookie(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Cookie *r)
 
1694
{
 
1695
        if (ndr_flags & NDR_SCALARS) {
 
1696
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1697
                NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
 
1698
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1699
        }
 
1700
        if (ndr_flags & NDR_BUFFERS) {
 
1701
        }
 
1702
        return NDR_ERR_SUCCESS;
 
1703
}
 
1704
 
 
1705
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Cookie(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Cookie *r)
 
1706
{
 
1707
        if (ndr_flags & NDR_SCALARS) {
 
1708
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1709
                NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->Cookie));
 
1710
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1711
        }
 
1712
        if (ndr_flags & NDR_BUFFERS) {
 
1713
        }
 
1714
        return NDR_ERR_SUCCESS;
 
1715
}
 
1716
 
 
1717
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_Cookie(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Cookie *r)
 
1718
{
 
1719
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Cookie");
 
1720
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1721
        ndr->depth++;
 
1722
        ndr_print_RTSCookie(ndr, "Cookie", &r->Cookie);
 
1723
        ndr->depth--;
 
1724
}
 
1725
 
 
1726
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ChannelLifetime(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ChannelLifetime *r)
 
1727
{
 
1728
        if (ndr_flags & NDR_SCALARS) {
 
1729
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1730
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ChannelLifetime));
 
1731
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1732
        }
 
1733
        if (ndr_flags & NDR_BUFFERS) {
 
1734
        }
 
1735
        return NDR_ERR_SUCCESS;
 
1736
}
 
1737
 
 
1738
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ChannelLifetime(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ChannelLifetime *r)
 
1739
{
 
1740
        if (ndr_flags & NDR_SCALARS) {
 
1741
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1742
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ChannelLifetime));
 
1743
                if (r->ChannelLifetime > 0x80000000) {
 
1744
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1745
                }
 
1746
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1747
        }
 
1748
        if (ndr_flags & NDR_BUFFERS) {
 
1749
        }
 
1750
        return NDR_ERR_SUCCESS;
 
1751
}
 
1752
 
 
1753
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ChannelLifetime(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ChannelLifetime *r)
 
1754
{
 
1755
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ChannelLifetime");
 
1756
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1757
        ndr->depth++;
 
1758
        ndr_print_uint32(ndr, "ChannelLifetime", r->ChannelLifetime);
 
1759
        ndr->depth--;
 
1760
}
 
1761
 
 
1762
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientKeepalive(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ClientKeepalive *r)
 
1763
{
 
1764
        if (ndr_flags & NDR_SCALARS) {
 
1765
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1766
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClientKeepalive));
 
1767
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1768
        }
 
1769
        if (ndr_flags & NDR_BUFFERS) {
 
1770
        }
 
1771
        return NDR_ERR_SUCCESS;
 
1772
}
 
1773
 
 
1774
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientKeepalive(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ClientKeepalive *r)
 
1775
{
 
1776
        if (ndr_flags & NDR_SCALARS) {
 
1777
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1778
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClientKeepalive));
 
1779
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1780
        }
 
1781
        if (ndr_flags & NDR_BUFFERS) {
 
1782
        }
 
1783
        return NDR_ERR_SUCCESS;
 
1784
}
 
1785
 
 
1786
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientKeepalive(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientKeepalive *r)
 
1787
{
 
1788
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientKeepalive");
 
1789
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1790
        ndr->depth++;
 
1791
        ndr_print_uint32(ndr, "ClientKeepalive", r->ClientKeepalive);
 
1792
        ndr->depth--;
 
1793
}
 
1794
 
 
1795
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Version(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Version *r)
 
1796
{
 
1797
        if (ndr_flags & NDR_SCALARS) {
 
1798
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1799
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Version));
 
1800
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1801
        }
 
1802
        if (ndr_flags & NDR_BUFFERS) {
 
1803
        }
 
1804
        return NDR_ERR_SUCCESS;
 
1805
}
 
1806
 
 
1807
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Version(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Version *r)
 
1808
{
 
1809
        if (ndr_flags & NDR_SCALARS) {
 
1810
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1811
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Version));
 
1812
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1813
        }
 
1814
        if (ndr_flags & NDR_BUFFERS) {
 
1815
        }
 
1816
        return NDR_ERR_SUCCESS;
 
1817
}
 
1818
 
 
1819
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_Version(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Version *r)
 
1820
{
 
1821
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Version");
 
1822
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1823
        ndr->depth++;
 
1824
        ndr_print_uint32(ndr, "Version", r->Version);
 
1825
        ndr->depth--;
 
1826
}
 
1827
 
 
1828
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Empty *r)
 
1829
{
 
1830
        if (ndr_flags & NDR_SCALARS) {
 
1831
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1832
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1833
        }
 
1834
        if (ndr_flags & NDR_BUFFERS) {
 
1835
        }
 
1836
        return NDR_ERR_SUCCESS;
 
1837
}
 
1838
 
 
1839
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Empty *r)
 
1840
{
 
1841
        if (ndr_flags & NDR_SCALARS) {
 
1842
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1843
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1844
        }
 
1845
        if (ndr_flags & NDR_BUFFERS) {
 
1846
        }
 
1847
        return NDR_ERR_SUCCESS;
 
1848
}
 
1849
 
 
1850
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_Empty(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Empty *r)
 
1851
{
 
1852
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Empty");
 
1853
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1854
        ndr->depth++;
 
1855
        ndr->depth--;
 
1856
}
 
1857
 
 
1858
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Padding(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Padding *r)
 
1859
{
 
1860
        if (ndr_flags & NDR_SCALARS) {
 
1861
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1862
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ConformanceCount));
 
1863
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Padding, r->ConformanceCount));
 
1864
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1865
        }
 
1866
        if (ndr_flags & NDR_BUFFERS) {
 
1867
        }
 
1868
        return NDR_ERR_SUCCESS;
 
1869
}
 
1870
 
 
1871
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Padding(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Padding *r)
 
1872
{
 
1873
        if (ndr_flags & NDR_SCALARS) {
 
1874
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1875
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ConformanceCount));
 
1876
                if (r->ConformanceCount > 0xFFFF) {
 
1877
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1878
                }
 
1879
                NDR_PULL_ALLOC_N(ndr, r->Padding, r->ConformanceCount);
 
1880
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Padding, r->ConformanceCount));
 
1881
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1882
        }
 
1883
        if (ndr_flags & NDR_BUFFERS) {
 
1884
        }
 
1885
        return NDR_ERR_SUCCESS;
 
1886
}
 
1887
 
 
1888
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_Padding(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Padding *r)
 
1889
{
 
1890
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Padding");
 
1891
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1892
        ndr->depth++;
 
1893
        ndr_print_uint32(ndr, "ConformanceCount", r->ConformanceCount);
 
1894
        ndr_print_array_uint8(ndr, "Padding", r->Padding, r->ConformanceCount);
 
1895
        ndr->depth--;
 
1896
}
 
1897
 
 
1898
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_NegativeANCE(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_NegativeANCE *r)
 
1899
{
 
1900
        if (ndr_flags & NDR_SCALARS) {
 
1901
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1902
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1903
        }
 
1904
        if (ndr_flags & NDR_BUFFERS) {
 
1905
        }
 
1906
        return NDR_ERR_SUCCESS;
 
1907
}
 
1908
 
 
1909
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_NegativeANCE(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_NegativeANCE *r)
 
1910
{
 
1911
        if (ndr_flags & NDR_SCALARS) {
 
1912
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1913
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1914
        }
 
1915
        if (ndr_flags & NDR_BUFFERS) {
 
1916
        }
 
1917
        return NDR_ERR_SUCCESS;
 
1918
}
 
1919
 
 
1920
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_NegativeANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_NegativeANCE *r)
 
1921
{
 
1922
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_NegativeANCE");
 
1923
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1924
        ndr->depth++;
 
1925
        ndr->depth--;
 
1926
}
 
1927
 
 
1928
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ANCE(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ANCE *r)
 
1929
{
 
1930
        if (ndr_flags & NDR_SCALARS) {
 
1931
                NDR_CHECK(ndr_push_align(ndr, 1));
 
1932
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
 
1933
        }
 
1934
        if (ndr_flags & NDR_BUFFERS) {
 
1935
        }
 
1936
        return NDR_ERR_SUCCESS;
 
1937
}
 
1938
 
 
1939
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ANCE(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ANCE *r)
 
1940
{
 
1941
        if (ndr_flags & NDR_SCALARS) {
 
1942
                NDR_CHECK(ndr_pull_align(ndr, 1));
 
1943
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
 
1944
        }
 
1945
        if (ndr_flags & NDR_BUFFERS) {
 
1946
        }
 
1947
        return NDR_ERR_SUCCESS;
 
1948
}
 
1949
 
 
1950
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ANCE(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ANCE *r)
 
1951
{
 
1952
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ANCE");
 
1953
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1954
        ndr->depth++;
 
1955
        ndr->depth--;
 
1956
}
 
1957
 
 
1958
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_ClientAddress(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_ClientAddress *r)
 
1959
{
 
1960
        if (ndr_flags & NDR_SCALARS) {
 
1961
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1962
                NDR_CHECK(ndr_push_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
 
1963
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1964
        }
 
1965
        if (ndr_flags & NDR_BUFFERS) {
 
1966
        }
 
1967
        return NDR_ERR_SUCCESS;
 
1968
}
 
1969
 
 
1970
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_ClientAddress(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_ClientAddress *r)
 
1971
{
 
1972
        if (ndr_flags & NDR_SCALARS) {
 
1973
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
1974
                NDR_CHECK(ndr_pull_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
 
1975
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
1976
        }
 
1977
        if (ndr_flags & NDR_BUFFERS) {
 
1978
        }
 
1979
        return NDR_ERR_SUCCESS;
 
1980
}
 
1981
 
 
1982
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_ClientAddress(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_ClientAddress *r)
 
1983
{
 
1984
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_ClientAddress");
 
1985
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1986
        ndr->depth++;
 
1987
        ndr_print_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
 
1988
        ndr->depth--;
 
1989
}
 
1990
 
 
1991
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_AssociationGroupId(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_AssociationGroupId *r)
 
1992
{
 
1993
        if (ndr_flags & NDR_SCALARS) {
 
1994
                NDR_CHECK(ndr_push_align(ndr, 4));
 
1995
                NDR_CHECK(ndr_push_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
 
1996
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
1997
        }
 
1998
        if (ndr_flags & NDR_BUFFERS) {
 
1999
        }
 
2000
        return NDR_ERR_SUCCESS;
 
2001
}
 
2002
 
 
2003
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_AssociationGroupId(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_AssociationGroupId *r)
 
2004
{
 
2005
        if (ndr_flags & NDR_SCALARS) {
 
2006
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2007
                NDR_CHECK(ndr_pull_RTSCookie(ndr, NDR_SCALARS, &r->AssociationGroupId));
 
2008
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2009
        }
 
2010
        if (ndr_flags & NDR_BUFFERS) {
 
2011
        }
 
2012
        return NDR_ERR_SUCCESS;
 
2013
}
 
2014
 
 
2015
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_AssociationGroupId(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_AssociationGroupId *r)
 
2016
{
 
2017
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_AssociationGroupId");
 
2018
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2019
        ndr->depth++;
 
2020
        ndr_print_RTSCookie(ndr, "AssociationGroupId", &r->AssociationGroupId);
 
2021
        ndr->depth--;
 
2022
}
 
2023
 
 
2024
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_Destination(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_Destination *r)
 
2025
{
 
2026
        if (ndr_flags & NDR_SCALARS) {
 
2027
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2028
                NDR_CHECK(ndr_push_ForwardDestination(ndr, NDR_SCALARS, r->ForwardDestination));
 
2029
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2030
        }
 
2031
        if (ndr_flags & NDR_BUFFERS) {
 
2032
        }
 
2033
        return NDR_ERR_SUCCESS;
 
2034
}
 
2035
 
 
2036
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_Destination(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_Destination *r)
 
2037
{
 
2038
        if (ndr_flags & NDR_SCALARS) {
 
2039
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2040
                NDR_CHECK(ndr_pull_ForwardDestination(ndr, NDR_SCALARS, &r->ForwardDestination));
 
2041
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2042
        }
 
2043
        if (ndr_flags & NDR_BUFFERS) {
 
2044
        }
 
2045
        return NDR_ERR_SUCCESS;
 
2046
}
 
2047
 
 
2048
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_Destination(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_Destination *r)
 
2049
{
 
2050
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_Destination");
 
2051
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2052
        ndr->depth++;
 
2053
        ndr_print_ForwardDestination(ndr, "ForwardDestination", r->ForwardDestination);
 
2054
        ndr->depth--;
 
2055
}
 
2056
 
 
2057
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
 
2058
{
 
2059
        if (ndr_flags & NDR_SCALARS) {
 
2060
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2061
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->PingTrafficSent));
 
2062
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2063
        }
 
2064
        if (ndr_flags & NDR_BUFFERS) {
 
2065
        }
 
2066
        return NDR_ERR_SUCCESS;
 
2067
}
 
2068
 
 
2069
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
 
2070
{
 
2071
        if (ndr_flags & NDR_SCALARS) {
 
2072
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2073
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->PingTrafficSent));
 
2074
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2075
        }
 
2076
        if (ndr_flags & NDR_BUFFERS) {
 
2077
        }
 
2078
        return NDR_ERR_SUCCESS;
 
2079
}
 
2080
 
 
2081
_PUBLIC_ void ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd_PingTrafficSentNotify *r)
 
2082
{
 
2083
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd_PingTrafficSentNotify");
 
2084
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2085
        ndr->depth++;
 
2086
        ndr_print_uint32(ndr, "PingTrafficSent", r->PingTrafficSent);
 
2087
        ndr->depth--;
 
2088
}
 
2089
 
 
2090
static enum ndr_err_code ndr_push_dcerpc_rts_cmds(struct ndr_push *ndr, int ndr_flags, const union dcerpc_rts_cmds *r)
 
2091
{
 
2092
        if (ndr_flags & NDR_SCALARS) {
 
2093
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
2094
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
2095
                switch (level) {
 
2096
                        case 0x0: {
 
2097
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
 
2098
                        break; }
 
2099
 
 
2100
                        case 0x1: {
 
2101
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
 
2102
                        break; }
 
2103
 
 
2104
                        case 0x2: {
 
2105
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
 
2106
                        break; }
 
2107
 
 
2108
                        case 0x3: {
 
2109
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
 
2110
                        break; }
 
2111
 
 
2112
                        case 0x4: {
 
2113
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
 
2114
                        break; }
 
2115
 
 
2116
                        case 0x5: {
 
2117
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
 
2118
                        break; }
 
2119
 
 
2120
                        case 0x6: {
 
2121
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
 
2122
                        break; }
 
2123
 
 
2124
                        case 0x7: {
 
2125
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
 
2126
                        break; }
 
2127
 
 
2128
                        case 0x8: {
 
2129
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
 
2130
                        break; }
 
2131
 
 
2132
                        case 0x9: {
 
2133
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
 
2134
                        break; }
 
2135
 
 
2136
                        case 0xA: {
 
2137
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
 
2138
                        break; }
 
2139
 
 
2140
                        case 0xB: {
 
2141
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
 
2142
                        break; }
 
2143
 
 
2144
                        case 0xC: {
 
2145
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
 
2146
                        break; }
 
2147
 
 
2148
                        case 0xD: {
 
2149
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
 
2150
                        break; }
 
2151
 
 
2152
                        case 0xE: {
 
2153
                                NDR_CHECK(ndr_push_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
 
2154
                        break; }
 
2155
 
 
2156
                        default:
 
2157
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2158
                }
 
2159
        }
 
2160
        if (ndr_flags & NDR_BUFFERS) {
 
2161
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
2162
                switch (level) {
 
2163
                        case 0x0:
 
2164
                        break;
 
2165
 
 
2166
                        case 0x1:
 
2167
                        break;
 
2168
 
 
2169
                        case 0x2:
 
2170
                        break;
 
2171
 
 
2172
                        case 0x3:
 
2173
                        break;
 
2174
 
 
2175
                        case 0x4:
 
2176
                        break;
 
2177
 
 
2178
                        case 0x5:
 
2179
                        break;
 
2180
 
 
2181
                        case 0x6:
 
2182
                        break;
 
2183
 
 
2184
                        case 0x7:
 
2185
                        break;
 
2186
 
 
2187
                        case 0x8:
 
2188
                        break;
 
2189
 
 
2190
                        case 0x9:
 
2191
                        break;
 
2192
 
 
2193
                        case 0xA:
 
2194
                        break;
 
2195
 
 
2196
                        case 0xB:
 
2197
                        break;
 
2198
 
 
2199
                        case 0xC:
 
2200
                        break;
 
2201
 
 
2202
                        case 0xD:
 
2203
                        break;
 
2204
 
 
2205
                        case 0xE:
 
2206
                        break;
 
2207
 
 
2208
                        default:
 
2209
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2210
                }
 
2211
        }
 
2212
        return NDR_ERR_SUCCESS;
 
2213
}
 
2214
 
 
2215
static enum ndr_err_code ndr_pull_dcerpc_rts_cmds(struct ndr_pull *ndr, int ndr_flags, union dcerpc_rts_cmds *r)
 
2216
{
 
2217
        uint32_t level;
 
2218
        level = ndr_pull_get_switch_value(ndr, r);
 
2219
        if (ndr_flags & NDR_SCALARS) {
 
2220
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
2221
                switch (level) {
 
2222
                        case 0x0: {
 
2223
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ReceiveWindowSize(ndr, NDR_SCALARS, &r->ReceiveWindowSize));
 
2224
                        break; }
 
2225
 
 
2226
                        case 0x1: {
 
2227
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_FlowControlAck(ndr, NDR_SCALARS, &r->FlowControlAck));
 
2228
                        break; }
 
2229
 
 
2230
                        case 0x2: {
 
2231
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ConnectionTimeout(ndr, NDR_SCALARS, &r->ConnectionTimeout));
 
2232
                        break; }
 
2233
 
 
2234
                        case 0x3: {
 
2235
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Cookie(ndr, NDR_SCALARS, &r->Cookie));
 
2236
                        break; }
 
2237
 
 
2238
                        case 0x4: {
 
2239
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ChannelLifetime(ndr, NDR_SCALARS, &r->ChannelLifetime));
 
2240
                        break; }
 
2241
 
 
2242
                        case 0x5: {
 
2243
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientKeepalive(ndr, NDR_SCALARS, &r->ClientKeepalive));
 
2244
                        break; }
 
2245
 
 
2246
                        case 0x6: {
 
2247
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Version(ndr, NDR_SCALARS, &r->Version));
 
2248
                        break; }
 
2249
 
 
2250
                        case 0x7: {
 
2251
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Empty(ndr, NDR_SCALARS, &r->Empty));
 
2252
                        break; }
 
2253
 
 
2254
                        case 0x8: {
 
2255
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Padding(ndr, NDR_SCALARS, &r->Padding));
 
2256
                        break; }
 
2257
 
 
2258
                        case 0x9: {
 
2259
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_NegativeANCE(ndr, NDR_SCALARS, &r->NegativeANCE));
 
2260
                        break; }
 
2261
 
 
2262
                        case 0xA: {
 
2263
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ANCE(ndr, NDR_SCALARS, &r->ANCE));
 
2264
                        break; }
 
2265
 
 
2266
                        case 0xB: {
 
2267
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_ClientAddress(ndr, NDR_SCALARS, &r->ClientAddress));
 
2268
                        break; }
 
2269
 
 
2270
                        case 0xC: {
 
2271
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_AssociationGroupId(ndr, NDR_SCALARS, &r->AssociationGroupId));
 
2272
                        break; }
 
2273
 
 
2274
                        case 0xD: {
 
2275
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_Destination(ndr, NDR_SCALARS, &r->Destination));
 
2276
                        break; }
 
2277
 
 
2278
                        case 0xE: {
 
2279
                                NDR_CHECK(ndr_pull_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, NDR_SCALARS, &r->PingTrafficSentNotify));
 
2280
                        break; }
 
2281
 
 
2282
                        default:
 
2283
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2284
                }
 
2285
        }
 
2286
        if (ndr_flags & NDR_BUFFERS) {
 
2287
                switch (level) {
 
2288
                        case 0x0:
 
2289
                        break;
 
2290
 
 
2291
                        case 0x1:
 
2292
                        break;
 
2293
 
 
2294
                        case 0x2:
 
2295
                        break;
 
2296
 
 
2297
                        case 0x3:
 
2298
                        break;
 
2299
 
 
2300
                        case 0x4:
 
2301
                        break;
 
2302
 
 
2303
                        case 0x5:
 
2304
                        break;
 
2305
 
 
2306
                        case 0x6:
 
2307
                        break;
 
2308
 
 
2309
                        case 0x7:
 
2310
                        break;
 
2311
 
 
2312
                        case 0x8:
 
2313
                        break;
 
2314
 
 
2315
                        case 0x9:
 
2316
                        break;
 
2317
 
 
2318
                        case 0xA:
 
2319
                        break;
 
2320
 
 
2321
                        case 0xB:
 
2322
                        break;
 
2323
 
 
2324
                        case 0xC:
 
2325
                        break;
 
2326
 
 
2327
                        case 0xD:
 
2328
                        break;
 
2329
 
 
2330
                        case 0xE:
 
2331
                        break;
 
2332
 
 
2333
                        default:
 
2334
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2335
                }
 
2336
        }
 
2337
        return NDR_ERR_SUCCESS;
 
2338
}
 
2339
 
 
2340
_PUBLIC_ void ndr_print_dcerpc_rts_cmds(struct ndr_print *ndr, const char *name, const union dcerpc_rts_cmds *r)
 
2341
{
 
2342
        uint32_t level;
 
2343
        level = ndr_print_get_switch_value(ndr, r);
 
2344
        ndr_print_union(ndr, name, level, "dcerpc_rts_cmds");
 
2345
        switch (level) {
 
2346
                case 0x0:
 
2347
                        ndr_print_dcerpc_rts_cmd_ReceiveWindowSize(ndr, "ReceiveWindowSize", &r->ReceiveWindowSize);
 
2348
                break;
 
2349
 
 
2350
                case 0x1:
 
2351
                        ndr_print_dcerpc_rts_cmd_FlowControlAck(ndr, "FlowControlAck", &r->FlowControlAck);
 
2352
                break;
 
2353
 
 
2354
                case 0x2:
 
2355
                        ndr_print_dcerpc_rts_cmd_ConnectionTimeout(ndr, "ConnectionTimeout", &r->ConnectionTimeout);
 
2356
                break;
 
2357
 
 
2358
                case 0x3:
 
2359
                        ndr_print_dcerpc_rts_cmd_Cookie(ndr, "Cookie", &r->Cookie);
 
2360
                break;
 
2361
 
 
2362
                case 0x4:
 
2363
                        ndr_print_dcerpc_rts_cmd_ChannelLifetime(ndr, "ChannelLifetime", &r->ChannelLifetime);
 
2364
                break;
 
2365
 
 
2366
                case 0x5:
 
2367
                        ndr_print_dcerpc_rts_cmd_ClientKeepalive(ndr, "ClientKeepalive", &r->ClientKeepalive);
 
2368
                break;
 
2369
 
 
2370
                case 0x6:
 
2371
                        ndr_print_dcerpc_rts_cmd_Version(ndr, "Version", &r->Version);
 
2372
                break;
 
2373
 
 
2374
                case 0x7:
 
2375
                        ndr_print_dcerpc_rts_cmd_Empty(ndr, "Empty", &r->Empty);
 
2376
                break;
 
2377
 
 
2378
                case 0x8:
 
2379
                        ndr_print_dcerpc_rts_cmd_Padding(ndr, "Padding", &r->Padding);
 
2380
                break;
 
2381
 
 
2382
                case 0x9:
 
2383
                        ndr_print_dcerpc_rts_cmd_NegativeANCE(ndr, "NegativeANCE", &r->NegativeANCE);
 
2384
                break;
 
2385
 
 
2386
                case 0xA:
 
2387
                        ndr_print_dcerpc_rts_cmd_ANCE(ndr, "ANCE", &r->ANCE);
 
2388
                break;
 
2389
 
 
2390
                case 0xB:
 
2391
                        ndr_print_dcerpc_rts_cmd_ClientAddress(ndr, "ClientAddress", &r->ClientAddress);
 
2392
                break;
 
2393
 
 
2394
                case 0xC:
 
2395
                        ndr_print_dcerpc_rts_cmd_AssociationGroupId(ndr, "AssociationGroupId", &r->AssociationGroupId);
 
2396
                break;
 
2397
 
 
2398
                case 0xD:
 
2399
                        ndr_print_dcerpc_rts_cmd_Destination(ndr, "Destination", &r->Destination);
 
2400
                break;
 
2401
 
 
2402
                case 0xE:
 
2403
                        ndr_print_dcerpc_rts_cmd_PingTrafficSentNotify(ndr, "PingTrafficSentNotify", &r->PingTrafficSentNotify);
 
2404
                break;
 
2405
 
 
2406
                default:
 
2407
                        ndr_print_bad_level(ndr, name, level);
 
2408
        }
 
2409
}
 
2410
 
 
2411
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_cmd(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts_cmd *r)
 
2412
{
 
2413
        if (ndr_flags & NDR_SCALARS) {
 
2414
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2415
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CommandType));
 
2416
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->Command, r->CommandType));
 
2417
                NDR_CHECK(ndr_push_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
 
2418
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2419
        }
 
2420
        if (ndr_flags & NDR_BUFFERS) {
 
2421
        }
 
2422
        return NDR_ERR_SUCCESS;
 
2423
}
 
2424
 
 
2425
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_cmd(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts_cmd *r)
 
2426
{
 
2427
        if (ndr_flags & NDR_SCALARS) {
 
2428
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2429
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CommandType));
 
2430
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->Command, r->CommandType));
 
2431
                NDR_CHECK(ndr_pull_dcerpc_rts_cmds(ndr, NDR_SCALARS, &r->Command));
 
2432
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2433
        }
 
2434
        if (ndr_flags & NDR_BUFFERS) {
 
2435
        }
 
2436
        return NDR_ERR_SUCCESS;
 
2437
}
 
2438
 
 
2439
_PUBLIC_ void ndr_print_dcerpc_rts_cmd(struct ndr_print *ndr, const char *name, const struct dcerpc_rts_cmd *r)
 
2440
{
 
2441
        ndr_print_struct(ndr, name, "dcerpc_rts_cmd");
 
2442
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2443
        ndr->depth++;
 
2444
        ndr_print_uint32(ndr, "CommandType", r->CommandType);
 
2445
        ndr_print_set_switch_value(ndr, &r->Command, r->CommandType);
 
2446
        ndr_print_dcerpc_rts_cmds(ndr, "Command", &r->Command);
 
2447
        ndr->depth--;
 
2448
}
 
2449
 
 
2450
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts_flags(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 
2451
{
 
2452
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
2453
        return NDR_ERR_SUCCESS;
 
2454
}
 
2455
 
 
2456
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts_flags(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 
2457
{
 
2458
        uint16_t v;
 
2459
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
2460
        *r = v;
 
2461
        return NDR_ERR_SUCCESS;
 
2462
}
 
2463
 
 
2464
_PUBLIC_ void ndr_print_dcerpc_rts_flags(struct ndr_print *ndr, const char *name, uint16_t r)
 
2465
{
 
2466
        ndr_print_uint16(ndr, name, r);
 
2467
        ndr->depth++;
 
2468
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_NONE", RTS_FLAG_NONE, r);
 
2469
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_PING", RTS_FLAG_PING, r);
 
2470
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OTHER_CMD", RTS_FLAG_OTHER_CMD, r);
 
2471
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_RECYCLE_CHANNEL", RTS_FLAG_RECYCLE_CHANNEL, r);
 
2472
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_IN_CHANNEL", RTS_FLAG_IN_CHANNEL, r);
 
2473
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_OUT_CHANNEL", RTS_FLAG_OUT_CHANNEL, r);
 
2474
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_EOF", RTS_FLAG_EOF, r);
 
2475
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "RTS_FLAG_ECHO", RTS_FLAG_ECHO, r);
 
2476
        ndr->depth--;
 
2477
}
 
2478
 
 
2479
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_rts(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_rts *r)
 
2480
{
 
2481
        uint32_t cntr_Commands_0;
 
2482
        if (ndr_flags & NDR_SCALARS) {
 
2483
                NDR_CHECK(ndr_push_align(ndr, 4));
 
2484
                NDR_CHECK(ndr_push_dcerpc_rts_flags(ndr, NDR_SCALARS, r->Flags));
 
2485
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumberOfCommands));
 
2486
                for (cntr_Commands_0 = 0; cntr_Commands_0 < r->NumberOfCommands; cntr_Commands_0++) {
 
2487
                        NDR_CHECK(ndr_push_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
 
2488
                }
 
2489
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
2490
        }
 
2491
        if (ndr_flags & NDR_BUFFERS) {
 
2492
        }
 
2493
        return NDR_ERR_SUCCESS;
 
2494
}
 
2495
 
 
2496
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_rts(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_rts *r)
 
2497
{
 
2498
        uint32_t cntr_Commands_0;
 
2499
        TALLOC_CTX *_mem_save_Commands_0;
 
2500
        if (ndr_flags & NDR_SCALARS) {
 
2501
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
2502
                NDR_CHECK(ndr_pull_dcerpc_rts_flags(ndr, NDR_SCALARS, &r->Flags));
 
2503
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumberOfCommands));
 
2504
                NDR_PULL_ALLOC_N(ndr, r->Commands, r->NumberOfCommands);
 
2505
                _mem_save_Commands_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2506
                NDR_PULL_SET_MEM_CTX(ndr, r->Commands, 0);
 
2507
                for (cntr_Commands_0 = 0; cntr_Commands_0 < r->NumberOfCommands; cntr_Commands_0++) {
 
2508
                        NDR_CHECK(ndr_pull_dcerpc_rts_cmd(ndr, NDR_SCALARS, &r->Commands[cntr_Commands_0]));
 
2509
                }
 
2510
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Commands_0, 0);
 
2511
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
2512
        }
 
2513
        if (ndr_flags & NDR_BUFFERS) {
 
2514
        }
 
2515
        return NDR_ERR_SUCCESS;
 
2516
}
 
2517
 
 
2518
_PUBLIC_ void ndr_print_dcerpc_rts(struct ndr_print *ndr, const char *name, const struct dcerpc_rts *r)
 
2519
{
 
2520
        uint32_t cntr_Commands_0;
 
2521
        ndr_print_struct(ndr, name, "dcerpc_rts");
 
2522
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2523
        ndr->depth++;
 
2524
        ndr_print_dcerpc_rts_flags(ndr, "Flags", r->Flags);
 
2525
        ndr_print_uint16(ndr, "NumberOfCommands", r->NumberOfCommands);
 
2526
        ndr->print(ndr, "%s: ARRAY(%d)", "Commands", (int)r->NumberOfCommands);
 
2527
        ndr->depth++;
 
2528
        for (cntr_Commands_0=0;cntr_Commands_0<r->NumberOfCommands;cntr_Commands_0++) {
 
2529
                ndr_print_dcerpc_rts_cmd(ndr, "Commands", &r->Commands[cntr_Commands_0]);
 
2530
        }
 
2531
        ndr->depth--;
 
2532
        ndr->depth--;
 
2533
}
 
2534
 
 
2535
static enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, int ndr_flags, enum dcerpc_pkt_type r)
 
2536
{
 
2537
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
 
2538
        return NDR_ERR_SUCCESS;
 
2539
}
 
2540
 
 
2541
static enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_pkt_type *r)
 
2542
{
 
2543
        uint8_t v;
 
2544
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
 
2545
        *r = v;
 
2546
        return NDR_ERR_SUCCESS;
 
2547
}
 
2548
 
 
2549
_PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
 
2550
{
 
2551
        const char *val = NULL;
 
2552
 
 
2553
        switch (r) {
 
2554
                case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
 
2555
                case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
 
2556
                case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
 
2557
                case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
 
2558
                case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
 
2559
                case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
 
2560
                case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
 
2561
                case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
 
2562
                case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
 
2563
                case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
 
2564
                case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
 
2565
                case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
 
2566
                case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
 
2567
                case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
 
2568
                case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
 
2569
                case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
 
2570
                case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
 
2571
                case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
 
2572
                case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
 
2573
                case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
 
2574
                case DCERPC_PKT_RTS: val = "DCERPC_PKT_RTS"; break;
 
2575
        }
 
2576
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
2577
}
 
2578
 
 
2579
static enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, int ndr_flags, const union dcerpc_payload *r)
 
2580
{
 
2581
        if (ndr_flags & NDR_SCALARS) {
 
2582
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
2583
                NDR_CHECK(ndr_push_union_align(ndr, 4));
 
2584
                switch (level) {
 
2585
                        case DCERPC_PKT_REQUEST: {
 
2586
                                NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
 
2587
                        break; }
 
2588
 
 
2589
                        case DCERPC_PKT_PING: {
 
2590
                                NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
 
2591
                        break; }
 
2592
 
 
2593
                        case DCERPC_PKT_RESPONSE: {
 
2594
                                NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
 
2595
                        break; }
 
2596
 
 
2597
                        case DCERPC_PKT_FAULT: {
 
2598
                                NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
 
2599
                        break; }
 
2600
 
 
2601
                        case DCERPC_PKT_WORKING: {
 
2602
                                NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
 
2603
                        break; }
 
2604
 
 
2605
                        case DCERPC_PKT_NOCALL: {
 
2606
                                NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
 
2607
                        break; }
 
2608
 
 
2609
                        case DCERPC_PKT_REJECT: {
 
2610
                                NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
 
2611
                        break; }
 
2612
 
 
2613
                        case DCERPC_PKT_ACK: {
 
2614
                                NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
 
2615
                        break; }
 
2616
 
 
2617
                        case DCERPC_PKT_CL_CANCEL: {
 
2618
                                NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
 
2619
                        break; }
 
2620
 
 
2621
                        case DCERPC_PKT_FACK: {
 
2622
                                NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
 
2623
                        break; }
 
2624
 
 
2625
                        case DCERPC_PKT_CANCEL_ACK: {
 
2626
                                NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
 
2627
                        break; }
 
2628
 
 
2629
                        case DCERPC_PKT_BIND: {
 
2630
                                NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
 
2631
                        break; }
 
2632
 
 
2633
                        case DCERPC_PKT_BIND_ACK: {
 
2634
                                NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
 
2635
                        break; }
 
2636
 
 
2637
                        case DCERPC_PKT_BIND_NAK: {
 
2638
                                NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
 
2639
                        break; }
 
2640
 
 
2641
                        case DCERPC_PKT_ALTER: {
 
2642
                                NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
 
2643
                        break; }
 
2644
 
 
2645
                        case DCERPC_PKT_ALTER_RESP: {
 
2646
                                NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
 
2647
                        break; }
 
2648
 
 
2649
                        case DCERPC_PKT_SHUTDOWN: {
 
2650
                                NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
 
2651
                        break; }
 
2652
 
 
2653
                        case DCERPC_PKT_CO_CANCEL: {
 
2654
                                NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
 
2655
                        break; }
 
2656
 
 
2657
                        case DCERPC_PKT_ORPHANED: {
 
2658
                                NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
 
2659
                        break; }
 
2660
 
 
2661
                        case DCERPC_PKT_AUTH3: {
 
2662
                                NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
 
2663
                        break; }
 
2664
 
 
2665
                        case DCERPC_PKT_RTS: {
 
2666
                                NDR_CHECK(ndr_push_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
 
2667
                        break; }
 
2668
 
 
2669
                        default:
 
2670
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2671
                }
 
2672
        }
 
2673
        if (ndr_flags & NDR_BUFFERS) {
 
2674
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
2675
                switch (level) {
 
2676
                        case DCERPC_PKT_REQUEST:
 
2677
                        break;
 
2678
 
 
2679
                        case DCERPC_PKT_PING:
 
2680
                        break;
 
2681
 
 
2682
                        case DCERPC_PKT_RESPONSE:
 
2683
                        break;
 
2684
 
 
2685
                        case DCERPC_PKT_FAULT:
 
2686
                        break;
 
2687
 
 
2688
                        case DCERPC_PKT_WORKING:
 
2689
                        break;
 
2690
 
 
2691
                        case DCERPC_PKT_NOCALL:
 
2692
                        break;
 
2693
 
 
2694
                        case DCERPC_PKT_REJECT:
 
2695
                        break;
 
2696
 
 
2697
                        case DCERPC_PKT_ACK:
 
2698
                        break;
 
2699
 
 
2700
                        case DCERPC_PKT_CL_CANCEL:
 
2701
                        break;
 
2702
 
 
2703
                        case DCERPC_PKT_FACK:
 
2704
                        break;
 
2705
 
 
2706
                        case DCERPC_PKT_CANCEL_ACK:
 
2707
                        break;
 
2708
 
 
2709
                        case DCERPC_PKT_BIND:
 
2710
                        break;
 
2711
 
 
2712
                        case DCERPC_PKT_BIND_ACK:
 
2713
                        break;
 
2714
 
 
2715
                        case DCERPC_PKT_BIND_NAK:
 
2716
                                NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
 
2717
                        break;
 
2718
 
 
2719
                        case DCERPC_PKT_ALTER:
 
2720
                        break;
 
2721
 
 
2722
                        case DCERPC_PKT_ALTER_RESP:
 
2723
                        break;
 
2724
 
 
2725
                        case DCERPC_PKT_SHUTDOWN:
 
2726
                        break;
 
2727
 
 
2728
                        case DCERPC_PKT_CO_CANCEL:
 
2729
                        break;
 
2730
 
 
2731
                        case DCERPC_PKT_ORPHANED:
 
2732
                        break;
 
2733
 
 
2734
                        case DCERPC_PKT_AUTH3:
 
2735
                        break;
 
2736
 
 
2737
                        case DCERPC_PKT_RTS:
 
2738
                        break;
 
2739
 
 
2740
                        default:
 
2741
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2742
                }
 
2743
        }
 
2744
        return NDR_ERR_SUCCESS;
 
2745
}
 
2746
 
 
2747
static enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, int ndr_flags, union dcerpc_payload *r)
 
2748
{
 
2749
        uint32_t level;
 
2750
        level = ndr_pull_get_switch_value(ndr, r);
 
2751
        if (ndr_flags & NDR_SCALARS) {
 
2752
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
 
2753
                switch (level) {
 
2754
                        case DCERPC_PKT_REQUEST: {
 
2755
                                NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
 
2756
                        break; }
 
2757
 
 
2758
                        case DCERPC_PKT_PING: {
 
2759
                                NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
 
2760
                        break; }
 
2761
 
 
2762
                        case DCERPC_PKT_RESPONSE: {
 
2763
                                NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
 
2764
                        break; }
 
2765
 
 
2766
                        case DCERPC_PKT_FAULT: {
 
2767
                                NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
 
2768
                        break; }
 
2769
 
 
2770
                        case DCERPC_PKT_WORKING: {
 
2771
                                NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
 
2772
                        break; }
 
2773
 
 
2774
                        case DCERPC_PKT_NOCALL: {
 
2775
                                NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
 
2776
                        break; }
 
2777
 
 
2778
                        case DCERPC_PKT_REJECT: {
 
2779
                                NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
 
2780
                        break; }
 
2781
 
 
2782
                        case DCERPC_PKT_ACK: {
 
2783
                                NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
 
2784
                        break; }
 
2785
 
 
2786
                        case DCERPC_PKT_CL_CANCEL: {
 
2787
                                NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
 
2788
                        break; }
 
2789
 
 
2790
                        case DCERPC_PKT_FACK: {
 
2791
                                NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
 
2792
                        break; }
 
2793
 
 
2794
                        case DCERPC_PKT_CANCEL_ACK: {
 
2795
                                NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
 
2796
                        break; }
 
2797
 
 
2798
                        case DCERPC_PKT_BIND: {
 
2799
                                NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
 
2800
                        break; }
 
2801
 
 
2802
                        case DCERPC_PKT_BIND_ACK: {
 
2803
                                NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
 
2804
                        break; }
 
2805
 
 
2806
                        case DCERPC_PKT_BIND_NAK: {
 
2807
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
 
2808
                        break; }
 
2809
 
 
2810
                        case DCERPC_PKT_ALTER: {
 
2811
                                NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
 
2812
                        break; }
 
2813
 
 
2814
                        case DCERPC_PKT_ALTER_RESP: {
 
2815
                                NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
 
2816
                        break; }
 
2817
 
 
2818
                        case DCERPC_PKT_SHUTDOWN: {
 
2819
                                NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
 
2820
                        break; }
 
2821
 
 
2822
                        case DCERPC_PKT_CO_CANCEL: {
 
2823
                                NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
 
2824
                        break; }
 
2825
 
 
2826
                        case DCERPC_PKT_ORPHANED: {
 
2827
                                NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
 
2828
                        break; }
 
2829
 
 
2830
                        case DCERPC_PKT_AUTH3: {
 
2831
                                NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
 
2832
                        break; }
 
2833
 
 
2834
                        case DCERPC_PKT_RTS: {
 
2835
                                NDR_CHECK(ndr_pull_dcerpc_rts(ndr, NDR_SCALARS, &r->rts));
 
2836
                        break; }
 
2837
 
 
2838
                        default:
 
2839
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2840
                }
 
2841
        }
 
2842
        if (ndr_flags & NDR_BUFFERS) {
 
2843
                switch (level) {
 
2844
                        case DCERPC_PKT_REQUEST:
 
2845
                        break;
 
2846
 
 
2847
                        case DCERPC_PKT_PING:
 
2848
                        break;
 
2849
 
 
2850
                        case DCERPC_PKT_RESPONSE:
 
2851
                        break;
 
2852
 
 
2853
                        case DCERPC_PKT_FAULT:
 
2854
                        break;
 
2855
 
 
2856
                        case DCERPC_PKT_WORKING:
 
2857
                        break;
 
2858
 
 
2859
                        case DCERPC_PKT_NOCALL:
 
2860
                        break;
 
2861
 
 
2862
                        case DCERPC_PKT_REJECT:
 
2863
                        break;
 
2864
 
 
2865
                        case DCERPC_PKT_ACK:
 
2866
                        break;
 
2867
 
 
2868
                        case DCERPC_PKT_CL_CANCEL:
 
2869
                        break;
 
2870
 
 
2871
                        case DCERPC_PKT_FACK:
 
2872
                        break;
 
2873
 
 
2874
                        case DCERPC_PKT_CANCEL_ACK:
 
2875
                        break;
 
2876
 
 
2877
                        case DCERPC_PKT_BIND:
 
2878
                        break;
 
2879
 
 
2880
                        case DCERPC_PKT_BIND_ACK:
 
2881
                        break;
 
2882
 
 
2883
                        case DCERPC_PKT_BIND_NAK:
 
2884
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
 
2885
                        break;
 
2886
 
 
2887
                        case DCERPC_PKT_ALTER:
 
2888
                        break;
 
2889
 
 
2890
                        case DCERPC_PKT_ALTER_RESP:
 
2891
                        break;
 
2892
 
 
2893
                        case DCERPC_PKT_SHUTDOWN:
 
2894
                        break;
 
2895
 
 
2896
                        case DCERPC_PKT_CO_CANCEL:
 
2897
                        break;
 
2898
 
 
2899
                        case DCERPC_PKT_ORPHANED:
 
2900
                        break;
 
2901
 
 
2902
                        case DCERPC_PKT_AUTH3:
 
2903
                        break;
 
2904
 
 
2905
                        case DCERPC_PKT_RTS:
 
2906
                        break;
 
2907
 
 
2908
                        default:
 
2909
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
2910
                }
 
2911
        }
 
2912
        return NDR_ERR_SUCCESS;
 
2913
}
 
2914
 
 
2915
_PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
 
2916
{
 
2917
        uint32_t level;
 
2918
        level = ndr_print_get_switch_value(ndr, r);
 
2919
        ndr_print_union(ndr, name, level, "dcerpc_payload");
 
2920
        switch (level) {
 
2921
                case DCERPC_PKT_REQUEST:
 
2922
                        ndr_print_dcerpc_request(ndr, "request", &r->request);
 
2923
                break;
 
2924
 
 
2925
                case DCERPC_PKT_PING:
 
2926
                        ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
 
2927
                break;
 
2928
 
 
2929
                case DCERPC_PKT_RESPONSE:
 
2930
                        ndr_print_dcerpc_response(ndr, "response", &r->response);
 
2931
                break;
 
2932
 
 
2933
                case DCERPC_PKT_FAULT:
 
2934
                        ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
 
2935
                break;
 
2936
 
 
2937
                case DCERPC_PKT_WORKING:
 
2938
                        ndr_print_dcerpc_working(ndr, "working", &r->working);
 
2939
                break;
 
2940
 
 
2941
                case DCERPC_PKT_NOCALL:
 
2942
                        ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
 
2943
                break;
 
2944
 
 
2945
                case DCERPC_PKT_REJECT:
 
2946
                        ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
 
2947
                break;
 
2948
 
 
2949
                case DCERPC_PKT_ACK:
 
2950
                        ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
 
2951
                break;
 
2952
 
 
2953
                case DCERPC_PKT_CL_CANCEL:
 
2954
                        ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
 
2955
                break;
 
2956
 
 
2957
                case DCERPC_PKT_FACK:
 
2958
                        ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
 
2959
                break;
 
2960
 
 
2961
                case DCERPC_PKT_CANCEL_ACK:
 
2962
                        ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
 
2963
                break;
 
2964
 
 
2965
                case DCERPC_PKT_BIND:
 
2966
                        ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
 
2967
                break;
 
2968
 
 
2969
                case DCERPC_PKT_BIND_ACK:
 
2970
                        ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
 
2971
                break;
 
2972
 
 
2973
                case DCERPC_PKT_BIND_NAK:
 
2974
                        ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
 
2975
                break;
 
2976
 
 
2977
                case DCERPC_PKT_ALTER:
 
2978
                        ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
 
2979
                break;
 
2980
 
 
2981
                case DCERPC_PKT_ALTER_RESP:
 
2982
                        ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
 
2983
                break;
 
2984
 
 
2985
                case DCERPC_PKT_SHUTDOWN:
 
2986
                        ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
 
2987
                break;
 
2988
 
 
2989
                case DCERPC_PKT_CO_CANCEL:
 
2990
                        ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
 
2991
                break;
 
2992
 
 
2993
                case DCERPC_PKT_ORPHANED:
 
2994
                        ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
 
2995
                break;
 
2996
 
 
2997
                case DCERPC_PKT_AUTH3:
 
2998
                        ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
 
2999
                break;
 
3000
 
 
3001
                case DCERPC_PKT_RTS:
 
3002
                        ndr_print_dcerpc_rts(ndr, "rts", &r->rts);
 
3003
                break;
 
3004
 
 
3005
                default:
 
3006
                        ndr_print_bad_level(ndr, name, level);
 
3007
        }
 
3008
}
 
3009
 
 
3010
_PUBLIC_ enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_flags, const struct ncacn_packet *r)
 
3011
{
 
3012
        if (ndr_flags & NDR_SCALARS) {
 
3013
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3014
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
 
3015
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
 
3016
                NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
 
3017
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
 
3018
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
 
3019
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->frag_length));
 
3020
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->auth_length));
 
3021
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
 
3022
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
 
3023
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
 
3024
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
3025
        }
 
3026
        if (ndr_flags & NDR_BUFFERS) {
 
3027
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
 
3028
        }
 
3029
        return NDR_ERR_SUCCESS;
 
3030
}
 
3031
 
 
3032
_PUBLIC_ enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_flags, struct ncacn_packet *r)
 
3033
{
 
3034
        if (ndr_flags & NDR_SCALARS) {
 
3035
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3036
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
 
3037
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
 
3038
                NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
 
3039
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
 
3040
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
 
3041
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->frag_length));
 
3042
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->auth_length));
 
3043
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
 
3044
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
 
3045
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
 
3046
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
3047
        }
 
3048
        if (ndr_flags & NDR_BUFFERS) {
 
3049
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
 
3050
        }
 
3051
        return NDR_ERR_SUCCESS;
 
3052
}
 
3053
 
 
3054
_PUBLIC_ void ndr_print_ncacn_packet(struct ndr_print *ndr, const char *name, const struct ncacn_packet *r)
 
3055
{
 
3056
        ndr_print_struct(ndr, name, "ncacn_packet");
 
3057
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3058
        ndr->depth++;
 
3059
        ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
 
3060
        ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
 
3061
        ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
 
3062
        ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
 
3063
        ndr_print_array_uint8(ndr, "drep", r->drep, 4);
 
3064
        ndr_print_uint16(ndr, "frag_length", r->frag_length);
 
3065
        ndr_print_uint16(ndr, "auth_length", r->auth_length);
 
3066
        ndr_print_uint32(ndr, "call_id", r->call_id);
 
3067
        ndr_print_set_switch_value(ndr, &r->u, r->ptype);
 
3068
        ndr_print_dcerpc_payload(ndr, "u", &r->u);
 
3069
        ndr->depth--;
 
3070
}
 
3071
 
 
3072
_PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_flags, const struct ncadg_packet *r)
 
3073
{
 
3074
        if (ndr_flags & NDR_SCALARS) {
 
3075
                NDR_CHECK(ndr_push_align(ndr, 4));
 
3076
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
 
3077
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
 
3078
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
 
3079
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
 
3080
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
 
3081
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
 
3082
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
 
3083
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
 
3084
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
 
3085
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
 
3086
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
 
3087
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
 
3088
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
 
3089
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
 
3090
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
 
3091
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
 
3092
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
 
3093
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
 
3094
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
 
3095
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
 
3096
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
 
3097
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
3098
        }
 
3099
        if (ndr_flags & NDR_BUFFERS) {
 
3100
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
 
3101
        }
 
3102
        return NDR_ERR_SUCCESS;
 
3103
}
 
3104
 
 
3105
_PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_flags, struct ncadg_packet *r)
 
3106
{
 
3107
        if (ndr_flags & NDR_SCALARS) {
 
3108
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
3109
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
 
3110
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
 
3111
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
 
3112
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
 
3113
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
 
3114
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
 
3115
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
 
3116
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
 
3117
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
 
3118
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
 
3119
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
 
3120
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
 
3121
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
 
3122
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
 
3123
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
 
3124
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
 
3125
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
 
3126
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
 
3127
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
 
3128
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
 
3129
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
 
3130
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
3131
        }
 
3132
        if (ndr_flags & NDR_BUFFERS) {
 
3133
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
 
3134
        }
 
3135
        return NDR_ERR_SUCCESS;
 
3136
}
 
3137
 
 
3138
_PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
 
3139
{
 
3140
        ndr_print_struct(ndr, name, "ncadg_packet");
 
3141
        if (r == NULL) { ndr_print_null(ndr); return; }
 
3142
        ndr->depth++;
 
3143
        ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
 
3144
        ndr_print_uint8(ndr, "ptype", r->ptype);
 
3145
        ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
 
3146
        ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
 
3147
        ndr_print_array_uint8(ndr, "drep", r->drep, 3);
 
3148
        ndr_print_uint8(ndr, "serial_high", r->serial_high);
 
3149
        ndr_print_GUID(ndr, "object", &r->object);
 
3150
        ndr_print_GUID(ndr, "iface", &r->iface);
 
3151
        ndr_print_GUID(ndr, "activity", &r->activity);
 
3152
        ndr_print_uint32(ndr, "server_boot", r->server_boot);
 
3153
        ndr_print_uint32(ndr, "iface_version", r->iface_version);
 
3154
        ndr_print_uint32(ndr, "seq_num", r->seq_num);
 
3155
        ndr_print_uint16(ndr, "opnum", r->opnum);
 
3156
        ndr_print_uint16(ndr, "ihint", r->ihint);
 
3157
        ndr_print_uint16(ndr, "ahint", r->ahint);
 
3158
        ndr_print_uint16(ndr, "len", r->len);
 
3159
        ndr_print_uint16(ndr, "fragnum", r->fragnum);
 
3160
        ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
 
3161
        ndr_print_uint8(ndr, "serial_low", r->serial_low);
 
3162
        ndr_print_set_switch_value(ndr, &r->u, r->ptype);
 
3163
        ndr_print_dcerpc_payload(ndr, "u", &r->u);
 
3164
        ndr->depth--;
 
3165
}
 
3166