← Back to branch summary

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

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/librpc/gen_ndr/ndr_frstrans.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "librpc/gen_ndr/ndr_frstrans.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
static enum ndr_err_code ndr_push_frstrans_ProtocolVersion(struct ndr_push *ndr, int ndr_flags, enum frstrans_ProtocolVersion r)
 
8
{
 
9
        {
 
10
                uint32_t _flags_save_ENUM = ndr->flags;
 
11
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
12
                NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 
13
                ndr->flags = _flags_save_ENUM;
 
14
        }
 
15
        return NDR_ERR_SUCCESS;
 
16
}
 
17
 
 
18
static enum ndr_err_code ndr_pull_frstrans_ProtocolVersion(struct ndr_pull *ndr, int ndr_flags, enum frstrans_ProtocolVersion *r)
 
19
{
 
20
        uint32_t v;
 
21
        {
 
22
                uint32_t _flags_save_ENUM = ndr->flags;
 
23
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
24
                NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 
25
                *r = v;
 
26
                ndr->flags = _flags_save_ENUM;
 
27
        }
 
28
        return NDR_ERR_SUCCESS;
 
29
}
 
30
 
 
31
_PUBLIC_ void ndr_print_frstrans_ProtocolVersion(struct ndr_print *ndr, const char *name, enum frstrans_ProtocolVersion r)
 
32
{
 
33
        const char *val = NULL;
 
34
 
 
35
        {
 
36
                uint32_t _flags_save_ENUM = ndr->flags;
 
37
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
38
                switch (r) {
 
39
                        case FRSTRANS_PROTOCOL_VERSION_W2K3R2: val = "FRSTRANS_PROTOCOL_VERSION_W2K3R2"; break;
 
40
                        case FRSTRANS_PROTOCOL_VERSION_LONGHORN_SERVER: val = "FRSTRANS_PROTOCOL_VERSION_LONGHORN_SERVER"; break;
 
41
                }
 
42
                ndr_print_enum(ndr, name, "ENUM", val, r);
 
43
                ndr->flags = _flags_save_ENUM;
 
44
        }
 
45
}
 
46
 
 
47
static enum ndr_err_code ndr_push_frstrans_TransportFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
48
{
 
49
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
50
        return NDR_ERR_SUCCESS;
 
51
}
 
52
 
 
53
static enum ndr_err_code ndr_pull_frstrans_TransportFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
54
{
 
55
        uint32_t v;
 
56
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
57
        *r = v;
 
58
        return NDR_ERR_SUCCESS;
 
59
}
 
60
 
 
61
_PUBLIC_ void ndr_print_frstrans_TransportFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 
62
{
 
63
        ndr_print_uint32(ndr, name, r);
 
64
        ndr->depth++;
 
65
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "FRSTRANS_TRANSPORT_SUPPORTS_RDC_SIMILARITY", FRSTRANS_TRANSPORT_SUPPORTS_RDC_SIMILARITY, r);
 
66
        ndr->depth--;
 
67
}
 
68
 
 
69
static enum ndr_err_code ndr_push_frstrans_UpdateRequestType(struct ndr_push *ndr, int ndr_flags, enum frstrans_UpdateRequestType r)
 
70
{
 
71
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
72
        return NDR_ERR_SUCCESS;
 
73
}
 
74
 
 
75
static enum ndr_err_code ndr_pull_frstrans_UpdateRequestType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_UpdateRequestType *r)
 
76
{
 
77
        uint16_t v;
 
78
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
79
        *r = v;
 
80
        return NDR_ERR_SUCCESS;
 
81
}
 
82
 
 
83
_PUBLIC_ void ndr_print_frstrans_UpdateRequestType(struct ndr_print *ndr, const char *name, enum frstrans_UpdateRequestType r)
 
84
{
 
85
        const char *val = NULL;
 
86
 
 
87
        switch (r) {
 
88
                case FRSTRANS_UPDATE_REQUEST_ALL: val = "FRSTRANS_UPDATE_REQUEST_ALL"; break;
 
89
                case FRSTRANS_UPDATE_REQUEST_TOMBSTONES: val = "FRSTRANS_UPDATE_REQUEST_TOMBSTONES"; break;
 
90
                case FRSTRANS_UPDATE_REQUEST_LIVE: val = "FRSTRANS_UPDATE_REQUEST_LIVE"; break;
 
91
        }
 
92
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
93
}
 
94
 
 
95
static enum ndr_err_code ndr_push_frstrans_UpdateStatus(struct ndr_push *ndr, int ndr_flags, enum frstrans_UpdateStatus r)
 
96
{
 
97
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
98
        return NDR_ERR_SUCCESS;
 
99
}
 
100
 
 
101
static enum ndr_err_code ndr_pull_frstrans_UpdateStatus(struct ndr_pull *ndr, int ndr_flags, enum frstrans_UpdateStatus *r)
 
102
{
 
103
        uint16_t v;
 
104
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
105
        *r = v;
 
106
        return NDR_ERR_SUCCESS;
 
107
}
 
108
 
 
109
_PUBLIC_ void ndr_print_frstrans_UpdateStatus(struct ndr_print *ndr, const char *name, enum frstrans_UpdateStatus r)
 
110
{
 
111
        const char *val = NULL;
 
112
 
 
113
        switch (r) {
 
114
                case FRSTRANS_UPDATE_STATUS_DONE: val = "FRSTRANS_UPDATE_STATUS_DONE"; break;
 
115
                case FRSTRANS_UPDATE_STATUS_MORE: val = "FRSTRANS_UPDATE_STATUS_MORE"; break;
 
116
        }
 
117
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
118
}
 
119
 
 
120
static enum ndr_err_code ndr_push_frstrans_VersionVector(struct ndr_push *ndr, int ndr_flags, const struct frstrans_VersionVector *r)
 
121
{
 
122
        if (ndr_flags & NDR_SCALARS) {
 
123
                NDR_CHECK(ndr_push_align(ndr, 8));
 
124
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->db_guid));
 
125
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->low));
 
126
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->high));
 
127
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
128
        }
 
129
        if (ndr_flags & NDR_BUFFERS) {
 
130
        }
 
131
        return NDR_ERR_SUCCESS;
 
132
}
 
133
 
 
134
static enum ndr_err_code ndr_pull_frstrans_VersionVector(struct ndr_pull *ndr, int ndr_flags, struct frstrans_VersionVector *r)
 
135
{
 
136
        if (ndr_flags & NDR_SCALARS) {
 
137
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
138
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->db_guid));
 
139
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->low));
 
140
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->high));
 
141
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
142
        }
 
143
        if (ndr_flags & NDR_BUFFERS) {
 
144
        }
 
145
        return NDR_ERR_SUCCESS;
 
146
}
 
147
 
 
148
_PUBLIC_ void ndr_print_frstrans_VersionVector(struct ndr_print *ndr, const char *name, const struct frstrans_VersionVector *r)
 
149
{
 
150
        ndr_print_struct(ndr, name, "frstrans_VersionVector");
 
151
        if (r == NULL) { ndr_print_null(ndr); return; }
 
152
        ndr->depth++;
 
153
        ndr_print_GUID(ndr, "db_guid", &r->db_guid);
 
154
        ndr_print_hyper(ndr, "low", r->low);
 
155
        ndr_print_hyper(ndr, "high", r->high);
 
156
        ndr->depth--;
 
157
}
 
158
 
 
159
static enum ndr_err_code ndr_push_frstrans_Update(struct ndr_push *ndr, int ndr_flags, const struct frstrans_Update *r)
 
160
{
 
161
        {
 
162
                uint32_t _flags_save_STRUCT = ndr->flags;
 
163
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
164
                if (ndr_flags & NDR_SCALARS) {
 
165
                        NDR_CHECK(ndr_push_align(ndr, 8));
 
166
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->present));
 
167
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->name_conflict));
 
168
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attributes));
 
169
                        NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->fence));
 
170
                        NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->clock));
 
171
                        NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
 
172
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->content_set_guid));
 
173
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->sha1_hash, 20));
 
174
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->rdc_similarity, 16));
 
175
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uid_db_guid));
 
176
                        NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->uid_version));
 
177
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->gsvn_db_guid));
 
178
                        NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->gsvn_version));
 
179
                        NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->parent_db_guid));
 
180
                        NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->parent_version));
 
181
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
182
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
 
183
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 
184
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 
185
                        NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
186
                }
 
187
                if (ndr_flags & NDR_BUFFERS) {
 
188
                }
 
189
                ndr->flags = _flags_save_STRUCT;
 
190
        }
 
191
        return NDR_ERR_SUCCESS;
 
192
}
 
193
 
 
194
static enum ndr_err_code ndr_pull_frstrans_Update(struct ndr_pull *ndr, int ndr_flags, struct frstrans_Update *r)
 
195
{
 
196
        {
 
197
                uint32_t _flags_save_STRUCT = ndr->flags;
 
198
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
199
                if (ndr_flags & NDR_SCALARS) {
 
200
                        NDR_CHECK(ndr_pull_align(ndr, 8));
 
201
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->present));
 
202
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->name_conflict));
 
203
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attributes));
 
204
                        NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->fence));
 
205
                        NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->clock));
 
206
                        NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
 
207
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->content_set_guid));
 
208
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->sha1_hash, 20));
 
209
                        NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->rdc_similarity, 16));
 
210
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uid_db_guid));
 
211
                        NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->uid_version));
 
212
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->gsvn_db_guid));
 
213
                        NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->gsvn_version));
 
214
                        NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->parent_db_guid));
 
215
                        NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->parent_version));
 
216
                        NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
 
217
                        if (ndr_get_array_length(ndr, &r->name) > 261) {
 
218
                                return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", 261, ndr_get_array_length(ndr, &r->name));
 
219
                        }
 
220
                        NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
 
221
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
 
222
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 
223
                        NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
224
                }
 
225
                if (ndr_flags & NDR_BUFFERS) {
 
226
                }
 
227
                ndr->flags = _flags_save_STRUCT;
 
228
        }
 
229
        return NDR_ERR_SUCCESS;
 
230
}
 
231
 
 
232
_PUBLIC_ void ndr_print_frstrans_Update(struct ndr_print *ndr, const char *name, const struct frstrans_Update *r)
 
233
{
 
234
        ndr_print_struct(ndr, name, "frstrans_Update");
 
235
        if (r == NULL) { ndr_print_null(ndr); return; }
 
236
        {
 
237
                uint32_t _flags_save_STRUCT = ndr->flags;
 
238
                ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 
239
                ndr->depth++;
 
240
                ndr_print_uint32(ndr, "present", r->present);
 
241
                ndr_print_uint32(ndr, "name_conflict", r->name_conflict);
 
242
                ndr_print_uint32(ndr, "attributes", r->attributes);
 
243
                ndr_print_NTTIME(ndr, "fence", r->fence);
 
244
                ndr_print_NTTIME(ndr, "clock", r->clock);
 
245
                ndr_print_NTTIME(ndr, "create_time", r->create_time);
 
246
                ndr_print_GUID(ndr, "content_set_guid", &r->content_set_guid);
 
247
                ndr_print_array_uint8(ndr, "sha1_hash", r->sha1_hash, 20);
 
248
                ndr_print_array_uint8(ndr, "rdc_similarity", r->rdc_similarity, 16);
 
249
                ndr_print_GUID(ndr, "uid_db_guid", &r->uid_db_guid);
 
250
                ndr_print_hyper(ndr, "uid_version", r->uid_version);
 
251
                ndr_print_GUID(ndr, "gsvn_db_guid", &r->gsvn_db_guid);
 
252
                ndr_print_hyper(ndr, "gsvn_version", r->gsvn_version);
 
253
                ndr_print_GUID(ndr, "parent_db_guid", &r->parent_db_guid);
 
254
                ndr_print_hyper(ndr, "parent_version", r->parent_version);
 
255
                ndr_print_string(ndr, "name", r->name);
 
256
                ndr_print_uint32(ndr, "flags", r->flags);
 
257
                ndr->depth--;
 
258
                ndr->flags = _flags_save_STRUCT;
 
259
        }
 
260
}
 
261
 
 
262
static enum ndr_err_code ndr_push_frstrans_VersionRequestType(struct ndr_push *ndr, int ndr_flags, enum frstrans_VersionRequestType r)
 
263
{
 
264
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
265
        return NDR_ERR_SUCCESS;
 
266
}
 
267
 
 
268
static enum ndr_err_code ndr_pull_frstrans_VersionRequestType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_VersionRequestType *r)
 
269
{
 
270
        uint16_t v;
 
271
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
272
        *r = v;
 
273
        return NDR_ERR_SUCCESS;
 
274
}
 
275
 
 
276
_PUBLIC_ void ndr_print_frstrans_VersionRequestType(struct ndr_print *ndr, const char *name, enum frstrans_VersionRequestType r)
 
277
{
 
278
        const char *val = NULL;
 
279
 
 
280
        switch (r) {
 
281
                case FRSTRANS_VERSION_REQUEST_NORNAL_SYNC: val = "FRSTRANS_VERSION_REQUEST_NORNAL_SYNC"; break;
 
282
                case FRSTRANS_VERSION_REQUEST_SLOW_SYNC: val = "FRSTRANS_VERSION_REQUEST_SLOW_SYNC"; break;
 
283
                case FRSTRANS_VERSION_REQUEST_SLAVE_SYNC: val = "FRSTRANS_VERSION_REQUEST_SLAVE_SYNC"; break;
 
284
        }
 
285
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
286
}
 
287
 
 
288
static enum ndr_err_code ndr_push_frstrans_VersionChangeType(struct ndr_push *ndr, int ndr_flags, enum frstrans_VersionChangeType r)
 
289
{
 
290
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
291
        return NDR_ERR_SUCCESS;
 
292
}
 
293
 
 
294
static enum ndr_err_code ndr_pull_frstrans_VersionChangeType(struct ndr_pull *ndr, int ndr_flags, enum frstrans_VersionChangeType *r)
 
295
{
 
296
        uint16_t v;
 
297
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
298
        *r = v;
 
299
        return NDR_ERR_SUCCESS;
 
300
}
 
301
 
 
302
_PUBLIC_ void ndr_print_frstrans_VersionChangeType(struct ndr_print *ndr, const char *name, enum frstrans_VersionChangeType r)
 
303
{
 
304
        const char *val = NULL;
 
305
 
 
306
        switch (r) {
 
307
                case FRSTRANS_VERSION_CHANGE_NOTIFY: val = "FRSTRANS_VERSION_CHANGE_NOTIFY"; break;
 
308
                case FRSTRANS_VERSION_CHANGE_ALL: val = "FRSTRANS_VERSION_CHANGE_ALL"; break;
 
309
        }
 
310
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
311
}
 
312
 
 
313
static enum ndr_err_code ndr_push_frstrans_EpoqueVector(struct ndr_push *ndr, int ndr_flags, const struct frstrans_EpoqueVector *r)
 
314
{
 
315
        if (ndr_flags & NDR_SCALARS) {
 
316
                NDR_CHECK(ndr_push_align(ndr, 4));
 
317
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->machine_guid));
 
318
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->year));
 
319
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->month));
 
320
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day_of_week));
 
321
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->day));
 
322
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->hour));
 
323
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minute));
 
324
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->second));
 
325
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->milli_seconds));
 
326
                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 
327
        }
 
328
        if (ndr_flags & NDR_BUFFERS) {
 
329
        }
 
330
        return NDR_ERR_SUCCESS;
 
331
}
 
332
 
 
333
static enum ndr_err_code ndr_pull_frstrans_EpoqueVector(struct ndr_pull *ndr, int ndr_flags, struct frstrans_EpoqueVector *r)
 
334
{
 
335
        if (ndr_flags & NDR_SCALARS) {
 
336
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
337
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->machine_guid));
 
338
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->year));
 
339
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->month));
 
340
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day_of_week));
 
341
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->day));
 
342
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->hour));
 
343
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minute));
 
344
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->second));
 
345
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->milli_seconds));
 
346
                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 
347
        }
 
348
        if (ndr_flags & NDR_BUFFERS) {
 
349
        }
 
