/*
 * Bobbi January-February 2020
 *
 * TODO: Trimming unused directory blocks
 * TODO: Make a version that doesn't need GNO - eliminate call to stat()
 */

#pragma debug 9
#pragma lint -1
#pragma stacksize 16384
#pragma memorymodel 0
#pragma optimize -1      /* Disable stack repair code */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <orca.h>
#include <gsos.h>
#include <prodos.h>

#undef DEBUG            /* Enable additional debug printout */
#define CHECK		/* Perform additional integrity checking */

typedef unsigned char uchar;
typedef unsigned int  uint;
typedef unsigned long ulong;

#define NMLEN 15	/* Length of filename */
#define MAXFILES 1000	/* Max files per directory */

/*
 * ProDOS directory header
 * See ProDOS-8 Tech Ref pp. 152
 */
struct pd_dirhdr {
	uchar	typ_len;
	char	name[NMLEN];
	char	reserved[8];
	uchar	ctime[4];
	uchar	vers;
	uchar	minvers;
	uchar	access;
	uchar	entlen;
	uchar	entperblk;
	uchar	filecnt[2];
	uchar	parptr[2];	/* Bitmap pointer in volume dir */
	uchar	parentry;	/* Total blocks LSB in volume dir */
	uchar	parentlen;	/* Total blocks MSB in volume dir */
};

/*
 * ProDOS file entry
 * See ProDOS-8 Tech Ref pp. 155
 */
struct pd_dirent {
	uchar	typ_len;
	char	name[NMLEN];
	uchar 	type;
	uchar	keyptr[2];
	uchar	blksused[2];
	uchar	eof[3];
	uchar	ctime[4];
	uchar	vers;
	uchar	minvers;
	uchar	access;
	uchar	auxtype[2];
	uchar	mtime[4];
	uchar	hdrptr[2];
};

#define BLKSZ 512	/* 512 byte blocks */
#define PTRSZ 4		/* 4 bytes of pointers at beginning of each blk */
#define FLSZ 8192	/* Bytes required for 64K block free-list */

/* Exit codes */
#define EXIT_SUCCESS    0
#define EXIT_BAD_ARG    1
#define EXIT_ALLOC_ERR  2
#define EXIT_FATAL_ERR  3

/*
 * Linked list of directory blocks read from disk
 * Original directory block is stored in data[]
 * Directory block for sorted directory is stored in sorteddata[]
 */
struct block {
	char data[BLKSZ];         /* Original contents of block */
	char sorteddata[BLKSZ];   /* Content block for sorted dir */
	uint blocknum;            /* Block number on disk */
	struct block *next;
};

/*
 * Entry for array of filenames used by qsort()
 */
struct fileent {
	char  name[NMLEN+1]; /* Name converted to upper/lower case */
	char  datetime[20];  /* Date/time as a yyyy-mm-dd hh:mm string */
	uchar type;          /* ProDOS file type */
	uint  blocks;        /* Size in blocks */
	ulong eof;           /* EOF position in bytes */
	uint  order;         /* Hack to make qsort() stable */
	uchar blockidx;      /* Index of dir block (1,2,3 ...)  */
	uchar entrynum;	     /* Entry within the block */
};

/*
 * Entry for list of directory keyblocks to check
 */
struct dirblk {
	uint          blocknum;
	struct dirblk *next;
};

/*
 * Represents a date and time
 */
struct datetime {
	uint  year;
	uchar month;
	uchar day;
	uchar hour;
	uchar minute;
	uchar ispd25format;
};

/* Globals */
static uint totblks;             /* Total # blocks on volume */
static uchar *freelist;          /* Free-list bitmap */
static uchar *usedlist;          /* Bit map of used blocks */
static uchar flloaded = 0;       /* 1 if free-list has been loaded */
static char currdir[NMLEN+1];    /* Name of directory currently processed */
static struct block *blocks = NULL;
static struct dirblk *dirs = NULL;
static struct fileent filelist[MAXFILES];
static uint numfiles;
static uchar entsz;              /* Bytes per file entry */
static uchar entperblk;          /* Number of entries per block */
static char buf[BLKSZ];          /* General purpose scratch buffer */
static char buf2[BLKSZ];         /* General purpose scratch buffer */
static char buf3[BLKSZ];         /* General purpose scratch buffer */
static uint errcount = 0;        /* Error counter */
static uchar dowholedisk = 0;    /* -D whole-disk option */
static uchar dorecurse = 0;      /* -r recurse option */
static uchar dowrite = 0;        /* -w write option */
static uchar doverbose = 0;      /* -v verbose option */
static uchar dodebug = 0;        /* -V very verbose option */
static uchar do_ctime = 0;       /* -k ctime option */
static uchar dozero = 0;         /* -z zero free blocks option */
static char sortopts[5] = "";    /* -s:abc list of sort options */
static char caseopts[2] = "";    /* -c:x case conversion option */
static char fixopts[2] = "";     /* -f:x fix mode option */
static char dateopts[2] = "";    /* -d:x date conversion option */

/* Prototypes */
void hline(void);
void err(enum errtype severity, char *fmt, ...);
void flushall(void);
int  readdiskblock(uchar device, uint blocknum, char *buf);
int  writediskblock(uchar device, uint blocknum, char *buf);
void fixcase(char *in, char *out, uchar minvers, uchar vers, uchar len);
void lowercase(char *p, uchar len, uchar *minvers, uchar *vers);
void uppercase(char *p, uchar len, uchar *minvers, uchar *vers);
void initialcase(uchar mode, char *p, uchar len, uchar *minvers, uchar *vers);
void readdatetime(uchar time[4], struct datetime *dt);
void writedatetime(uchar pd25, struct datetime *dt, uchar time[4]);
uint askfix(void);
int  readfreelist(uchar device);
int  isfree(uint blk);
void markfree(uint blk);
void marknotfree(uint blk);
int  isused(uint blk);
void markused(uint blk);
void checkblock(uint blk, char *msg);
int  seedlingblocks(uchar device, uint keyblk, uint *blkcnt);
int  saplingblocks(uchar device, uint keyblk, uint *blkcnt);
int  treeblocks(uchar device, uint keyblk, uint *blkcnt);
int  forkblocks(uchar device, uint keyblk, uint *blkcnt);
int  subdirblocks(uchar device, uint keyblk, struct pd_dirent *ent,
                  uint blocknum, uint blkentries, uint *blkcnt);
