afs: Remove useless afs_GetVCache arguments
[openafs.git] / src / afs / VNOPS / afs_vnop_access.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * afs_vnop_access.c - access vop ccess mode bit support for vnode operations.
12  *
13  * Implements:
14  * afs_GetAccessBits
15  * afs_AccessOK
16  * afs_access
17  *
18  * Local:
19  * fileModeMap (table)
20  */
21
22 #include <afsconfig.h>
23 #include "afs/param.h"
24
25
26 #include "afs/sysincludes.h"    /* Standard vendor system headers */
27 #include "afsincludes.h"        /* Afs-based standard headers */
28 #include "afs/afs_stats.h"      /* statistics */
29 #include "afs/afs_cbqueue.h"
30 #include "afs/nfsclient.h"
31 #include "afs/afs_osidnlc.h"
32
33 #ifndef ANONYMOUSID
34 #define ANONYMOUSID     32766   /* make sure this is same as in ptserver.h */
35 #endif
36
37
38
39
40 /* access bits to turn off for various owner Unix mode values */
41 static char fileModeMap[8] = {
42     PRSFS_READ | PRSFS_WRITE,
43     PRSFS_READ | PRSFS_WRITE,
44     PRSFS_READ,
45     PRSFS_READ,
46     PRSFS_WRITE,
47     PRSFS_WRITE,
48     0,
49     0
50 };
51
52 /* avc must be held.  Returns bit map of mode bits.  Ignores file mode bits */
53 afs_int32
54 afs_GetAccessBits(struct vcache *avc, afs_int32 arights,
55                   struct vrequest *areq)
56 {
57     AFS_STATCNT(afs_GetAccessBits);
58     /* see if anyuser has the required access bits */
59     if ((arights & avc->f.anyAccess) == arights) {
60         return arights;
61     }
62
63     /* look in per-pag cache */
64     if (avc->Access) {          /* not beautiful, but Sun's cc will tolerate it */
65         struct axscache *ac;
66
67         ac = afs_FindAxs(avc->Access, areq->uid);
68         if (ac) {
69             return (arights & ac->axess);
70         }
71     }
72
73     if (!(avc->f.states & CForeign)) {
74         /* If there aren't any bits cached for this user (but the vnode
75          * _is_ cached, obviously), make sure this user has valid tokens
76          * before bothering with the RPC.  */
77         struct unixuser *tu;
78         tu = afs_FindUser(areq->uid, avc->f.fid.Cell, READ_LOCK);
79         if (!tu) {
80             return (arights & avc->f.anyAccess);
81         }
82         if (!(tu->states & UHasTokens) || (tu->states & UTokensBad)) {
83             afs_PutUser(tu, READ_LOCK);
84             return (arights & avc->f.anyAccess);
85         } else {
86             afs_PutUser(tu, READ_LOCK);
87         }
88     }
89
90     if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
91         /* If we get this far, we have to ask the network. But we can't, so
92          * they're out of luck... */
93         return 0;
94     } else
95     {                           /* Ok, user has valid tokens, go ask the server. */
96         struct AFSFetchStatus OutStatus;
97         afs_int32 code;
98
99         code = afs_FetchStatus(avc, &avc->f.fid, areq, &OutStatus);
100         return (code ? 0 : OutStatus.CallerAccess & arights);
101     }
102 }
103
104
105 /* the new access ok function.  AVC must be held but not locked. if avc is a
106  * file, its parent need not be held, and should not be locked. */
107
108 int
109 afs_AccessOK(struct vcache *avc, afs_int32 arights, struct vrequest *areq,
110              afs_int32 check_mode_bits)
111 {
112     struct vcache *tvc;
113     struct VenusFid dirFid;
114     afs_int32 mask;
115     afs_int32 dirBits;
116     afs_int32 fileBits;
117
118     AFS_STATCNT(afs_AccessOK);
119
120     if ((vType(avc) == VDIR) || (avc->f.states & CForeign)) {
121         /* rights are just those from acl */
122         if (afs_InReadDir(avc)) {
123             /* if we are already in readdir, then they may have read and
124              * lookup, and nothing else, and nevermind the real ACL.
125              * Otherwise we might end up with problems trying to call
126              * FetchStatus on the vnode readdir is working on, and that
127              * would be a real mess.
128              */
129             dirBits = PRSFS_LOOKUP | PRSFS_READ;
130             return (arights == (dirBits & arights));
131         }
132         return (arights == afs_GetAccessBits(avc, arights, areq));
133     } else {
134         /* some rights come from dir and some from file.  Specifically, you 
135          * have "a" rights to a file if you are its owner, which comes
136          * back as "a" rights to the file. You have other rights just
137          * from dir, but all are restricted by the file mode bit. Now,
138          * if you have I and A rights to a file, we throw in R and W
139          * rights for free. These rights will then be restricted by
140          * the access mask. */
141         dirBits = 0;
142         if (avc->f.parent.vnode) {
143             dirFid.Cell = avc->f.fid.Cell;
144             dirFid.Fid.Volume = avc->f.fid.Fid.Volume;
145             dirFid.Fid.Vnode = avc->f.parent.vnode;
146             dirFid.Fid.Unique = avc->f.parent.unique;
147             /* Avoid this GetVCache call */
148             tvc = afs_GetVCache(&dirFid, areq);
149             if (tvc) {
150                 dirBits = afs_GetAccessBits(tvc, arights, areq);
151                 afs_PutVCache(tvc);
152             }
153         } else
154             dirBits = 0xffffffff;       /* assume OK; this is a race condition */
155         if (arights & PRSFS_ADMINISTER)
156             fileBits = afs_GetAccessBits(avc, arights, areq);
157         else
158             fileBits = 0;       /* don't make call if results don't matter */
159
160         /* compute basic rights in fileBits, taking A from file bits */
161         fileBits =
162             (fileBits & PRSFS_ADMINISTER) | (dirBits & ~PRSFS_ADMINISTER);
163
164         /* for files, throw in R and W if have I and A (owner).  This makes
165          * insert-only dirs work properly */
166         if (vType(avc) != VDIR
167             && (fileBits & (PRSFS_ADMINISTER | PRSFS_INSERT)) ==
168             (PRSFS_ADMINISTER | PRSFS_INSERT))
169             fileBits |= (PRSFS_READ | PRSFS_WRITE);
170
171         if (check_mode_bits & CHECK_MODE_BITS) {
172             /* owner mode bits are further restrictions on the access mode
173              * The mode bits are mapped to protection bits through the
174              * fileModeMap. If CMB_ALLOW_EXEC_AS_READ is set, it's from the
175              * NFS translator and we don't know if it's a read or execute
176              * on the NFS client, but both need to read the data.
177              */
178             mask = (avc->f.m.Mode & 0700) >> 6; /* file restrictions to use */
179             fileBits &= ~fileModeMap[mask];
180             if (check_mode_bits & CMB_ALLOW_EXEC_AS_READ) {
181                 if (avc->f.m.Mode & 0100)
182                     fileBits |= PRSFS_READ;
183             }
184         }
185         return ((fileBits & arights) == arights);       /* true if all rights bits are on */
186     }
187 }
188
189
190 #if defined(AFS_SUN5_ENV) || (defined(AFS_SGI_ENV) && !defined(AFS_SGI65_ENV))
191 int
192 afs_access(OSI_VC_DECL(avc), afs_int32 amode, int flags,
193            afs_ucred_t *acred)
194 #else
195 int
196 afs_access(OSI_VC_DECL(avc), afs_int32 amode,
197            afs_ucred_t *acred)
198 #endif
199 {
200     afs_int32 code;
201     struct vrequest *treq = NULL;
202     struct afs_fakestat_state fakestate;
203     OSI_VC_CONVERT(avc);
204
205     AFS_STATCNT(afs_access);
206     afs_Trace3(afs_iclSetp, CM_TRACE_ACCESS, ICL_TYPE_POINTER, avc,
207                ICL_TYPE_INT32, amode, ICL_TYPE_OFFSET,
208                ICL_HANDLE_OFFSET(avc->f.m.Length));
209
210     afs_InitFakeStat(&fakestate);
211     if ((code = afs_CreateReq(&treq, acred))) {
212         return code;
213     }
214
215     AFS_DISCON_LOCK();
216
217     if (afs_fakestat_enable && avc->mvstat == AFS_MVSTAT_MTPT) {
218         code = afs_TryEvalFakeStat(&avc, &fakestate, treq);
219         if (code == 0 && avc->mvstat == AFS_MVSTAT_MTPT) {
220             afs_PutFakeStat(&fakestate);
221             AFS_DISCON_UNLOCK();
222             afs_DestroyReq(treq);
223             return 0;
224         }
225     } else {
226         code = afs_EvalFakeStat(&avc, &fakestate, treq);
227     }
228
229     if (code) {
230         afs_PutFakeStat(&fakestate);
231         AFS_DISCON_UNLOCK();
232         afs_DestroyReq(treq);
233         return code;
234     }
235
236     if (vType(avc) != VDIR || !afs_InReadDir(avc)) {
237         code = afs_VerifyVCache(avc, treq);
238         if (code) {
239             afs_PutFakeStat(&fakestate);
240             AFS_DISCON_UNLOCK();
241             code = afs_CheckCode(code, treq, 16);
242             afs_DestroyReq(treq);
243             return code;
244         }
245     }
246
247     /* if we're looking for write access and we have a read-only file system, report it */
248     if ((amode & VWRITE) && (avc->f.states & CRO)) {
249         afs_PutFakeStat(&fakestate);
250         AFS_DISCON_UNLOCK();
251         afs_DestroyReq(treq);
252         return EROFS;
253     }
254     
255     /* If we're looking for write access, and we're disconnected without logging, forget it */
256     if ((amode & VWRITE) && (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW)) {
257         afs_PutFakeStat(&fakestate);
258         AFS_DISCON_UNLOCK();
259         /* printf("Network is down in afs_vnop_access\n"); */
260         afs_DestroyReq(treq);
261         return ENETDOWN;
262     }
263     
264     code = 1;                   /* Default from here on in is access ok. */
265     if (avc->f.states & CForeign) {
266         /* In the dfs xlator the EXEC bit is mapped to LOOKUP */
267         if (amode & VEXEC)
268             code = afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
269         if (code && (amode & VWRITE)) {
270             code = afs_AccessOK(avc, PRSFS_WRITE, treq, CHECK_MODE_BITS);
271             if (code && (vType(avc) == VDIR)) {
272                 if (code)
273                     code =
274                         afs_AccessOK(avc, PRSFS_INSERT, treq,
275                                      CHECK_MODE_BITS);
276                 if (!code)
277                     code =
278                         afs_AccessOK(avc, PRSFS_DELETE, treq,
279                                      CHECK_MODE_BITS);
280             }
281         }
282         if (code && (amode & VREAD))
283             code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
284     } else {
285         if (vType(avc) == VDIR) {
286             if (amode & VEXEC)
287                 code =
288                     afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
289             if (code && (amode & VWRITE)) {
290                 code =
291                     afs_AccessOK(avc, PRSFS_INSERT, treq, CHECK_MODE_BITS);
292                 if (!code)
293                     code =
294                         afs_AccessOK(avc, PRSFS_DELETE, treq,
295                                      CHECK_MODE_BITS);
296             }
297             if (code && (amode & VREAD))
298                 code =
299                     afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
300         } else {
301             if (amode & VEXEC) {
302                 code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
303                 if (code) {
304                         if ((avc->f.m.Mode & 0100) == 0)
305                             code = 0;
306                 } else if (avc->f.m.Mode & 0100)
307                     code = 1;
308             }
309             if (code && (amode & VWRITE)) {
310                 code = afs_AccessOK(avc, PRSFS_WRITE, treq, CHECK_MODE_BITS);
311
312                 /* The above call fails when the NFS translator tries to copy
313                  ** a file with r--r--r-- permissions into a directory which
314                  ** has system:anyuser acl. This is because the destination file
315                  ** file is first created with r--r--r-- permissions through an
316                  ** unauthenticated connectin.  hence, the above afs_AccessOK
317                  ** call returns failure. hence, we retry without any file 
318                  ** mode bit checking */
319                 if (!code && AFS_NFSXLATORREQ(acred)
320                     && avc->f.m.Owner == ANONYMOUSID)
321                     code =
322                         afs_AccessOK(avc, PRSFS_WRITE, treq,
323                                      DONT_CHECK_MODE_BITS);
324             }
325             if (code && (amode & VREAD))
326                 code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
327         }
328     }
329     afs_PutFakeStat(&fakestate);
330
331     AFS_DISCON_UNLOCK();
332     
333     if (code) {
334         afs_DestroyReq(treq);
335         return 0;               /* if access is ok */
336     } else {
337         code = afs_CheckCode(EACCES, treq, 17); /* failure code */
338         afs_DestroyReq(treq);
339         return code;
340     }
341 }
342
343 #if defined(UKERNEL)
344 /*
345  * afs_getRights
346  * This function is just an interface to afs_GetAccessBits
347  */
348 int
349 afs_getRights(OSI_VC_DECL(avc), afs_int32 arights,
350               afs_ucred_t *acred)
351 {
352     afs_int32 code;
353     struct vrequest *treq = NULL;
354     OSI_VC_CONVERT(avc);
355
356     if ((code = afs_CreateReq(&treq, acred)))
357         return code;
358
359     code = afs_VerifyVCache(avc, treq);
360     if (code) {
361         code = afs_CheckCode(code, treq, 18);
362         afs_DestroyReq(treq);
363         return code;
364     }
365
366     code = afs_GetAccessBits(avc, arights, treq);
367     afs_DestroyReq(treq);
368     return code;
369 }
370 #endif /* defined(UKERNEL) */