🚀 go-pugleaf

#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
#	mkentry.c
#	mmd.c
#	mrd.c
#	mread.c
#	mren.c
#	mtype.c
#	mwrite.c
#	putfat.c
#	search.c
#	subdir.c
#	unixname.c
# This archive created: Mon Jul 13 07:34:44 1987
export PATH; PATH=/bin:/usr/bin:$PATH
echo shar: "extracting 'mkentry.c'" '(2501 characters)'
if test -f 'mkentry.c'
then
	echo shar: "will not over-write existing file 'mkentry.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mkentry.c'
X/*
X * mk_entry(), grow()
X */
X
X#include <stdio.h>
X#include <time.h>
X#include "msdos.h"
X
Xextern int fd, dir_start, dir_len, clus_size, dir_entries;
Xextern int dir_chain[25];
X
X/*
X * Make a directory entry.  Builds a directory entry based on the
X * name, attribute, starting cluster number, and size.  Returns a pointer
X * to the directory structure.
X */
X
Xstruct directory *
Xmk_entry(filename, attr, fat, size)
Xchar *filename;
Xunsigned char attr;
Xint fat;
Xint size;
X{
X	long clock, time();
X	int i;
X	char *strncpy();
X	static struct directory ndir;
X	struct tm *now, *localtime();
X	unsigned char hour, min_hi, min_low, sec;
X	unsigned char year, month_hi, month_low, day;
X
X	time(&clock);
X	now = localtime(&clock);
X	strncpy(ndir.name, filename, 8);
X	strncpy(ndir.ext, filename+8, 3);
X	ndir.attr = attr;
X	for (i=0; i<10; i++)
X		ndir.reserved[i] = NULL;
X	hour = now->tm_hour << 3;
X	min_hi = now->tm_min >> 3;
X	min_low = now->tm_min << 5;
X	sec = 0;
X	ndir.time[1] = hour + min_hi;
X	ndir.time[0] = min_low + sec;
X	year = (now->tm_year - 80) << 1;
X	month_hi = (now->tm_mon+1) >> 3;
X	month_low = (now->tm_mon+1) << 5;
X	day = now->tm_mday;
X	ndir.date[1] = year + month_hi;
X	ndir.date[0] = month_low + day;
X	ndir.start[1] = fat / 0x100;
X	ndir.start[0] = fat % 0x100;
X	ndir.size[3] = 0;		/* can't be THAT large */
X	ndir.size[2] = size / 0x10000;
X	ndir.size[1] = (size % 0x10000) / 0x100;
X	ndir.size[0] = (size % 0x10000) % 0x100;
X	return(&ndir);
X}
X
X/*
X * Make a subdirectory grow in length.  Only subdirectories (not root) 
X * may grow.  Returns a 0 on success or 1 on failure (disk full).
X */
X
Xint
Xgrow(fat)
Xint fat;
X{
X	int i, next, last, getfat(), nextfat(), num, sector, buflen;
X	char tbuf[CLSTRBUF];
X	void perror(), exit();
X
X	last = nextfat(0);
X	if (last == -1)
X		return(1);
X
X	while (1) {
X		next = getfat(fat);
X		if (next == -1) {
X			fprintf(stderr, "grow: FAT problem\n");
X			exit(1);
X		}
X					/* end of cluster chain */
X		if (next >= 0xff8)
X			break;
X		fat = next;
X	}
X					/* mark the end of the chain */
X	putfat(fat, last);
X	putfat(last, 0xfff);
X					/* zero the buffer */
X	buflen = clus_size * MSECSIZ;
X	for (i=0; i<buflen; i++)
X		tbuf[i] = NULL;
X
X					/* write the cluster */
X	sector = (last - 2) * clus_size + dir_start + dir_len;
X	move(sector);
X	if (write(fd, tbuf, buflen) != buflen) {
X		perror("grow: write");
X		exit(1);
X	}
X					/* fix up the globals.... */
X	num = dir_entries / 16;
X	dir_entries += clus_size * 16;
X	dir_chain[num] = sector;
X	if (clus_size == 2)
X		dir_chain[num+1] = sector +1;
X	return(0);
X}
SHAR_EOF
if test 2501 -ne "`wc -c < 'mkentry.c'`"
then
	echo shar: "error transmitting 'mkentry.c'" '(should have been 2501 characters)'
fi
fi
echo shar: "extracting 'mmd.c'" '(3758 characters)'
if test -f 'mmd.c'
then
	echo shar: "will not over-write existing file 'mmd.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mmd.c'
