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 21: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 } 983