Macintosh-SW
/
libmfs
mirror of https://github.com/zydeco/libmfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
libmfs/mfs.c

762 lines
27 KiB
C
Raw Permalink Blame History

/*
* libmfs - library for reading Macintosh MFS volumes
* Copyright (C) 2008-2009 Jesus A. Alvarez
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <errno.h>
#include <arpa/inet.h>
#include "mfs.h"
#if defined(USE_LIBRES)
#include "fobj.h"
#endif
const char * libmfs_id = "libmfs 1.0.2 (C)2008-2010 namedfork.net";
// printable flags
#define BINFLG8(x) ((x)&0x80?'1':'0'),((x)&0x40?'1':'0'),((x)&0x20?'1':'0'),((x)&0x10?'1':'0'),((x)&0x08?'1':'0'),((x)&0x04?'1':'0'),((x)&0x02?'1':'0'),((x)&0x01?'1':'0')
#define BINFLG16(x) BINFLG8((x>>8)), BINFLG8(x)
// private functions
int mfs_blkread (MFSVolume *vol, size_t numBlocks, size_t offset, void *buf);
int mfs_albkread (MFSVolume *vol, size_t numBlocks, uint16_t start, void *buf);
int mfs_fkread_at_appledouble (MFSFork *fk, size_t size, size_t offset, void *buf);
int mfs_fkread_at_real (MFSFork *fk, size_t size, size_t offset, void *buf);
MFSVABM mfs_vabm (MFSVolume *vol);
MFSDirectoryRecord* mfs_directory_record (MFSDirectoryRecord *src, size_t size);
int16_t mfs_comment_id (const char *flCName);
int16_t mfs_folder_id (MFSDirectoryRecord *rec);
#ifdef USE_LIBRES
RFILE * mfs_desktop (MFSVolume *vol);
#endif
int mfs_load_folders (MFSVolume *vol);
int mfs_fneq (const uint8_t *s1, const uint8_t *s2);
#if defined(LIBMFS_VERBOSE)
int mfs_printmdb (MFSMasterDirectoryBlock *mdb);
int mfs_printrecord (MFSDirectoryRecord *rec);
#endif
MFSVolume* mfs_vopen (const char *path, size_t offset, int flags) {
FILE* fp = fopen(path, "r");
if (fp == NULL) return NULL;
MFSVolume* vol = malloc(sizeof(MFSVolume));
bzero(vol, sizeof(MFSVolume));
vol->fp = fp;
vol->offset = offset;
vol->openForks = 0;
// read MDB
void* mdb_block = malloc(kMFSBlockSize);
if (-1 == mfs_blkread(vol, 1, 2, mdb_block)) goto error;
memcpy(&vol->mdb, mdb_block, sizeof(MFSMasterDirectoryBlock));
free(mdb_block);
// bring to host endianness
MFSMasterDirectoryBlock *mdb = &vol->mdb;
mdb->drSigWord = ntohs(mdb->drSigWord);
mdb->drCrDate = ntohl(mdb->drCrDate);
mdb->drLsBkUp = ntohl(mdb->drLsBkUp);
mdb->drAtrb = ntohs(mdb->drAtrb);
mdb->drNmFls = ntohs(mdb->drNmFls);
mdb->drDirSt = ntohs(mdb->drDirSt);
mdb->drBlLen = ntohs(mdb->drBlLen);
mdb->drNmAlBlks = ntohs(mdb->drNmAlBlks);
mdb->drAlBlkSiz = ntohl(mdb->drAlBlkSiz);
mdb->drClpSiz = ntohl(mdb->drClpSiz);
mdb->drAlBlSt = ntohs(mdb->drAlBlSt);
mdb->drNxtFNum = ntohl(mdb->drNxtFNum);
mdb->drFreeBks = ntohs(mdb->drFreeBks);
strncpy(vol->name, (char*)&mdb->drVN[1], mdb->drVN[0]);
// check MDB
if (mdb->drSigWord != kMFSSignature) goto error;
#if defined(LIBMFS_VERBOSE)
mfs_printmdb(mdb);
#endif
// read volume allocation block map
vol->vabm = mfs_vabm(vol);
vol->alBkOff = mdb->drAlBlSt*kMFSBlockSize - 2*mdb->drAlBlkSiz;
// read directory
vol->directory = mfs_directory(vol);
// read tree
#if defined(USE_LIBRES)
if (flags & MFS_FOLDERS) mfs_load_folders(vol);
#endif
return vol;
error:
#if defined(_DARWIN_C_SOURCE)
errno = EFTYPE;
#else
errno = EINVAL;
#endif
free(vol);
return NULL;
}
int mfs_vclose (MFSVolume* vol) {
if (vol->openForks) {
errno = EBUSY;
return -1;
}
mfs_directory_free(vol->directory);
free(vol->vabm);
fclose(vol->fp);
#ifdef USE_LIBRES
if (vol->desktop) res_close(vol->desktop);
if (vol->folders) free(vol->folders);
#endif
free(vol);
return 0;
}
int mfs_blkread (MFSVolume *vol, size_t numBlocks, size_t offset, void *buf) {
if (-1 == fseek(vol->fp, vol->offset+(kMFSBlockSize*offset), SEEK_SET)) return -1;
if (numBlocks != fread(buf, kMFSBlockSize, numBlocks, vol->fp)) return -1;
return 0;
}
int mfs_albkread (MFSVolume *vol, size_t numBlocks, uint16_t start, void *buf) {
if (-1 == fseek(vol->fp, (vol->offset)+(vol->alBkOff)+(vol->mdb.drAlBlkSiz*start), SEEK_SET)) return -1;
if (numBlocks != fread(buf, vol->mdb.drAlBlkSiz, numBlocks, vol->fp)) return -1;
return 0;
}
time_t mfs_time (uint32_t mfsDate) {
return mfsDate - kMFSTimeDelta;
}
struct timespec mfs_timespec (uint32_t mfsDate) {
struct timespec ts;
ts.tv_sec = mfsDate - kMFSTimeDelta;
ts.tv_nsec = 0;
return ts;
}
#if defined(LIBMFS_VERBOSE)
int mfs_printmdb (MFSMasterDirectoryBlock *mdb) {
time_t t;
fprintf(stderr, "MASTER DIRECTORY BLOCK:\n");
fprintf(stderr, " signature: $%04X\n", mdb->drSigWord);
t = mfs_time(mdb->drCrDate);
fprintf(stderr, " creation: %s", asctime(localtime(&t)));
t = mfs_time(mdb->drLsBkUp);
fprintf(stderr, " backup: %s", asctime(localtime(&t)));
fprintf(stderr, " attributes: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n", BINFLG16(mdb->drAtrb));
fprintf(stderr, " files: %d\n", mdb->drNmFls);
fprintf(stderr, " dir.start: %d\n", mdb->drDirSt);
fprintf(stderr, " dir.len: %d\n", mdb->drBlLen);
fprintf(stderr, " al.bks: %d\n", mdb->drNmAlBlks);
fprintf(stderr, " al.bksz: %d\n", mdb->drAlBlkSiz);
fprintf(stderr, " al.bytes: %d\n", mdb->drClpSiz);
fprintf(stderr, " al.first: %d\n", mdb->drAlBlSt);
fprintf(stderr, " fn.next: %d\n", mdb->drNxtFNum);
fprintf(stderr, " free: %d\n", mdb->drFreeBks);
char volName[28];
strncpy(volName, (char*)&mdb->drVN[1], mdb->drVN[0]);
fprintf(stderr, " name: %s\n", volName);
fflush(stderr);
}
int mfs_printrecord (MFSDirectoryRecord *rec) {
fprintf(stderr, "DIRECTORY RECORD:\n");
fprintf(stderr, " name: %s\n", rec->flCName);
fprintf(stderr, " flags: %c%c%c%c%c%c%c%c\n", BINFLG8(rec->flFlags));
fprintf(stderr, " version: %d\n", rec->flTyp);
fprintf(stderr, " inode: %d\n", rec->flFlNum);
fprintf(stderr, " data.blk: %d\n", rec->flStBlk);
fprintf(stderr, " data.lgl: %d\n", rec->flLgLen);
fprintf(stderr, " data.pyl: %d\n", rec->flPyLen);
fprintf(stderr, " rsrc.blk: %d\n", rec->flRStBlk);
fprintf(stderr, " rsrc.lgl: %d\n", rec->flRLgLen);
fprintf(stderr, " rsrc.pyl: %d\n", rec->flRPyLen);
time_t t = mfs_time(rec->flCrDat);
fprintf(stderr, " created: %s", asctime(localtime(&t)));
t = mfs_time(rec->flMdDat);
fprintf(stderr, " modified: %s", asctime(localtime(&t)));
// user words
fprintf(stderr, " folder: %d\n", ntohs(rec->flUsrWds.folder));
uint16_t fflags = ntohs(rec->flUsrWds.flags);
fprintf(stderr, " fflags: %04X\n%s%s%s%s%s%s%s%s%s", fflags,
((fflags & kIsOnDesk)? " on desktop\n":""),
((fflags & kRequireSwitchLaunch)?" switch launch\n":""),
((fflags & kIsShared)? " shared\n":""),
((fflags & kHasNoINITs)? " no INITs\n":""),
((fflags & kHasBeenInited)? " inited\n":""),
((fflags & kChanged)? " changed\n":""),
((fflags & kNameLocked)? " name locked\n":""),
((fflags & kHasBundle)? " bundle\n":""),
((fflags & kIsInvisible)? " invisible\n":"")
);
fflush(stderr);
}
#endif
MFSVABM mfs_vabm (MFSVolume *vol) {
// VABM is 12-bit packed and comes after MDB
// read blocks containing VABM
MFSMasterDirectoryBlock *mdb = &vol->mdb;
size_t vabm_size = (mdb->drNmAlBlks*3)/2;
size_t vabm_span = vabm_size + sizeof(MFSMasterDirectoryBlock);
size_t vabm_blks = vabm_span/kMFSBlockSize + (vabm_span%kMFSBlockSize?1:0);
void* vabm_bits = malloc(vabm_blks*kMFSBlockSize);
if (-1 == mfs_blkread(vol, vabm_blks, 2, vabm_bits)) return NULL;
// parse VABM
void* vabm_base = vabm_bits + sizeof(MFSMasterDirectoryBlock);
MFSVABM vabm = malloc(sizeof(uint16_t)*(mdb->drNmAlBlks+2));
vabm[0] = mdb->drNmAlBlks;
vabm[1] = 0x1337;
size_t offset;
uint16_t val;
for(int n=2; n < 2+mdb->drNmAlBlks; n++) {
offset = ((n-2)*3)/2;
val = ntohs(*(uint16_t*)(vabm_base+offset));
if (n%2) vabm[n] = val & 0xFFF;
else vabm[n] = (val & 0xFFF0) >> 4;
}
return vabm;
}
// read directory
MFSDirectoryRecord ** mfs_directory (MFSVolume *vol) {
MFSMasterDirectoryBlock *mdb = &vol->mdb;
MFSBlock *dir_blk = calloc(mdb->drBlLen, kMFSBlockSize);
// array of pointers to records
MFSDirectoryRecord ** dir = calloc(mdb->drNmFls+1, sizeof(MFSDirectoryRecord*));
dir[mdb->drNmFls] = NULL;
// read directory blocks
mfs_blkread(vol, mdb->drBlLen, mdb->drDirSt, dir_blk);
// parse
MFSDirectoryRecord *rec;
size_t block, rec_offset;
size_t rec_count = 0, rec_size;
for(block = 0; block < mdb->drBlLen; block++) {
// read records in a block
rec_offset = 0;
for(;;) {
rec = (MFSDirectoryRecord*)&dir_blk[block][rec_offset];
rec_size = 51 + rec->flNam[0];
if (rec->flFlags) {
// record is used, copy it
dir[rec_count++] = mfs_directory_record(rec, rec_size);
rec_offset += rec_size;
if (rec_offset%2) rec_offset++;
} else break;
}
if (rec_count == mdb->drNmFls) break;
}
free(dir_blk);
return dir;
}
void mfs_directory_free (MFSDirectoryRecord ** dir) {
for(int i=0; dir[i]; i++) free(dir[i]);
free(dir);
}
MFSDirectoryRecord* mfs_directory_record (MFSDirectoryRecord *src, size_t size) {
MFSDirectoryRecord *rec = malloc(size+1);
memcpy(rec, src, size);
// null-terminate name
((uint8_t*)rec)[size] = '\0';
// bring to host endianness
rec->flFlNum = ntohl(rec->flFlNum);
rec->flStBlk = ntohs(rec->flStBlk);
rec->flLgLen = ntohl(rec->flLgLen);
rec->flPyLen = ntohl(rec->flPyLen);
rec->flRStBlk = ntohs(rec->flRStBlk);
rec->flRLgLen = ntohl(rec->flRLgLen);
rec->flRPyLen = ntohl(rec->flRPyLen);
rec->flCrDat = ntohl(rec->flCrDat);
rec->flMdDat = ntohl(rec->flMdDat);
#if defined(LIBMFS_VERBOSE)
mfs_printrecord(rec);
#endif
return rec;
}
MFSDirectoryRecord* mfs_directory_find_name (MFSDirectoryRecord **dir, const char *name) {
MFSDirectoryRecord *rec;
size_t namelen = strlen(name);
for(int i=0; dir[i]; i++) {
rec = dir[i];
if (rec->flNam[0] != namelen) continue;
if (mfs_fneq((const uint8_t*)rec->flCName, (const uint8_t*)name)) return rec;
}
return NULL;
}
// http://developer.apple.com/technotes/tb/tb_06.html
// Comments are in Desktop's FCMT resources, as a Str255
int16_t mfs_comment_id (const char *flCName) {
int16_t hash = 0;
for(int i = 0; flCName[i]; i++) {
hash ^= flCName[i];
// ROR.W
if (hash & 1) hash = (hash >> 1) | 0x8000;
else hash = ((hash >> 1) & 0x7fff);
if (hash > 0) hash = - hash;
}
return hash;
}
// returns newly allocated C-string in MacRoman encoding, or NULL if it fails
// pass rec as NULL for the disk's comment
char * mfs_comment (MFSVolume *vol, MFSDirectoryRecord *rec) {
if (vol == NULL) return NULL;
#if defined(USE_LIBRES)
int16_t cmtID = mfs_comment_id(rec? rec->flCName : vol->name);
unsigned char cmtLen;
size_t readBytes;
res_read(mfs_desktop(vol), 'FCMT', cmtID, &cmtLen, 0, 1, &readBytes, NULL);
if (readBytes == 0) return NULL;
char * comment = malloc((int)cmtLen+1);
res_read(mfs_desktop(vol), 'FCMT', cmtID, comment, 1, cmtLen, &readBytes, NULL);
comment[cmtLen] = '\0';
return comment;
#else
return NULL;
#endif
}
MFSFork* mfs_fkopen (MFSVolume *vol, MFSDirectoryRecord *rec, int mode, int write) {
if (vol == NULL || rec == NULL) {errno = ENOENT; return NULL;}
int isResourceFork = ((mode == kMFSForkRsrc) || (mode == kMFSForkAppleDouble));
// cannot open non-existant resource forks
// non-existant data forks behave like empty files
if ((mode == kMFSForkRsrc) && (rec->flRStBlk == 0)) {errno = ENOENT; return NULL;}
uint16_t fkNmBks = (isResourceFork?rec->flRPyLen:rec->flPyLen)/vol->mdb.drAlBlkSiz;
MFSFork* fk = malloc(sizeof(MFSFork) + (sizeof(uint16_t)*(fkNmBks+1)));
fk->_fkSgn = 0;
fk->fkVol = vol;
fk->fkDrRec = rec;
fk->fkMode = mode;
fk->fkLgLen = (isResourceFork?rec->flRLgLen:rec->flLgLen);
fk->fkNmBks = fkNmBks;
fk->fkAppleDouble = NULL;
fk->fkOffset = 0;
// read allocation map
if (fkNmBks) {
fk->fkAlMap[0] = (isResourceFork?rec->flRStBlk:rec->flStBlk);
uint16_t lastAlBk = fk->fkAlMap[0];
for(int i=1; i < fk->fkNmBks; i++) {
fk->fkAlMap[i] = vol->vabm[lastAlBk];
lastAlBk = fk->fkAlMap[i];
}
fk->fkAlMap[fkNmBks] = 0;
if (vol->vabm[lastAlBk] != kMFSAlBkLast) {
fprintf(stderr, "Invalid allocation block map for %s\n", rec->flCName);
errno = EFBIG;
free(fk);
return NULL;
};
}
// construct AppleDouble header
if (mode == kMFSForkAppleDouble) {
AppleDouble *as = malloc(kAppleDoubleHeaderLength);
fk->fkAppleDouble = as;
bzero(as, kAppleDoubleHeaderLength);
// header
as->magic = htonl(kAppleDoubleMagic);
as->version = htonl(kAppleDoubleVersion);
memcpy(&as->filesystem, "Mac OS X ", 16);
int e = 0;
// finder info
as->entry[e].type = htonl(kAppleDoubleFinderInfoEntry);
as->entry[e].offset = htonl(kAppleDoubleFinderInfoOffset);
as->entry[e].length = htonl(kAppleDoubleFinderInfoLength);
memcpy((void*)as+kAppleDoubleFinderInfoOffset, &rec->flUsrWds, 16);
e++;
/*
// finder comment
#ifdef USE_LIBRES
size_t commentLength;
if (mfs_desktop(vol) && res_read(vol->desktop, 'FCMT', mfs_comment_id(rec->flCName), (void*)as+kAppleDoubleCommentOffset, 0, 256, &commentLength, NULL)) {
as->entry[e].type = htonl(kAppleDoubleCommentEntry);
as->entry[e].offset = htonl(kAppleDoubleCommentOffset);
as->entry[e].length = htonl(commentLength);
e++;
}
#endif
*/
// resource fork
// kernel complains if it's not the last entry
if (fk->fkLgLen) {
as->entry[e].type = htonl(kAppleDoubleResourceForkEntry);
as->entry[e].offset = htonl(kAppleDoubleResourceForkOffset);
as->entry[e].length = htonl((uint32_t)fk->fkLgLen);
e++;
}
// number of entries written
as->numEntries = htons(e);
}
// set signature and open forks
vol->openForks++;
fk->_fkSgn = kMFSForkSignature;
return fk;
}
MFSFork* mfs_dhopen (MFSVolume *vol, MFSFolder *folder) {
// open AppleDouble header for folder
if (folder == NULL) return NULL;
MFSFork* fk = malloc(sizeof(MFSFork));
fk->_fkSgn = 0;
fk->fkVol = vol;
fk->fkDrRec = NULL;
fk->fkMode = kMFSForkAppleDouble;
fk->fkLgLen = 0;
fk->fkNmBks = 0;
fk->fkAppleDouble = NULL;
fk->fkOffset = 0;
// construct AppleDouble header
AppleDouble *as = malloc(kAppleDoubleHeaderLength);
fk->fkAppleDouble = as;
bzero(as, kAppleDoubleHeaderLength);
// header
as->magic = htonl(kAppleDoubleMagic);
as->version = htonl(kAppleDoubleVersion);
memcpy(&as->filesystem, "Mac OS X ", 16);
int e = 0;
// finder info
MFSFInfo finfo = {0, 0, 0, {0, 0}, 0};
finfo.flags = htons(folder->fdFlags);
finfo.loc.v = htons(folder->fdLocV);
finfo.loc.h = htons(folder->fdLocH);
as->entry[e].type = htonl(kAppleDoubleFinderInfoEntry);
as->entry[e].offset = htonl(kAppleDoubleFinderInfoOffset);
as->entry[e].length = htonl(kAppleDoubleFinderInfoLength);
memcpy((void*)as+kAppleDoubleFinderInfoOffset, &finfo, 16);
e++;
// TODO: finder comment as xattr
/*
// finder comment
#ifdef USE_LIBRES
size_t commentLength;
if (mfs_desktop(vol) && res_read(vol->desktop, 'FCMT', mfs_comment_id(folder->fdCNam), (void*)as+kAppleDoubleCommentOffset, 0, 256, &commentLength, NULL)) {
as->entry[e].type = htonl(kAppleDoubleCommentEntry);
as->entry[e].offset = htonl(kAppleDoubleCommentOffset);
as->entry[e].length = htonl(commentLength);
e++;
}
#endif
*/
// number of entries written
as->numEntries = htons(e);
// set signature and open forks
vol->openForks++;
fk->_fkSgn = kMFSForkSignature;
return fk;
}
int mfs_fkclose (MFSFork *fk) {
if (fk->_fkSgn != kMFSForkSignature) {
errno = EBADF;
return -1;
}
fk->_fkSgn = 0;
if (fk->fkAppleDouble) free(fk->fkAppleDouble);
fk->fkVol->openForks--;
free(fk);
return 0;
}
int mfs_fkread_at (MFSFork *fk, size_t size, size_t offset, void *buf) {
switch(fk->fkMode) {
case kMFSForkData:
case kMFSForkRsrc:
return mfs_fkread_at_real(fk, size, offset, buf);
case kMFSForkAppleDouble:
return mfs_fkread_at_appledouble(fk, size, offset, buf);
}
}
unsigned long mfs_fkread (void *fk, void *buf, unsigned long length) {
return mfs_fkread_at((MFSFork*)fk, length, ((MFSFork*)fk)->fkOffset, buf);
}
unsigned long mfs_fkseek (void *fk, long offset, int whence) {
// set offset
uint32_t fkLen = ((MFSFork*)fk)->fkLgLen + ((((MFSFork*)fk)->fkMode == kMFSForkAppleDouble)? kAppleDoubleHeaderLength : 0);
switch(whence) {
case SEEK_SET:
((MFSFork*)fk)->fkOffset = offset;
break;
case SEEK_END:
((MFSFork*)fk)->fkOffset = fkLen + offset;
break;
case SEEK_CUR:
((MFSFork*)fk)->fkOffset += offset;
break;
}
return (unsigned long)((MFSFork*)fk)->fkOffset;
}
long mfs_ftell (MFSFork *fk) {
return fk->fkOffset;
}
int mfs_fkread_at_appledouble (MFSFork *fk, size_t size, size_t offset, void *buf) {
if (size == 0) return 0;
size_t asLgLen = kAppleDoubleHeaderLength + fk->fkLgLen;
if (offset >= asLgLen) return 0;
if (offset + size > asLgLen) size = asLgLen - offset;
// read in resource fork only
if (offset >= kAppleDoubleResourceForkOffset)
return mfs_fkread_at_real(fk, size, offset-kAppleDoubleResourceForkOffset, buf);
// read from AppleDouble header:
size_t btr = size;
size_t hdBtr = kAppleDoubleHeaderLength - offset;
if (hdBtr > size) hdBtr = size;
memcpy(buf, fk->fkAppleDouble, hdBtr);
btr -= hdBtr;
buf += hdBtr;
// read from fork
if (btr) return hdBtr + mfs_fkread_at_real(fk, btr, 0, buf);
return size;
}
int mfs_fkread_at_real (MFSFork *fk, size_t size, size_t offset, void *buf) {
if (size == 0) return 0;
if (offset >= fk->fkLgLen) return 0;
if (offset + size > fk->fkLgLen) size = fk->fkLgLen - offset;
// read blocks and copy data
size_t btr = size; // total bytes to read
size_t bkBtr; // bytes to read from block
uint16_t bkn = offset / (fk->fkVol->mdb.drAlBlkSiz); // block index
size_t bk1Off = offset % (fk->fkVol->mdb.drAlBlkSiz); // offset in first block
void *bk = malloc(fk->fkVol->mdb.drAlBlkSiz);
// read first block
mfs_albkread(fk->fkVol, 1, fk->fkAlMap[bkn], bk);
bkBtr = (fk->fkVol->mdb.drAlBlkSiz - bk1Off); // maximum bytes readable from first block
if (bkBtr > btr) bkBtr = btr;
memcpy(buf, bk+bk1Off, bkBtr);
btr -= bkBtr;
buf += bkBtr;
bkn++;
// read other blocks
while(btr) {
// read block
mfs_albkread(fk->fkVol, 1, fk->fkAlMap[bkn], bk);
// bytes to read
if (btr >= fk->fkVol->mdb.drAlBlkSiz) bkBtr = fk->fkVol->mdb.drAlBlkSiz;
else bkBtr = btr;
// copy
memcpy(buf, bk, bkBtr);
// advance
btr -= bkBtr;
buf += bkBtr;
bkn++;
}
free(bk);
return (int)size;
}
#ifdef USE_LIBRES
RFILE * mfs_desktop (MFSVolume *vol) {
if (vol->desktop == NULL) {
MFSDirectoryRecord *dr = mfs_directory_find_name(vol->directory, "Desktop");
MFSFork *df = mfs_fkopen(vol, dr, kMFSForkRsrc, 0);
void* desktopData = malloc(df->fkLgLen);
mfs_fkread_at(df, df->fkLgLen, 0, desktopData);
vol->desktop = res_open_mem(desktopData, df->fkLgLen, 0);
mfs_fkclose(df);
}
return vol->desktop;
}
int mfs_load_folders (MFSVolume *vol) {
size_t count;
int i;
if (vol->desktop == NULL) vol->desktop = mfs_desktop(vol);
if (vol->desktop == NULL) return 0;
ResAttr * fobj = res_list(vol->desktop, 'FOBJ', NULL, 0, 0, &count, NULL);
if (fobj == NULL) return 0;
vol->folders = calloc(count, sizeof(struct MFSFolder));
if (vol->folders == NULL) return 0;
bzero(vol->folders, sizeof(struct MFSFolder)*count);
vol->numFolders = count;
// fill
for(i=0; i < count; i++) {
vol->folders[i].fdID = fobj[i].ID;
strncpy(vol->folders[i].fdCNam, fobj[i].name, 65); // stupid linux has no strlcpy
vol->folders[i].fdCNam[64] = '\0';
// FOBJ resource
FOBJrsrc * fr = res_read(vol->desktop, 'FOBJ', fobj[i].ID, NULL, 0, sizeof(FOBJrsrc), NULL, NULL);
if (fr) {
vol->folders[i].fdParent = ntohs(fr->parent);
vol->folders[i].fdCrDat = ntohl(fr->fdCrDat);
vol->folders[i].fdMdDat = ntohl(fr->fdMdDat);
vol->folders[i].fdFlags = ntohl(fr->fdFlags);
vol->folders->fdLocV = ntohs(fr->fdIconPos.v);
vol->folders->fdLocH = ntohs(fr->fdIconPos.h);
}
vol->folders[i].fdSubdirs = 0;
}
// set # of subdirs in each
for(i=0; i < count; i++) {
MFSFolder *parent = mfs_folder_find(vol, vol->folders[i].fdParent);
if (parent == NULL) continue;
++parent->fdSubdirs;
}
// print folders
#if defined(LIBMFS_VERBOSE)
fprintf(stderr, "FOLDERS:\n# PAR# SUB NAME\n");
for(i=0; i < count; i++)
fprintf(stderr, "%-7hd%-7hd%-4hd%s\n", vol->folders[i].fdID, vol->folders[i].fdParent,
vol->folders[i].fdSubdirs, vol->folders[i].fdCNam);
fflush(stderr);
#endif
free(fobj);
return count;
}
#endif
MFSFolder* mfs_folder_find (MFSVolume *vol, int16_t fdID) {
if (fdID == -2) return NULL;
if (vol->folders == NULL) return NULL;
for(int i=0; i < vol->numFolders; i++)
if (vol->folders[i].fdID == fdID) return &vol->folders[i];
return NULL;
}
MFSFolder* mfs_folder_find_name (MFSVolume *vol, const char *name) {
if (vol->folders == NULL) return NULL;
for(int i=0; i < vol->numFolders; i++)
if (mfs_fneq((const uint8_t*)name, (const uint8_t*)vol->folders[i].fdCNam)) return &vol->folders[i];
return NULL;
}
int mfs_path_info (MFSVolume *vol, const char *path) {
if (*path == ':') ++path;
if (*path == '\0') return kMFSPathFolder;
const char *last = strrchr(path, ':');
if (last == NULL) last=path; else ++last;
MFSDirectoryRecord *rec;
// check if last item exists
rec = mfs_directory_find_name(vol->directory, last);
if (vol->folders == NULL) return rec?kMFSPathFile:kMFSPathError;
if ((mfs_folder_find_name(vol, last) == NULL) && (rec == NULL))
return kMFSPathError;
// check every item
char *pathsep = strdup(path);
char *item, *next;
MFSFolder *parent = mfs_folder_find(vol, kMFSFolderRoot);
MFSFolder *folder;
last = strrchr(pathsep, ':');
if (last == NULL) last=pathsep; else ++last;
item = next = pathsep;
for(;;) {
item = strsep(&next, ":");
if (item == last) {
folder = mfs_folder_find_name(vol, item);
if (rec && ntohs(rec->flUsrWds.folder) != parent->fdID)
// file wasn't inside parent folder
goto fail;
else if ((rec == NULL) && folder && (folder->fdParent != parent->fdID))
// folder wasn't inside parent folder
goto fail;
break;
}
// check that the folder exists, and it's inside it's parent
folder = mfs_folder_find_name(vol, item);
if ((folder == NULL) || (folder->fdParent != parent->fdID)) goto fail;
parent = folder;
}
free(pathsep);
if (rec) return kMFSPathFile;
return kMFSPathFolder;
fail:
free(pathsep);
return kMFSPathError;
}
int mfs_fneq (const uint8_t *s1, const uint8_t *s2) {
// return 1 if MFS filenames are equal, 0 otherwise
static const uint8_t mfs_chars_toupper[256] = {
// array of MacRoman uppercase equivalents, taken from system 6
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0xCB, 0x89, 0x80, 0xCC, 0x81, 0x82, 0x83, 0x8F,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x84, 0x97, 0x98, 0x99, 0x85, 0xCD, 0x9C, 0x9D, 0x9E, 0x86,
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xAE, 0xAF,
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
};
while (mfs_chars_toupper[*s1] == mfs_chars_toupper[*s2++])
if (*s1++ == 0) return 1;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink