← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_security.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_security.c
 
1
/* parser auto-generated by pidl */
 
2
 
 
3
#include "includes.h"
 
4
#include "../librpc/gen_ndr/ndr_security.h"
 
5
 
 
6
#include "librpc/gen_ndr/ndr_misc.h"
 
7
_PUBLIC_ enum ndr_err_code ndr_push_security_ace_flags(struct ndr_push *ndr, int ndr_flags, uint8_t r)
 
8
{
 
9
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
10
        return NDR_ERR_SUCCESS;
 
11
}
 
12
 
 
13
_PUBLIC_ enum ndr_err_code ndr_pull_security_ace_flags(struct ndr_pull *ndr, int ndr_flags, uint8_t *r)
 
14
{
 
15
        uint8_t v;
 
16
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
17
        *r = v;
 
18
        return NDR_ERR_SUCCESS;
 
19
}
 
20
 
 
21
_PUBLIC_ void ndr_print_security_ace_flags(struct ndr_print *ndr, const char *name, uint8_t r)
 
22
{
 
23
        ndr_print_uint8(ndr, name, r);
 
24
        ndr->depth++;
 
25
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_OBJECT_INHERIT", SEC_ACE_FLAG_OBJECT_INHERIT, r);
 
26
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_CONTAINER_INHERIT", SEC_ACE_FLAG_CONTAINER_INHERIT, r);
 
27
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_NO_PROPAGATE_INHERIT", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT, r);
 
28
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERIT_ONLY", SEC_ACE_FLAG_INHERIT_ONLY, r);
 
29
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERITED_ACE", SEC_ACE_FLAG_INHERITED_ACE, r);
 
30
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_VALID_INHERIT", SEC_ACE_FLAG_VALID_INHERIT, r);
 
31
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_SUCCESSFUL_ACCESS", SEC_ACE_FLAG_SUCCESSFUL_ACCESS, r);
 
32
        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_FAILED_ACCESS", SEC_ACE_FLAG_FAILED_ACCESS, r);
 
33
        ndr->depth--;
 
34
}
 
35
 
 
36
_PUBLIC_ enum ndr_err_code ndr_push_security_ace_type(struct ndr_push *ndr, int ndr_flags, enum security_ace_type r)
 
37
{
 
38
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
39
        return NDR_ERR_SUCCESS;
 
40
}
 
41
 
 
42
_PUBLIC_ enum ndr_err_code ndr_pull_security_ace_type(struct ndr_pull *ndr, int ndr_flags, enum security_ace_type *r)
 
43
{
 
44
        uint8_t v;
 
45
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
46
        *r = v;
 
47
        return NDR_ERR_SUCCESS;
 
48
}
 
49
 
 
50
_PUBLIC_ void ndr_print_security_ace_type(struct ndr_print *ndr, const char *name, enum security_ace_type r)
 
51
{
 
52
        const char *val = NULL;
 
53
 
 
54
        switch (r) {
 
55
                case SEC_ACE_TYPE_ACCESS_ALLOWED: val = "SEC_ACE_TYPE_ACCESS_ALLOWED"; break;
 
56
                case SEC_ACE_TYPE_ACCESS_DENIED: val = "SEC_ACE_TYPE_ACCESS_DENIED"; break;
 
57
                case SEC_ACE_TYPE_SYSTEM_AUDIT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT"; break;
 
58
                case SEC_ACE_TYPE_SYSTEM_ALARM: val = "SEC_ACE_TYPE_SYSTEM_ALARM"; break;
 
59
                case SEC_ACE_TYPE_ALLOWED_COMPOUND: val = "SEC_ACE_TYPE_ALLOWED_COMPOUND"; break;
 
60
                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT"; break;
 
61
                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_DENIED_OBJECT"; break;
 
62
                case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT"; break;
 
63
                case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT"; break;
 
64
        }
 
65
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
66
}
 
67
 
 
68
static enum ndr_err_code ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
69
{
 
70
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
71
        return NDR_ERR_SUCCESS;
 
72
}
 
73
 
 
74
static enum ndr_err_code ndr_pull_security_ace_object_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
75
{
 
76
        uint32_t v;
 
77
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
78
        *r = v;
 
79
        return NDR_ERR_SUCCESS;
 
80
}
 
81
 
 
82
_PUBLIC_ void ndr_print_security_ace_object_flags(struct ndr_print *ndr, const char *name, uint32_t r)
 
83
{
 
84
        ndr_print_uint32(ndr, name, r);
 
85
        ndr->depth++;
 
86
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_OBJECT_TYPE_PRESENT", SEC_ACE_OBJECT_TYPE_PRESENT, r);
 
87
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT", SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT, r);
 
88
        ndr->depth--;
 
89
}
 
90
 
 
91
static enum ndr_err_code ndr_push_security_ace_object_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_type *r)
 
92
{
 
93
        if (ndr_flags & NDR_SCALARS) {
 
94
                int level = ndr_push_get_switch_value(ndr, r);
 
95
                switch (level) {
 
96
                        case SEC_ACE_OBJECT_TYPE_PRESENT: {
 
97
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->type));
 
98
                        break; }
 
99
 
 
100
                        default: {
 
101
                        break; }
 
102
 
 
103
                }
 
104
        }
 
105
        if (ndr_flags & NDR_BUFFERS) {
 
106
                int level = ndr_push_get_switch_value(ndr, r);
 
107
                switch (level) {
 
108
                        case SEC_ACE_OBJECT_TYPE_PRESENT:
 
109
                        break;
 
110
 
 
111
                        default:
 
112
                        break;
 
113
 
 
114
                }
 
115
        }
 