X/*
X * Make a MSDOS sub directory
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	int entry, slot, fat, dot, subdir();
X	char *filename, *newfile, *fixname(), *strncpy(), *unixname();
X	char *getpath(), *pathname, tname[9], text[4], *fixed;
X	void exit();
X	struct directory *dir, *search(), *mk_entry();
X
X	if (init(2)) {
X		fprintf(stderr, "mmd: Cannot initialize diskette\n");
X		exit(1);
X	}
X					/* only 1 directory ! */
X	if (argc != 2) {
X		fprintf(stderr, "Usage: mmd <MSDOS directory>\n");
X		exit(1);
X	}
X	fixed = fixname(argv[1]);
X	filename = unixname(fixed, fixed+8);
X	pathname = getpath(argv[1]);
X	if (strcmp(fixed+8, "   ")) {
X		fprintf(stderr, "mmd: Directory names cannot have extensions\n");
X		exit(1);
X	}
X	if (subdir(pathname))
X		exit(1);
X					/* see if exists and get slot */
X	slot = -1;
X	dot = 0;
X	for (entry=0; entry<dir_entries; entry++) {
X		dir = search(entry);
X					/* if empty */
X		if (dir->name[0] == NULL) {
X			if (slot < 0)
X				slot = entry;
X			break;
X		}
X					/* if erased */
X		if (dir->name[0] == 0xe5) {
X			if (slot < 0)
X				slot = entry;
X			continue;
X		}
X					/* if not a directory */
X		if (!(dir->attr & 0x10))
X			continue;
X		strncpy(tname, dir->name, 8);
X		strncpy(text, dir->ext, 3);
X		newfile = unixname(tname, text);
X					/* save the 'dot' directory info */
X		if (!strcmp(".", newfile))
X			dot = dir->start[1]*0x100 + dir->start[0];
X
X		if (!strcmp(filename, newfile)) {
X			fprintf(stderr, "mmd: Directory '%s' already exists\n", filename);
X			exit(1);
X		}
X	}
X					/* no '.' entry means root directory */
X	if (dot == 0 && slot < 0) {
X		printf(stderr, "mmd: No directory slots\n");
X		exit(1);
X	}
X					/* make the directory grow */
X	if (dot && slot < 0) {
X		if (grow(dot)) {
X			fprintf(stderr, "mmd: Disk full\n");
X			exit(1);
X		}
X					/* first slot in 'new' directory */
X		slot = entry;
X	}
X	fat = nextfat(0);
X	if (fat == -1) {
X		fprintf(stderr, "mmd: Disk full\n");
X		exit(1);
X	}
X					/* make directory entry */
X	dir = mk_entry(fixed, 0x10, fat, 0);
X	if (dir != NULL) {
X		writedir(slot, dir);
X					/* write the cluster */
X		putfat(fat, 0xfff);
X		putcluster(fat, dot);
X	}
X					/* write FAT sectors */
X	writefat();
X	close(fd);
X	exit(0);
X}
X
X/*
X * Write a blank directory 'template' to the cluster starting at 'dot'.
X */
X
Xputcluster(dot, dot_dot)
Xint dot;
Xint dot_dot;
X{
X	long start;
X	void exit(), perror();
X	int buflen;
X	static struct directory dirs[32];
X	struct directory *mk_entry();
X
X	start = (dot - 2)*clus_size + dir_start + dir_len;
X	move(start);
X
X	buflen = clus_size * MSECSIZ;
X					/* make the '.' and '..' entries */	
X	dirs[0] = *mk_entry(".          ", 0x10, dot, 0);
X	dirs[1] = *mk_entry("..         ", 0x10, dot_dot, 0);
X
X	if (write(fd, (char *) &dirs[0], buflen) != buflen) {
X		perror("putcluster: write");
X		exit(1);
X	}
X	return;
X}
X
X/*
X * Returns next free cluster or -1 if none are available.
X */
X
Xint
Xnextfat(last)
Xint last;
X{
X	static int i;
X
X	for (i=last+1; i<num_clus+2; i++) {
X		if (!getfat(i))
X			return(i);
X	}
X	return(-1);
X}
SHAR_EOF
if test 3758 -ne "`wc -c < 'mmd.c'`"
then
	echo shar: "error transmitting 'mmd.c'" '(should have been 3758 characters)'
fi
fi
echo shar: "extracting 'mrd.c'" '(3152 characters)'
if test -f 'mrd.c'
then
	echo shar: "will not over-write existing file 'mrd.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mrd.c'
X/*
X * Delete a MSDOS sub directory
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	int ismatch, entry, start, isempty();
X	char *filename, *newfile, text[4], tname[9], *getname();
X	char *strncpy(), *pathname, *getpath(), *unixname();
X	void exit();
X	struct directory *dir, *search();
X
X	if (init(2)) {
X		fprintf(stderr, "mrd: Cannot initialize diskette\n");
X		exit(1);
X	}
X					/* only 1 directory ! */
X	if (argc != 2) {
X		fprintf(stderr, "Usage: mrd <MSDOS directory>\n");
X		exit(1);
X	}
X
X	filename = getname(argv[1]);
X	pathname = getpath(argv[1]);
X	if (subdir(pathname))
X		exit(1);
X	ismatch = 0;
X	for (entry=0; entry<dir_entries; entry++) {
X		dir = search(entry);
X					/* if empty */
X		if (dir->name[0] == NULL)
X			break;
X					/* if erased */
X		if (dir->name[0] == 0xe5)
X			continue;
X					/* if not dir */
X		if (!(dir->attr & 0x10))
X			continue;
X		strncpy(tname, dir->name, 8);
X		strncpy(text, dir->ext, 3);
X		newfile = unixname(tname, text);
X		if (!strcmp(newfile, filename)) {
X			start = dir->start[1]*0x100 + dir->start[0];
X			if (!isempty(start)) {
X				fprintf(stderr, "mrd: Directory '%s' is not empty\n", filename);
X				exit(1);
X			}
X			if (!start) {
X				fprintf(stderr, "mrd: Can't remove root directory\n");
X				exit(1);
X			}
X			zapit(start);
X			dir->name[0] = 0xe5;
X			writedir(entry, dir);
X			ismatch = 1;
X		}
X	}
X	if (!ismatch) {
X		fprintf(stderr, "mrd: Directory '%s' not found\n", filename);
X		exit(1);
X	}
X					/* update the FAT sectors */
X	writefat();
X	close(fd);
X	exit(0);
X}
X
X/*
X * See if directory is empty.  Returns 1 if empty, 0 if not.  Can't use
X * subdir() and search() as it would clobber the globals.
X */
X
Xint
Xisempty(fat)
Xint fat;
X{
X	int i, next, buflen, sector, getfat();
X	unsigned char tbuf[CLSTRBUF];
X	void perror(), exit();
X
X	while (1) {
X		sector = (fat-2)*clus_size + dir_start + dir_len;
X		move(sector);
X		buflen = clus_size * MSECSIZ;
X		if (read(fd, tbuf, buflen) != buflen) {
X			perror("isempty: read");
X			exit(1);
X		}
X					/* check first character of name */
X		for (i=0; i<MSECSIZ; i+=MDIRSIZ) {
X			if (tbuf[i] == '.')
X				continue;
X			if (tbuf[i] != NULL && tbuf[i] != 0xe5)
X				return(0);
X		}
X					/* get next cluster number */
X		next = getfat(fat);
X		if (next == -1) {
X			fprintf(stderr, "isempty: FAT problem\n");
X			exit(1);
X		}
X					/* end of cluster chain */
X		if (next >= 0xff8)
X			break;
X		fat = next;
X	}
X	return(1);
X}
SHAR_EOF
if test 3152 -ne "`wc -c < 'mrd.c'`"
then
	echo shar: "error transmitting 'mrd.c'" '(should have been 3152 characters)'
fi
fi
echo shar: "extracting 'mread.c'" '(4675 characters)'
if test -f 'mread.c'
then
	echo shar: "will not over-write existing file 'mread.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mread.c'
