← Back to branch summary

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

« back to all changes in this revision

Viewing changes to 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:
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
 
        ndr->depth++;
53
 
        ndr_print_uint16(ndr, "context_id", r->context_id);
54
 
        ndr_print_uint8(ndr, "num_transfer_syntaxes", r->num_transfer_syntaxes);
55
 
        ndr_print_ndr_syntax_id(ndr, "abstract_syntax", &r->abstract_syntax);
56
 
        ndr->print(ndr, "%s: ARRAY(%d)", "transfer_syntaxes", (int)r->num_transfer_syntaxes);
57
 
        ndr->depth++;
58
 
        for (cntr_transfer_syntaxes_0=0;cntr_transfer_syntaxes_0<r->num_transfer_syntaxes;cntr_transfer_syntaxes_0++) {
59
 
                char *idx_0=NULL;
60
 
                if (asprintf(&idx_0, "[%d]", cntr_transfer_syntaxes_0) != -1) {
61
 
                        ndr_print_ndr_syntax_id(ndr, "transfer_syntaxes", &r->transfer_syntaxes[cntr_transfer_syntaxes_0]);
62
 
                        free(idx_0);
63
 
                }
64
 
        }
65
 
        ndr->depth--;
66
 
        ndr->depth--;
67
 
}
68
 
 
69
 
static enum ndr_err_code ndr_push_dcerpc_bind(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind *r)
70
 
{
71
 
        uint32_t cntr_ctx_list_0;
72
 
        if (ndr_flags & NDR_SCALARS) {
73
 
                NDR_CHECK(ndr_push_align(ndr, 4));
74
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
75
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
76
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
77
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_contexts));
78
 
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
79
 
                        NDR_CHECK(ndr_push_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
80
 
                }
81
 
                {
82
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
83
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
84
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
85
 
                        ndr->flags = _flags_save_DATA_BLOB;
86
 
                }
87
 
                {
88
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
89
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
90
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
91
 
                        ndr->flags = _flags_save_DATA_BLOB;
92
 
                }
93
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
94
 
        }
95
 
        if (ndr_flags & NDR_BUFFERS) {
96
 
        }
97
 
        return NDR_ERR_SUCCESS;
98
 
}
99
 
 
100
 
static enum ndr_err_code ndr_pull_dcerpc_bind(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind *r)
101
 
{
102
 
        uint32_t cntr_ctx_list_0;
103
 
        TALLOC_CTX *_mem_save_ctx_list_0;
104
 
        if (ndr_flags & NDR_SCALARS) {
105
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
106
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
107
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
108
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
109
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_contexts));
110
 
                NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_contexts);
111
 
                _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
112
 
                NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
113
 
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_contexts; cntr_ctx_list_0++) {
114
 
                        NDR_CHECK(ndr_pull_dcerpc_ctx_list(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
115
 
                }
116
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
117
 
                {
118
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
119
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
120
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
121
 
                        ndr->flags = _flags_save_DATA_BLOB;
122
 
                }
123
 
                {
124
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
125
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
126
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
127
 
                        ndr->flags = _flags_save_DATA_BLOB;
128
 
                }
129
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
130
 
        }
131
 
        if (ndr_flags & NDR_BUFFERS) {
132
 
        }
133
 
        return NDR_ERR_SUCCESS;
134
 
}
135
 
 
136
 
_PUBLIC_ void ndr_print_dcerpc_bind(struct ndr_print *ndr, const char *name, const struct dcerpc_bind *r)
137
 
{
138
 
        uint32_t cntr_ctx_list_0;
139
 
        ndr_print_struct(ndr, name, "dcerpc_bind");
140
 
        ndr->depth++;
141
 
        ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
142
 
        ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
143
 
        ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
144
 
        ndr_print_uint8(ndr, "num_contexts", r->num_contexts);
145
 
        ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_contexts);
146
 
        ndr->depth++;
147
 
        for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_contexts;cntr_ctx_list_0++) {
148
 
                char *idx_0=NULL;
149
 
                if (asprintf(&idx_0, "[%d]", cntr_ctx_list_0) != -1) {
150
 
                        ndr_print_dcerpc_ctx_list(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
151
 
                        free(idx_0);
152
 
                }
153
 
        }
154
 
        ndr->depth--;
155
 
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
156
 
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
157
 
        ndr->depth--;
158
 
}
159
 
 
160
 
static enum ndr_err_code ndr_push_dcerpc_empty(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_empty *r)
161
 
{
162
 
        if (ndr_flags & NDR_SCALARS) {
163
 
                NDR_CHECK(ndr_push_align(ndr, 1));
164
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
165
 
        }
166
 
        if (ndr_flags & NDR_BUFFERS) {
167
 
        }
168
 
        return NDR_ERR_SUCCESS;
169
 
}
170
 
 
171
 
static enum ndr_err_code ndr_pull_dcerpc_empty(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_empty *r)
172
 
{
173
 
        if (ndr_flags & NDR_SCALARS) {
174
 
                NDR_CHECK(ndr_pull_align(ndr, 1));
175
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
176
 
        }
177
 
        if (ndr_flags & NDR_BUFFERS) {
178
 
        }
179
 
        return NDR_ERR_SUCCESS;
180
 
}
181
 
 
182
 
_PUBLIC_ void ndr_print_dcerpc_empty(struct ndr_print *ndr, const char *name, const struct dcerpc_empty *r)
183
 
{
184
 
        ndr_print_struct(ndr, name, "dcerpc_empty");
185
 
        ndr->depth++;
186
 
        ndr->depth--;
187
 
}
188
 
 
189
 
static enum ndr_err_code ndr_push_dcerpc_object(struct ndr_push *ndr, int ndr_flags, const union dcerpc_object *r)
190
 
{
191
 
        if (ndr_flags & NDR_SCALARS) {
192
 
                int level = ndr_push_get_switch_value(ndr, r);
193
 
                NDR_CHECK(ndr_push_union_align(ndr, 4));
194
 
                switch (level) {
195
 
                        default: {
196
 
                                NDR_CHECK(ndr_push_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
197
 
                        break; }
198
 
 
199
 
                        case LIBNDR_FLAG_OBJECT_PRESENT: {
200
 
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
201
 
                        break; }
202
 
 
203
 
                }
204
 
        }
205
 
        if (ndr_flags & NDR_BUFFERS) {
206
 
                int level = ndr_push_get_switch_value(ndr, r);
207
 
                switch (level) {
208
 
                        default:
209
 
                        break;
210
 
 
211
 
                        case LIBNDR_FLAG_OBJECT_PRESENT:
212
 
                        break;
213
 
 
214
 
                }
215
 
        }
216
 
        return NDR_ERR_SUCCESS;
217
 
}
218
 
 
219
 
static enum ndr_err_code ndr_pull_dcerpc_object(struct ndr_pull *ndr, int ndr_flags, union dcerpc_object *r)
220
 
{
221
 
        int level;
222
 
        level = ndr_pull_get_switch_value(ndr, r);
223
 
        if (ndr_flags & NDR_SCALARS) {
224
 
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
225
 
                switch (level) {
226
 
                        default: {
227
 
                                NDR_CHECK(ndr_pull_dcerpc_empty(ndr, NDR_SCALARS, &r->empty));
228
 
                        break; }
229
 
 
230
 
                        case LIBNDR_FLAG_OBJECT_PRESENT: {
231
 
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
232
 
                        break; }
233
 
 
234
 
                }
235
 
        }
236
 
        if (ndr_flags & NDR_BUFFERS) {
237
 
                switch (level) {
238
 
                        default:
239
 
                        break;
240
 
 
241
 
                        case LIBNDR_FLAG_OBJECT_PRESENT:
242
 
                        break;
243
 
 
244
 
                }
245
 
        }
246
 
        return NDR_ERR_SUCCESS;
247
 
}
248
 
 
249
 
_PUBLIC_ void ndr_print_dcerpc_object(struct ndr_print *ndr, const char *name, const union dcerpc_object *r)
250
 
{
251
 
        int level;
252
 
        level = ndr_print_get_switch_value(ndr, r);
253
 
        ndr_print_union(ndr, name, level, "dcerpc_object");
254
 
        switch (level) {
255
 
                default:
256
 
                        ndr_print_dcerpc_empty(ndr, "empty", &r->empty);
257
 
                break;
258
 
 
259
 
                case LIBNDR_FLAG_OBJECT_PRESENT:
260
 
                        ndr_print_GUID(ndr, "object", &r->object);
261
 
                break;
262
 
 
263
 
        }
264
 
}
265
 
 
266
 
static enum ndr_err_code ndr_push_dcerpc_request(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_request *r)
267
 
{
268
 
        if (ndr_flags & NDR_SCALARS) {
269
 
                NDR_CHECK(ndr_push_align(ndr, 4));
270
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
271
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
272
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
273
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
274
 
                NDR_CHECK(ndr_push_dcerpc_object(ndr, NDR_SCALARS, &r->object));
275
 
                {
276
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
277
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
278
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
279
 
                        ndr->flags = _flags_save_DATA_BLOB;
280
 
                }
281
 
                {
282
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
283
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
284
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
285
 
                        ndr->flags = _flags_save_DATA_BLOB;
286
 
                }
287
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
288
 
        }
289
 
        if (ndr_flags & NDR_BUFFERS) {
290
 
        }
291
 
        return NDR_ERR_SUCCESS;
292
 
}
293
 
 
294
 
static enum ndr_err_code ndr_pull_dcerpc_request(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_request *r)
295
 
{
296
 
        if (ndr_flags & NDR_SCALARS) {
297
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
298
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
299
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
300
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
301
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT));
302
 
                NDR_CHECK(ndr_pull_dcerpc_object(ndr, NDR_SCALARS, &r->object));
303
 
                {
304
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
305
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
306
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
307
 
                        ndr->flags = _flags_save_DATA_BLOB;
308
 
                }
309
 
                {
310
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
311
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
312
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
313
 
                        ndr->flags = _flags_save_DATA_BLOB;
314
 
                }
315
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
316
 
        }