350
        return NDR_ERR_SUCCESS;
 
351
}
 
352
 
 
353
_PUBLIC_ void ndr_print_frstrans_EpoqueVector(struct ndr_print *ndr, const char *name, const struct frstrans_EpoqueVector *r)
 
354
{
 
355
        ndr_print_struct(ndr, name, "frstrans_EpoqueVector");
 
356
        if (r == NULL) { ndr_print_null(ndr); return; }
 
357
        ndr->depth++;
 
358
        ndr_print_GUID(ndr, "machine_guid", &r->machine_guid);
 
359
        ndr_print_uint32(ndr, "year", r->year);
 
360
        ndr_print_uint32(ndr, "month", r->month);
 
361
        ndr_print_uint32(ndr, "day_of_week", r->day_of_week);
 
362
        ndr_print_uint32(ndr, "day", r->day);
 
363
        ndr_print_uint32(ndr, "hour", r->hour);
 
364
        ndr_print_uint32(ndr, "minute", r->minute);
 
365
        ndr_print_uint32(ndr, "second", r->second);
 
366
        ndr_print_uint32(ndr, "milli_seconds", r->milli_seconds);
 
367
        ndr->depth--;
 
368
}
 
369
 
 
370
static enum ndr_err_code ndr_push_frstrans_AsyncVersionVectorResponse(struct ndr_push *ndr, int ndr_flags, const struct frstrans_AsyncVersionVectorResponse *r)
 
371
{
 
372
        uint32_t cntr_version_vector_1;
 
373
        uint32_t cntr_epoque_vector_1;
 
374
        if (ndr_flags & NDR_SCALARS) {
 
375
                NDR_CHECK(ndr_push_align(ndr, 8));
 
376
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->vv_generation));
 
377
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version_vector_count));
 
378
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->version_vector));
 
379
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->epoque_vector_count));
 
380
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->epoque_vector));
 
381
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
382
        }
 
383
        if (ndr_flags & NDR_BUFFERS) {
 
384
                if (r->version_vector) {
 
385
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->version_vector_count));
 
386
                        for (cntr_version_vector_1 = 0; cntr_version_vector_1 < r->version_vector_count; cntr_version_vector_1++) {
 
387
                                NDR_CHECK(ndr_push_frstrans_VersionVector(ndr, NDR_SCALARS, &r->version_vector[cntr_version_vector_1]));
 
388
                        }
 
389
                }
 
390
                if (r->epoque_vector) {
 
391
                        NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->epoque_vector_count));
 
392
                        for (cntr_epoque_vector_1 = 0; cntr_epoque_vector_1 < r->epoque_vector_count; cntr_epoque_vector_1++) {
 
393
                                NDR_CHECK(ndr_push_frstrans_EpoqueVector(ndr, NDR_SCALARS, &r->epoque_vector[cntr_epoque_vector_1]));
 
394
                        }
 
395
                }
 
396
        }
 
397
        return NDR_ERR_SUCCESS;
 
398
}
 
399
 
 
400
static enum ndr_err_code ndr_pull_frstrans_AsyncVersionVectorResponse(struct ndr_pull *ndr, int ndr_flags, struct frstrans_AsyncVersionVectorResponse *r)
 
401
{
 
402
        uint32_t _ptr_version_vector;
 
403
        uint32_t cntr_version_vector_1;
 
404
        TALLOC_CTX *_mem_save_version_vector_0;
 
405
        TALLOC_CTX *_mem_save_version_vector_1;
 
406
        uint32_t _ptr_epoque_vector;
 
407
        uint32_t cntr_epoque_vector_1;
 
408
        TALLOC_CTX *_mem_save_epoque_vector_0;
 
409
        TALLOC_CTX *_mem_save_epoque_vector_1;
 
410
        if (ndr_flags & NDR_SCALARS) {
 
411
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
412
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->vv_generation));
 
413
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version_vector_count));
 
414
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_version_vector));
 
415
                if (_ptr_version_vector) {
 
416
                        NDR_PULL_ALLOC(ndr, r->version_vector);
 
417
                } else {
 
418
                        r->version_vector = NULL;
 
419
                }
 
420
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->epoque_vector_count));
 
421
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_epoque_vector));
 
422
                if (_ptr_epoque_vector) {
 
423
                        NDR_PULL_ALLOC(ndr, r->epoque_vector);
 
424
                } else {
 
425
                        r->epoque_vector = NULL;
 
426
                }
 
427
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
428
        }
 
429
        if (ndr_flags & NDR_BUFFERS) {
 
430
                if (r->version_vector) {
 
431
                        _mem_save_version_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
432
                        NDR_PULL_SET_MEM_CTX(ndr, r->version_vector, 0);
 
433
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->version_vector));
 
434
                        NDR_PULL_ALLOC_N(ndr, r->version_vector, ndr_get_array_size(ndr, &r->version_vector));
 
435
                        _mem_save_version_vector_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
436
                        NDR_PULL_SET_MEM_CTX(ndr, r->version_vector, 0);
 
437
                        for (cntr_version_vector_1 = 0; cntr_version_vector_1 < r->version_vector_count; cntr_version_vector_1++) {
 
438
                                NDR_CHECK(ndr_pull_frstrans_VersionVector(ndr, NDR_SCALARS, &r->version_vector[cntr_version_vector_1]));
 
439
                        }
 
440
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_1, 0);
 
441
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_0, 0);
 
442
                }
 
443
                if (r->epoque_vector) {
 
444
                        _mem_save_epoque_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
445
                        NDR_PULL_SET_MEM_CTX(ndr, r->epoque_vector, 0);
 
446
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->epoque_vector));
 
447
                        NDR_PULL_ALLOC_N(ndr, r->epoque_vector, ndr_get_array_size(ndr, &r->epoque_vector));
 
448
                        _mem_save_epoque_vector_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
449
                        NDR_PULL_SET_MEM_CTX(ndr, r->epoque_vector, 0);
 
450
                        for (cntr_epoque_vector_1 = 0; cntr_epoque_vector_1 < r->epoque_vector_count; cntr_epoque_vector_1++) {
 
451
                                NDR_CHECK(ndr_pull_frstrans_EpoqueVector(ndr, NDR_SCALARS, &r->epoque_vector[cntr_epoque_vector_1]));
 
452
                        }
 
453
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epoque_vector_1, 0);
 
454
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_epoque_vector_0, 0);
 
455
                }
 
456
                if (r->version_vector) {
 
457
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->version_vector, r->version_vector_count));
 
458
                }
 
459
                if (r->epoque_vector) {
 
460
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->epoque_vector, r->epoque_vector_count));
 
461
                }
 
462
        }
 
463
        return NDR_ERR_SUCCESS;
 
464
}
 
465
 
 
466
_PUBLIC_ void ndr_print_frstrans_AsyncVersionVectorResponse(struct ndr_print *ndr, const char *name, const struct frstrans_AsyncVersionVectorResponse *r)
 
467
{
 
468
        uint32_t cntr_version_vector_1;
 
469
        uint32_t cntr_epoque_vector_1;
 
470
        ndr_print_struct(ndr, name, "frstrans_AsyncVersionVectorResponse");
 
471
        if (r == NULL) { ndr_print_null(ndr); return; }
 
472
        ndr->depth++;
 
473
        ndr_print_hyper(ndr, "vv_generation", r->vv_generation);
 
474
        ndr_print_uint32(ndr, "version_vector_count", r->version_vector_count);
 
475
        ndr_print_ptr(ndr, "version_vector", r->version_vector);
 
476
        ndr->depth++;
 
477
        if (r->version_vector) {
 
478
                ndr->print(ndr, "%s: ARRAY(%d)", "version_vector", (int)r->version_vector_count);
 
479
                ndr->depth++;
 
480
                for (cntr_version_vector_1=0;cntr_version_vector_1<r->version_vector_count;cntr_version_vector_1++) {
 
481
                        ndr_print_frstrans_VersionVector(ndr, "version_vector", &r->version_vector[cntr_version_vector_1]);
 
482
                }
 
483
                ndr->depth--;
 
484
        }
 
485
        ndr->depth--;
 
486
        ndr_print_uint32(ndr, "epoque_vector_count", r->epoque_vector_count);
 
487
        ndr_print_ptr(ndr, "epoque_vector", r->epoque_vector);
 
488
        ndr->depth++;
 
489
        if (r->epoque_vector) {
 
490
                ndr->print(ndr, "%s: ARRAY(%d)", "epoque_vector", (int)r->epoque_vector_count);
 
491
                ndr->depth++;
 
492
                for (cntr_epoque_vector_1=0;cntr_epoque_vector_1<r->epoque_vector_count;cntr_epoque_vector_1++) {
 
493
                        ndr_print_frstrans_EpoqueVector(ndr, "epoque_vector", &r->epoque_vector[cntr_epoque_vector_1]);
 
494
                }
 
495
                ndr->depth--;
 
496
        }
 
497
        ndr->depth--;
 
498
        ndr->depth--;
 
499
}
 
500
 
 
501
static enum ndr_err_code ndr_push_frstrans_AsyncResponseContext(struct ndr_push *ndr, int ndr_flags, const struct frstrans_AsyncResponseContext *r)
 
502
{
 
503
        if (ndr_flags & NDR_SCALARS) {
 
504
                NDR_CHECK(ndr_push_align(ndr, 8));
 
505
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sequence_number));
 
506
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
 
507
                NDR_CHECK(ndr_push_frstrans_AsyncVersionVectorResponse(ndr, NDR_SCALARS, &r->response));
 
508
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
509
        }
 
510
        if (ndr_flags & NDR_BUFFERS) {
 
511
                NDR_CHECK(ndr_push_frstrans_AsyncVersionVectorResponse(ndr, NDR_BUFFERS, &r->response));
 
512
        }
 
513
        return NDR_ERR_SUCCESS;
 
514
}
 
515
 
 
516
static enum ndr_err_code ndr_pull_frstrans_AsyncResponseContext(struct ndr_pull *ndr, int ndr_flags, struct frstrans_AsyncResponseContext *r)
 
517
{
 
518
        if (ndr_flags & NDR_SCALARS) {
 
519
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
520
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sequence_number));
 
521
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
 
522
                NDR_CHECK(ndr_pull_frstrans_AsyncVersionVectorResponse(ndr, NDR_SCALARS, &r->response));
 
523
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
524
        }
 
525
        if (ndr_flags & NDR_BUFFERS) {
 
526
                NDR_CHECK(ndr_pull_frstrans_AsyncVersionVectorResponse(ndr, NDR_BUFFERS, &r->response));
 
527
        }
 
528
        return NDR_ERR_SUCCESS;
 
529
}
 
530
 
 
531
_PUBLIC_ void ndr_print_frstrans_AsyncResponseContext(struct ndr_print *ndr, const char *name, const struct frstrans_AsyncResponseContext *r)
 
532
{
 
533
        ndr_print_struct(ndr, name, "frstrans_AsyncResponseContext");
 
534
        if (r == NULL) { ndr_print_null(ndr); return; }
 
535
        ndr->depth++;
 
536
        ndr_print_uint32(ndr, "sequence_number", r->sequence_number);
 
537
        ndr_print_WERROR(ndr, "status", r->status);
 
538
        ndr_print_frstrans_AsyncVersionVectorResponse(ndr, "response", &r->response);
 
539
        ndr->depth--;
 
540
}
 
541
 
 
542
static enum ndr_err_code ndr_push_frstrans_RequestedStagingPolicy(struct ndr_push *ndr, int ndr_flags, enum frstrans_RequestedStagingPolicy r)
 
543
{
 
544
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
545
        return NDR_ERR_SUCCESS;
 
546
}
 
547
 
 
548
static enum ndr_err_code ndr_pull_frstrans_RequestedStagingPolicy(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RequestedStagingPolicy *r)
 
549
{
 
550
        uint16_t v;
 
551
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
552
        *r = v;
 
553
        return NDR_ERR_SUCCESS;
 
554
}
 
555
 
 
556
_PUBLIC_ void ndr_print_frstrans_RequestedStagingPolicy(struct ndr_print *ndr, const char *name, enum frstrans_RequestedStagingPolicy r)
 
557
{
 
558
        const char *val = NULL;
 
559
 
 
560
        switch (r) {
 
561
                case FRSTRANS_STAGING_POLICY_SERVER_DEFAULTY: val = "FRSTRANS_STAGING_POLICY_SERVER_DEFAULTY"; break;
 
562
                case FRSTRANS_STAGING_POLICY_STATGING_REQUIRED: val = "FRSTRANS_STAGING_POLICY_STATGING_REQUIRED"; break;
 
563
                case FRSTRANS_STAGING_POLICY_RESTATGING_REQUIRED: val = "FRSTRANS_STAGING_POLICY_RESTATGING_REQUIRED"; break;
 
564
        }
 
565
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
566
}
 
567
 
 
568
static enum ndr_err_code ndr_push_frstrans_RdcChunckerAlgorithm(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcChunckerAlgorithm r)
 
569
{
 
570
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
571
        return NDR_ERR_SUCCESS;
 
572
}
 
573
 
 
574
static enum ndr_err_code ndr_pull_frstrans_RdcChunckerAlgorithm(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcChunckerAlgorithm *r)
 
575
{
 
576
        uint16_t v;
 
577
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
578
        *r = v;
 
579
        return NDR_ERR_SUCCESS;
 
580
}
 
581
 
 
582
_PUBLIC_ void ndr_print_frstrans_RdcChunckerAlgorithm(struct ndr_print *ndr, const char *name, enum frstrans_RdcChunckerAlgorithm r)
 
583
{
 
584
        const char *val = NULL;
 
585
 
 
586
        switch (r) {
 
587
                case FRSTRANS_RDC_FILTER_GENERIC: val = "FRSTRANS_RDC_FILTER_GENERIC"; break;
 
588
                case FRSTRANS_RDC_FILTER_MAX: val = "FRSTRANS_RDC_FILTER_MAX"; break;
 
589
                case FRSTRANS_RDC_FILTER_POINT: val = "FRSTRANS_RDC_FILTER_POINT"; break;
 
590
                case FRSTRANS_RDC_MAX_ALGORITHM: val = "FRSTRANS_RDC_MAX_ALGORITHM"; break;
 
591
        }
 
592
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
593
}
 
594
 
 
595
static enum ndr_err_code ndr_push_frstrans_RdcParameterGeneric(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterGeneric *r)
 
596
{
 
597
        if (ndr_flags & NDR_SCALARS) {
 
598
                NDR_CHECK(ndr_push_align(ndr, 3));
 
599
                NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, r->chunker_type));
 
600
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->chunker_parameters, 64));
 
601
                NDR_CHECK(ndr_push_trailer_align(ndr, 3));
 
602
        }
 
603
        if (ndr_flags & NDR_BUFFERS) {
 
604
        }
 
605
        return NDR_ERR_SUCCESS;
 
606
}
 
607
 
 
608
static enum ndr_err_code ndr_pull_frstrans_RdcParameterGeneric(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterGeneric *r)
 
609
{
 
610
        if (ndr_flags & NDR_SCALARS) {
 
611
                NDR_CHECK(ndr_pull_align(ndr, 3));
 
612
                NDR_CHECK(ndr_pull_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, &r->chunker_type));
 
613
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->chunker_parameters, 64));
 
614
                NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
 
615
        }
 
616
        if (ndr_flags & NDR_BUFFERS) {
 
617
        }
 
618
        return NDR_ERR_SUCCESS;
 
619
}
 
620
 
 
621
_PUBLIC_ void ndr_print_frstrans_RdcParameterGeneric(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterGeneric *r)
 
622
{
 
623
        ndr_print_struct(ndr, name, "frstrans_RdcParameterGeneric");
 
624
        if (r == NULL) { ndr_print_null(ndr); return; }
 
625
        ndr->depth++;
 
626
        ndr_print_frstrans_RdcChunckerAlgorithm(ndr, "chunker_type", r->chunker_type);
 
627
        ndr_print_array_uint8(ndr, "chunker_parameters", r->chunker_parameters, 64);
 
628
        ndr->depth--;
 
629
}
 