116
        return NDR_ERR_SUCCESS;
 
117
}
 
118
 
 
119
static enum ndr_err_code ndr_pull_security_ace_object_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_type *r)
 
120
{
 
121
        int level;
 
122
        level = ndr_pull_get_switch_value(ndr, r);
 
123
        if (ndr_flags & NDR_SCALARS) {
 
124
                switch (level) {
 
125
                        case SEC_ACE_OBJECT_TYPE_PRESENT: {
 
126
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->type));
 
127
                        break; }
 
128
 
 
129
                        default: {
 
130
                        break; }
 
131
 
 
132
                }
 
133
        }
 
134
        if (ndr_flags & NDR_BUFFERS) {
 
135
                switch (level) {
 
136
                        case SEC_ACE_OBJECT_TYPE_PRESENT:
 
137
                        break;
 
138
 
 
139
                        default:
 
140
                        break;
 
141
 
 
142
                }
 
143
        }
 
144
        return NDR_ERR_SUCCESS;
 
145
}
 
146
 
 
147
_PUBLIC_ void ndr_print_security_ace_object_type(struct ndr_print *ndr, const char *name, const union security_ace_object_type *r)
 
148
{
 
149
        int level;
 
150
        level = ndr_print_get_switch_value(ndr, r);
 
151
        ndr_print_union(ndr, name, level, "security_ace_object_type");
 
152
        switch (level) {
 
153
                case SEC_ACE_OBJECT_TYPE_PRESENT:
 
154
                        ndr_print_GUID(ndr, "type", &r->type);
 
155
                break;
 
156
 
 
157
                default:
 
158
                break;
 
159
 
 
160
        }
 
161
}
 
162
 
 
163
static enum ndr_err_code ndr_push_security_ace_object_inherited_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_inherited_type *r)
 
164
{
 
165
        if (ndr_flags & NDR_SCALARS) {
 
166
                int level = ndr_push_get_switch_value(ndr, r);
 
167
                switch (level) {
 
168
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
 
169
                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 
170
                        break; }
 
171
 
 
172
                        default: {
 
173
                        break; }
 
174
 
 
175
                }
 
176
        }
 
177
        if (ndr_flags & NDR_BUFFERS) {
 
178
                int level = ndr_push_get_switch_value(ndr, r);
 
179
                switch (level) {
 
180
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 
181
                        break;
 
182
 
 
183
                        default:
 
184
                        break;
 
185
 
 
186
                }
 
187
        }
 
188
        return NDR_ERR_SUCCESS;
 
189
}
 
190
 
 
191
static enum ndr_err_code ndr_pull_security_ace_object_inherited_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_inherited_type *r)
 
192
{
 
193
        int level;
 
194
        level = ndr_pull_get_switch_value(ndr, r);
 
195
        if (ndr_flags & NDR_SCALARS) {
 
196
                switch (level) {
 
197
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
 
198
                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->inherited_type));
 
199
                        break; }
 
200
 
 
201
                        default: {
 
202
                        break; }
 
203
 
 
204
                }
 
205
        }
 
206
        if (ndr_flags & NDR_BUFFERS) {
 
207
                switch (level) {
 
208
                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 
209
                        break;
 
210
 
 
211
                        default:
 
212
                        break;
 
213
 
 
214
                }
 
215
        }
 
216
        return NDR_ERR_SUCCESS;
 
217
}
 
218
 
 
219
_PUBLIC_ void ndr_print_security_ace_object_inherited_type(struct ndr_print *ndr, const char *name, const union security_ace_object_inherited_type *r)
 
220
{
 
221
        int level;
 
222
        level = ndr_print_get_switch_value(ndr, r);
 
223
        ndr_print_union(ndr, name, level, "security_ace_object_inherited_type");
 
224
        switch (level) {
 
225
                case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
 
226
                        ndr_print_GUID(ndr, "inherited_type", &r->inherited_type);
 
227
                break;
 
228
 
 
229
                default:
 
230
                break;
 
231
 
 
232
        }
 
233
}
 
234
 
 
235
static enum ndr_err_code ndr_push_security_ace_object(struct ndr_push *ndr, int ndr_flags, const struct security_ace_object *r)
 
236
{
 
237
        if (ndr_flags & NDR_SCALARS) {
 
238
                NDR_CHECK(ndr_push_align(ndr, 4));
 
239
                NDR_CHECK(ndr_push_security_ace_object_flags(ndr, NDR_SCALARS, r->flags));
 
240
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT));
 
241
                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 
242
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 
243
                NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 
244
        }
 
245
        if (ndr_flags & NDR_BUFFERS) {
 
246
                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 
247
                NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 
248
        }
 
249
        return NDR_ERR_SUCCESS;
 
250
}
 
251
 
 
252
static enum ndr_err_code ndr_pull_security_ace_object(struct ndr_pull *ndr, int ndr_flags, struct security_ace_object *r)
 
253
{
 
254
        if (ndr_flags & NDR_SCALARS) {
 
255
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
256
                NDR_CHECK(ndr_pull_security_ace_object_flags(ndr, NDR_SCALARS, &r->flags));
 
257
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT));
 
258
                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
 
259
                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
 
260
                NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
 
261
        }
 
262
        if (ndr_flags & NDR_BUFFERS) {
 
263
                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
 
264
                NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
 
265
        }
 
