/***
*disklib.c - disked library
*
*Copyright (c) 1991-1995, Gregg Jennings. All wrongs reserved.
* P O Box 200, Falmouth, MA 02541-0200
*
*Purpose:
* Main library functions.
*
*Notice:
* This progam may be freely used and distributed. Any distrubution
* with modifications must retain the above copyright statement and
* modifications noted.
* No pulp-publication, in whole or in part, permitted without
* permission (magazines or books).
*******************************************************************************/
/*
Versions
2.7 18-Mar-1995 moved find() into SEARCH.C
2.6 15-Mar-1995 file tracking stuff
2.7 05-Mar-1995 rewrote dparams() to show everything
2.6 10-Sep-1994 fixed %u on num_sectors in dparams()
complier checks in dparams()
2.5 02-Sep-1994 consolodated print vs printf
2.4 18-Apr-1994 removed text to data.c
2.3 13-Mar-1994 find() changes
2.2 01-Feb-1994 'dir_cluster' test bug fix
2.1 04-Jan-1994 added Translate if !Files for startup
added 'dir_cluster'
help()
*/
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <dos.h>
#include <malloc.h>
#include <errno.h>
#include "disked.h"
#include "diskio.h"
#include "mylib.h"
#include "files.h"
#include "keys.h"
#include "error.h"
#include "dpb.h"
#include "dirent.h"
#include "console.h"
/* static functions */
static void filename(unsigned int);
/* set to track, sector, head
Passed pointer to string, number of values, and struct of type
Msg which holds the messages to display for each value and
the number of digits for each value.
Modification of get() to return immediately on an 'f' or 'b'.
Returns a string containing the values seperated by commas
to be converted by sscanf().
Globals: Display, Radix.
*/
extern int set(struct Msg *str, int *t, int *s, int *h)
{
register int c,i,n;
long l;
char ts[7];
for (i = n = 0; n < 3; n++, i = 0, str++)
{
if (Display)
print(str->msg);
while ((c = input()) != '\r' && c != ' ' && c != ',')
{
if (n == 0 && i == 0 && (c == 'f' || c == 'b'))
{
output(c); /* special: Fat, Boot */
return(c);
}
if (c == '\b' && i != 0) /* backspace, delete number */
{
output(c); /* in buffer */
output(' '); /* and on screen */
output(c);
--i; /* move pointer back */
}
else if (c == 0x1b || c == 3) /* ESC, ^C to abort */
return 0; /* RETURN */
else if (Radix == 16 && !isxdigit(c))
continue;
else if (Radix==10 && !isdigit(c))
continue;
else
{
output(c);
ts[i++] = (char)c; /* save and echo numbers */
if (i == str->len)
break;
}
}
ts[i] = '\0';
if (i)
{
l = strtol(ts,NULL,Radix); /* strtol() for radix */
if (n == 0)
*t = (int)l;
else if (n == 1)
*s = (int)l;
else
*h = (int)l;
}
if (c == '\r')
break;
if (!Display && n < 2)
output(',');
}
return 1;
}
/* get a string for conversion to numbers
Passed pointer to string, number of values, and struct of type
Msg which holds the messages to display for each value and
the number of digits for each value.
Returns a string containing the values seperated by commas
to be converted by sscanf().
Globals: Display, Radix.
*/
extern int get(struct Msg *str,int *one, int *two)
{
register int t,v;
char temp[7];
for (t = 0; t < 2; t++, str++)
{
if (Display)
print(str->msg);
if (getstr(temp,str->len,(Radix == 16) ? _HEX : _DIGIT) > 0)
{
v = atoi(temp);
if (t == 0)
*one = v;
else
*two = v;
}
else
return 0; /* RETURN */
if (!Display && t < 1)
output(',');
}
return 1;
}
/* get - long version */
extern int getl(struct Msg *str, long *one, int *two)
{
register int t;
int i;
char temp[7];
long l;
for (t = 0; t < 2; t++, str++)
{
if (Display)
print(str->msg);
if ((i = getstr(temp,str->len,(Radix == 16) ? _HEX : _DIGIT)) > 0)
{
l = strtol(temp,NULL,Radix);
if (t == 0)
*one = l;
else
*two = (int)l;
}
else if (!t && i == -3)
print("%l",*one); /* putlong(*one); */
else
return 0;
if (!Display && t < 1)
output(',');
}
return(1);
}
/* display sector header */
extern void header(void)
{
register unsigned int i,j;
print("\nSector %lu",log_sector);
i = sectortocluster(log_sector);
j = clustersector(log_sector)+1;
if (log_sector > (dword)data_sector)
{
if (Radix == 10)
print(", Cluster %u:%u",i,j);
else
print(", Cluster %x:%x",i,j);
}
else
{ unsigned sector = (word)log_sector;
if (sector < reserved_secs)
{
print(" BOOT");
if (reserved_secs > 1)
print(" %d:%d",sector+1,reserved_secs);
}
else if (sector >= reserved_secs && sector <= secs_fat)
print(" FAT 1 %d:%d %d-BIT",
sector-reserved_secs+1,secs_fat,fat_size);
else if (num_fats > 1 && sector > secs_fat
&& sector <= (secs_fat*num_fats))
print(" FAT 2 %d:%d %d-BIT",
(sector-reserved_secs-secs_fat)+1,secs_fat,fat_size);
else if (sector >= dir_sector && sector <= data_sector)
print(" ROOT %d:%d",(sector-dir_sector)+1,dir_sectors);
}
if (!Logical)
print(" (t%u,h%u,s%u)",track,head,sector);
if (diskio_error)
print(" <BAD>");
if (Files > 0 && n_files)
filename(i);
}
static void filename(unsigned int i)
{
if (log_sector > (dword)data_sector && i < num_clusters)
{
if (clusters[i] > 0 && (unsigned)clusters[i] <= n_files)
{
output(' ');
print(gfile(clusters[i]));
if (files[clusters[i]].dir)
print(" <DIR>");
}
}
}
/* display disk drive info
Serial No: Drive Size: Root Sector:
Buffer Size: Sectors: Data Sector:
DOS Version: Sector Size: Reserved Sectors:
Number of Drives: Clusters: Hidden Sectors:
Current Drive: Cluster Size: Tracks:
Media: Secs/Cluster: Heads:
Volume: Number FATs: Sectors:
Serial ID: Secs/FAT: Sector Size:
Current Dir:
*/
extern void dparams(char *drivedir)
{
print("\n");
print("\n Serial No:%s",Version);
print("\t Drive Size: %lu",drive_size);
print("\t Root Sector: %u",dir_sector);
print("\n Buffer Size: %u",max_bytes);
print("\t Sectors: 0-%lu",num_sectors-1);
print("\t Data Sector: %u",data_sector);
#if defined(_MSC_VER)
print("\n DOS Version: %d.%d.%d",_osmajor,_osminor,_osmode);
#elif defined(__WATCOM__)
print("\n DOS Version: %d.%d.%d",_osmajor,_osminor,_osmode);
#else
print("\n DOS Version: %d.%d",_osmajor,_osminor);
#endif
print("\t Sector Size: %u",sec_size);
print("\t Reserved Sectors: %u",reserved_secs);
print("\n Number of Drives: %u",max_drive);
print("\t Clusters: 2-%u",num_clusters);
print("\t Hidden Sectors: %lu",hidden_secs);
print("\n Current Drive: %c:",disk+'@');
print("\t Cluster Size: %u",cluster_size);
print("\t Tracks: 0-%u",max_track);
print("\n Media: %s",format);
print("\t Sectors/Cluster: %u",secs_cluster);
print("\t Heads: 0-%u",max_head-1);
print("\n Volume: %-11.11s", (volume[0]=='\0') ? "?" : volume);
print("\t Number FATs: %u",num_fats);
print("\t Sectors: 1-%u",max_sector);
print("\n Serial ID:");
print("\t\t Sectors/FAT: %u",secs_fat);
print("\t Sector Size: %u",sec_size);
print("\n Current Dir: %s",&drivedir[2]);
}
/*
Read the next sector, display, continue. Checks console for
speed control and abort.
pass: direction, forward or backward. value, number of sectors
ver 1.1 9/91 added +1 to kbhit loop to correct '0' bug
*/
extern void range(int val)
{
register int i;
static int speed=4*50;
int io;
int c='4',b='4';
for (;;)
{
if ((io = movesector(val)) != DISK_OK)
{
output('\n');
printerror(Debug);
if (io == DISK_NREADY) /* door open! */
break;
}
dumpsector();
for (i = 0; i < speed; i++) /* loop in wait */
if (kbhit())
c = input();
if (isdigit(c)) /* reset speed, the same if c */
{
speed = ((c-'0')*50+1); /* did not change */
b = c;
}
else if (c == ' ')
{
input();
c = b;
}
else
break;
}
}
/***
*dumpsector() - display sector buffer (front-end)
*
* 2.4 25-Nov-1994 BigScreen reference
* 2.3 01-Apr-1994 no '\n' if !Partial
* 2.2 01-Feb-1994 (dir_cluster && ) addtition
* 2.1 04-Jan-1994 added Translate if !Files for startup
****/
extern void dumpsector(void)
{
int i;
word sector;
i = sectortocluster(log_sector);
sector = (word)log_sector;
if (Partial)
output('\n');
header();
if (Translate)
if ( (Files && clusters[i] > 0 && files[clusters[i]].dir)
|| (sector >= dir_sector && sector <= data_sector)
|| (dir_cluster && sectortocluster(log_sector) == dir_cluster)
)
{
dumpdir(sec_buf,sec_size);
return;
}
if (!Ascii)
{
if (BigScreen)
dump(sec_buf,0,sec_size,sec_size,Radix);
else if (Partial)
dump(sec_buf,0,sec_size,128,Radix);
else
dumpf(sec_buf,sec_size,Radix);
}
else
view(sec_buf,0,sec_size,NOPAUSE,Radix);
if (Partial || Ascii)
output('\n');
}
/***
* display databuffer, displaying all non-printable
* characters enclosed in <>
*
* Another complicated, horrible looking function.
*
* 0.1 15-Mar-1995 ft_track
****/
view(
register unsigned char *buffer, /* array of data */
unsigned int bfptr, /* index into array */
unsigned int bufend, /* size of array */
int pause,
int base)
{
register int c;
int length;
int p,n,nn,np;
p = n = nn = np = 0;
output('\n');
if (pause)
{
length = 21;
if (ft_track)
{
long l = filebytes();
if (base == 10)
print("%ld:\n",(long)bfptr + l);
else
print("%lx:\n",(long)bfptr + l);
}
else
{
if (base == 10)
print("%u:\n",bfptr);
else
print("%x:\n",bfptr);
}
}
else
{
length=sec_size;
output('\n');
}
do
{
c = (int)buffer[bfptr++];
if (bfptr > bufend)
{
bfptr = 0;
break;
}
if (p > 75)
{
p = 0;
++n;
++nn;
++np;
}
if (!isprint(c) && !isspace(c))
{
if (Strip) /* do we strip? */
continue;
if (Mask) /* do we mask ? */
c&=0x7f;
else if (Convert) /* do we convert? */
{
print("<%02x>",c);
p+=4;
continue;
}
}
if (c==7 || c==255 || c==0 || c==8)
continue;
if (c=='\n')
{
n++;
++nn;
p=0;
}
if (c!='\r')
{
output(c);
p++;
}
} while (n<length);
if (pause)
{
output('\n');
pnlz(bfptr,(getlen(bfptr,base)),base);
output(':');
}
return(bfptr);
}
/* lame attempt to display BOOT parameters */
void dumpboot(byte *buf)
{
struct BOOT b;
int i;
memcpy(&b,buf,sizeof(struct BOOT));
output('\n');
switch(b.jump[0])
{
case 0xeb:
print("JMP SHORT ");
puthex(b.jump[1]);
break;
case 0xe9:
print("JMP ");
puthex(b.jump[1]);output(':');puthex(b.jump[2]);
break;
case 0xff:
case 0xea:
print("JMP other ");
break;
default:
print("unknown");
}
output('\n');
print("OEM name:\t\t\t");
for (i=0;i<8;i++)
print("%02X",b.name[i]);
print("\nbytes per sector: %04X\n",b.sec_size);
print("sectors per allocation unit: %02X\n",b.secs_cluster);
print("reserved sectors: %04X\n",b.reserved_secs);
print("number of FATs: %02X\n",b.num_fats);
print("number of root dir entries: %04X\n",b.dir_entries);
print("number of sectors in logical image: %04X\n",b.num_sectors);
print("media descriptor: %02X\n",b.media_desc);
print("number of FAT sectors: %04X\n",b.secs_fat);
print("sectors per track: %04X\n",b.secs_track);
print("number of heads: %04X\n",b.num_heads);
print("number of hidden sectors: %04X\n",b.hidden_sectors);
print("high order number of hidden sectors: %04X\n",b.large_sectors);
print("number of logical sectors: %08X\n",b.total_sectors);
}
void help(void)
{
int c;
print(" Dir Boot Fat ?");
c = (int)(char)input();
if (c == 'd')
disptext(dir_help);
else if (c == 'b')
print(" not yet");
else if (c == 'f')
print(" not yet");
}
/***
* Display data in a HEX-ASCII format, starting at buf, ending at
* bufend. Returns the number of bytes displayed. bufend _must_
* be a multiple of 128
*
* unsigned char *buffer; - array of data
* unsigned int bfptr; - index into array
* unsigned int bufend; - size of array
* unsigned int len; - number of bytes to display
* int base;
*
* 0.2 15-Mar-1995 ft_track
* 0.1 15-Feb-1995 Filter
****/
int dump(unsigned char *buffer, unsigned int bfptr, unsigned int bufend, \
unsigned int len, int base)
{
register unsigned int c;
unsigned int l,n;
register int b;
if (bfptr > bufend)
bfptr = 0;
if (len > bufend)
len = bufend;
n = bfptr;
for (l = 0; l < len; l+=16)
{
if (ft_track)
{
long l = filebytes();
if (base == 10)
print("\n%08ld: ",(long)bfptr + l);
else
print("\n%06lx: ",(long)bfptr + l);
}
else
print((base==10)?"\n%0*d: ":"\n%0*x: ",getlen(bufend,base),bfptr);
for (b = 0; b < 16; b++)
{
c = buffer[bfptr];
output( ((c>>=4) > 9) ? (c+0x57) : (c+'0'));
c=buffer[bfptr];
output( ((c&=0xf) > 9) ? (c+0x57) : (c+'0'));
output(' ');
if (++bfptr == bufend)
{
bfptr = 0;
break;
}
}
for (b = 0; b < 16; b++)
{
c = buffer[n];
if (Filter)
output( (c>=' ' && c<=0xfe) ? (c) : ('.'));
else
{
charout( (c != 0 && c != 255) ? (c) : ('.'));
curright();
}
if (++n == bufend)
{
n = 0;
if (l < (len-16))
output('\n');
break;
}
}
}
return bfptr;
}
/***
*dumpf - Display sector contents to the screen in HEX/ASCII.
*
* Notes: This fills the entire screen width, and for the output()
* function, a CR/LF is automatically performed. If Filter
* is OFF, the charout() function (which uses the BIOS) does
* not do this.
*
* 0.2 15-Mar-1995 ft_track
* 0.1 15-Feb-1995 Filter
****/
void dumpf(register unsigned char *buffer, int size, int base)
{
register int c;
int i,j;
int ptr;
output('\n');
for (ptr = i = 0; i < size; i += 24)
{
#if 0 /* for this dump, file tracking */
if (ft_track) /* offset display messes things */
{ /* up */
long l = filebytes();
if (base == 10)
print("%08ld: ",(long)i + l);
else
print("%06lx: ",(long)i + l);
}
else
#endif
print((base==10)?"%0*d: ":"%0*x: ",getlen(size,base),i);
for (j = 1; j <= 24; j++)
{
c = buffer[ptr];
output( ((c>>=4) > 9) ? (c+0x57) : (c+'0'));
c = buffer[ptr];
output( ((c&=0xf) > 9) ? (c+0x57) : (c+'0'));
if (++ptr >= size)
{
output(' ');
j = 9;
break;
}
if (j%8 == 0)
output(' ');
}
ptr -= (j-1);
for (j = 1; j <= 24; j++)
{
c = buffer[ptr];
if (Filter)
output( (c<' ' || c>0xfe) ? ('.') : (c));
else
{
charout( (c != 0 && c != 255) ? (c) : ('.'));
if (j < 24)
curright();
else
output('\n');
}
if (++ptr >= size)
break;
}
}
}
/* command prompt */
int prompt(int n, int base)
{
unsigned int key;
output('\n');
output('(');
pnlz(n,(base==16)?4:5,base);
output(')');
if (byte_cnt==max_bytes)
charouta(' ',15);
if (ft_track)
output('t');
if (Files && n_files>1)
output(15);
else
output('*');
bdos(0x0c,0,0);
key=scankey();
if (! ((key&0xff)==0 || key>0x3920 || key<0x011B))
key&=0xff;
if (key<' ')
{
output('^');
output(key+'@');
}
else if (key<0xff)
output(key);
return key;
}