void enqueuesubdir(uint blocknum, uint subdiridx);
int  readdir(uint device, uint blocknum);
int  cmp_name_asc(const void *a, const void *b);
int  cmp_name_desc(const void *a, const void *b);
int  cmp_name_asc_ci(const void *a, const void *b);
int  cmp_name_desc_ci(const void *a, const void *b);
int  cmp_datetime_asc(const void *a, const void *b);
int  cmp_datetime_desc(const void *a, const void *b);
int  cmp_type_asc(const void *a, const void *b);
int  cmp_type_desc(const void *a, const void *b);
int  cmp_dir_beg(const void *a, const void *b);
int  cmp_dir_end(const void *a, const void *b);
int  cmp_blocks_asc(const void *a, const void *b);
int  cmp_blocks_desc(const void *a, const void *b);
int  cmp_eof_asc(const void *a, const void *b);
int  cmp_eof_desc(const void *a, const void *b);
int  cmp_noop(const void *a, const void *b);
void sortlist(char s);
void printlist(void);
uint blockidxtoblocknum(uint idx);
void copyent(uint srcblk, uint srcent, uint dstblk, uint dstent, uint device);
void sortblocks(uint device);
int  writedir(uchar device);
void freeblocks(void);
void usage(void);
void processdir(uint device, uint blocknum);
void checkfreeandused(uchar device);
void zeroblock(uchar device, uint blocknum);
void zerofreeblocks(uchar device, uint freeblks);

/* Horizontal line */
void hline(void) {
	for (uint i=0; i<80; ++i)
		putchar('-');
}

enum errtype {WARN, NONFATAL, FATAL, FATALALLOC, FATALBADARG, FINISHED};

/*
 * Display error message
 */
void err(enum errtype severity, char *fmt, ...) {
	if (severity == FINISHED) {
		hline();
		if (errcount == 0)
			printf("Done - no errors found.\n");
		else
			printf("Done - %u errors\n", errcount);
		hline();
		exit(EXIT_SUCCESS);
	}
	++errcount;
	fputs("  ", stdout);
	va_list v;
	va_start(v, fmt);
	vprintf(fmt, v);
	putchar('\n');
	va_end(v);
	switch (severity) {
	case FATAL:
		printf("Stopping after %u errors\n", errcount);
		exit(EXIT_FATAL_ERR);
	case FATALALLOC:
		printf("Stopping after %u errors\n", errcount);
		exit(EXIT_ALLOC_ERR);
	case FATALBADARG:
		printf("Stopping after %u errors\n", errcount);
		exit(EXIT_BAD_ARG);
	}
}

/*
 * Disable GSOS block cache and flush any unwritten changes
 */
void flushall(void) {
	ResetCacheGS(0); /* Disable block caching */
	short ff[2];
	ff[0] = 1;
	ff[1] = 0;
	FlushGS(ff);
}

/*
 * Read block from disk using ProDOS call
 * buf must point to buffer with at least 512 bytes
 */
int readdiskblock(uchar device, uint blocknum, char *buf) {
#ifdef DEBUG
	printf("Reading dev %2u block %5u\n", device, blocknum);
#endif
#ifdef CHECK
	if (flloaded)
		if (isfree(blocknum))
			err(NONFATAL, "Block %u is marked free!", blocknum);
#endif
	BlockRec br;
	br.blockDevNum = device;
	br.blockDataBuffer = buf;
	br.blockNum = blocknum;
	READ_BLOCK(&br);
	int rc = toolerror();
	if (rc) {
		err(FATAL, "Block read failed, err=%x", rc);
		return -1;
	}
	return 0;
}

/*
 * Write block from disk using ProDOS call
 * buf must point to buffer with at least 512 bytes
 */
int writediskblock(uchar device, uint blocknum, char *buf) {
#ifdef DEBUG
	printf("Writing dev %2u block %5u\n", device, blocknum);
#endif
	if ((strcmp(currdir, "LIB") == 0) ||
	    (strcmp(currdir, "LIBRARIES") == 0)) {
		printf("Not writing library directory %s\n", currdir);
		return 0;
	}
	flushall();
	DIORecGS dr;
	dr.pCount = 6;
	dr.devNum = device;
	dr.buffer = buf;
	dr.requestCount = BLKSZ;
	dr.startingBlock = blocknum;
	dr.blockSize = BLKSZ;
	DWriteGS(&dr);
	if (dr.transferCount != BLKSZ) {
		err(FATAL, "Block write failed");
		return -1;
	}
	return 0;
}

/*
 * Uses the vers and minvers fields of the directory entry
 * as a bitmap representing which characters are upper and which are
 * lowercase
 */
void fixcase(char *in, char *out, uchar minvers, uchar vers, uchar len) {
	uchar idx = 0;
	if (!(vers & 0x80)) {
		for (idx=0; idx<NMLEN; ++idx)
			out[idx] = in[idx];
		out[len] = '\0';
		return;
	}
	vers <<= 1;
	for (int i=0; i<7; ++i) {
		out[idx++] = ((vers&0x80) ? tolower(in[idx]) : in[idx]);
		vers <<= 1;
	}
	for (int i=0; i<8; ++i) {
		out[idx++] = ((minvers&0x80) ? tolower(in[idx]) : in[idx]);
		minvers <<= 1;
	}
	out[len] = '\0';
}

/*
 * Convert filename pointed to by p into lower case (which is recorded
 * as a bitmap in the vers and minvers fields.
 */
void lowercase(char *p, uchar len, uchar *minvers, uchar *vers) {
	uchar idx = 0;
	*vers = 0x01;
	*minvers = 0x00;
	for (uint i=0; i<7; ++i) {
		*vers <<= 1;
		if ((idx < len) && isalpha(p[idx++]))
			*vers |= 0x01;
	}
	for (uint i=0; i<8; ++i) {
		*minvers <<= 1;
		if ((idx < len) && isalpha(p[idx++]))
			*minvers |= 0x01;
	}
}

/*
 * Convert filename pointed to by p into upper case (which is recorded
 * as a bitmap in the vers and minvers fields.
 */
void uppercase(char *p, uchar len, uchar *minvers, uchar *vers) {
	*vers = 0x00;
	*minvers = 0x00;
}

/*
 * Convert filename pointed to by p into to have first letter capitalized
 * (which is recorded as a bitmap in the vers and minvers fields.
 * If mode = 0 then just uppercase the initial char ("Read.me")
 * otherwise camel-case the name ("Read.Me")
 */
void initialcase(uchar mode, char *p, uchar len, uchar *minvers, uchar *vers) {
	uchar idx = 0;
	uchar capsflag = 1;
	*vers = 0x01;
	*minvers = 0x00;
	for (uint i=0; i<7; ++i) {
		*vers <<= 1;
		if ((idx < len) && isalpha(p[idx++]))
			if (!capsflag)
				*vers |= 0x01;
		if ((mode == 1) && !isalpha(p[idx-1]))
			capsflag = 1;
		else
			capsflag = 0;
	}
	for (uint i=0; i<8; ++i) {
		*minvers <<= 1;
		if ((idx < len) && isalpha(p[idx++]))
			if (!capsflag)
				*minvers |= 0x01;
		if ((mode == 1) && !isalpha(p[idx-1]))
			capsflag = 1;
		else
			capsflag = 0;
	}
}

