af23798732b08f3b1d5a4c2f807dc91e9bcfbf95
[dragonfly.git] / sys / kern / kern_acl.c
1 /*-
2  * Copyright (c) 1999, 2000 Robert N. M. Watson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/kern/kern_acl.c,v 1.2.2.1 2000/07/28 18:48:16 rwatson Exp $
27  * $DragonFly: src/sys/kern/kern_acl.c,v 1.17 2007/02/19 00:51:54 swildner Exp $
28  */
29
30 /*
31  * Generic routines to support file system ACLs, at a syntactic level
32  * Semantics are the responsibility of the underlying file system
33  */
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/sysproto.h>
38 #include <sys/kernel.h>
39 #include <sys/malloc.h>
40 #include <sys/vnode.h>
41 #include <sys/lock.h>
42 #include <sys/proc.h>
43 #include <sys/nlookup.h>
44 #include <sys/file.h>
45 #include <sys/sysent.h>
46 #include <sys/errno.h>
47 #include <sys/stat.h>
48 #include <sys/acl.h>
49
50 static int vacl_set_acl(struct vnode *vp, acl_type_t type, struct acl *aclp);
51 static int vacl_get_acl(struct vnode *vp, acl_type_t type, struct acl *aclp);
52 static int vacl_aclcheck(struct vnode *vp, acl_type_t type, struct acl *aclp);
53
54 /*
55  * These calls wrap the real vnode operations, and are called by the 
56  * syscall code once the syscall has converted the path or file
57  * descriptor to a vnode (unlocked).  The aclp pointer is assumed
58  * still to point to userland, so this should not be consumed within
59  * the kernel except by syscall code.  Other code should directly
60  * invoke VOP_{SET,GET}ACL.
61  */
62
63 /*
64  * Given a vnode, set its ACL.
65  */
66 static int
67 vacl_set_acl(struct vnode *vp, acl_type_t type, struct acl *aclp)
68 {
69         struct thread *td = curthread;
70         struct acl inkernacl;
71         struct ucred *ucred;
72         int error;
73
74         error = copyin(aclp, &inkernacl, sizeof(struct acl));
75         if (error)
76                 return(error);
77         KKASSERT(td->td_proc);
78         ucred = td->td_proc->p_ucred;
79
80         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
81         error = VOP_SETACL(vp, type, &inkernacl, ucred);
82         vn_unlock(vp);
83         return(error);
84 }
85
86 /*
87  * Given a vnode, get its ACL.
88  */
89 static int
90 vacl_get_acl(struct vnode *vp, acl_type_t type, struct acl *aclp)
91 {
92         struct thread *td = curthread;
93         struct acl inkernelacl;
94         struct ucred *ucred;
95         int error;
96
97         KKASSERT(td->td_proc);
98         ucred = td->td_proc->p_ucred;
99         error = VOP_GETACL(vp, type, &inkernelacl, ucred);
100         if (error == 0)
101                 error = copyout(&inkernelacl, aclp, sizeof(struct acl));
102         return (error);
103 }
104
105 /*
106  * Given a vnode, delete its ACL.
107  */
108 static int
109 vacl_delete(struct vnode *vp, acl_type_t type)
110 {
111         struct thread *td = curthread;
112         struct ucred *ucred;
113         int error;
114
115         KKASSERT(td->td_proc);
116         ucred = td->td_proc->p_ucred;
117         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
118         error = VOP_SETACL(vp, ACL_TYPE_DEFAULT, 0, ucred);
119         vn_unlock(vp);
120         return (error);
121 }
122
123 /*
124  * Given a vnode, check whether an ACL is appropriate for it
125  */
126 static int
127 vacl_aclcheck(struct vnode *vp, acl_type_t type, struct acl *aclp)
128 {
129         struct thread *td = curthread;
130         struct ucred *ucred;
131         struct acl inkernelacl;
132         int error;
133
134         KKASSERT(td->td_proc);
135         ucred = td->td_proc->p_ucred;
136         error = copyin(aclp, &inkernelacl, sizeof(struct acl));
137         if (error)
138                 return(error);
139         error = VOP_ACLCHECK(vp, type, &inkernelacl, ucred);
140         return (error);
141 }
142
143 /*
144  * syscalls -- convert the path/fd to a vnode, and call vacl_whatever.
145  * Don't need to lock, as the vacl_ code will get/release any locks
146  * required.
147  */
148
149 /*
150  * Given a file path, get an ACL for it
151  *
152  * MPALMOSTSAFE
153  */
154 int
155 sys___acl_get_file(struct __acl_get_file_args *uap)
156 {
157         struct nlookupdata nd;
158         struct vnode *vp;
159         int error;
160
161         vp = NULL;
162         get_mplock();
163         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
164         if (error == 0)
165                 error = nlookup(&nd);
166         if (error == 0)
167                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
168         nlookup_done(&nd);
169         if (error == 0) {
170                 error = vacl_get_acl(vp, uap->type, uap->aclp);
171                 vrele(vp);
172         }
173         rel_mplock();
174
175         return (error);
176 }
177
178 /*
179  * Given a file path, set an ACL for it
180  *
181  * MPALMOSTSAFE
182  */
183 int
184 sys___acl_set_file(struct __acl_set_file_args *uap)
185 {
186         struct nlookupdata nd;
187         struct vnode *vp;
188         int error;
189
190         vp = NULL;
191         get_mplock();
192         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
193         if (error == 0)
194                 error = nlookup(&nd);
195         if (error == 0)
196                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
197         nlookup_done(&nd);
198         if (error == 0) {
199                 error = vacl_set_acl(vp, uap->type, uap->aclp);
200                 vrele(vp);
201         }
202         rel_mplock();
203
204         return (error);
205 }
206
207 /*
208  * Given a file descriptor, get an ACL for it
209  *
210  * MPALMOSTSAFE
211  */
212 int
213 sys___acl_get_fd(struct __acl_get_fd_args *uap)
214 {
215         struct thread *td = curthread;
216         struct file *fp;
217         int error;
218
219         KKASSERT(td->td_proc);
220         if ((error = holdvnode(td->td_proc->p_fd, uap->filedes, &fp)) != 0)
221                 return(error);
222         get_mplock();
223         error = vacl_get_acl((struct vnode *)fp->f_data, uap->type, uap->aclp);
224         rel_mplock();
225         fdrop(fp);
226
227         return (error);
228 }
229
230 /*
231  * Given a file descriptor, set an ACL for it
232  *
233  * MPALMOSTSAFE
234  */
235 int
236 sys___acl_set_fd(struct __acl_set_fd_args *uap)
237 {
238         struct thread *td = curthread;
239         struct file *fp;
240         int error;
241
242         KKASSERT(td->td_proc);
243         if ((error = holdvnode(td->td_proc->p_fd, uap->filedes, &fp)) != 0)
244                 return(error);
245         get_mplock();
246         error = vacl_set_acl((struct vnode *)fp->f_data, uap->type, uap->aclp);
247         rel_mplock();
248         fdrop(fp);
249         return (error);
250 }
251
252 /*
253  * Given a file path, delete an ACL from it.
254  *
255  * MPALMOSTSAFE
256  */
257 int
258 sys___acl_delete_file(struct __acl_delete_file_args *uap)
259 {
260         struct nlookupdata nd;
261         struct vnode *vp;
262         int error;
263
264         vp = NULL;
265         get_mplock();
266         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
267         if (error == 0)
268                 error = nlookup(&nd);
269         if (error == 0)
270                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
271         nlookup_done(&nd);
272
273         if (error == 0) {
274                 error = vacl_delete(vp, uap->type);
275                 vrele(vp);
276         }
277         rel_mplock();
278
279         return (error);
280 }
281
282 /*
283  * Given a file path, delete an ACL from it.
284  *
285  * MPALMOSTSAFE
286  */
287 int
288 sys___acl_delete_fd(struct __acl_delete_fd_args *uap)
289 {
290         struct thread *td = curthread;
291         struct file *fp;
292         int error;
293
294         KKASSERT(td->td_proc);
295         if ((error = holdvnode(td->td_proc->p_fd, uap->filedes, &fp)) != 0)
296                 return(error);
297         get_mplock();
298         error = vacl_delete((struct vnode *)fp->f_data, uap->type);
299         rel_mplock();
300         fdrop(fp);
301         return (error);
302 }
303
304 /*
305  * Given a file path, check an ACL for it
306  *
307  * MPALMOSTSAFE
308  */
309 int
310 sys___acl_aclcheck_file(struct __acl_aclcheck_file_args *uap)
311 {
312         struct nlookupdata nd;
313         struct vnode *vp;
314         int error;
315
316         vp = NULL;
317         get_mplock();
318         error = nlookup_init(&nd, uap->path, UIO_USERSPACE, NLC_FOLLOW);
319         if (error == 0)
320                 error = nlookup(&nd);
321         if (error == 0)
322                 error = cache_vref(&nd.nl_nch, nd.nl_cred, &vp);
323         nlookup_done(&nd);
324
325         if (error == 0) {
326                 error = vacl_aclcheck(vp, uap->type, uap->aclp);
327                 vrele(vp);
328         }
329         rel_mplock();
330         return (error);
331 }
332
333 /*
334  * Given a file descriptor, check an ACL for it
335  *
336  * MPALMOSTSAFE
337  */
338 int
339 sys___acl_aclcheck_fd(struct __acl_aclcheck_fd_args *uap)
340 {
341         struct thread *td = curthread;
342         struct file *fp;
343         int error;
344
345         KKASSERT(td->td_proc);
346         if ((error = holdvnode(td->td_proc->p_fd, uap->filedes, &fp)) != 0)
347                 return(error);
348         get_mplock();
349         error = vacl_aclcheck((struct vnode *)fp->f_data, uap->type, uap->aclp);
350         rel_mplock();
351         fdrop(fp);
352         return (error);
353 }
354