X/*
X * Read (copy) a MSDOS file to Unix
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include <sys/types.h>
X#include <sys/stat.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xlong size;
Xlong current;
Xint textmode = 0;
Xint nowarn = 0;
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	extern int optind;
X	extern char *optarg;
X	int fat, i, ismatch, entry, subdir(), single, c, oops;
X	char *filename, *newfile, text[4], tname[9], *getname(), *unixname();
X	char *strncpy(), *pathname, *getpath(), *target, *tmp, *malloc();
X	char *strcat(), *strcpy();
X	void perror(), exit();
X	struct directory *dir, *search();
X	struct stat stbuf;
X
X	if (init(0)) {
X		fprintf(stderr, "mread: Cannot initialize diskette\n");
X		exit(1);
X	}
X					/* get command line options */
X	oops = 0;
X	while ((c = getopt(argc, argv, "tn")) != EOF) {
X		switch(c) {
X			case 't':
X				textmode = 1;
X				break;
X			case 'n':
X				nowarn = 1;
X				break;
X			default:
X				oops = 1;
X				break;
X		}
X	}
X
X	if (oops || (argc - optind) < 2) {
X		fprintf(stderr, "Usage: mread [-t|-n] <MSDOS file> <Unix file>\n");
X		fprintf(stderr, "    or mread [-t|-n] <MSDOS file> [<MSDOS files...>] <Unix directory>\n");
X		exit(1);
X	}
X					/* only 1 file to copy... */
X	single = 1;
X	target = argv[argc-1];
X					/* ...unless last arg is a directory */
X	if (!stat(target, &stbuf)) {
X		if (stbuf.st_mode & 040000)
X			single = 0;	
X	}
X
X	for (i=optind; i<argc-1; i++) {
X		filename = getname(argv[i]);
X		pathname = getpath(argv[i]);
X		if (subdir(pathname))
X			continue;
X		ismatch = 0;
X		for (entry=0; entry<dir_entries; entry++) {
X			dir = search(entry);
X					/* if empty */
X			if (dir->name[0] == NULL)
X				break;
X					/* if erased */
X			if (dir->name[0] == 0xe5)
X				continue;
X					/* if dir or volume lable */
X			if ((dir->attr & 0x10) || (dir->attr & 0x08))
X				continue;
X			strncpy(tname, dir->name, 8);
X			strncpy(text, dir->ext, 3);
X			newfile = unixname(tname, text);
X			fat = dir->start[1]*0x100 + dir->start[0];
X			size = dir->size[2]*0x10000 + dir->size[1]*0x100 + dir->size[0];
X					/* if single file */
X			if (single) {
X				if (!strcmp(newfile, filename)) {
X					readit(fat, target);
X					ismatch = 1;
X					break;
X				}
X			}
X					/* if multiple files */
X			else {
X				if (match(newfile, filename)) {
X					printf("Copying %s\n", newfile);
X					tmp = malloc(strlen(target)+1+strlen(newfile)+1);
X					strcpy(tmp, target);
X					strcat(tmp, "/");
X					strcat(tmp, newfile);
X					readit(fat, tmp);
X					ismatch = 1;
X				}
X			}
X		}
X		if (!ismatch) {
X			fprintf(stderr, "mread: File '%s' not found\n", filename);
X			continue;
X		}
X	}
X	close(fd);
X	exit(0);
X}
X
X/*
X * Decode the FAT chain given the begining FAT entry, open the named Unix
X * file for write.
X */
X
Xreadit(fat, target)
Xint fat;
Xchar *target;
X{
X	char ans[10];
X	void exit();
X	FILE *fp;
X
X	current = 0L;
X	if (!nowarn) {
X		if (!access(target, 0)) {
X			while (1) {
X				printf("File '%s' exists, overwrite (y/n) ? ", target);
X				gets(ans);
X				if (ans[0] == 'n' || ans[0] == 'N')
X					return;
X				if (ans[0] == 'y' || ans[0] == 'Y')
X					break;
X			}
X		}
X	}
X
X	if (!(fp = fopen(target, "w"))) {
X		fprintf(stderr, "mread: Can't open '%s' for write\n", target);
X		return;
X	}
X
X	while (1) {
X		getcluster(fat, fp);
X					/* get next cluster number */
X		fat = getfat(fat);
X		if (fat == -1) {
X			fprintf(stderr, "mread: FAT problem\n");
X			exit(1);
X		}
X					/* end of cluster chain */
X		if (fat >= 0xff8)
X			break;
X	}
X	fclose(fp);
X	return;
X}
X
X/*
X * Read the named cluster, write to the Unix file descriptor.
X */
X
Xgetcluster(num, fp)
Xint num;
XFILE *fp;
X{
X	int i, buflen, start;
X	void exit(), perror();
X	char buf[CLSTRBUF];
X
X	start = (num - 2)*clus_size + dir_start + dir_len;
X	move(start);
X
X	buflen = clus_size * MSECSIZ;
X	if (read(fd, buf, buflen) != buflen) {
X		perror("getcluster: read");
X		exit(1);
X	}
X					/* stop at size not EOF marker */
X	for (i=0; i<buflen; i++) {
X		current++;
X		if (current > size) 
X			break;
X		if (textmode && buf[i] == '\r')
X			continue;
X		fputc(buf[i], fp);
X	}
X	return;
X}
SHAR_EOF
if test 4675 -ne "`wc -c < 'mread.c'`"
then
	echo shar: "error transmitting 'mread.c'" '(should have been 4675 characters)'
fi
fi
echo shar: "extracting 'mren.c'" '(2628 characters)'
if test -f 'mren.c'
then
	echo shar: "will not over-write existing file 'mren.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mren.c'