segment "extra";

/*
 * Read the first block of a directory and deduce the device ID and block
 * number of the first block of the directory.
 */
uchar firstblk(char *dirname, uchar *device, uint *block) {
	int fp;
	uchar rv = 0;

	fp = open(dirname, O_RDONLY);
	if (!fp) {
		err(NONFATAL, "Error opening dir %s", dirname);
		rv = 1;
		goto ret;
	}

	ssize_t len = read(fp, buf, BLKSZ);
	if (len != BLKSZ) {
		err(NONFATAL, "Error reading first block of dir %s", dirname);
		rv = 1;
		goto ret;
	}

	struct stat st;
	if (stat(dirname, &st) == -1)
		err(FATAL, "Can't stat %s", dirname);

	if (!S_ISDIR(st.st_mode))
		err(FATAL, "%s is not a directory", dirname);

	*device = st.st_dev;

	struct pd_dirhdr *hdr = (struct pd_dirhdr*)(buf + PTRSZ);

	/* Detect & handle volume directory */
	if ((hdr->typ_len & 0xf0) == 0xf0) {
		*block = 2;
		goto ret;
	}

#ifdef CHECK
	if ((hdr->typ_len & 0xf0) != 0xe0) {
		err(NONFATAL, "Bad storage type");
		rv = 1;
		goto ret;
	}
#endif

	/* Handle subdirectory */
	uint parentblk    = hdr->parptr[0] + 256U * hdr->parptr[1];
	uint parententry  = hdr->parentry;
	uint parententlen = hdr->parentlen;

	/* Read parent directory block */
	if (readdiskblock(*device, parentblk, buf) == -1)
		err(FATAL, "Can't read parent directory for %s", dirname);

	struct pd_dirent *ent =
	  (struct pd_dirent *)(buf + PTRSZ + (parententry-1) * parententlen);

	*block = ent->keyptr[0] + 256U * ent->keyptr[1];

ret:
	if (fp)
		close(fp);
	return rv;
}

/*
 * Parse mtime or ctime fields and populate the fields of the datetime struct
 * Supports the legacy ProDOS date/time format as used by ProDOS 1.0->2.4.0
 * and also the new format introduced with ProDOS 2.5.
 */
void readdatetime(uchar time[4], struct datetime *dt) {
	uint d = time[0] + 256U * time[1];
	uint t = time[2] + 256U * time[3];
	if (!(t & 0xe000)) {
		/* ProDOS 1.0 to 2.4.2 date format */
		dt->year   = (d & 0xfe00) >> 9;
		dt->month  = (d & 0x01e0) >> 5;
		dt->day    = d & 0x001f;
		dt->hour   = (t & 0x1f00) >> 8;
		dt->minute = t & 0x003f;
		dt->ispd25format = 0;
		if (dt->year < 40) /* See ProDOS-8 Tech Note 48 */
			dt->year += 2000;
		else
			dt->year += 1900;
	} else {
		/* ProDOS 2.5.0+ */
		dt->year   = t & 0x0fff;
		dt->month  = ((t & 0xf000) >> 12) - 1;
		dt->day    = (d & 0xf800) >> 11;
           	dt->hour   = (d & 0x07c0) >> 6; 
		dt->minute = d & 0x003f;
		dt->ispd25format = 1;
	}
}

/*
 * Write the date and time stored in struct datetime in ProDOS on disk format,
 * storing the bytes in array time[].  If pd25 is 0 then use legacy format
 * (ProDOS 1.0-2.4.2) otherwise use the new date and time format introduced
 * with ProDOS 2.5
 */
void writedatetime(uchar pd25, struct datetime *dt, uchar time[4]) {
	uint d, t;
	if (pd25 == 0) {
		/* ProDOS 1.0 to 2.4.2 date format */
		uint year = dt->year;
		if (year > 2039)		/* 2039 is last year */
			year = 2039;
		if (year < 1940)		/* 1940 is first year */
			year = 1940;
		if (year >= 2000)
			year -= 2000;
		if (year >= 1900)
			year -= 1900;
		d = (year << 9) | (dt->month << 5) | dt->day; 
		t = (dt->hour << 8) | dt->minute;
	} else {
		/* ProDOS 2.5.0+ */
		t = ((dt->month + 1) << 12) | dt->year;
		d = (dt->day << 11) | (dt->hour << 6) | dt->minute; 
	}
	time[0] = d & 0xff;
	time[1] = (d >> 8) & 0xff;
	time[2] = t & 0xff;
	time[3] = (t >> 8) & 0xff;
}

/*
 * Determine whether or not to perform a fix
 * Return 0 not to perform fix, 1 to perform fix
 */
uint askfix(void) {
	if (strlen(fixopts) == 0)
		return 0;
	switch (fixopts[0]) {
	case '?':
		fputs("Fix (y/n)? ", stdout);
		if (tolower(getchar()) == 'y')
			return 1;
		return 0;
	case 'y':
		return 1;
	default:
		return 0;
	}
}

/*
 * Read the free list
 */
int readfreelist(uchar device) {
	freelist = (uchar*)malloc(FLSZ);
	if (!freelist)
		err(FATALALLOC, "** Unable to allocate memory **");
	bzero(freelist, FLSZ);
	usedlist = (uchar*)malloc(FLSZ);
	if (!usedlist)
		err(FATALALLOC, "** Unable to allocate memory **");
	bzero(usedlist, FLSZ);
	markused(0); /* Boot block */
	markused(1); /* SOS boot block */
	if (readdiskblock(device, 2, buf) == -1) {
		err(NONFATAL, "Error reading volume dir");
		return -1;
	}
	uint flblk = buf[0x27] + 256U * buf[0x28];
	totblks = buf[0x29] + 256U * buf[0x2a];
	if (doverbose)
		printf("Volume has %u blocks\n", totblks);
	uint flsize = totblks / 4096U;
	if ((flsize % 4096) >0)
		++flsize;
	char *p = (char*)freelist;
	for (uint i=0; i<flsize; ++i) {
		markused(flblk);
		if (readdiskblock(device, flblk++, p) == -1) {
			err(NONFATAL, "Error reading free list");
			return -1;
		}
		p += BLKSZ;
	}
	flloaded = 1;
	return 0;
}

/*
 * Determine if block blk is free or not
 */