317
 
        if (ndr_flags & NDR_BUFFERS) {
318
 
        }
319
 
        return NDR_ERR_SUCCESS;
320
 
}
321
 
 
322
 
_PUBLIC_ void ndr_print_dcerpc_request(struct ndr_print *ndr, const char *name, const struct dcerpc_request *r)
323
 
{
324
 
        ndr_print_struct(ndr, name, "dcerpc_request");
325
 
        ndr->depth++;
326
 
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
327
 
        ndr_print_uint16(ndr, "context_id", r->context_id);
328
 
        ndr_print_uint16(ndr, "opnum", r->opnum);
329
 
        ndr_print_set_switch_value(ndr, &r->object, ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT);
330
 
        ndr_print_dcerpc_object(ndr, "object", &r->object);
331
 
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
332
 
        ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
333
 
        ndr->depth--;
334
 
}
335
 
 
336
 
static enum ndr_err_code ndr_push_dcerpc_ack_ctx(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack_ctx *r)
337
 
{
338
 
        if (ndr_flags & NDR_SCALARS) {
339
 
                NDR_CHECK(ndr_push_align(ndr, 4));
340
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->result));
341
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reason));
342
 
                NDR_CHECK(ndr_push_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
343
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
344
 
        }
345
 
        if (ndr_flags & NDR_BUFFERS) {
346
 
        }
347
 
        return NDR_ERR_SUCCESS;
348
 
}
349
 
 
350
 
static enum ndr_err_code ndr_pull_dcerpc_ack_ctx(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack_ctx *r)
351
 
{
352
 
        if (ndr_flags & NDR_SCALARS) {
353
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
354
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->result));
355
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reason));
356
 
                NDR_CHECK(ndr_pull_ndr_syntax_id(ndr, NDR_SCALARS, &r->syntax));
357
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
358
 
        }
359
 
        if (ndr_flags & NDR_BUFFERS) {
360
 
        }
361
 
        return NDR_ERR_SUCCESS;
362
 
}
363
 
 
364
 
_PUBLIC_ void ndr_print_dcerpc_ack_ctx(struct ndr_print *ndr, const char *name, const struct dcerpc_ack_ctx *r)
365
 
{
366
 
        ndr_print_struct(ndr, name, "dcerpc_ack_ctx");
367
 
        ndr->depth++;
368
 
        ndr_print_uint16(ndr, "result", r->result);
369
 
        ndr_print_uint16(ndr, "reason", r->reason);
370
 
        ndr_print_ndr_syntax_id(ndr, "syntax", &r->syntax);
371
 
        ndr->depth--;
372
 
}
373
 
 
374
 
static enum ndr_err_code ndr_push_dcerpc_bind_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_ack *r)
375
 
{
376
 
        uint32_t cntr_ctx_list_0;
377
 
        if (ndr_flags & NDR_SCALARS) {
378
 
                NDR_CHECK(ndr_push_align(ndr, 4));
379
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_xmit_frag));
380
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_recv_frag));
381
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->assoc_group_id));
382
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->secondary_address) + 1));
383
 
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->secondary_address, strlen(r->secondary_address) + 1, sizeof(uint8_t), CH_DOS));
384
 
                {
385
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
386
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
387
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad1));
388
 
                        ndr->flags = _flags_save_DATA_BLOB;
389
 
                }
390
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_results));
391
 
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
392
 
                        NDR_CHECK(ndr_push_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
393
 
                }
394
 
                {
395
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
396
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
397
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
398
 
                        ndr->flags = _flags_save_DATA_BLOB;
399
 
                }
400
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
401
 
        }
402
 
        if (ndr_flags & NDR_BUFFERS) {
403
 
        }
404
 
        return NDR_ERR_SUCCESS;
405
 
}
406
 
 
407
 
static enum ndr_err_code ndr_pull_dcerpc_bind_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_ack *r)
408
 
{
409
 
        uint32_t cntr_ctx_list_0;
410
 
        TALLOC_CTX *_mem_save_ctx_list_0;
411
 
        if (ndr_flags & NDR_SCALARS) {
412
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
413
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_xmit_frag));
414
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_recv_frag));
415
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->assoc_group_id));
416
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->secondary_address_size));
417
 
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->secondary_address, r->secondary_address_size, sizeof(uint8_t), CH_DOS));
418
 
                {
419
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
420
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
421
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad1));
422
 
                        ndr->flags = _flags_save_DATA_BLOB;
423
 
                }
424
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_results));
425
 
                NDR_PULL_ALLOC_N(ndr, r->ctx_list, r->num_results);
426
 
                _mem_save_ctx_list_0 = NDR_PULL_GET_MEM_CTX(ndr);
427
 
                NDR_PULL_SET_MEM_CTX(ndr, r->ctx_list, 0);
428
 
                for (cntr_ctx_list_0 = 0; cntr_ctx_list_0 < r->num_results; cntr_ctx_list_0++) {
429
 
                        NDR_CHECK(ndr_pull_dcerpc_ack_ctx(ndr, NDR_SCALARS, &r->ctx_list[cntr_ctx_list_0]));
430
 
                }
431
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctx_list_0, 0);
432
 
                {
433
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
434
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
435
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
436
 
                        ndr->flags = _flags_save_DATA_BLOB;
437
 
                }
438
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
439
 
        }
440
 
        if (ndr_flags & NDR_BUFFERS) {
441
 
        }
442
 
        return NDR_ERR_SUCCESS;
443
 
}
444
 
 
445
 
_PUBLIC_ void ndr_print_dcerpc_bind_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_ack *r)
446
 
{
447
 
        uint32_t cntr_ctx_list_0;
448
 
        ndr_print_struct(ndr, name, "dcerpc_bind_ack");
449
 
        ndr->depth++;
450
 
        ndr_print_uint16(ndr, "max_xmit_frag", r->max_xmit_frag);
451
 
        ndr_print_uint16(ndr, "max_recv_frag", r->max_recv_frag);
452
 
        ndr_print_uint32(ndr, "assoc_group_id", r->assoc_group_id);
453
 
        ndr_print_uint16(ndr, "secondary_address_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->secondary_address) + 1:r->secondary_address_size);
454
 
        ndr_print_string(ndr, "secondary_address", r->secondary_address);
455
 
        ndr_print_DATA_BLOB(ndr, "_pad1", r->_pad1);
456
 
        ndr_print_uint8(ndr, "num_results", r->num_results);
457
 
        ndr->print(ndr, "%s: ARRAY(%d)", "ctx_list", (int)r->num_results);
458
 
        ndr->depth++;
459
 
        for (cntr_ctx_list_0=0;cntr_ctx_list_0<r->num_results;cntr_ctx_list_0++) {
460
 
                char *idx_0=NULL;
461
 
                if (asprintf(&idx_0, "[%d]", cntr_ctx_list_0) != -1) {
462
 
                        ndr_print_dcerpc_ack_ctx(ndr, "ctx_list", &r->ctx_list[cntr_ctx_list_0]);
463
 
                        free(idx_0);
464
 
                }
465
 
        }
466
 
        ndr->depth--;
467
 
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
468
 
        ndr->depth--;
469
 
}
470
 
 
471
 
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)
472
 
{
473
 
        uint32_t cntr_versions_0;
474
 
        if (ndr_flags & NDR_SCALARS) {
475
 
                NDR_CHECK(ndr_push_align(ndr, 4));
476
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_versions));
477
 
                for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
478
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->versions[cntr_versions_0]));
479
 
                }
480
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
481
 
        }
482
 
        if (ndr_flags & NDR_BUFFERS) {
483
 
        }
484
 
        return NDR_ERR_SUCCESS;
485
 
}
486
 
 
487
 
static enum ndr_err_code ndr_pull_dcerpc_bind_nak_versions(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak_versions *r)
488
 
{
489
 
        uint32_t cntr_versions_0;
490
 
        TALLOC_CTX *_mem_save_versions_0;
491
 
        if (ndr_flags & NDR_SCALARS) {
492
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
493
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_versions));
494
 
                NDR_PULL_ALLOC_N(ndr, r->versions, r->num_versions);
495
 
                _mem_save_versions_0 = NDR_PULL_GET_MEM_CTX(ndr);
496
 
                NDR_PULL_SET_MEM_CTX(ndr, r->versions, 0);
497
 
                for (cntr_versions_0 = 0; cntr_versions_0 < r->num_versions; cntr_versions_0++) {
498
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
499
 
                }
500
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
501
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
502
 
        }
503
 
        if (ndr_flags & NDR_BUFFERS) {
504
 
        }
505
 
        return NDR_ERR_SUCCESS;
506
 
}
507
 
 
508
 
_PUBLIC_ void ndr_print_dcerpc_bind_nak_versions(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak_versions *r)
509
 
{
510
 
        uint32_t cntr_versions_0;
511
 
        ndr_print_struct(ndr, name, "dcerpc_bind_nak_versions");
512
 
        ndr->depth++;
513
 
        ndr_print_uint32(ndr, "num_versions", r->num_versions);
514
 
        ndr->print(ndr, "%s: ARRAY(%d)", "versions", (int)r->num_versions);
515
 
        ndr->depth++;
516
 
        for (cntr_versions_0=0;cntr_versions_0<r->num_versions;cntr_versions_0++) {
517
 
                char *idx_0=NULL;
518
 
                if (asprintf(&idx_0, "[%d]", cntr_versions_0) != -1) {
519
 
                        ndr_print_uint32(ndr, "versions", r->versions[cntr_versions_0]);
520
 
                        free(idx_0);
521
 
                }
522
 
        }
523
 
        ndr->depth--;
524
 
        ndr->depth--;
525
 
}
526
 
 
527
 
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)
528
 