266
        return NDR_ERR_SUCCESS;
 
267
}
 
268
 
 
269
_PUBLIC_ void ndr_print_security_ace_object(struct ndr_print *ndr, const char *name, const struct security_ace_object *r)
 
270
{
 
271
        ndr_print_struct(ndr, name, "security_ace_object");
 
272
        ndr->depth++;
 
273
        ndr_print_security_ace_object_flags(ndr, "flags", r->flags);
 
274
        ndr_print_set_switch_value(ndr, &r->type, r->flags & SEC_ACE_OBJECT_TYPE_PRESENT);
 
275
        ndr_print_security_ace_object_type(ndr, "type", &r->type);
 
276
        ndr_print_set_switch_value(ndr, &r->inherited_type, r->flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT);
 
277
        ndr_print_security_ace_object_inherited_type(ndr, "inherited_type", &r->inherited_type);
 
278
        ndr->depth--;
 
279
}
 
280
 
 
281
_PUBLIC_ enum ndr_err_code ndr_push_security_ace_object_ctr(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_ctr *r)
 
282
{
 
283
        if (ndr_flags & NDR_SCALARS) {
 
284
                int level = ndr_push_get_switch_value(ndr, r);
 
285
                switch (level) {
 
286
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
 
287
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
288
                        break; }
 
289
 
 
290
                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
 
291
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
292
                        break; }
 
293
 
 
294
                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
 
295
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
296
                        break; }
 
297
 
 
298
                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
 
299
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
300
                        break; }
 
301
 
 
302
                        default: {
 
303
                        break; }
 
304
 
 
305
                }
 
306
        }
 
307
        if (ndr_flags & NDR_BUFFERS) {
 
308
                int level = ndr_push_get_switch_value(ndr, r);
 
309
                switch (level) {
 
310
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 
311
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
312
                        break;
 
313
 
 
314
                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 
315
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
316
                        break;
 
317
 
 
318
                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 
319
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
320
                        break;
 
321
 
 
322
                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 
323
                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
324
                        break;
 
325
 
 
326
                        default:
 
327
                        break;
 
328
 
 
329
                }
 
330
        }
 
331
        return NDR_ERR_SUCCESS;
 
332
}
 
333
 
 
334
_PUBLIC_ enum ndr_err_code ndr_pull_security_ace_object_ctr(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_ctr *r)
 
335
{
 
336
        int level;
 
337
        level = ndr_pull_get_switch_value(ndr, r);
 
338
        if (ndr_flags & NDR_SCALARS) {
 
339
                switch (level) {
 
340
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
 
341
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
342
                        break; }
 
343
 
 
344
                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
 
345
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
346
                        break; }
 
347
 
 
348
                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
 
349
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
350
                        break; }
 
351
 
 
352
                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
 
353
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
 
354
                        break; }
 
355
 
 
356
                        default: {
 
357
                        break; }
 
358
 
 
359
                }
 
360
        }
 
361
        if (ndr_flags & NDR_BUFFERS) {
 
362
                switch (level) {
 
363
                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 
364
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
365
                        break;
 
366
 
 
367
                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 
368
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
369
                        break;
 
370
 
 
371
                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 
372
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
373
                        break;
 
374
 
 
375
                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 
376
                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
 
377
                        break;
 
378
 
 
379
                        default:
 
380
                        break;
 
381
 
 
382
                }
 
383
        }
 
384
        return NDR_ERR_SUCCESS;
 
385
}
 
386
 
 
387
_PUBLIC_ void ndr_print_security_ace_object_ctr(struct ndr_print *ndr, const char *name, const union security_ace_object_ctr *r)
 
388
{
 
389
        int level;
 
390
        level = ndr_print_get_switch_value(ndr, r);
 
391
        ndr_print_union(ndr, name, level, "security_ace_object_ctr");
 
392
        switch (level) {
 
393
                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
 
394
                        ndr_print_security_ace_object(ndr, "object", &r->object);
 
395
                break;
 
396
 
 
397
                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
 
398
                        ndr_print_security_ace_object(ndr, "object", &r->object);
 
399
                break;
 
400
 
 
401
                case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
 
402
                        ndr_print_security_ace_object(ndr, "object", &r->object);
 
403
                break;
 
404
 
 
405
                case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
 
406
                        ndr_print_security_ace_object(ndr, "object", &r->object);
 
407
                break;
 
408
 
 
409
                default:
 
410
                break;
 
411
 
 
412
        }
 
413
}
 
414
 
 
415
_PUBLIC_ enum ndr_err_code ndr_push_security_ace(struct ndr_push *ndr, int ndr_flags, const struct security_ace *r)
 
416
{
 
417
        if (ndr_flags & NDR_SCALARS) {
 
418
                NDR_CHECK(ndr_push_align(ndr, 4));
 
419
                NDR_CHECK(ndr_push_security_ace_type(ndr, NDR_SCALARS, r->type));
 
420
                NDR_CHECK(ndr_push_security_ace_flags(ndr, NDR_SCALARS, r->flags));
 
421
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_ace(r, ndr->iconv_convenience, ndr->flags)));
 
422
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->access_mask));
 
423
                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->type));
 
424
                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
 
425
                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->trustee));
 
426
        }
 
427
        if (ndr_flags & NDR_BUFFERS) {
 
428
                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
 
429
        }
 
430
        return NDR_ERR_SUCCESS;
 
431
}
 
432
 
 
433
_PUBLIC_ void ndr_print_security_ace(struct ndr_print *ndr, const char *name, const struct security_ace *r)
 