630
 
 
631
static enum ndr_err_code ndr_push_frstrans_RdcParameterFilterMax(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterFilterMax *r)
 
632
{
 
633
        if (ndr_flags & NDR_SCALARS) {
 
634
                NDR_CHECK(ndr_push_align(ndr, 2));
 
635
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_horizon_size));
 
636
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_window_size));
 
637
                NDR_CHECK(ndr_push_trailer_align(ndr, 2));
 
638
        }
 
639
        if (ndr_flags & NDR_BUFFERS) {
 
640
        }
 
641
        return NDR_ERR_SUCCESS;
 
642
}
 
643
 
 
644
static enum ndr_err_code ndr_pull_frstrans_RdcParameterFilterMax(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterFilterMax *r)
 
645
{
 
646
        if (ndr_flags & NDR_SCALARS) {
 
647
                NDR_CHECK(ndr_pull_align(ndr, 2));
 
648
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_horizon_size));
 
649
                if (r->min_horizon_size < 128 || r->min_horizon_size > 1024*16) {
 
650
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
651
                }
 
652
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_window_size));
 
653
                if (r->max_window_size < 2 || r->max_window_size > 96) {
 
654
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
655
                }
 
656
                NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
 
657
        }
 
658
        if (ndr_flags & NDR_BUFFERS) {
 
659
        }
 
660
        return NDR_ERR_SUCCESS;
 
661
}
 
662
 
 
663
_PUBLIC_ void ndr_print_frstrans_RdcParameterFilterMax(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterFilterMax *r)
 
664
{
 
665
        ndr_print_struct(ndr, name, "frstrans_RdcParameterFilterMax");
 
666
        if (r == NULL) { ndr_print_null(ndr); return; }
 
667
        ndr->depth++;
 
668
        ndr_print_uint16(ndr, "min_horizon_size", r->min_horizon_size);
 
669
        ndr_print_uint16(ndr, "max_window_size", r->max_window_size);
 
670
        ndr->depth--;
 
671
}
 
672
 
 
673
static enum ndr_err_code ndr_push_frstrans_RdcParameterFilterPoint(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameterFilterPoint *r)
 
674
{
 
675
        if (ndr_flags & NDR_SCALARS) {
 
676
                NDR_CHECK(ndr_push_align(ndr, 2));
 
677
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->min_chunk_size));
 
678
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->max_chunk_size));
 
679
                NDR_CHECK(ndr_push_trailer_align(ndr, 2));
 
680
        }
 
681
        if (ndr_flags & NDR_BUFFERS) {
 
682
        }
 
683
        return NDR_ERR_SUCCESS;
 
684
}
 
685
 
 
686
static enum ndr_err_code ndr_pull_frstrans_RdcParameterFilterPoint(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameterFilterPoint *r)
 
687
{
 
688
        if (ndr_flags & NDR_SCALARS) {
 
689
                NDR_CHECK(ndr_pull_align(ndr, 2));
 
690
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->min_chunk_size));
 
691
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->max_chunk_size));
 
692
                NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
 
693
        }
 
694
        if (ndr_flags & NDR_BUFFERS) {
 
695
        }
 
696
        return NDR_ERR_SUCCESS;
 
697
}
 
698
 
 
699
_PUBLIC_ void ndr_print_frstrans_RdcParameterFilterPoint(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameterFilterPoint *r)
 
700
{
 
701
        ndr_print_struct(ndr, name, "frstrans_RdcParameterFilterPoint");
 
702
        if (r == NULL) { ndr_print_null(ndr); return; }
 
703
        ndr->depth++;
 
704
        ndr_print_uint16(ndr, "min_chunk_size", r->min_chunk_size);
 
705
        ndr_print_uint16(ndr, "max_chunk_size", r->max_chunk_size);
 
706
        ndr->depth--;
 
707
}
 
708
 
 
709
static enum ndr_err_code ndr_push_frstrans_RdcParameterUnion(struct ndr_push *ndr, int ndr_flags, const union frstrans_RdcParameterUnion *r)
 
710
{
 
711
        if (ndr_flags & NDR_SCALARS) {
 
712
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
713
                NDR_CHECK(ndr_push_union_align(ndr, 3));
 
714
                NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, level));
 
715
                NDR_CHECK(ndr_push_union_align(ndr, 3));
 
716
                switch (level) {
 
717
                        case FRSTRANS_RDC_FILTER_GENERIC: {
 
718
                                NDR_CHECK(ndr_push_frstrans_RdcParameterGeneric(ndr, NDR_SCALARS, &r->filter_generic));
 
719
                        break; }
 
720
 
 
721
                        case FRSTRANS_RDC_FILTER_MAX: {
 
722
                                NDR_CHECK(ndr_push_frstrans_RdcParameterFilterMax(ndr, NDR_SCALARS, &r->filter_max));
 
723
                        break; }
 
724
 
 
725
                        case FRSTRANS_RDC_FILTER_POINT: {
 
726
                                NDR_CHECK(ndr_push_frstrans_RdcParameterFilterPoint(ndr, NDR_SCALARS, &r->filter_point));
 
727
                        break; }
 
728
 
 
729
                        default:
 
730
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
731
                }
 
732
        }
 
733
        if (ndr_flags & NDR_BUFFERS) {
 
734
                uint32_t level = ndr_push_get_switch_value(ndr, r);
 
735
                switch (level) {
 
736
                        case FRSTRANS_RDC_FILTER_GENERIC:
 
737
                        break;
 
738
 
 
739
                        case FRSTRANS_RDC_FILTER_MAX:
 
740
                        break;
 
741
 
 
742
                        case FRSTRANS_RDC_FILTER_POINT:
 
743
                        break;
 
744
 
 
745
                        default:
 
746
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
747
                }
 
748
        }
 
749
        return NDR_ERR_SUCCESS;
 
750
}
 
751
 
 
752
static enum ndr_err_code ndr_pull_frstrans_RdcParameterUnion(struct ndr_pull *ndr, int ndr_flags, union frstrans_RdcParameterUnion *r)
 
753
{
 
754
        uint32_t level;
 
755
        uint16_t _level;
 
756
        level = ndr_pull_get_switch_value(ndr, r);
 
757
        if (ndr_flags & NDR_SCALARS) {
 
758
                NDR_CHECK(ndr_pull_union_align(ndr, 3));
 
759
                NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
 
760
                if (_level != level) {
 
761
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 
762
                }
 
763
                NDR_CHECK(ndr_pull_union_align(ndr, 3));
 
764
                switch (level) {
 
765
                        case FRSTRANS_RDC_FILTER_GENERIC: {
 
766
                                NDR_CHECK(ndr_pull_frstrans_RdcParameterGeneric(ndr, NDR_SCALARS, &r->filter_generic));
 
767
                        break; }
 
768
 
 
769
                        case FRSTRANS_RDC_FILTER_MAX: {
 
770
                                NDR_CHECK(ndr_pull_frstrans_RdcParameterFilterMax(ndr, NDR_SCALARS, &r->filter_max));
 
771
                        break; }
 
772
 
 
773
                        case FRSTRANS_RDC_FILTER_POINT: {
 
774
                                NDR_CHECK(ndr_pull_frstrans_RdcParameterFilterPoint(ndr, NDR_SCALARS, &r->filter_point));
 
775
                        break; }
 
776
 
 
777
                        default:
 
778
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
779
                }
 
780
        }
 
781
        if (ndr_flags & NDR_BUFFERS) {
 
782
                switch (level) {
 
783
                        case FRSTRANS_RDC_FILTER_GENERIC:
 
784
                        break;
 
785
 
 
786
                        case FRSTRANS_RDC_FILTER_MAX:
 
787
                        break;
 
788
 
 
789
                        case FRSTRANS_RDC_FILTER_POINT:
 
790
                        break;
 
791
 
 
792
                        default:
 
793
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 
794
                }
 
795
        }
 
796
        return NDR_ERR_SUCCESS;
 
797
}
 
798
 
 
799
_PUBLIC_ void ndr_print_frstrans_RdcParameterUnion(struct ndr_print *ndr, const char *name, const union frstrans_RdcParameterUnion *r)
 
800
{
 
801
        uint32_t level;
 
802
        level = ndr_print_get_switch_value(ndr, r);
 
803
        ndr_print_union(ndr, name, level, "frstrans_RdcParameterUnion");
 
804
        switch (level) {
 
805
                case FRSTRANS_RDC_FILTER_GENERIC:
 
806
                        ndr_print_frstrans_RdcParameterGeneric(ndr, "filter_generic", &r->filter_generic);
 
807
                break;
 
808
 
 
809
                case FRSTRANS_RDC_FILTER_MAX:
 
810
                        ndr_print_frstrans_RdcParameterFilterMax(ndr, "filter_max", &r->filter_max);
 
811
                break;
 
812
 
 
813
                case FRSTRANS_RDC_FILTER_POINT:
 
814
                        ndr_print_frstrans_RdcParameterFilterPoint(ndr, "filter_point", &r->filter_point);
 
815
                break;
 
816
 
 
817
                default:
 
818
                        ndr_print_bad_level(ndr, name, level);
 
819
        }
 
820
}
 
821
 
 
822
static enum ndr_err_code ndr_push_frstrans_RdcParameters(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcParameters *r)
 
823
{
 
824
        if (ndr_flags & NDR_SCALARS) {
 
825
                NDR_CHECK(ndr_push_align(ndr, 3));
 
826
                NDR_CHECK(ndr_push_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, r->rdc_chunker_algorithm));
 
827
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm));
 
828
                NDR_CHECK(ndr_push_frstrans_RdcParameterUnion(ndr, NDR_SCALARS, &r->u));
 
829
                NDR_CHECK(ndr_push_trailer_align(ndr, 3));
 
830
        }
 
831
        if (ndr_flags & NDR_BUFFERS) {
 
832
        }
 
833
        return NDR_ERR_SUCCESS;
 
834
}
 
835
 
 
836
static enum ndr_err_code ndr_pull_frstrans_RdcParameters(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcParameters *r)
 
837
{
 
838
        if (ndr_flags & NDR_SCALARS) {
 
839
                NDR_CHECK(ndr_pull_align(ndr, 3));
 
840
                NDR_CHECK(ndr_pull_frstrans_RdcChunckerAlgorithm(ndr, NDR_SCALARS, &r->rdc_chunker_algorithm));
 
841
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm));
 
842
                NDR_CHECK(ndr_pull_frstrans_RdcParameterUnion(ndr, NDR_SCALARS, &r->u));
 
843
                NDR_CHECK(ndr_pull_trailer_align(ndr, 3));
 
844
        }
 
845
        if (ndr_flags & NDR_BUFFERS) {
 
846
        }
 
847
        return NDR_ERR_SUCCESS;
 
848
}
 
849
 
 
850
_PUBLIC_ void ndr_print_frstrans_RdcParameters(struct ndr_print *ndr, const char *name, const struct frstrans_RdcParameters *r)
 
851
{
 
852
        ndr_print_struct(ndr, name, "frstrans_RdcParameters");
 
853
        if (r == NULL) { ndr_print_null(ndr); return; }
 
854
        ndr->depth++;
 
855
        ndr_print_frstrans_RdcChunckerAlgorithm(ndr, "rdc_chunker_algorithm", r->rdc_chunker_algorithm);
 
856
        ndr_print_set_switch_value(ndr, &r->u, r->rdc_chunker_algorithm);
 
857
        ndr_print_frstrans_RdcParameterUnion(ndr, "u", &r->u);
 
858
        ndr->depth--;
 
859
}
 
860
 
 
861
static enum ndr_err_code ndr_push_frstrans_RdcVersion(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcVersion r)
 
862
{
 
863
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
864
        return NDR_ERR_SUCCESS;
 
865
}
 
866
 
 
867
static enum ndr_err_code ndr_pull_frstrans_RdcVersion(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcVersion *r)
 
868
{
 
869
        uint16_t v;
 
870
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
871
        *r = v;
 
872
        return NDR_ERR_SUCCESS;
 
873
}
 
874
 
 
875
_PUBLIC_ void ndr_print_frstrans_RdcVersion(struct ndr_print *ndr, const char *name, enum frstrans_RdcVersion r)
 
876
{
 
877
        const char *val = NULL;
 
878
 
 
879
        switch (r) {
 
880
                case FRSTRANS_RDC_VERSION: val = "FRSTRANS_RDC_VERSION"; break;
 
881
        }
 
882
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
883
}
 
884
 
 
885
static enum ndr_err_code ndr_push_frstrans_RdcVersionCompatible(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcVersionCompatible r)
 
886
{
 
887
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
888
        return NDR_ERR_SUCCESS;
 
889
}
 
890
 
 
891
static enum ndr_err_code ndr_pull_frstrans_RdcVersionCompatible(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcVersionCompatible *r)
 
892
{
 
893
        uint16_t v;
 
894
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
895
        *r = v;
 
896
        return NDR_ERR_SUCCESS;
 
897
}
 
898
 
 
899
_PUBLIC_ void ndr_print_frstrans_RdcVersionCompatible(struct ndr_print *ndr, const char *name, enum frstrans_RdcVersionCompatible r)
 
900
{
 
901
        const char *val = NULL;
 
902
 
 
903
        switch (r) {
 
904
                case FRSTRANS_RDC_VERSION_COMPATIBLE: val = "FRSTRANS_RDC_VERSION_COMPATIBLE"; break;
 
905
        }
 
906
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
907
}
 
908
 
 
909
static enum ndr_err_code ndr_push_frstrans_RdcCompressionAlgorithm(struct ndr_push *ndr, int ndr_flags, enum frstrans_RdcCompressionAlgorithm r)
 
910
{
 
911
        NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 
912
        return NDR_ERR_SUCCESS;
 
913
}
 
914
 
 
915
static enum ndr_err_code ndr_pull_frstrans_RdcCompressionAlgorithm(struct ndr_pull *ndr, int ndr_flags, enum frstrans_RdcCompressionAlgorithm *r)
 
916
{
 
917
        uint16_t v;
 
918
        NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 
919
        *r = v;
 
920
        return NDR_ERR_SUCCESS;
 
921
}
 
922
 
 
923
_PUBLIC_ void ndr_print_frstrans_RdcCompressionAlgorithm(struct ndr_print *ndr, const char *name, enum frstrans_RdcCompressionAlgorithm r)
 
924
{
 
925
        const char *val = NULL;
 
926
 
 
927
        switch (r) {
 
928
                case FRSTRANS_RDC_UNCOMPRESSED: val = "FRSTRANS_RDC_UNCOMPRESSED"; break;
 
929
                case FRSTRANS_RDC_XPRESS: val = "FRSTRANS_RDC_XPRESS"; break;
 
930
        }
 
931
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
932
}
 
933
 
 
934
static enum ndr_err_code ndr_push_frstrans_RdcFileInfo(struct ndr_push *ndr, int ndr_flags, const struct frstrans_RdcFileInfo *r)
 
935
{
 
936
        uint32_t cntr_rdc_filter_parameters_0;
 
937
        if (ndr_flags & NDR_SCALARS) {
 
938
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->rdc_signature_levels));
 
939
                NDR_CHECK(ndr_push_align(ndr, 8));
 
940
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->on_disk_file_size));
 
941
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->file_size_estimate));
 
942
                NDR_CHECK(ndr_push_frstrans_RdcVersion(ndr, NDR_SCALARS, r->rdc_version));
 
943
                NDR_CHECK(ndr_push_frstrans_RdcVersionCompatible(ndr, NDR_SCALARS, r->rdc_minimum_compatible_version));
 
944
                NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->rdc_signature_levels));
 
945
                NDR_CHECK(ndr_push_frstrans_RdcCompressionAlgorithm(ndr, NDR_SCALARS, r->compression_algorithm));
 
946
                for (cntr_rdc_filter_parameters_0 = 0; cntr_rdc_filter_parameters_0 < r->rdc_signature_levels; cntr_rdc_filter_parameters_0++) {
 
947
                        NDR_CHECK(ndr_push_frstrans_RdcParameters(ndr, NDR_SCALARS, &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]));
 
948
                }
 
949
                NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 
950
        }
 
