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