434
{
 
435
        ndr_print_struct(ndr, name, "security_ace");
 
436
        ndr->depth++;
 
437
        ndr_print_security_ace_type(ndr, "type", r->type);
 
438
        ndr_print_security_ace_flags(ndr, "flags", r->flags);
 
439
        ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_ace(r, ndr->iconv_convenience, ndr->flags):r->size);
 
440
        ndr_print_uint32(ndr, "access_mask", r->access_mask);
 
441
        ndr_print_set_switch_value(ndr, &r->object, r->type);
 
442
        ndr_print_security_ace_object_ctr(ndr, "object", &r->object);
 
443
        ndr_print_dom_sid(ndr, "trustee", &r->trustee);
 
444
        ndr->depth--;
 
445
}
 
446
 
 
447
static enum ndr_err_code ndr_push_security_acl_revision(struct ndr_push *ndr, int ndr_flags, enum security_acl_revision r)
 
448
{
 
449
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
450
        return NDR_ERR_SUCCESS;
 
451
}
 
452
 
 
453
static enum ndr_err_code ndr_pull_security_acl_revision(struct ndr_pull *ndr, int ndr_flags, enum security_acl_revision *r)
 
454
{
 
455
        uint16_t v;
 
456
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
457
        *r = v;
 
458
        return NDR_ERR_SUCCESS;
 
459
}
 
460
 
 
461
_PUBLIC_ void ndr_print_security_acl_revision(struct ndr_print *ndr, const char *name, enum security_acl_revision r)
 
462
{
 
463
        const char *val = NULL;
 
464
 
 
465
        switch (r) {
 
466
                case SECURITY_ACL_REVISION_NT4: val = "SECURITY_ACL_REVISION_NT4"; break;
 
467
                case SECURITY_ACL_REVISION_ADS: val = "SECURITY_ACL_REVISION_ADS"; break;
 
468
        }
 
469
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
470
}
 
471
 
 
472
_PUBLIC_ enum ndr_err_code ndr_push_security_acl(struct ndr_push *ndr, int ndr_flags, const struct security_acl *r)
 
473
{
 
474
        uint32_t cntr_aces_0;
 
475
        if (ndr_flags & NDR_SCALARS) {
 
476
                NDR_CHECK(ndr_push_align(ndr, 4));
 
477
                NDR_CHECK(ndr_push_security_acl_revision(ndr, NDR_SCALARS, r->revision));
 
478
                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_acl(r, ndr->iconv_convenience, ndr->flags)));
 
479
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aces));
 
480
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 
481
                        NDR_CHECK(ndr_push_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 
482
                }
 
483
        }
 
484
        if (ndr_flags & NDR_BUFFERS) {
 
485
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 
486
                        NDR_CHECK(ndr_push_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 
487
                }
 
488
        }
 
489
        return NDR_ERR_SUCCESS;
 
490
}
 
491
 
 
492
_PUBLIC_ enum ndr_err_code ndr_pull_security_acl(struct ndr_pull *ndr, int ndr_flags, struct security_acl *r)
 
493
{
 
494
        uint32_t cntr_aces_0;
 
495
        TALLOC_CTX *_mem_save_aces_0;
 
496
        if (ndr_flags & NDR_SCALARS) {
 
497
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
498
                NDR_CHECK(ndr_pull_security_acl_revision(ndr, NDR_SCALARS, &r->revision));
 
499
                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 
500
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aces));
 
501
                if (r->num_aces > 1000) {
 
502
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
503
                }
 
504
                NDR_PULL_ALLOC_N(ndr, r->aces, r->num_aces);
 
505
                _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
506
                NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 
507
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 
508
                        NDR_CHECK(ndr_pull_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
 
509
                }
 
510
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 
511
        }
 
512
        if (ndr_flags & NDR_BUFFERS) {
 
513
                _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
514
                NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
 
515
                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
 
516
                        NDR_CHECK(ndr_pull_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
 
517
                }
 
518
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
 
519
        }
 
520
        return NDR_ERR_SUCCESS;
 
521
}
 
522
 
 
523
_PUBLIC_ void ndr_print_security_acl(struct ndr_print *ndr, const char *name, const struct security_acl *r)
 
524
{
 
525
        uint32_t cntr_aces_0;
 
526
        ndr_print_struct(ndr, name, "security_acl");
 
527
        ndr->depth++;
 
528
        ndr_print_security_acl_revision(ndr, "revision", r->revision);
 
529
        ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_acl(r, ndr->iconv_convenience, ndr->flags):r->size);
 
530
        ndr_print_uint32(ndr, "num_aces", r->num_aces);
 
531
        ndr->print(ndr, "%s: ARRAY(%d)", "aces", (int)r->num_aces);
 
532
        ndr->depth++;
 
533
        for (cntr_aces_0=0;cntr_aces_0<r->num_aces;cntr_aces_0++) {
 
534
                char *idx_0=NULL;
 
535
                if (asprintf(&idx_0, "[%d]", cntr_aces_0) != -1) {
 
536
                        ndr_print_security_ace(ndr, "aces", &r->aces[cntr_aces_0]);
 
537
                        free(idx_0);
 
538
                }
 
539
        }
 
540
        ndr->depth--;
 
541
        ndr->depth--;
 
542
}
 
543
 
 
544
_PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_revision(struct ndr_push *ndr, int ndr_flags, enum security_descriptor_revision r)
 
545
{
 
546
        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
 
547
        return NDR_ERR_SUCCESS;
 
548
}
 