{
529
 
        if (ndr_flags & NDR_SCALARS) {
530
 
                int level = ndr_push_get_switch_value(ndr, r);
531
 
                NDR_CHECK(ndr_push_union_align(ndr, 4));
532
 
                switch (level) {
533
 
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
534
 
                                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
535
 
                        break; }
536
 
 
537
 
                        default: {
538
 
                        break; }
539
 
 
540
 
                }
541
 
        }
542
 
        if (ndr_flags & NDR_BUFFERS) {
543
 
                int level = ndr_push_get_switch_value(ndr, r);
544
 
                switch (level) {
545
 
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
546
 
                        break;
547
 
 
548
 
                        default:
549
 
                        break;
550
 
 
551
 
                }
552
 
        }
553
 
        return NDR_ERR_SUCCESS;
554
 
}
555
 
 
556
 
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)
557
 
{
558
 
        int level;
559
 
        level = ndr_pull_get_switch_value(ndr, r);
560
 
        if (ndr_flags & NDR_SCALARS) {
561
 
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
562
 
                switch (level) {
563
 
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED: {
564
 
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions(ndr, NDR_SCALARS, &r->v));
565
 
                        break; }
566
 
 
567
 
                        default: {
568
 
                        break; }
569
 
 
570
 
                }
571
 
        }
572
 
        if (ndr_flags & NDR_BUFFERS) {
573
 
                switch (level) {
574
 
                        case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
575
 
                        break;
576
 
 
577
 
                        default:
578
 
                        break;
579
 
 
580
 
                }
581
 
        }
582
 
        return NDR_ERR_SUCCESS;
583
 
}
584
 
 
585
 
_PUBLIC_ void ndr_print_dcerpc_bind_nak_versions_ctr(struct ndr_print *ndr, const char *name, const union dcerpc_bind_nak_versions_ctr *r)
586
 
{
587
 
        int level;
588
 
        level = ndr_print_get_switch_value(ndr, r);
589
 
        ndr_print_union(ndr, name, level, "dcerpc_bind_nak_versions_ctr");
590
 
        switch (level) {
591
 
                case DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED:
592
 
                        ndr_print_dcerpc_bind_nak_versions(ndr, "v", &r->v);
593
 
                break;
594
 
 
595
 
                default:
596
 
                break;
597
 
 
598
 
        }
599
 
}
600
 
 
601
 
static enum ndr_err_code ndr_push_dcerpc_bind_nak(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_bind_nak *r)
602
 
{
603
 
        if (ndr_flags & NDR_SCALARS) {
604
 
                NDR_CHECK(ndr_push_align(ndr, 4));
605
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reject_reason));
606
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->versions, r->reject_reason));
607
 
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
608
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
609
 
        }
610
 
        if (ndr_flags & NDR_BUFFERS) {
611
 
                NDR_CHECK(ndr_push_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
612
 
        }
613
 
        return NDR_ERR_SUCCESS;
614
 
}
615
 
 
616
 
static enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak *r)
617
 
{
618
 
        if (ndr_flags & NDR_SCALARS) {
619
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
620
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reject_reason));
621
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->versions, r->reject_reason));
622
 
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_SCALARS, &r->versions));
623
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
624
 
        }
625
 
        if (ndr_flags & NDR_BUFFERS) {
626
 
                NDR_CHECK(ndr_pull_dcerpc_bind_nak_versions_ctr(ndr, NDR_BUFFERS, &r->versions));
627
 
        }
628
 
        return NDR_ERR_SUCCESS;
629
 
}
630
 
 
631
 
_PUBLIC_ void ndr_print_dcerpc_bind_nak(struct ndr_print *ndr, const char *name, const struct dcerpc_bind_nak *r)
632
 
{
633
 
        ndr_print_struct(ndr, name, "dcerpc_bind_nak");
634
 
        ndr->depth++;
635
 
        ndr_print_uint16(ndr, "reject_reason", r->reject_reason);
636
 
        ndr_print_set_switch_value(ndr, &r->versions, r->reject_reason);
637
 
        ndr_print_dcerpc_bind_nak_versions_ctr(ndr, "versions", &r->versions);
638
 
        ndr->depth--;
639
 
}
640
 
 
641
 
static enum ndr_err_code ndr_push_dcerpc_response(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_response *r)
642
 
{
643
 
        if (ndr_flags & NDR_SCALARS) {
644
 
                NDR_CHECK(ndr_push_align(ndr, 4));
645
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
646
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
647
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
648
 
                {
649
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
650
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
651
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
652
 
                        ndr->flags = _flags_save_DATA_BLOB;
653
 
                }
654
 
                {
655
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
656
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
657
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->stub_and_verifier));
658
 
                        ndr->flags = _flags_save_DATA_BLOB;
659
 
                }
660
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
661
 
        }
662
 
        if (ndr_flags & NDR_BUFFERS) {
663
 
        }
664
 
        return NDR_ERR_SUCCESS;
665
 
}
666
 
 
667
 
static enum ndr_err_code ndr_pull_dcerpc_response(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_response *r)
668
 
{
669
 
        if (ndr_flags & NDR_SCALARS) {
670
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
671
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
672
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
673
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
674
 
                {
675
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
676
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN8);
677
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
678
 
                        ndr->flags = _flags_save_DATA_BLOB;
679
 
                }
680
 
                {
681
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
682
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
683
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->stub_and_verifier));
684
 
                        ndr->flags = _flags_save_DATA_BLOB;
685
 
                }
686
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
687
 
        }
688
 
        if (ndr_flags & NDR_BUFFERS) {
689
 
        }
690
 
        return NDR_ERR_SUCCESS;
691
 
}
692
 
 
693
 
_PUBLIC_ void ndr_print_dcerpc_response(struct ndr_print *ndr, const char *name, const struct dcerpc_response *r)
694
 
{
695
 
        ndr_print_struct(ndr, name, "dcerpc_response");
696
 
        ndr->depth++;
697
 
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
698
 
        ndr_print_uint16(ndr, "context_id", r->context_id);
699
 
        ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
700
 
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
701
 
        ndr_print_DATA_BLOB(ndr, "stub_and_verifier", r->stub_and_verifier);
702
 
        ndr->depth--;
703
 
}
704
 
 
705
 
static enum ndr_err_code ndr_push_dcerpc_fault(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fault *r)
706
 
{
707
 
        if (ndr_flags & NDR_SCALARS) {
708
 
                NDR_CHECK(ndr_push_align(ndr, 4));
709
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->alloc_hint));
710
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->context_id));
711
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->cancel_count));
712
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
713
 
                {
714
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
715
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
716
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
717
 
                        ndr->flags = _flags_save_DATA_BLOB;
718
 
                }
719
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
720
 
        }
721
 
        if (ndr_flags & NDR_BUFFERS) {
722
 
        }
723
 
        return NDR_ERR_SUCCESS;
724
 
}
725
 
 
726
 
static enum ndr_err_code ndr_pull_dcerpc_fault(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fault *r)
727
 
{
728
 
        if (ndr_flags & NDR_SCALARS) {
729
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
730
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->alloc_hint));
731
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->context_id));
732
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->cancel_count));
733
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
734
 
                {
735
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
736
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
737
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
738
 
                        ndr->flags = _flags_save_DATA_BLOB;
739
 
                }
740
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
741
 
        }
742
 
        if (ndr_flags & NDR_BUFFERS) {
743
 
        }
744
 
        return NDR_ERR_SUCCESS;
745
 
}
746
 
 
747
 
_PUBLIC_ void ndr_print_dcerpc_fault(struct ndr_print *ndr, const char *name, const struct dcerpc_fault *r)
748
 
{
749
 
        ndr_print_struct(ndr, name, "dcerpc_fault");
750
 
        ndr->depth++;
751
 
        ndr_print_uint32(ndr, "alloc_hint", r->alloc_hint);
752
 
        ndr_print_uint16(ndr, "context_id", r->context_id);
753
 
        ndr_print_uint8(ndr, "cancel_count", r->cancel_count);
754
 
        ndr_print_uint32(ndr, "status", r->status);
755
 
        ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
756
 
        ndr->depth--;
757
 
}
758
 
 
759
 
static enum ndr_err_code ndr_push_dcerpc_AuthType(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthType r)
760
 
{
761
 
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
762
 
        return NDR_ERR_SUCCESS;
763
 
}
764
 
 
765
 
static enum ndr_err_code ndr_pull_dcerpc_AuthType(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthType *r)
766
 
{
767
 
        uint8_t v;
768
 
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
769
 
        *r = v;
770
 
        return NDR_ERR_SUCCESS;
771
 
}
772
 
 
773
 
_PUBLIC_ void ndr_print_dcerpc_AuthType(struct ndr_print *ndr, const char *name, enum dcerpc_AuthType r)
774
 
{
775
 
        const char *val = NULL;
776
 
 
777
 
        switch (r) {
778
 
                case DCERPC_AUTH_TYPE_NONE: val = "DCERPC_AUTH_TYPE_NONE"; break;
779
 
                case DCERPC_AUTH_TYPE_KRB5_1: val = "DCERPC_AUTH_TYPE_KRB5_1"; break;
780
 
                case DCERPC_AUTH_TYPE_SPNEGO: val = "DCERPC_AUTH_TYPE_SPNEGO"; break;
781
 
                case DCERPC_AUTH_TYPE_NTLMSSP: val = "DCERPC_AUTH_TYPE_NTLMSSP"; break;
782
 
                case DCERPC_AUTH_TYPE_KRB5: val = "DCERPC_AUTH_TYPE_KRB5"; break;
783
 
                case DCERPC_AUTH_TYPE_DPA: val = "DCERPC_AUTH_TYPE_DPA"; break;
784
 
                case DCERPC_AUTH_TYPE_MSN: val = "DCERPC_AUTH_TYPE_MSN"; break;
785
 
                case DCERPC_AUTH_TYPE_DIGEST: val = "DCERPC_AUTH_TYPE_DIGEST"; break;
786
 
                case DCERPC_AUTH_TYPE_SCHANNEL: val = "DCERPC_AUTH_TYPE_SCHANNEL"; break;
787
 
                case DCERPC_AUTH_TYPE_MSMQ: val = "DCERPC_AUTH_TYPE_MSMQ"; break;
788
 
        }
789
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
790
 
}
791
 
 
792
 