int isfree(uint blk) {
	uint idx = blk / 8;
	uint bit = blk % 8;
	return (freelist[idx] << bit) & 0x80 ? 1 : 0;
}

/*
 * Mark a block as free
 */
void markfree(uint blk) {
	uint idx = blk / 8;
	uint bit = blk % 8;
	freelist[idx] |= (0x80 >> bit);
}

/*
 * Mark a block as not free
 */
void marknotfree(uint blk) {
	uint idx = blk / 8;
	uint bit = blk % 8;
	freelist[idx] &= ~(0x80 >> bit);
}

/*
 * Determine if block blk is used or not
 */
int isused(uint blk) {
	uint idx = blk / 8;
	uint bit = blk % 8;
	return (usedlist[idx] << bit) & 0x80 ? 1 : 0;
}

/*
 * Mark a block as used
 */
void markused(uint blk) {
	uint idx = blk / 8;
	uint bit = blk % 8;
	usedlist[idx] |= (0x80 >> bit);
}

/*
 * Perform all the operations to check a block which is used by
 * a directory or file.  Complains if the block is on the free-list
 * and also if we have encountered this block in a previous file or dir.
 */
void checkblock(uint blk, char *msg) {
	if (isfree(blk))
		err(WARN, "%s block %u is marked free!", msg, blk);
	if (isused(blk))
		err(WARN, "%s block %u is already used!", msg, blk);
	markused(blk);
}

/*
 * Count the blocks in a seedling file
 */
int seedlingblocks(uchar device, uint keyblk, uint *blkcnt) {
	checkblock(keyblk, "Data");
	*blkcnt = 1;
	return 0;
}

/*
 * Count the blocks in a sapling file
 */
int saplingblocks(uchar device, uint keyblk, uint *blkcnt) {
	checkblock(keyblk, "Data");
	if (readdiskblock(device, keyblk, buf) == -1) {
		err(NONFATAL, "Error reading blk %u", keyblk);
		return -1;
	}
	*blkcnt = 1;
	for (uint i=0; i<256; ++i) {
		uint p = buf[i] + 256U * buf[i+256];
		if (p) {
			checkblock(p, "Data");
			++(*blkcnt);
		}
	}
	return 0;
}

/*
 * Count the blocks in a tree file
 */
int treeblocks(uchar device, uint keyblk, uint *blkcnt) {
	checkblock(keyblk, "Tree index");
	if (readdiskblock(device, keyblk, buf2) == -1) {
		err(NONFATAL, "Error reading blk %u", keyblk);
		return -1;
	}
	*blkcnt = 1;
	for (uint i=0; i<256; ++i) {
		uint p = buf2[i] + 256U * buf2[i+256];
		if (p) {
			uint b;
			if (saplingblocks(device, p, &b) == 0)
				*blkcnt += b;
			else
				return -1;
		}
	}
	return 0;
}

/*
 * Count the blocks in a GSOS fork file
 * See http://1000bit.it/support/manual/apple/technotes/pdos/tn.pdos.25.html
 */
int forkblocks(uchar device, uint keyblk, uint *blkcnt) {
	checkblock(keyblk, "Fork key");
	if (readdiskblock(device, keyblk, buf3) == -1) {
		err(NONFATAL, "Error reading blk %u", keyblk);
		return -1;
	}
	*blkcnt = 1;
	uint count;

	/* Data fork */
	uchar type = buf3[0x00];
	keyblk = buf3[0x01] + 256U * buf3[0x02];
	uint blks = buf3[0x03] + 256U * buf3[0x04];
	switch (type) {
	case 0x1:
		/* Seedling */
		seedlingblocks(device, keyblk, &count);
		break;
	case 0x2:
		/* Sapling */
		saplingblocks(device, keyblk, &count);
		break;
	case 0x3:
		/* Tree */
		treeblocks(device, keyblk, &count);
		break;
	default:
		err(NONFATAL, "Invalid storage type for data fork");
		count = 0;
		break;
	}
	if (blks != count) {
		if (count != 0) {
			err(NONFATAL,
			    "Data fork size %u is incorrect, should be %u",
			    blks, count);
			if (askfix() == 1) {
				buf3[0x03] = count & 0xff;
				buf3[0x04] = (count >> 8) & 0xff;
			}
		}
	}
	*blkcnt += count;

	/* Data fork */
	type = buf3[0x100];
	keyblk = buf3[0x101] + 256U * buf3[0x102];
	blks = buf3[0x103] + 256U * buf3[0x104];
	switch (type) {
	case 0x1:
		/* Seedling */
		seedlingblocks(device, keyblk, &count);
		break;
	case 0x2:
		/* Sapling */
		saplingblocks(device, keyblk, &count);
		break;
	case 0x3:
		/* Tree */
		treeblocks(device, keyblk, &count);
		break;
	default:
		err(NONFATAL, "Invalid storage type for resource fork");
		count = 0;
		break;
	}
	if (blks != count) {
		if (count != 0) {
			err(NONFATAL,
			    "Res fork size %u is incorrect, should be %u",
			    blks, count);
			if (askfix() == 1) {
				buf3[0x103] = count & 0xff;
				buf3[0x104] = (count >> 8) & 0xff;
			}
		}
	}
	*blkcnt += count;

	return 0;
}

/*
 * Count the blocks in a subdirectory
 */
int  subdirblocks(uchar device, uint keyblk, struct pd_dirent *ent,
                  uint blocknum, uint blkentries, uint *blkcnt) {

	if (!dorecurse)
		checkblock(keyblk, "Directory");
	if (readdiskblock(device, keyblk, buf) == -1) {
		err(NONFATAL, "Error reading keyblock %u", keyblk);
		return -1;
	}
	*blkcnt = 1;
	struct pd_dirhdr *hdr = (struct pd_dirhdr*)(buf + PTRSZ);
	uchar parentry = hdr->parentry;
	uchar parentlen = hdr->parentlen;
	uint parblk = hdr->parptr[0] + 256U * hdr->parptr[1];

	if (parblk != blocknum) {
		err(NONFATAL, "Bad parent block %u, should be %u",
		    parblk, blocknum);
		if (askfix() == 1) {
			hdr->parptr[0] = blocknum & 0xff;
			hdr->parptr[1] = (blocknum >> 8) & 0xff;
		}
	}

	skipfix:

	if (parentry != blkentries) {
		err(NONFATAL, "Bad parent block entry %u, should be %u",
		    parentry, blkentries);
		if (askfix() == 1) {
			hdr->parentry = blkentries;
		}
	}
	if (parentlen != 0x27) {
		err(NONFATAL, "Bad parent entry length");
		if (askfix() == 1) {
			hdr->parentlen = 0x27;
		}
	}
	char *dirname = buf + 0x05;
	if (strncmp(dirname, ent->name, NMLEN)) {
		err(NONFATAL,"Subdirectory name mismatch");
	}

	blocknum = buf[0x02] + 256U * buf[0x03];
	while (blocknum) {
		if (!dorecurse)
			checkblock(blocknum, "Directory");
		if (readdiskblock(device, blocknum, buf) == -1) {
			err(NONFATAL, "Error reading dir block %u", blocknum);
			return -1;
		}
		++(*blkcnt);
		blocknum = buf[0x02] + 256U * buf[0x03];
	}
	return 0;
}