X/*
X * Rename an existing MSDOS file
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	int entry, ismatch, subdir(), nogo, isdir();
X	char *filename, *newfile, *fixname(), *strncpy(), *unixname();
X	char *getpath(), *pathname, tname[9], text[4], *getname(), *target;
X	char *new, ans[10], *temp, *strcpy();
X	void exit();
X	struct directory *dir, *search();
X
X	if (init(2)) {
X		fprintf(stderr, "mren: Cannot initialize diskette\n");
X		exit(1);
X	}
X	if (argc != 3) {
X		fprintf(stderr, "Usage: mren <MSDOS source file> <MSDOS target file>\n");
X		exit(1);
X	}
X	filename = getname(argv[1]);
X	pathname = getpath(argv[1]);
X	if (subdir(pathname))
X		exit(1);
X
X	temp = getname(argv[2]);
X	target = fixname(argv[2]);
X	if (isdir(filename) && strcmp(target+8, "   ")) {
X		strcpy(target+8, "   ");
X		fprintf(stderr, "mren: Directory names may not have extentions\n");
X	}
X	new = unixname(target, target+8);
X	nogo = 0;
X					/* the name supplied may be altered */
X	if (strcmp(temp, new)) {
X		while (!nogo) {
X			printf("Do you accept '%s' as the new file name (y/n) ? ", new);
X			gets(ans);
X			if (ans[0] == 'y' || ans[0] == 'Y')
X				break;
X			if (ans[0] == 'n' || ans[0] == 'N')
X				nogo = 1;
X		}
X	}
X	if (nogo)
X		exit(0);
X					/* see if exists and do it */
X	ismatch = 0;
X	for (entry=0; entry<dir_entries; entry++) {
X		dir = search(entry);
X					/* if empty */
X		if (dir->name[0] == NULL)
X			break;
X					/* if erased */
X		if (dir->name[0] == 0xe5)
X			continue;
X					/* you may rename a directory */
X		strncpy(tname, dir->name, 8);
X		strncpy(text, dir->ext, 3);
X		newfile = unixname(tname, text);
X		if (!strcmp(filename, newfile)) {
X			ismatch = 1;
X			strncpy(dir->name, target, 8);
X			strncpy(dir->ext, target+8, 3);
X			writedir(entry, dir);
X		}
X	}
X	if (!ismatch) {
X		fprintf(stderr, "mren: File '%s' not found\n", filename);
X		exit(1);
X	}
X	close(fd);
X	exit(0);
X}
SHAR_EOF
if test 2628 -ne "`wc -c < 'mren.c'`"
then
	echo shar: "error transmitting 'mren.c'" '(should have been 2628 characters)'
fi
fi
echo shar: "extracting 'mtype.c'" '(3462 characters)'
if test -f 'mtype.c'
then
	echo shar: "will not over-write existing file 'mtype.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mtype.c'
X/*
X * Display contents of a MSDOS file
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xlong size;
Xlong current;
Xstripmode = 0;
Xtextmode = 0;
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	extern int optind;
X	extern char *optarg;
X	int fat, i, ismatch, entry, subdir(), c, oops;
X	char *filename, *newfile, text[4], tname[9], *getname(), *unixname();
X	char *strncpy(), *pathname, *getpath();
X	void exit();
X	struct directory *dir, *search();
X
X	if (init(0)) {
X		fprintf(stderr, "mtype: Cannot initialize diskette\n");
X		exit(1);
X	}
X					/* get command line options */
X	oops = 0;
X	while ((c = getopt(argc, argv, "st")) != EOF) {
X		switch(c) {
X			case 's':
X				stripmode = 1;
X				break;
X			case 't':
X				textmode = 1;
X				break;
X			default:
X				oops = 1;
X				break;
X		}
X	}
X
X	if (oops || (argc - optind) < 1) {
X		fprintf(stderr, "Usage: mtype [-s|-t] <MSDOS file> [<MSDOS files...>]\n");
X		exit(1);
X	}
X
X	for (i=optind; i<argc; i++) {
X		filename = getname(argv[i]);
X		pathname = getpath(argv[i]);
X		if (subdir(pathname))
X			continue;
X		ismatch = 0;
X		for (entry=0; entry<dir_entries; entry++) {
X			dir = search(entry);
X					/* if empty */
X			if (dir->name[0] == NULL)
X				break;
X					/* if erased */
X			if (dir->name[0] == 0xe5)
X				continue;
X					/* if dir or volume lable */
X			if ((dir->attr & 0x10) || (dir->attr & 0x08))
X				continue;
X			strncpy(tname, dir->name, 8);
X			strncpy(text, dir->ext, 3);
X			newfile = unixname(tname, text);
X					/* see it if matches the pattern */
X			if (match(newfile, filename)) {
X				fat = dir->start[1]*0x100 + dir->start[0];
X				size = dir->size[2]*0x10000 + dir->size[1]*0x100 + dir->size[0];
X				readit(fat);
X				ismatch = 1;
X			}
X		}
X		if (!ismatch) {
X			fprintf(stderr, "mtype: File '%s' not found\n", filename);
X			continue;
X		}
X	}
X	close(fd);
X	exit(0);
X}
X
X/*
X * Decode the FAT chain given the begining FAT entry.
X */
X
Xreadit(fat)
Xint fat;
X{
X	current = 0L;
X
X	while (1) {
X		getcluster(fat);
X					/* get next cluster number */
X		fat = getfat(fat);
X		if (fat == -1) {
X			fprintf(stderr, "mtype: FAT problem\n");
X			exit(1);
X		}
X					/* end of cluster chain */
X		if (fat >= 0xff8)
X			break;
X	}
X	return;
X}
X
X/*
X * Read the name cluster, output to the stdout.
X */
X
Xgetcluster(num)
Xint num;
X{
X	int i, buflen, start;
X	void exit(), perror();
X	char buf[CLSTRBUF];
X
X	start = (num - 2)*clus_size + dir_start + dir_len;
X	move(start);
X
X	buflen = clus_size * MSECSIZ;
X	if (read(fd, buf, buflen) != buflen) {
X		perror("getcluster: read");
X		exit(1);
X	}
X					/* stop at size not EOF marker */
X	for (i=0; i<buflen; i++) {
X		current++;
X		if (current > size) 
X			break;
X		if (textmode & buf[i] == '\r')
X			continue;
X		if (stripmode)
X			putchar(buf[i] & 0x7f);
X		else
X			putchar(buf[i]);
X	}
X	return;
X}
SHAR_EOF
if test 3462 -ne "`wc -c < 'mtype.c'`"
then
	echo shar: "error transmitting 'mtype.c'" '(should have been 3462 characters)'
fi
fi
echo shar: "extracting 'mwrite.c'" '(7247 characters)'
if test -f 'mwrite.c'
then
	echo shar: "will not over-write existing file 'mwrite.c'"
