← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_xattr.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_xattr.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_xattr.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_security.h"
 
7
static enum ndr_err_code ndr_push_xattr_DosInfo1(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo1 *r)
 
8
{
 
9
        if (ndr_flags & NDR_SCALARS) {
 
10
                NDR_CHECK(ndr_push_align(ndr, 4));
 
11
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
 
12
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
 
13
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 
14
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 
15
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
 
16
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
 
17
        }
 
18
        if (ndr_flags & NDR_BUFFERS) {
 
19
        }
 
20
        return NDR_ERR_SUCCESS;
 
21
}
 
22
 
 
23
static enum ndr_err_code ndr_pull_xattr_DosInfo1(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo1 *r)
 
24
{
 
25
        if (ndr_flags & NDR_SCALARS) {
 
26
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
27
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
 
28
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
 
29
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 
30
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 
31
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
 
32
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
 
33
        }
 
34
        if (ndr_flags & NDR_BUFFERS) {
 
35
        }
 
36
        return NDR_ERR_SUCCESS;
 
37
}
 
38
 
 
39
_PUBLIC_ void ndr_print_xattr_DosInfo1(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo1 *r)
 
40
{
 
41
        ndr_print_struct(ndr, name, "xattr_DosInfo1");
 
42
        ndr->depth++;
 
43
        ndr_print_uint32(ndr, "attrib", r->attrib);
 
44
        ndr_print_uint32(ndr, "ea_size", r->ea_size);
 
45
        ndr_print_udlong(ndr, "size", r->size);
 
46
        ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 
47
        ndr_print_NTTIME(ndr, "create_time", r->create_time);
 
48
        ndr_print_NTTIME(ndr, "change_time", r->change_time);
 
49
        ndr->depth--;
 
50
}
 
51
 
 
52
static enum ndr_err_code ndr_push_xattr_DosInfo2Old(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosInfo2Old *r)
 
53
{
 
54
        if (ndr_flags & NDR_SCALARS) {
 
55
                NDR_CHECK(ndr_push_align(ndr, 4));
 
56
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 
57
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->attrib));
 
58
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ea_size));
 
59
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 
60
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 
61
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->create_time));
 
62
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->change_time));
 
63
                NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->write_time));
 
64
                {
 
65
                        uint32_t _flags_save_string = ndr->flags;
 
66
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
67
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 
68
                        ndr->flags = _flags_save_string;
 
69
                }
 
70
        }
 
71
        if (ndr_flags & NDR_BUFFERS) {
 
72
        }
 
73
        return NDR_ERR_SUCCESS;
 
74
}
 
75
 
 
76
static enum ndr_err_code ndr_pull_xattr_DosInfo2Old(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosInfo2Old *r)
 
77
{
 
78
        if (ndr_flags & NDR_SCALARS) {
 
79
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
80
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 
81
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->attrib));
 
82
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ea_size));
 
83
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 
84
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 
85
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->create_time));
 
86
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->change_time));
 
87
                NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->write_time));
 
88
                {
 
89
                        uint32_t _flags_save_string = ndr->flags;
 
90
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
91
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 
92
                        ndr->flags = _flags_save_string;
 
93
                }
 
94
        }
 
95
        if (ndr_flags & NDR_BUFFERS) {
 
96
        }
 
97
        return NDR_ERR_SUCCESS;
 
98
}
 
99
 
 
100
_PUBLIC_ void ndr_print_xattr_DosInfo2Old(struct ndr_print *ndr, const char *name, const struct xattr_DosInfo2Old *r)
 
101
{
 
102
        ndr_print_struct(ndr, name, "xattr_DosInfo2Old");
 
103
        ndr->depth++;
 
104
        ndr_print_uint32(ndr, "flags", r->flags);
 
105
        ndr_print_uint32(ndr, "attrib", r->attrib);
 
106
        ndr_print_uint32(ndr, "ea_size", r->ea_size);
 
107
        ndr_print_udlong(ndr, "size", r->size);
 
108
        ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 
109
        ndr_print_NTTIME(ndr, "create_time", r->create_time);
 
110
        ndr_print_NTTIME(ndr, "change_time", r->change_time);
 
111
        ndr_print_NTTIME(ndr, "write_time", r->write_time);
 
112
        ndr_print_string(ndr, "name", r->name);
 
113
        ndr->depth--;
 
114
}
 