/*
 * Record the keyblock of a subdirectory to be processed subsequently
 * blocknum is the block number of the subdirectory keyblock
 * subdiridx is a sequential counter of the subdirs in the current directory
 */
void enqueuesubdir(uint blocknum, uint subdiridx) {
	struct dirblk *p = (struct dirblk*)malloc(sizeof(struct dirblk));
	if (!p)
		err(FATALALLOC, "** Unable to allocate memory **");
	p->blocknum = blocknum;
	static struct dirblk *prev;
	if (subdiridx == 0) {     /* First subdir is inserted at head of list */
		p->next = dirs;
		dirs = p;
	} else {                  /* Subsequent subdirs follow the previous */
		p->next = prev->next;
		prev->next = p;
	}
	prev = p;
}

/*
 * Read a directory, store the raw directory blocks in a linked list
 * and build filelist[] in preparation for sorting. 
 * device is the device number containing the directory
 * blocknum is the block number of the first block of the directory
 */
int readdir(uint device, uint blocknum) {
	uint errsbefore = errcount;
	uint blkcnt = 1;
	uint hdrblknum = blocknum;

	numfiles = 0;

	blocks = (struct block*)malloc(sizeof(struct block));
	if (!blocks)
		err(FATALALLOC, "** Unable to allocate memory **");
	struct block *curblk = blocks;
	curblk->next = NULL;
	curblk->blocknum = blocknum;

	checkblock(blocknum, "Directory");
	if (readdiskblock(device, blocknum, curblk->data) == -1) {
		err(NONFATAL, "Error reading dir block %d", blkcnt);
		return 1;
	}

	struct pd_dirhdr *hdr = (struct pd_dirhdr*)(curblk->data + PTRSZ);

	entsz           = hdr->entlen;
	entperblk       = hdr->entperblk;
	uint filecount  = hdr->filecnt[0] + 256U * hdr->filecnt[1];

	fixcase(hdr->name, currdir,
	        hdr->vers, hdr->minvers, hdr->typ_len & 0x0f);

	hline();
	printf("Directory %s (%u", currdir, filecount);
	printf(" %s)\n", filecount == 1 ? "entry" : "entries");
	hline();

	/* Copy pointers to sorteddata[], zero the rest */
	bzero(curblk->sorteddata, BLKSZ);
	memcpy(curblk->sorteddata, curblk->data, PTRSZ);

#ifdef CHECK
	if (entsz != 0x27) {
		err(NONFATAL, "Error - bad entry size");
		return 1;
	}
	if (entperblk != 0x0d) {
		err(NONFATAL, "Error - bad entries/block");
		return 1;
	}
#endif
	uint idx = entsz + PTRSZ; /* Skip header */
	uchar blkentries = 2;
	uchar entries = 0;
	uint subdirs = 0;

	while (1) {
		struct pd_dirent *ent = (struct pd_dirent*)(curblk->data + idx);
		if (ent->typ_len != 0) {

			if (strlen(caseopts) > 0) {
				switch (caseopts[0]) {
				case 'u':
					uppercase(ent->name,
					          ent->typ_len & 0x0f,
			                          &(ent->vers),
					          &(ent->minvers));
					break;
				case 'l':
					lowercase(ent->name,
					          ent->typ_len & 0x0f,
			                          &(ent->vers),
					          &(ent->minvers));
					break;
				case 'i':
					initialcase(0,
					            ent->name,
					            ent->typ_len & 0x0f,
			                            &(ent->vers),
					            &(ent->minvers));
					break;
				case 'c':
					initialcase(1,
					            ent->name,
					            ent->typ_len & 0x0f,
			                            &(ent->vers),
					            &(ent->minvers));
					break;
				default:
					err(FATALBADARG, "Invalid case option");
				}
			}

			if (strlen(dateopts) > 0) {
				struct datetime ctime, mtime;
				readdatetime(ent->ctime, &ctime);
				readdatetime(ent->mtime, &mtime);
				uchar pd25;
				switch (dateopts[0]) {
				case 'n':
					pd25 = 1;
					break;
				case 'o':
					pd25 = 0;
					break;
				default:
					err(FATALBADARG, "Invalid date option");
				}
				writedatetime(pd25, &ctime, ent->ctime);
				writedatetime(pd25, &mtime, ent->mtime);
			}

			static char namebuf[NMLEN+1];

			fixcase(ent->name, namebuf,
			        ent->vers, ent->minvers, ent->typ_len & 0x0f);
#ifdef CHECK
			switch (ent->typ_len & 0xf0) {
			case 0x10:
				fputs("Seed  ", stdout);
				break;
			case 0x20:
				fputs("Sapl  ", stdout);
				break;
			case 0x30:
				fputs("Tree  ", stdout);
				break;
			case 0x40:
				fputs("Pasc  ", stdout);
				break;
			case 0x50:
				fputs("Fork  ", stdout);
				break;
			case 0xd0:
				fputs("Dir   ", stdout);
				break;
			default:
				fputs("????  ", stdout);
				break;
			}
			puts(namebuf);
#endif
			uint blks = ent->blksused[0] + 256U * ent->blksused[1];
			ulong eof = ent->eof[0] + 256L * ent->eof[1] +
			            65536L * ent->eof[2];
			for (uchar i=0; i<NMLEN+1; ++i)
				filelist[numfiles].name[i] = '\0';
			for (uchar i=0; i<(ent->typ_len & 0x0f); ++i)
				filelist[numfiles].name[i] = namebuf[i];
			filelist[numfiles].type = ent->type;
			filelist[numfiles].blockidx = blkcnt;
			filelist[numfiles].entrynum = blkentries;
			filelist[numfiles].blocks = blks;
			filelist[numfiles].eof = eof;

			struct datetime dt;
			readdatetime(do_ctime ? ent->ctime : ent->mtime, &dt);
			sprintf(filelist[numfiles].datetime,
			        "%04d-%02d-%02d %02d:%02d %s",
			        dt.year, dt.month, dt.day, dt.hour, dt.minute,
			        (dt.ispd25format ? "*" : " "));

#ifdef CHECK
			uint keyblk = ent->keyptr[0] + 256U * ent->keyptr[1];
			uint hdrblk = ent->hdrptr[0] + 256U * ent->hdrptr[1];
			if (hdrblk != hdrblknum) {
				err(NONFATAL, "Header ptr %u, should be %u",
				    hdrblk, hdrblknum);
				if (askfix() == 1) {
					ent->hdrptr[0] = hdrblknum & 0xff;
					ent->hdrptr[1] = (hdrblknum >> 8)&0xff;
				}
			}
			uint count;
			switch (ent->typ_len & 0xf0) {
			case 0xd0:
				/* Subdirectory */
				enqueuesubdir(keyblk, subdirs++);
				subdirblocks(device, keyblk, ent,
				             blocknum, blkentries, &count);
				break;
			case 0x10:
				/* Seedling */
				seedlingblocks(device, keyblk, &count);
				break;
			case 0x20:
				/* Sapling */
				saplingblocks(device, keyblk, &count);
				break;
			case 0x30:
				/* Tree */
				treeblocks(device, keyblk, &count);
				break;
			case 0x40:
				/* Pascal area */
				puts(" Pascal area!!");
				// TODO: Check name is PASCAL.AREA type 0xef
				count = 0;
				break;
			case 0x50:
				/* File with resource fork */
				forkblocks(device, keyblk, &count);
				break;
			default:
				err(NONFATAL,
				    "%s: unexpected storage type 0x%x",
				     namebuf, ent->typ_len & 0xf0);
				count = 0;
			}
			if (blks != count) {
				if (count != 0) {
					err(NONFATAL,
					    "Blocks used %u is incorrect, "
					    "should be %u", blks, count);
					if (askfix() == 1) {
						ent->blksused[0] = count&0xff;
						ent->blksused[1] =
						  (count >> 8) & 0xff;
					}
				}
			}
#endif
			++numfiles;
			if (numfiles == MAXFILES) {
				err(NONFATAL, "** Too many files! **");
				return 1;
			}
			++entries;
		}
		if (blkentries == entperblk) {
			blocknum = curblk->data[0x02] + 256U*curblk->data[0x03];
			if (blocknum == 0) {
				break;
			}
			curblk->next =
			  (struct block*)malloc(sizeof(struct block));
			if (!curblk->next)
				err(FATALALLOC,
				    "** Unable to allocate memory **");
			curblk = curblk->next;
			curblk->next = NULL;
			curblk->blocknum = blocknum;
			++blkcnt;
			checkblock(blocknum, "Directory");
			if ( readdiskblock(device, blocknum,
			                   curblk->data) == -1) {
				err(NONFATAL,"Error reading dir block %d",
				    blkcnt);
				return 1;
			}
			/* Copy ptrs to sorteddata[], zero the rest */
			bzero(curblk->sorteddata, BLKSZ);
			memcpy(curblk->sorteddata, curblk->data, PTRSZ);
			blkentries = 1;
			idx = PTRSZ;
		} else {
			++blkentries;
			idx += entsz;
		}
	}
	if (filecount != entries) {
		err(NONFATAL, "Filecount %u wrong, should be %u",
		    filecount, entries);
		if (askfix() == 1) {
			hdr->filecnt[0] = entries & 0xff;
			hdr->filecnt[1] = (entries >> 8) & 0xff;
		}
	}
	return errcount - errsbefore;
}