951
        if (ndr_flags & NDR_BUFFERS) {
 
952
        }
 
953
        return NDR_ERR_SUCCESS;
 
954
}
 
955
 
 
956
static enum ndr_err_code ndr_pull_frstrans_RdcFileInfo(struct ndr_pull *ndr, int ndr_flags, struct frstrans_RdcFileInfo *r)
 
957
{
 
958
        uint32_t cntr_rdc_filter_parameters_0;
 
959
        TALLOC_CTX *_mem_save_rdc_filter_parameters_0;
 
960
        if (ndr_flags & NDR_SCALARS) {
 
961
                NDR_CHECK(ndr_pull_array_size(ndr, &r->rdc_filter_parameters));
 
962
                NDR_CHECK(ndr_pull_align(ndr, 8));
 
963
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->on_disk_file_size));
 
964
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->file_size_estimate));
 
965
                NDR_CHECK(ndr_pull_frstrans_RdcVersion(ndr, NDR_SCALARS, &r->rdc_version));
 
966
                NDR_CHECK(ndr_pull_frstrans_RdcVersionCompatible(ndr, NDR_SCALARS, &r->rdc_minimum_compatible_version));
 
967
                NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->rdc_signature_levels));
 
968
                if (r->rdc_signature_levels > 8) {
 
969
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
970
                }
 
971
                NDR_CHECK(ndr_pull_frstrans_RdcCompressionAlgorithm(ndr, NDR_SCALARS, &r->compression_algorithm));
 
972
                NDR_PULL_ALLOC_N(ndr, r->rdc_filter_parameters, ndr_get_array_size(ndr, &r->rdc_filter_parameters));
 
973
                _mem_save_rdc_filter_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
974
                NDR_PULL_SET_MEM_CTX(ndr, r->rdc_filter_parameters, 0);
 
975
                for (cntr_rdc_filter_parameters_0 = 0; cntr_rdc_filter_parameters_0 < r->rdc_signature_levels; cntr_rdc_filter_parameters_0++) {
 
976
                        NDR_CHECK(ndr_pull_frstrans_RdcParameters(ndr, NDR_SCALARS, &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]));
 
977
                }
 
978
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_filter_parameters_0, 0);
 
979
                if (r->rdc_filter_parameters) {
 
980
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->rdc_filter_parameters, r->rdc_signature_levels));
 
981
                }
 
982
                NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 
983
        }
 
984
        if (ndr_flags & NDR_BUFFERS) {
 
985
        }
 
986
        return NDR_ERR_SUCCESS;
 
987
}
 
988
 
 
989
_PUBLIC_ void ndr_print_frstrans_RdcFileInfo(struct ndr_print *ndr, const char *name, const struct frstrans_RdcFileInfo *r)
 
990
{
 
991
        uint32_t cntr_rdc_filter_parameters_0;
 
992
        ndr_print_struct(ndr, name, "frstrans_RdcFileInfo");
 
993
        if (r == NULL) { ndr_print_null(ndr); return; }
 
994
        ndr->depth++;
 
995
        ndr_print_hyper(ndr, "on_disk_file_size", r->on_disk_file_size);
 
996
        ndr_print_hyper(ndr, "file_size_estimate", r->file_size_estimate);
 
997
        ndr_print_frstrans_RdcVersion(ndr, "rdc_version", r->rdc_version);
 
998
        ndr_print_frstrans_RdcVersionCompatible(ndr, "rdc_minimum_compatible_version", r->rdc_minimum_compatible_version);
 
999
        ndr_print_uint8(ndr, "rdc_signature_levels", r->rdc_signature_levels);
 
1000
        ndr_print_frstrans_RdcCompressionAlgorithm(ndr, "compression_algorithm", r->compression_algorithm);
 
1001
        ndr->print(ndr, "%s: ARRAY(%d)", "rdc_filter_parameters", (int)r->rdc_signature_levels);
 
1002
        ndr->depth++;
 
1003
        for (cntr_rdc_filter_parameters_0=0;cntr_rdc_filter_parameters_0<r->rdc_signature_levels;cntr_rdc_filter_parameters_0++) {
 
1004
                ndr_print_frstrans_RdcParameters(ndr, "rdc_filter_parameters", &r->rdc_filter_parameters[cntr_rdc_filter_parameters_0]);
 
1005
        }
 
1006
        ndr->depth--;
 
1007
        ndr->depth--;
 
1008
}
 
1009
 
 
1010
static enum ndr_err_code ndr_push_frstrans_BytePipe_chunk(struct ndr_push *ndr, int ndr_flags, const struct frstrans_BytePipe_chunk *r)
 
1011
{
 
1012
        if (ndr_flags & NDR_SCALARS) {
 
1013
                NDR_CHECK(ndr_push_align(ndr, 5));
 
1014
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 
1015
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->array, r->count));
 
1016
                NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 
1017
        }
 
1018
        if (ndr_flags & NDR_BUFFERS) {
 
1019
        }
 
1020
 
 
1021
        NDR_CHECK(ndr_push_pipe_chunk_trailer(ndr, ndr_flags, r->count));
 
1022
 
 
1023
        return NDR_ERR_SUCCESS;
 
1024
}
 
1025
 
 
1026
static enum ndr_err_code ndr_pull_frstrans_BytePipe_chunk(struct ndr_pull *ndr, int ndr_flags, struct frstrans_BytePipe_chunk *r)
 
1027
{
 
1028
        if (ndr_flags & NDR_SCALARS) {
 
1029
                NDR_CHECK(ndr_pull_align(ndr, 5));
 
1030
                NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &r->count));
 
1031
                NDR_PULL_ALLOC_N(ndr, r->array, r->count);
 
1032
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->array, r->count));
 
1033
                NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 
1034
        }
 
1035
        if (ndr_flags & NDR_BUFFERS) {
 
1036
        }
 
1037
 
 
1038
        NDR_CHECK(ndr_check_pipe_chunk_trailer(ndr, ndr_flags, r->count));
 
1039
 
 
1040
        return NDR_ERR_SUCCESS;
 
1041
}
 
1042
 
 
1043
_PUBLIC_ void ndr_print_frstrans_BytePipe_chunk(struct ndr_print *ndr, const char *name, const struct frstrans_BytePipe_chunk *r)
 
1044
{
 
1045
        ndr_print_struct(ndr, name, "frstrans_BytePipe_chunk");
 
1046
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1047
        ndr->depth++;
 
1048
        ndr_print_uint3264(ndr, "count", r->count);
 
1049
        ndr_print_array_uint8(ndr, "array", r->array, r->count);
 
1050
        ndr->depth--;
 
1051
}
 
1052
 
 
1053
static enum ndr_err_code ndr_push_frstrans_CheckConnectivity(struct ndr_push *ndr, int flags, const struct frstrans_CheckConnectivity *r)
 
1054
{
 
1055
        if (flags & NDR_IN) {
 
1056
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
 
1057
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1058
        }
 
1059
        if (flags & NDR_OUT) {
 
1060
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1061
        }
 
1062
        return NDR_ERR_SUCCESS;
 
1063
}
 
1064
 
 
1065
static enum ndr_err_code ndr_pull_frstrans_CheckConnectivity(struct ndr_pull *ndr, int flags, struct frstrans_CheckConnectivity *r)
 
1066
{
 
1067
        if (flags & NDR_IN) {
 
1068
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
 
1069
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1070
        }
 
1071
        if (flags & NDR_OUT) {
 
1072
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1073
        }
 
1074
        return NDR_ERR_SUCCESS;
 
1075
}
 
1076
 
 
1077
_PUBLIC_ void ndr_print_frstrans_CheckConnectivity(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_CheckConnectivity *r)
 
1078
{
 
1079
        ndr_print_struct(ndr, name, "frstrans_CheckConnectivity");
 
1080
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1081
        ndr->depth++;
 
1082
        if (flags & NDR_SET_VALUES) {
 
1083
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1084
        }
 
1085
        if (flags & NDR_IN) {
 
1086
                ndr_print_struct(ndr, "in", "frstrans_CheckConnectivity");
 
1087
                ndr->depth++;
 
1088
                ndr_print_GUID(ndr, "replica_set_guid", &r->in.replica_set_guid);
 
1089
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1090
                ndr->depth--;
 
1091
        }
 
1092
        if (flags & NDR_OUT) {
 
1093
                ndr_print_struct(ndr, "out", "frstrans_CheckConnectivity");
 
1094
                ndr->depth++;
 
1095
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1096
                ndr->depth--;
 
1097
        }
 
1098
        ndr->depth--;
 
1099
}
 
1100
 
 
1101
static enum ndr_err_code ndr_push_frstrans_EstablishConnection(struct ndr_push *ndr, int flags, const struct frstrans_EstablishConnection *r)
 
1102
{
 
1103
        if (flags & NDR_IN) {
 
1104
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
 
1105
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1106
                NDR_CHECK(ndr_push_frstrans_ProtocolVersion(ndr, NDR_SCALARS, r->in.downstream_protocol_version));
 
1107
                NDR_CHECK(ndr_push_frstrans_TransportFlags(ndr, NDR_SCALARS, r->in.downstream_flags));
 
1108
        }
 
1109
        if (flags & NDR_OUT) {
 
1110
                if (r->out.upstream_protocol_version == NULL) {
 
1111
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1112
                }
 
1113
                NDR_CHECK(ndr_push_frstrans_ProtocolVersion(ndr, NDR_SCALARS, *r->out.upstream_protocol_version));
 
1114
                if (r->out.upstream_flags == NULL) {
 
1115
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1116
                }
 
1117
                NDR_CHECK(ndr_push_frstrans_TransportFlags(ndr, NDR_SCALARS, *r->out.upstream_flags));
 
1118
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1119
        }
 
1120
        return NDR_ERR_SUCCESS;
 
1121
}
 
1122
 
 
1123
static enum ndr_err_code ndr_pull_frstrans_EstablishConnection(struct ndr_pull *ndr, int flags, struct frstrans_EstablishConnection *r)
 
1124
{
 
1125
        TALLOC_CTX *_mem_save_upstream_protocol_version_0;
 
1126
        TALLOC_CTX *_mem_save_upstream_flags_0;
 
1127
        if (flags & NDR_IN) {
 
1128
                ZERO_STRUCT(r->out);
 
1129
 
 
1130
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.replica_set_guid));
 
1131
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1132
                NDR_CHECK(ndr_pull_frstrans_ProtocolVersion(ndr, NDR_SCALARS, &r->in.downstream_protocol_version));
 
1133
                NDR_CHECK(ndr_pull_frstrans_TransportFlags(ndr, NDR_SCALARS, &r->in.downstream_flags));
 
1134
                NDR_PULL_ALLOC(ndr, r->out.upstream_protocol_version);
 
1135
                ZERO_STRUCTP(r->out.upstream_protocol_version);
 
1136
                NDR_PULL_ALLOC(ndr, r->out.upstream_flags);
 
1137
                ZERO_STRUCTP(r->out.upstream_flags);
 
1138
        }
 
1139
        if (flags & NDR_OUT) {
 
1140
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1141
                        NDR_PULL_ALLOC(ndr, r->out.upstream_protocol_version);
 
1142
                }
 
1143
                _mem_save_upstream_protocol_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1144
                NDR_PULL_SET_MEM_CTX(ndr, r->out.upstream_protocol_version, LIBNDR_FLAG_REF_ALLOC);
 
1145
                NDR_CHECK(ndr_pull_frstrans_ProtocolVersion(ndr, NDR_SCALARS, r->out.upstream_protocol_version));
 
1146
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upstream_protocol_version_0, LIBNDR_FLAG_REF_ALLOC);
 
1147
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1148
                        NDR_PULL_ALLOC(ndr, r->out.upstream_flags);
 
1149
                }
 
1150
                _mem_save_upstream_flags_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1151
                NDR_PULL_SET_MEM_CTX(ndr, r->out.upstream_flags, LIBNDR_FLAG_REF_ALLOC);
 
1152
                NDR_CHECK(ndr_pull_frstrans_TransportFlags(ndr, NDR_SCALARS, r->out.upstream_flags));
 
1153
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_upstream_flags_0, LIBNDR_FLAG_REF_ALLOC);
 
1154
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1155
        }
 
1156
        return NDR_ERR_SUCCESS;
 
1157
}
 
1158
 
 
1159
_PUBLIC_ void ndr_print_frstrans_EstablishConnection(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_EstablishConnection *r)
 
1160
{
 
1161
        ndr_print_struct(ndr, name, "frstrans_EstablishConnection");
 
1162
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1163
        ndr->depth++;
 
1164
        if (flags & NDR_SET_VALUES) {
 
1165
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1166
        }
 
1167
        if (flags & NDR_IN) {
 
1168
                ndr_print_struct(ndr, "in", "frstrans_EstablishConnection");
 
1169
                ndr->depth++;
 
1170
                ndr_print_GUID(ndr, "replica_set_guid", &r->in.replica_set_guid);
 
1171
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1172
                ndr_print_frstrans_ProtocolVersion(ndr, "downstream_protocol_version", r->in.downstream_protocol_version);
 
1173
                ndr_print_frstrans_TransportFlags(ndr, "downstream_flags", r->in.downstream_flags);
 
1174
                ndr->depth--;
 
1175
        }
 
1176
        if (flags & NDR_OUT) {
 
1177
                ndr_print_struct(ndr, "out", "frstrans_EstablishConnection");
 
1178
                ndr->depth++;
 
1179
                ndr_print_ptr(ndr, "upstream_protocol_version", r->out.upstream_protocol_version);
 
1180
                ndr->depth++;
 
1181
                ndr_print_frstrans_ProtocolVersion(ndr, "upstream_protocol_version", *r->out.upstream_protocol_version);
 
1182
                ndr->depth--;
 
1183
                ndr_print_ptr(ndr, "upstream_flags", r->out.upstream_flags);
 
1184
                ndr->depth++;
 
1185
                ndr_print_frstrans_TransportFlags(ndr, "upstream_flags", *r->out.upstream_flags);
 
1186
                ndr->depth--;
 
1187
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1188
                ndr->depth--;
 
1189
        }
 
1190
        ndr->depth--;
 
1191
}
 
1192
 
 
1193
static enum ndr_err_code ndr_push_frstrans_EstablishSession(struct ndr_push *ndr, int flags, const struct frstrans_EstablishSession *r)
 
1194
{
 
1195
        if (flags & NDR_IN) {
 
1196
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1197
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1198
        }
 
1199
        if (flags & NDR_OUT) {
 
1200
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1201
        }
 
1202
        return NDR_ERR_SUCCESS;
 
1203
}
 
1204
 
 
1205
static enum ndr_err_code ndr_pull_frstrans_EstablishSession(struct ndr_pull *ndr, int flags, struct frstrans_EstablishSession *r)
 
1206
{
 
1207
        if (flags & NDR_IN) {
 
1208
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1209
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1210
        }
 
1211
        if (flags & NDR_OUT) {
 
1212
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1213
        }
 
1214
        return NDR_ERR_SUCCESS;
 
1215
}
 
1216
 
 
1217
_PUBLIC_ void ndr_print_frstrans_EstablishSession(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_EstablishSession *r)
 
1218
{
 
1219
        ndr_print_struct(ndr, name, "frstrans_EstablishSession");
 
1220
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1221
        ndr->depth++;
 
1222
        if (flags & NDR_SET_VALUES) {
 
1223
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1224
        }
 
1225
        if (flags & NDR_IN) {
 
1226
                ndr_print_struct(ndr, "in", "frstrans_EstablishSession");
 
1227
                ndr->depth++;
 
1228
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1229
                ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
 
1230
                ndr->depth--;
 
1231
        }
 
1232
        if (flags & NDR_OUT) {
 
1233
                ndr_print_struct(ndr, "out", "frstrans_EstablishSession");
 
1234
                ndr->depth++;
 
1235
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1236
                ndr->depth--;
 
1237
        }
 
1238
        ndr->depth--;
 
1239
}
 
1240
 
 
1241
static enum ndr_err_code ndr_push_frstrans_RequestUpdates(struct ndr_push *ndr, int flags, const struct frstrans_RequestUpdates *r)
 
