Macintosh-Tools
/
executor
mirror of https://github.com/ctm/executor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
executor/src/hfsXbar.c

1033 lines
24 KiB
C
Raw Permalink Blame History

/* 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);
}
Reference in New Issue View Git Blame Copy Permalink