/*
 * Compare - filename sort in ascending order
 */
int cmp_name_asc(const void *a, const void *b) {
	return strncmp(((struct fileent*)a)->name,
	               ((struct fileent*)b)->name, NMLEN);
}

/*
 * Compare - filename sort in descending order
 */
int cmp_name_desc(const void *a, const void *b) {
	return strncmp(((struct fileent*)b)->name,
	               ((struct fileent*)a)->name, NMLEN);
}

/*
 * Compare - filename sort in ascending order - case insensitive
 */
int cmp_name_asc_ci(const void *a, const void *b) {
	return strncasecmp(((struct fileent*)a)->name,
	                   ((struct fileent*)b)->name, NMLEN);
}

/*
 * Compare - filename sort in descending order - case insensitive
 */
int cmp_name_desc_ci(const void *a, const void *b) {
	return strncasecmp(((struct fileent*)b)->name,
	                   ((struct fileent*)a)->name, NMLEN);
}

/*
 * Compare - date/time sort in ascending order
 */
int cmp_datetime_asc(const void *a, const void *b) {
	return strncmp(((struct fileent*)a)->datetime,
	               ((struct fileent*)b)->datetime, 16);
}

/*
 * Compare - date/time sort in descending order
 */
int cmp_datetime_desc(const void *a, const void *b) {
	return strncmp(((struct fileent*)b)->datetime,
	               ((struct fileent*)a)->datetime, 16);
}

/*
 * Compare - type sort in ascending order
 * Uses the order field to make qsort() stable
 */
int cmp_type_asc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	int rc = aa->type - bb->type;
	return rc != 0 ? rc : aa->order - bb->order;
}
/*
 * Compare - type sort in descending order
 * Uses the order field to make qsort() stable
 */
int cmp_type_desc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	int rc = bb->type - aa->type;
	return rc != 0 ? rc : aa->order - bb->order;
}

/*
 * Compare - sort with directories at the beginning
 * Uses the order field to make qsort() stable
 */
int cmp_dir_beg(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	if ((aa->type == 0x0f) && (bb->type != 0x0f))
		return -1;
	if ((bb->type == 0x0f) && (aa->type != 0x0f))
		return 1;
	return aa->order - bb->order;
}

/*
 * Compare - sort with directories at the end
 * Uses the order field to make qsort() stable
 */
int cmp_dir_end(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	if ((aa->type == 0x0f) && (bb->type != 0x0f))
		return 1;
	if ((bb->type == 0x0f) && (aa->type != 0x0f))
		return -1;
	return aa->order - bb->order;
}

/*
 * Compare - sort in increasing order of blocks used
 */
int  cmp_blocks_asc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	int rc = aa->blocks - bb->blocks;
	return rc != 0 ? rc : aa->order - bb->order;
}

/*
 * Compare - sort in decreasing order of blocks used
 */
int  cmp_blocks_desc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	int rc = bb->blocks - aa->blocks;
	return rc != 0 ? rc : aa->order - bb->order;
}

/*
 * Compare - sort in increasing order of EOF position
 */
int  cmp_eof_asc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	long diff = aa->eof - bb->eof;
	if (diff == 0)
		return aa->order - bb->order;
	if (diff > 0)
		return 1;
	else
		return -1;
}

/*
 * Compare - sort in decreasing order of EOF position
 */
