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