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