2 * Unix SMB/Netbios implementation.
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.
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.
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.
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.
28 extern int DEBUGLEVEL;
30 #define SD_HEADER_SIZE 0x14
32 /*******************************************************************
33 Sets up a SEC_ACCESS structure.
34 ********************************************************************/
36 void init_sec_access(SEC_ACCESS *t, uint32 mask)
41 /*******************************************************************
42 Reads or writes a SEC_ACCESS structure.
43 ********************************************************************/
45 BOOL sec_io_access(char *desc, SEC_ACCESS *t, prs_struct *ps, int depth)
50 prs_debug(ps, depth, desc, "sec_io_access");
56 if(!prs_uint32("mask", ps, depth, &(t->mask)))
63 /*******************************************************************
64 Sets up a SEC_ACE structure.
65 ********************************************************************/
67 void init_sec_ace(SEC_ACE *t, DOM_SID *sid, uint8 type, SEC_ACCESS mask, uint8 flag)
71 t->size = sid_size(sid) + 8;
74 ZERO_STRUCTP(&t->sid);
75 sid_copy(&t->sid, sid);
78 /*******************************************************************
79 Reads or writes a SEC_ACE structure.
80 ********************************************************************/
82 BOOL sec_io_ace(char *desc, SEC_ACE *psa, prs_struct *ps, int depth)
85 uint32 offset_ace_size;
90 prs_debug(ps, depth, desc, "sec_io_ace");
96 old_offset = prs_offset(ps);
98 if(!prs_uint8("type ", ps, depth, &psa->type))
101 if(!prs_uint8("flags", ps, depth, &psa->flags))
104 if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_ace_size))
107 if(!sec_io_access("info ", &psa->info, ps, depth))
113 if(!smb_io_dom_sid("sid ", &psa->sid , ps, depth))
116 if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_ace_size, old_offset))
122 /*******************************************************************
123 Create a SEC_ACL structure.
124 ********************************************************************/
126 SEC_ACL *make_sec_acl(uint16 revision, int num_aces, SEC_ACE *ace_list)
131 if((dst = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
136 dst->revision = revision;
137 dst->num_aces = num_aces;
140 if((dst->ace = (SEC_ACE *)malloc( sizeof(SEC_ACE) * num_aces )) == NULL) {
145 for (i = 0; i < num_aces; i++) {
146 dst->ace[i] = ace_list[i]; /* Structure copy. */
147 dst->size += ace_list[i].size;
153 /*******************************************************************
154 Duplicate a SEC_ACL structure.
155 ********************************************************************/
157 SEC_ACL *dup_sec_acl( SEC_ACL *src)
162 return make_sec_acl( src->revision, src->num_aces, src->ace);
165 /*******************************************************************
166 Delete a SEC_ACL structure.
167 ********************************************************************/
169 void free_sec_acl(SEC_ACL **ppsa)
173 if(ppsa == NULL || *ppsa == NULL)
177 if (psa->ace != NULL)
184 /*******************************************************************
185 Reads or writes a SEC_ACL structure.
187 First of the xx_io_xx functions that allocates its data structures
188 for you as it reads them.
189 ********************************************************************/
191 BOOL sec_io_acl(char *desc, SEC_ACL **ppsa, prs_struct *ps, int depth)
195 uint32 offset_acl_size;
203 if(UNMARSHALLING(ps) && psa == NULL) {
205 * This is a read and we must allocate the stuct to read into.
207 if((psa = (SEC_ACL *)malloc(sizeof(SEC_ACL))) == NULL)
213 prs_debug(ps, depth, desc, "sec_io_acl");
219 old_offset = prs_offset(ps);
221 if(!prs_uint16("revision", ps, depth, &psa->revision))
224 if(!prs_uint16_pre("size ", ps, depth, &psa->size, &offset_acl_size))
227 if(!prs_uint32("num_aces ", ps, depth, &psa->num_aces))
230 if (UNMARSHALLING(ps) && psa->num_aces != 0) {
232 if((psa->ace = malloc(sizeof(psa->ace[0]) * psa->num_aces)) == NULL)
234 ZERO_STRUCTP(psa->ace);
237 for (i = 0; i < psa->num_aces; i++) {
239 slprintf(tmp, sizeof(tmp)-1, "ace_list[%02d]: ", i);
240 if(!sec_io_ace(tmp, &psa->ace[i], ps, depth))
247 if(!prs_uint16_post("size ", ps, depth, &psa->size, offset_acl_size, old_offset))
253 /*******************************************************************
254 Works out the linearization size of a SEC_DESC.
255 ********************************************************************/
257 size_t sec_desc_size(SEC_DESC *psd)
263 offset = SD_HEADER_SIZE;
265 if (psd->owner_sid != NULL)
266 offset += ((sid_size(psd->owner_sid) + 3) & ~3);
268 if (psd->grp_sid != NULL)
269 offset += ((sid_size(psd->grp_sid) + 3) & ~3);
271 if (psd->sacl != NULL)
272 offset += ((psd->sacl->size + 3) & ~3);
274 if (psd->dacl != NULL)
275 offset += ((psd->dacl->size + 3) & ~3);
280 /*******************************************************************
281 Creates a SEC_DESC structure
282 ********************************************************************/
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)
293 if(( dst = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
298 dst->revision = revision;
301 dst->off_owner_sid = 0;
302 dst->off_grp_sid = 0;
306 if(owner_sid && ((dst->owner_sid = sid_dup(owner_sid)) == NULL))
309 if(grp_sid && ((dst->grp_sid = sid_dup(grp_sid)) == NULL))
312 if(sacl && ((dst->sacl = dup_sec_acl(sacl)) == NULL))
315 if(dacl && ((dst->dacl = dup_sec_acl(dacl)) == NULL))
321 * Work out the linearization sizes.
324 if (dst->owner_sid != NULL) {
327 offset = SD_HEADER_SIZE;
329 dst->off_owner_sid = offset;
330 offset += ((sid_size(dst->owner_sid) + 3) & ~3);
333 if (dst->grp_sid != NULL) {
336 offset = SD_HEADER_SIZE;
338 dst->off_grp_sid = offset;
339 offset += ((sid_size(dst->grp_sid) + 3) & ~3);
342 if (dst->sacl != NULL) {
345 offset = SD_HEADER_SIZE;
347 dst->off_sacl = offset;
348 offset += ((sacl->size + 3) & ~3);
351 if (dst->dacl != NULL) {
354 offset = SD_HEADER_SIZE;
356 dst->off_dacl = offset;
357 offset += ((dacl->size + 3) & ~3);
360 *sd_size = (size_t)((offset == 0) ? SD_HEADER_SIZE : offset);
370 /*******************************************************************
371 Duplicate a SEC_DESC structure.
372 ********************************************************************/
374 SEC_DESC *dup_sec_desc( SEC_DESC *src)
381 return make_sec_desc( src->revision, src->type,
382 src->owner_sid, src->grp_sid, src->sacl,
386 /*******************************************************************
387 Deletes a SEC_DESC structure
388 ********************************************************************/
390 void free_sec_desc(SEC_DESC **ppsd)
394 if(ppsd == NULL || *ppsd == NULL)
399 free_sec_acl(&psd->dacl);
400 free_sec_acl(&psd->dacl);
401 free(psd->owner_sid);
407 /*******************************************************************
408 Creates a SEC_DESC structure with typical defaults.
409 ********************************************************************/
411 SEC_DESC *make_standard_sec_desc(DOM_SID *owner_sid, DOM_SID *grp_sid,
412 SEC_ACL *dacl, size_t *sd_size)
414 return make_sec_desc(1, SEC_DESC_SELF_RELATIVE|SEC_DESC_DACL_PRESENT,
415 owner_sid, grp_sid, NULL, dacl, sd_size);
418 /*******************************************************************
419 Reads or writes a SEC_DESC structure.
420 If reading and the *ppsd = NULL, allocates the structure.
421 ********************************************************************/
423 BOOL sec_io_desc(char *desc, SEC_DESC **ppsd, prs_struct *ps, int depth)
426 uint32 max_offset = 0; /* after we're done, move offset to end */
435 if(UNMARSHALLING(ps)) {
436 if((psd = (SEC_DESC *)malloc(sizeof(SEC_DESC))) == NULL)
441 /* Marshalling - just ignore. */
446 prs_debug(ps, depth, desc, "sec_io_desc");
452 /* start of security descriptor stored for back-calc offset purposes */
453 old_offset = prs_offset(ps);
455 if(!prs_uint16("revision ", ps, depth, &psd->revision))
458 if(!prs_uint16("type ", ps, depth, &psd->type))
461 if(!prs_uint32("off_owner_sid", ps, depth, &psd->off_owner_sid))
464 if(!prs_uint32("off_grp_sid ", ps, depth, &psd->off_grp_sid))
467 if(!prs_uint32("off_sacl ", ps, depth, &psd->off_sacl))
470 if(!prs_uint32("off_dacl ", ps, depth, &psd->off_dacl))
473 max_offset = MAX(max_offset, prs_offset(ps));
475 if (psd->off_owner_sid != 0) {
477 if (UNMARSHALLING(ps)) {
478 if(!prs_set_offset(ps, old_offset + psd->off_owner_sid))
481 if((psd->owner_sid = malloc(sizeof(*psd->owner_sid))) == NULL)
483 ZERO_STRUCTP(psd->owner_sid);
486 if(!smb_io_dom_sid("owner_sid ", psd->owner_sid , ps, depth))
492 max_offset = MAX(max_offset, prs_offset(ps));
494 if (psd->off_grp_sid != 0) {
496 if (UNMARSHALLING(ps)) {
498 if(!prs_set_offset(ps, old_offset + psd->off_grp_sid))
500 if((psd->grp_sid = malloc(sizeof(*psd->grp_sid))) == NULL)
502 ZERO_STRUCTP(psd->grp_sid);
505 if(!smb_io_dom_sid("grp_sid", psd->grp_sid, ps, depth))
511 max_offset = MAX(max_offset, prs_offset(ps));
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))
516 if(!sec_io_acl("sacl", &psd->sacl, ps, depth))
522 max_offset = MAX(max_offset, prs_offset(ps));
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))
527 if(!sec_io_acl("dacl", &psd->dacl, ps, depth))
533 max_offset = MAX(max_offset, prs_offset(ps));
535 if(!prs_set_offset(ps, max_offset))
540 /*******************************************************************
541 Creates a SEC_DESC_BUF structure.
542 ********************************************************************/
544 SEC_DESC_BUF *make_sec_desc_buf(size_t len, SEC_DESC *sec_desc)
548 if((dst = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
553 /* max buffer size (allocated size) */
554 dst->max_len = (uint32)len;
555 dst->len = (uint32)len;
557 if(sec_desc && ((dst->sec = dup_sec_desc(sec_desc)) == NULL)) {
558 free_sec_desc_buf(&dst);
565 /*******************************************************************
566 Duplicates a SEC_DESC_BUF structure.
567 ********************************************************************/
569 SEC_DESC_BUF *dup_sec_desc_buf(SEC_DESC_BUF *src)
574 return make_sec_desc_buf( src->len, src->sec);
577 /*******************************************************************
578 Deletes a SEC_DESC_BUF structure.
579 ********************************************************************/
581 void free_sec_desc_buf(SEC_DESC_BUF **ppsdb)
585 if(ppsdb == NULL || *ppsdb == NULL)
589 free_sec_desc(&psdb->sec);
595 /*******************************************************************
596 Reads or writes a SEC_DESC_BUF structure.
597 ********************************************************************/
599 BOOL sec_io_desc_buf(char *desc, SEC_DESC_BUF **ppsdb, prs_struct *ps, int depth)
612 if (UNMARSHALLING(ps) && psdb == NULL) {
613 if((psdb = (SEC_DESC_BUF *)malloc(sizeof(SEC_DESC_BUF))) == NULL)
619 prs_debug(ps, depth, desc, "sec_io_desc_buf");
625 if(!prs_uint32_pre("max_len", ps, depth, &psdb->max_len, &off_max_len))
628 if(!prs_uint32 ("undoc ", ps, depth, &psdb->undoc))
631 if(!prs_uint32_pre("len ", ps, depth, &psdb->len, &off_len))
634 old_offset = prs_offset(ps);
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))
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))
649 if(!prs_uint32_post("len ", ps, depth, &psdb->len, off_len, size))