sbin/fsck_msdosfs/fat.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (C) 1995, 1996, 1997 Wolfgang Solfrank
   5  * Copyright (c) 1995 Martin Husemann
   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  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28
  29 #include <sys/cdefs.h>
  30 #ifndef lint
  31 __RCSID("$NetBSD: fat.c,v 1.18 2006/06/05 16:51:18 christos Exp $");
  32 static const char rcsid[] =
  33   "$FreeBSD$";
  34 #endif /* not lint */
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include <stdio.h>
  40 #include <unistd.h>
  41
  42 #include "ext.h"
  43 #include "fsutil.h"
  44
  45 static int checkclnum(struct bootblock *, u_int, cl_t, cl_t *);
  46 static int clustdiffer(cl_t, cl_t *, cl_t *, u_int);
  47 static int tryclear(struct bootblock *, struct fatEntry *, cl_t, cl_t *);
  48 static int _readfat(int, struct bootblock *, u_int, u_char **);
  49
  50 /*-
  51  * The first 2 FAT entries contain pseudo-cluster numbers with the following
  52  * layout:
  53  *
  54  * 31...... ........ ........ .......0
  55  * rrrr1111 11111111 11111111 mmmmmmmm         FAT32 entry 0
  56  * rrrrsh11 11111111 11111111 11111xxx         FAT32 entry 1
  57  *
  58  *                   11111111 mmmmmmmm         FAT16 entry 0
  59  *                   sh111111 11111xxx         FAT16 entry 1
  60  *
  61  * r = reserved
  62  * m = BPB media ID byte
  63  * s = clean flag (1 = dismounted; 0 = still mounted)
  64  * h = hard error flag (1 = ok; 0 = I/O error)
  65  * x = any value ok
  66  */
  67
  68 int
  69 checkdirty(int fs, struct bootblock *boot)
  70 {
  71         off_t off;
  72         u_char *buffer;
  73         int ret = 0;
  74         size_t len;
  75
  76         if (boot->ClustMask != CLUST16_MASK && boot->ClustMask != CLUST32_MASK)
  77                 return 0;
  78
  79         off = boot->bpbResSectors;
  80         off *= boot->bpbBytesPerSec;
  81
  82         buffer = malloc(len = boot->bpbBytesPerSec);
  83         if (buffer == NULL) {
  84                 perr("No space for FAT sectors (%zu)", len);
  85                 return 1;
  86         }
  87
  88         if (lseek(fs, off, SEEK_SET) != off) {
  89                 perr("Unable to read FAT");
  90                 goto err;
  91         }
  92
  93         if ((size_t)read(fs, buffer, boot->bpbBytesPerSec) !=
  94             boot->bpbBytesPerSec) {
  95                 perr("Unable to read FAT");
  96                 goto err;
  97         }
  98
  99         /*
 100          * If we don't understand the FAT, then the file system must be
 101          * assumed to be unclean.
 102          */
 103         if (buffer[0] != boot->bpbMedia || buffer[1] != 0xff)
 104                 goto err;
 105         if (boot->ClustMask == CLUST16_MASK) {
 106                 if ((buffer[2] & 0xf8) != 0xf8 || (buffer[3] & 0x3f) != 0x3f)
 107                         goto err;
 108         } else {
 109                 if (buffer[2] != 0xff || (buffer[3] & 0x0f) != 0x0f
 110                     || (buffer[4] & 0xf8) != 0xf8 || buffer[5] != 0xff
 111                     || buffer[6] != 0xff || (buffer[7] & 0x03) != 0x03)
 112                         goto err;
 113         }
 114
 115         /*
 116          * Now check the actual clean flag (and the no-error flag).
 117          */
 118         if (boot->ClustMask == CLUST16_MASK) {
 119                 if ((buffer[3] & 0xc0) == 0xc0)
 120                         ret = 1;
 121         } else {
 122                 if ((buffer[7] & 0x0c) == 0x0c)
 123                         ret = 1;
 124         }
 125
 126 err:
 127         free(buffer);
 128         return ret;
 129 }
 130
 131 /*
 132  * Check a cluster number for valid value
 133  */
 134 static int
 135 checkclnum(struct bootblock *boot, u_int fat, cl_t cl, cl_t *next)
 136 {
 137         if (*next >= (CLUST_RSRVD&boot->ClustMask))
 138                 *next |= ~boot->ClustMask;
 139         if (*next == CLUST_FREE) {
 140                 boot->NumFree++;
 141                 return FSOK;
 142         }
 143         if (*next == CLUST_BAD) {
 144                 boot->NumBad++;
 145                 return FSOK;
 146         }
 147         if (*next < CLUST_FIRST
 148             || (*next >= boot->NumClusters && *next < CLUST_EOFS)) {
 149                 pwarn("Cluster %u in FAT %d continues with %s cluster number %u\n",
 150                       cl, fat,
 151                       *next < CLUST_RSRVD ? "out of range" : "reserved",
 152                       *next&boot->ClustMask);
 153                 if (ask(0, "Truncate")) {
 154                         *next = CLUST_EOF;
 155                         return FSFATMOD;
 156                 }
 157                 return FSERROR;
 158         }
 159         return FSOK;
 160 }
 161
 162 /*
 163  * Read a FAT from disk. Returns 1 if successful, 0 otherwise.
 164  */
 165 static int
 166 _readfat(int fs, struct bootblock *boot, u_int no, u_char **buffer)
 167 {
 168         off_t off;
 169         size_t len;
 170
 171         *buffer = malloc(len = boot->FATsecs * boot->bpbBytesPerSec);
 172         if (*buffer == NULL) {
 173                 perr("No space for FAT sectors (%zu)", len);
 174                 return 0;
 175         }
 176
 177         off = boot->bpbResSectors + no * boot->FATsecs;
 178         off *= boot->bpbBytesPerSec;
 179
 180         if (lseek(fs, off, SEEK_SET) != off) {
 181                 perr("Unable to read FAT");
 182                 goto err;
 183         }
 184
 185         if ((size_t)read(fs, *buffer, boot->FATsecs * boot->bpbBytesPerSec)
 186             != boot->FATsecs * boot->bpbBytesPerSec) {
 187                 perr("Unable to read FAT");
 188                 goto err;
 189         }
 190
 191         return 1;
 192
 193     err:
 194         free(*buffer);
 195         return 0;
 196 }
 197
 198 /*
 199  * Read a FAT and decode it into internal format
 200  */
 201 int
 202 readfat(int fs, struct bootblock *boot, u_int no, struct fatEntry **fp)
 203 {
 204         struct fatEntry *fat;
 205         u_char *buffer, *p;
 206         cl_t cl;
 207         int ret = FSOK;
 208         size_t len;
 209
 210         boot->NumFree = boot->NumBad = 0;
 211
 212         if (!_readfat(fs, boot, no, &buffer))
 213                 return FSFATAL;
 214
 215         fat = malloc(len = boot->NumClusters * sizeof(struct fatEntry));
 216         if (fat == NULL) {
 217                 perr("No space for FAT clusters (%zu)", len);
 218                 free(buffer);
 219                 return FSFATAL;
 220         }
 221         (void)memset(fat, 0, len);
 222
 223         if (buffer[0] != boot->bpbMedia
 224             || buffer[1] != 0xff || buffer[2] != 0xff
 225             || (boot->ClustMask == CLUST16_MASK && buffer[3] != 0xff)
 226             || (boot->ClustMask == CLUST32_MASK
 227                 && ((buffer[3]&0x0f) != 0x0f
 228                     || buffer[4] != 0xff || buffer[5] != 0xff
 229                     || buffer[6] != 0xff || (buffer[7]&0x0f) != 0x0f))) {
 230
 231                 /* Windows 95 OSR2 (and possibly any later) changes
 232                  * the FAT signature to 0xXXffff7f for FAT16 and to
 233                  * 0xXXffff0fffffff07 for FAT32 upon boot, to know that the
 234                  * file system is dirty if it doesn't reboot cleanly.
 235                  * Check this special condition before errorring out.
 236                  */
 237                 if (buffer[0] == boot->bpbMedia && buffer[1] == 0xff
 238                     && buffer[2] == 0xff
 239                     && ((boot->ClustMask == CLUST16_MASK && buffer[3] == 0x7f)
 240                         || (boot->ClustMask == CLUST32_MASK
 241                             && buffer[3] == 0x0f && buffer[4] == 0xff
 242                             && buffer[5] == 0xff && buffer[6] == 0xff
 243                             && buffer[7] == 0x07)))
 244                         ret |= FSDIRTY;
 245                 else {
 246                         /* just some odd byte sequence in FAT */
 247
 248                         switch (boot->ClustMask) {
 249                         case CLUST32_MASK:
 250                                 pwarn("%s (%02x%02x%02x%02x%02x%02x%02x%02x)\n",
 251                                       "FAT starts with odd byte sequence",
 252                                       buffer[0], buffer[1], buffer[2], buffer[3],
 253                                       buffer[4], buffer[5], buffer[6], buffer[7]);
 254                                 break;
 255                         case CLUST16_MASK:
 256                                 pwarn("%s (%02x%02x%02x%02x)\n",
 257                                     "FAT starts with odd byte sequence",
 258                                     buffer[0], buffer[1], buffer[2], buffer[3]);
 259                                 break;
 260                         default:
 261                                 pwarn("%s (%02x%02x%02x)\n",
 262                                     "FAT starts with odd byte sequence",
 263                                     buffer[0], buffer[1], buffer[2]);
 264                                 break;
 265                         }
 266
 267
 268                         if (ask(1, "Correct"))
 269                                 ret |= FSFIXFAT;
 270                 }
 271         }
 272         switch (boot->ClustMask) {
 273         case CLUST32_MASK:
 274                 p = buffer + 8;
 275                 break;
 276         case CLUST16_MASK:
 277                 p = buffer + 4;
 278                 break;
 279         default:
 280                 p = buffer + 3;
 281                 break;
 282         }
 283         for (cl = CLUST_FIRST; cl < boot->NumClusters;) {
 284                 switch (boot->ClustMask) {
 285                 case CLUST32_MASK:
 286                         fat[cl].next = p[0] + (p[1] << 8)
 287                                        + (p[2] << 16) + (p[3] << 24);
 288                         fat[cl].next &= boot->ClustMask;
 289                         ret |= checkclnum(boot, no, cl, &fat[cl].next);
 290                         cl++;
 291                         p += 4;
 292                         break;
 293                 case CLUST16_MASK:
 294                         fat[cl].next = p[0] + (p[1] << 8);
 295                         ret |= checkclnum(boot, no, cl, &fat[cl].next);
 296                         cl++;
 297                         p += 2;
 298                         break;
 299                 default:
 300                         fat[cl].next = (p[0] + (p[1] << 8)) & 0x0fff;
 301                         ret |= checkclnum(boot, no, cl, &fat[cl].next);
 302                         cl++;
 303                         if (cl >= boot->NumClusters)
 304                                 break;
 305                         fat[cl].next = ((p[1] >> 4) + (p[2] << 4)) & 0x0fff;
 306                         ret |= checkclnum(boot, no, cl, &fat[cl].next);
 307                         cl++;
 308                         p += 3;
 309                         break;
 310                 }
 311         }
 312
 313         free(buffer);
 314         if (ret & FSFATAL) {
 315                 free(fat);
 316                 *fp = NULL;
 317         } else
 318                 *fp = fat;
 319         return ret;
 320 }
 321
 322 /*
 323  * Get type of reserved cluster
 324  */
 325 const char *
 326 rsrvdcltype(cl_t cl)
 327 {
 328         if (cl == CLUST_FREE)
 329                 return "free";
 330         if (cl < CLUST_BAD)
 331                 return "reserved";
 332         if (cl > CLUST_BAD)
 333                 return "as EOF";
 334         return "bad";
 335 }
 336
 337 static int
 338 clustdiffer(cl_t cl, cl_t *cp1, cl_t *cp2, u_int fatnum)
 339 {
 340         if (*cp1 == CLUST_FREE || *cp1 >= CLUST_RSRVD) {
 341                 if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
 342                         if ((*cp1 != CLUST_FREE && *cp1 < CLUST_BAD
 343                              && *cp2 != CLUST_FREE && *cp2 < CLUST_BAD)
 344                             || (*cp1 > CLUST_BAD && *cp2 > CLUST_BAD)) {
 345                                 pwarn("Cluster %u is marked %s with different indicators\n",
 346                                       cl, rsrvdcltype(*cp1));
 347                                 if (ask(1, "Fix")) {
 348                                         *cp2 = *cp1;
 349                                         return FSFATMOD;
 350                                 }
 351                                 return FSFATAL;
 352                         }
 353                         pwarn("Cluster %u is marked %s in FAT 0, %s in FAT %u\n",
 354                               cl, rsrvdcltype(*cp1), rsrvdcltype(*cp2), fatnum);
 355                         if (ask(0, "Use FAT 0's entry")) {
 356                                 *cp2 = *cp1;
 357                                 return FSFATMOD;
 358                         }
 359                         if (ask(0, "Use FAT %u's entry", fatnum)) {
 360                                 *cp1 = *cp2;
 361                                 return FSFATMOD;
 362                         }
 363                         return FSFATAL;
 364                 }
 365                 pwarn("Cluster %u is marked %s in FAT 0, but continues with cluster %u in FAT %d\n",
 366                       cl, rsrvdcltype(*cp1), *cp2, fatnum);
 367                 if (ask(0, "Use continuation from FAT %u", fatnum)) {
 368                         *cp1 = *cp2;
 369                         return FSFATMOD;
 370                 }
 371                 if (ask(0, "Use mark from FAT 0")) {
 372                         *cp2 = *cp1;
 373                         return FSFATMOD;
 374                 }
 375                 return FSFATAL;
 376         }
 377         if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
 378                 pwarn("Cluster %u continues with cluster %u in FAT 0, but is marked %s in FAT %u\n",
 379                       cl, *cp1, rsrvdcltype(*cp2), fatnum);
 380                 if (ask(0, "Use continuation from FAT 0")) {
 381                         *cp2 = *cp1;
 382                         return FSFATMOD;
 383                 }
 384                 if (ask(0, "Use mark from FAT %d", fatnum)) {
 385                         *cp1 = *cp2;
 386                         return FSFATMOD;
 387                 }
 388                 return FSERROR;
 389         }
 390         pwarn("Cluster %u continues with cluster %u in FAT 0, but with cluster %u in FAT %u\n",
 391               cl, *cp1, *cp2, fatnum);
 392         if (ask(0, "Use continuation from FAT 0")) {
 393                 *cp2 = *cp1;
 394                 return FSFATMOD;
 395         }
 396         if (ask(0, "Use continuation from FAT %u", fatnum)) {
 397                 *cp1 = *cp2;
 398                 return FSFATMOD;
 399         }
 400         return FSERROR;
 401 }
 402
 403 /*
 404  * Compare two FAT copies in memory. Resolve any conflicts and merge them
 405  * into the first one.
 406  */
 407 int
 408 comparefat(struct bootblock *boot, struct fatEntry *first,
 409     struct fatEntry *second, u_int fatnum)
 410 {
 411         cl_t cl;
 412         int ret = FSOK;
 413
 414         for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++)
 415                 if (first[cl].next != second[cl].next)
 416                         ret |= clustdiffer(cl, &first[cl].next, &second[cl].next, fatnum);
 417         return ret;
 418 }
 419
 420 void
 421 clearchain(struct bootblock *boot, struct fatEntry *fat, cl_t head)
 422 {
 423         cl_t p, q;
 424
 425         for (p = head; p >= CLUST_FIRST && p < boot->NumClusters; p = q) {
 426                 if (fat[p].head != head)
 427                         break;
 428                 q = fat[p].next;
 429                 fat[p].next = fat[p].head = CLUST_FREE;
 430                 fat[p].length = 0;
 431         }
 432 }
 433
 434 int
 435 tryclear(struct bootblock *boot, struct fatEntry *fat, cl_t head, cl_t *truncp)
 436 {
 437         if (ask(0, "Clear chain starting at %u", head)) {
 438                 clearchain(boot, fat, head);
 439                 return FSFATMOD;
 440         } else if (ask(0, "Truncate")) {
 441                 uint32_t len;
 442                 cl_t p;
 443
 444                 for (p = head, len = 0;
 445                     p >= CLUST_FIRST && p < boot->NumClusters;
 446                     p = fat[p].next, len++)
 447                         continue;
 448                 *truncp = CLUST_EOF;
 449                 fat[head].length = len;
 450                 return FSFATMOD;
 451         } else
 452                 return FSERROR;
 453 }
 454
 455 /*
 456  * Check a complete FAT in-memory for crosslinks
 457  */
 458 int
 459 checkfat(struct bootblock *boot, struct fatEntry *fat)
 460 {
 461         cl_t head, p, h, n;
 462         u_int len;
 463         int ret = 0;
 464         int conf;
 465
 466         /*
 467          * pass 1: figure out the cluster chains.
 468          */
 469         for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
 470                 /* find next untravelled chain */
 471                 if (fat[head].head != 0         /* cluster already belongs to some chain */
 472                     || fat[head].next == CLUST_FREE
 473                     || fat[head].next == CLUST_BAD)
 474                         continue;               /* skip it. */
 475
 476                 /* follow the chain and mark all clusters on the way */
 477                 for (len = 0, p = head;
 478                      p >= CLUST_FIRST && p < boot->NumClusters &&
 479                      fat[p].head != head;
 480                      p = fat[p].next) {
 481                         fat[p].head = head;
 482                         len++;
 483                 }
 484
 485                 /* the head record gets the length */
 486                 fat[head].length = fat[head].next == CLUST_FREE ? 0 : len;
 487         }
 488
 489         /*
 490          * pass 2: check for crosslinked chains (we couldn't do this in pass 1 because
 491          * we didn't know the real start of the chain then - would have treated partial
 492          * chains as interlinked with their main chain)
 493          */
 494         for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
 495                 /* find next untravelled chain */
 496                 if (fat[head].head != head)
 497                         continue;
 498
 499                 /* follow the chain to its end (hopefully) */
 500                 for (len = fat[head].length, p = head;
 501                      (n = fat[p].next) >= CLUST_FIRST && n < boot->NumClusters;
 502                      p = n)
 503                         if (fat[n].head != head || len-- < 2)
 504                                 break;
 505                 if (n >= CLUST_EOFS)
 506                         continue;
 507
 508                 if (n == CLUST_FREE || n >= CLUST_RSRVD) {
 509                         pwarn("Cluster chain starting at %u ends with cluster marked %s\n",
 510                               head, rsrvdcltype(n));
 511 clear:
 512                         ret |= tryclear(boot, fat, head, &fat[p].next);
 513                         continue;
 514                 }
 515                 if (n < CLUST_FIRST || n >= boot->NumClusters) {
 516                         pwarn("Cluster chain starting at %u ends with cluster out of range (%u)\n",
 517                             head, n);
 518                         goto clear;
 519                 }
 520                 if (head == fat[n].head) {
 521                         pwarn("Cluster chain starting at %u loops at cluster %u\n",
 522
 523                             head, p);
 524                         goto clear;
 525                 }
 526                 pwarn("Cluster chains starting at %u and %u are linked at cluster %u\n",
 527                       head, fat[n].head, n);
 528                 conf = tryclear(boot, fat, head, &fat[p].next);
 529                 if (ask(0, "Clear chain starting at %u", h = fat[n].head)) {
 530                         if (conf == FSERROR) {
 531                                 /*
 532                                  * Transfer the common chain to the one not cleared above.
 533                                  */
 534                                 for (p = n;
 535                                      p >= CLUST_FIRST && p < boot->NumClusters;
 536                                      p = fat[p].next) {
 537                                         if (h != fat[p].head) {
 538                                                 /*
 539                                                  * Have to reexamine this chain.
 540                                                  */
 541                                                 head--;
 542                                                 break;
 543                                         }
 544                                         fat[p].head = head;
 545                                 }
 546                         }
 547                         clearchain(boot, fat, h);
 548                         conf |= FSFATMOD;
 549                 }
 550                 ret |= conf;
 551         }
 552
 553         return ret;
 554 }
 555
 556 /*
 557  * Write out FATs encoding them from the internal format
 558  */
 559 int
 560 writefat(int fs, struct bootblock *boot, struct fatEntry *fat, int correct_fat)
 561 {
 562         u_char *buffer, *p;
 563         cl_t cl;
 564         u_int i;
 565         size_t fatsz;
 566         off_t off;
 567         int ret = FSOK;
 568
 569         buffer = malloc(fatsz = boot->FATsecs * boot->bpbBytesPerSec);
 570         if (buffer == NULL) {
 571                 perr("No space for FAT sectors (%zu)", fatsz);
 572                 return FSFATAL;
 573         }
 574         memset(buffer, 0, fatsz);
 575         boot->NumFree = 0;
 576         p = buffer;
 577         if (correct_fat) {
 578                 *p++ = (u_char)boot->bpbMedia;
 579                 *p++ = 0xff;
 580                 *p++ = 0xff;
 581                 switch (boot->ClustMask) {
 582                 case CLUST16_MASK:
 583                         *p++ = 0xff;
 584                         break;
 585                 case CLUST32_MASK:
 586                         *p++ = 0x0f;
 587                         *p++ = 0xff;
 588                         *p++ = 0xff;
 589                         *p++ = 0xff;
 590                         *p++ = 0x0f;
 591                         break;
 592                 }
 593         } else {
 594                 /* use same FAT signature as the old FAT has */
 595                 int count;
 596                 u_char *old_fat;
 597
 598                 switch (boot->ClustMask) {
 599                 case CLUST32_MASK:
 600                         count = 8;
 601                         break;
 602                 case CLUST16_MASK:
 603                         count = 4;
 604                         break;
 605                 default:
 606                         count = 3;
 607                         break;
 608                 }
 609
 610                 if (!_readfat(fs, boot, boot->ValidFat >= 0 ? boot->ValidFat :0,
 611                                          &old_fat)) {
 612                         free(buffer);
 613                         return FSFATAL;
 614                 }
 615
 616                 memcpy(p, old_fat, count);
 617                 free(old_fat);
 618                 p += count;
 619         }
 620
 621         for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++) {
 622                 switch (boot->ClustMask) {
 623                 case CLUST32_MASK:
 624                         if (fat[cl].next == CLUST_FREE)
 625                                 boot->NumFree++;
 626                         *p++ = (u_char)fat[cl].next;
 627                         *p++ = (u_char)(fat[cl].next >> 8);
 628                         *p++ = (u_char)(fat[cl].next >> 16);
 629                         *p &= 0xf0;
 630                         *p++ |= (fat[cl].next >> 24)&0x0f;
 631                         break;
 632                 case CLUST16_MASK:
 633                         if (fat[cl].next == CLUST_FREE)
 634                                 boot->NumFree++;
 635                         *p++ = (u_char)fat[cl].next;
 636                         *p++ = (u_char)(fat[cl].next >> 8);
 637                         break;
 638                 default:
 639                         if (fat[cl].next == CLUST_FREE)
 640                                 boot->NumFree++;
 641                         *p++ = (u_char)fat[cl].next;
 642                         *p = (u_char)((fat[cl].next >> 8) & 0xf);
 643                         cl++;
 644                         if (cl >= boot->NumClusters)
 645                                 break;
 646                         if (fat[cl].next == CLUST_FREE)
 647                                 boot->NumFree++;
 648                         *p++ |= (u_char)(fat[cl + 1].next << 4);
 649                         *p++ = (u_char)(fat[cl + 1].next >> 4);
 650                         break;
 651                 }
 652         }
 653         for (i = 0; i < boot->bpbFATs; i++) {
 654                 off = boot->bpbResSectors + i * boot->FATsecs;
 655                 off *= boot->bpbBytesPerSec;
 656                 if (lseek(fs, off, SEEK_SET) != off
 657                     || (size_t)write(fs, buffer, fatsz) != fatsz) {
 658                         perr("Unable to write FAT");
 659                         ret = FSFATAL; /* Return immediately?           XXX */
 660                 }
 661         }
 662         free(buffer);
 663         return ret;
 664 }
 665
 666 /*
 667  * Check a complete in-memory FAT for lost cluster chains
 668  */
 669 int
 670 checklost(int dosfs, struct bootblock *boot, struct fatEntry *fat)
 671 {
 672         cl_t head;
 673         int mod = FSOK;
 674         int ret;
 675
 676         for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
 677                 /* find next untravelled chain */
 678                 if (fat[head].head != head
 679                     || fat[head].next == CLUST_FREE
 680                     || (fat[head].next >= CLUST_RSRVD
 681                         && fat[head].next < CLUST_EOFS)
 682                     || (fat[head].flags & FAT_USED))
 683                         continue;
 684
 685                 pwarn("Lost cluster chain at cluster %u\n%d Cluster(s) lost\n",
 686                       head, fat[head].length);
 687                 mod |= ret = reconnect(dosfs, boot, fat, head);
 688                 if (mod & FSFATAL)
 689                         break;
 690                 if (ret == FSERROR && ask(0, "Clear")) {
 691                         clearchain(boot, fat, head);
 692                         mod |= FSFATMOD;
 693                 }
 694         }
 695         finishlf();
 696
 697         if (boot->bpbFSInfo) {
 698                 ret = 0;
 699                 if (boot->FSFree != 0xffffffffU &&
 700                     boot->FSFree != boot->NumFree) {
 701                         pwarn("Free space in FSInfo block (%u) not correct (%u)\n",
 702                               boot->FSFree, boot->NumFree);
 703                         if (ask(1, "Fix")) {
 704                                 boot->FSFree = boot->NumFree;
 705                                 ret = 1;
 706                         }
 707                 }
 708                 if (boot->FSNext != 0xffffffffU &&
 709                     (boot->FSNext >= boot->NumClusters ||
 710                     (boot->NumFree && fat[boot->FSNext].next != CLUST_FREE))) {
 711                         pwarn("Next free cluster in FSInfo block (%u) %s\n",
 712                               boot->FSNext,
 713                               (boot->FSNext >= boot->NumClusters) ? "invalid" : "not free");
 714                         if (ask(1, "fix"))
 715                                 for (head = CLUST_FIRST; head < boot->NumClusters; head++)
 716                                         if (fat[head].next == CLUST_FREE) {
 717                                                 boot->FSNext = head;
 718                                                 ret = 1;
 719                                                 break;
 720                                         }
 721                 }
 722                 if (ret)
 723                         mod |= writefsinfo(dosfs, boot);
 724         }
 725
 726         return mod;
 727 }