else
sed 's/^X//' << \SHAR_EOF > 'mwrite.c'
X/*
X * Write (copy) a Unix file to MSDOS
X *
X * Emmet P. Gray			US Army, HQ III Corps & Fort Hood
X * ...!ihnp4!uiucuxc!fthood!egray	Attn: AFZF-DE-ENV
X * 					Directorate of Engineering & Housing
X * 					Environmental Management Office
X * 					Fort Hood, TX 76544-5057
X */
X
X#include <stdio.h>
X#include <sys/types.h>
X#include <sys/stat.h>
X#include "msdos.h"
X
Xint fd;				/* the file descriptor for the floppy */
Xint dir_start;			/* starting sector for directory */
Xint dir_len;			/* length of directory (in sectors) */
Xint dir_entries;		/* number of directory entries */
Xint dir_chain[25];		/* chain of sectors in directory */
Xint clus_size;			/* cluster size (in sectors) */
Xint fat_len;			/* length of FAT table (in sectors) */
Xint num_clus;			/* number of available clusters */
Xunsigned char *fatbuf;		/* the File Allocation Table */
Xchar *mcwd;			/* the Current Working Directory */
X
Xint full = 0;
Xint textmode = 0;
Xint nowarn = 0;
Xint filesize;
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X	extern int optind;
X	extern char *optarg;
X	int i, entry, ismatch, nogo, slot, start, dot, subdir(), single;
X	int isdir(), root, c, oops;
X	char *filename, *newfile, tname[9], text[4], *fixname(), *getname();
X	char *unixname(), ans[10], *strncpy(), *pathname, *getpath(), *fixed;
X	char *tmp, *malloc(), *strcat(), *strcpy();
X	void exit();
X	struct directory *dir, *search(), *writeit();
X
X	if (init(2)) {
X		fprintf(stderr, "mwrite: Cannot initialize diskette\n");
X		exit(1);
X	}
X					/* get command line options */
X	oops = 0;
X	while ((c = getopt(argc, argv, "tn")) != EOF) {
X		switch(c) {
X			case 't':
X				textmode = 1;
X				break;
X			case 'n':
X				nowarn = 1;
X				break;
X			default:
X				oops = 1;
X				break;
X		}
X	}
X
X	if (oops || (argc - optind) < 2) {
X		fprintf(stderr, "Usage: mwrite [-t|-n] <Unix file> <MSDOS file>\n");
X		fprintf(stderr, "    or mwrite [-t|-n] <Unix file> [<Unix files...>] <MSDOS directory>\n");
X		exit(1);
X	}
X	root = 0;
X	if (!strcmp(argv[argc-1], "/") || !strcmp(argv[argc-1], "\\"))
X		root = 1;
X	filename = getname(argv[argc-1]);
X	pathname = getpath(argv[argc-1]);
X					/* test if path is ok first */
X	if (subdir(pathname))
X		exit(1);
X					/* test if last argv is a dir */
X	if (isdir(filename) || root) {
X		if (!strlen(pathname)) {
X					/* don't alter the presence or */
X					/* absence of a leading separator */
X			tmp = malloc(strlen(filename)+1);
X			strcpy(tmp, filename);
X		}
X		else {
X			tmp = malloc(strlen(pathname)+1+strlen(filename)+1);
X			strcpy(tmp, pathname);
X			strcat(tmp, "/");
X			strcat(tmp, filename);
X		}
X					/* subdir is not recursive */
X		subdir(tmp);
X		single = 0;
X	}
X	else
X		single = 1;
X
X	for (i=optind; i<argc-1; i++) {
X		if (single) {
X			fixed = fixname(argv[argc-1]);
X			filename = unixname(fixed, fixed+8);
X		}
X		else {
X			fixed = fixname(argv[i]);
X			filename = unixname(fixed, fixed+8);
X			printf("Copying %s\n", filename);
X		}
X					/* see if exists and get slot */
X		ismatch = 0;
X		slot = -1;
X		dot = 0;
X		nogo = 0;
X		for (entry=0; entry<dir_entries; entry++) {
X			dir = search(entry);
X					/* is empty */
X			if (dir->name[0] == NULL) {
X				if (slot < 0)
X					slot = entry;
X				break;
X			}
X					/* is erased */
X			if (dir->name[0] == 0xe5) {
X				if (slot < 0)
X					slot = entry;
X				continue;
X			}
X			strncpy(tname, dir->name, 8);
X			strncpy(text, dir->ext, 3);
X			newfile = unixname(tname, text);
X					/* save the '.' entry info */
X			if ((dir->attr & 0x10) && !strcmp(".", newfile)) {
X				dot = dir->start[1]*0x100 + dir->start[0];
X				continue;
X			}
X					/* is dir or volume lable */
X			if ((dir->attr & 0x10) || (dir->attr & 0x08))
X				continue;
X					/* if file exists, delete it first */
X			if (!strcmp(filename, newfile)) {
X				ismatch = 1;
X				start = dir->start[1]*0x100 + dir->start[0];
X				if (nowarn) {
X					zapit(start);
X					dir->name[0] = 0xe5;
X					writedir(entry, dir);
X					if (slot < 0)
X						slot = entry;
X				} else {
X					while (1) {
X						printf("File '%s' exists, overwrite (y/n) ? ", filename);
X						gets(ans);
X						if (ans[0] == 'n' || ans[0] == 'N') {
X							nogo = 1;
X							break;
X						}
X						if (ans[0] == 'y' || ans[0] == 'Y') {
X							zapit(start);
X							dir->name[0] = 0xe5;
X							writedir(entry, dir);
X							if (slot < 0)
X								slot = entry;
X							break;
X						}
X					}
X				}
X			}
X			if (ismatch)
X				break;
X		}
X		if (nogo)		/* chickened out... */
X			continue;
X					/* no '.' entry means root directory */
X		if (dot == 0 && slot < 0) {
X			printf(stderr, "mwrite: No directory slots\n");
X			exit(1);
X		}
X					/* make the directory grow */
X		if (dot && slot < 0) {
X			if (grow(dot)) {
X				fprintf(stderr, "mwrite: Disk full\n");
X				exit(1);
X			}
X					/* first entry in 'new' directory */
X			slot = entry;
X		}
X					/* write the file */
X		dir = writeit(fixed, argv[i]);
X		if (dir != NULL)
X			writedir(slot, dir);
X
X		if (full) {
X			fprintf(stderr, "mwrite: Disk Full\n");
X			break;
X		}
X		if (single)
X			break;
X	}
X					/* write FAT sectors */
X	writefat();
X	close(fd);
X	exit(0);
X}
X
X/*
X * Open the named file for write, create the cluster chain, return the
X * directory structure.
X */
X
Xstruct directory *
Xwriteit(fixed, path)
Xchar *fixed;
Xchar *path;
X{
X	FILE *fp;
X	int size, fat, firstfat, oldfat, nextfat(), putcluster(), putfat();
X	struct directory *mk_entry();
X	static struct directory *dir;
X	struct stat stbuf;
X
X	if (stat(path, &stbuf) < 0) {
X		fprintf(stderr, "mwrite: Can't stat '%s'\n", path);
X		return(NULL);
X	}
X	filesize = stbuf.st_size;
X	if (!(fp = fopen(path, "r"))) {
X		fprintf(stderr, "mwrite: Can't open '%s' for read\n", path);
X		return(NULL);
X	}
X	size = 0;
X	firstfat = nextfat(0);
X	if (firstfat == -1) {
X		full = 1;
X		return(NULL);
X	}
X	fat = firstfat;
X	while (1) {
X		size += putcluster(fat, fp);
X		if (size >= filesize) {
X			putfat(fat, 0xfff);
X			break;
X		}
X		oldfat = fat;
X					/* get next free cluster */
X		fat = nextfat(oldfat);
X		if (fat == -1) {
X			putfat(oldfat, 0xfff);
X			full = 1;
X			break;
X		}
X		putfat(oldfat, fat);
X	}
X	fclose(fp);
X	dir = mk_entry(fixed, 0, firstfat, size);
X	return(dir);
X}
X
X/*
X * Write to the cluster from the named Unix file descriptor.
X */
X
Xint
Xputcluster(num, fp)
Xint num;
XFILE *fp;
X{
X	long start;
X	void exit(), perror();
X	int buflen, c;
X	static int current;
X	char tbuf[CLSTRBUF];
X
X	start = (num - 2)*clus_size + dir_start + dir_len;
X	move(start);
X
X	buflen = clus_size * MSECSIZ;
X					/* '\n' to '\r\n' translation */
X	if (textmode) {
X		current = 0;
X		while (current < buflen) {
X			if ((c = fgetc(fp)) == EOF) {
X					/* put a file EOF marker */
X				tbuf[current] = 0x1a;
X				break;
X			}
X			if (c == '\n') {
X				tbuf[current++] = '\r';
X				if (current == buflen)
X					break;
X				tbuf[current++] = '\n';
X					/* make the file appear larger */
X				filesize++;
X			}
X			else 
X				tbuf[current++] = c;
X		}
X	}
X	else {
X		if ((current = fread(tbuf, sizeof(char), buflen, fp)) < 0) {
X			perror("putcluster: fread");
X			exit(1);
X		}
X					/* all files get an EOF marker */
X		if (current != buflen) 
X			tbuf[current+1] = 0x1a;
X	}
X	
X	if (write(fd, tbuf, buflen) != buflen) {
X		perror("putcluster: write");
X		exit(1);
X	}
X	return(current);
X}
X
X/*
X * Returns next free cluster or -1 if none are available.
X */
X
Xint
Xnextfat(last)
Xint last;
X{
X	static int i;
X
X	for (i=last+1; i<num_clus+2; i++) {
X		if (!getfat(i))
X			return(i);
X	}
X	return(-1);
X}
SHAR_EOF
if test 7247 -ne "`wc -c < 'mwrite.c'`"
then
	echo shar: "error transmitting 'mwrite.c'" '(should have been 7247 characters)'
