Windows: add cm_HaveToken
[openafs.git] / src / WINNT / afsd / cm_aclent.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 <afsconfig.h>
11 #include <afs/param.h>
12 #include <roken.h>
13
14 #include <afs/stds.h>
15
16 #include <windows.h>
17 #include <stdlib.h>
18 #include <string.h>
19
20 #include "afsd.h"
21 #include <osisleep.h>
22
23 /*
24  * This next lock controls access to all cm_aclent structures in the system,
25  * in either the free list or in the LRU queue.  A read lock prevents someone
26  * from modifying the list(s), and a write lock is required for modifying
27  * the list.  The actual data stored in the randomUid and randomAccess fields
28  * is actually maintained as up-to-date or not via the scache lock.
29  * An aclent structure is free if it has no back vnode pointer.
30  */
31 osi_rwlock_t cm_aclLock;                /* lock for system's aclents */
32
33 /* This must be called with cm_aclLock and the aclp->back->mx held */
34 static void CleanupACLEnt(cm_aclent_t * aclp)
35 {
36     cm_aclent_t *taclp;
37     cm_aclent_t **laclpp;
38
39     if (aclp->backp) {
40         if (aclp->backp->randomACLp) {
41             /*
42              * Remove the entry from the vnode's list
43              */
44             lock_AssertWrite(&aclp->backp->rw);
45             laclpp = &aclp->backp->randomACLp;
46             for (taclp = *laclpp; taclp; laclpp = &taclp->nextp, taclp = *laclpp) {
47                 if (taclp == aclp)
48                     break;
49             }
50             if (!taclp)
51                 osi_panic("CleanupACLEnt race", __FILE__, __LINE__);
52             *laclpp = aclp->nextp;                      /* remove from vnode list */
53         }
54         aclp->backp = NULL;
55     }
56
57     /* release the old user */
58     if (aclp->userp) {
59         cm_ReleaseUser(aclp->userp);
60         aclp->userp = NULL;
61     }
62
63     aclp->randomAccess = 0;
64     aclp->tgtLifetime = 0;
65 }
66
67 /*
68  * Get an acl cache entry for a particular user and file, or return that it doesn't exist.
69  * Called with the scp write locked.
70  */
71 long cm_FindACLCache(cm_scache_t *scp, cm_user_t *userp, afs_uint32 *rightsp)
72 {
73     cm_aclent_t *aclp;
74     long retval = -1;
75     time_t now = time(NULL);
76
77     lock_AssertWrite(&scp->rw);
78     lock_ObtainWrite(&cm_aclLock);
79     *rightsp = 0;   /* get a new acl from server if we don't find a
80                      * current entry
81                      */
82
83     for (aclp = scp->randomACLp; aclp; aclp = aclp->nextp) {
84         if (aclp->userp == userp) {
85             if (aclp->tgtLifetime && aclp->tgtLifetime <= now) {
86                 /* ticket expired */
87                 osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
88                 CleanupACLEnt(aclp);
89
90                 /* move to the tail of the LRU queue */
91                 osi_QAddT((osi_queue_t **) &cm_data.aclLRUp,
92                            (osi_queue_t **) &cm_data.aclLRUEndp,
93                            &aclp->q);
94             } else {
95                 *rightsp = aclp->randomAccess;
96                 if (cm_data.aclLRUp != aclp) {
97                     /* move to the head of the LRU queue */
98                     osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
99                     osi_QAddH((osi_queue_t **) &cm_data.aclLRUp,
100                               (osi_queue_t **) &cm_data.aclLRUEndp,
101                               &aclp->q);
102                 }
103                 retval = 0;     /* success */
104             }
105             break;
106         }
107     }
108
109     lock_ReleaseWrite(&cm_aclLock);
110     return retval;
111 }
112
113 /*
114  * This function returns a free (not in the LRU queue) acl cache entry.
115  * It must be called with the cm_aclLock lock held
116  */
117 static cm_aclent_t *GetFreeACLEnt(cm_scache_t * scp)
118 {
119     cm_aclent_t *aclp;
120     cm_scache_t *ascp = 0;
121
122     if (cm_data.aclLRUp == NULL)
123         osi_panic("empty aclent LRU", __FILE__, __LINE__);
124
125     if (cm_data.aclLRUEndp == NULL)
126         osi_panic("inconsistent aclent LRUEndp == NULL", __FILE__, __LINE__);
127
128     aclp = cm_data.aclLRUEndp;
129     osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
130
131     if (aclp->backp && scp != aclp->backp) {
132         ascp = aclp->backp;
133         lock_ReleaseWrite(&cm_aclLock);
134         lock_ObtainWrite(&ascp->rw);
135         lock_ObtainWrite(&cm_aclLock);
136     }
137     CleanupACLEnt(aclp);
138
139     if (ascp)
140         lock_ReleaseWrite(&ascp->rw);
141     return aclp;
142 }
143
144 time_t cm_TGTLifeTime(cm_user_t *userp, afs_uint32 cellID)
145 {
146     cm_cell_t *cellp = NULL;
147     cm_ucell_t * ucp = NULL;
148     time_t      expirationTime = 0;
149
150     lock_ObtainMutex(&userp->mx);
151     cellp = cm_FindCellByID(cellID, CM_FLAG_NOPROBE);
152     ucp = cm_GetUCell(userp, cellp);
153     if (ucp->ticketp)
154         expirationTime = ucp->expirationTime;
155     lock_ReleaseMutex(&userp->mx);
156
157     return expirationTime;
158 }
159
160 int
161 cm_HaveToken(cm_user_t *userp, afs_uint32 cellID)
162 {
163     cm_cell_t *cellp = NULL;
164     cm_ucell_t * ucp = NULL;
165     int         havetoken = 0;
166     time_t      now;
167
168     lock_ObtainMutex(&userp->mx);
169     cellp = cm_FindCellByID(cellID, CM_FLAG_NOPROBE);
170     ucp = cm_GetUCell(userp, cellp);
171     if (ucp->ticketp) {
172         now = time(NULL);
173         if (ucp->expirationTime > now)
174             havetoken = 1;
175     }
176     lock_ReleaseMutex(&userp->mx);
177
178     return havetoken;
179 }
180
181
182 /*
183  * Add rights to an acl cache entry.  Do the right thing if not present,
184  * including digging up an entry from the LRU queue.
185  *
186  * The scp must be locked when this function is called.
187  */
188 long cm_AddACLCache(cm_scache_t *scp, cm_user_t *userp, afs_uint32 rights)
189 {
190     struct cm_aclent *aclp;
191     time_t tgtLifeTime;
192
193     tgtLifeTime = cm_TGTLifeTime(userp, scp->fid.cell);
194
195     lock_ObtainWrite(&cm_aclLock);
196     for (aclp = scp->randomACLp; aclp; aclp = aclp->nextp) {
197         if (aclp->userp == userp) {
198             aclp->randomAccess = rights;
199             if (aclp->tgtLifetime < tgtLifeTime)
200                 aclp->tgtLifetime = tgtLifeTime;
201             if (cm_data.aclLRUp != aclp) {
202                 /* move to the head of the LRU queue */
203                 osi_QRemoveHT((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
204                 osi_QAddH((osi_queue_t **) &cm_data.aclLRUp,
205                            (osi_queue_t **) &cm_data.aclLRUEndp,
206                            &aclp->q);
207             }
208             lock_ReleaseWrite(&cm_aclLock);
209             return 0;
210         }
211     }
212
213     /*
214      * Didn't find the dude we're looking for, so take someone from the LRUQ
215      * and  reuse. But first try the free list and see if there's already
216      * someone there.
217      */
218     aclp = GetFreeACLEnt(scp);           /* can't fail, panics instead */
219     osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
220     aclp->backp = scp;
221     aclp->nextp = scp->randomACLp;
222     scp->randomACLp = aclp;
223     cm_HoldUser(userp);
224     aclp->userp = userp;
225     aclp->randomAccess = rights;
226     aclp->tgtLifetime = tgtLifeTime;
227     lock_ReleaseWrite(&cm_aclLock);
228
229     return 0;
230 }
231
232 long cm_ShutdownACLCache(void)
233 {
234     return 0;
235 }
236
237 long cm_ValidateACLCache(void)
238 {
239     long size = cm_data.stats * 2;
240     long count;
241     cm_aclent_t * aclp;
242
243     if ( cm_data.aclLRUp == NULL && cm_data.aclLRUEndp != NULL ||
244          cm_data.aclLRUp != NULL && cm_data.aclLRUEndp == NULL) {
245         afsi_log("cm_ValidateACLCache failure: inconsistent LRU pointers");
246         fprintf(stderr, "cm_ValidateACLCache failure: inconsistent LRU pointers\n");
247         return -9;
248     }
249
250     for ( aclp = cm_data.aclLRUp, count = 0; aclp;
251           aclp = (cm_aclent_t *) osi_QNext(&aclp->q), count++ ) {
252         if (aclp->magic != CM_ACLENT_MAGIC) {
253             afsi_log("cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC");
254             fprintf(stderr, "cm_ValidateACLCache failure: acpl->magic != CM_ACLENT_MAGIC\n");
255             return -1;
256         }
257         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
258             afsi_log("cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC");
259             fprintf(stderr,"cm_ValidateACLCache failure: acpl->nextp->magic != CM_ACLENT_MAGIC\n");
260             return -2;
261         }
262         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
263             afsi_log("cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC");
264             fprintf(stderr,"cm_ValidateACLCache failure: acpl->backp->magic != CM_SCACHE_MAGIC\n");
265             return -3;
266         }
267         if (count != 0 && aclp == cm_data.aclLRUp || count > size) {
268             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUp list");
269             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUp list\n");
270             return -4;
271         }
272     }
273
274     for ( aclp = cm_data.aclLRUEndp, count = 0; aclp;
275           aclp = (cm_aclent_t *) osi_QPrev(&aclp->q), count++ ) {
276         if (aclp->magic != CM_ACLENT_MAGIC) {
277             afsi_log("cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC");
278             fprintf(stderr, "cm_ValidateACLCache failure: aclp->magic != CM_ACLENT_MAGIC\n");
279             return -5;
280         }
281         if (aclp->nextp && aclp->nextp->magic != CM_ACLENT_MAGIC) {
282             afsi_log("cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC");
283             fprintf(stderr, "cm_ValidateACLCache failure: aclp->nextp->magic != CM_ACLENT_MAGIC\n");
284             return -6;
285         }
286         if (aclp->backp && aclp->backp->magic != CM_SCACHE_MAGIC) {
287             afsi_log("cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC");
288             fprintf(stderr, "cm_ValidateACLCache failure: aclp->backp->magic != CM_SCACHE_MAGIC\n");
289             return -7;
290         }
291
292         if (count != 0 && aclp == cm_data.aclLRUEndp || count > size) {
293             afsi_log("cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list");
294             fprintf(stderr, "cm_ValidateACLCache failure: loop in cm_data.aclLRUEndp list\n");
295             return -8;
296         }
297     }
298
299     return 0;
300 }
301
302 /*
303  * Initialize the cache to have an entries.  Called during system startup.
304  */
305 long cm_InitACLCache(int newFile, long size)
306 {
307     cm_aclent_t *aclp;
308     long i;
309     static osi_once_t once;
310
311     if (osi_Once(&once)) {
312         lock_InitializeRWLock(&cm_aclLock, "cm_aclLock", LOCK_HIERARCHY_ACL_GLOBAL);
313         osi_EndOnce(&once);
314     }
315
316     lock_ObtainWrite(&cm_aclLock);
317     if ( newFile ) {
318         cm_data.aclLRUp = cm_data.aclLRUEndp = NULL;
319         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
320         memset(aclp, 0, size * sizeof(cm_aclent_t));
321
322         /*
323          * Put all of these guys on the LRU queue
324          */
325         for (i = 0; i < size; i++) {
326             aclp->magic = CM_ACLENT_MAGIC;
327             osi_QAddH((osi_queue_t **) &cm_data.aclLRUp, (osi_queue_t **) &cm_data.aclLRUEndp, &aclp->q);
328             aclp++;
329         }
330     } else {
331         aclp = (cm_aclent_t *) cm_data.aclBaseAddress;
332         for (i = 0; i < size; i++) {
333             aclp->userp = NULL;
334             aclp->tgtLifetime = 0;
335             aclp++;
336         }
337     }
338     lock_ReleaseWrite(&cm_aclLock);
339     return 0;
340 }
341
342
343 /*
344  * Free all associated acl entries.  We actually just clear the back pointer
345  * since the acl entries are already in the free list.  The scp must be locked
346  * or completely unreferenced (such as when called while recycling the scp).
347  */
348 void cm_FreeAllACLEnts(cm_scache_t *scp)
349 {
350     cm_aclent_t *aclp;
351     cm_aclent_t *taclp;
352
353     lock_ObtainWrite(&cm_aclLock);
354     for (aclp = scp->randomACLp; aclp; aclp = taclp) {
355         taclp = aclp->nextp;
356         if (aclp->userp) {
357             cm_ReleaseUser(aclp->userp);
358             aclp->userp = NULL;
359         }
360         aclp->backp = (struct cm_scache *) 0;
361     }
362
363     scp->randomACLp = (struct cm_aclent *) 0;
364     scp->anyAccess = 0;         /* reset this, too */
365     lock_ReleaseWrite(&cm_aclLock);
366 }
367
368
369 /*
370  * Invalidate all ACL entries for particular user on this particular vnode.
371  *
372  * The scp must not be locked.
373  */
374 void cm_InvalidateACLUser(cm_scache_t *scp, cm_user_t *userp)
375 {
376     cm_aclent_t *aclp;
377     cm_aclent_t **laclpp;
378     int found = 0;
379     int callback = 0;
380
381     lock_ObtainWrite(&scp->rw);
382     lock_ObtainWrite(&cm_aclLock);
383     laclpp = &scp->randomACLp;
384     for (aclp = *laclpp; aclp; laclpp = &aclp->nextp, aclp = *laclpp) {
385         if (userp == aclp->userp) {     /* One for a given user/scache */
386             *laclpp = aclp->nextp;
387             cm_ReleaseUser(aclp->userp);
388             aclp->userp = NULL;
389             aclp->backp = (struct cm_scache *) 0;
390             found = 1;
391             break;
392         }
393     }
394     lock_ReleaseWrite(&cm_aclLock);
395     if (found)
396         callback = cm_HaveCallback(scp);
397     lock_ReleaseWrite(&scp->rw);
398
399     if (found && callback && RDR_Initialized)
400         RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode, scp->fid.unique,
401                              scp->fid.hash, scp->fileType, AFS_INVALIDATE_CREDS);
402 }
403
404 /*
405  * Invalidate ACL info for a user that has just obtained or lost tokens.
406  */
407 void
408 cm_ResetACLCache(cm_cell_t *cellp, cm_user_t *userp)
409 {
410     cm_volume_t *volp, *nextVolp;
411     cm_scache_t *scp, *nextScp;
412     afs_uint32 hash;
413
414     lock_ObtainRead(&cm_scacheLock);
415     for (hash=0; hash < cm_data.scacheHashTableSize; hash++) {
416         for (scp=cm_data.scacheHashTablep[hash]; scp; scp=nextScp) {
417             nextScp = scp->nextp;
418             if (cellp == NULL ||
419                 scp->fid.cell == cellp->cellID) {
420                 cm_HoldSCacheNoLock(scp);
421                 lock_ReleaseRead(&cm_scacheLock);
422                 cm_InvalidateACLUser(scp, userp);
423                 lock_ObtainRead(&cm_scacheLock);
424                 cm_ReleaseSCacheNoLock(scp);
425             }
426         }
427     }
428     lock_ReleaseRead(&cm_scacheLock);
429
430     cm_EAccesClearUserEntries(userp, cellp ? cellp->cellID : 0);
431
432     if (RDR_Initialized) {
433         lock_ObtainRead(&cm_volumeLock);
434         for (hash = 0; hash < cm_data.volumeHashTableSize; hash++) {
435             for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = nextVolp) {
436                 nextVolp = volp->vol[RWVOL].nextp;
437                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
438                     volp->vol[RWVOL].ID) {
439                     lock_ReleaseRead(&cm_volumeLock);
440                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[RWVOL].ID, AFS_INVALIDATE_CREDS);
441                     lock_ObtainRead(&cm_volumeLock);
442                 }
443             }
444             for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = nextVolp) {
445                 nextVolp = volp->vol[ROVOL].nextp;
446                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
447                     volp->vol[ROVOL].ID) {
448                     lock_ReleaseRead(&cm_volumeLock);
449                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[ROVOL].ID, AFS_INVALIDATE_CREDS);
450                     lock_ObtainRead(&cm_volumeLock);
451                 }
452             }
453             for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = nextVolp) {
454                 nextVolp = volp->vol[BACKVOL].nextp;
455                 if ((cellp == NULL || cellp->cellID == volp->cellp->cellID) &&
456                     volp->vol[BACKVOL].ID) {
457                     lock_ReleaseRead(&cm_volumeLock);
458                     RDR_InvalidateVolume(volp->cellp->cellID, volp->vol[BACKVOL].ID, AFS_INVALIDATE_CREDS);
459                     lock_ObtainRead(&cm_volumeLock);
460                 }
461             }
462         }
463         lock_ReleaseRead(&cm_volumeLock);
464     }
465 }
466
467