1242
{
 
1243
        uint32_t cntr_version_vector_diff_1;
 
1244
        uint32_t cntr_frs_update_1;
 
1245
        if (flags & NDR_IN) {
 
1246
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1247
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1248
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.credits_available));
 
1249
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.hash_requested));
 
1250
                NDR_CHECK(ndr_push_frstrans_UpdateRequestType(ndr, NDR_SCALARS, r->in.update_request_type));
 
1251
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version_vector_diff_count));
 
1252
                if (r->in.version_vector_diff == NULL) {
 
1253
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1254
                }
 
1255
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.version_vector_diff_count));
 
1256
                for (cntr_version_vector_diff_1 = 0; cntr_version_vector_diff_1 < r->in.version_vector_diff_count; cntr_version_vector_diff_1++) {
 
1257
                        NDR_CHECK(ndr_push_frstrans_VersionVector(ndr, NDR_SCALARS, &r->in.version_vector_diff[cntr_version_vector_diff_1]));
 
1258
                }
 
1259
        }
 
1260
        if (flags & NDR_OUT) {
 
1261
                if (r->out.frs_update == NULL) {
 
1262
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1263
                }
 
1264
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.credits_available));
 
1265
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
1266
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.update_count));
 
1267
                for (cntr_frs_update_1 = 0; cntr_frs_update_1 < *r->out.update_count; cntr_frs_update_1++) {
 
1268
                        NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, &r->out.frs_update[cntr_frs_update_1]));
 
1269
                }
 
1270
                if (r->out.update_count == NULL) {
 
1271
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1272
                }
 
1273
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.update_count));
 
1274
                if (r->out.update_status == NULL) {
 
1275
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1276
                }
 
1277
                NDR_CHECK(ndr_push_frstrans_UpdateStatus(ndr, NDR_SCALARS, *r->out.update_status));
 
1278
                if (r->out.gvsn_db_guid == NULL) {
 
1279
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1280
                }
 
1281
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->out.gvsn_db_guid));
 
1282
                if (r->out.gvsn_version == NULL) {
 
1283
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1284
                }
 
1285
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, *r->out.gvsn_version));
 
1286
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1287
        }
 
1288
        return NDR_ERR_SUCCESS;
 
1289
}
 
1290
 
 
1291
static enum ndr_err_code ndr_pull_frstrans_RequestUpdates(struct ndr_pull *ndr, int flags, struct frstrans_RequestUpdates *r)
 
1292
{
 
1293
        uint32_t cntr_version_vector_diff_1;
 
1294
        uint32_t cntr_frs_update_1;
 
1295
        TALLOC_CTX *_mem_save_version_vector_diff_1;
 
1296
        TALLOC_CTX *_mem_save_frs_update_1;
 
1297
        TALLOC_CTX *_mem_save_update_count_0;
 
1298
        TALLOC_CTX *_mem_save_update_status_0;
 
1299
        TALLOC_CTX *_mem_save_gvsn_db_guid_0;
 
1300
        TALLOC_CTX *_mem_save_gvsn_version_0;
 
1301
        if (flags & NDR_IN) {
 
1302
                ZERO_STRUCT(r->out);
 
1303
 
 
1304
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1305
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1306
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.credits_available));
 
1307
                if (r->in.credits_available > 256) {
 
1308
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1309
                }
 
1310
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.hash_requested));
 
1311
                if (r->in.hash_requested > 1) {
 
1312
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1313
                }
 
1314
                NDR_CHECK(ndr_pull_frstrans_UpdateRequestType(ndr, NDR_SCALARS, &r->in.update_request_type));
 
1315
                if (r->in.update_request_type > 2) {
 
1316
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1317
                }
 
1318
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version_vector_diff_count));
 
1319
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.version_vector_diff));
 
1320
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1321
                        NDR_PULL_ALLOC_N(ndr, r->in.version_vector_diff, ndr_get_array_size(ndr, &r->in.version_vector_diff));
 
1322
                }
 
1323
                _mem_save_version_vector_diff_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1324
                NDR_PULL_SET_MEM_CTX(ndr, r->in.version_vector_diff, 0);
 
1325
                for (cntr_version_vector_diff_1 = 0; cntr_version_vector_diff_1 < r->in.version_vector_diff_count; cntr_version_vector_diff_1++) {
 
1326
                        NDR_CHECK(ndr_pull_frstrans_VersionVector(ndr, NDR_SCALARS, &r->in.version_vector_diff[cntr_version_vector_diff_1]));
 
1327
                }
 
1328
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_version_vector_diff_1, 0);
 
1329
                NDR_PULL_ALLOC_N(ndr, r->out.frs_update, r->in.credits_available);
 
1330
                memset(r->out.frs_update, 0, (r->in.credits_available) * sizeof(*r->out.frs_update));
 
1331
                NDR_PULL_ALLOC(ndr, r->out.update_count);
 
1332
                ZERO_STRUCTP(r->out.update_count);
 
1333
                NDR_PULL_ALLOC(ndr, r->out.update_status);
 
1334
                ZERO_STRUCTP(r->out.update_status);
 
1335
                NDR_PULL_ALLOC(ndr, r->out.gvsn_db_guid);
 
1336
                ZERO_STRUCTP(r->out.gvsn_db_guid);
 
1337
                NDR_PULL_ALLOC(ndr, r->out.gvsn_version);
 
1338
                ZERO_STRUCTP(r->out.gvsn_version);
 
1339
                if (r->in.version_vector_diff) {
 
1340
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.version_vector_diff, r->in.version_vector_diff_count));
 
1341
                }
 
1342
        }
 
1343
        if (flags & NDR_OUT) {
 
1344
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.frs_update));
 
1345
                NDR_CHECK(ndr_pull_array_length(ndr, &r->out.frs_update));
 
1346
                if (ndr_get_array_length(ndr, &r->out.frs_update) > ndr_get_array_size(ndr, &r->out.frs_update)) {
 
1347
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.frs_update), ndr_get_array_length(ndr, &r->out.frs_update));
 
1348
                }
 
1349
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1350
                        NDR_PULL_ALLOC_N(ndr, r->out.frs_update, ndr_get_array_size(ndr, &r->out.frs_update));
 
1351
                }
 
1352
                _mem_save_frs_update_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
1353
                NDR_PULL_SET_MEM_CTX(ndr, r->out.frs_update, 0);
 
1354
                for (cntr_frs_update_1 = 0; cntr_frs_update_1 < ndr_get_array_length(ndr, &r->out.frs_update); cntr_frs_update_1++) {
 
1355
                        NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, &r->out.frs_update[cntr_frs_update_1]));
 
1356
                }
 
1357
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_1, 0);
 
1358
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1359
                        NDR_PULL_ALLOC(ndr, r->out.update_count);
 
1360
                }
 
1361
                _mem_save_update_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1362
                NDR_PULL_SET_MEM_CTX(ndr, r->out.update_count, LIBNDR_FLAG_REF_ALLOC);
 
1363
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.update_count));
 
1364
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_update_count_0, LIBNDR_FLAG_REF_ALLOC);
 
1365
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1366
                        NDR_PULL_ALLOC(ndr, r->out.update_status);
 
1367
                }
 
1368
                _mem_save_update_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1369
                NDR_PULL_SET_MEM_CTX(ndr, r->out.update_status, LIBNDR_FLAG_REF_ALLOC);
 
1370
                NDR_CHECK(ndr_pull_frstrans_UpdateStatus(ndr, NDR_SCALARS, r->out.update_status));
 
1371
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_update_status_0, LIBNDR_FLAG_REF_ALLOC);
 
1372
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1373
                        NDR_PULL_ALLOC(ndr, r->out.gvsn_db_guid);
 
1374
                }
 
1375
                _mem_save_gvsn_db_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1376
                NDR_PULL_SET_MEM_CTX(ndr, r->out.gvsn_db_guid, LIBNDR_FLAG_REF_ALLOC);
 
1377
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->out.gvsn_db_guid));
 
1378
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gvsn_db_guid_0, LIBNDR_FLAG_REF_ALLOC);
 
1379
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1380
                        NDR_PULL_ALLOC(ndr, r->out.gvsn_version);
 
1381
                }
 
1382
                _mem_save_gvsn_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1383
                NDR_PULL_SET_MEM_CTX(ndr, r->out.gvsn_version, LIBNDR_FLAG_REF_ALLOC);
 
1384
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, r->out.gvsn_version));
 
1385
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gvsn_version_0, LIBNDR_FLAG_REF_ALLOC);
 
1386
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1387
                if (r->out.frs_update) {
 
1388
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.frs_update, r->in.credits_available));
 
1389
                }
 
1390
                if (r->out.frs_update) {
 
1391
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.frs_update, *r->out.update_count));
 
1392
                }
 
1393
        }
 
1394
        return NDR_ERR_SUCCESS;
 
1395
}
 
1396
 
 
1397
_PUBLIC_ void ndr_print_frstrans_RequestUpdates(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RequestUpdates *r)
 
1398
{
 
1399
        uint32_t cntr_version_vector_diff_1;
 
1400
        uint32_t cntr_frs_update_1;
 
1401
        ndr_print_struct(ndr, name, "frstrans_RequestUpdates");
 
1402
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1403
        ndr->depth++;
 
1404
        if (flags & NDR_SET_VALUES) {
 
1405
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1406
        }
 
1407
        if (flags & NDR_IN) {
 
1408
                ndr_print_struct(ndr, "in", "frstrans_RequestUpdates");
 
1409
                ndr->depth++;
 
1410
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1411
                ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
 
1412
                ndr_print_uint32(ndr, "credits_available", r->in.credits_available);
 
1413
                ndr_print_uint32(ndr, "hash_requested", r->in.hash_requested);
 
1414
                ndr_print_frstrans_UpdateRequestType(ndr, "update_request_type", r->in.update_request_type);
 
1415
                ndr_print_uint32(ndr, "version_vector_diff_count", r->in.version_vector_diff_count);
 
1416
                ndr_print_ptr(ndr, "version_vector_diff", r->in.version_vector_diff);
 
1417
                ndr->depth++;
 
1418
                ndr->print(ndr, "%s: ARRAY(%d)", "version_vector_diff", (int)r->in.version_vector_diff_count);
 
1419
                ndr->depth++;
 
1420
                for (cntr_version_vector_diff_1=0;cntr_version_vector_diff_1<r->in.version_vector_diff_count;cntr_version_vector_diff_1++) {
 
1421
                        ndr_print_frstrans_VersionVector(ndr, "version_vector_diff", &r->in.version_vector_diff[cntr_version_vector_diff_1]);
 
1422
                }
 
1423
                ndr->depth--;
 
1424
                ndr->depth--;
 
1425
                ndr->depth--;
 
1426
        }
 
1427
        if (flags & NDR_OUT) {
 
1428
                ndr_print_struct(ndr, "out", "frstrans_RequestUpdates");
 
1429
                ndr->depth++;
 
1430
                ndr_print_ptr(ndr, "frs_update", r->out.frs_update);
 
1431
                ndr->depth++;
 
1432
                ndr->print(ndr, "%s: ARRAY(%d)", "frs_update", (int)*r->out.update_count);
 
1433
                ndr->depth++;
 
1434
                for (cntr_frs_update_1=0;cntr_frs_update_1<*r->out.update_count;cntr_frs_update_1++) {
 
1435
                        ndr_print_frstrans_Update(ndr, "frs_update", &r->out.frs_update[cntr_frs_update_1]);
 
1436
                }
 
1437
                ndr->depth--;
 
1438
                ndr->depth--;
 
1439
                ndr_print_ptr(ndr, "update_count", r->out.update_count);
 
1440
                ndr->depth++;
 
1441
                ndr_print_uint32(ndr, "update_count", *r->out.update_count);
 
1442
                ndr->depth--;
 
1443
                ndr_print_ptr(ndr, "update_status", r->out.update_status);
 
1444
                ndr->depth++;
 
1445
                ndr_print_frstrans_UpdateStatus(ndr, "update_status", *r->out.update_status);
 
1446
                ndr->depth--;
 
1447
                ndr_print_ptr(ndr, "gvsn_db_guid", r->out.gvsn_db_guid);
 
1448
                ndr->depth++;
 
1449
                ndr_print_GUID(ndr, "gvsn_db_guid", r->out.gvsn_db_guid);
 
1450
                ndr->depth--;
 
1451
                ndr_print_ptr(ndr, "gvsn_version", r->out.gvsn_version);
 
1452
                ndr->depth++;
 
1453
                ndr_print_hyper(ndr, "gvsn_version", *r->out.gvsn_version);
 
1454
                ndr->depth--;
 
1455
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1456
                ndr->depth--;
 
1457
        }
 
1458
        ndr->depth--;
 
1459
}
 
1460
 
 
1461
static enum ndr_err_code ndr_push_frstrans_RequestVersionVector(struct ndr_push *ndr, int flags, const struct frstrans_RequestVersionVector *r)
 
1462
{
 
1463
        if (flags & NDR_IN) {
 
1464
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.sequence_number));
 
1465
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1466
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1467
                NDR_CHECK(ndr_push_frstrans_VersionRequestType(ndr, NDR_SCALARS, r->in.request_type));
 
1468
                NDR_CHECK(ndr_push_frstrans_VersionChangeType(ndr, NDR_SCALARS, r->in.change_type));
 
1469
                NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->in.vv_generation));
 
1470
        }
 
1471
        if (flags & NDR_OUT) {
 
1472
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1473
        }
 
1474
        return NDR_ERR_SUCCESS;
 
1475
}
 
1476
 
 
1477
static enum ndr_err_code ndr_pull_frstrans_RequestVersionVector(struct ndr_pull *ndr, int flags, struct frstrans_RequestVersionVector *r)
 
1478
{
 
1479
        if (flags & NDR_IN) {
 
1480
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.sequence_number));
 
1481
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1482
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.content_set_guid));
 
1483
                NDR_CHECK(ndr_pull_frstrans_VersionRequestType(ndr, NDR_SCALARS, &r->in.request_type));
 
1484
                if (r->in.request_type > 2) {
 
1485
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1486
                }
 
1487
                NDR_CHECK(ndr_pull_frstrans_VersionChangeType(ndr, NDR_SCALARS, &r->in.change_type));
 
1488
                if (r->in.change_type > 2) {
 
1489
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1490
                }
 
1491
                NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->in.vv_generation));
 
1492
        }
 
1493
        if (flags & NDR_OUT) {
 
1494
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1495
        }
 
1496
        return NDR_ERR_SUCCESS;
 
1497
}
 
1498
 
 
1499
_PUBLIC_ void ndr_print_frstrans_RequestVersionVector(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RequestVersionVector *r)
 
1500
{
 
1501
        ndr_print_struct(ndr, name, "frstrans_RequestVersionVector");
 
1502
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1503
        ndr->depth++;
 
1504
        if (flags & NDR_SET_VALUES) {
 
1505
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1506
        }
 
1507
        if (flags & NDR_IN) {
 
1508
                ndr_print_struct(ndr, "in", "frstrans_RequestVersionVector");
 
1509
                ndr->depth++;
 
1510
                ndr_print_uint32(ndr, "sequence_number", r->in.sequence_number);
 
1511
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1512
                ndr_print_GUID(ndr, "content_set_guid", &r->in.content_set_guid);
 
1513
                ndr_print_frstrans_VersionRequestType(ndr, "request_type", r->in.request_type);
 
1514
                ndr_print_frstrans_VersionChangeType(ndr, "change_type", r->in.change_type);
 
1515
                ndr_print_hyper(ndr, "vv_generation", r->in.vv_generation);
 
1516
                ndr->depth--;
 
1517
        }
 
1518
        if (flags & NDR_OUT) {
 
1519
                ndr_print_struct(ndr, "out", "frstrans_RequestVersionVector");
 
1520
                ndr->depth++;
 
1521
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1522
                ndr->depth--;
 
1523
        }
 
1524
        ndr->depth--;
 
1525
}
 
1526
 
 
1527
static enum ndr_err_code ndr_push_frstrans_AsyncPoll(struct ndr_push *ndr, int flags, const struct frstrans_AsyncPoll *r)
 