fi
fi
echo shar: "extracting 'putfat.c'" '(3118 characters)'
if test -f 'putfat.c'
then
	echo shar: "will not over-write existing file 'putfat.c'"
else
sed 's/^X//' << \SHAR_EOF > 'putfat.c'
X/*
X * putfat(), writedir(), zapit(), writefat()
X */
X
X#include <stdio.h>
X#include "msdos.h"
X#undef DUP_FAT
X
Xextern int fd, fat_len, dir_chain[25];
Xextern unsigned char *fatbuf;
X
X/*
X * Puts a code into the FAT table.  Is the opposite of getfat().  No
X * sanity checking is done on the code.  Returns a 1 on error.
X */
X
Xint
Xputfat(num, code)
Xint num;
Xunsigned int code;
X{
X/*
X *	|0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|
X *	| | | | | | | | | | | | | | | | | | | | | | | | |
X *	|  n.0  |  n.5  | n+1.0 | n+1.5 | n+2.0 | n+2.5 |
X *	    \_____  \____   \______/________/_____   /
X *	      ____\______\________/   _____/  ____\_/
X *	     /     \      \          /       /     \
X *	| n+1.5 |  n.0  |  n.5  | n+2.0 | n+2.5 | n+1.0 |
X *	|      FAT entry k      |    FAT entry k+1      |
X */
X	int start;
X					/* which bytes contain the entry */
X	start = num * 3 / 2;
X	if (start < 0 || start+1 > (fat_len * MSECSIZ))
X		return(1);
X					/* (odd) not on byte boundary */
X	if (num % 2) {
X		*(fatbuf+start) = (*(fatbuf+start) & 0x0f) + ((code << 4) & 0xf0);
X		*(fatbuf+start+1) = (code >> 4) & 0xff;
X	}
X					/* (even) on byte boundary */
X	else {
X		*(fatbuf+start) = code & 0xff;
X		*(fatbuf+start+1) = (*(fatbuf+start+1) & 0xf0) + ((code >> 8) & 0x0f);
X	}
X	return(0);
X}
X
X/*
X * Write a directory entry.  The first argument is the directory entry
X * number to write to.  The second is a pointer to the directory itself.
X * All errors are fatal.
X */
X
Xwritedir(num, dir)
Xint num;
Xstruct directory *dir;
X{
X	int skip, entry;
X	void exit(), perror();
X	static struct directory dirs[16];
X					/* which sector */
X	skip = dir_chain[num / 16];
X
X	move(skip);
X					/* read the sector */
X	if (read(fd, (char *) &dirs[0], MSECSIZ) != MSECSIZ) {
X		perror("writedir: read");
X		exit(1);
X	}
X					/* which entry in sector */
X	entry = num % 16;
X					/* copy the structure */
X	dirs[entry] = *dir;
X	move(skip);
X					/* write the sector */
X	if (write(fd, (char *) &dirs[0], MSECSIZ) != MSECSIZ) {
X		perror("writedir: write");
X		exit(1);
X	}
X	return;
X}
X
X/*
X * Remove a string of FAT entries (delete the file).  The argument is
X * the beginning of the string.  Does not consider the file length, so
X * if FAT is corrupted, watch out!  All errors are fatal.
X */
X
Xzapit(fat)
Xint fat;
X{
X	int next;
X
X	while (1) {
X					/* get next cluster number */
X		next = getfat(fat);
X					/* mark current cluster as empty */
X		if (putfat(fat, 0) || next == -1) {
X			fprintf(stderr, "zapit: FAT problem\n");
X			exit(1);
X		}
X		if (next >= 0xff8)
X			break;
X		fat = next;
X	}
X	return;
X}
X
X/*
X * Write the FAT table to the disk.  Up to now the FAT manipulation has
X * been done in memory.  All errors are fatal.  (Might not be too smart
X * to wait till the end of the program to write the table.  Oh well...)
X */
X
Xwritefat()
X{
X	int buflen;
X
X	move(1);
X	buflen = fat_len * MSECSIZ;
X	if (write(fd, fatbuf, buflen) != buflen) {
X		perror("writefat: write");
X		exit(1);
X	}
X#ifdef DUP_FAT
X					/* the duplicate FAT table */
X	if (write(fd, fatbuf, buflen) != buflen) {
X		perror("writefat: write");
X		exit(1);
X	}
X#endif DUP_FAT
X	return;
X}
SHAR_EOF
if test 3118 -ne "`wc -c < 'putfat.c'`"
then
	echo shar: "error transmitting 'putfat.c'" '(should have been 3118 characters)'
