mirror of
https://github.com/bobbimanners/GNO-Extras.git
synced 2024-12-22 17:30:13 +00:00
673 lines
15 KiB
Plaintext
673 lines
15 KiB
Plaintext
/*
|
|
* Bobbi January 2020
|
|
*
|
|
* TODO: Fix bugs!!!!
|
|
* TODO: Sort by type, combinations etc.
|
|
* TODO: Improve checking code
|
|
*/
|
|
|
|
#pragma debug 25 /* Enable stack checking */
|
|
#pragma lint -1
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <orca.h>
|
|
#include <gsos.h>
|
|
#include <prodos.h>
|
|
|
|
|
|
#define DEBUG /* Enable additional debug printout */
|
|
#define CHECK /* Perform additional integrity checking */
|
|
|
|
typedef unsigned char uchar;
|
|
typedef unsigned int uint;
|
|
|
|
#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 */
|
|
|
|
/*
|
|
* 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;
|
|
};
|
|
|
|
struct block *blocks = NULL;
|
|
|
|
/*
|
|
* Entry for array of filenames used by qsort()
|
|
*/
|
|
struct fileent {
|
|
char name[NMLEN+1]; /* Name converted to upper/lower case */
|
|
uchar blockidx; /* Index of dir block (1,2,3 ...) */
|
|
uchar entrynum; /* Entry within the block */
|
|
};
|
|
|
|
/* Globals */
|
|
static struct fileent filelist[MAXFILES];
|
|
static uint numfiles = 0;
|
|
static uchar entsz; /* Bytes per file entry */
|
|
static uchar entperblk; /* Number of entries per block */
|
|
static char buf[BLKSZ]; /* General purpose scratch buffer */
|
|
static uchar dowrite = 0;
|
|
static uchar doreverse = 0;
|
|
|
|
static uint stack; // DEBUG
|
|
|
|
//#define STACK(msg) asm {tsc; sta stack }; fputs(msg, stdout); fputs(" ", stdout); pr_int(stack); putchar('\n');
|
|
|
|
/* Prototypes */
|
|
void prerr(char *s);
|
|
void reverse(char *s);
|
|
void itoa(int n, char s[]);
|
|
void uitoa(uint n, char s[]);
|
|
void pr_int(int a);
|
|
void pr_uint(uint a);
|
|
void print_uint(uint i);
|
|
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);
|
|
int readdir(uint device, uint blocknum);
|
|
int compare(const void *a, const void *b);
|
|
void sortlist(void);
|
|
void printlist(void);
|
|
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 prerr(char *s) {
|
|
fputs(s, stderr);
|
|
fputs("\n", stderr);
|
|
}
|
|
|
|
/* Reverse the characters of the string s */
|
|
void reverse(char *s) {
|
|
char buf[10];
|
|
int l = strlen(s);
|
|
for (int i=0; i<l; ++i)
|
|
buf[i] = s[i];
|
|
for (int i=0; i<l; ++i)
|
|
s[i] = buf[l-i-1];
|
|
}
|
|
|
|
/* Stolen from K&R 2nd Ed. pp 64 */
|
|
void itoa(int n, char s[]) {
|
|
int i, sign;
|
|
|
|
if ((sign = n) < 0)
|
|
n = -1;
|
|
i = 0;
|
|
do {
|
|
s[i++] = n % 10 + '0';
|
|
} while ((n /= 10) > 0);
|
|
if (sign < 0)
|
|
s[i++] = '-';
|
|
s[i] = '\0';
|
|
reverse(s);
|
|
}
|
|
|
|
/* Unsigned verson of itoa() */
|
|
void uitoa(uint n, char s[]) {
|
|
int i;
|
|
|
|
i = 0;
|
|
do {
|
|
s[i++] = n % 10 + '0';
|
|
} while ((n /= 10) > 0);
|
|
s[i] = '\0';
|
|
reverse(s);
|
|
}
|
|
|
|
/* Print an integer */
|
|
void pr_int(int a) {
|
|
char buf[10];
|
|
itoa(a, buf);
|
|
fputs(buf, stdout);
|
|
}
|
|
|
|
/* Print an unsigned integer */
|
|
void pr_uint(unsigned int a) {
|
|
char buf[10];
|
|
uitoa(a, buf);
|
|
fputs(buf, stdout);
|
|
}
|
|
|
|
/*
|
|
* 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
|
|
fputs("Reading dev ", stdout);
|
|
pr_int(device);
|
|
fputs(" block ", stdout);
|
|
pr_uint(blocknum);
|
|
putchar('\n');
|
|
#endif
|
|
BlockRec br;
|
|
br.blockDevNum = device;
|
|
br.blockDataBuffer = buf;
|
|
br.blockNum = blocknum;
|
|
READ_BLOCK(&br);
|
|
int rc = toolerror();
|
|
if (rc) {
|
|
fprintf(stderr, "READ_BLOCK failed, err=%x\n", 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
|
|
fputs("Writing dev ", stdout);
|
|
pr_int(device);
|
|
fputs(" block ", stdout);
|
|
pr_uint(blocknum);
|
|
putchar('\n');
|
|
#endif
|
|
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)
|
|
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 idx = 0;
|
|
if (!(vers&0x80)) {
|
|
for (idx=0; idx<NMLEN; ++idx)
|
|
out[idx] = in[idx];
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
fprintf(stderr, "Error opening dir %s\n", dirname);
|
|
rv = 1;
|
|
goto ret;
|
|
}
|
|
|
|
ssize_t len = read(fp, buf, BLKSZ);
|
|
if (len != BLKSZ) {
|
|
fprintf(stderr, "Error reading first block of dir %s", dirname);
|
|
rv = 1;
|
|
goto ret;
|
|
}
|
|
|
|
struct stat st;
|
|
if (stat(dirname, &st) == -1) {
|
|
fprintf(stderr, "Can't stat %s\n", dirname);
|
|
exit(1);
|
|
}
|
|
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
fprintf(stderr, "%s is not a directory\n", dirname);
|
|
exit(1);
|
|
}
|
|
|
|
*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) {
|
|
prerr("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) {
|
|
fprintf(stderr, "Can't read parent directory for %s", dirname);
|
|
rv = 1;
|
|
goto ret;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
uchar blkcnt = 1;
|
|
uint hdrblknum = blocknum;
|
|
|
|
blocks = (struct block*)malloc(BLKSZ);
|
|
if (!blocks) {
|
|
prerr("Unable to allocate memory");
|
|
return 1;
|
|
}
|
|
struct block *curblk = blocks;
|
|
curblk->next = NULL;
|
|
curblk->blocknum = blocknum;
|
|
|
|
if (readdiskblock(device, blocknum, curblk->data) == -1) {
|
|
fprintf(stderr, "Error reading dir block %d\n", 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];
|
|
|
|
/* Copy pointers and header to sorteddata[], zero the rest */
|
|
bzero(curblk->sorteddata, BLKSZ);
|
|
memcpy(curblk->sorteddata, curblk->data, PTRSZ + entsz);
|
|
|
|
|
|
#ifdef DEBUG
|
|
fputs("entsz=", stdout);
|
|
pr_uint(entsz);
|
|
putchar('\n');
|
|
fputs("entperblk=", stdout);
|
|
pr_uint(entperblk);
|
|
putchar('\n');
|
|
fputs("filecount=", stdout);
|
|
pr_uint(filecount);
|
|
putchar('\n');
|
|
#endif
|
|
|
|
// TODO: Add a check that the filecount is correct
|
|
|
|
#ifdef CHECK
|
|
if (entsz != 0x27) {
|
|
prerr("Error - bad entry size");
|
|
return 1;
|
|
}
|
|
if (entperblk != 0x0d) {
|
|
prerr("Error - bad entries/block");
|
|
return 1;
|
|
}
|
|
#endif
|
|
uint idx = entsz + PTRSZ; /* Skip header */
|
|
uchar blkentries = 2;
|
|
uchar entries = 0;
|
|
|
|
static char namebuf[NMLEN];
|
|
|
|
while (entries < filecount) {
|
|
struct pd_dirent *ent = (struct pd_dirent*)(curblk->data + idx);
|
|
if (ent->typ_len != 0) {
|
|
fixcase(ent->name, namebuf, ent->vers, ent->minvers);
|
|
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].blockidx = blkcnt;
|
|
filelist[numfiles].entrynum = blkentries;
|
|
#ifdef CHECK
|
|
uint keyblk = ent->keyptr[0] + 256U * ent->keyptr[1];
|
|
uint hdrblk = ent->hdrptr[0] + 256U * ent->hdrptr[1];
|
|
if (hdrblk != hdrblknum) {
|
|
fprintf(stderr,
|
|
"%s: Header ptr %u should be %u\n",
|
|
namebuf, hdrblk, hdrblknum);
|
|
}
|
|
if ((ent->typ_len & 0xf0) == 0xd0) {
|
|
if (readdiskblock(device, keyblk, buf) == -1) {
|
|
fprintf(stderr,
|
|
"Error reading blk %u\n",
|
|
keyblk);
|
|
return 1;
|
|
}
|
|
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) {
|
|
prerr("Bad parent block number");
|
|
return 1;
|
|
}
|
|
if (parentry != blkentries) {
|
|
prerr("Bad parent block entry num");
|
|
return 1;
|
|
}
|
|
if (parentlen != 0x27) {
|
|
prerr("Bad parent entry length");
|
|
return 1;
|
|
}
|
|
char *dirname = buf + 0x05;
|
|
if (strncmp(dirname, ent->name, NMLEN)) {
|
|
prerr("Subdirectory name mismatch");
|
|
return 1;
|
|
}
|
|
}
|
|
#endif
|
|
++numfiles;
|
|
if (numfiles == MAXFILES) {
|
|
prerr("Too many files");
|
|
return 1;
|
|
}
|
|
++entries;
|
|
}
|
|
if (entries < filecount) {
|
|
if (blkentries == entperblk) {
|
|
blocknum =
|
|
curblk->data[0x02] + 256U*curblk->data[0x03];
|
|
curblk->next = (struct block*)malloc(BLKSZ);
|
|
if (!curblk->next) {
|
|
prerr("Unable to allocate memory");
|
|
return 1;
|
|
}
|
|
curblk = curblk->next;
|
|
curblk->next = NULL;
|
|
curblk->blocknum = blocknum;
|
|
++blkcnt;
|
|
if (readdiskblock(device,
|
|
blocknum,
|
|
curblk->data) == -1) {
|
|
fprintf(stderr,
|
|
"Error reading dir block %d\n",
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Compare two filenames
|
|
*/
|
|
int compare(const void *a, const void *b) {
|
|
int rc;
|
|
rc = strncmp(((struct fileent*)a)->name,
|
|
((struct fileent*)b)->name, 15);
|
|
return (doreverse ? -rc : rc);
|
|
}
|
|
|
|
/*
|
|
* Sort filelist[]
|
|
*/
|
|
void sortlist(void) {
|
|
qsort(filelist, numfiles, sizeof(struct fileent), compare);
|
|
}
|
|
|
|
/*
|
|
* Print the file info stored in filelist[]
|
|
*/
|
|
void printlist(void) {
|
|
fputs("numfiles=", stdout);
|
|
pr_int(numfiles);
|
|
putchar('\n');
|
|
for(uint i=0; i<numfiles; ++i) {
|
|
fputs("blk=", stdout);
|
|
pr_int(filelist[i].blockidx);
|
|
fputs(" ent=", stdout);
|
|
pr_int(filelist[i].entrynum);
|
|
putchar('\t');
|
|
fputs(filelist[i].name, stdout);
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
|
|
fputs(" from blk ", stdout);
|
|
pr_uint(srcblk);
|
|
fputs(" entry ", stdout);
|
|
pr_uint(srcent);
|
|
putchar('\n');
|
|
fputs(" to blk ", stdout);
|
|
pr_uint(dstblk);
|
|
fputs(" entry ", stdout);
|
|
pr_uint(dstent);
|
|
putchar('\n');
|
|
|
|
struct block *source = blocks;
|
|
struct block *dest = blocks;
|
|
while (--srcblk > 0)
|
|
source = source->next;
|
|
while (--dstblk > 0)
|
|
dest = dest->next;
|
|
char *dstptr = dest->sorteddata + PTRSZ + (dstent-1) * entsz;
|
|
memcpy(dstptr,
|
|
source->data + PTRSZ + (srcent-1) * entsz,
|
|
entsz);
|
|
|
|
/* For directories, update the parent dir entry number */
|
|
if ((*dstptr & 0xf0) == 0xd0) {
|
|
struct pd_dirent *ent = (struct pd_dirent *)dstptr;
|
|
uint block = ent->keyptr[0] + 256U * ent->keyptr[1];
|
|
if (readdiskblock(device, block, buf) == -1) {
|
|
prerr("Can't read subdirectory");
|
|
exit(1);
|
|
}
|
|
struct pd_dirhdr *hdr = (struct pd_dirhdr*)(buf + PTRSZ);
|
|
hdr->parentry = dstent;
|
|
if (dowrite) {
|
|
if (writediskblock(device, block, buf) == -1) {
|
|
prerr("Can't write subdirectory");
|
|
exit(1);
|
|
}
|
|
} else {
|
|
puts("Not writing updated subdir to disk");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
uchar destblk = 1;
|
|
uchar destentry = 2; /* Skip header on first block */
|
|
for(uint i=0; i<numfiles; ++i) {
|
|
puts(filelist[i].name);
|
|
copyent(filelist[i].blockidx, filelist[i].entrynum,
|
|
destblk, destentry, device);
|
|
++destentry;
|
|
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) {
|
|
fprintf(stderr, "Can't write block %u\n", 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;
|
|
}
|
|
}
|
|
|
|
void usage(void) {
|
|
prerr("usage: sortdir [-w] [-r] path\n");
|
|
prerr(" Flags: -w Enable writing to disk");
|
|
prerr(" -r Reverse sort order\n");
|
|
exit(2);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
if (argc < 2) {
|
|
usage();
|
|
exit(1);
|
|
}
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "rw")) != -1) {
|
|
switch (opt) {
|
|
case 'r':
|
|
doreverse = 1;
|
|
break;
|
|
case 'w':
|
|
dowrite = 1;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
if (optind >= argc)
|
|
usage();
|
|
|
|
uchar dev;
|
|
uint blk;
|
|
if (firstblk(argv[optind], &dev, &blk) != 0) {
|
|
exit(1);
|
|
}
|
|
uchar err = readdir(dev, blk);
|
|
if (!err) {
|
|
printlist();
|
|
sortlist();
|
|
sortblocks(dev);
|
|
if (dowrite)
|
|
err = writedir(dev);
|
|
else
|
|
puts("Not writing to disk");
|
|
}
|
|
freeblocks();
|
|
return err;
|
|
}
|
|
|