115
 
 
116
static enum ndr_err_code ndr_push_xattr_DosInfo(struct ndr_push *ndr, int ndr_flags, const union xattr_DosInfo *r)
 
117
{
 
118
        if (ndr_flags & NDR_SCALARS) {
 
119
                int level = ndr_push_get_switch_value(ndr, r);
 
120
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
121
                switch (level) {
 
122
                        case 1: {
 
123
                                NDR_CHECK(ndr_push_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 
124
                        break; }
 
125
 
 
126
                        case 2: {
 
127
                                NDR_CHECK(ndr_push_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 
128
                        break; }
 
129
 
 
130
                        default:
 
131
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
132
                }
 
133
        }
 
134
        if (ndr_flags & NDR_BUFFERS) {
 
135
                int level = ndr_push_get_switch_value(ndr, r);
 
136
                switch (level) {
 
137
                        case 1:
 
138
                        break;
 
139
 
 
140
                        case 2:
 
141
                        break;
 
142
 
 
143
                        default:
 
144
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
145
                }
 
146
        }
 
147
        return NDR_ERR_SUCCESS;
 
148
}
 
149
 
 
150
static enum ndr_err_code ndr_pull_xattr_DosInfo(struct ndr_pull *ndr, int ndr_flags, union xattr_DosInfo *r)
 
151
{
 
152
        int level;
 
153
        uint16_t _level;
 
154
        level = ndr_pull_get_switch_value(ndr, r);
 
155
        if (ndr_flags & NDR_SCALARS) {
 
156
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
157
                if (_level != level) {
 
158
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
159
                }
 
160
                switch (level) {
 
161
                        case 1: {
 
162
                                NDR_CHECK(ndr_pull_xattr_DosInfo1(ndr, NDR_SCALARS, &r->info1));
 
163
                        break; }
 
164
 
 
165
                        case 2: {
 
166
                                NDR_CHECK(ndr_pull_xattr_DosInfo2Old(ndr, NDR_SCALARS, &r->oldinfo2));
 
167
                        break; }
 
168
 
 
169
                        default:
 
170
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
171
                }
 
172
        }
 
173
        if (ndr_flags & NDR_BUFFERS) {
 
174
                switch (level) {
 
175
                        case 1:
 
176
                        break;
 
177
 
 
178
                        case 2:
 
179
                        break;
 
180
 
 
181
                        default:
 
182
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
183
                }
 
184
        }
 
185
        return NDR_ERR_SUCCESS;
 
186
}
 
187
 
 
188
_PUBLIC_ void ndr_print_xattr_DosInfo(struct ndr_print *ndr, const char *name, const union xattr_DosInfo *r)
 
189
{
 
190
        int level;
 
191
        level = ndr_print_get_switch_value(ndr, r);
 
192
        ndr_print_union(ndr, name, level, "xattr_DosInfo");
 
193
        switch (level) {
 
194
                case 1:
 
195
                        ndr_print_xattr_DosInfo1(ndr, "info1", &r->info1);
 
196
                break;
 
197
 
 
198
                case 2:
 
199
                        ndr_print_xattr_DosInfo2Old(ndr, "oldinfo2", &r->oldinfo2);
 
200
                break;
 
201
 
 
202
                default:
 
203
                        ndr_print_bad_level(ndr, name, level);
 
204
        }
 
205
}
 
206
 
 
207
_PUBLIC_ enum ndr_err_code ndr_push_xattr_DosAttrib(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosAttrib *r)
 
208
{
 
209
        if (ndr_flags & NDR_SCALARS) {
 
210
                NDR_CHECK(ndr_push_align(ndr, 4));
 
211
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 
212
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 
213
                NDR_CHECK(ndr_push_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 
214
        }
 
215
        if (ndr_flags & NDR_BUFFERS) {
 
216
        }
 
217
        return NDR_ERR_SUCCESS;
 
218
}
 
219
 
 
220
_PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosAttrib(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosAttrib *r)
 
221
{
 
222
        if (ndr_flags & NDR_SCALARS) {
 
223
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
224
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 
225
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 
226
                NDR_CHECK(ndr_pull_xattr_DosInfo(ndr, NDR_SCALARS, &r->info));
 
227
        }
 
228
        if (ndr_flags & NDR_BUFFERS) {
 
229
        }
 
230
        return NDR_ERR_SUCCESS;
 
231
}
 
232
 
 
233
_PUBLIC_ void ndr_print_xattr_DosAttrib(struct ndr_print *ndr, const char *name, const struct xattr_DosAttrib *r)
 
234
{
 
235
        ndr_print_struct(ndr, name, "xattr_DosAttrib");
 
236
        ndr->depth++;
 
237
        ndr_print_uint16(ndr, "version", r->version);
 
238
        ndr_print_set_switch_value(ndr, &r->info, r->version);
 
239
        ndr_print_xattr_DosInfo(ndr, "info", &r->info);
 
240
        ndr->depth--;
 
241
}
 
242
 
 
243
static enum ndr_err_code ndr_push_xattr_EA(struct ndr_push *ndr, int ndr_flags, const struct xattr_EA *r)
 
244
{
 
245
        if (ndr_flags & NDR_SCALARS) {
 
246
                NDR_CHECK(ndr_push_align(ndr, 4));
 
247
                {
 
248
                        uint32_t _flags_save_string = ndr->flags;
 
249
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
250
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 
251
                        ndr->flags = _flags_save_string;
 
252
                }
 
253
                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->value));
 
254
        }
 
255
        if (ndr_flags & NDR_BUFFERS) {
 
256
        }
 
257
        return NDR_ERR_SUCCESS;
 
258
}
 
259
 
 
260
static enum ndr_err_code ndr_pull_xattr_EA(struct ndr_pull *ndr, int ndr_flags, struct xattr_EA *r)
 
261
{
 
262
        if (ndr_flags & NDR_SCALARS) {
 
263
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
264
                {
 
265
                        uint32_t _flags_save_string = ndr->flags;
 
266
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
267
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 
268
                        ndr->flags = _flags_save_string;
 
269
                }
 
270
                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->value));
 
271
        }
 