549
 
 
550
_PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_revision(struct ndr_pull *ndr, int ndr_flags, enum security_descriptor_revision *r)
 
551
{
 
552
        uint8_t v;
 
553
        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
 
554
        *r = v;
 
555
        return NDR_ERR_SUCCESS;
 
556
}
 
557
 
 
558
_PUBLIC_ void ndr_print_security_descriptor_revision(struct ndr_print *ndr, const char *name, enum security_descriptor_revision r)
 
559
{
 
560
        const char *val = NULL;
 
561
 
 
562
        switch (r) {
 
563
                case SECURITY_DESCRIPTOR_REVISION_1: val = "SECURITY_DESCRIPTOR_REVISION_1"; break;
 
564
        }
 
565
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
566
}
 
567
 
 
568
_PUBLIC_ enum ndr_err_code ndr_push_security_descriptor_type(struct ndr_push *ndr, int ndr_flags, uint16_t r)
 
569
{
 
570
        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 
571
        return NDR_ERR_SUCCESS;
 
572
}
 
573
 
 
574
_PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor_type(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
 
575
{
 
576
        uint16_t v;
 
577
        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 
578
        *r = v;
 
579
        return NDR_ERR_SUCCESS;
 
580
}
 
581
 
 
582
_PUBLIC_ void ndr_print_security_descriptor_type(struct ndr_print *ndr, const char *name, uint16_t r)
 
583
{
 
584
        ndr_print_uint16(ndr, name, r);
 
585
        ndr->depth++;
 
586
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_OWNER_DEFAULTED", SEC_DESC_OWNER_DEFAULTED, r);
 
587
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_GROUP_DEFAULTED", SEC_DESC_GROUP_DEFAULTED, r);
 
588
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PRESENT", SEC_DESC_DACL_PRESENT, r);
 
589
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_DEFAULTED", SEC_DESC_DACL_DEFAULTED, r);
 
590
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PRESENT", SEC_DESC_SACL_PRESENT, r);
 
591
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_DEFAULTED", SEC_DESC_SACL_DEFAULTED, r);
 
592
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_TRUSTED", SEC_DESC_DACL_TRUSTED, r);
 
593
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SERVER_SECURITY", SEC_DESC_SERVER_SECURITY, r);
 
594
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERIT_REQ", SEC_DESC_DACL_AUTO_INHERIT_REQ, r);
 
595
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERIT_REQ", SEC_DESC_SACL_AUTO_INHERIT_REQ, r);
 
596
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERITED", SEC_DESC_DACL_AUTO_INHERITED, r);
 
597
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERITED", SEC_DESC_SACL_AUTO_INHERITED, r);
 
598
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PROTECTED", SEC_DESC_DACL_PROTECTED, r);
 
599
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PROTECTED", SEC_DESC_SACL_PROTECTED, r);
 
600
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_RM_CONTROL_VALID", SEC_DESC_RM_CONTROL_VALID, r);
 
601
        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SELF_RELATIVE", SEC_DESC_SELF_RELATIVE, r);
 
602
        ndr->depth--;
 
603
}
 
604
 
 
605
_PUBLIC_ enum ndr_err_code ndr_push_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
 
606
{
 
607
        {
 
608
                uint32_t _flags_save_STRUCT = ndr->flags;
 
609
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
610
                if (ndr_flags & NDR_SCALARS) {
 
611
                        NDR_CHECK(ndr_push_align(ndr, 4));
 
612
                        NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
 
613
                        NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
 
614
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
 
615
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
 
616
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
 
617
                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
 
618
                }
 
619
                if (ndr_flags & NDR_BUFFERS) {
 
620
                        if (r->owner_sid) {
 
621
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->owner_sid));
 
622
                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 
623
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->owner_sid));
 
624
                        }
 
625
                        if (r->group_sid) {
 
626
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->group_sid));
 
627
                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 
628
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->group_sid));
 
629
                        }
 
630
                        if (r->sacl) {
 
631
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sacl));
 
632
                                NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 
633
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sacl));
 
634
                        }
 
635
                        if (r->dacl) {
 
636
                                NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dacl));
 
637
                                NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 
638
                                NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dacl));
 
639
                        }
 
640
                }
 
641
                ndr->flags = _flags_save_STRUCT;
 
642
        }
 
643
        return NDR_ERR_SUCCESS;
 
644
}
 
645
 
 
646
_PUBLIC_ enum ndr_err_code ndr_pull_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
 
647
{
 
648
        uint32_t _ptr_owner_sid;
 
649
        TALLOC_CTX *_mem_save_owner_sid_0;
 
650
        uint32_t _ptr_group_sid;
 
651
        TALLOC_CTX *_mem_save_group_sid_0;
 
652
        uint32_t _ptr_sacl;
 
653
        TALLOC_CTX *_mem_save_sacl_0;
 
654
        uint32_t _ptr_dacl;
 
655
        TALLOC_CTX *_mem_save_dacl_0;
 
656
        {
 
657
                uint32_t _flags_save_STRUCT = ndr->flags;
 
658
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
659
                if (ndr_flags & NDR_SCALARS) {
 
660
                        NDR_CHECK(ndr_pull_align(ndr, 4));
 
661
                        NDR_CHECK(ndr_pull_security_descriptor_revision(ndr, NDR_SCALARS, &r->revision));
 
662
                        NDR_CHECK(ndr_pull_security_descriptor_type(ndr, NDR_SCALARS, &r->type));
 
663
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_owner_sid));
 
664
                        if (_ptr_owner_sid) {
 
665
                                NDR_PULL_ALLOC(ndr, r->owner_sid);
 
666
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->owner_sid, _ptr_owner_sid));
 
