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