static enum ndr_err_code ndr_push_dcerpc_AuthLevel(struct ndr_push *ndr, int ndr_flags, enum dcerpc_AuthLevel r)
793
 
{
794
 
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
795
 
        return NDR_ERR_SUCCESS;
796
 
}
797
 
 
798
 
static enum ndr_err_code ndr_pull_dcerpc_AuthLevel(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_AuthLevel *r)
799
 
{
800
 
        uint8_t v;
801
 
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
802
 
        *r = v;
803
 
        return NDR_ERR_SUCCESS;
804
 
}
805
 
 
806
 
_PUBLIC_ void ndr_print_dcerpc_AuthLevel(struct ndr_print *ndr, const char *name, enum dcerpc_AuthLevel r)
807
 
{
808
 
        const char *val = NULL;
809
 
 
810
 
        switch (r) {
811
 
                case DCERPC_AUTH_LEVEL_NONE: val = "DCERPC_AUTH_LEVEL_NONE"; break;
812
 
                case DCERPC_AUTH_LEVEL_CONNECT: val = "DCERPC_AUTH_LEVEL_CONNECT"; break;
813
 
                case DCERPC_AUTH_LEVEL_CALL: val = "DCERPC_AUTH_LEVEL_CALL"; break;
814
 
                case DCERPC_AUTH_LEVEL_PACKET: val = "DCERPC_AUTH_LEVEL_PACKET"; break;
815
 
                case DCERPC_AUTH_LEVEL_INTEGRITY: val = "DCERPC_AUTH_LEVEL_INTEGRITY"; break;
816
 
                case DCERPC_AUTH_LEVEL_PRIVACY: val = "DCERPC_AUTH_LEVEL_PRIVACY"; break;
817
 
        }
818
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
819
 
}
820
 
 
821
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth *r)
822
 
{
823
 
        if (ndr_flags & NDR_SCALARS) {
824
 
                NDR_CHECK(ndr_push_align(ndr, 4));
825
 
                NDR_CHECK(ndr_push_dcerpc_AuthType(ndr, NDR_SCALARS, r->auth_type));
826
 
                NDR_CHECK(ndr_push_dcerpc_AuthLevel(ndr, NDR_SCALARS, r->auth_level));
827
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_pad_length));
828
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_reserved));
829
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->auth_context_id));
830
 
                {
831
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
832
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
833
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->credentials));
834
 
                        ndr->flags = _flags_save_DATA_BLOB;
835
 
                }
836
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
837
 
        }
838
 
        if (ndr_flags & NDR_BUFFERS) {
839
 
        }
840
 
        return NDR_ERR_SUCCESS;
841
 
}
842
 
 
843
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth *r)
844
 
{
845
 
        if (ndr_flags & NDR_SCALARS) {
846
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
847
 
                NDR_CHECK(ndr_pull_dcerpc_AuthType(ndr, NDR_SCALARS, &r->auth_type));
848
 
                NDR_CHECK(ndr_pull_dcerpc_AuthLevel(ndr, NDR_SCALARS, &r->auth_level));
849
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_pad_length));
850
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_reserved));
851
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->auth_context_id));
852
 
                {
853
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
854
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
855
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->credentials));
856
 
                        ndr->flags = _flags_save_DATA_BLOB;
857
 
                }
858
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
859
 
        }
860
 
        if (ndr_flags & NDR_BUFFERS) {
861
 
        }
862
 
        return NDR_ERR_SUCCESS;
863
 
}
864
 
 
865
 
_PUBLIC_ void ndr_print_dcerpc_auth(struct ndr_print *ndr, const char *name, const struct dcerpc_auth *r)
866
 
{
867
 
        ndr_print_struct(ndr, name, "dcerpc_auth");
868
 
        ndr->depth++;
869
 
        ndr_print_dcerpc_AuthType(ndr, "auth_type", r->auth_type);
870
 
        ndr_print_dcerpc_AuthLevel(ndr, "auth_level", r->auth_level);
871
 
        ndr_print_uint8(ndr, "auth_pad_length", r->auth_pad_length);
872
 
        ndr_print_uint8(ndr, "auth_reserved", r->auth_reserved);
873
 
        ndr_print_uint32(ndr, "auth_context_id", r->auth_context_id);
874
 
        ndr_print_DATA_BLOB(ndr, "credentials", r->credentials);
875
 
        ndr->depth--;
876
 
}
877
 
 
878
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_auth3(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_auth3 *r)
879
 
{
880
 
        if (ndr_flags & NDR_SCALARS) {
881
 
                NDR_CHECK(ndr_push_align(ndr, 4));
882
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
883
 
                {
884
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
885
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
886
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
887
 
                        ndr->flags = _flags_save_DATA_BLOB;
888
 
                }
889
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
890
 
        }
891
 
        if (ndr_flags & NDR_BUFFERS) {
892
 
        }
893
 
        return NDR_ERR_SUCCESS;
894
 
}
895
 
 
896
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_auth3(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_auth3 *r)
897
 
{
898
 
        if (ndr_flags & NDR_SCALARS) {
899
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
900
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
901
 
                {
902
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
903
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
904
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
905
 
                        ndr->flags = _flags_save_DATA_BLOB;
906
 
                }
907
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
908
 
        }
909
 
        if (ndr_flags & NDR_BUFFERS) {
910
 
        }
911
 
        return NDR_ERR_SUCCESS;
912
 
}
913
 
 
914
 
_PUBLIC_ void ndr_print_dcerpc_auth3(struct ndr_print *ndr, const char *name, const struct dcerpc_auth3 *r)
915
 
{
916
 
        ndr_print_struct(ndr, name, "dcerpc_auth3");
917
 
        ndr->depth++;
918
 
        ndr_print_uint32(ndr, "_pad", r->_pad);
919
 
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
920
 
        ndr->depth--;
921
 
}
922
 
 
923
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_orphaned(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_orphaned *r)
924
 
{
925
 
        if (ndr_flags & NDR_SCALARS) {
926
 
                NDR_CHECK(ndr_push_align(ndr, 4));
927
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
928
 
                {
929
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
930
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
931
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
932
 
                        ndr->flags = _flags_save_DATA_BLOB;
933
 
                }
934
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
935
 
        }
936
 
        if (ndr_flags & NDR_BUFFERS) {
937
 
        }
938
 
        return NDR_ERR_SUCCESS;
939
 
}
940
 
 
941
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_orphaned(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_orphaned *r)
942
 
{
943
 
        if (ndr_flags & NDR_SCALARS) {
944
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
945
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
946
 
                {
947
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
948
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
949
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
950
 
                        ndr->flags = _flags_save_DATA_BLOB;
951
 
                }
952
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
953
 
        }
954
 
        if (ndr_flags & NDR_BUFFERS) {
955
 
        }
956
 
        return NDR_ERR_SUCCESS;
957
 
}
958
 
 
959
 
_PUBLIC_ void ndr_print_dcerpc_orphaned(struct ndr_print *ndr, const char *name, const struct dcerpc_orphaned *r)
960
 
{
961
 
        ndr_print_struct(ndr, name, "dcerpc_orphaned");
962
 
        ndr->depth++;
963
 
        ndr_print_uint32(ndr, "_pad", r->_pad);
964
 
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
965
 
        ndr->depth--;
966
 
}
967
 
 
968
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_co_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_co_cancel *r)
969
 
{
970
 
        if (ndr_flags & NDR_SCALARS) {
971
 
                NDR_CHECK(ndr_push_align(ndr, 4));
972
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_pad));
973
 
                {
974
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
975
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
976
 
                        NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->auth_info));
977
 
                        ndr->flags = _flags_save_DATA_BLOB;
978
 
                }
979
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
980
 
        }
981
 
        if (ndr_flags & NDR_BUFFERS) {
982
 
        }
983
 
        return NDR_ERR_SUCCESS;
984
 
}
985
 
 
986
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_co_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_co_cancel *r)
987
 
{
988
 
        if (ndr_flags & NDR_SCALARS) {
989
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
990
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_pad));
991
 
                {
992
 
                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
993
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
994
 
                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->auth_info));
995
 
                        ndr->flags = _flags_save_DATA_BLOB;
996
 
                }
997
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
998
 
        }
999
 
        if (ndr_flags & NDR_BUFFERS) {
1000
 
        }
1001
 
        return NDR_ERR_SUCCESS;
1002
 
}
1003
 
 
1004
 
_PUBLIC_ void ndr_print_dcerpc_co_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_co_cancel *r)
1005
 
{
1006
 
        ndr_print_struct(ndr, name, "dcerpc_co_cancel");
1007
 
        ndr->depth++;
1008
 
        ndr_print_uint32(ndr, "_pad", r->_pad);
1009
 
        ndr_print_DATA_BLOB(ndr, "auth_info", r->auth_info);
1010
 
        ndr->depth--;
1011
 
}
1012
 
 
1013
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cl_cancel(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cl_cancel *r)
1014
 
{
1015
 
        if (ndr_flags & NDR_SCALARS) {
1016
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1017
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1018
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1019
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1020
 
        }
1021
 
        if (ndr_flags & NDR_BUFFERS) {
1022
 
        }
1023
 
        return NDR_ERR_SUCCESS;
1024
 
}
1025
 
 
1026
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cl_cancel(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cl_cancel *r)
1027
 
{
1028
 
        if (ndr_flags & NDR_SCALARS) {
1029
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1030
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1031
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1032
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1033
 
        }
1034
 
        if (ndr_flags & NDR_BUFFERS) {
1035
 
        }
1036
 
        return NDR_ERR_SUCCESS;
1037
 
}
1038
 
 
1039
 
