AI_Slop/joeylib2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
joeylib2/tools/adfTool/adfTool.c

419 lines
14 KiB
C
Raw Blame History

// Part of JoeyLib, Copyright (c) 2026 Scott Duensing, under the MIT License.
// See LICENSE.md for license information.
// SPDX-License-Identifier: MIT
//
// adfTool.c - read files out of an Amiga OFS/FFS disk image (.adf).
//
// adfTool list IMAGE every file, one path per line
// adfTool extract IMAGE PATH OUT one file (PATH like Devs/serial.device)
// adfTool extractall IMAGE OUTDIR every file, keeping the drawer tree
//
// Read-only. Used by the installer's `import` (a Workbench disk image is how
// most people own AmigaOS files such as Devs/serial.device) and by the Amiga
// gates. Handles DD (880 KB) and HD (1.76 MB) images; names match
// case-insensitively, as AmigaDOS does, and a drawer lists in name order
// without regard to case.
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "toolBuf.h"
#include "toolFile.h"
#define TOOL_NAME "adfTool"
#define USAGE_EXIT 2
#define BLOCK_SIZE 512u
// The hash table (and a file header's table of data blocks) has 72 slots
// from byte 24.
#define HASH_SLOTS 72u
#define TABLE_AT 24u
#define TYPE_HEADER 2
#define SEC_TYPE_USERDIR 2
#define SEC_TYPE_FILE (-3)
// OFS data blocks start with a 24-byte header, their data's length at 12.
#define OFS_DATA_HEADER 24u
#define OFS_DATA_SIZE_AT 12
// Fields counted from a header block's end, as AmigaDOS defines them: the
// name's length byte (its characters after it), the file's size, the hash
// chain's next, the extension block, and the secondary type.
#define NAME_LENGTH_FROM_END 80
#define FILE_SIZE_FROM_END 188
#define HASH_CHAIN_FROM_END 16
#define EXTENSION_FROM_END 8
#define SEC_TYPE_FROM_END 4
#define BLOCK_COUNT_AT 8
#define NAME_MAX_BYTES 31u
// A name is Latin-1; on the host it is UTF-8, up to two bytes a character.
#define NAME_UTF8_BYTES (2u * NAME_MAX_BYTES + 1u)
#define ASCII_END 0x80u
#define UTF8_LEAD_2 0xC0u
#define UTF8_CONT 0x80u
#define UTF8_SHIFT 6u
#define UTF8_CONT_MASK 0x3Fu
#define PATH_MAX_BYTES 1024u
#define DIR_MODE 0777
#define DOS_MAGIC_BYTES 3u
#define FFS_FLAG 1u
// One entry of a drawer: its name, header block, and secondary type.
typedef struct EntryT {
char name[NAME_UTF8_BYTES];
uint32_t block;
int32_t secType;
} EntryT;
typedef struct AdfT {
const char *path;
uint8_t *image;
size_t len;
uint32_t blocks;
uint32_t rootBlock;
bool ffs;
} AdfT;
static const uint8_t *block(const AdfT *a, uint32_t number);
static size_t entries(const AdfT *a, uint32_t dirBlock, EntryT **out);
static int entryCompare(const void *x, const void *y);
static void extractAll(const AdfT *a, uint32_t dirBlock, const char *prefix, const char *outDir);
static int32_t field(const uint8_t *data, int offset);
static uint32_t find(const AdfT *a, const char *path);
static void latin1ToUtf8(const uint8_t *name, size_t len, char *out);
static void listAll(const AdfT *a, uint32_t dirBlock, const char *prefix);
static void makeDirs(const char *path);
static bool nameEqual(const char *a, size_t aLen, const char *b, size_t bLen);
static uint8_t *readFile(const AdfT *a, uint32_t headerBlock, size_t *len);
static void usage(void);
// A block of the image; a fatal error past its end.
static const uint8_t *block(const AdfT *a, uint32_t number) {
if (number >= a->blocks) {
toolFail("%s: block %u is past the image's end", a->path, number);
}
return a->image + (size_t)number * BLOCK_SIZE;
}
// Everything in a drawer (its hash table's chains), in name order; how
// many. A damaged image's looping chain stops after as many entries as the
// image has blocks.
static size_t entries(const AdfT *a, uint32_t dirBlock, EntryT **out) {
const uint8_t *dir;
const uint8_t *header;
EntryT *found;
EntryT *grown;
size_t count;
size_t cap;
size_t nameLen;
uint32_t slot;
uint32_t number;
uint32_t guard;
dir = block(a, dirBlock);
found = NULL;
count = 0u;
cap = 0u;
guard = 0u;
for (slot = 0; slot < HASH_SLOTS; slot++) {
number = (uint32_t)field(dir, (int)(TABLE_AT + 4u * slot));
while (number != 0u) {
if (++guard > a->blocks) {
toolFail("%s: a drawer's hash chain loops", a->path);
}
header = block(a, number);
if (field(header, 0) == TYPE_HEADER) {
if (count == cap) {
cap = cap == 0u ? 16u : cap * 2u;
grown = (EntryT *)realloc(found, cap * sizeof(EntryT));
if (grown == NULL) {
toolFail("out of memory");
}
found = grown;
}
nameLen = header[BLOCK_SIZE - NAME_LENGTH_FROM_END];
if (nameLen > NAME_MAX_BYTES) {
nameLen = NAME_MAX_BYTES;
}
latin1ToUtf8(header + BLOCK_SIZE - NAME_LENGTH_FROM_END + 1u, nameLen, found[count].name);
found[count].block = number;
found[count].secType = field(header, -SEC_TYPE_FROM_END);
count++;
}
number = (uint32_t)field(header, -HASH_CHAIN_FROM_END);
}
}
if (count > 1u) {
qsort(found, count, sizeof(EntryT), entryCompare);
}
*out = found;
return count;
}
// Names in order without regard to (ASCII) case.
static int entryCompare(const void *x, const void *y) {
const unsigned char *p;
const unsigned char *q;
p = (const unsigned char *)((const EntryT *)x)->name;
q = (const unsigned char *)((const EntryT *)y)->name;
while (*p != '\0' && toupper(*p) == toupper(*q)) {
p++;
q++;
}
return toupper(*p) - toupper(*q);
}
// Every file under a drawer into outDir, keeping the drawer tree.
static void extractAll(const AdfT *a, uint32_t dirBlock, const char *prefix, const char *outDir) {
EntryT *list;
uint8_t *data;
size_t count;
size_t len;
size_t i;
char path[PATH_MAX_BYTES];
char out[PATH_MAX_BYTES];
count = entries(a, dirBlock, &list);
for (i = 0; i < count; i++) {
snprintf(path, sizeof(path), "%s%s", prefix, list[i].name);
if (list[i].secType == SEC_TYPE_USERDIR) {
strncat(path, "/", sizeof(path) - strlen(path) - 1u);
extractAll(a, list[i].block, path, outDir);
} else if (list[i].secType == SEC_TYPE_FILE) {
snprintf(out, sizeof(out), "%s/%s", outDir, prefix);
makeDirs(out);
strncat(out, list[i].name, sizeof(out) - strlen(out) - 1u);
data = readFile(a, list[i].block, &len);
if (!toolWriteFile(out, data, len)) {
toolFail("cannot write %s", out);
}
free(data);
}
}
free(list);
}
// A big-endian 32-bit field of a block; a negative offset counts from the
// block's end, as the AmigaDOS structure definitions do.
static int32_t field(const uint8_t *data, int offset) {
const uint8_t *p;
p = data + (offset < 0 ? (int)BLOCK_SIZE + offset : offset);
return (int32_t)(((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) | ((uint32_t)p[2] << 8) | (uint32_t)p[3]);
}
// The header block of the file or drawer at path ("Devs/serial.device"),
// each part matched without regard to case; a fatal error when it is not
// there.
static uint32_t find(const AdfT *a, const char *path) {
EntryT *list;
const char *part;
const char *end;
uint32_t current;
size_t count;
size_t i;
current = a->rootBlock;
for (part = path;; part = end + 1) {
end = strchr(part, '/');
end = end != NULL ? end : part + strlen(part);
count = entries(a, current, &list);
for (i = 0; i < count && !nameEqual(list[i].name, strlen(list[i].name), part, (size_t)(end - part)); i++) {
}
if (i == count) {
toolFail("not found in image: %s", path);
}
current = list[i].block;
free(list);
if (*end == '\0') {
break;
}
}
return current;
}
// len bytes of a Latin-1 name as a UTF-8 string in out (NAME_UTF8_BYTES).
static void latin1ToUtf8(const uint8_t *name, size_t len, char *out) {
size_t i;
size_t n;
n = 0u;
for (i = 0; i < len; i++) {
if (name[i] < ASCII_END) {
out[n++] = (char)name[i];
} else {
out[n++] = (char)(UTF8_LEAD_2 | (name[i] >> UTF8_SHIFT));
out[n++] = (char)(UTF8_CONT | (name[i] & UTF8_CONT_MASK));
}
}
out[n] = '\0';
}
// Every file under a drawer, one path a line.
static void listAll(const AdfT *a, uint32_t dirBlock, const char *prefix) {
EntryT *list;
size_t count;
size_t i;
char path[PATH_MAX_BYTES];
count = entries(a, dirBlock, &list);
for (i = 0; i < count; i++) {
snprintf(path, sizeof(path), "%s%s", prefix, list[i].name);
if (list[i].secType == SEC_TYPE_USERDIR) {
strncat(path, "/", sizeof(path) - strlen(path) - 1u);
listAll(a, list[i].block, path);
} else if (list[i].secType == SEC_TYPE_FILE) {
printf("%s\n", path);
}
}
free(list);
}
// A folder and every folder above it that is not there yet.
static void makeDirs(const char *path) {
char buf[PATH_MAX_BYTES];
size_t i;
size_t n;
n = strlen(path);
if (n >= sizeof(buf)) {
toolFail("path too long: %s", path);
}
memcpy(buf, path, n + 1u);
for (i = 1; i <= n; i++) {
if (buf[i] == '/' || buf[i] == '\0') {
buf[i] = '\0';
if (mkdir(buf, DIR_MODE) != 0 && errno != EEXIST) {
toolFail("cannot make the folder %s: %s", buf, strerror(errno));
}
buf[i] = path[i];
}
}
}
static bool nameEqual(const char *a, size_t aLen, const char *b, size_t bLen) {
size_t i;
if (aLen != bLen) {
return false;
}
for (i = 0; i < aLen; i++) {
if (toupper((unsigned char)a[i]) != toupper((unsigned char)b[i])) {
return false;
}
}
return true;
}
// A file's bytes: its header's and extension blocks' tables of data
// blocks, which fill from the end (slot 71 first); an OFS data block holds
// its length after a 24-byte header, an FFS one is all data.
static uint8_t *readFile(const AdfT *a, uint32_t headerBlock, size_t *len) {
const uint8_t *chunk;
const uint8_t *data;
ToolBufT out;
int32_t size;
int32_t count;
int32_t used;
uint32_t slot;
uint32_t extension;
uint32_t guard;
memset(&out, 0, sizeof(out));
chunk = block(a, headerBlock);
size = field(chunk, -FILE_SIZE_FROM_END);
for (guard = 0;; guard++) {
if (guard > a->blocks) {
toolFail("%s: a file's extension blocks loop", a->path);
}
count = field(chunk, BLOCK_COUNT_AT);
for (slot = 0; (int32_t)slot < count && slot < HASH_SLOTS; slot++) {
data = block(a, (uint32_t)field(chunk, (int)(TABLE_AT + 4u * (HASH_SLOTS - 1u - slot))));
if (a->ffs) {
toolBufAdd(&out, data, BLOCK_SIZE);
} else {
used = field(data, OFS_DATA_SIZE_AT);
if (used < 0) {
used = 0;
} else if ((uint32_t)used > BLOCK_SIZE - OFS_DATA_HEADER) {
used = (int32_t)(BLOCK_SIZE - OFS_DATA_HEADER);
}
toolBufAdd(&out, data + OFS_DATA_HEADER, (size_t)used);
}
}
extension = (uint32_t)field(chunk, -EXTENSION_FROM_END);
if (extension == 0u) {
break;
}
chunk = block(a, extension);
}
*len = size < 0 ? 0u : ((size_t)size < out.len ? (size_t)size : out.len);
if (out.data == NULL) {
toolBufZeros(&out, 1u);
}
return out.data;
}
static void usage(void) {
fprintf(stderr, "usage: %s list IMAGE\n", TOOL_NAME);
fprintf(stderr, " %s extract IMAGE PATH OUT\n", TOOL_NAME);
fprintf(stderr, " %s extractall IMAGE OUTDIR\n", TOOL_NAME);
exit(USAGE_EXIT);
}
int main(int argc, char **argv) {
AdfT a;
uint8_t *data;
size_t len;
toolFileName(TOOL_NAME);
if (argc < 3 || (strcmp(argv[1], "list") != 0 && strcmp(argv[1], "extract") != 0 && strcmp(argv[1], "extractall") != 0)) {
usage();
}
memset(&a, 0, sizeof(a));
a.path = argv[2];
if (!toolReadFile(a.path, &a.image, &a.len)) {
toolFail("cannot read %s", a.path);
}
if (a.len % BLOCK_SIZE != 0u || a.len < BLOCK_SIZE || memcmp(a.image, "DOS", DOS_MAGIC_BYTES) != 0) {
toolFail("%s is not an AmigaDOS disk image", a.path);
}
a.ffs = (a.image[DOS_MAGIC_BYTES] & FFS_FLAG) != 0u;
a.blocks = (uint32_t)(a.len / BLOCK_SIZE);
a.rootBlock = a.blocks / 2u;
if (strcmp(argv[1], "list") == 0) {
listAll(&a, a.rootBlock, "");
} else if (strcmp(argv[1], "extract") == 0) {
if (argc != 5) {
usage();
}
data = readFile(&a, find(&a, argv[3]), &len);
if (!toolWriteFile(argv[4], data, len)) {
toolFail("cannot write %s", argv[4]);
}
free(data);
} else {
if (argc != 4) {
usage();
}
extractAll(&a, a.rootBlock, "", argv[3]);
}
free(a.image);
return 0;
}
Reference in a new issue View git blame Copy permalink