Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/fsck_msdos/fat.c	Lines:	0	278	0.0 %
Date:	2016-12-06	Branches:	0	233	0.0 %


/*	$OpenBSD: fat.c,v 1.27 2015/12/10 17:26:59 mmcc Exp $	*/
/*	$NetBSD: fat.c,v 1.8 1997/10/17 11:19:53 ws Exp $	*/

/*
 * Copyright (C) 1995, 1996, 1997 Wolfgang Solfrank
 * Copyright (c) 1995 Martin Husemann
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <unistd.h>

#include "ext.h"

static int checkclnum(struct bootblock *, int, cl_t, cl_t *);
static int clustdiffer(cl_t, cl_t *, cl_t *, int);
static int tryclear(struct bootblock *, struct fatEntry *, cl_t, cl_t *);

/*
 * Check a cluster number for valid value
 */
static int
checkclnum(struct bootblock *boot, int fat, cl_t cl, cl_t *next)
{
	if (*next >= (CLUST_RSRVD&boot->ClustMask))
		*next |= ~boot->ClustMask;
	if (*next == CLUST_FREE) {
		boot->NumFree++;
		return (FSOK);
	}
	if (*next == CLUST_BAD) {
		boot->NumBad++;
		return (FSOK);
	}
	if (*next < CLUST_FIRST
	    || (*next >= boot->NumClusters && *next < CLUST_EOFS)) {
		pwarn("Cluster %u in FAT %d continues with %s cluster number %u\n",
		      cl, fat,
		      *next < CLUST_RSRVD ? "out of range" : "reserved",
		      *next&boot->ClustMask);
		if (ask(0, "Truncate")) {
			*next = CLUST_EOF;
			return (FSFATMOD);
		}
		return (FSERROR);
	}
	return (FSOK);
}

/*
 * Read a FAT and decode it into internal format
 */
int
readfat(int fs, struct bootblock *boot, int no, struct fatEntry **fp)
{
	struct fatEntry *fat;
	u_char *buffer, *p;
	cl_t cl;
	off_t off;
	int ret = FSOK;

	boot->NumFree = boot->NumBad = 0;
	fat = calloc(boot->NumClusters, sizeof(struct fatEntry));
	buffer = calloc(boot->FATsecs, boot->BytesPerSec);
	if (fat == NULL || buffer == NULL) {
		xperror("No space for FAT");
		free(fat);
		free(buffer);
		return (FSFATAL);
	}

	off = boot->ResSectors + no * boot->FATsecs;
	off *= boot->BytesPerSec;

	if (lseek(fs, off, SEEK_SET) != off) {
		xperror("Unable to read FAT");
		free(buffer);
		free(fat);
		return (FSFATAL);
	}

	if (read(fs, buffer, boot->FATsecs * boot->BytesPerSec)
	    != boot->FATsecs * boot->BytesPerSec) {
		xperror("Unable to read FAT");
		free(buffer);
		free(fat);
		return (FSFATAL);
	}

	if (buffer[0] != boot->Media
	    || buffer[1] != 0xff || buffer[2] != 0xff
	    || (boot->ClustMask == CLUST16_MASK && buffer[3] != 0xff)
	    || (boot->ClustMask == CLUST32_MASK
		&& ((buffer[3]&0x0f) != 0x0f
		    || buffer[4] != 0xff || buffer[5] != 0xff
		    || buffer[6] != 0xff || (buffer[7]&0x0f) != 0x0f))) {
		static const char msg[] = "FAT starts with odd byte sequence ";

		switch (boot->ClustMask) {
		case CLUST32_MASK:
			pwarn("%s(%02x%02x%02x%02x%02x%02x%02x%02x)\n", msg,
			    buffer[0], buffer[1], buffer[2], buffer[3],
			    buffer[4], buffer[5], buffer[6], buffer[7]);
			break;
		case CLUST16_MASK:
			pwarn("%s(%02x%02x%02x%02x)\n", msg,
			    buffer[0], buffer[1], buffer[2], buffer[3]);
			break;
		default:
			pwarn("%s(%02x%02x%02x)\n", msg,
			    buffer[0], buffer[1], buffer[2]);
			break;
		}
		if (ask(1, "Correct"))
			ret |= FSFATMOD;
	}
	switch (boot->ClustMask) {
	case CLUST32_MASK:
		p = buffer + 8;
		break;
	case CLUST16_MASK:
		p = buffer + 4;
		break;
	default:
		p = buffer + 3;
		break;
	}
	for (cl = CLUST_FIRST; cl < boot->NumClusters;) {
		switch (boot->ClustMask) {
		case CLUST32_MASK:
			fat[cl].next = p[0] + (p[1] << 8)
				       + (p[2] << 16) + (p[3] << 24);
			fat[cl].next &= boot->ClustMask;
			ret |= checkclnum(boot, no, cl, &fat[cl].next);
			cl++;
			p += 4;
			break;
		case CLUST16_MASK:
			fat[cl].next = p[0] + (p[1] << 8);
			ret |= checkclnum(boot, no, cl, &fat[cl].next);
			cl++;
			p += 2;
			break;
		default:
			fat[cl].next = (p[0] + (p[1] << 8)) & 0x0fff;
			ret |= checkclnum(boot, no, cl, &fat[cl].next);
			cl++;
			if (cl >= boot->NumClusters)
				break;
			fat[cl].next = ((p[1] >> 4) + (p[2] << 4)) & 0x0fff;
			ret |= checkclnum(boot, no, cl, &fat[cl].next);
			cl++;
			p += 3;
			break;
		}
	}

	free(buffer);
	if (ret & FSFATAL) {
		free(fat);
		*fp = NULL;
	} else
		*fp = fat;
	return (ret);
}