1528
{
 
1529
        if (flags & NDR_IN) {
 
1530
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1531
        }
 
1532
        if (flags & NDR_OUT) {
 
1533
                if (r->out.response == NULL) {
 
1534
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1535
                }
 
1536
                NDR_CHECK(ndr_push_frstrans_AsyncResponseContext(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.response));
 
1537
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1538
        }
 
1539
        return NDR_ERR_SUCCESS;
 
1540
}
 
1541
 
 
1542
static enum ndr_err_code ndr_pull_frstrans_AsyncPoll(struct ndr_pull *ndr, int flags, struct frstrans_AsyncPoll *r)
 
1543
{
 
1544
        TALLOC_CTX *_mem_save_response_0;
 
1545
        if (flags & NDR_IN) {
 
1546
                ZERO_STRUCT(r->out);
 
1547
 
 
1548
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1549
                NDR_PULL_ALLOC(ndr, r->out.response);
 
1550
                ZERO_STRUCTP(r->out.response);
 
1551
        }
 
1552
        if (flags & NDR_OUT) {
 
1553
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1554
                        NDR_PULL_ALLOC(ndr, r->out.response);
 
1555
                }
 
1556
                _mem_save_response_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1557
                NDR_PULL_SET_MEM_CTX(ndr, r->out.response, LIBNDR_FLAG_REF_ALLOC);
 
1558
                NDR_CHECK(ndr_pull_frstrans_AsyncResponseContext(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.response));
 
1559
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_response_0, LIBNDR_FLAG_REF_ALLOC);
 
1560
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
1561
        }
 
1562
        return NDR_ERR_SUCCESS;
 
1563
}
 
1564
 
 
1565
_PUBLIC_ void ndr_print_frstrans_AsyncPoll(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_AsyncPoll *r)
 
1566
{
 
1567
        ndr_print_struct(ndr, name, "frstrans_AsyncPoll");
 
1568
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1569
        ndr->depth++;
 
1570
        if (flags & NDR_SET_VALUES) {
 
1571
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1572
        }
 
1573
        if (flags & NDR_IN) {
 
1574
                ndr_print_struct(ndr, "in", "frstrans_AsyncPoll");
 
1575
                ndr->depth++;
 
1576
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
1577
                ndr->depth--;
 
1578
        }
 
1579
        if (flags & NDR_OUT) {
 
1580
                ndr_print_struct(ndr, "out", "frstrans_AsyncPoll");
 
1581
                ndr->depth++;
 
1582
                ndr_print_ptr(ndr, "response", r->out.response);
 
1583
                ndr->depth++;
 
1584
                ndr_print_frstrans_AsyncResponseContext(ndr, "response", r->out.response);
 
1585
                ndr->depth--;
 
1586
                ndr_print_WERROR(ndr, "result", r->out.result);
 
1587
                ndr->depth--;
 
1588
        }
 
1589
        ndr->depth--;
 
1590
}
 
1591
 
 
1592
static enum ndr_err_code ndr_push_FRSTRANS_REQUEST_RECORDS(struct ndr_push *ndr, int flags, const struct FRSTRANS_REQUEST_RECORDS *r)
 
1593
{
 
1594
        if (flags & NDR_IN) {
 
1595
        }
 
1596
        if (flags & NDR_OUT) {
 
1597
        }
 
1598
        return NDR_ERR_SUCCESS;
 
1599
}
 
1600
 
 
1601
static enum ndr_err_code ndr_pull_FRSTRANS_REQUEST_RECORDS(struct ndr_pull *ndr, int flags, struct FRSTRANS_REQUEST_RECORDS *r)
 
1602
{
 
1603
        if (flags & NDR_IN) {
 
1604
        }
 
1605
        if (flags & NDR_OUT) {
 
1606
        }
 
1607
        return NDR_ERR_SUCCESS;
 
1608
}
 
1609
 
 
1610
_PUBLIC_ void ndr_print_FRSTRANS_REQUEST_RECORDS(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_REQUEST_RECORDS *r)
 
1611
{
 
1612
        ndr_print_struct(ndr, name, "FRSTRANS_REQUEST_RECORDS");
 
1613
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1614
        ndr->depth++;
 
1615
        if (flags & NDR_SET_VALUES) {
 
1616
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1617
        }
 
1618
        if (flags & NDR_IN) {
 
1619
                ndr_print_struct(ndr, "in", "FRSTRANS_REQUEST_RECORDS");
 
1620
                ndr->depth++;
 
1621
                ndr->depth--;
 
1622
        }
 
1623
        if (flags & NDR_OUT) {
 
1624
                ndr_print_struct(ndr, "out", "FRSTRANS_REQUEST_RECORDS");
 
1625
                ndr->depth++;
 
1626
                ndr->depth--;
 
1627
        }
 
1628
        ndr->depth--;
 
1629
}
 
1630
 
 
1631
static enum ndr_err_code ndr_push_FRSTRANS_UPDATE_CANCEL(struct ndr_push *ndr, int flags, const struct FRSTRANS_UPDATE_CANCEL *r)
 
1632
{
 
1633
        if (flags & NDR_IN) {
 
1634
        }
 
1635
        if (flags & NDR_OUT) {
 
1636
        }
 
1637
        return NDR_ERR_SUCCESS;
 
1638
}
 
1639
 
 
1640
static enum ndr_err_code ndr_pull_FRSTRANS_UPDATE_CANCEL(struct ndr_pull *ndr, int flags, struct FRSTRANS_UPDATE_CANCEL *r)
 
1641
{
 
1642
        if (flags & NDR_IN) {
 
1643
        }
 
1644
        if (flags & NDR_OUT) {
 
1645
        }
 
1646
        return NDR_ERR_SUCCESS;
 
1647
}
 
1648
 
 
1649
_PUBLIC_ void ndr_print_FRSTRANS_UPDATE_CANCEL(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_UPDATE_CANCEL *r)
 
1650
{
 
1651
        ndr_print_struct(ndr, name, "FRSTRANS_UPDATE_CANCEL");
 
1652
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1653
        ndr->depth++;
 
1654
        if (flags & NDR_SET_VALUES) {
 
1655
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1656
        }
 
1657
        if (flags & NDR_IN) {
 
1658
                ndr_print_struct(ndr, "in", "FRSTRANS_UPDATE_CANCEL");
 
1659
                ndr->depth++;
 
1660
                ndr->depth--;
 
1661
        }
 
1662
        if (flags & NDR_OUT) {
 
1663
                ndr_print_struct(ndr, "out", "FRSTRANS_UPDATE_CANCEL");
 
1664
                ndr->depth++;
 
1665
                ndr->depth--;
 
1666
        }
 
1667
        ndr->depth--;
 
1668
}
 
1669
 
 
1670
static enum ndr_err_code ndr_push_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_push *ndr, int flags, const struct FRSTRANS_RAW_GET_FILE_DATA *r)
 
1671
{
 
1672
        if (flags & NDR_IN) {
 
1673
        }
 
1674
        if (flags & NDR_OUT) {
 
1675
        }
 
1676
        return NDR_ERR_SUCCESS;
 
1677
}
 
1678
 
 
1679
static enum ndr_err_code ndr_pull_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_pull *ndr, int flags, struct FRSTRANS_RAW_GET_FILE_DATA *r)
 
1680
{
 
1681
        if (flags & NDR_IN) {
 
1682
        }
 
1683
        if (flags & NDR_OUT) {
 
1684
        }
 
1685
        return NDR_ERR_SUCCESS;
 
1686
}
 
1687
 
 
1688
_PUBLIC_ void ndr_print_FRSTRANS_RAW_GET_FILE_DATA(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RAW_GET_FILE_DATA *r)
 
1689
{
 
1690
        ndr_print_struct(ndr, name, "FRSTRANS_RAW_GET_FILE_DATA");
 
1691
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1692
        ndr->depth++;
 
1693
        if (flags & NDR_SET_VALUES) {
 
1694
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1695
        }
 
1696
        if (flags & NDR_IN) {
 
1697
                ndr_print_struct(ndr, "in", "FRSTRANS_RAW_GET_FILE_DATA");
 
1698
                ndr->depth++;
 
1699
                ndr->depth--;
 
1700
        }
 
1701
        if (flags & NDR_OUT) {
 
1702
                ndr_print_struct(ndr, "out", "FRSTRANS_RAW_GET_FILE_DATA");
 
1703
                ndr->depth++;
 
1704
                ndr->depth--;
 
1705
        }
 
1706
        ndr->depth--;
 
1707
}
 
1708
 
 
1709
static enum ndr_err_code ndr_push_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_GET_SIGNATURES *r)
 
1710
{
 
1711
        if (flags & NDR_IN) {
 
1712
        }
 
1713
        if (flags & NDR_OUT) {
 
1714
        }
 
1715
        return NDR_ERR_SUCCESS;
 
1716
}
 
1717
 
 
1718
static enum ndr_err_code ndr_pull_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_GET_SIGNATURES *r)
 
1719
{
 
1720
        if (flags & NDR_IN) {
 
1721
        }
 
1722
        if (flags & NDR_OUT) {
 
1723
        }
 
1724
        return NDR_ERR_SUCCESS;
 
1725
}
 
1726
 
 
1727
_PUBLIC_ void ndr_print_FRSTRANS_RDC_GET_SIGNATURES(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_GET_SIGNATURES *r)
 
1728
{
 
1729
        ndr_print_struct(ndr, name, "FRSTRANS_RDC_GET_SIGNATURES");
 
1730
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1731
        ndr->depth++;
 
1732
        if (flags & NDR_SET_VALUES) {
 
1733
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1734
        }
 
1735
        if (flags & NDR_IN) {
 
1736
                ndr_print_struct(ndr, "in", "FRSTRANS_RDC_GET_SIGNATURES");
 
1737
                ndr->depth++;
 
1738
                ndr->depth--;
 
1739
        }
 
1740
        if (flags & NDR_OUT) {
 
1741
                ndr_print_struct(ndr, "out", "FRSTRANS_RDC_GET_SIGNATURES");
 
1742
                ndr->depth++;
 
1743
                ndr->depth--;
 
1744
        }
 
1745
        ndr->depth--;
 
1746
}
 
1747
 
 
1748
static enum ndr_err_code ndr_push_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
 
1749
{
 
1750
        if (flags & NDR_IN) {
 
1751
        }
 
1752
        if (flags & NDR_OUT) {
 
1753
        }
 
1754
        return NDR_ERR_SUCCESS;
 
1755
}
 
1756
 
 
1757
static enum ndr_err_code ndr_pull_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
 
1758
{
 
1759
        if (flags & NDR_IN) {
 
1760
        }
 
1761
        if (flags & NDR_OUT) {
 
1762
        }
 
1763
        return NDR_ERR_SUCCESS;
 
1764
}
 
1765
 
 
1766
_PUBLIC_ void ndr_print_FRSTRANS_RDC_PUSH_SOURCE_NEEDS(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS *r)
 
1767
{
 
1768
        ndr_print_struct(ndr, name, "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
 
1769
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1770
        ndr->depth++;
 
1771
        if (flags & NDR_SET_VALUES) {
 
1772
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1773
        }
 
1774
        if (flags & NDR_IN) {
 
1775
                ndr_print_struct(ndr, "in", "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
 
1776
                ndr->depth++;
 
1777
                ndr->depth--;
 
1778
        }
 
1779
        if (flags & NDR_OUT) {
 
1780
                ndr_print_struct(ndr, "out", "FRSTRANS_RDC_PUSH_SOURCE_NEEDS");
 
1781
                ndr->depth++;
 
1782
                ndr->depth--;
 
1783
        }
 
1784
        ndr->depth--;
 
1785
}
 
1786
 
 
1787
static enum ndr_err_code ndr_push_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_GET_FILE_DATA *r)
 
1788
{
 
1789
        if (flags & NDR_IN) {
 
1790
        }
 
1791
        if (flags & NDR_OUT) {
 
1792
        }
 
1793
        return NDR_ERR_SUCCESS;
 
1794
}
 
1795
 
 
1796
static enum ndr_err_code ndr_pull_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_GET_FILE_DATA *r)
 
1797
{
 
1798
        if (flags & NDR_IN) {
 
1799
        }
 
1800
        if (flags & NDR_OUT) {
 
1801
        }
 
1802
        return NDR_ERR_SUCCESS;
 
1803
}
 
1804
 
 
1805
_PUBLIC_ void ndr_print_FRSTRANS_RDC_GET_FILE_DATA(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_GET_FILE_DATA *r)
 
1806
{
 
1807
        ndr_print_struct(ndr, name, "FRSTRANS_RDC_GET_FILE_DATA");
 
1808
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1809
        ndr->depth++;
 
1810
        if (flags & NDR_SET_VALUES) {
 
1811
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1812
        }
 
1813
        if (flags & NDR_IN) {
 
1814
                ndr_print_struct(ndr, "in", "FRSTRANS_RDC_GET_FILE_DATA");
 
1815
                ndr->depth++;
 
1816
                ndr->depth--;
 
1817
        }
 
1818
        if (flags & NDR_OUT) {
 
1819
                ndr_print_struct(ndr, "out", "FRSTRANS_RDC_GET_FILE_DATA");
 
1820
                ndr->depth++;
 
1821
                ndr->depth--;
 
1822
        }
 
1823
        ndr->depth--;
 
1824
}
 
1825
 
 
1826
static enum ndr_err_code ndr_push_FRSTRANS_RDC_CLOSE(struct ndr_push *ndr, int flags, const struct FRSTRANS_RDC_CLOSE *r)
 
1827
{
 
1828
        if (flags & NDR_IN) {
 
1829
        }
 
1830
        if (flags & NDR_OUT) {
 
1831
        }
 
1832
        return NDR_ERR_SUCCESS;
 
1833
}
 
1834
 
 
1835
static enum ndr_err_code ndr_pull_FRSTRANS_RDC_CLOSE(struct ndr_pull *ndr, int flags, struct FRSTRANS_RDC_CLOSE *r)
 
1836
{
 
1837
        if (flags & NDR_IN) {
 
1838
        }
 
1839
        if (flags & NDR_OUT) {
 
1840
        }
 
1841
        return NDR_ERR_SUCCESS;
 
1842
}
 
1843
 
 
1844
_PUBLIC_ void ndr_print_FRSTRANS_RDC_CLOSE(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_RDC_CLOSE *r)
 
1845
{
 
1846
        ndr_print_struct(ndr, name, "FRSTRANS_RDC_CLOSE");
 
1847
        if (r == NULL) { ndr_print_null(ndr); return; }
 
1848
        ndr->depth++;
 
1849
        if (flags & NDR_SET_VALUES) {
 
1850
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
1851
        }
 
1852
        if (flags & NDR_IN) {
 
1853
                ndr_print_struct(ndr, "in", "FRSTRANS_RDC_CLOSE");
 
1854
                ndr->depth++;
 
1855
                ndr->depth--;
 
1856
        }
 
1857
        if (flags & NDR_OUT) {
 
1858
                ndr_print_struct(ndr, "out", "FRSTRANS_RDC_CLOSE");
 
1859
                ndr->depth++;
 
1860
                ndr->depth--;
 
1861
        }
 
1862
        ndr->depth--;
 
1863
}
 
1864
 
 
1865
static enum ndr_err_code ndr_push_frstrans_InitializeFileTransferAsync(struct ndr_push *ndr, int flags, const struct frstrans_InitializeFileTransferAsync *r)
 
1866
{
 
1867
        if (flags & NDR_IN) {
 
1868
                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1869
                if (r->in.frs_update == NULL) {
 
1870
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1871
                }
 
1872
                NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, r->in.frs_update));
 
1873
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.rdc_desired));
 
1874
                if (r->in.staging_policy == NULL) {
 
1875
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1876
                }
 
1877
                NDR_CHECK(ndr_push_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, *r->in.staging_policy));
 
1878
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
 
1879
        }
 