272
        if (ndr_flags & NDR_BUFFERS) {
 
273
        }
 
274
        return NDR_ERR_SUCCESS;
 
275
}
 
276
 
 
277
_PUBLIC_ void ndr_print_xattr_EA(struct ndr_print *ndr, const char *name, const struct xattr_EA *r)
 
278
{
 
279
        ndr_print_struct(ndr, name, "xattr_EA");
 
280
        ndr->depth++;
 
281
        ndr_print_string(ndr, "name", r->name);
 
282
        ndr_print_DATA_BLOB(ndr, "value", r->value);
 
283
        ndr->depth--;
 
284
}
 
285
 
 
286
_PUBLIC_ enum ndr_err_code ndr_push_xattr_DosEAs(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosEAs *r)
 
287
{
 
288
        uint32_t cntr_eas_1;
 
289
        if (ndr_flags & NDR_SCALARS) {
 
290
                NDR_CHECK(ndr_push_align(ndr, 4));
 
291
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->num_eas));
 
292
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->eas));
 
293
        }
 
294
        if (ndr_flags & NDR_BUFFERS) {
 
295
                if (r->eas) {
 
296
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_eas));
 
297
                        for (cntr_eas_1 = 0; cntr_eas_1 < r->num_eas; cntr_eas_1++) {
 
298
                                NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 
299
                        }
 
300
                }
 
301
        }
 
302
        return NDR_ERR_SUCCESS;
 
303
}
 
304
 
 
305
_PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosEAs(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosEAs *r)
 
306
{
 
307
        uint32_t _ptr_eas;
 
308
        uint32_t cntr_eas_1;
 
309
        TALLOC_CTX *_mem_save_eas_0;
 
310
        TALLOC_CTX *_mem_save_eas_1;
 
311
        if (ndr_flags & NDR_SCALARS) {
 
312
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
313
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->num_eas));
 
