/*
Program: RWTEST.C
Author : Kim Moser
Date   : 09/11/89
System : IBM PC / Borland Turbo-C 2.0
Descrip: Performs a read/write test on every track and sector of a
	 given drive.  Reports any bad sectors.

Usage  : RWTEST [d]

	 where 'd' is the letter of the drive which contains the
	 disk(ette) to be tested.  If 'd' is not specified, then the
	 currently logged drive will be tested.
*/

#include <stdio.h>
#include <conio.h>
#include <dir.h>
#include <stdlib.h>
#include <alloc.h>
#include <ctype.h>
#include <dos.h>
#include <mem.h>

char DRV;  /* Determined at runtime; 0=A:, 1=B:, etc. */
int WARNDAMAGE = 0;  /* Whether data may have been corrupted */

static void credits(void);
static void credits(void)
{
	fprintf( stderr, "RWTEST v1.0 (09/11/89)  Copyright (C) 1989  Kim Moser  All Rights Reserved\n\n" );
}

static void usage(void);
static void usage(void)
{
	fprintf( stderr, "Usage: RWTEST d:\n" );
	fprintf( stderr, "Tests every byte of every sector of every cluster on drive 'd'\n" );
	fprintf( stderr, "and reports any sector which does not reliably hold data.\n" );
}

static void dodrive(void);
static void dodrive(void)
{
/*
	char fi_sclus;  /* Sectors per cluster */
	char fi_fatid;  /* FAT id byte */
	int fi_nclus;  /* Number of clusters */
	int fi_bysec;  /* Bytes per sector */
*/
	struct fatinfo FAT;
	unsigned char *sect1, *sect2, *hold;  /* Will point to space the size of a sector */
	int clus, sect, byte;
	int wasAltered;
	int done;
	int out=0;
	unsigned long p;

	FAT.fi_bysec=0;

	getfat(DRV+1, &FAT);  /* 0=default, 1=A, 2=B, etc. */

	/* 0 bytes per sector indicates an error getting FAT info */
	if (!FAT.fi_bysec) {
		fprintf( stderr, "\nError: either %c: is an invalid drive or it can not be read.\n", DRV+'A' );
		exit(-1);
	}

	/* Allocate room for 3 sectors: */
	byte = ((sect1=malloc((size_t)FAT.fi_bysec))==NULL);
	byte |= ((sect2=malloc((size_t)FAT.fi_bysec))==NULL);
	if ( byte|=((hold=malloc((size_t)FAT.fi_bysec))==NULL) ) {
		fprintf( stderr, "Unable to allocate enough memory.\n" );
		exit(-1);
	}

	fprintf( stderr, "\nDrive %c: %d clusters, %d sector(s) per cluster, %d bytes per sector\n",
		DRV+'A', FAT.fi_nclus, (int)FAT.fi_sclus, FAT.fi_bysec );

	fprintf( stderr, "Working; please wait (hit any key to abort)...\n" );

	for (clus=0; (clus<FAT.fi_nclus) && !out; clus++) {  /* For every cluster... */
		for (sect=0; (sect<FAT.fi_sclus) && !out; sect++) {  /* For every sector */
			p = (100.0*clus) / FAT.fi_nclus;
			fprintf( stderr, "Cluster %d, sector %d (%ld%% done): ", clus, sect, p );

			if (kbhit()) {
				getch();
				done=0;
				fprintf( stderr, "\nContinue (Y/N)? " );
				do {
					switch (toupper(getch())) {
						case 'Y':
							fputc('Y', stderr);
							done=1;
							break;
						case 'N':
							fputc('N', stderr);
							done=1;
							out=1;
							fprintf( stderr, "\nProgram aborted by user.\n" );
							break;
						default:
							fputc('\a', stderr);
							break;
					}
				} while (!done);
				if (!out) {
					fputc('\n', stderr);
				}
			}
			if (!out) {
				wasAltered = 0;
				/* Read old sector: */
				fprintf( stderr, "Reading  \b\b\b\b\b\b\b\b\b" );
				if (absread(DRV,1,sect,hold)) {
					printf( "\nError reading original data from cluster %d, sector %d\n", clus, sect );
					printf( "(Skipping to next sector)\n" );
					break;  /* Skip to next sector */
				}
				/* Make a random sector :*/
				for (byte=0; byte<FAT.fi_bysec; byte++)
					sect1[byte] = (unsigned char)random(256);
				/* Write it and read it back: */
				fprintf( stderr, "Writing\b\b\b\b\b\b\b" );
				if ( abswrite(DRV,1,sect,sect1) ) {
					printf( "\nError writing cluster %d, sector %d\n", clus, sect );
				} else {
					wasAltered = 1;
					fprintf( stderr, "Reading\b\b\b\b\b\b\b" );
					if ( absread(DRV,1,sect,sect2) ) {
						printf( "\nError reading cluster %d, sector %d\n", clus, sect );
					} else {
						/* Make sure it was read properly: */
						if ( memcmp(sect1, sect2, FAT.fi_bysec) ) {
							printf( "\nData on cluster %d, sector %d is unstable.\n", clus, sect );
						}
					}
					if (wasAltered) {
						fprintf( stderr, "Writing  \b\b\b\b\b\b\b\b\b" );
						if (abswrite(DRV,1,sect,hold)) {
							printf( "\nError writing original data to cluster %d, sector %d\n", clus, sect );
							WARNDAMAGE=1;
						}
					}
				}
				fprintf( stderr, "%c", 13 );
			}
		}
	}

	free(sect1);
	free(sect2);
	free(hold);

	if (!out) {
		fprintf( stderr, "\nDone.\n" );
	}
}

void main(int argc, char **argv)
{
	int current=0;
	int done;

	credits();

	current = getdisk();

	if (argc==1) {
		usage();
		exit(-1);
	}

	DRV = toupper(argv[1][0])-'A';

	done = setdisk(DRV);  /* Log to drive DRV to see if it's valid... */
	setdisk(current);  /* ...and log back to current drive */
	if (!done) {
		fprintf( stderr, "Unable to log to drive %c:\n", DRV+'A' );
		exit(-1);
	}

	fprintf( stderr, "IF THE DISK(ETTE) IN DRIVE %c: IS FAULTY, INFORMATION ON IT MAY BE ALTERED!\nDO YOU WANT TO CONTINUE (Y/N)? ", DRV+'A' );

	done=0;
	do {
		switch (toupper(getch())) {
			case 'N':
				fprintf( stderr, "N\nProgram aborted by user.\n" );
				exit(1);
			case 'Y':
				fprintf( stderr, "Y\n" );
				done=1;
				break;
			default:
				fprintf( stderr, "\a" );
				break;
		}
	} while (!done);

	dodrive();

	if (WARNDAMAGE) {
		printf( "Warning: data may have been damaged.\n" );
	}

	exit(0);
}