source: trunk/samba/source/librpc/ndr/ndr_sec_helper.c @ 26

Last change on this file since 26 was 26, checked in by Paul Smedley, 14 years ago

Updated source to 3.0.25rc1

File size: 30.4 KB
Line 
1/*
2   Unix SMB/CIFS implementation.
3
4   fast routines for getting the wire size of security objects
5
6   Copyright (C) Andrew Tridgell 2003
7   
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 of the License, or
11   (at your option) any later version.
12   
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17   
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23
24#include "includes.h"
25
26/*
27  return the wire size of a dom_sid
28*/
29size_t ndr_size_dom_sid(const struct dom_sid *sid, int flags)
30{
31        if (!sid) return 0;
32        return 8 + 4*sid->num_auths;
33}
34
35/*
36  return the wire size of a security_ace
37*/
38size_t ndr_size_security_ace(const struct security_ace *ace, int flags)
39{
40        if (!ace) return 0;
41        return 8 + ndr_size_dom_sid(&ace->trustee, flags);
42}
43
44
45/*
46  return the wire size of a security_acl
47*/
48size_t ndr_size_security_acl(const struct security_acl *acl, int flags)
49{
50        size_t ret;
51        int i;
52        if (!acl) return 0;
53        ret = 8;
54        for (i=0;i<acl->num_aces;i++) {
55                ret += ndr_size_security_ace(&acl->aces[i], flags);
56        }
57        return ret;
58}
59
60/*
61  return the wire size of a security descriptor
62*/
63size_t ndr_size_security_descriptor(const struct security_descriptor *sd, int flags)
64{
65        size_t ret;
66        if (!sd) return 0;
67       
68        ret = 20;
69        ret += ndr_size_dom_sid(sd->owner_sid, flags);
70        ret += ndr_size_dom_sid(sd->group_sid, flags);
71        ret += ndr_size_security_acl(sd->dacl, flags);
72        ret += ndr_size_security_acl(sd->sacl, flags);
73        return ret;
74}
75
76/*
77  print a dom_sid
78*/
79void ndr_print_dom_sid(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
80{
81        ndr->print(ndr, "%-25s: %s", name, dom_sid_string(ndr, sid));
82}
83
84void ndr_print_dom_sid2(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
85{
86        ndr_print_dom_sid(ndr, name, sid);
87}
88
89void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid)
90{
91        ndr_print_dom_sid(ndr, name, sid);
92}
93
94static NTSTATUS ndr_push_security_ace_flags(struct ndr_push *ndr, int ndr_flags, uint8_t r)
95{
96        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
97        return NT_STATUS_OK;
98}
99
100static NTSTATUS ndr_pull_security_ace_flags(struct ndr_pull *ndr, int ndr_flags, uint8_t *r)
101{
102        uint8_t v;
103        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
104        *r = v;
105        return NT_STATUS_OK;
106}
107
108void ndr_print_security_ace_flags(struct ndr_print *ndr, const char *name, uint8_t r)
109{
110        ndr_print_uint8(ndr, name, r);
111        ndr->depth++;
112        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_OBJECT_INHERIT", SEC_ACE_FLAG_OBJECT_INHERIT, r);
113        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_CONTAINER_INHERIT", SEC_ACE_FLAG_CONTAINER_INHERIT, r);
114        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_NO_PROPAGATE_INHERIT", SEC_ACE_FLAG_NO_PROPAGATE_INHERIT, r);
115        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERIT_ONLY", SEC_ACE_FLAG_INHERIT_ONLY, r);
116        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_INHERITED_ACE", SEC_ACE_FLAG_INHERITED_ACE, r);
117        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_VALID_INHERIT", SEC_ACE_FLAG_VALID_INHERIT, r);
118        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_SUCCESSFUL_ACCESS", SEC_ACE_FLAG_SUCCESSFUL_ACCESS, r);
119        ndr_print_bitmap_flag(ndr, sizeof(uint8_t), "SEC_ACE_FLAG_FAILED_ACCESS", SEC_ACE_FLAG_FAILED_ACCESS, r);
120        ndr->depth--;
121}
122
123static NTSTATUS ndr_push_security_ace_type(struct ndr_push *ndr, int ndr_flags, enum security_ace_type r)
124{
125        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
126        return NT_STATUS_OK;
127}
128
129static NTSTATUS ndr_pull_security_ace_type(struct ndr_pull *ndr, int ndr_flags, enum security_ace_type *r)
130{
131        uint8_t v;
132        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
133        *r = (enum security_ace_type)v;
134        return NT_STATUS_OK;
135}
136
137void ndr_print_security_ace_type(struct ndr_print *ndr, const char *name, enum security_ace_type r)
138{
139        const char *val = NULL;
140
141        switch (r) {
142                case SEC_ACE_TYPE_ACCESS_ALLOWED: val = "SEC_ACE_TYPE_ACCESS_ALLOWED"; break;
143                case SEC_ACE_TYPE_ACCESS_DENIED: val = "SEC_ACE_TYPE_ACCESS_DENIED"; break;
144                case SEC_ACE_TYPE_SYSTEM_AUDIT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT"; break;
145                case SEC_ACE_TYPE_SYSTEM_ALARM: val = "SEC_ACE_TYPE_SYSTEM_ALARM"; break;
146                case SEC_ACE_TYPE_ALLOWED_COMPOUND: val = "SEC_ACE_TYPE_ALLOWED_COMPOUND"; break;
147                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT"; break;
148                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: val = "SEC_ACE_TYPE_ACCESS_DENIED_OBJECT"; break;
149                case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT"; break;
150                case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: val = "SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT"; break;
151        }
152        ndr_print_enum(ndr, name, "ENUM", val, r);
153}
154
155static NTSTATUS ndr_push_security_ace_object_flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
156{
157        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
158        return NT_STATUS_OK;
159}
160
161static NTSTATUS ndr_pull_security_ace_object_flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
162{
163        uint32_t v;
164        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
165        *r = v;
166        return NT_STATUS_OK;
167}
168
169void ndr_print_security_ace_object_flags(struct ndr_print *ndr, const char *name, uint32_t r)
170{
171        ndr_print_uint32(ndr, name, r);
172        ndr->depth++;
173        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_OBJECT_TYPE_PRESENT", SEC_ACE_OBJECT_TYPE_PRESENT, r);
174        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT", SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT, r);
175        ndr->depth--;
176}
177
178static NTSTATUS ndr_push_security_ace_object_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_type *r)
179{
180        int level;
181        level = ndr_push_get_switch_value(ndr, r);
182        if (ndr_flags & NDR_SCALARS) {
183                switch (level) {
184                        case SEC_ACE_OBJECT_TYPE_PRESENT:
185                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->type));
186                        break;
187
188                        default:
189                        break;
190
191                }
192        }
193        if (ndr_flags & NDR_BUFFERS) {
194                switch (level) {
195                        case SEC_ACE_OBJECT_TYPE_PRESENT:
196                        break;
197
198                        default:
199                        break;
200
201                }
202        }
203        return NT_STATUS_OK;
204}
205
206static NTSTATUS ndr_pull_security_ace_object_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_type *r)
207{
208        int level;
209        level = ndr_pull_get_switch_value(ndr, r);
210        if (ndr_flags & NDR_SCALARS) {
211                switch (level) {
212                        case SEC_ACE_OBJECT_TYPE_PRESENT: {
213                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->type));
214                        break; }
215
216                        default: {
217                        break; }
218
219                }
220        }
221        if (ndr_flags & NDR_BUFFERS) {
222                switch (level) {
223                        case SEC_ACE_OBJECT_TYPE_PRESENT:
224                        break;
225
226                        default:
227                        break;
228
229                }
230        }
231        return NT_STATUS_OK;
232}
233
234void ndr_print_security_ace_object_type(struct ndr_print *ndr, const char *name, const union security_ace_object_type *r)
235{
236        int level;
237        level = ndr_print_get_switch_value(ndr, r);
238        ndr_print_union(ndr, name, level, "security_ace_object_type");
239        switch (level) {
240                case SEC_ACE_OBJECT_TYPE_PRESENT:
241                        ndr_print_GUID(ndr, "type", &r->type);
242                break;
243
244                default:
245                break;
246
247        }
248}
249
250static NTSTATUS ndr_push_security_ace_object_inherited_type(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_inherited_type *r)
251{
252        int level;
253        level = ndr_push_get_switch_value(ndr, r);
254        if (ndr_flags & NDR_SCALARS) {
255                switch (level) {
256                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
257                                NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->inherited_type));
258                        break;
259
260                        default:
261                        break;
262
263                }
264        }
265        if (ndr_flags & NDR_BUFFERS) {
266                switch (level) {
267                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
268                        break;
269
270                        default:
271                        break;
272
273                }
274        }
275        return NT_STATUS_OK;
276}
277
278static NTSTATUS ndr_pull_security_ace_object_inherited_type(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_inherited_type *r)
279{
280        int level;
281        level = ndr_pull_get_switch_value(ndr, r);
282        if (ndr_flags & NDR_SCALARS) {
283                switch (level) {
284                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT: {
285                                NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->inherited_type));
286                        break; }
287
288                        default: {
289                        break; }
290
291                }
292        }
293        if (ndr_flags & NDR_BUFFERS) {
294                switch (level) {
295                        case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
296                        break;
297
298                        default:
299                        break;
300
301                }
302        }
303        return NT_STATUS_OK;
304}
305
306void ndr_print_security_ace_object_inherited_type(struct ndr_print *ndr, const char *name, const union security_ace_object_inherited_type *r)
307{
308        int level;
309        level = ndr_print_get_switch_value(ndr, r);
310        ndr_print_union(ndr, name, level, "security_ace_object_inherited_type");
311        switch (level) {
312                case SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT:
313                        ndr_print_GUID(ndr, "inherited_type", &r->inherited_type);
314                break;
315
316                default:
317                break;
318
319        }
320}
321
322static NTSTATUS ndr_push_security_ace_object(struct ndr_push *ndr, int ndr_flags, const struct security_ace_object *r)
323{
324        if (ndr_flags & NDR_SCALARS) {
325                NDR_CHECK(ndr_push_align(ndr, 4));
326                NDR_CHECK(ndr_push_security_ace_object_flags(ndr, NDR_SCALARS, r->flags));
327                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT));
328                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
329                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
330                NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
331        }
332        if (ndr_flags & NDR_BUFFERS) {
333                NDR_CHECK(ndr_push_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
334                NDR_CHECK(ndr_push_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
335        }
336        return NT_STATUS_OK;
337}
338
339static NTSTATUS ndr_pull_security_ace_object(struct ndr_pull *ndr, int ndr_flags, struct security_ace_object *r)
340{
341        if (ndr_flags & NDR_SCALARS) {
342                NDR_CHECK(ndr_pull_align(ndr, 4));
343                NDR_CHECK(ndr_pull_security_ace_object_flags(ndr, NDR_SCALARS, &r->flags));
344                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT));
345                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_SCALARS, &r->type));
346                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT));
347                NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_SCALARS, &r->inherited_type));
348        }
349        if (ndr_flags & NDR_BUFFERS) {
350                NDR_CHECK(ndr_pull_security_ace_object_type(ndr, NDR_BUFFERS, &r->type));
351                NDR_CHECK(ndr_pull_security_ace_object_inherited_type(ndr, NDR_BUFFERS, &r->inherited_type));
352        }
353        return NT_STATUS_OK;
354}
355
356void ndr_print_security_ace_object(struct ndr_print *ndr, const char *name, const struct security_ace_object *r)
357{
358        ndr_print_struct(ndr, name, "security_ace_object");
359        ndr->depth++;
360        ndr_print_security_ace_object_flags(ndr, "flags", r->flags);
361        ndr_print_set_switch_value(ndr, &r->type, r->flags&SEC_ACE_OBJECT_TYPE_PRESENT);
362        ndr_print_security_ace_object_type(ndr, "type", &r->type);
363        ndr_print_set_switch_value(ndr, &r->inherited_type, r->flags&SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT);
364        ndr_print_security_ace_object_inherited_type(ndr, "inherited_type", &r->inherited_type);
365        ndr->depth--;
366}
367
368static NTSTATUS ndr_push_security_ace_object_ctr(struct ndr_push *ndr, int ndr_flags, const union security_ace_object_ctr *r)
369{
370        int level;
371        level = ndr_push_get_switch_value(ndr, r);
372        if (ndr_flags & NDR_SCALARS) {
373                switch (level) {
374                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
375                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
376                        break;
377
378                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
379                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
380                        break;
381
382                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
383                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
384                        break;
385
386                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
387                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_SCALARS, &r->object));
388                        break;
389
390                        default:
391                        break;
392
393                }
394        }
395        if (ndr_flags & NDR_BUFFERS) {
396                switch (level) {
397                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
398                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
399                        break;
400
401                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
402                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
403                        break;
404
405                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
406                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
407                        break;
408
409                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
410                                NDR_CHECK(ndr_push_security_ace_object(ndr, NDR_BUFFERS, &r->object));
411                        break;
412
413                        default:
414                        break;
415
416                }
417        }
418        return NT_STATUS_OK;
419}
420
421static NTSTATUS ndr_pull_security_ace_object_ctr(struct ndr_pull *ndr, int ndr_flags, union security_ace_object_ctr *r)
422{
423        int level;
424        level = ndr_pull_get_switch_value(ndr, r);
425        if (ndr_flags & NDR_SCALARS) {
426                switch (level) {
427                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT: {
428                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
429                        break; }
430
431                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT: {
432                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
433                        break; }
434
435                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT: {
436                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
437                        break; }
438
439                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT: {
440                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_SCALARS, &r->object));
441                        break; }
442
443                        default: {
444                        break; }
445
446                }
447        }
448        if (ndr_flags & NDR_BUFFERS) {
449                switch (level) {
450                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
451                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
452                        break;
453
454                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
455                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
456                        break;
457
458                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
459                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
460                        break;
461
462                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
463                                NDR_CHECK(ndr_pull_security_ace_object(ndr, NDR_BUFFERS, &r->object));
464                        break;
465
466                        default:
467                        break;
468
469                }
470        }
471        return NT_STATUS_OK;
472}
473
474void ndr_print_security_ace_object_ctr(struct ndr_print *ndr, const char *name, const union security_ace_object_ctr *r)
475{
476        int level;
477        level = ndr_print_get_switch_value(ndr, r);
478        ndr_print_union(ndr, name, level, "security_ace_object_ctr");
479        switch (level) {
480                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
481                        ndr_print_security_ace_object(ndr, "object", &r->object);
482                break;
483
484                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
485                        ndr_print_security_ace_object(ndr, "object", &r->object);
486                break;
487
488                case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
489                        ndr_print_security_ace_object(ndr, "object", &r->object);
490                break;
491
492                case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
493                        ndr_print_security_ace_object(ndr, "object", &r->object);
494                break;
495
496                default:
497                break;
498
499        }
500}
501
502NTSTATUS ndr_push_security_ace(struct ndr_push *ndr, int ndr_flags, const struct security_ace *r)
503{
504        if (ndr_flags & NDR_SCALARS) {
505                NDR_CHECK(ndr_push_align(ndr, 4));
506                NDR_CHECK(ndr_push_security_ace_type(ndr, NDR_SCALARS, r->type));
507                NDR_CHECK(ndr_push_security_ace_flags(ndr, NDR_SCALARS, r->flags));
508                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_ace(r,ndr->flags)));
509                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->access_mask));
510                NDR_CHECK(ndr_push_set_switch_value(ndr, &r->object, r->type));
511                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
512                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, &r->trustee));
513        }
514        if (ndr_flags & NDR_BUFFERS) {
515                NDR_CHECK(ndr_push_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
516        }
517        return NT_STATUS_OK;
518}
519
520NTSTATUS ndr_pull_security_ace(struct ndr_pull *ndr, int ndr_flags, struct security_ace *r)
521{
522        if (ndr_flags & NDR_SCALARS) {
523                NDR_CHECK(ndr_pull_align(ndr, 4));
524                NDR_CHECK(ndr_pull_security_ace_type(ndr, NDR_SCALARS, &r->type));
525                NDR_CHECK(ndr_pull_security_ace_flags(ndr, NDR_SCALARS, &r->flags));
526                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
527                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->access_mask));
528                NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->object, r->type));
529                NDR_CHECK(ndr_pull_security_ace_object_ctr(ndr, NDR_SCALARS, &r->object));
530                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, &r->trustee));
531        }
532        if (ndr_flags & NDR_BUFFERS) {
533                NDR_CHECK(ndr_pull_security_ace_object_ctr(ndr, NDR_BUFFERS, &r->object));
534        }
535        return NT_STATUS_OK;
536}
537
538void ndr_print_security_ace(struct ndr_print *ndr, const char *name, const struct security_ace *r)
539{
540        ndr_print_struct(ndr, name, "security_ace");
541        ndr->depth++;
542        ndr_print_security_ace_type(ndr, "type", r->type);
543        ndr_print_security_ace_flags(ndr, "flags", r->flags);
544        ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_ace(r,ndr->flags):r->size);
545        ndr_print_uint32(ndr, "access_mask", r->access_mask);
546        ndr_print_set_switch_value(ndr, &r->object, r->type);
547        ndr_print_security_ace_object_ctr(ndr, "object", &r->object);
548        ndr_print_dom_sid(ndr, "trustee", &r->trustee);
549        ndr->depth--;
550}
551
552static NTSTATUS ndr_push_security_acl_revision(struct ndr_push *ndr, int ndr_flags, enum security_acl_revision r)
553{
554        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
555        return NT_STATUS_OK;
556}
557
558static NTSTATUS ndr_pull_security_acl_revision(struct ndr_pull *ndr, int ndr_flags, enum security_acl_revision *r)
559{
560        uint16_t v;
561        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
562        *r = (enum security_acl_revision)v;
563        return NT_STATUS_OK;
564}
565
566void ndr_print_security_acl_revision(struct ndr_print *ndr, const char *name, enum security_acl_revision r)
567{
568        const char *val = NULL;
569
570        switch (r) {
571                case SECURITY_ACL_REVISION_NT4: val = "SECURITY_ACL_REVISION_NT4"; break;
572                case SECURITY_ACL_REVISION_ADS: val = "SECURITY_ACL_REVISION_ADS"; break;
573        }
574        ndr_print_enum(ndr, name, "ENUM", val, r);
575}
576
577NTSTATUS ndr_push_security_acl(struct ndr_push *ndr, int ndr_flags, const struct security_acl *r)
578{
579        uint32_t cntr_aces_0;
580        if (ndr_flags & NDR_SCALARS) {
581                NDR_CHECK(ndr_push_align(ndr, 4));
582                NDR_CHECK(ndr_push_security_acl_revision(ndr, NDR_SCALARS, r->revision));
583                NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_security_acl(r,ndr->flags)));
584                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_aces));
585                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
586                        NDR_CHECK(ndr_push_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
587                }
588        }
589        if (ndr_flags & NDR_BUFFERS) {
590                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
591                        NDR_CHECK(ndr_push_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
592                }
593        }
594        return NT_STATUS_OK;
595}
596
597NTSTATUS ndr_pull_security_acl(struct ndr_pull *ndr, int ndr_flags, struct security_acl *r)
598{
599        uint32_t cntr_aces_0;
600        TALLOC_CTX *_mem_save_aces_0;
601        if (ndr_flags & NDR_SCALARS) {
602                NDR_CHECK(ndr_pull_align(ndr, 4));
603                NDR_CHECK(ndr_pull_security_acl_revision(ndr, NDR_SCALARS, &r->revision));
604                NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
605                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_aces));
606                if (r->num_aces > 1000) { /* num_aces is unsigned */
607                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
608                }
609                NDR_PULL_ALLOC_N(ndr, r->aces, r->num_aces);
610                _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
611                NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
612                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
613                        NDR_CHECK(ndr_pull_security_ace(ndr, NDR_SCALARS, &r->aces[cntr_aces_0]));
614                }
615                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
616        }
617        if (ndr_flags & NDR_BUFFERS) {
618                _mem_save_aces_0 = NDR_PULL_GET_MEM_CTX(ndr);
619                NDR_PULL_SET_MEM_CTX(ndr, r->aces, 0);
620                for (cntr_aces_0 = 0; cntr_aces_0 < r->num_aces; cntr_aces_0++) {
621                        NDR_CHECK(ndr_pull_security_ace(ndr, NDR_BUFFERS, &r->aces[cntr_aces_0]));
622                }
623                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_aces_0, 0);
624        }
625        return NT_STATUS_OK;
626}
627
628void ndr_print_security_acl(struct ndr_print *ndr, const char *name, const struct security_acl *r)
629{
630        uint32_t cntr_aces_0;
631        ndr_print_struct(ndr, name, "security_acl");
632        ndr->depth++;
633        ndr_print_security_acl_revision(ndr, "revision", r->revision);
634        ndr_print_uint16(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_security_acl(r,ndr->flags):r->size);
635        ndr_print_uint32(ndr, "num_aces", r->num_aces);
636        ndr->print(ndr, "%s: ARRAY(%d)", "aces", r->num_aces);
637        ndr->depth++;
638        for (cntr_aces_0=0;cntr_aces_0<r->num_aces;cntr_aces_0++) {
639                char *idx_0=NULL;
640                asprintf(&idx_0, "[%d]", cntr_aces_0);
641                if (idx_0) {
642                        ndr_print_security_ace(ndr, "aces", &r->aces[cntr_aces_0]);
643                        free(idx_0);
644                }
645        }
646        ndr->depth--;
647        ndr->depth--;
648}
649
650static NTSTATUS ndr_push_security_descriptor_revision(struct ndr_push *ndr, int ndr_flags, enum security_descriptor_revision r)
651{
652        NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r));
653        return NT_STATUS_OK;
654}
655
656static NTSTATUS ndr_pull_security_descriptor_revision(struct ndr_pull *ndr, int ndr_flags, enum security_descriptor_revision *r)
657{
658        uint8_t v;
659        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &v));
660        *r = (enum security_descriptor_revision)v;
661        return NT_STATUS_OK;
662}
663
664void ndr_print_security_descriptor_revision(struct ndr_print *ndr, const char *name, enum security_descriptor_revision r)
665{
666        const char *val = NULL;
667
668        switch (r) {
669                case SECURITY_DESCRIPTOR_REVISION_1: val = "SECURITY_DESCRIPTOR_REVISION_1"; break;
670        }
671        ndr_print_enum(ndr, name, "ENUM", val, r);
672}
673
674static NTSTATUS ndr_push_security_descriptor_type(struct ndr_push *ndr, int ndr_flags, uint16_t r)
675{
676        NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
677        return NT_STATUS_OK;
678}
679
680static NTSTATUS ndr_pull_security_descriptor_type(struct ndr_pull *ndr, int ndr_flags, uint16_t *r)
681{
682        uint16_t v;
683        NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
684        *r = v;
685        return NT_STATUS_OK;
686}
687
688void ndr_print_security_descriptor_type(struct ndr_print *ndr, const char *name, uint16_t r)
689{
690        ndr_print_uint16(ndr, name, r);
691        ndr->depth++;
692        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_OWNER_DEFAULTED", SEC_DESC_OWNER_DEFAULTED, r);
693        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_GROUP_DEFAULTED", SEC_DESC_GROUP_DEFAULTED, r);
694        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PRESENT", SEC_DESC_DACL_PRESENT, r);
695        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_DEFAULTED", SEC_DESC_DACL_DEFAULTED, r);
696        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PRESENT", SEC_DESC_SACL_PRESENT, r);
697        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_DEFAULTED", SEC_DESC_SACL_DEFAULTED, r);
698        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_TRUSTED", SEC_DESC_DACL_TRUSTED, r);
699        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SERVER_SECURITY", SEC_DESC_SERVER_SECURITY, r);
700        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERIT_REQ", SEC_DESC_DACL_AUTO_INHERIT_REQ, r);
701        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERIT_REQ", SEC_DESC_SACL_AUTO_INHERIT_REQ, r);
702        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_AUTO_INHERITED", SEC_DESC_DACL_AUTO_INHERITED, r);
703        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_AUTO_INHERITED", SEC_DESC_SACL_AUTO_INHERITED, r);
704        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_DACL_PROTECTED", SEC_DESC_DACL_PROTECTED, r);
705        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SACL_PROTECTED", SEC_DESC_SACL_PROTECTED, r);
706        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_RM_CONTROL_VALID", SEC_DESC_RM_CONTROL_VALID, r);
707        ndr_print_bitmap_flag(ndr, sizeof(uint16_t), "SEC_DESC_SELF_RELATIVE", SEC_DESC_SELF_RELATIVE, r);
708        ndr->depth--;
709}
710
711NTSTATUS ndr_push_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
712{
713        {
714                uint32_t _flags_save_STRUCT = ndr->flags;
715                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
716                if (ndr_flags & NDR_SCALARS) {
717                        NDR_CHECK(ndr_push_align(ndr, 4));
718                        NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
719                        NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
720                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
721                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
722                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
723                        NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
724                }
725                if (ndr_flags & NDR_BUFFERS) {
726                        if (r->owner_sid) {
727                                NDR_CHECK(ndr_push_relative_ptr2(ndr, r->owner_sid));
728                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
729                        }
730                        if (r->group_sid) {
731                                NDR_CHECK(ndr_push_relative_ptr2(ndr, r->group_sid));
732                                NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
733                        }
734                        if (r->sacl) {
735                                NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sacl));
736                                NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
737                        }
738                        if (r->dacl) {
739                                NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dacl));
740                                NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
741                        }
742                }
743                ndr->flags = _flags_save_STRUCT;
744        }
745        return NT_STATUS_OK;
746}
747
748NTSTATUS ndr_pull_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
749{
750        uint32_t _ptr_owner_sid;
751        TALLOC_CTX *_mem_save_owner_sid_0;
752        uint32_t _ptr_group_sid;
753        TALLOC_CTX *_mem_save_group_sid_0;
754        uint32_t _ptr_sacl;
755        TALLOC_CTX *_mem_save_sacl_0;
756        uint32_t _ptr_dacl;
757        TALLOC_CTX *_mem_save_dacl_0;
758        {
759                uint32_t _flags_save_STRUCT = ndr->flags;
760                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
761                if (ndr_flags & NDR_SCALARS) {
762                        NDR_CHECK(ndr_pull_align(ndr, 4));
763                        NDR_CHECK(ndr_pull_security_descriptor_revision(ndr, NDR_SCALARS, &r->revision));
764                        NDR_CHECK(ndr_pull_security_descriptor_type(ndr, NDR_SCALARS, &r->type));
765                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_owner_sid));
766                        if (_ptr_owner_sid) {
767                                NDR_PULL_ALLOC(ndr, r->owner_sid);
768                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->owner_sid, _ptr_owner_sid));
769                        } else {
770                                r->owner_sid = NULL;
771                        }
772                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_sid));
773                        if (_ptr_group_sid) {
774                                NDR_PULL_ALLOC(ndr, r->group_sid);
775                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->group_sid, _ptr_group_sid));
776                        } else {
777                                r->group_sid = NULL;
778                        }
779                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sacl));
780                        if (_ptr_sacl) {
781                                NDR_PULL_ALLOC(ndr, r->sacl);
782                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sacl, _ptr_sacl));
783                        } else {
784                                r->sacl = NULL;
785                        }
786                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dacl));
787                        if (_ptr_dacl) {
788                                NDR_PULL_ALLOC(ndr, r->dacl);
789                                NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dacl, _ptr_dacl));
790                        } else {
791                                r->dacl = NULL;
792                        }
793                }
794                if (ndr_flags & NDR_BUFFERS) {
795                        if (r->owner_sid) {
796                                struct ndr_pull_save _relative_save;
797                                ndr_pull_save(ndr, &_relative_save);
798                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->owner_sid));
799                                _mem_save_owner_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
800                                NDR_PULL_SET_MEM_CTX(ndr, r->owner_sid, 0);
801                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
802                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_owner_sid_0, 0);
803                                ndr_pull_restore(ndr, &_relative_save);
804                        }
805                        if (r->group_sid) {
806                                struct ndr_pull_save _relative_save;
807                                ndr_pull_save(ndr, &_relative_save);
808                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->group_sid));
809                                _mem_save_group_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
810                                NDR_PULL_SET_MEM_CTX(ndr, r->group_sid, 0);
811                                NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->group_sid));
812                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_sid_0, 0);
813                                ndr_pull_restore(ndr, &_relative_save);
814                        }
815                        if (r->sacl) {
816                                struct ndr_pull_save _relative_save;
817                                ndr_pull_save(ndr, &_relative_save);
818                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sacl));
819                                _mem_save_sacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
820                                NDR_PULL_SET_MEM_CTX(ndr, r->sacl, 0);
821                                NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
822                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sacl_0, 0);
823                                ndr_pull_restore(ndr, &_relative_save);
824                        }
825                        if (r->dacl) {
826                                struct ndr_pull_save _relative_save;
827                                ndr_pull_save(ndr, &_relative_save);
828                                NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dacl));
829                                _mem_save_dacl_0 = NDR_PULL_GET_MEM_CTX(ndr);
830                                NDR_PULL_SET_MEM_CTX(ndr, r->dacl, 0);
831                                NDR_CHECK(ndr_pull_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
832                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dacl_0, 0);
833                                ndr_pull_restore(ndr, &_relative_save);
834                        }
835                }
836                ndr->flags = _flags_save_STRUCT;
837        }
838        return NT_STATUS_OK;
839}
840
841void ndr_print_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
842{
843        ndr_print_struct(ndr, name, "security_descriptor");
844        {
845                uint32_t _flags_save_STRUCT = ndr->flags;
846                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
847                ndr->depth++;
848                ndr_print_security_descriptor_revision(ndr, "revision", r->revision);
849                ndr_print_security_descriptor_type(ndr, "type", r->type);
850                ndr_print_ptr(ndr, "owner_sid", r->owner_sid);
851                ndr->depth++;
852                if (r->owner_sid) {
853                        ndr_print_dom_sid(ndr, "owner_sid", r->owner_sid);
854                }
855                ndr->depth--;
856                ndr_print_ptr(ndr, "group_sid", r->group_sid);
857                ndr->depth++;
858                if (r->group_sid) {
859                        ndr_print_dom_sid(ndr, "group_sid", r->group_sid);
860                }
861                ndr->depth--;
862                ndr_print_ptr(ndr, "sacl", r->sacl);
863                ndr->depth++;
864                if (r->sacl) {
865                        ndr_print_security_acl(ndr, "sacl", r->sacl);
866                }
867                ndr->depth--;
868                ndr_print_ptr(ndr, "dacl", r->dacl);
869                ndr->depth++;
870                if (r->dacl) {
871                        ndr_print_security_acl(ndr, "dacl", r->dacl);
872                }
873                ndr->depth--;
874                ndr->depth--;
875                ndr->flags = _flags_save_STRUCT;
876        }
877}
878
879NTSTATUS ndr_push_security_secinfo(struct ndr_push *ndr, int ndr_flags, uint32_t r)
880{
881        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
882        return NT_STATUS_OK;
883}
884
885NTSTATUS ndr_pull_security_secinfo(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
886{
887        uint32_t v;
888        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
889        *r = v;
890        return NT_STATUS_OK;
891}
892
893void ndr_print_security_secinfo(struct ndr_print *ndr, const char *name, uint32_t r)
894{
895        ndr_print_uint32(ndr, name, r);
896        ndr->depth++;
897        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_OWNER", SECINFO_OWNER, r);
898        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_GROUP", SECINFO_GROUP, r);
899        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_DACL", SECINFO_DACL, r);
900        ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SECINFO_SACL", SECINFO_SACL, r);
901        ndr->depth--;
902}
903
Note: See TracBrowser for help on using the repository browser.