int  cmp_eof_desc(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	long diff = bb->eof - aa->eof;
	if (diff == 0)
		return aa->order - bb->order;
	if (diff > 0)
		return 1;
	else
		return -1;
}

/*
 * No-op sort which just keeps items in the same order
 */
int  cmp_noop(const void *a, const void *b) {
	struct fileent *aa = (struct fileent*)a;
	struct fileent *bb = (struct fileent*)b;
	return aa->order - bb->order;
}

/*
 * Sort filelist[]
 * s defines the field to sort on
 */
void sortlist(char s) {
	for(uint i=0; i<numfiles; ++i) {
		filelist[i].order = i;
	}
	switch (s) {
	case 'n':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_name_asc);
		break;
	case 'N':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_name_desc);
		break;
	case 'i':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_name_asc_ci);
		break;
	case 'I':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_name_desc_ci);
		break;
	case 'd':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_datetime_asc);
		break;
	case 'D':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_datetime_desc);
		break;
	case 't':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_type_asc);
		break;
	case 'T':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_type_desc);
		break;
	case 'f':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_dir_beg);
		break;
	case 'F':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_dir_end);
		break;
	case 'b':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_blocks_asc);
		break;
	case 'B':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_blocks_desc);
		break;
	case 'e':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_eof_asc);
		break;
	case 'E':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_eof_desc);
		break;
	case '.':
		qsort(filelist, numfiles, sizeof(struct fileent),
		      cmp_noop);
		break;
	default:
		err(FATALBADARG, "Invalid sort option");
	}
}

/*
 * Print the file info stored in filelist[]
 */
void printlist(void) {
	hline();
	fputs("Dirblk Entry Type : Name            : Blocks      EOF ", stdout);
	if (do_ctime)
		puts("Created");
	else
		puts("Modified");
	for (uint i=0; i<numfiles; ++i) {
		printf("   %03u    %02u   %02x : %s",
		       filelist[i].blockidx,
		       filelist[i].entrynum,
		       filelist[i].type,
		       filelist[i].name);
		for (uint j=0; j<(16-strlen(filelist[i].name)); ++j)
			putchar(' ');
		printf(": %5u  %8lu", filelist[i].blocks, filelist[i].eof);
		printf(" %s\n", filelist[i].datetime);
	}
	hline();
}

/*
 * Convert block index to block number
 * Block index is 1-based (1,2,3 ...)
 */
uint blockidxtoblocknum(uint idx) {
	struct block *p = blocks;
	for (uint i=1; i<idx; ++i)
		if (p)
			p = p->next;
		else {
			puts("** Internal error **");
			exit(3);
		}
	if (!p) {
		puts("** Internal error **");
		exit(3);
	}
	return p->blocknum;
}

/*
 * Copy a file entry from one srcblk, srcent to dstblk, dstent
 * All indices are 1-based.
 */
void copyent(uint srcblk, uint srcent, uint dstblk, uint dstent, uint device) {

	if (dodebug) {
		printf("  from dirblk %03u entry %02u", srcblk, srcent);
		printf("    to dirblk %03u entry %02u", dstblk, dstent);
	}

	uint parentblk = blockidxtoblocknum(dstblk);

	struct block *source = blocks;
	struct block *dest   = blocks;
	while (--srcblk > 0)
		source = source->next;
	while (--dstblk > 0)
		dest = dest->next;
	char *srcptr =  source->data + PTRSZ + (srcent-1) * entsz;
	char *dstptr =  dest->sorteddata + PTRSZ + (dstent-1) * entsz;
	memcpy(dstptr, srcptr, entsz);

	/* For directories, update the parent dir entry number */
	struct pd_dirent *ent = (struct pd_dirent*)dstptr;
	if ((ent->typ_len & 0xf0) == 0xd0) {
		uint block = ent->keyptr[0] + 256U * ent->keyptr[1];
		if (readdiskblock(device, block, buf) == -1) {
			puts("Can't read subdirectory");
			exit(1);
		}
		struct pd_dirhdr *hdr = (struct pd_dirhdr*)(buf + PTRSZ);
		hdr->parptr[0] = parentblk & 0xff;
		hdr->parptr[1] = (parentblk >> 8) & 0xff;
		hdr->parentry = dstent;
		if (dowrite) {
			if (writediskblock(device, block, buf) == -1) {
				puts("Can't write subdirectory");
				exit(1);
			}
		} else {
			if (doverbose)
				puts("Not writing updated subdir without -w");
		}
	}
}

/*
 * Use the sorted list in filelist[] to create a sorted set of directory
 * blocks.  Note that the block and entry numbers are 1-based indices.
 */
void sortblocks(uint device) {
	copyent(1, 1, 1, 1, device); /* Copy directory header */
	uchar destblk = 1;
	uchar destentry = 2; /* Skip header on first block */
	for(uint i=0; i<numfiles; ++i) {
		if (dodebug)
			puts(filelist[i].name);
		copyent(filelist[i].blockidx, filelist[i].entrynum,
		        destblk, destentry, device);
		if (destentry++ == entperblk) {
			++destblk;
			destentry = 1;
		}
	}
}

/*
 * Write out the sorted directory
 */
int writedir(uchar device) {
	struct block *i = blocks;
	while (i) {
		if(writediskblock(device, i->blocknum, i->sorteddata) == -1) {
			err(NONFATAL, "Can't write block %u", i->blocknum);
			return 1;
		}
		i = i->next;
	}
	return 0;
}

/*
 * Walk through the linked list freeing memory
 */
void freeblocks(void) {
	struct block *i = blocks, *j;
	while (i) {
		j = i->next;
		free(i);
		i = j;
	}
	blocks = NULL;
}