314
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_eas));
 
315
                if (_ptr_eas) {
 
316
                        NDR_PULL_ALLOC(ndr, r->eas);
 
317
                } else {
 
318
                        r->eas = NULL;
 
319
                }
 
320
        }
 
321
        if (ndr_flags & NDR_BUFFERS) {
 
322
                if (r->eas) {
 
323
                        _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
324
                        NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 
325
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->eas));
 
326
                        NDR_PULL_ALLOC_N(ndr, r->eas, ndr_get_array_size(ndr, &r->eas));
 
327
                        _mem_save_eas_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
328
                        NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 
329
                        for (cntr_eas_1 = 0; cntr_eas_1 < r->num_eas; cntr_eas_1++) {
 
330
                                NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_1]));
 
331
                        }
 
332
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_1, 0);
 
333
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 
334
                }
 
335
                if (r->eas) {
 
336
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->eas, r->num_eas));
 
337
                }
 
338
        }
 
339
        return NDR_ERR_SUCCESS;
 
340
}
 
341
 
 
342
_PUBLIC_ void ndr_print_xattr_DosEAs(struct ndr_print *ndr, const char *name, const struct xattr_DosEAs *r)
 
343
{
 
344
        uint32_t cntr_eas_1;
 
345
        ndr_print_struct(ndr, name, "xattr_DosEAs");
 
346
        ndr->depth++;
 
347
        ndr_print_uint16(ndr, "num_eas", r->num_eas);
 
348
        ndr_print_ptr(ndr, "eas", r->eas);
 
349
        ndr->depth++;
 
350
        if (r->eas) {
 
351
                ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 
352
                ndr->depth++;
 
353
                for (cntr_eas_1=0;cntr_eas_1<r->num_eas;cntr_eas_1++) {
 
354
                        char *idx_1=NULL;
 
355
                        if (asprintf(&idx_1, "[%d]", cntr_eas_1) != -1) {
 
356
                                ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_1]);
 
357
                                free(idx_1);
 
358
                        }
 
359
                }
 
360
                ndr->depth--;
 
361
        }
 
362
        ndr->depth--;
 
363
        ndr->depth--;
 
364
}
 
365
 
 
366
_PUBLIC_ enum ndr_err_code ndr_push_tdb_xattrs(struct ndr_push *ndr, int ndr_flags, const struct tdb_xattrs *r)
 
367
{
 
368
        uint32_t cntr_eas_0;
 
369
        if (ndr_flags & NDR_SCALARS) {
 
370
                NDR_CHECK(ndr_push_align(ndr, 4));
 
371
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_eas));
 
372
                for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
 
373
                        NDR_CHECK(ndr_push_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 
374
                }
 
375
        }
 
376
        if (ndr_flags & NDR_BUFFERS) {
 
377
        }
 
378
        return NDR_ERR_SUCCESS;
 
379
}
 
380
 
 
381
_PUBLIC_ enum ndr_err_code ndr_pull_tdb_xattrs(struct ndr_pull *ndr, int ndr_flags, struct tdb_xattrs *r)
 
382
{
 
383
        uint32_t cntr_eas_0;
 
384
        TALLOC_CTX *_mem_save_eas_0;
 
385
        if (ndr_flags & NDR_SCALARS) {
 
386
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
387
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_eas));
 
388
                NDR_PULL_ALLOC_N(ndr, r->eas, r->num_eas);
 
389
                _mem_save_eas_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
390
                NDR_PULL_SET_MEM_CTX(ndr, r->eas, 0);
 
391
                for (cntr_eas_0 = 0; cntr_eas_0 < r->num_eas; cntr_eas_0++) {
 
392
                        NDR_CHECK(ndr_pull_xattr_EA(ndr, NDR_SCALARS, &r->eas[cntr_eas_0]));
 
393
                }
 
394
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_eas_0, 0);
 
395
        }
 
396
        if (ndr_flags & NDR_BUFFERS) {
 
397
        }
 
