sbin/fsck_msdosfs/dir.c

   1 /*
   2  * Copyright (C) 1995, 1996, 1997 Wolfgang Solfrank
   3  * Copyright (c) 1995 Martin Husemann
   4  * Some structure declaration borrowed from Paul Popelka
   5  * (paulp@uts.amdahl.com), see /sys/msdosfs/ for reference.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by Martin Husemann
  18  *      and Wolfgang Solfrank.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  * $NetBSD: dir.c,v 1.14 1998/08/25 19:18:15 ross Exp $
  35  * $FreeBSD: src/sbin/fsck_msdosfs/dir.c,v 1.1.2.1 2001/08/01 05:47:55 obrien Exp $
  36  * $DragonFly: src/sbin/fsck_msdosfs/dir.c,v 1.6 2004/12/18 22:43:38 swildner Exp $
  37  */
  38
  39
  40 #include <sys/cdefs.h>
  41
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44 #include <string.h>
  45 #include <ctype.h>
  46 #include <stdio.h>
  47 #include <unistd.h>
  48 #include <time.h>
  49
  50 #include <sys/param.h>
  51
  52 #include "ext.h"
  53 #include "fsutil.h"
  54
  55 #define SLOT_EMPTY      0x00            /* slot has never been used */
  56 #define SLOT_E5         0x05            /* the real value is 0xe5 */
  57 #define SLOT_DELETED    0xe5            /* file in this slot deleted */
  58
  59 #define ATTR_NORMAL     0x00            /* normal file */
  60 #define ATTR_READONLY   0x01            /* file is readonly */
  61 #define ATTR_HIDDEN     0x02            /* file is hidden */
  62 #define ATTR_SYSTEM     0x04            /* file is a system file */
  63 #define ATTR_VOLUME     0x08            /* entry is a volume label */
  64 #define ATTR_DIRECTORY  0x10            /* entry is a directory name */
  65 #define ATTR_ARCHIVE    0x20            /* file is new or modified */
  66
  67 #define ATTR_WIN95      0x0f            /* long name record */
  68
  69 /*
  70  * This is the format of the contents of the deTime field in the direntry
  71  * structure.
  72  * We don't use bitfields because we don't know how compilers for
  73  * arbitrary machines will lay them out.
  74  */
  75 #define DT_2SECONDS_MASK        0x1F    /* seconds divided by 2 */
  76 #define DT_2SECONDS_SHIFT       0
  77 #define DT_MINUTES_MASK         0x7E0   /* minutes */
  78 #define DT_MINUTES_SHIFT        5
  79 #define DT_HOURS_MASK           0xF800  /* hours */
  80 #define DT_HOURS_SHIFT          11
  81
  82 /*
  83  * This is the format of the contents of the deDate field in the direntry
  84  * structure.
  85  */
  86 #define DD_DAY_MASK             0x1F    /* day of month */
  87 #define DD_DAY_SHIFT            0
  88 #define DD_MONTH_MASK           0x1E0   /* month */
  89 #define DD_MONTH_SHIFT          5
  90 #define DD_YEAR_MASK            0xFE00  /* year - 1980 */
  91 #define DD_YEAR_SHIFT           9
  92
  93
  94 /* dir.c */
  95 static struct dosDirEntry *newDosDirEntry(void);
  96 static void freeDosDirEntry(struct dosDirEntry *);
  97 static struct dirTodoNode *newDirTodo(void);
  98 static void freeDirTodo(struct dirTodoNode *);
  99 static char *fullpath(struct dosDirEntry *);
 100 static u_char calcShortSum(u_char *);
 101 static int delete(int, struct bootblock *, struct fatEntry *, cl_t, int,
 102     cl_t, int, int);
 103 static int removede(int, struct bootblock *, struct fatEntry *, u_char *,
 104     u_char *, cl_t, cl_t, cl_t, char *, int);
 105 static int checksize(struct bootblock *, struct fatEntry *, u_char *,
 106     struct dosDirEntry *);
 107 static int readDosDirSection(int, struct bootblock *, struct fatEntry *,
 108     struct dosDirEntry *);
 109
 110 /*
 111  * Manage free dosDirEntry structures.
 112  */
 113 static struct dosDirEntry *freede;
 114
 115 static struct dosDirEntry *
 116 newDosDirEntry(void)
 117 {
 118         struct dosDirEntry *de;
 119
 120         if (!(de = freede)) {
 121                 if (!(de = (struct dosDirEntry *)malloc(sizeof *de)))
 122                         return 0;
 123         } else
 124                 freede = de->next;
 125         return de;
 126 }
 127
 128 static void
 129 freeDosDirEntry(struct dosDirEntry *de)
 130 {
 131         de->next = freede;
 132         freede = de;
 133 }
 134
 135 /*
 136  * The same for dirTodoNode structures.
 137  */
 138 static struct dirTodoNode *freedt;
 139
 140 static struct dirTodoNode *
 141 newDirTodo(void)
 142 {
 143         struct dirTodoNode *dt;
 144
 145         if (!(dt = freedt)) {
 146                 if (!(dt = (struct dirTodoNode *)malloc(sizeof *dt)))
 147                         return 0;
 148         } else
 149                 freedt = dt->next;
 150         return dt;
 151 }
 152
 153 static void
 154 freeDirTodo(struct dirTodoNode *dt)
 155 {
 156         dt->next = freedt;
 157         freedt = dt;
 158 }
 159
 160 /*
 161  * The stack of unread directories
 162  */
 163 struct dirTodoNode *pendingDirectories = NULL;
 164
 165 /*
 166  * Return the full pathname for a directory entry.
 167  */
 168 static char *
 169 fullpath(struct dosDirEntry *dir)
 170 {
 171         static char namebuf[MAXPATHLEN + 1];
 172         char *cp, *np;
 173         int nl;
 174
 175         cp = namebuf + sizeof namebuf - 1;
 176         *cp = '\0';
 177         do {
 178                 np = dir->lname[0] ? dir->lname : dir->name;
 179                 nl = strlen(np);
 180                 if ((cp -= nl) <= namebuf + 1)
 181                         break;
 182                 memcpy(cp, np, nl);
 183                 *--cp = '/';
 184         } while ((dir = dir->parent) != NULL);
 185         if (dir)
 186                 *--cp = '?';
 187         else
 188                 cp++;
 189         return cp;
 190 }
 191
 192 /*
 193  * Calculate a checksum over an 8.3 alias name
 194  */
 195 static u_char
 196 calcShortSum(u_char *p)
 197 {
 198         u_char sum = 0;
 199         int i;
 200
 201         for (i = 0; i < 11; i++) {
 202                 sum = (sum << 7)|(sum >> 1);    /* rotate right */
 203                 sum += p[i];
 204         }
 205
 206         return sum;
 207 }
 208
 209 /*
 210  * Global variables temporarily used during a directory scan
 211  */
 212 static char longName[DOSLONGNAMELEN] = "";
 213 static u_char *buffer = NULL;
 214 static u_char *delbuf = NULL;
 215
 216 struct dosDirEntry *rootDir;
 217 static struct dosDirEntry *lostDir;
 218
 219 /*
 220  * Init internal state for a new directory scan.
 221  */
 222 int
 223 resetDosDirSection(struct bootblock *boot, struct fatEntry *fat)
 224 {
 225         int b1, b2;
 226         cl_t cl;
 227         int ret = FSOK;
 228
 229         b1 = boot->RootDirEnts * 32;
 230         b2 = boot->SecPerClust * boot->BytesPerSec;
 231
 232         if (!(buffer = malloc(b1 > b2 ? b1 : b2))
 233             || !(delbuf = malloc(b2))
 234             || !(rootDir = newDosDirEntry())) {
 235                 perror("No space for directory");
 236                 return FSFATAL;
 237         }
 238         memset(rootDir, 0, sizeof *rootDir);
 239         if (boot->flags & FAT32) {
 240                 if (boot->RootCl < CLUST_FIRST || boot->RootCl >= boot->NumClusters) {
 241                         pfatal("Root directory starts with cluster out of range(%u)",
 242                                boot->RootCl);
 243                         return FSFATAL;
 244                 }
 245                 cl = fat[boot->RootCl].next;
 246                 if (cl < CLUST_FIRST
 247                     || (cl >= CLUST_RSRVD && cl< CLUST_EOFS)
 248                     || fat[boot->RootCl].head != boot->RootCl) {
 249                         if (cl == CLUST_FREE)
 250                                 pwarn("Root directory starts with free cluster\n");
 251                         else if (cl >= CLUST_RSRVD)
 252                                 pwarn("Root directory starts with cluster marked %s\n",
 253                                       rsrvdcltype(cl));
 254                         else {
 255                                 pfatal("Root directory doesn't start a cluster chain");
 256                                 return FSFATAL;
 257                         }
 258                         if (ask(1, "Fix")) {
 259                                 fat[boot->RootCl].next = CLUST_FREE;
 260                                 ret = FSFATMOD;
 261                         } else
 262                                 ret = FSFATAL;
 263                 }
 264
 265                 fat[boot->RootCl].flags |= FAT_USED;
 266                 rootDir->head = boot->RootCl;
 267         }
 268
 269         return ret;
 270 }
 271
 272 /*
 273  * Cleanup after a directory scan
 274  */
 275 void
 276 finishDosDirSection(void)
 277 {
 278         struct dirTodoNode *p, *np;
 279         struct dosDirEntry *d, *nd;
 280
 281         for (p = pendingDirectories; p; p = np) {
 282                 np = p->next;
 283                 freeDirTodo(p);
 284         }
 285         pendingDirectories = 0;
 286         for (d = rootDir; d; d = nd) {
 287                 if ((nd = d->child) != NULL) {
 288                         d->child = 0;
 289                         continue;
 290                 }
 291                 if (!(nd = d->next))
 292                         nd = d->parent;
 293                 freeDosDirEntry(d);
 294         }
 295         rootDir = lostDir = NULL;
 296         free(buffer);
 297         free(delbuf);
 298         buffer = NULL;
 299         delbuf = NULL;
 300 }
 301
 302 /*
 303  * Delete directory entries between startcl, startoff and endcl, endoff.
 304  */
 305 static int
 306 delete(int f, struct bootblock *boot, struct fatEntry *fat, cl_t startcl,
 307        int startoff, cl_t endcl, int endoff, int notlast)
 308 {
 309         u_char *s, *e;
 310         off_t off;
 311         int clsz = boot->SecPerClust * boot->BytesPerSec;
 312
 313         s = delbuf + startoff;
 314         e = delbuf + clsz;
 315         while (startcl >= CLUST_FIRST && startcl < boot->NumClusters) {
 316                 if (startcl == endcl) {
 317                         if (notlast)
 318                                 break;
 319                         e = delbuf + endoff;
 320                 }
 321                 off = startcl * boot->SecPerClust + boot->ClusterOffset;
 322                 off *= boot->BytesPerSec;
 323                 if (lseek(f, off, SEEK_SET) != off
 324                     || read(f, delbuf, clsz) != clsz) {
 325                         perror("Unable to read directory");
 326                         return FSFATAL;
 327                 }
 328                 while (s < e) {
 329                         *s = SLOT_DELETED;
 330                         s += 32;
 331                 }
 332                 if (lseek(f, off, SEEK_SET) != off
 333                     || write(f, delbuf, clsz) != clsz) {
 334                         perror("Unable to write directory");
 335                         return FSFATAL;
 336                 }
 337                 if (startcl == endcl)
 338                         break;
 339                 startcl = fat[startcl].next;
 340                 s = delbuf;
 341         }
 342         return FSOK;
 343 }
 344
 345 static int
 346 removede(int f, struct bootblock *boot, struct fatEntry *fat, u_char *start,
 347          u_char *end, cl_t startcl, cl_t endcl, cl_t curcl, char *path,
 348          int type)
 349 {
 350         switch (type) {
 351         case 0:
 352                 pwarn("Invalid long filename entry for %s\n", path);
 353                 break;
 354         case 1:
 355                 pwarn("Invalid long filename entry at end of directory %s\n", path);
 356                 break;
 357         case 2:
 358                 pwarn("Invalid long filename entry for volume label\n");
 359                 break;
 360         }
 361         if (ask(0, "Remove")) {
 362                 if (startcl != curcl) {
 363                         if (delete(f, boot, fat,
 364                                    startcl, start - buffer,
 365                                    endcl, end - buffer,
 366                                    endcl == curcl) == FSFATAL)
 367                                 return FSFATAL;
 368                         start = buffer;
 369                 }
 370                 if (endcl == curcl)
 371                         for (; start < end; start += 32)
 372                                 *start = SLOT_DELETED;
 373                 return FSDIRMOD;
 374         }
 375         return FSERROR;
 376 }
 377
 378 /*
 379  * Check an in-memory file entry
 380  */
 381 static int
 382 checksize(struct bootblock *boot, struct fatEntry *fat, u_char *p,
 383           struct dosDirEntry *dir)
 384 {
 385         /*
 386          * Check size on ordinary files
 387          */
 388         int32_t physicalSize;
 389
 390         if (dir->head == CLUST_FREE)
 391                 physicalSize = 0;
 392         else {
 393                 if (dir->head < CLUST_FIRST || dir->head >= boot->NumClusters)
 394                         return FSERROR;
 395                 physicalSize = fat[dir->head].length * boot->ClusterSize;
 396         }
 397         if (physicalSize < dir->size) {
 398                 pwarn("size of %s is %u, should at most be %u\n",
 399                       fullpath(dir), dir->size, physicalSize);
 400                 if (ask(1, "Truncate")) {
 401                         dir->size = physicalSize;
 402                         p[28] = (u_char)physicalSize;
 403                         p[29] = (u_char)(physicalSize >> 8);
 404                         p[30] = (u_char)(physicalSize >> 16);
 405                         p[31] = (u_char)(physicalSize >> 24);
 406                         return FSDIRMOD;
 407                 } else
 408                         return FSERROR;
 409         } else if (physicalSize - dir->size >= boot->ClusterSize) {
 410                 pwarn("%s has too many clusters allocated\n",
 411                       fullpath(dir));
 412                 if (ask(1, "Drop superfluous clusters")) {
 413                         cl_t cl;
 414                         u_int32_t sz = 0;
 415
 416                         for (cl = dir->head; (sz += boot->ClusterSize) < dir->size;)
 417                                 cl = fat[cl].next;
 418                         clearchain(boot, fat, fat[cl].next);
 419                         fat[cl].next = CLUST_EOF;
 420                         return FSFATMOD;
 421                 } else
 422                         return FSERROR;
 423         }
 424         return FSOK;
 425 }
 426
 427 /*
 428  * Read a directory and
 429  *   - resolve long name records
 430  *   - enter file and directory records into the parent's list
 431  *   - push directories onto the todo-stack
 432  */
 433 static int
 434 readDosDirSection(int f, struct bootblock *boot, struct fatEntry *fat,
 435                   struct dosDirEntry *dir)
 436 {
 437         struct dosDirEntry dirent, *d;
 438         u_char *p, *vallfn, *invlfn, *empty;
 439         off_t off;
 440         int i, j, k, last;
 441         cl_t cl, valcl = ~0, invcl = ~0, empcl = ~0;
 442         char *t;
 443         u_int lidx = 0;
 444         int shortSum;
 445         int mod = FSOK;
 446 #define THISMOD 0x8000                  /* Only used within this routine */
 447
 448         cl = dir->head;
 449         if (dir->parent && (cl < CLUST_FIRST || cl >= boot->NumClusters)) {
 450                 /*
 451                  * Already handled somewhere else.
 452                  */
 453                 return FSOK;
 454         }
 455         shortSum = -1;
 456         vallfn = invlfn = empty = NULL;
 457         do {
 458                 if (!(boot->flags & FAT32) && !dir->parent) {
 459                         last = boot->RootDirEnts * 32;
 460                         off = boot->ResSectors + boot->FATs * boot->FATsecs;
 461                 } else {
 462                         last = boot->SecPerClust * boot->BytesPerSec;
 463                         off = cl * boot->SecPerClust + boot->ClusterOffset;
 464                 }
 465
 466                 off *= boot->BytesPerSec;
 467                 if (lseek(f, off, SEEK_SET) != off
 468                     || read(f, buffer, last) != last) {
 469                         perror("Unable to read directory");
 470                         return FSFATAL;
 471                 }
 472                 last /= 32;
 473                 /*
 474                  * Check `.' and `..' entries here?                     XXX
 475                  */
 476                 for (p = buffer, i = 0; i < last; i++, p += 32) {
 477                         if (dir->fsckflags & DIREMPWARN) {
 478                                 *p = SLOT_EMPTY;
 479                                 continue;
 480                         }
 481
 482                         if (*p == SLOT_EMPTY || *p == SLOT_DELETED) {
 483                                 if (*p == SLOT_EMPTY) {
 484                                         dir->fsckflags |= DIREMPTY;
 485                                         empty = p;
 486                                         empcl = cl;
 487                                 }
 488                                 continue;
 489                         }
 490
 491                         if (dir->fsckflags & DIREMPTY) {
 492                                 if (!(dir->fsckflags & DIREMPWARN)) {
 493                                         pwarn("%s has entries after end of directory\n",
 494                                               fullpath(dir));
 495                                         if (ask(1, "Extend")) {
 496                                                 u_char *q;
 497
 498                                                 dir->fsckflags &= ~DIREMPTY;
 499                                                 if (delete(f, boot, fat,
 500                                                            empcl, empty - buffer,
 501                                                            cl, p - buffer, 1) == FSFATAL)
 502                                                         return FSFATAL;
 503                                                 q = empcl == cl ? empty : buffer;
 504                                                 for (; q < p; q += 32)
 505                                                         *q = SLOT_DELETED;
 506                                                 mod |= THISMOD|FSDIRMOD;
 507                                         } else if (ask(0, "Truncate"))
 508                                                 dir->fsckflags |= DIREMPWARN;
 509                                 }
 510                                 if (dir->fsckflags & DIREMPWARN) {
 511                                         *p = SLOT_DELETED;
 512                                         mod |= THISMOD|FSDIRMOD;
 513                                         continue;
 514                                 } else if (dir->fsckflags & DIREMPTY)
 515                                         mod |= FSERROR;
 516                                 empty = NULL;
 517                         }
 518
 519                         if (p[11] == ATTR_WIN95) {
 520                                 if (*p & LRFIRST) {
 521                                         if (shortSum != -1) {
 522                                                 if (!invlfn) {
 523                                                         invlfn = vallfn;
 524                                                         invcl = valcl;
 525                                                 }
 526                                         }
 527                                         memset(longName, 0, sizeof longName);
 528                                         shortSum = p[13];
 529                                         vallfn = p;
 530                                         valcl = cl;
 531                                 } else if (shortSum != p[13]
 532                                            || lidx != (*p & LRNOMASK)) {
 533                                         if (!invlfn) {
 534                                                 invlfn = vallfn;
 535                                                 invcl = valcl;
 536                                         }
 537                                         if (!invlfn) {
 538                                                 invlfn = p;
 539                                                 invcl = cl;
 540                                         }
 541                                         vallfn = NULL;
 542                                 }
 543                                 lidx = *p & LRNOMASK;
 544                                 t = longName + --lidx * 13;
 545                                 for (k = 1; k < 11 && t < longName + sizeof(longName); k += 2) {
 546                                         if (!p[k] && !p[k + 1])
 547                                                 break;
 548                                         *t++ = p[k];
 549                                         /*
 550                                          * Warn about those unusable chars in msdosfs here?     XXX
 551                                          */
 552                                         if (p[k + 1])
 553                                                 t[-1] = '?';
 554                                 }
 555                                 if (k >= 11)
 556                                         for (k = 14; k < 26 && t < longName + sizeof(longName); k += 2) {
 557                                                 if (!p[k] && !p[k + 1])
 558                                                         break;
 559                                                 *t++ = p[k];
 560                                                 if (p[k + 1])
 561                                                         t[-1] = '?';
 562                                         }
 563                                 if (k >= 26)
 564                                         for (k = 28; k < 32 && t < longName + sizeof(longName); k += 2) {
 565                                                 if (!p[k] && !p[k + 1])
 566                                                         break;
 567                                                 *t++ = p[k];
 568                                                 if (p[k + 1])
 569                                                         t[-1] = '?';
 570                                         }
 571                                 if (t >= longName + sizeof(longName)) {
 572                                         pwarn("long filename too long\n");
 573                                         if (!invlfn) {
 574                                                 invlfn = vallfn;
 575                                                 invcl = valcl;
 576                                         }
 577                                         vallfn = NULL;
 578                                 }
 579                                 if (p[26] | (p[27] << 8)) {
 580                                         pwarn("long filename record cluster start != 0\n");
 581                                         if (!invlfn) {
 582                                                 invlfn = vallfn;
 583                                                 invcl = cl;
 584                                         }
 585                                         vallfn = NULL;
 586                                 }
 587                                 continue;       /* long records don't carry further
 588                                                  * information */
 589                         }
 590
 591                         /*
 592                          * This is a standard msdosfs directory entry.
 593                          */
 594                         memset(&dirent, 0, sizeof dirent);
 595
 596                         /*
 597                          * it's a short name record, but we need to know
 598                          * more, so get the flags first.
 599                          */
 600                         dirent.flags = p[11];
 601
 602                         /*
 603                          * Translate from 850 to ISO here               XXX
 604                          */
 605                         for (j = 0; j < 8; j++)
 606                                 dirent.name[j] = p[j];
 607                         dirent.name[8] = '\0';
 608                         for (k = 7; k >= 0 && dirent.name[k] == ' '; k--)
 609                                 dirent.name[k] = '\0';
 610                         if (dirent.name[k] != '\0')
 611                                 k++;
 612                         if (dirent.name[0] == SLOT_E5)
 613                                 dirent.name[0] = 0xe5;
 614
 615                         if (dirent.flags & ATTR_VOLUME) {
 616                                 if (vallfn || invlfn) {
 617                                         mod |= removede(f, boot, fat,
 618                                                         invlfn ? invlfn : vallfn, p,
 619                                                         invlfn ? invcl : valcl, -1, 0,
 620                                                         fullpath(dir), 2);
 621                                         vallfn = NULL;
 622                                         invlfn = NULL;
 623                                 }
 624                                 continue;
 625                         }
 626
 627                         if (p[8] != ' ')
 628                                 dirent.name[k++] = '.';
 629                         for (j = 0; j < 3; j++)
 630                                 dirent.name[k++] = p[j+8];
 631                         dirent.name[k] = '\0';
 632                         for (k--; k >= 0 && dirent.name[k] == ' '; k--)
 633                                 dirent.name[k] = '\0';
 634
 635                         if (vallfn && shortSum != calcShortSum(p)) {
 636                                 if (!invlfn) {
 637                                         invlfn = vallfn;
 638                                         invcl = valcl;
 639                                 }
 640                                 vallfn = NULL;
 641                         }
 642                         dirent.head = p[26] | (p[27] << 8);
 643                         if (boot->ClustMask == CLUST32_MASK)
 644                                 dirent.head |= (p[20] << 16) | (p[21] << 24);
 645                         dirent.size = p[28] | (p[29] << 8) | (p[30] << 16) | (p[31] << 24);
 646                         if (vallfn) {
 647                                 strcpy(dirent.lname, longName);
 648                                 longName[0] = '\0';
 649                                 shortSum = -1;
 650                         }
 651
 652                         dirent.parent = dir;
 653                         dirent.next = dir->child;
 654
 655                         if (invlfn) {
 656                                 mod |= k = removede(f, boot, fat,
 657                                                     invlfn, vallfn ? vallfn : p,
 658                                                     invcl, vallfn ? valcl : cl, cl,
 659                                                     fullpath(&dirent), 0);
 660                                 if (mod & FSFATAL)
 661                                         return FSFATAL;
 662                                 if (vallfn
 663                                     ? (valcl == cl && vallfn != buffer)
 664                                     : p != buffer)
 665                                         if (k & FSDIRMOD)
 666                                                 mod |= THISMOD;
 667                         }
 668
 669                         vallfn = NULL; /* not used any longer */
 670                         invlfn = NULL;
 671
 672                         if (dirent.size == 0 && !(dirent.flags & ATTR_DIRECTORY)) {
 673                                 if (dirent.head != 0) {
 674                                         pwarn("%s has clusters, but size 0\n",
 675                                               fullpath(&dirent));
 676                                         if (ask(1, "Drop allocated clusters")) {
 677                                                 p[26] = p[27] = 0;
 678                                                 if (boot->ClustMask == CLUST32_MASK)
 679                                                         p[20] = p[21] = 0;
 680                                                 clearchain(boot, fat, dirent.head);
 681                                                 dirent.head = 0;
 682                                                 mod |= THISMOD|FSDIRMOD|FSFATMOD;
 683                                         } else
 684                                                 mod |= FSERROR;
 685                                 }
 686                         } else if (dirent.head == 0
 687                                    && !strcmp(dirent.name, "..")
 688                                    && dir->parent                       /* XXX */
 689                                    && !dir->parent->parent) {
 690                                 /*
 691                                  *  Do nothing, the parent is the root
 692                                  */
 693                         } else if (dirent.head < CLUST_FIRST
 694                                    || dirent.head >= boot->NumClusters
 695                                    || fat[dirent.head].next == CLUST_FREE
 696                                    || (fat[dirent.head].next >= CLUST_RSRVD
 697                                        && fat[dirent.head].next < CLUST_EOFS)
 698                                    || fat[dirent.head].head != dirent.head) {
 699                                 if (dirent.head == 0)
 700                                         pwarn("%s has no clusters\n",
 701                                               fullpath(&dirent));
 702                                 else if (dirent.head < CLUST_FIRST
 703                                          || dirent.head >= boot->NumClusters)
 704                                         pwarn("%s starts with cluster out of range(%u)\n",
 705                                               fullpath(&dirent),
 706                                               dirent.head);
 707                                 else if (fat[dirent.head].next == CLUST_FREE)
 708                                         pwarn("%s starts with free cluster\n",
 709                                               fullpath(&dirent));
 710                                 else if (fat[dirent.head].next >= CLUST_RSRVD)
 711                                         pwarn("%s starts with cluster marked %s\n",
 712                                               fullpath(&dirent),
 713                                               rsrvdcltype(fat[dirent.head].next));
 714                                 else
 715                                         pwarn("%s doesn't start a cluster chain\n",
 716                                               fullpath(&dirent));
 717                                 if (dirent.flags & ATTR_DIRECTORY) {
 718                                         if (ask(0, "Remove")) {
 719                                                 *p = SLOT_DELETED;
 720                                                 mod |= THISMOD|FSDIRMOD;
 721                                         } else
 722                                                 mod |= FSERROR;
 723                                         continue;
 724                                 } else {
 725                                         if (ask(1, "Truncate")) {
 726                                                 p[28] = p[29] = p[30] = p[31] = 0;
 727                                                 p[26] = p[27] = 0;
 728                                                 if (boot->ClustMask == CLUST32_MASK)
 729                                                         p[20] = p[21] = 0;
 730                                                 dirent.size = 0;
 731                                                 mod |= THISMOD|FSDIRMOD;
 732                                         } else
 733                                                 mod |= FSERROR;
 734                                 }
 735                         }
 736
 737                         if (dirent.head >= CLUST_FIRST && dirent.head < boot->NumClusters)
 738                                 fat[dirent.head].flags |= FAT_USED;
 739
 740                         if (dirent.flags & ATTR_DIRECTORY) {
 741                                 /*
 742                                  * gather more info for directories
 743                                  */
 744                                 struct dirTodoNode *n;
 745
 746                                 if (dirent.size) {
 747                                         pwarn("Directory %s has size != 0\n",
 748                                               fullpath(&dirent));
 749                                         if (ask(1, "Correct")) {
 750                                                 p[28] = p[29] = p[30] = p[31] = 0;
 751                                                 dirent.size = 0;
 752                                                 mod |= THISMOD|FSDIRMOD;
 753                                         } else
 754                                                 mod |= FSERROR;
 755                                 }
 756                                 /*
 757                                  * handle `.' and `..' specially
 758                                  */
 759                                 if (strcmp(dirent.name, ".") == 0) {
 760                                         if (dirent.head != dir->head) {
 761                                                 pwarn("`.' entry in %s has incorrect start cluster\n",
 762                                                       fullpath(dir));
 763                                                 if (ask(1, "Correct")) {
 764                                                         dirent.head = dir->head;
 765                                                         p[26] = (u_char)dirent.head;
 766                                                         p[27] = (u_char)(dirent.head >> 8);
 767                                                         if (boot->ClustMask == CLUST32_MASK) {
 768                                                                 p[20] = (u_char)(dirent.head >> 16);
 769                                                                 p[21] = (u_char)(dirent.head >> 24);
 770                                                         }
 771                                                         mod |= THISMOD|FSDIRMOD;
 772                                                 } else
 773                                                         mod |= FSERROR;
 774                                         }
 775                                         continue;
 776                                 }
 777                                 if (strcmp(dirent.name, "..") == 0) {
 778                                         if (dir->parent) {              /* XXX */
 779                                                 if (!dir->parent->parent) {
 780                                                         if (dirent.head) {
 781                                                                 pwarn("`..' entry in %s has non-zero start cluster\n",
 782                                                                       fullpath(dir));
 783                                                                 if (ask(1, "Correct")) {
 784                                                                         dirent.head = 0;
 785                                                                         p[26] = p[27] = 0;
 786                                                                         if (boot->ClustMask == CLUST32_MASK)
 787                                                                                 p[20] = p[21] = 0;
 788                                                                         mod |= THISMOD|FSDIRMOD;
 789                                                                 } else
 790                                                                         mod |= FSERROR;
 791                                                         }
 792                                                 } else if (dirent.head != dir->parent->head) {
 793                                                         pwarn("`..' entry in %s has incorrect start cluster\n",
 794                                                               fullpath(dir));
 795                                                         if (ask(1, "Correct")) {
 796                                                                 dirent.head = dir->parent->head;
 797                                                                 p[26] = (u_char)dirent.head;
 798                                                                 p[27] = (u_char)(dirent.head >> 8);
 799                                                                 if (boot->ClustMask == CLUST32_MASK) {
 800                                                                         p[20] = (u_char)(dirent.head >> 16);
 801                                                                         p[21] = (u_char)(dirent.head >> 24);
 802                                                                 }
 803                                                                 mod |= THISMOD|FSDIRMOD;
 804                                                         } else
 805                                                                 mod |= FSERROR;
 806                                                 }
 807                                         }
 808                                         continue;
 809                                 }
 810
 811                                 /* create directory tree node */
 812                                 if (!(d = newDosDirEntry())) {
 813                                         perror("No space for directory");
 814                                         return FSFATAL;
 815                                 }
 816                                 memcpy(d, &dirent, sizeof(struct dosDirEntry));
 817                                 /* link it into the tree */
 818                                 dir->child = d;
 819
 820                                 /* Enter this directory into the todo list */
 821                                 if (!(n = newDirTodo())) {
 822                                         perror("No space for todo list");
 823                                         return FSFATAL;
 824                                 }
 825                                 n->next = pendingDirectories;
 826                                 n->dir = d;
 827                                 pendingDirectories = n;
 828                         } else {
 829                                 mod |= k = checksize(boot, fat, p, &dirent);
 830                                 if (k & FSDIRMOD)
 831                                         mod |= THISMOD;
 832                         }
 833                         boot->NumFiles++;
 834                 }
 835                 if (mod & THISMOD) {
 836                         last *= 32;
 837                         if (lseek(f, off, SEEK_SET) != off
 838                             || write(f, buffer, last) != last) {
 839                                 perror("Unable to write directory");
 840                                 return FSFATAL;
 841                         }
 842                         mod &= ~THISMOD;
 843                 }
 844         } while ((cl = fat[cl].next) >= CLUST_FIRST && cl < boot->NumClusters);
 845         if (invlfn || vallfn)
 846                 mod |= removede(f, boot, fat,
 847                                 invlfn ? invlfn : vallfn, p,
 848                                 invlfn ? invcl : valcl, -1, 0,
 849                                 fullpath(dir), 1);
 850         return mod & ~THISMOD;
 851 }
 852
 853 int
 854 handleDirTree(int dosfs, struct bootblock *boot, struct fatEntry *fat)
 855 {
 856         int mod;
 857
 858         mod = readDosDirSection(dosfs, boot, fat, rootDir);
 859         if (mod & FSFATAL)
 860                 return FSFATAL;
 861
 862         /*
 863          * process the directory todo list
 864          */
 865         while (pendingDirectories) {
 866                 struct dosDirEntry *dir = pendingDirectories->dir;
 867                 struct dirTodoNode *n = pendingDirectories->next;
 868
 869                 /*
 870                  * remove TODO entry now, the list might change during
 871                  * directory reads
 872                  */
 873                 freeDirTodo(pendingDirectories);
 874                 pendingDirectories = n;
 875
 876                 /*
 877                  * handle subdirectory
 878                  */
 879                 mod |= readDosDirSection(dosfs, boot, fat, dir);
 880                 if (mod & FSFATAL)
 881                         return FSFATAL;
 882         }
 883
 884         return mod;
 885 }
 886
 887 /*
 888  * Try to reconnect a FAT chain into dir
 889  */
 890 static u_char *lfbuf;
 891 static cl_t lfcl;
 892 static off_t lfoff;
 893
 894 int
 895 reconnect(int dosfs, struct bootblock *boot, struct fatEntry *fat, cl_t head)
 896 {
 897         struct dosDirEntry d;
 898         u_char *p;
 899
 900         if (!ask(1, "Reconnect"))
 901                 return FSERROR;
 902
 903         if (!lostDir) {
 904                 for (lostDir = rootDir->child; lostDir; lostDir = lostDir->next) {
 905                         if (!strcmp(lostDir->name, LOSTDIR))
 906                                 break;
 907                 }
 908                 if (!lostDir) {         /* Create LOSTDIR?              XXX */
 909                         pwarn("No %s directory\n", LOSTDIR);
 910                         return FSERROR;
 911                 }
 912         }
 913         if (!lfbuf) {
 914                 lfbuf = malloc(boot->ClusterSize);
 915                 if (!lfbuf) {
 916                         perror("No space for buffer");
 917                         return FSFATAL;
 918                 }
 919                 p = NULL;
 920         } else
 921                 p = lfbuf;
 922         while (1) {
 923                 if (p)
 924                         for (; p < lfbuf + boot->ClusterSize; p += 32)
 925                                 if (*p == SLOT_EMPTY
 926                                     || *p == SLOT_DELETED)
 927                                         break;
 928                 if (p && p < lfbuf + boot->ClusterSize)
 929                         break;
 930                 lfcl = p ? fat[lfcl].next : lostDir->head;
 931                 if (lfcl < CLUST_FIRST || lfcl >= boot->NumClusters) {
 932                         /* Extend LOSTDIR?                              XXX */
 933                         pwarn("No space in %s\n", LOSTDIR);
 934                         return FSERROR;
 935                 }
 936                 lfoff = lfcl * boot->ClusterSize
 937                     + boot->ClusterOffset * boot->BytesPerSec;
 938                 if (lseek(dosfs, lfoff, SEEK_SET) != lfoff
 939                     || read(dosfs, lfbuf, boot->ClusterSize) != boot->ClusterSize) {
 940                         perror("could not read LOST.DIR");
 941                         return FSFATAL;
 942                 }
 943                 p = lfbuf;
 944         }
 945
 946         boot->NumFiles++;
 947         /* Ensure uniqueness of entry here!                             XXX */
 948         memset(&d, 0, sizeof d);
 949         snprintf(d.name, sizeof(d.name), "%u", head);
 950         d.flags = 0;
 951         d.head = head;
 952         d.size = fat[head].length * boot->ClusterSize;
 953
 954         memset(p, 0, 32);
 955         memset(p, ' ', 11);
 956         memcpy(p, d.name, strlen(d.name));
 957         p[26] = (u_char)d.head;
 958         p[27] = (u_char)(d.head >> 8);
 959         if (boot->ClustMask == CLUST32_MASK) {
 960                 p[20] = (u_char)(d.head >> 16);
 961                 p[21] = (u_char)(d.head >> 24);
 962         }
 963         p[28] = (u_char)d.size;
 964         p[29] = (u_char)(d.size >> 8);
 965         p[30] = (u_char)(d.size >> 16);
 966         p[31] = (u_char)(d.size >> 24);
 967         fat[head].flags |= FAT_USED;
 968         if (lseek(dosfs, lfoff, SEEK_SET) != lfoff
 969             || write(dosfs, lfbuf, boot->ClusterSize) != boot->ClusterSize) {
 970                 perror("could not write LOST.DIR");
 971                 return FSFATAL;
 972         }
 973         return FSDIRMOD;
 974 }
 975
 976 void
 977 finishlf(void)
 978 {
 979         if (lfbuf)
 980                 free(lfbuf);
 981         lfbuf = NULL;
 982 }