/*
 * Get type of reserved cluster
 */
char *
rsrvdcltype(cl_t cl)
{
	if (cl == CLUST_FREE)
		return ("free");
	if (cl < CLUST_BAD)
		return ("reserved");
	if (cl > CLUST_BAD)
		return ("as EOF");
	return ("bad");
}

static int
clustdiffer(cl_t cl, cl_t *cp1, cl_t *cp2, int fatnum)
{
	if (*cp1 == CLUST_FREE || *cp1 >= CLUST_RSRVD) {
		if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
			if ((*cp1 != CLUST_FREE && *cp1 < CLUST_BAD
			     && *cp2 != CLUST_FREE && *cp2 < CLUST_BAD)
			    || (*cp1 > CLUST_BAD && *cp2 > CLUST_BAD)) {
				pwarn("Cluster %u is marked %s with different indicators, ",
				      cl, rsrvdcltype(*cp1));
				if (ask(1, "fix")) {
					*cp2 = *cp1;
					return (FSFATMOD);
				}
				return (FSFATAL);
			}
			pwarn("Cluster %u is marked %s in FAT 0, %s in FAT %d\n",
			      cl, rsrvdcltype(*cp1), rsrvdcltype(*cp2), fatnum);
			if (ask(0, "use FAT 0's entry")) {
				*cp2 = *cp1;
				return (FSFATMOD);
			}
			if (ask(0, "use FAT %d's entry", fatnum)) {
				*cp1 = *cp2;
				return (FSFATMOD);
			}
			return (FSFATAL);
		}
		pwarn("Cluster %u is marked %s in FAT 0, but continues with cluster %u in FAT %d\n",
		      cl, rsrvdcltype(*cp1), *cp2, fatnum);
		if (ask(0, "Use continuation from FAT %d", fatnum)) {
			*cp1 = *cp2;
			return (FSFATMOD);
		}
		if (ask(0, "Use mark from FAT 0")) {
			*cp2 = *cp1;
			return (FSFATMOD);
		}
		return (FSFATAL);
	}
	if (*cp2 == CLUST_FREE || *cp2 >= CLUST_RSRVD) {
		pwarn("Cluster %u continues with cluster %u in FAT 0, but is marked %s in FAT %d\n",
		      cl, *cp1, rsrvdcltype(*cp2), fatnum);
		if (ask(0, "Use continuation from FAT 0")) {
			*cp2 = *cp1;
			return (FSFATMOD);
		}
		if (ask(0, "Use mark from FAT %d", fatnum)) {
			*cp1 = *cp2;
			return (FSFATMOD);
		}
		return (FSERROR);
	}
	pwarn("Cluster %u continues with cluster %u in FAT 0, but with cluster %u in FAT %d\n",
	      cl, *cp1, *cp2, fatnum);
	if (ask(0, "Use continuation from FAT 0")) {
		*cp2 = *cp1;
		return (FSFATMOD);
	}
	if (ask(0, "Use continuation from FAT %d", fatnum)) {
		*cp1 = *cp2;
		return (FSFATMOD);
	}
	return (FSERROR);
}

/*
 * Compare two FAT copies in memory. Resolve any conflicts and merge them
 * into the first one.
 */
int
comparefat(struct bootblock *boot, struct fatEntry *first,
	   struct fatEntry *second, int fatnum)
{
	cl_t cl;
	int ret = FSOK;

	for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++)
		if (first[cl].next != second[cl].next)
			ret |= clustdiffer(cl, &first[cl].next, &second[cl].next, fatnum);
	return (ret);
}

void
clearchain(struct bootblock *boot, struct fatEntry *fat, cl_t head)
{
	cl_t p, q;

	for (p = head; p >= CLUST_FIRST && p < boot->NumClusters; p = q) {
		if (fat[p].head != head)
			break;
		q = fat[p].next;
		fat[p].next = fat[p].head = CLUST_FREE;
		fat[p].length = 0;
	}
}

