26515cfe1a6249cfc4a9ea3b462d085196b468ef
[ira/wip.git] / source4 / ntvfs / posix / pvfs_acl.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - ACL support
5
6    Copyright (C) Andrew Tridgell 2004
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "auth/auth.h"
24 #include "vfs_posix.h"
25 #include "librpc/gen_ndr/xattr.h"
26 #include "libcli/security/security.h"
27 #include "param/param.h"
28
29
30 /* the list of currently registered ACL backends */
31 static struct pvfs_acl_backend {
32         const struct pvfs_acl_ops *ops;
33 } *backends = NULL;
34 static int num_backends;
35
36 /*
37   register a pvfs acl backend. 
38
39   The 'name' can be later used by other backends to find the operations
40   structure for this backend.  
41 */
42 NTSTATUS pvfs_acl_register(const struct pvfs_acl_ops *ops)
43 {
44         struct pvfs_acl_ops *new_ops;
45
46         if (pvfs_acl_backend_byname(ops->name) != NULL) {
47                 DEBUG(0,("pvfs acl backend '%s' already registered\n", ops->name));
48                 return NT_STATUS_OBJECT_NAME_COLLISION;
49         }
50
51         backends = talloc_realloc(talloc_autofree_context(), backends, struct pvfs_acl_backend, num_backends+1);
52         NT_STATUS_HAVE_NO_MEMORY(backends);
53
54         new_ops = (struct pvfs_acl_ops *)talloc_memdup(backends, ops, sizeof(*ops));
55         new_ops->name = talloc_strdup(new_ops, ops->name);
56
57         backends[num_backends].ops = new_ops;
58
59         num_backends++;
60
61         DEBUG(3,("NTVFS backend '%s' registered\n", ops->name));
62
63         return NT_STATUS_OK;
64 }
65
66
67 /*
68   return the operations structure for a named backend
69 */
70 const struct pvfs_acl_ops *pvfs_acl_backend_byname(const char *name)
71 {
72         int i;
73
74         for (i=0;i<num_backends;i++) {
75                 if (strcmp(backends[i].ops->name, name) == 0) {
76                         return backends[i].ops;
77                 }
78         }
79
80         return NULL;
81 }
82
83 NTSTATUS pvfs_acl_init(struct loadparm_context *lp_ctx)
84 {
85         static bool initialized = false;
86         extern NTSTATUS pvfs_acl_nfs4_init(void);
87         extern NTSTATUS pvfs_acl_xattr_init(void);
88         init_module_fn static_init[] = { STATIC_pvfs_acl_MODULES };
89         init_module_fn *shared_init;
90
91         if (initialized) return NT_STATUS_OK;
92         initialized = true;
93
94         shared_init = load_samba_modules(NULL, lp_ctx, "pvfs_acl");
95
96         run_init_functions(static_init);
97         run_init_functions(shared_init);
98
99         talloc_free(shared_init);
100
101         return NT_STATUS_OK;
102 }
103
104
105 /*
106   map a single access_mask from generic to specific bits for files/dirs
107 */
108 static uint32_t pvfs_translate_mask(uint32_t access_mask)
109 {
110         if (access_mask & SEC_MASK_GENERIC) {
111                 if (access_mask & SEC_GENERIC_READ)    access_mask |= SEC_RIGHTS_FILE_READ;
112                 if (access_mask & SEC_GENERIC_WRITE)   access_mask |= SEC_RIGHTS_FILE_WRITE;
113                 if (access_mask & SEC_GENERIC_EXECUTE) access_mask |= SEC_RIGHTS_FILE_EXECUTE;
114                 if (access_mask & SEC_GENERIC_ALL)     access_mask |= SEC_RIGHTS_FILE_ALL;
115                 access_mask &= ~SEC_MASK_GENERIC;
116         }
117         return access_mask;
118 }
119
120
121 /*
122   map any generic access bits in the given acl
123   this relies on the fact that the mappings for files and directories
124   are the same
125 */
126 static void pvfs_translate_generic_bits(struct security_acl *acl)
127 {
128         unsigned i;
129
130         if (!acl) return;
131
132         for (i=0;i<acl->num_aces;i++) {
133                 struct security_ace *ace = &acl->aces[i];
134                 ace->access_mask = pvfs_translate_mask(ace->access_mask);
135         }
136 }
137
138
139 /*
140   setup a default ACL for a file
141 */
142 static NTSTATUS pvfs_default_acl(struct pvfs_state *pvfs,
143                                  struct ntvfs_request *req,
144                                  struct pvfs_filename *name, int fd, 
145                                  struct security_descriptor **psd)
146 {
147         struct security_descriptor *sd;
148         NTSTATUS status;
149         struct security_ace ace;
150         mode_t mode;
151         struct id_mapping *ids;
152         struct composite_context *ctx;
153
154         *psd = security_descriptor_initialise(req);
155         if (*psd == NULL) {
156                 return NT_STATUS_NO_MEMORY;
157         }
158         sd = *psd;
159
160         ids = talloc_zero_array(sd, struct id_mapping, 2);
161         NT_STATUS_HAVE_NO_MEMORY(ids);
162
163         ids[0].unixid = talloc(ids, struct unixid);
164         NT_STATUS_HAVE_NO_MEMORY(ids[0].unixid);
165
166         ids[0].unixid->id = name->st.st_uid;
167         ids[0].unixid->type = ID_TYPE_UID;
168         ids[0].sid = NULL;
169
170         ids[1].unixid = talloc(ids, struct unixid);
171         NT_STATUS_HAVE_NO_MEMORY(ids[1].unixid);
172
173         ids[1].unixid->id = name->st.st_gid;
174         ids[1].unixid->type = ID_TYPE_GID;
175         ids[1].sid = NULL;
176
177         ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
178         NT_STATUS_HAVE_NO_MEMORY(ctx);
179
180         status = wbc_xids_to_sids_recv(ctx, &ids);
181         NT_STATUS_NOT_OK_RETURN(status);
182
183         sd->owner_sid = talloc_steal(sd, ids[0].sid);
184         sd->group_sid = talloc_steal(sd, ids[1].sid);
185
186         talloc_free(ids);
187         sd->type |= SEC_DESC_DACL_PRESENT;
188
189         mode = name->st.st_mode;
190
191         /*
192           we provide up to 4 ACEs
193             - Owner
194             - Group
195             - Everyone
196             - Administrator
197          */
198
199
200         /* setup owner ACE */
201         ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
202         ace.flags = 0;
203         ace.trustee = *sd->owner_sid;
204         ace.access_mask = 0;
205
206         if (mode & S_IRUSR) {
207                 if (mode & S_IWUSR) {
208                         ace.access_mask |= SEC_RIGHTS_FILE_ALL;
209                 } else {
210                         ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
211                 }
212         }
213         if (mode & S_IWUSR) {
214                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE | SEC_STD_DELETE;
215         }
216         if (ace.access_mask) {
217                 security_descriptor_dacl_add(sd, &ace);
218         }
219
220
221         /* setup group ACE */
222         ace.trustee = *sd->group_sid;
223         ace.access_mask = 0;
224         if (mode & S_IRGRP) {
225                 ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
226         }
227         if (mode & S_IWGRP) {
228                 /* note that delete is not granted - this matches posix behaviour */
229                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE;
230         }
231         if (ace.access_mask) {
232                 security_descriptor_dacl_add(sd, &ace);
233         }
234
235         /* setup other ACE */
236         ace.trustee = *dom_sid_parse_talloc(req, SID_WORLD);
237         ace.access_mask = 0;
238         if (mode & S_IROTH) {
239                 ace.access_mask |= SEC_RIGHTS_FILE_READ | SEC_FILE_EXECUTE;
240         }
241         if (mode & S_IWOTH) {
242                 ace.access_mask |= SEC_RIGHTS_FILE_WRITE;
243         }
244         if (ace.access_mask) {
245                 security_descriptor_dacl_add(sd, &ace);
246         }
247
248         /* setup system ACE */
249         ace.trustee = *dom_sid_parse_talloc(req, SID_NT_SYSTEM);
250         ace.access_mask = SEC_RIGHTS_FILE_ALL;
251         security_descriptor_dacl_add(sd, &ace);
252         
253         return NT_STATUS_OK;
254 }
255                                  
256
257 /*
258   omit any security_descriptor elements not specified in the given
259   secinfo flags
260 */
261 static void normalise_sd_flags(struct security_descriptor *sd, uint32_t secinfo_flags)
262 {
263         if (!(secinfo_flags & SECINFO_OWNER)) {
264                 sd->owner_sid = NULL;
265         }
266         if (!(secinfo_flags & SECINFO_GROUP)) {
267                 sd->group_sid = NULL;
268         }
269         if (!(secinfo_flags & SECINFO_DACL)) {
270                 sd->dacl = NULL;
271         }
272         if (!(secinfo_flags & SECINFO_SACL)) {
273                 sd->sacl = NULL;
274         }
275 }
276
277 /*
278   answer a setfileinfo for an ACL
279 */
280 NTSTATUS pvfs_acl_set(struct pvfs_state *pvfs, 
281                       struct ntvfs_request *req,
282                       struct pvfs_filename *name, int fd, 
283                       uint32_t access_mask,
284                       union smb_setfileinfo *info)
285 {
286         uint32_t secinfo_flags = info->set_secdesc.in.secinfo_flags;
287         struct security_descriptor *new_sd, *sd, orig_sd;
288         NTSTATUS status = NT_STATUS_NOT_FOUND;
289         uid_t old_uid = -1;
290         gid_t old_gid = -1;
291         uid_t new_uid = -1;
292         gid_t new_gid = -1;
293         struct id_mapping *ids;
294         struct composite_context *ctx;
295
296         if (pvfs->acl_ops != NULL) {
297                 status = pvfs->acl_ops->acl_load(pvfs, name, fd, req, &sd);
298         }
299         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
300                 status = pvfs_default_acl(pvfs, req, name, fd, &sd);
301         }
302         if (!NT_STATUS_IS_OK(status)) {
303                 return status;
304         }
305
306         ids = talloc(req, struct id_mapping);
307         NT_STATUS_HAVE_NO_MEMORY(ids);
308         ids->unixid = NULL;
309         ids->sid = NULL;
310         ids->status = NT_STATUS_NONE_MAPPED;
311
312         new_sd = info->set_secdesc.in.sd;
313         orig_sd = *sd;
314
315         old_uid = name->st.st_uid;
316         old_gid = name->st.st_gid;
317
318         /* only set the elements that have been specified */
319         if (secinfo_flags & SECINFO_OWNER) {
320                 if (!(access_mask & SEC_STD_WRITE_OWNER)) {
321                         return NT_STATUS_ACCESS_DENIED;
322                 }
323                 if (!dom_sid_equal(sd->owner_sid, new_sd->owner_sid)) {
324                         ids->sid = new_sd->owner_sid;
325                         ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
326                         NT_STATUS_HAVE_NO_MEMORY(ctx);
327                         status = wbc_sids_to_xids_recv(ctx, &ids);
328                         NT_STATUS_NOT_OK_RETURN(status);
329
330                         if (ids->unixid->type == ID_TYPE_BOTH ||
331                             ids->unixid->type == ID_TYPE_UID) {
332                                 new_uid = ids->unixid->id;
333                         }
334                 }
335                 sd->owner_sid = new_sd->owner_sid;
336         }
337         if (secinfo_flags & SECINFO_GROUP) {
338                 if (!(access_mask & SEC_STD_WRITE_OWNER)) {
339                         return NT_STATUS_ACCESS_DENIED;
340                 }
341                 if (!dom_sid_equal(sd->group_sid, new_sd->group_sid)) {
342                         ids->sid = new_sd->group_sid;
343                         ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
344                         NT_STATUS_HAVE_NO_MEMORY(ctx);
345                         status = wbc_sids_to_xids_recv(ctx, &ids);
346                         NT_STATUS_NOT_OK_RETURN(status);
347
348                         if (ids->unixid->type == ID_TYPE_BOTH ||
349                             ids->unixid->type == ID_TYPE_GID) {
350                                 new_gid = ids->unixid->id;
351                         }
352
353                 }
354                 sd->group_sid = new_sd->group_sid;
355         }
356         if (secinfo_flags & SECINFO_DACL) {
357                 if (!(access_mask & SEC_STD_WRITE_DAC)) {
358                         return NT_STATUS_ACCESS_DENIED;
359                 }
360                 sd->dacl = new_sd->dacl;
361                 pvfs_translate_generic_bits(sd->dacl);
362         }
363         if (secinfo_flags & SECINFO_SACL) {
364                 if (!(access_mask & SEC_FLAG_SYSTEM_SECURITY)) {
365                         return NT_STATUS_ACCESS_DENIED;
366                 }
367                 sd->sacl = new_sd->sacl;
368                 pvfs_translate_generic_bits(sd->sacl);
369         }
370
371         if (new_uid == old_uid) {
372                 new_uid = -1;
373         }
374
375         if (new_gid == old_gid) {
376                 new_gid = -1;
377         }
378
379         /* if there's something to change try it */
380         if (new_uid != -1 || new_gid != -1) {
381                 int ret;
382                 if (fd == -1) {
383                         ret = chown(name->full_name, new_uid, new_gid);
384                 } else {
385                         ret = fchown(fd, new_uid, new_gid);
386                 }
387                 if (errno == EPERM && uwrap_enabled()) {
388                         ret = 0;
389                 }
390                 if (ret == -1) {
391                         return pvfs_map_errno(pvfs, errno);
392                 }
393         }
394
395         /* we avoid saving if the sd is the same. This means when clients
396            copy files and end up copying the default sd that we don't
397            needlessly use xattrs */
398         if (!security_descriptor_equal(sd, &orig_sd) && pvfs->acl_ops) {
399                 status = pvfs->acl_ops->acl_save(pvfs, name, fd, sd);
400         }
401
402         return status;
403 }
404
405
406 /*
407   answer a fileinfo query for the ACL
408 */
409 NTSTATUS pvfs_acl_query(struct pvfs_state *pvfs, 
410                         struct ntvfs_request *req,
411                         struct pvfs_filename *name, int fd, 
412                         union smb_fileinfo *info)
413 {
414         NTSTATUS status = NT_STATUS_NOT_FOUND;
415         struct security_descriptor *sd;
416
417         if (pvfs->acl_ops) {
418                 status = pvfs->acl_ops->acl_load(pvfs, name, fd, req, &sd);
419         }
420         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
421                 status = pvfs_default_acl(pvfs, req, name, fd, &sd);
422         }
423         if (!NT_STATUS_IS_OK(status)) {
424                 return status;
425         }
426
427         normalise_sd_flags(sd, info->query_secdesc.in.secinfo_flags);
428
429         info->query_secdesc.out.sd = sd;
430
431         return NT_STATUS_OK;
432 }
433
434
435 /*
436   check the read only bit against any of the write access bits
437 */
438 static bool pvfs_read_only(struct pvfs_state *pvfs, uint32_t access_mask)
439 {
440         if ((pvfs->flags & PVFS_FLAG_READONLY) &&
441             (access_mask & (SEC_FILE_WRITE_DATA |
442                             SEC_FILE_APPEND_DATA | 
443                             SEC_FILE_WRITE_EA | 
444                             SEC_FILE_WRITE_ATTRIBUTE | 
445                             SEC_STD_DELETE | 
446                             SEC_STD_WRITE_DAC | 
447                             SEC_STD_WRITE_OWNER | 
448                             SEC_DIR_DELETE_CHILD))) {
449                 return true;
450         }
451         return false;
452 }
453
454 /*
455   see if we are a member of the appropriate unix group
456  */
457 static bool pvfs_group_member(struct pvfs_state *pvfs, gid_t gid)
458 {
459         int i, ngroups;
460         gid_t *groups;
461         if (getegid() == gid) {
462                 return true;
463         }
464         ngroups = getgroups(0, NULL);
465         if (ngroups == 0) {
466                 return false;
467         }
468         groups = talloc_array(pvfs, gid_t, ngroups);
469         if (groups == NULL) {
470                 return false;
471         }
472         if (getgroups(ngroups, groups) != ngroups) {
473                 talloc_free(groups);
474                 return false;
475         }
476         for (i=0; i<ngroups; i++) {
477                 if (groups[i] == gid) break;
478         }
479         talloc_free(groups);
480         return i < ngroups;
481 }
482
483 /*
484   default access check function based on unix permissions
485   doing this saves on building a full security descriptor
486   for the common case of access check on files with no 
487   specific NT ACL
488 */
489 NTSTATUS pvfs_access_check_unix(struct pvfs_state *pvfs, 
490                                 struct ntvfs_request *req,
491                                 struct pvfs_filename *name,
492                                 uint32_t *access_mask)
493 {
494         uid_t uid = geteuid();
495         uint32_t max_bits = SEC_RIGHTS_FILE_READ | SEC_FILE_ALL;
496         struct security_token *token = req->session_info->security_token;
497
498         if (pvfs_read_only(pvfs, *access_mask)) {
499                 return NT_STATUS_ACCESS_DENIED;
500         }
501
502         if (uid == name->st.st_uid) {
503                 max_bits |= SEC_STD_ALL;
504         } else if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
505                 max_bits |= SEC_STD_DELETE;
506         }
507
508         if ((name->st.st_mode & S_IWOTH) ||
509             ((name->st.st_mode & S_IWGRP) && 
510              pvfs_group_member(pvfs, name->st.st_gid))) {
511                 max_bits |= SEC_STD_ALL;
512         }
513
514         if (uwrap_enabled()) {
515                 /* when running with the uid wrapper, files will be created
516                    owned by the ruid, but we may have a different simulated 
517                    euid. We need to force the permission bits as though the 
518                    files owner matches the euid */
519                 max_bits |= SEC_STD_ALL;
520         }
521
522         if (*access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
523                 *access_mask |= max_bits;
524                 *access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
525         }
526
527         if ((*access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
528             security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
529                 max_bits |= SEC_FLAG_SYSTEM_SECURITY;
530         }
531         
532         if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_RESTORE) &&
533             security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
534                 max_bits |= ~(SEC_RIGHTS_PRIV_RESTORE);
535         }
536         if (((*access_mask & ~max_bits) & SEC_RIGHTS_PRIV_BACKUP) &&
537             security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
538                 max_bits |= ~(SEC_RIGHTS_PRIV_BACKUP);
539         }
540
541         if (*access_mask & ~max_bits) {
542                 DEBUG(0,(__location__ " denied access to '%s' - wanted 0x%08x but got 0x%08x (missing 0x%08x)\n",
543                          name->full_name, *access_mask, max_bits, *access_mask & ~max_bits));
544                 return NT_STATUS_ACCESS_DENIED;
545         }
546
547         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
548                 /* on SMB, this bit is always granted, even if not
549                    asked for */
550                 *access_mask |= SEC_FILE_READ_ATTRIBUTE;
551         }
552
553         return NT_STATUS_OK;
554 }
555
556
557 /*
558   check the security descriptor on a file, if any
559   
560   *access_mask is modified with the access actually granted
561 */
562 NTSTATUS pvfs_access_check(struct pvfs_state *pvfs, 
563                            struct ntvfs_request *req,
564                            struct pvfs_filename *name,
565                            uint32_t *access_mask)
566 {
567         struct security_token *token = req->session_info->security_token;
568         struct xattr_NTACL *acl;
569         NTSTATUS status;
570         struct security_descriptor *sd;
571
572         /* on SMB2 a blank access mask is always denied */
573         if (pvfs->ntvfs->ctx->protocol == PROTOCOL_SMB2 &&
574             *access_mask == 0) {
575                 return NT_STATUS_ACCESS_DENIED;
576         }
577
578         if (pvfs_read_only(pvfs, *access_mask)) {
579                 return NT_STATUS_ACCESS_DENIED;
580         }
581
582         acl = talloc(req, struct xattr_NTACL);
583         if (acl == NULL) {
584                 return NT_STATUS_NO_MEMORY;
585         }
586
587         /* expand the generic access bits to file specific bits */
588         *access_mask = pvfs_translate_mask(*access_mask);
589         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
590                 *access_mask &= ~SEC_FILE_READ_ATTRIBUTE;
591         }
592
593         status = pvfs_acl_load(pvfs, name, -1, acl);
594         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
595                 talloc_free(acl);
596                 return pvfs_access_check_unix(pvfs, req, name, access_mask);
597         }
598         if (!NT_STATUS_IS_OK(status)) {
599                 return status;
600         }
601
602         switch (acl->version) {
603         case 1:
604                 sd = acl->info.sd;
605                 break;
606         default:
607                 return NT_STATUS_INVALID_ACL;
608         }
609
610         /* check the acl against the required access mask */
611         status = sec_access_check(sd, token, *access_mask, access_mask);
612
613         if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
614                 /* on SMB, this bit is always granted, even if not
615                    asked for */
616                 *access_mask |= SEC_FILE_READ_ATTRIBUTE;
617         }
618
619         talloc_free(acl);
620         
621         return status;
622 }
623
624
625 /*
626   a simplified interface to access check, designed for calls that
627   do not take or return an access check mask
628 */
629 NTSTATUS pvfs_access_check_simple(struct pvfs_state *pvfs, 
630                                   struct ntvfs_request *req,
631                                   struct pvfs_filename *name,
632                                   uint32_t access_needed)
633 {
634         if (access_needed == 0) {
635                 return NT_STATUS_OK;
636         }
637         return pvfs_access_check(pvfs, req, name, &access_needed);
638 }
639
640 /*
641   access check for creating a new file/directory
642 */
643 NTSTATUS pvfs_access_check_create(struct pvfs_state *pvfs, 
644                                   struct ntvfs_request *req,
645                                   struct pvfs_filename *name,
646                                   uint32_t *access_mask)
647 {
648         struct pvfs_filename *parent;
649         NTSTATUS status;
650
651         status = pvfs_resolve_parent(pvfs, req, name, &parent);
652         if (!NT_STATUS_IS_OK(status)) {
653                 return status;
654         }
655
656         status = pvfs_access_check(pvfs, req, parent, access_mask);
657         if (!NT_STATUS_IS_OK(status)) {
658                 return status;
659         }
660
661         if (! ((*access_mask) & SEC_DIR_ADD_FILE)) {
662                 return pvfs_access_check_simple(pvfs, req, parent, SEC_DIR_ADD_FILE);
663         }
664
665         return status;
666 }
667
668 /*
669   access check for creating a new file/directory - no access mask supplied
670 */
671 NTSTATUS pvfs_access_check_parent(struct pvfs_state *pvfs, 
672                                   struct ntvfs_request *req,
673                                   struct pvfs_filename *name,
674                                   uint32_t access_mask)
675 {
676         struct pvfs_filename *parent;
677         NTSTATUS status;
678
679         status = pvfs_resolve_parent(pvfs, req, name, &parent);
680         if (!NT_STATUS_IS_OK(status)) {
681                 return status;
682         }
683
684         return pvfs_access_check_simple(pvfs, req, parent, access_mask);
685 }
686
687
688 /*
689   determine if an ACE is inheritable
690 */
691 static bool pvfs_inheritable_ace(struct pvfs_state *pvfs,
692                                  const struct security_ace *ace,
693                                  bool container)
694 {
695         if (!container) {
696                 return (ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT) != 0;
697         }
698
699         if (ace->flags & SEC_ACE_FLAG_CONTAINER_INHERIT) {
700                 return true;
701         }
702
703         if ((ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT) &&
704             !(ace->flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT)) {
705                 return true;
706         }
707
708         return false;
709 }
710
711 /*
712   this is the core of ACL inheritance. It copies any inheritable
713   aces from the parent SD to the child SD. Note that the algorithm 
714   depends on whether the child is a container or not
715 */
716 static NTSTATUS pvfs_acl_inherit_aces(struct pvfs_state *pvfs, 
717                                       struct security_descriptor *parent_sd,
718                                       struct security_descriptor *sd,
719                                       bool container)
720 {
721         int i;
722         
723         for (i=0;i<parent_sd->dacl->num_aces;i++) {
724                 struct security_ace ace = parent_sd->dacl->aces[i];
725                 NTSTATUS status;
726                 const struct dom_sid *creator = NULL, *new_id = NULL;
727                 uint32_t orig_flags;
728
729                 if (!pvfs_inheritable_ace(pvfs, &ace, container)) {
730                         continue;
731                 }
732
733                 orig_flags = ace.flags;
734
735                 /* see the RAW-ACLS inheritance test for details on these rules */
736                 if (!container) {
737                         ace.flags = 0;
738                 } else {
739                         ace.flags &= ~SEC_ACE_FLAG_INHERIT_ONLY;
740
741                         if (!(ace.flags & SEC_ACE_FLAG_CONTAINER_INHERIT)) {
742                                 ace.flags |= SEC_ACE_FLAG_INHERIT_ONLY;
743                         }
744                         if (ace.flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT) {
745                                 ace.flags = 0;
746                         }
747                 }
748
749                 /* the CREATOR sids are special when inherited */
750                 if (dom_sid_equal(&ace.trustee, pvfs->sid_cache.creator_owner)) {
751                         creator = pvfs->sid_cache.creator_owner;
752                         new_id = sd->owner_sid;
753                 } else if (dom_sid_equal(&ace.trustee, pvfs->sid_cache.creator_group)) {
754                         creator = pvfs->sid_cache.creator_group;
755                         new_id = sd->group_sid;
756                 } else {
757                         new_id = &ace.trustee;
758                 }
759
760                 if (creator && container && 
761                     (ace.flags & SEC_ACE_FLAG_CONTAINER_INHERIT)) {
762                         uint32_t flags = ace.flags;
763
764                         ace.trustee = *new_id;
765                         ace.flags = 0;
766                         status = security_descriptor_dacl_add(sd, &ace);
767                         if (!NT_STATUS_IS_OK(status)) {
768                                 return status;
769                         }
770
771                         ace.trustee = *creator;
772                         ace.flags = flags | SEC_ACE_FLAG_INHERIT_ONLY;
773                         status = security_descriptor_dacl_add(sd, &ace);
774                 } else if (container && 
775                            !(orig_flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT)) {
776                         status = security_descriptor_dacl_add(sd, &ace);
777                 } else {
778                         ace.trustee = *new_id;
779                         status = security_descriptor_dacl_add(sd, &ace);
780                 }
781
782                 if (!NT_STATUS_IS_OK(status)) {
783                         return status;
784                 }
785         }
786
787         return NT_STATUS_OK;
788 }
789
790
791
792 /*
793   setup an ACL on a new file/directory based on the inherited ACL from
794   the parent. If there is no inherited ACL then we don't set anything,
795   as the default ACL applies anyway
796 */
797 NTSTATUS pvfs_acl_inherit(struct pvfs_state *pvfs, 
798                           struct ntvfs_request *req,
799                           struct pvfs_filename *name,
800                           int fd)
801 {
802         struct xattr_NTACL *acl;
803         NTSTATUS status;
804         struct pvfs_filename *parent;
805         struct security_descriptor *parent_sd, *sd;
806         bool container;
807         struct id_mapping *ids;
808         struct composite_context *ctx;
809
810         /* form the parents path */
811         status = pvfs_resolve_parent(pvfs, req, name, &parent);
812         if (!NT_STATUS_IS_OK(status)) {
813                 return status;
814         }
815
816         acl = talloc(req, struct xattr_NTACL);
817         if (acl == NULL) {
818                 return NT_STATUS_NO_MEMORY;
819         }
820
821         status = pvfs_acl_load(pvfs, parent, -1, acl);
822         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
823                 return NT_STATUS_OK;
824         }
825         if (!NT_STATUS_IS_OK(status)) {
826                 return status;
827         }
828
829         switch (acl->version) {
830         case 1:
831                 parent_sd = acl->info.sd;
832                 break;
833         default:
834                 return NT_STATUS_INVALID_ACL;
835         }
836
837         if (parent_sd == NULL ||
838             parent_sd->dacl == NULL ||
839             parent_sd->dacl->num_aces == 0) {
840                 /* go with the default ACL */
841                 return NT_STATUS_OK;
842         }
843
844         /* create the new sd */
845         sd = security_descriptor_initialise(req);
846         if (sd == NULL) {
847                 return NT_STATUS_NO_MEMORY;
848         }
849
850         ids = talloc_array(sd, struct id_mapping, 2);
851         NT_STATUS_HAVE_NO_MEMORY(ids);
852
853         ids[0].unixid = talloc(ids, struct unixid);
854         NT_STATUS_HAVE_NO_MEMORY(ids[0].unixid);
855         ids[0].unixid->id = name->st.st_uid;
856         ids[0].unixid->type = ID_TYPE_UID;
857         ids[0].sid = NULL;
858         ids[0].status = NT_STATUS_NONE_MAPPED;
859
860         ids[1].unixid = talloc(ids, struct unixid);
861         NT_STATUS_HAVE_NO_MEMORY(ids[1].unixid);
862         ids[1].unixid->id = name->st.st_gid;
863         ids[1].unixid->type = ID_TYPE_GID;
864         ids[1].sid = NULL;
865         ids[1].status = NT_STATUS_NONE_MAPPED;
866
867         ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
868         NT_STATUS_HAVE_NO_MEMORY(ctx);
869
870         status = wbc_xids_to_sids_recv(ctx, &ids);
871         NT_STATUS_NOT_OK_RETURN(status);
872
873         sd->owner_sid = talloc_steal(sd, ids[0].sid);
874         sd->group_sid = talloc_steal(sd, ids[1].sid);
875
876         sd->type |= SEC_DESC_DACL_PRESENT;
877
878         container = (name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY) ? true:false;
879
880         /* fill in the aces from the parent */
881         status = pvfs_acl_inherit_aces(pvfs, parent_sd, sd, container);
882         if (!NT_STATUS_IS_OK(status)) {
883                 return status;
884         }
885
886         /* if there is nothing to inherit then we fallback to the
887            default acl */
888         if (sd->dacl == NULL || sd->dacl->num_aces == 0) {
889                 return NT_STATUS_OK;
890         }
891
892         acl->info.sd = sd;
893
894         status = pvfs_acl_save(pvfs, name, fd, acl);
895         
896         return status;
897 }
898
899 /*
900   return the maximum allowed access mask
901 */
902 NTSTATUS pvfs_access_maximal_allowed(struct pvfs_state *pvfs, 
903                                      struct ntvfs_request *req,
904                                      struct pvfs_filename *name,
905                                      uint32_t *maximal_access)
906 {
907         *maximal_access = SEC_FLAG_MAXIMUM_ALLOWED;
908         return pvfs_access_check(pvfs, req, name, maximal_access);
909 }