dir: do not leak contents of deleted directory entries
[openafs.git] / src / dir / dir.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
13 #ifdef KERNEL
14 # if !defined(UKERNEL)
15 #  include "h/types.h"
16 #  if !defined(AFS_LINUX26_ENV)
17 #   include "h/param.h"
18 #  endif
19 #  ifdef        AFS_AUX_ENV
20 #   include "h/mmu.h"
21 #   include "h/seg.h"
22 #   include "h/sysmacros.h"
23 #   include "h/signal.h"
24 #   include "h/errno.h"
25 #  endif
26 #  include "h/time.h"
27 #  if defined(AFS_AIX_ENV) || defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV) || defined(AFS_LINUX20_ENV)
28 #   include "h/errno.h"
29 #  else
30 #   if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
31 #    include "h/kernel.h"
32 #   endif
33 #  endif
34 #  if   defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV) || defined(AFS_FBSD_ENV) || defined(AFS_DARWIN80_ENV)
35 #   include "afs/sysincludes.h"
36 #  endif
37 #  if !defined(AFS_SGI64_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_OBSD48_ENV) && !defined(AFS_NBSD_ENV)
38 #   include "h/user.h"
39 #  endif /* AFS_SGI64_ENV */
40 #  include "h/uio.h"
41 #  ifdef        AFS_OSF_ENV
42 #   include <sys/mount.h>
43 #   include <sys/vnode.h>
44 #   include <ufs/inode.h>
45 #  endif
46 #  if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_HPUX110_ENV)
47 #   include "h/mbuf.h"
48 #  endif
49 #  ifndef AFS_LINUX20_ENV
50 #   include "netinet/in.h"
51 #  endif
52 # else /* !defined(UKERNEL) */
53 #  include "afs/stds.h"
54 #  include "afs/sysincludes.h"
55 # endif /* !defined(UKERNEL) */
56
57 /* afs_buffer.c */
58 /* These are needed because afs_prototypes.h is not included here */
59 struct dcache;
60 struct DirBuffer;
61 extern int DRead(struct dcache *adc, int page, struct DirBuffer *);
62 extern int DNew(struct dcache *adc, int page, struct DirBuffer *);
63
64 # include "afs/afs_osi.h"
65
66 # include "afs/dir.h"
67
68 # ifdef AFS_LINUX20_ENV
69 #  include "h/string.h"
70 # endif
71
72 #else /* KERNEL */
73
74 # include <roken.h>
75 # include "dir.h"
76 #endif /* KERNEL */
77
78 afs_int32 DErrno;
79
80 /* Local static prototypes */
81 static int FindBlobs(dir_file_t, int);
82 static void AddPage(dir_file_t, int);
83 static void FreeBlobs(dir_file_t, int, int);
84 static int FindItem(dir_file_t, char *, struct DirBuffer *,
85                     struct DirBuffer *);
86
87 /* Find out how many entries are required to store a name. */
88 int
89 afs_dir_NameBlobs(char *name)
90 {
91     int i;
92     i = strlen(name) + 1;
93     return 1 + ((i + 15) >> 5);
94 }
95
96 /* Create an entry in a file.  Dir is a file representation, while entry is
97  * a string name. */
98 int
99 afs_dir_Create(dir_file_t dir, char *entry, void *voidfid)
100 {
101     afs_int32 *vfid = (afs_int32 *) voidfid;
102     int blobs, firstelt;
103     int i;
104     struct DirBuffer entrybuf, prevbuf, headerbuf;
105     struct DirEntry *ep;
106     struct DirHeader *dhp;
107
108     /* check name quality */
109     if (*entry == 0)
110         return EINVAL;
111
112     /* First check if file already exists. */
113     if (FindItem(dir, entry, &prevbuf, &entrybuf) == 0) {
114         DRelease(&entrybuf, 0);
115         DRelease(&prevbuf, 0);
116         return EEXIST;
117     }
118
119     blobs = afs_dir_NameBlobs(entry);   /* number of entries required */
120     firstelt = FindBlobs(dir, blobs);
121     if (firstelt < 0)
122         return EFBIG;           /* directory is full */
123
124     /* First, we fill in the directory entry. */
125     if (afs_dir_GetBlob(dir, firstelt, &entrybuf) != 0)
126         return EIO;
127     ep = (struct DirEntry *)entrybuf.data;
128
129     ep->flag = FFIRST;
130     ep->fid.vnode = htonl(vfid[1]);
131     ep->fid.vunique = htonl(vfid[2]);
132     strcpy(ep->name, entry);
133
134     /* Now we just have to thread it on the hash table list. */
135     if (DRead(dir, 0, &headerbuf) != 0) {
136         DRelease(&entrybuf, 1);
137         return EIO;
138     }
139     dhp = (struct DirHeader *)headerbuf.data;
140
141     i = afs_dir_DirHash(entry);
142     ep->next = dhp->hashTable[i];
143     dhp->hashTable[i] = htons(firstelt);
144     DRelease(&headerbuf, 1);
145     DRelease(&entrybuf, 1);
146     return 0;
147 }
148
149 int
150 afs_dir_Length(dir_file_t dir)
151 {
152     int i, ctr;
153     struct DirBuffer headerbuf;
154     struct DirHeader *dhp;
155
156     if (DRead(dir, 0, &headerbuf) != 0)
157         return 0;
158     dhp = (struct DirHeader *)headerbuf.data;
159
160     if (dhp->header.pgcount != 0)
161         ctr = ntohs(dhp->header.pgcount);
162     else {
163         /* old style, count the pages */
164         ctr = 0;
165         for (i = 0; i < MAXPAGES; i++)
166             if (dhp->alloMap[i] != EPP)
167                 ctr++;
168     }
169     DRelease(&headerbuf, 0);
170     return ctr * AFS_PAGESIZE;
171 }
172
173 /* Delete an entry from a directory, including update of all free entry
174  * descriptors. */
175 int
176 afs_dir_Delete(dir_file_t dir, char *entry)
177 {
178
179     int nitems, index;
180     struct DirBuffer entrybuf, prevbuf;
181     struct DirEntry *firstitem;
182     unsigned short *previtem;
183
184     if (FindItem(dir, entry, &prevbuf, &entrybuf) != 0)
185         return ENOENT;
186
187     firstitem = (struct DirEntry *)entrybuf.data;
188     previtem = (unsigned short *)prevbuf.data;
189
190     *previtem = firstitem->next;
191     DRelease(&prevbuf, 1);
192     index = DVOffset(&entrybuf) / 32;
193     nitems = afs_dir_NameBlobs(firstitem->name);
194     /* Clear entire DirEntry and any DirXEntry extensions */
195     memset(firstitem, 0, nitems * sizeof(*firstitem));
196     DRelease(&entrybuf, 1);
197     FreeBlobs(dir, index, nitems);
198     return 0;
199 }
200
201 /* Find a bunch of contiguous entries; at least nblobs in a row. */
202 static int
203 FindBlobs(dir_file_t dir, int nblobs)
204 {
205     int i, j, k;
206     int failed = 0;
207     struct DirBuffer headerbuf, pagebuf;
208     struct DirHeader *dhp;
209     struct PageHeader *pp;
210     int pgcount;
211
212     /* read the dir header in first. */
213     if (DRead(dir, 0, &headerbuf) != 0)
214         return -1;
215     dhp = (struct DirHeader *)headerbuf.data;
216
217     for (i = 0; i < BIGMAXPAGES; i++) {
218         if (i >= MAXPAGES || dhp->alloMap[i] >= nblobs) {
219             /* if page could contain enough entries */
220             /* If there are EPP free entries, then the page is not even allocated. */
221             if (i >= MAXPAGES) {
222                 /* this pages exists past the end of the old-style dir */
223                 pgcount = ntohs(dhp->header.pgcount);
224                 if (pgcount == 0) {
225                     pgcount = MAXPAGES;
226                     dhp->header.pgcount = htons(pgcount);
227                 }
228                 if (i > pgcount - 1) {
229                     /* this page is bigger than last allocated page */
230                     AddPage(dir, i);
231                     dhp->header.pgcount = htons(i + 1);
232                 }
233             } else if (dhp->alloMap[i] == EPP) {
234                 /* Add the page to the directory. */
235                 AddPage(dir, i);
236                 dhp->alloMap[i] = EPP - 1;
237                 dhp->header.pgcount = htons(i + 1);
238             }
239
240             /* read the page in. */
241             if (DRead(dir, i, &pagebuf) != 0) {
242                 break;
243             }
244             pp = (struct PageHeader *)pagebuf.data;
245             for (j = 0; j <= EPP - nblobs; j++) {
246                 failed = 0;
247                 for (k = 0; k < nblobs; k++)
248                     if ((pp->freebitmap[(j + k) >> 3] >> ((j + k) & 7)) & 1) {
249                         failed = 1;
250                         break;
251                     }
252                 if (!failed)
253                     break;
254                 failed = 1;
255             }
256             if (!failed) {
257                 /* Here we have the first index in j.  We update the allocation maps
258                  * and free up any resources we've got allocated. */
259                 if (i < MAXPAGES)
260                     dhp->alloMap[i] -= nblobs;
261                 DRelease(&headerbuf, 1);
262                 for (k = 0; k < nblobs; k++)
263                     pp->freebitmap[(j + k) >> 3] |= 1 << ((j + k) & 7);
264                 DRelease(&pagebuf, 1);
265                 return j + i * EPP;
266             }
267             DRelease(&pagebuf, 0);      /* This dir page is unchanged. */
268         }
269     }
270     /* If we make it here, the directory is full. */
271     DRelease(&headerbuf, 1);
272     return -1;
273 }
274
275 static void
276 AddPage(dir_file_t dir, int pageno)
277 {                               /* Add a page to a directory. */
278     int i;
279     struct PageHeader *pp;
280     struct DirBuffer pagebuf;
281
282     /* Get a new buffer labelled dir,pageno */
283     DNew(dir, pageno, &pagebuf);
284     pp = (struct PageHeader *)pagebuf.data;
285
286     pp->tag = htons(1234);
287     if (pageno > 0)
288         pp->pgcount = 0;
289     pp->freecount = EPP - 1;    /* The first dude is already allocated */
290     pp->freebitmap[0] = 0x01;
291     for (i = 1; i < EPP / 8; i++)       /* It's a constant */
292         pp->freebitmap[i] = 0;
293     DRelease(&pagebuf, 1);
294 }
295
296 /* Free a whole bunch of directory entries. */
297
298 static void
299 FreeBlobs(dir_file_t dir, int firstblob, int nblobs)
300 {
301     int i;
302     int page;
303     struct DirBuffer headerbuf, pagehdbuf;
304     struct DirHeader *dhp;
305     struct PageHeader *pp;
306     page = firstblob / EPP;
307     firstblob -= EPP * page;    /* convert to page-relative entry */
308
309     if (DRead(dir, 0, &headerbuf) != 0)
310         return;
311     dhp = (struct DirHeader *)headerbuf.data;
312
313     if (page < MAXPAGES)
314         dhp->alloMap[page] += nblobs;
315
316     DRelease(&headerbuf, 1);
317
318     if (DRead(dir, page, &pagehdbuf) != 0)
319         return;
320     pp = (struct PageHeader *)pagehdbuf.data;
321
322     for (i = 0; i < nblobs; i++)
323         pp->freebitmap[(firstblob + i) >> 3] &= ~(1 << ((firstblob + i) & 7));
324
325     DRelease(&pagehdbuf, 1);
326 }
327
328 /*
329  * Format an empty directory properly.  Note that the first 13 entries in a
330  * directory header page are allocated, 1 to the page header, 4 to the
331  * allocation map and 8 to the hash table.
332  */
333 int
334 afs_dir_MakeDir(dir_file_t dir, afs_int32 * me, afs_int32 * parent)
335 {
336     int i;
337     struct DirBuffer buffer;
338     struct DirHeader *dhp;
339
340     DNew(dir, 0, &buffer);
341     dhp = (struct DirHeader *)buffer.data;
342
343     dhp->header.pgcount = htons(1);
344     dhp->header.tag = htons(1234);
345     dhp->header.freecount = (EPP - DHE - 1);
346     dhp->header.freebitmap[0] = 0xff;
347     dhp->header.freebitmap[1] = 0x1f;
348     for (i = 2; i < EPP / 8; i++)
349         dhp->header.freebitmap[i] = 0;
350     dhp->alloMap[0] = (EPP - DHE - 1);
351     for (i = 1; i < MAXPAGES; i++)
352         dhp->alloMap[i] = EPP;
353     for (i = 0; i < NHASHENT; i++)
354         dhp->hashTable[i] = 0;
355     DRelease(&buffer, 1);
356     afs_dir_Create(dir, ".", me);
357     afs_dir_Create(dir, "..", parent);  /* Virtue is its own .. */
358     return 0;
359 }
360
361 /* Look up a file name in directory. */
362
363 int
364 afs_dir_Lookup(dir_file_t dir, char *entry, void *voidfid)
365 {
366     afs_int32 *fid = (afs_int32 *) voidfid;
367     struct DirBuffer firstbuf, prevbuf;
368     struct DirEntry *firstitem;
369
370     if (FindItem(dir, entry, &prevbuf, &firstbuf) != 0)
371         return ENOENT;
372     DRelease(&prevbuf, 0);
373     firstitem = (struct DirEntry *)firstbuf.data;
374
375     fid[1] = ntohl(firstitem->fid.vnode);
376     fid[2] = ntohl(firstitem->fid.vunique);
377     DRelease(&firstbuf, 0);
378     return 0;
379 }
380
381 /* Look up a file name in directory. */
382
383 int
384 afs_dir_LookupOffset(dir_file_t dir, char *entry, void *voidfid,
385                      long *offsetp)
386 {
387     afs_int32 *fid = (afs_int32 *) voidfid;
388     struct DirBuffer firstbuf, prevbuf;
389     struct DirEntry *firstitem;
390
391     if (FindItem(dir, entry, &prevbuf, &firstbuf) != 0)
392         return ENOENT;
393     DRelease(&prevbuf, 0);
394     firstitem = (struct DirEntry *)firstbuf.data;
395
396     fid[1] = ntohl(firstitem->fid.vnode);
397     fid[2] = ntohl(firstitem->fid.vunique);
398     if (offsetp)
399         *offsetp = DVOffset(&firstbuf);
400     DRelease(&firstbuf, 0);
401     return 0;
402 }
403
404 /*
405  * Enumerate the contents of a directory. Break when hook function
406  * returns non 0.
407  */
408
409 int
410 afs_dir_EnumerateDir(dir_file_t dir, int (*proc) (void *, char *name,
411                                                   afs_int32 vnode,
412                                                   afs_int32 unique),
413                      void *hook)
414 {
415     int i;
416     int num;
417     struct DirBuffer headerbuf, entrybuf;
418     struct DirHeader *dhp;
419     struct DirEntry *ep;
420     int code = 0;
421     int elements;
422
423     if (DRead(dir, 0, &headerbuf) != 0)
424         return EIO;
425     dhp = (struct DirHeader *)headerbuf.data;
426
427     for (i = 0; i < NHASHENT; i++) {
428         /* For each hash chain, enumerate everyone on the list. */
429         num = ntohs(dhp->hashTable[i]);
430         elements = 0;
431         while (num != 0 && elements < BIGMAXPAGES * EPP) {
432             elements++;
433
434             /* Walk down the hash table list. */
435             code = afs_dir_GetVerifiedBlob(dir, num, &entrybuf);
436             if (code)
437                 goto out;
438
439             ep = (struct DirEntry *)entrybuf.data;
440             if (!ep) {
441                 DRelease(&entrybuf, 0);
442                 break;
443             }
444
445             num = ntohs(ep->next);
446             code = (*proc) (hook, ep->name, ntohl(ep->fid.vnode),
447                             ntohl(ep->fid.vunique));
448             DRelease(&entrybuf, 0);
449             if (code)
450                 goto out;
451         }
452     }
453
454 out:
455     DRelease(&headerbuf, 0);
456     return 0;
457 }
458
459 int
460 afs_dir_IsEmpty(dir_file_t dir)
461 {
462     /* Enumerate the contents of a directory. */
463     int i;
464     int num;
465     struct DirBuffer headerbuf, entrybuf;
466     struct DirHeader *dhp;
467     struct DirEntry *ep;
468     int elements;
469
470     if (DRead(dir, 0, &headerbuf) != 0)
471         return 0;
472     dhp = (struct DirHeader *)headerbuf.data;
473
474     for (i = 0; i < NHASHENT; i++) {
475         /* For each hash chain, enumerate everyone on the list. */
476         num = ntohs(dhp->hashTable[i]);
477         elements = 0;
478         while (num != 0 && elements < BIGMAXPAGES * EPP) {
479             elements++;
480             /* Walk down the hash table list. */
481             if (afs_dir_GetVerifiedBlob(dir, num, &entrybuf) != 0)
482                 break;
483             ep = (struct DirEntry *)entrybuf.data;
484             if (strcmp(ep->name, "..") && strcmp(ep->name, ".")) {
485                 DRelease(&entrybuf, 0);
486                 DRelease(&headerbuf, 0);
487                 return 1;
488             }
489             num = ntohs(ep->next);
490             DRelease(&entrybuf, 0);
491         }
492     }
493     DRelease(&headerbuf, 0);
494     return 0;
495 }
496
497 /* Return a pointer to an entry, given its number. Also return the maximum
498  * size of the entry, which is determined by its position within the directory
499  * page.
500  */
501
502 static int
503 GetBlobWithLimit(dir_file_t dir, afs_int32 blobno,
504                  struct DirBuffer *buffer, afs_size_t *maxlen)
505 {
506     afs_size_t pos;
507     int code;
508
509     *maxlen = 0;
510     memset(buffer, 0, sizeof(struct DirBuffer));
511
512     code = DRead(dir, blobno >> LEPP, buffer);
513     if (code)
514         return code;
515
516     pos = 32 * (blobno & (EPP - 1));
517
518     *maxlen = AFS_PAGESIZE - pos - 1;
519
520     buffer->data = (void *)(((char *)buffer->data) + pos);
521
522     return 0;
523 }
524
525 /* Given an entries number, return a pointer to that entry */
526 int
527 afs_dir_GetBlob(dir_file_t dir, afs_int32 blobno, struct DirBuffer *buffer)
528 {
529     afs_size_t maxlen = 0;
530     return GetBlobWithLimit(dir, blobno, buffer, &maxlen);
531 }
532
533 /* Return an entry, having verified that the name held within the entry
534  * doesn't overflow off the end of the directory page it is contained
535  * within
536  */
537
538 int
539 afs_dir_GetVerifiedBlob(dir_file_t file, afs_int32 blobno,
540                         struct DirBuffer *outbuf)
541 {
542     struct DirEntry *dir;
543     struct DirBuffer buffer;
544     afs_size_t maxlen;
545     int code;
546     char *cp;
547
548     code = GetBlobWithLimit(file, blobno, &buffer, &maxlen);
549     if (code)
550         return code;
551
552     dir = (struct DirEntry *)buffer.data;
553
554     /* A blob is only valid if the name within it is NULL terminated before
555      * the end of the blob's containing page */
556     for (cp = dir->name; *cp != '\0' && cp < ((char *)dir) + maxlen; cp++);
557
558     if (*cp != '\0') {
559         DRelease(&buffer, 0);
560         return EIO;
561     }
562
563     *outbuf = buffer;
564     return 0;
565 }
566
567 int
568 afs_dir_DirHash(char *string)
569 {
570     /* Hash a string to a number between 0 and NHASHENT. */
571     unsigned char tc;
572     unsigned int hval;
573     int tval;
574     hval = 0;
575     while ((tc = (*string++))) {
576         hval *= 173;
577         hval += tc;
578     }
579     tval = hval & (NHASHENT - 1);
580     if (tval == 0)
581         return tval;
582     else if (hval >= 1u<<31)
583         tval = NHASHENT - tval;
584     return tval;
585 }
586
587
588 /* Find a directory entry, given its name.  This entry returns a pointer
589  * to a locked buffer, and a pointer to a locked buffer (in previtem)
590  * referencing the found item (to aid the delete code).  If no entry is
591  * found, however, no items are left locked, and a null pointer is
592  * returned instead. */
593
594 static int
595 FindItem(dir_file_t dir, char *ename, struct DirBuffer *prevbuf,
596          struct DirBuffer *itembuf )
597 {
598     int i, code;
599     struct DirBuffer curr, prev;
600     struct DirHeader *dhp;
601     struct DirEntry *tp;
602     int elements;
603
604     memset(prevbuf, 0, sizeof(struct DirBuffer));
605     memset(itembuf, 0, sizeof(struct DirBuffer));
606
607     code = DRead(dir, 0, &prev);
608     if (code)
609         return code;
610     dhp = (struct DirHeader *)prev.data;
611
612     i = afs_dir_DirHash(ename);
613     if (dhp->hashTable[i] == 0) {
614         /* no such entry */
615         DRelease(&prev, 0);
616         return ENOENT;
617     }
618
619     code = afs_dir_GetVerifiedBlob(dir,
620                                    (u_short) ntohs(dhp->hashTable[i]),
621                                    &curr);
622     if (code) {
623         DRelease(&prev, 0);
624         return code;
625     }
626
627     prev.data = &(dhp->hashTable[i]);
628     elements = 0;
629     /* Detect circular hash chains. Absolute max size of a directory */
630     while (elements < BIGMAXPAGES * EPP) {
631         elements++;
632
633         /* Look at each entry on the hash chain */
634         tp = (struct DirEntry *)curr.data;
635         if (!strcmp(ename, tp->name)) {
636             /* Found it! */
637             *prevbuf = prev;
638             *itembuf = curr;
639             return 0;
640         }
641
642         DRelease(&prev, 0);
643
644         prev = curr;
645         prev.data = &(tp->next);
646
647         if (tp->next == 0)
648             goto out; /* The end of the line */
649
650         code = afs_dir_GetVerifiedBlob(dir, (u_short) ntohs(tp->next),
651                                        &curr);
652         if (code)
653             goto out;
654     }
655
656 out:
657     DRelease(&prev, 0);
658     return ENOENT;
659 }
660
661 static int
662 FindFid (void *dir, afs_uint32 vnode, afs_uint32 unique,
663          struct DirBuffer *itembuf)
664 {
665     /* Find a directory entry, given the vnode and uniquifier of a object.
666      * This entry returns a pointer to a locked buffer.  If no entry is found,
667      * however, no items are left locked, and a null pointer is returned
668      * instead.
669      */
670     int i, code;
671     unsigned short next;
672     struct DirBuffer curr, header;
673     struct DirHeader *dhp;
674     struct DirEntry *tp;
675     int elements;
676
677     memset(itembuf, 0, sizeof(struct DirBuffer));
678
679     code = DRead(dir, 0, &header);
680     if (code)
681         return code;
682     dhp = (struct DirHeader *)header.data;
683
684     for (i=0; i<NHASHENT; i++) {
685         if (dhp->hashTable[i] != 0) {
686             code = afs_dir_GetVerifiedBlob(dir,
687                                            (u_short)ntohs(dhp->hashTable[i]),
688                                            &curr);
689             if (code) {
690                 DRelease(&header, 0);
691                 return code;
692             }
693             elements = 0;
694             while(curr.data != NULL && elements < BIGMAXPAGES * EPP) {
695                 elements++;
696                 tp = (struct DirEntry *)curr.data;
697
698                 if (vnode == ntohl(tp->fid.vnode)
699                     && unique == ntohl(tp->fid.vunique)) {
700                     DRelease(&header, 0);
701                     *itembuf = curr;
702                     return 0;
703                 }
704
705                 next = tp->next;
706                 DRelease(&curr, 0);
707
708                 if (next == 0)
709                     break;
710
711                 code = afs_dir_GetVerifiedBlob(dir, (u_short)ntohs(next),
712                                                &curr);
713                 if (code) {
714                     DRelease(&header, 0);
715                     return code;
716                 }
717             }
718         }
719     }
720     DRelease(&header, 0);
721     return ENOENT;
722 }
723
724 int
725 afs_dir_InverseLookup(void *dir, afs_uint32 vnode, afs_uint32 unique,
726                       char *name, afs_uint32 length)
727 {
728     /* Look for the name pointing to given vnode and unique in a directory */
729     struct DirBuffer entrybuf;
730     struct DirEntry *entry;
731     int code = 0;
732
733     if (FindFid(dir, vnode, unique, &entrybuf) != 0)
734         return ENOENT;
735     entry = (struct DirEntry *)entrybuf.data;
736
737     if (strlen(entry->name) >= length)
738         code = E2BIG;
739     else
740         strcpy(name, entry->name);
741     DRelease(&entrybuf, 0);
742     return code;
743 }
744
745 /*!
746  * Change an entry fid.
747  *
748  * \param dir
749  * \param entry The entry name.
750  * \param old_fid The old find in MKFid format (host order).
751  * It can be omitted if you don't need a safety check...
752  * \param new_fid The new find in MKFid format (host order).
753  */
754 int
755 afs_dir_ChangeFid(dir_file_t dir, char *entry, afs_uint32 *old_fid,
756                   afs_uint32 *new_fid)
757 {
758     struct DirBuffer prevbuf, entrybuf;
759     struct DirEntry *firstitem;
760     struct MKFid *fid_old = (struct MKFid *) old_fid;
761     struct MKFid *fid_new = (struct MKFid *) new_fid;
762
763     /* Find entry. */
764     if (FindItem(dir, entry, &prevbuf, &entrybuf) != 0)
765         return ENOENT;
766     firstitem = (struct DirEntry *)entrybuf.data;
767     DRelease(&prevbuf, 1);
768
769     /* Replace fid. */
770     if (!old_fid ||
771         ((htonl(fid_old->vnode) == firstitem->fid.vnode) &&
772         (htonl(fid_old->vunique) == firstitem->fid.vunique))) {
773
774         firstitem->fid.vnode = htonl(fid_new->vnode);
775         firstitem->fid.vunique = htonl(fid_new->vunique);
776     }
777
778     DRelease(&entrybuf, 1);
779
780     return 0;
781 }