int
tryclear(struct bootblock *boot, struct fatEntry *fat, cl_t head, cl_t *trunc)
{
	u_int len;
	cl_t p;

	if (ask(0, "Clear chain starting at %u", head)) {
		clearchain(boot, fat, head);
		return FSFATMOD;
	} else if (ask(0, "Truncate")) {
		*trunc = CLUST_EOF;
		len = 0;
		for (p = head; p >= CLUST_FIRST && p < boot->NumClusters;
		    p = fat[p].next) {
			len++;
		}
		fat[head].length = len;
		return FSFATMOD;
	} else
		return FSERROR;
}

/*
 * Check a complete FAT in-memory for crosslinks
 */
int
checkfat(struct bootblock *boot, struct fatEntry *fat)
{
	cl_t head, p, h, n;
	u_int len;
	int ret = 0;
	int conf;

	/*
	 * pass 1: figure out the cluster chains.
	 */
	for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
		/* find next untravelled chain */
		if (fat[head].head != 0		/* cluster already belongs to some chain */
		    || fat[head].next == CLUST_FREE
		    || fat[head].next == CLUST_BAD)
			continue;		/* skip it. */

		/* follow the chain and mark all clusters on the way */
		for (len = 0, p = head;
		     p >= CLUST_FIRST && p < boot->NumClusters &&
		     fat[p].head != head;
		     p = fat[p].next) {
			fat[p].head = head;
			len++;
		}

		/* the head record gets the length */
		fat[head].length = fat[head].next == CLUST_FREE ? 0 : len;
	}

	/*
	 * pass 2: check for crosslinked chains (we couldn't do this in pass 1 because
	 * we didn't know the real start of the chain then - would have treated partial
	 * chains as interlinked with their main chain)
	 */
	for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
		/* find next untravelled chain */
		if (fat[head].head != head)
			continue;

		/* follow the chain to its end (hopefully) */
		for (len = fat[head].length, p = head;
		     (n = fat[p].next) >= CLUST_FIRST && n < boot->NumClusters;
		     p = n) {
			/* len is always off by one due to n assignment */
			if (fat[n].head != head || len-- < 2)
				break;
		}
		if (n >= CLUST_EOFS)
			continue;

		if (n == CLUST_FREE || n >= CLUST_RSRVD) {
			pwarn("Cluster chain starting at %u ends with cluster marked %s\n",
			      head, rsrvdcltype(n));
			ret |= tryclear(boot, fat, head, &fat[p].next);
			continue;
		}
		if (n < CLUST_FIRST || n >= boot->NumClusters) {
			pwarn("Cluster chain starting at %u ends with cluster out of range (%u)\n",
			      head, n);
			ret |= tryclear(boot, fat, head, &fat[p].next);
			continue;
		}
		if (head == fat[n].head) {
			pwarn("Cluster chain starting at %u loops at cluster %u\n",
			      head, p);
			ret |= tryclear(boot, fat, head, &fat[p].next);
			continue;
		}
		pwarn("Cluster chains starting at %u and %u are linked at cluster %u\n",
		      head, fat[n].head, n);
		conf = tryclear(boot, fat, head, &fat[p].next);
		if (ask(0, "Clear chain starting at %u", h = fat[n].head)) {
			if (conf == FSERROR) {
				/*
				 * Transfer the common chain to the one not cleared above.
				 */
				for (p = n;
				     p >= CLUST_FIRST && p < boot->NumClusters;
				     p = fat[p].next) {
					if (h != fat[p].head) {
						/*
						 * Have to reexamine this chain.
						 */
						head--;
						break;
					}
					fat[p].head = head;
				}
			}
			clearchain(boot, fat, h);
			conf |= FSFATMOD;
		}
		ret |= conf;
	}

	return (ret);
}

/*
 * Write out FATs encoding them from the internal format
 */
