?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fairly large change to printing code.
[Samba.git] / source / smbd / posix_acls.c
blob043e33e83675ca9267345bbffecbb078365b611e
1 /*
2 Unix SMB/CIFS implementation.
3 SMB NT Security Descriptor / Unix permission conversion.
4 Copyright (C) Jeremy Allison 1994-2000
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 /****************************************************************************
24 Data structures representing the internal ACE format.
25 ****************************************************************************/
26
27 enum ace_owner {UID_ACE, GID_ACE, WORLD_ACE};
28 enum ace_attribute {ALLOW_ACE, DENY_ACE}; /* Used for incoming NT ACLS. */
29
30 typedef union posix_id {
31 uid_t uid;
32 gid_t gid;
33 int world;
34 } posix_id;
35
36 typedef struct canon_ace {
37 struct canon_ace *next, *prev;
38 SMB_ACL_TAG_T type;
39 mode_t perms; /* Only use S_I(R|W|X)USR mode bits here. */
40 DOM_SID trustee;
41 enum ace_owner owner_type;
42 enum ace_attribute attr;
43 posix_id unix_ug;
44 } canon_ace;
45
46 #define ALL_ACE_PERMS (S_IRUSR|S_IWUSR|S_IXUSR)
47
48 /****************************************************************************
49 Functions to manipulate the internal ACE format.
50 ****************************************************************************/
51
52 /****************************************************************************
53 Count a linked list of canonical ACE entries.
54 ****************************************************************************/
55
56 static size_t count_canon_ace_list( canon_ace *list_head )
57 {
58 size_t count = 0;
59 canon_ace *ace;
60
61 for (ace = list_head; ace; ace = ace->next)
62 count++;
63
64 return count;
65 }
66
67 /****************************************************************************
68 Free a linked list of canonical ACE entries.
69 ****************************************************************************/
70
71 static void free_canon_ace_list( canon_ace *list_head )
72 {
73 while (list_head) {
74 canon_ace *old_head = list_head;
75 DLIST_REMOVE(list_head, list_head);
76 SAFE_FREE(old_head);
77 }
78 }
79
80 /****************************************************************************
81 Function to duplicate a canon_ace entry.
82 ****************************************************************************/
83
84 static canon_ace *dup_canon_ace( canon_ace *src_ace)
85 {
86 canon_ace *dst_ace = (canon_ace *)malloc(sizeof(canon_ace));
87
88 if (dst_ace == NULL)
89 return NULL;
90
91 *dst_ace = *src_ace;
92 dst_ace->prev = dst_ace->next = NULL;
93 return dst_ace;
94 }
95
96 /****************************************************************************
97 Print out a canon ace.
98 ****************************************************************************/
99
100 static void print_canon_ace(canon_ace *pace, int num)
101 {
102 fstring str;
103
104 dbgtext( "canon_ace index %d. Type = %s ", num, pace->attr == ALLOW_ACE ? "allow" : "deny" );
105 dbgtext( "SID = %s ", sid_to_string( str, &pace->trustee));
106 if (pace->owner_type == UID_ACE) {
107 const char *u_name = uidtoname(pace->unix_ug.uid);
108 dbgtext( "uid %u (%s) ", (unsigned int)pace->unix_ug.uid, u_name);
109 } else if (pace->owner_type == GID_ACE) {
110 char *g_name = gidtoname(pace->unix_ug.gid);
111 dbgtext( "gid %u (%s) ", (unsigned int)pace->unix_ug.gid, g_name);
112 } else
113 dbgtext( "other ");
114 switch (pace->type) {
115 case SMB_ACL_USER:
116 dbgtext( "SMB_ACL_USER ");
117 break;
118 case SMB_ACL_USER_OBJ:
119 dbgtext( "SMB_ACL_USER_OBJ ");
120 break;
121 case SMB_ACL_GROUP:
122 dbgtext( "SMB_ACL_GROUP ");
123 break;
124 case SMB_ACL_GROUP_OBJ:
125 dbgtext( "SMB_ACL_GROUP_OBJ ");
126 break;
127 case SMB_ACL_OTHER:
128 dbgtext( "SMB_ACL_OTHER ");
129 break;
130 }
131 dbgtext( "perms ");
132 dbgtext( "%c", pace->perms & S_IRUSR ? 'r' : '-');
133 dbgtext( "%c", pace->perms & S_IWUSR ? 'w' : '-');
134 dbgtext( "%c\n", pace->perms & S_IXUSR ? 'x' : '-');
135 }
136
137 /****************************************************************************
138 Print out a canon ace list.
139 ****************************************************************************/
140
141 static void print_canon_ace_list(const char *name, canon_ace *ace_list)
142 {
143 int count = 0;
144
145 if( DEBUGLVL( 10 )) {
146 dbgtext( "print_canon_ace_list: %s\n", name );
147 for (;ace_list; ace_list = ace_list->next, count++)
148 print_canon_ace(ace_list, count );
149 }
150 }
151
152 /****************************************************************************
153 Map POSIX ACL perms to canon_ace permissions (a mode_t containing only S_(R|W|X)USR bits).
154 ****************************************************************************/
155
156 static mode_t convert_permset_to_mode_t(connection_struct *conn, SMB_ACL_PERMSET_T permset)
157 {
158 mode_t ret = 0;
159
160 ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_READ) ? S_IRUSR : 0);
161 ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_WRITE) ? S_IWUSR : 0);
162 ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_EXECUTE) ? S_IXUSR : 0);
163
164 return ret;
165 }
166
167 /****************************************************************************
168 Map generic UNIX permissions to canon_ace permissions (a mode_t containing only S_(R|W|X)USR bits).
169 ****************************************************************************/
170
171 static mode_t unix_perms_to_acl_perms(mode_t mode, int r_mask, int w_mask, int x_mask)
172 {
173 mode_t ret = 0;
174
175 if (mode & r_mask)
176 ret |= S_IRUSR;
177 if (mode & w_mask)
178 ret |= S_IWUSR;
179 if (mode & x_mask)
180 ret |= S_IXUSR;
181
182 return ret;
183 }
184
185 /****************************************************************************
186 Map canon_ace permissions (a mode_t containing only S_(R|W|X)USR bits) to
187 an SMB_ACL_PERMSET_T.
188 ****************************************************************************/
189
190 static int map_acl_perms_to_permset(connection_struct *conn, mode_t mode, SMB_ACL_PERMSET_T *p_permset)
191 {
192 if (conn->vfs_ops.sys_acl_clear_perms(conn, *p_permset) == -1)
193 return -1;
194 if (mode & S_IRUSR) {
195 if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_READ) == -1)
196 return -1;
197 }
198 if (mode & S_IWUSR) {
199 if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_WRITE) == -1)
200 return -1;
201 }
202 if (mode & S_IXUSR) {
203 if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_EXECUTE) == -1)
204 return -1;
205 }
206 return 0;
207 }
208 /****************************************************************************
209 Function to create owner and group SIDs from a SMB_STRUCT_STAT.
210 ****************************************************************************/
211
212 static void create_file_sids(SMB_STRUCT_STAT *psbuf, DOM_SID *powner_sid, DOM_SID *pgroup_sid)
213 {
214 uid_to_sid( powner_sid, psbuf->st_uid );
215 gid_to_sid( pgroup_sid, psbuf->st_gid );
216 }
217
218 /****************************************************************************
219 Merge aces with a common sid - if both are allow or deny, OR the permissions together and
220 delete the second one. If the first is deny, mask the permissions off and delete the allow
221 if the permissions become zero, delete the deny if the permissions are non zero.
222 ****************************************************************************/
223
224 static void merge_aces( canon_ace **pp_list_head )
225 {
226 canon_ace *list_head = *pp_list_head;
227 canon_ace *curr_ace_outer;
228 canon_ace *curr_ace_outer_next;
229
230 /*
231 * First, merge allow entries with identical SIDs, and deny entries
232 * with identical SIDs.
233 */
234
235 for (curr_ace_outer = list_head; curr_ace_outer; curr_ace_outer = curr_ace_outer_next) {
236 canon_ace *curr_ace;
237 canon_ace *curr_ace_next;
238
239 curr_ace_outer_next = curr_ace_outer->next; /* Save the link in case we delete. */
240
241 for (curr_ace = curr_ace_outer->next; curr_ace; curr_ace = curr_ace_next) {
242
243 curr_ace_next = curr_ace->next; /* Save the link in case of delete. */
244
245 if (sid_equal(&curr_ace->trustee, &curr_ace_outer->trustee) &&
246 (curr_ace->attr == curr_ace_outer->attr)) {
247
248 if( DEBUGLVL( 10 )) {
249 dbgtext("merge_aces: Merging ACE's\n");
250 print_canon_ace( curr_ace_outer, 0);
251 print_canon_ace( curr_ace, 0);
252 }
253
254 /* Merge two allow or two deny ACE's. */
255
256 curr_ace_outer->perms |= curr_ace->perms;
257 DLIST_REMOVE(list_head, curr_ace);
258 SAFE_FREE(curr_ace);
259 curr_ace_outer_next = curr_ace_outer->next; /* We may have deleted the link. */
260 }
261 }
262 }
263
264 /*
265 * Now go through and mask off allow permissions with deny permissions.
266 * We can delete either the allow or deny here as we know that each SID
267 * appears only once in the list.
268 */
269
270 for (curr_ace_outer = list_head; curr_ace_outer; curr_ace_outer = curr_ace_outer_next) {
271 canon_ace *curr_ace;
272 canon_ace *curr_ace_next;
273
274 curr_ace_outer_next = curr_ace_outer->next; /* Save the link in case we delete. */
275
276 for (curr_ace = curr_ace_outer->next; curr_ace; curr_ace = curr_ace_next) {
277
278 curr_ace_next = curr_ace->next; /* Save the link in case of delete. */
279
280 /*
281 * Subtract ACE's with different entries. Due to the ordering constraints
282 * we've put on the ACL, we know the deny must be the first one.
283 */
284
285 if (sid_equal(&curr_ace->trustee, &curr_ace_outer->trustee) &&
286 (curr_ace_outer->attr == DENY_ACE) && (curr_ace->attr == ALLOW_ACE)) {
287
288 if( DEBUGLVL( 10 )) {
289 dbgtext("merge_aces: Masking ACE's\n");
290 print_canon_ace( curr_ace_outer, 0);
291 print_canon_ace( curr_ace, 0);
292 }
293
294 curr_ace->perms &= ~curr_ace_outer->perms;
295
296 if (curr_ace->perms == 0) {
297
298 /*
299 * The deny overrides the allow. Remove the allow.
300 */
301
302 DLIST_REMOVE(list_head, curr_ace);
303 SAFE_FREE(curr_ace);
304 curr_ace_outer_next = curr_ace_outer->next; /* We may have deleted the link. */
305
306 } else {
307
308 /*
309 * Even after removing permissions, there
310 * are still allow permissions - delete the deny.
311 * It is safe to delete the deny here,
312 * as we are guarenteed by the deny first
313 * ordering that all the deny entries for
314 * this SID have already been merged into one
315 * before we can get to an allow ace.
316 */
317
318 DLIST_REMOVE(list_head, curr_ace_outer);
319 SAFE_FREE(curr_ace_outer);
320 break;
321 }
322 }
323
324 } /* end for curr_ace */
325 } /* end for curr_ace_outer */
326
327 /* We may have modified the list. */
328
329 *pp_list_head = list_head;
330 }
331
332 /****************************************************************************
333 Map canon_ace perms to permission bits NT.
334 The attr element is not used here - we only process deny entries on set,
335 not get. Deny entries are implicit on get with ace->perms = 0.
336 ****************************************************************************/
337
338 static SEC_ACCESS map_canon_ace_perms(int *pacl_type, DOM_SID *powner_sid, canon_ace *ace)
339 {
340 SEC_ACCESS sa;
341 uint32 nt_mask = 0;
342
343 *pacl_type = SEC_ACE_TYPE_ACCESS_ALLOWED;
344
345 if ((ace->perms & ALL_ACE_PERMS) == ALL_ACE_PERMS) {
346 nt_mask = UNIX_ACCESS_RWX;
347 } else if ((ace->perms & ALL_ACE_PERMS) == (mode_t)0) {
348 nt_mask = UNIX_ACCESS_NONE;
349 } else {
350 nt_mask |= ((ace->perms & S_IRUSR) ? UNIX_ACCESS_R : 0 );
351 nt_mask |= ((ace->perms & S_IWUSR) ? UNIX_ACCESS_W : 0 );
352 nt_mask |= ((ace->perms & S_IXUSR) ? UNIX_ACCESS_X : 0 );
353 }
354
355 DEBUG(10,("map_canon_ace_perms: Mapped (UNIX) %x to (NT) %x\n",
356 (unsigned int)ace->perms, (unsigned int)nt_mask ));
357
358 init_sec_access(&sa,nt_mask);
359 return sa;
360 }
361
362 /****************************************************************************
363 Map NT perms to a UNIX mode_t.
364 ****************************************************************************/
365
366 #define FILE_SPECIFIC_READ_BITS (FILE_READ_DATA|FILE_READ_EA|FILE_READ_ATTRIBUTES)
367 #define FILE_SPECIFIC_WRITE_BITS (FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_WRITE_EA|FILE_WRITE_ATTRIBUTES)
368 #define FILE_SPECIFIC_EXECUTE_BITS (FILE_EXECUTE)
369
370 static mode_t map_nt_perms( SEC_ACCESS sec_access, int type)
371 {
372 mode_t mode = 0;
373
374 switch(type) {
375 case S_IRUSR:
376 if(sec_access.mask & GENERIC_ALL_ACCESS)
377 mode = S_IRUSR|S_IWUSR|S_IXUSR;
378 else {
379 mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IRUSR : 0;
380 mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWUSR : 0;
381 mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXUSR : 0;
382 }
383 break;
384 case S_IRGRP:
385 if(sec_access.mask & GENERIC_ALL_ACCESS)
386 mode = S_IRGRP|S_IWGRP|S_IXGRP;
387 else {
388 mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IRGRP : 0;
389 mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWGRP : 0;
390 mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXGRP : 0;
391 }
392 break;
393 case S_IROTH:
394 if(sec_access.mask & GENERIC_ALL_ACCESS)
395 mode = S_IROTH|S_IWOTH|S_IXOTH;
396 else {
397 mode |= (sec_access.mask & (GENERIC_READ_ACCESS|FILE_SPECIFIC_READ_BITS)) ? S_IROTH : 0;
398 mode |= (sec_access.mask & (GENERIC_WRITE_ACCESS|FILE_SPECIFIC_WRITE_BITS)) ? S_IWOTH : 0;
399 mode |= (sec_access.mask & (GENERIC_EXECUTE_ACCESS|FILE_SPECIFIC_EXECUTE_BITS)) ? S_IXOTH : 0;
400 }
401 break;
402 }
403
404 return mode;
405 }
406
407 /****************************************************************************
408 Unpack a SEC_DESC into a UNIX owner and group.
409 ****************************************************************************/
410
411 static BOOL unpack_nt_owners(SMB_STRUCT_STAT *psbuf, uid_t *puser, gid_t *pgrp, uint32 security_info_sent, SEC_DESC *psd)
412 {
413 DOM_SID owner_sid;
414 DOM_SID grp_sid;
415 enum SID_NAME_USE sid_type;
416
417 *puser = (uid_t)-1;
418 *pgrp = (gid_t)-1;
419
420 if(security_info_sent == 0) {
421 DEBUG(0,("unpack_nt_owners: no security info sent !\n"));
422 return True;
423 }
424
425 /*
426 * Validate the owner and group SID's.
427 */
428
429 memset(&owner_sid, '\0', sizeof(owner_sid));
430 memset(&grp_sid, '\0', sizeof(grp_sid));
431
432 DEBUG(5,("unpack_nt_owners: validating owner_sids.\n"));
433
434 /*
435 * Don't immediately fail if the owner sid cannot be validated.
436 * This may be a group chown only set.
437 */
438
439 if (security_info_sent & OWNER_SECURITY_INFORMATION) {
440 sid_copy(&owner_sid, psd->owner_sid);
441 if (!sid_to_uid( &owner_sid, puser, &sid_type)) {
442 #if ACL_FORCE_UNMAPPABLE
443 /* this allows take ownership to work reasonably */
444 extern struct current_user current_user;
445 *puser = current_user.uid;
446 #else
447 DEBUG(3,("unpack_nt_owners: unable to validate owner sid for %s\n",
448 sid_string_static(&owner_sid)));
449 return False;
450 #endif
451 }
452 }
453
454 /*
455 * Don't immediately fail if the group sid cannot be validated.
456 * This may be an owner chown only set.
457 */
458
459 if (security_info_sent & GROUP_SECURITY_INFORMATION) {
460 sid_copy(&grp_sid, psd->grp_sid);
461 if (!sid_to_gid( &grp_sid, pgrp, &sid_type)) {
462 #if ACL_FORCE_UNMAPPABLE
463 /* this allows take group ownership to work reasonably */
464 extern struct current_user current_user;
465 *pgrp = current_user.gid;
466 #else
467 DEBUG(3,("unpack_nt_owners: unable to validate group sid.\n"));
468 return False;
469 #endif
470 }
471 }
472
473 DEBUG(5,("unpack_nt_owners: owner_sids validated.\n"));
474
475 return True;
476 }
477
478 /****************************************************************************
479 Ensure the enforced permissions for this share apply.
480 ****************************************************************************/
481
482 static void apply_default_perms(files_struct *fsp, canon_ace *pace, mode_t type)
483 {
484 int snum = SNUM(fsp->conn);
485 mode_t and_bits = (mode_t)0;
486 mode_t or_bits = (mode_t)0;
487
488 /* Get the initial bits to apply. */
489
490 if (fsp->is_directory) {
491 and_bits = lp_dir_security_mask(snum);
492 or_bits = lp_force_dir_security_mode(snum);
493 } else {
494 and_bits = lp_security_mask(snum);
495 or_bits = lp_force_security_mode(snum);
496 }
497
498 /* Now bounce them into the S_USR space. */
499 switch(type) {
500 case S_IRUSR:
501 /* Ensure owner has read access. */
502 pace->perms |= S_IRUSR;
503 if (fsp->is_directory)
504 pace->perms |= (S_IWUSR|S_IXUSR);
505 and_bits = unix_perms_to_acl_perms(and_bits, S_IRUSR, S_IWUSR, S_IXUSR);
506 or_bits = unix_perms_to_acl_perms(or_bits, S_IRUSR, S_IWUSR, S_IXUSR);
507 break;
508 case S_IRGRP:
509 and_bits = unix_perms_to_acl_perms(and_bits, S_IRGRP, S_IWGRP, S_IXGRP);
510 or_bits = unix_perms_to_acl_perms(or_bits, S_IRGRP, S_IWGRP, S_IXGRP);
511 break;
512 case S_IROTH:
513 and_bits = unix_perms_to_acl_perms(and_bits, S_IROTH, S_IWOTH, S_IXOTH);
514 or_bits = unix_perms_to_acl_perms(or_bits, S_IROTH, S_IWOTH, S_IXOTH);
515 break;
516 }
517
518 pace->perms = ((pace->perms & and_bits)|or_bits);
519 }
520
521 /****************************************************************************
522 Check if a given uid/SID is in a group gid/SID. This is probably very
523 expensive and will need optimisation. A *lot* of optimisation :-). JRA.
524 ****************************************************************************/
525
526 static BOOL uid_entry_in_group( canon_ace *uid_ace, canon_ace *group_ace )
527 {
528 extern DOM_SID global_sid_World;
529 fstring u_name;
530 fstring g_name;
531
532 /* "Everyone" always matches every uid. */
533
534 if (sid_equal(&group_ace->trustee, &global_sid_World))
535 return True;
536
537 fstrcpy(u_name, uidtoname(uid_ace->unix_ug.uid));
538 fstrcpy(g_name, gidtoname(group_ace->unix_ug.gid));
539
540 /*
541 * Due to the winbind interfaces we need to do this via names,
542 * not uids/gids.
543 */
544
545 return user_in_group_list(u_name, g_name );
546 }
547
548 /****************************************************************************
549 A well formed POSIX file or default ACL has at least 3 entries, a
550 SMB_ACL_USER_OBJ, SMB_ACL_GROUP_OBJ, SMB_ACL_OTHER_OBJ.
551 In addition, the owner must always have at least read access.
552 When using this call on get_acl, the pst struct is valid and contains
553 the mode of the file. When using this call on set_acl, the pst struct has
554 been modified to have a mode containing the default for this file or directory
555 type.
556 ****************************************************************************/
557
558 static BOOL ensure_canon_entry_valid(canon_ace **pp_ace,
559 files_struct *fsp,
560 DOM_SID *pfile_owner_sid,
561 DOM_SID *pfile_grp_sid,
562 SMB_STRUCT_STAT *pst,
563 BOOL setting_acl)
564 {
565 extern DOM_SID global_sid_World;
566 canon_ace *pace;
567 BOOL got_user = False;
568 BOOL got_grp = False;
569 BOOL got_other = False;
570 canon_ace *pace_other = NULL;
571 canon_ace *pace_group = NULL;
572
573 for (pace = *pp_ace; pace; pace = pace->next) {
574 if (pace->type == SMB_ACL_USER_OBJ) {
575
576 if (setting_acl)
577 apply_default_perms(fsp, pace, S_IRUSR);
578 got_user = True;
579
580 } else if (pace->type == SMB_ACL_GROUP_OBJ) {
581
582 /*
583 * Ensure create mask/force create mode is respected on set.
584 */
585
586 if (setting_acl)
587 apply_default_perms(fsp, pace, S_IRGRP);
588 got_grp = True;
589 pace_group = pace;
590
591 } else if (pace->type == SMB_ACL_OTHER) {
592
593 /*
594 * Ensure create mask/force create mode is respected on set.
595 */
596
597 if (setting_acl)
598 apply_default_perms(fsp, pace, S_IROTH);
599 got_other = True;
600 pace_other = pace;
601 }
602 }
603
604 if (!got_user) {
605 if ((pace = (canon_ace *)malloc(sizeof(canon_ace))) == NULL) {
606 DEBUG(0,("ensure_canon_entry_valid: malloc fail.\n"));
607 return False;
608 }
609
610 ZERO_STRUCTP(pace);
611 pace->type = SMB_ACL_USER_OBJ;
612 pace->owner_type = UID_ACE;
613 pace->unix_ug.uid = pst->st_uid;
614 pace->trustee = *pfile_owner_sid;
615 pace->attr = ALLOW_ACE;
616
617 if (setting_acl) {
618 /* If we only got an "everyone" perm, just use that. */
619 if (!got_grp && got_other)
620 pace->perms = pace_other->perms;
621 else if (got_grp && uid_entry_in_group(pace, pace_group))
622 pace->perms = pace_group->perms;
623 else
624 pace->perms = unix_perms_to_acl_perms(pst->st_mode, S_IRUSR, S_IWUSR, S_IXUSR);
625 apply_default_perms(fsp, pace, S_IRUSR);
626 } else {
627 pace->perms = unix_perms_to_acl_perms(pst->st_mode, S_IRUSR, S_IWUSR, S_IXUSR);
628 }
629
630 DLIST_ADD(*pp_ace, pace);
631 }
632
633 if (!got_grp) {
634 if ((pace = (canon_ace *)malloc(sizeof(canon_ace))) == NULL) {
635 DEBUG(0,("ensure_canon_entry_valid: malloc fail.\n"));
636 return False;
637 }
638
639 ZERO_STRUCTP(pace);
640 pace->type = SMB_ACL_GROUP_OBJ;
641 pace->owner_type = GID_ACE;
642 pace->unix_ug.uid = pst->st_gid;
643 pace->trustee = *pfile_grp_sid;
644 pace->attr = ALLOW_ACE;
645 if (setting_acl) {
646 /* If we only got an "everyone" perm, just use that. */
647 if (got_other)
648 pace->perms = pace_other->perms;
649 else
650 pace->perms = unix_perms_to_acl_perms(pst->st_mode, S_IRGRP, S_IWGRP, S_IXGRP);
651 apply_default_perms(fsp, pace, S_IRGRP);
652 } else {
653 pace->perms = unix_perms_to_acl_perms(pst->st_mode, S_IRGRP, S_IWGRP, S_IXGRP);
654 }
655
656 DLIST_ADD(*pp_ace, pace);
657 }
658
659 if (!got_other) {
660 if ((pace = (canon_ace *)malloc(sizeof(canon_ace))) == NULL) {
661 DEBUG(0,("ensure_canon_entry_valid: malloc fail.\n"));
662 return False;
663 }
664
665 ZERO_STRUCTP(pace);
666 pace->type = SMB_ACL_OTHER;
667 pace->owner_type = WORLD_ACE;
668 pace->unix_ug.world = -1;
669 pace->trustee = global_sid_World;
670 pace->attr = ALLOW_ACE;
671 pace->perms = unix_perms_to_acl_perms(pst->st_mode, S_IROTH, S_IWOTH, S_IXOTH);
672 apply_default_perms(fsp, pace, S_IROTH);
673
674 DLIST_ADD(*pp_ace, pace);
675 }
676
677 return True;
678 }
679
680 /****************************************************************************
681 Unpack a SEC_DESC into two canonical ace lists.
682 ****************************************************************************/
683
684 static BOOL create_canon_ace_lists(files_struct *fsp,
685 DOM_SID *pfile_owner_sid,
686 DOM_SID *pfile_grp_sid,
687 canon_ace **ppfile_ace, canon_ace **ppdir_ace,
688 SEC_ACL *dacl)
689 {
690 extern DOM_SID global_sid_World;
691 extern struct generic_mapping file_generic_mapping;
692 BOOL all_aces_are_inherit_only = (fsp->is_directory ? True : False);
693 canon_ace *file_ace = NULL;
694 canon_ace *dir_ace = NULL;
695 canon_ace *tmp_ace = NULL;
696 canon_ace *current_ace = NULL;
697 BOOL got_dir_allow = False;
698 BOOL got_file_allow = False;
699 int i, j;
700
701 *ppfile_ace = NULL;
702 *ppdir_ace = NULL;
703
704 /*
705 * Convert the incoming ACL into a more regular form.
706 */
707
708 for(i = 0; i < dacl->num_aces; i++) {
709 SEC_ACE *psa = &dacl->ace[i];
710
711 if((psa->type != SEC_ACE_TYPE_ACCESS_ALLOWED) && (psa->type != SEC_ACE_TYPE_ACCESS_DENIED)) {
712 DEBUG(3,("create_canon_ace_lists: unable to set anything but an ALLOW or DENY ACE.\n"));
713 return False;
714 }
715
716 /*
717 * The security mask may be UNIX_ACCESS_NONE which should map into
718 * no permissions (we overload the WRITE_OWNER bit for this) or it
719 * should be one of the ALL/EXECUTE/READ/WRITE bits. Arrange for this
720 * to be so. Any other bits override the UNIX_ACCESS_NONE bit.
721 */
722
723 /*
724 * Convert GENERIC bits to specific bits.
725 */
726
727 se_map_generic(&psa->info.mask, &file_generic_mapping);
728
729 psa->info.mask &= (UNIX_ACCESS_NONE|FILE_ALL_ACCESS);
730
731 if(psa->info.mask != UNIX_ACCESS_NONE)
732 psa->info.mask &= ~UNIX_ACCESS_NONE;
733 }
734
735 /*
736 * Deal with the fact that NT 4.x re-writes the canonical format
737 * that we return for default ACLs. If a directory ACE is identical
738 * to a inherited directory ACE then NT changes the bits so that the
739 * first ACE is set to OI|IO and the second ACE for this SID is set
740 * to CI. We need to repair this. JRA.
741 */
742
743 for(i = 0; i < dacl->num_aces; i++) {
744 SEC_ACE *psa1 = &dacl->ace[i];
745
746 for (j = i + 1; j < dacl->num_aces; j++) {
747 SEC_ACE *psa2 = &dacl->ace[j];
748
749 if (psa1->info.mask != psa2->info.mask)
750 continue;
751
752 if (!sid_equal(&psa1->trustee, &psa2->trustee))
753 continue;
754
755 /*
756 * Ok - permission bits and SIDs are equal.
757 * Check if flags were re-written.
758 */
759
760 if (psa1->flags & SEC_ACE_FLAG_INHERIT_ONLY) {
761
762 psa1->flags |= (psa2->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT));
763 psa2->flags &= ~(SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT);
764
765 } else if (psa2->flags & SEC_ACE_FLAG_INHERIT_ONLY) {
766
767 psa2->flags |= (psa1->flags & (SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT));
768 psa1->flags &= ~(SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_OBJECT_INHERIT);
769
770 }
771 }
772 }
773
774 for(i = 0; i < dacl->num_aces; i++) {
775 enum SID_NAME_USE sid_type;
776 SEC_ACE *psa = &dacl->ace[i];
777
778 /*
779 * Ignore non-mappable SIDs (NT Authority, BUILTIN etc).
780 */
781
782 if (non_mappable_sid(&psa->trustee)) {
783 fstring str;
784 DEBUG(10,("create_canon_ace_lists: ignoring non-mappable SID %s\n",
785 sid_to_string(str, &psa->trustee) ));
786 continue;
787 }
788
789 /*
790 * Create a cannon_ace entry representing this NT DACL ACE.
791 */
792
793 if ((current_ace = (canon_ace *)malloc(sizeof(canon_ace))) == NULL) {
794 free_canon_ace_list(file_ace);
795 free_canon_ace_list(dir_ace);
796 DEBUG(0,("create_canon_ace_lists: malloc fail.\n"));
797 return False;
798 }
799
800 ZERO_STRUCTP(current_ace);
801
802 sid_copy(&current_ace->trustee, &psa->trustee);
803
804 /*
805 * Try and work out if the SID is a user or group
806 * as we need to flag these differently for POSIX.
807 */
808
809 if( sid_equal(&current_ace->trustee, &global_sid_World)) {
810 current_ace->owner_type = WORLD_ACE;
811 current_ace->unix_ug.world = -1;
812 } else if (sid_to_uid( &current_ace->trustee, &current_ace->unix_ug.uid, &sid_type)) {
813 current_ace->owner_type = UID_ACE;
814 } else if (sid_to_gid( &current_ace->trustee, &current_ace->unix_ug.gid, &sid_type)) {
815 current_ace->owner_type = GID_ACE;
816 } else {
817 fstring str;
818
819 free_canon_ace_list(file_ace);
820 free_canon_ace_list(dir_ace);
821 DEBUG(0,("create_canon_ace_lists: unable to map SID %s to uid or gid.\n",
822 sid_to_string(str, &current_ace->trustee) ));
823 SAFE_FREE(current_ace);
824 return False;
825 }
826
827 /*
828 * Map the given NT permissions into a UNIX mode_t containing only
829 * S_I(R|W|X)USR bits.
830 */
831
832 current_ace->perms |= map_nt_perms( psa->info, S_IRUSR);
833 current_ace->attr = (psa->type == SEC_ACE_TYPE_ACCESS_ALLOWED) ? ALLOW_ACE : DENY_ACE;
834
835 /*
836 * Now note what kind of a POSIX ACL this should map to.
837 */
838
839 if(sid_equal(&current_ace->trustee, pfile_owner_sid)) {
840
841 current_ace->type = SMB_ACL_USER_OBJ;
842
843 } else if( sid_equal(&current_ace->trustee, pfile_grp_sid)) {
844
845 current_ace->type = SMB_ACL_GROUP_OBJ;
846
847 } else if( sid_equal(&current_ace->trustee, &global_sid_World)) {
848
849 current_ace->type = SMB_ACL_OTHER;
850
851 } else {
852 /*
853 * Could be a SMB_ACL_USER or SMB_ACL_GROUP. Check by
854 * looking at owner_type.
855 */
856
857 current_ace->type = (current_ace->owner_type == UID_ACE) ? SMB_ACL_USER : SMB_ACL_GROUP;
858 }
859
860 /*
861 * Now add the created ace to either the file list, the directory
862 * list, or both. We *MUST* preserve the order here (hence we use
863 * DLIST_ADD_END) as NT ACLs are order dependent.
864 */
865
866 if (fsp->is_directory) {
867
868 /*
869 * We can only add to the default POSIX ACE list if the ACE is
870 * designed to be inherited by both files and directories.
871 */
872
873 if ((psa->flags & (SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT)) ==
874 (SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT)) {
875
876 DLIST_ADD_END(dir_ace, current_ace, tmp_ace);
877
878 /*
879 * Note if this was an allow ace. We can't process
880 * any further deny ace's after this.
881 */
882
883 if (current_ace->attr == ALLOW_ACE)
884 got_dir_allow = True;
885
886 if ((current_ace->attr == DENY_ACE) && got_dir_allow) {
887 DEBUG(0,("create_canon_ace_lists: malformed ACL in inheritable ACL ! \
888 Deny entry after Allow entry. Failing to set on file %s.\n", fsp->fsp_name ));
889 free_canon_ace_list(file_ace);
890 free_canon_ace_list(dir_ace);
891 SAFE_FREE(current_ace);
892 return False;
893 }
894
895 if( DEBUGLVL( 10 )) {
896 dbgtext("create_canon_ace_lists: adding dir ACL:\n");
897 print_canon_ace( current_ace, 0);
898 }
899
900 /*
901 * If this is not an inherit only ACE we need to add a duplicate
902 * to the file acl.
903 */
904
905 if (!(psa->flags & SEC_ACE_FLAG_INHERIT_ONLY)) {
906 canon_ace *dup_ace = dup_canon_ace(current_ace);
907
908 if (!dup_ace) {
909 DEBUG(0,("create_canon_ace_lists: malloc fail !\n"));
910 free_canon_ace_list(file_ace);
911 free_canon_ace_list(dir_ace);
912 return False;
913 }
914
915 current_ace = dup_ace;
916 } else {
917 current_ace = NULL;
918 }
919 }
920 }
921
922 /*
923 * Only add to the file ACL if not inherit only.
924 */
925
926 if (!(psa->flags & SEC_ACE_FLAG_INHERIT_ONLY)) {
927 DLIST_ADD_END(file_ace, current_ace, tmp_ace);
928
929 /*
930 * Note if this was an allow ace. We can't process
931 * any further deny ace's after this.
932 */
933
934 if (current_ace->attr == ALLOW_ACE)
935 got_file_allow = True;
936
937 if ((current_ace->attr == DENY_ACE) && got_file_allow) {
938 DEBUG(0,("create_canon_ace_lists: malformed ACL in file ACL ! \
939 Deny entry after Allow entry. Failing to set on file %s.\n", fsp->fsp_name ));
940 free_canon_ace_list(file_ace);
941 free_canon_ace_list(dir_ace);
942 SAFE_FREE(current_ace);
943 return False;
944 }
945
946 if( DEBUGLVL( 10 )) {
947 dbgtext("create_canon_ace_lists: adding file ACL:\n");
948 print_canon_ace( current_ace, 0);
949 }
950 all_aces_are_inherit_only = False;
951 current_ace = NULL;
952 }
953
954 /*
955 * Free if ACE was not added.
956 */
957
958 SAFE_FREE(current_ace);
959 }
960
961 if (fsp->is_directory && all_aces_are_inherit_only) {
962 /*
963 * Windows 2000 is doing one of these weird 'inherit acl'
964 * traverses to conserve NTFS ACL resources. Just pretend
965 * there was no DACL sent. JRA.
966 */
967
968 DEBUG(10,("create_canon_ace_lists: Win2k inherit acl traverse. Ignoring DACL.\n"));
969 free_canon_ace_list(file_ace);
970 free_canon_ace_list(dir_ace);
971 file_ace = NULL;
972 dir_ace = NULL;
973 }
974
975 *ppfile_ace = file_ace;
976 *ppdir_ace = dir_ace;
977
978 return True;
979 }
980
981 /****************************************************************************
982 ASCII art time again... JRA :-).
983
984 We have 3 cases to process when moving from an NT ACL to a POSIX ACL. Firstly,
985 we insist the ACL is in canonical form (ie. all DENY entries preceede ALLOW
986 entries). Secondly, the merge code has ensured that all duplicate SID entries for
987 allow or deny have been merged, so the same SID can only appear once in the deny
988 list or once in the allow list.
989
990 We then process as follows :
991
992 ---------------------------------------------------------------------------
993 First pass - look for a Everyone DENY entry.
994
995 If it is deny all (rwx) trunate the list at this point.
996 Else, walk the list from this point and use the deny permissions of this
997 entry as a mask on all following allow entries. Finally, delete
998 the Everyone DENY entry (we have applied it to everything possible).
999
1000 In addition, in this pass we remove any DENY entries that have
1001 no permissions (ie. they are a DENY nothing).
1002 ---------------------------------------------------------------------------
1003 Second pass - only deal with deny user entries.
1004
1005 DENY user1 (perms XXX)
1006
1007 new_perms = 0
1008 for all following allow group entries where user1 is in group
1009 new_perms |= group_perms;
1010
1011 user1 entry perms = new_perms & ~ XXX;
1012
1013 Convert the deny entry to an allow entry with the new perms and
1014 push to the end of the list. Note if the user was in no groups
1015 this maps to a specific allow nothing entry for this user.
1016
1017 The common case from the NT ACL choser (userX deny all) is
1018 optimised so we don't do the group lookup - we just map to
1019 an allow nothing entry.
1020
1021 What we're doing here is inferring the allow permissions the
1022 person setting the ACE on user1 wanted by looking at the allow
1023 permissions on the groups the user is currently in. This will
1024 be a snapshot, depending on group membership but is the best
1025 we can do and has the advantage of failing closed rather than
1026 open.
1027 ---------------------------------------------------------------------------
1028 Third pass - only deal with deny group entries.
1029
1030 DENY group1 (perms XXX)
1031
1032 for all following allow user entries where user is in group1
1033 user entry perms = user entry perms & ~ XXX;
1034
1035 If there is a group Everyone allow entry with permissions YYY,
1036 convert the group1 entry to an allow entry and modify its
1037 permissions to be :
1038
1039 new_perms = YYY & ~ XXX
1040
1041 and push to the end of the list.
1042
1043 If there is no group Everyone allow entry then convert the
1044 group1 entry to a allow nothing entry and push to the end of the list.
1045
1046 Note that the common case from the NT ACL choser (groupX deny all)
1047 cannot be optimised here as we need to modify user entries who are
1048 in the group to change them to a deny all also.
1049
1050 What we're doing here is modifying the allow permissions of
1051 user entries (which are more specific in POSIX ACLs) to mask
1052 out the explicit deny set on the group they are in. This will
1053 be a snapshot depending on current group membership but is the
1054 best we can do and has the advantage of failing closed rather
1055 than open.
1056 ---------------------------------------------------------------------------
1057
1058 Note we *MUST* do the deny user pass first as this will convert deny user
1059 entries into allow user entries which can then be processed by the deny
1060 group pass.
1061
1062 The above algorithm took a *lot* of thinking about - hence this
1063 explaination :-). JRA.
1064 ****************************************************************************/
1065
1066 /****************************************************************************
1067 Process a canon_ace list entries. This is very complex code. We need
1068 to go through and remove the "deny" permissions from any allow entry that matches
1069 the id of this entry. We have already refused any NT ACL that wasn't in correct
1070 order (DENY followed by ALLOW). If any allow entry ends up with zero permissions,
1071 we just remove it (to fail safe). We have already removed any duplicate ace
1072 entries. Treat an "Everyone" DENY_ACE as a special case - use it to mask all
1073 allow entries.
1074 ****************************************************************************/
1075
1076 static void process_deny_list( canon_ace **pp_ace_list )
1077 {
1078 extern DOM_SID global_sid_World;
1079 canon_ace *ace_list = *pp_ace_list;
1080 canon_ace *curr_ace = NULL;
1081 canon_ace *curr_ace_next = NULL;
1082
1083 /* Pass 1 above - look for an Everyone, deny entry. */
1084
1085 for (curr_ace = ace_list; curr_ace; curr_ace = curr_ace_next) {
1086 canon_ace *allow_ace_p;
1087
1088 curr_ace_next = curr_ace->next; /* So we can't lose the link. */
1089
1090 if (curr_ace->attr != DENY_ACE)
1091 continue;
1092
1093 if (curr_ace->perms == (mode_t)0) {
1094
1095 /* Deny nothing entry - delete. */
1096
1097 DLIST_REMOVE(ace_list, curr_ace);
1098 continue;
1099 }
1100
1101 if (!sid_equal(&curr_ace->trustee, &global_sid_World))
1102 continue;
1103
1104 /* JRATEST - assert. */
1105 SMB_ASSERT(curr_ace->owner_type == WORLD_ACE);
1106
1107 if (curr_ace->perms == ALL_ACE_PERMS) {
1108
1109 /*
1110 * Optimisation. This is a DENY_ALL to Everyone. Truncate the
1111 * list at this point including this entry.
1112 */
1113
1114 canon_ace *prev_entry = curr_ace->prev;
1115
1116 free_canon_ace_list( curr_ace );
1117 if (prev_entry)
1118 prev_entry->next = NULL;
1119 else {
1120 /* We deleted the entire list. */
1121 ace_list = NULL;
1122 }
1123 break;
1124 }
1125
1126 for (allow_ace_p = curr_ace->next; allow_ace_p; allow_ace_p = allow_ace_p->next) {
1127
1128 /*
1129 * Only mask off allow entries.
1130 */
1131
1132 if (allow_ace_p->attr != ALLOW_ACE)
1133 continue;
1134
1135 allow_ace_p->perms &= ~curr_ace->perms;
1136 }
1137
1138 /*
1139 * Now it's been applied, remove it.
1140 */
1141
1142 DLIST_REMOVE(ace_list, curr_ace);
1143 }
1144
1145 /* Pass 2 above - deal with deny user entries. */
1146
1147 for (curr_ace = ace_list; curr_ace; curr_ace = curr_ace_next) {
1148 mode_t new_perms = (mode_t)0;
1149 canon_ace *allow_ace_p;
1150 canon_ace *tmp_ace;
1151
1152 curr_ace_next = curr_ace->next; /* So we can't lose the link. */
1153
1154 if (curr_ace->attr != DENY_ACE)
1155 continue;
1156
1157 if (curr_ace->owner_type != UID_ACE)
1158 continue;
1159
1160 if (curr_ace->perms == ALL_ACE_PERMS) {
1161
1162 /*
1163 * Optimisation - this is a deny everything to this user.
1164 * Convert to an allow nothing and push to the end of the list.
1165 */
1166
1167 curr_ace->attr = ALLOW_ACE;
1168 curr_ace->perms = (mode_t)0;
1169 DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
1170 continue;
1171 }
1172
1173 for (allow_ace_p = curr_ace->next; allow_ace_p; allow_ace_p = allow_ace_p->next) {
1174
1175 if (allow_ace_p->attr != ALLOW_ACE)
1176 continue;
1177
1178 /* We process GID_ACE and WORLD_ACE entries only. */
1179
1180 if (allow_ace_p->owner_type == UID_ACE)
1181 continue;
1182
1183 if (uid_entry_in_group( curr_ace, allow_ace_p))
1184 new_perms |= allow_ace_p->perms;
1185 }
1186
1187 /*
1188 * Convert to a allow entry, modify the perms and push to the end
1189 * of the list.
1190 */
1191
1192 curr_ace->attr = ALLOW_ACE;
1193 curr_ace->perms = (new_perms & ~curr_ace->perms);
1194 DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
1195 }
1196
1197 /* Pass 3 above - deal with deny group entries. */
1198
1199 for (curr_ace = ace_list; curr_ace; curr_ace = curr_ace_next) {
1200 canon_ace *tmp_ace;
1201 canon_ace *allow_ace_p;
1202 canon_ace *allow_everyone_p = NULL;
1203
1204 curr_ace_next = curr_ace->next; /* So we can't lose the link. */
1205
1206 if (curr_ace->attr != DENY_ACE)
1207 continue;
1208
1209 if (curr_ace->owner_type != GID_ACE)
1210 continue;
1211
1212 for (allow_ace_p = curr_ace->next; allow_ace_p; allow_ace_p = allow_ace_p->next) {
1213
1214 if (allow_ace_p->attr != ALLOW_ACE)
1215 continue;
1216
1217 /* Store a pointer to the Everyone allow, if it exists. */
1218 if (allow_ace_p->owner_type == WORLD_ACE)
1219 allow_everyone_p = allow_ace_p;
1220
1221 /* We process UID_ACE entries only. */
1222
1223 if (allow_ace_p->owner_type != UID_ACE)
1224 continue;
1225
1226 /* Mask off the deny group perms. */
1227
1228 if (uid_entry_in_group( allow_ace_p, curr_ace))
1229 allow_ace_p->perms &= ~curr_ace->perms;
1230 }
1231
1232 /*
1233 * Convert the deny to an allow with the correct perms and
1234 * push to the end of the list.
1235 */
1236
1237 curr_ace->attr = ALLOW_ACE;
1238 if (allow_everyone_p)
1239 curr_ace->perms = allow_everyone_p->perms & ~curr_ace->perms;
1240 else
1241 curr_ace->perms = (mode_t)0;
1242 DLIST_DEMOTE(ace_list, curr_ace, tmp_ace);
1243
1244 }
1245
1246 *pp_ace_list = ace_list;
1247 }
1248
1249 /****************************************************************************
1250 Create a default mode that will be used if a security descriptor entry has
1251 no user/group/world entries.
1252 ****************************************************************************/
1253
1254 static mode_t create_default_mode(files_struct *fsp, BOOL interitable_mode)
1255 {
1256 int snum = SNUM(fsp->conn);
1257 mode_t and_bits = (mode_t)0;
1258 mode_t or_bits = (mode_t)0;
1259 mode_t mode = interitable_mode ? unix_mode( fsp->conn, FILE_ATTRIBUTE_ARCHIVE, fsp->fsp_name) : S_IRUSR;
1260
1261 if (fsp->is_directory)
1262 mode |= (S_IWUSR|S_IXUSR);
1263
1264 /*
1265 * Now AND with the create mode/directory mode bits then OR with the
1266 * force create mode/force directory mode bits.
1267 */
1268
1269 if (fsp->is_directory) {
1270 and_bits = lp_dir_security_mask(snum);
1271 or_bits = lp_force_dir_security_mode(snum);
1272 } else {
1273 and_bits = lp_security_mask(snum);
1274 or_bits = lp_force_security_mode(snum);
1275 }
1276
1277 return ((mode & and_bits)|or_bits);
1278 }
1279
1280 /****************************************************************************
1281 Unpack a SEC_DESC into two canonical ace lists. We don't depend on this
1282 succeeding.
1283 ****************************************************************************/
1284
1285 static BOOL unpack_canon_ace(files_struct *fsp,
1286 SMB_STRUCT_STAT *pst,
1287 DOM_SID *pfile_owner_sid,
1288 DOM_SID *pfile_grp_sid,
1289 canon_ace **ppfile_ace, canon_ace **ppdir_ace,
1290 uint32 security_info_sent, SEC_DESC *psd)
1291 {
1292 canon_ace *file_ace = NULL;
1293 canon_ace *dir_ace = NULL;
1294
1295 *ppfile_ace = NULL;
1296 *ppdir_ace = NULL;
1297
1298 if(security_info_sent == 0) {
1299 DEBUG(0,("unpack_canon_ace: no security info sent !\n"));
1300 return False;
1301 }
1302
1303 /*
1304 * If no DACL then this is a chown only security descriptor.
1305 */
1306
1307 if(!(security_info_sent & DACL_SECURITY_INFORMATION) || !psd->dacl)
1308 return True;
1309
1310 /*
1311 * Now go through the DACL and create the canon_ace lists.
1312 */
1313
1314 if (!create_canon_ace_lists( fsp, pfile_owner_sid, pfile_grp_sid,
1315 &file_ace, &dir_ace, psd->dacl))
1316 return False;
1317
1318 if ((file_ace == NULL) && (dir_ace == NULL)) {
1319 /* W2K traverse DACL set - ignore. */
1320 return True;
1321 }
1322
1323 /*
1324 * Go through the canon_ace list and merge entries
1325 * belonging to identical users of identical allow or deny type.
1326 * We can do this as all deny entries come first, followed by
1327 * all allow entries (we have mandated this before accepting this acl).
1328 */
1329
1330 print_canon_ace_list( "file ace - before merge", file_ace);
1331 merge_aces( &file_ace );
1332
1333 print_canon_ace_list( "dir ace - before merge", dir_ace);
1334 merge_aces( &dir_ace );
1335
1336 /*
1337 * NT ACLs are order dependent. Go through the acl lists and
1338 * process DENY entries by masking the allow entries.
1339 */
1340
1341 print_canon_ace_list( "file ace - before deny", file_ace);
1342 process_deny_list( &file_ace);
1343
1344 print_canon_ace_list( "dir ace - before deny", dir_ace);
1345 process_deny_list( &dir_ace);
1346
1347 /*
1348 * A well formed POSIX file or default ACL has at least 3 entries, a
1349 * SMB_ACL_USER_OBJ, SMB_ACL_GROUP_OBJ, SMB_ACL_OTHER_OBJ
1350 * and optionally a mask entry. Ensure this is the case.
1351 */
1352
1353 print_canon_ace_list( "file ace - before valid", file_ace);
1354
1355 /*
1356 * A default 3 element mode entry for a file should be r-- --- ---.
1357 * A default 3 element mode entry for a directory should be rwx --- ---.
1358 */
1359
1360 pst->st_mode = create_default_mode(fsp, False);
1361
1362 if (!ensure_canon_entry_valid(&file_ace, fsp, pfile_owner_sid, pfile_grp_sid, pst, True)) {
1363 free_canon_ace_list(file_ace);
1364 free_canon_ace_list(dir_ace);
1365 return False;
1366 }
1367
1368 print_canon_ace_list( "dir ace - before valid", dir_ace);
1369
1370 /*
1371 * A default inheritable 3 element mode entry for a directory should be the
1372 * mode Samba will use to create a file within. Ensure user rwx bits are set if
1373 * it's a directory.
1374 */
1375
1376 pst->st_mode = create_default_mode(fsp, True);
1377
1378 if (!ensure_canon_entry_valid(&dir_ace, fsp, pfile_owner_sid, pfile_grp_sid, pst, True)) {
1379 free_canon_ace_list(file_ace);
1380 free_canon_ace_list(dir_ace);
1381 return False;
1382 }
1383
1384 print_canon_ace_list( "file ace - return", file_ace);
1385 print_canon_ace_list( "dir ace - return", dir_ace);
1386
1387 *ppfile_ace = file_ace;
1388 *ppdir_ace = dir_ace;
1389 return True;
1390
1391 }
1392
1393 /******************************************************************************
1394 When returning permissions, try and fit NT display
1395 semantics if possible. Note the the canon_entries here must have been malloced.
1396 The list format should be - first entry = owner, followed by group and other user
1397 entries, last entry = other.
1398
1399 Note that this doesn't exactly match the NT semantics for an ACL. As POSIX entries
1400 are not ordered, and match on the most specific entry rather than walking a list,
1401 then a simple POSIX permission of rw-r--r-- should really map to 6 entries,
1402
1403 Entry 0: owner : deny all except read and write.
1404 Entry 1: group : deny all except read.
1405 Entry 2: Everyone : deny all except read.
1406 Entry 3: owner : allow read and write.
1407 Entry 4: group : allow read.
1408 Entry 5: Everyone : allow read.
1409
1410 But NT cannot display this in their ACL editor !
1411 ********************************************************************************/
1412
1413 static void arrange_posix_perms( char *filename, canon_ace **pp_list_head)
1414 {
1415 canon_ace *list_head = *pp_list_head;
1416 canon_ace *owner_ace = NULL;
1417 canon_ace *other_ace = NULL;
1418 canon_ace *ace = NULL;
1419
1420 for (ace = list_head; ace; ace = ace->next) {
1421 if (ace->type == SMB_ACL_USER_OBJ)
1422 owner_ace = ace;
1423 else if (ace->type == SMB_ACL_OTHER) {
1424 /* Last ace - this is "other" */
1425 other_ace = ace;
1426 }
1427 }
1428
1429 if (!owner_ace || !other_ace) {
1430 DEBUG(0,("arrange_posix_perms: Invalid POSIX permissions for file %s, missing owner or other.\n",
1431 filename ));
1432 return;
1433 }
1434
1435 /*
1436 * The POSIX algorithm applies to owner first, and other last,
1437 * so ensure they are arranged in this order.
1438 */
1439
1440 if (owner_ace) {
1441 DLIST_PROMOTE(list_head, owner_ace);
1442 }
1443
1444 if (other_ace) {
1445 DLIST_DEMOTE(list_head, other_ace, ace);
1446 }
1447
1448 /* We have probably changed the head of the list. */
1449
1450 *pp_list_head = list_head;
1451 }
1452
1453 /****************************************************************************
1454 Create a linked list of canonical ACE entries.
1455 ****************************************************************************/
1456
1457 static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_STRUCT_STAT *psbuf,
1458 DOM_SID *powner, DOM_SID *pgroup)
1459 {
1460 extern DOM_SID global_sid_World;
1461 connection_struct *conn = fsp->conn;
1462 mode_t acl_mask = (S_IRUSR|S_IWUSR|S_IXUSR);
1463 canon_ace *list_head = NULL;
1464 canon_ace *ace = NULL;
1465 canon_ace *next_ace = NULL;
1466 int entry_id = SMB_ACL_FIRST_ENTRY;
1467 SMB_ACL_ENTRY_T entry;
1468 size_t ace_count;
1469
1470 while ( posix_acl && (conn->vfs_ops.sys_acl_get_entry(conn, posix_acl, entry_id, &entry) == 1)) {
1471 SMB_ACL_TAG_T tagtype;
1472 SMB_ACL_PERMSET_T permset;
1473 DOM_SID sid;
1474 posix_id unix_ug;
1475 enum ace_owner owner_type;
1476
1477 /* get_next... */
1478 if (entry_id == SMB_ACL_FIRST_ENTRY)
1479 entry_id = SMB_ACL_NEXT_ENTRY;
1480
1481 /* Is this a MASK entry ? */
1482 if (conn->vfs_ops.sys_acl_get_tag_type(conn, entry, &tagtype) == -1)
1483 continue;
1484
1485 if (conn->vfs_ops.sys_acl_get_permset(conn, entry, &permset) == -1)
1486 continue;
1487
1488 /* Decide which SID to use based on the ACL type. */
1489 switch(tagtype) {
1490 case SMB_ACL_USER_OBJ:
1491 /* Get the SID from the owner. */
1492 uid_to_sid( &sid, psbuf->st_uid );
1493 unix_ug.uid = psbuf->st_uid;
1494 owner_type = UID_ACE;
1495 break;
1496 case SMB_ACL_USER:
1497 {
1498 uid_t *puid = (uid_t *)conn->vfs_ops.sys_acl_get_qualifier(conn, entry);
1499 if (puid == NULL) {
1500 DEBUG(0,("canonicalise_acl: Failed to get uid.\n"));
1501 continue;
1502 }
1503 uid_to_sid( &sid, *puid);
1504 unix_ug.uid = *puid;
1505 owner_type = UID_ACE;
1506 conn->vfs_ops.sys_acl_free_qualifier(conn, (void *)puid,tagtype);
1507 break;
1508 }
1509 case SMB_ACL_GROUP_OBJ:
1510 /* Get the SID from the owning group. */
1511 gid_to_sid( &sid, psbuf->st_gid );
1512 unix_ug.gid = psbuf->st_gid;
1513 owner_type = GID_ACE;
1514 break;
1515 case SMB_ACL_GROUP:
1516 {
1517 gid_t *pgid = (gid_t *)conn->vfs_ops.sys_acl_get_qualifier(conn, entry);
1518 if (pgid == NULL) {
1519 DEBUG(0,("canonicalise_acl: Failed to get gid.\n"));
1520 continue;
1521 }
1522 gid_to_sid( &sid, *pgid);
1523 unix_ug.gid = *pgid;
1524 owner_type = GID_ACE;
1525 conn->vfs_ops.sys_acl_free_qualifier(conn, (void *)pgid,tagtype);
1526 break;
1527 }
1528 case SMB_ACL_MASK:
1529 acl_mask = convert_permset_to_mode_t(conn, permset);
1530 continue; /* Don't count the mask as an entry. */
1531 case SMB_ACL_OTHER:
1532 /* Use the Everyone SID */
1533 sid = global_sid_World;
1534 unix_ug.world = -1;
1535 owner_type = WORLD_ACE;
1536 break;
1537 default:
1538 DEBUG(0,("canonicalise_acl: Unknown tagtype %u\n", (unsigned int)tagtype));
1539 continue;
1540 }
1541
1542 /*
1543 * Add this entry to the list.
1544 */
1545
1546 if ((ace = (canon_ace *)malloc(sizeof(canon_ace))) == NULL)
1547 goto fail;
1548
1549 ZERO_STRUCTP(ace);
1550 ace->type = tagtype;
1551 ace->perms = convert_permset_to_mode_t(conn, permset);
1552 ace->attr = ALLOW_ACE;
1553 ace->trustee = sid;
1554 ace->unix_ug = unix_ug;
1555 ace->owner_type = owner_type;
1556
1557 DLIST_ADD(list_head, ace);
1558 }
1559
1560 /*
1561 * This next call will ensure we have at least a user/group/world set.
1562 */
1563
1564 if (!ensure_canon_entry_valid(&list_head, fsp, powner, pgroup, psbuf, False))
1565 goto fail;
1566
1567 arrange_posix_perms(fsp->fsp_name,&list_head );
1568
1569 /*
1570 * Now go through the list, masking the permissions with the
1571 * acl_mask. Ensure all DENY Entries are at the start of the list.
1572 */
1573
1574 DEBUG(10,("canonicalise_acl: ace entries before arrange :\n"));
1575
1576 for ( ace_count = 0, ace = list_head; ace; ace = next_ace, ace_count++) {
1577 next_ace = ace->next;
1578
1579 /* Masks are only applied to entries other than USER_OBJ and OTHER. */
1580 if (ace->type != SMB_ACL_OTHER && ace->type != SMB_ACL_USER_OBJ)
1581 ace->perms &= acl_mask;
1582
1583 if (ace->perms == 0) {
1584 DLIST_PROMOTE(list_head, ace);
1585 }
1586
1587 if( DEBUGLVL( 10 ) ) {
1588 print_canon_ace(ace, ace_count);
1589 }
1590 }
1591
1592 print_canon_ace_list( "canonicalise_acl: ace entries after arrange", list_head );
1593
1594 return list_head;
1595
1596 fail:
1597
1598 free_canon_ace_list(list_head);
1599 return NULL;
1600 }
1601
1602 /****************************************************************************
1603 Attempt to apply an ACL to a file or directory.
1604 ****************************************************************************/
1605
1606 static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL default_ace, BOOL *pacl_set_support)
1607 {
1608 connection_struct *conn = fsp->conn;
1609 BOOL ret = False;
1610 SMB_ACL_T the_acl = conn->vfs_ops.sys_acl_init(conn, (int)count_canon_ace_list(the_ace) + 1);
1611 canon_ace *p_ace;
1612 int i;
1613 SMB_ACL_ENTRY_T mask_entry;
1614 SMB_ACL_PERMSET_T mask_permset;
1615 SMB_ACL_TYPE_T the_acl_type = (default_ace ? SMB_ACL_TYPE_DEFAULT : SMB_ACL_TYPE_ACCESS);
1616
1617 if (the_acl == NULL) {
1618
1619 if (errno != ENOSYS) {
1620 /*
1621 * Only print this error message if we have some kind of ACL
1622 * support that's not working. Otherwise we would always get this.
1623 */
1624 DEBUG(0,("set_canon_ace_list: Unable to init %s ACL. (%s)\n",
1625 default_ace ? "default" : "file", strerror(errno) ));
1626 }
1627 *pacl_set_support = False;
1628 return False;
1629 }
1630
1631 for (i = 0, p_ace = the_ace; p_ace; p_ace = p_ace->next, i++ ) {
1632 SMB_ACL_ENTRY_T the_entry;
1633 SMB_ACL_PERMSET_T the_permset;
1634
1635 /*
1636 * Get the entry for this ACE.
1637 */
1638
1639 if (conn->vfs_ops.sys_acl_create_entry(conn, &the_acl, &the_entry) == -1) {
1640 DEBUG(0,("set_canon_ace_list: Failed to create entry %d. (%s)\n",
1641 i, strerror(errno) ));
1642 goto done;
1643 }
1644
1645 /*
1646 * Ok - we now know the ACL calls should be working, don't
1647 * allow fallback to chmod.
1648 */
1649
1650 *pacl_set_support = True;
1651
1652 /*
1653 * Initialise the entry from the canon_ace.
1654 */
1655
1656 /*
1657 * First tell the entry what type of ACE this is.
1658 */
1659
1660 if (conn->vfs_ops.sys_acl_set_tag_type(conn, the_entry, p_ace->type) == -1) {
1661 DEBUG(0,("set_canon_ace_list: Failed to set tag type on entry %d. (%s)\n",
1662 i, strerror(errno) ));
1663 goto done;
1664 }
1665
1666 /*
1667 * Only set the qualifier (user or group id) if the entry is a user
1668 * or group id ACE.
1669 */
1670
1671 if ((p_ace->type == SMB_ACL_USER) || (p_ace->type == SMB_ACL_GROUP)) {
1672 if (conn->vfs_ops.sys_acl_set_qualifier(conn, the_entry,(void *)&p_ace->unix_ug.uid) == -1) {
1673 DEBUG(0,("set_canon_ace_list: Failed to set qualifier on entry %d. (%s)\n",
1674 i, strerror(errno) ));
1675 goto done;
1676 }
1677 }
1678
1679 /*
1680 * Convert the mode_t perms in the canon_ace to a POSIX permset.
1681 */
1682
1683 if (conn->vfs_ops.sys_acl_get_permset(conn, the_entry, &the_permset) == -1) {
1684 DEBUG(0,("set_canon_ace_list: Failed to get permset on entry %d. (%s)\n",
1685 i, strerror(errno) ));
1686 goto done;
1687 }
1688
1689 if (map_acl_perms_to_permset(conn, p_ace->perms, &the_permset) == -1) {
1690 DEBUG(0,("set_canon_ace_list: Failed to create permset for mode (%u) on entry %d. (%s)\n",
1691 (unsigned int)p_ace->perms, i, strerror(errno) ));
1692 goto done;
1693 }
1694
1695 /*
1696 * ..and apply them to the entry.
1697 */
1698
1699 if (conn->vfs_ops.sys_acl_set_permset(conn, the_entry, the_permset) == -1) {
1700 DEBUG(0,("set_canon_ace_list: Failed to add permset on entry %d. (%s)\n",
1701 i, strerror(errno) ));
1702 goto done;
1703 }
1704
1705 if( DEBUGLVL( 10 ))
1706 print_canon_ace( p_ace, i);
1707 }
1708
1709 /*
1710 * Add in a mask of rwx.
1711 */
1712
1713 if (conn->vfs_ops.sys_acl_create_entry( conn, &the_acl, &mask_entry) == -1) {
1714 DEBUG(0,("set_canon_ace_list: Failed to create mask entry. (%s)\n", strerror(errno) ));
1715 goto done;
1716 }
1717
1718 if (conn->vfs_ops.sys_acl_set_tag_type(conn, mask_entry, SMB_ACL_MASK) == -1) {
1719 DEBUG(0,("set_canon_ace_list: Failed to set tag type on mask entry. (%s)\n",strerror(errno) ));
1720 goto done;
1721 }
1722
1723 if (conn->vfs_ops.sys_acl_get_permset(conn, mask_entry, &mask_permset) == -1) {
1724 DEBUG(0,("set_canon_ace_list: Failed to get mask permset. (%s)\n", strerror(errno) ));
1725 goto done;
1726 }
1727
1728 if (map_acl_perms_to_permset(conn, S_IRUSR|S_IWUSR|S_IXUSR, &mask_permset) == -1) {
1729 DEBUG(0,("set_canon_ace_list: Failed to create mask permset. (%s)\n", strerror(errno) ));
1730 goto done;
1731 }
1732
1733 if (conn->vfs_ops.sys_acl_set_permset(conn, mask_entry, mask_permset) == -1) {
1734 DEBUG(0,("set_canon_ace_list: Failed to add mask permset. (%s)\n", strerror(errno) ));
1735 goto done;
1736 }
1737
1738 /*
1739 * Check if the ACL is valid.
1740 */
1741
1742 if (conn->vfs_ops.sys_acl_valid(conn, the_acl) == -1) {
1743 DEBUG(0,("set_canon_ace_list: ACL type (%s) is invalid for set (%s).\n",
1744 the_acl_type == SMB_ACL_TYPE_DEFAULT ? "directory default" : "file",
1745 strerror(errno) ));
1746 goto done;
1747 }
1748
1749 /*
1750 * Finally apply it to the file or directory.
1751 */
1752
1753 if(default_ace || fsp->is_directory || fsp->fd == -1) {
1754 if (conn->vfs_ops.sys_acl_set_file(conn, fsp->fsp_name, the_acl_type, the_acl) == -1) {
1755 /*
1756 * Some systems allow all the above calls and only fail with no ACL support
1757 * when attempting to apply the acl. HPUX with HFS is an example of this. JRA.
1758 */
1759 if (errno == ENOSYS)
1760 *pacl_set_support = False;
1761 DEBUG(2,("set_canon_ace_list: sys_acl_set_file type %s failed for file %s (%s).\n",
1762 the_acl_type == SMB_ACL_TYPE_DEFAULT ? "directory default" : "file",
1763 fsp->fsp_name, strerror(errno) ));
1764 goto done;
1765 }
1766 } else {
1767 if (conn->vfs_ops.sys_acl_set_fd(fsp, fsp->fd, the_acl) == -1) {
1768 /*
1769 * Some systems allow all the above calls and only fail with no ACL support
1770 * when attempting to apply the acl. HPUX with HFS is an example of this. JRA.
1771 */
1772 if (errno == ENOSYS)
1773 *pacl_set_support = False;
1774 DEBUG(2,("set_canon_ace_list: sys_acl_set_file failed for file %s (%s).\n",
1775 fsp->fsp_name, strerror(errno) ));
1776 goto done;
1777 }
1778 }
1779
1780 ret = True;
1781
1782 done:
1783
1784 if (the_acl != NULL)
1785 conn->vfs_ops.sys_acl_free_acl(conn, the_acl);
1786
1787 return ret;
1788 }
1789
1790 /****************************************************************************
1791 Convert a canon_ace to a generic 3 element permission - if possible.
1792 ****************************************************************************/
1793
1794 #define MAP_PERM(p,mask,result) (((p) & (mask)) ? (result) : 0 )
1795
1796 static BOOL convert_canon_ace_to_posix_perms( files_struct *fsp, canon_ace *file_ace_list, mode_t *posix_perms)
1797 {
1798 int snum = SNUM(fsp->conn);
1799 size_t ace_count = count_canon_ace_list(file_ace_list);
1800 canon_ace *ace_p;
1801 canon_ace *owner_ace = NULL;
1802 canon_ace *group_ace = NULL;
1803 canon_ace *other_ace = NULL;
1804 mode_t and_bits;
1805 mode_t or_bits;
1806
1807 if (ace_count != 3) {
1808 DEBUG(3,("convert_canon_ace_to_posix_perms: Too many ACE entries for file %s to convert to \
1809 posix perms.\n", fsp->fsp_name ));
1810 return False;
1811 }
1812
1813 for (ace_p = file_ace_list; ace_p; ace_p = ace_p->next) {
1814 if (ace_p->owner_type == UID_ACE)
1815 owner_ace = ace_p;
1816 else if (ace_p->owner_type == GID_ACE)
1817 group_ace = ace_p;
1818 else if (ace_p->owner_type == WORLD_ACE)
1819 other_ace = ace_p;
1820 }
1821
1822 if (!owner_ace || !group_ace || !other_ace) {
1823 DEBUG(3,("convert_canon_ace_to_posix_perms: Can't get standard entries for file %s.\n",
1824 fsp->fsp_name ));
1825 return False;
1826 }
1827
1828 *posix_perms = (mode_t)0;
1829
1830 *posix_perms |= owner_ace->perms;
1831 *posix_perms |= MAP_PERM(group_ace->perms, S_IRUSR, S_IRGRP);
1832 *posix_perms |= MAP_PERM(group_ace->perms, S_IWUSR, S_IWGRP);
1833 *posix_perms |= MAP_PERM(group_ace->perms, S_IXUSR, S_IXGRP);
1834 *posix_perms |= MAP_PERM(other_ace->perms, S_IRUSR, S_IROTH);
1835 *posix_perms |= MAP_PERM(other_ace->perms, S_IWUSR, S_IWOTH);
1836 *posix_perms |= MAP_PERM(other_ace->perms, S_IXUSR, S_IXOTH);
1837
1838 /* The owner must have at least read access. */
1839
1840 *posix_perms |= S_IRUSR;
1841 if (fsp->is_directory)
1842 *posix_perms |= (S_IWUSR|S_IXUSR);
1843
1844 /* If requested apply the masks. */
1845
1846 /* Get the initial bits to apply. */
1847
1848 if (fsp->is_directory) {
1849 and_bits = lp_dir_security_mask(snum);
1850 or_bits = lp_force_dir_security_mode(snum);
1851 } else {
1852 and_bits = lp_security_mask(snum);
1853 or_bits = lp_force_security_mode(snum);
1854 }
1855
1856 *posix_perms = (((*posix_perms) & and_bits)|or_bits);
1857
1858 DEBUG(10,("convert_canon_ace_to_posix_perms: converted u=%o,g=%o,w=%o to perm=0%o for file %s.\n",
1859 (int)owner_ace->perms, (int)group_ace->perms, (int)other_ace->perms, (int)*posix_perms,
1860 fsp->fsp_name ));
1861
1862 return True;
1863 }
1864
1865 static int nt_ace_comp( SEC_ACE *a1, SEC_ACE *a2)
1866 {
1867 if (a1->type == a2->type)
1868 return 0;
1869
1870 if (a1->type == SEC_ACE_TYPE_ACCESS_DENIED && a2->type == SEC_ACE_TYPE_ACCESS_ALLOWED)
1871 return -1;
1872 return 1;
1873 }
1874
1875 /****************************************************************************
1876 Reply to query a security descriptor from an fsp. If it succeeds it allocates
1877 the space for the return elements and returns the size needed to return the
1878 security descriptor. This should be the only external function needed for
1879 the UNIX style get ACL.
1880 ****************************************************************************/
1881
1882 size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc)
1883 {
1884 connection_struct *conn = fsp->conn;
1885 SMB_STRUCT_STAT sbuf;
1886 SEC_ACE *nt_ace_list = NULL;
1887 DOM_SID owner_sid;
1888 DOM_SID group_sid;
1889 size_t sd_size = 0;
1890 SEC_ACL *psa = NULL;
1891 size_t num_acls = 0;
1892 size_t num_dir_acls = 0;
1893 size_t num_aces = 0;
1894 SMB_ACL_T posix_acl = NULL;
1895 SMB_ACL_T dir_acl = NULL;
1896 canon_ace *file_ace = NULL;
1897 canon_ace *dir_ace = NULL;
1898
1899 *ppdesc = NULL;
1900
1901 DEBUG(10,("get_nt_acl: called for file %s\n", fsp->fsp_name ));
1902
1903 if(fsp->is_directory || fsp->fd == -1) {
1904
1905 /* Get the stat struct for the owner info. */
1906 if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0) {
1907 return 0;
1908 }
1909 /*
1910 * Get the ACL from the path.
1911 */
1912
1913 posix_acl = conn->vfs_ops.sys_acl_get_file(conn, fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
1914
1915 /*
1916 * If it's a directory get the default POSIX ACL.
1917 */
1918
1919 if(fsp->is_directory)
1920 dir_acl = conn->vfs_ops.sys_acl_get_file(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
1921
1922 } else {
1923
1924 /* Get the stat struct for the owner info. */
1925 if(vfs_fstat(fsp,fsp->fd,&sbuf) != 0) {
1926 return 0;
1927 }
1928 /*
1929 * Get the ACL from the fd.
1930 */
1931 posix_acl = conn->vfs_ops.sys_acl_get_fd(fsp, fsp->fd);
1932 }
1933
1934 DEBUG(5,("get_nt_acl : file ACL %s, directory ACL %s\n",
1935 posix_acl ? "present" : "absent",
1936 dir_acl ? "present" : "absent" ));
1937
1938 /*
1939 * Get the owner, group and world SIDs.
1940 */
1941
1942 create_file_sids(&sbuf, &owner_sid, &group_sid);
1943
1944 /* Create the canon_ace lists. */
1945 file_ace = canonicalise_acl( fsp, posix_acl, &sbuf, &owner_sid, &group_sid);
1946 num_acls = count_canon_ace_list(file_ace);
1947
1948 /* We must have *some* ACLS. */
1949
1950 if (num_acls == 0) {
1951 DEBUG(0,("get_nt_acl : No ACLs on file (%s) !\n", fsp->fsp_name ));
1952 return 0;
1953 }
1954
1955 if (fsp->is_directory) {
1956 /*
1957 * If we have to fake a default ACL then this is the mode to use.
1958 */
1959 sbuf.st_mode = unix_mode( fsp->conn, FILE_ATTRIBUTE_ARCHIVE, fsp->fsp_name);
1960
1961 dir_ace = canonicalise_acl(fsp, dir_acl, &sbuf, &owner_sid, &group_sid);
1962 num_dir_acls = count_canon_ace_list(dir_ace);
1963 }
1964
1965 /* Allocate the ace list. */
1966 if ((nt_ace_list = (SEC_ACE *)malloc((num_acls + num_dir_acls)* sizeof(SEC_ACE))) == NULL) {
1967 DEBUG(0,("get_nt_acl: Unable to malloc space for nt_ace_list.\n"));
1968 goto done;
1969 }
1970
1971 memset(nt_ace_list, '\0', (num_acls + num_dir_acls) * sizeof(SEC_ACE) );
1972
1973 /*
1974 * Create the NT ACE list from the canonical ace lists.
1975 */
1976
1977 {
1978 canon_ace *ace;
1979 int nt_acl_type;
1980 int i;
1981
1982 ace = file_ace;
1983
1984 for (i = 0; i < num_acls; i++, ace = ace->next) {
1985 SEC_ACCESS acc = map_canon_ace_perms(&nt_acl_type, &owner_sid, ace );
1986 init_sec_ace(&nt_ace_list[num_aces++], &ace->trustee, nt_acl_type, acc, 0);
1987 }
1988
1989 ace = dir_ace;
1990
1991 for (i = 0; i < num_dir_acls; i++, ace = ace->next) {
1992 SEC_ACCESS acc = map_canon_ace_perms(&nt_acl_type, &owner_sid, ace );
1993 init_sec_ace(&nt_ace_list[num_aces++], &ace->trustee, nt_acl_type, acc,
1994 SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY);
1995 }
1996
1997 /*
1998 * Sort to force deny entries to the front.
1999 */
2000
2001 if (num_acls + num_dir_acls)
2002 qsort( nt_ace_list, num_acls + num_dir_acls, sizeof(nt_ace_list[0]), QSORT_CAST nt_ace_comp);
2003 }
2004
2005 if (num_acls) {
2006 if((psa = make_sec_acl( main_loop_talloc_get(), ACL_REVISION, num_aces, nt_ace_list)) == NULL) {
2007 DEBUG(0,("get_nt_acl: Unable to malloc space for acl.\n"));
2008 goto done;
2009 }
2010 }
2011
2012 *ppdesc = make_standard_sec_desc( main_loop_talloc_get(), &owner_sid, &group_sid, psa, &sd_size);
2013
2014 if(!*ppdesc) {
2015 DEBUG(0,("get_nt_acl: Unable to malloc space for security descriptor.\n"));
2016 sd_size = 0;
2017 }
2018
2019 done:
2020
2021 if (posix_acl)
2022 conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
2023 if (dir_acl)
2024 conn->vfs_ops.sys_acl_free_acl(conn, dir_acl);
2025 free_canon_ace_list(file_ace);
2026 free_canon_ace_list(dir_ace);
2027 SAFE_FREE(nt_ace_list);
2028
2029 return sd_size;
2030 }
2031
2032 /*
2033 try to chown a file. We will be able to chown it under the following conditions
2034
2035 1) if we have root privileges, then it will just work
2036 2) if we have write permission to the file and dos_filemodes is set
2037 then allow chown to the currently authenticated user.
2038
2039 */
2040 static int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_t gid)
2041 {
2042 int ret;
2043 extern struct current_user current_user;
2044 files_struct *fsp;
2045 SMB_STRUCT_STAT st;
2046
2047 /* try the direct way first */
2048 ret = vfs_chown(conn, fname, uid, gid);
2049 if (ret == 0)
2050 return 0;
2051
2052 if(!CAN_WRITE(conn) || !lp_dos_filemode(SNUM(conn)))
2053 return -1;
2054
2055 if (vfs_stat(conn,fname,&st))
2056 return -1;
2057
2058 fsp = open_file_fchmod(conn,fname,&st);
2059 if (!fsp)
2060 return -1;
2061
2062 /* only allow chown to the current user. This is more secure,
2063 and also copes with the case where the SID in a take ownership ACL is
2064 a local SID on the users workstation
2065 */
2066 uid = current_user.uid;
2067
2068 become_root();
2069 /* Keep the current file gid the same. */
2070 ret = vfswrap_fchown(fsp, fsp->fd, uid, (gid_t)-1);
2071 unbecome_root();
2072
2073 close_file_fchmod(fsp);
2074
2075 return ret;
2076 }
2077
2078 /****************************************************************************
2079 Reply to set a security descriptor on an fsp. security_info_sent is the
2080 description of the following NT ACL.
2081 This should be the only external function needed for the UNIX style set ACL.
2082 ****************************************************************************/
2083
2084 BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
2085 {
2086 connection_struct *conn = fsp->conn;
2087 uid_t user = (uid_t)-1;
2088 gid_t grp = (gid_t)-1;
2089 SMB_STRUCT_STAT sbuf;
2090 DOM_SID file_owner_sid;
2091 DOM_SID file_grp_sid;
2092 canon_ace *file_ace_list = NULL;
2093 canon_ace *dir_ace_list = NULL;
2094 BOOL acl_perms = False;
2095 mode_t orig_mode = (mode_t)0;
2096 uid_t orig_uid;
2097 gid_t orig_gid;
2098
2099 DEBUG(10,("set_nt_acl: called for file %s\n", fsp->fsp_name ));
2100
2101 /*
2102 * Get the current state of the file.
2103 */
2104
2105 if(fsp->is_directory || fsp->fd == -1) {
2106 if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0)
2107 return False;
2108 } else {
2109 if(vfs_fstat(fsp,fsp->fd,&sbuf) != 0)
2110 return False;
2111 }
2112
2113 /* Save the original elements we check against. */
2114 orig_mode = sbuf.st_mode;
2115 orig_uid = sbuf.st_uid;
2116 orig_gid = sbuf.st_gid;
2117
2118 /*
2119 * Unpack the user/group/world id's.
2120 */
2121
2122 if (!unpack_nt_owners( &sbuf, &user, &grp, security_info_sent, psd))
2123 return False;
2124
2125 /*
2126 * Do we need to chown ?
2127 */
2128
2129 if((user != (uid_t)-1 || grp != (uid_t)-1) && (orig_uid != user || orig_gid != grp)) {
2130
2131 DEBUG(3,("set_nt_acl: chown %s. uid = %u, gid = %u.\n",
2132 fsp->fsp_name, (unsigned int)user, (unsigned int)grp ));
2133
2134 if(try_chown( fsp->conn, fsp->fsp_name, user, grp) == -1) {
2135 DEBUG(3,("set_nt_acl: chown %s, %u, %u failed. Error = %s.\n",
2136 fsp->fsp_name, (unsigned int)user, (unsigned int)grp, strerror(errno) ));
2137 return False;
2138 }
2139
2140 /*
2141 * Recheck the current state of the file, which may have changed.
2142 * (suid/sgid bits, for instance)
2143 */
2144
2145 if(fsp->is_directory) {
2146 if(vfs_stat(fsp->conn, fsp->fsp_name, &sbuf) != 0) {
2147 return False;
2148 }
2149 } else {
2150
2151 int ret;
2152
2153 if(fsp->fd == -1)
2154 ret = vfs_stat(fsp->conn, fsp->fsp_name, &sbuf);
2155 else
2156 ret = vfs_fstat(fsp,fsp->fd,&sbuf);
2157
2158 if(ret != 0)
2159 return False;
2160 }
2161
2162 /* Save the original elements we check against. */
2163 orig_mode = sbuf.st_mode;
2164 orig_uid = sbuf.st_uid;
2165 orig_gid = sbuf.st_gid;
2166 }
2167
2168 create_file_sids(&sbuf, &file_owner_sid, &file_grp_sid);
2169
2170 acl_perms = unpack_canon_ace( fsp, &sbuf, &file_owner_sid, &file_grp_sid,
2171 &file_ace_list, &dir_ace_list, security_info_sent, psd);
2172
2173 if ((file_ace_list == NULL) && (dir_ace_list == NULL)) {
2174 /* W2K traverse DACL set - ignore. */
2175 return True;
2176 }
2177
2178 if (!acl_perms) {
2179 DEBUG(3,("set_nt_acl: cannot set permissions\n"));
2180 free_canon_ace_list(file_ace_list);
2181 free_canon_ace_list(dir_ace_list);
2182 return False;
2183 }
2184
2185 /*
2186 * Only change security if we got a DACL.
2187 */
2188
2189 if((security_info_sent & DACL_SECURITY_INFORMATION) && (psd->dacl != NULL)) {
2190
2191 BOOL acl_set_support = False;
2192 BOOL ret = False;
2193
2194 /*
2195 * Try using the POSIX ACL set first. Fall back to chmod if
2196 * we have no ACL support on this filesystem.
2197 */
2198
2199 if (acl_perms && file_ace_list) {
2200 ret = set_canon_ace_list(fsp, file_ace_list, False, &acl_set_support);
2201 if (acl_set_support && ret == False) {
2202 DEBUG(3,("set_nt_acl: failed to set file acl on file %s (%s).\n", fsp->fsp_name, strerror(errno) ));
2203 free_canon_ace_list(file_ace_list);
2204 free_canon_ace_list(dir_ace_list);
2205 return False;
2206 }
2207 }
2208
2209 if (acl_perms && acl_set_support && fsp->is_directory) {
2210 if (dir_ace_list) {
2211 if (!set_canon_ace_list(fsp, dir_ace_list, True, &acl_set_support)) {
2212 DEBUG(3,("set_nt_acl: failed to set default acl on directory %s (%s).\n", fsp->fsp_name, strerror(errno) ));
2213 free_canon_ace_list(file_ace_list);
2214 free_canon_ace_list(dir_ace_list);
2215 return False;
2216 }
2217 } else {
2218
2219 /*
2220 * No default ACL - delete one if it exists.
2221 */
2222
2223 if (conn->vfs_ops.sys_acl_delete_def_file(conn, fsp->fsp_name) == -1) {
2224 DEBUG(3,("set_nt_acl: sys_acl_delete_def_file failed (%s)\n", strerror(errno)));
2225 free_canon_ace_list(file_ace_list);
2226 return False;
2227 }
2228 }
2229 }
2230
2231 /*
2232 * If we cannot set using POSIX ACLs we fall back to checking if we need to chmod.
2233 */
2234
2235 if(!acl_set_support && acl_perms) {
2236 mode_t posix_perms;
2237
2238 if (!convert_canon_ace_to_posix_perms( fsp, file_ace_list, &posix_perms)) {
2239 free_canon_ace_list(file_ace_list);
2240 free_canon_ace_list(dir_ace_list);
2241 DEBUG(3,("set_nt_acl: failed to convert file acl to posix permissions for file %s.\n",
2242 fsp->fsp_name ));
2243 return False;
2244 }
2245
2246 if (orig_mode != posix_perms) {
2247
2248 DEBUG(3,("set_nt_acl: chmod %s. perms = 0%o.\n",
2249 fsp->fsp_name, (unsigned int)posix_perms ));
2250
2251 if(conn->vfs_ops.chmod(conn,fsp->fsp_name, posix_perms) == -1) {
2252 DEBUG(3,("set_nt_acl: chmod %s, 0%o failed. Error = %s.\n",
2253 fsp->fsp_name, (unsigned int)posix_perms, strerror(errno) ));
2254 free_canon_ace_list(file_ace_list);
2255 free_canon_ace_list(dir_ace_list);
2256 return False;
2257 }
2258 }
2259 }
2260 }
2261
2262 free_canon_ace_list(file_ace_list);
2263 free_canon_ace_list(dir_ace_list);
2264
2265 return True;
2266 }
2267
2268 /****************************************************************************
2269 Do a chmod by setting the ACL USER_OBJ, GROUP_OBJ and OTHER bits in an ACL
2270 and set the mask to rwx. Needed to preserve complex ACLs set by NT.
2271 ****************************************************************************/
2272
2273 static int chmod_acl_internals( connection_struct *conn, SMB_ACL_T posix_acl, mode_t mode)
2274 {
2275 int entry_id = SMB_ACL_FIRST_ENTRY;
2276 SMB_ACL_ENTRY_T entry;
2277 int num_entries = 0;
2278
2279 while ( conn->vfs_ops.sys_acl_get_entry(conn, posix_acl, entry_id, &entry) == 1) {
2280 SMB_ACL_TAG_T tagtype;
2281 SMB_ACL_PERMSET_T permset;
2282 mode_t perms;
2283
2284 /* get_next... */
2285 if (entry_id == SMB_ACL_FIRST_ENTRY)
2286 entry_id = SMB_ACL_NEXT_ENTRY;
2287
2288 if (conn->vfs_ops.sys_acl_get_tag_type(conn, entry, &tagtype) == -1)
2289 return -1;
2290
2291 if (conn->vfs_ops.sys_acl_get_permset(conn, entry, &permset) == -1)
2292 return -1;
2293
2294 num_entries++;
2295
2296 switch(tagtype) {
2297 case SMB_ACL_USER_OBJ:
2298 perms = unix_perms_to_acl_perms(mode, S_IRUSR, S_IWUSR, S_IXUSR);
2299 break;
2300 case SMB_ACL_GROUP_OBJ:
2301 perms = unix_perms_to_acl_perms(mode, S_IRGRP, S_IWGRP, S_IXGRP);
2302 break;
2303 case SMB_ACL_MASK:
2304 perms = S_IRUSR|S_IWUSR|S_IXUSR;
2305 break;
2306 case SMB_ACL_OTHER:
2307 perms = unix_perms_to_acl_perms(mode, S_IROTH, S_IWOTH, S_IXOTH);
2308 break;
2309 default:
2310 continue;
2311 }
2312
2313 if (map_acl_perms_to_permset(conn, perms, &permset) == -1)
2314 return -1;
2315
2316 if (conn->vfs_ops.sys_acl_set_permset(conn, entry, permset) == -1)
2317 return -1;
2318 }
2319
2320 /*
2321 * If this is a simple 3 element ACL or no elements then it's a standard
2322 * UNIX permission set. Just use chmod...
2323 */
2324
2325 if ((num_entries == 3) || (num_entries == 0))
2326 return -1;
2327
2328 return 0;
2329 }
2330
2331 /****************************************************************************
2332 Do a chmod by setting the ACL USER_OBJ, GROUP_OBJ and OTHER bits in an ACL
2333 and set the mask to rwx. Needed to preserve complex ACLs set by NT.
2334 Note that name is in UNIX character set.
2335 ****************************************************************************/
2336
2337 int chmod_acl(connection_struct *conn, const char *name, mode_t mode)
2338 {
2339 SMB_ACL_T posix_acl = NULL;
2340 int ret = -1;
2341
2342 if ((posix_acl = conn->vfs_ops.sys_acl_get_file(conn, name, SMB_ACL_TYPE_ACCESS)) == NULL)
2343 return -1;
2344
2345 if ((ret = chmod_acl_internals(conn, posix_acl, mode)) == -1)
2346 goto done;
2347
2348 ret = conn->vfs_ops.sys_acl_set_file(conn, name, SMB_ACL_TYPE_ACCESS, posix_acl);
2349
2350 done:
2351
2352 conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
2353 return ret;
2354 }
2355
2356 /****************************************************************************
2357 Do an fchmod by setting the ACL USER_OBJ, GROUP_OBJ and OTHER bits in an ACL
2358 and set the mask to rwx. Needed to preserve complex ACLs set by NT.
2359 ****************************************************************************/
2360
2361 int fchmod_acl(files_struct *fsp, int fd, mode_t mode)
2362 {
2363 connection_struct *conn = fsp->conn;
2364 SMB_ACL_T posix_acl = NULL;
2365 int ret = -1;
2366
2367 if ((posix_acl = conn->vfs_ops.sys_acl_get_fd(fsp, fd)) == NULL)
2368 return -1;
2369
2370 if ((ret = chmod_acl_internals(conn, posix_acl, mode)) == -1)
2371 goto done;
2372
2373 ret = conn->vfs_ops.sys_acl_set_fd(fsp, fd, posix_acl);
2374
2375 done:
2376
2377 conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
2378 return ret;
2379 }
2380
2381 BOOL directory_has_default_acl(connection_struct *conn, const char *fname)
2382 {
2383 SMB_ACL_T dir_acl = conn->vfs_ops.sys_acl_get_file( conn, fname, SMB_ACL_TYPE_DEFAULT);
2384 BOOL has_acl = False;
2385 SMB_ACL_ENTRY_T entry;
2386
2387 if (dir_acl != NULL && (conn->vfs_ops.sys_acl_get_entry(conn, dir_acl, SMB_ACL_FIRST_ENTRY, &entry) == 1))
2388 has_acl = True;
2389
2390 if (dir_acl)
2391 conn->vfs_ops.sys_acl_free_acl(conn, dir_acl);
2392 return has_acl;
2393 }
Samba GIT mirror