667
                        } else {
 
668
                                r->owner_sid = NULL;
 
669
                        }
 
670
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
 
671
                        if (_ptr_group_sid) {
 
672
                                NDR_PULL_ALLOC(ndr, r->group_sid);
 
673
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->group_sid, _ptr_group_sid));
 
674
                        } else {
 
675
                                r->group_sid = NULL;
 
676
                        }
 
677
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sacl));
 
678
                        if (_ptr_sacl) {
 
679
                                NDR_PULL_ALLOC(ndr, r->sacl);
 
680
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sacl, _ptr_sacl));
 
681
                        } else {
 
682
                                r->sacl = NULL;
 
683
                        }
 
684
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dacl));
 
685
                        if (_ptr_dacl) {
 
686
                                NDR_PULL_ALLOC(ndr, r->dacl);
 
687
                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dacl, _ptr_dacl));
 
688
                        } else {
 
689
                                r->dacl = NULL;
 
690
                        }
 
691
                }
 
692
                if (ndr_flags & NDR_BUFFERS) {
 
693
                        if (r->owner_sid) {
 
694
                                uint32_t _relative_save_offset;
 
695
                                _relative_save_offset = ndr->offset;
 
696
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->owner_sid));
 
697
                                _mem_save_owner_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
698
                                NDR_PULL_SET_MEM_CTX(ndr, r->owner_sid, 0);
 
699
                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
 
700
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_owner_sid_0, 0);
 
701
                                ndr->offset = _relative_save_offset;
 
702
                        }
 
703
                        if (r->group_sid) {
 
704
                                uint32_t _relative_save_offset;
 
705
                                _relative_save_offset = ndr->offset;
 
706
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->group_sid));
 
707
                                _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
708
                                NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
 
709
                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 
710
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
 
711
                                ndr->offset = _relative_save_offset;
 
712
                        }
 
713
                        if (r->sacl) {
 
714
                                uint32_t _relative_save_offset;
 
715
                                _relative_save_offset = ndr->offset;
 
716
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sacl));
 
717
                                _mem_save_sacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
718
                                NDR_PULL_SET_MEM_CTX(ndr, r->sacl, 0);
 
719
                                NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
 
720
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sacl_0, 0);
 
721
                                ndr->offset = _relative_save_offset;
 
722
                        }
 
723
                        if (r->dacl) {
 
724
                                uint32_t _relative_save_offset;
 
725
                                _relative_save_offset = ndr->offset;
 
726
                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dacl));
 
727
                                _mem_save_dacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
728
                                NDR_PULL_SET_MEM_CTX(ndr, r->dacl, 0);
 
729
                                NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
 
730
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dacl_0, 0);
 
731
                                ndr->offset = _relative_save_offset;
 
732
                        }
 
733
                }
 
734
                ndr->flags = _flags_save_STRUCT;
 
735
        }
 
736
        return NDR_ERR_SUCCESS;
 
737
}
 
738
 
 
739
_PUBLIC_ void ndr_print_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
 
740
{
 
741
        ndr_print_struct(ndr, name, "security_descriptor");
 
742
        {
 
743
                uint32_t _flags_save_STRUCT = ndr->flags;
 
744
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
745
                ndr->depth++;
 
746
                ndr_print_security_descriptor_revision(ndr, "revision", r->revision);
 
747
                ndr_print_security_descriptor_type(ndr, "type", r->type);
 
748
                ndr_print_ptr(ndr, "owner_sid", r->owner_sid);
 
749
                ndr->depth++;
 
750
                if (r->owner_sid) {
 
751
                        ndr_print_dom_sid(ndr, "owner_sid", r->owner_sid);
 
752
                }
 
753
                ndr->depth--;
 
754
                ndr_print_ptr(ndr, "group_sid", r->group_sid);
 
755
                ndr->depth++;
 
756
                if (r->group_sid) {
 
757
                        ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
 
758
                }
 
759
                ndr->depth--;
 
760
                ndr_print_ptr(ndr, "sacl", r->sacl);
 
761
                ndr->depth++;
 
762
                if (r->sacl) {
 
763
                        ndr_print_security_acl(ndr, "sacl", r->sacl);
 
764
                }
 
765
                ndr->depth--;
 
766
                ndr_print_ptr(ndr, "dacl", r->dacl);
 
767
                ndr->depth++;
 
768
                if (r->dacl) {
 
769
                        ndr_print_security_acl(ndr, "dacl", r->dacl);
 
770
                }
 
771
                ndr->depth--;
 
772
                ndr->depth--;
 
773
                ndr->flags = _flags_save_STRUCT;
 
774
        }
 
775
}
 
776
 
 
777
_PUBLIC_ enum ndr_err_code ndr_push_sec_desc_buf(struct ndr_push *ndr, int ndr_flags, const struct sec_desc_buf *r)
 
778
{
 
779
        if (ndr_flags & NDR_SCALARS) {
 
780
                NDR_CHECK(ndr_push_align(ndr, 4));
 
781
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_security_descriptor(r->sd, ndr->iconv_convenience, ndr->flags)));
 
782
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->sd));
 
783
        }
 
