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