mirror of
https://github.com/ctm/executor.git
synced 2024-09-29 18:58:01 +00:00
1033 lines
24 KiB
C
1033 lines
24 KiB
C
/* Copyright 1992 - 1996 by Abacus Research and
|
|
* Development, Inc. All rights reserved.
|
|
*/
|
|
|
|
#if !defined (OMIT_RCSID_STRINGS)
|
|
char ROMlib_rcsid_hfsXbar[] =
|
|
"$Id: hfsXbar.c 87 2005-05-25 01:57:33Z ctm $";
|
|
#endif
|
|
|
|
/* Forward declarations in FileMgr.h (DO NOT DELETE THIS LINE) */
|
|
|
|
#include "rsys/common.h"
|
|
#include "FileMgr.h"
|
|
#include "rsys/hfs.h"
|
|
#include "rsys/file.h"
|
|
#include "rsys/stdfile.h"
|
|
#include "rsys/flags.h"
|
|
|
|
/*
|
|
* TODO: pass the information gleaned by hfsvol and hfsfil into the
|
|
* various hfsPB and ufsPB routines.
|
|
*/
|
|
|
|
#if defined(CACHECHECK)
|
|
void cachecheck(HVCB *vcbp)
|
|
{
|
|
cacheentry *cachep;
|
|
cachehead *headp;
|
|
INTEGER i;
|
|
|
|
headp = (cachehead *) CL(vcbp->vcbCtlBuf);
|
|
for (i = Cx(headp->nitems), cachep = Cx(headp->flink); --i >= 0;
|
|
cachep = Cx(cachep->flink))
|
|
if (Cx(cachep->flags) & CACHEBUSY)
|
|
warning_unexpected ("busy");
|
|
}
|
|
#endif /* defined(CACHECHECK) */
|
|
|
|
PRIVATE BOOLEAN hfsvol(ioParam *pb)
|
|
{
|
|
HVCB *vcbp;
|
|
LONGINT dir;
|
|
|
|
vcbp = ROMlib_findvcb(Cx(pb->ioVRefNum), MR(pb->ioNamePtr), &dir, TRUE);
|
|
if (!vcbp) {
|
|
vcbp = ROMlib_findvcb(Cx(pb->ioVRefNum), (StringPtr) 0, &dir, TRUE);
|
|
if (!vcbp)
|
|
return TRUE; /* hopefully is a messed up working dir
|
|
reference */
|
|
}
|
|
if (vcbp->vcbCTRef) {
|
|
#if defined(CACHECHECK)
|
|
cachecheck(vcbp);
|
|
#endif /* defined(CACHECHECK) */
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
|
|
PRIVATE BOOLEAN hfsIvol(volumeParam *pb) /* potentially Indexed vol */
|
|
{
|
|
BOOLEAN retval;
|
|
HVCB *vcbp;
|
|
|
|
retval = FALSE;
|
|
if (Cx(pb->ioVolIndex) > 0) {
|
|
vcbp = (HVCB *) ROMlib_indexqueue(&VCBQHdr, Cx(pb->ioVolIndex));
|
|
if (vcbp && vcbp->vcbCTRef)
|
|
retval = TRUE;
|
|
} else
|
|
retval = hfsvol((ioParam *) pb);
|
|
return retval;
|
|
}
|
|
|
|
PRIVATE BOOLEAN hfsfil(ioParam *pb)
|
|
{
|
|
filecontrolblock *fcbp;
|
|
HVCB *vcbp;
|
|
|
|
fcbp = ROMlib_refnumtofcbp(Cx(pb->ioRefNum));
|
|
if (fcbp) {
|
|
vcbp = MR(fcbp->fcbVPtr);
|
|
if (vcbp->vcbCTRef) {
|
|
#if defined(CACHECHECK)
|
|
cachecheck(vcbp);
|
|
#endif /* defined(CACHECHECK) */
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHRename, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHRename(pb, async);
|
|
else
|
|
retval = ufsPBHRename(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHCreate, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHCreate(pb, async);
|
|
else
|
|
retval = ufsPBHCreate(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBDirCreate, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBDirCreate(pb, async);
|
|
else
|
|
retval = ufsPBDirCreate(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHDelete, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHDelete(pb, async);
|
|
else
|
|
retval = ufsPBHDelete(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
PRIVATE void
|
|
try_to_reopen (DrvQExtra *dqp)
|
|
{
|
|
#if defined(LINUX)
|
|
drive_flags_t flags;
|
|
dqp->hfs.fd = linuxfloppy_open (0, &dqp->hfs.bsize, &flags,
|
|
(char *) dqp->devicename);
|
|
#elif defined(MSDOS)
|
|
#else
|
|
/* #warning need to be able to reopen a drive */
|
|
warning_unimplemented ("Unable to reopen a drive because the code has not "
|
|
"yet\nbeen written for this platform.");
|
|
#endif
|
|
}
|
|
|
|
PUBLIC int ROMlib_directdiskaccess = FALSE;
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBRead, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
DrvQExtra *dqp;
|
|
|
|
switch (Cx(pb->ioParam.ioRefNum)) {
|
|
case OURHFSDREF:
|
|
if (ROMlib_directdiskaccess) {
|
|
dqp = ROMlib_dqbydrive(Cx(pb->ioParam.ioVRefNum));
|
|
if (!dqp) {
|
|
pb->ioParam.ioResult = CW(nsvErr);
|
|
pb->ioParam.ioActCount = 0;
|
|
} else {
|
|
if (dqp->hfs.fd == -1)
|
|
try_to_reopen (dqp);
|
|
if (dqp->hfs.fd == -1)
|
|
{
|
|
pb->ioParam.ioResult = CWC (nsvErr);
|
|
pb->ioParam.ioActCount = 0;
|
|
}
|
|
else if (Cx(pb->ioParam.ioPosMode) != fsFromStart) {
|
|
pb->ioParam.ioResult = CW(paramErr); /* for now */
|
|
pb->ioParam.ioActCount = 0;
|
|
} else
|
|
pb->ioParam.ioResult = CW(ROMlib_transphysblk(&dqp->hfs,
|
|
Cx(pb->ioParam.ioPosOffset),
|
|
Cx(pb->ioParam.ioReqCount) / PHYSBSIZE,
|
|
MR(pb->ioParam.ioBuffer), reading,
|
|
&pb->ioParam.ioActCount));
|
|
|
|
}
|
|
} else {
|
|
pb->ioParam.ioResult = CW(vLckdErr);
|
|
pb->ioParam.ioActCount = 0;
|
|
}
|
|
retval = Cx(pb->ioParam.ioResult);
|
|
break;
|
|
|
|
default:
|
|
if (pb->ioParam.ioPosMode & CWC (NEWLINEMODE))
|
|
{
|
|
char *buf, *p_to_find, *p_alternate, *p;
|
|
unsigned char to_find;
|
|
long act_count;
|
|
ParamBlockRec pbr;
|
|
|
|
pbr = *pb;
|
|
to_find = CW (pb->ioParam.ioPosMode) >> 8;
|
|
pbr.ioParam.ioPosMode &= CWC (0x7F);
|
|
|
|
buf = alloca (CL (pb->ioParam.ioReqCount));
|
|
|
|
pbr.ioParam.ioBuffer = (Ptr) RM (buf);
|
|
retval = PBRead (&pbr, FALSE);
|
|
pb->ioParam.ioActCount = pbr.ioParam.ioActCount;
|
|
pb->ioParam.ioPosOffset = pbr.ioParam.ioPosOffset;
|
|
|
|
act_count = CL (pb->ioParam.ioActCount);
|
|
p_to_find = memchr (buf, to_find, act_count);
|
|
|
|
if (to_find == '\r' && ROMlib_newlinetocr)
|
|
p_alternate = memchr (buf, '\n', act_count);
|
|
else
|
|
p_alternate = 0;
|
|
|
|
if (p_alternate && (!p_to_find || p_alternate < p_to_find))
|
|
p = p_alternate;
|
|
else
|
|
p = p_to_find;
|
|
|
|
if (p)
|
|
{
|
|
long to_backup;
|
|
|
|
retval = noErr; /* we couldn't have gotten EOF yet */
|
|
to_backup = act_count - (p+1 - buf);
|
|
SWAPPED_OPL (pb->ioParam.ioActCount , -, to_backup);
|
|
#if 0
|
|
SWAPPED_OPL (pb->ioParam.ioPosOffset, -, to_backup);
|
|
#else
|
|
{
|
|
ParamBlockRec newpb;
|
|
OSErr newerr;
|
|
|
|
newpb.ioParam.ioRefNum = pb->ioParam.ioRefNum;
|
|
newpb.ioParam.ioPosMode = CWC (fsFromMark);
|
|
newpb.ioParam.ioPosOffset = CL (- to_backup);
|
|
newerr = PBSetFPos (&newpb, FALSE);
|
|
if (newerr != noErr)
|
|
warning_unexpected ("err = %d", newerr);
|
|
}
|
|
#endif
|
|
if (ROMlib_newlinetocr && to_find == '\r')
|
|
*p = '\r';
|
|
}
|
|
memcpy (MR (pb->ioParam.ioBuffer), MR (pbr.ioParam.ioBuffer),
|
|
CL (pb->ioParam.ioActCount));
|
|
ROMlib_destroy_blocks ((syn68k_addr_t) (long)
|
|
US_TO_SYN68K(MR (pb->ioParam.ioBuffer)),
|
|
CL (pb->ioParam.ioActCount), TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBRead(pb, async);
|
|
else
|
|
retval = ufsPBRead(pb, async);
|
|
}
|
|
break;
|
|
}
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
#define SOUND_DRIVER_REF (-4)
|
|
#define ffMode 0
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBWrite, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
HVCB *vcbp;
|
|
DrvQExtra *dqp;
|
|
|
|
switch (Cx(pb->ioParam.ioRefNum)) {
|
|
case OURHFSDREF:
|
|
if (!ROMlib_directdiskaccess)
|
|
pb->ioParam.ioResult = CW(vLckdErr);
|
|
else {
|
|
dqp = ROMlib_dqbydrive(Cx(pb->ioParam.ioVRefNum));
|
|
if (dqp && dqp->hfs.fd == -1)
|
|
try_to_reopen (dqp);
|
|
vcbp = ROMlib_vcbbydrive (Cx(pb->ioParam.ioVRefNum));
|
|
if (!dqp)
|
|
pb->ioParam.ioResult = CW(nsvErr);
|
|
else if (vcbp && (Cx(vcbp->vcbAtrb) & VSOFTLOCKBIT))
|
|
pb->ioParam.ioResult = CW(vLckdErr);
|
|
else if (vcbp && (Cx(vcbp->vcbAtrb) & VHARDLOCKBIT))
|
|
pb->ioParam.ioResult = CW(wPrErr);
|
|
else if (Cx(pb->ioParam.ioPosMode) != fsFromStart)
|
|
pb->ioParam.ioResult = CW(paramErr); /* for now */
|
|
else
|
|
pb->ioParam.ioResult = CW(ROMlib_transphysblk(&dqp->hfs,
|
|
Cx(pb->ioParam.ioPosOffset),
|
|
Cx(pb->ioParam.ioReqCount) / PHYSBSIZE,
|
|
MR(pb->ioParam.ioBuffer), writing,
|
|
&pb->ioParam.ioActCount));
|
|
|
|
}
|
|
if (pb->ioParam.ioResult != noErr)
|
|
pb->ioParam.ioActCount = 0;
|
|
retval = Cx(pb->ioParam.ioResult);
|
|
break;
|
|
|
|
#if 0
|
|
case SOUND_DRIVER_REF:
|
|
p = (char *) Cx(pb->ioParam.ioBuffer);
|
|
if (CW(*(short *)p) == ffMode) {
|
|
n = Cx(pb->ioParam.ioReqCount);
|
|
ROMlib_dosound(p + 4, n - 4, (void (*)(void)) 0);
|
|
}
|
|
retval = noErr;
|
|
break;
|
|
#endif
|
|
default:
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBWrite(pb, async);
|
|
else
|
|
retval = ufsPBWrite(pb, async);
|
|
break;
|
|
}
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBClose, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBClose(pb, async);
|
|
else
|
|
retval = ufsPBClose(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
/*
|
|
* The test for ioBuffer being 0 was determined necessary after MacRoads
|
|
* couldn't open the serial drivers. When I first tested PBHOpen to see
|
|
* if it could open drivers, it couldn't, but that's because my test was
|
|
* coded according to Inside Macintosh and I was assuming that ioBuffer
|
|
* wasn't examined. It took a few runs of binary searches stuffing fields
|
|
* with zeros to find out that ioBuffer had this magic property.
|
|
*
|
|
* PBOpen doesn't require ioBuffer to be 0 in order to open a driver.
|
|
*/
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHOpen, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (pb->ioParam.ioBuffer == 0 &&
|
|
pb->ioParam.ioNamePtr && MR(pb->ioParam.ioNamePtr)[0]
|
|
&& MR(pb->ioParam.ioNamePtr)[1] == '.')
|
|
retval = ROMlib_driveropen((ParmBlkPtr) pb, async);
|
|
else if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHOpen(pb, async);
|
|
else
|
|
retval = ufsPBHOpen(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBOpenDF, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHOpen(pb, async);
|
|
else
|
|
retval = ufsPBHOpen(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHOpenRF, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHOpenRF(pb, async);
|
|
else
|
|
retval = ufsPBHOpenRF(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
#if 0
|
|
PRIVATE void
|
|
swappedstr255print (const char *prefix, Str255 sp)
|
|
{
|
|
printf ("%s", prefix);
|
|
if (sp)
|
|
{
|
|
unsigned char *cp;
|
|
int n;
|
|
|
|
cp = (unsigned char *) MR(sp);
|
|
n = *cp++;
|
|
while (n-- > 0)
|
|
putchar (*cp++);
|
|
}
|
|
else
|
|
printf ("<empty>");
|
|
printf ("\n");
|
|
}
|
|
#endif
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetCatInfo, CInfoPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
BOOLEAN ishfs;
|
|
StringPtr savep;
|
|
|
|
if (CW(pb->dirInfo.ioFDirIndex) < 0 && pb->hFileInfo.ioDirID == CLC (1))
|
|
retval = -43; /* perhaps we should check for a valid volume
|
|
first */
|
|
else
|
|
{
|
|
savep = pb->dirInfo.ioNamePtr;
|
|
if (pb->dirInfo.ioFDirIndex != CWC (0)) /* IMIV-155, 156 */
|
|
pb->dirInfo.ioNamePtr = 0;
|
|
ishfs = hfsvol((ioParam *) pb);
|
|
pb->dirInfo.ioNamePtr = savep;
|
|
|
|
if (ishfs)
|
|
retval = hfsPBGetCatInfo(pb, async);
|
|
else
|
|
retval = ufsPBGetCatInfo(pb, async);
|
|
}
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetCatInfo, CInfoPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBSetCatInfo(pb, async);
|
|
else
|
|
retval = ufsPBSetCatInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBCatMove, CMovePBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBCatMove(pb, async);
|
|
else
|
|
retval = ufsPBCatMove(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetVInfo, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsIvol((volumeParam *) pb))
|
|
retval = hfsPBGetVInfo(pb, async);
|
|
else
|
|
retval = ufsPBGetVInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A1(PUBLIC trap, OSErrRET, PBUnmountVol, ParmBlkPtr, pb)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBUnmountVol(pb);
|
|
else
|
|
retval = ufsPBUnmountVol(pb);
|
|
PBRETURN (pb, retval);
|
|
}
|
|
|
|
A1(PUBLIC trap, OSErrRET, PBEject, ParmBlkPtr, pb)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBEject(pb);
|
|
else
|
|
retval = ufsPBEject(pb);
|
|
PBRETURN (pb, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBAllocate, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBAllocate(pb, async);
|
|
else
|
|
retval = ufsPBAllocate(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBAllocContig, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBAllocContig(pb, async);
|
|
else
|
|
retval = ufsPBAllocContig(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHGetFInfo, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
BOOLEAN ishfs;
|
|
StringPtr savep;
|
|
|
|
savep = pb->ioParam.ioNamePtr;
|
|
if (CW(pb->fileParam.ioFDirIndex) > 0) /* IMIV-155, 156 */
|
|
pb->ioParam.ioNamePtr = 0;
|
|
ishfs = hfsvol((ioParam *) pb);
|
|
pb->ioParam.ioNamePtr = savep;
|
|
|
|
if (ishfs)
|
|
retval = hfsPBHGetFInfo(pb, async);
|
|
else
|
|
retval = ufsPBHGetFInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetEOF, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBSetEOF(pb, async);
|
|
else
|
|
retval = ufsPBSetEOF(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBOpen, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (pb->ioParam.ioNamePtr && MR(pb->ioParam.ioNamePtr)[0]
|
|
&& MR(pb->ioParam.ioNamePtr)[1] == '.')
|
|
retval = ROMlib_driveropen(pb, async);
|
|
else if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBOpen(pb, async);
|
|
else
|
|
retval = ufsPBOpen(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
#if !defined (NDEBUG)
|
|
PUBLIC void test_serial(void)
|
|
{
|
|
OSErr open_in_val, open_out_val, close_in_val, close_out_val;
|
|
ParamBlockRec pb_in, pb_out;
|
|
static int count = 0;
|
|
|
|
memset (&pb_in, 0, sizeof pb_in);
|
|
memset (&pb_out, 0, sizeof pb_out);
|
|
pb_in.ioParam.ioNamePtr = RM ((StringPtr) "\004.AIn");
|
|
pb_out.ioParam.ioNamePtr = RM ((StringPtr) "\005.AOut");
|
|
open_in_val = PBOpen (&pb_in, FALSE);
|
|
open_out_val = PBOpen (&pb_out, FALSE);
|
|
close_in_val = PBClose (&pb_in, FALSE);
|
|
close_out_val = PBClose (&pb_out, FALSE);
|
|
++count;
|
|
}
|
|
#endif
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBOpenRF, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBOpenRF(pb, async);
|
|
else
|
|
retval = ufsPBOpenRF(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBLockRange, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBLockRange(pb, async);
|
|
else
|
|
retval = ufsPBLockRange(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBUnlockRange, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBUnlockRange(pb, async);
|
|
else
|
|
retval = ufsPBUnlockRange(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetFPos, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBGetFPos(pb, async);
|
|
else
|
|
retval = ufsPBGetFPos(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetFPos, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBSetFPos(pb, async);
|
|
else
|
|
retval = ufsPBSetFPos(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetEOF, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBGetEOF(pb, async);
|
|
else
|
|
retval = ufsPBGetEOF(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBFlushFile, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsfil((ioParam *) pb))
|
|
retval = hfsPBFlushFile(pb, async);
|
|
else
|
|
retval = ufsPBFlushFile(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBCreate, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBCreate(pb, async);
|
|
else
|
|
retval = ufsPBCreate(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBDelete, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBDelete(pb, async);
|
|
else
|
|
retval = ufsPBDelete(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBOpenWD, WDPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBOpenWD(pb, async);
|
|
else
|
|
retval = ufsPBOpenWD(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBCloseWD, WDPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBCloseWD(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetWDInfo, WDPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBGetWDInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetFInfo, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
BOOLEAN ishfs;
|
|
StringPtr savep;
|
|
OSErr retval;
|
|
|
|
savep = pb->ioParam.ioNamePtr;
|
|
if (CW(pb->fileParam.ioFDirIndex) > 0) /* IMIV-155, 156 */
|
|
pb->ioParam.ioNamePtr = 0;
|
|
ishfs = hfsvol((ioParam *) pb);
|
|
pb->ioParam.ioNamePtr = savep;
|
|
|
|
if (ishfs)
|
|
retval = hfsPBGetFInfo(pb, async);
|
|
else
|
|
retval = ufsPBGetFInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetFInfo, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBSetFInfo(pb, async);
|
|
else
|
|
retval = ufsPBSetFInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHSetFInfo, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHSetFInfo(pb, async);
|
|
else
|
|
retval = ufsPBHSetFInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetFLock, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBSetFLock(pb, async);
|
|
else
|
|
retval = ufsPBSetFLock(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHSetFLock, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHSetFLock(pb, async);
|
|
else
|
|
retval = ufsPBHSetFLock(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBRstFLock, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBRstFLock(pb, async);
|
|
else
|
|
retval = ufsPBRstFLock(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHRstFLock, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBHRstFLock(pb, async);
|
|
else
|
|
retval = ufsPBHRstFLock(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetFVers, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBSetFVers(pb, async);
|
|
else
|
|
retval = ufsPBSetFVers(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBRename, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBRename(pb, async);
|
|
else
|
|
retval = ufsPBRename(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
/*
|
|
* The code below has a hack in it that is due to the non-standard way in
|
|
* which we handle floppy drives. Currently, under Executor, Cmd-Shift-2
|
|
* causes all potentially removable media drives to be scanned for new volumes
|
|
* and any that are found are immediately mounted. This means that programs
|
|
* that use GetOSEvent to pick up disk inserted events *before* mounting that
|
|
* then do their own mounting will lose, since the volume will already be
|
|
* mounted and hence their own mount will fail. BodyWorks 3.0's Installer
|
|
* does this. So currently if drive 1 or drive 2 is explictly being mounted
|
|
* we return noErr. This can get us into trouble later, but to fix it will
|
|
* require a major rewrite of how we handle removable media.
|
|
*
|
|
* As a matter of fact, Browser used to have problems with this because it
|
|
* would call PBMountVol to determine whether or not the floppy drive had
|
|
* a disk in it that either was mounted or could be mounted, and it would
|
|
* then call PBGetVInfo and not look at the return value and unconditionally
|
|
* use the volume name it expected to be returned. Ugh.
|
|
*/
|
|
|
|
/* #warning hacked PBMountVol */
|
|
|
|
A1(PUBLIC trap, OSErr, PBMountVol, ParmBlkPtr, pb)
|
|
{
|
|
#if 0
|
|
if (hfsfil((ioParam *) pb))
|
|
return hfsPBMountVol(pb);
|
|
else
|
|
return ufsPBMountVol(pb);
|
|
#else
|
|
INTEGER vref;
|
|
OSErr retval;
|
|
|
|
vref = CW(pb->ioParam.ioVRefNum);
|
|
if (vref == 1 || vref == 2)
|
|
retval = noErr;
|
|
else
|
|
retval = ufsPBMountVol(pb);
|
|
PBRETURN (pb, retval);
|
|
#endif
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHGetVInfo, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsIvol((volumeParam *) pb))
|
|
retval = hfsPBHGetVInfo(pb, async);
|
|
else
|
|
retval = ufsPBHGetVInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
/* Smaller Installer wants to see bit 17 set. We're guessing the other
|
|
* bits will keep programs from messing with us */
|
|
|
|
enum { VOL_BITS = ((1L << bHasExtFSVol)
|
|
| (1L << bNoSysDir)
|
|
| (1L << bNoBootBlks)
|
|
| (1L << bNoDeskItems)
|
|
| (1L << bNoSwitchTo)
|
|
| (1L << bNoLclSync)
|
|
| (1L << bNoVNEdit)
|
|
| (1L << bNoMiniFndr)) };
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHGetVolParms, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
LONGINT dir;
|
|
HVCB *vcbp;
|
|
getvolparams_info_t *infop;
|
|
OSErr err;
|
|
INTEGER rc, nused;
|
|
|
|
#define roomfor(ptr, field, byte_count) \
|
|
((byte_count) \
|
|
>= (int) offsetof (typeof (*(ptr)), field) + (int) sizeof ((ptr)->field))
|
|
|
|
vcbp = ROMlib_findvcb(Cx(pb->ioParam.ioVRefNum),
|
|
MR(pb->ioParam.ioNamePtr), &dir, FALSE);
|
|
if (vcbp)
|
|
{
|
|
infop = (getvolparams_info_t *) MR (pb->ioParam.ioBuffer);
|
|
rc = CL (pb->ioParam.ioReqCount);
|
|
nused = 0;
|
|
if (roomfor (infop, vMVersion, rc))
|
|
{
|
|
infop->vMVersion = CWC (2);
|
|
nused += sizeof (infop->vMVersion);
|
|
}
|
|
if (roomfor (infop, vMAttrib, rc))
|
|
{
|
|
infop->vMAttrib = CLC(VOL_BITS);
|
|
nused += sizeof (infop->vMAttrib);
|
|
}
|
|
if (roomfor (infop, vMLocalHand, rc))
|
|
{
|
|
infop->vMLocalHand = CLC (0);
|
|
nused += sizeof (infop->vMLocalHand);
|
|
}
|
|
if (roomfor (infop, vMServerAdr, rc))
|
|
{
|
|
infop->vMServerAdr = CLC (0);
|
|
nused += sizeof (infop->vMServerAdr);
|
|
}
|
|
if (roomfor (infop, vMForeignPrivID, rc))
|
|
{
|
|
infop->vMForeignPrivID = CWC (2); /* fsUnixPriv + 1 */
|
|
nused += sizeof (infop->vMForeignPrivID);
|
|
}
|
|
pb->ioParam.ioActCount = CL((LONGINT) nused);
|
|
err = noErr;
|
|
}
|
|
else
|
|
{
|
|
err = nsvErr;
|
|
pb->ioParam.ioActCount = CLC (0);
|
|
}
|
|
FAKEASYNC (pb, async, err);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetVInfo, HParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBSetVInfo(pb, async);
|
|
else
|
|
retval = ufsPBSetVInfo(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBGetVol, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBGetVol(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHGetVol, WDPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBHGetVol(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBSetVol, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBSetVol(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBHSetVol, WDPBPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
retval = hfsPBHSetVol(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBFlushVol, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBFlushVol(pb, async);
|
|
else
|
|
retval = ufsPBFlushVol(pb, async);
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A1(PUBLIC trap, OSErrRET, PBOffLine, ParmBlkPtr, pb)
|
|
{
|
|
OSErr retval;
|
|
|
|
if (hfsvol((ioParam *) pb))
|
|
retval = hfsPBOffLine(pb);
|
|
else
|
|
retval = ufsPBOffLine(pb);
|
|
PBRETURN (pb, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBExchangeFiles, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
warning_unimplemented (NULL_STRING);
|
|
retval = paramErr;
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBCatSearch, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
warning_unimplemented (NULL_STRING);
|
|
retval = paramErr;
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBCreateFileIDRef, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
warning_unimplemented (NULL_STRING);
|
|
retval = paramErr;
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBDeleteFileIDRef, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
warning_unimplemented (NULL_STRING);
|
|
retval = paramErr;
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|
|
|
|
A2(PUBLIC trap, OSErrRET, PBResolveFileIDRef, ParmBlkPtr, pb, BOOLEAN, async)
|
|
{
|
|
OSErr retval;
|
|
|
|
warning_unimplemented (NULL_STRING);
|
|
retval = paramErr;
|
|
FAKEASYNC (pb, async, retval);
|
|
}
|