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