3ffb9fb80291eb504a716f8af9f082b7180b0b02
[openafs.git] / src / WINNT / afsd / cm_vnodeops.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 #ifndef DJGPP
14 #include <windows.h>
15 #include <winsock2.h>
16 #endif /* !DJGPP */
17 #include <stddef.h>
18 #include <malloc.h>
19 #include <string.h>
20 #include <stdlib.h>
21
22 #include <osi.h>
23
24 #include "afsd.h"
25
26 /* Used by cm_FollowMountPoint */
27 #define RWVOL   0
28 #define ROVOL   1
29 #define BACKVOL 2
30
31 #ifdef DEBUG
32 extern void afsi_log(char *pattern, ...);
33 #endif
34
35 unsigned int cm_mountRootGen = 0;
36
37 /*
38  * Case-folding array.  This was constructed by inspecting of SMBtrace output.
39  * I do not know anything more about it.
40  */
41 unsigned char cm_foldUpper[256] = {
42      0x0,  0x1,  0x2,  0x3,  0x4,  0x5,  0x6,  0x7,
43      0x8,  0x9,  0xa,  0xb,  0xc,  0xd,  0xe,  0xf,
44     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
45     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
46     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
47     0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
48     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
49     0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
50     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
51     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
52     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
53     0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
54     0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
55     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
56     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
57     0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
58     0x80, 0x9a, 0x90, 0x41, 0x8e, 0x41, 0x8f, 0x80,
59     0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x8e, 0x8f,
60     0x90, 0x92, 0x92, 0x4f, 0x99, 0x4f, 0x55, 0x55,
61     0x59, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
62     0x41, 0x49, 0x4f, 0x55, 0xa5, 0xa5, 0x56, 0xa7,
63     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
64     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
65     0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
66     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
67     0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
68     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
69     0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
70     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
71     0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
72     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
73     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
74 };
75
76 /*
77  * Case-insensitive string comparison.  We used to use stricmp, but it doesn't
78  * know about 8-bit characters (e.g. 129 is lowercase u-umlaut, 154 is
79  * upper-case u-umlaut).
80  */
81 int cm_stricmp(const char *str1, const char *str2)
82 {
83         char c1, c2;
84
85         while (1) {
86                 if (*str1 == 0)
87                         if (*str2 == 0)
88                                 return 0;
89                         else
90                                 return -1;
91                 if (*str2 == 0)
92                         return 1;
93                 c1 = (char) cm_foldUpper[(unsigned char)(*str1++)];
94                 c2 = (char) cm_foldUpper[(unsigned char)(*str2++)];
95                 if (c1 < c2)
96                         return -1;
97                 if (c1 > c2)
98                         return 1;
99         }
100 }
101
102 /* characters that are legal in an 8.3 name */
103 /*
104  * We used to have 1's for all characters from 128 to 254.  But
105  * the NT client behaves better if we create an 8.3 name for any
106  * name that has a character with the high bit on, and if we
107  * delete those characters from 8.3 names.  In particular, see
108  * Sybase defect 10859.
109  */
110 char cm_LegalChars[256] = {
111  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
112  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
113  0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
114  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
115  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
117  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
119  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
120  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
121  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
122  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
123  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
124  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
125  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
126  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
127 };
128
129 /* return true iff component is a valid 8.3 name */
130 int cm_Is8Dot3(char *namep)
131 {
132         int sawDot = 0;
133         int sawUpper = 0, sawLower = 0;
134         unsigned char tc;
135         int charCount = 0;
136         
137         /*
138          * can't have a leading dot;
139          * special case for . and ..
140          */
141         if (namep[0] == '.') {
142                 if (namep[1] == 0)
143                         return 1;
144                 if (namep[1] == '.' && namep[2] == 0)
145                         return 1;
146                 return 0;
147         }
148         while (tc = *namep++) {
149                 if (tc == '.') {
150                         /* saw another dot */
151                         if (sawDot) return 0;   /* second dot */
152                         sawDot = 1;
153                         charCount = 0;
154                         continue;
155                 }
156                 if (cm_LegalChars[tc] == 0)
157                         return 0;
158                 if (tc >= 'A' && tc <= 'Z')
159                         sawUpper = 1;
160                 else if (tc >= 'a' && tc <= 'z')
161                         sawLower = 1;
162                 charCount++;
163                 if (!sawDot && charCount > 8)
164                         /* more than 8 chars in name */
165                         return 0;
166                 if (sawDot && charCount > 3)
167                         /* more than 3 chars in extension */
168                         return 0;
169         }
170 /*
171  * Used to check that all characters were the same case.
172  * This doesn't help 16-bit apps, and meanwhile it causes the
173  * MS-DOS Command Prompt to misbehave; see Sybase defect 10709.
174  *
175         if (sawUpper && sawLower)
176                 return 0;
177  */
178         return 1;
179 }
180
181 /*
182  * Number unparsing map for generating 8.3 names;
183  * Taken from DFS.
184  */
185 char cm_8Dot3Mapping[41] =
186 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
187  'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S',
188  'T', 'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '@', '%', '!', '&', 'E', 'O'
189 };
190 int cm_8Dot3MapSize = sizeof(cm_8Dot3Mapping);
191
192 void cm_Gen8Dot3Name(cm_dirEntry_t *dep, char *shortName, char **shortNameEndp)
193 {
194         char number[12];
195         int i, nsize = 0;
196         int vnode = ntohl(dep->fid.vnode);
197         char *lastDot;
198         int validExtension = 0;
199         char tc, *temp, *name;
200
201         /* Unparse the file's vnode number to get a "uniquifier" */
202         do {
203                 number[nsize] = cm_8Dot3Mapping[vnode % cm_8Dot3MapSize];
204                 nsize++;
205                 vnode /= cm_8Dot3MapSize;
206         } while (vnode);
207
208         /*
209          * Look for valid extension.  There has to be a dot, and
210          * at least one of the characters following has to be legal.
211          */
212         lastDot = strrchr(dep->name, '.');
213         if (lastDot) {
214                 temp = lastDot; temp++;
215                 while (tc = *temp++)
216                         if (cm_LegalChars[tc])
217                                 break;
218                 if (tc)
219                         validExtension = 1;
220         }
221
222         /* Copy name characters */
223         name = dep->name;
224         for (i = 0, name = dep->name;
225              i < (7 - nsize) && name != lastDot; ) {
226                 tc = *name++;
227
228                 if (tc == 0)
229                         break;
230                 if (!cm_LegalChars[tc])
231                         continue;
232                 i++;
233                 *shortName++ = toupper(tc);
234         }
235
236         /* tilde */
237         *shortName++ = '~';
238
239         /* Copy uniquifier characters */
240         memcpy(shortName, number, nsize);
241         shortName += nsize;
242
243         if (validExtension) {
244                 /* Copy extension characters */
245                 *shortName++ = *lastDot++;      /* copy dot */
246                 for (i = 0, tc = *lastDot++;
247                      i < 3 && tc;
248                      tc = *lastDot++) {
249                         if (cm_LegalChars[tc]) {
250                                 i++;
251                                 *shortName++ = toupper(tc);
252                         }
253                 }
254         }
255
256         /* Trailing null */
257         *shortName = 0;
258
259         if (shortNameEndp)
260                 *shortNameEndp = shortName;
261 }
262
263 /* return success if we can open this file in this mode */
264 long cm_CheckOpen(cm_scache_t *scp, int openMode, int trunc, cm_user_t *userp,
265         cm_req_t *reqp)
266 {
267         long rights;
268         long code;
269
270         rights = 0;
271         if (openMode != 1) rights |= PRSFS_READ;
272         if (openMode == 1 || openMode == 2 || trunc) rights |= PRSFS_WRITE;
273         
274         lock_ObtainMutex(&scp->mx);
275
276         code = cm_SyncOp(scp, NULL, userp, reqp, rights,
277                          CM_SCACHESYNC_GETSTATUS
278                          | CM_SCACHESYNC_NEEDCALLBACK);
279         lock_ReleaseMutex(&scp->mx);
280
281         return code;
282 }
283
284 /* return success if we can open this file in this mode */
285 long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess,
286         unsigned int createDisp, cm_user_t *userp, cm_req_t *reqp)
287 {
288         long rights;
289         long code;
290
291         /* Always allow delete; the RPC will tell us if it's OK */
292         if (desiredAccess == DELETE)
293                 return 0;
294
295         rights = 0;
296
297         if (desiredAccess & AFS_ACCESS_READ)
298                 rights |= PRSFS_READ;
299
300         if ((desiredAccess & AFS_ACCESS_WRITE)
301             || createDisp == 4)
302                 rights |= PRSFS_WRITE;
303         
304         lock_ObtainMutex(&scp->mx);
305
306         code = cm_SyncOp(scp, NULL, userp, reqp, rights,
307                          CM_SCACHESYNC_GETSTATUS
308                          | CM_SCACHESYNC_NEEDCALLBACK);
309         lock_ReleaseMutex(&scp->mx);
310
311         /*
312          * If the open will fail because the volume is readonly, then we will
313          * return an access denied error instead.  This is to help brain-dead
314          * apps run correctly on replicated volumes.
315          * See defect 10007 for more information.
316          */
317         if (code == CM_ERROR_READONLY)
318                 code = CM_ERROR_NOACCESS;
319
320         return code;
321 }
322
323 /*
324  * When CAP_NT_SMBS has been negotiated, deletion (of files or directories) is
325  * done in three steps:
326  * (1) open for deletion (NT_CREATE_AND_X)
327  * (2) set for deletion on close (NTWTRANSACTION2, SET_FILE_INFO)
328  * (3) close (CLOSE)
329  * We must not do the RPC until step 3.  But if we are going to return an error
330  * code (e.g. directory not empty), we must return it by step 2, otherwise most
331  * clients will not notice it.  So we do a preliminary check.  For deleting
332  * files, this is almost free, since we have already done the RPC to get the
333  * parent directory's status bits.  But for deleting directories, we must do an
334  * additional RPC to get the directory's data to check if it is empty.  Sigh.
335  */
336 long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp,
337         cm_req_t *reqp)
338 {
339         long code;
340         osi_hyper_t thyper;
341         cm_buf_t *bufferp;
342         cm_dirEntry_t *dep;
343         unsigned short *hashTable;
344         unsigned int i, idx;
345         int BeyondPage = 0, HaveDot = 0, HaveDotDot = 0;
346
347         /* First check permissions */
348         lock_ObtainMutex(&dscp->mx);
349         code = cm_SyncOp(dscp, NULL, userp, reqp, PRSFS_DELETE,
350                          CM_SCACHESYNC_GETSTATUS
351                          | CM_SCACHESYNC_NEEDCALLBACK);
352         lock_ReleaseMutex(&dscp->mx);
353         if (code)
354                 return code;
355
356         /* If deleting directory, must be empty */
357
358         if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
359                 return code;
360
361         thyper.HighPart = 0; thyper.LowPart = 0;
362         lock_ObtainRead(&scp->bufCreateLock);
363         code = buf_Get(scp, &thyper, &bufferp);
364         lock_ReleaseRead(&scp->bufCreateLock);
365         if (code)
366                 return code;
367
368         lock_ObtainMutex(&bufferp->mx);
369         lock_ObtainMutex(&scp->mx);
370         while (1) {
371                 code = cm_SyncOp(scp, bufferp, userp, reqp, 0,
372                                  CM_SCACHESYNC_NEEDCALLBACK
373                                  | CM_SCACHESYNC_READ
374                                  | CM_SCACHESYNC_BUFLOCKED);
375                 if (code)
376                         break;
377
378                 if (cm_HaveBuffer(scp, bufferp, 1))
379                         break;
380
381                 /* otherwise, load the buffer and try again */
382                 lock_ReleaseMutex(&bufferp->mx);
383                 code = cm_GetBuffer(scp, bufferp, NULL, userp, reqp);
384                 lock_ReleaseMutex(&scp->mx);
385                 lock_ObtainMutex(&bufferp->mx);
386                 lock_ObtainMutex(&scp->mx);
387                 if (code)
388                         break;
389         }
390
391         /* We try to determine emptiness without looking beyond the first page,
392          * and without assuming "." and ".." are present and are on the first
393          * page (though these assumptions might, after all, be reasonable).
394          */
395         hashTable = (unsigned short *)(bufferp->datap + (32 * 5));
396         for (i=0; i<128; i++) {
397                 idx = ntohs(hashTable[i]);
398                 while (idx) {
399                         if (idx >= 64) {
400                                 BeyondPage = 1;
401                                 break;
402                         }
403                         dep = (cm_dirEntry_t *)(bufferp->datap + (32 * idx));
404                         if (strcmp(dep->name, ".") == 0)
405                                 HaveDot = 1;
406                         else if (strcmp(dep->name, "..") == 0)
407                                 HaveDotDot = 1;
408                         else {
409                                 code = CM_ERROR_NOTEMPTY;
410                                 goto done;
411                         }
412                         idx = ntohs(dep->next);
413                 }
414         }
415         if (BeyondPage && HaveDot && HaveDotDot)
416                 code = CM_ERROR_NOTEMPTY;
417         else
418                 code = 0;
419 done:
420         lock_ReleaseMutex(&bufferp->mx);
421         buf_Release(bufferp);
422         lock_ReleaseMutex(&scp->mx);
423         return code;
424 }
425
426 /*
427  * Iterate through all entries in a directory.
428  * When the function funcp is called, the buffer is locked but the
429  * directory vnode is not.
430  */
431 long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp,
432         osi_hyper_t *startOffsetp, cm_user_t *userp, cm_req_t *reqp,
433         cm_scache_t **retscp)
434 {
435     char *tp;
436     long code;
437     cm_dirEntry_t *dep;
438     cm_buf_t *bufferp;
439     long temp;
440     osi_hyper_t dirLength;
441     osi_hyper_t bufferOffset;
442     osi_hyper_t curOffset;
443     osi_hyper_t thyper;
444     long entryInDir;
445     long entryInBuffer;
446         cm_pageHeader_t *pageHeaderp;
447     int slotInPage;
448     long nextEntryCookie;
449     int numDirChunks;   /* # of 32 byte dir chunks in this entry */
450         
451     /* get the directory size */
452         lock_ObtainMutex(&scp->mx);
453     code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_LOOKUP,
454                      CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
455         if (code) {
456                 lock_ReleaseMutex(&scp->mx);
457         return code;
458     }
459         
460     if (scp->fileType != CM_SCACHETYPE_DIRECTORY) {
461                 lock_ReleaseMutex(&scp->mx);
462                 return CM_ERROR_NOTDIR;
463     }
464
465         if (retscp)                     /* if this is a lookup call */
466         {
467                 cm_lookupSearch_t*      sp = parmp;
468         int casefold = sp->caseFold;
469
470         sp->caseFold = 0; /* we have a strong preference for exact matches */
471                 if ( *retscp = cm_dnlcLookup(scp, sp))  /* dnlc hit */
472                 {
473             sp->caseFold = casefold;
474                         lock_ReleaseMutex(&scp->mx);
475                         return 0;
476                 }
477
478         sp->caseFold = casefold;
479         }       
480
481         /*
482          * XXX We only get the length once.  It might change when we drop the
483          * lock.
484          */
485     dirLength = scp->length;
486
487         lock_ReleaseMutex(&scp->mx);
488
489     bufferp = NULL;
490     bufferOffset.LowPart = bufferOffset.HighPart = 0;
491         if (startOffsetp)
492         curOffset = *startOffsetp;
493         else {
494         curOffset.HighPart = 0;
495         curOffset.LowPart = 0;
496         }   
497
498     while (1) {
499                 /* make sure that curOffset.LowPart doesn't point to the first
500          * 32 bytes in the 2nd through last dir page, and that it
501                  * doesn't point at the first 13 32-byte chunks in the first
502                  * dir page, since those are dir and page headers, and don't
503                  * contain useful information.
504          */
505                 temp = curOffset.LowPart & (2048-1);
506         if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
507             /* we're in the first page */
508             if (temp < 13*32) temp = 13*32;
509                 }
510                 else {
511                         /* we're in a later dir page */
512             if (temp < 32) temp = 32;
513         }
514                 
515         /* make sure the low order 5 bits are zero */
516         temp &= ~(32-1);
517                 
518         /* now put temp bits back ito curOffset.LowPart */
519         curOffset.LowPart &= ~(2048-1);
520         curOffset.LowPart |= temp;
521
522         /* check if we've passed the dir's EOF */
523         if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength))
524                         break;
525                 
526         /* see if we can use the bufferp we have now; compute in which
527          * page the current offset would be, and check whether that's
528                  * the offset of the buffer we have.  If not, get the buffer.
529                  */
530         thyper.HighPart = curOffset.HighPart;
531         thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
532         if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
533                         /* wrong buffer */
534             if (bufferp) {
535                                 lock_ReleaseMutex(&bufferp->mx);
536                 buf_Release(bufferp);
537                 bufferp = NULL;
538                         }
539
540                         lock_ObtainRead(&scp->bufCreateLock);
541             code = buf_Get(scp, &thyper, &bufferp);
542                         lock_ReleaseRead(&scp->bufCreateLock);
543
544                         lock_ObtainMutex(&bufferp->mx);
545             if (code) break;
546             bufferOffset = thyper;
547
548             /* now get the data in the cache */
549             while (1) {
550                 lock_ObtainMutex(&scp->mx);
551                                 code = cm_SyncOp(scp, bufferp, userp, reqp,
552                                  PRSFS_LOOKUP,
553                                  CM_SCACHESYNC_NEEDCALLBACK
554                                  | CM_SCACHESYNC_READ
555                                  | CM_SCACHESYNC_BUFLOCKED);
556                                 if (code) {
557                                         lock_ReleaseMutex(&scp->mx);
558                                         break;
559                                 }
560                                 
561                 if (cm_HaveBuffer(scp, bufferp, 1)) {
562                                         lock_ReleaseMutex(&scp->mx);
563                                         break;
564                                 }
565                                 
566                 /* otherwise, load the buffer and try again */
567                 lock_ReleaseMutex(&bufferp->mx);
568                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
569                                     reqp);
570                 lock_ReleaseMutex(&scp->mx);
571                 lock_ObtainMutex(&bufferp->mx);
572                 if (code) break;
573             }
574             if (code) {
575                                 lock_ReleaseMutex(&bufferp->mx);
576                                 buf_Release(bufferp);
577                 bufferp = NULL;
578                 break;
579                         }
580         }       /* if (wrong buffer) ... */
581                 
582         /* now we have the buffer containing the entry we're interested
583          * in; copy it out if it represents a non-deleted entry.
584          */
585                 entryInDir = curOffset.LowPart & (2048-1);
586         entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
587
588                 /* page header will help tell us which entries are free.  Page
589                  * header can change more often than once per buffer, since
590                  * AFS 3 dir page size may be less than (but not more than) a
591                  * buffer package buffer.
592          */
593                 /* only look intra-buffer */
594                 temp = curOffset.LowPart & (buf_bufferSize - 1);
595         temp &= ~(2048 - 1);    /* turn off intra-page bits */
596                 pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
597
598                 /* now determine which entry we're looking at in the page.  If
599                  * it is free (there's a free bitmap at the start of the dir),
600                  * we should skip these 32 bytes.
601          */
602         slotInPage = (entryInDir & 0x7e0) >> 5;
603         if (!(pageHeaderp->freeBitmap[slotInPage>>3]
604                & (1 << (slotInPage & 0x7)))) {
605                         /* this entry is free */
606             numDirChunks = 1;   /* only skip this guy */
607             goto nextEntry;
608         }
609
610                 tp = bufferp->datap + entryInBuffer;
611         dep = (cm_dirEntry_t *) tp;     /* now points to AFS3 dir entry */
612
613         /* while we're here, compute the next entry's location, too,
614                  * since we'll need it when writing out the cookie into the
615                  * dir listing stream.
616          */
617                 numDirChunks = cm_NameEntries(dep->name, NULL);
618                 
619         /* compute the offset of the cookie representing the next entry */
620         nextEntryCookie = curOffset.LowPart
621                         + (CM_DIR_CHUNKSIZE * numDirChunks);
622
623         if (dep->fid.vnode != 0) {
624                         /* this is one of the entries to use: it is not deleted */
625                         code = (*funcp)(scp, dep, parmp, &curOffset);
626             if (code) break;
627                 }       /* if we're including this name */
628                 
629       nextEntry:
630         /* and adjust curOffset to be where the new cookie is */
631                 thyper.HighPart = 0;
632         thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
633         curOffset = LargeIntegerAdd(thyper, curOffset);
634     }           /* while copying data for dir listing */
635
636         /* release the mutex */
637     if (bufferp) {
638                 lock_ReleaseMutex(&bufferp->mx);
639         buf_Release(bufferp);
640         }
641     return code;
642 }
643
644 int cm_NoneUpper(char *s)
645 {
646         char c;
647         while (c = *s++)
648                 if (c >= 'A' && c <= 'Z')
649                         return 0;
650         return 1;
651 }
652
653 int cm_NoneLower(char *s)
654 {
655         char c;
656         while (c = *s++)
657                 if (c >= 'a' && c <= 'z')
658                         return 0;
659         return 1;
660 }
661
662 long cm_LookupSearchProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
663         osi_hyper_t *offp)
664 {
665         cm_lookupSearch_t *sp;
666     int match;
667         char shortName[13];
668         char *matchName;
669         
670     sp = (cm_lookupSearch_t *) rockp;
671
672         matchName = dep->name;
673         if (sp->caseFold)
674         match = cm_stricmp(matchName, sp->searchNamep);
675         else
676                 match = strcmp(matchName, sp->searchNamep);
677
678         if (match != 0
679             && sp->hasTilde
680             && !cm_Is8Dot3(dep->name)) {
681                 matchName = shortName;
682                 cm_Gen8Dot3Name(dep, shortName, NULL);
683                 if (sp->caseFold)
684                         match = cm_stricmp(matchName, sp->searchNamep);
685                 else
686                         match = strcmp(matchName, sp->searchNamep);
687         }
688
689         if (match != 0)
690                 return 0;
691
692         sp->found = 1;
693     if(!sp->caseFold) sp->ExactFound = 1;
694
695         if (!sp->caseFold || matchName == shortName) {
696                 sp->fid.vnode = ntohl(dep->fid.vnode);
697                 sp->fid.unique = ntohl(dep->fid.unique);
698         return CM_ERROR_STOPNOW;
699     }
700
701         /*
702          * If we get here, we are doing a case-insensitive search, and we
703          * have found a match.  Now we determine what kind of match it is:
704          * exact, lower-case, upper-case, or none of the above.  This is done
705          * in order to choose among matches, if there are more than one.
706          */
707
708         /* Exact matches are the best. */
709         match = strcmp(matchName, sp->searchNamep);
710         if (match == 0) {
711         sp->ExactFound = 1;
712                 sp->fid.vnode = ntohl(dep->fid.vnode);
713                 sp->fid.unique = ntohl(dep->fid.unique);
714         return CM_ERROR_STOPNOW;
715     }
716
717         /* Lower-case matches are next. */
718         if (sp->LCfound)
719                 return 0;
720         if (cm_NoneUpper(matchName)) {
721                 sp->LCfound = 1;
722                 goto inexact;
723         }
724
725         /* Upper-case matches are next. */
726         if (sp->UCfound)
727                 return 0;
728         if (cm_NoneLower(matchName)) {
729                 sp->UCfound = 1;
730                 goto inexact;
731         }
732
733         /* General matches are last. */
734         if (sp->NCfound)
735                 return 0;
736         sp->NCfound = 1;
737
738 inexact:
739         sp->fid.vnode = ntohl(dep->fid.vnode);
740         sp->fid.unique = ntohl(dep->fid.unique);
741         return 0;
742 }
743
744 /* read the contents of a mount point into the appropriate string.
745  * called with locked scp, and returns with locked scp.
746  */
747 long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
748 {
749         long code;
750         cm_buf_t *bufp;
751         osi_hyper_t thyper;
752         int tlen;
753
754         if (scp->mountPointStringp) return 0;
755         
756         /* otherwise, we have to read it in */
757         lock_ReleaseMutex(&scp->mx);
758
759         lock_ObtainRead(&scp->bufCreateLock);
760         thyper.LowPart = thyper.HighPart = 0;
761         code = buf_Get(scp, &thyper, &bufp);
762         lock_ReleaseRead(&scp->bufCreateLock);
763
764         lock_ObtainMutex(&scp->mx);
765         if (code) {
766                 return code;
767         }
768         while (1) {
769                 code = cm_SyncOp(scp, bufp, userp, reqp, 0,
770                         CM_SCACHESYNC_READ | CM_SCACHESYNC_NEEDCALLBACK);
771                 if (code) {
772                         goto done;
773                 }
774                 
775                 if (cm_HaveBuffer(scp, bufp, 0)) break;
776                 
777                 /* otherwise load buffer */
778                 code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
779                 if (code) {
780                         goto done;
781                 }
782         }
783         /* locked, has callback, has valid data in buffer */
784         if ((tlen = scp->length.LowPart) > 1000) return CM_ERROR_TOOBIG;
785         if (tlen <= 0) {
786                 code = CM_ERROR_INVAL;
787                 goto done;
788         }
789         
790         /* someone else did the work while we were out */
791         if (scp->mountPointStringp) {
792                 code = 0;
793                 goto done;
794         }
795         
796         /* otherwise, copy out the link */
797         scp->mountPointStringp = malloc(tlen);
798         memcpy(scp->mountPointStringp, bufp->datap, tlen);
799
800         /* now make it null-terminated.  Note that the original contents of a
801          * link that is a mount point is "#volname." where "." is there just to
802          * be turned into a null.  That is, we can trash the last char of the
803          * link without damaging the vol name.  This is a stupid convention,
804          * but that's the protocol.
805          */
806         scp->mountPointStringp[tlen-1] = 0;
807         code = 0;
808
809 done:
810         if (bufp) buf_Release(bufp);
811         return code;
812 }
813
814 /* called with a locked scp and chases the mount point, yielding outScpp.
815  * scp remains locked, just for simplicity of describing the interface.
816  */
817 long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp,
818         cm_req_t *reqp, cm_scache_t **outScpp)
819 {
820         char *cellNamep;
821         char *volNamep;
822         int tlen;
823         long code;
824         char *cp;
825         char *mpNamep;
826         cm_volume_t *volp;
827         cm_cell_t *cellp;
828         char mtType;
829         cm_fid_t tfid;
830         size_t vnLength;
831         int type;
832
833         if (scp->mountRootFidp && scp->mountRootGen >= cm_mountRootGen) {
834                 tfid = *scp->mountRootFidp;
835                 lock_ReleaseMutex(&scp->mx);
836                 code = cm_GetSCache(&tfid, outScpp, userp, reqp);
837                 lock_ObtainMutex(&scp->mx);
838                 return code;
839         }
840
841         /* parse the volume name */
842         mpNamep = scp->mountPointStringp;
843         osi_assert(mpNamep);
844         tlen = strlen(scp->mountPointStringp);
845         mtType = *scp->mountPointStringp;
846         cellNamep = malloc(tlen);
847         volNamep = malloc(tlen);
848         
849         cp = strrchr(mpNamep, ':');
850         if (cp) {
851                 /* cellular mount point */
852                 memset(cellNamep, 0, tlen);
853                 strncpy(cellNamep, mpNamep+1, cp - mpNamep - 1);
854                 strcpy(volNamep, cp+1);
855                 /* now look up the cell */
856                 cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE);
857         }
858         else {
859                 /* normal mt pt */
860                 strcpy(volNamep, mpNamep+1);
861                 
862                 cellp = cm_FindCellByID(scp->fid.cell);
863         }
864         
865         if (!cellp) {
866                 code = CM_ERROR_NOSUCHCELL;
867                 goto done;
868         }
869
870         vnLength = strlen(volNamep);
871         if (vnLength >= 8 && strcmp(volNamep + vnLength - 7, ".backup") == 0)
872                 type = BACKVOL;
873         else if (vnLength >= 10
874                   && strcmp(volNamep + vnLength - 9, ".readonly") == 0)
875                 type = ROVOL;
876         else
877                 type = RWVOL;
878
879         /* check for backups within backups */
880         if (type == BACKVOL
881             && (scp->flags & (CM_SCACHEFLAG_RO | CM_SCACHEFLAG_PURERO))
882                   == CM_SCACHEFLAG_RO) {
883                 code = CM_ERROR_NOSUCHVOLUME;
884                 goto done;
885         }
886
887         /* now we need to get the volume */
888         lock_ReleaseMutex(&scp->mx);
889         code = cm_GetVolumeByName(cellp, volNamep, userp, reqp, 0, &volp);
890         lock_ObtainMutex(&scp->mx);
891         
892         if (code == 0) {
893                 /* save the parent of the volume root for this is the 
894                  * place where the volume is mounted and we must remember 
895                  * this in the volume structure rather than just in the 
896                  * scache entry lest the scache entry gets recycled 
897                  * (defect 11489)
898                  */
899                 lock_ObtainMutex(&volp->mx);
900                 if(volp->dotdotFidp == (cm_fid_t *) NULL) 
901                         volp->dotdotFidp = (cm_fid_t *) malloc(sizeof(cm_fid_t));
902                 *(volp->dotdotFidp) = dscp->fid;
903                 lock_ReleaseMutex(&volp->mx);
904
905                 if (scp->mountRootFidp == 0) {
906                         scp->mountRootFidp = malloc(sizeof(cm_fid_t));
907                 }
908                 scp->mountRootFidp->cell = cellp->cellID;
909                 /* if the mt pt is in a read-only volume (not just a
910                  * backup), and if there is a read-only volume for the
911                  * target, and if this is a type '#' mount point, use
912                  * the read-only, otherwise use the one specified.
913                  */
914                 if (mtType == '#' && (scp->flags & CM_SCACHEFLAG_PURERO)
915                         && volp->roID != 0 && type == RWVOL)
916                         type = ROVOL;
917                 if (type == ROVOL)
918                         scp->mountRootFidp->volume = volp->roID;
919                 else if (type == BACKVOL)
920                         scp->mountRootFidp->volume = volp->bkID;
921                 else
922                         scp->mountRootFidp->volume = volp->rwID;
923
924                 /* the rest of the fid is a magic number */
925                 scp->mountRootFidp->vnode = 1;
926                 scp->mountRootFidp->unique = 1;
927                 scp->mountRootGen = cm_mountRootGen;
928                
929                 tfid = *scp->mountRootFidp;
930                 lock_ReleaseMutex(&scp->mx);
931                 code = cm_GetSCache(&tfid, outScpp, userp, reqp);
932                 lock_ObtainMutex(&scp->mx);
933         }
934
935 done:
936         free(cellNamep);
937         free(volNamep);
938         return code;
939 }
940
941 int cm_ExpandSysName(char *inp, char *outp, long outSize)
942 {
943         char *tp;
944     int prefixCount;
945
946     tp = strrchr(inp, '@');
947     if (tp == NULL) return 0;           /* no @sys */
948
949     if (strcmp(tp, "@sys") != 0) return 0;      /* no @sys */
950
951         /* caller just wants to know if this is a valid @sys type of name */
952         if (outp == NULL) return 1;
953
954         /* otherwise generate the properly expanded @sys name */
955     prefixCount = tp - inp;
956
957     strncpy(outp, inp, prefixCount);    /* copy out "a." from "a.@sys" */
958     outp[prefixCount] = 0;                      /* null terminate the "a." */
959     strcat(outp, cm_sysName);           /* append i386_nt40 */
960     return 1;
961 }   
962
963 long cm_Lookup(cm_scache_t *dscp, char *namep, long flags, cm_user_t *userp,
964         cm_req_t *reqp, cm_scache_t **outpScpp)
965 {
966         long code;
967         int dnlcHit = 1;        /* did we hit in the dnlc? yes, we did */
968     cm_scache_t *tscp = NULL;
969     cm_scache_t *mountedScp;
970     cm_lookupSearch_t rock;
971     char tname[256];
972         int getroot;
973
974         if (dscp->fid.vnode == 1 && dscp->fid.unique == 1
975          && strcmp(namep, "..") == 0) {
976                 if (dscp->dotdotFidp == (cm_fid_t *)NULL
977              || dscp->dotdotFidp->volume == 0)
978                         return CM_ERROR_NOSUCHVOLUME;
979                 rock.fid = *dscp->dotdotFidp;
980                 goto haveFid;
981         }
982
983         if (cm_ExpandSysName(namep, tname, sizeof(tname))) {
984                 namep = tname;
985     }
986         memset(&rock, 0, sizeof(rock));
987     rock.fid.cell = dscp->fid.cell;
988     rock.fid.volume = dscp->fid.volume;
989     rock.searchNamep = namep;
990     rock.caseFold = (flags & CM_FLAG_CASEFOLD);
991         rock.hasTilde = ((strchr(namep, '~') != NULL) ? 1 : 0);
992
993         /* If NOMOUNTCHASE, bypass DNLC by passing NULL scp pointer */
994         code = cm_ApplyDir(dscp, cm_LookupSearchProc, &rock, NULL, userp, reqp,
995                        (flags & CM_FLAG_NOMOUNTCHASE) ? NULL : &tscp);
996
997         /* code == 0 means we fell off the end of the dir, while stopnow means
998      * that we stopped early, probably because we found the entry we're
999          * looking for.  Any other non-zero code is an error.
1000      */
1001     if (code && code != CM_ERROR_STOPNOW) 
1002         return code;
1003
1004         getroot = (dscp==cm_rootSCachep) ;
1005     if (!rock.found) {
1006         if (!cm_freelanceEnabled || !getroot) {
1007             if (flags & CM_FLAG_CHECKPATH)
1008                 return CM_ERROR_NOSUCHPATH;
1009             else
1010                 return CM_ERROR_NOSUCHFILE;
1011         }
1012         else {  /* nonexistent dir on freelance root, so add it */
1013                         osi_Log1(afsd_logp,"cm_Lookup adding mount for non-existent directory: %s", 
1014                      osi_LogSaveString(afsd_logp,namep));
1015                         code = cm_FreelanceAddMount(namep, namep, "root.cell.", namep[0] == '.', &rock.fid);
1016             if (code < 0) {   /* add mount point failed, so give up */
1017                 if (flags & CM_FLAG_CHECKPATH)
1018                     return CM_ERROR_NOSUCHPATH;
1019                 else
1020                     return CM_ERROR_NOSUCHFILE;
1021             }
1022             tscp = NULL;   /* to force call of cm_GetSCache */
1023         }
1024         }
1025
1026 haveFid:       
1027         if ( !tscp )    /* we did not find it in the dnlc */
1028         {
1029                 dnlcHit = 0;    
1030         code = cm_GetSCache(&rock.fid, &tscp, userp, reqp);
1031         if (code) 
1032             return code;
1033         }
1034     /* tscp is now held */
1035
1036         lock_ObtainMutex(&tscp->mx);
1037         code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1038                       CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
1039     if (code) { 
1040                 lock_ReleaseMutex(&tscp->mx);
1041                 cm_ReleaseSCache(tscp);
1042         return code;
1043         }
1044     /* tscp is now locked */
1045
1046     if (!(flags & CM_FLAG_NOMOUNTCHASE)
1047               && tscp->fileType == CM_SCACHETYPE_MOUNTPOINT) {
1048                 /* mount points are funny: they have a volume name to mount
1049          * the root of.
1050          */
1051                 code = cm_ReadMountPoint(tscp, userp, reqp);
1052         if (code == 0)
1053                         code = cm_FollowMountPoint(tscp, dscp, userp, reqp,
1054                                         &mountedScp);
1055                 lock_ReleaseMutex(&tscp->mx);
1056                 cm_ReleaseSCache(tscp);
1057                 if (code) {
1058             return code;
1059         }
1060         tscp = mountedScp;
1061     }
1062         else {
1063                 lock_ReleaseMutex(&tscp->mx);
1064         }
1065
1066         /* copy back pointer */
1067     *outpScpp = tscp;
1068
1069         /* insert scache in dnlc */
1070         if ( !dnlcHit && !(flags & CM_FLAG_NOMOUNTCHASE) && rock.ExactFound ) {
1071             /* lock the directory entry to prevent racing callback revokes */
1072             lock_ObtainMutex(&dscp->mx);
1073             if ( dscp->cbServerp && dscp->cbExpires )
1074             cm_dnlcEnter(dscp, namep, tscp);
1075             lock_ReleaseMutex(&dscp->mx);
1076         }
1077
1078         /* and return */
1079     return 0;
1080 }
1081
1082 long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp)
1083 {
1084         long code;
1085         cm_conn_t *connp;
1086         AFSFid afsFid;
1087         int sflags;
1088         AFSFetchStatus newDirStatus;
1089         AFSVolSync volSync;
1090
1091 #ifdef AFS_FREELANCE_CLIENT
1092         if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
1093           /* deleting a mount point from the root dir. */
1094           code = cm_FreelanceRemoveMount(namep);
1095           return code;
1096         }
1097 #endif
1098
1099         /* make sure we don't screw up the dir status during the merge */
1100         lock_ObtainMutex(&dscp->mx);
1101         sflags = CM_SCACHESYNC_STOREDATA;
1102         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, sflags);
1103         lock_ReleaseMutex(&dscp->mx);
1104         if (code) return code;
1105
1106         /* make the RPC */
1107         afsFid.Volume = dscp->fid.volume;
1108         afsFid.Vnode = dscp->fid.vnode;
1109         afsFid.Unique = dscp->fid.unique;
1110         do {
1111                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1112                 if (code) continue;
1113                 
1114                 code = RXAFS_RemoveFile(connp->callp, &afsFid, namep,
1115                                         &newDirStatus, &volSync);
1116                 
1117         } while (cm_Analyze(connp, userp, reqp,
1118                             &dscp->fid, &volSync, NULL, code));
1119         code = cm_MapRPCError(code, reqp);
1120
1121         lock_ObtainMutex(&dscp->mx);
1122         cm_dnlcRemove(dscp, namep);
1123         cm_SyncOpDone(dscp, NULL, sflags);
1124         if (code == 0) cm_MergeStatus(dscp, &newDirStatus, &volSync, userp, 0);
1125         lock_ReleaseMutex(&dscp->mx);
1126
1127         return code;
1128 }
1129
1130 /* called with a locked vnode, and fills in the link info.
1131  * returns this the vnode still locked.
1132  */
1133 long cm_HandleLink(cm_scache_t *linkScp, cm_user_t *userp, cm_req_t *reqp)
1134 {
1135         long code;
1136         cm_buf_t *bufp;
1137         long temp;
1138         osi_hyper_t thyper;
1139
1140         lock_AssertMutex(&linkScp->mx);
1141         if (!linkScp->mountPointStringp) {
1142                 /* read the link data */
1143                 lock_ReleaseMutex(&linkScp->mx);
1144                 thyper.LowPart = thyper.HighPart = 0;
1145                 code = buf_Get(linkScp, &thyper, &bufp);
1146                 lock_ObtainMutex(&linkScp->mx);
1147                 if (code) return code;
1148                 while (1) {
1149                         code = cm_SyncOp(linkScp, bufp, userp, reqp, 0,
1150                                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
1151                         if (code) {
1152                                 buf_Release(bufp);
1153                                 return code;
1154                         }
1155                         if (cm_HaveBuffer(linkScp, bufp, 0)) break;
1156                         
1157                         code = cm_GetBuffer(linkScp, bufp, NULL, userp, reqp);
1158                         if (code) {
1159                                 buf_Release(bufp);
1160                                 return code;
1161                         }
1162                 } /* while loop to get the data */
1163                 
1164                 /* now if we still have no link read in,
1165                  * copy the data from the buffer */
1166                 if ((temp = linkScp->length.LowPart) >= 1024) {
1167                         buf_Release(bufp);
1168                         return CM_ERROR_TOOBIG;
1169                 }
1170                 
1171                 /* otherwise, it fits; make sure it is still null (could have
1172                  * lost race with someone else referencing this link above),
1173                  * and if so, copy in the data.
1174                  */
1175                 if (linkScp->mountPointStringp == NULL) {
1176                         linkScp->mountPointStringp = malloc(temp+1);
1177                         strncpy(linkScp->mountPointStringp, bufp->datap, temp);
1178                         linkScp->mountPointStringp[temp] = 0;   /* null terminate */
1179                 }
1180                 buf_Release(bufp);
1181         }       /* don't have sym link contents cached */
1182         
1183         return 0;
1184 }
1185
1186 /* called with a held vnode and a path suffix, with the held vnode being a
1187  * symbolic link.  Our goal is to generate a new path to interpret, and return
1188  * this new path in newSpaceBufferp.  If the new vnode is relative to a dir
1189  * other than the directory containing the symbolic link, then the new root is
1190  * returned in *newRootScpp, otherwise a null is returned there.
1191  */
1192 long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp,
1193         cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
1194         cm_user_t *userp, cm_req_t *reqp)
1195 {
1196         long code;
1197         char *linkp;
1198         cm_space_t *tsp;
1199
1200         lock_ObtainMutex(&linkScp->mx);
1201         code = cm_HandleLink(linkScp, userp, reqp);
1202         if (code) goto done;
1203
1204         /* if we may overflow the buffer, bail out; buffer is signficantly
1205          * bigger than max path length, so we don't really have to worry about
1206          * being a little conservative here.
1207          */
1208         if (strlen(linkScp->mountPointStringp) + strlen(pathSuffixp) + 2
1209              >= CM_UTILS_SPACESIZE)
1210                 return CM_ERROR_TOOBIG;
1211
1212         tsp = cm_GetSpace();
1213         linkp = linkScp->mountPointStringp;
1214         if (strncmp(linkp, cm_mountRoot, cm_mountRootLen) == 0) {
1215                 if (strlen(linkp) > cm_mountRootLen)
1216                         strcpy(tsp->data, linkp+cm_mountRootLen+1);
1217                 else
1218                         tsp->data[0] = 0;
1219                 *newRootScpp = cm_rootSCachep;
1220                 cm_HoldSCache(cm_rootSCachep);
1221         } else if (*linkp == '\\' || *linkp == '/') {
1222           /* formerly, this was considered to be from the AFS root,
1223              but this seems to create problems.  instead, we will just
1224              reject the link */
1225 #if 0
1226                 strcpy(tsp->data, linkp+1);
1227                 *newRootScpp = cm_rootSCachep;
1228                 cm_HoldSCache(cm_rootSCachep);
1229 #else
1230                 code = CM_ERROR_NOSUCHPATH;
1231                 goto done;
1232 #endif
1233         }
1234         else {
1235                 /* a relative link */
1236                 strcpy(tsp->data, linkp);
1237                 *newRootScpp = NULL;
1238         }
1239         if (pathSuffixp[0] != 0) {      /* if suffix string is non-null */
1240                 strcat(tsp->data, "\\");
1241                 strcat(tsp->data, pathSuffixp);
1242         }
1243         *newSpaceBufferp = tsp;
1244         code = 0;
1245
1246 done:
1247         lock_ReleaseMutex(&linkScp->mx);
1248         return code;
1249 }
1250
1251 long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags,
1252         cm_user_t *userp, char *tidPathp, cm_req_t *reqp, cm_scache_t **outScpp)
1253 {
1254         long code;
1255         char *tp;                       /* ptr moving through input buffer */
1256         char tc;                        /* temp char */
1257         int haveComponent;              /* has new component started? */
1258         char component[256];            /* this is the new component */
1259         char *cp;                       /* component name being assembled */
1260         cm_scache_t *tscp;              /* current location in the hierarchy */
1261         cm_scache_t *nscp;              /* next dude down */
1262         cm_scache_t *dirScp;            /* last dir we searched */
1263         cm_scache_t *linkScp;           /* new root for the symlink we just
1264                                          * looked up */
1265         cm_space_t *psp;                /* space for current path, if we've hit
1266                                          * any symlinks */
1267         cm_space_t *tempsp;             /* temp vbl */
1268         char *restp;                    /* rest of the pathname to interpret */
1269         int symlinkCount;               /* count of # of symlinks traversed */
1270         int extraFlag;                  /* avoid chasing mt pts for dir cmd */
1271         int phase = 1;                  /* 1 = tidPathp, 2 = pathp */
1272
1273         tp = tidPathp;
1274         if (tp == NULL) {
1275                 tp = pathp;
1276                 phase = 2;
1277         }
1278         if (tp == NULL) {
1279                 tp = "";
1280         }
1281         haveComponent = 0;
1282         psp = NULL;
1283         tscp = rootSCachep;
1284         cm_HoldSCache(tscp);
1285         symlinkCount = 0;
1286         while (1) {
1287             tc = *tp++;
1288                 
1289             /* map Unix slashes into DOS ones so we can interpret Unix
1290              * symlinks properly
1291              */
1292             if (tc == '/') tc = '\\';
1293
1294             if (!haveComponent) {
1295                         if (tc == '\\') continue;
1296             else if (tc == 0) {
1297                                 if (phase == 1) {
1298                                         phase = 2;
1299                                         tp = pathp;
1300                                         continue;
1301                                 }
1302                 code = 0;
1303                 break;
1304             }
1305             else {
1306                                 haveComponent = 1;
1307                 cp = component;
1308                 *cp++ = tc;
1309             }
1310             }
1311             else {
1312                 /* we have a component here */
1313                 if (tc == 0 || tc == '\\') {
1314                     /* end of the component; we're at the last
1315                      * component if tc == 0.  However, if the last
1316                      * is a symlink, we have more to do.
1317                      */
1318                     *cp++ = 0;  /* add null termination */
1319                     extraFlag = 0;
1320                     if ((flags & CM_FLAG_DIRSEARCH) && tc == 0)
1321                         extraFlag = CM_FLAG_NOMOUNTCHASE;
1322                     code = cm_Lookup(tscp, component,
1323                                       flags | extraFlag,
1324                                       userp, reqp, &nscp);
1325
1326                     if (code) {
1327                         cm_ReleaseSCache(tscp);
1328                         if (psp) cm_FreeSpace(psp);
1329                         return code;
1330                     }
1331                     haveComponent = 0;  /* component done */
1332                     dirScp = tscp;              /* for some symlinks */
1333                     tscp = nscp;        /* already held */
1334                     if (tc == 0 && !(flags & CM_FLAG_FOLLOW) && phase == 2) {
1335                         code = 0;
1336                         cm_ReleaseSCache(dirScp);
1337                         break;
1338                     }
1339
1340                     /* now, if tscp is a symlink, we should follow
1341                      * it and assemble the path again.
1342                      */
1343                     lock_ObtainMutex(&tscp->mx);
1344                     code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1345                                       CM_SCACHESYNC_GETSTATUS
1346                                       | CM_SCACHESYNC_NEEDCALLBACK);
1347                     if (code) {
1348                         lock_ReleaseMutex(&tscp->mx);
1349                         cm_ReleaseSCache(tscp);
1350                         cm_ReleaseSCache(dirScp);
1351                         break;
1352                     }
1353                     if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
1354                         /* this is a symlink; assemble a new buffer */
1355                         lock_ReleaseMutex(&tscp->mx);
1356                         if (symlinkCount++ >= 16) {
1357                             cm_ReleaseSCache(tscp);
1358                             cm_ReleaseSCache(dirScp);
1359                             if (psp) cm_FreeSpace(psp);
1360                             return CM_ERROR_TOOBIG;
1361                         }
1362                         if (tc == 0) restp = "";
1363                         else restp = tp;
1364                         code = cm_AssembleLink(tscp, restp, &linkScp, &tempsp, userp, reqp);
1365                         if (code) {
1366                             /* something went wrong */
1367                             cm_ReleaseSCache(tscp);
1368                             cm_ReleaseSCache(dirScp);
1369                             break;
1370                         }
1371
1372                         /* otherwise, tempsp has the new path,
1373                          * and linkScp is the new root from
1374                          * which to interpret that path.
1375                          * Continue with the namei processing,
1376                          * also doing the bookkeeping for the
1377                          * space allocation and tracking the
1378                          * vnode reference counts.
1379                          */
1380                         if (psp) cm_FreeSpace(psp);
1381                         psp = tempsp;
1382                         tp = psp->data;
1383                         cm_ReleaseSCache(tscp);
1384                         tscp = linkScp; /* already held
1385                                          * by AssembleLink */
1386                         /* now, if linkScp is null, that's
1387                          * AssembleLink's way of telling us that
1388                          * the sym link is relative to the dir
1389                          * containing the link.  We have a ref
1390                          * to it in dirScp, and we hold it now
1391                          * and reuse it as the new spot in the
1392                          * dir hierarchy.
1393                          */
1394                         if (tscp == NULL) {
1395                             cm_HoldSCache(dirScp);
1396                             tscp = dirScp;
1397                         }
1398                     }   /* if we have a sym link */
1399                     else {
1400                         /* not a symlink, we may be done */
1401                         lock_ReleaseMutex(&tscp->mx);
1402                         if (tc == 0) {
1403                             if (phase == 1) {
1404                                 phase = 2;
1405                                 tp = pathp;
1406                                 continue;
1407                             }
1408                             cm_ReleaseSCache(dirScp);
1409                             code = 0;
1410                             break;
1411                         }
1412                     }
1413                     cm_ReleaseSCache(dirScp);
1414                 } /* end of a component */
1415                 else *cp++ = tc;
1416             } /* we have a component */
1417         } /* big while loop over all components */
1418
1419         /* already held */
1420     if (psp) cm_FreeSpace(psp);
1421         if (code == 0) *outScpp = tscp;
1422         return code;
1423 }
1424
1425 /* called with a dir, and a vnode within the dir that happens to be a symlink.
1426  * We chase the link, and return a held pointer to the target, if it exists,
1427  * in *outScpp.  If we succeed, we return 0, otherwise we return an error code
1428  * and do not hold or return a target vnode.
1429  *
1430  * This is very similar to calling cm_NameI with the last component of a name,
1431  * which happens to be a symlink, except that we've already passed by the name.
1432  *
1433  * This function is typically called by the directory listing functions, which
1434  * encounter symlinks but need to return the proper file length so programs
1435  * like "more" work properly when they make use of the attributes retrieved from
1436  * the dir listing.
1437  *
1438  * The input vnode should not be locked when this function is called.
1439  */
1440 long cm_EvaluateSymLink(cm_scache_t *dscp, cm_scache_t *linkScp,
1441         cm_scache_t **outScpp, cm_user_t *userp, cm_req_t *reqp)
1442 {
1443         long code;
1444         cm_space_t *spacep;
1445         cm_scache_t *newRootScp;
1446
1447         osi_Log1(afsd_logp, "Evaluating symlink vp %x", linkScp);
1448
1449         code = cm_AssembleLink(linkScp, "", &newRootScp, &spacep, userp, reqp);
1450         if (code) return code;
1451         
1452         /* now, if newRootScp is NULL, we're really being told that the symlink
1453          * is relative to the current directory (dscp).
1454          */
1455         if (newRootScp == NULL) {
1456                 newRootScp = dscp;
1457                 cm_HoldSCache(dscp);
1458         }
1459         
1460         code = cm_NameI(newRootScp, spacep->data,
1461                 CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW | CM_FLAG_DIRSEARCH,
1462                 userp, NULL, reqp, outScpp);
1463
1464         /* this stuff is allocated no matter what happened on the namei call,
1465          * so free it */
1466         cm_FreeSpace(spacep);
1467         cm_ReleaseSCache(newRootScp);
1468
1469         return code;
1470 }
1471
1472 /* make this big enough so that one buffer of dir pages won't overflow.  We'll
1473  * check anyway, but we want to minimize the chance that we have to leave stuff
1474  * unstat'd.
1475  */
1476 #define CM_BULKMAX              128
1477
1478 /* rock for bulk stat calls */
1479 typedef struct cm_bulkStat {
1480         osi_hyper_t bufOffset;  /* only do it for things in this buffer page */
1481
1482         /* info for the actual call */
1483         int counter;                    /* next free slot */
1484         AFSFid fids[CM_BULKMAX];
1485         AFSFetchStatus stats[CM_BULKMAX];
1486         AFSCallBack callbacks[CM_BULKMAX];
1487 } cm_bulkStat_t;
1488
1489 /* for a given entry, make sure that it isn't in the stat cache, and then
1490  * add it to the list of file IDs to be obtained.
1491  *
1492  * Don't bother adding it if we already have a vnode.  Note that the dir
1493  * is locked, so we have to be careful checking the vnode we're thinking of
1494  * processing, to avoid deadlocks.
1495  */
1496 long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
1497         osi_hyper_t *offp)
1498 {
1499         osi_hyper_t thyper;
1500         cm_bulkStat_t *bsp;
1501         int i;
1502         cm_scache_t *tscp;
1503         cm_fid_t tfid;
1504
1505         bsp = rockp;
1506
1507         /* Don't overflow bsp. */
1508         if (bsp->counter >= CM_BULKMAX)
1509                 return CM_ERROR_STOPNOW;
1510
1511         thyper.LowPart = buf_bufferSize;
1512         thyper.HighPart = 0;
1513         thyper = LargeIntegerAdd(thyper, bsp->bufOffset);
1514         
1515         /* thyper is now the first byte past the end of the record we're
1516          * interested in, and bsp->bufOffset is the first byte of the record
1517          * we're interested in.
1518          * Skip data in the others.
1519          * Skip '.' and '..'
1520          */
1521         if (LargeIntegerLessThan(*offp, bsp->bufOffset))
1522                 return 0;
1523         if (LargeIntegerGreaterThanOrEqualTo(*offp, thyper))
1524                 return CM_ERROR_STOPNOW;
1525         if (strcmp(dep->name, ".") == 0 || strcmp(dep->name, "..") == 0)
1526                 return 0;
1527         
1528         tfid.cell = scp->fid.cell;
1529         tfid.volume = scp->fid.volume;
1530         tfid.vnode = ntohl(dep->fid.vnode);
1531         tfid.unique = ntohl(dep->fid.unique);
1532         tscp = cm_FindSCache(&tfid);
1533         if (tscp) {
1534                 if (lock_TryMutex(&tscp->mx)) {
1535                         /* we have an entry that we can look at */
1536                         if (cm_HaveCallback(tscp)) {
1537                                 /* we have a callback on it.  Don't bother
1538                                  * fetching this stat entry, since we're happy
1539                                  * with the info we have.
1540                                  */
1541                                 lock_ReleaseMutex(&tscp->mx);
1542                                 cm_ReleaseSCache(tscp);
1543                                 return 0;
1544                         }
1545                         lock_ReleaseMutex(&tscp->mx);
1546                 }       /* got lock */
1547                 cm_ReleaseSCache(tscp);
1548         }       /* found entry */
1549
1550 #ifdef AFS_FREELANCE_CLIENT
1551         // yj: if this is a mountpoint under root.afs then we don't want it
1552         // to be bulkstat-ed, instead, we call getSCache directly and under
1553         // getSCache, it is handled specially.
1554         if      ( cm_freelanceEnabled &&
1555           tfid.cell==AFS_FAKE_ROOT_CELL_ID && 
1556           tfid.volume==AFS_FAKE_ROOT_VOL_ID &&
1557           !(tfid.vnode==0x1 && tfid.unique==0x1) )
1558         {
1559         osi_Log0(afsd_logp, "cm_TryBulkProc Freelance calls cm_SCache on root.afs mountpoint");
1560                 return cm_GetSCache(&tfid, &tscp, NULL, NULL);
1561         }
1562 #endif /* AFS_FREELANCE_CLIENT */
1563
1564         i = bsp->counter++;
1565         bsp->fids[i].Volume = scp->fid.volume;
1566         bsp->fids[i].Vnode = tfid.vnode;
1567         bsp->fids[i].Unique = tfid.unique;
1568         return 0;
1569 }
1570
1571 /* called with a locked scp and a pointer to a buffer.  Make bulk stat
1572  * calls on all undeleted files in the page of the directory specified.
1573  */
1574 void cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
1575         cm_req_t *reqp)
1576 {
1577         long code;
1578         cm_bulkStat_t bb;       /* this is *BIG*, probably 12K or so;
1579                                  * watch for stack problems */
1580         AFSCBFids fidStruct;
1581         AFSBulkStats statStruct;
1582         cm_conn_t *connp;
1583         AFSCBs callbackStruct;
1584         long filex;
1585         AFSVolSync volSync;
1586         cm_callbackRequest_t cbReq;
1587         long filesThisCall;
1588         long i;
1589         long j;
1590         cm_scache_t *scp;
1591         cm_fid_t tfid;
1592
1593         osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%x", (long) dscp);
1594
1595         /* should be on a buffer boundary */
1596         osi_assert((offsetp->LowPart & (buf_bufferSize - 1)) == 0);
1597
1598         bb.counter = 0;
1599         bb.bufOffset = *offsetp;
1600
1601         /* first, assemble the file IDs we need to stat */
1602         code = cm_ApplyDir(dscp, cm_TryBulkProc, (void *) &bb, offsetp, userp,
1603                            reqp, NULL);
1604
1605         /* if we failed, bail out early */
1606         if (code && code != CM_ERROR_STOPNOW) return;
1607         
1608         /* otherwise, we may have one or more bulk stat's worth of stuff in bb;
1609          * make the calls to create the entries.  Handle AFSCBMAX files at a
1610          * time.
1611          */
1612         filex = 0;
1613         while(filex < bb.counter) {
1614                 filesThisCall = bb.counter - filex;
1615                 if (filesThisCall > AFSCBMAX) filesThisCall = AFSCBMAX;
1616
1617                 fidStruct.AFSCBFids_len = filesThisCall;
1618                 fidStruct.AFSCBFids_val = &bb.fids[filex];
1619                 statStruct.AFSBulkStats_len = filesThisCall;
1620                 statStruct.AFSBulkStats_val = &bb.stats[filex];
1621                 callbackStruct.AFSCBs_len = filesThisCall;
1622                 callbackStruct.AFSCBs_val = &bb.callbacks[filex];
1623                 cm_StartCallbackGrantingCall(NULL, &cbReq);
1624                 osi_Log1(afsd_logp, "CALL BulkStatus, %d entries", filesThisCall);
1625                 do {
1626                         code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1627                         if (code) continue;
1628                 
1629                         code = RXAFS_BulkStatus(connp->callp, &fidStruct,
1630                                 &statStruct, &callbackStruct, &volSync);
1631
1632                 } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
1633                                     &volSync, &cbReq, code));
1634                 code = cm_MapRPCError(code, reqp);
1635
1636                 osi_Log0(afsd_logp, "CALL BulkStatus DONE");
1637                 
1638                 /* may as well quit on an error, since we're not going to do
1639                  * much better on the next immediate call, either.
1640                  */
1641                 if (code) break;
1642                 
1643                 /* otherwise, we should do the merges */
1644                 for(i = 0; i<filesThisCall; i++) {
1645                         j = filex + i;
1646                         tfid.cell = dscp->fid.cell;
1647                         tfid.volume = bb.fids[j].Volume;
1648                         tfid.vnode = bb.fids[j].Vnode;
1649                         tfid.unique = bb.fids[j].Unique;
1650                         code = cm_GetSCache(&tfid, &scp, userp, reqp);
1651                         if (code != 0) continue;
1652                         
1653                         /* otherwise, if this entry has no callback info, 
1654                          * merge in this.
1655                          */
1656                         lock_ObtainMutex(&scp->mx);
1657                         /* now, we have to be extra paranoid on merging in this
1658                          * information, since we didn't use cm_SyncOp before
1659                          * starting the fetch to make sure that no bad races
1660                          * were occurring.  Specifically, we need to make sure
1661                          * we don't obliterate any newer information in the
1662                          * vnode than have here.
1663                          *
1664                          * Right now, be pretty conservative: if there's a
1665                          * callback or a pending call, skip it.
1666                          */
1667                         if (scp->cbServerp == NULL
1668                                 && !(scp->flags &
1669                                         (CM_SCACHEFLAG_FETCHING
1670                                          | CM_SCACHEFLAG_STORING
1671                                          | CM_SCACHEFLAG_SIZESTORING))) {
1672                                 cm_EndCallbackGrantingCall(scp, &cbReq,
1673                                         &bb.callbacks[j],
1674                                         CM_CALLBACK_MAINTAINCOUNT);
1675                                 cm_MergeStatus(scp, &bb.stats[j], &volSync,
1676                                         userp, 0);
1677                         }
1678                         lock_ReleaseMutex(&scp->mx);
1679                         cm_ReleaseSCache(scp);
1680                 } /* all files in the response */
1681                 /* now tell it to drop the count,
1682                  * after doing the vnode processing above */
1683                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
1684                 
1685                 filex += filesThisCall;
1686         }       /* while there are still more files to process */
1687         osi_Log0(afsd_logp, "END cm_TryBulkStat");
1688 }
1689
1690 void cm_StatusFromAttr(AFSStoreStatus *statusp, cm_scache_t *scp, cm_attr_t *attrp)
1691 {
1692         long mask;
1693
1694         /* initialize store back mask as inexpensive local variable */
1695         mask = 0;
1696         memset(statusp, 0, sizeof(AFSStoreStatus));
1697
1698         /* copy out queued info from scache first, if scp passed in */
1699         if (scp) {
1700                 if (scp->mask & CM_SCACHEMASK_CLIENTMODTIME) {
1701                         statusp->ClientModTime = scp->clientModTime;
1702                         mask |= AFS_SETMODTIME;
1703                         scp->mask &= ~CM_SCACHEMASK_CLIENTMODTIME;
1704                 }
1705         }
1706
1707         if (attrp) {
1708                 /* now add in our locally generated request */
1709                 if (attrp->mask & CM_ATTRMASK_CLIENTMODTIME) {
1710                         statusp->ClientModTime = attrp->clientModTime;
1711                         mask |= AFS_SETMODTIME;
1712                 }
1713                 if (attrp->mask & CM_ATTRMASK_UNIXMODEBITS) {
1714                         statusp->UnixModeBits = attrp->unixModeBits;
1715                         mask |= AFS_SETMODE;
1716                 }
1717                 if (attrp->mask & CM_ATTRMASK_OWNER) {
1718                         statusp->Owner = attrp->owner;
1719                         mask |= AFS_SETOWNER;
1720                 }
1721                 if (attrp->mask & CM_ATTRMASK_GROUP) {
1722                         statusp->Group = attrp->group;
1723                         mask |= AFS_SETGROUP;
1724                 }
1725         }
1726         statusp->Mask = mask;
1727 }
1728
1729 /* set the file size, and make sure that all relevant buffers have been
1730  * truncated.  Ensure that any partially truncated buffers have been zeroed
1731  * to the end of the buffer.
1732  */
1733 long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp,
1734         cm_req_t *reqp)
1735 {
1736         long code;
1737         int shrinking;
1738
1739         /* start by locking out buffer creation */
1740         lock_ObtainWrite(&scp->bufCreateLock);
1741
1742         /* verify that this is a file, not a dir or a symlink */
1743         lock_ObtainMutex(&scp->mx);
1744         code = cm_SyncOp(scp, NULL, userp, reqp, 0,
1745                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1746         if (code) goto done;
1747         
1748         if (scp->fileType != CM_SCACHETYPE_FILE) {
1749                 code = CM_ERROR_ISDIR;
1750                 goto done;
1751         }
1752
1753 startover:
1754         if (LargeIntegerLessThan(*sizep, scp->length))
1755                 shrinking = 1;
1756         else
1757                 shrinking = 0;
1758
1759         lock_ReleaseMutex(&scp->mx);
1760
1761         /* can't hold scp->mx lock here, since we may wait for a storeback to
1762          * finish if the buffer package is cleaning a buffer by storing it to
1763          * the server.
1764          */
1765         if (shrinking)
1766                 buf_Truncate(scp, userp, reqp, sizep);
1767         
1768         /* now ensure that file length is short enough, and update truncPos */
1769         lock_ObtainMutex(&scp->mx);
1770         
1771         /* make sure we have a callback (so we have the right value for the
1772          * length), and wait for it to be safe to do a truncate.
1773          */
1774         code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_WRITE,
1775                 CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
1776                 | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
1777         if (code) goto done;
1778
1779         if (LargeIntegerLessThan(*sizep, scp->length)) {
1780                 /* a real truncation.  If truncPos is not set yet, or is bigger
1781                  * than where we're truncating the file, set truncPos to this
1782                  * new value.
1783                  */
1784                 if (!shrinking)
1785                         goto startover;
1786                 if (!(scp->mask & CM_SCACHEMASK_TRUNCPOS)
1787                         || LargeIntegerLessThan(*sizep, scp->length)) {
1788                         /* set trunc pos */
1789                         scp->truncPos = *sizep;
1790                         scp->mask |= CM_SCACHEMASK_TRUNCPOS;
1791                 }
1792                 /* in either case, the new file size has been changed */
1793                 scp->length = *sizep;
1794                 scp->mask |= CM_SCACHEMASK_LENGTH;
1795         }
1796         else if (LargeIntegerGreaterThan(*sizep, scp->length)) {
1797                 /* really extending the file */
1798                 scp->length = *sizep;
1799                 scp->mask |= CM_SCACHEMASK_LENGTH;
1800         }
1801
1802         /* done successfully */
1803         code = 0;
1804
1805 done:
1806         lock_ReleaseMutex(&scp->mx);
1807         lock_ReleaseWrite(&scp->bufCreateLock);
1808
1809         return code;
1810 }
1811
1812 /* set the file size or other attributes (but not both at once) */
1813 long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
1814         cm_req_t *reqp)
1815 {
1816         long code;
1817         int flags;
1818         AFSFetchStatus afsOutStatus;
1819         AFSVolSync volSync;
1820         cm_conn_t *connp;
1821         AFSFid tfid;
1822         AFSStoreStatus afsInStatus;
1823
1824         /* handle file length setting */
1825         if (attrp->mask & CM_ATTRMASK_LENGTH)
1826                 return cm_SetLength(scp, &attrp->length, userp, reqp);
1827
1828         flags = CM_SCACHESYNC_STORESTATUS;
1829
1830         lock_ObtainMutex(&scp->mx);
1831         /* otherwise, we have to make an RPC to get the status */
1832         code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
1833
1834         /* make the attr structure */
1835         cm_StatusFromAttr(&afsInStatus, scp, attrp);
1836
1837         lock_ReleaseMutex(&scp->mx);
1838         if (code) return code;
1839                 
1840         /* now make the RPC */
1841         osi_Log1(afsd_logp, "CALL StoreStatus vp %x", (long) scp);
1842         tfid.Volume = scp->fid.volume;
1843         tfid.Vnode = scp->fid.vnode;
1844         tfid.Unique = scp->fid.unique;
1845         do {
1846                 code = cm_Conn(&scp->fid, userp, reqp, &connp);
1847                 if (code) continue;
1848                 
1849                 code = RXAFS_StoreStatus(connp->callp, &tfid,
1850                         &afsInStatus, &afsOutStatus, &volSync);
1851
1852         } while (cm_Analyze(connp, userp, reqp,
1853                             &scp->fid, &volSync, NULL, code));
1854         code = cm_MapRPCError(code, reqp);
1855
1856         osi_Log1(afsd_logp, "CALL StoreStatus DONE, code %d", code);
1857
1858         lock_ObtainMutex(&scp->mx);
1859         cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
1860         if (code == 0)
1861                 cm_MergeStatus(scp, &afsOutStatus, &volSync, userp,
1862                                 CM_MERGEFLAG_FORCE);
1863         
1864         /* if we're changing the mode bits, discard the ACL cache, 
1865          * since we changed the mode bits.
1866          */
1867         if (afsInStatus.Mask & AFS_SETMODE) cm_FreeAllACLEnts(scp);
1868         lock_ReleaseMutex(&scp->mx);
1869         return code;
1870 }
1871
1872 long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
1873         cm_scache_t **scpp, cm_user_t *userp, cm_req_t *reqp)
1874 {
1875         cm_conn_t *connp;
1876         long code;
1877         AFSFid dirAFSFid;
1878         cm_callbackRequest_t cbReq;
1879         AFSFid newAFSFid;
1880         cm_fid_t newFid;
1881         cm_scache_t *scp;
1882         int didEnd;
1883         AFSStoreStatus inStatus;
1884         AFSFetchStatus updatedDirStatus;
1885         AFSFetchStatus newFileStatus;
1886         AFSCallBack newFileCallback;
1887         AFSVolSync volSync;
1888
1889         /* can't create names with @sys in them; must expand it manually first.
1890          * return "invalid request" if they try.
1891          */
1892         if (cm_ExpandSysName(namep, NULL, 0)) {
1893                 return CM_ERROR_ATSYS;
1894         }
1895
1896         /* before starting the RPC, mark that we're changing the file data, so
1897          * that someone who does a chmod will know to wait until our call
1898          * completes.
1899          */
1900         lock_ObtainMutex(&dscp->mx);
1901         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
1902         if (code == 0) {
1903                 cm_StartCallbackGrantingCall(NULL, &cbReq);
1904         }
1905         lock_ReleaseMutex(&dscp->mx);
1906         if (code) {
1907                 return code;
1908         }
1909         didEnd = 0;
1910
1911         cm_StatusFromAttr(&inStatus, NULL, attrp);
1912
1913         /* try the RPC now */
1914         do {
1915                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
1916                 if (code) continue;
1917                 
1918                 dirAFSFid.Volume = dscp->fid.volume;
1919                 dirAFSFid.Vnode = dscp->fid.vnode;
1920                 dirAFSFid.Unique = dscp->fid.unique;
1921                 code = RXAFS_CreateFile(connp->callp, &dirAFSFid, namep,
1922                                         &inStatus, &newAFSFid, &newFileStatus,
1923                                         &updatedDirStatus, &newFileCallback,
1924                                         &volSync);
1925         } while (cm_Analyze(connp, userp, reqp,
1926                             &dscp->fid, &volSync, &cbReq, code));
1927         code = cm_MapRPCError(code, reqp);
1928         
1929         lock_ObtainMutex(&dscp->mx);
1930         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
1931         if (code == 0) {
1932                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
1933         }
1934         lock_ReleaseMutex(&dscp->mx);
1935
1936         /* now try to create the file's entry, too, but be careful to 
1937          * make sure that we don't merge in old info.  Since we weren't locking
1938          * out any requests during the file's creation, we may have pretty old
1939          * info.
1940          */
1941         if (code == 0) {
1942                 newFid.cell = dscp->fid.cell;
1943                 newFid.volume = dscp->fid.volume;
1944                 newFid.vnode = newAFSFid.Vnode;
1945                 newFid.unique = newAFSFid.Unique;
1946                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
1947                 if (code == 0) {
1948                         lock_ObtainMutex(&scp->mx);
1949                         if (!cm_HaveCallback(scp)) {
1950                                 cm_MergeStatus(scp, &newFileStatus, &volSync,
1951                                                 userp, 0);
1952                                 cm_EndCallbackGrantingCall(scp, &cbReq,
1953                                                         &newFileCallback, 0);
1954                                 didEnd = 1;
1955                         }
1956                         lock_ReleaseMutex(&scp->mx);
1957                         *scpp = scp;
1958                 }
1959         }
1960         
1961         /* make sure we end things properly */
1962         if (!didEnd)
1963                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
1964
1965         return code;
1966 }
1967
1968 long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
1969 {
1970         long code;
1971
1972         lock_ObtainWrite(&scp->bufCreateLock);
1973         code = buf_CleanVnode(scp, userp, reqp);
1974         lock_ReleaseWrite(&scp->bufCreateLock);
1975         if (code == 0) {
1976                 lock_ObtainMutex(&scp->mx);
1977                 scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA
1978                                  | CM_SCACHEFLAG_OUTOFSPACE);
1979                 if (scp->mask & (CM_SCACHEMASK_TRUNCPOS
1980                                    | CM_SCACHEMASK_CLIENTMODTIME
1981                                    | CM_SCACHEMASK_LENGTH))
1982                         code = cm_StoreMini(scp, userp, reqp);
1983                 lock_ReleaseMutex(&scp->mx);
1984         }
1985         return code;
1986 }
1987
1988 long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
1989         cm_user_t *userp, cm_req_t *reqp)
1990 {
1991         cm_conn_t *connp;
1992         long code;
1993         AFSFid dirAFSFid;
1994         cm_callbackRequest_t cbReq;
1995         AFSFid newAFSFid;
1996         cm_fid_t newFid;
1997         cm_scache_t *scp;
1998         int didEnd;
1999         AFSStoreStatus inStatus;
2000         AFSFetchStatus updatedDirStatus;
2001         AFSFetchStatus newDirStatus;
2002         AFSCallBack newDirCallback;
2003         AFSVolSync volSync;
2004
2005         /* can't create names with @sys in them; must expand it manually first.
2006          * return "invalid request" if they try.
2007          */
2008         if (cm_ExpandSysName(namep, NULL, 0)) {
2009                 return CM_ERROR_ATSYS;
2010         }
2011
2012         /* before starting the RPC, mark that we're changing the directory
2013          * data, so that someone who does a chmod on the dir will wait until
2014          * our call completes.
2015          */
2016         lock_ObtainMutex(&dscp->mx);
2017         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2018         if (code == 0) {
2019                 cm_StartCallbackGrantingCall(NULL, &cbReq);
2020         }
2021         lock_ReleaseMutex(&dscp->mx);
2022         if (code) {
2023                 return code;
2024         }
2025         didEnd = 0;
2026
2027         cm_StatusFromAttr(&inStatus, NULL, attrp);
2028
2029         /* try the RPC now */
2030         do {
2031                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2032                 if (code) continue;
2033                 
2034                 dirAFSFid.Volume = dscp->fid.volume;
2035                 dirAFSFid.Vnode = dscp->fid.vnode;
2036                 dirAFSFid.Unique = dscp->fid.unique;
2037                 code = RXAFS_MakeDir(connp->callp, &dirAFSFid, namep,
2038                                      &inStatus, &newAFSFid, &newDirStatus,
2039                                      &updatedDirStatus, &newDirCallback,
2040                                      &volSync);
2041         } while (cm_Analyze(connp, userp, reqp,
2042                             &dscp->fid, &volSync, &cbReq, code));
2043         code = cm_MapRPCError(code, reqp);
2044         
2045         lock_ObtainMutex(&dscp->mx);
2046         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2047         if (code == 0) {
2048                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2049         }
2050         lock_ReleaseMutex(&dscp->mx);
2051
2052         /* now try to create the new dir's entry, too, but be careful to 
2053          * make sure that we don't merge in old info.  Since we weren't locking
2054          * out any requests during the file's creation, we may have pretty old
2055          * info.
2056          */
2057         if (code == 0) {
2058                 newFid.cell = dscp->fid.cell;
2059                 newFid.volume = dscp->fid.volume;
2060                 newFid.vnode = newAFSFid.Vnode;
2061                 newFid.unique = newAFSFid.Unique;
2062                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
2063                 if (code == 0) {
2064                         lock_ObtainMutex(&scp->mx);
2065                         if (!cm_HaveCallback(scp)) {
2066                                 cm_MergeStatus(scp, &newDirStatus, &volSync,
2067                                                 userp, 0);
2068                                 cm_EndCallbackGrantingCall(scp, &cbReq,
2069                                                         &newDirCallback, 0);
2070                                 didEnd = 1;
2071                         }
2072                         lock_ReleaseMutex(&scp->mx);
2073                         cm_ReleaseSCache(scp);
2074                 }
2075         }
2076         
2077         /* make sure we end things properly */
2078         if (!didEnd)
2079                 cm_EndCallbackGrantingCall(NULL, NULL, NULL, 0);
2080         
2081         /* and return error code */
2082         return code;
2083 }
2084
2085 long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags,
2086         cm_attr_t *attrp, cm_user_t *userp, cm_req_t *reqp)
2087 {
2088         cm_conn_t *connp;
2089         long code;
2090         AFSFid dirAFSFid;
2091         AFSFid newAFSFid;
2092         cm_fid_t newFid;
2093         cm_scache_t *scp;
2094         AFSStoreStatus inStatus;
2095         AFSFetchStatus updatedDirStatus;
2096         AFSFetchStatus newLinkStatus;
2097         AFSVolSync volSync;
2098
2099         /* before starting the RPC, mark that we're changing the directory data,
2100          * so that someone who does a chmod on the dir will wait until our
2101          * call completes.
2102          */
2103         lock_ObtainMutex(&dscp->mx);
2104         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2105         lock_ReleaseMutex(&dscp->mx);
2106         if (code) {
2107                 return code;
2108         }
2109
2110         cm_StatusFromAttr(&inStatus, NULL, attrp);
2111
2112         /* try the RPC now */
2113         do {
2114                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2115                 if (code) continue;
2116                 
2117                 dirAFSFid.Volume = dscp->fid.volume;
2118                 dirAFSFid.Vnode = dscp->fid.vnode;
2119                 dirAFSFid.Unique = dscp->fid.unique;
2120                 code = RXAFS_Symlink(connp->callp, &dirAFSFid, namep, contentsp,
2121                                      &inStatus, &newAFSFid, &newLinkStatus,
2122                                      &updatedDirStatus, &volSync);
2123         } while (cm_Analyze(connp, userp, reqp,
2124                             &dscp->fid, &volSync, NULL, code));
2125         code = cm_MapRPCError(code, reqp);
2126         
2127         lock_ObtainMutex(&dscp->mx);
2128         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2129         if (code == 0) {
2130                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2131         }
2132         lock_ReleaseMutex(&dscp->mx);
2133
2134         /* now try to create the new dir's entry, too, but be careful to 
2135          * make sure that we don't merge in old info.  Since we weren't locking
2136          * out any requests during the file's creation, we may have pretty old
2137          * info.
2138          */
2139         if (code == 0) {
2140                 newFid.cell = dscp->fid.cell;
2141                 newFid.volume = dscp->fid.volume;
2142                 newFid.vnode = newAFSFid.Vnode;
2143                 newFid.unique = newAFSFid.Unique;
2144                 code = cm_GetSCache(&newFid, &scp, userp, reqp);
2145                 if (code == 0) {
2146                         lock_ObtainMutex(&scp->mx);
2147                         if (!cm_HaveCallback(scp)) {
2148                                 cm_MergeStatus(scp, &newLinkStatus, &volSync,
2149                                                 userp, 0);
2150                         }
2151                         lock_ReleaseMutex(&scp->mx);
2152                         cm_ReleaseSCache(scp);
2153                 }
2154         }
2155         
2156         /* and return error code */
2157         return code;
2158 }
2159
2160 long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp,
2161         cm_req_t *reqp)
2162 {
2163         cm_conn_t *connp;
2164         long code;
2165         AFSFid dirAFSFid;
2166         int didEnd;
2167         AFSFetchStatus updatedDirStatus;
2168         AFSVolSync volSync;
2169
2170         /* before starting the RPC, mark that we're changing the directory data,
2171          * so that someone who does a chmod on the dir will wait until our
2172          * call completes.
2173          */
2174         lock_ObtainMutex(&dscp->mx);
2175         code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2176         lock_ReleaseMutex(&dscp->mx);
2177         if (code) {
2178                 return code;
2179         }
2180         didEnd = 0;
2181
2182         /* try the RPC now */
2183         do {
2184                 code = cm_Conn(&dscp->fid, userp, reqp, &connp);
2185                 if (code) continue;
2186                 
2187                 dirAFSFid.Volume = dscp->fid.volume;
2188                 dirAFSFid.Vnode = dscp->fid.vnode;
2189                 dirAFSFid.Unique = dscp->fid.unique;
2190                 code = RXAFS_RemoveDir(connp->callp, &dirAFSFid, namep,
2191                                         &updatedDirStatus, &volSync);
2192         } while (cm_Analyze(connp, userp, reqp,
2193                             &dscp->fid, &volSync, NULL, code));
2194         code = cm_MapRPCErrorRmdir(code, reqp);
2195         
2196         lock_ObtainMutex(&dscp->mx);
2197         cm_dnlcRemove(dscp, namep); 
2198         cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2199         if (code == 0) {
2200                 cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
2201         }
2202         lock_ReleaseMutex(&dscp->mx);
2203
2204         /* and return error code */
2205         return code;
2206 }
2207
2208 long cm_Open(cm_scache_t *scp, int type, cm_user_t *userp)
2209 {
2210         /* grab mutex on contents */
2211         lock_ObtainMutex(&scp->mx);
2212
2213         /* reset the prefetch info */
2214         scp->prefetch.base.LowPart = 0;         /* base */
2215         scp->prefetch.base.HighPart = 0;
2216         scp->prefetch.end.LowPart = 0;          /* and end */
2217         scp->prefetch.end.HighPart = 0;
2218         
2219         /* release mutex on contents */
2220         lock_ReleaseMutex(&scp->mx);
2221         
2222         /* we're done */
2223         return 0;
2224 }
2225
2226 long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp,
2227         char *newNamep, cm_user_t *userp, cm_req_t *reqp)
2228 {
2229         cm_conn_t *connp;
2230         long code;
2231         AFSFid oldDirAFSFid;
2232         AFSFid newDirAFSFid;
2233         int didEnd;
2234         AFSFetchStatus updatedOldDirStatus;
2235         AFSFetchStatus updatedNewDirStatus;
2236         AFSVolSync volSync;
2237         int oneDir;
2238
2239         /* before starting the RPC, mark that we're changing the directory data,
2240          * so that someone who does a chmod on the dir will wait until our call
2241          * completes.  We do this in vnode order so that we don't deadlock,
2242          * which makes the code a little verbose.
2243          */
2244         if (oldDscp == newDscp) {
2245                 /* check for identical names */
2246                 if (strcmp(oldNamep, newNamep) == 0)
2247                         return CM_ERROR_RENAME_IDENTICAL;
2248
2249                 oneDir = 1;
2250                 lock_ObtainMutex(&oldDscp->mx);
2251                 cm_dnlcRemove(oldDscp, oldNamep);
2252                 cm_dnlcRemove(oldDscp, newNamep);
2253                 code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2254                                  CM_SCACHESYNC_STOREDATA);
2255                 lock_ReleaseMutex(&oldDscp->mx);
2256         }
2257         else {
2258                 /* two distinct dir vnodes */
2259                 oneDir = 0;
2260                 if (oldDscp->fid.cell != newDscp->fid.cell ||
2261                         oldDscp->fid.volume != newDscp->fid.volume)
2262                                 return CM_ERROR_CROSSDEVLINK;
2263
2264                 /* shouldn't happen that we have distinct vnodes for two
2265                  * different files, but could due to deliberate attack, or
2266                  * stale info.  Avoid deadlocks and quit now.
2267                  */
2268                 if (oldDscp->fid.vnode == newDscp->fid.vnode)
2269                         return CM_ERROR_CROSSDEVLINK;
2270                         
2271                 if (oldDscp->fid.vnode < newDscp->fid.vnode) {
2272                         lock_ObtainMutex(&oldDscp->mx);
2273                         cm_dnlcRemove(oldDscp, oldNamep);
2274                         code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2275                                          CM_SCACHESYNC_STOREDATA);
2276                         lock_ReleaseMutex(&oldDscp->mx);
2277                         if (code == 0) {
2278                                 lock_ObtainMutex(&newDscp->mx);
2279                                 cm_dnlcRemove(newDscp, newNamep);
2280                                 code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
2281                                                  CM_SCACHESYNC_STOREDATA);
2282                                 lock_ReleaseMutex(&newDscp->mx);
2283                                 if (code) {
2284                                         /* cleanup first one */
2285                                         cm_SyncOpDone(oldDscp, NULL,
2286                                                       CM_SCACHESYNC_STOREDATA);
2287                                 }
2288                         }
2289                 }
2290                 else {
2291                         /* lock the new vnode entry first */
2292                         lock_ObtainMutex(&newDscp->mx);
2293                         cm_dnlcRemove(newDscp, newNamep);
2294                         code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
2295                                          CM_SCACHESYNC_STOREDATA);
2296                         lock_ReleaseMutex(&newDscp->mx);
2297                         if (code == 0) {
2298                                 lock_ObtainMutex(&oldDscp->mx);
2299                                 cm_dnlcRemove(oldDscp, oldNamep);
2300                                 code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
2301                                                  CM_SCACHESYNC_STOREDATA);
2302                                 lock_ReleaseMutex(&oldDscp->mx);
2303                                 if (code) {
2304                                         /* cleanup first one */
2305                                         cm_SyncOpDone(newDscp, NULL,
2306                                                       CM_SCACHESYNC_STOREDATA);
2307                                 }
2308                         }
2309                 }
2310         }       /* two distinct vnodes */
2311
2312         if (code) {
2313                 return code;
2314         }
2315         didEnd = 0;
2316
2317         /* try the RPC now */
2318         do {
2319                 code = cm_Conn(&oldDscp->fid, userp, reqp, &connp);
2320                 if (code) continue;
2321                 
2322                 oldDirAFSFid.Volume = oldDscp->fid.volume;
2323                 oldDirAFSFid.Vnode = oldDscp->fid.vnode;
2324                 oldDirAFSFid.Unique = oldDscp->fid.unique;
2325                 newDirAFSFid.Volume = newDscp->fid.volume;
2326                 newDirAFSFid.Vnode = newDscp->fid.vnode;
2327                 newDirAFSFid.Unique = newDscp->fid.unique;
2328                 code = RXAFS_Rename(connp->callp, &oldDirAFSFid, oldNamep,
2329                         &newDirAFSFid, newNamep,
2330                         &updatedOldDirStatus, &updatedNewDirStatus,
2331                         &volSync);
2332         } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
2333                             &volSync, NULL, code));
2334         code = cm_MapRPCError(code, reqp);
2335         
2336         /* update the individual stat cache entries for the directories */
2337         lock_ObtainMutex(&oldDscp->mx);
2338         cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
2339         if (code == 0) {
2340                 cm_MergeStatus(oldDscp, &updatedOldDirStatus, &volSync,
2341                                 userp, 0);
2342         }
2343         lock_ReleaseMutex(&oldDscp->mx);
2344
2345         /* and update it for the new one, too, if necessary */
2346         if (!oneDir) {
2347                 lock_ObtainMutex(&newDscp->mx);
2348                 cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
2349                 if (code == 0) {
2350                         cm_MergeStatus(newDscp, &updatedNewDirStatus, &volSync,
2351                                         userp, 0);
2352                 }
2353                 lock_ReleaseMutex(&newDscp->mx);
2354         }
2355
2356         /* and return error code */
2357         return code;
2358 }
2359
2360 long cm_Lock(cm_scache_t *scp, unsigned char LockType,
2361         LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
2362         u_long Timeout, cm_user_t *userp, cm_req_t *reqp,
2363         void **lockpp)
2364 {
2365         long code;
2366         int Which = ((LockType & 0x1) ? LockRead : LockWrite);
2367         AFSFid tfid;
2368         AFSVolSync volSync;
2369         cm_conn_t *connp;
2370         cm_file_lock_t *fileLock;
2371         osi_queue_t *q;
2372         int found = 0;
2373
2374         /* Look for a conflict.  Also, if we are asking for a shared lock,
2375          * look for another shared lock, so we don't have to do an RPC.
2376          */
2377         q = scp->fileLocks;
2378         while (q) {
2379                 fileLock = (cm_file_lock_t *)
2380                                 ((char *) q - offsetof(cm_file_lock_t, fileq));
2381                 if ((fileLock->flags &
2382                         (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
2383                     == 0) {
2384                         if ((LockType & 0x1) == 0
2385                             || (fileLock->LockType & 0x1) == 0)
2386                                 return CM_ERROR_WOULDBLOCK;
2387                         found = 1;
2388                 }
2389                 q = osi_QNext(q);
2390         }
2391
2392         if (found)
2393                 code = 0;
2394         else {
2395                 tfid.Volume = scp->fid.volume;
2396                 tfid.Vnode = scp->fid.vnode;
2397                 tfid.Unique = scp->fid.unique;
2398                 lock_ReleaseMutex(&scp->mx);
2399                 do {
2400                         code = cm_Conn(&scp->fid, userp, reqp, &connp);
2401                         if (code) break;
2402                         code = RXAFS_SetLock(connp->callp, &tfid, Which,
2403                                              &volSync);
2404                 } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
2405                                     NULL, code));
2406                 lock_ObtainMutex(&scp->mx);
2407                 code = cm_MapRPCError(code, reqp);
2408         }
2409
2410         if (code == 0 || Timeout != 0) {
2411                 fileLock = malloc(sizeof(cm_file_lock_t));
2412                 fileLock->LockType = LockType;
2413                 cm_HoldUser(userp);
2414                 fileLock->userp = userp;
2415                 fileLock->fid = scp->fid;
2416                 fileLock->LOffset = LOffset;
2417                 fileLock->LLength = LLength;
2418                 fileLock->flags = (code == 0 ? 0 : CM_FILELOCK_FLAG_WAITING);
2419                 osi_QAdd(&scp->fileLocks, &fileLock->fileq);
2420                 lock_ObtainWrite(&cm_scacheLock);
2421                 osi_QAdd(&cm_allFileLocks, &fileLock->q);
2422                 lock_ReleaseWrite(&cm_scacheLock);
2423                 if (code != 0) *lockpp = fileLock;
2424         }
2425         return code;
2426 }
2427
2428 long cm_Unlock(cm_scache_t *scp, unsigned char LockType,
2429         LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
2430         cm_user_t *userp, cm_req_t *reqp)
2431 {
2432         long code = 0;
2433         int Which = ((LockType & 0x1) ? LockRead : LockWrite);
2434         AFSFid tfid;
2435         AFSVolSync volSync;
2436         cm_conn_t *connp;
2437         cm_file_lock_t *fileLock, *ourLock;
2438         osi_queue_t *q, *qq;
2439         int anotherReader = 0;
2440         int smallLock = 0;
2441         int found = 0;
2442
2443         if (LargeIntegerLessThan(LLength, scp->length))
2444                 smallLock = 1;
2445
2446         /* Look for our own lock on the list, so as to remove it.
2447          * Also, determine if we're the last reader; if not, avoid an RPC.
2448          */
2449         q = scp->fileLocks;
2450         while (q) {
2451                 fileLock = (cm_file_lock_t *)
2452             ((char *) q - offsetof(cm_file_lock_t, fileq));
2453                 if (!found
2454                     && fileLock->userp == userp
2455                     && LargeIntegerEqualTo(fileLock->LOffset, LOffset)
2456                     && LargeIntegerEqualTo(fileLock->LLength, LLength)) {
2457                         found = 1;
2458                         ourLock = fileLock;
2459                         qq = q;
2460                 }
2461                 else if (fileLock->LockType & 0x1)
2462                         anotherReader = 1;
2463                 q = osi_QNext(q);
2464         }
2465
2466         /* ignore byte ranges */
2467         if (smallLock && !found)
2468                 return 0;
2469
2470         /* don't try to unlock other people's locks */
2471         if (!found)
2472                 return CM_ERROR_WOULDBLOCK;
2473
2474         /* discard lock record */
2475         osi_QRemove(&scp->fileLocks, qq);
2476         /*
2477          * Don't delete it here; let the daemon delete it, to simplify
2478          * the daemon's traversal of the list.
2479          */
2480         lock_ObtainWrite(&cm_scacheLock);
2481         ourLock->flags |= CM_FILELOCK_FLAG_INVALID;
2482         cm_ReleaseUser(ourLock->userp);
2483         lock_ReleaseWrite(&cm_scacheLock);
2484
2485         if (!anotherReader) {
2486                 tfid.Volume = scp->fid.volume;
2487                 tfid.Vnode = scp->fid.vnode;
2488                 tfid.Unique = scp->fid.unique;
2489                 lock_ReleaseMutex(&scp->mx);
2490                 do {
2491                         code = cm_Conn(&scp->fid, userp, reqp, &connp);
2492                         if (code) 
2493                 break;
2494                         code = RXAFS_ReleaseLock(connp->callp, &tfid, &volSync);
2495                 } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
2496                                     NULL, code));
2497                 code = cm_MapRPCError(code, reqp);
2498                 lock_ObtainMutex(&scp->mx);
2499         }
2500
2501         return code;
2502 }
2503
2504 void cm_CheckLocks()
2505 {
2506         osi_queue_t *q, *nq;
2507         cm_file_lock_t *fileLock;
2508         cm_req_t req;
2509         AFSFid tfid;
2510         AFSVolSync volSync;
2511         cm_conn_t *connp;
2512         long code;
2513
2514         cm_InitReq(&req);
2515
2516         lock_ObtainWrite(&cm_scacheLock);
2517         q = cm_allFileLocks;
2518         while (q) {
2519                 fileLock = (cm_file_lock_t *) q;
2520                 nq = osi_QNext(q);
2521                 if (fileLock->flags & CM_FILELOCK_FLAG_INVALID) {
2522                         osi_QRemove(&cm_allFileLocks, q);
2523                         free(fileLock);
2524                 }
2525                 else if (!(fileLock->flags & CM_FILELOCK_FLAG_WAITING)) {
2526                         tfid.Volume = fileLock->fid.volume;
2527                         tfid.Vnode = fileLock->fid.vnode;
2528                         tfid.Unique = fileLock->fid.unique;
2529                         lock_ReleaseWrite(&cm_scacheLock);
2530                         do {
2531                                 code = cm_Conn(&fileLock->fid, fileLock->userp,
2532                                                 &req, &connp);
2533                                 if (code) break;
2534                                 code = RXAFS_ExtendLock(connp->callp, &tfid,
2535                                                         &volSync);
2536                         } while (cm_Analyze(connp, fileLock->userp, &req,
2537                                             &fileLock->fid, &volSync, NULL,
2538                                             code));
2539                         code = cm_MapRPCError(code, &req);
2540                         lock_ObtainWrite(&cm_scacheLock);
2541                 }
2542                 q = nq;
2543         }
2544         lock_ReleaseWrite(&cm_scacheLock);
2545 }
2546
2547 long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
2548 {
2549         long code;
2550         int Which = ((oldFileLock->LockType & 0x1) ? LockRead : LockWrite);
2551         cm_scache_t *scp;
2552         AFSFid tfid;
2553         AFSVolSync volSync;
2554         cm_conn_t *connp;
2555         cm_file_lock_t *fileLock;
2556         osi_queue_t *q;
2557         cm_req_t req;
2558         int found = 0;
2559
2560         if (vcp_is_dead) {
2561                 code = CM_ERROR_TIMEDOUT;
2562                 goto handleCode;
2563         }
2564
2565         cm_InitReq(&req);
2566
2567         /* Look for a conflict.  Also, if we are asking for a shared lock,
2568          * look for another shared lock, so we don't have to do an RPC.
2569          */
2570         code = cm_GetSCache(&oldFileLock->fid, &scp, oldFileLock->userp, &req);
2571         if (code)
2572                 return code;
2573
2574         q = scp->fileLocks;
2575         while (q) {
2576                 fileLock = (cm_file_lock_t *)
2577                                 ((char *) q - offsetof(cm_file_lock_t, fileq));
2578                 if ((fileLock->flags &
2579                         (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
2580                     == 0) {
2581                         if ((oldFileLock->LockType & 0x1) == 0
2582                             || (fileLock->LockType & 0x1) == 0) {
2583                                 cm_ReleaseSCache(scp);
2584                                 return CM_ERROR_WOULDBLOCK;
2585                         }
2586                         found = 1;
2587                 }
2588                 q = osi_QNext(q);
2589         }
2590
2591         if (found)
2592                 code = 0;
2593         else {
2594                 tfid.Volume = oldFileLock->fid.volume;
2595                 tfid.Vnode = oldFileLock->fid.vnode;
2596                 tfid.Unique = oldFileLock->fid.unique;
2597                 do {
2598                         code = cm_Conn(&oldFileLock->fid, oldFileLock->userp,
2599                                        &req, &connp);
2600                         if (code) break;
2601                         code = RXAFS_SetLock(connp->callp, &tfid, Which,
2602                                              &volSync);
2603                 } while (cm_Analyze(connp, oldFileLock->userp, &req,
2604                                     &oldFileLock->fid, &volSync,
2605                                     NULL, code));
2606                 code = cm_MapRPCError(code, &req);
2607         }
2608
2609   handleCode:
2610         if (code != 0 && code != CM_ERROR_WOULDBLOCK) {
2611                 lock_ObtainMutex(&scp->mx);
2612                 osi_QRemove(&scp->fileLocks, &oldFileLock->fileq);
2613                 lock_ReleaseMutex(&scp->mx);
2614         }
2615         lock_ObtainWrite(&cm_scacheLock);
2616         if (code == 0)
2617                 oldFileLock->flags = 0;
2618         else if (code != CM_ERROR_WOULDBLOCK) {
2619                 oldFileLock->flags |= CM_FILELOCK_FLAG_INVALID;
2620                 cm_ReleaseUser(oldFileLock->userp);
2621         oldFileLock->userp = NULL;
2622         }
2623         lock_ReleaseWrite(&cm_scacheLock);
2624
2625         return code;
2626 }