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