int
writefat(int fs, struct bootblock *boot, struct fatEntry *fat)
{
	u_char *buffer, *p;
	cl_t cl;
	int i;
	u_int32_t fatsz;
	off_t off;
	int ret = FSOK;

	fatsz = boot->FATsecs * boot->BytesPerSec;
	buffer = calloc(boot->FATsecs, boot->BytesPerSec);
	if (buffer == NULL) {
		xperror("No space for FAT");
		return (FSFATAL);
	}
	(void)memset(buffer, 0, fatsz);
	boot->NumFree = 0;
	p = buffer;
	*p++ = (u_char)boot->Media;
	*p++ = 0xff;
	*p++ = 0xff;
	switch (boot->ClustMask) {
	case CLUST16_MASK:
		*p++ = 0xff;
		break;
	case CLUST32_MASK:
		*p++ = 0x0f;
		*p++ = 0xff;
		*p++ = 0xff;
		*p++ = 0xff;
		*p++ = 0x0f;
		break;
	}
	for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++) {
		switch (boot->ClustMask) {
		case CLUST32_MASK:
			if (fat[cl].next == CLUST_FREE)
				boot->NumFree++;
			*p++ = (u_char)fat[cl].next;
			*p++ = (u_char)(fat[cl].next >> 8);
			*p++ = (u_char)(fat[cl].next >> 16);
			*p &= 0xf0;
			*p++ |= (fat[cl].next >> 24)&0x0f;
			break;
		case CLUST16_MASK:
			if (fat[cl].next == CLUST_FREE)
				boot->NumFree++;
			*p++ = (u_char)fat[cl].next;
			*p++ = (u_char)(fat[cl].next >> 8);
			break;
		default:
			if (fat[cl].next == CLUST_FREE)
				boot->NumFree++;
			*p++ = (u_char)fat[cl].next;
			*p = (u_char)((fat[cl].next >> 8) & 0xf);
			cl++;
			if (cl >= boot->NumClusters)
				break;
			if (fat[cl].next == CLUST_FREE)
				boot->NumFree++;
			*p++ |= (u_char)(fat[cl].next << 4);
			*p++ = (u_char)(fat[cl].next >> 4);
			break;
		}
	}
	for (i = 0; i < boot->FATs; i++) {
		off = boot->ResSectors + i * boot->FATsecs;
		off *= boot->BytesPerSec;
		if (lseek(fs, off, SEEK_SET) != off
		    || write(fs, buffer, fatsz) != fatsz) {
			xperror("Unable to write FAT");
			ret = FSFATAL; /* Return immediately?		XXX */
		}
	}
	free(buffer);
	return (ret);
}

/*
 * Check a complete in-memory FAT for lost cluster chains
 */
int
checklost(int dosfs, struct bootblock *boot, struct fatEntry *fat)
{
	cl_t head;
	int mod = FSOK;
	int ret;

	for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
		/* find next untravelled chain */
		if (fat[head].head != head
		    || fat[head].next == CLUST_FREE
		    || (fat[head].next >= CLUST_RSRVD
			&& fat[head].next < CLUST_EOFS)
		    || (fat[head].flags & FAT_USED))
			continue;

		pwarn("Lost cluster chain at cluster %u\n%d Cluster(s) lost\n",
		      head, fat[head].length);
		mod |= ret = reconnect(dosfs, boot, fat, head);
		if (mod & FSFATAL)
			break;
		if (ret == FSERROR && ask(0, "Clear")) {
			clearchain(boot, fat, head);
			mod |= FSFATMOD;
		}
	}
	finishlf();

	if (boot->FSInfo) {
		ret = 0;
		if (boot->FSFree != 0xffffffff &&
		    boot->FSFree != boot->NumFree) {
			pwarn("Free space in FSInfo block (%u) not correct (%u)\n",
			      boot->FSFree, boot->NumFree);
			if (ask(1, "fix")) {
				boot->FSFree = boot->NumFree;
				ret = 1;
			}
		}
		if (boot->FSNext != 0xffffffff &&
		    boot->NumFree && (boot->FSNext >= boot->NumClusters ||
		    fat[boot->FSNext].next != CLUST_FREE)) {
			pwarn("Next free cluster in FSInfo block (%u) not free\n",
			      boot->FSNext);
			if (ask(1, "fix"))
				for (head = CLUST_FIRST; head < boot->NumClusters; head++)
					if (fat[head].next == CLUST_FREE) {
						boot->FSNext = head;
						ret = 1;
						break;
					}
		}
		if (ret)
			mod |= writefsinfo(dosfs, boot);
	}

	return (mod);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: fat.c,v 1.27 2015/12/10 17:26:59 mmcc Exp $ */
