hfsplus: creation of hidden dir on mount can fail
[linux-2.6.git] / fs / afs / security.c
1 /* AFS security handling
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/fs.h>
15 #include <linux/ctype.h>
16 #include <linux/sched.h>
17 #include <keys/rxrpc-type.h>
18 #include "internal.h"
19
20 /*
21  * get a key
22  */
23 struct key *afs_request_key(struct afs_cell *cell)
24 {
25         struct key *key;
26
27         _enter("{%x}", key_serial(cell->anonymous_key));
28
29         _debug("key %s", cell->anonymous_key->description);
30         key = request_key(&key_type_rxrpc, cell->anonymous_key->description,
31                           NULL);
32         if (IS_ERR(key)) {
33                 if (PTR_ERR(key) != -ENOKEY) {
34                         _leave(" = %ld", PTR_ERR(key));
35                         return key;
36                 }
37
38                 /* act as anonymous user */
39                 _leave(" = {%x} [anon]", key_serial(cell->anonymous_key));
40                 return key_get(cell->anonymous_key);
41         } else {
42                 /* act as authorised user */
43                 _leave(" = {%x} [auth]", key_serial(key));
44                 return key;
45         }
46 }
47
48 /*
49  * dispose of a permits list
50  */
51 void afs_zap_permits(struct rcu_head *rcu)
52 {
53         struct afs_permits *permits =
54                 container_of(rcu, struct afs_permits, rcu);
55         int loop;
56
57         _enter("{%d}", permits->count);
58
59         for (loop = permits->count - 1; loop >= 0; loop--)
60                 key_put(permits->permits[loop].key);
61         kfree(permits);
62 }
63
64 /*
65  * dispose of a permits list in which all the key pointers have been copied
66  */
67 static void afs_dispose_of_permits(struct rcu_head *rcu)
68 {
69         struct afs_permits *permits =
70                 container_of(rcu, struct afs_permits, rcu);
71
72         _enter("{%d}", permits->count);
73
74         kfree(permits);
75 }
76
77 /*
78  * get the authorising vnode - this is the specified inode itself if it's a
79  * directory or it's the parent directory if the specified inode is a file or
80  * symlink
81  * - the caller must release the ref on the inode
82  */
83 static struct afs_vnode *afs_get_auth_inode(struct afs_vnode *vnode,
84                                             struct key *key)
85 {
86         struct afs_vnode *auth_vnode;
87         struct inode *auth_inode;
88
89         _enter("");
90
91         if (S_ISDIR(vnode->vfs_inode.i_mode)) {
92                 auth_inode = igrab(&vnode->vfs_inode);
93                 ASSERT(auth_inode != NULL);
94         } else {
95                 auth_inode = afs_iget(vnode->vfs_inode.i_sb, key,
96                                       &vnode->status.parent, NULL, NULL);
97                 if (IS_ERR(auth_inode))
98                         return ERR_CAST(auth_inode);
99         }
100
101         auth_vnode = AFS_FS_I(auth_inode);
102         _leave(" = {%x}", auth_vnode->fid.vnode);
103         return auth_vnode;
104 }
105
106 /*
107  * clear the permit cache on a directory vnode
108  */
109 void afs_clear_permits(struct afs_vnode *vnode)
110 {
111         struct afs_permits *permits;
112
113         _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
114
115         mutex_lock(&vnode->permits_lock);
116         permits = vnode->permits;
117         rcu_assign_pointer(vnode->permits, NULL);
118         mutex_unlock(&vnode->permits_lock);
119
120         if (permits)
121                 call_rcu(&permits->rcu, afs_zap_permits);
122         _leave("");
123 }
124
125 /*
126  * add the result obtained for a vnode to its or its parent directory's cache
127  * for the key used to access it
128  */
129 void afs_cache_permit(struct afs_vnode *vnode, struct key *key, long acl_order)
130 {
131         struct afs_permits *permits, *xpermits;
132         struct afs_permit *permit;
133         struct afs_vnode *auth_vnode;
134         int count, loop;
135
136         _enter("{%x:%u},%x,%lx",
137                vnode->fid.vid, vnode->fid.vnode, key_serial(key), acl_order);
138
139         auth_vnode = afs_get_auth_inode(vnode, key);
140         if (IS_ERR(auth_vnode)) {
141                 _leave(" [get error %ld]", PTR_ERR(auth_vnode));
142                 return;
143         }
144
145         mutex_lock(&auth_vnode->permits_lock);
146
147         /* guard against a rename being detected whilst we waited for the
148          * lock */
149         if (memcmp(&auth_vnode->fid, &vnode->status.parent,
150                    sizeof(struct afs_fid)) != 0) {
151                 _debug("renamed");
152                 goto out_unlock;
153         }
154
155         /* have to be careful as the directory's callback may be broken between
156          * us receiving the status we're trying to cache and us getting the
157          * lock to update the cache for the status */
158         if (auth_vnode->acl_order - acl_order > 0) {
159                 _debug("ACL changed?");
160                 goto out_unlock;
161         }
162
163         /* always update the anonymous mask */
164         _debug("anon access %x", vnode->status.anon_access);
165         auth_vnode->status.anon_access = vnode->status.anon_access;
166         if (key == vnode->volume->cell->anonymous_key)
167                 goto out_unlock;
168
169         xpermits = auth_vnode->permits;
170         count = 0;
171         if (xpermits) {
172                 /* see if the permit is already in the list
173                  * - if it is then we just amend the list
174                  */
175                 count = xpermits->count;
176                 permit = xpermits->permits;
177                 for (loop = count; loop > 0; loop--) {
178                         if (permit->key == key) {
179                                 permit->access_mask =
180                                         vnode->status.caller_access;
181                                 goto out_unlock;
182                         }
183                         permit++;
184                 }
185         }
186
187         permits = kmalloc(sizeof(*permits) + sizeof(*permit) * (count + 1),
188                           GFP_NOFS);
189         if (!permits)
190                 goto out_unlock;
191
192         if (xpermits)
193                 memcpy(permits->permits, xpermits->permits,
194                         count * sizeof(struct afs_permit));
195
196         _debug("key %x access %x",
197                key_serial(key), vnode->status.caller_access);
198         permits->permits[count].access_mask = vnode->status.caller_access;
199         permits->permits[count].key = key_get(key);
200         permits->count = count + 1;
201
202         rcu_assign_pointer(auth_vnode->permits, permits);
203         if (xpermits)
204                 call_rcu(&xpermits->rcu, afs_dispose_of_permits);
205
206 out_unlock:
207         mutex_unlock(&auth_vnode->permits_lock);
208         iput(&auth_vnode->vfs_inode);
209         _leave("");
210 }
211
212 /*
213  * check with the fileserver to see if the directory or parent directory is
214  * permitted to be accessed with this authorisation, and if so, what access it
215  * is granted
216  */
217 static int afs_check_permit(struct afs_vnode *vnode, struct key *key,
218                             afs_access_t *_access)
219 {
220         struct afs_permits *permits;
221         struct afs_permit *permit;
222         struct afs_vnode *auth_vnode;
223         bool valid;
224         int loop, ret;
225
226         _enter("{%x:%u},%x",
227                vnode->fid.vid, vnode->fid.vnode, key_serial(key));
228
229         auth_vnode = afs_get_auth_inode(vnode, key);
230         if (IS_ERR(auth_vnode)) {
231                 *_access = 0;
232                 _leave(" = %ld", PTR_ERR(auth_vnode));
233                 return PTR_ERR(auth_vnode);
234         }
235
236         ASSERT(S_ISDIR(auth_vnode->vfs_inode.i_mode));
237
238         /* check the permits to see if we've got one yet */
239         if (key == auth_vnode->volume->cell->anonymous_key) {
240                 _debug("anon");
241                 *_access = auth_vnode->status.anon_access;
242                 valid = true;
243         } else {
244                 valid = false;
245                 rcu_read_lock();
246                 permits = rcu_dereference(auth_vnode->permits);
247                 if (permits) {
248                         permit = permits->permits;
249                         for (loop = permits->count; loop > 0; loop--) {
250                                 if (permit->key == key) {
251                                         _debug("found in cache");
252                                         *_access = permit->access_mask;
253                                         valid = true;
254                                         break;
255                                 }
256                                 permit++;
257                         }
258                 }
259                 rcu_read_unlock();
260         }
261
262         if (!valid) {
263                 /* check the status on the file we're actually interested in
264                  * (the post-processing will cache the result on auth_vnode) */
265                 _debug("no valid permit");
266
267                 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
268                 ret = afs_vnode_fetch_status(vnode, auth_vnode, key);
269                 if (ret < 0) {
270                         iput(&auth_vnode->vfs_inode);
271                         *_access = 0;
272                         _leave(" = %d", ret);
273                         return ret;
274                 }
275                 *_access = vnode->status.caller_access;
276         }
277
278         iput(&auth_vnode->vfs_inode);
279         _leave(" = 0 [access %x]", *_access);
280         return 0;
281 }
282
283 /*
284  * check the permissions on an AFS file
285  * - AFS ACLs are attached to directories only, and a file is controlled by its
286  *   parent directory's ACL
287  */
288 int afs_permission(struct inode *inode, int mask)
289 {
290         struct afs_vnode *vnode = AFS_FS_I(inode);
291         afs_access_t uninitialized_var(access);
292         struct key *key;
293         int ret;
294
295         if (mask & MAY_NOT_BLOCK)
296                 return -ECHILD;
297
298         _enter("{{%x:%u},%lx},%x,",
299                vnode->fid.vid, vnode->fid.vnode, vnode->flags, mask);
300
301         key = afs_request_key(vnode->volume->cell);
302         if (IS_ERR(key)) {
303                 _leave(" = %ld [key]", PTR_ERR(key));
304                 return PTR_ERR(key);
305         }
306
307         /* if the promise has expired, we need to check the server again */
308         if (!vnode->cb_promised) {
309                 _debug("not promised");
310                 ret = afs_vnode_fetch_status(vnode, NULL, key);
311                 if (ret < 0)
312                         goto error;
313                 _debug("new promise [fl=%lx]", vnode->flags);
314         }
315
316         /* check the permits to see if we've got one yet */
317         ret = afs_check_permit(vnode, key, &access);
318         if (ret < 0)
319                 goto error;
320
321         /* interpret the access mask */
322         _debug("REQ %x ACC %x on %s",
323                mask, access, S_ISDIR(inode->i_mode) ? "dir" : "file");
324
325         if (S_ISDIR(inode->i_mode)) {
326                 if (mask & MAY_EXEC) {
327                         if (!(access & AFS_ACE_LOOKUP))
328                                 goto permission_denied;
329                 } else if (mask & MAY_READ) {
330                         if (!(access & AFS_ACE_READ))
331                                 goto permission_denied;
332                 } else if (mask & MAY_WRITE) {
333                         if (!(access & (AFS_ACE_DELETE | /* rmdir, unlink, rename from */
334                                         AFS_ACE_INSERT | /* create, mkdir, symlink, rename to */
335                                         AFS_ACE_WRITE))) /* chmod */
336                                 goto permission_denied;
337                 } else {
338                         BUG();
339                 }
340         } else {
341                 if (!(access & AFS_ACE_LOOKUP))
342                         goto permission_denied;
343                 if (mask & (MAY_EXEC | MAY_READ)) {
344                         if (!(access & AFS_ACE_READ))
345                                 goto permission_denied;
346                 } else if (mask & MAY_WRITE) {
347                         if (!(access & AFS_ACE_WRITE))
348                                 goto permission_denied;
349                 }
350         }
351
352         key_put(key);
353         ret = generic_permission(inode, mask);
354         _leave(" = %d", ret);
355         return ret;
356
357 permission_denied:
358         ret = -EACCES;
359 error:
360         key_put(key);
361         _leave(" = %d", ret);
362         return ret;
363 }