398
        return NDR_ERR_SUCCESS;
 
399
}
 
400
 
 
401
_PUBLIC_ void ndr_print_tdb_xattrs(struct ndr_print *ndr, const char *name, const struct tdb_xattrs *r)
 
402
{
 
403
        uint32_t cntr_eas_0;
 
404
        ndr_print_struct(ndr, name, "tdb_xattrs");
 
405
        ndr->depth++;
 
406
        ndr_print_uint32(ndr, "num_eas", r->num_eas);
 
407
        ndr->print(ndr, "%s: ARRAY(%d)", "eas", (int)r->num_eas);
 
408
        ndr->depth++;
 
409
        for (cntr_eas_0=0;cntr_eas_0<r->num_eas;cntr_eas_0++) {
 
410
                char *idx_0=NULL;
 
411
                if (asprintf(&idx_0, "[%d]", cntr_eas_0) != -1) {
 
412
                        ndr_print_xattr_EA(ndr, "eas", &r->eas[cntr_eas_0]);
 
413
                        free(idx_0);
 
414
                }
 
415
        }
 
416
        ndr->depth--;
 
417
        ndr->depth--;
 
418
}
 
419
 
 
420
static enum ndr_err_code ndr_push_xattr_DosStream(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStream *r)
 
421
{
 
422
        if (ndr_flags & NDR_SCALARS) {
 
423
                NDR_CHECK(ndr_push_align(ndr, 4));
 
424
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
 
425
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->size));
 
426
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->alloc_size));
 
427
                {
 
428
                        uint32_t _flags_save_string = ndr->flags;
 
429
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
430
                        NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 
431
                        ndr->flags = _flags_save_string;
 
432
                }
 
433
        }
 
434
        if (ndr_flags & NDR_BUFFERS) {
 
435
        }
 
436
        return NDR_ERR_SUCCESS;
 
437
}
 
438
 
 
439
static enum ndr_err_code ndr_pull_xattr_DosStream(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStream *r)
 
440
{
 
441
        if (ndr_flags & NDR_SCALARS) {
 
442
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
443
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
 
444
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->size));
 
445
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->alloc_size));
 
446
                {
 
447
                        uint32_t _flags_save_string = ndr->flags;
 
448
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_UTF8|LIBNDR_FLAG_STR_NULLTERM);
 
449
                        NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 
450
                        ndr->flags = _flags_save_string;
 
451
                }
 
452
        }
 
453
        if (ndr_flags & NDR_BUFFERS) {
 
454
        }
 
455
        return NDR_ERR_SUCCESS;
 
456
}
 
457
 
 
458
_PUBLIC_ void ndr_print_xattr_DosStream(struct ndr_print *ndr, const char *name, const struct xattr_DosStream *r)
 
459
{
 
460
        ndr_print_struct(ndr, name, "xattr_DosStream");
 
461
        ndr->depth++;
 
462
        ndr_print_uint32(ndr, "flags", r->flags);
 
463
        ndr_print_udlong(ndr, "size", r->size);
 
464
        ndr_print_udlong(ndr, "alloc_size", r->alloc_size);
 
465
        ndr_print_string(ndr, "name", r->name);
 
466
        ndr->depth--;
 
467
}
 
468
 
 
469
_PUBLIC_ enum ndr_err_code ndr_push_xattr_DosStreams(struct ndr_push *ndr, int ndr_flags, const struct xattr_DosStreams *r)
 
470
{
 
471
        uint32_t cntr_streams_1;
 
472
        if (ndr_flags & NDR_SCALARS) {
 
473
                NDR_CHECK(ndr_push_align(ndr, 4));
 
474
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
 
475
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->streams));
 
476
        }
 
477
        if (ndr_flags & NDR_BUFFERS) {
 
478
                if (r->streams) {
 
479
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_streams));
 
480
                        for (cntr_streams_1 = 0; cntr_streams_1 < r->num_streams; cntr_streams_1++) {
 
481
                                NDR_CHECK(ndr_push_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 
482
                        }
 
483
                }
 