2			/* $NetBSD: fat.c,v 1.8 1997/10/17 11:19:53 ws Exp $ */
3
4			/*
5			* Copyright (C) 1995, 1996, 1997 Wolfgang Solfrank
6			* Copyright (c) 1995 Martin Husemann
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20			* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26			* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27			*/
28
29			#include <stdlib.h>
30			#include <string.h>
31			#include <ctype.h>
32			#include <stdio.h>
33			#include <unistd.h>
34
35			#include "ext.h"
36
37			static int checkclnum(struct bootblock , int, cl_t, cl_t );
38			static int clustdiffer(cl_t, cl_t , cl_t , int);
39			static int tryclear(struct bootblock , struct fatEntry , cl_t, cl_t *);
40
41			/*
42			* Check a cluster number for valid value
43			*/
44			static int
45			checkclnum(struct bootblock boot, int fat, cl_t cl, cl_t next)
46			{
47			if (*next >= (CLUST_RSRVD&boot->ClustMask))
48			*next \|= ~boot->ClustMask;
49			if (*next == CLUST_FREE) {
50			boot->NumFree++;
51			return (FSOK);
52			}
53			if (*next == CLUST_BAD) {
54			boot->NumBad++;
55			return (FSOK);
56			}
57			if (*next < CLUST_FIRST
58			\|\| (next >= boot->NumClusters && next < CLUST_EOFS)) {
59			pwarn("Cluster %u in FAT %d continues with %s cluster number %u\n",
60			cl, fat,
61			*next < CLUST_RSRVD ? "out of range" : "reserved",
62			*next&boot->ClustMask);
63			if (ask(0, "Truncate")) {
64			*next = CLUST_EOF;
65			return (FSFATMOD);
66			}
67			return (FSERROR);
68			}
69			return (FSOK);
70			}
71
72			/*
73			* Read a FAT and decode it into internal format
74			*/
75			int
76			readfat(int fs, struct bootblock boot, int no, struct fatEntry *fp)
77			{
78			struct fatEntry *fat;
79			u_char buffer, p;
80			cl_t cl;
81			off_t off;
82			int ret = FSOK;
83
84			boot->NumFree = boot->NumBad = 0;
85			fat = calloc(boot->NumClusters, sizeof(struct fatEntry));
86			buffer = calloc(boot->FATsecs, boot->BytesPerSec);
87			if (fat == NULL \|\| buffer == NULL) {
88			xperror("No space for FAT");
89			free(fat);
90			free(buffer);
91			return (FSFATAL);
92			}
93
94			off = boot->ResSectors + no * boot->FATsecs;
95			off *= boot->BytesPerSec;
96
97			if (lseek(fs, off, SEEK_SET) != off) {
98			xperror("Unable to read FAT");
99			free(buffer);
100			free(fat);
101			return (FSFATAL);
102			}
103
104			if (read(fs, buffer, boot->FATsecs * boot->BytesPerSec)
105			!= boot->FATsecs * boot->BytesPerSec) {
106			xperror("Unable to read FAT");
107			free(buffer);
108			free(fat);
109			return (FSFATAL);
110			}
111
112			if (buffer[0] != boot->Media
113			\|\| buffer[1] != 0xff \|\| buffer[2] != 0xff
114			\|\| (boot->ClustMask == CLUST16_MASK && buffer[3] != 0xff)
115			\|\| (boot->ClustMask == CLUST32_MASK
116			&& ((buffer[3]&0x0f) != 0x0f
117			\|\| buffer[4] != 0xff \|\| buffer[5] != 0xff
118			\|\| buffer[6] != 0xff \|\| (buffer[7]&0x0f) != 0x0f))) {
119			static const char msg[] = "FAT starts with odd byte sequence ";
120
121			switch (boot->ClustMask) {
122			case CLUST32_MASK:
123			pwarn("%s(%02x%02x%02x%02x%02x%02x%02x%02x)\n", msg,
124			buffer[0], buffer[1], buffer[2], buffer[3],
125			buffer[4], buffer[5], buffer[6], buffer[7]);
126			break;
127			case CLUST16_MASK:
128			pwarn("%s(%02x%02x%02x%02x)\n", msg,
129			buffer[0], buffer[1], buffer[2], buffer[3]);
130			break;
131			default:
132			pwarn("%s(%02x%02x%02x)\n", msg,
133			buffer[0], buffer[1], buffer[2]);
134			break;
135			}
136			if (ask(1, "Correct"))
137			ret \|= FSFATMOD;
138			}
139			switch (boot->ClustMask) {
140			case CLUST32_MASK:
141			p = buffer + 8;
142			break;
143			case CLUST16_MASK:
144			p = buffer + 4;
145			break;
146			default:
147			p = buffer + 3;
148			break;
149			}
150			for (cl = CLUST_FIRST; cl < boot->NumClusters;) {
151			switch (boot->ClustMask) {
152			case CLUST32_MASK:
153			fat[cl].next = p[0] + (p[1] << 8)
154			+ (p[2] << 16) + (p[3] << 24);
155			fat[cl].next &= boot->ClustMask;
156			ret \|= checkclnum(boot, no, cl, &fat[cl].next);
157			cl++;
158			p += 4;
159			break;
160			case CLUST16_MASK:
161			fat[cl].next = p[0] + (p[1] << 8);
162			ret \|= checkclnum(boot, no, cl, &fat[cl].next);
163			cl++;
164			p += 2;
165			break;
166			default:
167			fat[cl].next = (p[0] + (p[1] << 8)) & 0x0fff;
168			ret \|= checkclnum(boot, no, cl, &fat[cl].next);
169			cl++;
170			if (cl >= boot->NumClusters)
171			break;
172			fat[cl].next = ((p[1] >> 4) + (p[2] << 4)) & 0x0fff;
173			ret \|= checkclnum(boot, no, cl, &fat[cl].next);
174			cl++;
175			p += 3;
176			break;
177			}
178			}
179
180			free(buffer);
181			if (ret & FSFATAL) {
182			free(fat);
183			*fp = NULL;
184			} else
185			*fp = fat;
186			return (ret);
187			}
188
189			/*
190			* Get type of reserved cluster
191			*/
192			char *
193			rsrvdcltype(cl_t cl)
194			{
195			if (cl == CLUST_FREE)
196			return ("free");
197			if (cl < CLUST_BAD)
198			return ("reserved");
199			if (cl > CLUST_BAD)
200			return ("as EOF");
201			return ("bad");
202			}
203
204			static int
205			clustdiffer(cl_t cl, cl_t cp1, cl_t cp2, int fatnum)
206			{
207			if (cp1 == CLUST_FREE \|\| cp1 >= CLUST_RSRVD) {
208			if (cp2 == CLUST_FREE \|\| cp2 >= CLUST_RSRVD) {
209			if ((cp1 != CLUST_FREE && cp1 < CLUST_BAD
210			&& cp2 != CLUST_FREE && cp2 < CLUST_BAD)
211			\|\| (cp1 > CLUST_BAD && cp2 > CLUST_BAD)) {
212			pwarn("Cluster %u is marked %s with different indicators, ",
213			cl, rsrvdcltype(*cp1));
214			if (ask(1, "fix")) {
215			cp2 = cp1;
216			return (FSFATMOD);
217			}
218			return (FSFATAL);
219			}
220			pwarn("Cluster %u is marked %s in FAT 0, %s in FAT %d\n",
221			cl, rsrvdcltype(cp1), rsrvdcltype(cp2), fatnum);
222			if (ask(0, "use FAT 0's entry")) {
223			cp2 = cp1;
224			return (FSFATMOD);
225			}
226			if (ask(0, "use FAT %d's entry", fatnum)) {
227			cp1 = cp2;
228			return (FSFATMOD);
229			}
230			return (FSFATAL);
231			}
232			pwarn("Cluster %u is marked %s in FAT 0, but continues with cluster %u in FAT %d\n",
233			cl, rsrvdcltype(cp1), cp2, fatnum);
234			if (ask(0, "Use continuation from FAT %d", fatnum)) {
235			cp1 = cp2;
236			return (FSFATMOD);
237			}
238			if (ask(0, "Use mark from FAT 0")) {
239			cp2 = cp1;
240			return (FSFATMOD);
241			}
242			return (FSFATAL);
243			}
244			if (cp2 == CLUST_FREE \|\| cp2 >= CLUST_RSRVD) {
245			pwarn("Cluster %u continues with cluster %u in FAT 0, but is marked %s in FAT %d\n",
246			cl, cp1, rsrvdcltype(cp2), fatnum);
247			if (ask(0, "Use continuation from FAT 0")) {
248			cp2 = cp1;
249			return (FSFATMOD);
250			}
251			if (ask(0, "Use mark from FAT %d", fatnum)) {
252			cp1 = cp2;
253			return (FSFATMOD);
254			}
255			return (FSERROR);
256			}
257			pwarn("Cluster %u continues with cluster %u in FAT 0, but with cluster %u in FAT %d\n",
258			cl, cp1, cp2, fatnum);
259			if (ask(0, "Use continuation from FAT 0")) {
260			cp2 = cp1;
261			return (FSFATMOD);
262			}
263			if (ask(0, "Use continuation from FAT %d", fatnum)) {
264			cp1 = cp2;
265			return (FSFATMOD);
266			}
267			return (FSERROR);
268			}
269
270			/*
271			* Compare two FAT copies in memory. Resolve any conflicts and merge them
272			* into the first one.
273			*/
274			int
275			comparefat(struct bootblock boot, struct fatEntry first,
276			struct fatEntry *second, int fatnum)
277			{
278			cl_t cl;
279			int ret = FSOK;
280
281			for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++)
282			if (first[cl].next != second[cl].next)
283			ret \|= clustdiffer(cl, &first[cl].next, &second[cl].next, fatnum);
284			return (ret);
285			}
286
287			void
288			clearchain(struct bootblock boot, struct fatEntry fat, cl_t head)
289			{
290			cl_t p, q;
291
292			for (p = head; p >= CLUST_FIRST && p < boot->NumClusters; p = q) {
293			if (fat[p].head != head)
294			break;
295			q = fat[p].next;
296			fat[p].next = fat[p].head = CLUST_FREE;
297			fat[p].length = 0;
298			}
299			}
300
301			int
302			tryclear(struct bootblock boot, struct fatEntry fat, cl_t head, cl_t *trunc)
303			{
304			u_int len;
305			cl_t p;
306
307			if (ask(0, "Clear chain starting at %u", head)) {
308			clearchain(boot, fat, head);
309			return FSFATMOD;
310			} else if (ask(0, "Truncate")) {
311			*trunc = CLUST_EOF;
312			len = 0;
313			for (p = head; p >= CLUST_FIRST && p < boot->NumClusters;
314			p = fat[p].next) {
315			len++;
316			}
317			fat[head].length = len;
318			return FSFATMOD;
319			} else
320			return FSERROR;
321			}
322
323			/*
324			* Check a complete FAT in-memory for crosslinks
325			*/
326			int
327			checkfat(struct bootblock boot, struct fatEntry fat)
328			{
329			cl_t head, p, h, n;
330			u_int len;
331			int ret = 0;
332			int conf;
333
334			/*
335			* pass 1: figure out the cluster chains.
336			*/
337			for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
338			/* find next untravelled chain */
339			if (fat[head].head != 0 /* cluster already belongs to some chain */
340			\|\| fat[head].next == CLUST_FREE
341			\|\| fat[head].next == CLUST_BAD)
342			continue; /* skip it. */
343
344			/* follow the chain and mark all clusters on the way */
345			for (len = 0, p = head;
346			p >= CLUST_FIRST && p < boot->NumClusters &&
347			fat[p].head != head;
348			p = fat[p].next) {
349			fat[p].head = head;
350			len++;
351			}
352
353			/* the head record gets the length */
354			fat[head].length = fat[head].next == CLUST_FREE ? 0 : len;
355			}
356
357			/*
358			* pass 2: check for crosslinked chains (we couldn't do this in pass 1 because
359			* we didn't know the real start of the chain then - would have treated partial
360			* chains as interlinked with their main chain)
361			*/
362			for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
363			/* find next untravelled chain */
364			if (fat[head].head != head)
365			continue;
366
367			/* follow the chain to its end (hopefully) */
368			for (len = fat[head].length, p = head;
369			(n = fat[p].next) >= CLUST_FIRST && n < boot->NumClusters;
370			p = n) {
371			/* len is always off by one due to n assignment */
372			if (fat[n].head != head \|\| len-- < 2)
373			break;
374			}
375			if (n >= CLUST_EOFS)
376			continue;
377
378			if (n == CLUST_FREE \|\| n >= CLUST_RSRVD) {
379			pwarn("Cluster chain starting at %u ends with cluster marked %s\n",
380			head, rsrvdcltype(n));
381			ret \|= tryclear(boot, fat, head, &fat[p].next);
382			continue;
383			}
384			if (n < CLUST_FIRST \|\| n >= boot->NumClusters) {
385			pwarn("Cluster chain starting at %u ends with cluster out of range (%u)\n",
386			head, n);
387			ret \|= tryclear(boot, fat, head, &fat[p].next);
388			continue;
389			}
390			if (head == fat[n].head) {
391			pwarn("Cluster chain starting at %u loops at cluster %u\n",
392			head, p);
393			ret \|= tryclear(boot, fat, head, &fat[p].next);
394			continue;
395			}
396			pwarn("Cluster chains starting at %u and %u are linked at cluster %u\n",
397			head, fat[n].head, n);
398			conf = tryclear(boot, fat, head, &fat[p].next);
399			if (ask(0, "Clear chain starting at %u", h = fat[n].head)) {
400			if (conf == FSERROR) {
401			/*
402			* Transfer the common chain to the one not cleared above.
403			*/
404			for (p = n;
405			p >= CLUST_FIRST && p < boot->NumClusters;
406			p = fat[p].next) {
407			if (h != fat[p].head) {
408			/*
409			* Have to reexamine this chain.
410			*/
411			head--;
412			break;
413			}
414			fat[p].head = head;
415			}
416			}
417			clearchain(boot, fat, h);
418			conf \|= FSFATMOD;
419			}
420			ret \|= conf;
421			}
422
423			return (ret);
424			}
425
426			/*
427			* Write out FATs encoding them from the internal format
428			*/
429			int
430			writefat(int fs, struct bootblock boot, struct fatEntry fat)
431			{
432			u_char buffer, p;
433			cl_t cl;
434			int i;
435			u_int32_t fatsz;
436			off_t off;
437			int ret = FSOK;
438
439			fatsz = boot->FATsecs * boot->BytesPerSec;
440			buffer = calloc(boot->FATsecs, boot->BytesPerSec);
441			if (buffer == NULL) {
442			xperror("No space for FAT");
443			return (FSFATAL);
444			}
445			(void)memset(buffer, 0, fatsz);
446			boot->NumFree = 0;
447			p = buffer;
448			*p++ = (u_char)boot->Media;
449			*p++ = 0xff;
450			*p++ = 0xff;
451			switch (boot->ClustMask) {
452			case CLUST16_MASK:
453			*p++ = 0xff;
454			break;
455			case CLUST32_MASK:
456			*p++ = 0x0f;
457			*p++ = 0xff;
458			*p++ = 0xff;
459			*p++ = 0xff;
460			*p++ = 0x0f;
461			break;
462			}
463			for (cl = CLUST_FIRST; cl < boot->NumClusters; cl++) {
464			switch (boot->ClustMask) {
465			case CLUST32_MASK:
466			if (fat[cl].next == CLUST_FREE)
467			boot->NumFree++;
468			*p++ = (u_char)fat[cl].next;
469			*p++ = (u_char)(fat[cl].next >> 8);
470			*p++ = (u_char)(fat[cl].next >> 16);
471			*p &= 0xf0;
472			*p++ \|= (fat[cl].next >> 24)&0x0f;
473			break;
474			case CLUST16_MASK:
475			if (fat[cl].next == CLUST_FREE)
476			boot->NumFree++;
477			*p++ = (u_char)fat[cl].next;
478			*p++ = (u_char)(fat[cl].next >> 8);
479			break;
480			default:
481			if (fat[cl].next == CLUST_FREE)
482			boot->NumFree++;
483			*p++ = (u_char)fat[cl].next;
484			*p = (u_char)((fat[cl].next >> 8) & 0xf);
485			cl++;
486			if (cl >= boot->NumClusters)
487			break;
488			if (fat[cl].next == CLUST_FREE)
489			boot->NumFree++;
490			*p++ \|= (u_char)(fat[cl].next << 4);
491			*p++ = (u_char)(fat[cl].next >> 4);
492			break;
493			}
494			}
495			for (i = 0; i < boot->FATs; i++) {
496			off = boot->ResSectors + i * boot->FATsecs;
497			off *= boot->BytesPerSec;
498			if (lseek(fs, off, SEEK_SET) != off
499			\|\| write(fs, buffer, fatsz) != fatsz) {
500			xperror("Unable to write FAT");
501			ret = FSFATAL; /* Return immediately? XXX */
502			}
503			}
504			free(buffer);
505			return (ret);
506			}
507
508			/*
509			* Check a complete in-memory FAT for lost cluster chains
510			*/
511			int
512			checklost(int dosfs, struct bootblock boot, struct fatEntry fat)
513			{
514			cl_t head;
515			int mod = FSOK;
516			int ret;
517
518			for (head = CLUST_FIRST; head < boot->NumClusters; head++) {
519			/* find next untravelled chain */
520			if (fat[head].head != head
521			\|\| fat[head].next == CLUST_FREE
522			\|\| (fat[head].next >= CLUST_RSRVD
523			&& fat[head].next < CLUST_EOFS)
524			\|\| (fat[head].flags & FAT_USED))
525			continue;
526
527			pwarn("Lost cluster chain at cluster %u\n%d Cluster(s) lost\n",
528			head, fat[head].length);
529			mod \|= ret = reconnect(dosfs, boot, fat, head);
530			if (mod & FSFATAL)
531			break;
532			if (ret == FSERROR && ask(0, "Clear")) {
533			clearchain(boot, fat, head);
534			mod \|= FSFATMOD;
535			}
536			}
537			finishlf();
538
539			if (boot->FSInfo) {
540			ret = 0;
541			if (boot->FSFree != 0xffffffff &&
542			boot->FSFree != boot->NumFree) {
543			pwarn("Free space in FSInfo block (%u) not correct (%u)\n",
544			boot->FSFree, boot->NumFree);
545			if (ask(1, "fix")) {
546			boot->FSFree = boot->NumFree;
547			ret = 1;
548			}
549			}
550			if (boot->FSNext != 0xffffffff &&
551			boot->NumFree && (boot->FSNext >= boot->NumClusters \|\|
552			fat[boot->FSNext].next != CLUST_FREE)) {
553			pwarn("Next free cluster in FSInfo block (%u) not free\n",
554			boot->FSNext);
555			if (ask(1, "fix"))
556			for (head = CLUST_FIRST; head < boot->NumClusters; head++)
557			if (fat[head].next == CLUST_FREE) {
558			boot->FSNext = head;
559			ret = 1;
560			break;
561			}
562			}
563			if (ret)
564			mod \|= writefsinfo(dosfs, boot);
565			}
566
567			return (mod);
568			}