784
        if (ndr_flags & NDR_BUFFERS) {
 
785
                if (r->sd) {
 
786
                        {
 
787
                                struct ndr_push *_ndr_sd;
 
788
                                NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_sd, 4, -1));
 
789
                                NDR_CHECK(ndr_push_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
790
                                NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_sd, 4, -1));
 
791
                        }
 
792
                }
 
793
        }
 
794
        return NDR_ERR_SUCCESS;
 
795
}
 
796
 
 
797
_PUBLIC_ enum ndr_err_code ndr_pull_sec_desc_buf(struct ndr_pull *ndr, int ndr_flags, struct sec_desc_buf *r)
 
798
{
 
799
        uint32_t _ptr_sd;
 
800
        TALLOC_CTX *_mem_save_sd_0;
 
801
        if (ndr_flags & NDR_SCALARS) {
 
802
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
803
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sd_size));
 
804
                if (r->sd_size > 0x40000) {
 
805
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 
806
                }
 
807
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sd));
 
808
                if (_ptr_sd) {
 
809
                        NDR_PULL_ALLOC(ndr, r->sd);
 
810
                } else {
 
811
                        r->sd = NULL;
 
812
                }
 
813
        }
 
814
        if (ndr_flags & NDR_BUFFERS) {
 
815
                if (r->sd) {
 
816
                        _mem_save_sd_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
817
                        NDR_PULL_SET_MEM_CTX(ndr, r->sd, 0);
 
818
                        {
 
819
                                struct ndr_pull *_ndr_sd;
 
820
                                NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_sd, 4, -1));
 
821
                                NDR_CHECK(ndr_pull_security_descriptor(_ndr_sd, NDR_SCALARS|NDR_BUFFERS, r->sd));
 
822
                                NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_sd, 4, -1));
 
823
                        }
 
824
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sd_0, 0);
 
825
                }
 
826
        }
 
827
        return NDR_ERR_SUCCESS;
 
828
}
 
829
 
 
830
_PUBLIC_ void ndr_print_sec_desc_buf(struct ndr_print *ndr, const char *name, const struct sec_desc_buf *r)
 
831
{
 
832
        ndr_print_struct(ndr, name, "sec_desc_buf");
 
833
        ndr->depth++;
 
834
        ndr_print_uint32(ndr, "sd_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_descriptor(r->sd, ndr->iconv_convenience, ndr->flags):r->sd_size);
 
835
        ndr_print_ptr(ndr, "sd", r->sd);
 
836
        ndr->depth++;
 
837
        if (r->sd) {
 
838
                ndr_print_security_descriptor(ndr, "sd", r->sd);
 
839
        }
 
840
        ndr->depth--;
 
841
        ndr->depth--;
 
842
}
 
843
 
 
844
_PUBLIC_ enum ndr_err_code ndr_push_security_token(struct ndr_push *ndr, int ndr_flags, const struct security_token *r)
 
845
{
 
846
        uint32_t cntr_sids_0;
 
847
        if (ndr_flags & NDR_SCALARS) {
 
848
                NDR_CHECK(ndr_push_align(ndr, 4));
 
849
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_sid));
 
850
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_sid));
 
851
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 
852
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
 
853
                for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 
854
                        NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_0]));
 
855
                }
 
856
                NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->privilege_mask));
 
857
        }
 
858
        if (ndr_flags & NDR_BUFFERS) {
 
859
                if (r->user_sid) {
 
860
                        NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->user_sid));
 
861
                }
 
862
                if (r->group_sid) {
 
863
                        NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 
864
                }
 
865
                for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 
866
                        if (r->sids[cntr_sids_0]) {
 
867
                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->sids[cntr_sids_0]));
 
868
                        }
 
869
                }
 
870
        }
 
871
        return NDR_ERR_SUCCESS;
 
872
}
 
873
 
 
874
_PUBLIC_ enum ndr_err_code ndr_pull_security_token(struct ndr_pull *ndr, int ndr_flags, struct security_token *r)
 
875
{
 
876
        uint32_t _ptr_user_sid;
 
877
        TALLOC_CTX *_mem_save_user_sid_0;
 
878
        uint32_t _ptr_group_sid;
 
879
        TALLOC_CTX *_mem_save_group_sid_0;
 
880
        uint32_t _ptr_sids;
 
881
        uint32_t cntr_sids_0;
 
882
        TALLOC_CTX *_mem_save_sids_0;
 
883
        TALLOC_CTX *_mem_save_sids_1;
 
884
        if (ndr_flags & NDR_SCALARS) {
 
885
                NDR_CHECK(ndr_pull_align(ndr, 4));
 
886
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
 
887
                if (_ptr_user_sid) {
 
888
                        NDR_PULL_ALLOC(ndr, r->user_sid);
 
889
                } else {
 
890
                        r->user_sid = NULL;
 
891
                }
 
892
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
 
893
                if (_ptr_group_sid) {
 
894
                        NDR_PULL_ALLOC(ndr, r->group_sid);
 
895
                } else {
 
896
                        r->group_sid = NULL;
 
897
                }
 
898
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
 
899
                NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
 
900
                NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
 
901
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
902
                NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 
903
                for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 
904
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
 
905
                        if (_ptr_sids) {
 
906
                                NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_0]);
 
907
                        } else {
 
908
                                r->sids[cntr_sids_0] = NULL;
 
909
                        }
 
910
                }
 
911
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 
912
                NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->privilege_mask));
 
913
                if (r->sids) {
 
914
                        NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
 
915
                }
 
916
        }
 
