mirror of
https://github.com/mabam/CAP.git
synced 2024-09-28 05:56:14 +00:00
880 lines
17 KiB
C
880 lines
17 KiB
C
/*
|
|
* $Author: djh $ $Date: 1996/04/25 01:18:16 $
|
|
* $Header: /mac/src/cap60/lib/afpc/RCS/afpcc.c,v 2.5 1996/04/25 01:18:16 djh Rel djh $
|
|
* $Revision: 2.5 $
|
|
*/
|
|
|
|
/*
|
|
* afpcc.c - easy interface to AFP client calls
|
|
*
|
|
*
|
|
* AppleTalk package for UNIX (4.2 BSD).
|
|
*
|
|
* Copyright (c) 1986, 1987 by The Trustees of Columbia University in the
|
|
* City of New York.
|
|
*
|
|
* Edit History:
|
|
*
|
|
* March 1987 CCKim Created.
|
|
*
|
|
*/
|
|
|
|
/* PATCH: Rutgers1/*, djh@munnari.OZ.AU, 19/11/90 */
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <sys/types.h>
|
|
#include <netat/appletalk.h>
|
|
#include <netat/afp.h>
|
|
#include <netat/afpcmd.h>
|
|
#include <netat/afpc.h>
|
|
#ifdef SUNOS4_FASTDES
|
|
#include <des_crypt.h>
|
|
#endif SUNOS4_FASTDES
|
|
|
|
eFPAddAPPL(srn, dtr, dirid, fcreator, appltag, path, cr)
|
|
int srn;
|
|
word dtr;
|
|
dword dirid;
|
|
char fcreator[];
|
|
dword appltag;
|
|
byte *path;
|
|
dword *cr;
|
|
{
|
|
AddAPPLPkt aa;
|
|
|
|
aa.aap_cmd = AFPAddAPPL;
|
|
aa.aap_zero = 0;
|
|
aa.aap_dtrefnum = dtr;
|
|
aa.aap_dirid = dirid;
|
|
bcopy(fcreator, aa.aap_fcreator, 4);
|
|
aa.aap_apptag = appltag;
|
|
aa.aap_ptype = 2;
|
|
pstrcpy(aa.aap_path, path); /* copy in path */
|
|
return(FPAddAPPL(srn, &aa, cr));
|
|
}
|
|
|
|
eFPAddComment(srn, dtr, dirid, path, comment, cr)
|
|
int srn;
|
|
word dtr;
|
|
dword dirid;
|
|
byte *path;
|
|
byte *comment;
|
|
dword *cr;
|
|
{
|
|
AddCommentPkt ac;
|
|
int len;
|
|
|
|
ac.adc_cmd = AFPAddComment;
|
|
ac.adc_zero = 0;
|
|
ac.adc_dtrefnum = dtr;
|
|
ac.adc_dirid = dirid;
|
|
ac.adc_ptype = 2;
|
|
pstrcpy(ac.adc_path, path);
|
|
if ((len = pstrlen(comment)) > 199)
|
|
len = 199;
|
|
ac.adc_clen = len;
|
|
pstrcpy(ac.adc_comment, comment);
|
|
return(FPAddComment(srn, &ac, cr));
|
|
}
|
|
|
|
eFPAddIcon(srn, dtr, fcreator, ftype, icontype, icontag, icon, iconlen, cr)
|
|
int srn;
|
|
word dtr;
|
|
byte fcreator[];
|
|
byte ftype[];
|
|
byte icontype;
|
|
dword icontag;
|
|
byte *icon;
|
|
int iconlen;
|
|
dword *cr;
|
|
{
|
|
AddIconPkt adi;
|
|
adi.adi_cmd = AFPAddIcon;
|
|
adi.adi_zero = 0;
|
|
adi.adi_dtref = dtr;
|
|
bcopy(fcreator, adi.adi_fcreator, 4);
|
|
bcopy(ftype, adi.adi_ftype, 4);
|
|
adi.adi_icontype = icontype;
|
|
adi.adi_icontag = icontag;
|
|
adi.adi_iconsize = iconlen;
|
|
|
|
return(FPAddIcon(srn, &adi, icon, iconlen, cr));
|
|
}
|
|
|
|
eFPByteRangeLock(srn, oforkrefnum, offset, length, flags, rangestart, cr)
|
|
int srn;
|
|
word oforkrefnum;
|
|
dword offset, length;
|
|
word flags;
|
|
dword *rangestart;
|
|
dword *cr;
|
|
{
|
|
ByteRangeLockPkt brl;
|
|
|
|
brl.brl_cmd = AFPByteRangeLock;
|
|
brl.brl_flg = flags;
|
|
brl.brl_refnum = oforkrefnum;
|
|
brl.brl_offset = offset;
|
|
brl.brl_length = length;
|
|
return(FPByteRangeLock(srn, &brl, rangestart, cr));
|
|
}
|
|
|
|
eFPCloseDir(srn, volid, dirid, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
dword *cr;
|
|
{
|
|
CloseDirPkt cd;
|
|
cd.cdr_cmd = AFPCloseDir;
|
|
cd.cdr_zero = 0;
|
|
cd.cdr_volid = volid;
|
|
cd.cdr_dirid = dirid;
|
|
return(FPCloseDir(srn, &cd, cr));
|
|
}
|
|
|
|
eFPCloseDT(srn, dtrefnum, cr)
|
|
int srn;
|
|
word dtrefnum;
|
|
dword *cr;
|
|
{
|
|
CloseDTPkt cdt;
|
|
|
|
cdt.cdt_cmd = AFPCloseDT;
|
|
cdt.cdt_zero = 0;
|
|
cdt.cdt_dtrefnum = dtrefnum;
|
|
|
|
return(FPCloseDT(srn, &cdt, cr));
|
|
}
|
|
|
|
eFPCloseFork(SRefNum, OForkRefnum, cr)
|
|
int SRefNum;
|
|
word OForkRefnum;
|
|
dword *cr;
|
|
{
|
|
CloseForkPkt cfp;
|
|
|
|
cfp.cfk_cmd = AFPCloseFork;
|
|
cfp.cfk_zero = 0;
|
|
cfp.cfk_refnum = OForkRefnum;
|
|
|
|
return(FPCloseFork(SRefNum, &cfp, cr));
|
|
}
|
|
|
|
eFPCloseVol(srn, volid, cr)
|
|
int srn;
|
|
word volid;
|
|
dword *cr;
|
|
{
|
|
CloseVolPkt cv;
|
|
|
|
cv.cv_cmd = AFPCloseVol;
|
|
cv.cv_zero = 0;
|
|
cv.cv_volid = volid;
|
|
return(FPCloseVol(srn, &cv, cr));
|
|
}
|
|
|
|
eFPCopyFile(srn, svolid, sdirid, spath, dvolid, ddirid, dpath, newname, cr)
|
|
int srn;
|
|
word svolid;
|
|
dword sdirid;
|
|
byte *spath;
|
|
word dvolid;
|
|
dword ddirid;
|
|
byte *dpath;
|
|
byte *newname;
|
|
dword *cr;
|
|
{
|
|
CopyFilePkt cf;
|
|
|
|
cf.cpf_cmd = AFPCopyFile;
|
|
cf.cpf_zero = 0;
|
|
cf.cpf_svolid = svolid;
|
|
cf.cpf_sdirid = sdirid;
|
|
cf.cpf_dvolid = dvolid;
|
|
cf.cpf_ddirid = ddirid;
|
|
cf.cpf_sptype = 2;
|
|
pstrcpy(cf.cpf_spath, spath);
|
|
cf.cpf_dptype = 2;
|
|
pstrcpy(cf.cpf_dpath, dpath);
|
|
cf.cpf_newtype = 2;
|
|
pstrcpy(cf.cpf_newname, newname);
|
|
return(FPCopyFile(srn, &cf, cr));
|
|
}
|
|
|
|
eFPCreateDir(srn, volid, dirid, path, newdirid, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte *path;
|
|
dword *newdirid;
|
|
dword *cr;
|
|
{
|
|
CreateDirPkt cd;
|
|
|
|
cd.crd_cmd = AFPCreateDir;
|
|
cd.crd_zero = 0;
|
|
cd.crd_volid = volid;
|
|
cd.crd_dirid = dirid;
|
|
cd.crd_ptype = 2;
|
|
pstrcpy(cd.crd_path, path);
|
|
return(FPCreateDir(srn, &cd, newdirid, cr));
|
|
}
|
|
|
|
eFPCreateFile(srn, volid, dirid, createflag, pathname, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte createflag;
|
|
byte *pathname;
|
|
dword *cr;
|
|
{
|
|
CreateFilePkt cf;
|
|
|
|
cf.crf_cmd = AFPCreateFile;
|
|
cf.crf_flg = createflag ? CRF_HARD : 0;
|
|
cf.crf_volid = volid;
|
|
cf.crf_dirid = dirid;
|
|
cf.crf_ptype = 0x2; /* always long name */
|
|
pstrcpy(cf.crf_path, pathname); /* file name */
|
|
return(FPCreateFile(srn, &cf, cr));
|
|
}
|
|
|
|
eFPDelete(srn, volid, dirid, path, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte *path;
|
|
dword *cr;
|
|
{
|
|
DeletePkt dp;
|
|
|
|
dp.del_cmd = AFPDelete;
|
|
dp.del_zero = 0;
|
|
dp.del_volid = volid;
|
|
dp.del_dirid = dirid;
|
|
dp.del_ptype = 0x2; /* long name */
|
|
pstrcpy(dp.del_path, path);
|
|
return(FPDelete(srn, &dp, cr));
|
|
}
|
|
|
|
/* call with epars, returns filled in */
|
|
eFPEnumerate(srn, volid, dirid, path, idx, fbitmap, dbitmap,
|
|
epar, eparcnt, cnt, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte *path;
|
|
int idx;
|
|
word fbitmap;
|
|
word dbitmap;
|
|
FileDirParm *epar;
|
|
int eparcnt;
|
|
int *cnt;
|
|
dword *cr;
|
|
{
|
|
EnumeratePkt ep;
|
|
byte buf[576*3-1];
|
|
|
|
ep.enu_cmd = AFPEnumerate;
|
|
ep.enu_zero = 0;
|
|
ep.enu_volid = volid;
|
|
ep.enu_dirid = dirid; /* root */
|
|
ep.enu_fbitmap = fbitmap;
|
|
ep.enu_dbitmap = dbitmap;
|
|
ep.enu_reqcnt = eparcnt;
|
|
ep.enu_stidx = idx;
|
|
ep.enu_maxreply = 576*3-1;
|
|
ep.enu_ptype = 2;
|
|
pstrcpy(ep.enu_path, path);
|
|
|
|
return(FPEnumerate(srn, &ep, buf, 576*3-1, epar, eparcnt, cnt, cr));
|
|
}
|
|
|
|
eFPFlush(srn, volid, cr)
|
|
int srn;
|
|
word volid;
|
|
dword *cr;
|
|
{
|
|
FlushPkt fv;
|
|
|
|
fv.fls_cmd = AFPFlush;
|
|
fv.fls_zero = 0;
|
|
fv.fls_volid = volid;
|
|
return(FPFlush(srn, &fv, cr));
|
|
}
|
|
|
|
eFPFlushFork(srn, oforkrefnum, cr)
|
|
int srn;
|
|
word oforkrefnum;
|
|
dword *cr;
|
|
{
|
|
FlushForkPkt ff;
|
|
|
|
ff.flf_cmd = AFPFlushFork;
|
|
ff.flf_zero = 0;
|
|
ff.flf_refnum = oforkrefnum;
|
|
return(FPFlushFork(srn, &ff, cr));
|
|
}
|
|
|
|
eFPGetAPPL(srn, dtr, fcreator, idx, bitmap, gar, cr)
|
|
int srn;
|
|
word dtr;
|
|
byte fcreator[];
|
|
word idx;
|
|
word bitmap;
|
|
GetAPPLReplyPkt *gar;
|
|
dword *cr;
|
|
{
|
|
GetAPPLPkt gap;
|
|
|
|
gap.gap_cmd = AFPGetAPPL;
|
|
gap.gap_zero = 0;
|
|
gap.gap_dtrefnum = dtr;
|
|
bcopy(fcreator, gap.gap_fcreator, 4);
|
|
gap.gap_applidx = idx;
|
|
gap.gap_bitmap = bitmap;
|
|
|
|
return(FPGetAPPL(srn, &gap, gar, cr));
|
|
}
|
|
|
|
eFPGetComment(srn, dtr, dirid, path, gcr, cr)
|
|
int srn;
|
|
word dtr;
|
|
dword dirid;
|
|
byte *path;
|
|
GCRPPtr gcr;
|
|
dword *cr;
|
|
{
|
|
GetCommentPkt gc;
|
|
|
|
gc.gcm_cmd = AFPGetComment;
|
|
gc.gcm_zero = 0;
|
|
gc.gcm_dtrefnum = dtr;
|
|
gc.gcm_dirid = dirid;
|
|
gc.gcm_ptype = 2; /* long name */
|
|
pstrcpy(gc.gcm_path, path);
|
|
return(FPGetComment(srn, &gc, gcr, cr));
|
|
}
|
|
|
|
eFPGetFileDirParms(srn, volid, dirid, fbitmap, dbitmap, path, epar, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
word fbitmap;
|
|
word dbitmap;
|
|
byte *path;
|
|
FileDirParm *epar;
|
|
dword *cr;
|
|
{
|
|
GetFileDirParmsPkt gfdp;
|
|
|
|
gfdp.gdp_cmd = AFPGetFileDirParms;
|
|
gfdp.gdp_zero = 0;
|
|
gfdp.gdp_volid = volid;
|
|
gfdp.gdp_dirid = dirid; /* root */
|
|
gfdp.gdp_fbitmap = fbitmap;
|
|
gfdp.gdp_dbitmap = dbitmap;
|
|
gfdp.gdp_ptype = 0x2; /* long path type */
|
|
pstrcpy(gfdp.gdp_path,path);
|
|
return(FPGetFileDirParms(srn, &gfdp, epar, cr));
|
|
}
|
|
|
|
eFPGetForkParms(srn, fref, bitmap, epar, cr)
|
|
int srn;
|
|
word fref;
|
|
word bitmap;
|
|
FileDirParm *epar;
|
|
dword *cr;
|
|
{
|
|
GetForkParmsPkt gfp;
|
|
|
|
gfp.gfp_cmd = AFPGetForkParms;
|
|
gfp.gfp_zero = 0;
|
|
gfp.gfp_refnum = fref;
|
|
gfp.gfp_bitmap = bitmap;
|
|
return(FPGetForkParms(srn, &gfp, epar, cr));
|
|
}
|
|
|
|
eFPGetIcon(srn, dtr, fcreator, ftype, icontype, icon, iconlen, cr)
|
|
int srn;
|
|
word dtr;
|
|
byte fcreator[];
|
|
byte ftype[];
|
|
byte icontype;
|
|
byte *icon;
|
|
int iconlen;
|
|
dword *cr;
|
|
{
|
|
GetIconPkt gic;
|
|
|
|
gic.gic_cmd = AFPGetIcon;
|
|
gic.gic_zero = 0;
|
|
gic.gic_dtrefnum = dtr;
|
|
bcopy(fcreator, gic.gic_fcreator, 4);
|
|
bcopy(ftype,gic.gic_ftype, 4);
|
|
gic.gic_itype = icontype;
|
|
gic.gic_zero2 = 0;
|
|
gic.gic_length = iconlen;
|
|
return(FPGetIcon(srn, &gic, icon, iconlen, cr));
|
|
}
|
|
|
|
eFPGetIconInfo(srn, dtr, fcreator, iconidx, gicr, cr)
|
|
int srn;
|
|
word dtr;
|
|
byte fcreator[];
|
|
word iconidx;
|
|
GetIconInfoReplyPkt *gicr;
|
|
dword *cr;
|
|
{
|
|
GetIconInfoPkt gii;
|
|
|
|
gii.gii_cmd = AFPGetIconInfo;
|
|
gii.gii_zero = 0;
|
|
gii.gii_dtrefnum = dtr;
|
|
bcopy(fcreator, gii.gii_fcreator, 4);
|
|
gii.gii_iidx = iconidx;
|
|
|
|
return(FPGetIconInfo(srn, &gii, gicr, cr));
|
|
}
|
|
|
|
/* maybe make this do a lookup first someday? */
|
|
eFPGetSrvrInfo(addr, sr)
|
|
AddrBlock *addr;
|
|
GetSrvrInfoReplyPkt *sr;
|
|
{
|
|
return(FPGetSrvrInfo(addr, sr));
|
|
}
|
|
|
|
eFPGetSrvrParms(srn, sp, cr)
|
|
int srn;
|
|
GSPRPPtr *sp;
|
|
dword *cr;
|
|
{
|
|
return(FPGetSrvrParms(srn, sp, cr));
|
|
}
|
|
|
|
eFPGetVolParms(srn, volid, vbitmap, ve, cr)
|
|
int srn;
|
|
word volid;
|
|
word vbitmap;
|
|
GetVolParmsReplyPkt *ve;
|
|
dword *cr;
|
|
{
|
|
GetVolParmsPkt gvp;
|
|
|
|
gvp.gvp_cmd = AFPGetVolParms;
|
|
gvp.gvp_zero = 0;
|
|
gvp.gvp_volid = volid;
|
|
gvp.gvp_bitmap = vbitmap;
|
|
|
|
return(FPGetVolParms(srn, &gvp, ve, cr));
|
|
}
|
|
|
|
/* Order matters */
|
|
static char *uam_which[3] = {
|
|
"No User Authent",
|
|
"Cleartxt passwrd",
|
|
"Randnum exchange"
|
|
};
|
|
|
|
eFPLogin(srn, user, passwd, uam, cr)
|
|
int srn;
|
|
byte *user, *passwd;
|
|
int uam;
|
|
dword *cr;
|
|
{
|
|
static byte uam_flags[3] = {
|
|
0, /* no special parms for ANON */
|
|
UAMP_USER|UAMP_PASS|UAMP_ZERO, /* passwd + user... */
|
|
UAMP_USER, /* just pass user for RANDNUM initially */
|
|
};
|
|
LoginPkt lp;
|
|
LoginReplyPkt lrp;
|
|
LoginContPkt lcp;
|
|
byte flgs;
|
|
int comp;
|
|
|
|
if (desinit(0) < 0)
|
|
if (uam == UAM_RANDNUM) {
|
|
*cr = aeBadUAM;
|
|
return(-1);
|
|
}
|
|
lp.log_cmd = AFPLogin;
|
|
strcpy(lp.log_ver, "AFPVersion 1.1");
|
|
strcpy(lp.log_uam, uam_which[uam]);
|
|
flgs = lp.log_flag = uam_flags[uam];
|
|
/* Have to do this - we are going to say this don't have to valid */
|
|
/* if not needed for uam */
|
|
if (flgs & UAMP_USER)
|
|
strcpy(lp.log_user,user);
|
|
if (flgs & UAMP_PASS)
|
|
bcopy(passwd, lp.log_passwd, 8); /* copy in password */
|
|
if (uam == UAM_RANDNUM)
|
|
lrp.logr_flag = UAMP_RAND|UAMP_INUM; /* expect these back */
|
|
comp = FPLogin(srn, &lp, &lrp, cr);
|
|
if (comp < 0)
|
|
return(comp);
|
|
if ((((dword)*cr) != aeAuthContinue) && (uam != UAM_RANDNUM))
|
|
return(comp);
|
|
if (desinit(0) < 0) {
|
|
/* here handle randnum exchange */
|
|
*cr = aeBadUAM;
|
|
return(-1);
|
|
}
|
|
#ifdef SUNOS4_FASTDES
|
|
des_setparity(passwd);
|
|
bcopy(lrp.logr_randnum, lcp.lgc_encrypted, sizeof(lcp.lgc_encrypted));
|
|
ecb_crypt(passwd,lcp.lgc_encrypted,64,DES_ENCRYPT|DES_HW);
|
|
#else SUNOS4_FASTDES
|
|
dessetkey(passwd);
|
|
bcopy(lrp.logr_randnum, lcp.lgc_encrypted, sizeof(lcp.lgc_encrypted));
|
|
endes(lcp.lgc_encrypted);
|
|
desdone(); /* clean up (not used except by login) */
|
|
#endif SUNOS4_FASTDES
|
|
lcp.lgc_cmd = AFPLoginCont;
|
|
lcp.lgc_zero = 0;
|
|
lcp.lgc_idno = lrp.logr_idnum;
|
|
lcp.lgc_flags = UAMP_INUM|UAMP_ENCR;
|
|
return(FPLoginCont(srn, &lcp, &lrp, cr));
|
|
}
|
|
|
|
eFPMapID(srn, fnc, ugid, mapr, cr)
|
|
int srn;
|
|
byte fnc;
|
|
dword ugid;
|
|
MapIDReplyPkt *mapr;
|
|
dword *cr;
|
|
{
|
|
MapIDPkt mi;
|
|
|
|
mi.mpi_cmd = AFPMapID;
|
|
mi.mpi_fcn = fnc;
|
|
mi.mpi_id = ugid;
|
|
|
|
return(FPMapID(srn, &mi, mapr, cr));
|
|
}
|
|
|
|
eFPMapName(srn, fnc, name, id, cr)
|
|
int srn;
|
|
byte fnc;
|
|
byte *name;
|
|
dword *id;
|
|
dword *cr;
|
|
{
|
|
MapNamePkt mnp;
|
|
|
|
mnp.mpn_cmd = AFPMapName;
|
|
mnp.mpn_fcn = fnc;
|
|
pstrcpy(mnp.mpn_name, name);
|
|
return(FPMapName(srn, &mnp, id, cr));
|
|
}
|
|
|
|
eFPMoveFile(srn, volid, sdirid, spath, ddirid, dpath, newname, cr)
|
|
int srn;
|
|
word volid;
|
|
dword sdirid;
|
|
byte *spath;
|
|
dword ddirid;
|
|
byte *dpath;
|
|
byte *newname;
|
|
dword *cr;
|
|
{
|
|
MovePkt mf;
|
|
|
|
mf.mov_cmd = AFPMove;
|
|
mf.mov_zero = 0;
|
|
mf.mov_volid = volid;
|
|
mf.mov_sdirid = sdirid;
|
|
mf.mov_ddirid = ddirid;
|
|
mf.mov_sptype = 2;
|
|
pstrcpy(mf.mov_spath, spath);
|
|
mf.mov_dptype = 2;
|
|
pstrcpy(mf.mov_dpath, dpath);
|
|
mf.mov_newtype = 2;
|
|
pstrcpy(mf.mov_newname, newname);
|
|
return(FPMoveFile(srn, &mf, cr));
|
|
}
|
|
|
|
eFPOpenDir(srn, volid, dirid, path, retdirid, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte *path;
|
|
dword *retdirid;
|
|
dword *cr;
|
|
{
|
|
OpenDirPkt od;
|
|
|
|
od.odr_cmd = AFPOpenDir;
|
|
od.odr_zero = 0;
|
|
od.odr_dirid = dirid;
|
|
od.odr_volid = volid;
|
|
od.odr_ptype = 2;
|
|
pstrcpy(od.odr_path, path);
|
|
return(FPOpenDir(srn, &od, retdirid, cr));
|
|
}
|
|
|
|
eFPOpenDT(srn, volid, dtrefnum, cr)
|
|
int srn;
|
|
word volid;
|
|
word *dtrefnum;
|
|
dword *cr;
|
|
{
|
|
OpenDTPkt odt;
|
|
|
|
odt.odt_cmd = AFPOpenDT;
|
|
odt.odt_zero = 0;
|
|
odt.odt_volid = volid;
|
|
return(FPOpenDT(srn, &odt, dtrefnum, cr));
|
|
}
|
|
|
|
eFPOpenFork(srn, volid, dirid, mode, path, type, bitmap, epar, refnum, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
word mode;
|
|
char *path;
|
|
byte type;
|
|
word bitmap;
|
|
FileDirParm *epar;
|
|
word *refnum;
|
|
dword *cr;
|
|
{
|
|
OpenForkPkt of;
|
|
|
|
of.ofk_cmd = AFPOpenFork;
|
|
of.ofk_rdflg = type ? OFK_RSRC : 0;
|
|
of.ofk_volid = volid;
|
|
of.ofk_dirid = dirid; /* root */
|
|
of.ofk_bitmap = bitmap; /* no info */
|
|
of.ofk_mode = mode; /* read/write */
|
|
of.ofk_ptype = 0x2; /* long name */
|
|
pstrcpy(of.ofk_path, path); /* file name */
|
|
return(FPOpenFork(srn, &of, epar, refnum, cr));
|
|
}
|
|
|
|
eFPOpenVol(srn, bitmap, dovol, passwd, op, cr)
|
|
int srn;
|
|
word bitmap;
|
|
char *dovol;
|
|
byte *passwd;
|
|
GetVolParmsReplyPkt *op;
|
|
dword *cr;
|
|
{
|
|
OpenVolPkt ov;
|
|
|
|
ov.ovl_cmd = AFPOpenVol;
|
|
ov.ovl_zero = 0;
|
|
ov.ovl_bitmap = bitmap;
|
|
strcpy(ov.ovl_name, dovol);
|
|
if (passwd)
|
|
pstrcpy(ov.ovl_pass, passwd);
|
|
else
|
|
ov.ovl_pass[0] = 0;
|
|
return(FPOpenVol(srn, &ov, op, cr));
|
|
}
|
|
|
|
eFPRead(srn, fd, buf, buflen, toget, offset, cr)
|
|
int srn;
|
|
word fd;
|
|
char *buf;
|
|
int buflen;
|
|
int toget;
|
|
dword offset;
|
|
dword *cr;
|
|
{
|
|
ReadPkt rp;
|
|
int err;
|
|
int rlen;
|
|
|
|
rp.rdf_cmd = AFPRead;
|
|
rp.rdf_zero = 0;
|
|
rp.rdf_refnum = fd;
|
|
rp.rdf_offset = offset;
|
|
rp.rdf_reqcnt = toget;
|
|
rp.rdf_flag = 0;
|
|
rp.rdf_nlchar = 0;
|
|
err = FPRead(srn, &rp, buf, buflen, &rlen, cr);
|
|
if (err < 0)
|
|
return(err);
|
|
if (*cr && ((dword)*cr) != aeEOFErr)
|
|
return(0);
|
|
return(rlen);
|
|
}
|
|
|
|
eFPRemoveAPPL(srn, dtr, dirid, fcreator, path, cr)
|
|
int srn;
|
|
word dtr;
|
|
dword dirid;
|
|
byte fcreator[];
|
|
byte *path;
|
|
dword *cr;
|
|
{
|
|
RemoveAPPLPkt rma;
|
|
|
|
rma.rma_cmd = AFPRmvAPPL;
|
|
rma.rma_zero = 0;
|
|
rma.rma_refnum = dtr;
|
|
rma.rma_dirid = dirid;
|
|
bcopy(fcreator, rma.rma_fcreator, 4);
|
|
rma.rma_ptype = 0x2;
|
|
pstrcpy(rma.rma_path, path);
|
|
return(FPRemoveAPPL(srn, &rma, cr));
|
|
}
|
|
|
|
eFPRemoveComment(srn, dtr, dirid, path, cr)
|
|
int srn;
|
|
word dtr;
|
|
dword dirid;
|
|
byte *path;
|
|
dword *cr;
|
|
{
|
|
RemoveCommentPkt rmc;
|
|
|
|
rmc.rmc_cmd = AFPRmvComment;
|
|
rmc.rmc_zero = 0;
|
|
rmc.rmc_dtrefnum = dtr;
|
|
rmc.rmc_dirid = dirid;
|
|
rmc.rmc_ptype = 0x2;
|
|
pstrcpy(rmc.rmc_path, path);
|
|
return(FPRemoveComment(srn, &rmc, cr));
|
|
}
|
|
|
|
eFPRename(srn, volid, dirid, path, newname, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
byte *path, *newname;
|
|
dword *cr;
|
|
{
|
|
RenamePkt rn;
|
|
rn.ren_cmd = AFPRename;
|
|
rn.ren_zero = 0;
|
|
rn.ren_volid = volid;
|
|
rn.ren_dirid = dirid;
|
|
rn.ren_ptype = 0x2;
|
|
pstrcpy(rn.ren_path, path);
|
|
rn.ren_ntype = 0x2;
|
|
pstrcpy(rn.ren_npath, newname);
|
|
return(FPRename(srn, &rn, cr));
|
|
}
|
|
|
|
eFPSetDirParms(srn, volid, dirid, bitmap, path, di, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
word bitmap;
|
|
byte *path;
|
|
FileDirParm *di;
|
|
dword *cr;
|
|
{
|
|
SetDirParmsPkt sdp;
|
|
sdp.sdp_cmd = AFPSetDirParms;
|
|
sdp.sdp_zero = 0;
|
|
sdp.sdp_volid = volid;
|
|
sdp.sdp_dirid = dirid;
|
|
sdp.sdp_bitmap = bitmap;
|
|
sdp.sdp_ptype = 0x2;
|
|
pstrcpy(sdp.sdp_path, path);
|
|
return(FPSetDirParms(srn, &sdp, di, cr));
|
|
}
|
|
|
|
eFPSetFileParms(srn, volid, dirid, bitmap, path, fi, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
word bitmap;
|
|
byte *path;
|
|
FileDirParm *fi;
|
|
dword *cr;
|
|
{
|
|
SetFileParmsPkt sfp;
|
|
|
|
sfp.sfp_cmd = AFPSetFileParms;
|
|
sfp.sfp_zero = 0;
|
|
sfp.sfp_volid = volid;
|
|
sfp.sfp_dirid = dirid;
|
|
sfp.sfp_bitmap = bitmap;
|
|
sfp.sfp_ptype = 0x2;
|
|
pstrcpy(sfp.sfp_path, path);
|
|
return(FPSetFileParms(srn, &sfp, fi, cr));
|
|
}
|
|
|
|
eFPSetFileDirParms(srn, volid, dirid, bitmap, path, fdi, cr)
|
|
int srn;
|
|
word volid;
|
|
dword dirid;
|
|
word bitmap;
|
|
byte *path;
|
|
FileDirParm *fdi;
|
|
dword *cr;
|
|
{
|
|
SetFileDirParmsPkt scp;
|
|
|
|
scp.scp_cmd = AFPSetFileParms;
|
|
scp.scp_zero = 0;
|
|
scp.scp_volid = volid;
|
|
scp.scp_dirid = dirid;
|
|
scp.scp_bitmap = bitmap;
|
|
scp.scp_ptype = 0x2;
|
|
pstrcpy(scp.scp_path, path);
|
|
return(FPSetFileDirParms(srn, &scp, fdi, cr));
|
|
}
|
|
|
|
eFPSetForkParms(srn, fd, bitmap, fi, cr)
|
|
int srn;
|
|
word fd;
|
|
word bitmap;
|
|
FileParm *fi;
|
|
dword *cr;
|
|
{
|
|
SetForkParmsPkt sfp;
|
|
sfp.sfkp_cmd = AFPSetForkParms;
|
|
sfp.sfkp_zero = 0;
|
|
sfp.sfkp_refnum = fd;
|
|
sfp.sfkp_bitmap = bitmap;
|
|
sfp.sfkp_rflen = fi->fp_rflen;
|
|
sfp.sfkp_dflen = fi->fp_dflen;
|
|
return(FPSetForkParms(srn, &sfp, cr));
|
|
}
|
|
|
|
eFPSetVolParms(srn, volid, backupdate, cr)
|
|
int srn;
|
|
word volid;
|
|
dword backupdate;
|
|
dword *cr;
|
|
{
|
|
SetVolParmsPkt svp;
|
|
|
|
svp.svp_cmd = AFPSetVolParms;
|
|
svp.svp_zero = 0;
|
|
svp.svp_volid = volid;
|
|
svp.svp_bitmap = VP_BDATE;
|
|
svp.svp_backdata = backupdate;
|
|
return(FPSetVolParms(srn, &svp, cr));
|
|
}
|
|
|
|
eFPWrite(srn, fd, wbuf, wlen, towrite, actcnt, offset, cr)
|
|
int srn, fd;
|
|
char *wbuf;
|
|
int towrite;
|
|
dword *actcnt;
|
|
int *offset;
|
|
dword *cr;
|
|
{
|
|
WritePkt wp;
|
|
dword pactcnt, pwritten;
|
|
int comp;
|
|
|
|
*actcnt = 0;
|
|
wp.wrt_cmd = AFPWrite;
|
|
wp.wrt_flag = 0;
|
|
wp.wrt_refnum = fd;
|
|
wp.wrt_offset = *offset;
|
|
wp.wrt_reqcnt = towrite;
|
|
|
|
return(FPWrite(srn, wbuf, wlen, &wp, actcnt, offset, cr));
|
|
}
|