CAP/lib/afpc/afpc.c

/*
 * $Author: djh $ $Date: 1996/04/25 01:12:53 $
 * $Header: /mac/src/cap60/lib/afpc/RCS/afpc.c,v 2.6 1996/04/25 01:12:53 djh Rel djh $
 * $Revision: 2.6 $
 *
 */

/*
 * afpc.c - AFP client calls
 *
 *
 * AppleTalk package for UNIX (4.2 BSD).
 *
 * Copyright (c) 1986, 1987, 1988 by The Trustees of Columbia University in the
 * City of New York.
 *
 * Edit History:
 *
 *  March 1987  CCKim		Created.
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <netinet/in.h>		/* so ntohl, etc work on non-vax */
#include <netat/appletalk.h>
#include <netat/afp.h>
#include <netat/afpcmd.h>
#include <netat/afpc.h>

sendspcmd(srn, sbuf, slen, cr)
byte *sbuf;
int slen;
dword *cr;
{
  int rlen, comp;

  SPCommand(srn, sbuf, slen, NULL, 0, cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  /* should we check rlen? */
  return(comp);
}


FPAddAPPL(srn, aa, cr)
int srn;
AddAPPLPkt *aa;
{
  char lbuf[sizeof(AddAPPLPkt)+1];
  extern PackEntry ProtoAAP[];
  int len;

  len = htonPackX(ProtoAAP, aa, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPAddComment(srn, ac, cr)
int srn;
AddCommentPkt *ac;
dword *cr;
{
  int len;
  char lbuf[sizeof(AddCommentPkt)+1];
  extern PackEntry ProtoACP[];

  len = htonPackX(ProtoACP, ac, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPAddIcon(srn, adi, icon, il, cr)
int srn;
AddIconPkt *adi;
byte *icon;
int il;
dword *cr;
{
  int len, rlen, wlen, comp;
  char lbuf[sizeof(AddIconPkt)+1];
  extern PackEntry ProtoAIP[];

  len = htonPackX(ProtoAIP, adi, lbuf);

  SPWrite(srn,lbuf,len, icon, il, NULL, 0, cr, &wlen, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)	/* keep trying if so */
    return(comp);
  return(noErr);
}


FPByteRangeLock(srn, brl, rangestart, cr)
int srn;
ByteRangeLockPkt *brl;
dword *rangestart;
dword *cr;
{
  dword reply;
  int rlen, len, comp;
  char lbuf[sizeof(ByteRangeLockPkt)+1];
  extern PackEntry ProtoBRL[];

  len = htonPackX(ProtoBRL, brl, lbuf);
  SPCommand(srn, lbuf, len, &reply, sizeof(reply), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  *rangestart = ntohl(reply);
  return(comp);
}


FPCloseDir(srn, cd, cr)
int srn;
CloseDirPkt *cd;
dword *cr;
{
  char lbuf[sizeof(CloseDirPkt)+1];
  extern PackEntry ProtoCDP[];
  int len;

  len = htonPackX(ProtoCDP, cd, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPCloseDT(srn, cdt, cr)
int srn;
CloseDTPkt *cdt;
dword *cr;
{
  extern PackEntry ProtoCDT[];
  int len;
  char lbuf[sizeof(CloseDTPkt)+1];

  len = htonPackX(ProtoCDT, cdt, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPCloseFork(SRefNum, cfp, cr)
int SRefNum;
CloseForkPkt *cfp;
dword *cr;
{
  char lbuf[sizeof(CloseForkPkt)+1];
  extern PackEntry ProtoCFkP[];
  int len;
  len = htonPackX(ProtoCFkP, cfp, lbuf);

  return(sendspcmd(SRefNum, lbuf, len, cr));
}


FPCloseVol(srn, cv, cr)
int srn;
CloseVolPkt *cv;
dword *cr;
{
  int len;
  extern PackEntry ProtoCVP[];
  char lbuf[sizeof(CloseVolPkt)+1];

  len = htonPackX(ProtoCVP, cv, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPCopyFile(srn, cf, cr)
int srn;
CopyFilePkt *cf;
dword *cr;
{
  char lbuf[sizeof(CopyFilePkt)];
  extern PackEntry ProtoCpFP[];
  int len;

  len = htonPackX(ProtoCpFP, cf, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPCreateDir(srn, cd, newdirid, cr)
int srn;
CreateDirPkt *cd;
dword *newdirid;
dword *cr;
{
  dword reply;
  int rlen, len, comp;
  char lbuf[sizeof(CreateDirPkt)+1];
  extern PackEntry ProtoCRDP[];

  len = htonPackX(ProtoCRDP, cd, lbuf);
  SPCommand(srn, lbuf, len, &reply, sizeof(reply), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  *newdirid = ntohl(reply);
  return(comp);
}


FPCreateFile(srn, cf, cr)
int srn;
CreateFilePkt *cf;
dword *cr;
{
  char lbuf[sizeof(CreateFilePkt)+1];
  int len;
  extern PackEntry ProtoCFP[];

  len = htonPackX(ProtoCFP, cf, lbuf);

  return(sendspcmd(srn, lbuf, len, cr));
}


FPDelete(srn, dp, cr)
int srn;
DeletePkt *dp;
dword *cr;
{
  char lbuf[sizeof(DeletePkt)+1];
  extern PackEntry ProtoDFP[];
  int len;

  len = htonPackX(ProtoDFP, dp, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPEnumerate(srn, ep, tbuf, tbufsiz, epar, eparcnt, cnt, cr)
int srn;
EnumeratePkt *ep;
byte *tbuf;
int tbufsiz;
FileDirParm *epar;
int eparcnt;
int *cnt;
dword *cr;
{
  char lbuf[sizeof(EnumeratePkt)];
  int rlen, comp, len, i;
  word bitmap;
  extern PackEntry ProtoEP[], ProtoEPR[], ProtoFileAttr[], ProtoDirAttr[];
  unsigned char *p;
  EnumerateReplyPkt epr;

  len = htonPackX(ProtoEP, ep, lbuf);  

  SPCommand(srn, lbuf, len, tbuf, tbufsiz, cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  len = ntohPackX(ProtoEPR, tbuf, rlen, &epr);
  *cnt = epr.enur_actcnt;
  for (i = 0, p = tbuf+len; i<(int)epr.enur_actcnt ; i++) {
    len = (int)p[0];
    epar->fdp_flg = p[1];
    bitmap = FDP_ISDIR(p[1]) ? epr.enur_dbitmap : epr.enur_fbitmap;
    ntohPackXbitmap(FDP_ISDIR(p[1]) ? ProtoDirAttr : ProtoFileAttr,
		    &p[2], len-2, epar, bitmap);
    epar++;
    p+=len;
  }
  return(noErr);
}


FPFlush(srn, fv, cr)
int srn;
FlushPkt *fv;
dword *cr;
{
  char lbuf[sizeof(FlushPkt)+1];
  int len;
  extern PackEntry ProtoCFP[];

  len = htonPackX(ProtoCFP, fv, lbuf);

  return(sendspcmd(srn, lbuf, len, cr));
}


FPFlushFork(srn, ff, cr)
int srn;
FlushForkPkt *ff;
dword *cr;
{
  char lbuf[sizeof(FlushForkPkt)+1];
  extern PackEntry ProtoFFP[];
  int len;

  len = htonPackX(ProtoFFP, ff, lbuf);

  return(sendspcmd(srn, lbuf, len, cr));
}


FPGetAPPL(srn, gap, gar, cr)
int srn;
GetAPPLPkt *gap;
GetAPPLReplyPkt *gar;
dword *cr;
{
  char lbuf[sizeof(GetAPPLPkt)+1];
  char buf[sizeof(GetAPPLReplyPkt)+1];
  int rlen, comp, len;
  extern PackEntry ProtoGAP[], ProtoGAPR[], ProtoFileAttr[];

  len = htonPackX(ProtoGAP, gap, lbuf);
  SPCommand(srn,lbuf,len,buf,sizeof(GetAPPLReplyPkt),cr,&rlen,-1,&comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  len = ntohPackX(ProtoGAPR, buf, rlen, gar);
  rlen -= len;
  ntohPackXbitmap(ProtoFileAttr, buf+len, rlen, &gar->fdp, gar->gapr_bitmap);
  return(noErr);
}


FPGetComment(srn, gc, gcr, cr)
int srn;
GetCommentPkt *gc;
GCRPPtr gcr;
dword *cr;
{
  char lbuf[sizeof(GetCommentPkt)+1];
  char buf[sizeof(GetCommentReplyPkt)+1];
  int rlen, comp, len;
  extern PackEntry ProtoGCP[];

  len = htonPackX(ProtoGCP, gc, lbuf);
  SPCommand(srn,lbuf,len,buf,sizeof(GetCommentReplyPkt),cr,&rlen,-1,&comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  len = (int)buf[0];		/* get return string len */
  if (len > 199)
    len = 199;			/* truncate if too long */
  bcopy(buf+1, gcr->gcmr_ctxt, len);
  gcr->gcmr_clen = len;
  return(noErr);
}


FPGetFileDirParms(srn, gfdp, epar, cr)
int srn;
GetFileDirParmsPkt *gfdp;
FileDirParm *epar;
dword *cr;
{
  byte lbuf[sizeof(GetFileDirParmsPkt)+1];
  byte buf[sizeof(FileDirParm)+10];
  int rlen, comp, len;
  extern PackEntry ProtoGFDPP[], ProtoFileAttr[], ProtoDirAttr[];
  word rfbitmap, rdbitmap;
  byte *p, isfiledir;

  len = htonPackX(ProtoGFDPP, gfdp, lbuf);

  SPCommand(srn,lbuf, len, buf, sizeof(FileDirParm)+10, cr, &rlen,-1,&comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0) 
    return(comp);
  p = buf;
  UnpackWord(&p, &rfbitmap);
  UnpackWord(&p, &rdbitmap);
  epar->fdp_flg = isfiledir = *p++;
  p++;				/* skip past zero entry */
  if (FDP_ISDIR(isfiledir))
    ntohPackXbitmap(ProtoDirAttr, p, rlen, epar, rdbitmap); /* directory */
  else
    ntohPackXbitmap(ProtoFileAttr, p, rlen, epar, rfbitmap); /* file */
  return(noErr);
}


FPGetForkParms(srn, gfp, epar, cr)
int srn;
GetForkParmsPkt *gfp;
FileDirParm *epar;
dword *cr;
{
  byte lbuf[sizeof(GetForkParmsPkt)+1];
  byte buf[sizeof(FileDirParm)+10];
  int rlen, comp, len;
  extern PackEntry ProtoGFkPP[],ProtoFileAttr[], ProtoDirAttr[];
  byte *p;
  word fbitmap;

  len = htonPackX(ProtoGFkPP, gfp, lbuf);

  SPCommand(srn,lbuf, len, buf, sizeof(buf), cr, &rlen,-1,&comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != noErr) 
    return(comp);
  p = buf;			/* copy pointer */
  UnpackWord(&p, &fbitmap);		/* unpack bitmap */
  ntohPackXbitmap(ProtoFileAttr, p, rlen, epar, fbitmap);
  return(noErr);
}


FPGetIcon(srn, gi, icon, iconlen, cr)
int srn;
GetIconPkt *gi;
byte *icon;
int iconlen;
dword *cr;
{
  byte lbuf[sizeof(GetIconPkt)+1];
  extern PackEntry ProtoGI[];
  int comp, rlen, len;

  len = htonPackX(ProtoGI, gi, lbuf);
  
  SPCommand(srn, lbuf, len, icon, iconlen, cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != noErr) 
    return(comp);
  return(noErr);
}


FPGetIconInfo(srn, gii, gicr, cr)
int srn;
GetIconInfoPkt *gii;
GetIconInfoReplyPkt *gicr;
dword *cr;
{
  byte buf[sizeof(GetIconInfoPkt)+1], lbuf[sizeof(GetIconInfoReplyPkt)+1];
  int len, rlen, comp;
  extern PackEntry ProtoGII[], ProtoGIIR[];

  len = htonPackX(ProtoGII, gii, lbuf);
  SPCommand(srn, lbuf, len, buf, sizeof(buf), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != noErr) 
    return(comp);
  ntohPackX(ProtoGIIR, buf, rlen, gicr);
  return(noErr);
}


FPGetSrvrMsg(srn, smp, smrp, cr)
int srn;
SrvrMsgPkt *smp;
SrvrMsgReplyPkt *smrp;
dword *cr;
{
  byte buf[sizeof(SrvrMsgPkt)+1], lbuf[sizeof(SrvrMsgReplyPkt)+1];
  int len, rlen, comp;
  extern PackEntry ProtoMsgP[], ProtoMsgRP[];

  len = htonPackX(ProtoMsgP, smp, lbuf);
  SPCommand(srn, lbuf, len, buf, sizeof(buf), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != noErr) 
    return(comp);
  ntohPackX(ProtoMsgRP, buf, rlen, smrp);
  return(noErr);
}


FPGetSrvrInfo(addr, sr)
AddrBlock *addr;
GetSrvrInfoReplyPkt *sr;
{
  byte buf[atpMaxData];
  int len, comp;
  extern PackEntry ProtoSRP[];
  int avolen, uamolen;
  byte *p;

  SPGetStatus(addr, buf, atpMaxData-1, &len, 1, -1, &comp) ;
  while (comp > 0)
    abSleep(4*9, TRUE);
  if (comp < 0)
    return(comp);

  ntohPackX(ProtoSRP, buf, len, sr);
  /* number of bytes for avo and uamo strings */
  avolen = IndStrLen(sr->sr_avo);
  uamolen = IndStrLen(sr->sr_uamo);
  if ((p = (byte *)malloc(avolen+uamolen)) == NULL)
    return(-1);
  /* copy the data */
  bcopy(sr->sr_avo, p, avolen);
  bcopy(sr->sr_uamo, p+avolen, uamolen);
  /* reset pointers */
  sr->sr_avo = p;
  sr->sr_uamo = p+avolen;
  return(noErr);
}


FPGetSrvrParms(srn, sp, cr)
int srn;
GSPRPPtr *sp;
dword *cr;
{
  byte cmd = AFPGetSrvrParms;
  byte buf[atpMaxData];
  int rlen, comp, i, nvols;
  extern PackEntry ProtoGSPRP[];
  GSPRPPtr rp;
  byte *p;
  
  SPCommand(srn, &cmd, 1, buf, sizeof(buf)-1, cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  nvols = (int)buf[4];		/* count of vols */
  if (nvols == 0)
    *sp = (GSPRPPtr)malloc(sizeof(GetSrvrParmsReplyPkt));
  else
    *sp = (GSPRPPtr)malloc(sizeof(GetSrvrParmsReplyPkt)+
			  (nvols-1)*sizeof(VolParm));
  if (*sp == NULL)
    return(-1);
  rp = *sp;
  ntohPackX(ProtoGSPRP, buf, rlen, rp);
  for (p = &buf[5], i = 0; i < nvols; i++) {
    rp->gspr_volp[i].volp_flag = *p;
    cpyp2cstr(rp->gspr_volp[i].volp_name, p+1);
    p += 2+(int)p[1];
  }
  return(noErr);
}


FPGetVolParms(srn, gvp, ve, cr)
int srn;
GetVolParmsPkt *gvp;
GetVolParmsReplyPkt *ve;
dword *cr;
{
  byte lbuf[sizeof(GetVolParmsPkt)+1];
  byte buf[sizeof(GetVolParmsReplyPkt)+10];
  int len, rlen, comp;
  extern PackEntry ProtoGVPP[];	/* getvolparms */
  extern PackEntry ProtoGVPRP[]; /* volume info */

  len = htonPackX(ProtoGVPP, gvp, lbuf);
  SPCommand(srn, lbuf, len, buf, sizeof(GetVolParmsReplyPkt)+10,
	    cr, &rlen, -1, &comp);
  while (comp > 0) abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  ntohPackX(ProtoGVPRP, buf, rlen, ve);
  return(noErr);
}


FPLogin(srn, lp, lir, cr)
int srn;
LoginPkt *lp;
LoginReplyPkt *lir;
dword *cr;
{
  byte lbuf[sizeof(LoginPkt)+8];
  int rlen, len, comp;
  extern PackEntry ProtoLP[], ProtoLRP[];
  char buf[sizeof(LoginReplyPkt)+1];

  len = htonPackXbitmap(ProtoLP, lp, lbuf, lp->log_flag);

  SPCommand(srn, lbuf, len, buf, sizeof(buf), cr, &rlen, -1, &comp);

  while (comp > 0)
    abSleep(4, TRUE);
  ntohPackXbitmap(ProtoLRP, buf, rlen, lir, lir->logr_flag);
  return(comp);
}


/* For now - assume no response - this is not necessarily true though */
FPLoginCont(srn, lgc, lir, cr)
int srn;
LoginContPkt *lgc;
LoginReplyPkt *lir;
dword *cr;
{
  extern PackEntry ProtoLCP[], ProtoLRP[];
  char lbuf[sizeof(LoginContPkt)];
  char buf[sizeof(LoginReplyPkt)+1];
  int rlen, len, comp;

  len = htonPackXbitmap(ProtoLCP, lgc, lbuf, lgc->lgc_flags);
  SPCommand(srn, lbuf, len, buf, sizeof(buf), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  ntohPackXbitmap(ProtoLRP, buf, rlen, lir, lir->logr_flag);
  return(comp);
}


FPLogout(srn, cr)
int srn;
dword *cr;
{
  byte cmd = AFPLogout;
  return(sendspcmd(srn, &cmd, 1, cr));
}


FPMapID(srn, mi,mapr, cr)
int srn;
MapIDPkt *mi;
MapIDReplyPkt *mapr;
dword *cr;
{
  byte buf[sizeof(MapIDReplyPkt)+1], lbuf[sizeof(MapIDPkt)+1];
  int len, rlen, comp;
  extern PackEntry ProtoMIP[];

  len = htonPackX(ProtoMIP, mi, lbuf);
  SPCommand(srn,lbuf,len,buf,sizeof(MapIDReplyPkt)+1, cr, &rlen, -1, &comp);
  while (comp > 0) abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  pstrcpy(mapr->mpir_name, buf); /* copy back name */
  return(noErr);
}


FPMapName(srn, mnp, id, cr)
int srn;
MapNamePkt *mnp;
dword *id;
dword *cr;
{
  byte lbuf[sizeof(MapNamePkt)+1], retid[sizeof(dword)], *p;
  int len, rlen, comp;
  extern PackEntry ProtoMNP[];

  len = htonPackX(ProtoMNP, mnp, lbuf);
  SPCommand(srn, lbuf, len, retid, sizeof(retid), cr, &rlen, -1, &comp);
  while (comp > 0) abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  p = retid;
  UnpackDWord(&p, id);
  return(comp);
}


FPMoveFile(srn, mf, cr)
int srn;
MovePkt *mf;
dword *cr;
{
  char lbuf[sizeof(MovePkt)];
  extern PackEntry ProtoMFP[];
  int len;

  len = htonPackX(ProtoMFP, mf, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPOpenDir(srn, od, retdirid, cr)
int srn;
OpenDirPkt *od;
dword *retdirid;
dword *cr;
{
  byte lbuf[sizeof(OpenDirPkt)+1], retid[sizeof(dword)], *p;
  int len, rlen, comp;
  extern PackEntry ProtoODP[];
  
  len = htonPackX(ProtoODP, od, lbuf);
  SPCommand(srn, lbuf, len, retid, sizeof(retid), cr, &rlen, -1, &comp);
  while (comp > 0) abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  p = retid;
  UnpackDWord(&p, retdirid);
  return(comp);
}


FPOpenDT(srn, odt, dtrefnum, cr)
int srn;
OpenDTPkt *odt;
word *dtrefnum;
dword *cr;
{
  extern PackEntry ProtoODT[];
  word reply;
  int rlen, len, comp;
  char lbuf[sizeof(OpenDTPkt)+1];

  len = htonPackX(ProtoODT, odt, lbuf);
  SPCommand(srn, lbuf, len, &reply, sizeof(reply), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)
    return(comp);
  *dtrefnum = ntohs(reply);
  return(comp);
}


/* if type  then rsrc else data */
/* should really optionally return bitmap data */


FPOpenFork(srn, of, epar, refnum, cr)
int srn;
OpenForkPkt *of;
FileDirParm *epar;
word *refnum;
dword *cr;
{
  extern PackEntry ProtoOFkP[], ProtoFileAttr[];
  byte lbuf[sizeof(OpenForkPkt)], buf[sizeof(FileDirParm)+20], *p;
  int rlen, comp, len;
  word bitmap;
  
  len = htonPackX(ProtoOFkP, of, lbuf);

  SPCommand(srn, lbuf, len, buf, sizeof(buf), cr, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0) 
    return(comp);
  p = buf;
  UnpackWord(&p, &bitmap);
  UnpackWord(&p, refnum);
  if (epar)
    ntohPackXbitmap(ProtoFileAttr, p, rlen, epar, bitmap);
#ifdef notdef
  printf("openfork CR = %X, %d\n",cr,-(*cr));
  printf("RLEN = %d\n",rlen);
  printf("Open file refnum = %d\n",*refnum);
#endif
  return(noErr);
}


FPOpenVol(srn, ov, op, cr)
int srn;
OpenVolPkt *ov;
GetVolParmsReplyPkt *op;
dword *cr;
{
  byte lbuf[sizeof(OpenVolPkt)+1];
  byte buf[100];
  int rlen, comp, len;
  extern PackEntry ProtoGVPRP[];
  extern PackEntry ProtoOVP[];

  len = htonPackX(ProtoOVP, ov, lbuf);

  SPCommand(srn, lbuf, len, buf, 100, cr, &rlen, -1, &comp);

  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0) 
    return(comp);

  ntohPackX(ProtoGVPRP, buf, rlen, op);
  return(noErr);
}


/*
 * reads from remote into buf for length at most buflen starting at offset
 * file must already be open
 * returns length read
 * sets eof if eof was returned 
*/


FPRead(srn, rp, buf, buflen, rlen, cr)
int srn;
ReadPkt *rp;
byte *buf;
int *rlen;
dword *cr;
{
  char lbuf[sizeof(ReadPkt)+1];
  extern PackEntry ProtoRP[];
  int comp, len;

  len = htonPackX(ProtoRP, rp, lbuf);

  SPCommand(srn, lbuf, len, buf, buflen, cr, rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  return(comp);
}


FPRemoveAPPL(srn, ra, cr)
int srn;
RemoveAPPLPkt *ra;
dword *cr;
{
  extern PackEntry ProtoRMA[];
  int len;
  byte lbuf[sizeof(RemoveAPPLPkt)+1];

  len = htonPackX(ProtoRMA, ra, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPRemoveComment(srn, rc, cr)
int srn;
RemoveCommentPkt *rc;
dword *cr;
{
  extern PackEntry ProtoRMC[];
  int len;
  byte lbuf[sizeof(RemoveCommentPkt)+1];

  len = htonPackX(ProtoRMC, rc, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPRename(srn, rn, cr)
int srn;
RenamePkt *rn;
dword *cr;
{
  extern PackEntry ProtoRFP[];
  byte lbuf[sizeof(RenamePkt)+1];
  int len;

  len = htonPackX(ProtoRFP, rn, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPSetDirParms(srn, sdp, fdp, cr)
int srn;
SetDirParmsPkt *sdp;
FileDirParm *fdp;
dword *cr;
{
  extern PackEntry ProtoSDPP[], ProtoDirAttr[];
  byte lbuf[sizeof(SetDirParmsPkt)+sizeof(FileDirParm)+1];
  int len;

  len = htonPackX(ProtoSDPP, sdp, lbuf);
  len += htonPackXbitmap(ProtoDirAttr, fdp, lbuf+len, sdp->sdp_bitmap);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPSetFileParms(srn, sfp, fdp, cr)
int srn;
SetFileParmsPkt *sfp;
FileDirParm *fdp;
dword *cr;
{
  extern PackEntry ProtoSFPP[], ProtoFileAttr[];
  byte lbuf[sizeof(SetFileParmsPkt)+sizeof(FileDirParm)+1];
  int len;

  len = htonPackX(ProtoSFPP, sfp, lbuf);
  len += htonPackXbitmap(ProtoFileAttr, fdp, lbuf+len, sfp->sfp_bitmap);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPSetFileDirParms(srn, sfdp, fdp, cr)
int srn;
SetFileDirParmsPkt *sfdp;
FileDirParm *fdp;
dword *cr;
{
  extern PackEntry ProtoSDPP[], ProtoFileDirAttr[];
  byte lbuf[sizeof(SetForkParmsPkt)+sizeof(FileDirParm)+1];
  int len;

  len = htonPackX(ProtoSDPP, sfdp, lbuf);
  len += htonPackXbitmap(ProtoFileDirAttr, fdp, lbuf+len, sfdp->scp_bitmap);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPSetForkParms(srn, sfp, cr)
int srn;
SetForkParmsPkt *sfp;
dword *cr;
{
  extern PackEntry ProtoSFkPP[];
  byte lbuf[sizeof(SetForkParmsPkt)+1];
  int len;

  len = htonPackX(ProtoSFkPP, sfp, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPSetVolParms(srn, svp, cr)
SetVolParmsPkt *svp;
dword *cr;
{
  extern PackEntry ProtoSVPP[];
  byte lbuf[sizeof(SetVolParmsPkt)+1];
  int len;

  len = htonPackX(ProtoSVPP, svp, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}


FPWrite(srn, wbuf, wlen, wp, actcnt, lastoffset_written, cr)
int srn;
char *wbuf;
int wlen;
WritePkt *wp;
dword *actcnt;			/* actual count written */
dword *lastoffset_written;	/* last offset written */
dword *cr;
{
  char lbuf[sizeof(WritePkt)+1];
  dword low;
  int rlen, comp, len;
  extern PackEntry ProtoWP[];

  len = htonPackX(ProtoWP, wp, lbuf);

  SPWrite(srn, lbuf, len, wbuf, wlen, &low, sizeof(low),
		cr, actcnt, &rlen, -1, &comp);
  while (comp > 0)
    abSleep(4, TRUE);
  if (comp < 0 || *cr != 0)	/* keep trying if so */
    return(comp);
  *lastoffset_written = htonl(low); /* ugh */
  return(noErr);
}


FPExchangeFiles(srn, mf, cr)
int srn;
ExchPkt *mf;
dword *cr;
{
  char lbuf[sizeof(ExchPkt)];
  extern PackEntry ProtoExP[];
  int len;

  len = htonPackX(ProtoExP, mf, lbuf);
  return(sendspcmd(srn, lbuf, len, cr));
}