c3248754178b09350d75af0874e2c583f6c0535d
[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 #include <windows.h>
14 #include <winsock2.h>
15 #include <stddef.h>
16 #include <malloc.h>
17 #include <string.h>
18 #include <stdlib.h>
19 #include <errno.h>
20
21 #include <osi.h>
22
23 #include "afsd.h"
24 #include "cm_btree.h"
25
26 #ifdef DEBUG
27 extern void afsi_log(char *pattern, ...);
28 #endif
29
30 int cm_enableServerLocks = 1;
31
32 int cm_followBackupPath = 0;
33
34 /*
35  * Case-folding array.  This was constructed by inspecting of SMBtrace output.
36  * I do not know anything more about it.
37  */
38 unsigned char cm_foldUpper[256] = {
39      0x0,  0x1,  0x2,  0x3,  0x4,  0x5,  0x6,  0x7,
40      0x8,  0x9,  0xa,  0xb,  0xc,  0xd,  0xe,  0xf,
41     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
42     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
43     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
44     0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
45     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
46     0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
47     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
48     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
49     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
50     0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
51     0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
52     0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
53     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
54     0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
55     0x80, 0x9a, 0x90, 0x41, 0x8e, 0x41, 0x8f, 0x80,
56     0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x8e, 0x8f,
57     0x90, 0x92, 0x92, 0x4f, 0x99, 0x4f, 0x55, 0x55,
58     0x59, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
59     0x41, 0x49, 0x4f, 0x55, 0xa5, 0xa5, 0x56, 0xa7,
60     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
61     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
62     0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
63     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
64     0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
65     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
66     0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
67     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
68     0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
69     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
70     0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
71 };
72
73 /*
74  * Case-insensitive string comparison.  We used to use stricmp, but it doesn't
75  * know about 8-bit characters (e.g. 129 is lowercase u-umlaut, 154 is
76  * upper-case u-umlaut).
77  */
78 int cm_stricmp(const char *str1, const char *str2)
79 {
80     char c1, c2;
81
82     while (1) {
83         if (*str1 == 0)
84             if (*str2 == 0)
85                 return 0;
86             else
87                 return -1;
88         if (*str2 == 0)
89             return 1;
90         c1 = (char) cm_foldUpper[(unsigned char)(*str1++)];
91         c2 = (char) cm_foldUpper[(unsigned char)(*str2++)];
92         if (c1 < c2)
93             return -1;
94         if (c1 > c2)
95             return 1;
96     }
97 }
98
99 /* characters that are legal in an 8.3 name */
100 /*
101  * We used to have 1's for all characters from 128 to 254.  But
102  * the NT client behaves better if we create an 8.3 name for any
103  * name that has a character with the high bit on, and if we
104  * delete those characters from 8.3 names.  In particular, see
105  * Sybase defect 10859.
106  */
107 char cm_LegalChars[256] = {
108  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110  0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0,
111  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
112  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
114  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
116  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
117  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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 };
125
126 /* return true iff component is a valid 8.3 name */
127 int cm_Is8Dot3(char *namep)
128 {
129     int sawDot = 0;
130     unsigned char tc;
131     int charCount = 0;
132         
133     /*
134      * can't have a leading dot;
135      * special case for . and ..
136      */
137     if (namep[0] == '.') {
138         if (namep[1] == 0)
139             return 1;
140         if (namep[1] == '.' && namep[2] == 0)
141             return 1;
142         return 0;
143     }
144     while (tc = *namep++) {
145         if (tc == '.') {
146             /* saw another dot */
147             if (sawDot) return 0;       /* second dot */
148             sawDot = 1;
149             charCount = 0;
150             continue;
151         }
152         if (cm_LegalChars[tc] == 0)
153             return 0;
154         charCount++;
155         if (!sawDot && charCount > 8)
156             /* more than 8 chars in name */
157             return 0;
158         if (sawDot && charCount > 3)
159             /* more than 3 chars in extension */
160             return 0;
161     }
162     return 1;
163 }
164
165 /*
166  * Number unparsing map for generating 8.3 names;
167  * The version taken from DFS was on drugs.  
168  * You can't include '&' and '@' in a file name.
169  */
170 char cm_8Dot3Mapping[42] =
171 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
172  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 
173  'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 
174  'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '!', '+', '='
175 };
176 int cm_8Dot3MapSize = sizeof(cm_8Dot3Mapping);
177
178 void cm_Gen8Dot3NameInt(const char * longname, cm_dirFid_t * pfid,
179                         char *shortName, char **shortNameEndp)
180 {
181     char number[12];
182     int i, nsize = 0;
183     int vnode = ntohl(pfid->vnode);
184     char *lastDot;
185     int validExtension = 0;
186     char tc, *temp;
187     const char *name;
188
189     /* Unparse the file's vnode number to get a "uniquifier" */
190     do {
191         number[nsize] = cm_8Dot3Mapping[vnode % cm_8Dot3MapSize];
192         nsize++;
193         vnode /= cm_8Dot3MapSize;
194     } while (vnode);
195
196     /*
197      * Look for valid extension.  There has to be a dot, and
198      * at least one of the characters following has to be legal.
199      */
200     lastDot = strrchr(longname, '.');
201     if (lastDot) {
202         temp = lastDot; temp++;
203         while (tc = *temp++)
204             if (cm_LegalChars[tc])
205                 break;
206         if (tc)
207             validExtension = 1;
208     }
209
210     /* Copy name characters */
211     for (i = 0, name = longname;
212           i < (7 - nsize) && name != lastDot; ) {
213         tc = *name++;
214
215         if (tc == 0)
216             break;
217         if (!cm_LegalChars[tc])
218             continue;
219         i++;
220         *shortName++ = toupper(tc);
221     }
222
223     /* tilde */
224     *shortName++ = '~';
225
226     /* Copy uniquifier characters */
227     memcpy(shortName, number, nsize);
228     shortName += nsize;
229
230     if (validExtension) {
231         /* Copy extension characters */
232         *shortName++ = *lastDot++;      /* copy dot */
233         for (i = 0, tc = *lastDot++;
234               i < 3 && tc;
235               tc = *lastDot++) {
236             if (cm_LegalChars[tc]) {
237                 i++;
238                 *shortName++ = toupper(tc);
239             }
240         }
241     }
242
243     /* Trailing null */
244     *shortName = 0;
245
246     if (shortNameEndp)
247         *shortNameEndp = shortName;
248 }       
249
250 /* return success if we can open this file in this mode */
251 long cm_CheckOpen(cm_scache_t *scp, int openMode, int trunc, cm_user_t *userp,
252                   cm_req_t *reqp)
253 {
254     long rights;
255     long code;
256
257     rights = 0;
258     if (openMode != 1) 
259         rights |= PRSFS_READ;
260     if (openMode == 1 || openMode == 2 || trunc) 
261         rights |= PRSFS_WRITE;
262         
263     lock_ObtainMutex(&scp->mx);
264
265     code = cm_SyncOp(scp, NULL, userp, reqp, rights,
266                       CM_SCACHESYNC_GETSTATUS
267                      | CM_SCACHESYNC_NEEDCALLBACK
268                      | CM_SCACHESYNC_LOCK);
269
270     if (code == 0 && 
271         ((rights & PRSFS_WRITE) || (rights & PRSFS_READ)) &&
272         scp->fileType == CM_SCACHETYPE_FILE) {
273
274         cm_key_t key;
275         unsigned int sLockType;
276         LARGE_INTEGER LOffset, LLength;
277
278         /* Check if there's some sort of lock on the file at the
279            moment. */
280
281         key = cm_GenerateKey(CM_SESSION_CMINT,0,0);
282
283         if (rights & PRSFS_WRITE)
284             sLockType = 0;
285         else
286             sLockType = LOCKING_ANDX_SHARED_LOCK;
287
288         LOffset.HighPart = CM_FLSHARE_OFFSET_HIGH;
289         LOffset.LowPart  = CM_FLSHARE_OFFSET_LOW;
290         LLength.HighPart = CM_FLSHARE_LENGTH_HIGH;
291         LLength.LowPart  = CM_FLSHARE_LENGTH_LOW;
292
293         code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, reqp, NULL);
294
295         if (code == 0) {
296             cm_Unlock(scp, sLockType, LOffset, LLength, key, userp, reqp);
297         } else {
298             /* In this case, we allow the file open to go through even
299                though we can't enforce mandatory locking on the
300                file. */
301             if (code == CM_ERROR_NOACCESS &&
302                 !(rights & PRSFS_WRITE))
303                 code = 0;
304             else {
305                 switch (code) {
306                 case CM_ERROR_ALLOFFLINE:
307                 case CM_ERROR_ALLDOWN:
308                 case CM_ERROR_ALLBUSY:
309                 case CM_ERROR_TIMEDOUT:
310                 case CM_ERROR_RETRY:
311                 case CM_ERROR_WOULDBLOCK:
312                     break;
313                 default:
314                     code = CM_ERROR_SHARING_VIOLATION;
315                 }
316             }
317         }
318
319     } else if (code != 0) {
320         goto _done;
321     }
322
323     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
324
325  _done:
326
327     lock_ReleaseMutex(&scp->mx);
328
329     return code;
330 }
331
332 /* return success if we can open this file in this mode */
333 long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess,
334                     unsigned int createDisp, cm_user_t *userp, cm_req_t *reqp, 
335                     cm_lock_data_t **ldpp)
336 {
337     long rights;
338     long code;
339
340     osi_assertx(ldpp != NULL, "null cm_lock_data_t");
341     *ldpp = NULL;
342
343     /* Always allow delete; the RPC will tell us if it's OK */
344     if (desiredAccess == DELETE)
345         return 0;
346
347     rights = 0;
348
349     if (desiredAccess & AFS_ACCESS_READ)
350         rights |= (scp->fileType == CM_SCACHETYPE_DIRECTORY ? PRSFS_LOOKUP : PRSFS_READ);
351
352     /* We used to require PRSFS_WRITE if createDisp was 4
353        (OPEN_ALWAYS) even if AFS_ACCESS_WRITE was not requested.
354        However, we don't need to do that since the existence of the
355        scp implies that we don't need to create it. */
356     if (desiredAccess & AFS_ACCESS_WRITE)
357         rights |= PRSFS_WRITE;
358
359     lock_ObtainMutex(&scp->mx);
360
361     code = cm_SyncOp(scp, NULL, userp, reqp, rights,
362                       CM_SCACHESYNC_GETSTATUS
363                      | CM_SCACHESYNC_NEEDCALLBACK
364                      | CM_SCACHESYNC_LOCK);
365
366     /*
367      * If the open will fail because the volume is readonly, then we will
368      * return an access denied error instead.  This is to help brain-dead
369      * apps run correctly on replicated volumes.
370      * See defect 10007 for more information.
371      */
372     if (code == CM_ERROR_READONLY)
373         code = CM_ERROR_NOACCESS;
374
375     if (code == 0 &&
376              ((rights & PRSFS_WRITE) || (rights & PRSFS_READ)) &&
377              scp->fileType == CM_SCACHETYPE_FILE) {
378         cm_key_t key;
379         unsigned int sLockType;
380         LARGE_INTEGER LOffset, LLength;
381
382         /* Check if there's some sort of lock on the file at the
383            moment. */
384
385         key = cm_GenerateKey(CM_SESSION_CMINT,0,0);
386         if (rights & PRSFS_WRITE)
387             sLockType = 0;
388         else
389             sLockType = LOCKING_ANDX_SHARED_LOCK;
390
391         /* single byte lock at offset 0x0100 0000 0000 0000 */
392         LOffset.HighPart = CM_FLSHARE_OFFSET_HIGH;
393         LOffset.LowPart  = CM_FLSHARE_OFFSET_LOW;
394         LLength.HighPart = CM_FLSHARE_LENGTH_HIGH;
395         LLength.LowPart  = CM_FLSHARE_LENGTH_LOW;
396
397         code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, reqp, NULL);
398
399         if (code == 0) {
400             (*ldpp) = (cm_lock_data_t *)malloc(sizeof(cm_lock_data_t));
401             if (!*ldpp) {
402                 code = ENOMEM;
403                 goto _done;
404             }
405
406             (*ldpp)->key = key;
407             (*ldpp)->sLockType = sLockType;
408             (*ldpp)->LOffset.HighPart = LOffset.HighPart;
409             (*ldpp)->LOffset.LowPart = LOffset.LowPart;
410             (*ldpp)->LLength.HighPart = LLength.HighPart;
411             (*ldpp)->LLength.LowPart = LLength.LowPart;
412         } else {
413             /* In this case, we allow the file open to go through even
414                though we can't enforce mandatory locking on the
415                file. */
416             if (code == CM_ERROR_NOACCESS &&
417                 !(rights & PRSFS_WRITE))
418                 code = 0;
419             else {
420                 switch (code) {
421                 case CM_ERROR_ALLOFFLINE:
422                 case CM_ERROR_ALLDOWN:
423                 case CM_ERROR_ALLBUSY:
424                 case CM_ERROR_TIMEDOUT:
425                 case CM_ERROR_RETRY:
426                 case CM_ERROR_WOULDBLOCK:
427                     break;
428                 default:
429                     code = CM_ERROR_SHARING_VIOLATION;
430                 }
431             }
432         }
433     } else if (code != 0) {
434         goto _done;
435     }
436
437     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
438
439  _done:
440     lock_ReleaseMutex(&scp->mx);
441
442     return code;
443 }
444
445 extern long cm_CheckNTOpenDone(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp, 
446                                cm_lock_data_t ** ldpp)
447 {
448     if (*ldpp) {
449         lock_ObtainMutex(&scp->mx);
450         cm_Unlock(scp, (*ldpp)->sLockType, (*ldpp)->LOffset, (*ldpp)->LLength, 
451                   (*ldpp)->key, userp, reqp);
452         lock_ReleaseMutex(&scp->mx);
453         free(*ldpp);
454         *ldpp = NULL;
455     }
456     return 0;
457 }
458 /*
459  * When CAP_NT_SMBS has been negotiated, deletion (of files or directories) is
460  * done in three steps:
461  * (1) open for deletion (NT_CREATE_AND_X)
462  * (2) set for deletion on close (NT_TRANSACTION2, SET_FILE_INFO)
463  * (3) close (CLOSE)
464  * We must not do the RPC until step 3.  But if we are going to return an error
465  * code (e.g. directory not empty), we must return it by step 2, otherwise most
466  * clients will not notice it.  So we do a preliminary check.  For deleting
467  * files, this is almost free, since we have already done the RPC to get the
468  * parent directory's status bits.  But for deleting directories, we must do an
469  * additional RPC to get the directory's data to check if it is empty.  Sigh.
470  */
471 long cm_CheckNTDelete(cm_scache_t *dscp, cm_scache_t *scp, cm_user_t *userp,
472         cm_req_t *reqp)
473 {
474     long code;
475     osi_hyper_t thyper;
476     cm_buf_t *bufferp;
477     cm_dirEntry_t *dep = 0;
478     unsigned short *hashTable;
479     unsigned int i, idx;
480     int BeyondPage = 0, HaveDot = 0, HaveDotDot = 0;
481
482     /* First check permissions */
483     lock_ObtainMutex(&scp->mx);
484     code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_DELETE,
485                       CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
486     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
487     lock_ReleaseMutex(&scp->mx);
488     if (code)
489         return code;
490
491     /* If deleting directory, must be empty */
492
493     if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
494         return code;
495
496     thyper.HighPart = 0; thyper.LowPart = 0;
497     lock_ObtainRead(&scp->bufCreateLock);
498     code = buf_Get(scp, &thyper, &bufferp);
499     lock_ReleaseRead(&scp->bufCreateLock);
500     if (code)
501         return code;
502
503     lock_ObtainMutex(&bufferp->mx);
504     lock_ObtainMutex(&scp->mx);
505     while (1) {
506         code = cm_SyncOp(scp, bufferp, userp, reqp, 0,
507                           CM_SCACHESYNC_NEEDCALLBACK
508                           | CM_SCACHESYNC_READ
509                           | CM_SCACHESYNC_BUFLOCKED);
510         if (code)
511             break;
512
513         if (cm_HaveBuffer(scp, bufferp, 1))
514             break;
515
516         /* otherwise, load the buffer and try again */
517         lock_ReleaseMutex(&bufferp->mx);
518         code = cm_GetBuffer(scp, bufferp, NULL, userp, reqp);
519         lock_ReleaseMutex(&scp->mx);
520         lock_ObtainMutex(&bufferp->mx);
521         lock_ObtainMutex(&scp->mx);
522         cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
523         if (code)
524             break;
525     }
526
527     /* We try to determine emptiness without looking beyond the first page,
528      * and without assuming "." and ".." are present and are on the first
529      * page (though these assumptions might, after all, be reasonable).
530      */
531     hashTable = (unsigned short *)(bufferp->datap + (32 * 5));
532     for (i=0; i<128; i++) {
533         idx = ntohs(hashTable[i]);
534         while (idx) {
535             if (idx >= 64) {
536                 BeyondPage = 1;
537                 break;
538             }
539             dep = (cm_dirEntry_t *)(bufferp->datap + (32 * idx));
540             if (strcmp(dep->name, ".") == 0)
541                 HaveDot = 1;
542             else if (strcmp(dep->name, "..") == 0)
543                 HaveDotDot = 1;
544             else {
545                 code = CM_ERROR_NOTEMPTY;
546                 goto done;
547             }
548             idx = ntohs(dep->next);
549         }
550     }
551     if (BeyondPage && HaveDot && HaveDotDot)
552         code = CM_ERROR_NOTEMPTY;
553     else
554         code = 0;
555   done:   
556     lock_ReleaseMutex(&bufferp->mx);
557     buf_Release(bufferp);
558     lock_ReleaseMutex(&scp->mx);
559     return code;
560 }       
561
562 /*
563  * Iterate through all entries in a directory.
564  * When the function funcp is called, the buffer is locked but the
565  * directory vnode is not.
566  *
567  * If the retscp parameter is not NULL, the parmp must be a 
568  * cm_lookupSearch_t object.  
569  */
570 long cm_ApplyDir(cm_scache_t *scp, cm_DirFuncp_t funcp, void *parmp,
571                   osi_hyper_t *startOffsetp, cm_user_t *userp, cm_req_t *reqp,
572                   cm_scache_t **retscp)
573 {
574     char *tp;
575     long code;
576     cm_dirEntry_t *dep = 0;
577     cm_buf_t *bufferp;
578     long temp;
579     osi_hyper_t dirLength;
580     osi_hyper_t bufferOffset;
581     osi_hyper_t curOffset;
582     osi_hyper_t thyper;
583     long entryInDir;
584     long entryInBuffer;
585     cm_pageHeader_t *pageHeaderp;
586     int slotInPage;
587     long nextEntryCookie;
588     int numDirChunks;   /* # of 32 byte dir chunks in this entry */
589         
590     /* get the directory size */
591     lock_ObtainMutex(&scp->mx);
592     code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_LOOKUP,
593                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
594     lock_ReleaseMutex(&scp->mx);
595     if (code)
596         return code;
597         
598     if (scp->fileType != CM_SCACHETYPE_DIRECTORY)
599         return CM_ERROR_NOTDIR;
600
601     if (retscp)                         /* if this is a lookup call */
602     {
603         cm_lookupSearch_t*      sp = parmp;
604
605         if (
606 #ifdef AFS_FREELANCE_CLIENT
607         /* Freelance entries never end up in the DNLC because they
608          * do not have an associated cm_server_t
609          */
610             !(cm_freelanceEnabled &&
611             sp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
612               sp->fid.volume==AFS_FAKE_ROOT_VOL_ID )
613 #else /* !AFS_FREELANCE_CLIENT */
614             TRUE
615 #endif
616             ) 
617         {
618             int casefold = sp->caseFold;
619             sp->caseFold = 0; /* we have a strong preference for exact matches */
620             if ( *retscp = cm_dnlcLookup(scp, sp))      /* dnlc hit */
621             {
622                 sp->caseFold = casefold;
623                 return 0;
624             }
625             sp->caseFold = casefold;
626
627             /* see if we can find it using the directory hash tables.
628                we can only do exact matches, since the hash is case
629                sensitive. */
630             {
631                 cm_dirOp_t dirop;
632 #ifdef USE_BPLUS
633                 int usedBplus = 0;
634 #endif
635
636                 code = ENOENT;
637
638                 code = cm_BeginDirOp(scp, userp, reqp, CM_DIRLOCK_READ, &dirop);
639                 if (code == 0) {
640
641 #ifdef USE_BPLUS
642                     code = cm_BPlusDirLookup(&dirop, sp->searchNamep, &sp->fid);
643                     if (code != EINVAL)
644                         usedBplus = 1;
645                     else 
646 #endif
647                         code = cm_DirLookup(&dirop, sp->searchNamep, &sp->fid);
648
649                     cm_EndDirOp(&dirop);
650                 }
651
652                 if (code == 0) {
653                     /* found it */
654                     sp->found = TRUE;
655                     sp->ExactFound = TRUE;
656                     *retscp = NULL; /* force caller to call cm_GetSCache() */
657                     return 0;
658                 }
659 #ifdef USE_BPLUS
660                 if (usedBplus) {
661                     if (sp->caseFold && code == CM_ERROR_INEXACT_MATCH) {
662                         /* found it */
663                         sp->found = TRUE;
664                         sp->ExactFound = FALSE;
665                         *retscp = NULL; /* force caller to call cm_GetSCache() */
666                         return 0;
667                     }
668                     
669                     return CM_ERROR_BPLUS_NOMATCH;
670                 }
671 #endif 
672             }
673         }
674     }   
675
676     /*
677      * XXX We only get the length once.  It might change when we drop the
678      * lock.
679      */
680     dirLength = scp->length;
681
682     bufferp = NULL;
683     bufferOffset.LowPart = bufferOffset.HighPart = 0;
684     if (startOffsetp)
685         curOffset = *startOffsetp;
686     else {
687         curOffset.HighPart = 0;
688         curOffset.LowPart = 0;
689     }   
690
691     while (1) {
692         /* make sure that curOffset.LowPart doesn't point to the first
693          * 32 bytes in the 2nd through last dir page, and that it
694          * doesn't point at the first 13 32-byte chunks in the first
695          * dir page, since those are dir and page headers, and don't
696          * contain useful information.
697          */
698         temp = curOffset.LowPart & (2048-1);
699         if (curOffset.HighPart == 0 && curOffset.LowPart < 2048) {
700             /* we're in the first page */
701             if (temp < 13*32) temp = 13*32;
702         }
703         else {
704             /* we're in a later dir page */
705             if (temp < 32) temp = 32;
706         }       
707                 
708         /* make sure the low order 5 bits are zero */
709         temp &= ~(32-1);
710                 
711         /* now put temp bits back ito curOffset.LowPart */
712         curOffset.LowPart &= ~(2048-1);
713         curOffset.LowPart |= temp;
714
715         /* check if we've passed the dir's EOF */
716         if (LargeIntegerGreaterThanOrEqualTo(curOffset, dirLength))
717             break;
718                 
719         /* see if we can use the bufferp we have now; compute in which
720          * page the current offset would be, and check whether that's
721          * the offset of the buffer we have.  If not, get the buffer.
722          */
723         thyper.HighPart = curOffset.HighPart;
724         thyper.LowPart = curOffset.LowPart & ~(cm_data.buf_blockSize-1);
725         if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
726             /* wrong buffer */
727             if (bufferp) {
728                 lock_ReleaseMutex(&bufferp->mx);
729                 buf_Release(bufferp);
730                 bufferp = NULL;
731             }
732
733             lock_ObtainRead(&scp->bufCreateLock);
734             code = buf_Get(scp, &thyper, &bufferp);
735             lock_ReleaseRead(&scp->bufCreateLock);
736             if (code) {
737                 /* if buf_Get() fails we do not have a buffer object to lock */
738                 bufferp = NULL;
739                 break;
740             }
741
742 #ifdef AFSIFS
743             /* for the IFS version, we bulkstat the dirents because this
744                routine is used in place of smb_ReceiveCoreSearchDir.  our
745                other option is to modify smb_ReceiveCoreSearchDir itself, 
746                but this seems to be the proper use for cm_ApplyDir. */
747             lock_ObtainMutex(&scp->mx);
748             if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
749                  && (scp->bulkStatProgress.QuadPart <= thyper.QuadPart))
750             {
751                 scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
752                 code = cm_TryBulkStat(scp, &thyper, userp, reqp);
753                 scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
754                 scp->bulkStatProgress = thyper;
755             }
756             lock_ReleaseMutex(&scp->mx);
757 #endif
758
759             lock_ObtainMutex(&bufferp->mx);
760             bufferOffset = thyper;
761
762             /* now get the data in the cache */
763             while (1) {
764                 lock_ObtainMutex(&scp->mx);
765                 code = cm_SyncOp(scp, bufferp, userp, reqp,
766                                   PRSFS_LOOKUP,
767                                   CM_SCACHESYNC_NEEDCALLBACK
768                                   | CM_SCACHESYNC_READ
769                                   | CM_SCACHESYNC_BUFLOCKED);
770                 if (code) {
771                     lock_ReleaseMutex(&scp->mx);
772                     break;
773                 }
774                 cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
775                                 
776                 if (cm_HaveBuffer(scp, bufferp, 1)) {
777                     lock_ReleaseMutex(&scp->mx);
778                     break;
779                 }
780
781                 /* otherwise, load the buffer and try again */
782                 lock_ReleaseMutex(&bufferp->mx);
783                 code = cm_GetBuffer(scp, bufferp, NULL, userp,
784                                     reqp);
785                 lock_ReleaseMutex(&scp->mx);
786                 lock_ObtainMutex(&bufferp->mx);
787                 if (code) 
788                     break;
789             }
790             if (code) {
791                 lock_ReleaseMutex(&bufferp->mx);
792                 buf_Release(bufferp);
793                 bufferp = NULL;
794                 break;
795             }
796         }       /* if (wrong buffer) ... */
797            
798         /* now we have the buffer containing the entry we're interested
799          * in; copy it out if it represents a non-deleted entry.
800          */
801         entryInDir = curOffset.LowPart & (2048-1);
802         entryInBuffer = curOffset.LowPart & (cm_data.buf_blockSize - 1);
803
804         /* page header will help tell us which entries are free.  Page
805          * header can change more often than once per buffer, since
806          * AFS 3 dir page size may be less than (but not more than) a
807          * buffer package buffer.
808          */
809         /* only look intra-buffer */
810         temp = curOffset.LowPart & (cm_data.buf_blockSize - 1);
811         temp &= ~(2048 - 1);    /* turn off intra-page bits */
812         pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
813
814         /* now determine which entry we're looking at in the page.  If
815          * it is free (there's a free bitmap at the start of the dir),
816          * we should skip these 32 bytes.
817          */
818         slotInPage = (entryInDir & 0x7e0) >> 5;
819         if (!(pageHeaderp->freeBitmap[slotInPage>>3]
820                & (1 << (slotInPage & 0x7)))) {
821             /* this entry is free */
822             numDirChunks = 1;   /* only skip this guy */
823             goto nextEntry;
824         }
825
826         tp = bufferp->datap + entryInBuffer;
827         dep = (cm_dirEntry_t *) tp;     /* now points to AFS3 dir entry */
828
829         /* while we're here, compute the next entry's location, too,
830          * since we'll need it when writing out the cookie into the
831          * dir listing stream.
832          */
833         numDirChunks = cm_NameEntries(dep->name, NULL);
834                 
835         /* compute the offset of the cookie representing the next entry */
836         nextEntryCookie = curOffset.LowPart
837             + (CM_DIR_CHUNKSIZE * numDirChunks);
838
839         if (dep->fid.vnode != 0) {
840             /* this is one of the entries to use: it is not deleted */
841             code = (*funcp)(scp, dep, parmp, &curOffset);
842             if (code) 
843                 break;
844         }       /* if we're including this name */
845                 
846       nextEntry:
847         /* and adjust curOffset to be where the new cookie is */
848         thyper.HighPart = 0;
849         thyper.LowPart = CM_DIR_CHUNKSIZE * numDirChunks;
850         curOffset = LargeIntegerAdd(thyper, curOffset);
851     }           /* while copying data for dir listing */
852
853     /* release the mutex */
854     if (bufferp) {
855         lock_ReleaseMutex(&bufferp->mx);
856         buf_Release(bufferp);
857     }
858     return code;
859 }
860
861 int cm_NoneUpper(char *s)
862 {
863     char c;
864     while (c = *s++)
865         if (c >= 'A' && c <= 'Z')
866             return 0;
867     return 1;
868 }
869
870 int cm_NoneLower(char *s)
871 {
872     char c;
873     while (c = *s++)
874         if (c >= 'a' && c <= 'z')
875             return 0;
876     return 1;
877 }
878
879 long cm_LookupSearchProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
880                           osi_hyper_t *offp)
881 {
882     cm_lookupSearch_t *sp;
883     int match;
884     char shortName[13];
885     char *matchName;
886
887     sp = (cm_lookupSearch_t *) rockp;
888
889     matchName = dep->name;
890     if (sp->caseFold)
891         match = cm_stricmp(matchName, sp->searchNamep);
892     else
893         match = strcmp(matchName, sp->searchNamep);
894
895     if (match != 0
896          && sp->hasTilde
897          && !cm_Is8Dot3(dep->name)) {
898         matchName = shortName;
899         cm_Gen8Dot3Name(dep, shortName, NULL);
900         if (sp->caseFold)
901             match = cm_stricmp(matchName, sp->searchNamep);
902         else
903             match = strcmp(matchName, sp->searchNamep);
904     }
905
906     if (match != 0)
907         return 0;
908
909     sp->found = 1;
910     if (!sp->caseFold) 
911         sp->ExactFound = 1;
912
913     if (!sp->caseFold || matchName == shortName) {
914         sp->fid.vnode = ntohl(dep->fid.vnode);
915         sp->fid.unique = ntohl(dep->fid.unique);
916         return CM_ERROR_STOPNOW;
917     }
918
919     /*
920      * If we get here, we are doing a case-insensitive search, and we
921      * have found a match.  Now we determine what kind of match it is:
922      * exact, lower-case, upper-case, or none of the above.  This is done
923      * in order to choose among matches, if there are more than one.
924      */
925
926     /* Exact matches are the best. */
927     match = strcmp(matchName, sp->searchNamep);
928     if (match == 0) {
929         sp->ExactFound = 1;
930         sp->fid.vnode = ntohl(dep->fid.vnode);
931         sp->fid.unique = ntohl(dep->fid.unique);
932         return CM_ERROR_STOPNOW;
933     }
934
935     /* Lower-case matches are next. */
936     if (sp->LCfound)
937         return 0;
938     if (cm_NoneUpper(matchName)) {
939         sp->LCfound = 1;
940         goto inexact;
941     }
942
943     /* Upper-case matches are next. */
944     if (sp->UCfound)
945         return 0;
946     if (cm_NoneLower(matchName)) {
947         sp->UCfound = 1;
948         goto inexact;
949     }
950
951     /* General matches are last. */
952     if (sp->NCfound)
953         return 0;
954     sp->NCfound = 1;
955
956   inexact:
957     sp->fid.vnode = ntohl(dep->fid.vnode);
958     sp->fid.unique = ntohl(dep->fid.unique);
959     return 0;
960 }       
961
962 /* read the contents of a mount point into the appropriate string.
963  * called with locked scp, and returns with locked scp.
964  */
965 long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
966 {
967     long code;
968     cm_buf_t *bufp;
969     osi_hyper_t thyper;
970     int tlen;
971
972     if (scp->mountPointStringp[0]) 
973         return 0;
974         
975     /* otherwise, we have to read it in */
976     lock_ReleaseMutex(&scp->mx);
977
978     lock_ObtainRead(&scp->bufCreateLock);
979     thyper.LowPart = thyper.HighPart = 0;
980     code = buf_Get(scp, &thyper, &bufp);
981     lock_ReleaseRead(&scp->bufCreateLock);
982
983     lock_ObtainMutex(&scp->mx);
984     if (code)
985         return code;
986
987     while (1) {
988         code = cm_SyncOp(scp, bufp, userp, reqp, 0,
989                           CM_SCACHESYNC_READ | CM_SCACHESYNC_NEEDCALLBACK);
990         if (code)
991             goto done;
992
993         cm_SyncOpDone(scp, bufp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
994
995         if (cm_HaveBuffer(scp, bufp, 0)) 
996             break;
997
998         /* otherwise load buffer */
999         code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
1000         if (code)
1001             goto done;
1002     }
1003     /* locked, has callback, has valid data in buffer */
1004     if ((tlen = scp->length.LowPart) > MOUNTPOINTLEN - 1) 
1005         return CM_ERROR_TOOBIG;
1006     if (tlen <= 0) {
1007         code = CM_ERROR_INVAL;
1008         goto done;
1009     }
1010
1011     /* someone else did the work while we were out */
1012     if (scp->mountPointStringp[0]) {
1013         code = 0;
1014         goto done;
1015     }
1016
1017     /* otherwise, copy out the link */
1018     memcpy(scp->mountPointStringp, bufp->datap, tlen);
1019
1020     /* now make it null-terminated.  Note that the original contents of a
1021      * link that is a mount point is "#volname." where "." is there just to
1022      * be turned into a null.  That is, we can trash the last char of the
1023      * link without damaging the vol name.  This is a stupid convention,
1024      * but that's the protocol.
1025      */
1026     scp->mountPointStringp[tlen-1] = 0;
1027     code = 0;
1028
1029   done:
1030     if (bufp) 
1031         buf_Release(bufp);
1032     return code;
1033 }
1034
1035
1036 /* called with a locked scp and chases the mount point, yielding outScpp.
1037  * scp remains locked, just for simplicity of describing the interface.
1038  */
1039 long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp,
1040                          cm_req_t *reqp, cm_scache_t **outScpp)
1041 {
1042     char *cellNamep;
1043     char *volNamep;
1044     int tlen;
1045     long code;
1046     char *cp;
1047     char *mpNamep;
1048     cm_volume_t *volp = NULL;
1049     cm_cell_t *cellp;
1050     char mtType;
1051     cm_fid_t tfid;
1052     size_t vnLength;
1053     int targetType;
1054
1055     if (scp->mountRootFid.cell != 0 && scp->mountRootGen >= cm_data.mountRootGen) {
1056         tfid = scp->mountRootFid;
1057         lock_ReleaseMutex(&scp->mx);
1058         code = cm_GetSCache(&tfid, outScpp, userp, reqp);
1059         lock_ObtainMutex(&scp->mx);
1060         return code;
1061     }
1062
1063     /* parse the volume name */
1064     mpNamep = scp->mountPointStringp;
1065     if (!mpNamep[0])
1066         return CM_ERROR_NOSUCHPATH;
1067     tlen = (int)strlen(scp->mountPointStringp);
1068     mtType = *scp->mountPointStringp;
1069     cellNamep = malloc(tlen);
1070     volNamep = malloc(tlen);
1071
1072     cp = strrchr(mpNamep, ':');
1073     if (cp) {
1074         /* cellular mount point */
1075         memset(cellNamep, 0, tlen);
1076         strncpy(cellNamep, mpNamep+1, cp - mpNamep - 1);
1077         strcpy(volNamep, cp+1);
1078         /* now look up the cell */
1079         lock_ReleaseMutex(&scp->mx);
1080         cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE);
1081         lock_ObtainMutex(&scp->mx);
1082     }
1083     else {
1084         /* normal mt pt */
1085         strcpy(volNamep, mpNamep+1);
1086
1087         cellp = cm_FindCellByID(scp->fid.cell);
1088     }
1089
1090     if (!cellp) {
1091         code = CM_ERROR_NOSUCHCELL;
1092         goto done;
1093     }
1094
1095     vnLength = strlen(volNamep);
1096     if (vnLength >= 8 && strcmp(volNamep + vnLength - 7, ".backup") == 0)
1097         targetType = BACKVOL;
1098     else if (vnLength >= 10
1099               && strcmp(volNamep + vnLength - 9, ".readonly") == 0)
1100         targetType = ROVOL;
1101     else
1102         targetType = RWVOL;
1103
1104     /* check for backups within backups */
1105     if (targetType == BACKVOL
1106          && (scp->flags & (CM_SCACHEFLAG_RO | CM_SCACHEFLAG_PURERO))
1107          == CM_SCACHEFLAG_RO) {
1108         code = CM_ERROR_NOSUCHVOLUME;
1109         goto done;
1110     }
1111
1112     /* now we need to get the volume */
1113     lock_ReleaseMutex(&scp->mx);
1114     if (cm_VolNameIsID(volNamep)) {
1115         code = cm_GetVolumeByID(cellp, atoi(volNamep), userp, reqp, 
1116                                 CM_GETVOL_FLAG_CREATE, &volp);
1117     } else {
1118         code = cm_GetVolumeByName(cellp, volNamep, userp, reqp, 
1119                                   CM_GETVOL_FLAG_CREATE, &volp);
1120     }
1121     lock_ObtainMutex(&scp->mx);
1122         
1123     if (code == 0) {
1124         /* save the parent of the volume root for this is the 
1125          * place where the volume is mounted and we must remember 
1126          * this in the volume structure rather than just in the 
1127          * scache entry lest the scache entry gets recycled 
1128          * (defect 11489)
1129          */
1130         lock_ObtainMutex(&volp->mx);
1131         volp->dotdotFid = dscp->fid;
1132         lock_ReleaseMutex(&volp->mx);
1133
1134         scp->mountRootFid.cell = cellp->cellID;
1135         
1136         /* if the mt pt originates in a .backup volume (not a .readonly)
1137          * and FollowBackupPath is active, and if there is a .backup
1138          * volume for the target, then use the .backup of the target
1139          * instead of the read-write.
1140          */
1141         if (cm_followBackupPath && 
1142             volp->bk.ID != 0 &&
1143             (dscp->flags & (CM_SCACHEFLAG_RO|CM_SCACHEFLAG_PURERO)) == CM_SCACHEFLAG_RO &&
1144             (targetType == RWVOL || targetType == ROVOL && volp->ro.ID == 0)
1145             ) {
1146             targetType = BACKVOL;
1147         } 
1148         /* if the mt pt is in a read-only volume (not just a
1149          * backup), and if there is a read-only volume for the
1150          * target, and if this is a targetType '#' mount point, use
1151          * the read-only, otherwise use the one specified.
1152          */
1153         else if (mtType == '#' && targetType == RWVOL && 
1154                  (scp->flags & CM_SCACHEFLAG_PURERO) && 
1155                  volp->ro.ID != 0) {
1156             targetType = ROVOL;
1157         }
1158         if (targetType == ROVOL)
1159             scp->mountRootFid.volume = volp->ro.ID;
1160         else if (targetType == BACKVOL)
1161             scp->mountRootFid.volume = volp->bk.ID;
1162         else
1163             scp->mountRootFid.volume = volp->rw.ID;
1164
1165         /* the rest of the fid is a magic number */
1166         scp->mountRootFid.vnode = 1;
1167         scp->mountRootFid.unique = 1;
1168         scp->mountRootGen = cm_data.mountRootGen;
1169
1170         tfid = scp->mountRootFid;
1171         lock_ReleaseMutex(&scp->mx);
1172         code = cm_GetSCache(&tfid, outScpp, userp, reqp);
1173         lock_ObtainMutex(&scp->mx);
1174     }
1175
1176   done:
1177     if (volp)
1178         cm_PutVolume(volp);
1179     free(cellNamep);
1180     free(volNamep);
1181     return code;
1182 }       
1183
1184 long cm_LookupInternal(cm_scache_t *dscp, char *namep, long flags, cm_user_t *userp,
1185                        cm_req_t *reqp, cm_scache_t **outpScpp)
1186 {
1187     long code;
1188     int dnlcHit = 1;    /* did we hit in the dnlc? yes, we did */
1189     cm_scache_t *tscp = NULL;
1190     cm_scache_t *mountedScp;
1191     cm_lookupSearch_t rock;
1192     int getroot;
1193
1194     memset(&rock, 0, sizeof(rock));
1195
1196     if (dscp->fid.vnode == 1 && dscp->fid.unique == 1
1197          && strcmp(namep, "..") == 0) {
1198         if (dscp->dotdotFid.volume == 0)
1199             return CM_ERROR_NOSUCHVOLUME;
1200         rock.fid = dscp->dotdotFid;
1201         goto haveFid;
1202     } else if (strcmp(namep, ".") == 0) {
1203         rock.fid = dscp->fid;
1204         goto haveFid;
1205     }
1206
1207     if (flags & CM_FLAG_NOMOUNTCHASE) {
1208         /* In this case, we should go and call cm_Dir* functions
1209            directly since the following cm_ApplyDir() function will
1210            not. */
1211
1212         cm_dirOp_t dirop;
1213 #ifdef USE_BPLUS
1214         int usedBplus = 0;
1215 #endif
1216
1217         code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
1218         if (code == 0) {
1219 #ifdef USE_BPLUS
1220             code = cm_BPlusDirLookup(&dirop, namep, &rock.fid);
1221             if (code != EINVAL)
1222                 usedBplus = 1;
1223             else
1224 #endif
1225                 code = cm_DirLookup(&dirop, namep, &rock.fid);
1226
1227             cm_EndDirOp(&dirop);
1228         }
1229
1230         if (code == 0) {
1231             /* found it */
1232             rock.found = TRUE;
1233             goto haveFid;
1234         }
1235 #ifdef USE_BPLUS
1236         if (usedBplus) {
1237             if (code == CM_ERROR_INEXACT_MATCH && (flags & CM_FLAG_CASEFOLD)) {
1238                 /* found it */
1239                 code = 0;
1240                 rock.found = TRUE;
1241                 goto haveFid;
1242             }
1243             
1244             return CM_ERROR_BPLUS_NOMATCH;
1245         }
1246 #endif
1247     }
1248
1249     rock.fid.cell = dscp->fid.cell;
1250     rock.fid.volume = dscp->fid.volume;
1251     rock.searchNamep = namep;
1252     rock.caseFold = (flags & CM_FLAG_CASEFOLD);
1253     rock.hasTilde = ((strchr(namep, '~') != NULL) ? 1 : 0);
1254
1255     /* If NOMOUNTCHASE, bypass DNLC by passing NULL scp pointer */
1256     code = cm_ApplyDir(dscp, cm_LookupSearchProc, &rock, NULL, userp, reqp,
1257                         (flags & CM_FLAG_NOMOUNTCHASE) ? NULL : &tscp);
1258
1259     /* code == 0 means we fell off the end of the dir, while stopnow means
1260      * that we stopped early, probably because we found the entry we're
1261      * looking for.  Any other non-zero code is an error.
1262      */
1263     if (code && code != CM_ERROR_STOPNOW) {
1264         /* if the cm_scache_t we are searching in is not a directory 
1265          * we must return path not found because the error 
1266          * is to describe the final component not an intermediary
1267          */
1268         if (code == CM_ERROR_NOTDIR) {
1269             if (flags & CM_FLAG_CHECKPATH)
1270                 return CM_ERROR_NOSUCHPATH;
1271             else
1272                 return CM_ERROR_NOSUCHFILE;
1273         }
1274         return code;
1275     }
1276
1277     getroot = (dscp==cm_data.rootSCachep) ;
1278     if (!rock.found) {
1279         if (!cm_freelanceEnabled || !getroot) {
1280             if (flags & CM_FLAG_CHECKPATH)
1281                 return CM_ERROR_NOSUCHPATH;
1282             else
1283                 return CM_ERROR_NOSUCHFILE;
1284         }
1285         else {  /* nonexistent dir on freelance root, so add it */
1286             char fullname[200] = ".";
1287             int  found = 0;
1288
1289             osi_Log1(afsd_logp,"cm_Lookup adding mount for non-existent directory: %s", 
1290                       osi_LogSaveString(afsd_logp,namep));
1291             if (namep[0] == '.') {
1292                 if (cm_GetCell_Gen(&namep[1], &fullname[1], CM_FLAG_CREATE)) {
1293                     found = 1;
1294                     if ( stricmp(&namep[1], &fullname[1]) )
1295                         code = cm_FreelanceAddSymlink(namep, fullname, &rock.fid);
1296                     else
1297                         code = cm_FreelanceAddMount(namep, &fullname[1], "root.cell.", 1, &rock.fid);
1298                 }
1299             } else {
1300                 if (cm_GetCell_Gen(namep, fullname, CM_FLAG_CREATE)) {
1301                     found = 1;
1302                     if ( stricmp(namep, fullname) )
1303                         code = cm_FreelanceAddSymlink(namep, fullname, &rock.fid);
1304                     else
1305                         code = cm_FreelanceAddMount(namep, fullname, "root.cell.", 0, &rock.fid);
1306                 }
1307             }
1308             if (!found || code < 0) {   /* add mount point failed, so give up */
1309                 if (flags & CM_FLAG_CHECKPATH)
1310                     return CM_ERROR_NOSUCHPATH;
1311                 else
1312                     return CM_ERROR_NOSUCHFILE;
1313             }
1314             tscp = NULL;   /* to force call of cm_GetSCache */
1315         }
1316     }
1317
1318   haveFid:       
1319     if ( !tscp )    /* we did not find it in the dnlc */
1320     {
1321         dnlcHit = 0;    
1322         code = cm_GetSCache(&rock.fid, &tscp, userp, reqp);
1323         if (code) 
1324             return code;
1325     }       
1326     /* tscp is now held */
1327
1328     lock_ObtainMutex(&tscp->mx);
1329     code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1330                       CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
1331     if (code) { 
1332         lock_ReleaseMutex(&tscp->mx);
1333         cm_ReleaseSCache(tscp);
1334         return code;
1335     }
1336     cm_SyncOpDone(tscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
1337     /* tscp is now locked */
1338
1339     if (!(flags & CM_FLAG_NOMOUNTCHASE)
1340          && tscp->fileType == CM_SCACHETYPE_MOUNTPOINT) {
1341         /* mount points are funny: they have a volume name to mount
1342          * the root of.
1343          */
1344         code = cm_ReadMountPoint(tscp, userp, reqp);
1345         if (code == 0)
1346             code = cm_FollowMountPoint(tscp, dscp, userp, reqp,
1347                                         &mountedScp);
1348         lock_ReleaseMutex(&tscp->mx);
1349         cm_ReleaseSCache(tscp);
1350         if (code) {
1351             return code;
1352         }
1353         tscp = mountedScp;
1354     }
1355     else {
1356         lock_ReleaseMutex(&tscp->mx);
1357     }
1358
1359     /* copy back pointer */
1360     *outpScpp = tscp;
1361
1362     /* insert scache in dnlc */
1363     if ( !dnlcHit && !(flags & CM_FLAG_NOMOUNTCHASE) && rock.ExactFound ) {
1364         /* lock the directory entry to prevent racing callback revokes */
1365         lock_ObtainMutex(&dscp->mx);
1366         if ( dscp->cbServerp != NULL && dscp->cbExpires > 0 )
1367             cm_dnlcEnter(dscp, namep, tscp);
1368         lock_ReleaseMutex(&dscp->mx);
1369     }
1370
1371     /* and return */
1372     return 0;
1373 }
1374
1375 int cm_ExpandSysName(char *inp, char *outp, long outSize, unsigned int index)
1376 {
1377     char *tp;
1378     int prefixCount;
1379
1380     tp = strrchr(inp, '@');
1381     if (tp == NULL) 
1382         return 0;               /* no @sys */
1383
1384     if (strcmp(tp, "@sys") != 0) 
1385         return 0;       /* no @sys */
1386
1387     /* caller just wants to know if this is a valid @sys type of name */
1388     if (outp == NULL) 
1389         return 1;
1390
1391     if (index >= MAXNUMSYSNAMES)
1392         return -1;
1393
1394     /* otherwise generate the properly expanded @sys name */
1395     prefixCount = (int)(tp - inp);
1396
1397     strncpy(outp, inp, prefixCount);    /* copy out "a." from "a.@sys" */
1398     outp[prefixCount] = 0;              /* null terminate the "a." */
1399     strcat(outp, cm_sysNameList[index]);/* append i386_nt40 */
1400     return 1;
1401 }   
1402
1403 long cm_EvaluateVolumeReference(char * namep, long flags, cm_user_t * userp,
1404                                 cm_req_t *reqp, cm_scache_t ** outpScpp)
1405 {
1406     long          code = 0;
1407     char          cellName[CELL_MAXNAMELEN];
1408     char          volumeName[VL_MAXNAMELEN];
1409     size_t        len;
1410     char *        cp;
1411     char *        tp;
1412
1413     cm_cell_t *   cellp = NULL;
1414     cm_volume_t * volp = NULL;
1415     cm_fid_t      fid;
1416     int           volType;
1417     int           mountType = RWVOL;
1418
1419     osi_Log1(afsd_logp, "cm_EvaluateVolumeReference for string [%s]",
1420              osi_LogSaveString(afsd_logp, namep));
1421
1422     if (strnicmp(namep, CM_PREFIX_VOL, CM_PREFIX_VOL_CCH) != 0) {
1423         goto _exit_invalid_path;
1424     }
1425
1426     /* namep is assumed to look like the following:
1427
1428        @vol:<cellname>%<volume>\0
1429        or
1430        @vol:<cellname>#<volume>\0
1431
1432      */
1433
1434     cp = namep + CM_PREFIX_VOL_CCH; /* cp points to cell name, hopefully */
1435     tp = strchr(cp, '%');
1436     if (tp == NULL)
1437         tp = strchr(cp, '#');
1438     if (tp == NULL ||
1439         (len = tp - cp) == 0 ||
1440         len > CELL_MAXNAMELEN)
1441         goto _exit_invalid_path;
1442     strncpy(cellName, cp, len);
1443     cellName[len] = '\0';
1444
1445     if (*tp == '#')
1446         mountType = ROVOL;
1447
1448     cp = tp+1;                  /* cp now points to volume, supposedly */
1449     strncpy(volumeName, cp, VL_MAXNAMELEN-1);
1450     volumeName[VL_MAXNAMELEN - 1] = 0;
1451
1452     /* OK, now we have the cell and the volume */
1453     osi_Log2(afsd_logp, "   Found cell [%s] and volume [%s]",
1454              osi_LogSaveString(afsd_logp, cellName),
1455              osi_LogSaveString(afsd_logp, volumeName));
1456
1457     cellp = cm_GetCell(cellName, CM_FLAG_CREATE);
1458     if (cellp == NULL) {
1459         goto _exit_invalid_path;
1460     }
1461
1462     len = strlen(volumeName);
1463     if (len >= 8 && strcmp(volumeName + len - 7, ".backup") == 0)
1464         volType = BACKVOL;
1465     else if (len >= 10 &&
1466              strcmp(volumeName + len - 9, ".readonly") == 0)
1467         volType = ROVOL;
1468     else
1469         volType = RWVOL;
1470
1471     if (cm_VolNameIsID(volumeName)) {
1472         code = cm_GetVolumeByID(cellp, atoi(volumeName), userp, reqp,
1473                                 CM_GETVOL_FLAG_CREATE, &volp);
1474     } else {
1475         code = cm_GetVolumeByName(cellp, volumeName, userp, reqp,
1476                                   CM_GETVOL_FLAG_CREATE, &volp);
1477     }
1478
1479     if (code != 0)
1480         goto _exit_cleanup;
1481
1482     fid.cell = cellp->cellID;
1483
1484     if (volType == BACKVOL)
1485         fid.volume = volp->bk.ID;
1486     else if (volType == ROVOL ||
1487              (volType == RWVOL && mountType == ROVOL && volp->ro.ID != 0))
1488         fid.volume = volp->ro.ID;
1489     else
1490         fid.volume = volp->rw.ID;
1491
1492     fid.vnode = 1;
1493     fid.unique = 1;
1494
1495     code = cm_GetSCache(&fid, outpScpp, userp, reqp);
1496
1497  _exit_cleanup:
1498     if (volp)
1499         cm_PutVolume(volp);
1500
1501     if (code == 0)
1502         return code;
1503
1504  _exit_invalid_path:
1505     if (flags & CM_FLAG_CHECKPATH)
1506         return CM_ERROR_NOSUCHPATH;
1507     else
1508         return CM_ERROR_NOSUCHFILE;
1509 }
1510
1511 #ifdef DEBUG_REFCOUNT
1512 long cm_LookupDbg(cm_scache_t *dscp, char *namep, long flags, cm_user_t *userp,
1513                cm_req_t *reqp, cm_scache_t **outpScpp, char * file, long line)
1514 #else
1515 long cm_Lookup(cm_scache_t *dscp, char *namep, long flags, cm_user_t *userp,
1516                cm_req_t *reqp, cm_scache_t **outpScpp)
1517 #endif
1518 {
1519     long code;
1520     char tname[AFSPATHMAX];
1521     int sysNameIndex = 0;
1522     cm_scache_t *scp = NULL;
1523
1524 #ifdef DEBUG_REFCOUNT
1525     afsi_log("%s:%d cm_Lookup dscp 0x%p ref %d", file, line, dscp, dscp->refCount, file, line);
1526     osi_Log2(afsd_logp, "cm_Lookup dscp 0x%p ref %d", dscp, dscp->refCount);
1527 #endif
1528
1529     if ( stricmp(namep,SMB_IOCTL_FILENAME_NOSLASH) == 0 ) {
1530         if (flags & CM_FLAG_CHECKPATH)
1531             return CM_ERROR_NOSUCHPATH;
1532         else
1533             return CM_ERROR_NOSUCHFILE;
1534     }
1535
1536     if (dscp == cm_data.rootSCachep &&
1537         strnicmp(namep, CM_PREFIX_VOL, CM_PREFIX_VOL_CCH) == 0) {
1538         return cm_EvaluateVolumeReference(namep, flags, userp, reqp, outpScpp);
1539     }
1540
1541     if (cm_ExpandSysName(namep, NULL, 0, 0) > 0) {
1542         for ( sysNameIndex = 0; sysNameIndex < MAXNUMSYSNAMES; sysNameIndex++) {
1543             code = cm_ExpandSysName(namep, tname, sizeof(tname), sysNameIndex);
1544             if (code > 0) {
1545                 code = cm_LookupInternal(dscp, tname, flags, userp, reqp, &scp);
1546 #ifdef DEBUG_REFCOUNT
1547                 afsi_log("%s:%d cm_LookupInternal (1) code 0x%x dscp 0x%p ref %d scp 0x%p ref %d", file, line, code, dscp, dscp->refCount, scp, scp ? scp->refCount : 0);
1548                 osi_Log3(afsd_logp, "cm_LookupInternal (1) code 0x%x dscp 0x%p scp 0x%p", code, dscp, scp);
1549 #endif
1550
1551                 if (code == 0) {
1552                     *outpScpp = scp;
1553                     return 0;
1554                 }
1555                 if (scp) {
1556                     cm_ReleaseSCache(scp);
1557                     scp = NULL;
1558                 }
1559             } else {
1560                 code = cm_LookupInternal(dscp, namep, flags, userp, reqp, &scp);
1561 #ifdef DEBUG_REFCOUNT
1562                 afsi_log("%s:%d cm_LookupInternal (2) code 0x%x dscp 0x%p ref %d scp 0x%p ref %d", file, line, code, dscp, dscp->refCount, scp, scp ? scp->refCount : 0);
1563                 osi_Log3(afsd_logp, "cm_LookupInternal (2) code 0x%x dscp 0x%p scp 0x%p", code, dscp, scp);
1564 #endif
1565                 *outpScpp = scp;
1566                 return code;
1567             }
1568         }
1569     } else {
1570         code = cm_LookupInternal(dscp, namep, flags, userp, reqp, &scp);
1571 #ifdef DEBUG_REFCOUNT
1572         afsi_log("%s:%d cm_LookupInternal (2) code 0x%x dscp 0x%p ref %d scp 0x%p ref %d", file, line, code, dscp, dscp->refCount, scp, scp ? scp->refCount : 0);
1573         osi_Log3(afsd_logp, "cm_LookupInternal (2) code 0x%x dscp 0x%p scp 0x%p", code, dscp, scp);
1574 #endif
1575         *outpScpp = scp;
1576         return code;
1577     }
1578
1579     /* None of the possible sysName expansions could be found */
1580     if (flags & CM_FLAG_CHECKPATH)
1581         return CM_ERROR_NOSUCHPATH;
1582     else
1583         return CM_ERROR_NOSUCHFILE;
1584 }
1585
1586 long cm_Unlink(cm_scache_t *dscp, char *namep, cm_user_t *userp, cm_req_t *reqp)
1587 {
1588     long code;
1589     cm_conn_t *connp;
1590     AFSFid afsFid;
1591     int sflags;
1592     AFSFetchStatus newDirStatus;
1593     AFSVolSync volSync;
1594     struct rx_connection * callp;
1595     cm_dirOp_t dirop;
1596
1597 #ifdef AFS_FREELANCE_CLIENT
1598     if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
1599         /* deleting a mount point from the root dir. */
1600         code = cm_FreelanceRemoveMount(namep);
1601         return code;
1602     }
1603 #endif  
1604
1605     /* make sure we don't screw up the dir status during the merge */
1606     code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
1607
1608     lock_ObtainMutex(&dscp->mx);
1609     sflags = CM_SCACHESYNC_STOREDATA;
1610     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, sflags);
1611     lock_ReleaseMutex(&dscp->mx);
1612     if (code) {
1613         cm_EndDirOp(&dirop);
1614         return code;
1615     }
1616
1617     /* make the RPC */
1618     afsFid.Volume = dscp->fid.volume;
1619     afsFid.Vnode = dscp->fid.vnode;
1620     afsFid.Unique = dscp->fid.unique;
1621
1622     osi_Log1(afsd_logp, "CALL RemoveFile scp 0x%p", dscp);
1623     do {
1624         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
1625         if (code) 
1626             continue;
1627
1628         callp = cm_GetRxConn(connp);
1629         code = RXAFS_RemoveFile(callp, &afsFid, namep,
1630                                  &newDirStatus, &volSync);
1631         rx_PutConnection(callp);
1632
1633     } while (cm_Analyze(connp, userp, reqp, &dscp->fid, &volSync, NULL, NULL, code));
1634     code = cm_MapRPCError(code, reqp);
1635
1636     if (code)
1637         osi_Log1(afsd_logp, "CALL RemoveFile FAILURE, code 0x%x", code);
1638     else
1639         osi_Log0(afsd_logp, "CALL RemoveFile SUCCESS");
1640
1641     if (dirop.scp) {
1642         lock_ObtainWrite(&dirop.scp->dirlock);
1643         dirop.lockType = CM_DIRLOCK_WRITE;
1644     }
1645     lock_ObtainMutex(&dscp->mx);
1646     cm_dnlcRemove(dscp, namep);
1647     cm_SyncOpDone(dscp, NULL, sflags);
1648     if (code == 0) {
1649         cm_MergeStatus(NULL, dscp, &newDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
1650     } else if (code == CM_ERROR_NOSUCHFILE) {
1651         /* windows would not have allowed the request to delete the file 
1652          * if it did not believe the file existed.  therefore, we must 
1653          * have an inconsistent view of the world.
1654          */
1655         dscp->cbServerp = NULL;
1656     }
1657     lock_ReleaseMutex(&dscp->mx);
1658
1659     if (code == 0 && cm_CheckDirOpForSingleChange(&dirop)) {
1660         cm_DirDeleteEntry(&dirop, namep);
1661 #ifdef USE_BPLUS
1662         cm_BPlusDirDeleteEntry(&dirop, namep);
1663 #endif
1664     }
1665     cm_EndDirOp(&dirop);
1666
1667     return code;
1668 }
1669
1670 /* called with a locked vnode, and fills in the link info.
1671  * returns this the vnode still locked.
1672  */
1673 long cm_HandleLink(cm_scache_t *linkScp, cm_user_t *userp, cm_req_t *reqp)
1674 {
1675     long code;
1676     cm_buf_t *bufp;
1677     long temp;
1678     osi_hyper_t thyper;
1679
1680     lock_AssertMutex(&linkScp->mx);
1681     if (!linkScp->mountPointStringp[0]) {
1682         /* read the link data */
1683         lock_ReleaseMutex(&linkScp->mx);
1684         thyper.LowPart = thyper.HighPart = 0;
1685         code = buf_Get(linkScp, &thyper, &bufp);
1686         lock_ObtainMutex(&linkScp->mx);
1687         if (code) 
1688             return code;
1689         while (1) {
1690             code = cm_SyncOp(linkScp, bufp, userp, reqp, 0,
1691                               CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
1692             if (code) {
1693                 buf_Release(bufp);
1694                 return code;
1695             }
1696             cm_SyncOpDone(linkScp, bufp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
1697
1698             if (cm_HaveBuffer(linkScp, bufp, 0)) 
1699                 break;
1700
1701             code = cm_GetBuffer(linkScp, bufp, NULL, userp, reqp);
1702             if (code) {
1703                 buf_Release(bufp);
1704                 return code;
1705             }
1706         } /* while loop to get the data */
1707                 
1708         /* now if we still have no link read in,
1709          * copy the data from the buffer */
1710         if ((temp = linkScp->length.LowPart) >= MOUNTPOINTLEN) {
1711             buf_Release(bufp);
1712             return CM_ERROR_TOOBIG;
1713         }
1714
1715         /* otherwise, it fits; make sure it is still null (could have
1716          * lost race with someone else referencing this link above),
1717          * and if so, copy in the data.
1718          */
1719         if (!linkScp->mountPointStringp[0]) {
1720             strncpy(linkScp->mountPointStringp, bufp->datap, temp);
1721             linkScp->mountPointStringp[temp] = 0;       /* null terminate */
1722
1723             if ( !strnicmp(linkScp->mountPointStringp, "msdfs:", strlen("msdfs:")) )
1724                  linkScp->fileType = CM_SCACHETYPE_DFSLINK;
1725         }
1726         buf_Release(bufp);
1727     }   /* don't have sym link contents cached */
1728
1729     return 0;
1730 }       
1731
1732 /* called with a held vnode and a path suffix, with the held vnode being a
1733  * symbolic link.  Our goal is to generate a new path to interpret, and return
1734  * this new path in newSpaceBufferp.  If the new vnode is relative to a dir
1735  * other than the directory containing the symbolic link, then the new root is
1736  * returned in *newRootScpp, otherwise a null is returned there.
1737  */
1738 long cm_AssembleLink(cm_scache_t *linkScp, char *pathSuffixp,
1739                       cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
1740                       cm_user_t *userp, cm_req_t *reqp)
1741 {
1742     long code = 0;
1743     long len;
1744     char *linkp;
1745     cm_space_t *tsp;
1746
1747     *newRootScpp = NULL;
1748     *newSpaceBufferp = NULL;
1749
1750     lock_ObtainMutex(&linkScp->mx);
1751     code = cm_HandleLink(linkScp, userp, reqp);
1752     if (code)
1753         goto done;
1754
1755     /* if we may overflow the buffer, bail out; buffer is signficantly
1756      * bigger than max path length, so we don't really have to worry about
1757      * being a little conservative here.
1758      */
1759     if (strlen(linkScp->mountPointStringp) + strlen(pathSuffixp) + 2
1760          >= CM_UTILS_SPACESIZE)
1761         return CM_ERROR_TOOBIG;
1762
1763     tsp = cm_GetSpace();
1764     linkp = linkScp->mountPointStringp;
1765     if (strncmp(linkp, cm_mountRoot, cm_mountRootLen) == 0) {
1766         if (strlen(linkp) > cm_mountRootLen)
1767             strcpy(tsp->data, linkp+cm_mountRootLen+1);
1768         else
1769             tsp->data[0] = 0;
1770         *newRootScpp = cm_data.rootSCachep;
1771         cm_HoldSCache(cm_data.rootSCachep);
1772     } else if (linkp[0] == '\\' && linkp[1] == '\\') {
1773         if (!strnicmp(&linkp[2], cm_NetbiosName, (len = (long)strlen(cm_NetbiosName)))) 
1774         {
1775             char * p = &linkp[len + 3];
1776             if (strnicmp(p, "all", 3) == 0)
1777                 p += 4;
1778
1779             strcpy(tsp->data, p);
1780             for (p = tsp->data; *p; p++) {
1781                 if (*p == '\\')
1782                     *p = '/';
1783             }
1784             *newRootScpp = cm_data.rootSCachep;
1785             cm_HoldSCache(cm_data.rootSCachep);
1786         } else {
1787             linkScp->fileType = CM_SCACHETYPE_DFSLINK;
1788             strcpy(tsp->data, linkp);
1789             code = CM_ERROR_PATH_NOT_COVERED;
1790         }
1791     } else if ( linkScp->fileType == CM_SCACHETYPE_DFSLINK ||
1792                 !strnicmp(linkp, "msdfs:", (len = (long)strlen("msdfs:"))) ) {
1793         linkScp->fileType = CM_SCACHETYPE_DFSLINK;
1794         strcpy(tsp->data, linkp);
1795         code = CM_ERROR_PATH_NOT_COVERED;
1796     } else if (*linkp == '\\' || *linkp == '/') {
1797 #if 0   
1798         /* formerly, this was considered to be from the AFS root,
1799          * but this seems to create problems.  instead, we will just
1800          * reject the link */
1801         strcpy(tsp->data, linkp+1);
1802         *newRootScpp = cm_data.rootSCachep;
1803         cm_HoldSCache(cm_data.rootSCachep);
1804 #else
1805         /* we still copy the link data into the response so that 
1806          * the user can see what the link points to
1807          */
1808         linkScp->fileType = CM_SCACHETYPE_INVALID;
1809         strcpy(tsp->data, linkp);
1810         code = CM_ERROR_NOSUCHPATH;
1811 #endif  
1812     } else {
1813         /* a relative link */
1814         strcpy(tsp->data, linkp);
1815     }
1816     if (pathSuffixp[0] != 0) {  /* if suffix string is non-null */
1817         strcat(tsp->data, "\\");
1818         strcat(tsp->data, pathSuffixp);
1819     }
1820     if (code == 0)
1821         *newSpaceBufferp = tsp;
1822     else {
1823         cm_FreeSpace(tsp);
1824
1825         if (code == CM_ERROR_PATH_NOT_COVERED && reqp->tidPathp && reqp->relPathp)
1826             cm_VolStatus_Notify_DFS_Mapping(linkScp, reqp->tidPathp, reqp->relPathp);
1827     }
1828
1829   done:
1830     lock_ReleaseMutex(&linkScp->mx);
1831     return code;
1832 }
1833 #ifdef DEBUG_REFCOUNT
1834 long cm_NameIDbg(cm_scache_t *rootSCachep, char *pathp, long flags,
1835                cm_user_t *userp, char *tidPathp, cm_req_t *reqp, cm_scache_t **outScpp, 
1836                char * file, long line)
1837 #else
1838 long cm_NameI(cm_scache_t *rootSCachep, char *pathp, long flags,
1839                cm_user_t *userp, char *tidPathp, cm_req_t *reqp, cm_scache_t **outScpp)
1840 #endif
1841 {
1842     long code;
1843     char *tp;                   /* ptr moving through input buffer */
1844     char tc;                    /* temp char */
1845     int haveComponent;          /* has new component started? */
1846     char component[AFSPATHMAX]; /* this is the new component */
1847     char *cp;                   /* component name being assembled */
1848     cm_scache_t *tscp;          /* current location in the hierarchy */
1849     cm_scache_t *nscp;          /* next dude down */
1850     cm_scache_t *dirScp;        /* last dir we searched */
1851     cm_scache_t *linkScp;       /* new root for the symlink we just
1852     * looked up */
1853     cm_space_t *psp;            /* space for current path, if we've hit
1854     * any symlinks */
1855     cm_space_t *tempsp;         /* temp vbl */
1856     char *restp;                /* rest of the pathname to interpret */
1857     int symlinkCount;           /* count of # of symlinks traversed */
1858     int extraFlag;              /* avoid chasing mt pts for dir cmd */
1859     int phase = 1;              /* 1 = tidPathp, 2 = pathp */
1860 #define MAX_FID_COUNT 512
1861     cm_fid_t fids[MAX_FID_COUNT]; /* array of fids processed in this path walk */
1862     int fid_count = 0;          /* number of fids processed in this path walk */
1863     int i;
1864
1865 #ifdef DEBUG_REFCOUNT
1866     afsi_log("%s:%d cm_NameI rootscp 0x%p ref %d", file, line, rootSCachep, rootSCachep->refCount);
1867     osi_Log4(afsd_logp,"cm_NameI rootscp 0x%p path %s tidpath %s flags 0x%x",
1868               rootSCachep, pathp ? pathp : "<NULL>", tidPathp ? tidPathp : "<NULL>", 
1869               flags);
1870 #endif
1871
1872     tp = tidPathp;
1873     if (tp == NULL) {
1874         tp = pathp;
1875         phase = 2;
1876     }
1877     if (tp == NULL) {
1878         tp = "";
1879     }
1880     haveComponent = 0;
1881     psp = NULL;
1882     tscp = rootSCachep;
1883     cm_HoldSCache(tscp);
1884     symlinkCount = 0;
1885     dirScp = NULL;
1886
1887
1888     while (1) {
1889         tc = *tp++;
1890
1891         /* map Unix slashes into DOS ones so we can interpret Unix
1892          * symlinks properly
1893          */
1894         if (tc == '/') 
1895             tc = '\\';
1896
1897         if (!haveComponent) {
1898             if (tc == '\\') {
1899                 continue;
1900             } else if (tc == 0) {
1901                 if (phase == 1) {
1902                     phase = 2;
1903                     tp = pathp;
1904                     continue;
1905                 }
1906                 code = 0;
1907                 break;
1908             } else {
1909                 haveComponent = 1;
1910                 cp = component;
1911                 *cp++ = tc;
1912             }
1913         } else {
1914             /* we have a component here */
1915             if (tc == 0 || tc == '\\') {
1916                 /* end of the component; we're at the last
1917                  * component if tc == 0.  However, if the last
1918                  * is a symlink, we have more to do.
1919                  */
1920                 *cp++ = 0;      /* add null termination */
1921                 extraFlag = 0;
1922                 if ((flags & CM_FLAG_DIRSEARCH) && tc == 0)
1923                     extraFlag = CM_FLAG_NOMOUNTCHASE;
1924                 code = cm_Lookup(tscp, component,
1925                                   flags | extraFlag,
1926                                   userp, reqp, &nscp);
1927
1928                 if (code == 0) {
1929                     if (!strcmp(component,"..") || !strcmp(component,".")) {
1930                         /* 
1931                          * roll back the fid list until we find the fid 
1932                          * that matches where we are now.  Its not necessarily
1933                          * one or two fids because they might have been 
1934                          * symlinks or mount points or both that were crossed.  
1935                          */
1936                         for ( i=fid_count-1; i>=0; i--) {
1937                             if (!cm_FidCmp(&nscp->fid, &fids[i]))
1938                                 break;
1939                         }
1940                     } else {
1941                         /* add the new fid to the list */
1942                         for ( i=0; i<fid_count; i++) {
1943                             if ( !cm_FidCmp(&nscp->fid, &fids[i]) ) {
1944                                 code = CM_ERROR_TOO_MANY_SYMLINKS;
1945                                 cm_ReleaseSCache(nscp);
1946                                 nscp = NULL;
1947                                 break;
1948                             }
1949                         }
1950                         if (i == fid_count && fid_count < MAX_FID_COUNT) {
1951                             fids[fid_count++] = nscp->fid;
1952                         }
1953                     }
1954                 }
1955
1956                 if (code) {
1957                     cm_ReleaseSCache(tscp);
1958                     if (dirScp)
1959                         cm_ReleaseSCache(dirScp);
1960                     if (psp) 
1961                         cm_FreeSpace(psp);
1962                     if ((code == CM_ERROR_NOSUCHFILE || code == CM_ERROR_BPLUS_NOMATCH) && 
1963                          tscp->fileType == CM_SCACHETYPE_SYMLINK) 
1964                     {
1965                         osi_Log0(afsd_logp,"cm_NameI code CM_ERROR_NOSUCHPATH");
1966                         return CM_ERROR_NOSUCHPATH;
1967                     } else {
1968                         osi_Log1(afsd_logp,"cm_NameI code 0x%x", code);
1969                         return code;
1970                     }
1971                 }
1972
1973                 haveComponent = 0;      /* component done */
1974                 if (dirScp)
1975                     cm_ReleaseSCache(dirScp);
1976                 dirScp = tscp;          /* for some symlinks */
1977                 tscp = nscp;            /* already held */
1978                 nscp = NULL;
1979                 if (tc == 0 && !(flags & CM_FLAG_FOLLOW) && phase == 2) {
1980                     code = 0;
1981                     if (dirScp) {
1982                         cm_ReleaseSCache(dirScp);
1983                         dirScp = NULL;
1984                     }
1985                     break;
1986                 }
1987
1988                 /* now, if tscp is a symlink, we should follow
1989                  * it and assemble the path again.
1990                  */
1991                 lock_ObtainMutex(&tscp->mx);
1992                 code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
1993                                   CM_SCACHESYNC_GETSTATUS
1994                                   | CM_SCACHESYNC_NEEDCALLBACK);
1995                 if (code) {
1996                     lock_ReleaseMutex(&tscp->mx);
1997                     cm_ReleaseSCache(tscp);
1998                     tscp = NULL;
1999                     if (dirScp) {
2000                         cm_ReleaseSCache(dirScp);
2001                         dirScp = NULL;
2002                     }
2003                     break;
2004                 }
2005                 cm_SyncOpDone(tscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2006
2007                 if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
2008                     /* this is a symlink; assemble a new buffer */
2009                     lock_ReleaseMutex(&tscp->mx);
2010                     if (symlinkCount++ >= MAX_SYMLINK_COUNT) {
2011                         cm_ReleaseSCache(tscp);
2012                         tscp = NULL;
2013                         if (dirScp) {
2014                             cm_ReleaseSCache(dirScp);
2015                             dirScp = NULL;
2016                         }
2017                         if (psp) 
2018                             cm_FreeSpace(psp);
2019                         osi_Log0(afsd_logp,"cm_NameI code CM_ERROR_TOO_MANY_SYMLINKS");
2020                         return CM_ERROR_TOO_MANY_SYMLINKS;
2021                     }
2022                     if (tc == 0) 
2023                         restp = "";
2024                     else 
2025                         restp = tp;
2026                     code = cm_AssembleLink(tscp, restp, &linkScp, &tempsp, userp, reqp);
2027
2028                     if (code == 0 && linkScp != NULL) {
2029                         if (linkScp == cm_data.rootSCachep) 
2030                             fid_count = 0;
2031                         else {
2032                             for ( i=0; i<fid_count; i++) {
2033                                 if ( !cm_FidCmp(&linkScp->fid, &fids[i]) ) {
2034                                     code = CM_ERROR_TOO_MANY_SYMLINKS;
2035                                     cm_ReleaseSCache(linkScp);
2036                                     nscp = NULL;
2037                                     break;
2038                                 }
2039                             }
2040                         }
2041                         if (i == fid_count && fid_count < MAX_FID_COUNT) {
2042                             fids[fid_count++] = linkScp->fid;
2043                         }
2044                     }
2045
2046                     if (code) {
2047                         /* something went wrong */
2048                         cm_ReleaseSCache(tscp);
2049                         tscp = NULL;
2050                         if (dirScp) {
2051                             cm_ReleaseSCache(dirScp);
2052                             dirScp = NULL;
2053                         }
2054                         break;
2055                     }
2056
2057                     /* otherwise, tempsp has the new path,
2058                      * and linkScp is the new root from
2059                      * which to interpret that path.
2060                      * Continue with the namei processing,
2061                      * also doing the bookkeeping for the
2062                      * space allocation and tracking the
2063                      * vnode reference counts.
2064                      */
2065                     if (psp) 
2066                         cm_FreeSpace(psp);
2067                     psp = tempsp;
2068                     tp = psp->data;
2069                     cm_ReleaseSCache(tscp);
2070                     tscp = linkScp;
2071                     linkScp = NULL;
2072                     /* already held
2073                      * by AssembleLink
2074                      * now, if linkScp is null, that's
2075                      * AssembleLink's way of telling us that
2076                      * the sym link is relative to the dir
2077                      * containing the link.  We have a ref
2078                      * to it in dirScp, and we hold it now
2079                      * and reuse it as the new spot in the
2080                      * dir hierarchy.
2081                      */
2082                     if (tscp == NULL) {
2083                         tscp = dirScp;
2084                         dirScp = NULL;
2085                     }
2086                 } else {
2087                     /* not a symlink, we may be done */
2088                     lock_ReleaseMutex(&tscp->mx);
2089                     if (tc == 0) {
2090                         if (phase == 1) {
2091                             phase = 2;
2092                             tp = pathp;
2093                             continue;
2094                         }
2095                         if (dirScp) {
2096                             cm_ReleaseSCache(dirScp);
2097                             dirScp = NULL;
2098                         }
2099                         code = 0;
2100                         break;
2101                     }
2102                 }
2103                 if (dirScp) {
2104                     cm_ReleaseSCache(dirScp);
2105                     dirScp = NULL;
2106                 }
2107             } /* end of a component */
2108             else 
2109                 *cp++ = tc;
2110         } /* we have a component */
2111     } /* big while loop over all components */
2112
2113     /* already held */
2114     if (dirScp)
2115         cm_ReleaseSCache(dirScp);
2116     if (psp) 
2117         cm_FreeSpace(psp);
2118     if (code == 0) 
2119         *outScpp = tscp;
2120     else if (tscp)
2121         cm_ReleaseSCache(tscp);
2122
2123 #ifdef DEBUG_REFCOUNT
2124     afsi_log("%s:%d cm_NameI code 0x%x outScpp 0x%p ref %d", file, line, code, *outScpp, (*outScpp)->refCount);
2125 #endif
2126     osi_Log2(afsd_logp,"cm_NameI code 0x%x outScpp 0x%p", code, *outScpp);
2127     return code;
2128 }
2129
2130 /* called with a dir, and a vnode within the dir that happens to be a symlink.
2131  * We chase the link, and return a held pointer to the target, if it exists,
2132  * in *outScpp.  If we succeed, we return 0, otherwise we return an error code
2133  * and do not hold or return a target vnode.
2134  *
2135  * This is very similar to calling cm_NameI with the last component of a name,
2136  * which happens to be a symlink, except that we've already passed by the name.
2137  *
2138  * This function is typically called by the directory listing functions, which
2139  * encounter symlinks but need to return the proper file length so programs
2140  * like "more" work properly when they make use of the attributes retrieved from
2141  * the dir listing.
2142  *
2143  * The input vnode should not be locked when this function is called.
2144  */
2145 long cm_EvaluateSymLink(cm_scache_t *dscp, cm_scache_t *linkScp,
2146                          cm_scache_t **outScpp, cm_user_t *userp, cm_req_t *reqp)
2147 {
2148     long code;
2149     cm_space_t *spacep;
2150     cm_scache_t *newRootScp;
2151
2152     osi_Log1(afsd_logp, "Evaluating symlink scp 0x%p", linkScp);
2153
2154     code = cm_AssembleLink(linkScp, "", &newRootScp, &spacep, userp, reqp);
2155     if (code) 
2156         return code;
2157
2158     /* now, if newRootScp is NULL, we're really being told that the symlink
2159      * is relative to the current directory (dscp).
2160      */
2161     if (newRootScp == NULL) {
2162         newRootScp = dscp;
2163         cm_HoldSCache(dscp);
2164     }
2165
2166     code = cm_NameI(newRootScp, spacep->data,
2167                      CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW | CM_FLAG_DIRSEARCH,
2168                      userp, NULL, reqp, outScpp);
2169
2170     if (code == CM_ERROR_NOSUCHFILE || code == CM_ERROR_BPLUS_NOMATCH)
2171         code = CM_ERROR_NOSUCHPATH;
2172
2173     /* this stuff is allocated no matter what happened on the namei call,
2174      * so free it */
2175     cm_FreeSpace(spacep);
2176     cm_ReleaseSCache(newRootScp);
2177
2178     if (linkScp == *outScpp) {
2179         cm_ReleaseSCache(*outScpp);
2180         *outScpp = NULL;
2181         code = CM_ERROR_NOSUCHPATH;
2182     }
2183
2184     return code;
2185 }
2186
2187 /* make this big enough so that one buffer of dir pages won't overflow.  We'll
2188  * check anyway, but we want to minimize the chance that we have to leave stuff
2189  * unstat'd.
2190  */
2191 #define CM_BULKMAX              (3 * AFSCBMAX)
2192
2193 /* rock for bulk stat calls */
2194 typedef struct cm_bulkStat {
2195     osi_hyper_t bufOffset;      /* only do it for things in this buffer page */
2196
2197     /* info for the actual call */
2198     int counter;                        /* next free slot */
2199     AFSFid fids[CM_BULKMAX];
2200     AFSFetchStatus stats[CM_BULKMAX];
2201     AFSCallBack callbacks[CM_BULKMAX];
2202 } cm_bulkStat_t;
2203
2204 /* for a given entry, make sure that it isn't in the stat cache, and then
2205  * add it to the list of file IDs to be obtained.
2206  *
2207  * Don't bother adding it if we already have a vnode.  Note that the dir
2208  * is locked, so we have to be careful checking the vnode we're thinking of
2209  * processing, to avoid deadlocks.
2210  */
2211 long cm_TryBulkProc(cm_scache_t *scp, cm_dirEntry_t *dep, void *rockp,
2212                      osi_hyper_t *offp)
2213 {
2214     osi_hyper_t thyper;
2215     cm_bulkStat_t *bsp;
2216     int i;
2217     cm_scache_t *tscp;
2218     cm_fid_t tfid;
2219
2220     bsp = rockp;
2221
2222     /* Don't overflow bsp. */
2223     if (bsp->counter >= CM_BULKMAX)
2224         return CM_ERROR_STOPNOW;
2225
2226     thyper.LowPart = cm_data.buf_blockSize;
2227     thyper.HighPart = 0;
2228     thyper = LargeIntegerAdd(thyper, bsp->bufOffset);
2229
2230     /* thyper is now the first byte past the end of the record we're
2231      * interested in, and bsp->bufOffset is the first byte of the record
2232      * we're interested in.
2233      * Skip data in the others.
2234      * Skip '.' and '..'
2235      */
2236     if (LargeIntegerLessThan(*offp, bsp->bufOffset))
2237         return 0;
2238     if (LargeIntegerGreaterThanOrEqualTo(*offp, thyper))
2239         return CM_ERROR_STOPNOW;
2240     if (strcmp(dep->name, ".") == 0 || strcmp(dep->name, "..") == 0)
2241         return 0;
2242
2243     tfid.cell = scp->fid.cell;
2244     tfid.volume = scp->fid.volume;
2245     tfid.vnode = ntohl(dep->fid.vnode);
2246     tfid.unique = ntohl(dep->fid.unique);
2247     tscp = cm_FindSCache(&tfid);
2248     if (tscp) {
2249         if (lock_TryMutex(&tscp->mx)) {
2250             /* we have an entry that we can look at */
2251             if (!(tscp->flags & CM_SCACHEFLAG_EACCESS) && cm_HaveCallback(tscp)) {
2252                 /* we have a callback on it.  Don't bother
2253                  * fetching this stat entry, since we're happy
2254                  * with the info we have.
2255                  */
2256                 lock_ReleaseMutex(&tscp->mx);
2257                 cm_ReleaseSCache(tscp);
2258                 return 0;
2259             }
2260             lock_ReleaseMutex(&tscp->mx);
2261         }       /* got lock */
2262         cm_ReleaseSCache(tscp);
2263     }   /* found entry */
2264
2265 #ifdef AFS_FREELANCE_CLIENT
2266     // yj: if this is a mountpoint under root.afs then we don't want it
2267     // to be bulkstat-ed, instead, we call getSCache directly and under
2268     // getSCache, it is handled specially.
2269     if  ( cm_freelanceEnabled &&
2270           tfid.cell==AFS_FAKE_ROOT_CELL_ID && 
2271           tfid.volume==AFS_FAKE_ROOT_VOL_ID &&
2272           !(tfid.vnode==0x1 && tfid.unique==0x1) )
2273     {       
2274         osi_Log0(afsd_logp, "cm_TryBulkProc Freelance calls cm_SCache on root.afs mountpoint");
2275         return cm_GetSCache(&tfid, &tscp, NULL, NULL);
2276     }
2277 #endif /* AFS_FREELANCE_CLIENT */
2278
2279     i = bsp->counter++;
2280     bsp->fids[i].Volume = scp->fid.volume;
2281     bsp->fids[i].Vnode = tfid.vnode;
2282     bsp->fids[i].Unique = tfid.unique;
2283     return 0;
2284 }       
2285
2286 /* called with a locked scp and a pointer to a buffer.  Make bulk stat
2287  * calls on all undeleted files in the page of the directory specified.
2288  */
2289 afs_int32
2290 cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
2291                cm_req_t *reqp)
2292 {
2293     long code;
2294     cm_bulkStat_t bb;   /* this is *BIG*, probably 16K or so;
2295                          * watch for stack problems */
2296     AFSCBFids fidStruct;
2297     AFSBulkStats statStruct;
2298     cm_conn_t *connp;
2299     AFSCBs callbackStruct;
2300     long filex;
2301     AFSVolSync volSync;
2302     cm_callbackRequest_t cbReq;
2303     long filesThisCall;
2304     long i;
2305     long j;
2306     cm_scache_t *scp;
2307     cm_fid_t tfid;
2308     struct rx_connection * callp;
2309     int inlinebulk = 0;         /* Did we use InlineBulkStatus RPC or not? */
2310
2311     osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%p", dscp);
2312
2313     /* should be on a buffer boundary */
2314     osi_assertx((offsetp->LowPart & (cm_data.buf_blockSize - 1)) == 0, "invalid offset");
2315
2316     memset(&bb, 0, sizeof(bb));
2317     bb.bufOffset = *offsetp;
2318
2319     lock_ReleaseMutex(&dscp->mx);
2320     /* first, assemble the file IDs we need to stat */
2321     code = cm_ApplyDir(dscp, cm_TryBulkProc, (void *) &bb, offsetp, userp, reqp, NULL);
2322
2323     /* if we failed, bail out early */
2324     if (code && code != CM_ERROR_STOPNOW) {
2325         lock_ObtainMutex(&dscp->mx);
2326         return code;
2327     }
2328
2329     /* otherwise, we may have one or more bulk stat's worth of stuff in bb;
2330      * make the calls to create the entries.  Handle AFSCBMAX files at a
2331      * time.
2332      */
2333     filex = 0;
2334     while (filex < bb.counter) {
2335         filesThisCall = bb.counter - filex;
2336         if (filesThisCall > AFSCBMAX) 
2337             filesThisCall = AFSCBMAX;
2338
2339         fidStruct.AFSCBFids_len = filesThisCall;
2340         fidStruct.AFSCBFids_val = &bb.fids[filex];
2341         statStruct.AFSBulkStats_len = filesThisCall;
2342         statStruct.AFSBulkStats_val = &bb.stats[filex];
2343         callbackStruct.AFSCBs_len = filesThisCall;
2344         callbackStruct.AFSCBs_val = &bb.callbacks[filex];
2345         cm_StartCallbackGrantingCall(NULL, &cbReq);
2346         osi_Log1(afsd_logp, "CALL BulkStatus, %d entries", filesThisCall);
2347         do {
2348             code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
2349             if (code) 
2350                 continue;
2351
2352             callp = cm_GetRxConn(connp);
2353             if (!(connp->serverp->flags & CM_SERVERFLAG_NOINLINEBULK)) {
2354                 code = RXAFS_InlineBulkStatus(callp, &fidStruct,
2355                                      &statStruct, &callbackStruct, &volSync);
2356                 if (code == RXGEN_OPCODE) {
2357                     cm_SetServerNoInlineBulk(connp->serverp, 0);
2358                 } else {
2359                     inlinebulk = 1;
2360                 }
2361             }
2362             if (!inlinebulk) {
2363                 code = RXAFS_BulkStatus(callp, &fidStruct,
2364                                         &statStruct, &callbackStruct, &volSync);
2365             }
2366             rx_PutConnection(callp);
2367
2368         } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
2369                              &volSync, NULL, &cbReq, code));
2370         code = cm_MapRPCError(code, reqp);
2371         if (code)
2372             osi_Log2(afsd_logp, "CALL %sBulkStatus FAILURE code 0x%x", 
2373                       inlinebulk ? "Inline" : "", code);
2374         else
2375             osi_Log1(afsd_logp, "CALL %sBulkStatus SUCCESS", inlinebulk ? "Inline" : "");
2376
2377         /* may as well quit on an error, since we're not going to do
2378          * much better on the next immediate call, either.
2379          */
2380         if (code) {
2381             cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, 0);
2382             break;
2383         }
2384
2385         /* otherwise, we should do the merges */
2386         for (i = 0; i<filesThisCall; i++) {
2387             j = filex + i;
2388             tfid.cell = dscp->fid.cell;
2389             tfid.volume = bb.fids[j].Volume;
2390             tfid.vnode = bb.fids[j].Vnode;
2391             tfid.unique = bb.fids[j].Unique;
2392             code = cm_GetSCache(&tfid, &scp, userp, reqp);
2393             if (code != 0) 
2394                 continue;
2395
2396             /* otherwise, if this entry has no callback info, 
2397              * merge in this.
2398              */
2399             lock_ObtainMutex(&scp->mx);
2400             /* now, we have to be extra paranoid on merging in this
2401              * information, since we didn't use cm_SyncOp before
2402              * starting the fetch to make sure that no bad races
2403              * were occurring.  Specifically, we need to make sure
2404              * we don't obliterate any newer information in the
2405              * vnode than have here.
2406              *
2407              * Right now, be pretty conservative: if there's a
2408              * callback or a pending call, skip it.
2409              */
2410             if ((scp->cbServerp == NULL || (scp->flags & CM_SCACHEFLAG_EACCESS))
2411                  && !(scp->flags &
2412                        (CM_SCACHEFLAG_FETCHING
2413                          | CM_SCACHEFLAG_STORING
2414                          | CM_SCACHEFLAG_SIZESTORING))) {
2415                 cm_EndCallbackGrantingCall(scp, &cbReq,
2416                                             &bb.callbacks[j],
2417                                             CM_CALLBACK_MAINTAINCOUNT);
2418                 cm_MergeStatus(dscp, scp, &bb.stats[j], &volSync, userp, 0);
2419             }       
2420             lock_ReleaseMutex(&scp->mx);
2421             cm_ReleaseSCache(scp);
2422         } /* all files in the response */
2423         /* now tell it to drop the count,
2424          * after doing the vnode processing above */
2425         cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, 0);
2426
2427         filex += filesThisCall;
2428     }   /* while there are still more files to process */
2429     lock_ObtainMutex(&dscp->mx);
2430
2431     /* If we did the InlineBulk RPC pull out the return code and log it */
2432     if (inlinebulk) {
2433         if ((&bb.stats[0])->errorCode) {
2434             osi_Log1(afsd_logp, "cm_TryBulkStat bulk stat error: %d", 
2435                      (&bb.stats[0])->errorCode);
2436         }
2437     }
2438
2439     osi_Log0(afsd_logp, "END cm_TryBulkStat");
2440     return 0;
2441 }       
2442
2443 void cm_StatusFromAttr(AFSStoreStatus *statusp, cm_scache_t *scp, cm_attr_t *attrp)
2444 {
2445     long mask;
2446
2447     /* initialize store back mask as inexpensive local variable */
2448     mask = 0;
2449     memset(statusp, 0, sizeof(AFSStoreStatus));
2450
2451     /* copy out queued info from scache first, if scp passed in */
2452     if (scp) {
2453         if (scp->mask & CM_SCACHEMASK_CLIENTMODTIME) {
2454             statusp->ClientModTime = scp->clientModTime;
2455             mask |= AFS_SETMODTIME;
2456             scp->mask &= ~CM_SCACHEMASK_CLIENTMODTIME;
2457         }
2458     }
2459
2460     if (attrp) {
2461         /* now add in our locally generated request */
2462         if (attrp->mask & CM_ATTRMASK_CLIENTMODTIME) {
2463             statusp->ClientModTime = attrp->clientModTime;
2464             mask |= AFS_SETMODTIME;
2465         }
2466         if (attrp->mask & CM_ATTRMASK_UNIXMODEBITS) {
2467             statusp->UnixModeBits = attrp->unixModeBits;
2468             mask |= AFS_SETMODE;
2469         }
2470         if (attrp->mask & CM_ATTRMASK_OWNER) {
2471             statusp->Owner = attrp->owner;
2472             mask |= AFS_SETOWNER;
2473         }
2474         if (attrp->mask & CM_ATTRMASK_GROUP) {
2475             statusp->Group = attrp->group;
2476             mask |= AFS_SETGROUP;
2477         }
2478     }
2479     statusp->Mask = mask;
2480 }       
2481
2482 /* set the file size, and make sure that all relevant buffers have been
2483  * truncated.  Ensure that any partially truncated buffers have been zeroed
2484  * to the end of the buffer.
2485  */
2486 long cm_SetLength(cm_scache_t *scp, osi_hyper_t *sizep, cm_user_t *userp,
2487                    cm_req_t *reqp)
2488 {
2489     long code;
2490     int shrinking;
2491
2492     /* start by locking out buffer creation */
2493     lock_ObtainWrite(&scp->bufCreateLock);
2494
2495     /* verify that this is a file, not a dir or a symlink */
2496     lock_ObtainMutex(&scp->mx);
2497     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
2498                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2499     if (code) 
2500         goto done;
2501     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
2502
2503     if (scp->fileType != CM_SCACHETYPE_FILE) {
2504         code = CM_ERROR_ISDIR;
2505         goto done;
2506     }
2507
2508   startover:
2509     if (LargeIntegerLessThan(*sizep, scp->length))
2510         shrinking = 1;
2511     else
2512         shrinking = 0;
2513
2514     lock_ReleaseMutex(&scp->mx);
2515
2516     /* can't hold scp->mx lock here, since we may wait for a storeback to
2517      * finish if the buffer package is cleaning a buffer by storing it to
2518      * the server.
2519      */
2520     if (shrinking)
2521         buf_Truncate(scp, userp, reqp, sizep);
2522
2523     /* now ensure that file length is short enough, and update truncPos */
2524     lock_ObtainMutex(&scp->mx);
2525
2526     /* make sure we have a callback (so we have the right value for the
2527      * length), and wait for it to be safe to do a truncate.
2528      */
2529     code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_WRITE,
2530                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
2531                       | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
2532
2533     /* If we only have 'i' bits, then we should still be able to set
2534        the size of a file we created. */
2535     if (code == CM_ERROR_NOACCESS && scp->creator == userp) {
2536         code = cm_SyncOp(scp, NULL, userp, reqp, PRSFS_INSERT,
2537                          CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
2538                          | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
2539     }
2540
2541     if (code) 
2542         goto done;
2543
2544     if (LargeIntegerLessThan(*sizep, scp->length)) {
2545         /* a real truncation.  If truncPos is not set yet, or is bigger
2546          * than where we're truncating the file, set truncPos to this
2547          * new value.
2548          */
2549         if (!shrinking)
2550             goto startover;
2551         if (!(scp->mask & CM_SCACHEMASK_TRUNCPOS)
2552              || LargeIntegerLessThan(*sizep, scp->length)) {
2553             /* set trunc pos */
2554             scp->truncPos = *sizep;
2555             scp->mask |= CM_SCACHEMASK_TRUNCPOS;
2556         }
2557         /* in either case, the new file size has been changed */
2558         scp->length = *sizep;
2559         scp->mask |= CM_SCACHEMASK_LENGTH;
2560     }
2561     else if (LargeIntegerGreaterThan(*sizep, scp->length)) {
2562         /* really extending the file */
2563         scp->length = *sizep;
2564         scp->mask |= CM_SCACHEMASK_LENGTH;
2565     }
2566
2567     /* done successfully */
2568     code = 0;
2569
2570     cm_SyncOpDone(scp, NULL, 
2571                    CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
2572                    | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
2573
2574   done:
2575     lock_ReleaseMutex(&scp->mx);
2576     lock_ReleaseWrite(&scp->bufCreateLock);
2577
2578     return code;
2579 }
2580
2581 /* set the file size or other attributes (but not both at once) */
2582 long cm_SetAttr(cm_scache_t *scp, cm_attr_t *attrp, cm_user_t *userp,
2583                 cm_req_t *reqp)
2584 {
2585     long code;
2586     AFSFetchStatus afsOutStatus;
2587     AFSVolSync volSync;
2588     cm_conn_t *connp;
2589     AFSFid tfid;
2590     AFSStoreStatus afsInStatus;
2591     struct rx_connection * callp;
2592
2593     /* handle file length setting */
2594     if (attrp->mask & CM_ATTRMASK_LENGTH)
2595         return cm_SetLength(scp, &attrp->length, userp, reqp);
2596
2597     lock_ObtainMutex(&scp->mx);
2598     /* otherwise, we have to make an RPC to get the status */
2599     code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
2600     if (code) {
2601         lock_ReleaseMutex(&scp->mx);
2602         return code;
2603     }
2604
2605     /* make the attr structure */
2606     cm_StatusFromAttr(&afsInStatus, scp, attrp);
2607
2608     tfid.Volume = scp->fid.volume;
2609     tfid.Vnode = scp->fid.vnode;
2610     tfid.Unique = scp->fid.unique;
2611         lock_ReleaseMutex(&scp->mx);
2612
2613     /* now make the RPC */
2614     osi_Log1(afsd_logp, "CALL StoreStatus scp 0x%p", scp);
2615     do {
2616         code = cm_ConnFromFID(&scp->fid, userp, reqp, &connp);
2617         if (code) 
2618             continue;
2619
2620         callp = cm_GetRxConn(connp);
2621         code = RXAFS_StoreStatus(callp, &tfid,
2622                                   &afsInStatus, &afsOutStatus, &volSync);
2623         rx_PutConnection(callp);
2624
2625     } while (cm_Analyze(connp, userp, reqp,
2626                          &scp->fid, &volSync, NULL, NULL, code));
2627     code = cm_MapRPCError(code, reqp);
2628
2629     if (code)
2630         osi_Log1(afsd_logp, "CALL StoreStatus FAILURE, code 0x%x", code);
2631     else
2632         osi_Log0(afsd_logp, "CALL StoreStatus SUCCESS");
2633
2634     lock_ObtainMutex(&scp->mx);
2635     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
2636     if (code == 0)
2637         cm_MergeStatus(NULL, scp, &afsOutStatus, &volSync, userp,
2638                         CM_MERGEFLAG_FORCE|CM_MERGEFLAG_STOREDATA);
2639         
2640     /* if we're changing the mode bits, discard the ACL cache, 
2641      * since we changed the mode bits.
2642      */
2643     if (afsInStatus.Mask & AFS_SETMODE) 
2644         cm_FreeAllACLEnts(scp);
2645     lock_ReleaseMutex(&scp->mx);
2646     return code;
2647 }       
2648
2649 long cm_Create(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
2650                cm_scache_t **scpp, cm_user_t *userp, cm_req_t *reqp)
2651 {       
2652     cm_conn_t *connp;
2653     long code;
2654     AFSFid dirAFSFid;
2655     cm_callbackRequest_t cbReq;
2656     AFSFid newAFSFid;
2657     cm_fid_t newFid;
2658     cm_scache_t *scp = NULL;
2659     int didEnd;
2660     AFSStoreStatus inStatus;
2661     AFSFetchStatus updatedDirStatus;
2662     AFSFetchStatus newFileStatus;
2663     AFSCallBack newFileCallback;
2664     AFSVolSync volSync;
2665     struct rx_connection * callp;
2666     cm_dirOp_t dirop;
2667
2668     /* can't create names with @sys in them; must expand it manually first.
2669      * return "invalid request" if they try.
2670      */
2671     if (cm_ExpandSysName(namep, NULL, 0, 0)) {
2672         return CM_ERROR_ATSYS;
2673     }
2674
2675     /* before starting the RPC, mark that we're changing the file data, so
2676      * that someone who does a chmod will know to wait until our call
2677      * completes.
2678      */
2679     cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
2680     lock_ObtainMutex(&dscp->mx);
2681     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2682     lock_ReleaseMutex(&dscp->mx);
2683     if (code == 0) {
2684         cm_StartCallbackGrantingCall(NULL, &cbReq);
2685     } else {
2686         cm_EndDirOp(&dirop);
2687     }
2688     if (code) {
2689         return code;
2690     }
2691     didEnd = 0;
2692
2693     cm_StatusFromAttr(&inStatus, NULL, attrp);
2694
2695     /* try the RPC now */
2696     osi_Log1(afsd_logp, "CALL CreateFile scp 0x%p", dscp);
2697     do {
2698         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
2699         if (code) 
2700             continue;
2701
2702         dirAFSFid.Volume = dscp->fid.volume;
2703         dirAFSFid.Vnode = dscp->fid.vnode;
2704         dirAFSFid.Unique = dscp->fid.unique;
2705
2706         callp = cm_GetRxConn(connp);
2707         code = RXAFS_CreateFile(connp->callp, &dirAFSFid, namep,
2708                                  &inStatus, &newAFSFid, &newFileStatus,
2709                                  &updatedDirStatus, &newFileCallback,
2710                                  &volSync);
2711         rx_PutConnection(callp);
2712
2713     } while (cm_Analyze(connp, userp, reqp,
2714                          &dscp->fid, &volSync, NULL, &cbReq, code));
2715     code = cm_MapRPCError(code, reqp);
2716         
2717     if (code)
2718         osi_Log1(afsd_logp, "CALL CreateFile FAILURE, code 0x%x", code);
2719     else
2720         osi_Log0(afsd_logp, "CALL CreateFile SUCCESS");
2721
2722     if (dirop.scp) {
2723         lock_ObtainWrite(&dirop.scp->dirlock);
2724         dirop.lockType = CM_DIRLOCK_WRITE;
2725     }
2726     lock_ObtainMutex(&dscp->mx);
2727     cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2728     if (code == 0) {
2729         cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
2730     }
2731     lock_ReleaseMutex(&dscp->mx);
2732
2733     /* now try to create the file's entry, too, but be careful to 
2734      * make sure that we don't merge in old info.  Since we weren't locking
2735      * out any requests during the file's creation, we may have pretty old
2736      * info.
2737      */
2738     if (code == 0) {
2739         newFid.cell = dscp->fid.cell;
2740         newFid.volume = dscp->fid.volume;
2741         newFid.vnode = newAFSFid.Vnode;
2742         newFid.unique = newAFSFid.Unique;
2743         code = cm_GetSCache(&newFid, &scp, userp, reqp);
2744         if (code == 0) {
2745             lock_ObtainMutex(&scp->mx);
2746             scp->creator = userp;               /* remember who created it */
2747             if (!cm_HaveCallback(scp)) {
2748                 cm_MergeStatus(dscp, scp, &newFileStatus, &volSync,
2749                                 userp, 0);
2750                 cm_EndCallbackGrantingCall(scp, &cbReq,
2751                                             &newFileCallback, 0);
2752                 didEnd = 1;     
2753             }       
2754             lock_ReleaseMutex(&scp->mx);
2755             *scpp = scp;
2756         }
2757     }
2758
2759     /* make sure we end things properly */
2760     if (!didEnd)
2761         cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, 0);
2762
2763     if (scp && cm_CheckDirOpForSingleChange(&dirop)) {
2764         cm_DirCreateEntry(&dirop, namep, &newFid);
2765 #ifdef USE_BPLUS
2766         cm_BPlusDirCreateEntry(&dirop, namep, &newFid);
2767 #endif
2768     }
2769     cm_EndDirOp(&dirop);
2770
2771     return code;
2772 }       
2773
2774 long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
2775 {
2776     long code;
2777
2778     lock_ObtainWrite(&scp->bufCreateLock);
2779     code = buf_CleanVnode(scp, userp, reqp);
2780     lock_ReleaseWrite(&scp->bufCreateLock);
2781     if (code == 0) {
2782         lock_ObtainMutex(&scp->mx);
2783
2784         if (scp->mask & (CM_SCACHEMASK_TRUNCPOS
2785                           | CM_SCACHEMASK_CLIENTMODTIME
2786                           | CM_SCACHEMASK_LENGTH))
2787             code = cm_StoreMini(scp, userp, reqp);
2788
2789         if (scp->flags & (CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE)) {
2790             code = (scp->flags & CM_SCACHEFLAG_OVERQUOTA) ? CM_ERROR_QUOTA : CM_ERROR_SPACE;
2791             scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE);
2792         }
2793
2794         lock_ReleaseMutex(&scp->mx);
2795     }
2796     return code;
2797 }
2798
2799 long cm_MakeDir(cm_scache_t *dscp, char *namep, long flags, cm_attr_t *attrp,
2800                  cm_user_t *userp, cm_req_t *reqp)
2801 {
2802     cm_conn_t *connp;
2803     long code;
2804     AFSFid dirAFSFid;
2805     cm_callbackRequest_t cbReq;
2806     AFSFid newAFSFid;
2807     cm_fid_t newFid;
2808     cm_scache_t *scp = NULL;
2809     int didEnd;
2810     AFSStoreStatus inStatus;
2811     AFSFetchStatus updatedDirStatus;
2812     AFSFetchStatus newDirStatus;
2813     AFSCallBack newDirCallback;
2814     AFSVolSync volSync;
2815     struct rx_connection * callp;
2816     cm_dirOp_t dirop;
2817
2818     /* can't create names with @sys in them; must expand it manually first.
2819      * return "invalid request" if they try.
2820      */
2821     if (cm_ExpandSysName(namep, NULL, 0, 0)) {
2822         return CM_ERROR_ATSYS;
2823     }
2824
2825     /* before starting the RPC, mark that we're changing the directory
2826      * data, so that someone who does a chmod on the dir will wait until
2827      * our call completes.
2828      */
2829     cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
2830     lock_ObtainMutex(&dscp->mx);
2831     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2832     lock_ReleaseMutex(&dscp->mx);
2833     if (code == 0) {
2834         cm_StartCallbackGrantingCall(NULL, &cbReq);
2835     } else {
2836         cm_EndDirOp(&dirop);
2837     }
2838     if (code) {
2839         return code;
2840     }
2841     didEnd = 0;
2842
2843     cm_StatusFromAttr(&inStatus, NULL, attrp);
2844
2845     /* try the RPC now */
2846     osi_Log1(afsd_logp, "CALL MakeDir scp 0x%p", dscp);
2847     do {
2848         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
2849         if (code) 
2850             continue;
2851
2852         dirAFSFid.Volume = dscp->fid.volume;
2853         dirAFSFid.Vnode = dscp->fid.vnode;
2854         dirAFSFid.Unique = dscp->fid.unique;
2855
2856         callp = cm_GetRxConn(connp);
2857         code = RXAFS_MakeDir(connp->callp, &dirAFSFid, namep,
2858                               &inStatus, &newAFSFid, &newDirStatus,
2859                               &updatedDirStatus, &newDirCallback,
2860                               &volSync);
2861         rx_PutConnection(callp);
2862
2863     } while (cm_Analyze(connp, userp, reqp,
2864                          &dscp->fid, &volSync, NULL, &cbReq, code));
2865     code = cm_MapRPCError(code, reqp);
2866         
2867     if (code)
2868         osi_Log1(afsd_logp, "CALL MakeDir FAILURE, code 0x%x", code);
2869     else
2870         osi_Log0(afsd_logp, "CALL MakeDir SUCCESS");
2871
2872     if (dirop.scp) {
2873         lock_ObtainWrite(&dirop.scp->dirlock);
2874         dirop.lockType = CM_DIRLOCK_WRITE;
2875     }
2876     lock_ObtainMutex(&dscp->mx);
2877     cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2878     if (code == 0) {
2879         cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
2880     }
2881     lock_ReleaseMutex(&dscp->mx);
2882
2883     /* now try to create the new dir's entry, too, but be careful to 
2884      * make sure that we don't merge in old info.  Since we weren't locking
2885      * out any requests during the file's creation, we may have pretty old
2886      * info.
2887      */
2888     if (code == 0) {
2889         newFid.cell = dscp->fid.cell;
2890         newFid.volume = dscp->fid.volume;
2891         newFid.vnode = newAFSFid.Vnode;
2892         newFid.unique = newAFSFid.Unique;
2893         code = cm_GetSCache(&newFid, &scp, userp, reqp);
2894         if (code == 0) {
2895             lock_ObtainMutex(&scp->mx);
2896             if (!cm_HaveCallback(scp)) {
2897                 cm_MergeStatus(dscp, scp, &newDirStatus, &volSync,
2898                                 userp, 0);
2899                 cm_EndCallbackGrantingCall(scp, &cbReq,
2900                                             &newDirCallback, 0);
2901                 didEnd = 1;             
2902             }
2903             lock_ReleaseMutex(&scp->mx);
2904             cm_ReleaseSCache(scp);
2905         }
2906     }
2907
2908     /* make sure we end things properly */
2909     if (!didEnd)
2910         cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, 0);
2911
2912     if (scp && cm_CheckDirOpForSingleChange(&dirop)) {
2913         cm_DirCreateEntry(&dirop, namep, &newFid);
2914 #ifdef USE_BPLUS
2915         cm_BPlusDirCreateEntry(&dirop, namep, &newFid);
2916 #endif
2917     }
2918     cm_EndDirOp(&dirop);
2919
2920     /* and return error code */
2921     return code;
2922 }       
2923
2924 long cm_Link(cm_scache_t *dscp, char *namep, cm_scache_t *sscp, long flags,
2925              cm_user_t *userp, cm_req_t *reqp)
2926 {
2927     cm_conn_t *connp;
2928     long code = 0;
2929     AFSFid dirAFSFid;
2930     AFSFid existingAFSFid;
2931     AFSFetchStatus updatedDirStatus;
2932     AFSFetchStatus newLinkStatus;
2933     AFSVolSync volSync;
2934     struct rx_connection * callp;
2935     cm_dirOp_t dirop;
2936
2937     if (dscp->fid.cell != sscp->fid.cell ||
2938         dscp->fid.volume != sscp->fid.volume) {
2939         return CM_ERROR_CROSSDEVLINK;
2940     }
2941
2942     cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
2943     lock_ObtainMutex(&dscp->mx);
2944     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
2945     lock_ReleaseMutex(&dscp->mx);
2946     if (code != 0)
2947         cm_EndDirOp(&dirop);
2948
2949     if (code)
2950         return code;
2951
2952     /* try the RPC now */
2953     osi_Log1(afsd_logp, "CALL Link scp 0x%p", dscp);
2954     do {
2955         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
2956         if (code) continue;
2957
2958         dirAFSFid.Volume = dscp->fid.volume;
2959         dirAFSFid.Vnode = dscp->fid.vnode;
2960         dirAFSFid.Unique = dscp->fid.unique;
2961
2962         existingAFSFid.Volume = sscp->fid.volume;
2963         existingAFSFid.Vnode = sscp->fid.vnode;
2964         existingAFSFid.Unique = sscp->fid.unique;
2965
2966         callp = cm_GetRxConn(connp);
2967         code = RXAFS_Link(callp, &dirAFSFid, namep, &existingAFSFid,
2968             &newLinkStatus, &updatedDirStatus, &volSync);
2969         rx_PutConnection(callp);
2970         osi_Log1(smb_logp,"  RXAFS_Link returns 0x%x", code);
2971
2972     } while (cm_Analyze(connp, userp, reqp,
2973         &dscp->fid, &volSync, NULL, NULL, code));
2974
2975     code = cm_MapRPCError(code, reqp);
2976
2977     if (code)
2978         osi_Log1(afsd_logp, "CALL Link FAILURE, code 0x%x", code);
2979     else
2980         osi_Log0(afsd_logp, "CALL Link SUCCESS");
2981
2982     if (dirop.scp) {
2983         lock_ObtainWrite(&dirop.scp->dirlock);
2984         dirop.lockType = CM_DIRLOCK_WRITE;
2985     }
2986     lock_ObtainMutex(&dscp->mx);
2987     cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
2988     if (code == 0) {
2989         cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
2990     }
2991     lock_ReleaseMutex(&dscp->mx);
2992
2993     if (code == 0) {
2994         if (cm_CheckDirOpForSingleChange(&dirop)) {
2995             cm_DirCreateEntry(&dirop, namep, &sscp->fid);
2996 #ifdef USE_BPLUS
2997             cm_BPlusDirCreateEntry(&dirop, namep, &sscp->fid);
2998 #endif
2999         }
3000     }
3001     cm_EndDirOp(&dirop);
3002
3003     return code;
3004 }
3005
3006 long cm_SymLink(cm_scache_t *dscp, char *namep, char *contentsp, long flags,
3007                 cm_attr_t *attrp, cm_user_t *userp, cm_req_t *reqp)
3008 {
3009     cm_conn_t *connp;
3010     long code;
3011     AFSFid dirAFSFid;
3012     AFSFid newAFSFid;
3013     cm_fid_t newFid;
3014     cm_scache_t *scp;
3015     AFSStoreStatus inStatus;
3016     AFSFetchStatus updatedDirStatus;
3017     AFSFetchStatus newLinkStatus;
3018     AFSVolSync volSync;
3019     struct rx_connection * callp;
3020     cm_dirOp_t dirop;
3021
3022     /* before starting the RPC, mark that we're changing the directory data,
3023      * so that someone who does a chmod on the dir will wait until our
3024      * call completes.
3025      */
3026     cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
3027     lock_ObtainMutex(&dscp->mx);
3028     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
3029     lock_ReleaseMutex(&dscp->mx);
3030     if (code != 0)
3031         cm_EndDirOp(&dirop);
3032     if (code) {
3033         return code;
3034     }
3035
3036     cm_StatusFromAttr(&inStatus, NULL, attrp);
3037
3038     /* try the RPC now */
3039     osi_Log1(afsd_logp, "CALL Symlink scp 0x%p", dscp);
3040     do {
3041         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
3042         if (code) 
3043             continue;
3044
3045         dirAFSFid.Volume = dscp->fid.volume;
3046         dirAFSFid.Vnode = dscp->fid.vnode;
3047         dirAFSFid.Unique = dscp->fid.unique;
3048
3049         callp = cm_GetRxConn(connp);
3050         code = RXAFS_Symlink(callp, &dirAFSFid, namep, contentsp,
3051                               &inStatus, &newAFSFid, &newLinkStatus,
3052                               &updatedDirStatus, &volSync);
3053         rx_PutConnection(callp);
3054
3055     } while (cm_Analyze(connp, userp, reqp,
3056                          &dscp->fid, &volSync, NULL, NULL, code));
3057     code = cm_MapRPCError(code, reqp);
3058         
3059     if (code)
3060         osi_Log1(afsd_logp, "CALL Symlink FAILURE, code 0x%x", code);
3061     else
3062         osi_Log0(afsd_logp, "CALL Symlink SUCCESS");
3063
3064     if (dirop.scp) {
3065         lock_ObtainWrite(&dirop.scp->dirlock);
3066         dirop.lockType = CM_DIRLOCK_WRITE;
3067     }
3068     lock_ObtainMutex(&dscp->mx);
3069     cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
3070     if (code == 0) {
3071         cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
3072     }
3073     lock_ReleaseMutex(&dscp->mx);
3074
3075     if (code == 0) {
3076         if (cm_CheckDirOpForSingleChange(&dirop)) {
3077             newFid.cell = dscp->fid.cell;
3078             newFid.volume = dscp->fid.volume;
3079             newFid.vnode = newAFSFid.Vnode;
3080             newFid.unique = newAFSFid.Unique;
3081
3082             cm_DirCreateEntry(&dirop, namep, &newFid);
3083 #ifdef USE_BPLUS
3084             cm_BPlusDirCreateEntry(&dirop, namep, &newFid);
3085 #endif
3086         }
3087     }
3088     cm_EndDirOp(&dirop);
3089
3090     /* now try to create the new dir's entry, too, but be careful to 
3091      * make sure that we don't merge in old info.  Since we weren't locking
3092      * out any requests during the file's creation, we may have pretty old
3093      * info.
3094      */
3095     if (code == 0) {
3096         newFid.cell = dscp->fid.cell;
3097         newFid.volume = dscp->fid.volume;
3098         newFid.vnode = newAFSFid.Vnode;
3099         newFid.unique = newAFSFid.Unique;
3100         code = cm_GetSCache(&newFid, &scp, userp, reqp);
3101         if (code == 0) {
3102             lock_ObtainMutex(&scp->mx);
3103             if (!cm_HaveCallback(scp)) {
3104                 cm_MergeStatus(dscp, scp, &newLinkStatus, &volSync,
3105                                 userp, 0);
3106             }       
3107             lock_ReleaseMutex(&scp->mx);
3108             cm_ReleaseSCache(scp);
3109         }
3110     }
3111         
3112     /* and return error code */
3113     return code;
3114 }
3115
3116 long cm_RemoveDir(cm_scache_t *dscp, char *namep, cm_user_t *userp,
3117                    cm_req_t *reqp)
3118 {
3119     cm_conn_t *connp;
3120     long code;
3121     AFSFid dirAFSFid;
3122     int didEnd;
3123     AFSFetchStatus updatedDirStatus;
3124     AFSVolSync volSync;
3125     struct rx_connection * callp;
3126     cm_dirOp_t dirop;
3127
3128     /* before starting the RPC, mark that we're changing the directory data,
3129      * so that someone who does a chmod on the dir will wait until our
3130      * call completes.
3131      */
3132     cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
3133     lock_ObtainMutex(&dscp->mx);
3134     code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
3135     lock_ReleaseMutex(&dscp->mx);
3136     if (code) {
3137         cm_EndDirOp(&dirop);
3138         return code;
3139     }
3140     didEnd = 0;
3141
3142     /* try the RPC now */
3143     osi_Log1(afsd_logp, "CALL RemoveDir scp 0x%p", dscp);
3144     do {
3145         code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
3146         if (code) 
3147             continue;
3148
3149         dirAFSFid.Volume = dscp->fid.volume;
3150         dirAFSFid.Vnode = dscp->fid.vnode;
3151         dirAFSFid.Unique = dscp->fid.unique;
3152
3153         callp = cm_GetRxConn(connp);
3154         code = RXAFS_RemoveDir(callp, &dirAFSFid, namep,
3155                                 &updatedDirStatus, &volSync);
3156         rx_PutConnection(callp);
3157
3158     } while (cm_Analyze(connp, userp, reqp,
3159                          &dscp->fid, &volSync, NULL, NULL, code));
3160     code = cm_MapRPCErrorRmdir(code, reqp);
3161
3162     if (code)
3163         osi_Log1(afsd_logp, "CALL RemoveDir FAILURE, code 0x%x", code);
3164     else
3165         osi_Log0(afsd_logp, "CALL RemoveDir SUCCESS");
3166
3167     if (dirop.scp) {
3168         lock_ObtainWrite(&dirop.scp->dirlock);
3169         dirop.lockType = CM_DIRLOCK_WRITE;
3170     }
3171     lock_ObtainMutex(&dscp->mx);
3172     cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
3173     if (code == 0) {
3174         cm_dnlcRemove(dscp, namep); 
3175         cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, CM_MERGEFLAG_DIROP);
3176     }
3177     lock_ReleaseMutex(&dscp->mx);
3178
3179     if (code == 0) {
3180         if (cm_CheckDirOpForSingleChange(&dirop)) {
3181             cm_DirDeleteEntry(&dirop, namep);
3182 #ifdef USE_BPLUS
3183             cm_BPlusDirDeleteEntry(&dirop, namep);
3184 #endif
3185         }
3186     }
3187     cm_EndDirOp(&dirop);
3188
3189     /* and return error code */
3190     return code;
3191 }
3192
3193 long cm_Open(cm_scache_t *scp, int type, cm_user_t *userp)
3194 {
3195     /* grab mutex on contents */
3196     lock_ObtainMutex(&scp->mx);
3197
3198     /* reset the prefetch info */
3199     scp->prefetch.base.LowPart = 0;             /* base */
3200     scp->prefetch.base.HighPart = 0;
3201     scp->prefetch.end.LowPart = 0;              /* and end */
3202     scp->prefetch.end.HighPart = 0;
3203
3204     /* release mutex on contents */
3205     lock_ReleaseMutex(&scp->mx);
3206
3207     /* we're done */
3208     return 0;
3209 }       
3210
3211 long cm_Rename(cm_scache_t *oldDscp, char *oldNamep, cm_scache_t *newDscp,
3212                 char *newNamep, cm_user_t *userp, cm_req_t *reqp)
3213 {
3214     cm_conn_t *connp;
3215     long code;
3216     AFSFid oldDirAFSFid;
3217     AFSFid newDirAFSFid;
3218     int didEnd;
3219     AFSFetchStatus updatedOldDirStatus;
3220     AFSFetchStatus updatedNewDirStatus;
3221     AFSVolSync volSync;
3222     int oneDir;
3223     struct rx_connection * callp;
3224     cm_dirOp_t oldDirOp;
3225     cm_fid_t   fileFid;
3226     int        diropCode = -1;
3227     cm_dirOp_t newDirOp;
3228
3229     /* before starting the RPC, mark that we're changing the directory data,
3230      * so that someone who does a chmod on the dir will wait until our call
3231      * completes.  We do this in vnode order so that we don't deadlock,
3232      * which makes the code a little verbose.
3233      */
3234     if (oldDscp == newDscp) {
3235         /* check for identical names */
3236         if (strcmp(oldNamep, newNamep) == 0)
3237             return CM_ERROR_RENAME_IDENTICAL;
3238
3239         oneDir = 1;
3240         cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
3241         lock_ObtainMutex(&oldDscp->mx);
3242         cm_dnlcRemove(oldDscp, oldNamep);
3243         cm_dnlcRemove(oldDscp, newNamep);
3244         code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
3245                           CM_SCACHESYNC_STOREDATA);
3246         lock_ReleaseMutex(&oldDscp->mx);
3247         if (code != 0) {
3248             cm_EndDirOp(&oldDirOp);
3249         }
3250     }
3251     else {
3252         /* two distinct dir vnodes */
3253         oneDir = 0;
3254         if (oldDscp->fid.cell != newDscp->fid.cell ||
3255              oldDscp->fid.volume != newDscp->fid.volume)
3256             return CM_ERROR_CROSSDEVLINK;
3257
3258         /* shouldn't happen that we have distinct vnodes for two
3259          * different files, but could due to deliberate attack, or
3260          * stale info.  Avoid deadlocks and quit now.
3261          */
3262         if (oldDscp->fid.vnode == newDscp->fid.vnode)
3263             return CM_ERROR_CROSSDEVLINK;
3264
3265         if (oldDscp->fid.vnode < newDscp->fid.vnode) {
3266             cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
3267             lock_ObtainMutex(&oldDscp->mx);
3268             cm_dnlcRemove(oldDscp, oldNamep);
3269             code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
3270                               CM_SCACHESYNC_STOREDATA);
3271             lock_ReleaseMutex(&oldDscp->mx);
3272             if (code != 0)
3273                 cm_EndDirOp(&oldDirOp);
3274             if (code == 0) {
3275                 cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
3276                 lock_ObtainMutex(&newDscp->mx);
3277                 cm_dnlcRemove(newDscp, newNamep);
3278                 code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
3279                                   CM_SCACHESYNC_STOREDATA);
3280                 lock_ReleaseMutex(&newDscp->mx);
3281                 if (code) {
3282                     cm_EndDirOp(&newDirOp);
3283
3284                     /* cleanup first one */
3285                     lock_ObtainMutex(&oldDscp->mx);
3286                     cm_SyncOpDone(oldDscp, NULL,
3287                                    CM_SCACHESYNC_STOREDATA);
3288                     lock_ReleaseMutex(&oldDscp->mx);
3289                     cm_EndDirOp(&oldDirOp);
3290                 }       
3291             }
3292         }
3293         else {
3294             /* lock the new vnode entry first */
3295             cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
3296             lock_ObtainMutex(&newDscp->mx);
3297             cm_dnlcRemove(newDscp, newNamep);
3298             code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
3299                               CM_SCACHESYNC_STOREDATA);
3300             lock_ReleaseMutex(&newDscp->mx);
3301             if (code != 0)
3302                 cm_EndDirOp(&newDirOp);
3303             if (code == 0) {
3304                 cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
3305                 lock_ObtainMutex(&oldDscp->mx);
3306                 cm_dnlcRemove(oldDscp, oldNamep);
3307                 code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
3308                                   CM_SCACHESYNC_STOREDATA);
3309                 lock_ReleaseMutex(&oldDscp->mx);
3310                 if (code != 0)
3311                     cm_EndDirOp(&oldDirOp);
3312                 if (code) {
3313                     /* cleanup first one */
3314                     lock_ObtainMutex(&newDscp->mx);
3315                     cm_SyncOpDone(newDscp, NULL,
3316                                    CM_SCACHESYNC_STOREDATA);
3317                     lock_ReleaseMutex(&newDscp->mx);
3318                     cm_EndDirOp(&newDirOp);
3319                 }       
3320             }
3321         }
3322     }   /* two distinct vnodes */
3323
3324     if (code) {
3325         return code;
3326     }
3327     didEnd = 0;
3328
3329     /* try the RPC now */
3330     osi_Log2(afsd_logp, "CALL Rename old scp 0x%p new scp 0x%p", 
3331               oldDscp, newDscp);
3332     do {
3333         code = cm_ConnFromFID(&oldDscp->fid, userp, reqp, &connp);
3334         if (code) 
3335             continue;
3336
3337         oldDirAFSFid.Volume = oldDscp->fid.volume;
3338         oldDirAFSFid.Vnode = oldDscp->fid.vnode;
3339         oldDirAFSFid.Unique = oldDscp->fid.unique;
3340         newDirAFSFid.Volume = newDscp->fid.volume;
3341         newDirAFSFid.Vnode = newDscp->fid.vnode;
3342         newDirAFSFid.Unique = newDscp->fid.unique;
3343
3344         callp = cm_GetRxConn(connp);
3345         code = RXAFS_Rename(callp, &oldDirAFSFid, oldNamep,
3346                              &newDirAFSFid, newNamep,
3347                              &updatedOldDirStatus, &updatedNewDirStatus,
3348                              &volSync);
3349         rx_PutConnection(callp);
3350
3351     } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
3352                          &volSync, NULL, NULL, code));
3353     code = cm_MapRPCError(code, reqp);
3354         
3355     if (code)
3356         osi_Log1(afsd_logp, "CALL Rename FAILURE, code 0x%x", code);
3357     else
3358         osi_Log0(afsd_logp, "CALL Rename SUCCESS");
3359
3360     /* update the individual stat cache entries for the directories */
3361     if (oldDirOp.scp) {
3362         lock_ObtainWrite(&oldDirOp.scp->dirlock);
3363         oldDirOp.lockType = CM_DIRLOCK_WRITE;
3364     }
3365     lock_ObtainMutex(&oldDscp->mx);
3366     cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
3367
3368     if (code == 0)
3369         cm_MergeStatus(NULL, oldDscp, &updatedOldDirStatus, &volSync,
3370                         userp, CM_MERGEFLAG_DIROP);
3371     lock_ReleaseMutex(&oldDscp->mx);
3372
3373     if (code == 0) {
3374         if (cm_CheckDirOpForSingleChange(&oldDirOp)) {
3375
3376 #ifdef USE_BPLUS
3377             diropCode = cm_BPlusDirLookup(&oldDirOp, oldNamep, &fileFid);
3378             if (diropCode == CM_ERROR_INEXACT_MATCH)
3379                 diropCode = 0;
3380             else if (diropCode == EINVAL)
3381 #endif
3382                 diropCode = cm_DirLookup(&oldDirOp, oldNamep, &fileFid);
3383
3384             if (diropCode == 0) {
3385                 if (oneDir) {
3386                     diropCode = cm_DirCreateEntry(&oldDirOp, newNamep, &fileFid);
3387 #ifdef USE_BPLUS
3388                     cm_BPlusDirCreateEntry(&oldDirOp, newNamep, &fileFid);
3389 #endif
3390                 }
3391
3392                 if (diropCode == 0) { 
3393                     diropCode = cm_DirDeleteEntry(&oldDirOp, oldNamep);
3394 #ifdef USE_BPLUS
3395                     cm_BPlusDirDeleteEntry(&oldDirOp, oldNamep);
3396 #endif
3397                 }
3398             }
3399         }
3400     }
3401     cm_EndDirOp(&oldDirOp);
3402
3403     /* and update it for the new one, too, if necessary */
3404     if (!oneDir) {
3405         if (newDirOp.scp) {
3406             lock_ObtainWrite(&newDirOp.scp->dirlock);
3407             newDirOp.lockType = CM_DIRLOCK_WRITE;
3408         }
3409         lock_ObtainMutex(&newDscp->mx);
3410         cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
3411         if (code == 0)
3412             cm_MergeStatus(NULL, newDscp, &updatedNewDirStatus, &volSync,
3413                             userp, CM_MERGEFLAG_DIROP);
3414         lock_ReleaseMutex(&newDscp->mx);
3415
3416         if (code == 0) {
3417             /* we only make the local change if we successfully made
3418                the change in the old directory AND there was only one
3419                change in the new directory */
3420             if (diropCode == 0 && cm_CheckDirOpForSingleChange(&newDirOp)) {
3421                 cm_DirCreateEntry(&newDirOp, newNamep, &fileFid);
3422 #ifdef USE_BPLUS
3423                 cm_BPlusDirCreateEntry(&newDirOp, newNamep, &fileFid);
3424 #endif
3425             }
3426         }
3427         cm_EndDirOp(&newDirOp);
3428     }
3429
3430     /* and return error code */
3431     return code;
3432 }
3433
3434 /* Byte range locks:
3435
3436    The OpenAFS Windows client has to fake byte range locks given no
3437    server side support for such locks.  This is implemented as keyed
3438    byte range locks on the cache manager.
3439
3440    Keyed byte range locks:
3441
3442    Each cm_scache_t structure keeps track of a list of keyed locks.
3443    The key for a lock identifies an owner of a set of locks (referred
3444    to as a client).  Each key is represented by a value.  The set of
3445    key values used within a specific cm_scache_t structure form a
3446    namespace that has a scope of just that cm_scache_t structure.  The
3447    same key value can be used with another cm_scache_t structure and
3448    correspond to a completely different client.  However it is
3449    advantageous for the SMB or IFS layer to make sure that there is a
3450    1-1 mapping between client and keys over all cm_scache_t objects.
3451
3452    Assume a client C has key Key(C) (although, since the scope of the
3453    key is a cm_scache_t, the key can be Key(C,S), where S is the
3454    cm_scache_t.  But assume a 1-1 relation between keys and clients).
3455    A byte range (O,+L) denotes byte addresses (O) through (O+L-1)
3456    inclusive (a.k.a. [O,O+L-1]).  The function Key(x) is implemented
3457    through cm_generateKey() function for both SMB and IFS.
3458
3459    The list of locks for a cm_scache_t object S is maintained in