_PUBLIC_ void ndr_print_dcerpc_cl_cancel(struct ndr_print *ndr, const char *name, const struct dcerpc_cl_cancel *r)
1040
 
{
1041
 
        ndr_print_struct(ndr, name, "dcerpc_cl_cancel");
1042
 
        ndr->depth++;
1043
 
        ndr_print_uint32(ndr, "version", r->version);
1044
 
        ndr_print_uint32(ndr, "id", r->id);
1045
 
        ndr->depth--;
1046
 
}
1047
 
 
1048
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_cancel_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_cancel_ack *r)
1049
 
{
1050
 
        if (ndr_flags & NDR_SCALARS) {
1051
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1052
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1053
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id));
1054
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_is_accepting));
1055
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1056
 
        }
1057
 
        if (ndr_flags & NDR_BUFFERS) {
1058
 
        }
1059
 
        return NDR_ERR_SUCCESS;
1060
 
}
1061
 
 
1062
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_cancel_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_cancel_ack *r)
1063
 
{
1064
 
        if (ndr_flags & NDR_SCALARS) {
1065
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1066
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1067
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id));
1068
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_is_accepting));
1069
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1070
 
        }
1071
 
        if (ndr_flags & NDR_BUFFERS) {
1072
 
        }
1073
 
        return NDR_ERR_SUCCESS;
1074
 
}
1075
 
 
1076
 
_PUBLIC_ void ndr_print_dcerpc_cancel_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_cancel_ack *r)
1077
 
{
1078
 
        ndr_print_struct(ndr, name, "dcerpc_cancel_ack");
1079
 
        ndr->depth++;
1080
 
        ndr_print_uint32(ndr, "version", r->version);
1081
 
        ndr_print_uint32(ndr, "id", r->id);
1082
 
        ndr_print_uint32(ndr, "server_is_accepting", r->server_is_accepting);
1083
 
        ndr->depth--;
1084
 
}
1085
 
 
1086
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_fack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_fack *r)
1087
 
{
1088
 
        uint32_t cntr_selack_0;
1089
 
        if (ndr_flags & NDR_SCALARS) {
1090
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1091
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1092
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->_pad1));
1093
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->window_size));
1094
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_tdsu));
1095
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_frag_size));
1096
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->serial_no));
1097
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->selack_size));
1098
 
                for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
1099
 
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->selack[cntr_selack_0]));
1100
 
                }
1101
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1102
 
        }
1103
 
        if (ndr_flags & NDR_BUFFERS) {
1104
 
        }
1105
 
        return NDR_ERR_SUCCESS;
1106
 
}
1107
 
 
1108
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_fack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_fack *r)
1109
 
{
1110
 
        uint32_t cntr_selack_0;
1111
 
        TALLOC_CTX *_mem_save_selack_0;
1112
 
        if (ndr_flags & NDR_SCALARS) {
1113
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1114
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1115
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->_pad1));
1116
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->window_size));
1117
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_tdsu));
1118
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_frag_size));
1119
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->serial_no));
1120
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->selack_size));
1121
 
                NDR_PULL_ALLOC_N(ndr, r->selack, r->selack_size);
1122
 
                _mem_save_selack_0 = NDR_PULL_GET_MEM_CTX(ndr);
1123
 
                NDR_PULL_SET_MEM_CTX(ndr, r->selack, 0);
1124
 
                for (cntr_selack_0 = 0; cntr_selack_0 < r->selack_size; cntr_selack_0++) {
1125
 
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->selack[cntr_selack_0]));
1126
 
                }
1127
 
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_selack_0, 0);
1128
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1129
 
        }
1130
 
        if (ndr_flags & NDR_BUFFERS) {
1131
 
        }
1132
 
        return NDR_ERR_SUCCESS;
1133
 
}
1134
 
 
1135
 
_PUBLIC_ void ndr_print_dcerpc_fack(struct ndr_print *ndr, const char *name, const struct dcerpc_fack *r)
1136
 
{
1137
 
        uint32_t cntr_selack_0;
1138
 
        ndr_print_struct(ndr, name, "dcerpc_fack");
1139
 
        ndr->depth++;
1140
 
        ndr_print_uint32(ndr, "version", r->version);
1141
 
        ndr_print_uint8(ndr, "_pad1", r->_pad1);
1142
 
        ndr_print_uint16(ndr, "window_size", r->window_size);
1143
 
        ndr_print_uint32(ndr, "max_tdsu", r->max_tdsu);
1144
 
        ndr_print_uint32(ndr, "max_frag_size", r->max_frag_size);
1145
 
        ndr_print_uint16(ndr, "serial_no", r->serial_no);
1146
 
        ndr_print_uint16(ndr, "selack_size", r->selack_size);
1147
 
        ndr->print(ndr, "%s: ARRAY(%d)", "selack", (int)r->selack_size);
1148
 
        ndr->depth++;
1149
 
        for (cntr_selack_0=0;cntr_selack_0<r->selack_size;cntr_selack_0++) {
1150
 
                char *idx_0=NULL;
1151
 
                if (asprintf(&idx_0, "[%d]", cntr_selack_0) != -1) {
1152
 
                        ndr_print_uint32(ndr, "selack", r->selack[cntr_selack_0]);
1153
 
                        free(idx_0);
1154
 
                }
1155
 
        }
1156
 
        ndr->depth--;
1157
 
        ndr->depth--;
1158
 
}
1159
 
 
1160
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ack(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ack *r)
1161
 
{
1162
 
        if (ndr_flags & NDR_SCALARS) {
1163
 
                NDR_CHECK(ndr_push_align(ndr, 1));
1164
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1165
 
        }
1166
 
        if (ndr_flags & NDR_BUFFERS) {
1167
 
        }
1168
 
        return NDR_ERR_SUCCESS;
1169
 
}
1170
 
 
1171
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ack(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ack *r)
1172
 
{
1173
 
        if (ndr_flags & NDR_SCALARS) {
1174
 
                NDR_CHECK(ndr_pull_align(ndr, 1));
1175
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1176
 
        }
1177
 
        if (ndr_flags & NDR_BUFFERS) {
1178
 
        }
1179
 
        return NDR_ERR_SUCCESS;
1180
 
}
1181
 
 
1182
 
_PUBLIC_ void ndr_print_dcerpc_ack(struct ndr_print *ndr, const char *name, const struct dcerpc_ack *r)
1183
 
{
1184
 
        ndr_print_struct(ndr, name, "dcerpc_ack");
1185
 
        ndr->depth++;
1186
 
        ndr->depth--;
1187
 
}
1188
 
 
1189
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_ping(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_ping *r)
1190
 
{
1191
 
        if (ndr_flags & NDR_SCALARS) {
1192
 
                NDR_CHECK(ndr_push_align(ndr, 1));
1193
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1194
 
        }
1195
 
        if (ndr_flags & NDR_BUFFERS) {
1196
 
        }
1197
 
        return NDR_ERR_SUCCESS;
1198
 
}
1199
 
 
1200
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_ping(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_ping *r)
1201
 
{
1202
 
        if (ndr_flags & NDR_SCALARS) {
1203
 
                NDR_CHECK(ndr_pull_align(ndr, 1));
1204
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1205
 
        }
1206
 
        if (ndr_flags & NDR_BUFFERS) {
1207
 
        }
1208
 
        return NDR_ERR_SUCCESS;
1209
 
}
1210
 
 
1211
 
_PUBLIC_ void ndr_print_dcerpc_ping(struct ndr_print *ndr, const char *name, const struct dcerpc_ping *r)
1212
 
{
1213
 
        ndr_print_struct(ndr, name, "dcerpc_ping");
1214
 
        ndr->depth++;
1215
 
        ndr->depth--;
1216
 
}
1217
 
 
1218
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_shutdown(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_shutdown *r)
1219
 
{
1220
 
        if (ndr_flags & NDR_SCALARS) {
1221
 
                NDR_CHECK(ndr_push_align(ndr, 1));
1222
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1223
 
        }
1224
 
        if (ndr_flags & NDR_BUFFERS) {
1225
 
        }
1226
 
        return NDR_ERR_SUCCESS;
1227
 
}
1228
 
 
1229
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_shutdown(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_shutdown *r)
1230
 
{
1231
 
        if (ndr_flags & NDR_SCALARS) {
1232
 
                NDR_CHECK(ndr_pull_align(ndr, 1));
1233
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1234
 
        }
1235
 
        if (ndr_flags & NDR_BUFFERS) {
1236
 
        }
1237
 
        return NDR_ERR_SUCCESS;
1238
 
}
1239
 
 
1240
 
_PUBLIC_ void ndr_print_dcerpc_shutdown(struct ndr_print *ndr, const char *name, const struct dcerpc_shutdown *r)
1241
 
{
1242
 
        ndr_print_struct(ndr, name, "dcerpc_shutdown");
1243
 
        ndr->depth++;
1244
 
        ndr->depth--;
1245
 
}
1246
 
 
1247
 
_PUBLIC_ enum ndr_err_code ndr_push_dcerpc_working(struct ndr_push *ndr, int ndr_flags, const struct dcerpc_working *r)
1248
 
{
1249
 
        if (ndr_flags & NDR_SCALARS) {
1250
 
                NDR_CHECK(ndr_push_align(ndr, 1));
1251
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 1));
1252
 
        }
1253
 
        if (ndr_flags & NDR_BUFFERS) {
1254
 
        }
1255
 
        return NDR_ERR_SUCCESS;
1256
 
}
1257
 
 
1258
 
_PUBLIC_ enum ndr_err_code ndr_pull_dcerpc_working(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_working *r)
1259
 