void usage(void) {
	printf("usage: sortdir [-s xxx] [-n x] [-rDwcvVh] path\n\n");
	printf("  Options: -s xxx  Directory sort options\n");
	printf("           -n x    Filename upper/lower case options\n");
	printf("           -d x    Date format conversion options\n");
	printf("           -f x    Fix mode\n");
	printf("           -r      Recursive descent\n");
	printf("           -D      Whole-disk mode (implies -r)\n");
	printf("           -w      Enable writing to disk\n");
	printf("           -c      Use create time rather than modify time\n");
	printf("           -z      Zero free space\n");
	printf("           -v      Verbose output\n");
	printf("           -V      Verbose debugging output\n");
	printf("           -h      This help\n");
	printf("\n");
	printf("-nx: Upper/lower case filenames, where x is:\n");
	printf("  l  convert filenames to lower case           eg: read.me\n");
	printf("  u  convert filenames to upper case           eg: READ.ME\n");
	printf("  i  convert filenames to initial upper case   eg: Read.me\n");
	printf("  c  convert filenames to camel case           eg: Read.Me\n");
	printf("\n");
	printf("-dx: Date/time on-disk format conversion, where x is:\n");
	printf("  n  convert to new (ProDOS 2.5+) format\n");
	printf("  o  convert to old (ProDOS 1.0-2.4.2, GSOS) format\n");
	printf("\n");
	printf("-sxxx: Dir sort, where xxx is a list of fields to sort\n");
	printf("on. The sort options are processed left-to-right.\n");
	printf("  n  sort by filename ascending\n");
	printf("  N  sort by filename descending\n");
	printf("  i  sort by filename ascending - case insensitive\n");
	printf("  I  sort by filename descending - case insensitive\n");
	printf("  d  sort by modify (or create [-c]) date ascending\n");
	printf("  D  sort by modify (or create [-c]) date descending\n");
	printf("  t  sort by type ascending\n");
	printf("  T  sort by type descending\n");
	printf("  f  sort folders (directories) to top\n");
	printf("  F  sort folders (directories) to bottom\n");
	printf("  b  sort by blocks used ascending\n");
	printf("  B  sort by blocks used descending\n");
	printf("  e  sort by EOF position ascending\n");
	printf("  E  sort by EOF position descending\n");
	printf("\n");
	printf("-fx: Fix mode, where x is:\n");
	printf("  ?  prompt for each fix\n");
	printf("  n  never fix\n");
	printf("  y  always fix (be careful!)\n");
	printf("\n");
	printf("e.g.: sortdir -w -s nf .\n");
	printf("Will sort the current directory first by name (ascending),\n");
	printf("then sort directories to the top, and will write the\n");
	printf("sorted directory to disk.\n");
	exit(2);
}

/*
 * Performs all actions for a single directory
 * blocknum is the keyblock of the directory to process
 */
void processdir(uint device, uint blocknum) {
	flushall();
	uchar errs = readdir(device, blocknum);
	if (doverbose) {
		printlist();
	}
	if ((strlen(fixopts) == 0) && errs) {
		printf("Error scanning directory, will not sort\n");
		goto done;
	}
	if (strlen(sortopts) > 0) {
		for (uchar i=0; i<strlen(sortopts); ++i) {
			if (doverbose) {
				printf("Sorting - order '%c' ...\n",
				    sortopts[i]);
			}
			sortlist(sortopts[i]);
		}
		sortblocks(device);
		if (doverbose) {
			puts("After sorting ...");
			printlist();
		}
		if (dowrite) {
			hline();
			puts("Writing modified directory to disk");
			errs = writedir(device);
		} else
			puts("Not writing to disk without -w");
	}
done:
	freeblocks();
}

/*
 * Iterate through freelist[] and usedlist[] and see if all is well.
 * If we have visited all files and directories on the volume, every
 * block should either be marked free or marked used.
 */
void checkfreeandused(uchar device) {
	printf("Total blocks on volume\t%u\n", totblks);
	uint freeblks = 0;
	for (uint i=0; i<totblks; ++i)
		if (isfree(i))
			++freeblks;
	printf("Free blocks on volume\t%u\n", freeblks);
	printf("Percentage full\t\t%.1f\n",
	       100.0 * (float)(totblks - freeblks) / totblks);
	for (uint i=0; i<totblks; ++i) {
		uint idx = i / 8;
		if (!(freelist[idx] ^ usedlist[i]))	/* Speed-up */
			continue;
		if (isfree(i)) {
			if (isused(i)) {
				err(NONFATAL,
				    "Block %u used, marked free", i);
				if (askfix() == 1)
					marknotfree(i);
			}
		} else {
			if (!isused(i)) {
				err(NONFATAL,
				    "Block %u unused, not marked free", i);
				if (askfix() == 1)
					markfree(i);
			}
		}
	}
	if (dozero)
		zerofreeblocks(device, freeblks);
}

/*
 * Zero block blocknum
 */
void zeroblock(uchar device, uint blocknum) {
	bzero(buf, BLKSZ);
	DIORecGS dr;
	dr.pCount = 6;
	dr.devNum = device;
	dr.buffer = buf;
	dr.requestCount = BLKSZ;
	dr.startingBlock = blocknum;
	dr.blockSize = BLKSZ;
	DWriteGS(&dr);
	if (dr.transferCount != BLKSZ)
		err(FATAL, "Block write failed");
}

/*
 * Zero all free blocks on the volume
 */
void zerofreeblocks(uchar device, uint freeblks) {
	puts("Zeroing free blocks ...");
	uint step = freeblks / 60;
	uint ctr = 0;
	for (uint i=0; i<totblks; ++i)
		if (isfree(i)) {
			zeroblock(device, i);
			++ctr;
			if (ctr == step) {
				putchar('=');
				fflush(stdout);
				ctr = 0;
			}
		}
	puts("\nDone zeroing!");
}

int main(int argc, char *argv[]) {

	if (argc < 2) {
		usage();
		exit(1);
	}
	int opt;
	while ((opt = getopt(argc, argv, "cDrwvVzs:n:f:d:h")) != -1) {
		switch (opt) {
		case 'c':
			do_ctime = 1;
			break;
		case 'D':
			dowholedisk = 1;
			dorecurse = 1;
			break;
		case 'r':
			dorecurse = 1;
			break;
		case 'w':
			dowrite = 1;
			break;
		case 'v':
			doverbose = 1;
			break;
		case 'V':
			dodebug = 1;
			break;
		case 'z':
			dozero = 1;
			dowholedisk = 1;
			dorecurse = 1;
			break;
		case 's':
			strncpy(sortopts, optarg, 5);
			break;
		case 'n':
			strncpy(caseopts, optarg, 1);
			break;
		case 'f':
			strncpy(fixopts, optarg, 1);
			break;
		case 'd':
			strncpy(dateopts, optarg, 1);
			break;
		case 'h':
		default:
			usage();
		}
	}

	if (optind != argc - 1)
		usage();

	if (((strlen(caseopts) > 0) || (strlen(fixopts) > 0) ||
	     (strlen(dateopts) > 0)) && (strlen(sortopts) == 0))
		strncpy(sortopts, ".", 1);

	uchar dev;
	uint blk;
	if (firstblk(argv[optind], &dev, &blk) != 0) {
		exit(1);
	}
	readfreelist(dev);
	if (dowholedisk)
		processdir(dev, 2);
	else
		processdir(dev, blk);
	if (dorecurse) {
		while (dirs) {
			struct dirblk *d = dirs;
			blk = dirs->blocknum;
			dirs = d->next;
			free(d);
			processdir(dev, blk);
		}
	}
	if (dowholedisk)
		checkfreeandused(dev);
	free(freelist);
	free(usedlist);
	err(FINISHED, "");
}