484
        }
 
485
        return NDR_ERR_SUCCESS;
 
486
}
 
487
 
 
488
_PUBLIC_ enum ndr_err_code ndr_pull_xattr_DosStreams(struct ndr_pull *ndr, int ndr_flags, struct xattr_DosStreams *r)
 
489
{
 
490
        uint32_t _ptr_streams;
 
491
        uint32_t cntr_streams_1;
 
492
        TALLOC_CTX *_mem_save_streams_0;
 
493
        TALLOC_CTX *_mem_save_streams_1;
 
494
        if (ndr_flags & NDR_SCALARS) {
 
495
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
496
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_streams));
 
497
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_streams));
 
498
                if (_ptr_streams) {
 
499
                        NDR_PULL_ALLOC(ndr, r->streams);
 
500
                } else {
 
501
                        r->streams = NULL;
 
502
                }
 
503
        }
 
504
        if (ndr_flags & NDR_BUFFERS) {
 
505
                if (r->streams) {
 
506
                        _mem_save_streams_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
507
                        NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 
508
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->streams));
 
509
                        NDR_PULL_ALLOC_N(ndr, r->streams, ndr_get_array_size(ndr, &r->streams));
 
510
                        _mem_save_streams_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
511
                        NDR_PULL_SET_MEM_CTX(ndr, r->streams, 0);
 
512
                        for (cntr_streams_1 = 0; cntr_streams_1 < r->num_streams; cntr_streams_1++) {
 
513
                                NDR_CHECK(ndr_pull_xattr_DosStream(ndr, NDR_SCALARS, &r->streams[cntr_streams_1]));
 
514
                        }
 
515
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_1, 0);
 
516
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_streams_0, 0);
 
517
                }
 
518
                if (r->streams) {
 
519
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->streams, r->num_streams));
 
520
                }
 
521
        }
 
522
        return NDR_ERR_SUCCESS;
 
523
}
 
524
 
 
525
_PUBLIC_ void ndr_print_xattr_DosStreams(struct ndr_print *ndr, const char *name, const struct xattr_DosStreams *r)
 
526
{
 
527
        uint32_t cntr_streams_1;
 
528
        ndr_print_struct(ndr, name, "xattr_DosStreams");
 
529
        ndr->depth++;
 
530
        ndr_print_uint32(ndr, "num_streams", r->num_streams);
 
531
        ndr_print_ptr(ndr, "streams", r->streams);
 
532
        ndr->depth++;
 
533
        if (r->streams) {
 
534
                ndr->print(ndr, "%s: ARRAY(%d)", "streams", (int)r->num_streams);
 
535
                ndr->depth++;
 
536
                for (cntr_streams_1=0;cntr_streams_1<r->num_streams;cntr_streams_1++) {
 
537
                        char *idx_1=NULL;
 
538
                        if (asprintf(&idx_1, "[%d]", cntr_streams_1) != -1) {
 
539
                                ndr_print_xattr_DosStream(ndr, "streams", &r->streams[cntr_streams_1]);
 
540
                                free(idx_1);
 
541
                        }
 
542
                }
 
543
                ndr->depth--;
 
544
        }
 
545
        ndr->depth--;
 
546
        ndr->depth--;
 
547
}
 
548
 
 
549
_PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_hash(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor_hash *r)
 
550
{
 
551
        if (ndr_flags & NDR_SCALARS) {
 
552
                NDR_CHECK(ndr_push_align(ndr, 4));
 
553
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 
554
                NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
555
        }
 
556
        if (ndr_flags & NDR_BUFFERS) {
 
557
                if (r->sd) {
 
558
                        NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
559
                }
 
560
        }
 
561
        return NDR_ERR_SUCCESS;
 
562
}
 
563
 
 
564
_PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_hash(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor_hash *r)
 
565
{
 
566
        uint32_t _ptr_sd;
 
567
        TALLOC_CTX *_mem_save_sd_0;
 
568
        if (ndr_flags & NDR_SCALARS) {
 
569
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
570
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 
571
                if (_ptr_sd) {
 
572
                        NDR_PULL_ALLOC(ndr, r->sd);
 
573
                } else {
 
574
                        r->sd = NULL;
 
575
                }
 
576
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->hash, 16));
 