{
1260
 
        if (ndr_flags & NDR_SCALARS) {
1261
 
                NDR_CHECK(ndr_pull_align(ndr, 1));
1262
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
1263
 
        }
1264
 
        if (ndr_flags & NDR_BUFFERS) {
1265
 
        }
1266
 
        return NDR_ERR_SUCCESS;
1267
 
}
1268
 
 
1269
 
_PUBLIC_ void ndr_print_dcerpc_working(struct ndr_print *ndr, const char *name, const struct dcerpc_working *r)
1270
 
{
1271
 
        ndr_print_struct(ndr, name, "dcerpc_working");
1272
 
        ndr->depth++;
1273
 
        ndr->depth--;
1274
 
}
1275
 
 
1276
 
static enum ndr_err_code ndr_push_dcerpc_pkt_type(struct ndr_push *ndr, int ndr_flags, enum dcerpc_pkt_type r)
1277
 
{
1278
 
        NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
1279
 
        return NDR_ERR_SUCCESS;
1280
 
}
1281
 
 
1282
 
static enum ndr_err_code ndr_pull_dcerpc_pkt_type(struct ndr_pull *ndr, int ndr_flags, enum dcerpc_pkt_type *r)
1283
 
{
1284
 
        uint8_t v;
1285
 
        NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
1286
 
        *r = v;
1287
 
        return NDR_ERR_SUCCESS;
1288
 
}
1289
 
 
1290
 
_PUBLIC_ void ndr_print_dcerpc_pkt_type(struct ndr_print *ndr, const char *name, enum dcerpc_pkt_type r)
1291
 
{
1292
 
        const char *val = NULL;
1293
 
 
1294
 
        switch (r) {
1295
 
                case DCERPC_PKT_REQUEST: val = "DCERPC_PKT_REQUEST"; break;
1296
 
                case DCERPC_PKT_PING: val = "DCERPC_PKT_PING"; break;
1297
 
                case DCERPC_PKT_RESPONSE: val = "DCERPC_PKT_RESPONSE"; break;
1298
 
                case DCERPC_PKT_FAULT: val = "DCERPC_PKT_FAULT"; break;
1299
 
                case DCERPC_PKT_WORKING: val = "DCERPC_PKT_WORKING"; break;
1300
 
                case DCERPC_PKT_NOCALL: val = "DCERPC_PKT_NOCALL"; break;
1301
 
                case DCERPC_PKT_REJECT: val = "DCERPC_PKT_REJECT"; break;
1302
 
                case DCERPC_PKT_ACK: val = "DCERPC_PKT_ACK"; break;
1303
 
                case DCERPC_PKT_CL_CANCEL: val = "DCERPC_PKT_CL_CANCEL"; break;
1304
 
                case DCERPC_PKT_FACK: val = "DCERPC_PKT_FACK"; break;
1305
 
                case DCERPC_PKT_CANCEL_ACK: val = "DCERPC_PKT_CANCEL_ACK"; break;
1306
 
                case DCERPC_PKT_BIND: val = "DCERPC_PKT_BIND"; break;
1307
 
                case DCERPC_PKT_BIND_ACK: val = "DCERPC_PKT_BIND_ACK"; break;
1308
 
                case DCERPC_PKT_BIND_NAK: val = "DCERPC_PKT_BIND_NAK"; break;
1309
 
                case DCERPC_PKT_ALTER: val = "DCERPC_PKT_ALTER"; break;
1310
 
                case DCERPC_PKT_ALTER_RESP: val = "DCERPC_PKT_ALTER_RESP"; break;
1311
 
                case DCERPC_PKT_AUTH3: val = "DCERPC_PKT_AUTH3"; break;
1312
 
                case DCERPC_PKT_SHUTDOWN: val = "DCERPC_PKT_SHUTDOWN"; break;
1313
 
                case DCERPC_PKT_CO_CANCEL: val = "DCERPC_PKT_CO_CANCEL"; break;
1314
 
                case DCERPC_PKT_ORPHANED: val = "DCERPC_PKT_ORPHANED"; break;
1315
 
        }
1316
 
        ndr_print_enum(ndr, name, "ENUM", val, r);
1317
 
}
1318
 
 
1319
 
static enum ndr_err_code ndr_push_dcerpc_payload(struct ndr_push *ndr, int ndr_flags, const union dcerpc_payload *r)
1320
 
