windows-unix-mode-bit-enforcement-20070105
[openafs.git] / src / WINNT / afsd / cm_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 #include <afs/param.h>
11 #include <afs/stds.h>
12
13 #include <windows.h>
14 #include <winsock2.h>
15 #include <malloc.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <nb30.h>
19 #include <osi.h>
20
21 #include "afsd.h"
22
23 int cm_deleteReadOnly = 0;
24
25 /* called with scp write-locked, check to see if we have the ACL info we need
26  * and can get it w/o blocking for any locks.
27  *
28  * Never drops the scp lock, but may fail if the access control info comes from
29  * the parent directory, and the parent's scache entry can't be found, or it
30  * can't be locked.  Thus, this must always be called in a while loop to stabilize
31  * things, since we can always lose the race condition getting to the parent vnode.
32  */
33 int cm_HaveAccessRights(struct cm_scache *scp, struct cm_user *userp, afs_uint32 rights,
34                         afs_uint32 *outRightsp)
35 {
36     cm_scache_t *aclScp;
37     long code;
38     cm_fid_t tfid;
39     int didLock;
40     long trights;
41         
42     didLock = 0;
43     if (scp->fileType == CM_SCACHETYPE_DIRECTORY) {
44         aclScp = scp;
45         cm_HoldSCache(scp);
46     } else {
47         tfid.cell = scp->fid.cell;
48         tfid.volume = scp->fid.volume;
49         tfid.vnode = scp->parentVnode;
50         tfid.unique = scp->parentUnique;
51         aclScp = cm_FindSCache(&tfid);
52         if (!aclScp) 
53             return 0;
54         if (aclScp != scp) {
55             code = lock_TryMutex(&aclScp->mx);
56             if (code == 0) {
57                 /* can't get lock safely and easily */
58                 cm_ReleaseSCache(aclScp);
59                 return 0;
60             }
61
62             /* check that we have a callback, too */
63             if (!cm_HaveCallback(aclScp)) {
64                 /* can't use it */
65                 lock_ReleaseMutex(&aclScp->mx);
66                 cm_ReleaseSCache(aclScp);
67                 return 0;
68             }
69             didLock = 1;
70         }
71     }
72
73     lock_AssertMutex(&aclScp->mx);
74         
75     /* now if rights is a subset of the public rights, we're done.
76      * Otherwise, if we an explicit acl entry, we're also in good shape,
77      * and can definitively answer.
78      */
79     if ((~aclScp->anyAccess & rights) == 0) {
80         *outRightsp = rights;
81     } else {
82         /* we have to check the specific rights info */
83         code = cm_FindACLCache(aclScp, userp, &trights);
84         if (code) {
85             code = 0;
86             goto done;
87         }
88         *outRightsp = trights;
89     }
90
91     /* check mode bits */
92     if (!(scp->unixModeBits & 0400))
93         *outRightsp &= ~PRSFS_READ;
94     if (!(scp->unixModeBits & 0200) && !(rights == (PRSFS_WRITE | PRSFS_LOCK)))
95         *outRightsp &= ~PRSFS_WRITE;
96     if (!(scp->unixModeBits & 0200) && !cm_deleteReadOnly)
97         *outRightsp &= ~PRSFS_DELETE;
98
99     /* if the user can obtain a write-lock, read-locks are implied */
100     if (*outRightsp & PRSFS_WRITE)
101         *outRightsp |= PRSFS_LOCK;
102
103     code = 1;
104     /* fall through */
105
106   done:
107     if (didLock) 
108         lock_ReleaseMutex(&aclScp->mx);
109     cm_ReleaseSCache(aclScp);
110     return code;
111 }
112
113 /* called with locked scp; ensures that we have an ACL cache entry for the
114  * user specified by the parameter "userp."
115  * In pathological race conditions, this function may return success without
116  * having loaded the entry properly (due to a racing callback revoke), so this
117  * function must also be called in a while loop to make sure that we eventually
118  * succeed.
119  */
120 long cm_GetAccessRights(struct cm_scache *scp, struct cm_user *userp,
121                         struct cm_req *reqp)
122 {
123     long code;
124     cm_fid_t tfid;
125     cm_scache_t *aclScp = NULL;
126     int got_cb = 0;
127
128     /* pretty easy: just force a pass through the fetch status code */
129         
130     osi_Log2(afsd_logp, "GetAccess scp 0x%p user 0x%p", scp, userp);
131
132     /* first, start by finding out whether we have a directory or something
133      * else, so we can find what object's ACL we need.
134      */
135     if (scp->fileType == CM_SCACHETYPE_DIRECTORY ) {
136         code = cm_SyncOp(scp, NULL, userp, reqp, 0,
137                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_FORCECB);
138         if (!code) 
139             cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
140     } else {
141         /* not a dir, use parent dir's acl */
142         tfid.cell = scp->fid.cell;
143         tfid.volume = scp->fid.volume;
144         tfid.vnode = scp->parentVnode;
145         tfid.unique = scp->parentUnique;
146         lock_ReleaseMutex(&scp->mx);
147         code = cm_GetSCache(&tfid, &aclScp, userp, reqp);
148         if (code) {
149             lock_ObtainMutex(&scp->mx);
150             goto _done;
151         }       
152                 
153         osi_Log2(afsd_logp, "GetAccess parent scp %x user %x", aclScp, userp);
154         lock_ObtainMutex(&aclScp->mx);
155         code = cm_SyncOp(aclScp, NULL, userp, reqp, 0,
156                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_FORCECB);
157         if (!code)
158             cm_SyncOpDone(aclScp, NULL, 
159                           CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
160         lock_ReleaseMutex(&aclScp->mx);
161         cm_ReleaseSCache(aclScp);
162         lock_ObtainMutex(&scp->mx);
163     }
164
165   _done:
166     return code;
167 }