577
        }
 
578
        if (ndr_flags & NDR_BUFFERS) {
 
579
                if (r->sd) {
 
580
                        _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
581
                        NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 
582
                        NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
583
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 
584
                }
 
585
        }
 
586
        return NDR_ERR_SUCCESS;
 
587
}
 
588
 
 
589
_PUBLIC_ void ndr_print_security_descriptor_hash(struct ndr_print *ndr, const char *name, const struct security_descriptor_hash *r)
 
590
{
 
591
        ndr_print_struct(ndr, name, "security_descriptor_hash");
 
592
        ndr->depth++;
 
593
        ndr_print_ptr(ndr, "sd", r->sd);
 
594
        ndr->depth++;
 
595
        if (r->sd) {
 
596
                ndr_print_security_descriptor(ndr, "sd", r->sd);
 
597
        }
 
598
        ndr->depth--;
 
599
        ndr_print_array_uint8(ndr, "hash", r->hash, 16);
 
600
        ndr->depth--;
 
601
}
 
602
 
 
603
static enum ndr_err_code ndr_push_xattr_NTACL_Info(struct ndr_push *ndr, int ndr_flags, const union xattr_NTACL_Info *r)
 
604
{
 
605
        if (ndr_flags & NDR_SCALARS) {
 
606
                int level = ndr_push_get_switch_value(ndr, r);
 
607
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, level));
 
608
                switch (level) {
 
609
                        case 1: {
 
610
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 
611
                        break; }
 
612
 
 
613
                        case 2: {
 
614
                                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd_hs));
 
615
                        break; }
 
616
 
 
617
                        default:
 
618
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
619
                }
 
620
        }
 
621
        if (ndr_flags & NDR_BUFFERS) {
 
622
                int level = ndr_push_get_switch_value(ndr, r);
 
623
                switch (level) {
 
624
                        case 1:
 
625
                                if (r->sd) {
 
626
                                        NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
627
                                }
 
628
                        break;
 
629
 
 
630
                        case 2:
 
631
                                if (r->sd_hs) {
 
632
                                        NDR_CHECK(ndr_push_security_descriptor_hash(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs));
 
633
                                }
 
634
                        break;
 
635
 
 
636
                        default:
 
637
                                return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
638
                }
 
639
        }
 
640
        return NDR_ERR_SUCCESS;
 
641
}
 
642
 
 
643
static enum ndr_err_code ndr_pull_xattr_NTACL_Info(struct ndr_pull *ndr, int ndr_flags, union xattr_NTACL_Info *r)
 
644
{
 
645
        int level;
 
646
        uint16_t _level;
 
647
        TALLOC_CTX *_mem_save_sd_0;
 
648
        TALLOC_CTX *_mem_save_sd_hs_0;
 
649
        level = ndr_pull_get_switch_value(ndr, r);
 
650
        if (ndr_flags & NDR_SCALARS) {
 
651
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &_level));
 
652
                if (_level != level) {
 
653
                        return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
 
654
                }
 
655
                switch (level) {
 
656
                        case 1: {
 
657
                                uint32_t _ptr_sd;
 
658
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 
659
                                if (_ptr_sd) {
 
660
                                        NDR_PULL_ALLOC(ndr, r->sd);
 
661
                                } else {
 
662
                                        r->sd = NULL;
 
663
                                }
 
664
                        break; }
 
665
 
 
666
                        case 2: {
 
667
                                uint32_t _ptr_sd_hs;
 
668
                                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd_hs));
 
669
                                if (_ptr_sd_hs) {
 
670
                                        NDR_PULL_ALLOC(ndr, r->sd_hs);
 
671
                                } else {
 
672
                                        r->sd_hs = NULL;
 
673
                                }
 
674
                        break; }
 
675
 
 
676
                        default:
 
677
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
678
                }
 
679
        }
 