917
        if (ndr_flags & NDR_BUFFERS) {
 
918
                if (r->user_sid) {
 
919
                        _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
920
                        NDR_PULL_SET_MEM_CTX(ndr, r->user_sid, 0);
 
921
                        NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->user_sid));
 
922
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
 
923
                }
 
924
                if (r->group_sid) {
 
925
                        _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
926
                        NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
 
927
                        NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
 
928
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
 
929
                }
 
930
                _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
931
                NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
 
932
                for (cntr_sids_0 = 0; cntr_sids_0 < r->num_sids; cntr_sids_0++) {
 
933
                        if (r->sids[cntr_sids_0]) {
 
934
                                _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
 
935
                                NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_0], 0);
 
936
                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->sids[cntr_sids_0]));
 
937
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
 
938
                        }
 
939
                }
 
940
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
 
941
        }
 
942
        return NDR_ERR_SUCCESS;
 
943
}
 
944
 
 
945
_PUBLIC_ void ndr_print_security_token(struct ndr_print *ndr, const char *name, const struct security_token *r)
 
946
{
 
947
        uint32_t cntr_sids_0;
 
948
        ndr_print_struct(ndr, name, "security_token");
 
949
        ndr->depth++;
 
950
        ndr_print_ptr(ndr, "user_sid", r->user_sid);
 
951
        ndr->depth++;
 
952
        if (r->user_sid) {
 
953
                ndr_print_dom_sid(ndr, "user_sid", r->user_sid);
 
954
        }
 
955
        ndr->depth--;
 
956
        ndr_print_ptr(ndr, "group_sid", r->group_sid);
 
957
        ndr->depth++;
 
958
        if (r->group_sid) {
 
959
                ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
 
960
        }
 
961
        ndr->depth--;
 
962
        ndr_print_uint32(ndr, "num_sids", r->num_sids);
 
963
        ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
 
964
        ndr->depth++;
 
965
        for (cntr_sids_0=0;cntr_sids_0<r->num_sids;cntr_sids_0++) {
 
966
                char *idx_0=NULL;
 
967
                if (asprintf(&idx_0, "[%d]", cntr_sids_0) != -1) {
 
968
                        ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_0]);
 
969
                        ndr->depth++;
 
970
                        if (r->sids[cntr_sids_0]) {
 
971
                                ndr_print_dom_sid(ndr, "sids", r->sids[cntr_sids_0]);
 
972
                        }
 
973
                        ndr->depth--;
 
974
                        free(idx_0);
 
975
                }
 
976
        }
 
977
        ndr->depth--;
 
978
        ndr_print_udlong(ndr, "privilege_mask", r->privilege_mask);
 
979
        ndr->depth--;
 
980
}
 
981
 
 
982
_PUBLIC_ enum ndr_err_code ndr_push_security_secinfo(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
983
{
 
984
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
985
        return NDR_ERR_SUCCESS;
 
986
}
 
987
 
 
988
_PUBLIC_ enum ndr_err_code ndr_pull_security_secinfo(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
989
{
 
990
        uint32_t v;
 
991
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
992
        *r = v;
 
993
        return NDR_ERR_SUCCESS;
 
994
}
 
995
 
 
996
_PUBLIC_ void ndr_print_security_secinfo(struct ndr_print *ndr, const char *name, uint32_t r)
 
997
{
 
998
        ndr_print_uint32(ndr, name, r);
 
999
        ndr->depth++;
 
1000
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_OWNER", SECINFO_OWNER, r);
 
1001
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_GROUP", SECINFO_GROUP, r);
 
1002
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_DACL", SECINFO_DACL, r);
 
1003
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_SACL", SECINFO_SACL, r);
 
1004
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_UNPROTECTED_SACL", SECINFO_UNPROTECTED_SACL, r);
 
1005
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_UNPROTECTED_DACL", SECINFO_UNPROTECTED_DACL, r);
 
1006
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_PROTECTED_SACL", SECINFO_PROTECTED_SACL, r);
 
1007
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_PROTECTED_DACL", SECINFO_PROTECTED_DACL, r);
 
1008
        ndr->depth--;
 
1009
}
 
1010
 
 
1011
_PUBLIC_ enum ndr_err_code ndr_push_kerb_EncTypes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 
1012
{
 
1013
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
1014
        return NDR_ERR_SUCCESS;
 
1015
}
 
1016
 
 
1017
_PUBLIC_ enum ndr_err_code ndr_pull_kerb_EncTypes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 
1018
{
 
1019
        uint32_t v;
 
1020
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
1021
        *r = v;
 
1022
        return NDR_ERR_SUCCESS;
 
1023
}
 
1024
 
 
1025
_PUBLIC_ void ndr_print_kerb_EncTypes(struct ndr_print *ndr, const char *name, uint32_t r)
 
1026
{
 
1027
        ndr_print_uint32(ndr, name, r);
 
1028
        ndr->depth++;
 
1029
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_DES_CBC_CRC", KERB_ENCTYPE_DES_CBC_CRC, r);
 
1030
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_DES_CBC_MD5", KERB_ENCTYPE_DES_CBC_MD5, r);
 
1031
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_RC4_HMAC_MD5", KERB_ENCTYPE_RC4_HMAC_MD5, r);
 
1032
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_AES128_CTS_HMAC_SHA1_96", KERB_ENCTYPE_AES128_CTS_HMAC_SHA1_96, r);
 
1033
        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96", KERB_ENCTYPE_AES256_CTS_HMAC_SHA1_96, r);
 
1034
        ndr->depth--;
 
1035
}
 
1036