1880
        if (flags & NDR_OUT) {
 
1881
                if (r->out.frs_update == NULL) {
 
1882
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1883
                }
 
1884
                NDR_CHECK(ndr_push_frstrans_Update(ndr, NDR_SCALARS, r->out.frs_update));
 
1885
                if (r->out.staging_policy == NULL) {
 
1886
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1887
                }
 
1888
                NDR_CHECK(ndr_push_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, *r->out.staging_policy));
 
1889
                if (r->out.server_context == NULL) {
 
1890
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1891
                }
 
1892
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
 
1893
                if (r->out.rdc_file_info == NULL) {
 
1894
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1895
                }
 
1896
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.rdc_file_info));
 
1897
                if (*r->out.rdc_file_info) {
 
1898
                        NDR_CHECK(ndr_push_frstrans_RdcFileInfo(ndr, NDR_SCALARS, *r->out.rdc_file_info));
 
1899
                }
 
1900
                if (r->out.data_buffer == NULL) {
 
1901
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1902
                }
 
1903
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.buffer_size));
 
1904
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 
1905
                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, *r->out.size_read));
 
1906
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data_buffer, *r->out.size_read));
 
1907
                if (r->out.size_read == NULL) {
 
1908
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1909
                }
 
1910
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.size_read));
 
1911
                if (r->out.is_end_of_file == NULL) {
 
1912
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
1913
                }
 
1914
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.is_end_of_file));
 
1915
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
1916
        }
 
1917
        return NDR_ERR_SUCCESS;
 
1918
}
 
1919
 
 
1920
static enum ndr_err_code ndr_pull_frstrans_InitializeFileTransferAsync(struct ndr_pull *ndr, int flags, struct frstrans_InitializeFileTransferAsync *r)
 
1921
{
 
1922
        uint32_t _ptr_rdc_file_info;
 
1923
        TALLOC_CTX *_mem_save_frs_update_0;
 
1924
        TALLOC_CTX *_mem_save_staging_policy_0;
 
1925
        TALLOC_CTX *_mem_save_server_context_0;
 
1926
        TALLOC_CTX *_mem_save_rdc_file_info_0;
 
1927
        TALLOC_CTX *_mem_save_rdc_file_info_1;
 
1928
        TALLOC_CTX *_mem_save_size_read_0;
 
1929
        TALLOC_CTX *_mem_save_is_end_of_file_0;
 
1930
        if (flags & NDR_IN) {
 
1931
                ZERO_STRUCT(r->out);
 
1932
 
 
1933
                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->in.connection_guid));
 
1934
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1935
                        NDR_PULL_ALLOC(ndr, r->in.frs_update);
 
1936
                }
 
1937
                _mem_save_frs_update_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1938
                NDR_PULL_SET_MEM_CTX(ndr, r->in.frs_update, LIBNDR_FLAG_REF_ALLOC);
 
1939
                NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, r->in.frs_update));
 
1940
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_0, LIBNDR_FLAG_REF_ALLOC);
 
1941
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.rdc_desired));
 
1942
                if (r->in.rdc_desired > 1) {
 
1943
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1944
                }
 
1945
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1946
                        NDR_PULL_ALLOC(ndr, r->in.staging_policy);
 
1947
                }
 
1948
                _mem_save_staging_policy_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1949
                NDR_PULL_SET_MEM_CTX(ndr, r->in.staging_policy, LIBNDR_FLAG_REF_ALLOC);
 
1950
                NDR_CHECK(ndr_pull_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, r->in.staging_policy));
 
1951
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_staging_policy_0, LIBNDR_FLAG_REF_ALLOC);
 
1952
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buffer_size));
 
1953
                if (r->in.buffer_size > 262144) {
 
1954
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
1955
                }
 
1956
                NDR_PULL_ALLOC(ndr, r->out.frs_update);
 
1957
                *r->out.frs_update = *r->in.frs_update;
 
1958
                NDR_PULL_ALLOC(ndr, r->out.staging_policy);
 
1959
                *r->out.staging_policy = *r->in.staging_policy;
 
1960
                NDR_PULL_ALLOC(ndr, r->out.server_context);
 
1961
                ZERO_STRUCTP(r->out.server_context);
 
1962
                NDR_PULL_ALLOC(ndr, r->out.rdc_file_info);
 
1963
                ZERO_STRUCTP(r->out.rdc_file_info);
 
1964
                NDR_PULL_ALLOC_N(ndr, r->out.data_buffer, r->in.buffer_size);
 
1965
                memset(r->out.data_buffer, 0, (r->in.buffer_size) * sizeof(*r->out.data_buffer));
 
1966
                NDR_PULL_ALLOC(ndr, r->out.size_read);
 
1967
                ZERO_STRUCTP(r->out.size_read);
 
1968
                NDR_PULL_ALLOC(ndr, r->out.is_end_of_file);
 
1969
                ZERO_STRUCTP(r->out.is_end_of_file);
 
1970
        }
 
1971
        if (flags & NDR_OUT) {
 
1972
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1973
                        NDR_PULL_ALLOC(ndr, r->out.frs_update);
 
1974
                }
 
1975
                _mem_save_frs_update_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1976
                NDR_PULL_SET_MEM_CTX(ndr, r->out.frs_update, LIBNDR_FLAG_REF_ALLOC);
 
1977
                NDR_CHECK(ndr_pull_frstrans_Update(ndr, NDR_SCALARS, r->out.frs_update));
 
1978
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_frs_update_0, LIBNDR_FLAG_REF_ALLOC);
 
1979
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1980
                        NDR_PULL_ALLOC(ndr, r->out.staging_policy);
 
1981
                }
 
1982
                _mem_save_staging_policy_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1983
                NDR_PULL_SET_MEM_CTX(ndr, r->out.staging_policy, LIBNDR_FLAG_REF_ALLOC);
 
1984
                NDR_CHECK(ndr_pull_frstrans_RequestedStagingPolicy(ndr, NDR_SCALARS, r->out.staging_policy));
 
1985
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_staging_policy_0, LIBNDR_FLAG_REF_ALLOC);
 
1986
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1987
                        NDR_PULL_ALLOC(ndr, r->out.server_context);
 
1988
                }
 
1989
                _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1990
                NDR_PULL_SET_MEM_CTX(ndr, r->out.server_context, LIBNDR_FLAG_REF_ALLOC);
 
1991
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.server_context));
 
1992
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
 
1993
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
1994
                        NDR_PULL_ALLOC(ndr, r->out.rdc_file_info);
 
1995
                }
 
1996
                _mem_save_rdc_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
1997
                NDR_PULL_SET_MEM_CTX(ndr, r->out.rdc_file_info, LIBNDR_FLAG_REF_ALLOC);
 
1998
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rdc_file_info));
 
1999
                if (_ptr_rdc_file_info) {
 
2000
                        NDR_PULL_ALLOC(ndr, *r->out.rdc_file_info);
 
2001
                } else {
 
2002
                        *r->out.rdc_file_info = NULL;
 
2003
                }
 
2004
                if (*r->out.rdc_file_info) {
 
2005
                        _mem_save_rdc_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
2006
                        NDR_PULL_SET_MEM_CTX(ndr, *r->out.rdc_file_info, 0);
 
2007
                        NDR_CHECK(ndr_pull_frstrans_RdcFileInfo(ndr, NDR_SCALARS, *r->out.rdc_file_info));
 
2008
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_file_info_1, 0);
 
2009
                }
 
2010
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rdc_file_info_0, LIBNDR_FLAG_REF_ALLOC);
 
2011
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data_buffer));
 
2012
                NDR_CHECK(ndr_pull_array_length(ndr, &r->out.data_buffer));
 
2013
                if (ndr_get_array_length(ndr, &r->out.data_buffer) > ndr_get_array_size(ndr, &r->out.data_buffer)) {
 
2014
                        return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->out.data_buffer), ndr_get_array_length(ndr, &r->out.data_buffer));
 
2015
                }
 
2016
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
2017
                        NDR_PULL_ALLOC_N(ndr, r->out.data_buffer, ndr_get_array_size(ndr, &r->out.data_buffer));
 
2018
                }
 
2019
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data_buffer, ndr_get_array_length(ndr, &r->out.data_buffer)));
 
2020
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
2021
                        NDR_PULL_ALLOC(ndr, r->out.size_read);
 
2022
                }
 
2023
                _mem_save_size_read_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2024
                NDR_PULL_SET_MEM_CTX(ndr, r->out.size_read, LIBNDR_FLAG_REF_ALLOC);
 
2025
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.size_read));
 
2026
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_size_read_0, LIBNDR_FLAG_REF_ALLOC);
 
2027
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
2028
                        NDR_PULL_ALLOC(ndr, r->out.is_end_of_file);
 
2029
                }
 
2030
                _mem_save_is_end_of_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2031
                NDR_PULL_SET_MEM_CTX(ndr, r->out.is_end_of_file, LIBNDR_FLAG_REF_ALLOC);
 
2032
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.is_end_of_file));
 
2033
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_is_end_of_file_0, LIBNDR_FLAG_REF_ALLOC);
 
2034
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
2035
                if (r->out.data_buffer) {
 
2036
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data_buffer, r->in.buffer_size));
 
2037
                }
 
2038
                if (r->out.data_buffer) {
 
2039
                        NDR_CHECK(ndr_check_array_length(ndr, (void*)&r->out.data_buffer, *r->out.size_read));
 
2040
                }
 
2041
        }
 
2042
        return NDR_ERR_SUCCESS;
 
2043
}
 
2044
 
 
2045
_PUBLIC_ void ndr_print_frstrans_InitializeFileTransferAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_InitializeFileTransferAsync *r)
 
2046
{
 
2047
        ndr_print_struct(ndr, name, "frstrans_InitializeFileTransferAsync");
 
2048
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2049
        ndr->depth++;
 
2050
        if (flags & NDR_SET_VALUES) {
 
2051
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
2052
        }
 
2053
        if (flags & NDR_IN) {
 
2054
                ndr_print_struct(ndr, "in", "frstrans_InitializeFileTransferAsync");
 
2055
                ndr->depth++;
 
2056
                ndr_print_GUID(ndr, "connection_guid", &r->in.connection_guid);
 
2057
                ndr_print_ptr(ndr, "frs_update", r->in.frs_update);
 
2058
                ndr->depth++;
 
2059
                ndr_print_frstrans_Update(ndr, "frs_update", r->in.frs_update);
 
2060
                ndr->depth--;
 
2061
                ndr_print_uint32(ndr, "rdc_desired", r->in.rdc_desired);
 
2062
                ndr_print_ptr(ndr, "staging_policy", r->in.staging_policy);
 
2063
                ndr->depth++;
 
2064
                ndr_print_frstrans_RequestedStagingPolicy(ndr, "staging_policy", *r->in.staging_policy);
 
2065
                ndr->depth--;
 
2066
                ndr_print_uint32(ndr, "buffer_size", r->in.buffer_size);
 
2067
                ndr->depth--;
 
2068
        }
 
2069
        if (flags & NDR_OUT) {
 
2070
                ndr_print_struct(ndr, "out", "frstrans_InitializeFileTransferAsync");
 
2071
                ndr->depth++;
 
2072
                ndr_print_ptr(ndr, "frs_update", r->out.frs_update);
 
2073
                ndr->depth++;
 
2074
                ndr_print_frstrans_Update(ndr, "frs_update", r->out.frs_update);
 
2075
                ndr->depth--;
 
2076
                ndr_print_ptr(ndr, "staging_policy", r->out.staging_policy);
 
2077
                ndr->depth++;
 
2078
                ndr_print_frstrans_RequestedStagingPolicy(ndr, "staging_policy", *r->out.staging_policy);
 
2079
                ndr->depth--;
 
2080
                ndr_print_ptr(ndr, "server_context", r->out.server_context);
 
2081
                ndr->depth++;
 
2082
                ndr_print_policy_handle(ndr, "server_context", r->out.server_context);
 
2083
                ndr->depth--;
 
2084
                ndr_print_ptr(ndr, "rdc_file_info", r->out.rdc_file_info);
 
2085
                ndr->depth++;
 
2086
                ndr_print_ptr(ndr, "rdc_file_info", *r->out.rdc_file_info);
 
2087
                ndr->depth++;
 
2088
                if (*r->out.rdc_file_info) {
 
2089
                        ndr_print_frstrans_RdcFileInfo(ndr, "rdc_file_info", *r->out.rdc_file_info);
 
2090
                }
 
2091
                ndr->depth--;
 
2092
                ndr->depth--;
 
2093
                ndr_print_ptr(ndr, "data_buffer", r->out.data_buffer);
 
2094
                ndr->depth++;
 
2095
                ndr_print_array_uint8(ndr, "data_buffer", r->out.data_buffer, *r->out.size_read);
 
2096
                ndr->depth--;
 
2097
                ndr_print_ptr(ndr, "size_read", r->out.size_read);
 
2098
                ndr->depth++;
 
2099
                ndr_print_uint32(ndr, "size_read", *r->out.size_read);
 
2100
                ndr->depth--;
 
2101
                ndr_print_ptr(ndr, "is_end_of_file", r->out.is_end_of_file);
 
2102
                ndr->depth++;
 
2103
                ndr_print_uint32(ndr, "is_end_of_file", *r->out.is_end_of_file);
 
2104
                ndr->depth--;
 
2105
                ndr_print_WERROR(ndr, "result", r->out.result);
 
2106
                ndr->depth--;
 
2107
        }
 
2108
        ndr->depth--;
 
2109
}
 
2110
 
 
2111
static enum ndr_err_code ndr_push_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_push *ndr, int flags, const struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
 
2112
{
 
2113
        if (flags & NDR_IN) {
 
2114
        }
 
2115
        if (flags & NDR_OUT) {
 
2116
        }
 
2117
        return NDR_ERR_SUCCESS;
 
2118
}
 
2119
 
 
2120
static enum ndr_err_code ndr_pull_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_pull *ndr, int flags, struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
 
2121
{
 
2122
        if (flags & NDR_IN) {
 
2123
        }
 
2124
        if (flags & NDR_OUT) {
 
2125
        }
 
2126
        return NDR_ERR_SUCCESS;
 
2127
}
 
2128
 
 
2129
_PUBLIC_ void ndr_print_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE(struct ndr_print *ndr, const char *name, int flags, const struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE *r)
 
2130
{
 
2131
        ndr_print_struct(ndr, name, "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
 
2132
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2133
        ndr->depth++;
 
2134
        if (flags & NDR_SET_VALUES) {
 
2135
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
2136
        }
 
2137
        if (flags & NDR_IN) {
 
2138
                ndr_print_struct(ndr, "in", "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
 
2139
                ndr->depth++;
 
2140
                ndr->depth--;
 
2141
        }
 
2142
        if (flags & NDR_OUT) {
 
2143
                ndr_print_struct(ndr, "out", "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE");
 
2144
                ndr->depth++;
 
2145
                ndr->depth--;
 
2146
        }
 
2147
        ndr->depth--;
 
2148
}
 
2149
 
 
2150
static enum ndr_err_code ndr_push_frstrans_RawGetFileDataAsync(struct ndr_push *ndr, int flags, const struct frstrans_RawGetFileDataAsync *r)
 
2151
{
 
2152
        if (flags & NDR_IN) {
 
2153
                if (r->in.server_context == NULL) {
 
2154
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
2155
                }
 
2156
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
 
2157
        }
 
2158
        if (flags & NDR_OUT) {
 
2159
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
2160
        }
 
2161
        return NDR_ERR_SUCCESS;
 
2162
}
 
2163
 
 
2164
static enum ndr_err_code ndr_pull_frstrans_RawGetFileDataAsync(struct ndr_pull *ndr, int flags, struct frstrans_RawGetFileDataAsync *r)
 
2165
{
 
2166
        TALLOC_CTX *_mem_save_server_context_0;
 
2167
        if (flags & NDR_IN) {
 
2168
                ZERO_STRUCT(r->out);
 
2169
 
 
2170
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
2171
                        NDR_PULL_ALLOC(ndr, r->in.server_context);
 
2172
                }
 
2173
                _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2174
                NDR_PULL_SET_MEM_CTX(ndr, r->in.server_context, LIBNDR_FLAG_REF_ALLOC);
 
2175
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
 
2176
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
 
2177
        }
 
2178
        if (flags & NDR_OUT) {
 
2179
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
2180
        }
 
2181
        return NDR_ERR_SUCCESS;
 
2182
}
 
2183
 
 
2184
_PUBLIC_ void ndr_print_frstrans_RawGetFileDataAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RawGetFileDataAsync *r)
 