680
        if (ndr_flags & NDR_BUFFERS) {
 
681
                switch (level) {
 
682
                        case 1:
 
683
                                if (r->sd) {
 
684
                                        _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
685
                                        NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 
686
                                        NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
687
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 
688
                                }
 
689
                        break;
 
690
 
 
691
                        case 2:
 
692
                                if (r->sd_hs) {
 
693
                                        _mem_save_sd_hs_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
694
                                        NDR_PULL_SET_MEM_CTX(ndr, r->sd_hs, 0);
 
695
                                        NDR_CHECK(ndr_pull_security_descriptor_hash(ndr, NDR_SCALARS|NDR_BUFFERS, r->sd_hs));
 
696
                                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_hs_0, 0);
 
697
                                }
 
698
                        break;
 
699
 
 
700
                        default:
 
701
                                return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
 
702
                }
 
703
        }
 
704
        return NDR_ERR_SUCCESS;
 
705
}
 
706
 
 
707
_PUBLIC_ void ndr_print_xattr_NTACL_Info(struct ndr_print *ndr, const char *name, const union xattr_NTACL_Info *r)
 
708
{
 
709
        int level;
 
710
        level = ndr_print_get_switch_value(ndr, r);
 
711
        ndr_print_union(ndr, name, level, "xattr_NTACL_Info");
 
712
        switch (level) {
 
713
                case 1:
 
714
                        ndr_print_ptr(ndr, "sd", r->sd);
 
715
                        ndr->depth++;
 
716
                        if (r->sd) {
 
717
                                ndr_print_security_descriptor(ndr, "sd", r->sd);
 
718
                        }
 
719
                        ndr->depth--;
 
720
                break;
 
721
 
 
722
                case 2:
 
723
                        ndr_print_ptr(ndr, "sd_hs", r->sd_hs);
 
724
                        ndr->depth++;
 
725
                        if (r->sd_hs) {
 
726
                                ndr_print_security_descriptor_hash(ndr, "sd_hs", r->sd_hs);
 
727
                        }
 
728
                        ndr->depth--;
 
729
                break;
 
730
 
 
731
                default:
 
732
                        ndr_print_bad_level(ndr, name, level);
 
733
        }
 
734
}
 
735
 
 
736
_PUBLIC_ enum ndr_err_code ndr_push_xattr_NTACL(struct ndr_push *ndr, int ndr_flags, const struct xattr_NTACL *r)
 
737
{
 
738
        if (ndr_flags & NDR_SCALARS) {
 
739
                NDR_CHECK(ndr_push_align(ndr, 4));
 
740
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->version));
 
741
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->version));
 
742
                NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 
743
        }
 
744
        if (ndr_flags & NDR_BUFFERS) {
 
745
                NDR_CHECK(ndr_push_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 
746
        }
 
747
        return NDR_ERR_SUCCESS;
 
748
}
 
749
 
 
750
_PUBLIC_ enum ndr_err_code ndr_pull_xattr_NTACL(struct ndr_pull *ndr, int ndr_flags, struct xattr_NTACL *r)
 
751
{
 
752
        if (ndr_flags & NDR_SCALARS) {
 
753
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
754
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->version));
 
755
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->version));
 
756
                NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_SCALARS, &r->info));
 
757
        }
 
758
        if (ndr_flags & NDR_BUFFERS) {
 
759
                NDR_CHECK(ndr_pull_xattr_NTACL_Info(ndr, NDR_BUFFERS, &r->info));
 
760
        }
 
761
        return NDR_ERR_SUCCESS;
 
762
}
 
763
 
 
764
_PUBLIC_ void ndr_print_xattr_NTACL(struct ndr_print *ndr, const char *name, const struct xattr_NTACL *r)
 
765
{
 
766
        ndr_print_struct(ndr, name, "xattr_NTACL");
 
767
        ndr->depth++;
 
768
        ndr_print_uint16(ndr, "version", r->version);
 
769
        ndr_print_set_switch_value(ndr, &r->info, r->version);
 
770
        ndr_print_xattr_NTACL_Info(ndr, "info", &r->info);
 
771
        ndr->depth--;
 
772
}
 
773