{
1321
 
        if (ndr_flags & NDR_SCALARS) {
1322
 
                int level = ndr_push_get_switch_value(ndr, r);
1323
 
                NDR_CHECK(ndr_push_union_align(ndr, 4));
1324
 
                switch (level) {
1325
 
                        case DCERPC_PKT_REQUEST: {
1326
 
                                NDR_CHECK(ndr_push_dcerpc_request(ndr, NDR_SCALARS, &r->request));
1327
 
                        break; }
1328
 
 
1329
 
                        case DCERPC_PKT_PING: {
1330
 
                                NDR_CHECK(ndr_push_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
1331
 
                        break; }
1332
 
 
1333
 
                        case DCERPC_PKT_RESPONSE: {
1334
 
                                NDR_CHECK(ndr_push_dcerpc_response(ndr, NDR_SCALARS, &r->response));
1335
 
                        break; }
1336
 
 
1337
 
                        case DCERPC_PKT_FAULT: {
1338
 
                                NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
1339
 
                        break; }
1340
 
 
1341
 
                        case DCERPC_PKT_WORKING: {
1342
 
                                NDR_CHECK(ndr_push_dcerpc_working(ndr, NDR_SCALARS, &r->working));
1343
 
                        break; }
1344
 
 
1345
 
                        case DCERPC_PKT_NOCALL: {
1346
 
                                NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
1347
 
                        break; }
1348
 
 
1349
 
                        case DCERPC_PKT_REJECT: {
1350
 
                                NDR_CHECK(ndr_push_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
1351
 
                        break; }
1352
 
 
1353
 
                        case DCERPC_PKT_ACK: {
1354
 
                                NDR_CHECK(ndr_push_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
1355
 
                        break; }
1356
 
 
1357
 
                        case DCERPC_PKT_CL_CANCEL: {
1358
 
                                NDR_CHECK(ndr_push_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
1359
 
                        break; }
1360
 
 
1361
 
                        case DCERPC_PKT_FACK: {
1362
 
                                NDR_CHECK(ndr_push_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
1363
 
                        break; }
1364
 
 
1365
 
                        case DCERPC_PKT_CANCEL_ACK: {
1366
 
                                NDR_CHECK(ndr_push_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
1367
 
                        break; }
1368
 
 
1369
 
                        case DCERPC_PKT_BIND: {
1370
 
                                NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
1371
 
                        break; }
1372
 
 
1373
 
                        case DCERPC_PKT_BIND_ACK: {
1374
 
                                NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
1375
 
                        break; }
1376
 
 
1377
 
                        case DCERPC_PKT_BIND_NAK: {
1378
 
                                NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
1379
 
                        break; }
1380
 
 
1381
 
                        case DCERPC_PKT_ALTER: {
1382
 
                                NDR_CHECK(ndr_push_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
1383
 
                        break; }
1384
 
 
1385
 
                        case DCERPC_PKT_ALTER_RESP: {
1386
 
                                NDR_CHECK(ndr_push_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
1387
 
                        break; }
1388
 
 
1389
 
                        case DCERPC_PKT_SHUTDOWN: {
1390
 
                                NDR_CHECK(ndr_push_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
1391
 
                        break; }
1392
 
 
1393
 
                        case DCERPC_PKT_CO_CANCEL: {
1394
 
                                NDR_CHECK(ndr_push_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
1395
 
                        break; }
1396
 
 
1397
 
                        case DCERPC_PKT_ORPHANED: {
1398
 
                                NDR_CHECK(ndr_push_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
1399
 
                        break; }
1400
 
 
1401
 
                        case DCERPC_PKT_AUTH3: {
1402
 
                                NDR_CHECK(ndr_push_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
1403
 
                        break; }
1404
 
 
1405
 
                        default:
1406
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1407
 
                }
1408
 
        }
1409
 
        if (ndr_flags & NDR_BUFFERS) {
1410
 
                int level = ndr_push_get_switch_value(ndr, r);
1411
 
                switch (level) {
1412
 
                        case DCERPC_PKT_REQUEST:
1413
 
                        break;
1414
 
 
1415
 
                        case DCERPC_PKT_PING:
1416
 
                        break;
1417
 
 
1418
 
                        case DCERPC_PKT_RESPONSE:
1419
 
                        break;
1420
 
 
1421
 
                        case DCERPC_PKT_FAULT:
1422
 
                        break;
1423
 
 
1424
 
                        case DCERPC_PKT_WORKING:
1425
 
                        break;
1426
 
 
1427
 
                        case DCERPC_PKT_NOCALL:
1428
 
                        break;
1429
 
 
1430
 
                        case DCERPC_PKT_REJECT:
1431
 
                        break;
1432
 
 
1433
 
                        case DCERPC_PKT_ACK:
1434
 
                        break;
1435
 
 
1436
 
                        case DCERPC_PKT_CL_CANCEL:
1437
 
                        break;
1438
 
 
1439
 
                        case DCERPC_PKT_FACK:
1440
 
                        break;
1441
 
 
1442
 
                        case DCERPC_PKT_CANCEL_ACK:
1443
 
                        break;
1444
 
 
1445
 
                        case DCERPC_PKT_BIND:
1446
 
                        break;
1447
 
 
1448
 
                        case DCERPC_PKT_BIND_ACK:
1449
 
                        break;
1450
 
 
1451
 
                        case DCERPC_PKT_BIND_NAK:
1452
 
                                NDR_CHECK(ndr_push_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
1453
 
                        break;
1454
 
 
1455
 
                        case DCERPC_PKT_ALTER:
1456
 
                        break;
1457
 
 
1458
 
                        case DCERPC_PKT_ALTER_RESP:
1459
 
                        break;
1460
 
 
1461
 
                        case DCERPC_PKT_SHUTDOWN:
1462
 
                        break;
1463
 
 
1464
 
                        case DCERPC_PKT_CO_CANCEL:
1465
 
                        break;
1466
 
 
1467
 
                        case DCERPC_PKT_ORPHANED:
1468
 
                        break;
1469
 
 
1470
 
                        case DCERPC_PKT_AUTH3:
1471
 
                        break;
1472
 
 
1473
 
                        default:
1474
 
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1475
 
                }
1476
 
        }
1477
 
        return NDR_ERR_SUCCESS;
1478
 
}
1479
 
 
1480
 
static enum ndr_err_code ndr_pull_dcerpc_payload(struct ndr_pull *ndr, int ndr_flags, union dcerpc_payload *r)
1481
 
{
1482
 
        int level;
1483
 
        level = ndr_pull_get_switch_value(ndr, r);
1484
 
        if (ndr_flags & NDR_SCALARS) {
1485
 
                NDR_CHECK(ndr_pull_union_align(ndr, 4));
1486
 
                switch (level) {
1487
 
                        case DCERPC_PKT_REQUEST: {
1488
 
                                NDR_CHECK(ndr_pull_dcerpc_request(ndr, NDR_SCALARS, &r->request));
1489
 
                        break; }
1490
 
 
1491
 
                        case DCERPC_PKT_PING: {
1492
 
                                NDR_CHECK(ndr_pull_dcerpc_ping(ndr, NDR_SCALARS, &r->ping));
1493
 
                        break; }
1494
 
 
1495
 
                        case DCERPC_PKT_RESPONSE: {
1496
 
                                NDR_CHECK(ndr_pull_dcerpc_response(ndr, NDR_SCALARS, &r->response));
1497
 
                        break; }
1498
 
 
1499
 
                        case DCERPC_PKT_FAULT: {
1500
 
                                NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->fault));
1501
 
                        break; }
1502
 
 
1503
 
                        case DCERPC_PKT_WORKING: {
1504
 
                                NDR_CHECK(ndr_pull_dcerpc_working(ndr, NDR_SCALARS, &r->working));
1505
 
                        break; }
1506
 
 
1507
 
                        case DCERPC_PKT_NOCALL: {
1508
 
                                NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->nocall));
1509
 
                        break; }
1510
 
 
1511
 
                        case DCERPC_PKT_REJECT: {
1512
 
                                NDR_CHECK(ndr_pull_dcerpc_fault(ndr, NDR_SCALARS, &r->reject));
1513
 
                        break; }
1514
 
 
1515
 
                        case DCERPC_PKT_ACK: {
1516
 
                                NDR_CHECK(ndr_pull_dcerpc_ack(ndr, NDR_SCALARS, &r->ack));
1517
 
                        break; }
1518
 
 
1519
 
                        case DCERPC_PKT_CL_CANCEL: {
1520
 
                                NDR_CHECK(ndr_pull_dcerpc_cl_cancel(ndr, NDR_SCALARS, &r->cl_cancel));
1521
 
                        break; }
1522
 
 
1523
 
                        case DCERPC_PKT_FACK: {
1524
 
                                NDR_CHECK(ndr_pull_dcerpc_fack(ndr, NDR_SCALARS, &r->fack));
1525
 
                        break; }
1526
 
 
1527
 
                        case DCERPC_PKT_CANCEL_ACK: {
1528
 
                                NDR_CHECK(ndr_pull_dcerpc_cancel_ack(ndr, NDR_SCALARS, &r->cancel_ack));
1529
 
                        break; }
1530
 
 
1531
 
                        case DCERPC_PKT_BIND: {
1532
 
                                NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->bind));
1533
 
                        break; }
1534
 
 
1535
 
                        case DCERPC_PKT_BIND_ACK: {
1536
 
                                NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->bind_ack));
1537
 
                        break; }
1538
 
 
1539
 
                        case DCERPC_PKT_BIND_NAK: {
1540
 
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_SCALARS, &r->bind_nak));
1541
 
                        break; }
1542
 
 
1543
 
                        case DCERPC_PKT_ALTER: {
1544
 
                                NDR_CHECK(ndr_pull_dcerpc_bind(ndr, NDR_SCALARS, &r->alter));
1545
 
                        break; }
1546
 
 
1547
 
                        case DCERPC_PKT_ALTER_RESP: {
1548
 
                                NDR_CHECK(ndr_pull_dcerpc_bind_ack(ndr, NDR_SCALARS, &r->alter_resp));
1549
 
                        break; }
1550
 
 
1551
 
                        case DCERPC_PKT_SHUTDOWN: {
1552
 
                                NDR_CHECK(ndr_pull_dcerpc_shutdown(ndr, NDR_SCALARS, &r->shutdown));
1553
 
                        break; }
1554
 
 
1555
 
                        case DCERPC_PKT_CO_CANCEL: {
1556
 
                                NDR_CHECK(ndr_pull_dcerpc_co_cancel(ndr, NDR_SCALARS, &r->co_cancel));
1557
 
                        break; }
1558
 
 
1559
 
                        case DCERPC_PKT_ORPHANED: {
1560
 
                                NDR_CHECK(ndr_pull_dcerpc_orphaned(ndr, NDR_SCALARS, &r->orphaned));
1561
 
                        break; }
1562
 
 
1563
 
                        case DCERPC_PKT_AUTH3: {
1564
 
                                NDR_CHECK(ndr_pull_dcerpc_auth3(ndr, NDR_SCALARS, &r->auth3));
1565
 
                        break; }
1566
 
 
1567
 
                        default:
1568
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1569
 
                }
1570
 
        }
1571
 
        if (ndr_flags & NDR_BUFFERS) {
1572
 
                switch (level) {
1573
 
                        case DCERPC_PKT_REQUEST:
1574
 
                        break;
1575
 
 
1576
 
                        case DCERPC_PKT_PING:
1577
 
                        break;
1578
 
 
1579
 
                        case DCERPC_PKT_RESPONSE:
1580
 
                        break;
1581
 
 
1582
 
                        case DCERPC_PKT_FAULT:
1583
 
                        break;
1584
 
 
1585
 
                        case DCERPC_PKT_WORKING:
1586
 
                        break;
1587
 
 
1588
 
                        case DCERPC_PKT_NOCALL:
1589
 
                        break;
1590
 
 
1591
 
                        case DCERPC_PKT_REJECT:
1592
 
                        break;
1593
 
 
1594
 
                        case DCERPC_PKT_ACK:
1595
 
                        break;
1596
 
 
1597
 
                        case DCERPC_PKT_CL_CANCEL:
1598
 
                        break;
1599
 
 
1600
 
                        case DCERPC_PKT_FACK:
1601
 
                        break;
1602
 
 
1603
 
                        case DCERPC_PKT_CANCEL_ACK:
1604
 
                        break;
1605
 
 
1606
 
                        case DCERPC_PKT_BIND:
1607
 
                        break;
1608
 
 
1609
 
                        case DCERPC_PKT_BIND_ACK:
1610
 
                        break;
1611
 
 
1612
 
                        case DCERPC_PKT_BIND_NAK:
1613
 
                                NDR_CHECK(ndr_pull_dcerpc_bind_nak(ndr, NDR_BUFFERS, &r->bind_nak));
1614
 
                        break;
1615
 
 
1616
 
                        case DCERPC_PKT_ALTER:
1617
 
                        break;
1618
 
 
1619
 
                        case DCERPC_PKT_ALTER_RESP:
1620
 
                        break;
1621
 
 
1622
 
                        case DCERPC_PKT_SHUTDOWN:
1623
 
                        break;
1624
 
 
1625
 
                        case DCERPC_PKT_CO_CANCEL:
1626
 
                        break;
1627
 
 
1628
 
                        case DCERPC_PKT_ORPHANED:
1629
 
                        break;
1630
 
 
1631
 
                        case DCERPC_PKT_AUTH3:
1632
 
                        break;
1633
 
 
1634
 
                        default:
1635
 
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1636
 
                }
1637
 
        }
1638
 
        return NDR_ERR_SUCCESS;
1639
 
}
1640
 
 
1641
 
_PUBLIC_ void ndr_print_dcerpc_payload(struct ndr_print *ndr, const char *name, const union dcerpc_payload *r)
1642
 
{
1643
 
        int level;
1644
 
        level = ndr_print_get_switch_value(ndr, r);
1645
 
        ndr_print_union(ndr, name, level, "dcerpc_payload");
1646
 
        switch (level) {
1647
 
                case DCERPC_PKT_REQUEST:
1648
 
                        ndr_print_dcerpc_request(ndr, "request", &r->request);
1649
 
                break;
1650
 
 
1651
 
                case DCERPC_PKT_PING:
1652
 
                        ndr_print_dcerpc_ping(ndr, "ping", &r->ping);
1653
 
                break;
1654
 
 
1655
 
                case DCERPC_PKT_RESPONSE:
1656
 
                        ndr_print_dcerpc_response(ndr, "response", &r->response);
1657
 
                break;
1658
 
 
1659
 
                case DCERPC_PKT_FAULT:
1660
 
                        ndr_print_dcerpc_fault(ndr, "fault", &r->fault);
1661
 
                break;
1662
 
 
1663
 
                case DCERPC_PKT_WORKING:
1664
 
                        ndr_print_dcerpc_working(ndr, "working", &r->working);
1665
 
                break;
1666
 
 
1667
 
                case DCERPC_PKT_NOCALL:
1668
 
                        ndr_print_dcerpc_fack(ndr, "nocall", &r->nocall);
1669
 
                break;
1670
 
 
1671
 
                case DCERPC_PKT_REJECT:
1672
 
                        ndr_print_dcerpc_fault(ndr, "reject", &r->reject);
1673
 
                break;
1674
 
 
1675
 
                case DCERPC_PKT_ACK:
1676
 
                        ndr_print_dcerpc_ack(ndr, "ack", &r->ack);
1677
 
                break;
1678
 
 
1679
 
                case DCERPC_PKT_CL_CANCEL:
1680
 
                        ndr_print_dcerpc_cl_cancel(ndr, "cl_cancel", &r->cl_cancel);
1681
 
                break;
1682
 
 
1683
 
                case DCERPC_PKT_FACK:
1684
 
                        ndr_print_dcerpc_fack(ndr, "fack", &r->fack);
1685
 
                break;
1686
 
 
1687
 
                case DCERPC_PKT_CANCEL_ACK:
1688
 
                        ndr_print_dcerpc_cancel_ack(ndr, "cancel_ack", &r->cancel_ack);
1689
 
                break;
1690
 
 
1691
 
                case DCERPC_PKT_BIND:
1692
 
                        ndr_print_dcerpc_bind(ndr, "bind", &r->bind);
1693
 
                break;
1694
 
 
1695
 
                case DCERPC_PKT_BIND_ACK:
1696
 
                        ndr_print_dcerpc_bind_ack(ndr, "bind_ack", &r->bind_ack);
1697
 
                break;
1698
 
 
1699
 
                case DCERPC_PKT_BIND_NAK:
1700
 
                        ndr_print_dcerpc_bind_nak(ndr, "bind_nak", &r->bind_nak);
1701
 
                break;
1702
 
 
1703
 
                case DCERPC_PKT_ALTER:
1704
 
                        ndr_print_dcerpc_bind(ndr, "alter", &r->alter);
1705
 
                break;
1706
 
 
1707
 
                case DCERPC_PKT_ALTER_RESP:
1708
 
                        ndr_print_dcerpc_bind_ack(ndr, "alter_resp", &r->alter_resp);
1709
 
                break;
1710
 
 
1711
 
                case DCERPC_PKT_SHUTDOWN:
1712
 
                        ndr_print_dcerpc_shutdown(ndr, "shutdown", &r->shutdown);
1713
 
                break;
1714
 
 
1715
 
                case DCERPC_PKT_CO_CANCEL:
1716
 
                        ndr_print_dcerpc_co_cancel(ndr, "co_cancel", &r->co_cancel);
1717
 
                break;
1718
 
 
1719
 
                case DCERPC_PKT_ORPHANED:
1720
 
                        ndr_print_dcerpc_orphaned(ndr, "orphaned", &r->orphaned);
1721
 
                break;
1722
 
 
1723
 
                case DCERPC_PKT_AUTH3:
1724
 
                        ndr_print_dcerpc_auth3(ndr, "auth3", &r->auth3);
1725
 
                break;
1726
 
 
1727
 
                default:
1728
 
                        ndr_print_bad_level(ndr, name, level);
1729
 
        }
1730
 
}
1731
 
 
1732
 
_PUBLIC_ enum ndr_err_code ndr_push_ncacn_packet(struct ndr_push *ndr, int ndr_flags, const struct ncacn_packet *r)
1733
 
{
1734
 
        if (ndr_flags & NDR_SCALARS) {
1735
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1736
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
1737
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers_minor));
1738
 
                NDR_CHECK(ndr_push_dcerpc_pkt_type(ndr, NDR_SCALARS, r->ptype));
1739
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
1740
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
1741
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->frag_length));
1742
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->auth_length));
1743
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->call_id));
1744
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
1745
 
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1746
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1747
 
        }