2185
{
 
2186
        ndr_print_struct(ndr, name, "frstrans_RawGetFileDataAsync");
 
2187
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2188
        ndr->depth++;
 
2189
        if (flags & NDR_SET_VALUES) {
 
2190
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
2191
        }
 
2192
        if (flags & NDR_IN) {
 
2193
                ndr_print_struct(ndr, "in", "frstrans_RawGetFileDataAsync");
 
2194
                ndr->depth++;
 
2195
                ndr_print_ptr(ndr, "server_context", r->in.server_context);
 
2196
                ndr->depth++;
 
2197
                ndr_print_policy_handle(ndr, "server_context", r->in.server_context);
 
2198
                ndr->depth--;
 
2199
                ndr->depth--;
 
2200
        }
 
2201
        if (flags & NDR_OUT) {
 
2202
                ndr_print_struct(ndr, "out", "frstrans_RawGetFileDataAsync");
 
2203
                ndr->depth++;
 
2204
                ndr_print_ptr(ndr, "byte_pipe", r->out.byte_pipe);
 
2205
                ndr->depth++;
 
2206
                ndr->depth--;
 
2207
                ndr_print_WERROR(ndr, "result", r->out.result);
 
2208
                ndr->depth--;
 
2209
        }
 
2210
        ndr->depth--;
 
2211
}
 
2212
 
 
2213
static enum ndr_err_code ndr_push_frstrans_RdcGetFileDataAsync(struct ndr_push *ndr, int flags, const struct frstrans_RdcGetFileDataAsync *r)
 
2214
{
 
2215
        if (flags & NDR_IN) {
 
2216
                if (r->in.server_context == NULL) {
 
2217
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
2218
                }
 
2219
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
 
2220
        }
 
2221
        if (flags & NDR_OUT) {
 
2222
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 
2223
        }
 
2224
        return NDR_ERR_SUCCESS;
 
2225
}
 
2226
 
 
2227
static enum ndr_err_code ndr_pull_frstrans_RdcGetFileDataAsync(struct ndr_pull *ndr, int flags, struct frstrans_RdcGetFileDataAsync *r)
 
2228
{
 
2229
        TALLOC_CTX *_mem_save_server_context_0;
 
2230
        if (flags & NDR_IN) {
 
2231
                ZERO_STRUCT(r->out);
 
2232
 
 
2233
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
2234
                        NDR_PULL_ALLOC(ndr, r->in.server_context);
 
2235
                }
 
2236
                _mem_save_server_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
2237
                NDR_PULL_SET_MEM_CTX(ndr, r->in.server_context, LIBNDR_FLAG_REF_ALLOC);
 
2238
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.server_context));
 
2239
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_context_0, LIBNDR_FLAG_REF_ALLOC);
 
2240
        }
 
2241
        if (flags & NDR_OUT) {
 
2242
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 
2243
        }
 
2244
        return NDR_ERR_SUCCESS;
 
2245
}
 
2246
 
 
2247
_PUBLIC_ void ndr_print_frstrans_RdcGetFileDataAsync(struct ndr_print *ndr, const char *name, int flags, const struct frstrans_RdcGetFileDataAsync *r)
 
2248
{
 
2249
        ndr_print_struct(ndr, name, "frstrans_RdcGetFileDataAsync");
 
2250
        if (r == NULL) { ndr_print_null(ndr); return; }
 
2251
        ndr->depth++;
 
2252
        if (flags & NDR_SET_VALUES) {
 
2253
                ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 
2254
        }
 
2255
        if (flags & NDR_IN) {
 
2256
                ndr_print_struct(ndr, "in", "frstrans_RdcGetFileDataAsync");
 
2257
                ndr->depth++;
 
2258
                ndr_print_ptr(ndr, "server_context", r->in.server_context);
 
2259
                ndr->depth++;
 
2260
                ndr_print_policy_handle(ndr, "server_context", r->in.server_context);
 
2261
                ndr->depth--;
 
2262
                ndr->depth--;
 
2263
        }
 
2264
        if (flags & NDR_OUT) {
 
2265
                ndr_print_struct(ndr, "out", "frstrans_RdcGetFileDataAsync");
 
2266
                ndr->depth++;
 
2267
                ndr_print_ptr(ndr, "byte_pipe", r->out.byte_pipe);
 
2268
                ndr->depth++;
 
2269
                ndr->depth--;
 
2270
                ndr_print_WERROR(ndr, "result", r->out.result);
 
2271
                ndr->depth--;
 
2272
        }
 
2273
        ndr->depth--;
 
2274
}
 
2275
 
 
2276
static const struct ndr_interface_call_pipe frstrans_RawGetFileDataAsync_out_pipes[] = {
 
2277
        {
 
2278
                "out.byte_pipe",
 
2279
                "frstrans_BytePipe_chunk",
 
2280
                sizeof(struct frstrans_BytePipe_chunk),
 
2281
                (ndr_push_flags_fn_t) ndr_push_frstrans_BytePipe_chunk,
 
2282
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_BytePipe_chunk,
 
2283
                (ndr_print_fn_t) ndr_print_frstrans_BytePipe_chunk,
 
2284
        },
 
2285
        { NULL, NULL, 0, NULL, NULL, NULL }
 
2286
};
 
2287
 
 
2288
static const struct ndr_interface_call_pipe frstrans_RdcGetFileDataAsync_out_pipes[] = {
 
2289
        {
 
2290
                "out.byte_pipe",
 
2291
                "frstrans_BytePipe_chunk",
 
2292
                sizeof(struct frstrans_BytePipe_chunk),
 
2293
                (ndr_push_flags_fn_t) ndr_push_frstrans_BytePipe_chunk,
 
2294
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_BytePipe_chunk,
 
2295
                (ndr_print_fn_t) ndr_print_frstrans_BytePipe_chunk,
 
2296
        },
 
2297
        { NULL, NULL, 0, NULL, NULL, NULL }
 
2298
};
 
2299
 
 
2300
static const struct ndr_interface_call frstrans_calls[] = {
 
2301
        {
 
2302
                "frstrans_CheckConnectivity",
 
2303
                sizeof(struct frstrans_CheckConnectivity),
 
2304
                (ndr_push_flags_fn_t) ndr_push_frstrans_CheckConnectivity,
 
2305
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_CheckConnectivity,
 
2306
                (ndr_print_function_t) ndr_print_frstrans_CheckConnectivity,
 
2307
                { 0, NULL },
 
2308
                { 0, NULL },
 
2309
        },
 
2310
        {
 
2311
                "frstrans_EstablishConnection",
 
2312
                sizeof(struct frstrans_EstablishConnection),
 
2313
                (ndr_push_flags_fn_t) ndr_push_frstrans_EstablishConnection,
 
2314
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_EstablishConnection,
 
2315
                (ndr_print_function_t) ndr_print_frstrans_EstablishConnection,
 
2316
                { 0, NULL },
 
2317
                { 0, NULL },
 
2318
        },
 
2319
        {
 
2320
                "frstrans_EstablishSession",
 
2321
                sizeof(struct frstrans_EstablishSession),
 
2322
                (ndr_push_flags_fn_t) ndr_push_frstrans_EstablishSession,
 
2323
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_EstablishSession,
 
2324
                (ndr_print_function_t) ndr_print_frstrans_EstablishSession,
 
2325
                { 0, NULL },
 
2326
                { 0, NULL },
 
2327
        },
 
2328
        {
 
2329
                "frstrans_RequestUpdates",
 
2330
                sizeof(struct frstrans_RequestUpdates),
 
2331
                (ndr_push_flags_fn_t) ndr_push_frstrans_RequestUpdates,
 
2332
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_RequestUpdates,
 
2333
                (ndr_print_function_t) ndr_print_frstrans_RequestUpdates,
 
2334
                { 0, NULL },
 
2335
                { 0, NULL },
 
2336
        },
 
2337
        {
 
2338
                "frstrans_RequestVersionVector",
 
2339
                sizeof(struct frstrans_RequestVersionVector),
 
2340
                (ndr_push_flags_fn_t) ndr_push_frstrans_RequestVersionVector,
 
2341
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_RequestVersionVector,
 
2342
                (ndr_print_function_t) ndr_print_frstrans_RequestVersionVector,
 
2343
                { 0, NULL },
 
2344
                { 0, NULL },
 
2345
        },
 
2346
        {
 
2347
                "frstrans_AsyncPoll",
 
2348
                sizeof(struct frstrans_AsyncPoll),
 
2349
                (ndr_push_flags_fn_t) ndr_push_frstrans_AsyncPoll,
 
2350
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_AsyncPoll,
 
2351
                (ndr_print_function_t) ndr_print_frstrans_AsyncPoll,
 
2352
                { 0, NULL },
 
2353
                { 0, NULL },
 
2354
        },
 
2355
        {
 
2356
                "FRSTRANS_REQUEST_RECORDS",
 
2357
                sizeof(struct FRSTRANS_REQUEST_RECORDS),
 
2358
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_REQUEST_RECORDS,
 
2359
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_REQUEST_RECORDS,
 
2360
                (ndr_print_function_t) ndr_print_FRSTRANS_REQUEST_RECORDS,
 
2361
                { 0, NULL },
 
2362
                { 0, NULL },
 
2363
        },
 
2364
        {
 
2365
                "FRSTRANS_UPDATE_CANCEL",
 
2366
                sizeof(struct FRSTRANS_UPDATE_CANCEL),
 
2367
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_UPDATE_CANCEL,
 
2368
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_UPDATE_CANCEL,
 
2369
                (ndr_print_function_t) ndr_print_FRSTRANS_UPDATE_CANCEL,
 
2370
                { 0, NULL },
 
2371
                { 0, NULL },
 
2372
        },
 
2373
        {
 
2374
                "FRSTRANS_RAW_GET_FILE_DATA",
 
2375
                sizeof(struct FRSTRANS_RAW_GET_FILE_DATA),
 
2376
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RAW_GET_FILE_DATA,
 
2377
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RAW_GET_FILE_DATA,
 
2378
                (ndr_print_function_t) ndr_print_FRSTRANS_RAW_GET_FILE_DATA,
 
2379
                { 0, NULL },
 
2380
                { 0, NULL },
 
2381
        },
 
2382
        {
 
2383
                "FRSTRANS_RDC_GET_SIGNATURES",
 
2384
                sizeof(struct FRSTRANS_RDC_GET_SIGNATURES),
 
2385
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_GET_SIGNATURES,
 
2386
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_GET_SIGNATURES,
 
2387
                (ndr_print_function_t) ndr_print_FRSTRANS_RDC_GET_SIGNATURES,
 
2388
                { 0, NULL },
 
2389
                { 0, NULL },
 
2390
        },
 
2391
        {
 
2392
                "FRSTRANS_RDC_PUSH_SOURCE_NEEDS",
 
2393
                sizeof(struct FRSTRANS_RDC_PUSH_SOURCE_NEEDS),
 
2394
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
 
2395
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
 
2396
                (ndr_print_function_t) ndr_print_FRSTRANS_RDC_PUSH_SOURCE_NEEDS,
 
2397
                { 0, NULL },
 
2398
                { 0, NULL },
 
2399
        },
 
2400
        {
 
2401
                "FRSTRANS_RDC_GET_FILE_DATA",
 
2402
                sizeof(struct FRSTRANS_RDC_GET_FILE_DATA),
 
2403
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_GET_FILE_DATA,
 
2404
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_GET_FILE_DATA,
 
2405
                (ndr_print_function_t) ndr_print_FRSTRANS_RDC_GET_FILE_DATA,
 
2406
                { 0, NULL },
 
2407
                { 0, NULL },
 
2408
        },
 
2409
        {
 
2410
                "FRSTRANS_RDC_CLOSE",
 
2411
                sizeof(struct FRSTRANS_RDC_CLOSE),
 
2412
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_RDC_CLOSE,
 
2413
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_RDC_CLOSE,
 
2414
                (ndr_print_function_t) ndr_print_FRSTRANS_RDC_CLOSE,
 
2415
                { 0, NULL },
 
2416
                { 0, NULL },
 
2417
        },
 
2418
        {
 
2419
                "frstrans_InitializeFileTransferAsync",
 
2420
                sizeof(struct frstrans_InitializeFileTransferAsync),
 
2421
                (ndr_push_flags_fn_t) ndr_push_frstrans_InitializeFileTransferAsync,
 
2422
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_InitializeFileTransferAsync,
 
2423
                (ndr_print_function_t) ndr_print_frstrans_InitializeFileTransferAsync,
 
2424
                { 0, NULL },
 
2425
                { 0, NULL },
 
2426
        },
 
2427
        {
 
2428
                "FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE",
 
2429
                sizeof(struct FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE),
 
2430
                (ndr_push_flags_fn_t) ndr_push_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
 
2431
                (ndr_pull_flags_fn_t) ndr_pull_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
 
2432
                (ndr_print_function_t) ndr_print_FRSTRANS_OPNUM_0E_NOT_USED_ON_THE_WIRE,
 
2433
                { 0, NULL },
 
2434
                { 0, NULL },
 
2435
        },
 
2436
        {
 
2437
                "frstrans_RawGetFileDataAsync",
 
2438
                sizeof(struct frstrans_RawGetFileDataAsync),
 
2439
                (ndr_push_flags_fn_t) ndr_push_frstrans_RawGetFileDataAsync,
 
2440
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_RawGetFileDataAsync,
 
2441
                (ndr_print_function_t) ndr_print_frstrans_RawGetFileDataAsync,
 
2442
                { 0, NULL },
 
2443
                { 1, frstrans_RawGetFileDataAsync_out_pipes },
 
2444
        },
 
2445
        {
 
2446
                "frstrans_RdcGetFileDataAsync",
 
2447
                sizeof(struct frstrans_RdcGetFileDataAsync),
 
2448
                (ndr_push_flags_fn_t) ndr_push_frstrans_RdcGetFileDataAsync,
 
2449
                (ndr_pull_flags_fn_t) ndr_pull_frstrans_RdcGetFileDataAsync,
 
2450
                (ndr_print_function_t) ndr_print_frstrans_RdcGetFileDataAsync,
 
2451
                { 0, NULL },
 
2452
                { 1, frstrans_RdcGetFileDataAsync_out_pipes },
 
2453
        },
 
2454
        { NULL, 0, NULL, NULL, NULL }
 
2455
};
 
2456
 
 
2457
static const char * const frstrans_endpoint_strings[] = {
 
2458
        "ncacn_ip_tcp:", 
 
2459
        "ncalrpc:", 
 
2460
};
 
2461
 
 
2462
static const struct ndr_interface_string_array frstrans_endpoints = {
 
2463
        .count  = 2,
 
2464
        .names  = frstrans_endpoint_strings
 
2465
};
 
2466
 
 
2467
static const char * const frstrans_authservice_strings[] = {
 
2468
        "host", 
 
2469
};
 
2470
 
 
2471
static const struct ndr_interface_string_array frstrans_authservices = {
 
2472
        .count  = 1,
 
2473
        .names  = frstrans_authservice_strings
 
2474
};
 
2475
 
 
2476
 
 
2477
const struct ndr_interface_table ndr_table_frstrans = {
 
2478
        .name           = "frstrans",
 
2479
        .syntax_id      = {
 
2480
                {0x897e2e5f,0x93f3,0x4376,{0x9c,0x9c},{0xfd,0x22,0x77,0x49,0x5c,0x27}},
 
2481
                NDR_FRSTRANS_VERSION
 
2482
        },
 
2483
        .helpstring     = NDR_FRSTRANS_HELPSTRING,
 
2484
        .num_calls      = 17,
 
2485
        .calls          = frstrans_calls,
 
2486
        .endpoints      = &frstrans_endpoints,
 
2487
        .authservices   = &frstrans_authservices
 
2488
};
 
2489