Fixing get/set of security descriptors.
[samba.git] / source3 / rpc_parse / parse_sec.c
1 /* 
2  *  Unix SMB/Netbios implementation.
3  *  Version 1.9.
4  *  RPC Pipe client / server routines
5  *  Copyright (C) Andrew Tridgell              1992-1998,
6  *  Copyright (C) Jeremy R. Allison            1995-1998
7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
8  *  Copyright (C) Paul Ashton                  1997-1998.
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25
26 #include "includes.h"
27
28 extern int DEBUGLEVEL;
29
30 #define SD_HEADER_SIZE 0x14
31
32 /*******************************************************************
33  Sets up a SEC_ACCESS structure.
34 ********************************************************************/
35
36 void init_sec_access(SEC_ACCESS *t, uint32 mask)
37 {
38         t->mask = mask;
39 }
40
41 /*******************************************************************
42  Reads or writes a SEC_ACCESS structure.
43 ********************************************************************/
44
45 BOOL sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
46 {
47         if (t == NULL)
48                 return False;
49
50         prs_debug(ps, depth, desc, "sec_io_access");
51         depth++;
52
53         if(!prs_align(ps))
54                 return False;
55         
56         if(!prs_uint32("mask", ps, depth, &(t->mask)))
57                 return False;
58
59         return True;
60 }
61
62
63 /*******************************************************************
64  Sets up a SEC_ACE structure.
65 ********************************************************************/
66
67 void init_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
68 {
69         t->type = type;
70         t->flags = flag;
71         t->size = sid_size(sid) + 8;
72         t->info = mask;
73
74         ZERO_STRUCTP(&t->sid);
75         sid_copy(&t->sid, sid);
76 }
77
78 /*******************************************************************
79  Reads or writes a SEC_ACE structure.
80 ********************************************************************/
81
82 BOOL sec_io_ace(char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
83 {
84         uint32 old_offset;
85         uint32 offset_ace_size;
86
87         if (psa == NULL)
88                 return False;
89
90         prs_debug(ps, depth, desc, "sec_io_ace");
91         depth++;
92
93         if(!prs_align(ps))
94                 return False;
95         
96         old_offset = prs_offset(ps);
97
98         if(!prs_uint8("type ", ps, depth, &psa->type))
99                 return False;
100
101         if(!prs_uint8("flags", ps, depth, &psa->flags))
102                 return False;
103
104         if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
105                 return False;
106
107         if(!sec_io_access("info ", &psa->info, ps, depth))
108                 return False;
109
110         if(!prs_align(ps))
111                 return False;
112
113         if(!smb_io_dom_sid("sid  ", &psa->sid , ps, depth))
114                 return False;
115
116         if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
117                 return False;
118
119         return True;
120 }
121
122 /*******************************************************************
123  Create a SEC_ACL structure.  
124 ********************************************************************/
125
126 SEC_ACL *make_sec_acl(uint16 revision, int num_aces, SEC_ACE *ace_list)
127 {
128         SEC_ACL *dst;
129         int i;
130
131         if((dst = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
132                 return NULL;
133
134         ZERO_STRUCTP(dst);
135
136         dst->revision = revision;
137         dst->num_aces = num_aces;
138         dst->size = 8;
139
140         if((dst->ace = (SEC_ACE *)malloc( sizeof(SEC_ACE) * num_aces )) == NULL) {
141                 free_sec_acl(&dst);
142                 return NULL;
143         }
144
145         for (i = 0; i < num_aces; i++) {
146                 dst->ace[i] = ace_list[i]; /* Structure copy. */
147                 dst->size += ace_list[i].size;
148         }
149
150         return dst;
151 }
152
153 /*******************************************************************
154  Duplicate a SEC_ACL structure.  
155 ********************************************************************/
156
157 SEC_ACL *dup_sec_acl( SEC_ACL *src)
158 {
159         if(src == NULL)
160                 return NULL;
161
162         return make_sec_acl( src->revision, src->num_aces, src->ace);
163 }
164
165 /*******************************************************************
166  Delete a SEC_ACL structure.  
167 ********************************************************************/
168
169 void free_sec_acl(SEC_ACL **ppsa)
170 {
171         SEC_ACL *psa;
172
173         if(ppsa == NULL || *ppsa == NULL)
174                 return;
175
176         psa = *ppsa;
177         if (psa->ace != NULL)
178                 free(psa->ace);
179
180         free(psa);
181         *ppsa = NULL;
182 }
183
184 /*******************************************************************
185  Reads or writes a SEC_ACL structure.  
186
187  First of the xx_io_xx functions that allocates its data structures
188  for you as it reads them.
189 ********************************************************************/
190
191 BOOL sec_io_acl(char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
192 {
193         int i;
194         uint32 old_offset;
195         uint32 offset_acl_size;
196         SEC_ACL *psa;
197
198         if (ppsa == NULL)
199                 return False;
200
201         psa = *ppsa;
202
203         if(UNMARSHALLING(ps) && psa == NULL) {
204                 /*
205                  * This is a read and we must allocate the stuct to read into.
206                  */
207                 if((psa = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
208                         return False;
209                 ZERO_STRUCTP(psa);
210                 *ppsa = psa;
211         }
212
213         prs_debug(ps, depth, desc, "sec_io_acl");
214         depth++;
215
216         if(!prs_align(ps))
217                 return False;
218         
219         old_offset = prs_offset(ps);
220
221         if(!prs_uint16("revision", ps, depth, &psa->revision))
222                 return False;
223
224         if(!prs_uint16_pre("size     ", ps, depth, &psa->size, &offset_acl_size))
225                 return False;
226
227         if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
228                 return False;
229
230         if (UNMARSHALLING(ps) && psa->num_aces != 0) {
231                 /* reading */
232                 if((psa->ace = malloc(sizeof(psa->ace[0]) * psa->num_aces)) == NULL)
233                         return False;
234                 ZERO_STRUCTP(psa->ace);
235         }
236
237         for (i = 0; i < psa->num_aces; i++) {
238                 fstring tmp;
239                 slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
240                 if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
241                         return False;
242         }
243
244         if(!prs_align(ps))
245                 return False;
246
247         if(!prs_uint16_post("size     ", ps, depth, &psa->size, offset_acl_size, old_offset))
248                 return False;
249
250         return True;
251 }
252
253 /*******************************************************************
254  Works out the linearization size of a SEC_DESC.
255 ********************************************************************/
256
257 size_t sec_desc_size(SEC_DESC *psd)
258 {
259         size_t offset;
260
261         if (!psd) return 0;
262
263         offset = SD_HEADER_SIZE;
264
265         if (psd->owner_sid != NULL)
266                 offset += ((sid_size(psd->owner_sid) + 3) & ~3);
267
268         if (psd->grp_sid != NULL)
269                 offset += ((sid_size(psd->grp_sid) + 3) & ~3);
270
271         if (psd->sacl != NULL)
272                 offset += ((psd->sacl->size + 3) & ~3);
273
274         if (psd->dacl != NULL)
275                 offset += ((psd->dacl->size + 3) & ~3);
276
277         return offset;
278 }
279
280 /*******************************************************************
281  Creates a SEC_DESC structure
282 ********************************************************************/
283
284 SEC_DESC *make_sec_desc(uint16 revision, uint16 type,
285                         DOM_SID *owner_sid, DOM_SID *grp_sid,
286                         SEC_ACL *sacl, SEC_ACL *dacl, size_t *sd_size)
287 {
288         SEC_DESC *dst;
289         uint32 offset;
290
291         *sd_size = 0;
292
293         if(( dst = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
294                 return NULL;
295
296         ZERO_STRUCTP(dst);
297
298         dst->revision = revision;
299         dst->type     = type;
300
301         dst->off_owner_sid = 0;
302         dst->off_grp_sid   = 0;
303         dst->off_sacl      = 0;
304         dst->off_dacl      = 0;
305
306         if(owner_sid && ((dst->owner_sid = sid_dup(owner_sid)) == NULL))
307                 goto error_exit;
308
309         if(grp_sid && ((dst->grp_sid = sid_dup(grp_sid)) == NULL))
310                 goto error_exit;
311
312         if(sacl && ((dst->sacl = dup_sec_acl(sacl)) == NULL))
313                 goto error_exit;
314
315         if(dacl && ((dst->dacl = dup_sec_acl(dacl)) == NULL))
316                 goto error_exit;
317                 
318         offset = 0;
319
320         /*
321          * Work out the linearization sizes.
322          */
323
324         if (dst->owner_sid != NULL) {
325
326                 if (offset == 0)
327                         offset = SD_HEADER_SIZE;
328
329                 dst->off_owner_sid = offset;
330                 offset += ((sid_size(dst->owner_sid) + 3) & ~3);
331         }
332
333         if (dst->grp_sid != NULL) {
334
335                 if (offset == 0)
336                         offset = SD_HEADER_SIZE;
337
338                 dst->off_grp_sid = offset;
339                 offset += ((sid_size(dst->grp_sid) + 3) & ~3);
340         }
341
342         if (dst->sacl != NULL) {
343
344                 if (offset == 0)
345                         offset = SD_HEADER_SIZE;
346
347                 dst->off_sacl = offset;
348                 offset += ((sacl->size + 3) & ~3);
349         }
350
351         if (dst->dacl != NULL) {
352
353                 if (offset == 0)
354                         offset = SD_HEADER_SIZE;
355
356                 dst->off_dacl = offset;
357                 offset += ((dacl->size + 3) & ~3);
358         }
359
360         *sd_size = (size_t)((offset == 0) ? SD_HEADER_SIZE : offset);
361         return dst;
362
363 error_exit:
364
365         *sd_size = 0;
366         free_sec_desc(&dst);
367         return NULL;
368 }
369
370 /*******************************************************************
371  Duplicate a SEC_DESC structure.  
372 ********************************************************************/
373
374 SEC_DESC *dup_sec_desc( SEC_DESC *src)
375 {
376         size_t dummy;
377
378         if(src == NULL)
379                 return NULL;
380
381         return make_sec_desc( src->revision, src->type, 
382                                 src->owner_sid, src->grp_sid, src->sacl,
383                                 src->dacl, &dummy);
384 }
385
386 /*******************************************************************
387  Deletes a SEC_DESC structure
388 ********************************************************************/
389
390 void free_sec_desc(SEC_DESC **ppsd)
391 {
392         SEC_DESC *psd;
393
394         if(ppsd == NULL || *ppsd == NULL)
395                 return;
396
397         psd = *ppsd;
398
399         free_sec_acl(&psd->dacl);
400         free_sec_acl(&psd->dacl);
401         free(psd->owner_sid);
402         free(psd->grp_sid);
403         free(psd);
404         *ppsd = NULL;
405 }
406
407 /*******************************************************************
408  Creates a SEC_DESC structure with typical defaults.
409 ********************************************************************/
410
411 SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid,
412                                  SEC_ACL *dacl, size_t *sd_size)
413 {
414         return make_sec_desc(1, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
415                              owner_sid, grp_sid, NULL, dacl, sd_size);
416 }
417
418 /*******************************************************************
419  Reads or writes a SEC_DESC structure.
420  If reading and the *ppsd = NULL, allocates the structure.
421 ********************************************************************/
422
423 BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
424 {
425         uint32 old_offset;
426         uint32 max_offset = 0; /* after we're done, move offset to end */
427         SEC_DESC *psd;
428
429         if (ppsd == NULL)
430                 return False;
431
432         psd = *ppsd;
433
434         if (psd == NULL) {
435                 if(UNMARSHALLING(ps)) {
436                         if((psd = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
437                                 return False;
438                         ZERO_STRUCTP(psd);
439                         *ppsd = psd;
440                 } else {
441                         /* Marshalling - just ignore. */
442                         return True;
443                 }
444         }
445
446         prs_debug(ps, depth, desc, "sec_io_desc");
447         depth++;
448
449         if(!prs_align(ps))
450                 return False;
451         
452         /* start of security descriptor stored for back-calc offset purposes */
453         old_offset = prs_offset(ps);
454
455         if(!prs_uint16("revision ", ps, depth, &psd->revision))
456                 return False;
457
458         if(!prs_uint16("type     ", ps, depth, &psd->type))
459                 return False;
460
461         if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
462                 return False;
463
464         if(!prs_uint32("off_grp_sid  ", ps, depth, &psd->off_grp_sid))
465                 return False;
466
467         if(!prs_uint32("off_sacl     ", ps, depth, &psd->off_sacl))
468                 return False;
469
470         if(!prs_uint32("off_dacl     ", ps, depth, &psd->off_dacl))
471                 return False;
472
473         max_offset = MAX(max_offset, prs_offset(ps));
474
475         if (psd->off_owner_sid != 0) {
476
477                 if (UNMARSHALLING(ps)) {
478                         if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
479                                 return False;
480                         /* reading */
481                         if((psd->owner_sid = malloc(sizeof(*psd->owner_sid))) == NULL)
482                                 return False;
483                         ZERO_STRUCTP(psd->owner_sid);
484                 }
485
486                 if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
487                         return False;
488                 if(!prs_align(ps))
489                         return False;
490         }
491
492         max_offset = MAX(max_offset, prs_offset(ps));
493
494         if (psd->off_grp_sid != 0) {
495
496                 if (UNMARSHALLING(ps)) {
497                         /* reading */
498                         if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
499                                 return False;
500                         if((psd->grp_sid = malloc(sizeof(*psd->grp_sid))) == NULL)
501                                 return False;
502                         ZERO_STRUCTP(psd->grp_sid);
503                 }
504
505                 if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
506                         return False;
507                 if(!prs_align(ps))
508                         return False;
509         }
510
511         max_offset = MAX(max_offset, prs_offset(ps));
512
513         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_SACL_PRESENT) && psd->off_sacl) {
514                 if(!prs_set_offset(ps, old_offset + psd->off_sacl))
515                         return False;
516                 if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
517                         return False;
518                 if(!prs_align(ps))
519                         return False;
520         }
521
522         max_offset = MAX(max_offset, prs_offset(ps));
523
524         if (IS_BITS_SET_ALL(psd->type, SEC_DESC_DACL_PRESENT) && psd->off_dacl != 0) {
525                 if(!prs_set_offset(ps, old_offset + psd->off_dacl))
526                         return False;
527                 if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
528                         return False;
529                 if(!prs_align(ps))
530                         return False;
531         }
532
533         max_offset = MAX(max_offset, prs_offset(ps));
534
535         if(!prs_set_offset(ps, max_offset))
536                 return False;
537         return True;
538 }
539
540 /*******************************************************************
541  Creates a SEC_DESC_BUF structure.
542 ********************************************************************/
543
544 SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc)
545 {
546         SEC_DESC_BUF *dst;
547
548         if((dst = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
549                 return NULL;
550
551         ZERO_STRUCTP(dst);
552
553         /* max buffer size (allocated size) */
554         dst->max_len = (uint32)len;
555         dst->len = (uint32)len;
556
557         if(sec_desc && ((dst->sec = dup_sec_desc(sec_desc)) == NULL)) {
558                 free_sec_desc_buf(&dst);
559                 return NULL;
560         }
561
562         return dst;
563 }
564
565 /*******************************************************************
566  Duplicates a SEC_DESC_BUF structure.
567 ********************************************************************/
568
569 SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src)
570 {
571         if(src == NULL)
572                 return NULL;
573
574         return make_sec_desc_buf( src->len, src->sec);
575 }
576
577 /*******************************************************************
578  Deletes a SEC_DESC_BUF structure.
579 ********************************************************************/
580
581 void free_sec_desc_buf(SEC_DESC_BUF **ppsdb)
582 {
583         SEC_DESC_BUF *psdb;
584
585         if(ppsdb == NULL || *ppsdb == NULL)
586                 return;
587
588         psdb = *ppsdb;
589         free_sec_desc(&psdb->sec);
590         free(psdb);
591         *ppsdb = NULL;
592 }
593
594
595 /*******************************************************************
596  Reads or writes a SEC_DESC_BUF structure.
597 ********************************************************************/
598
599 BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
600 {
601         uint32 off_len;
602         uint32 off_max_len;
603         uint32 old_offset;
604         uint32 size;
605         SEC_DESC_BUF *psdb;
606
607         if (ppsdb == NULL)
608                 return False;
609
610         psdb = *ppsdb;
611
612         if (UNMARSHALLING(ps) && psdb == NULL) {
613                 if((psdb = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
614                         return False;
615                 ZERO_STRUCTP(psdb);
616                 *ppsdb = psdb;
617         }
618
619         prs_debug(ps, depth, desc, "sec_io_desc_buf");
620         depth++;
621
622         if(!prs_align(ps))
623                 return False;
624         
625         if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len))
626                 return False;
627
628         if(!prs_uint32    ("undoc  ", ps, depth, &psdb->undoc))
629                 return False;
630
631         if(!prs_uint32_pre("len    ", ps, depth, &psdb->len, &off_len))
632                 return False;
633
634         old_offset = prs_offset(ps);
635
636         /* reading, length is non-zero; writing, descriptor is non-NULL */
637         if ((UNMARSHALLING(ps) && psdb->len != 0) || (MARSHALLING(ps) && psdb->sec != NULL)) {
638                 if(!sec_io_desc("sec   ", &psdb->sec, ps, depth))
639                         return False;
640         }
641
642         if(!prs_align(ps))
643                 return False;
644         
645         size = prs_offset(ps) - old_offset;
646         if(!prs_uint32_post("max_len", ps, depth, &psdb->max_len, off_max_len, size == 0 ? psdb->max_len : size))
647                 return False;
648
649         if(!prs_uint32_post("len    ", ps, depth, &psdb->len, off_len, size))
650                 return False;
651
652         return True;
653 }