1748
 
        if (ndr_flags & NDR_BUFFERS) {
1749
 
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1750
 
        }
1751
 
        return NDR_ERR_SUCCESS;
1752
 
}
1753
 
 
1754
 
_PUBLIC_ enum ndr_err_code ndr_pull_ncacn_packet(struct ndr_pull *ndr, int ndr_flags, struct ncacn_packet *r)
1755
 
{
1756
 
        if (ndr_flags & NDR_SCALARS) {
1757
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1758
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
1759
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers_minor));
1760
 
                NDR_CHECK(ndr_pull_dcerpc_pkt_type(ndr, NDR_SCALARS, &r->ptype));
1761
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
1762
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 4));
1763
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->frag_length));
1764
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->auth_length));
1765
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->call_id));
1766
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
1767
 
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1768
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1769
 
        }
1770
 
        if (ndr_flags & NDR_BUFFERS) {
1771
 
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1772
 
        }
1773
 
        return NDR_ERR_SUCCESS;
1774
 
}
1775
 
 
1776
 
_PUBLIC_ void ndr_print_ncacn_packet(struct ndr_print *ndr, const char *name, const struct ncacn_packet *r)
1777
 
{
1778
 
        ndr_print_struct(ndr, name, "ncacn_packet");
1779
 
        ndr->depth++;
1780
 
        ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
1781
 
        ndr_print_uint8(ndr, "rpc_vers_minor", r->rpc_vers_minor);
1782
 
        ndr_print_dcerpc_pkt_type(ndr, "ptype", r->ptype);
1783
 
        ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
1784
 
        ndr_print_array_uint8(ndr, "drep", r->drep, 4);
1785
 
        ndr_print_uint16(ndr, "frag_length", r->frag_length);
1786
 
        ndr_print_uint16(ndr, "auth_length", r->auth_length);
1787
 
        ndr_print_uint32(ndr, "call_id", r->call_id);
1788
 
        ndr_print_set_switch_value(ndr, &r->u, r->ptype);
1789
 
        ndr_print_dcerpc_payload(ndr, "u", &r->u);
1790
 
        ndr->depth--;
1791
 
}
1792
 
 
1793
 
_PUBLIC_ enum ndr_err_code ndr_push_ncadg_packet(struct ndr_push *ndr, int ndr_flags, const struct ncadg_packet *r)
1794
 
{
1795
 
        if (ndr_flags & NDR_SCALARS) {
1796
 
                NDR_CHECK(ndr_push_align(ndr, 4));
1797
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rpc_vers));
1798
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ptype));
1799
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->pfc_flags));
1800
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->ncadg_flags));
1801
 
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
1802
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_high));
1803
 
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->object));
1804
 
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->iface));
1805
 
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->activity));
1806
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->server_boot));
1807
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iface_version));
1808
 
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->seq_num));
1809
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->opnum));
1810
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ihint));
1811
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ahint));
1812
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->len));
1813
 
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->fragnum));
1814
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->auth_proto));
1815
 
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->serial_low));
1816
 
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->ptype));
1817
 
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1818
 
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1819
 
        }
1820
 
        if (ndr_flags & NDR_BUFFERS) {
1821
 
                NDR_CHECK(ndr_push_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1822
 
        }
1823
 
        return NDR_ERR_SUCCESS;
1824
 
}
1825
 
 
1826
 
_PUBLIC_ enum ndr_err_code ndr_pull_ncadg_packet(struct ndr_pull *ndr, int ndr_flags, struct ncadg_packet *r)
1827
 
{
1828
 
        if (ndr_flags & NDR_SCALARS) {
1829
 
                NDR_CHECK(ndr_pull_align(ndr, 4));
1830
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rpc_vers));
1831
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ptype));
1832
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->pfc_flags));
1833
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->ncadg_flags));
1834
 
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->drep, 3));
1835
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_high));
1836
 
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->object));
1837
 
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->iface));
1838
 
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->activity));
1839
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->server_boot));
1840
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iface_version));
1841
 
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->seq_num));
1842
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->opnum));
1843
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ihint));
1844
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ahint));
1845
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->len));
1846
 
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->fragnum));
1847
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->auth_proto));
1848
 
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->serial_low));
1849
 
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->ptype));
1850
 
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_SCALARS, &r->u));
1851
 
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1852
 
        }
1853
 
        if (ndr_flags & NDR_BUFFERS) {
1854
 
                NDR_CHECK(ndr_pull_dcerpc_payload(ndr, NDR_BUFFERS, &r->u));
1855
 
        }
1856
 
        return NDR_ERR_SUCCESS;
1857
 
}
1858
 
 
1859
 
_PUBLIC_ void ndr_print_ncadg_packet(struct ndr_print *ndr, const char *name, const struct ncadg_packet *r)
1860
 
{
1861
 
        ndr_print_struct(ndr, name, "ncadg_packet");
1862
 
        ndr->depth++;
1863
 
        ndr_print_uint8(ndr, "rpc_vers", r->rpc_vers);
1864
 
        ndr_print_uint8(ndr, "ptype", r->ptype);
1865
 
        ndr_print_uint8(ndr, "pfc_flags", r->pfc_flags);
1866
 
        ndr_print_uint8(ndr, "ncadg_flags", r->ncadg_flags);
1867
 
        ndr_print_array_uint8(ndr, "drep", r->drep, 3);
1868
 
        ndr_print_uint8(ndr, "serial_high", r->serial_high);
1869
 
        ndr_print_GUID(ndr, "object", &r->object);
1870
 
        ndr_print_GUID(ndr, "iface", &r->iface);
1871
 
        ndr_print_GUID(ndr, "activity", &r->activity);
1872
 
        ndr_print_uint32(ndr, "server_boot", r->server_boot);
1873
 
        ndr_print_uint32(ndr, "iface_version", r->iface_version);
1874
 
        ndr_print_uint32(ndr, "seq_num", r->seq_num);
1875
 
        ndr_print_uint16(ndr, "opnum", r->opnum);
1876
 
        ndr_print_uint16(ndr, "ihint", r->ihint);
1877
 
        ndr_print_uint16(ndr, "ahint", r->ahint);
1878
 
        ndr_print_uint16(ndr, "len", r->len);
1879
 
        ndr_print_uint16(ndr, "fragnum", r->fragnum);
1880
 
        ndr_print_uint8(ndr, "auth_proto", r->auth_proto);
1881
 
        ndr_print_uint8(ndr, "serial_low", r->serial_low);
1882
 
        ndr_print_set_switch_value(ndr, &r->u, r->ptype);
1883
 
        ndr_print_dcerpc_payload(ndr, "u", &r->u);
1884
 
        ndr->depth--;
1885
 
}
1886