fi
fi
echo shar: "extracting 'search.c'" '(1075 characters)'
if test -f 'search.c'
then
	echo shar: "will not over-write existing file 'search.c'"
else
sed 's/^X//' << \SHAR_EOF > 'search.c'
X/*
X * Search and extract a directory structure.  The argument is the
X * relative directory entry number (no sanity checking).  It returns a
X * pointer to the directory structure at that location.  Attempts to
X * optimize by trying to determine if the buffer needs to be re-read.
X * A call to writedir() will scribble on the real buffer, so watch out!
X */
X
X#include <stdio.h>
X#include "msdos.h"
X				/* dir_chain contains the list of sectors */
X				/* that make up the current directory */
Xextern int fd, dir_chain[25];
X
Xstruct directory *
Xsearch(num)
Xint num;
X{
X	int skip, entry;
X	void exit(), perror();
X	static int last;
X	static struct directory dirs[16];
X
X					/* first call disables optimzation */
X	if (num == 0)
X		last = 0;
X					/* which sector */
X	skip = dir_chain[num / 16];
X					/* don't read it if same sector */
X	if (skip != last) {
X		move(skip);
X					/* read the sector */
X		if (read(fd, (char *) &dirs[0], MSECSIZ) != MSECSIZ) {
X			perror("mread: read");
X			exit(1);
X		}
X	}
X	last = skip;
X					/* which entry in sector */
X	entry = num % 16;
X	return(&dirs[entry]);
X}
SHAR_EOF
if test 1075 -ne "`wc -c < 'search.c'`"
then
	echo shar: "error transmitting 'search.c'" '(should have been 1075 characters)'
fi
fi
echo shar: "extracting 'subdir.c'" '(3843 characters)'
if test -f 'subdir.c'
then
	echo shar: "will not over-write existing file 'subdir.c'"
else
sed 's/^X//' << \SHAR_EOF > 'subdir.c'
X/*
X * subdir(), getdir(), get_chain(), reset_dir()
X */
X
X#include <stdio.h>
X#include "msdos.h"
X
Xextern int dir_chain[25], dir_start, dir_len, dir_entries, clus_size;
Xextern char *mcwd;
Xstatic char *lastpath;
X
X/*
X * Parse the path names of a sub directory.  Both '/' and '\' are
X * valid separators.  However, the use of '\' will force the operator
X * to use quotes in the command line to protect '\' from the shell.
X * Returns 1 on error.  Attempts to optimize by remembering the last
X * path it parsed
X */
X
Xsubdir(name)
Xchar *name;
X{
X	char *s, *tmp, *path, *malloc(), *strcpy(), *strcat();
X	static int code;
X	int getdir();
X					/* if full pathname */
X	if (*name == '/' || *name == '\\') {
X		tmp = malloc(strlen(name)+1);
X		strcpy(tmp, name);
X	}
X					/* if relative to MCWD */
X	else {
X		if (!strlen(name)) {
X			tmp = malloc(strlen(mcwd)+1);
X			strcpy(tmp, mcwd);
X		}
X		else {
X			tmp = malloc(strlen(mcwd)+1+strlen(name)+1);
X			strcpy(tmp, mcwd);
X			strcat(tmp, "/");
X			strcat(tmp, name);
X		}
X	}
X					/* if paths are same, do nothing */
X	if (!strcmp(tmp, lastpath))
X		return(0);
X					/* not recursive, start at root */
X	reset_dir();
X	lastpath = malloc(strlen(tmp)+1);
X	strcpy(lastpath, tmp);
X					/* zap the leading separator */
X	if (*tmp == '\\' || *tmp == '/')
X		tmp++;
X	for (s = tmp; *s; ++s) {
X		if (*s == '\\' || *s == '/') {
X			path = tmp;
X			*s = NULL;
X			if (getdir(path))
X				return(1);
X			tmp = s+1;
X		}
X	}
X	code = getdir(tmp);
X	return(code);
X}
X
X/*
X * Find the directory and get the starting cluster.  A null directory
X * is ok.  Returns a 1 on error.
X */
X
Xint
Xgetdir(path)
Xchar *path;
X{
X	int entry, start, get_chain();
X	char *newname, *unixname(), *strncpy(), name[9], ext[4];
X	struct directory *dir, *search();
X
X					/* nothing required */
X	if (*path == NULL)
X		return(0);
X
X	for (entry=0; entry<dir_entries; entry++) {
X		dir = search(entry);
X					/* if empty */
X		if (dir->name[0] == NULL)
X			break;
X					/* if erased */
X		if (dir->name[0] == 0xe5)
X			continue;
X					/* skip if not a directory */
X		if (!(dir->attr & 0x10))
X			continue;
X		strncpy(name, dir->name, 8);
X		name[8] = NULL;
X		strncpy(ext, dir->ext, 3);
X		ext[3] = NULL;
X		newname = unixname(name, ext);
X		if (!strcmp(newname, path)) {
X			start = dir->start[1]*0x100 + dir->start[0];
X					/* if '..' pointing to root */
X			if (!start && !strcmp(path, "..")) {
X				reset_dir();
X				return(0);
X			}
X					/* fill in the directory chain */
X			dir_entries = get_chain(start) * 16;
X			return(0);
X		}
X	}
X					/* if '.' or '..', must be root */
X	if (!strcmp(path, ".") || !strcmp(path, "..")) {
X		reset_dir();
X		return(0);
X	}
X	fprintf(stderr, "Path component '%s' is not a directory\n", path);
X	return(1);
X}
X
X/*
X * Fill in the global variable dir_chain.  Argument is the starting
X * cluster number.  Info, in this variable is used by search() to 
X * scan a directory.  An arbitrary limit of 25 sectors is placed, this
X * equates to 400 entries.  Returns the number of sectors in the chain.
X */
X
Xint
Xget_chain(num)				/* fill the directory chain */
Xint num;
X{
X	int next;
X	static int i;
X	void exit();
X
X	i = 0;
X	while (1) {
X		dir_chain[i] = (num - 2)*clus_size + dir_start + dir_len;
X					/* sectors, not clusters! */
X		if (clus_size == 2) {
X			dir_chain[i+1] = dir_chain[i] + 1;
X			i++;
X		}
X		i++;
X		if (i >= 25) {
X			fprintf(stderr, "get_chain: directory too large\n");
X			exit(1);
X		}
X					/* get next cluster number */
X		next = getfat(num);
X		if (next == -1) {
X			fprintf(stderr, "get_chain: FAT problem\n");
X			exit(1);
X		}
X					/* end of cluster chain */
X		if (next >= 0xff8) {
X			break;
X		}
X		num = next;
X	}
X	return(i);
X}
X
X/* 
X * Reset the global variable dir_chain to the root directory.
X */
X
Xreset_dir()
X{
X	int i;
X
X	for (i=0; i<dir_len; i++)
X		dir_chain[i] = dir_start + i;
X	dir_entries = dir_len * 16;
X					/* disable subdir() optimization */
X	lastpath = "\0";
X	return;
X}
SHAR_EOF
if test 3843 -ne "`wc -c < 'subdir.c'`"
then
	echo shar: "error transmitting 'subdir.c'" '(should have been 3843 characters)'
