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

1782 lines
42 KiB
C
Raw Permalink Blame History

/* Copyright 1986-1996 by Abacus Research and
* Development, Inc. All rights reserved.
*/
#if !defined (OMIT_RCSID_STRINGS)
char ROMlib_rcsid_fileAccess[] =
"$Id: fileAccess.c 86 2005-05-25 00:47:12Z ctm $";
#endif
/* Forward declarations in FileMgr.h (DO NOT DELETE THIS LINE) */
#include "rsys/common.h"
#include "FileMgr.h"
#include "OSEvent.h"
#include "VRetraceMgr.h"
#include "OSUtil.h"
#include "DeviceMgr.h"
#include "MemoryMgr.h"
#include "rsys/hfs.h"
#include "rsys/file.h"
#include "rsys/glue.h"
#include "rsys/filedouble.h"
#include "rsys/segment.h"
#include "rsys/string.h"
#include "rsys/file.h"
#include "rsys/suffix_maps.h"
#include "rsys/lockunlock.h"
#include <ctype.h>
#if defined (CYGWIN32)
#include "winfs.h"
#endif
int ROMlib_nosync = 0; /* if non-zero, we don't call sync () or fsync () */
#if !defined(NDEBUG)
PUBLIC void fs_err_hook (OSErr err)
{
}
#endif
PUBLIC int ROMlib_lasterrnomapped;
#define MAX_ERRNO 50
#define install_errno(uerr, merr) \
do \
{ \
gui_assert(uerr < NELEM(xtable)); \
xtable[uerr] = merr; \
} \
while (FALSE);
A0(PUBLIC, OSErr, ROMlib_maperrno) /* INTERNAL */
{
OSErr retval;
static OSErr xtable[MAX_ERRNO + 1];
static char been_here = FALSE;
int errno_save;
if (!been_here)
{
int i;
for (i = 0; i < (int) NELEM(xtable); ++i)
xtable[i] = fsDSIntErr;
install_errno(0, noErr);
install_errno(EPERM, permErr);
install_errno(ENOENT, fnfErr);
install_errno(EIO, ioErr);
install_errno(ENXIO, paramErr);
install_errno(EBADF, fnOpnErr);
install_errno(EAGAIN, fLckdErr);
install_errno(ENOMEM, memFullErr);
install_errno(EACCES, permErr);
install_errno(EFAULT, paramErr);
install_errno(EBUSY, fBsyErr);
install_errno(EEXIST, dupFNErr);
install_errno(EXDEV, fsRnErr);
install_errno(ENODEV, nsvErr);
install_errno(ENOTDIR, dirNFErr);
install_errno(EINVAL, paramErr);
install_errno(ENFILE, tmfoErr);
install_errno(EMFILE, tmfoErr);
install_errno(EFBIG, dskFulErr);
install_errno(ENOSPC, dskFulErr);
install_errno(ESPIPE, posErr);
install_errno(EROFS, wPrErr);
install_errno(EMLINK, dirFulErr);
#if !defined(MSDOS) && !defined(CYGWIN32)
install_errno(ETXTBSY, fBsyErr);
install_errno(EWOULDBLOCK,permErr);
#endif
been_here = TRUE;
}
errno_save = errno;
ROMlib_lasterrnomapped = errno_save;
if (errno_save < 0 || errno_save >= (int) NELEM(xtable))
retval = fsDSIntErr;
else
retval = xtable[errno_save];
if (retval == fsDSIntErr)
warning_unexpected ("fsDSIntErr errno = %d", errno_save);
if (retval == dirNFErr)
warning_trace_info ("dirNFErr errno = %d", errno_save);
fs_err_hook (retval);
return retval;
}
A3(PUBLIC, OSErr, FSOpen, StringPtr, filen, INTEGER, vrn, /* IMIV-109 */
INTEGER *, rn)
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioNamePtr = RM(filen);
pbr.ioParam.ioVRefNum = CW(vrn);
pbr.ioParam.ioVersNum = 0;
pbr.ioParam.ioPermssn = fsCurPerm;
pbr.ioParam.ioMisc = 0;
temp = PBOpen(&pbr, 0);
*rn = CW(pbr.ioParam.ioRefNum);
fs_err_hook (temp);
return(temp);
}
A3(PUBLIC, OSErr, OpenRF, StringPtr, filen, INTEGER, vrn, /* IMIV-109 */
INTEGER *, rn)
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioNamePtr = RM(filen);
pbr.ioParam.ioVRefNum = CW(vrn);
pbr.ioParam.ioVersNum = 0;
pbr.ioParam.ioPermssn = fsCurPerm;
pbr.ioParam.ioMisc = 0;
temp = PBOpenRF(&pbr, 0);
*rn = CW(pbr.ioParam.ioRefNum);
fs_err_hook (temp);
return(temp);
}
A3(PUBLIC, OSErr, FSRead, INTEGER, rn, LONGINT *, count, /* IMIV-109 */
Ptr, buffp)
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = CW(rn);
pbr.ioParam.ioBuffer = RM(buffp);
pbr.ioParam.ioReqCount = CL(*count);
pbr.ioParam.ioPosMode = CWC(fsAtMark);
temp = PBRead(&pbr, 0);
*count = CL(pbr.ioParam.ioActCount);
fs_err_hook (temp);
return(temp);
}
PUBLIC OSErr
FSReadAll (INTEGER rn, LONGINT *countp, Ptr buffp)
{
LONGINT orig_count;
OSErr retval;
orig_count = *countp;
retval = FSRead (rn, countp, buffp);
if (retval == noErr && *countp != orig_count)
retval = eofErr;
return retval;
}
A3(PUBLIC, OSErr, FSWrite, INTEGER, rn, LONGINT *, count, /* IMIV-110 */
Ptr, buffp)
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = CW(rn);
pbr.ioParam.ioBuffer = RM(buffp);
pbr.ioParam.ioReqCount = CL(*count);
pbr.ioParam.ioPosMode = CWC(fsAtMark);
temp = PBWrite(&pbr, 0);
*count = CL(pbr.ioParam.ioActCount);
fs_err_hook (temp);
return(temp);
}
PUBLIC OSErr
FSWriteAll (INTEGER rn, LONGINT *countp, Ptr buffp)
{
LONGINT orig_count;
OSErr retval;
orig_count = *countp;
retval = FSWrite (rn, countp, buffp);
if (retval == noErr && *countp != orig_count)
retval = ioErr;
return retval;
}
A2(PUBLIC, OSErr, GetFPos, INTEGER, rn, LONGINT *, filep) /* IMIV-110 */
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = CW(rn);
temp = PBGetFPos(&pbr, 0);
*filep = CL(pbr.ioParam.ioPosOffset);
fs_err_hook (temp);
return(temp);
}
A3(PUBLIC, OSErr, SetFPos, INTEGER, rn, INTEGER, posmode, /* IMIV-110 */
LONGINT, possoff)
{
ParamBlockRec pbr;
OSErr err;
pbr.ioParam.ioRefNum = CW(rn);
pbr.ioParam.ioPosMode = CW(posmode);
pbr.ioParam.ioPosOffset = Cx(possoff);
err = PBSetFPos(&pbr, 0);
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, GetEOF, INTEGER, rn, LONGINT *, eof) /* IMIV-111 */
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = Cx(rn);
temp = PBGetEOF(&pbr, 0);
*eof = CL(pbr.ioParam.ioMisc);
fs_err_hook (temp);
return(temp);
}
A2(PUBLIC, OSErr, SetEOF, INTEGER, rn, LONGINT, eof) /* IMIV-111 */
{
ParamBlockRec pbr;
OSErr err;
pbr.ioParam.ioRefNum = Cx(rn);
pbr.ioParam.ioMisc = Cx(eof);
err = PBSetEOF(&pbr, 0);
fs_err_hook (err);
return (err);
}
A2(PUBLIC, OSErr, Allocate, INTEGER, rn, LONGINT *, count) /* IMIV-112 */
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = Cx(rn);
pbr.ioParam.ioReqCount = *count;
temp = PBAllocate(&pbr, 0);
*count = CL(pbr.ioParam.ioActCount);
fs_err_hook (temp);
return(temp);
}
A2(PUBLIC, OSErr, AllocContig, INTEGER, rn, LONGINT *, count)
{
ParamBlockRec pbr;
OSErr temp;
pbr.ioParam.ioRefNum = Cx(rn);
pbr.ioParam.ioReqCount = *count;
temp = PBAllocContig(&pbr, 0);
*count = CL(pbr.ioParam.ioActCount);
fs_err_hook (temp);
return(temp);
}
A1(PUBLIC, OSErr, FSClose, INTEGER, rn) /* IMIV-112 */
{
ParamBlockRec pbr;
OSErr err;
pbr.ioParam.ioRefNum = Cx(rn);
err = PBClose(&pbr, 0);
fs_err_hook (err);
return err;
}
A2(PUBLIC, VCB *, vlookupbyname, const char *, namep, const char *, endp)
{
VCB *retval;
int n;
n = endp - namep;
for (retval = (VCB *)MR(VCBQHdr.qHead); retval;
retval = (VCB *) MR(retval->qLink))
if (n == retval->vcbVN[0] &&
strncmp(namep, (char *) retval->vcbVN+1, n) == 0)
return retval;
#if defined (MSDOS) || defined (CYGWIN32)
for (retval = (VCB *)MR(VCBQHdr.qHead); retval;
retval = (VCB *) MR(retval->qLink))
if (n == retval->vcbVN[0] &&
strncasecmp(namep, (char *) retval->vcbVN+1, n) == 0)
return retval;
#endif
return 0;
}
A1(PRIVATE, VCB *, vlookupbydrive, INTEGER, drive)
{
VCB *retval;
for (retval = (VCB *)MR(VCBQHdr.qHead); retval;
retval = (VCB *) MR(retval->qLink))
if (drive == Cx(retval->vcbDrvNum))
return retval;
return 0;
}
PRIVATE LONGINT cacheindex = 0x7fffffff;
A0(PUBLIC, void, ROMlib_rewinddir)
{
cacheindex = 0x7fffffff;
}
/*
* Blech! I've finally caved in and am going to look for the magic
* number in the obnoxious case of a file that starts with %XX where XX
* are two upper case hex digits.
*/
PUBLIC BOOLEAN ROMlib_isresourcefork(const char *fullname)
{
LONGINT fd;
LONGINT magic;
BOOLEAN retval;
const char *filename;
/* netatalk_conventions_p means we never see resource forks, because
they're stored in a subdirectory */
if (netatalk_conventions_p)
retval = FALSE;
else
{
filename = strrchr(fullname, '/');
if (!filename)
filename = fullname;
else
++filename;
if (filename[0] != '%')
retval = FALSE;
else if (!isxdigit(filename[1]) || !isxdigit(filename[2]))
retval = TRUE;
else {
fd = -1;
retval = (fd = Uopen(fullname, O_BINARY|O_RDONLY, 0)) >= 0 &&
read(fd, (void *) &magic, sizeof(magic)) == sizeof(magic) &&
(magic == CLC(DOUBLEMAGIC)
|| magic == DOUBLEMAGIC);
if (fd >= 0)
Uclose(fd);
}
}
return retval;
}
int ROMlib_no_dot_files = FALSE;
static boolean_t
dislike_name (char *namep)
{
boolean_t retval;
if (strcmp (namep, ".") == 0
|| strcmp (namep, "..") == 0
|| strcmp (namep, ".AppleDouble") == 0
|| strcmp (namep, ".AppleDesktop") == 0
|| (ROMlib_no_dot_files && namep[0] == '.'))
retval = TRUE;
else
{
char *buf;
int namelen;
namelen = strlen (namep);
buf = alloca (namelen);
memcpy (buf, namep, namelen);
namelen -= ROMlib_UNIX7_to_Mac (buf, namelen);
retval = namelen > 31;
}
return retval;
}
A4(PRIVATE, char *, dirindex, char *, dir, LONGINT, index, BOOLEAN, nodirectories,
struct stat *, sbufp)
{
THz saveZone;
static char *cachedir = 0, *cachedirend;
static DIR *dirp = 0;
#if defined (USE_STRUCT_DIRECT)
struct direct *dp;
#else
struct dirent *dp;
#endif
int dirnamelen;
struct stat sbuf;
#if defined(MSDOS) || defined (CYGWIN32)
while (dir[0] == '/' && dir[1] == '/')
++dir;
#endif
if (!sbufp)
sbufp = &sbuf;
if (index <= cacheindex || !cachedir || strcmp(dir, cachedir) != 0) {
if (cachedir)
free (cachedir);
if (dirp)
closedir(dirp);
dirp = Uopendir(dir);
if (!dirp) {
dp = 0;
goto DONE;
}
cacheindex = 0;
dirnamelen = strlen(dir);
#if !defined(MAXNAMLEN)
#define MAXNAMLEN 1024
#endif /* !defined(MAXNAMLEN) */
saveZone = TheZone;
TheZone = SysZone;
cachedir = malloc (dirnamelen+1+MAXNAMLEN+1);
TheZone = saveZone;
if (!cachedir)
/*-->*/ return 0;
strcpy(cachedir, dir);
cachedirend = cachedir + dirnamelen;
}
*cachedirend = '/';
do {
if ((dp = readdir(dirp))) {
strcpy(cachedirend+1, dp->d_name);
if (!dislike_name (dp->d_name)
&& !ROMlib_isresourcefork(cachedir)
&& Ustat(cachedir, sbufp) == 0) {
if (!nodirectories || !S_ISDIR (sbufp->st_mode))
++cacheindex;
}
}
} while (dp && cacheindex != index);
*cachedirend = 0;
DONE:
return dp ? dp->d_name : 0;
}
/*
* NOTE: we must use capital letters in tohex below. Code depends on it.
*/
A1(PRIVATE, unsigned char, tohex, unsigned char, c)
{
unsigned char retval;
retval = (unsigned char) (netatalk_conventions_p ?
"0123456789abcdef"
:
"0123456789ABCDEF")[c & 0xF];
return retval;
}
A3(PRIVATE, INTEGER, Mac_to_UNIX7, unsigned char *, name, INTEGER, length,
unsigned char *, out)
{
unsigned char c;
INTEGER retval;
boolean_t last_character_was_colon;
retval = length;
last_character_was_colon = TRUE;
while (--length >= 0) {
c = *name++;
if (NEEDTOMAP(c)) {
*out++ = apple_double_quote_char;
*out++ = tohex(c >> 4);
*out++ = tohex(c);
retval += 2;
} else if (c == ':') {
if (last_character_was_colon)
{
*out++ = '.';
*out++ = '.';
retval += 2;
}
*out++ = '/';
} else
*out++ = c;
last_character_was_colon = c == ':';
}
return retval;
}
A2(PUBLIC, char *, ROMlib_newunixfrommac, char *, ip, INTEGER, n)
{
char *retval;
if ((retval = malloc (3*n+1))) /* worst case numbers */
retval[Mac_to_UNIX7((unsigned char *) ip, n,
(unsigned char *) retval)] = 0;
return retval;
}
/*
* ROMlib_breakoutioname's role is to examine ioNamePtr and vRefNum
* to determine the vcbp, but since it has to look at ioNamePtr
* anyway it makes sense to make a unix partial pathname for the
* rest. While we're at it, if we get passed in a working-director
* instead of a TRUE vrn we might as well note the directory id
* that is associated with it.
*/
/*
* BUG Fix TODO: newunixfrommac needs to be more complex; specifically
* it needs to handle :: properly (which is to go up
* a directory, UNLESS it's already at the top).
*/
A5(PUBLIC, VCB *, ROMlib_breakoutioname, ParmBlkPtr, pb, /* INTERNAL */
LONGINT *, diridp, char **, therestp, BOOLEAN *, fullpathp,
BOOLEAN, usedefault)
{
VCB *retval;
char *colon;
unsigned char *p;
INTEGER v;
wdentry *wdp;
retval = 0;
*diridp = 0;
*therestp = 0;
if (fullpathp)
*fullpathp = FALSE;
if ((p = (unsigned char *) MR(pb->ioParam.ioNamePtr))) {
if (p[0] > 1 && p[1] != ':') {
if ((colon = pstr_index_after(p, ':', SLASH_CHAR_OFFSET))) {
retval = vlookupbyname((char *) p+1, colon);
if (colon - ((char *)p+1) < p[0])
*therestp =
ROMlib_newunixfrommac(colon+1,
p[0] + (char *) p - colon);
if (fullpathp)
*fullpathp = TRUE;
} else
*therestp = ROMlib_newunixfrommac((char *) p+1, p[0]);
} else if (p[0] > 0) {
if (p[1] == ':' || (p[0] == 1 && p[1] == '/'))
*therestp = ROMlib_newunixfrommac((char *)p+2, p[0]-1);
else
*therestp = ROMlib_newunixfrommac((char *)p+1, p[0]);
}
}
if (!retval) {
if ((v = Cx(pb->ioParam.ioVRefNum)) > 0) /* drive number */
retval = vlookupbydrive(v);
else if (v < 0) {
if (ISWDNUM(v)) {
wdp = WDNUMTOWDP(v);
*diridp = CL(wdp->dirid);
retval = MR(wdp->vcbp);
} else
retval = ROMlib_vcbbyvrn(v);
}
if (!retval && (usedefault ||
(!pb->ioParam.ioNamePtr && !pb->ioParam.ioVRefNum))) {
retval = MR(DefVCBPtr);
*diridp = CL(DefDirID);
}
}
return retval;
}
/*
* myscandir looks through a directory for a filename match with case not
* significant. It returns TRUE if a match was found; FALSE
* otherwise. Note, the filename specified in "rest" starts
* out smashed and needs the character stored in "save" to
* be filled in before it can be used, but this has to be
* done after "dirname" has been used.
*/
A4(PRIVATE, BOOLEAN, myscandir, char *, dirname, char, save, char *, rest,
INTEGER, restlen)
{
DIR *dirp;
#if defined (USE_STRUCT_DIRECT)
struct direct *directp;
#else
struct dirent *directp;
#endif
int retval;
LONGINT d0;
#if defined(MSDOS) || defined (CYGWIN32)
while (dirname[0] == '/' && dirname[1] == '/')
++dirname;
#endif
retval = FALSE;
if ((dirp = Uopendir(dirname))) {
*rest = save;
d0 = ((LONGINT) restlen << 16) | (unsigned short) restlen;
while ((directp = readdir(dirp)))
if (restlen == (INTEGER) strlen (directp->d_name) &&
ROMlib_RelString((unsigned char *) rest,
(unsigned char *) directp->d_name, FALSE, TRUE, d0) == 0) {
retval = TRUE;
memcpy(rest, directp->d_name, restlen);
/*-->*/ break;
}
closedir(dirp);
} else
*rest = save;
return retval;
}
A2(PRIVATE, LONGINT, weasel, char *, fullpathname, struct stat *, sbufp)
{
char *start, *nextslash, save;
INTEGER length;
LONGINT retval;
#if 1
gui_assert(fullpathname[SLASH_CHAR_OFFSET] == '/');
#else
if (fullpathname[SLASH_CHAR_OFFSET] != '/')
{
DEBUG_OUT("weasel surprise %s", fullpathname);
*(long *) -1 = -1;
}
#endif
if (Ustat(fullpathname, sbufp) < 0) {
switch(errno) {
#if !defined (CYGWIN32)
case ENOENT:
#if 0
/* this will only work on systems that distinguish
between ENOENT and ENOTDIR ... maybe it won't work
at all. It doesn't work under Linux, so omit it
for now */
start = strrchr(fullpathname, '/') + 1;
break;
#endif
case ENOTDIR:
start = fullpathname + SLASH_CHAR_OFFSET + 1;
break;
#endif
default:
return errno;
break;
}
} else
return 0;
do {
nextslash = strchr(start, '/');
if (nextslash)
length = nextslash - start;
else
length = strlen(start);
save = *start;
*start = 0;
if (!myscandir(fullpathname, save, start, length)) {
return nextslash ? ENOTDIR : ENOENT;
}
start = nextslash + 1;
} while (nextslash);
if (Ustat(fullpathname, sbufp) < 0)
{
retval = errno;
return retval;
}
else
return 0;
}
/*
* NOTE: As of today, ROMlib_nami always either returns an error, or leaves
* a valid result in *sbufp (if sbufp is non-zero). That means that
* you can call ROMlib_nami and not have to do a stat afterward.
*/
A9(PUBLIC, OSErr, ROMlib_nami, ParmBlkPtr, pb, LONGINT, dir, /* INTERNAL */
IndexType, indextype, char **, pathname, char **, filename,
char **, endname, BOOLEAN, nodirs, VCBExtra **, vcbpp, struct stat *, sbufp)
{
char *temp1, *temp2, *temp3;
INTEGER index;
StringPtr fnamep;
Str255 fname;
LONGINT dirid;
char *therest;
char *fn;
VCBExtra *vcbp;
datum content;
char *vcbanddir;
int vcbstrlen, therestlen;
StringPtr savenamep;
BOOLEAN fullp;
struct stat sbuf;
INTEGER badness;
OSErr err;
ALLOCABEGIN
if (!pathname)
pathname = &temp1;
if (!filename)
filename = &temp2;
if (!endname)
endname = &temp3;
fnamep = 0;
if (indextype != NoIndex) {
savenamep = MR(pb->ioParam.ioNamePtr);
pb->ioParam.ioNamePtr = 0;
}
#if !defined (LETGCCWAIL)
else
savenamep = (StringPtr) -1;
#endif /* LETGCCWAIL */
vcbp = (VCBExtra *) ROMlib_breakoutioname(pb, &dirid, &therest, &fullp,
TRUE);
if (vcbpp)
*vcbpp = vcbp;
if (fullp)
dir = 0;
else {
if (dir <= 0)
dir = dirid;
}
content.dsize = 0;
/*
* Retry strategy:
* first time things don't work we try closing and reopening
* the database (badness == 1); second time we try closing,
* rebuilding and reopening the database (badness == 2).
*/
badness = 0;
/* do { */
loop:
if (dir > 2) {
content = ROMlib_dbm_fetch(vcbp, dir);
if (!content.dptr)
{
content.dsize = 0;
}
}
vcbstrlen = strlen(vcbp->unixname);
vcbanddir = ALLOCA(vcbstrlen + content.dsize + 2);
BlockMove((Ptr) vcbp->unixname, (Ptr) vcbanddir, (Size) vcbstrlen+1);
if (content.dsize) {
if (vcbanddir[vcbstrlen-1] != '/')
{
vcbanddir[vcbstrlen] = '/';
++vcbstrlen;
}
BlockMove((Ptr) content.dptr, (Ptr) vcbanddir+vcbstrlen,
(Size) content.dsize);
vcbanddir[vcbstrlen+content.dsize] = 0;
if (Ustat(vcbanddir, &sbuf) < 0)
{
warning_unexpected ("vcbanddir = '%s', dir = 0x%x",
vcbanddir, dir);
ROMlib_dbm_delete_inode(vcbp, dir);
/*-->*/ goto loop;
}
else if (ST_INO(sbuf) != dir)
{
#if 1
warning_unexpected ("ST_INO(sbuf) = 0x%lx, dir = 0x%x",
(unsigned long) ST_INO(sbuf), dir);
ROMlib_dbm_delete_inode(vcbp, dir);
{
LONGINT templong;
templong = ST_INO(sbuf);
ROMlib_dbm_store(vcbp, vcbanddir, &templong, TRUE);
}
/*-->*/ goto loop;
#else
fprintf(stderr, "ino mismatch %s %ld %d\n", vcbanddir,
(long)ST_INO(sbuf), dir);
++badness;
#endif
}
else
badness = 0;
} else if (dir > 2)
++badness;
if (badness == 1 && dirid)
{
dir = dirid;
badness = 2;
goto loop;
}
if (badness && badness <= 1)
goto loop;
/* } while (badness && badness <= 1); */
if (badness)
{
err = dirNFErr;
warning_trace_info ("badness = %d, dirid = %d, dir = %d, "
"vcbp->unixname = '%s', therest = '%s', "
"fullp = %d, vcbanddir = '%s'",
badness, dirid, dir,
vcbp->unixname, therest, fullp, vcbanddir);
fs_err_hook (err);
free (therest);
/*-->*/ return err;
}
if (indextype != NoIndex)
pb->ioParam.ioNamePtr = RM(savenamep);
if (indextype == FDirIndex && (index = Cx(pb->fileParam.ioFDirIndex)) > 0) {
free (therest);
therest = 0;
if (!(fn = dirindex(vcbanddir, index, nodirs, sbufp))) {
ALLOCAEND
err = fnfErr;
fs_err_hook (err);
/*-->*/ return err;
}
if (pb->ioParam.ioNamePtr)
fnamep = MR(pb->ioParam.ioNamePtr);
else
fnamep = fname;
fnamep[0] = strlen(fn);
strcpy((char *) fnamep+1, fn);
#if 0
therest = ROMlib_newunixfrommac((char *) fnamep+1, fnamep[0]);
#else
therest = malloc ((Size) fnamep[0] + 1);
BlockMove((Ptr) fnamep+1, (Ptr) therest, (Size) fnamep[0]);
therest[fnamep[0]] = 0;
#endif
}
therestlen = therest ? strlen(therest) : 0;
*pathname = malloc (therestlen + strlen(vcbanddir)+2);
*filename = *pathname + strlen(vcbanddir) +1;
*endname = *filename + therestlen + 1;
BlockMove((Ptr) vcbanddir, (Ptr) *pathname, (Size) strlen(vcbanddir));
if (therest) {
if (vcbanddir[1 + SLASH_CHAR_OFFSET]) /* i.e. test for "/" */
(*filename)[-1] = '/';
else {
--*filename;
--*endname;
}
BlockMove((Ptr) therest, (Ptr) *filename, (Size) therestlen);
(*endname)[-1] = 0;
} else {
*endname = *filename;
(*endname)[-1] = 0;
}
if (strcmp(*pathname + SLASH_CHAR_OFFSET, "/") != 0) {
while ((*endname)[-2] == '/') { /* remove trailing slashes */
(*endname)[-2] = 0;
--*endname;
}
if ((*filename = strrchr(*pathname, '/')))
++*filename;
else
*filename = *pathname;
} else
*filename = *pathname;
if (therest)
free (therest);
ALLOCAEND
if (indextype == NoIndex && sbufp) {
errno = weasel(*pathname, sbufp);
err = ROMlib_maperrno();
} else if (indextype == IGNORENAME && sbufp)
{
if (Ustat(*pathname, sbufp) < 0)
{
err = ROMlib_maperrno();
}
else
err = noErr;
}
else
err = noErr;
fs_err_hook (err);
if (err == noErr && fullp)
ROMlib_automount (*pathname);
return err;
}
/*
* Old algorithm:
*
* The new code is a little bit tricky; it would be just prepend a %, except
* if someone has a name that begins with two hex digits ("feed me") you would
* get something that could be a data fork, so we make sure that if the first
* char is a % and the next two are hex and the hex would make something that
* we would have wanted to map then we map the second character even though
* we normally wouldn't map it.
*
* New algorithm:
*
* We just prepend the bloody "%" -- We get into trouble with other providers
* of Apple Double if we do it differently. What a crock.
*/
#define ROOTS_PERCENT_FILE "%%2F"
A3(PUBLIC, char *, ROMlib_resname, char *, pathname, /* INTERNAL */
char *, filename, char *, endname)
{
int pathnamesize, filenamesize, newsize;
char *newname;
pathnamesize = filename - pathname;
filenamesize = endname - filename;
if (pathnamesize)
{
newsize = pathnamesize + filenamesize
+ apple_double_fork_prefix_length;
newname = malloc (newsize);
memcpy (newname, pathname, pathnamesize);
strcpy (&newname[pathnamesize], apple_double_fork_prefix);
memcpy (newname + pathnamesize + apple_double_fork_prefix_length,
filename, filenamesize);
}
else
{
/* "E:/" --> "E:/%%2F" */
newsize = filenamesize + sizeof (ROOTS_PERCENT_FILE);
newname = malloc (newsize);
sprintf (newname, "%s%s", filename, ROOTS_PERCENT_FILE);
}
return newname;
}
/*
* macopen opens the file using mac permissions, returning an OSErr
* the file descriptor of the opened file is filled in where fdp points
*/
A5(PRIVATE, OSErr, macopen, char *, file, short, perm, LONGINT *, fdp,
BOOLEAN, isres, Byte *,flagp)
{
int newperm;
int flockret;
boolean_t open_should_fail_p;
OSErr err;
switch (perm) {
default:
warning_unexpected ("perm = %d", perm);
/* FALL THROUGH */
case fsCurPerm:
newperm = O_RDWR; /* start out here, downgrade if necessary */
*flagp |= fcwriteperm;
break;
case fsRdPerm:
newperm = O_RDONLY;
break;
case fsWrPerm:
*flagp |= fcwriteperm;
newperm = isres ? O_RDWR : O_WRONLY;
break;
case fsRdWrPerm:
*flagp |= fcwriteperm;
newperm = O_RDWR;
break;
case fsRdWrShPerm:
*flagp |= fcwriteperm;
newperm = O_RDWR;
break;
}
#if defined(MSDOS)
#define BROKEN_OPEN
#endif
#if defined(BROKEN_OPEN)
{
struct stat sbuf;
open_should_fail_p = ((newperm == O_WRONLY || newperm == O_RDWR)
&& Ustat(file, &sbuf) == 0
&& (!(sbuf.st_mode & S_IWUSR)));
}
#else
open_should_fail_p = FALSE;
#endif
if (open_should_fail_p)
*fdp = -1;
else
*fdp = Uopen(file, O_BINARY|newperm, 0);
if (*fdp == -1 && perm == fsCurPerm) {
*fdp = Uopen(file, O_BINARY|O_RDONLY, 0);
*flagp &= ~fcwriteperm;
}
flockret = 0;
#if !defined(AVIION) && !defined(MACBLITZ) && 0
if (*fdp != -1) {
if (perm == fsCurPerm || perm == fsRdWrPerm)
flockret = flock(*fdp, LOCK_EX|LOCK_NB);
if (perm == fsRdWrShPerm || (perm == fsCurPerm && flockret == -1))
flockret = flock(*fdp, LOCK_SH|LOCK_NB);
if (flockret == -1 && perm != fsCurPerm) {
Uclose(*fdp);
*fdp = flockret;
}
}
#endif /* !defined(AVIION) */
err = *fdp == -1 ? ROMlib_maperrno(): noErr;
fs_err_hook (err);
return err;
}
A1(PRIVATE, void, freeprn, fcbrec *, fp)
{
fp->fdfnum = 0;
}
A1(PRIVATE, OSErr, getprn, INTEGER *, pprn)
{
INTEGER length;
fcbrec *fcbp, *efcbp;
OSErr err;
/* #define NASTYTEMPHAXK */
#if defined(NASTYTEMPHAXK) && defined(MSDOS)
static int n = 0;
*pprn = 2 + 94 * n++;
return noErr;
#endif
length =CW( *(short *)MR(FCBSPtr));
fcbp = (fcbrec *) ((short *)MR(FCBSPtr)+1);
efcbp = (fcbrec *) ((char *)MR(FCBSPtr) + length);
for (;fcbp < efcbp && fcbp->fdfnum;
fcbp = (fcbrec *) ((char *)fcbp + Cx(FSFCBLen)))
;
if (fcbp < efcbp) {
*pprn = (char *) fcbp - (char *) MR(FCBSPtr);
err = noErr;
} else
err = tmfoErr;
fs_err_hook (err);
return err;
}
A4(PRIVATE, OSErr, PBOpenForkD, ParmBlkPtr, pb, BOOLEAN, a,
ForkType, fork, LONGINT, dir)
{
OSErr err;
int temp;
INTEGER prn;
char *pathname, *filename, *endname, *newname;
struct stat sbuf;
VCBExtra *vcbp;
int namelen;
fcbrec *fp;
THz savezone;
int save_index;
char save_char;
char *need_to_free;
need_to_free = 0;
pb->ioParam.ioRefNum = CWC(0); /* in case some goofy program,
like StuffIt Lite decides to
ignore error codes */
savezone = TheZone;
TheZone = SysZone;
pathname = 0;
/*
* We have to pass in sbuf below or we won't be weaseled like we should be.
*/
if ((err = ROMlib_nami(pb, dir, NoIndex, &pathname, &filename, &endname,
TRUE, &vcbp, (struct stat *) &sbuf)) == noErr) {
err = getprn(&prn);
if (err == noErr) {
fp = (fcbrec *) (MR(FCBSPtr) + prn);
fp->fdfnum = CL((LONGINT) ST_INO(sbuf));
fp->fcfd = -1;
fp->fcflags = 0;
fp->fcbTypByt = 0;
fp->fcbCrPs = 0;
if ((filename == pathname + 1) ||
(filename == pathname + SLASH_CHAR_OFFSET + 1))
save_index = 0; /* root ... don't scorch leading "/" */
else
save_index = -1;
save_char = filename[save_index];
filename[save_index] = 0;
if (Ustat(pathname, &sbuf) < 0) /* NOTE: this is a stat of */
err = ROMlib_maperrno(); /* the parent's directory, */
else { /* so ROMlib_nami won't do */
if (ST_INO(sbuf) == vcbp->u.ufs.ino) /* the stat for us */
fp->fcparid = CLC (2);
else
fp->fcparid = CL((LONGINT) ST_INO(sbuf));
filename[save_index] = save_char;
if (fork == ResourceFork) {
newname = ROMlib_resname(pathname, filename, endname);
temp = Ustat(newname, &sbuf);
if (temp < 0 && errno != ENOENT)
err = ioErr;
need_to_free = pathname; /* can't free it now, because
filename is drawn from
here */
pathname = newname;
}
}
if (err == noErr) {
err = macopen(pathname, pb->ioParam.ioPermssn,
&fp->fcfd, fork == ResourceFork, &fp->fcflags);
if (err != noErr
&& (fork != ResourceFork ||
(err = ROMlib_newresfork(pathname, &fp->fcfd, TRUE))))
freeprn(fp);
else {
if (fork == ResourceFork)
{
fp->fcflags |= fcfisres;
fp->hiddenfd = fp->fcfd;
lseek(fp->fcfd, ROMlib_FORKOFFSET(fp), L_SET);
}
else
{
newname = ROMlib_resname (pathname, filename,
endname);
fp->hiddenfd = Uopen (newname, O_BINARY|O_RDWR, 0666L);
if (fp->hiddenfd < 0)
{
Byte dummy_byte = -1;
if (errno == ENOENT)
{
if ((fp->fcflags & fcwriteperm) &&
!ROMlib_creator_and_type_from_filename
(strlen (filename), filename, NULL, NULL))
err = ROMlib_newresfork(newname,
&fp->hiddenfd, TRUE);
else
{
err = noErr;
fp->hiddenfd = -1;
}
}
else
macopen(newname, pb->ioParam.ioPermssn,
&fp->hiddenfd, TRUE, &dummy_byte);
}
free (newname);
}
if (err == noErr)
err = ROMlib_geteofostype(fp);
fp->fcvptr = RM((VCB *) vcbp);
pb->ioParam.ioRefNum = CW(prn);
namelen = strlen (filename);
namelen -= ROMlib_UNIX7_to_Mac (filename, namelen);
namelen = MIN(namelen, 31);
fp->fcname[0] = namelen;
BlockMove((Ptr) filename,
(Ptr) fp->fcname+1, (Size) namelen);
}
}
}
}
if (need_to_free)
free (need_to_free);
if (pathname)
free (pathname);
TheZone = savezone;
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBOpen, ParmBlkPtr, pb, BOOLEAN, a) /* INTERNAL */
{
OSErr err;
err = PBOpenForkD(pb, a, DataFork, 0);
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBHOpen, HParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a) /* IMIV-136 */
{
OSErr err;
err = PBOpenForkD((ParmBlkPtr) pb, a, DataFork, CL(pb->fileParam.ioDirID));
fs_err_hook (err);
return err;
}
A2(PUBLIC trap, OSErrRET, OpenDeny, HParmBlkPtr, pb, /* IMV-397 */
BOOLEAN, a)
{ /* HACK */
HParamBlockRec block;
OSErr retval;
block.ioParam.ioCompletion = pb->ioParam.ioCompletion;
block.ioParam.ioNamePtr = pb->ioParam.ioNamePtr;
block.ioParam.ioVRefNum = pb->ioParam.ioVRefNum;
block.ioParam.ioVersNum = 0;
switch (pb->ioParam.ioPermssn & 3) {
case 0:
block.ioParam.ioPermssn = fsCurPerm;
break;
case 1:
block.ioParam.ioPermssn = fsRdPerm;
break;
case 2:
block.ioParam.ioPermssn = fsWrPerm;
break;
case 3:
block.ioParam.ioPermssn = fsRdWrPerm;
break;
}
block.ioParam.ioMisc = 0;
block.fileParam.ioDirID = pb->fileParam.ioDirID;
retval = PBHOpen(&block, a);
pb->ioParam.ioResult = block.ioParam.ioResult;
pb->ioParam.ioRefNum = block.ioParam.ioRefNum;
fs_err_hook (retval);
return retval;
}
A2(PUBLIC, OSErr, ufsPBOpenRF, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
err = PBOpenForkD(pb, a, ResourceFork, 0);
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBHOpenRF, HParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
err = PBOpenForkD((ParmBlkPtr) pb, a, ResourceFork,
CL(pb->fileParam.ioDirID));
fs_err_hook (err);
return err;
}
#define POSMASK 0x3 /* IMIV-121 */
PRIVATE OSErr
pbfpos (ParmBlkPtr pb, LONGINT *toseekp, boolean_t can_go_past_eof)
{
OSErr err;
LONGINT leof;
INTEGER forkoffset;
LONGINT pos;
int fd;
fcbrec *fp;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
forkoffset = FORKOFFSET(fp);
leof = Cx(fp->fcleof);
fd = fp->fcfd;
switch (Cx(pb->ioParam.ioPosMode) & POSMASK) {
case fsAtMark:
if ((pos = lseek(fd, 0L, L_INCR)) == -1) {
switch(errno) {
case EBADF:
err = fnOpnErr;
break;
case EINVAL:
err = paramErr;
break;
default:
err = ioErr;
}
} else
*toseekp = pos - forkoffset;
break;
case fsFromStart:
*toseekp = Cx(pb->ioParam.ioPosOffset);
break;
case fsFromLEOF:
*toseekp = leof + Cx(pb->ioParam.ioPosOffset);
break;
case fsFromMark:
if ((pos = lseek(fd, 0L, L_INCR)) == -1) {
switch(errno) {
case EBADF:
err = fnOpnErr;
break;
case EINVAL:
err = paramErr;
break;
default:
err = ioErr;
}
} else
*toseekp = pos + Cx(pb->ioParam.ioPosOffset) - forkoffset;
break;
}
if (*toseekp + forkoffset < 0) {
err = posErr;
*toseekp = 0;
} else if ((*toseekp > leof) && !can_go_past_eof) {
err = eofErr;
*toseekp = leof;
}
*toseekp += forkoffset;
}
fs_err_hook (err);
return err;
}
A3(PRIVATE, OSErr, PBLockUnlockRange, ParmBlkPtr, pb, BOOLEAN, a,
lockunlock_t, op)
{
OSErr err;
LONGINT toseek;
int fd;
LONGINT curseek;
fcbrec *fp;
err = noErr;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
if ((err = pbfpos(pb, &toseek, TRUE)) == noErr) {
OSErr (*verify ) (int fd, uint32 start, uint32 count);
OSErr (*cleanup) (int fd, uint32 start, uint32 count);
fd = fp->fcfd;
curseek = lseek(fd, 0, L_SET);
if (op == lock)
{
verify = ROMlib_fd_range_overlap;
cleanup = ROMlib_fd_add_range;
}
else
{
verify = ROMlib_find_fd_start_count;
cleanup = ROMlib_fd_remove_range;
}
err = verify (fd, toseek, CL (pb->ioParam.ioReqCount));
if (err == noErr && lseek(fd, toseek, L_SET) == -1)
err = ROMlib_maperrno();
if (err == noErr)
err = ROMlib_lockunlockrange (fd, toseek,
CL (pb->ioParam.ioReqCount), op);
if (err == noErr)
err = cleanup (fd, toseek, CL (pb->ioParam.ioReqCount));
lseek(fd, curseek, L_SET);
}
}
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBLockRange, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
err = PBLockUnlockRange(pb, a, lock);
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBUnlockRange, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
err = PBLockUnlockRange(pb, a, unlock);
fs_err_hook (err);
return err;
}
PRIVATE OSErr
pbsetfpos (ParmBlkPtr pb, boolean_t can_go_past_eof)
{
OSErr err;
INTEGER forkoffset;
LONGINT toseek;
int fd;
fcbrec *fp;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
forkoffset = FORKOFFSET(fp);
err = pbfpos(pb, &toseek, can_go_past_eof);
fd = fp->fcfd;
pb->ioParam.ioPosOffset = CL(lseek(fd, toseek, L_SET) - forkoffset);
}
fs_err_hook (err);
return err;
}
PUBLIC int ROMlib_newlinetocr = TRUE;
/*
* NOTE: ROMlib_destroy_blocks is a wrapper routine that either destroys
* a limited range or flushes the entire cache. Apple's semantics
* say that you must flush the entire cache in certain circumstances.
* However, 99% of all programs need to destroy only a range of
* addresses.
*/
PUBLIC int ROMlib_flushoften = 0;
PUBLIC unsigned long ROMlib_destroy_blocks(syn68k_addr_t start, uint32 count,
BOOLEAN flush_only_faulty_checksums)
{
unsigned long num_blocks_destroyed;
if (ROMlib_flushoften)
{
start = 0;
count = ~0;
}
if (count)
{
if (flush_only_faulty_checksums)
num_blocks_destroyed =
destroy_blocks_with_checksum_mismatch (start, count);
else
num_blocks_destroyed = destroy_blocks (start, count);
}
else
num_blocks_destroyed = 0;
return num_blocks_destroyed;
}
A2(PUBLIC, OSErr, ufsPBRead, ParmBlkPtr, pb, BOOLEAN, a) /* INTERNAL */
{
OSErr err;
LONGINT nread;
INTEGER forkoffset;
fcbrec *fp;
#if 0
if (pb->ioParam.ioRefNum == 0x5003)
{
printf ("read IN mode = %d, offset = %5d, req = %5d\n",
CW (pb->ioParam.ioPosMode),
CL (pb->ioParam.ioPosOffset), CL (pb->ioParam.ioReqCount));
}
#endif
if (Cx(pb->ioParam.ioRefNum) < 0)
{
err = ROMlib_dispatch(pb, a, Prime, aRdCmd);
fs_err_hook (err);
return err;
}
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr && ((err = pbsetfpos(pb, FALSE)) == noErr || err == eofErr)) {
forkoffset = FORKOFFSET(fp);
if (Cx(pb->ioParam.ioReqCount) < 0)
err = paramErr;
else {
int fd = fp->fcfd;
LONGINT rc = Cx(pb->ioParam.ioReqCount);
if (Cx(pb->ioParam.ioPosOffset) + rc > Cx(fp->fcleof))
rc = Cx(fp->fcleof) - Cx(pb->ioParam.ioPosOffset);
nread = read(fd, (char *)(MR(pb->ioParam.ioBuffer)), rc);
ROMlib_destroy_blocks((syn68k_addr_t)
(long) US_TO_SYN68K(MR(pb->ioParam.ioBuffer)),
rc, TRUE);
if (nread == -1) {
pb->ioParam.ioActCount = 0;
err = ioErr;
} else {
pb->ioParam.ioActCount = CL(nread);
pb->ioParam.ioPosOffset = CL(lseek(fd, 0L, L_INCR) -
forkoffset);
if (rc != Cx(pb->ioParam.ioReqCount))
err = eofErr;
}
}
}
fs_err_hook (err);
#if 0
if (pb->ioParam.ioRefNum == 0x5003)
{
printf ("read OUT mode = %d, offset = %5d, req = %5d, act = %d, err = %d\n",
CW (pb->ioParam.ioPosMode),
CL (pb->ioParam.ioPosOffset), CL (pb->ioParam.ioReqCount),
CL (pb->ioParam.ioActCount),
err);
}
#endif
return err;
}
A2(PUBLIC, OSErr, ufsPBWrite, ParmBlkPtr, pb, BOOLEAN, a) /* INTERNAL */
{
OSErr err;
LONGINT nwrite, rc;
INTEGER forkoffset;
fcbrec *fp;
if (Cx(pb->ioParam.ioRefNum) < 0)
{
err = ROMlib_dispatch(pb, a, Prime, aWrCmd);
fs_err_hook (err);
return err;
}
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr && ((err = pbsetfpos(pb, TRUE)) == noErr || err == eofErr)) {
forkoffset = FORKOFFSET(fp);
if ((rc = Cx(pb->ioParam.ioReqCount)) < 0)
err = paramErr;
else {
int fd = fp->fcfd;
#if defined (WEHAVEENOUGHSWAPSPACETORUNSUNSGOOFYLITTLERPCTHINGYS)
#if defined (SUN)
if (lockf(fd, F_TLOCK, rc))
err = fLckdErr;
#endif /* SUN */
#endif /* WEHAVEENOUGHSWAPSPACETORUNSUNSGOOFYLITTLERPCTHINGYS */
if (err == noErr && Cx(pb->ioParam.ioPosOffset) + rc > Cx(fp->fcleof)) {
fp->fcleof = CL(CL(pb->ioParam.ioPosOffset) + rc);
err = ROMlib_seteof(fp);
}
if (err == noErr) {
nwrite = write(fd, (char *)(MR(pb->ioParam.ioBuffer)), rc);
if (nwrite == -1) {
pb->ioParam.ioActCount = 0;
err = ioErr;
} else {
err = noErr;
pb->ioParam.ioActCount = CL(nwrite);
pb->ioParam.ioPosOffset = CL(lseek(fd, 0L, L_INCR) -
forkoffset);
if (Cx(pb->ioParam.ioPosOffset) > Cx(fp->fcleof)) {
fp->fcleof = pb->ioParam.ioPosOffset;
err = ROMlib_seteof(fp);
}
}
}
#if defined (WEHAVEENOUGHSWAPSPACETORUNSUNSGOOFYLITTLERPCTHINGYS)
#if defined (SUN)
lockf(fd, F_ULOCK, Cx(pb->ioParam.ioReqCount));
#endif /* SUN */
#endif /* WEHAVEENOUGHSWAPSPACETORUNSUNSGOOFYLITTLERPCTHINGYS */
}
}
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBGetFPos, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
INTEGER forkoffset;
fcbrec *fp;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
forkoffset = FORKOFFSET(fp);
pb->ioParam.ioPosOffset = CL(lseek(fp->fcfd, 0L, L_INCR) -
forkoffset);
pb->ioParam.ioReqCount = pb->ioParam.ioActCount =
pb->ioParam.ioPosMode = 0;
}
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBSetFPos, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err = pbsetfpos(pb, FALSE);
#if 0
if (pb->ioParam.ioRefNum == 0x5003)
{
printf ("seek IN mode = %d, offset = %5d\n",
CW (pb->ioParam.ioPosMode),
CL (pb->ioParam.ioPosOffset));
}
#endif
if (err == noErr)
pb->ioParam.ioReqCount = pb->ioParam.ioActCount = 0;
fs_err_hook (err);
#if 0
if (pb->ioParam.ioRefNum == 0x5003)
{
printf ("seek OUT mode = %d, offset = %5d, err = %d\n",
CW (pb->ioParam.ioPosMode),
CL (pb->ioParam.ioPosOffset), err);
}
#endif
return err;
}
A2(PUBLIC, OSErr, ufsPBGetEOF, ParmBlkPtr, pb, BOOLEAN, a) /* INTERNAL */
{
fcbrec *fp;
OSErr err;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr)
pb->ioParam.ioMisc = fp->fcleof;
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBSetEOF, ParmBlkPtr, pb, BOOLEAN, a) /* INTERNAL */
{
fcbrec *fp;
OSErr err;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
fp->fcleof = pb->ioParam.ioMisc;
err = ROMlib_seteof(fp);
}
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBAllocate, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
fcbrec *fp;
OSErr err;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
fp->fcleof = CL(CL(fp->fcleof) + CL(pb->ioParam.ioReqCount));
err = ROMlib_seteof(fp);
pb->ioParam.ioActCount = pb->ioParam.ioReqCount;
}
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBAllocContig, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
OSErr err;
/* WARN that calling this might be a sign of a non-portable program */
err = PBAllocate(pb, a); /* o.k. a lie, but wtf */
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBFlushFile, ParmBlkPtr, pb, /* INTERNAL */
BOOLEAN, a)
{
fcbrec *fp;
OSErr err;
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (!ROMlib_nosync)
sync ();
fs_err_hook (err);
return err;
}
A2(PUBLIC, OSErr, ufsPBClose, ParmBlkPtr, pb, BOOLEAN, a)/* INTERNAL */
{
OSErr err;
fcbrec *fp;
if (Cx(pb->ioParam.ioRefNum) < 0)
{
err = ROMlib_dispatch(pb, a, Close, 0);
fs_err_hook (err);
return err;
}
fp = PRNTOFPERR(Cx(pb->ioParam.ioRefNum), &err);
if (err == noErr) {
if (Uclose(fp->fcfd) < 0)
{
err = ioErr;
}
Uclose(fp->hiddenfd);
freeprn(fp);
}
fs_err_hook (err);
return err;
}
A2(PUBLIC trap, OSErrRET, PBHGetLogInInfo, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHGetDirAccess, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHCopyFile, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHMapName, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHMapID, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHSetDirAccess, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
A2(PUBLIC trap, OSErrRET, PBHMoveRename, HParmBlkPtr, pb, BOOLEAN, a)
{
OSErrRET retval;
warning_unimplemented (NULL_STRING);
retval = paramErr;
return retval;
}
Reference in New Issue View Git Blame Copy Permalink