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