fi
fi
echo shar: "extracting 'unixname.c'" '(2293 characters)'
if test -f 'unixname.c'
then
	echo shar: "will not over-write existing file 'unixname.c'"
else
sed 's/^X//' << \SHAR_EOF > 'unixname.c'
X/*
X * unixname(), getname(), getpath()
X */
X
X#include <stdio.h>
X#include <ctype.h>
X
X/*
X * Get rid of spaces in a MSDOS 'raw' name (one that has come from the
X * directory structure) so that it can be used for regular expression
X * matching with a unix file name.  Also used to 'unfix' a name that has
X * been altered by fixname().  Returns a pointer to the unix style name.
X */
X
Xchar *
Xunixname(name, ext)
Xchar *name;
Xchar *ext;
X{
X	static char *ans;
X	char *s, tname[9], text[4], *strcpy(), *strcat(), *malloc();
X	char *strchr(), *strncpy();
X
X	strncpy(tname, name, 8);
X	s = strchr(tname, ' ');
X	if (s != NULL)
X		*s = NULL;
X	tname[8] = NULL;
X
X	strncpy(text, ext, 3);
X	s = strchr(text, ' ');
X	if (s != NULL)
X		*s = NULL;
X	text[3] = NULL;
X
X	if (*text != NULL) {
X		ans = malloc(strlen(tname)+1+strlen(text)+1);
X		strcpy(ans, tname);
X		strcat(ans, ".");
X		strcat(ans, text);
X	}
X	else {
X		ans = malloc(strlen(tname)+1);
X		strcpy(ans, tname);
X	}
X	return(ans);
X}
X
X/*
X * Get name component of filename.  Translates name to upper case.  Returns
X * pointer to new name.  Could be NULL.
X */
X
Xchar *
Xgetname(name)
Xchar *name;
X{
X	char *s, *malloc(), *strcpy(), *strrchr();
X	static char *temp;
X
X	if (*name == NULL)
X		return(NULL);
X
X	temp = malloc(strlen(name)+1);
X	strcpy(temp, name);
X				
X	if (s = strrchr(temp, '/'))
X		temp = s+1;
X	if (s = strrchr(temp, '\\'))
X		temp = s+1;
X
X	for (s = temp; *s; ++s) {
X		if (islower(*s))
X			*s = toupper(*s);
X	}
X	return(temp);
X}
X
X/*
X * Get the path component of the filename.  Translates to upper case.
X * Returns pointer to path or NULL if no path exist.  Doesn't alter
X * leading separator, always strips trailing separator (unless it is the
X * path itself).
X */
X
Xchar *
Xgetpath(name)
Xchar *name;
X{
X	char *s, *s1, *malloc(), *strcpy(), *strrchr();
X	static char *temp;
X
X	if (*name == NULL)
X		return(NULL);
X
X	temp = malloc(strlen(name)+1);
X	strcpy(temp, name);
X
X	s = strrchr(temp, '/');
X	s1 = strrchr(temp, '\\');
X					/* if both are NULL , no path */
X	if (s1 == s)
X		return(NULL);
X					/* zap which ever is last separator */
X	if (s1 > s)
X		*s1 = NULL;
X	if (s > s1)
X		*s = NULL;
X					/* translate to upper case */
X	for (s = temp; *s; ++s) {
X		if (islower(*s))
X			*s = toupper(*s);
X	}
X					/* if null, put separator back */
X	if (!strlen(temp))
X		temp = "/";
X	return(temp);
X}
SHAR_EOF
if test 2293 -ne "`wc -c < 'unixname.c'`"
then
	echo shar: "error transmitting 'unixname.c'" '(should have been 2293 characters)'
fi
fi
exit 0
#	End of shell archive