~ubuntu-branches/ubuntu/wily/samba/wily
» Revision
179
: .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_drsblobs.c
« back to all changes in this revision
Viewing changes to .pc/CVE-2012-1182-2.patch/source3/librpc/gen_ndr/ndr_drsblobs.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_drsblobs.c
1
/* parser auto-generated by pidl */
2
3
#include "includes.h"
4
#include "librpc/gen_ndr/ndr_drsblobs.h"
5
6
#include "librpc/gen_ndr/ndr_drsuapi.h"
7
#include "librpc/gen_ndr/ndr_misc.h"
8
#include "librpc/gen_ndr/ndr_samr.h"
9
#include "librpc/gen_ndr/ndr_lsa.h"
10
#include "librpc/gen_ndr/ndr_security.h"
11
static enum ndr_err_code ndr_push_replPropertyMetaData1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaData1 *r)
12
{
13
if (ndr_flags & NDR_SCALARS) {
14
NDR_CHECK(ndr_push_align(ndr, 8));
15
NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
16
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
17
NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
18
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
19
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
20
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
21
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
22
}
23
if (ndr_flags & NDR_BUFFERS) {
24
}
25
return NDR_ERR_SUCCESS;
26
}
27
28
static enum ndr_err_code ndr_pull_replPropertyMetaData1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaData1 *r)
29
{
30
if (ndr_flags & NDR_SCALARS) {
31
NDR_CHECK(ndr_pull_align(ndr, 8));
32
NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
33
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
34
NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
35
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
36
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
37
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
38
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
39
}
40
if (ndr_flags & NDR_BUFFERS) {
41
}
42
return NDR_ERR_SUCCESS;
43
}
44
45
_PUBLIC_ void ndr_print_replPropertyMetaData1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaData1 *r)
46
{
47
ndr_print_struct(ndr, name, "replPropertyMetaData1");
48
if (r == NULL) { ndr_print_null(ndr); return; }
49
ndr->depth++;
50
ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
51
ndr_print_uint32(ndr, "version", r->version);
52
ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
53
ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
54
ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
55
ndr_print_hyper(ndr, "local_usn", r->local_usn);
56
ndr->depth--;
57
}
58
59
static enum ndr_err_code ndr_push_replPropertyMetaDataCtr1(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataCtr1 *r)
60
{
61
uint32_t cntr_array_0;
62
if (ndr_flags & NDR_SCALARS) {
63
NDR_CHECK(ndr_push_align(ndr, 8));
64
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
65
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
66
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
67
NDR_CHECK(ndr_push_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
68
}
69
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
70
}
71
if (ndr_flags & NDR_BUFFERS) {
72
}
73
return NDR_ERR_SUCCESS;
74
}
75
76
static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr1(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataCtr1 *r)
77
{
78
uint32_t cntr_array_0;
79
TALLOC_CTX *_mem_save_array_0;
80
if (ndr_flags & NDR_SCALARS) {
81
NDR_CHECK(ndr_pull_align(ndr, 8));
82
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
83
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
84
NDR_PULL_ALLOC_N(ndr, r->array, r->count);
85
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
86
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
87
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
88
NDR_CHECK(ndr_pull_replPropertyMetaData1(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
89
}
90
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
91
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
92
}
93
if (ndr_flags & NDR_BUFFERS) {
94
}
95
return NDR_ERR_SUCCESS;
96
}
97
98
_PUBLIC_ void ndr_print_replPropertyMetaDataCtr1(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataCtr1 *r)
99
{
100
uint32_t cntr_array_0;
101
ndr_print_struct(ndr, name, "replPropertyMetaDataCtr1");
102
if (r == NULL) { ndr_print_null(ndr); return; }
103
ndr->depth++;
104
ndr_print_uint32(ndr, "count", r->count);
105
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
106
ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
107
ndr->depth++;
108
for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
109
ndr_print_replPropertyMetaData1(ndr, "array", &r->array[cntr_array_0]);
110
}
111
ndr->depth--;
112
ndr->depth--;
113
}
114
115
static enum ndr_err_code ndr_push_replPropertyMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const union replPropertyMetaDataCtr *r)
116
{
117
if (ndr_flags & NDR_SCALARS) {
118
uint32_t level = ndr_push_get_switch_value(ndr, r);
119
NDR_CHECK(ndr_push_union_align(ndr, 8));
120
switch (level) {
121
case 1: {
122
NDR_CHECK(ndr_push_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
123
break; }
124
125
default:
126
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
127
}
128
}
129
if (ndr_flags & NDR_BUFFERS) {
130
uint32_t level = ndr_push_get_switch_value(ndr, r);
131
switch (level) {
132
case 1:
133
break;
134
135
default:
136
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
137
}
138
}
139
return NDR_ERR_SUCCESS;
140
}
141
142
static enum ndr_err_code ndr_pull_replPropertyMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, union replPropertyMetaDataCtr *r)
143
{
144
uint32_t level;
145
level = ndr_pull_get_switch_value(ndr, r);
146
if (ndr_flags & NDR_SCALARS) {
147
NDR_CHECK(ndr_pull_union_align(ndr, 8));
148
switch (level) {
149
case 1: {
150
NDR_CHECK(ndr_pull_replPropertyMetaDataCtr1(ndr, NDR_SCALARS, &r->ctr1));
151
break; }
152
153
default:
154
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
155
}
156
}
157
if (ndr_flags & NDR_BUFFERS) {
158
switch (level) {
159
case 1:
160
break;
161
162
default:
163
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
164
}
165
}
166
return NDR_ERR_SUCCESS;
167
}
168
169
_PUBLIC_ void ndr_print_replPropertyMetaDataCtr(struct ndr_print *ndr, const char *name, const union replPropertyMetaDataCtr *r)
170
{
171
uint32_t level;
172
level = ndr_print_get_switch_value(ndr, r);
173
ndr_print_union(ndr, name, level, "replPropertyMetaDataCtr");
174
switch (level) {
175
case 1:
176
ndr_print_replPropertyMetaDataCtr1(ndr, "ctr1", &r->ctr1);
177
break;
178
179
default:
180
ndr_print_bad_level(ndr, name, level);
181
}
182
}
183
184
_PUBLIC_ enum ndr_err_code ndr_push_replPropertyMetaDataBlob(struct ndr_push *ndr, int ndr_flags, const struct replPropertyMetaDataBlob *r)
185
{
186
if (ndr_flags & NDR_SCALARS) {
187
NDR_CHECK(ndr_push_align(ndr, 8));
188
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
189
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
190
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
191
NDR_CHECK(ndr_push_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
192
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
193
}
194
if (ndr_flags & NDR_BUFFERS) {
195
}
196
return NDR_ERR_SUCCESS;
197
}
198
199
_PUBLIC_ enum ndr_err_code ndr_pull_replPropertyMetaDataBlob(struct ndr_pull *ndr, int ndr_flags, struct replPropertyMetaDataBlob *r)
200
{
201
if (ndr_flags & NDR_SCALARS) {
202
NDR_CHECK(ndr_pull_align(ndr, 8));
203
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
204
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
205
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
206
NDR_CHECK(ndr_pull_replPropertyMetaDataCtr(ndr, NDR_SCALARS, &r->ctr));
207
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
208
}
209
if (ndr_flags & NDR_BUFFERS) {
210
}
211
return NDR_ERR_SUCCESS;
212
}
213
214
_PUBLIC_ void ndr_print_replPropertyMetaDataBlob(struct ndr_print *ndr, const char *name, const struct replPropertyMetaDataBlob *r)
215
{
216
ndr_print_struct(ndr, name, "replPropertyMetaDataBlob");
217
if (r == NULL) { ndr_print_null(ndr); return; }
218
ndr->depth++;
219
ndr_print_uint32(ndr, "version", r->version);
220
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
221
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
222
ndr_print_replPropertyMetaDataCtr(ndr, "ctr", &r->ctr);
223
ndr->depth--;
224
}
225
226
static enum ndr_err_code ndr_push_replUpToDateVectorCtr1(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr1 *r)
227
{
228
uint32_t cntr_cursors_0;
229
if (ndr_flags & NDR_SCALARS) {
230
NDR_CHECK(ndr_push_align(ndr, 8));
231
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
232
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
233
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
234
NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
235
}
236
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
237
}
238
if (ndr_flags & NDR_BUFFERS) {
239
}
240
return NDR_ERR_SUCCESS;
241
}
242
243
static enum ndr_err_code ndr_pull_replUpToDateVectorCtr1(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr1 *r)
244
{
245
uint32_t cntr_cursors_0;
246
TALLOC_CTX *_mem_save_cursors_0;
247
if (ndr_flags & NDR_SCALARS) {
248
NDR_CHECK(ndr_pull_align(ndr, 8));
249
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
250
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
251
NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
252
_mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
253
NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
254
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
255
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
256
}
257
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
258
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
259
}
260
if (ndr_flags & NDR_BUFFERS) {
261
}
262
return NDR_ERR_SUCCESS;
263
}
264
265
_PUBLIC_ void ndr_print_replUpToDateVectorCtr1(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr1 *r)
266
{
267
uint32_t cntr_cursors_0;
268
ndr_print_struct(ndr, name, "replUpToDateVectorCtr1");
269
if (r == NULL) { ndr_print_null(ndr); return; }
270
ndr->depth++;
271
ndr_print_uint32(ndr, "count", r->count);
272
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
273
ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
274
ndr->depth++;
275
for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
276
ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
277
}
278
ndr->depth--;
279
ndr->depth--;
280
}
281
282
static enum ndr_err_code ndr_push_replUpToDateVectorCtr2(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorCtr2 *r)
283
{
284
uint32_t cntr_cursors_0;
285
if (ndr_flags & NDR_SCALARS) {
286
NDR_CHECK(ndr_push_align(ndr, 8));
287
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
288
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
289
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
290
NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
291
}
292
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
293
}
294
if (ndr_flags & NDR_BUFFERS) {
295
}
296
return NDR_ERR_SUCCESS;
297
}
298
299
static enum ndr_err_code ndr_pull_replUpToDateVectorCtr2(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorCtr2 *r)
300
{
301
uint32_t cntr_cursors_0;
302
TALLOC_CTX *_mem_save_cursors_0;
303
if (ndr_flags & NDR_SCALARS) {
304
NDR_CHECK(ndr_pull_align(ndr, 8));
305
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
306
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
307
NDR_PULL_ALLOC_N(ndr, r->cursors, r->count);
308
_mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
309
NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
310
for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
311
NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
312
}
313
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
314
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
315
}
316
if (ndr_flags & NDR_BUFFERS) {
317
}
318
return NDR_ERR_SUCCESS;
319
}
320
321
_PUBLIC_ void ndr_print_replUpToDateVectorCtr2(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorCtr2 *r)
322
{
323
uint32_t cntr_cursors_0;
324
ndr_print_struct(ndr, name, "replUpToDateVectorCtr2");
325
if (r == NULL) { ndr_print_null(ndr); return; }
326
ndr->depth++;
327
ndr_print_uint32(ndr, "count", r->count);
328
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
329
ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
330
ndr->depth++;
331
for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
332
ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
333
}
334
ndr->depth--;
335
ndr->depth--;
336
}
337
338
static enum ndr_err_code ndr_push_replUpToDateVectorCtr(struct ndr_push *ndr, int ndr_flags, const union replUpToDateVectorCtr *r)
339
{
340
if (ndr_flags & NDR_SCALARS) {
341
uint32_t level = ndr_push_get_switch_value(ndr, r);
342
NDR_CHECK(ndr_push_union_align(ndr, 8));
343
switch (level) {
344
case 1: {
345
NDR_CHECK(ndr_push_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
346
break; }
347
348
case 2: {
349
NDR_CHECK(ndr_push_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
350
break; }
351
352
default:
353
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
354
}
355
}
356
if (ndr_flags & NDR_BUFFERS) {
357
uint32_t level = ndr_push_get_switch_value(ndr, r);
358
switch (level) {
359
case 1:
360
break;
361
362
case 2:
363
break;
364
365
default:
366
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
367
}
368
}
369
return NDR_ERR_SUCCESS;
370
}
371
372
static enum ndr_err_code ndr_pull_replUpToDateVectorCtr(struct ndr_pull *ndr, int ndr_flags, union replUpToDateVectorCtr *r)
373
{
374
uint32_t level;
375
level = ndr_pull_get_switch_value(ndr, r);
376
if (ndr_flags & NDR_SCALARS) {
377
NDR_CHECK(ndr_pull_union_align(ndr, 8));
378
switch (level) {
379
case 1: {
380
NDR_CHECK(ndr_pull_replUpToDateVectorCtr1(ndr, NDR_SCALARS, &r->ctr1));
381
break; }
382
383
case 2: {
384
NDR_CHECK(ndr_pull_replUpToDateVectorCtr2(ndr, NDR_SCALARS, &r->ctr2));
385
break; }
386
387
default:
388
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
389
}
390
}
391
if (ndr_flags & NDR_BUFFERS) {
392
switch (level) {
393
case 1:
394
break;
395
396
case 2:
397
break;
398
399
default:
400
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
401
}
402
}
403
return NDR_ERR_SUCCESS;
404
}
405
406
_PUBLIC_ void ndr_print_replUpToDateVectorCtr(struct ndr_print *ndr, const char *name, const union replUpToDateVectorCtr *r)
407
{
408
uint32_t level;
409
level = ndr_print_get_switch_value(ndr, r);
410
ndr_print_union(ndr, name, level, "replUpToDateVectorCtr");
411
switch (level) {
412
case 1:
413
ndr_print_replUpToDateVectorCtr1(ndr, "ctr1", &r->ctr1);
414
break;
415
416
case 2:
417
ndr_print_replUpToDateVectorCtr2(ndr, "ctr2", &r->ctr2);
418
break;
419
420
default:
421
ndr_print_bad_level(ndr, name, level);
422
}
423
}
424
425
_PUBLIC_ enum ndr_err_code ndr_push_replUpToDateVectorBlob(struct ndr_push *ndr, int ndr_flags, const struct replUpToDateVectorBlob *r)
426
{
427
if (ndr_flags & NDR_SCALARS) {
428
NDR_CHECK(ndr_push_align(ndr, 8));
429
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
430
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
431
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
432
NDR_CHECK(ndr_push_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
433
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
434
}
435
if (ndr_flags & NDR_BUFFERS) {
436
}
437
return NDR_ERR_SUCCESS;
438
}
439
440
_PUBLIC_ enum ndr_err_code ndr_pull_replUpToDateVectorBlob(struct ndr_pull *ndr, int ndr_flags, struct replUpToDateVectorBlob *r)
441
{
442
if (ndr_flags & NDR_SCALARS) {
443
NDR_CHECK(ndr_pull_align(ndr, 8));
444
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
445
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
446
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
447
NDR_CHECK(ndr_pull_replUpToDateVectorCtr(ndr, NDR_SCALARS, &r->ctr));
448
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
449
}
450
if (ndr_flags & NDR_BUFFERS) {
451
}
452
return NDR_ERR_SUCCESS;
453
}
454
455
_PUBLIC_ void ndr_print_replUpToDateVectorBlob(struct ndr_print *ndr, const char *name, const struct replUpToDateVectorBlob *r)
456
{
457
ndr_print_struct(ndr, name, "replUpToDateVectorBlob");
458
if (r == NULL) { ndr_print_null(ndr); return; }
459
ndr->depth++;
460
ndr_print_uint32(ndr, "version", r->version);
461
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
462
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
463
ndr_print_replUpToDateVectorCtr(ndr, "ctr", &r->ctr);
464
ndr->depth--;
465
}
466
467
_PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1OtherInfo(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1OtherInfo *r)
468
{
469
if (ndr_flags & NDR_SCALARS) {
470
NDR_CHECK(ndr_push_align(ndr, 4));
471
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen(r->dns_name) + 1));
472
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, strlen(r->dns_name) + 1, sizeof(uint8_t), CH_DOS));
473
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
474
}
475
if (ndr_flags & NDR_BUFFERS) {
476
}
477
return NDR_ERR_SUCCESS;
478
}
479
480
_PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1OtherInfo(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1OtherInfo *r)
481
{
482
if (ndr_flags & NDR_SCALARS) {
483
NDR_CHECK(ndr_pull_align(ndr, 4));
484
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__dns_name_size));
485
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, r->__dns_name_size, sizeof(uint8_t), CH_DOS));
486
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
487
}
488
if (ndr_flags & NDR_BUFFERS) {
489
}
490
return NDR_ERR_SUCCESS;
491
}
492
493
_PUBLIC_ void ndr_print_repsFromTo1OtherInfo(struct ndr_print *ndr, const char *name, const struct repsFromTo1OtherInfo *r)
494
{
495
ndr_print_struct(ndr, name, "repsFromTo1OtherInfo");
496
if (r == NULL) { ndr_print_null(ndr); return; }
497
ndr->depth++;
498
ndr_print_uint32(ndr, "__dns_name_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->dns_name) + 1:r->__dns_name_size);
499
ndr_print_string(ndr, "dns_name", r->dns_name);
500
ndr->depth--;
501
}
502
503
_PUBLIC_ size_t ndr_size_repsFromTo1OtherInfo(const struct repsFromTo1OtherInfo *r, int flags)
504
{
505
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1OtherInfo);
506
}
507
508
_PUBLIC_ enum ndr_err_code ndr_push_repsFromTo1(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo1 *r)
509
{
510
{
511
uint32_t _flags_save_STRUCT = ndr->flags;
512
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
513
if (ndr_flags & NDR_SCALARS) {
514
NDR_CHECK(ndr_push_align(ndr, 8));
515
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1(r, ndr->flags) + 8));
516
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
517
NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_success));
518
NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_attempt));
519
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
520
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->other_info));
521
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->flags)));
522
NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
523
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
524
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
525
NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
526
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
527
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
528
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
529
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
530
}
531
if (ndr_flags & NDR_BUFFERS) {
532
if (r->other_info) {
533
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->other_info));
534
NDR_CHECK(ndr_push_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
535
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->other_info));
536
}
537
}
538
ndr->flags = _flags_save_STRUCT;
539
}
540
return NDR_ERR_SUCCESS;
541
}
542
543
_PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo1(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo1 *r)
544
{
545
uint32_t _ptr_other_info;
546
TALLOC_CTX *_mem_save_other_info_0;
547
{
548
uint32_t _flags_save_STRUCT = ndr->flags;
549
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
550
if (ndr_flags & NDR_SCALARS) {
551
NDR_CHECK(ndr_pull_align(ndr, 8));
552
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blobsize));
553
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
554
NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_success));
555
NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_attempt));
556
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
557
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
558
if (_ptr_other_info) {
559
NDR_PULL_ALLOC(ndr, r->other_info);
560
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->other_info, _ptr_other_info));
561
} else {
562
r->other_info = NULL;
563
}
564
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->other_info_length));
565
NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
566
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
567
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
568
NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
569
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
570
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
571
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
572
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
573
}
574
if (ndr_flags & NDR_BUFFERS) {
575
if (r->other_info) {
576
uint32_t _relative_save_offset;
577
_relative_save_offset = ndr->offset;
578
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->other_info));
579
_mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
580
NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
581
NDR_CHECK(ndr_pull_repsFromTo1OtherInfo(ndr, NDR_SCALARS, r->other_info));
582
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
583
if (ndr->offset > ndr->relative_highest_offset) {
584
ndr->relative_highest_offset = ndr->offset;
585
}
586
ndr->offset = _relative_save_offset;
587
}
588
}
589
ndr->flags = _flags_save_STRUCT;
590
}
591
return NDR_ERR_SUCCESS;
592
}
593
594
_PUBLIC_ void ndr_print_repsFromTo1(struct ndr_print *ndr, const char *name, const struct repsFromTo1 *r)
595
{
596
ndr_print_struct(ndr, name, "repsFromTo1");
597
if (r == NULL) { ndr_print_null(ndr); return; }
598
{
599
uint32_t _flags_save_STRUCT = ndr->flags;
600
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
601
ndr->depth++;
602
ndr_print_uint32(ndr, "blobsize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1(r, ndr->flags) + 8:r->blobsize);
603
ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
604
ndr_print_NTTIME_1sec(ndr, "last_success", r->last_success);
605
ndr_print_NTTIME_1sec(ndr, "last_attempt", r->last_attempt);
606
ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
607
ndr_print_ptr(ndr, "other_info", r->other_info);
608
ndr->depth++;
609
if (r->other_info) {
610
ndr_print_repsFromTo1OtherInfo(ndr, "other_info", r->other_info);
611
}
612
ndr->depth--;
613
ndr_print_uint32(ndr, "other_info_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo1OtherInfo(r->other_info, ndr->flags):r->other_info_length);
614
ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
615
ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
616
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
617
ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
618
ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
619
ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
620
ndr_print_GUID(ndr, "transport_guid", &r->transport_guid);
621
ndr->depth--;
622
ndr->flags = _flags_save_STRUCT;
623
}
624
}
625
626
_PUBLIC_ size_t ndr_size_repsFromTo1(const struct repsFromTo1 *r, int flags)
627
{
628
flags |= LIBNDR_PRINT_ARRAY_HEX;
629
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo1);
630
}
631
632
_PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2OtherInfo(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo2OtherInfo *r)
633
{
634
uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
635
if (ndr_flags & NDR_SCALARS) {
636
NDR_CHECK(ndr_push_align(ndr, 8));
637
NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
638
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2OtherInfo(r, ndr->flags)));
639
{
640
uint32_t _flags_save_string = ndr->flags;
641
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
642
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dns_name1));
643
ndr->flags = _flags_save_string;
644
}
645
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
646
{
647
uint32_t _flags_save_string = ndr->flags;
648
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
649
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dns_name2));
650
ndr->flags = _flags_save_string;
651
}
652
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown2));
653
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
654
}
655
if (ndr_flags & NDR_BUFFERS) {
656
NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
657
{
658
uint32_t _flags_save_string = ndr->flags;
659
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
660
if (r->dns_name1) {
661
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dns_name1));
662
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dns_name1));
663
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dns_name1));
664
}
665
ndr->flags = _flags_save_string;
666
}
667
{
668
uint32_t _flags_save_string = ndr->flags;
669
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
670
if (r->dns_name2) {
671
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dns_name2));
672
NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dns_name2));
673
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dns_name2));
674
}
675
ndr->flags = _flags_save_string;
676
}
677
}
678
ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
679
return NDR_ERR_SUCCESS;
680
}
681
682
_PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2OtherInfo(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo2OtherInfo *r)
683
{
684
uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
685
uint32_t _ptr_dns_name1;
686
TALLOC_CTX *_mem_save_dns_name1_0;
687
uint32_t _ptr_dns_name2;
688
TALLOC_CTX *_mem_save_dns_name2_0;
689
if (ndr_flags & NDR_SCALARS) {
690
NDR_CHECK(ndr_pull_align(ndr, 8));
691
NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
692
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
693
{
694
uint32_t _flags_save_string = ndr->flags;
695
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
696
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name1));
697
if (_ptr_dns_name1) {
698
NDR_PULL_ALLOC(ndr, r->dns_name1);
699
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dns_name1, _ptr_dns_name1));
700
} else {
701
r->dns_name1 = NULL;
702
}
703
ndr->flags = _flags_save_string;
704
}
705
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
706
{
707
uint32_t _flags_save_string = ndr->flags;
708
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
709
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name2));
710
if (_ptr_dns_name2) {
711
NDR_PULL_ALLOC(ndr, r->dns_name2);
712
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dns_name2, _ptr_dns_name2));
713
} else {
714
r->dns_name2 = NULL;
715
}
716
ndr->flags = _flags_save_string;
717
}
718
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown2));
719
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
720
}
721
if (ndr_flags & NDR_BUFFERS) {
722
NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
723
{
724
uint32_t _flags_save_string = ndr->flags;
725
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
726
if (r->dns_name1) {
727
uint32_t _relative_save_offset;
728
_relative_save_offset = ndr->offset;
729
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_name1));
730
_mem_save_dns_name1_0 = NDR_PULL_GET_MEM_CTX(ndr);
731
NDR_PULL_SET_MEM_CTX(ndr, r->dns_name1, 0);
732
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dns_name1));
733
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name1_0, 0);
734
if (ndr->offset > ndr->relative_highest_offset) {
735
ndr->relative_highest_offset = ndr->offset;
736
}
737
ndr->offset = _relative_save_offset;
738
}
739
ndr->flags = _flags_save_string;
740
}
741
{
742
uint32_t _flags_save_string = ndr->flags;
743
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
744
if (r->dns_name2) {
745
uint32_t _relative_save_offset;
746
_relative_save_offset = ndr->offset;
747
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dns_name2));
748
_mem_save_dns_name2_0 = NDR_PULL_GET_MEM_CTX(ndr);
749
NDR_PULL_SET_MEM_CTX(ndr, r->dns_name2, 0);
750
NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dns_name2));
751
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name2_0, 0);
752
if (ndr->offset > ndr->relative_highest_offset) {
753
ndr->relative_highest_offset = ndr->offset;
754
}
755
ndr->offset = _relative_save_offset;
756
}
757
ndr->flags = _flags_save_string;
758
}
759
}
760
ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
761
return NDR_ERR_SUCCESS;
762
}
763
764
_PUBLIC_ void ndr_print_repsFromTo2OtherInfo(struct ndr_print *ndr, const char *name, const struct repsFromTo2OtherInfo *r)
765
{
766
ndr_print_struct(ndr, name, "repsFromTo2OtherInfo");
767
if (r == NULL) { ndr_print_null(ndr); return; }
768
ndr->depth++;
769
ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2OtherInfo(r, ndr->flags):r->__ndr_size);
770
ndr_print_ptr(ndr, "dns_name1", r->dns_name1);
771
ndr->depth++;
772
if (r->dns_name1) {
773
ndr_print_string(ndr, "dns_name1", r->dns_name1);
774
}
775
ndr->depth--;
776
ndr_print_uint32(ndr, "unknown1", r->unknown1);
777
ndr_print_ptr(ndr, "dns_name2", r->dns_name2);
778
ndr->depth++;
779
if (r->dns_name2) {
780
ndr_print_string(ndr, "dns_name2", r->dns_name2);
781
}
782
ndr->depth--;
783
ndr_print_hyper(ndr, "unknown2", r->unknown2);
784
ndr->depth--;
785
}
786
787
_PUBLIC_ size_t ndr_size_repsFromTo2OtherInfo(const struct repsFromTo2OtherInfo *r, int flags)
788
{
789
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo2OtherInfo);
790
}
791
792
_PUBLIC_ enum ndr_err_code ndr_push_repsFromTo2(struct ndr_push *ndr, int ndr_flags, const struct repsFromTo2 *r)
793
{
794
{
795
uint32_t _flags_save_STRUCT = ndr->flags;
796
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
797
if (ndr_flags & NDR_SCALARS) {
798
NDR_CHECK(ndr_push_align(ndr, 8));
799
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2(r, ndr->flags) + 8));
800
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
801
NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_success));
802
NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->last_attempt));
803
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
804
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->other_info));
805
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_repsFromTo2OtherInfo(r->other_info, ndr->flags)));
806
NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
807
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
808
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
809
NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
810
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
811
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
812
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_guid));
813
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
814
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
815
}
816
if (ndr_flags & NDR_BUFFERS) {
817
if (r->other_info) {
818
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->other_info));
819
NDR_CHECK(ndr_push_repsFromTo2OtherInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->other_info));
820
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->other_info));
821
}
822
}
823
ndr->flags = _flags_save_STRUCT;
824
}
825
return NDR_ERR_SUCCESS;
826
}
827
828
_PUBLIC_ enum ndr_err_code ndr_pull_repsFromTo2(struct ndr_pull *ndr, int ndr_flags, struct repsFromTo2 *r)
829
{
830
uint32_t _ptr_other_info;
831
TALLOC_CTX *_mem_save_other_info_0;
832
{
833
uint32_t _flags_save_STRUCT = ndr->flags;
834
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
835
if (ndr_flags & NDR_SCALARS) {
836
NDR_CHECK(ndr_pull_align(ndr, 8));
837
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->blobsize));
838
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
839
NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_success));
840
NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->last_attempt));
841
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
842
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
843
if (_ptr_other_info) {
844
NDR_PULL_ALLOC(ndr, r->other_info);
845
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->other_info, _ptr_other_info));
846
} else {
847
r->other_info = NULL;
848
}
849
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->other_info_length));
850
NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
851
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
852
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
853
NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
854
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
855
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
856
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_guid));
857
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
858
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
859
}
860
if (ndr_flags & NDR_BUFFERS) {
861
if (r->other_info) {
862
uint32_t _relative_save_offset;
863
_relative_save_offset = ndr->offset;
864
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->other_info));
865
_mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
866
NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
867
NDR_CHECK(ndr_pull_repsFromTo2OtherInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->other_info));
868
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
869
if (ndr->offset > ndr->relative_highest_offset) {
870
ndr->relative_highest_offset = ndr->offset;
871
}
872
ndr->offset = _relative_save_offset;
873
}
874
}
875
ndr->flags = _flags_save_STRUCT;
876
}
877
return NDR_ERR_SUCCESS;
878
}
879
880
_PUBLIC_ void ndr_print_repsFromTo2(struct ndr_print *ndr, const char *name, const struct repsFromTo2 *r)
881
{
882
ndr_print_struct(ndr, name, "repsFromTo2");
883
if (r == NULL) { ndr_print_null(ndr); return; }
884
{
885
uint32_t _flags_save_STRUCT = ndr->flags;
886
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
887
ndr->depth++;
888
ndr_print_uint32(ndr, "blobsize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2(r, ndr->flags) + 8:r->blobsize);
889
ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
890
ndr_print_NTTIME_1sec(ndr, "last_success", r->last_success);
891
ndr_print_NTTIME_1sec(ndr, "last_attempt", r->last_attempt);
892
ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
893
ndr_print_ptr(ndr, "other_info", r->other_info);
894
ndr->depth++;
895
if (r->other_info) {
896
ndr_print_repsFromTo2OtherInfo(ndr, "other_info", r->other_info);
897
}
898
ndr->depth--;
899
ndr_print_uint32(ndr, "other_info_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_repsFromTo2OtherInfo(r->other_info, ndr->flags):r->other_info_length);
900
ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
901
ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
902
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
903
ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
904
ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
905
ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
906
ndr_print_GUID(ndr, "transport_guid", &r->transport_guid);
907
ndr_print_hyper(ndr, "unknown1", r->unknown1);
908
ndr->depth--;
909
ndr->flags = _flags_save_STRUCT;
910
}
911
}
912
913
_PUBLIC_ size_t ndr_size_repsFromTo2(const struct repsFromTo2 *r, int flags)
914
{
915
flags |= LIBNDR_PRINT_ARRAY_HEX;
916
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_repsFromTo2);
917
}
918
919
static enum ndr_err_code ndr_push_repsFromTo(struct ndr_push *ndr, int ndr_flags, const union repsFromTo *r)
920
{
921
if (ndr_flags & NDR_SCALARS) {
922
uint32_t level = ndr_push_get_switch_value(ndr, r);
923
NDR_CHECK(ndr_push_union_align(ndr, 8));
924
switch (level) {
925
case 1: {
926
NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
927
break; }
928
929
case 2: {
930
NDR_CHECK(ndr_push_repsFromTo2(ndr, NDR_SCALARS, &r->ctr2));
931
break; }
932
933
default:
934
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
935
}
936
}
937
if (ndr_flags & NDR_BUFFERS) {
938
uint32_t level = ndr_push_get_switch_value(ndr, r);
939
switch (level) {
940
case 1:
941
NDR_CHECK(ndr_push_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
942
break;
943
944
case 2:
945
NDR_CHECK(ndr_push_repsFromTo2(ndr, NDR_BUFFERS, &r->ctr2));
946
break;
947
948
default:
949
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
950
}
951
}
952
return NDR_ERR_SUCCESS;
953
}
954
955
static enum ndr_err_code ndr_pull_repsFromTo(struct ndr_pull *ndr, int ndr_flags, union repsFromTo *r)
956
{
957
uint32_t level;
958
level = ndr_pull_get_switch_value(ndr, r);
959
if (ndr_flags & NDR_SCALARS) {
960
NDR_CHECK(ndr_pull_union_align(ndr, 8));
961
switch (level) {
962
case 1: {
963
NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_SCALARS, &r->ctr1));
964
break; }
965
966
case 2: {
967
NDR_CHECK(ndr_pull_repsFromTo2(ndr, NDR_SCALARS, &r->ctr2));
968
break; }
969
970
default:
971
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
972
}
973
}
974
if (ndr_flags & NDR_BUFFERS) {
975
switch (level) {
976
case 1:
977
NDR_CHECK(ndr_pull_repsFromTo1(ndr, NDR_BUFFERS, &r->ctr1));
978
break;
979
980
case 2:
981
NDR_CHECK(ndr_pull_repsFromTo2(ndr, NDR_BUFFERS, &r->ctr2));
982
break;
983
984
default:
985
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
986
}
987
}
988
return NDR_ERR_SUCCESS;
989
}
990
991
_PUBLIC_ void ndr_print_repsFromTo(struct ndr_print *ndr, const char *name, const union repsFromTo *r)
992
{
993
uint32_t level;
994
level = ndr_print_get_switch_value(ndr, r);
995
ndr_print_union(ndr, name, level, "repsFromTo");
996
switch (level) {
997
case 1:
998
ndr_print_repsFromTo1(ndr, "ctr1", &r->ctr1);
999
break;
1000
1001
case 2:
1002
ndr_print_repsFromTo2(ndr, "ctr2", &r->ctr2);
1003
break;
1004
1005
default:
1006
ndr_print_bad_level(ndr, name, level);
1007
}
1008
}
1009
1010
_PUBLIC_ enum ndr_err_code ndr_push_repsFromToBlob(struct ndr_push *ndr, int ndr_flags, const struct repsFromToBlob *r)
1011
{
1012
if (ndr_flags & NDR_SCALARS) {
1013
NDR_CHECK(ndr_push_align(ndr, 8));
1014
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1015
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1016
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1017
NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
1018
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1019
}
1020
if (ndr_flags & NDR_BUFFERS) {
1021
NDR_CHECK(ndr_push_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
1022
}
1023
return NDR_ERR_SUCCESS;
1024
}
1025
1026
_PUBLIC_ enum ndr_err_code ndr_pull_repsFromToBlob(struct ndr_pull *ndr, int ndr_flags, struct repsFromToBlob *r)
1027
{
1028
if (ndr_flags & NDR_SCALARS) {
1029
NDR_CHECK(ndr_pull_align(ndr, 8));
1030
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1031
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1032
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1033
NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_SCALARS, &r->ctr));
1034
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1035
}
1036
if (ndr_flags & NDR_BUFFERS) {
1037
NDR_CHECK(ndr_pull_repsFromTo(ndr, NDR_BUFFERS, &r->ctr));
1038
}
1039
return NDR_ERR_SUCCESS;
1040
}
1041
1042
_PUBLIC_ void ndr_print_repsFromToBlob(struct ndr_print *ndr, const char *name, const struct repsFromToBlob *r)
1043
{
1044
ndr_print_struct(ndr, name, "repsFromToBlob");
1045
if (r == NULL) { ndr_print_null(ndr); return; }
1046
ndr->depth++;
1047
ndr_print_uint32(ndr, "version", r->version);
1048
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1049
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1050
ndr_print_repsFromTo(ndr, "ctr", &r->ctr);
1051
ndr->depth--;
1052
}
1053
1054
static enum ndr_err_code ndr_push_partialAttributeSetCtr1(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetCtr1 *r)
1055
{
1056
uint32_t cntr_array_0;
1057
if (ndr_flags & NDR_SCALARS) {
1058
NDR_CHECK(ndr_push_align(ndr, 4));
1059
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1060
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
1061
NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->array[cntr_array_0]));
1062
}
1063
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1064
}
1065
if (ndr_flags & NDR_BUFFERS) {
1066
}
1067
return NDR_ERR_SUCCESS;
1068
}
1069
1070
static enum ndr_err_code ndr_pull_partialAttributeSetCtr1(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetCtr1 *r)
1071
{
1072
uint32_t cntr_array_0;
1073
TALLOC_CTX *_mem_save_array_0;
1074
if (ndr_flags & NDR_SCALARS) {
1075
NDR_CHECK(ndr_pull_align(ndr, 4));
1076
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1077
NDR_PULL_ALLOC_N(ndr, r->array, r->count);
1078
_mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
1079
NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
1080
for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
1081
NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
1082
}
1083
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
1084
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1085
}
1086
if (ndr_flags & NDR_BUFFERS) {
1087
}
1088
return NDR_ERR_SUCCESS;
1089
}
1090
1091
_PUBLIC_ void ndr_print_partialAttributeSetCtr1(struct ndr_print *ndr, const char *name, const struct partialAttributeSetCtr1 *r)
1092
{
1093
uint32_t cntr_array_0;
1094
ndr_print_struct(ndr, name, "partialAttributeSetCtr1");
1095
if (r == NULL) { ndr_print_null(ndr); return; }
1096
ndr->depth++;
1097
ndr_print_uint32(ndr, "count", r->count);
1098
ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
1099
ndr->depth++;
1100
for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
1101
ndr_print_drsuapi_DsAttributeId(ndr, "array", r->array[cntr_array_0]);
1102
}
1103
ndr->depth--;
1104
ndr->depth--;
1105
}
1106
1107
static enum ndr_err_code ndr_push_partialAttributeSetCtr(struct ndr_push *ndr, int ndr_flags, const union partialAttributeSetCtr *r)
1108
{
1109
if (ndr_flags & NDR_SCALARS) {
1110
uint32_t level = ndr_push_get_switch_value(ndr, r);
1111
NDR_CHECK(ndr_push_union_align(ndr, 4));
1112
switch (level) {
1113
case 1: {
1114
NDR_CHECK(ndr_push_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
1115
break; }
1116
1117
default:
1118
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1119
}
1120
}
1121
if (ndr_flags & NDR_BUFFERS) {
1122
uint32_t level = ndr_push_get_switch_value(ndr, r);
1123
switch (level) {
1124
case 1:
1125
break;
1126
1127
default:
1128
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1129
}
1130
}
1131
return NDR_ERR_SUCCESS;
1132
}
1133
1134
static enum ndr_err_code ndr_pull_partialAttributeSetCtr(struct ndr_pull *ndr, int ndr_flags, union partialAttributeSetCtr *r)
1135
{
1136
uint32_t level;
1137
level = ndr_pull_get_switch_value(ndr, r);
1138
if (ndr_flags & NDR_SCALARS) {
1139
NDR_CHECK(ndr_pull_union_align(ndr, 4));
1140
switch (level) {
1141
case 1: {
1142
NDR_CHECK(ndr_pull_partialAttributeSetCtr1(ndr, NDR_SCALARS, &r->ctr1));
1143
break; }
1144
1145
default:
1146
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1147
}
1148
}
1149
if (ndr_flags & NDR_BUFFERS) {
1150
switch (level) {
1151
case 1:
1152
break;
1153
1154
default:
1155
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1156
}
1157
}
1158
return NDR_ERR_SUCCESS;
1159
}
1160
1161
_PUBLIC_ void ndr_print_partialAttributeSetCtr(struct ndr_print *ndr, const char *name, const union partialAttributeSetCtr *r)
1162
{
1163
uint32_t level;
1164
level = ndr_print_get_switch_value(ndr, r);
1165
ndr_print_union(ndr, name, level, "partialAttributeSetCtr");
1166
switch (level) {
1167
case 1:
1168
ndr_print_partialAttributeSetCtr1(ndr, "ctr1", &r->ctr1);
1169
break;
1170
1171
default:
1172
ndr_print_bad_level(ndr, name, level);
1173
}
1174
}
1175
1176
_PUBLIC_ enum ndr_err_code ndr_push_partialAttributeSetBlob(struct ndr_push *ndr, int ndr_flags, const struct partialAttributeSetBlob *r)
1177
{
1178
if (ndr_flags & NDR_SCALARS) {
1179
NDR_CHECK(ndr_push_align(ndr, 4));
1180
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
1181
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1182
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1183
NDR_CHECK(ndr_push_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
1184
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1185
}
1186
if (ndr_flags & NDR_BUFFERS) {
1187
}
1188
return NDR_ERR_SUCCESS;
1189
}
1190
1191
_PUBLIC_ enum ndr_err_code ndr_pull_partialAttributeSetBlob(struct ndr_pull *ndr, int ndr_flags, struct partialAttributeSetBlob *r)
1192
{
1193
if (ndr_flags & NDR_SCALARS) {
1194
NDR_CHECK(ndr_pull_align(ndr, 4));
1195
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1196
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1197
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1198
NDR_CHECK(ndr_pull_partialAttributeSetCtr(ndr, NDR_SCALARS, &r->ctr));
1199
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1200
}
1201
if (ndr_flags & NDR_BUFFERS) {
1202
}
1203
return NDR_ERR_SUCCESS;
1204
}
1205
1206
_PUBLIC_ void ndr_print_partialAttributeSetBlob(struct ndr_print *ndr, const char *name, const struct partialAttributeSetBlob *r)
1207
{
1208
ndr_print_struct(ndr, name, "partialAttributeSetBlob");
1209
if (r == NULL) { ndr_print_null(ndr); return; }
1210
ndr->depth++;
1211
ndr_print_uint32(ndr, "version", r->version);
1212
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1213
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1214
ndr_print_partialAttributeSetCtr(ndr, "ctr", &r->ctr);
1215
ndr->depth--;
1216
}
1217
1218
_PUBLIC_ enum ndr_err_code ndr_push_schemaInfoBlob(struct ndr_push *ndr, int ndr_flags, const struct schemaInfoBlob *r)
1219
{
1220
{
1221
uint32_t _flags_save_STRUCT = ndr->flags;
1222
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1223
if (ndr_flags & NDR_SCALARS) {
1224
NDR_CHECK(ndr_push_align(ndr, 4));
1225
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0xFF));
1226
{
1227
uint32_t _flags_save_uint32 = ndr->flags;
1228
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1229
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->revision));
1230
ndr->flags = _flags_save_uint32;
1231
}
1232
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->invocation_id));
1233
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1234
}
1235
if (ndr_flags & NDR_BUFFERS) {
1236
}
1237
ndr->flags = _flags_save_STRUCT;
1238
}
1239
return NDR_ERR_SUCCESS;
1240
}
1241
1242
_PUBLIC_ enum ndr_err_code ndr_pull_schemaInfoBlob(struct ndr_pull *ndr, int ndr_flags, struct schemaInfoBlob *r)
1243
{
1244
{
1245
uint32_t _flags_save_STRUCT = ndr->flags;
1246
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1247
if (ndr_flags & NDR_SCALARS) {
1248
NDR_CHECK(ndr_pull_align(ndr, 4));
1249
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->marker));
1250
{
1251
uint32_t _flags_save_uint32 = ndr->flags;
1252
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
1253
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->revision));
1254
ndr->flags = _flags_save_uint32;
1255
}
1256
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->invocation_id));
1257
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1258
}
1259
if (ndr_flags & NDR_BUFFERS) {
1260
}
1261
ndr->flags = _flags_save_STRUCT;
1262
}
1263
return NDR_ERR_SUCCESS;
1264
}
1265
1266
_PUBLIC_ void ndr_print_schemaInfoBlob(struct ndr_print *ndr, const char *name, const struct schemaInfoBlob *r)
1267
{
1268
ndr_print_struct(ndr, name, "schemaInfoBlob");
1269
if (r == NULL) { ndr_print_null(ndr); return; }
1270
{
1271
uint32_t _flags_save_STRUCT = ndr->flags;
1272
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1273
ndr->depth++;
1274
ndr_print_uint8(ndr, "marker", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0xFF:r->marker);
1275
ndr_print_uint32(ndr, "revision", r->revision);
1276
ndr_print_GUID(ndr, "invocation_id", &r->invocation_id);
1277
ndr->depth--;
1278
ndr->flags = _flags_save_STRUCT;
1279
}
1280
}
1281
1282
static enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Entry(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Entry *r)
1283
{
1284
{
1285
uint32_t _flags_save_STRUCT = ndr->flags;
1286
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1287
if (ndr_flags & NDR_SCALARS) {
1288
NDR_CHECK(ndr_push_align(ndr, 2));
1289
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->entryID));
1290
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
1291
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1292
NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1293
}
1294
if (ndr_flags & NDR_BUFFERS) {
1295
}
1296
ndr->flags = _flags_save_STRUCT;
1297
}
1298
return NDR_ERR_SUCCESS;
1299
}
1300
1301
static enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Entry(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Entry *r)
1302
{
1303
{
1304
uint32_t _flags_save_STRUCT = ndr->flags;
1305
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
1306
if (ndr_flags & NDR_SCALARS) {
1307
NDR_CHECK(ndr_pull_align(ndr, 2));
1308
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->entryID));
1309
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
1310
NDR_PULL_ALLOC_N(ndr, r->binary_oid, r->length);
1311
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1312
NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1313
}
1314
if (ndr_flags & NDR_BUFFERS) {
1315
}
1316
ndr->flags = _flags_save_STRUCT;
1317
}
1318
return NDR_ERR_SUCCESS;
1319
}
1320
1321
_PUBLIC_ enum ndr_err_code ndr_push_drsuapi_MSPrefixMap_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_MSPrefixMap_Ctr *r)
1322
{
1323
uint32_t cntr_entries_0;
1324
if (ndr_flags & NDR_SCALARS) {
1325
NDR_CHECK(ndr_push_align(ndr, 4));
1326
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_entries));
1327
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->flags)));
1328
for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1329
NDR_CHECK(ndr_push_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1330
}
1331
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1332
}
1333
if (ndr_flags & NDR_BUFFERS) {
1334
}
1335
return NDR_ERR_SUCCESS;
1336
}
1337
1338
_PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_MSPrefixMap_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_MSPrefixMap_Ctr *r)
1339
{
1340
uint32_t cntr_entries_0;
1341
TALLOC_CTX *_mem_save_entries_0;
1342
if (ndr_flags & NDR_SCALARS) {
1343
NDR_CHECK(ndr_pull_align(ndr, 4));
1344
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_entries));
1345
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1346
NDR_PULL_ALLOC_N(ndr, r->entries, r->num_entries);
1347
_mem_save_entries_0 = NDR_PULL_GET_MEM_CTX(ndr);
1348
NDR_PULL_SET_MEM_CTX(ndr, r->entries, 0);
1349
for (cntr_entries_0 = 0; cntr_entries_0 < r->num_entries; cntr_entries_0++) {
1350
NDR_CHECK(ndr_pull_drsuapi_MSPrefixMap_Entry(ndr, NDR_SCALARS, &r->entries[cntr_entries_0]));
1351
}
1352
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_entries_0, 0);
1353
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1354
}
1355
if (ndr_flags & NDR_BUFFERS) {
1356
}
1357
return NDR_ERR_SUCCESS;
1358
}
1359
1360
_PUBLIC_ void ndr_print_drsuapi_MSPrefixMap_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_MSPrefixMap_Ctr *r)
1361
{
1362
uint32_t cntr_entries_0;
1363
ndr_print_struct(ndr, name, "drsuapi_MSPrefixMap_Ctr");
1364
if (r == NULL) { ndr_print_null(ndr); return; }
1365
ndr->depth++;
1366
ndr_print_uint32(ndr, "num_entries", r->num_entries);
1367
ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_MSPrefixMap_Ctr(r, ndr->flags):r->__ndr_size);
1368
ndr->print(ndr, "%s: ARRAY(%d)", "entries", (int)r->num_entries);
1369
ndr->depth++;
1370
for (cntr_entries_0=0;cntr_entries_0<r->num_entries;cntr_entries_0++) {
1371
ndr_print_drsuapi_MSPrefixMap_Entry(ndr, "entries", &r->entries[cntr_entries_0]);
1372
}
1373
ndr->depth--;
1374
ndr->depth--;
1375
}
1376
1377
_PUBLIC_ size_t ndr_size_drsuapi_MSPrefixMap_Ctr(const struct drsuapi_MSPrefixMap_Ctr *r, int flags)
1378
{
1379
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_MSPrefixMap_Ctr);
1380
}
1381
1382
static enum ndr_err_code ndr_push_prefixMapVersion(struct ndr_push *ndr, int ndr_flags, enum prefixMapVersion r)
1383
{
1384
NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1385
return NDR_ERR_SUCCESS;
1386
}
1387
1388
static enum ndr_err_code ndr_pull_prefixMapVersion(struct ndr_pull *ndr, int ndr_flags, enum prefixMapVersion *r)
1389
{
1390
uint32_t v;
1391
NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1392
*r = v;
1393
return NDR_ERR_SUCCESS;
1394
}
1395
1396
_PUBLIC_ void ndr_print_prefixMapVersion(struct ndr_print *ndr, const char *name, enum prefixMapVersion r)
1397
{
1398
const char *val = NULL;
1399
1400
switch (r) {
1401
case PREFIX_MAP_VERSION_DSDB: val = "PREFIX_MAP_VERSION_DSDB"; break;
1402
}
1403
ndr_print_enum(ndr, name, "ENUM", val, r);
1404
}
1405
1406
static enum ndr_err_code ndr_push_prefixMapCtr(struct ndr_push *ndr, int ndr_flags, const union prefixMapCtr *r)
1407
{
1408
if (ndr_flags & NDR_SCALARS) {
1409
uint32_t level = ndr_push_get_switch_value(ndr, r);
1410
NDR_CHECK(ndr_push_union_align(ndr, 5));
1411
switch (level) {
1412
case PREFIX_MAP_VERSION_DSDB: {
1413
NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1414
break; }
1415
1416
default:
1417
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1418
}
1419
}
1420
if (ndr_flags & NDR_BUFFERS) {
1421
uint32_t level = ndr_push_get_switch_value(ndr, r);
1422
switch (level) {
1423
case PREFIX_MAP_VERSION_DSDB:
1424
NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1425
break;
1426
1427
default:
1428
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1429
}
1430
}
1431
return NDR_ERR_SUCCESS;
1432
}
1433
1434
static enum ndr_err_code ndr_pull_prefixMapCtr(struct ndr_pull *ndr, int ndr_flags, union prefixMapCtr *r)
1435
{
1436
uint32_t level;
1437
level = ndr_pull_get_switch_value(ndr, r);
1438
if (ndr_flags & NDR_SCALARS) {
1439
NDR_CHECK(ndr_pull_union_align(ndr, 5));
1440
switch (level) {
1441
case PREFIX_MAP_VERSION_DSDB: {
1442
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->dsdb));
1443
break; }
1444
1445
default:
1446
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1447
}
1448
}
1449
if (ndr_flags & NDR_BUFFERS) {
1450
switch (level) {
1451
case PREFIX_MAP_VERSION_DSDB:
1452
NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->dsdb));
1453
break;
1454
1455
default:
1456
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1457
}
1458
}
1459
return NDR_ERR_SUCCESS;
1460
}
1461
1462
_PUBLIC_ void ndr_print_prefixMapCtr(struct ndr_print *ndr, const char *name, const union prefixMapCtr *r)
1463
{
1464
uint32_t level;
1465
level = ndr_print_get_switch_value(ndr, r);
1466
ndr_print_union(ndr, name, level, "prefixMapCtr");
1467
switch (level) {
1468
case PREFIX_MAP_VERSION_DSDB:
1469
ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "dsdb", &r->dsdb);
1470
break;
1471
1472
default:
1473
ndr_print_bad_level(ndr, name, level);
1474
}
1475
}
1476
1477
_PUBLIC_ enum ndr_err_code ndr_push_prefixMapBlob(struct ndr_push *ndr, int ndr_flags, const struct prefixMapBlob *r)
1478
{
1479
if (ndr_flags & NDR_SCALARS) {
1480
NDR_CHECK(ndr_push_align(ndr, 5));
1481
NDR_CHECK(ndr_push_prefixMapVersion(ndr, NDR_SCALARS, r->version));
1482
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1483
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
1484
NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1485
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1486
}
1487
if (ndr_flags & NDR_BUFFERS) {
1488
NDR_CHECK(ndr_push_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1489
}
1490
return NDR_ERR_SUCCESS;
1491
}
1492
1493
_PUBLIC_ enum ndr_err_code ndr_pull_prefixMapBlob(struct ndr_pull *ndr, int ndr_flags, struct prefixMapBlob *r)
1494
{
1495
if (ndr_flags & NDR_SCALARS) {
1496
NDR_CHECK(ndr_pull_align(ndr, 5));
1497
NDR_CHECK(ndr_pull_prefixMapVersion(ndr, NDR_SCALARS, &r->version));
1498
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
1499
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
1500
NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_SCALARS, &r->ctr));
1501
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1502
}
1503
if (ndr_flags & NDR_BUFFERS) {
1504
NDR_CHECK(ndr_pull_prefixMapCtr(ndr, NDR_BUFFERS, &r->ctr));
1505
}
1506
return NDR_ERR_SUCCESS;
1507
}
1508
1509
_PUBLIC_ void ndr_print_prefixMapBlob(struct ndr_print *ndr, const char *name, const struct prefixMapBlob *r)
1510
{
1511
ndr_print_struct(ndr, name, "prefixMapBlob");
1512
if (r == NULL) { ndr_print_null(ndr); return; }
1513
ndr->depth++;
1514
ndr_print_prefixMapVersion(ndr, "version", r->version);
1515
ndr_print_uint32(ndr, "reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved);
1516
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
1517
ndr_print_prefixMapCtr(ndr, "ctr", &r->ctr);
1518
ndr->depth--;
1519
}
1520
1521
static enum ndr_err_code ndr_push_ldapControlDirSyncExtra(struct ndr_push *ndr, int ndr_flags, const union ldapControlDirSyncExtra *r)
1522
{
1523
if (ndr_flags & NDR_SCALARS) {
1524
uint32_t level = ndr_push_get_switch_value(ndr, r);
1525
NDR_CHECK(ndr_push_union_align(ndr, 8));
1526
switch (level) {
1527
case 0: {
1528
break; }
1529
1530
default: {
1531
NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1532
break; }
1533
1534
}
1535
}
1536
if (ndr_flags & NDR_BUFFERS) {
1537
uint32_t level = ndr_push_get_switch_value(ndr, r);
1538
switch (level) {
1539
case 0:
1540
break;
1541
1542
default:
1543
break;
1544
1545
}
1546
}
1547
return NDR_ERR_SUCCESS;
1548
}
1549
1550
static enum ndr_err_code ndr_pull_ldapControlDirSyncExtra(struct ndr_pull *ndr, int ndr_flags, union ldapControlDirSyncExtra *r)
1551
{
1552
uint32_t level;
1553
level = ndr_pull_get_switch_value(ndr, r);
1554
if (ndr_flags & NDR_SCALARS) {
1555
NDR_CHECK(ndr_pull_union_align(ndr, 8));
1556
switch (level) {
1557
case 0: {
1558
break; }
1559
1560
default: {
1561
NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->uptodateness_vector));
1562
break; }
1563
1564
}
1565
}
1566
if (ndr_flags & NDR_BUFFERS) {
1567
switch (level) {
1568
case 0:
1569
break;
1570
1571
default:
1572
break;
1573
1574
}
1575
}
1576
return NDR_ERR_SUCCESS;
1577
}
1578
1579
_PUBLIC_ void ndr_print_ldapControlDirSyncExtra(struct ndr_print *ndr, const char *name, const union ldapControlDirSyncExtra *r)
1580
{
1581
uint32_t level;
1582
level = ndr_print_get_switch_value(ndr, r);
1583
ndr_print_union(ndr, name, level, "ldapControlDirSyncExtra");
1584
switch (level) {
1585
case 0:
1586
break;
1587
1588
default:
1589
ndr_print_replUpToDateVectorBlob(ndr, "uptodateness_vector", &r->uptodateness_vector);
1590
break;
1591
1592
}
1593
}
1594
1595
static size_t ndr_size_ldapControlDirSyncExtra(const union ldapControlDirSyncExtra *r, uint32_t level, int flags)
1596
{
1597
return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_ldapControlDirSyncExtra);
1598
}
1599
1600
static enum ndr_err_code ndr_push_ldapControlDirSyncBlob(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncBlob *r)
1601
{
1602
if (ndr_flags & NDR_SCALARS) {
1603
NDR_CHECK(ndr_push_align(ndr, 8));
1604
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 3));
1605
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
1606
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
1607
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
1608
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0)));
1609
NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1610
NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
1611
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->extra, ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0)));
1612
NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1613
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1614
}
1615
if (ndr_flags & NDR_BUFFERS) {
1616
NDR_CHECK(ndr_push_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1617
}
1618
return NDR_ERR_SUCCESS;
1619
}
1620
1621
static enum ndr_err_code ndr_pull_ldapControlDirSyncBlob(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncBlob *r)
1622
{
1623
if (ndr_flags & NDR_SCALARS) {
1624
NDR_CHECK(ndr_pull_align(ndr, 8));
1625
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
1626
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
1627
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
1628
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
1629
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->extra_length));
1630
NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1631
NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
1632
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->extra, r->extra_length));
1633
NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_SCALARS, &r->extra));
1634
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1635
}
1636
if (ndr_flags & NDR_BUFFERS) {
1637
NDR_CHECK(ndr_pull_ldapControlDirSyncExtra(ndr, NDR_BUFFERS, &r->extra));
1638
}
1639
return NDR_ERR_SUCCESS;
1640
}
1641
1642
_PUBLIC_ void ndr_print_ldapControlDirSyncBlob(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncBlob *r)
1643
{
1644
ndr_print_struct(ndr, name, "ldapControlDirSyncBlob");
1645
if (r == NULL) { ndr_print_null(ndr); return; }
1646
ndr->depth++;
1647
ndr_print_uint32(ndr, "u1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?3:r->u1);
1648
ndr_print_NTTIME(ndr, "time", r->time);
1649
ndr_print_uint32(ndr, "u2", r->u2);
1650
ndr_print_uint32(ndr, "u3", r->u3);
1651
ndr_print_uint32(ndr, "extra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ldapControlDirSyncExtra(&r->extra, r->extra.uptodateness_vector.version, 0):r->extra_length);
1652
ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1653
ndr_print_GUID(ndr, "guid1", &r->guid1);
1654
ndr_print_set_switch_value(ndr, &r->extra, r->extra_length);
1655
ndr_print_ldapControlDirSyncExtra(ndr, "extra", &r->extra);
1656
ndr->depth--;
1657
}
1658
1659
_PUBLIC_ enum ndr_err_code ndr_push_ldapControlDirSyncCookie(struct ndr_push *ndr, int ndr_flags, const struct ldapControlDirSyncCookie *r)
1660
{
1661
uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1662
if (ndr_flags & NDR_SCALARS) {
1663
NDR_CHECK(ndr_push_align(ndr, 8));
1664
NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1665
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "MSDS", 4, sizeof(uint8_t), CH_DOS));
1666
{
1667
struct ndr_push *_ndr_blob;
1668
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_blob, 0, -1));
1669
NDR_CHECK(ndr_push_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1670
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_blob, 0, -1));
1671
}
1672
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1673
}
1674
if (ndr_flags & NDR_BUFFERS) {
1675
NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
1676
}
1677
ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
1678
return NDR_ERR_SUCCESS;
1679
}
1680
1681
_PUBLIC_ enum ndr_err_code ndr_pull_ldapControlDirSyncCookie(struct ndr_pull *ndr, int ndr_flags, struct ldapControlDirSyncCookie *r)
1682
{
1683
uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
1684
if (ndr_flags & NDR_SCALARS) {
1685
NDR_CHECK(ndr_pull_align(ndr, 8));
1686
NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
1687
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->msds, 4, sizeof(uint8_t), CH_DOS));
1688
{
1689
struct ndr_pull *_ndr_blob;
1690
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_blob, 0, -1));
1691
NDR_CHECK(ndr_pull_ldapControlDirSyncBlob(_ndr_blob, NDR_SCALARS|NDR_BUFFERS, &r->blob));
1692
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_blob, 0, -1));
1693
}
1694
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1695
}
1696
if (ndr_flags & NDR_BUFFERS) {
1697
NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
1698
}
1699
ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
1700
return NDR_ERR_SUCCESS;
1701
}
1702
1703
_PUBLIC_ void ndr_print_ldapControlDirSyncCookie(struct ndr_print *ndr, const char *name, const struct ldapControlDirSyncCookie *r)
1704
{
1705
ndr_print_struct(ndr, name, "ldapControlDirSyncCookie");
1706
if (r == NULL) { ndr_print_null(ndr); return; }
1707
ndr->depth++;
1708
ndr_print_string(ndr, "msds", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"MSDS":r->msds);
1709
ndr_print_ldapControlDirSyncBlob(ndr, "blob", &r->blob);
1710
ndr->depth--;
1711
}
1712
1713
static enum ndr_err_code ndr_push_supplementalCredentialsPackage(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsPackage *r)
1714
{
1715
if (ndr_flags & NDR_SCALARS) {
1716
NDR_CHECK(ndr_push_align(ndr, 2));
1717
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->name)));
1718
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen(r->data)));
1719
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->reserved));
1720
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, 2 * strlen_m(r->name), sizeof(uint8_t), CH_UTF16));
1721
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data, strlen(r->data), sizeof(uint8_t), CH_DOS));
1722
NDR_CHECK(ndr_push_trailer_align(ndr, 2));
1723
}
1724
if (ndr_flags & NDR_BUFFERS) {
1725
}
1726
return NDR_ERR_SUCCESS;
1727
}
1728
1729
static enum ndr_err_code ndr_pull_supplementalCredentialsPackage(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsPackage *r)
1730
{
1731
if (ndr_flags & NDR_SCALARS) {
1732
NDR_CHECK(ndr_pull_align(ndr, 2));
1733
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->name_len));
1734
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data_len));
1735
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved));
1736
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, r->name_len, sizeof(uint8_t), CH_UTF16));
1737
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data, r->data_len, sizeof(uint8_t), CH_DOS));
1738
NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
1739
}
1740
if (ndr_flags & NDR_BUFFERS) {
1741
}
1742
return NDR_ERR_SUCCESS;
1743
}
1744
1745
_PUBLIC_ void ndr_print_supplementalCredentialsPackage(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsPackage *r)
1746
{
1747
ndr_print_struct(ndr, name, "supplementalCredentialsPackage");
1748
if (r == NULL) { ndr_print_null(ndr); return; }
1749
ndr->depth++;
1750
ndr_print_uint16(ndr, "name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->name):r->name_len);
1751
ndr_print_uint16(ndr, "data_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen(r->data):r->data_len);
1752
ndr_print_uint16(ndr, "reserved", r->reserved);
1753
ndr_print_string(ndr, "name", r->name);
1754
ndr_print_string(ndr, "data", r->data);
1755
ndr->depth--;
1756
}
1757
1758
static enum ndr_err_code ndr_push_supplementalCredentialsSignature(struct ndr_push *ndr, int ndr_flags, enum supplementalCredentialsSignature r)
1759
{
1760
{
1761
uint32_t _flags_save_ENUM = ndr->flags;
1762
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1763
NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
1764
ndr->flags = _flags_save_ENUM;
1765
}
1766
return NDR_ERR_SUCCESS;
1767
}
1768
1769
static enum ndr_err_code ndr_pull_supplementalCredentialsSignature(struct ndr_pull *ndr, int ndr_flags, enum supplementalCredentialsSignature *r)
1770
{
1771
uint16_t v;
1772
{
1773
uint32_t _flags_save_ENUM = ndr->flags;
1774
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1775
NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
1776
*r = v;
1777
ndr->flags = _flags_save_ENUM;
1778
}
1779
return NDR_ERR_SUCCESS;
1780
}
1781
1782
_PUBLIC_ void ndr_print_supplementalCredentialsSignature(struct ndr_print *ndr, const char *name, enum supplementalCredentialsSignature r)
1783
{
1784
const char *val = NULL;
1785
1786
{
1787
uint32_t _flags_save_ENUM = ndr->flags;
1788
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1789
switch (r) {
1790
case SUPPLEMENTAL_CREDENTIALS_SIGNATURE: val = "SUPPLEMENTAL_CREDENTIALS_SIGNATURE"; break;
1791
}
1792
ndr_print_enum(ndr, name, "ENUM", val, r);
1793
ndr->flags = _flags_save_ENUM;
1794
}
1795
}
1796
1797
static enum ndr_err_code ndr_push_supplementalCredentialsSubBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsSubBlob *r)
1798
{
1799
uint32_t cntr_packages_0;
1800
if (ndr_flags & NDR_SCALARS) {
1801
NDR_CHECK(ndr_push_align(ndr, 3));
1802
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_PREFIX, 0x30, sizeof(uint16_t), CH_UTF16));
1803
NDR_CHECK(ndr_push_supplementalCredentialsSignature(ndr, NDR_SCALARS, SUPPLEMENTAL_CREDENTIALS_SIGNATURE));
1804
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_packages));
1805
for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1806
NDR_CHECK(ndr_push_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1807
}
1808
NDR_CHECK(ndr_push_trailer_align(ndr, 3));
1809
}
1810
if (ndr_flags & NDR_BUFFERS) {
1811
}
1812
return NDR_ERR_SUCCESS;
1813
}
1814
1815
static enum ndr_err_code ndr_pull_supplementalCredentialsSubBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsSubBlob *r)
1816
{
1817
uint32_t cntr_packages_0;
1818
TALLOC_CTX *_mem_save_packages_0;
1819
if (ndr_flags & NDR_SCALARS) {
1820
NDR_CHECK(ndr_pull_align(ndr, 3));
1821
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->prefix, 0x30, sizeof(uint16_t), CH_UTF16));
1822
NDR_CHECK(ndr_pull_supplementalCredentialsSignature(ndr, NDR_SCALARS, &r->signature));
1823
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_packages));
1824
NDR_PULL_ALLOC_N(ndr, r->packages, r->num_packages);
1825
_mem_save_packages_0 = NDR_PULL_GET_MEM_CTX(ndr);
1826
NDR_PULL_SET_MEM_CTX(ndr, r->packages, 0);
1827
for (cntr_packages_0 = 0; cntr_packages_0 < r->num_packages; cntr_packages_0++) {
1828
NDR_CHECK(ndr_pull_supplementalCredentialsPackage(ndr, NDR_SCALARS, &r->packages[cntr_packages_0]));
1829
}
1830
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_packages_0, 0);
1831
NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
1832
}
1833
if (ndr_flags & NDR_BUFFERS) {
1834
}
1835
return NDR_ERR_SUCCESS;
1836
}
1837
1838
_PUBLIC_ void ndr_print_supplementalCredentialsSubBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsSubBlob *r)
1839
{
1840
uint32_t cntr_packages_0;
1841
ndr_print_struct(ndr, name, "supplementalCredentialsSubBlob");
1842
if (r == NULL) { ndr_print_null(ndr); return; }
1843
ndr->depth++;
1844
ndr_print_string(ndr, "prefix", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_PREFIX:r->prefix);
1845
ndr_print_supplementalCredentialsSignature(ndr, "signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SUPPLEMENTAL_CREDENTIALS_SIGNATURE:r->signature);
1846
ndr_print_uint16(ndr, "num_packages", r->num_packages);
1847
ndr->print(ndr, "%s: ARRAY(%d)", "packages", (int)r->num_packages);
1848
ndr->depth++;
1849
for (cntr_packages_0=0;cntr_packages_0<r->num_packages;cntr_packages_0++) {
1850
ndr_print_supplementalCredentialsPackage(ndr, "packages", &r->packages[cntr_packages_0]);
1851
}
1852
ndr->depth--;
1853
ndr->depth--;
1854
}
1855
1856
static size_t ndr_size_supplementalCredentialsSubBlob(const struct supplementalCredentialsSubBlob *r, int flags)
1857
{
1858
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_supplementalCredentialsSubBlob);
1859
}
1860
1861
_PUBLIC_ enum ndr_err_code ndr_push_supplementalCredentialsBlob(struct ndr_push *ndr, int ndr_flags, const struct supplementalCredentialsBlob *r)
1862
{
1863
if (ndr_flags & NDR_SCALARS) {
1864
NDR_CHECK(ndr_push_align(ndr, 4));
1865
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1866
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1867
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1868
{
1869
struct ndr_push *_ndr_sub;
1870
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1871
NDR_CHECK(ndr_push_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1872
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sub, 0, ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags)));
1873
}
1874
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0));
1875
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1876
}
1877
if (ndr_flags & NDR_BUFFERS) {
1878
}
1879
return NDR_ERR_SUCCESS;
1880
}
1881
1882
_PUBLIC_ enum ndr_err_code ndr_pull_supplementalCredentialsBlob(struct ndr_pull *ndr, int ndr_flags, struct supplementalCredentialsBlob *r)
1883
{
1884
if (ndr_flags & NDR_SCALARS) {
1885
NDR_CHECK(ndr_pull_align(ndr, 4));
1886
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
1887
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
1888
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
1889
{
1890
struct ndr_pull *_ndr_sub;
1891
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sub, 0, r->__ndr_size));
1892
NDR_CHECK(ndr_pull_supplementalCredentialsSubBlob(_ndr_sub, NDR_SCALARS, &r->sub));
1893
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sub, 0, r->__ndr_size));
1894
}
1895
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown3));
1896
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1897
}
1898
if (ndr_flags & NDR_BUFFERS) {
1899
}
1900
return NDR_ERR_SUCCESS;
1901
}
1902
1903
_PUBLIC_ void ndr_print_supplementalCredentialsBlob(struct ndr_print *ndr, const char *name, const struct supplementalCredentialsBlob *r)
1904
{
1905
ndr_print_struct(ndr, name, "supplementalCredentialsBlob");
1906
if (r == NULL) { ndr_print_null(ndr); return; }
1907
ndr->depth++;
1908
ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown1);
1909
ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_supplementalCredentialsSubBlob(&r->sub, ndr->flags):r->__ndr_size);
1910
ndr_print_uint32(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown2);
1911
ndr_print_supplementalCredentialsSubBlob(ndr, "sub", &r->sub);
1912
ndr_print_uint8(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
1913
ndr->depth--;
1914
}
1915
1916
_PUBLIC_ enum ndr_err_code ndr_push_package_PackagesBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PackagesBlob *r)
1917
{
1918
if (ndr_flags & NDR_SCALARS) {
1919
NDR_CHECK(ndr_push_align(ndr, 4));
1920
{
1921
uint32_t _flags_save_string_array = ndr->flags;
1922
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1923
NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->names));
1924
ndr->flags = _flags_save_string_array;
1925
}
1926
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1927
}
1928
if (ndr_flags & NDR_BUFFERS) {
1929
}
1930
return NDR_ERR_SUCCESS;
1931
}
1932
1933
_PUBLIC_ enum ndr_err_code ndr_pull_package_PackagesBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PackagesBlob *r)
1934
{
1935
if (ndr_flags & NDR_SCALARS) {
1936
NDR_CHECK(ndr_pull_align(ndr, 4));
1937
{
1938
uint32_t _flags_save_string_array = ndr->flags;
1939
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1940
NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->names));
1941
ndr->flags = _flags_save_string_array;
1942
}
1943
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1944
}
1945
if (ndr_flags & NDR_BUFFERS) {
1946
}
1947
return NDR_ERR_SUCCESS;
1948
}
1949
1950
_PUBLIC_ void ndr_print_package_PackagesBlob(struct ndr_print *ndr, const char *name, const struct package_PackagesBlob *r)
1951
{
1952
ndr_print_struct(ndr, name, "package_PackagesBlob");
1953
if (r == NULL) { ndr_print_null(ndr); return; }
1954
ndr->depth++;
1955
ndr_print_string_array(ndr, "names", r->names);
1956
ndr->depth--;
1957
}
1958
1959
static enum ndr_err_code ndr_push_package_PrimaryKerberosString(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosString *r)
1960
{
1961
if (ndr_flags & NDR_SCALARS) {
1962
NDR_CHECK(ndr_push_align(ndr, 5));
1963
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1964
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 2 * strlen_m(r->string)));
1965
{
1966
uint32_t _flags_save_string = ndr->flags;
1967
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1968
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->string));
1969
ndr->flags = _flags_save_string;
1970
}
1971
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1972
}
1973
if (ndr_flags & NDR_BUFFERS) {
1974
{
1975
uint32_t _flags_save_string = ndr->flags;
1976
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
1977
if (r->string) {
1978
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->string));
1979
{
1980
struct ndr_push *_ndr_string;
1981
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_string, 0, 2 * strlen_m(r->string)));
1982
NDR_CHECK(ndr_push_string(_ndr_string, NDR_SCALARS, r->string));
1983
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_string, 0, 2 * strlen_m(r->string)));
1984
}
1985
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->string));
1986
}
1987
ndr->flags = _flags_save_string;
1988
}
1989
}
1990
return NDR_ERR_SUCCESS;
1991
}
1992
1993
static enum ndr_err_code ndr_pull_package_PrimaryKerberosString(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosString *r)
1994
{
1995
uint32_t _ptr_string;
1996
TALLOC_CTX *_mem_save_string_0;
1997
if (ndr_flags & NDR_SCALARS) {
1998
NDR_CHECK(ndr_pull_align(ndr, 5));
1999
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
2000
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
2001
{
2002
uint32_t _flags_save_string = ndr->flags;
2003
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2004
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
2005
if (_ptr_string) {
2006
NDR_PULL_ALLOC(ndr, r->string);
2007
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->string, _ptr_string));
2008
} else {
2009
r->string = NULL;
2010
}
2011
ndr->flags = _flags_save_string;
2012
}
2013
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2014
}
2015
if (ndr_flags & NDR_BUFFERS) {
2016
{
2017
uint32_t _flags_save_string = ndr->flags;
2018
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
2019
if (r->string) {
2020
uint32_t _relative_save_offset;
2021
_relative_save_offset = ndr->offset;
2022
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->string));
2023
_mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
2024
NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
2025
{
2026
struct ndr_pull *_ndr_string;
2027
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_string, 0, r->size));
2028
NDR_CHECK(ndr_pull_string(_ndr_string, NDR_SCALARS, &r->string));
2029
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_string, 0, r->size));
2030
}
2031
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
2032
if (ndr->offset > ndr->relative_highest_offset) {
2033
ndr->relative_highest_offset = ndr->offset;
2034
}
2035
ndr->offset = _relative_save_offset;
2036
}
2037
ndr->flags = _flags_save_string;
2038
}
2039
}
2040
return NDR_ERR_SUCCESS;
2041
}
2042
2043
_PUBLIC_ void ndr_print_package_PrimaryKerberosString(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosString *r)
2044
{
2045
ndr_print_struct(ndr, name, "package_PrimaryKerberosString");
2046
if (r == NULL) { ndr_print_null(ndr); return; }
2047
ndr->depth++;
2048
ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->length);
2049
ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m(r->string):r->size);
2050
ndr_print_ptr(ndr, "string", r->string);
2051
ndr->depth++;
2052
if (r->string) {
2053
ndr_print_string(ndr, "string", r->string);
2054
}
2055
ndr->depth--;
2056
ndr->depth--;
2057
}
2058
2059
static enum ndr_err_code ndr_push_package_PrimaryKerberosKey3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey3 *r)
2060
{
2061
if (ndr_flags & NDR_SCALARS) {
2062
NDR_CHECK(ndr_push_align(ndr, 5));
2063
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2064
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2065
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2066
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
2067
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2068
{
2069
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2070
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2071
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2072
ndr->flags = _flags_save_DATA_BLOB;
2073
}
2074
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2075
}
2076
if (ndr_flags & NDR_BUFFERS) {
2077
{
2078
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2079
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2080
if (r->value) {
2081
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value));
2082
{
2083
struct ndr_push *_ndr_value;
2084
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2085
NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2086
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2087
}
2088
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value));
2089
}
2090
ndr->flags = _flags_save_DATA_BLOB;
2091
}
2092
}
2093
return NDR_ERR_SUCCESS;
2094
}
2095
2096
static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey3 *r)
2097
{
2098
uint32_t _ptr_value;
2099
TALLOC_CTX *_mem_save_value_0;
2100
if (ndr_flags & NDR_SCALARS) {
2101
NDR_CHECK(ndr_pull_align(ndr, 5));
2102
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2103
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2104
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2105
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2106
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2107
{
2108
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2109
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2110
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2111
if (_ptr_value) {
2112
NDR_PULL_ALLOC(ndr, r->value);
2113
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2114
} else {
2115
r->value = NULL;
2116
}
2117
ndr->flags = _flags_save_DATA_BLOB;
2118
}
2119
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2120
}
2121
if (ndr_flags & NDR_BUFFERS) {
2122
{
2123
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2124
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2125
if (r->value) {
2126
uint32_t _relative_save_offset;
2127
_relative_save_offset = ndr->offset;
2128
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2129
_mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2130
NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2131
{
2132
struct ndr_pull *_ndr_value;
2133
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2134
NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2135
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2136
}
2137
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2138
if (ndr->offset > ndr->relative_highest_offset) {
2139
ndr->relative_highest_offset = ndr->offset;
2140
}
2141
ndr->offset = _relative_save_offset;
2142
}
2143
ndr->flags = _flags_save_DATA_BLOB;
2144
}
2145
}
2146
return NDR_ERR_SUCCESS;
2147
}
2148
2149
_PUBLIC_ void ndr_print_package_PrimaryKerberosKey3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey3 *r)
2150
{
2151
ndr_print_struct(ndr, name, "package_PrimaryKerberosKey3");
2152
if (r == NULL) { ndr_print_null(ndr); return; }
2153
ndr->depth++;
2154
ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2155
ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2156
ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2157
ndr_print_uint32(ndr, "keytype", r->keytype);
2158
ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2159
ndr_print_ptr(ndr, "value", r->value);
2160
ndr->depth++;
2161
if (r->value) {
2162
ndr_print_DATA_BLOB(ndr, "value", *r->value);
2163
}
2164
ndr->depth--;
2165
ndr->depth--;
2166
}
2167
2168
static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr3(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr3 *r)
2169
{
2170
uint32_t cntr_keys_0;
2171
uint32_t cntr_old_keys_0;
2172
if (ndr_flags & NDR_SCALARS) {
2173
NDR_CHECK(ndr_push_align(ndr, 5));
2174
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2175
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2176
NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2177
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2178
NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2179
}
2180
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2181
NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2182
}
2183
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2184
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2185
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2186
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2187
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2188
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2189
}
2190
if (ndr_flags & NDR_BUFFERS) {
2191
NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2192
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2193
NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2194
}
2195
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2196
NDR_CHECK(ndr_push_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2197
}
2198
}
2199
return NDR_ERR_SUCCESS;
2200
}
2201
2202
static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr3(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr3 *r)
2203
{
2204
uint32_t cntr_keys_0;
2205
TALLOC_CTX *_mem_save_keys_0;
2206
uint32_t cntr_old_keys_0;
2207
TALLOC_CTX *_mem_save_old_keys_0;
2208
if (ndr_flags & NDR_SCALARS) {
2209
NDR_CHECK(ndr_pull_align(ndr, 5));
2210
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2211
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2212
NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2213
NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2214
_mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2215
NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2216
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2217
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2218
}
2219
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2220
NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2221
_mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2222
NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2223
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2224
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2225
}
2226
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2227
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding1));
2228
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding2));
2229
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding3));
2230
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding4));
2231
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->padding5));
2232
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2233
}
2234
if (ndr_flags & NDR_BUFFERS) {
2235
NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2236
_mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2237
NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2238
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2239
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2240
}
2241
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2242
_mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2243
NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2244
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2245
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey3(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2246
}
2247
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2248
}
2249
return NDR_ERR_SUCCESS;
2250
}
2251
2252
_PUBLIC_ void ndr_print_package_PrimaryKerberosCtr3(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr3 *r)
2253
{
2254
uint32_t cntr_keys_0;
2255
uint32_t cntr_old_keys_0;
2256
ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr3");
2257
if (r == NULL) { ndr_print_null(ndr); return; }
2258
ndr->depth++;
2259
ndr_print_uint16(ndr, "num_keys", r->num_keys);
2260
ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2261
ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2262
ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2263
ndr->depth++;
2264
for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2265
ndr_print_package_PrimaryKerberosKey3(ndr, "keys", &r->keys[cntr_keys_0]);
2266
}
2267
ndr->depth--;
2268
ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2269
ndr->depth++;
2270
for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2271
ndr_print_package_PrimaryKerberosKey3(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2272
}
2273
ndr->depth--;
2274
ndr_print_uint32(ndr, "padding1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding1);
2275
ndr_print_uint32(ndr, "padding2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding2);
2276
ndr_print_uint32(ndr, "padding3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding3);
2277
ndr_print_uint32(ndr, "padding4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding4);
2278
ndr_print_uint32(ndr, "padding5", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->padding5);
2279
ndr->depth--;
2280
}
2281
2282
static enum ndr_err_code ndr_push_package_PrimaryKerberosKey4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosKey4 *r)
2283
{
2284
if (ndr_flags & NDR_SCALARS) {
2285
NDR_CHECK(ndr_push_align(ndr, 5));
2286
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2287
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2288
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2289
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->iteration_count));
2290
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->keytype));
2291
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->value?r->value->length:0)));
2292
{
2293
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2294
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2295
NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value));
2296
ndr->flags = _flags_save_DATA_BLOB;
2297
}
2298
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2299
}
2300
if (ndr_flags & NDR_BUFFERS) {
2301
{
2302
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2303
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2304
if (r->value) {
2305
NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value));
2306
{
2307
struct ndr_push *_ndr_value;
2308
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_value, 0, (r->value?r->value->length:0)));
2309
NDR_CHECK(ndr_push_DATA_BLOB(_ndr_value, NDR_SCALARS, *r->value));
2310
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_value, 0, (r->value?r->value->length:0)));
2311
}
2312
NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value));
2313
}
2314
ndr->flags = _flags_save_DATA_BLOB;
2315
}
2316
}
2317
return NDR_ERR_SUCCESS;
2318
}
2319
2320
static enum ndr_err_code ndr_pull_package_PrimaryKerberosKey4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosKey4 *r)
2321
{
2322
uint32_t _ptr_value;
2323
TALLOC_CTX *_mem_save_value_0;
2324
if (ndr_flags & NDR_SCALARS) {
2325
NDR_CHECK(ndr_pull_align(ndr, 5));
2326
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved1));
2327
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->reserved2));
2328
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
2329
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->iteration_count));
2330
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->keytype));
2331
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_len));
2332
{
2333
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2334
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2335
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value));
2336
if (_ptr_value) {
2337
NDR_PULL_ALLOC(ndr, r->value);
2338
NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value, _ptr_value));
2339
} else {
2340
r->value = NULL;
2341
}
2342
ndr->flags = _flags_save_DATA_BLOB;
2343
}
2344
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2345
}
2346
if (ndr_flags & NDR_BUFFERS) {
2347
{
2348
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2349
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2350
if (r->value) {
2351
uint32_t _relative_save_offset;
2352
_relative_save_offset = ndr->offset;
2353
NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value));
2354
_mem_save_value_0 = NDR_PULL_GET_MEM_CTX(ndr);
2355
NDR_PULL_SET_MEM_CTX(ndr, r->value, 0);
2356
{
2357
struct ndr_pull *_ndr_value;
2358
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_value, 0, r->value_len));
2359
NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_value, NDR_SCALARS, r->value));
2360
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_value, 0, r->value_len));
2361
}
2362
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_0, 0);
2363
if (ndr->offset > ndr->relative_highest_offset) {
2364
ndr->relative_highest_offset = ndr->offset;
2365
}
2366
ndr->offset = _relative_save_offset;
2367
}
2368
ndr->flags = _flags_save_DATA_BLOB;
2369
}
2370
}
2371
return NDR_ERR_SUCCESS;
2372
}
2373
2374
_PUBLIC_ void ndr_print_package_PrimaryKerberosKey4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosKey4 *r)
2375
{
2376
ndr_print_struct(ndr, name, "package_PrimaryKerberosKey4");
2377
if (r == NULL) { ndr_print_null(ndr); return; }
2378
ndr->depth++;
2379
ndr_print_uint16(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2380
ndr_print_uint16(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2381
ndr_print_uint32(ndr, "reserved3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved3);
2382
ndr_print_uint32(ndr, "iteration_count", r->iteration_count);
2383
ndr_print_uint32(ndr, "keytype", r->keytype);
2384
ndr_print_uint32(ndr, "value_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->value?r->value->length:0):r->value_len);
2385
ndr_print_ptr(ndr, "value", r->value);
2386
ndr->depth++;
2387
if (r->value) {
2388
ndr_print_DATA_BLOB(ndr, "value", *r->value);
2389
}
2390
ndr->depth--;
2391
ndr->depth--;
2392
}
2393
2394
static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr4(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosCtr4 *r)
2395
{
2396
uint32_t cntr_keys_0;
2397
uint32_t cntr_old_keys_0;
2398
uint32_t cntr_older_keys_0;
2399
if (ndr_flags & NDR_SCALARS) {
2400
NDR_CHECK(ndr_push_align(ndr, 5));
2401
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_keys));
2402
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2403
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_old_keys));
2404
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_older_keys));
2405
NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2406
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->default_iteration_count));
2407
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2408
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2409
}
2410
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2411
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2412
}
2413
for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2414
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2415
}
2416
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2417
}
2418
if (ndr_flags & NDR_BUFFERS) {
2419
NDR_CHECK(ndr_push_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2420
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2421
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2422
}
2423
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2424
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2425
}
2426
for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2427
NDR_CHECK(ndr_push_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2428
}
2429
}
2430
return NDR_ERR_SUCCESS;
2431
}
2432
2433
static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr4(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosCtr4 *r)
2434
{
2435
uint32_t cntr_keys_0;
2436
TALLOC_CTX *_mem_save_keys_0;
2437
uint32_t cntr_service_keys_0;
2438
TALLOC_CTX *_mem_save_service_keys_0;
2439
uint32_t cntr_old_keys_0;
2440
TALLOC_CTX *_mem_save_old_keys_0;
2441
uint32_t cntr_older_keys_0;
2442
TALLOC_CTX *_mem_save_older_keys_0;
2443
if (ndr_flags & NDR_SCALARS) {
2444
NDR_CHECK(ndr_pull_align(ndr, 5));
2445
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_keys));
2446
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_service_keys));
2447
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_old_keys));
2448
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_older_keys));
2449
NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_SCALARS, &r->salt));
2450
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->default_iteration_count));
2451
NDR_PULL_ALLOC_N(ndr, r->keys, r->num_keys);
2452
_mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2453
NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2454
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2455
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->keys[cntr_keys_0]));
2456
}
2457
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2458
NDR_PULL_ALLOC_N(ndr, r->service_keys, r->num_service_keys);
2459
_mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2460
NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2461
for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2462
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->service_keys[cntr_service_keys_0]));
2463
}
2464
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2465
NDR_PULL_ALLOC_N(ndr, r->old_keys, r->num_old_keys);
2466
_mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2467
NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2468
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2469
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->old_keys[cntr_old_keys_0]));
2470
}
2471
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2472
NDR_PULL_ALLOC_N(ndr, r->older_keys, r->num_older_keys);
2473
_mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2474
NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2475
for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2476
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_SCALARS, &r->older_keys[cntr_older_keys_0]));
2477
}
2478
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2479
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2480
}
2481
if (ndr_flags & NDR_BUFFERS) {
2482
NDR_CHECK(ndr_pull_package_PrimaryKerberosString(ndr, NDR_BUFFERS, &r->salt));
2483
_mem_save_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2484
NDR_PULL_SET_MEM_CTX(ndr, r->keys, 0);
2485
for (cntr_keys_0 = 0; cntr_keys_0 < r->num_keys; cntr_keys_0++) {
2486
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->keys[cntr_keys_0]));
2487
}
2488
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keys_0, 0);
2489
_mem_save_service_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490
NDR_PULL_SET_MEM_CTX(ndr, r->service_keys, 0);
2491
for (cntr_service_keys_0 = 0; cntr_service_keys_0 < r->num_service_keys; cntr_service_keys_0++) {
2492
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->service_keys[cntr_service_keys_0]));
2493
}
2494
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_keys_0, 0);
2495
_mem_save_old_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2496
NDR_PULL_SET_MEM_CTX(ndr, r->old_keys, 0);
2497
for (cntr_old_keys_0 = 0; cntr_old_keys_0 < r->num_old_keys; cntr_old_keys_0++) {
2498
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->old_keys[cntr_old_keys_0]));
2499
}
2500
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_old_keys_0, 0);
2501
_mem_save_older_keys_0 = NDR_PULL_GET_MEM_CTX(ndr);
2502
NDR_PULL_SET_MEM_CTX(ndr, r->older_keys, 0);
2503
for (cntr_older_keys_0 = 0; cntr_older_keys_0 < r->num_older_keys; cntr_older_keys_0++) {
2504
NDR_CHECK(ndr_pull_package_PrimaryKerberosKey4(ndr, NDR_BUFFERS, &r->older_keys[cntr_older_keys_0]));
2505
}
2506
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_older_keys_0, 0);
2507
}
2508
return NDR_ERR_SUCCESS;
2509
}
2510
2511
_PUBLIC_ void ndr_print_package_PrimaryKerberosCtr4(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosCtr4 *r)
2512
{
2513
uint32_t cntr_keys_0;
2514
uint32_t cntr_service_keys_0;
2515
uint32_t cntr_old_keys_0;
2516
uint32_t cntr_older_keys_0;
2517
ndr_print_struct(ndr, name, "package_PrimaryKerberosCtr4");
2518
if (r == NULL) { ndr_print_null(ndr); return; }
2519
ndr->depth++;
2520
ndr_print_uint16(ndr, "num_keys", r->num_keys);
2521
ndr_print_uint16(ndr, "num_service_keys", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->num_service_keys);
2522
ndr_print_uint16(ndr, "num_old_keys", r->num_old_keys);
2523
ndr_print_uint16(ndr, "num_older_keys", r->num_older_keys);
2524
ndr_print_package_PrimaryKerberosString(ndr, "salt", &r->salt);
2525
ndr_print_uint32(ndr, "default_iteration_count", r->default_iteration_count);
2526
ndr->print(ndr, "%s: ARRAY(%d)", "keys", (int)r->num_keys);
2527
ndr->depth++;
2528
for (cntr_keys_0=0;cntr_keys_0<r->num_keys;cntr_keys_0++) {
2529
ndr_print_package_PrimaryKerberosKey4(ndr, "keys", &r->keys[cntr_keys_0]);
2530
}
2531
ndr->depth--;
2532
ndr->print(ndr, "%s: ARRAY(%d)", "service_keys", (int)r->num_service_keys);
2533
ndr->depth++;
2534
for (cntr_service_keys_0=0;cntr_service_keys_0<r->num_service_keys;cntr_service_keys_0++) {
2535
ndr_print_package_PrimaryKerberosKey4(ndr, "service_keys", &r->service_keys[cntr_service_keys_0]);
2536
}
2537
ndr->depth--;
2538
ndr->print(ndr, "%s: ARRAY(%d)", "old_keys", (int)r->num_old_keys);
2539
ndr->depth++;
2540
for (cntr_old_keys_0=0;cntr_old_keys_0<r->num_old_keys;cntr_old_keys_0++) {
2541
ndr_print_package_PrimaryKerberosKey4(ndr, "old_keys", &r->old_keys[cntr_old_keys_0]);
2542
}
2543
ndr->depth--;
2544
ndr->print(ndr, "%s: ARRAY(%d)", "older_keys", (int)r->num_older_keys);
2545
ndr->depth++;
2546
for (cntr_older_keys_0=0;cntr_older_keys_0<r->num_older_keys;cntr_older_keys_0++) {
2547
ndr_print_package_PrimaryKerberosKey4(ndr, "older_keys", &r->older_keys[cntr_older_keys_0]);
2548
}
2549
ndr->depth--;
2550
ndr->depth--;
2551
}
2552
2553
static enum ndr_err_code ndr_push_package_PrimaryKerberosCtr(struct ndr_push *ndr, int ndr_flags, const union package_PrimaryKerberosCtr *r)
2554
{
2555
if (ndr_flags & NDR_SCALARS) {
2556
uint32_t level = ndr_push_get_switch_value(ndr, r);
2557
NDR_CHECK(ndr_push_union_align(ndr, 5));
2558
switch (level) {
2559
case 3: {
2560
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2561
break; }
2562
2563
case 4: {
2564
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2565
break; }
2566
2567
default:
2568
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2569
}
2570
}
2571
if (ndr_flags & NDR_BUFFERS) {
2572
uint32_t level = ndr_push_get_switch_value(ndr, r);
2573
switch (level) {
2574
case 3:
2575
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2576
break;
2577
2578
case 4:
2579
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2580
break;
2581
2582
default:
2583
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2584
}
2585
}
2586
return NDR_ERR_SUCCESS;
2587
}
2588
2589
static enum ndr_err_code ndr_pull_package_PrimaryKerberosCtr(struct ndr_pull *ndr, int ndr_flags, union package_PrimaryKerberosCtr *r)
2590
{
2591
uint32_t level;
2592
level = ndr_pull_get_switch_value(ndr, r);
2593
if (ndr_flags & NDR_SCALARS) {
2594
NDR_CHECK(ndr_pull_union_align(ndr, 5));
2595
switch (level) {
2596
case 3: {
2597
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_SCALARS, &r->ctr3));
2598
break; }
2599
2600
case 4: {
2601
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_SCALARS, &r->ctr4));
2602
break; }
2603
2604
default:
2605
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2606
}
2607
}
2608
if (ndr_flags & NDR_BUFFERS) {
2609
switch (level) {
2610
case 3:
2611
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr3(ndr, NDR_BUFFERS, &r->ctr3));
2612
break;
2613
2614
case 4:
2615
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr4(ndr, NDR_BUFFERS, &r->ctr4));
2616
break;
2617
2618
default:
2619
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
2620
}
2621
}
2622
return NDR_ERR_SUCCESS;
2623
}
2624
2625
_PUBLIC_ void ndr_print_package_PrimaryKerberosCtr(struct ndr_print *ndr, const char *name, const union package_PrimaryKerberosCtr *r)
2626
{
2627
uint32_t level;
2628
level = ndr_print_get_switch_value(ndr, r);
2629
ndr_print_union(ndr, name, level, "package_PrimaryKerberosCtr");
2630
switch (level) {
2631
case 3:
2632
ndr_print_package_PrimaryKerberosCtr3(ndr, "ctr3", &r->ctr3);
2633
break;
2634
2635
case 4:
2636
ndr_print_package_PrimaryKerberosCtr4(ndr, "ctr4", &r->ctr4);
2637
break;
2638
2639
default:
2640
ndr_print_bad_level(ndr, name, level);
2641
}
2642
}
2643
2644
_PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryKerberosBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryKerberosBlob *r)
2645
{
2646
if (ndr_flags & NDR_SCALARS) {
2647
NDR_CHECK(ndr_push_align(ndr, 5));
2648
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
2649
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
2650
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->version));
2651
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2652
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2653
}
2654
if (ndr_flags & NDR_BUFFERS) {
2655
NDR_CHECK(ndr_push_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2656
}
2657
return NDR_ERR_SUCCESS;
2658
}
2659
2660
_PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryKerberosBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryKerberosBlob *r)
2661
{
2662
if (ndr_flags & NDR_SCALARS) {
2663
NDR_CHECK(ndr_pull_align(ndr, 5));
2664
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
2665
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
2666
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->version));
2667
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_SCALARS, &r->ctr));
2668
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2669
}
2670
if (ndr_flags & NDR_BUFFERS) {
2671
NDR_CHECK(ndr_pull_package_PrimaryKerberosCtr(ndr, NDR_BUFFERS, &r->ctr));
2672
}
2673
return NDR_ERR_SUCCESS;
2674
}
2675
2676
_PUBLIC_ void ndr_print_package_PrimaryKerberosBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryKerberosBlob *r)
2677
{
2678
ndr_print_struct(ndr, name, "package_PrimaryKerberosBlob");
2679
if (r == NULL) { ndr_print_null(ndr); return; }
2680
ndr->depth++;
2681
ndr_print_uint16(ndr, "version", r->version);
2682
ndr_print_uint16(ndr, "flags", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags);
2683
ndr_print_set_switch_value(ndr, &r->ctr, r->version);
2684
ndr_print_package_PrimaryKerberosCtr(ndr, "ctr", &r->ctr);
2685
ndr->depth--;
2686
}
2687
2688
_PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryCLEARTEXTBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryCLEARTEXTBlob *r)
2689
{
2690
if (ndr_flags & NDR_SCALARS) {
2691
NDR_CHECK(ndr_push_align(ndr, 4));
2692
{
2693
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2694
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2695
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->cleartext));
2696
ndr->flags = _flags_save_DATA_BLOB;
2697
}
2698
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2699
}
2700
if (ndr_flags & NDR_BUFFERS) {
2701
}
2702
return NDR_ERR_SUCCESS;
2703
}
2704
2705
_PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryCLEARTEXTBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryCLEARTEXTBlob *r)
2706
{
2707
if (ndr_flags & NDR_SCALARS) {
2708
NDR_CHECK(ndr_pull_align(ndr, 4));
2709
{
2710
uint32_t _flags_save_DATA_BLOB = ndr->flags;
2711
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2712
NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->cleartext));
2713
ndr->flags = _flags_save_DATA_BLOB;
2714
}
2715
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2716
}
2717
if (ndr_flags & NDR_BUFFERS) {
2718
}
2719
return NDR_ERR_SUCCESS;
2720
}
2721
2722
_PUBLIC_ void ndr_print_package_PrimaryCLEARTEXTBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryCLEARTEXTBlob *r)
2723
{
2724
ndr_print_struct(ndr, name, "package_PrimaryCLEARTEXTBlob");
2725
if (r == NULL) { ndr_print_null(ndr); return; }
2726
ndr->depth++;
2727
ndr_print_DATA_BLOB(ndr, "cleartext", r->cleartext);
2728
ndr->depth--;
2729
}
2730
2731
static enum ndr_err_code ndr_push_package_PrimaryWDigestHash(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestHash *r)
2732
{
2733
{
2734
uint32_t _flags_save_STRUCT = ndr->flags;
2735
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2736
if (ndr_flags & NDR_SCALARS) {
2737
NDR_CHECK(ndr_push_align(ndr, 1));
2738
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2739
NDR_CHECK(ndr_push_trailer_align(ndr, 1));
2740
}
2741
if (ndr_flags & NDR_BUFFERS) {
2742
}
2743
ndr->flags = _flags_save_STRUCT;
2744
}
2745
return NDR_ERR_SUCCESS;
2746
}
2747
2748
static enum ndr_err_code ndr_pull_package_PrimaryWDigestHash(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestHash *r)
2749
{
2750
{
2751
uint32_t _flags_save_STRUCT = ndr->flags;
2752
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2753
if (ndr_flags & NDR_SCALARS) {
2754
NDR_CHECK(ndr_pull_align(ndr, 1));
2755
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
2756
NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
2757
}
2758
if (ndr_flags & NDR_BUFFERS) {
2759
}
2760
ndr->flags = _flags_save_STRUCT;
2761
}
2762
return NDR_ERR_SUCCESS;
2763
}
2764
2765
_PUBLIC_ void ndr_print_package_PrimaryWDigestHash(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestHash *r)
2766
{
2767
ndr_print_struct(ndr, name, "package_PrimaryWDigestHash");
2768
if (r == NULL) { ndr_print_null(ndr); return; }
2769
{
2770
uint32_t _flags_save_STRUCT = ndr->flags;
2771
ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
2772
ndr->depth++;
2773
ndr_print_array_uint8(ndr, "hash", r->hash, 16);
2774
ndr->depth--;
2775
ndr->flags = _flags_save_STRUCT;
2776
}
2777
}
2778
2779
_PUBLIC_ enum ndr_err_code ndr_push_package_PrimaryWDigestBlob(struct ndr_push *ndr, int ndr_flags, const struct package_PrimaryWDigestBlob *r)
2780
{
2781
uint32_t cntr_hashes_0;
2782
if (ndr_flags & NDR_SCALARS) {
2783
NDR_CHECK(ndr_push_align(ndr, 4));
2784
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0x31));
2785
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0x01));
2786
NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->num_hashes));
2787
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2788
NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, 0));
2789
for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2790
NDR_CHECK(ndr_push_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2791
}
2792
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2793
}
2794
if (ndr_flags & NDR_BUFFERS) {
2795
}
2796
return NDR_ERR_SUCCESS;
2797
}
2798
2799
_PUBLIC_ enum ndr_err_code ndr_pull_package_PrimaryWDigestBlob(struct ndr_pull *ndr, int ndr_flags, struct package_PrimaryWDigestBlob *r)
2800
{
2801
uint32_t cntr_hashes_0;
2802
TALLOC_CTX *_mem_save_hashes_0;
2803
if (ndr_flags & NDR_SCALARS) {
2804
NDR_CHECK(ndr_pull_align(ndr, 4));
2805
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown1));
2806
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->unknown2));
2807
NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_hashes));
2808
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
2809
NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->uuknown4));
2810
NDR_PULL_ALLOC_N(ndr, r->hashes, r->num_hashes);
2811
_mem_save_hashes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2812
NDR_PULL_SET_MEM_CTX(ndr, r->hashes, 0);
2813
for (cntr_hashes_0 = 0; cntr_hashes_0 < r->num_hashes; cntr_hashes_0++) {
2814
NDR_CHECK(ndr_pull_package_PrimaryWDigestHash(ndr, NDR_SCALARS, &r->hashes[cntr_hashes_0]));
2815
}
2816
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hashes_0, 0);
2817
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2818
}
2819
if (ndr_flags & NDR_BUFFERS) {
2820
}
2821
return NDR_ERR_SUCCESS;
2822
}
2823
2824
_PUBLIC_ void ndr_print_package_PrimaryWDigestBlob(struct ndr_print *ndr, const char *name, const struct package_PrimaryWDigestBlob *r)
2825
{
2826
uint32_t cntr_hashes_0;
2827
ndr_print_struct(ndr, name, "package_PrimaryWDigestBlob");
2828
if (r == NULL) { ndr_print_null(ndr); return; }
2829
ndr->depth++;
2830
ndr_print_uint16(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x31:r->unknown1);
2831
ndr_print_uint8(ndr, "unknown2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x01:r->unknown2);
2832
ndr_print_uint8(ndr, "num_hashes", r->num_hashes);
2833
ndr_print_uint32(ndr, "unknown3", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->unknown3);
2834
ndr_print_udlong(ndr, "uuknown4", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->uuknown4);
2835
ndr->print(ndr, "%s: ARRAY(%d)", "hashes", (int)r->num_hashes);
2836
ndr->depth++;
2837
for (cntr_hashes_0=0;cntr_hashes_0<r->num_hashes;cntr_hashes_0++) {
2838
ndr_print_package_PrimaryWDigestHash(ndr, "hashes", &r->hashes[cntr_hashes_0]);
2839
}
2840
ndr->depth--;
2841
ndr->depth--;
2842
}
2843
2844
static enum ndr_err_code ndr_push_AuthInfoNone(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNone *r)
2845
{
2846
if (ndr_flags & NDR_SCALARS) {
2847
NDR_CHECK(ndr_push_align(ndr, 4));
2848
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2849
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2850
}
2851
if (ndr_flags & NDR_BUFFERS) {
2852
}
2853
return NDR_ERR_SUCCESS;
2854
}
2855
2856
static enum ndr_err_code ndr_pull_AuthInfoNone(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNone *r)
2857
{
2858
if (ndr_flags & NDR_SCALARS) {
2859
NDR_CHECK(ndr_pull_align(ndr, 4));
2860
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2861
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2862
}
2863
if (ndr_flags & NDR_BUFFERS) {
2864
}
2865
return NDR_ERR_SUCCESS;
2866
}
2867
2868
_PUBLIC_ void ndr_print_AuthInfoNone(struct ndr_print *ndr, const char *name, const struct AuthInfoNone *r)
2869
{
2870
ndr_print_struct(ndr, name, "AuthInfoNone");
2871
if (r == NULL) { ndr_print_null(ndr); return; }
2872
ndr->depth++;
2873
ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->size);
2874
ndr->depth--;
2875
}
2876
2877
static enum ndr_err_code ndr_push_AuthInfoNT4Owf(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoNT4Owf *r)
2878
{
2879
if (ndr_flags & NDR_SCALARS) {
2880
NDR_CHECK(ndr_push_align(ndr, 4));
2881
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 16));
2882
NDR_CHECK(ndr_push_samr_Password(ndr, NDR_SCALARS, &r->password));
2883
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2884
}
2885
if (ndr_flags & NDR_BUFFERS) {
2886
}
2887
return NDR_ERR_SUCCESS;
2888
}
2889
2890
static enum ndr_err_code ndr_pull_AuthInfoNT4Owf(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoNT4Owf *r)
2891
{
2892
if (ndr_flags & NDR_SCALARS) {
2893
NDR_CHECK(ndr_pull_align(ndr, 4));
2894
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2895
NDR_CHECK(ndr_pull_samr_Password(ndr, NDR_SCALARS, &r->password));
2896
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2897
}
2898
if (ndr_flags & NDR_BUFFERS) {
2899
}
2900
return NDR_ERR_SUCCESS;
2901
}
2902
2903
_PUBLIC_ void ndr_print_AuthInfoNT4Owf(struct ndr_print *ndr, const char *name, const struct AuthInfoNT4Owf *r)
2904
{
2905
ndr_print_struct(ndr, name, "AuthInfoNT4Owf");
2906
if (r == NULL) { ndr_print_null(ndr); return; }
2907
ndr->depth++;
2908
ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?16:r->size);
2909
ndr_print_samr_Password(ndr, "password", &r->password);
2910
ndr->depth--;
2911
}
2912
2913
static enum ndr_err_code ndr_push_AuthInfoClear(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoClear *r)
2914
{
2915
if (ndr_flags & NDR_SCALARS) {
2916
NDR_CHECK(ndr_push_align(ndr, 4));
2917
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2918
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2919
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2920
}
2921
if (ndr_flags & NDR_BUFFERS) {
2922
}
2923
return NDR_ERR_SUCCESS;
2924
}
2925
2926
static enum ndr_err_code ndr_pull_AuthInfoClear(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoClear *r)
2927
{
2928
if (ndr_flags & NDR_SCALARS) {
2929
NDR_CHECK(ndr_pull_align(ndr, 4));
2930
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2931
NDR_PULL_ALLOC_N(ndr, r->password, r->size);
2932
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->password, r->size));
2933
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2934
}
2935
if (ndr_flags & NDR_BUFFERS) {
2936
}
2937
return NDR_ERR_SUCCESS;
2938
}
2939
2940
_PUBLIC_ void ndr_print_AuthInfoClear(struct ndr_print *ndr, const char *name, const struct AuthInfoClear *r)
2941
{
2942
ndr_print_struct(ndr, name, "AuthInfoClear");
2943
if (r == NULL) { ndr_print_null(ndr); return; }
2944
ndr->depth++;
2945
ndr_print_uint32(ndr, "size", r->size);
2946
ndr_print_array_uint8(ndr, "password", r->password, r->size);
2947
ndr->depth--;
2948
}
2949
2950
static enum ndr_err_code ndr_push_AuthInfoVersion(struct ndr_push *ndr, int ndr_flags, const struct AuthInfoVersion *r)
2951
{
2952
if (ndr_flags & NDR_SCALARS) {
2953
NDR_CHECK(ndr_push_align(ndr, 4));
2954
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 4));
2955
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2956
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2957
}
2958
if (ndr_flags & NDR_BUFFERS) {
2959
}
2960
return NDR_ERR_SUCCESS;
2961
}
2962
2963
static enum ndr_err_code ndr_pull_AuthInfoVersion(struct ndr_pull *ndr, int ndr_flags, struct AuthInfoVersion *r)
2964
{
2965
if (ndr_flags & NDR_SCALARS) {
2966
NDR_CHECK(ndr_pull_align(ndr, 4));
2967
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
2968
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2969
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2970
}
2971
if (ndr_flags & NDR_BUFFERS) {
2972
}
2973
return NDR_ERR_SUCCESS;
2974
}
2975
2976
_PUBLIC_ void ndr_print_AuthInfoVersion(struct ndr_print *ndr, const char *name, const struct AuthInfoVersion *r)
2977
{
2978
ndr_print_struct(ndr, name, "AuthInfoVersion");
2979
if (r == NULL) { ndr_print_null(ndr); return; }
2980
ndr->depth++;
2981
ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?4:r->size);
2982
ndr_print_uint32(ndr, "version", r->version);
2983
ndr->depth--;
2984
}
2985
2986
static enum ndr_err_code ndr_push_AuthInfo(struct ndr_push *ndr, int ndr_flags, const union AuthInfo *r)
2987
{
2988
if (ndr_flags & NDR_SCALARS) {
2989
uint32_t level = ndr_push_get_switch_value(ndr, r);
2990
NDR_CHECK(ndr_push_union_align(ndr, 4));
2991
switch (level) {
2992
case TRUST_AUTH_TYPE_NONE: {
2993
NDR_CHECK(ndr_push_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
2994
break; }
2995
2996
case TRUST_AUTH_TYPE_NT4OWF: {
2997
NDR_CHECK(ndr_push_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
2998
break; }
2999
3000
case TRUST_AUTH_TYPE_CLEAR: {
3001
NDR_CHECK(ndr_push_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
3002
break; }
3003
3004
case TRUST_AUTH_TYPE_VERSION: {
3005
NDR_CHECK(ndr_push_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
3006
break; }
3007
3008
default:
3009
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3010
}
3011
}
3012
if (ndr_flags & NDR_BUFFERS) {
3013
uint32_t level = ndr_push_get_switch_value(ndr, r);
3014
switch (level) {
3015
case TRUST_AUTH_TYPE_NONE:
3016
break;
3017
3018
case TRUST_AUTH_TYPE_NT4OWF:
3019
break;
3020
3021
case TRUST_AUTH_TYPE_CLEAR:
3022
break;
3023
3024
case TRUST_AUTH_TYPE_VERSION:
3025
break;
3026
3027
default:
3028
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3029
}
3030
}
3031
return NDR_ERR_SUCCESS;
3032
}
3033
3034
static enum ndr_err_code ndr_pull_AuthInfo(struct ndr_pull *ndr, int ndr_flags, union AuthInfo *r)
3035
{
3036
uint32_t level;
3037
level = ndr_pull_get_switch_value(ndr, r);
3038
if (ndr_flags & NDR_SCALARS) {
3039
NDR_CHECK(ndr_pull_union_align(ndr, 4));
3040
switch (level) {
3041
case TRUST_AUTH_TYPE_NONE: {
3042
NDR_CHECK(ndr_pull_AuthInfoNone(ndr, NDR_SCALARS, &r->none));
3043
break; }
3044
3045
case TRUST_AUTH_TYPE_NT4OWF: {
3046
NDR_CHECK(ndr_pull_AuthInfoNT4Owf(ndr, NDR_SCALARS, &r->nt4owf));
3047
break; }
3048
3049
case TRUST_AUTH_TYPE_CLEAR: {
3050
NDR_CHECK(ndr_pull_AuthInfoClear(ndr, NDR_SCALARS, &r->clear));
3051
break; }
3052
3053
case TRUST_AUTH_TYPE_VERSION: {
3054
NDR_CHECK(ndr_pull_AuthInfoVersion(ndr, NDR_SCALARS, &r->version));
3055
break; }
3056
3057
default:
3058
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3059
}
3060
}
3061
if (ndr_flags & NDR_BUFFERS) {
3062
switch (level) {
3063
case TRUST_AUTH_TYPE_NONE:
3064
break;
3065
3066
case TRUST_AUTH_TYPE_NT4OWF:
3067
break;
3068
3069
case TRUST_AUTH_TYPE_CLEAR:
3070
break;
3071
3072
case TRUST_AUTH_TYPE_VERSION:
3073
break;
3074
3075
default:
3076
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3077
}
3078
}
3079
return NDR_ERR_SUCCESS;
3080
}
3081
3082
_PUBLIC_ void ndr_print_AuthInfo(struct ndr_print *ndr, const char *name, const union AuthInfo *r)
3083
{
3084
uint32_t level;
3085
level = ndr_print_get_switch_value(ndr, r);
3086
ndr_print_union(ndr, name, level, "AuthInfo");
3087
switch (level) {
3088
case TRUST_AUTH_TYPE_NONE:
3089
ndr_print_AuthInfoNone(ndr, "none", &r->none);
3090
break;
3091
3092
case TRUST_AUTH_TYPE_NT4OWF:
3093
ndr_print_AuthInfoNT4Owf(ndr, "nt4owf", &r->nt4owf);
3094
break;
3095
3096
case TRUST_AUTH_TYPE_CLEAR:
3097
ndr_print_AuthInfoClear(ndr, "clear", &r->clear);
3098
break;
3099
3100
case TRUST_AUTH_TYPE_VERSION:
3101
ndr_print_AuthInfoVersion(ndr, "version", &r->version);
3102
break;
3103
3104
default:
3105
ndr_print_bad_level(ndr, name, level);
3106
}
3107
}
3108
3109
_PUBLIC_ enum ndr_err_code ndr_push_AuthenticationInformation(struct ndr_push *ndr, int ndr_flags, const struct AuthenticationInformation *r)
3110
{
3111
if (ndr_flags & NDR_SCALARS) {
3112
NDR_CHECK(ndr_push_align(ndr, 4));
3113
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->LastUpdateTime));
3114
NDR_CHECK(ndr_push_lsa_TrustAuthType(ndr, NDR_SCALARS, r->AuthType));
3115
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3116
NDR_CHECK(ndr_push_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3117
{
3118
uint32_t _flags_save_DATA_BLOB = ndr->flags;
3119
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3120
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->_pad));
3121
ndr->flags = _flags_save_DATA_BLOB;
3122
}
3123
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3124
}
3125
if (ndr_flags & NDR_BUFFERS) {
3126
}
3127
return NDR_ERR_SUCCESS;
3128
}
3129
3130
_PUBLIC_ enum ndr_err_code ndr_pull_AuthenticationInformation(struct ndr_pull *ndr, int ndr_flags, struct AuthenticationInformation *r)
3131
{
3132
if (ndr_flags & NDR_SCALARS) {
3133
NDR_CHECK(ndr_pull_align(ndr, 4));
3134
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->LastUpdateTime));
3135
NDR_CHECK(ndr_pull_lsa_TrustAuthType(ndr, NDR_SCALARS, &r->AuthType));
3136
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->AuthInfo, r->AuthType));
3137
NDR_CHECK(ndr_pull_AuthInfo(ndr, NDR_SCALARS, &r->AuthInfo));
3138
{
3139
uint32_t _flags_save_DATA_BLOB = ndr->flags;
3140
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3141
NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
3142
ndr->flags = _flags_save_DATA_BLOB;
3143
}
3144
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3145
}
3146
if (ndr_flags & NDR_BUFFERS) {
3147
}
3148
return NDR_ERR_SUCCESS;
3149
}
3150
3151
_PUBLIC_ void ndr_print_AuthenticationInformation(struct ndr_print *ndr, const char *name, const struct AuthenticationInformation *r)
3152
{
3153
ndr_print_struct(ndr, name, "AuthenticationInformation");
3154
if (r == NULL) { ndr_print_null(ndr); return; }
3155
ndr->depth++;
3156
ndr_print_NTTIME(ndr, "LastUpdateTime", r->LastUpdateTime);
3157
ndr_print_lsa_TrustAuthType(ndr, "AuthType", r->AuthType);
3158
ndr_print_set_switch_value(ndr, &r->AuthInfo, r->AuthType);
3159
ndr_print_AuthInfo(ndr, "AuthInfo", &r->AuthInfo);
3160
ndr_print_DATA_BLOB(ndr, "_pad", r->_pad);
3161
ndr->depth--;
3162
}
3163
3164
_PUBLIC_ void ndr_print_AuthenticationInformationArray(struct ndr_print *ndr, const char *name, const struct AuthenticationInformationArray *r)
3165
{
3166
uint32_t cntr_array_0;
3167
ndr_print_struct(ndr, name, "AuthenticationInformationArray");
3168
if (r == NULL) { ndr_print_null(ndr); return; }
3169
ndr->depth++;
3170
ndr_print_uint32(ndr, "count", r->count);
3171
ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
3172
ndr->depth++;
3173
for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
3174
ndr_print_AuthenticationInformation(ndr, "array", &r->array[cntr_array_0]);
3175
}
3176
ndr->depth--;
3177
ndr->depth--;
3178
}
3179
3180
_PUBLIC_ size_t ndr_size_AuthenticationInformationArray(const struct AuthenticationInformationArray *r, int flags)
3181
{
3182
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_AuthenticationInformationArray);
3183
}
3184
3185
_PUBLIC_ enum ndr_err_code ndr_pull_trustAuthInOutBlob(struct ndr_pull *ndr, int ndr_flags, struct trustAuthInOutBlob *r)
3186
{
3187
if (ndr_flags & NDR_SCALARS) {
3188
NDR_CHECK(ndr_pull_align(ndr, 4));
3189
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
3190
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->current_offset));
3191
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->previous_offset));
3192
{
3193
struct ndr_pull *_ndr_current;
3194
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_current, 0, (r->previous_offset) - (r->current_offset)));
3195
NDR_CHECK(ndr_pull_AuthenticationInformationArray(_ndr_current, NDR_SCALARS, &r->current));
3196
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_current, 0, (r->previous_offset) - (r->current_offset)));
3197
}
3198
{
3199
uint32_t _flags_save_AuthenticationInformationArray = ndr->flags;
3200
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
3201
{
3202
struct ndr_pull *_ndr_previous;
3203
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_previous, 0, -1));
3204
NDR_CHECK(ndr_pull_AuthenticationInformationArray(_ndr_previous, NDR_SCALARS, &r->previous));
3205
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_previous, 0, -1));
3206
}
3207
ndr->flags = _flags_save_AuthenticationInformationArray;
3208
}
3209
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3210
}
3211
if (ndr_flags & NDR_BUFFERS) {
3212
}
3213
return NDR_ERR_SUCCESS;
3214
}
3215
3216
_PUBLIC_ void ndr_print_trustAuthInOutBlob(struct ndr_print *ndr, const char *name, const struct trustAuthInOutBlob *r)
3217
{
3218
ndr_print_struct(ndr, name, "trustAuthInOutBlob");
3219
if (r == NULL) { ndr_print_null(ndr); return; }
3220
ndr->depth++;
3221
ndr_print_uint32(ndr, "count", r->count);
3222
ndr_print_uint32(ndr, "current_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->count > 0)?12:0:r->current_offset);
3223
ndr_print_uint32(ndr, "previous_offset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, ndr->flags):0:r->previous_offset);
3224
ndr_print_AuthenticationInformationArray(ndr, "current", &r->current);
3225
ndr_print_AuthenticationInformationArray(ndr, "previous", &r->previous);
3226
ndr->depth--;
3227
}
3228
3229
_PUBLIC_ size_t ndr_size_trustAuthInOutBlob(const struct trustAuthInOutBlob *r, int flags)
3230
{
3231
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
3232
}
3233
3234
_PUBLIC_ enum ndr_err_code ndr_push_trustDomainPasswords(struct ndr_push *ndr, int ndr_flags, const struct trustDomainPasswords *r)
3235
{
3236
if (ndr_flags & NDR_SCALARS) {
3237
NDR_CHECK(ndr_push_align(ndr, 4));
3238
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->confounder, 512));
3239
{
3240
struct ndr_push *_ndr_outgoing;
3241
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_outgoing, 0, ndr_size_trustAuthInOutBlob(&r->outgoing, ndr->flags)));
3242
NDR_CHECK(ndr_push_trustAuthInOutBlob(_ndr_outgoing, NDR_SCALARS, &r->outgoing));
3243
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_outgoing, 0, ndr_size_trustAuthInOutBlob(&r->outgoing, ndr->flags)));
3244
}
3245
{
3246
struct ndr_push *_ndr_incoming;
3247
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_incoming, 0, ndr_size_trustAuthInOutBlob(&r->incoming, ndr->flags)));
3248
NDR_CHECK(ndr_push_trustAuthInOutBlob(_ndr_incoming, NDR_SCALARS, &r->incoming));
3249
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_incoming, 0, ndr_size_trustAuthInOutBlob(&r->incoming, ndr->flags)));
3250
}
3251
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustAuthInOutBlob(&r->outgoing, ndr->flags)));
3252
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_trustAuthInOutBlob(&r->incoming, ndr->flags)));
3253
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3254
}
3255
if (ndr_flags & NDR_BUFFERS) {
3256
}
3257
return NDR_ERR_SUCCESS;
3258
}
3259
3260
_PUBLIC_ void ndr_print_trustDomainPasswords(struct ndr_print *ndr, const char *name, const struct trustDomainPasswords *r)
3261
{
3262
ndr_print_struct(ndr, name, "trustDomainPasswords");
3263
if (r == NULL) { ndr_print_null(ndr); return; }
3264
ndr->depth++;
3265
ndr_print_array_uint8(ndr, "confounder", r->confounder, 512);
3266
ndr_print_trustAuthInOutBlob(ndr, "outgoing", &r->outgoing);
3267
ndr_print_trustAuthInOutBlob(ndr, "incoming", &r->incoming);
3268
ndr_print_uint32(ndr, "outgoing_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_trustAuthInOutBlob(&r->outgoing, ndr->flags):r->outgoing_size);
3269
ndr_print_uint32(ndr, "incoming_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_trustAuthInOutBlob(&r->incoming, ndr->flags):r->incoming_size);
3270
ndr->depth--;
3271
}
3272
3273
_PUBLIC_ enum ndr_err_code ndr_push_DsCompressedChunk(struct ndr_push *ndr, int ndr_flags, const struct DsCompressedChunk *r)
3274
{
3275
if (ndr_flags & NDR_SCALARS) {
3276
NDR_CHECK(ndr_push_align(ndr, 4));
3277
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->marker));
3278
NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
3279
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
3280
}
3281
if (ndr_flags & NDR_BUFFERS) {
3282
}
3283
return NDR_ERR_SUCCESS;
3284
}
3285
3286
_PUBLIC_ enum ndr_err_code ndr_pull_DsCompressedChunk(struct ndr_pull *ndr, int ndr_flags, struct DsCompressedChunk *r)
3287
{
3288
if (ndr_flags & NDR_SCALARS) {
3289
NDR_CHECK(ndr_pull_align(ndr, 4));
3290
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->marker));
3291
NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
3292
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
3293
}
3294
if (ndr_flags & NDR_BUFFERS) {
3295
}
3296
return NDR_ERR_SUCCESS;
3297
}
3298
3299
_PUBLIC_ void ndr_print_DsCompressedChunk(struct ndr_print *ndr, const char *name, const struct DsCompressedChunk *r)
3300
{
3301
ndr_print_struct(ndr, name, "DsCompressedChunk");
3302
if (r == NULL) { ndr_print_null(ndr); return; }
3303
ndr->depth++;
3304
ndr_print_uint32(ndr, "marker", r->marker);
3305
ndr_print_DATA_BLOB(ndr, "data", r->data);
3306
ndr->depth--;
3307
}
3308
3309
static enum ndr_err_code ndr_push_ExtendedErrorAString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorAString *r)
3310
{
3311
if (ndr_flags & NDR_SCALARS) {
3312
NDR_CHECK(ndr_push_align(ndr, 5));
3313
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3314
NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3315
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3316
}
3317
if (ndr_flags & NDR_BUFFERS) {
3318
if (r->string) {
3319
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3320
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint8_t), CH_DOS));
3321
}
3322
}
3323
return NDR_ERR_SUCCESS;
3324
}
3325
3326
static enum ndr_err_code ndr_pull_ExtendedErrorAString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorAString *r)
3327
{
3328
uint32_t _ptr_string;
3329
TALLOC_CTX *_mem_save_string_0;
3330
if (ndr_flags & NDR_SCALARS) {
3331
NDR_CHECK(ndr_pull_align(ndr, 5));
3332
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3333
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3334
if (_ptr_string) {
3335
NDR_PULL_ALLOC(ndr, r->string);
3336
} else {
3337
r->string = NULL;
3338
}
3339
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3340
}
3341
if (ndr_flags & NDR_BUFFERS) {
3342
if (r->string) {
3343
_mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344
NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3345
NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3346
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint8_t), CH_DOS));
3347
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3348
}
3349
if (r->string) {
3350
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3351
}
3352
}
3353
return NDR_ERR_SUCCESS;
3354
}
3355
3356
_PUBLIC_ void ndr_print_ExtendedErrorAString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorAString *r)
3357
{
3358
ndr_print_struct(ndr, name, "ExtendedErrorAString");
3359
if (r == NULL) { ndr_print_null(ndr); return; }
3360
ndr->depth++;
3361
ndr_print_uint16(ndr, "__size", r->__size);
3362
ndr_print_ptr(ndr, "string", r->string);
3363
ndr->depth++;
3364
if (r->string) {
3365
ndr_print_string(ndr, "string", r->string);
3366
}
3367
ndr->depth--;
3368
ndr->depth--;
3369
}
3370
3371
static enum ndr_err_code ndr_push_ExtendedErrorUString(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorUString *r)
3372
{
3373
if (ndr_flags & NDR_SCALARS) {
3374
NDR_CHECK(ndr_push_align(ndr, 5));
3375
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->__size));
3376
NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
3377
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3378
}
3379
if (ndr_flags & NDR_BUFFERS) {
3380
if (r->string) {
3381
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->__size));
3382
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->__size, sizeof(uint16_t), CH_UTF16));
3383
}
3384
}
3385
return NDR_ERR_SUCCESS;
3386
}
3387
3388
static enum ndr_err_code ndr_pull_ExtendedErrorUString(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorUString *r)
3389
{
3390
uint32_t _ptr_string;
3391
TALLOC_CTX *_mem_save_string_0;
3392
if (ndr_flags & NDR_SCALARS) {
3393
NDR_CHECK(ndr_pull_align(ndr, 5));
3394
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__size));
3395
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
3396
if (_ptr_string) {
3397
NDR_PULL_ALLOC(ndr, r->string);
3398
} else {
3399
r->string = NULL;
3400
}
3401
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3402
}
3403
if (ndr_flags & NDR_BUFFERS) {
3404
if (r->string) {
3405
_mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
3406
NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
3407
NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
3408
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
3409
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
3410
}
3411
if (r->string) {
3412
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->__size));
3413
}
3414
}
3415
return NDR_ERR_SUCCESS;
3416
}
3417
3418
_PUBLIC_ void ndr_print_ExtendedErrorUString(struct ndr_print *ndr, const char *name, const struct ExtendedErrorUString *r)
3419
{
3420
ndr_print_struct(ndr, name, "ExtendedErrorUString");
3421
if (r == NULL) { ndr_print_null(ndr); return; }
3422
ndr->depth++;
3423
ndr_print_uint16(ndr, "__size", r->__size);
3424
ndr_print_ptr(ndr, "string", r->string);
3425
ndr->depth++;
3426
if (r->string) {
3427
ndr_print_string(ndr, "string", r->string);
3428
}
3429
ndr->depth--;
3430
ndr->depth--;
3431
}
3432
3433
static enum ndr_err_code ndr_push_ExtendedErrorBlob(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorBlob *r)
3434
{
3435
if (ndr_flags & NDR_SCALARS) {
3436
NDR_CHECK(ndr_push_align(ndr, 5));
3437
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->length));
3438
NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
3439
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3440
}
3441
if (ndr_flags & NDR_BUFFERS) {
3442
if (r->data) {
3443
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
3444
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
3445
}
3446
}
3447
return NDR_ERR_SUCCESS;
3448
}
3449
3450
static enum ndr_err_code ndr_pull_ExtendedErrorBlob(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorBlob *r)
3451
{
3452
uint32_t _ptr_data;
3453
TALLOC_CTX *_mem_save_data_0;
3454
if (ndr_flags & NDR_SCALARS) {
3455
NDR_CHECK(ndr_pull_align(ndr, 5));
3456
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->length));
3457
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
3458
if (_ptr_data) {
3459
NDR_PULL_ALLOC(ndr, r->data);
3460
} else {
3461
r->data = NULL;
3462
}
3463
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3464
}
3465
if (ndr_flags & NDR_BUFFERS) {
3466
if (r->data) {
3467
_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
3468
NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
3469
NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
3470
NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
3471
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
3472
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
3473
}
3474
if (r->data) {
3475
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
3476
}
3477
}
3478
return NDR_ERR_SUCCESS;
3479
}
3480
3481
_PUBLIC_ void ndr_print_ExtendedErrorBlob(struct ndr_print *ndr, const char *name, const struct ExtendedErrorBlob *r)
3482
{
3483
ndr_print_struct(ndr, name, "ExtendedErrorBlob");
3484
if (r == NULL) { ndr_print_null(ndr); return; }
3485
ndr->depth++;
3486
ndr_print_uint16(ndr, "length", r->length);
3487
ndr_print_ptr(ndr, "data", r->data);
3488
ndr->depth++;
3489
if (r->data) {
3490
ndr_print_array_uint8(ndr, "data", r->data, r->length);
3491
}
3492
ndr->depth--;
3493
ndr->depth--;
3494
}
3495
3496
static enum ndr_err_code ndr_push_ExtendedErrorComputerNamePresent(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent r)
3497
{
3498
NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3499
return NDR_ERR_SUCCESS;
3500
}
3501
3502
static enum ndr_err_code ndr_pull_ExtendedErrorComputerNamePresent(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorComputerNamePresent *r)
3503
{
3504
uint16_t v;
3505
NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3506
*r = v;
3507
return NDR_ERR_SUCCESS;
3508
}
3509
3510
_PUBLIC_ void ndr_print_ExtendedErrorComputerNamePresent(struct ndr_print *ndr, const char *name, enum ExtendedErrorComputerNamePresent r)
3511
{
3512
const char *val = NULL;
3513
3514
switch (r) {
3515
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_PRESENT"; break;
3516
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: val = "EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT"; break;
3517
}
3518
ndr_print_enum(ndr, name, "ENUM", val, r);
3519
}
3520
3521
static enum ndr_err_code ndr_push_ExtendedErrorComputerNameU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorComputerNameU *r)
3522
{
3523
if (ndr_flags & NDR_SCALARS) {
3524
uint32_t level = ndr_push_get_switch_value(ndr, r);
3525
NDR_CHECK(ndr_push_union_align(ndr, 5));
3526
NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, level));
3527
NDR_CHECK(ndr_push_union_align(ndr, 5));
3528
switch (level) {
3529
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3530
NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3531
break; }
3532
3533
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3534
break; }
3535
3536
default:
3537
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3538
}
3539
}
3540
if (ndr_flags & NDR_BUFFERS) {
3541
uint32_t level = ndr_push_get_switch_value(ndr, r);
3542
switch (level) {
3543
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3544
NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3545
break;
3546
3547
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3548
break;
3549
3550
default:
3551
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3552
}
3553
}
3554
return NDR_ERR_SUCCESS;
3555
}
3556
3557
static enum ndr_err_code ndr_pull_ExtendedErrorComputerNameU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorComputerNameU *r)
3558
{
3559
uint32_t level;
3560
uint16_t _level;
3561
level = ndr_pull_get_switch_value(ndr, r);
3562
if (ndr_flags & NDR_SCALARS) {
3563
NDR_CHECK(ndr_pull_union_align(ndr, 5));
3564
NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3565
if (_level != level) {
3566
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3567
}
3568
NDR_CHECK(ndr_pull_union_align(ndr, 5));
3569
switch (level) {
3570
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT: {
3571
NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->name));
3572
break; }
3573
3574
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT: {
3575
break; }
3576
3577
default:
3578
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3579
}
3580
}
3581
if (ndr_flags & NDR_BUFFERS) {
3582
switch (level) {
3583
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3584
NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->name));
3585
break;
3586
3587
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3588
break;
3589
3590
default:
3591
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3592
}
3593
}
3594
return NDR_ERR_SUCCESS;
3595
}
3596
3597
_PUBLIC_ void ndr_print_ExtendedErrorComputerNameU(struct ndr_print *ndr, const char *name, const union ExtendedErrorComputerNameU *r)
3598
{
3599
uint32_t level;
3600
level = ndr_print_get_switch_value(ndr, r);
3601
ndr_print_union(ndr, name, level, "ExtendedErrorComputerNameU");
3602
switch (level) {
3603
case EXTENDED_ERROR_COMPUTER_NAME_PRESENT:
3604
ndr_print_ExtendedErrorUString(ndr, "name", &r->name);
3605
break;
3606
3607
case EXTENDED_ERROR_COMPUTER_NAME_NOT_PRESENT:
3608
break;
3609
3610
default:
3611
ndr_print_bad_level(ndr, name, level);
3612
}
3613
}
3614
3615
static enum ndr_err_code ndr_push_ExtendedErrorComputerName(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorComputerName *r)
3616
{
3617
if (ndr_flags & NDR_SCALARS) {
3618
NDR_CHECK(ndr_push_align(ndr, 5));
3619
NDR_CHECK(ndr_push_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, r->present));
3620
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->n, r->present));
3621
NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3622
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3623
}
3624
if (ndr_flags & NDR_BUFFERS) {
3625
NDR_CHECK(ndr_push_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3626
}
3627
return NDR_ERR_SUCCESS;
3628
}
3629
3630
static enum ndr_err_code ndr_pull_ExtendedErrorComputerName(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorComputerName *r)
3631
{
3632
if (ndr_flags & NDR_SCALARS) {
3633
NDR_CHECK(ndr_pull_align(ndr, 5));
3634
NDR_CHECK(ndr_pull_ExtendedErrorComputerNamePresent(ndr, NDR_SCALARS, &r->present));
3635
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->n, r->present));
3636
NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_SCALARS, &r->n));
3637
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3638
}
3639
if (ndr_flags & NDR_BUFFERS) {
3640
NDR_CHECK(ndr_pull_ExtendedErrorComputerNameU(ndr, NDR_BUFFERS, &r->n));
3641
}
3642
return NDR_ERR_SUCCESS;
3643
}
3644
3645
_PUBLIC_ void ndr_print_ExtendedErrorComputerName(struct ndr_print *ndr, const char *name, const struct ExtendedErrorComputerName *r)
3646
{
3647
ndr_print_struct(ndr, name, "ExtendedErrorComputerName");
3648
if (r == NULL) { ndr_print_null(ndr); return; }
3649
ndr->depth++;
3650
ndr_print_ExtendedErrorComputerNamePresent(ndr, "present", r->present);
3651
ndr_print_set_switch_value(ndr, &r->n, r->present);
3652
ndr_print_ExtendedErrorComputerNameU(ndr, "n", &r->n);
3653
ndr->depth--;
3654
}
3655
3656
static enum ndr_err_code ndr_push_ExtendedErrorParamType(struct ndr_push *ndr, int ndr_flags, enum ExtendedErrorParamType r)
3657
{
3658
NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
3659
return NDR_ERR_SUCCESS;
3660
}
3661
3662
static enum ndr_err_code ndr_pull_ExtendedErrorParamType(struct ndr_pull *ndr, int ndr_flags, enum ExtendedErrorParamType *r)
3663
{
3664
uint16_t v;
3665
NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
3666
*r = v;
3667
return NDR_ERR_SUCCESS;
3668
}
3669
3670
_PUBLIC_ void ndr_print_ExtendedErrorParamType(struct ndr_print *ndr, const char *name, enum ExtendedErrorParamType r)
3671
{
3672
const char *val = NULL;
3673
3674
switch (r) {
3675
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING"; break;
3676
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: val = "EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING"; break;
3677
case EXTENDED_ERROR_PARAM_TYPE_UINT32: val = "EXTENDED_ERROR_PARAM_TYPE_UINT32"; break;
3678
case EXTENDED_ERROR_PARAM_TYPE_UINT16: val = "EXTENDED_ERROR_PARAM_TYPE_UINT16"; break;
3679
case EXTENDED_ERROR_PARAM_TYPE_UINT64: val = "EXTENDED_ERROR_PARAM_TYPE_UINT64"; break;
3680
case EXTENDED_ERROR_PARAM_TYPE_NONE: val = "EXTENDED_ERROR_PARAM_TYPE_NONE"; break;
3681
case EXTENDED_ERROR_PARAM_TYPE_BLOB: val = "EXTENDED_ERROR_PARAM_TYPE_BLOB"; break;
3682
}
3683
ndr_print_enum(ndr, name, "ENUM", val, r);
3684
}
3685
3686
static enum ndr_err_code ndr_push_ExtendedErrorParamU(struct ndr_push *ndr, int ndr_flags, const union ExtendedErrorParamU *r)
3687
{
3688
if (ndr_flags & NDR_SCALARS) {
3689
uint32_t level = ndr_push_get_switch_value(ndr, r);
3690
NDR_CHECK(ndr_push_union_align(ndr, 8));
3691
NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, level));
3692
NDR_CHECK(ndr_push_union_align(ndr, 8));
3693
switch (level) {
3694
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3695
NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3696
break; }
3697
3698
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3699
NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3700
break; }
3701
3702
case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3703
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->uint32));
3704
break; }
3705
3706
case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3707
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->uint16));
3708
break; }
3709
3710
case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3711
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uint64));
3712
break; }
3713
3714
case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3715
break; }
3716
3717
case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3718
NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3719
break; }
3720
3721
default:
3722
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3723
}
3724
}
3725
if (ndr_flags & NDR_BUFFERS) {
3726
uint32_t level = ndr_push_get_switch_value(ndr, r);
3727
switch (level) {
3728
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3729
NDR_CHECK(ndr_push_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3730
break;
3731
3732
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3733
NDR_CHECK(ndr_push_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3734
break;
3735
3736
case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3737
break;
3738
3739
case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3740
break;
3741
3742
case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3743
break;
3744
3745
case EXTENDED_ERROR_PARAM_TYPE_NONE:
3746
break;
3747
3748
case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3749
NDR_CHECK(ndr_push_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3750
break;
3751
3752
default:
3753
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3754
}
3755
}
3756
return NDR_ERR_SUCCESS;
3757
}
3758
3759
static enum ndr_err_code ndr_pull_ExtendedErrorParamU(struct ndr_pull *ndr, int ndr_flags, union ExtendedErrorParamU *r)
3760
{
3761
uint32_t level;
3762
uint16_t _level;
3763
level = ndr_pull_get_switch_value(ndr, r);
3764
if (ndr_flags & NDR_SCALARS) {
3765
NDR_CHECK(ndr_pull_union_align(ndr, 8));
3766
NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
3767
if (_level != level) {
3768
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3769
}
3770
NDR_CHECK(ndr_pull_union_align(ndr, 8));
3771
switch (level) {
3772
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING: {
3773
NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_SCALARS, &r->a_string));
3774
break; }
3775
3776
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING: {
3777
NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_SCALARS, &r->u_string));
3778
break; }
3779
3780
case EXTENDED_ERROR_PARAM_TYPE_UINT32: {
3781
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->uint32));
3782
break; }
3783
3784
case EXTENDED_ERROR_PARAM_TYPE_UINT16: {
3785
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->uint16));
3786
break; }
3787
3788
case EXTENDED_ERROR_PARAM_TYPE_UINT64: {
3789
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uint64));
3790
break; }
3791
3792
case EXTENDED_ERROR_PARAM_TYPE_NONE: {
3793
break; }
3794
3795
case EXTENDED_ERROR_PARAM_TYPE_BLOB: {
3796
NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_SCALARS, &r->blob));
3797
break; }
3798
3799
default:
3800
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3801
}
3802
}
3803
if (ndr_flags & NDR_BUFFERS) {
3804
switch (level) {
3805
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3806
NDR_CHECK(ndr_pull_ExtendedErrorAString(ndr, NDR_BUFFERS, &r->a_string));
3807
break;
3808
3809
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3810
NDR_CHECK(ndr_pull_ExtendedErrorUString(ndr, NDR_BUFFERS, &r->u_string));
3811
break;
3812
3813
case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3814
break;
3815
3816
case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3817
break;
3818
3819
case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3820
break;
3821
3822
case EXTENDED_ERROR_PARAM_TYPE_NONE:
3823
break;
3824
3825
case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3826
NDR_CHECK(ndr_pull_ExtendedErrorBlob(ndr, NDR_BUFFERS, &r->blob));
3827
break;
3828
3829
default:
3830
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3831
}
3832
}
3833
return NDR_ERR_SUCCESS;
3834
}
3835
3836
_PUBLIC_ void ndr_print_ExtendedErrorParamU(struct ndr_print *ndr, const char *name, const union ExtendedErrorParamU *r)
3837
{
3838
uint32_t level;
3839
level = ndr_print_get_switch_value(ndr, r);
3840
ndr_print_union(ndr, name, level, "ExtendedErrorParamU");
3841
switch (level) {
3842
case EXTENDED_ERROR_PARAM_TYPE_ASCII_STRING:
3843
ndr_print_ExtendedErrorAString(ndr, "a_string", &r->a_string);
3844
break;
3845
3846
case EXTENDED_ERROR_PARAM_TYPE_UNICODE_STRING:
3847
ndr_print_ExtendedErrorUString(ndr, "u_string", &r->u_string);
3848
break;
3849
3850
case EXTENDED_ERROR_PARAM_TYPE_UINT32:
3851
ndr_print_uint32(ndr, "uint32", r->uint32);
3852
break;
3853
3854
case EXTENDED_ERROR_PARAM_TYPE_UINT16:
3855
ndr_print_uint16(ndr, "uint16", r->uint16);
3856
break;
3857
3858
case EXTENDED_ERROR_PARAM_TYPE_UINT64:
3859
ndr_print_hyper(ndr, "uint64", r->uint64);
3860
break;
3861
3862
case EXTENDED_ERROR_PARAM_TYPE_NONE:
3863
break;
3864
3865
case EXTENDED_ERROR_PARAM_TYPE_BLOB:
3866
ndr_print_ExtendedErrorBlob(ndr, "blob", &r->blob);
3867
break;
3868
3869
default:
3870
ndr_print_bad_level(ndr, name, level);
3871
}
3872
}
3873
3874
static enum ndr_err_code ndr_push_ExtendedErrorParam(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorParam *r)
3875
{
3876
if (ndr_flags & NDR_SCALARS) {
3877
NDR_CHECK(ndr_push_align(ndr, 8));
3878
NDR_CHECK(ndr_push_ExtendedErrorParamType(ndr, NDR_SCALARS, r->type));
3879
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->p, r->type));
3880
NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3881
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3882
}
3883
if (ndr_flags & NDR_BUFFERS) {
3884
NDR_CHECK(ndr_push_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3885
}
3886
return NDR_ERR_SUCCESS;
3887
}
3888
3889
static enum ndr_err_code ndr_pull_ExtendedErrorParam(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorParam *r)
3890
{
3891
if (ndr_flags & NDR_SCALARS) {
3892
NDR_CHECK(ndr_pull_align(ndr, 8));
3893
NDR_CHECK(ndr_pull_ExtendedErrorParamType(ndr, NDR_SCALARS, &r->type));
3894
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->p, r->type));
3895
NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_SCALARS, &r->p));
3896
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3897
}
3898
if (ndr_flags & NDR_BUFFERS) {
3899
NDR_CHECK(ndr_pull_ExtendedErrorParamU(ndr, NDR_BUFFERS, &r->p));
3900
}
3901
return NDR_ERR_SUCCESS;
3902
}
3903
3904
_PUBLIC_ void ndr_print_ExtendedErrorParam(struct ndr_print *ndr, const char *name, const struct ExtendedErrorParam *r)
3905
{
3906
ndr_print_struct(ndr, name, "ExtendedErrorParam");
3907
if (r == NULL) { ndr_print_null(ndr); return; }
3908
ndr->depth++;
3909
ndr_print_ExtendedErrorParamType(ndr, "type", r->type);
3910
ndr_print_set_switch_value(ndr, &r->p, r->type);
3911
ndr_print_ExtendedErrorParamU(ndr, "p", &r->p);
3912
ndr->depth--;
3913
}
3914
3915
_PUBLIC_ enum ndr_err_code ndr_push_ExtendedErrorInfo(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfo *r)
3916
{
3917
uint32_t cntr_params_0;
3918
if (ndr_flags & NDR_SCALARS) {
3919
NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_params));
3920
NDR_CHECK(ndr_push_align(ndr, 8));
3921
NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
3922
NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
3923
NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->pid));
3924
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
3925
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->generating_component));
3926
NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
3927
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->detection_location));
3928
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->flags));
3929
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_params));
3930
for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3931
NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
3932
}
3933
NDR_CHECK(ndr_push_trailer_align(ndr, 8));
3934
}
3935
if (ndr_flags & NDR_BUFFERS) {
3936
if (r->next) {
3937
NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
3938
}
3939
NDR_CHECK(ndr_push_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
3940
for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3941
NDR_CHECK(ndr_push_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
3942
}
3943
}
3944
return NDR_ERR_SUCCESS;
3945
}
3946
3947
_PUBLIC_ enum ndr_err_code ndr_pull_ExtendedErrorInfo(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfo *r)
3948
{
3949
uint32_t _ptr_next;
3950
TALLOC_CTX *_mem_save_next_0;
3951
uint32_t cntr_params_0;
3952
TALLOC_CTX *_mem_save_params_0;
3953
if (ndr_flags & NDR_SCALARS) {
3954
NDR_CHECK(ndr_pull_array_size(ndr, &r->params));
3955
NDR_CHECK(ndr_pull_align(ndr, 8));
3956
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
3957
if (_ptr_next) {
3958
NDR_PULL_ALLOC(ndr, r->next);
3959
} else {
3960
r->next = NULL;
3961
}
3962
NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_SCALARS, &r->computer_name));
3963
NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->pid));
3964
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
3965
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->generating_component));
3966
NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
3967
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->detection_location));
3968
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->flags));
3969
NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_params));
3970
NDR_PULL_ALLOC_N(ndr, r->params, ndr_get_array_size(ndr, &r->params));
3971
_mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972
NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
3973
for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3974
NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_SCALARS, &r->params[cntr_params_0]));
3975
}
3976
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
3977
if (r->params) {
3978
NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->params, r->num_params));
3979
}
3980
NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3981
}
3982
if (ndr_flags & NDR_BUFFERS) {
3983
if (r->next) {
3984
_mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
3985
NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
3986
NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
3987
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
3988
}
3989
NDR_CHECK(ndr_pull_ExtendedErrorComputerName(ndr, NDR_BUFFERS, &r->computer_name));
3990
_mem_save_params_0 = NDR_PULL_GET_MEM_CTX(ndr);
3991
NDR_PULL_SET_MEM_CTX(ndr, r->params, 0);
3992
for (cntr_params_0 = 0; cntr_params_0 < r->num_params; cntr_params_0++) {
3993
NDR_CHECK(ndr_pull_ExtendedErrorParam(ndr, NDR_BUFFERS, &r->params[cntr_params_0]));
3994
}
3995
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_params_0, 0);
3996
}
3997
return NDR_ERR_SUCCESS;
3998
}
3999
4000
_PUBLIC_ void ndr_print_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfo *r)
4001
{
4002
uint32_t cntr_params_0;
4003
ndr_print_struct(ndr, name, "ExtendedErrorInfo");
4004
if (r == NULL) { ndr_print_null(ndr); return; }
4005
ndr->depth++;
4006
ndr_print_ptr(ndr, "next", r->next);
4007
ndr->depth++;
4008
if (r->next) {
4009
ndr_print_ExtendedErrorInfo(ndr, "next", r->next);
4010
}
4011
ndr->depth--;
4012
ndr_print_ExtendedErrorComputerName(ndr, "computer_name", &r->computer_name);
4013
ndr_print_hyper(ndr, "pid", r->pid);
4014
ndr_print_NTTIME(ndr, "time", r->time);
4015
ndr_print_uint32(ndr, "generating_component", r->generating_component);
4016
ndr_print_WERROR(ndr, "status", r->status);
4017
ndr_print_uint16(ndr, "detection_location", r->detection_location);
4018
ndr_print_uint16(ndr, "flags", r->flags);
4019
ndr_print_uint16(ndr, "num_params", r->num_params);
4020
ndr->print(ndr, "%s: ARRAY(%d)", "params", (int)r->num_params);
4021
ndr->depth++;
4022
for (cntr_params_0=0;cntr_params_0<r->num_params;cntr_params_0++) {
4023
ndr_print_ExtendedErrorParam(ndr, "params", &r->params[cntr_params_0]);
4024
}
4025
ndr->depth--;
4026
ndr->depth--;
4027
}
4028
4029
static enum ndr_err_code ndr_push_ExtendedErrorInfoPtr(struct ndr_push *ndr, int ndr_flags, const struct ExtendedErrorInfoPtr *r)
4030
{
4031
if (ndr_flags & NDR_SCALARS) {
4032
NDR_CHECK(ndr_push_align(ndr, 5));
4033
NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
4034
NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4035
}
4036
if (ndr_flags & NDR_BUFFERS) {
4037
if (r->info) {
4038
NDR_CHECK(ndr_push_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4039
}
4040
}
4041
return NDR_ERR_SUCCESS;
4042
}
4043
4044
static enum ndr_err_code ndr_pull_ExtendedErrorInfoPtr(struct ndr_pull *ndr, int ndr_flags, struct ExtendedErrorInfoPtr *r)
4045
{
4046
uint32_t _ptr_info;
4047
TALLOC_CTX *_mem_save_info_0;
4048
if (ndr_flags & NDR_SCALARS) {
4049
NDR_CHECK(ndr_pull_align(ndr, 5));
4050
NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4051
if (_ptr_info) {
4052
NDR_PULL_ALLOC(ndr, r->info);
4053
} else {
4054
r->info = NULL;
4055
}
4056
NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4057
}
4058
if (ndr_flags & NDR_BUFFERS) {
4059
if (r->info) {
4060
_mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4061
NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
4062
NDR_CHECK(ndr_pull_ExtendedErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
4063
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4064
}
4065
}
4066
return NDR_ERR_SUCCESS;
4067
}
4068
4069
_PUBLIC_ void ndr_print_ExtendedErrorInfoPtr(struct ndr_print *ndr, const char *name, const struct ExtendedErrorInfoPtr *r)
4070
{
4071
ndr_print_struct(ndr, name, "ExtendedErrorInfoPtr");
4072
if (r == NULL) { ndr_print_null(ndr); return; }
4073
ndr->depth++;
4074
ndr_print_ptr(ndr, "info", r->info);
4075
ndr->depth++;
4076
if (r->info) {
4077
ndr_print_ExtendedErrorInfo(ndr, "info", r->info);
4078
}
4079
ndr->depth--;
4080
ndr->depth--;
4081
}
4082
4083
static enum ndr_err_code ndr_push_ForestTrustString(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustString *r)
4084
{
4085
if (ndr_flags & NDR_SCALARS) {
4086
NDR_CHECK(ndr_push_align(ndr, 4));
4087
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->string)));
4088
NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, strlen_m(r->string), sizeof(uint8_t), CH_UTF8));
4089
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4090
}
4091
if (ndr_flags & NDR_BUFFERS) {
4092
}
4093
return NDR_ERR_SUCCESS;
4094
}
4095
4096
static enum ndr_err_code ndr_pull_ForestTrustString(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustString *r)
4097
{
4098
if (ndr_flags & NDR_SCALARS) {
4099
NDR_CHECK(ndr_pull_align(ndr, 4));
4100
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4101
NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, r->size, sizeof(uint8_t), CH_UTF8));
4102
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4103
}
4104
if (ndr_flags & NDR_BUFFERS) {
4105
}
4106
return NDR_ERR_SUCCESS;
4107
}
4108
4109
_PUBLIC_ void ndr_print_ForestTrustString(struct ndr_print *ndr, const char *name, const struct ForestTrustString *r)
4110
{
4111
ndr_print_struct(ndr, name, "ForestTrustString");
4112
if (r == NULL) { ndr_print_null(ndr); return; }
4113
ndr->depth++;
4114
ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->string):r->size);
4115
ndr_print_string(ndr, "string", r->string);
4116
ndr->depth--;
4117
}
4118
4119
static enum ndr_err_code ndr_push_ForestTrustDataDomainInfo(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustDataDomainInfo *r)
4120
{
4121
{
4122
uint32_t _flags_save_STRUCT = ndr->flags;
4123
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4124
if (ndr_flags & NDR_SCALARS) {
4125
NDR_CHECK(ndr_push_align(ndr, 4));
4126
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4127
{
4128
struct ndr_push *_ndr_sid;
4129
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4130
NDR_CHECK(ndr_push_dom_sid(_ndr_sid, NDR_SCALARS, &r->sid));
4131
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sid, 0, ndr_size_dom_sid0(&r->sid, ndr->flags)));
4132
}
4133
NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->dns_name));
4134
NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->netbios_name));
4135
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4136
}
4137
if (ndr_flags & NDR_BUFFERS) {
4138
}
4139
ndr->flags = _flags_save_STRUCT;
4140
}
4141
return NDR_ERR_SUCCESS;
4142
}
4143
4144
static enum ndr_err_code ndr_pull_ForestTrustDataDomainInfo(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustDataDomainInfo *r)
4145
{
4146
{
4147
uint32_t _flags_save_STRUCT = ndr->flags;
4148
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4149
if (ndr_flags & NDR_SCALARS) {
4150
NDR_CHECK(ndr_pull_align(ndr, 4));
4151
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sid_size));
4152
{
4153
struct ndr_pull *_ndr_sid;
4154
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sid, 0, r->sid_size));
4155
NDR_CHECK(ndr_pull_dom_sid(_ndr_sid, NDR_SCALARS, &r->sid));
4156
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sid, 0, r->sid_size));
4157
}
4158
NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->dns_name));
4159
NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->netbios_name));
4160
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4161
}
4162
if (ndr_flags & NDR_BUFFERS) {
4163
}
4164
ndr->flags = _flags_save_STRUCT;
4165
}
4166
return NDR_ERR_SUCCESS;
4167
}
4168
4169
_PUBLIC_ void ndr_print_ForestTrustDataDomainInfo(struct ndr_print *ndr, const char *name, const struct ForestTrustDataDomainInfo *r)
4170
{
4171
ndr_print_struct(ndr, name, "ForestTrustDataDomainInfo");
4172
if (r == NULL) { ndr_print_null(ndr); return; }
4173
{
4174
uint32_t _flags_save_STRUCT = ndr->flags;
4175
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4176
ndr->depth++;
4177
ndr_print_uint32(ndr, "sid_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->sid, ndr->flags):r->sid_size);
4178
ndr_print_dom_sid(ndr, "sid", &r->sid);
4179
ndr_print_ForestTrustString(ndr, "dns_name", &r->dns_name);
4180
ndr_print_ForestTrustString(ndr, "netbios_name", &r->netbios_name);
4181
ndr->depth--;
4182
ndr->flags = _flags_save_STRUCT;
4183
}
4184
}
4185
4186
static enum ndr_err_code ndr_push_ForestTrustDataBinaryData(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustDataBinaryData *r)
4187
{
4188
{
4189
uint32_t _flags_save_STRUCT = ndr->flags;
4190
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4191
if (ndr_flags & NDR_SCALARS) {
4192
NDR_CHECK(ndr_push_align(ndr, 4));
4193
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4194
NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
4195
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4196
}
4197
if (ndr_flags & NDR_BUFFERS) {
4198
}
4199
ndr->flags = _flags_save_STRUCT;
4200
}
4201
return NDR_ERR_SUCCESS;
4202
}
4203
4204
static enum ndr_err_code ndr_pull_ForestTrustDataBinaryData(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustDataBinaryData *r)
4205
{
4206
{
4207
uint32_t _flags_save_STRUCT = ndr->flags;
4208
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4209
if (ndr_flags & NDR_SCALARS) {
4210
NDR_CHECK(ndr_pull_align(ndr, 4));
4211
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4212
NDR_PULL_ALLOC_N(ndr, r->data, r->size);
4213
NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
4214
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4215
}
4216
if (ndr_flags & NDR_BUFFERS) {
4217
}
4218
ndr->flags = _flags_save_STRUCT;
4219
}
4220
return NDR_ERR_SUCCESS;
4221
}
4222
4223
_PUBLIC_ void ndr_print_ForestTrustDataBinaryData(struct ndr_print *ndr, const char *name, const struct ForestTrustDataBinaryData *r)
4224
{
4225
ndr_print_struct(ndr, name, "ForestTrustDataBinaryData");
4226
if (r == NULL) { ndr_print_null(ndr); return; }
4227
{
4228
uint32_t _flags_save_STRUCT = ndr->flags;
4229
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4230
ndr->depth++;
4231
ndr_print_uint32(ndr, "size", r->size);
4232
ndr_print_array_uint8(ndr, "data", r->data, r->size);
4233
ndr->depth--;
4234
ndr->flags = _flags_save_STRUCT;
4235
}
4236
}
4237
4238
static enum ndr_err_code ndr_push_ForestTrustData(struct ndr_push *ndr, int ndr_flags, const union ForestTrustData *r)
4239
{
4240
if (ndr_flags & NDR_SCALARS) {
4241
uint32_t level = ndr_push_get_switch_value(ndr, r);
4242
NDR_CHECK(ndr_push_union_align(ndr, 4));
4243
switch (level) {
4244
case FOREST_TRUST_TOP_LEVEL_NAME: {
4245
NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4246
break; }
4247
4248
case FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4249
NDR_CHECK(ndr_push_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4250
break; }
4251
4252
case FOREST_TRUST_DOMAIN_INFO: {
4253
NDR_CHECK(ndr_push_ForestTrustDataDomainInfo(ndr, NDR_SCALARS, &r->info));
4254
break; }
4255
4256
default: {
4257
NDR_CHECK(ndr_push_ForestTrustDataBinaryData(ndr, NDR_SCALARS, &r->data));
4258
break; }
4259
4260
}
4261
}
4262
if (ndr_flags & NDR_BUFFERS) {
4263
uint32_t level = ndr_push_get_switch_value(ndr, r);
4264
switch (level) {
4265
case FOREST_TRUST_TOP_LEVEL_NAME:
4266
break;
4267
4268
case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4269
break;
4270
4271
case FOREST_TRUST_DOMAIN_INFO:
4272
break;
4273
4274
default:
4275
break;
4276
4277
}
4278
}
4279
return NDR_ERR_SUCCESS;
4280
}
4281
4282
static enum ndr_err_code ndr_pull_ForestTrustData(struct ndr_pull *ndr, int ndr_flags, union ForestTrustData *r)
4283
{
4284
uint32_t level;
4285
level = ndr_pull_get_switch_value(ndr, r);
4286
if (ndr_flags & NDR_SCALARS) {
4287
NDR_CHECK(ndr_pull_union_align(ndr, 4));
4288
switch (level) {
4289
case FOREST_TRUST_TOP_LEVEL_NAME: {
4290
NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4291
break; }
4292
4293
case FOREST_TRUST_TOP_LEVEL_NAME_EX: {
4294
NDR_CHECK(ndr_pull_ForestTrustString(ndr, NDR_SCALARS, &r->name));
4295
break; }
4296
4297
case FOREST_TRUST_DOMAIN_INFO: {
4298
NDR_CHECK(ndr_pull_ForestTrustDataDomainInfo(ndr, NDR_SCALARS, &r->info));
4299
break; }
4300
4301
default: {
4302
NDR_CHECK(ndr_pull_ForestTrustDataBinaryData(ndr, NDR_SCALARS, &r->data));
4303
break; }
4304
4305
}
4306
}
4307
if (ndr_flags & NDR_BUFFERS) {
4308
switch (level) {
4309
case FOREST_TRUST_TOP_LEVEL_NAME:
4310
break;
4311
4312
case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4313
break;
4314
4315
case FOREST_TRUST_DOMAIN_INFO:
4316
break;
4317
4318
default:
4319
break;
4320
4321
}
4322
}
4323
return NDR_ERR_SUCCESS;
4324
}
4325
4326
_PUBLIC_ void ndr_print_ForestTrustData(struct ndr_print *ndr, const char *name, const union ForestTrustData *r)
4327
{
4328
uint32_t level;
4329
level = ndr_print_get_switch_value(ndr, r);
4330
ndr_print_union(ndr, name, level, "ForestTrustData");
4331
switch (level) {
4332
case FOREST_TRUST_TOP_LEVEL_NAME:
4333
ndr_print_ForestTrustString(ndr, "name", &r->name);
4334
break;
4335
4336
case FOREST_TRUST_TOP_LEVEL_NAME_EX:
4337
ndr_print_ForestTrustString(ndr, "name", &r->name);
4338
break;
4339
4340
case FOREST_TRUST_DOMAIN_INFO:
4341
ndr_print_ForestTrustDataDomainInfo(ndr, "info", &r->info);
4342
break;
4343
4344
default:
4345
ndr_print_ForestTrustDataBinaryData(ndr, "data", &r->data);
4346
break;
4347
4348
}
4349
}
4350
4351
static enum ndr_err_code ndr_push_ForestTrustInfoRecordType(struct ndr_push *ndr, int ndr_flags, enum ForestTrustInfoRecordType r)
4352
{
4353
NDR_CHECK(ndr_push_enum_uint8(ndr, NDR_SCALARS, r));
4354
return NDR_ERR_SUCCESS;
4355
}
4356
4357
static enum ndr_err_code ndr_pull_ForestTrustInfoRecordType(struct ndr_pull *ndr, int ndr_flags, enum ForestTrustInfoRecordType *r)
4358
{
4359
uint8_t v;
4360
NDR_CHECK(ndr_pull_enum_uint8(ndr, NDR_SCALARS, &v));
4361
*r = v;
4362
return NDR_ERR_SUCCESS;
4363
}
4364
4365
_PUBLIC_ void ndr_print_ForestTrustInfoRecordType(struct ndr_print *ndr, const char *name, enum ForestTrustInfoRecordType r)
4366
{
4367
const char *val = NULL;
4368
4369
switch (r) {
4370
case FOREST_TRUST_TOP_LEVEL_NAME: val = "FOREST_TRUST_TOP_LEVEL_NAME"; break;
4371
case FOREST_TRUST_TOP_LEVEL_NAME_EX: val = "FOREST_TRUST_TOP_LEVEL_NAME_EX"; break;
4372
case FOREST_TRUST_DOMAIN_INFO: val = "FOREST_TRUST_DOMAIN_INFO"; break;
4373
}
4374
ndr_print_enum(ndr, name, "ENUM", val, r);
4375
}
4376
4377
_PUBLIC_ enum ndr_err_code ndr_push_ForestTrustInfoRecord(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfoRecord *r)
4378
{
4379
{
4380
uint32_t _flags_save_STRUCT = ndr->flags;
4381
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4382
if (ndr_flags & NDR_SCALARS) {
4383
NDR_CHECK(ndr_push_align(ndr, 4));
4384
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4385
NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->timestamp));
4386
NDR_CHECK(ndr_push_ForestTrustInfoRecordType(ndr, NDR_SCALARS, r->type));
4387
NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->type));
4388
NDR_CHECK(ndr_push_ForestTrustData(ndr, NDR_SCALARS, &r->data));
4389
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4390
}
4391
if (ndr_flags & NDR_BUFFERS) {
4392
}
4393
ndr->flags = _flags_save_STRUCT;
4394
}
4395
return NDR_ERR_SUCCESS;
4396
}
4397
4398
_PUBLIC_ enum ndr_err_code ndr_pull_ForestTrustInfoRecord(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfoRecord *r)
4399
{
4400
{
4401
uint32_t _flags_save_STRUCT = ndr->flags;
4402
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4403
if (ndr_flags & NDR_SCALARS) {
4404
NDR_CHECK(ndr_pull_align(ndr, 4));
4405
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
4406
NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->timestamp));
4407
NDR_CHECK(ndr_pull_ForestTrustInfoRecordType(ndr, NDR_SCALARS, &r->type));
4408
NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->type));
4409
NDR_CHECK(ndr_pull_ForestTrustData(ndr, NDR_SCALARS, &r->data));
4410
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4411
}
4412
if (ndr_flags & NDR_BUFFERS) {
4413
}
4414
ndr->flags = _flags_save_STRUCT;
4415
}
4416
return NDR_ERR_SUCCESS;
4417
}
4418
4419
_PUBLIC_ void ndr_print_ForestTrustInfoRecord(struct ndr_print *ndr, const char *name, const struct ForestTrustInfoRecord *r)
4420
{
4421
ndr_print_struct(ndr, name, "ForestTrustInfoRecord");
4422
if (r == NULL) { ndr_print_null(ndr); return; }
4423
{
4424
uint32_t _flags_save_STRUCT = ndr->flags;
4425
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4426
ndr->depth++;
4427
ndr_print_uint32(ndr, "flags", r->flags);
4428
ndr_print_NTTIME(ndr, "timestamp", r->timestamp);
4429
ndr_print_ForestTrustInfoRecordType(ndr, "type", r->type);
4430
ndr_print_set_switch_value(ndr, &r->data, r->type);
4431
ndr_print_ForestTrustData(ndr, "data", &r->data);
4432
ndr->depth--;
4433
ndr->flags = _flags_save_STRUCT;
4434
}
4435
}
4436
4437
_PUBLIC_ size_t ndr_size_ForestTrustInfoRecord(const struct ForestTrustInfoRecord *r, int flags)
4438
{
4439
flags |= LIBNDR_FLAG_NOALIGN;
4440
return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ForestTrustInfoRecord);
4441
}
4442
4443
static enum ndr_err_code ndr_push_ForestTrustInfoRecordArmor(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfoRecordArmor *r)
4444
{
4445
{
4446
uint32_t _flags_save_STRUCT = ndr->flags;
4447
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4448
if (ndr_flags & NDR_SCALARS) {
4449
NDR_CHECK(ndr_push_align(ndr, 4));
4450
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_ForestTrustInfoRecord(&r->record, ndr->flags)));
4451
NDR_CHECK(ndr_push_ForestTrustInfoRecord(ndr, NDR_SCALARS, &r->record));
4452
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4453
}
4454
if (ndr_flags & NDR_BUFFERS) {
4455
}
4456
ndr->flags = _flags_save_STRUCT;
4457
}
4458
return NDR_ERR_SUCCESS;
4459
}
4460
4461
static enum ndr_err_code ndr_pull_ForestTrustInfoRecordArmor(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfoRecordArmor *r)
4462
{
4463
{
4464
uint32_t _flags_save_STRUCT = ndr->flags;
4465
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4466
if (ndr_flags & NDR_SCALARS) {
4467
NDR_CHECK(ndr_pull_align(ndr, 4));
4468
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->record_size));
4469
NDR_CHECK(ndr_pull_ForestTrustInfoRecord(ndr, NDR_SCALARS, &r->record));
4470
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4471
}
4472
if (ndr_flags & NDR_BUFFERS) {
4473
}
4474
ndr->flags = _flags_save_STRUCT;
4475
}
4476
return NDR_ERR_SUCCESS;
4477
}
4478
4479
_PUBLIC_ void ndr_print_ForestTrustInfoRecordArmor(struct ndr_print *ndr, const char *name, const struct ForestTrustInfoRecordArmor *r)
4480
{
4481
ndr_print_struct(ndr, name, "ForestTrustInfoRecordArmor");
4482
if (r == NULL) { ndr_print_null(ndr); return; }
4483
{
4484
uint32_t _flags_save_STRUCT = ndr->flags;
4485
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4486
ndr->depth++;
4487
ndr_print_uint32(ndr, "record_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_ForestTrustInfoRecord(&r->record, ndr->flags):r->record_size);
4488
ndr_print_ForestTrustInfoRecord(ndr, "record", &r->record);
4489
ndr->depth--;
4490
ndr->flags = _flags_save_STRUCT;
4491
}
4492
}
4493
4494
_PUBLIC_ enum ndr_err_code ndr_push_ForestTrustInfo(struct ndr_push *ndr, int ndr_flags, const struct ForestTrustInfo *r)
4495
{
4496
uint32_t cntr_records_0;
4497
{
4498
uint32_t _flags_save_STRUCT = ndr->flags;
4499
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4500
if (ndr_flags & NDR_SCALARS) {
4501
NDR_CHECK(ndr_push_align(ndr, 4));
4502
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
4503
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4504
for (cntr_records_0 = 0; cntr_records_0 < r->count; cntr_records_0++) {
4505
NDR_CHECK(ndr_push_ForestTrustInfoRecordArmor(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
4506
}
4507
NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4508
}
4509
if (ndr_flags & NDR_BUFFERS) {
4510
}
4511
ndr->flags = _flags_save_STRUCT;
4512
}
4513
return NDR_ERR_SUCCESS;
4514
}
4515
4516
_PUBLIC_ enum ndr_err_code ndr_pull_ForestTrustInfo(struct ndr_pull *ndr, int ndr_flags, struct ForestTrustInfo *r)
4517
{
4518
uint32_t cntr_records_0;
4519
TALLOC_CTX *_mem_save_records_0;
4520
{
4521
uint32_t _flags_save_STRUCT = ndr->flags;
4522
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4523
if (ndr_flags & NDR_SCALARS) {
4524
NDR_CHECK(ndr_pull_align(ndr, 4));
4525
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
4526
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
4527
NDR_PULL_ALLOC_N(ndr, r->records, r->count);
4528
_mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);
4529
NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);
4530
for (cntr_records_0 = 0; cntr_records_0 < r->count; cntr_records_0++) {
4531
NDR_CHECK(ndr_pull_ForestTrustInfoRecordArmor(ndr, NDR_SCALARS, &r->records[cntr_records_0]));
4532
}
4533
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);
4534
NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4535
}
4536
if (ndr_flags & NDR_BUFFERS) {
4537
}
4538
ndr->flags = _flags_save_STRUCT;
4539
}
4540
return NDR_ERR_SUCCESS;
4541
}
4542
4543
_PUBLIC_ void ndr_print_ForestTrustInfo(struct ndr_print *ndr, const char *name, const struct ForestTrustInfo *r)
4544
{
4545
uint32_t cntr_records_0;
4546
ndr_print_struct(ndr, name, "ForestTrustInfo");
4547
if (r == NULL) { ndr_print_null(ndr); return; }
4548
{
4549
uint32_t _flags_save_STRUCT = ndr->flags;
4550
ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
4551
ndr->depth++;
4552
ndr_print_uint32(ndr, "version", r->version);
4553
ndr_print_uint32(ndr, "count", r->count);
4554
ndr->print(ndr, "%s: ARRAY(%d)", "records", (int)r->count);
4555
ndr->depth++;
4556
for (cntr_records_0=0;cntr_records_0<r->count;cntr_records_0++) {
4557
ndr_print_ForestTrustInfoRecordArmor(ndr, "records", &r->records[cntr_records_0]);
4558
}
4559
ndr->depth--;
4560
ndr->depth--;
4561
ndr->flags = _flags_save_STRUCT;
4562
}
4563
}
4564
4565
static enum ndr_err_code ndr_push_decode_replPropertyMetaData(struct ndr_push *ndr, int flags, const struct decode_replPropertyMetaData *r)
4566
{
4567
if (flags & NDR_IN) {
4568
NDR_CHECK(ndr_push_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4569
}
4570
if (flags & NDR_OUT) {
4571
}
4572
return NDR_ERR_SUCCESS;
4573
}
4574
4575
static enum ndr_err_code ndr_pull_decode_replPropertyMetaData(struct ndr_pull *ndr, int flags, struct decode_replPropertyMetaData *r)
4576
{
4577
if (flags & NDR_IN) {
4578
NDR_CHECK(ndr_pull_replPropertyMetaDataBlob(ndr, NDR_SCALARS, &r->in.blob));
4579
}
4580
if (flags & NDR_OUT) {
4581
}
4582
return NDR_ERR_SUCCESS;
4583
}
4584
4585
_PUBLIC_ void ndr_print_decode_replPropertyMetaData(struct ndr_print *ndr, const char *name, int flags, const struct decode_replPropertyMetaData *r)
4586
{
4587
ndr_print_struct(ndr, name, "decode_replPropertyMetaData");
4588
if (r == NULL) { ndr_print_null(ndr); return; }
4589
ndr->depth++;
4590
if (flags & NDR_SET_VALUES) {
4591
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4592
}
4593
if (flags & NDR_IN) {
4594
ndr_print_struct(ndr, "in", "decode_replPropertyMetaData");
4595
ndr->depth++;
4596
ndr_print_replPropertyMetaDataBlob(ndr, "blob", &r->in.blob);
4597
ndr->depth--;
4598
}
4599
if (flags & NDR_OUT) {
4600
ndr_print_struct(ndr, "out", "decode_replPropertyMetaData");
4601
ndr->depth++;
4602
ndr->depth--;
4603
}
4604
ndr->depth--;
4605
}
4606
4607
static enum ndr_err_code ndr_push_decode_replUpToDateVector(struct ndr_push *ndr, int flags, const struct decode_replUpToDateVector *r)
4608
{
4609
if (flags & NDR_IN) {
4610
NDR_CHECK(ndr_push_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4611
}
4612
if (flags & NDR_OUT) {
4613
}
4614
return NDR_ERR_SUCCESS;
4615
}
4616
4617
static enum ndr_err_code ndr_pull_decode_replUpToDateVector(struct ndr_pull *ndr, int flags, struct decode_replUpToDateVector *r)
4618
{
4619
if (flags & NDR_IN) {
4620
NDR_CHECK(ndr_pull_replUpToDateVectorBlob(ndr, NDR_SCALARS, &r->in.blob));
4621
}
4622
if (flags & NDR_OUT) {
4623
}
4624
return NDR_ERR_SUCCESS;
4625
}
4626
4627
_PUBLIC_ void ndr_print_decode_replUpToDateVector(struct ndr_print *ndr, const char *name, int flags, const struct decode_replUpToDateVector *r)
4628
{
4629
ndr_print_struct(ndr, name, "decode_replUpToDateVector");
4630
if (r == NULL) { ndr_print_null(ndr); return; }
4631
ndr->depth++;
4632
if (flags & NDR_SET_VALUES) {
4633
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4634
}
4635
if (flags & NDR_IN) {
4636
ndr_print_struct(ndr, "in", "decode_replUpToDateVector");
4637
ndr->depth++;
4638
ndr_print_replUpToDateVectorBlob(ndr, "blob", &r->in.blob);
4639
ndr->depth--;
4640
}
4641
if (flags & NDR_OUT) {
4642
ndr_print_struct(ndr, "out", "decode_replUpToDateVector");
4643
ndr->depth++;
4644
ndr->depth--;
4645
}
4646
ndr->depth--;
4647
}
4648
4649
static enum ndr_err_code ndr_push_decode_repsFromTo(struct ndr_push *ndr, int flags, const struct decode_repsFromTo *r)
4650
{
4651
if (flags & NDR_IN) {
4652
NDR_CHECK(ndr_push_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4653
}
4654
if (flags & NDR_OUT) {
4655
}
4656
return NDR_ERR_SUCCESS;
4657
}
4658
4659
static enum ndr_err_code ndr_pull_decode_repsFromTo(struct ndr_pull *ndr, int flags, struct decode_repsFromTo *r)
4660
{
4661
if (flags & NDR_IN) {
4662
NDR_CHECK(ndr_pull_repsFromToBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4663
}
4664
if (flags & NDR_OUT) {
4665
}
4666
return NDR_ERR_SUCCESS;
4667
}
4668
4669
_PUBLIC_ void ndr_print_decode_repsFromTo(struct ndr_print *ndr, const char *name, int flags, const struct decode_repsFromTo *r)
4670
{
4671
ndr_print_struct(ndr, name, "decode_repsFromTo");
4672
if (r == NULL) { ndr_print_null(ndr); return; }
4673
ndr->depth++;
4674
if (flags & NDR_SET_VALUES) {
4675
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4676
}
4677
if (flags & NDR_IN) {
4678
ndr_print_struct(ndr, "in", "decode_repsFromTo");
4679
ndr->depth++;
4680
ndr_print_repsFromToBlob(ndr, "blob", &r->in.blob);
4681
ndr->depth--;
4682
}
4683
if (flags & NDR_OUT) {
4684
ndr_print_struct(ndr, "out", "decode_repsFromTo");
4685
ndr->depth++;
4686
ndr->depth--;
4687
}
4688
ndr->depth--;
4689
}
4690
4691
static enum ndr_err_code ndr_push_decode_partialAttributeSet(struct ndr_push *ndr, int flags, const struct decode_partialAttributeSet *r)
4692
{
4693
if (flags & NDR_IN) {
4694
NDR_CHECK(ndr_push_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4695
}
4696
if (flags & NDR_OUT) {
4697
}
4698
return NDR_ERR_SUCCESS;
4699
}
4700
4701
static enum ndr_err_code ndr_pull_decode_partialAttributeSet(struct ndr_pull *ndr, int flags, struct decode_partialAttributeSet *r)
4702
{
4703
if (flags & NDR_IN) {
4704
NDR_CHECK(ndr_pull_partialAttributeSetBlob(ndr, NDR_SCALARS, &r->in.blob));
4705
}
4706
if (flags & NDR_OUT) {
4707
}
4708
return NDR_ERR_SUCCESS;
4709
}
4710
4711
_PUBLIC_ void ndr_print_decode_partialAttributeSet(struct ndr_print *ndr, const char *name, int flags, const struct decode_partialAttributeSet *r)
4712
{
4713
ndr_print_struct(ndr, name, "decode_partialAttributeSet");
4714
if (r == NULL) { ndr_print_null(ndr); return; }
4715
ndr->depth++;
4716
if (flags & NDR_SET_VALUES) {
4717
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4718
}
4719
if (flags & NDR_IN) {
4720
ndr_print_struct(ndr, "in", "decode_partialAttributeSet");
4721
ndr->depth++;
4722
ndr_print_partialAttributeSetBlob(ndr, "blob", &r->in.blob);
4723
ndr->depth--;
4724
}
4725
if (flags & NDR_OUT) {
4726
ndr_print_struct(ndr, "out", "decode_partialAttributeSet");
4727
ndr->depth++;
4728
ndr->depth--;
4729
}
4730
ndr->depth--;
4731
}
4732
4733
static enum ndr_err_code ndr_push_decode_prefixMap(struct ndr_push *ndr, int flags, const struct decode_prefixMap *r)
4734
{
4735
if (flags & NDR_IN) {
4736
NDR_CHECK(ndr_push_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4737
}
4738
if (flags & NDR_OUT) {
4739
}
4740
return NDR_ERR_SUCCESS;
4741
}
4742
4743
static enum ndr_err_code ndr_pull_decode_prefixMap(struct ndr_pull *ndr, int flags, struct decode_prefixMap *r)
4744
{
4745
if (flags & NDR_IN) {
4746
NDR_CHECK(ndr_pull_prefixMapBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4747
}
4748
if (flags & NDR_OUT) {
4749
}
4750
return NDR_ERR_SUCCESS;
4751
}
4752
4753
_PUBLIC_ void ndr_print_decode_prefixMap(struct ndr_print *ndr, const char *name, int flags, const struct decode_prefixMap *r)
4754
{
4755
ndr_print_struct(ndr, name, "decode_prefixMap");
4756
if (r == NULL) { ndr_print_null(ndr); return; }
4757
ndr->depth++;
4758
if (flags & NDR_SET_VALUES) {
4759
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4760
}
4761
if (flags & NDR_IN) {
4762
ndr_print_struct(ndr, "in", "decode_prefixMap");
4763
ndr->depth++;
4764
ndr_print_prefixMapBlob(ndr, "blob", &r->in.blob);
4765
ndr->depth--;
4766
}
4767
if (flags & NDR_OUT) {
4768
ndr_print_struct(ndr, "out", "decode_prefixMap");
4769
ndr->depth++;
4770
ndr->depth--;
4771
}
4772
ndr->depth--;
4773
}
4774
4775
static enum ndr_err_code ndr_push_decode_ldapControlDirSync(struct ndr_push *ndr, int flags, const struct decode_ldapControlDirSync *r)
4776
{
4777
if (flags & NDR_IN) {
4778
NDR_CHECK(ndr_push_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4779
}
4780
if (flags & NDR_OUT) {
4781
}
4782
return NDR_ERR_SUCCESS;
4783
}
4784
4785
static enum ndr_err_code ndr_pull_decode_ldapControlDirSync(struct ndr_pull *ndr, int flags, struct decode_ldapControlDirSync *r)
4786
{
4787
if (flags & NDR_IN) {
4788
NDR_CHECK(ndr_pull_ldapControlDirSyncCookie(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.cookie));
4789
}
4790
if (flags & NDR_OUT) {
4791
}
4792
return NDR_ERR_SUCCESS;
4793
}
4794
4795
_PUBLIC_ void ndr_print_decode_ldapControlDirSync(struct ndr_print *ndr, const char *name, int flags, const struct decode_ldapControlDirSync *r)
4796
{
4797
ndr_print_struct(ndr, name, "decode_ldapControlDirSync");
4798
if (r == NULL) { ndr_print_null(ndr); return; }
4799
ndr->depth++;
4800
if (flags & NDR_SET_VALUES) {
4801
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4802
}
4803
if (flags & NDR_IN) {
4804
ndr_print_struct(ndr, "in", "decode_ldapControlDirSync");
4805
ndr->depth++;
4806
ndr_print_ldapControlDirSyncCookie(ndr, "cookie", &r->in.cookie);
4807
ndr->depth--;
4808
}
4809
if (flags & NDR_OUT) {
4810
ndr_print_struct(ndr, "out", "decode_ldapControlDirSync");
4811
ndr->depth++;
4812
ndr->depth--;
4813
}
4814
ndr->depth--;
4815
}
4816
4817
static enum ndr_err_code ndr_push_decode_supplementalCredentials(struct ndr_push *ndr, int flags, const struct decode_supplementalCredentials *r)
4818
{
4819
if (flags & NDR_IN) {
4820
NDR_CHECK(ndr_push_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4821
}
4822
if (flags & NDR_OUT) {
4823
}
4824
return NDR_ERR_SUCCESS;
4825
}
4826
4827
static enum ndr_err_code ndr_pull_decode_supplementalCredentials(struct ndr_pull *ndr, int flags, struct decode_supplementalCredentials *r)
4828
{
4829
if (flags & NDR_IN) {
4830
NDR_CHECK(ndr_pull_supplementalCredentialsBlob(ndr, NDR_SCALARS, &r->in.blob));
4831
}
4832
if (flags & NDR_OUT) {
4833
}
4834
return NDR_ERR_SUCCESS;
4835
}
4836
4837
_PUBLIC_ void ndr_print_decode_supplementalCredentials(struct ndr_print *ndr, const char *name, int flags, const struct decode_supplementalCredentials *r)
4838
{
4839
ndr_print_struct(ndr, name, "decode_supplementalCredentials");
4840
if (r == NULL) { ndr_print_null(ndr); return; }
4841
ndr->depth++;
4842
if (flags & NDR_SET_VALUES) {
4843
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4844
}
4845
if (flags & NDR_IN) {
4846
ndr_print_struct(ndr, "in", "decode_supplementalCredentials");
4847
ndr->depth++;
4848
ndr_print_supplementalCredentialsBlob(ndr, "blob", &r->in.blob);
4849
ndr->depth--;
4850
}
4851
if (flags & NDR_OUT) {
4852
ndr_print_struct(ndr, "out", "decode_supplementalCredentials");
4853
ndr->depth++;
4854
ndr->depth--;
4855
}
4856
ndr->depth--;
4857
}
4858
4859
static enum ndr_err_code ndr_push_decode_Packages(struct ndr_push *ndr, int flags, const struct decode_Packages *r)
4860
{
4861
if (flags & NDR_IN) {
4862
NDR_CHECK(ndr_push_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4863
}
4864
if (flags & NDR_OUT) {
4865
}
4866
return NDR_ERR_SUCCESS;
4867
}
4868
4869
static enum ndr_err_code ndr_pull_decode_Packages(struct ndr_pull *ndr, int flags, struct decode_Packages *r)
4870
{
4871
if (flags & NDR_IN) {
4872
NDR_CHECK(ndr_pull_package_PackagesBlob(ndr, NDR_SCALARS, &r->in.blob));
4873
}
4874
if (flags & NDR_OUT) {
4875
}
4876
return NDR_ERR_SUCCESS;
4877
}
4878
4879
_PUBLIC_ void ndr_print_decode_Packages(struct ndr_print *ndr, const char *name, int flags, const struct decode_Packages *r)
4880
{
4881
ndr_print_struct(ndr, name, "decode_Packages");
4882
if (r == NULL) { ndr_print_null(ndr); return; }
4883
ndr->depth++;
4884
if (flags & NDR_SET_VALUES) {
4885
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4886
}
4887
if (flags & NDR_IN) {
4888
ndr_print_struct(ndr, "in", "decode_Packages");
4889
ndr->depth++;
4890
ndr_print_package_PackagesBlob(ndr, "blob", &r->in.blob);
4891
ndr->depth--;
4892
}
4893
if (flags & NDR_OUT) {
4894
ndr_print_struct(ndr, "out", "decode_Packages");
4895
ndr->depth++;
4896
ndr->depth--;
4897
}
4898
ndr->depth--;
4899
}
4900
4901
static enum ndr_err_code ndr_push_decode_PrimaryKerberos(struct ndr_push *ndr, int flags, const struct decode_PrimaryKerberos *r)
4902
{
4903
if (flags & NDR_IN) {
4904
NDR_CHECK(ndr_push_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4905
}
4906
if (flags & NDR_OUT) {
4907
}
4908
return NDR_ERR_SUCCESS;
4909
}
4910
4911
static enum ndr_err_code ndr_pull_decode_PrimaryKerberos(struct ndr_pull *ndr, int flags, struct decode_PrimaryKerberos *r)
4912
{
4913
if (flags & NDR_IN) {
4914
NDR_CHECK(ndr_pull_package_PrimaryKerberosBlob(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.blob));
4915
}
4916
if (flags & NDR_OUT) {
4917
}
4918
return NDR_ERR_SUCCESS;
4919
}
4920
4921
_PUBLIC_ void ndr_print_decode_PrimaryKerberos(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryKerberos *r)
4922
{
4923
ndr_print_struct(ndr, name, "decode_PrimaryKerberos");
4924
if (r == NULL) { ndr_print_null(ndr); return; }
4925
ndr->depth++;
4926
if (flags & NDR_SET_VALUES) {
4927
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4928
}
4929
if (flags & NDR_IN) {
4930
ndr_print_struct(ndr, "in", "decode_PrimaryKerberos");
4931
ndr->depth++;
4932
ndr_print_package_PrimaryKerberosBlob(ndr, "blob", &r->in.blob);
4933
ndr->depth--;
4934
}
4935
if (flags & NDR_OUT) {
4936
ndr_print_struct(ndr, "out", "decode_PrimaryKerberos");
4937
ndr->depth++;
4938
ndr->depth--;
4939
}
4940
ndr->depth--;
4941
}
4942
4943
static enum ndr_err_code ndr_push_decode_PrimaryCLEARTEXT(struct ndr_push *ndr, int flags, const struct decode_PrimaryCLEARTEXT *r)
4944
{
4945
if (flags & NDR_IN) {
4946
NDR_CHECK(ndr_push_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4947
}
4948
if (flags & NDR_OUT) {
4949
}
4950
return NDR_ERR_SUCCESS;
4951
}
4952
4953
static enum ndr_err_code ndr_pull_decode_PrimaryCLEARTEXT(struct ndr_pull *ndr, int flags, struct decode_PrimaryCLEARTEXT *r)
4954
{
4955
if (flags & NDR_IN) {
4956
NDR_CHECK(ndr_pull_package_PrimaryCLEARTEXTBlob(ndr, NDR_SCALARS, &r->in.blob));
4957
}
4958
if (flags & NDR_OUT) {
4959
}
4960
return NDR_ERR_SUCCESS;
4961
}
4962
4963
_PUBLIC_ void ndr_print_decode_PrimaryCLEARTEXT(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryCLEARTEXT *r)
4964
{
4965
ndr_print_struct(ndr, name, "decode_PrimaryCLEARTEXT");
4966
if (r == NULL) { ndr_print_null(ndr); return; }
4967
ndr->depth++;
4968
if (flags & NDR_SET_VALUES) {
4969
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4970
}
4971
if (flags & NDR_IN) {
4972
ndr_print_struct(ndr, "in", "decode_PrimaryCLEARTEXT");
4973
ndr->depth++;
4974
ndr_print_package_PrimaryCLEARTEXTBlob(ndr, "blob", &r->in.blob);
4975
ndr->depth--;
4976
}
4977
if (flags & NDR_OUT) {
4978
ndr_print_struct(ndr, "out", "decode_PrimaryCLEARTEXT");
4979
ndr->depth++;
4980
ndr->depth--;
4981
}
4982
ndr->depth--;
4983
}
4984
4985
static enum ndr_err_code ndr_push_decode_PrimaryWDigest(struct ndr_push *ndr, int flags, const struct decode_PrimaryWDigest *r)
4986
{
4987
if (flags & NDR_IN) {
4988
NDR_CHECK(ndr_push_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
4989
}
4990
if (flags & NDR_OUT) {
4991
}
4992
return NDR_ERR_SUCCESS;
4993
}
4994
4995
static enum ndr_err_code ndr_pull_decode_PrimaryWDigest(struct ndr_pull *ndr, int flags, struct decode_PrimaryWDigest *r)
4996
{
4997
if (flags & NDR_IN) {
4998
NDR_CHECK(ndr_pull_package_PrimaryWDigestBlob(ndr, NDR_SCALARS, &r->in.blob));
4999
}
5000
if (flags & NDR_OUT) {
5001
}
5002
return NDR_ERR_SUCCESS;
5003
}
5004
5005
_PUBLIC_ void ndr_print_decode_PrimaryWDigest(struct ndr_print *ndr, const char *name, int flags, const struct decode_PrimaryWDigest *r)
5006
{
5007
ndr_print_struct(ndr, name, "decode_PrimaryWDigest");
5008
if (r == NULL) { ndr_print_null(ndr); return; }
5009
ndr->depth++;
5010
if (flags & NDR_SET_VALUES) {
5011
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5012
}
5013
if (flags & NDR_IN) {
5014
ndr_print_struct(ndr, "in", "decode_PrimaryWDigest");
5015
ndr->depth++;
5016
ndr_print_package_PrimaryWDigestBlob(ndr, "blob", &r->in.blob);
5017
ndr->depth--;
5018
}
5019
if (flags & NDR_OUT) {
5020
ndr_print_struct(ndr, "out", "decode_PrimaryWDigest");
5021
ndr->depth++;
5022
ndr->depth--;
5023
}
5024
ndr->depth--;
5025
}
5026
5027
static enum ndr_err_code ndr_push_decode_trustAuthInOut(struct ndr_push *ndr, int flags, const struct decode_trustAuthInOut *r)
5028
{
5029
if (flags & NDR_IN) {
5030
NDR_CHECK(ndr_push_trustAuthInOutBlob(ndr, NDR_SCALARS, &r->in.blob));
5031
}
5032
if (flags & NDR_OUT) {
5033
}
5034
return NDR_ERR_SUCCESS;
5035
}
5036
5037
static enum ndr_err_code ndr_pull_decode_trustAuthInOut(struct ndr_pull *ndr, int flags, struct decode_trustAuthInOut *r)
5038
{
5039
if (flags & NDR_IN) {
5040
NDR_CHECK(ndr_pull_trustAuthInOutBlob(ndr, NDR_SCALARS, &r->in.blob));
5041
}
5042
if (flags & NDR_OUT) {
5043
}
5044
return NDR_ERR_SUCCESS;
5045
}
5046
5047
_PUBLIC_ void ndr_print_decode_trustAuthInOut(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustAuthInOut *r)
5048
{
5049
ndr_print_struct(ndr, name, "decode_trustAuthInOut");
5050
if (r == NULL) { ndr_print_null(ndr); return; }
5051
ndr->depth++;
5052
if (flags & NDR_SET_VALUES) {
5053
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5054
}
5055
if (flags & NDR_IN) {
5056
ndr_print_struct(ndr, "in", "decode_trustAuthInOut");
5057
ndr->depth++;
5058
ndr_print_trustAuthInOutBlob(ndr, "blob", &r->in.blob);
5059
ndr->depth--;
5060
}
5061
if (flags & NDR_OUT) {
5062
ndr_print_struct(ndr, "out", "decode_trustAuthInOut");
5063
ndr->depth++;
5064
ndr->depth--;
5065
}
5066
ndr->depth--;
5067
}
5068
5069
static enum ndr_err_code ndr_push_decode_trustDomainPasswords(struct ndr_push *ndr, int flags, const struct decode_trustDomainPasswords *r)
5070
{
5071
if (flags & NDR_IN) {
5072
NDR_CHECK(ndr_push_trustDomainPasswords(ndr, NDR_SCALARS, &r->in.blob));
5073
}
5074
if (flags & NDR_OUT) {
5075
}
5076
return NDR_ERR_SUCCESS;
5077
}
5078
5079
static enum ndr_err_code ndr_pull_decode_trustDomainPasswords(struct ndr_pull *ndr, int flags, struct decode_trustDomainPasswords *r)
5080
{
5081
if (flags & NDR_IN) {
5082
NDR_CHECK(ndr_pull_trustDomainPasswords(ndr, NDR_SCALARS, &r->in.blob));
5083
}
5084
if (flags & NDR_OUT) {
5085
}
5086
return NDR_ERR_SUCCESS;
5087
}
5088
5089
_PUBLIC_ void ndr_print_decode_trustDomainPasswords(struct ndr_print *ndr, const char *name, int flags, const struct decode_trustDomainPasswords *r)
5090
{
5091
ndr_print_struct(ndr, name, "decode_trustDomainPasswords");
5092
if (r == NULL) { ndr_print_null(ndr); return; }
5093
ndr->depth++;
5094
if (flags & NDR_SET_VALUES) {
5095
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5096
}
5097
if (flags & NDR_IN) {
5098
ndr_print_struct(ndr, "in", "decode_trustDomainPasswords");
5099
ndr->depth++;
5100
ndr_print_trustDomainPasswords(ndr, "blob", &r->in.blob);
5101
ndr->depth--;
5102
}
5103
if (flags & NDR_OUT) {
5104
ndr_print_struct(ndr, "out", "decode_trustDomainPasswords");
5105
ndr->depth++;
5106
ndr->depth--;
5107
}
5108
ndr->depth--;
5109
}
5110
5111
static enum ndr_err_code ndr_push_decode_ExtendedErrorInfo(struct ndr_push *ndr, int flags, const struct decode_ExtendedErrorInfo *r)
5112
{
5113
if (flags & NDR_IN) {
5114
{
5115
struct ndr_push *_ndr_ptr;
5116
NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
5117
NDR_CHECK(ndr_push_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
5118
NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
5119
}
5120
}
5121
if (flags & NDR_OUT) {
5122
}
5123
return NDR_ERR_SUCCESS;
5124
}
5125
5126
static enum ndr_err_code ndr_pull_decode_ExtendedErrorInfo(struct ndr_pull *ndr, int flags, struct decode_ExtendedErrorInfo *r)
5127
{
5128
if (flags & NDR_IN) {
5129
{
5130
struct ndr_pull *_ndr_ptr;
5131
NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ptr, 0xFFFFFC01, -1));
5132
NDR_CHECK(ndr_pull_ExtendedErrorInfoPtr(_ndr_ptr, NDR_SCALARS|NDR_BUFFERS, &r->in.ptr));
5133
NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ptr, 0xFFFFFC01, -1));
5134
}
5135
}
5136
if (flags & NDR_OUT) {
5137
}
5138
return NDR_ERR_SUCCESS;
5139
}
5140
5141
_PUBLIC_ void ndr_print_decode_ExtendedErrorInfo(struct ndr_print *ndr, const char *name, int flags, const struct decode_ExtendedErrorInfo *r)
5142
{
5143
ndr_print_struct(ndr, name, "decode_ExtendedErrorInfo");
5144
if (r == NULL) { ndr_print_null(ndr); return; }
5145
ndr->depth++;
5146
if (flags & NDR_SET_VALUES) {
5147
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5148
}
5149
if (flags & NDR_IN) {
5150
ndr_print_struct(ndr, "in", "decode_ExtendedErrorInfo");
5151
ndr->depth++;
5152
ndr_print_ExtendedErrorInfoPtr(ndr, "ptr", &r->in.ptr);
5153
ndr->depth--;
5154
}
5155
if (flags & NDR_OUT) {
5156
ndr_print_struct(ndr, "out", "decode_ExtendedErrorInfo");
5157
ndr->depth++;
5158
ndr->depth--;
5159
}
5160
ndr->depth--;
5161
}
5162
5163
static enum ndr_err_code ndr_push_decode_ForestTrustInfo(struct ndr_push *ndr, int flags, const struct decode_ForestTrustInfo *r)
5164
{
5165
if (flags & NDR_IN) {
5166
NDR_CHECK(ndr_push_ForestTrustInfo(ndr, NDR_SCALARS, &r->in.blob));
5167
}
5168
if (flags & NDR_OUT) {
5169
}
5170
return NDR_ERR_SUCCESS;
5171
}
5172
5173
static enum ndr_err_code ndr_pull_decode_ForestTrustInfo(struct ndr_pull *ndr, int flags, struct decode_ForestTrustInfo *r)
5174
{
5175
if (flags & NDR_IN) {
5176
NDR_CHECK(ndr_pull_ForestTrustInfo(ndr, NDR_SCALARS, &r->in.blob));
5177
}
5178
if (flags & NDR_OUT) {
5179
}
5180
return NDR_ERR_SUCCESS;
5181
}
5182
5183
_PUBLIC_ void ndr_print_decode_ForestTrustInfo(struct ndr_print *ndr, const char *name, int flags, const struct decode_ForestTrustInfo *r)
5184
{
5185
ndr_print_struct(ndr, name, "decode_ForestTrustInfo");
5186
if (r == NULL) { ndr_print_null(ndr); return; }
5187
ndr->depth++;
5188
if (flags & NDR_SET_VALUES) {
5189
ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5190
}
5191
if (flags & NDR_IN) {
5192
ndr_print_struct(ndr, "in", "decode_ForestTrustInfo");
5193
ndr->depth++;
5194
ndr_print_ForestTrustInfo(ndr, "blob", &r->in.blob);
5195
ndr->depth--;
5196
}
5197
if (flags & NDR_OUT) {
5198
ndr_print_struct(ndr, "out", "decode_ForestTrustInfo");
5199
ndr->depth++;
5200
ndr->depth--;
5201
}
5202
ndr->depth--;
5203
}
5204
5205
static const struct ndr_interface_call drsblobs_calls[] = {
5206
{
5207
"decode_replPropertyMetaData",
5208
sizeof(struct decode_replPropertyMetaData),
5209
(ndr_push_flags_fn_t) ndr_push_decode_replPropertyMetaData,
5210
(ndr_pull_flags_fn_t) ndr_pull_decode_replPropertyMetaData,
5211
(ndr_print_function_t) ndr_print_decode_replPropertyMetaData,
5212
{ 0, NULL },
5213
{ 0, NULL },
5214
},
5215
{
5216
"decode_replUpToDateVector",
5217
sizeof(struct decode_replUpToDateVector),
5218
(ndr_push_flags_fn_t) ndr_push_decode_replUpToDateVector,
5219
(ndr_pull_flags_fn_t) ndr_pull_decode_replUpToDateVector,
5220
(ndr_print_function_t) ndr_print_decode_replUpToDateVector,
5221
{ 0, NULL },
5222
{ 0, NULL },
5223
},
5224
{
5225
"decode_repsFromTo",
5226
sizeof(struct decode_repsFromTo),
5227
(ndr_push_flags_fn_t) ndr_push_decode_repsFromTo,
5228
(ndr_pull_flags_fn_t) ndr_pull_decode_repsFromTo,
5229
(ndr_print_function_t) ndr_print_decode_repsFromTo,
5230
{ 0, NULL },
5231
{ 0, NULL },
5232
},
5233
{
5234
"decode_partialAttributeSet",
5235
sizeof(struct decode_partialAttributeSet),
5236
(ndr_push_flags_fn_t) ndr_push_decode_partialAttributeSet,
5237
(ndr_pull_flags_fn_t) ndr_pull_decode_partialAttributeSet,
5238
(ndr_print_function_t) ndr_print_decode_partialAttributeSet,
5239
{ 0, NULL },
5240
{ 0, NULL },
5241
},
5242
{
5243
"decode_prefixMap",
5244
sizeof(struct decode_prefixMap),
5245
(ndr_push_flags_fn_t) ndr_push_decode_prefixMap,
5246
(ndr_pull_flags_fn_t) ndr_pull_decode_prefixMap,
5247
(ndr_print_function_t) ndr_print_decode_prefixMap,
5248
{ 0, NULL },
5249
{ 0, NULL },
5250
},
5251
{
5252
"decode_ldapControlDirSync",
5253
sizeof(struct decode_ldapControlDirSync),
5254
(ndr_push_flags_fn_t) ndr_push_decode_ldapControlDirSync,
5255
(ndr_pull_flags_fn_t) ndr_pull_decode_ldapControlDirSync,
5256
(ndr_print_function_t) ndr_print_decode_ldapControlDirSync,
5257
{ 0, NULL },
5258
{ 0, NULL },
5259
},
5260
{
5261
"decode_supplementalCredentials",
5262
sizeof(struct decode_supplementalCredentials),
5263
(ndr_push_flags_fn_t) ndr_push_decode_supplementalCredentials,
5264
(ndr_pull_flags_fn_t) ndr_pull_decode_supplementalCredentials,
5265
(ndr_print_function_t) ndr_print_decode_supplementalCredentials,
5266
{ 0, NULL },
5267
{ 0, NULL },
5268
},
5269
{
5270
"decode_Packages",
5271
sizeof(struct decode_Packages),
5272
(ndr_push_flags_fn_t) ndr_push_decode_Packages,
5273
(ndr_pull_flags_fn_t) ndr_pull_decode_Packages,
5274
(ndr_print_function_t) ndr_print_decode_Packages,
5275
{ 0, NULL },
5276
{ 0, NULL },
5277
},
5278
{
5279
"decode_PrimaryKerberos",
5280
sizeof(struct decode_PrimaryKerberos),
5281
(ndr_push_flags_fn_t) ndr_push_decode_PrimaryKerberos,
5282
(ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryKerberos,
5283
(ndr_print_function_t) ndr_print_decode_PrimaryKerberos,
5284
{ 0, NULL },
5285
{ 0, NULL },
5286
},
5287
{
5288
"decode_PrimaryCLEARTEXT",
5289
sizeof(struct decode_PrimaryCLEARTEXT),
5290
(ndr_push_flags_fn_t) ndr_push_decode_PrimaryCLEARTEXT,
5291
(ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryCLEARTEXT,
5292
(ndr_print_function_t) ndr_print_decode_PrimaryCLEARTEXT,
5293
{ 0, NULL },
5294
{ 0, NULL },
5295
},
5296
{
5297
"decode_PrimaryWDigest",
5298
sizeof(struct decode_PrimaryWDigest),
5299
(ndr_push_flags_fn_t) ndr_push_decode_PrimaryWDigest,
5300
(ndr_pull_flags_fn_t) ndr_pull_decode_PrimaryWDigest,
5301
(ndr_print_function_t) ndr_print_decode_PrimaryWDigest,
5302
{ 0, NULL },
5303
{ 0, NULL },
5304
},
5305
{
5306
"decode_trustAuthInOut",
5307
sizeof(struct decode_trustAuthInOut),
5308
(ndr_push_flags_fn_t) ndr_push_decode_trustAuthInOut,
5309
(ndr_pull_flags_fn_t) ndr_pull_decode_trustAuthInOut,
5310
(ndr_print_function_t) ndr_print_decode_trustAuthInOut,
5311
{ 0, NULL },
5312
{ 0, NULL },
5313
},
5314
{
5315
"decode_trustDomainPasswords",
5316
sizeof(struct decode_trustDomainPasswords),
5317
(ndr_push_flags_fn_t) ndr_push_decode_trustDomainPasswords,
5318
(ndr_pull_flags_fn_t) ndr_pull_decode_trustDomainPasswords,
5319
(ndr_print_function_t) ndr_print_decode_trustDomainPasswords,
5320
{ 0, NULL },
5321
{ 0, NULL },
5322
},
5323
{
5324
"decode_ExtendedErrorInfo",
5325
sizeof(struct decode_ExtendedErrorInfo),
5326
(ndr_push_flags_fn_t) ndr_push_decode_ExtendedErrorInfo,
5327
(ndr_pull_flags_fn_t) ndr_pull_decode_ExtendedErrorInfo,
5328
(ndr_print_function_t) ndr_print_decode_ExtendedErrorInfo,
5329
{ 0, NULL },
5330
{ 0, NULL },
5331
},
5332
{
5333
"decode_ForestTrustInfo",
5334
sizeof(struct decode_ForestTrustInfo),
5335
(ndr_push_flags_fn_t) ndr_push_decode_ForestTrustInfo,
5336
(ndr_pull_flags_fn_t) ndr_pull_decode_ForestTrustInfo,
5337
(ndr_print_function_t) ndr_print_decode_ForestTrustInfo,
5338
{ 0, NULL },
5339
{ 0, NULL },
5340
},
5341
{ NULL, 0, NULL, NULL, NULL }
5342
};
5343
5344
static const char * const drsblobs_endpoint_strings[] = {
5345
"ncacn_np:[\\pipe\\drsblobs]",
5346
};
5347
5348
static const struct ndr_interface_string_array drsblobs_endpoints = {
5349
.count = 1,
5350
.names = drsblobs_endpoint_strings
5351
};
5352
5353
static const char * const drsblobs_authservice_strings[] = {
5354
"host",
5355
};
5356
5357
static const struct ndr_interface_string_array drsblobs_authservices = {
5358
.count = 1,
5359
.names = drsblobs_authservice_strings
5360
};
5361
5362
5363
const struct ndr_interface_table ndr_table_drsblobs = {
5364
.name = "drsblobs",
5365
.syntax_id = {
5366
{0x12345778,0x1234,0xabcd,{0x00,0x01},{0x00,0x00,0x00,0x01}},
5367
NDR_DRSBLOBS_VERSION
5368
},
5369
.helpstring = NDR_DRSBLOBS_HELPSTRING,
5370
.num_calls = 15,
5371
.calls = drsblobs_calls,
5372
.endpoints = &drsblobs_endpoints,
5373
.authservices = &drsblobs_authservices
5374
};
5375
Loggerhead is a web-based interface for Breezy
Version: 2.0.1