Fix include paths to new location of libutil.
[kai/samba-autobuild/.git] / source4 / ntvfs / posix / pvfs_acl_nfs4.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    POSIX NTVFS backend - NT ACLs mapped to NFS4 ACLs, as per
5    http://www.suse.de/~agruen/nfs4acl/
6
7    Copyright (C) Andrew Tridgell 2006
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "vfs_posix.h"
25 #include "../lib/util/unix_privs.h"
26 #include "librpc/gen_ndr/ndr_nfs4acl.h"
27 #include "libcli/security/security.h"
28
29 #define ACE4_IDENTIFIER_GROUP 0x40
30
31 /*
32   load the current ACL from system.nfs4acl
33 */
34 static NTSTATUS pvfs_acl_load_nfs4(struct pvfs_state *pvfs, struct pvfs_filename *name, int fd,
35                                    TALLOC_CTX *mem_ctx,
36                                    struct security_descriptor **psd)
37 {
38         NTSTATUS status;
39         struct nfs4acl *acl;
40         struct security_descriptor *sd;
41         int i, num_ids;
42         struct id_mapping *ids;
43         struct composite_context *ctx;
44
45         acl = talloc_zero(mem_ctx, struct nfs4acl);
46         NT_STATUS_HAVE_NO_MEMORY(acl);
47
48         status = pvfs_xattr_ndr_load(pvfs, mem_ctx, name->full_name, fd, 
49                                      NFS4ACL_XATTR_NAME,
50                                      acl, ndr_pull_nfs4acl);
51         if (!NT_STATUS_IS_OK(status)) {
52                 talloc_free(acl);
53                 return status;
54         }
55
56         *psd = security_descriptor_initialise(mem_ctx);
57         NT_STATUS_HAVE_NO_MEMORY(*psd);
58
59         sd = *psd;
60
61         sd->type |= acl->a_flags;
62
63         /* the number of ids to map is the acl count plus uid and gid */
64         num_ids = acl->a_count +2;
65         ids = talloc_array(sd, struct id_mapping, num_ids);
66         NT_STATUS_HAVE_NO_MEMORY(ids);
67
68         ids[0].unixid = talloc(ids, struct unixid);
69         NT_STATUS_HAVE_NO_MEMORY(ids[0].unixid);
70         ids[0].unixid->id = name->st.st_uid;
71         ids[0].unixid->type = ID_TYPE_UID;
72         ids[0].sid = NULL;
73         ids[0].status = NT_STATUS_NONE_MAPPED;
74
75         ids[1].unixid = talloc(ids, struct unixid);
76         NT_STATUS_HAVE_NO_MEMORY(ids[1].unixid);
77         ids[1].unixid->id = name->st.st_gid;
78         ids[1].unixid->type = ID_TYPE_GID;
79         ids[1].sid = NULL;
80         ids[1].status = NT_STATUS_NONE_MAPPED;
81
82         for (i=0;i<acl->a_count;i++) {
83                 struct nfs4ace *a = &acl->ace[i];
84                 ids[i+2].unixid = talloc(ids, struct unixid);
85                 NT_STATUS_HAVE_NO_MEMORY(ids[i+2].unixid);
86                 ids[i+2].unixid->id = a->e_id;
87                 if (a->e_flags & ACE4_IDENTIFIER_GROUP) {
88                         ids[i+2].unixid->type = ID_TYPE_GID;
89                 } else {
90                         ids[i+2].unixid->type = ID_TYPE_UID;
91                 }
92                 ids[i+2].sid = NULL;
93                 ids[i+2].status = NT_STATUS_NONE_MAPPED;
94         }
95
96         /* Allocate memory for the sids from the security descriptor to be on
97          * the safe side. */
98         ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, sd, num_ids, ids);
99         NT_STATUS_HAVE_NO_MEMORY(ctx);
100         status = wbc_xids_to_sids_recv(ctx, &ids);
101         NT_STATUS_NOT_OK_RETURN(status);
102
103         sd->owner_sid = talloc_steal(sd, ids[0].sid);
104         sd->group_sid = talloc_steal(sd, ids[1].sid);
105
106         for (i=0;i<acl->a_count;i++) {
107                 struct nfs4ace *a = &acl->ace[i];
108                 struct security_ace ace;
109                 ace.type = a->e_type;
110                 ace.flags = a->e_flags;
111                 ace.access_mask = a->e_mask;
112                 ace.trustee = *ids[i+2].sid;
113                 security_descriptor_dacl_add(sd, &ace);
114         }
115
116         return NT_STATUS_OK;
117 }
118
119 /*
120   save the acl for a file into system.nfs4acl
121 */
122 static NTSTATUS pvfs_acl_save_nfs4(struct pvfs_state *pvfs, struct pvfs_filename *name, int fd,
123                                    struct security_descriptor *sd)
124 {
125         NTSTATUS status;
126         void *privs;
127         struct nfs4acl acl;
128         int i;
129         TALLOC_CTX *tmp_ctx;
130         struct id_mapping *ids;
131         struct composite_context *ctx;
132
133         tmp_ctx = talloc_new(pvfs);
134         NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
135
136         acl.a_version = 0;
137         acl.a_flags   = sd->type;
138         acl.a_count   = sd->dacl?sd->dacl->num_aces:0;
139         acl.a_owner_mask = 0;
140         acl.a_group_mask = 0;
141         acl.a_other_mask = 0;
142
143         acl.ace = talloc_array(tmp_ctx, struct nfs4ace, acl.a_count);
144         if (!acl.ace) {
145                 talloc_free(tmp_ctx);
146                 return NT_STATUS_NO_MEMORY;
147         }
148
149         ids = talloc_array(tmp_ctx, struct id_mapping, acl.a_count);
150         if (ids == NULL) {
151                 talloc_free(tmp_ctx);
152                 return NT_STATUS_NO_MEMORY;
153         }
154
155         for (i=0;i<acl.a_count;i++) {
156                 struct security_ace *ace = &sd->dacl->aces[i];
157                 ids[i].unixid = NULL;
158                 ids[i].sid = dom_sid_dup(ids, &ace->trustee);
159                 if (ids[i].sid == NULL) {
160                         talloc_free(tmp_ctx);
161                         return NT_STATUS_NO_MEMORY;
162                 }
163                 ids[i].status = NT_STATUS_NONE_MAPPED;
164         }
165
166         ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx,ids, acl.a_count, ids);
167         if (ctx == NULL) {
168                 talloc_free(tmp_ctx);
169                 return NT_STATUS_NO_MEMORY;
170         }
171         status = wbc_sids_to_xids_recv(ctx, &ids);
172         if (!NT_STATUS_IS_OK(status)) {
173                 talloc_free(tmp_ctx);
174                 return status;
175         }
176
177         for (i=0;i<acl.a_count;i++) {
178                 struct nfs4ace *a = &acl.ace[i];
179                 struct security_ace *ace = &sd->dacl->aces[i];
180                 a->e_type  = ace->type;
181                 a->e_flags = ace->flags;
182                 a->e_mask  = ace->access_mask;
183                 if (ids[i].unixid->type != ID_TYPE_UID) {
184                         a->e_flags |= ACE4_IDENTIFIER_GROUP;
185                 }
186                 a->e_id = ids[i].unixid->id;
187                 a->e_who   = "";
188         }
189
190         privs = root_privileges();
191         status = pvfs_xattr_ndr_save(pvfs, name->full_name, fd, 
192                                      NFS4ACL_XATTR_NAME, 
193                                      &acl, ndr_push_nfs4acl);
194         talloc_free(privs);
195
196         talloc_free(tmp_ctx);
197         return status;
198 }
199
200
201 /*
202   initialise pvfs acl NFS4 backend
203 */
204 NTSTATUS pvfs_acl_nfs4_init(void)
205 {
206         struct pvfs_acl_ops ops = {
207                 .name = "nfs4acl",
208                 .acl_load = pvfs_acl_load_nfs4,
209                 .acl_save = pvfs_acl_save_nfs4
210         };
211         return pvfs_acl_register(&ops);
212 }