sealink.c

/* SEAlink - Sliding window file transfer protocol

 Version 1.20, created on 08/05/87 at 17:51:40

 Copyright 1986,87 by System Enhancement Associates; ALL RIGHTS RESERVED

 By: Thom Henderson

 Description:

 This file contains a set of routines to illustrate the SEAlink
 sliding window file transfer protocol. SEAlink is fully backward
 compatible to XMODEM, and can be easily adapted to most XMODEM
 variants.

 The intent of SEAlink is to provide a file transfer protocol that
 does not suffer from propagation delays, such as are introduced
 by satellite relays or packet switched networks.

 Instructions:

 Two routines are provided to implement SEAlink file transfers.

 int xmtfile(name) /+ transmit a file +/
 char *name; /+ name of file to transmit +/

 This routine is used to send a file. One file is sent at a time.
 If the name is blank (name is null or *name points to a null),
 then only an end of transmission marker is sent.

 This routine returns a one if the file is successfully
 transmitted, or a zero if a fatal error occurs.

 char *rcvfile(name) /+ receive a file +/
 char *name; /+ name of file (optional) +/

 This routine is used to receive a file. One file is received.
 The name, if given, takes precedence and will be the name of
 the resulting file. If the name is blank (name is null or *name
 points to a null), then the name given by the transmitter is used.
 If the transmitter does not give a name, then the file transfer
 is aborted.

 This routine returns a pointer to the name of the file that
 was received. If the file transfer is not successful, then
 a null pointer is returned.

 The pointer returned by rcvfile() points to a static data buffer.
 This does not have to be freed (and should not be), but it will
 be overwritten the next time rcvfile() is called.

 The rcvfile() function works on a temporary file whose name is
 the same as the final file, but with a dash ("-") added at the
 beginning. If a file transfer is aborted, then this temporary
 file will be retained. An aborted file transfer will not harm
 a pre-existing file of the same name.

 Programming notes:

 These routines can be used for either single or multiple file
 transfers.

 To send multiple files, send each one one at a time until either
 a transmit fails or all files are sent. If all files are sent,
 then signal the end by calling xmtfile() with a null pointer.

 To receive multiple files, call rcvfile() repeatedly until it
 returns a null pointer.

 These routines pass a "block zero", which contains information
 about the original file name, size, and date/time of last
 modification. If you cannot implement block zero, then you can
 leave it out. If you cannot set any given field in block zero
 when transmitting, then you should leave it set to zeros. If you
 cannot use any given field of block zero when receiving, then
 you should ignore it.

 These routines are fully compatible with XMODEM, including the
 original checksum method and later CRC adaptations. It can be
 easily adapted to Modem7 protocol by adding a Modem7 filename
 transfer shell, though we do not recommend it. The underlying
 logic, of course, can be adapted to almost any variant of XMODEM.

 License:

 You are granted a license to use this code in your programs, and
 to adapt it to your particular situation and needs, subject only
 to the following conditions:

 1) You must refer to it as the SEAlink protocol, and you must
 give credit to System Enhancement Associates.

 2) If you modify it in such a way that your version cannot
 converse with the original code as supplied by us, then
 you should refer to it as "SEAlink derived", or as a
 "variation of SEAlink", or words to that effect.

 In short, we're not asking for any money, but we'd like to
 get some credit for our work.

 Language:
 Computer Innovations Optimizing C86
*/
#include<stdio.h>
#include"fstat.h"
#include<time.h>

structzeros/* block zero data structure */
{ longflen; /* file length */
longfstamp; /* file date/time stamp */
charfnam[17]; /* original file name */
charprog[15]; /* sending program name */
charnoacks; /* true if ACKing not required */
charfill[87]; /* reserved for future use */
} ;

#defineACK 0x06
#defineNAK 0x15
#defineSOH 0x01
#defineEOT 0x04

#defineWINDOW 6 /* normal window size */

staticintoutblk; /* number of next block to send */
staticintackblk; /* number of last block ACKed */
staticintblksnt; /* number of last block sent */
staticintslide; /* true if sliding window */
staticintackst; /* ACK/NAK state */
staticintnumnak; /* number of sequential NAKs */
staticintchktec; /* check type, 1=CRC, 0=checksum */
staticinttoterr; /* total number of errors */
staticintackrep; /* true when ACK or NAK reported */
staticintackseen; /* count of sliding ACKs seen */

char*progname="Your name here"; /* name of sending program */
intackless=0; /* true if ACKs not required */

/* File transmitter logic */

intxmtfile(name) /* transmit a file */
char*name; /* name of file to send */
{
FILE*f, *fopen(); /* file to send */
longt1, timerset(); /* timers */
intendblk; /* block number of EOT */
structfilstatfst; /* data about file */
structzeroszero; /* block zero data */

if(name&&*name) /* if sending a file */
 { if(!(f=fopen(name,"rb")))
 { printf(" Can't read %s\n",name);
return0;
 }

setmem(&zero,sizeof(zero),0); /* clear out data block */

filestat(name,&fst); /* get file statistics */
zero.flen=fst.fs_fsize;
zero.fstamp=fst.fs_abs;
strcpy(zero.fnam,fst.fs_fname);
strcpy(zero.prog,progname);
zero.noacks=ackless;

endblk= ((zero.flen+127)/128) +1;
printf(" Ready to send %d blocks of %s\n",endblk-1,zero.fnam);
 }
elseendblk=0; /* fake for no file */

outblk=1; /* set starting state */
ackblk=-1;
blksnt=slide=ackst=numnak=toterr=ackrep=ackseen=0;
chktec=2; /* undetermined */

t1=timerset(300); /* time limit for first block */
printf(" Waiting...\r");

while(ackblk<endblk) /* while not all there yet */
 { if(!carrier())
 { printf("\n Lost carrier\n");
 goto abort;
 }
if(key_scan()!=EOF)
 { if((key_getc()&0xff)==27)
 { printf("\n Aborted by operator\n");
 goto abort;
 }
 }
if(timeup(t1))
 { printf("\n Fatal timeout\n");
 goto abort;
 }

if(outblk <= ackblk+ (slide? WINDOW : 1))
 { if(outblk<endblk)
 { if(outblk>0)
sendblk(f,outblk);
elseshipblk(&zero,0);

if(ackrep)
printf(" Sending block #%d \r",outblk);

if(ackless&&slide)
 { if(!(outblk%10))
printf("\r Passing block %d \t\t\r",outblk);
ackblk=outblk;
 }
 }
elseif(outblk==endblk)
 { com_putc(EOT);
if(ackrep)
printf(" Sending EOT \r");
 }
outblk++;
t1=timerset(300); /* time limit between blocks */
 }

ackchk();
if(numnak>10)
 { printf("\n Too many errors\n");
 goto abort;
 }
 }

printf(" End of file \n");
if(endblk)
fclose(f);
if(toterr>2)
printf(" %d errors detected and fixed in %d blocks.\n",
toterr,blksnt);
return1; /* exit with good status */

abort:
if(endblk)
fclose(f);
if(toterr)
printf(" %d errors detected and fixed in %d blocks.\n",
toterr,blksnt);
return0; /* exit with bad status */
}

/* The various ACK/NAK states are:
 0: Ground state, ACK or NAK expected.
 1: ACK received
 2: NAK received
 3: ACK, block# received
 4: NAK, block# received
 5: Returning to ground state
*/

staticackchk() /* check for ACK or NAK */
{
intc; /* one byte of data */
staticintrawblk; /* raw block number */

ackrep=0; /* nothing reported yet */

while((c=com_getc(0))!=EOF)
 { if(ackst==3||ackst==4)
 { slide=0; /* assume this will fail */
if(rawblk== (c^0xff)) /* see if we believe the number */
 { rawblk=outblk- ((outblk-rawblk)&0xff);
if(rawblk >= 0&&rawblk<=outblk&&rawblk>outblk-128)
 { if(ackst==3) /* advance for an ACK */
 { ackblk=ackblk>rawblk? ackblk : rawblk;
slide=1;
if(ackless&&++ackseen>10)
 { ackless=0; /* receiver not ACKless */
printf("- Overdrive disengaged \n");
 }
printf("\r ACK %d ==",rawblk);
 }
else/* else retransmit for a NAK */
 { outblk=rawblk<0? 0 : rawblk;
slide=numnak<4;
printf("\r NAK %d ==",rawblk);
 }
ackrep=1; /* we reported something */
 }
 }
ackst=5; /* return to ground state */
 }

if(ackst==1||ackst==2)
 { rawblk=c;
ackst+=2;
 }

if(!slide||ackst==0)
 { if(c==ACK)
 { if(!slide)
 { ackblk++;
printf("\r ACK %d --",ackblk);
ackrep=1; /* we reported an ACK */
 }
ackst=1;
numnak=0;
 }

elseif(c=='C'||c==NAK)
 { if(chktec>1) /* if method not determined yet */
chktec= (c=='C'); /* then do what rcver wants */

com_dump(); /* purge pending output */
delay(6); /* resynch */
if(!slide)
 { outblk=ackblk+1;
printf("\r NAK %d --",ackblk+1);
ackrep=1; /* we reported a negative ACK */
 }
ackst=2;
numnak++;
if(blksnt) toterr++;
 }
 }

if(ackst==5)
ackst=0;
 }
}

staticsendblk(f,blknum) /* send one block */
FILE*f; /* file to read from */
intblknum; /* block to send */
{
longblkloc; /* address of start of block */
charbuf[128]; /* one block of data */

if(blknum!=blksnt+1) /* if jumping */
 { blkloc= (long)(blknum-1) *128L;
fseek(f,blkloc,0); /* move where to */
 }
blksnt=blknum;

setmem(buf,128,26); /* fill buffer with control Zs */
fread(buf,1,128,f); /* read in some data */
shipblk(buf,blknum); /* pump it out the comm port */
}

staticintshipblk(blk,blknum) /* physically ship a block */
char*blk; /* data to be shipped */
intblknum; /* number of block */
{
char*b=blk; /* data pointer */
intcrc=0; /* CRC check value */
intn; /* index */

com_putc(SOH); /* block header */
com_putc(blknum); /* block number */
com_putc(blknum^0xff); /* block number check value */

for(n=0; n<128; n++) /* ship the data */
 { if(chktec)
crc=crc_update(crc,*b);
elsecrc+=*b;
com_putc(*b++);
 }

if(chktec) /* send proper check value */
 { crc=crc_finish(crc);
com_putc(crc>>8);
com_putc(crc&0xff);
 }
elsecom_putc(crc);

return1;
}

/* File receiver logic */

char*rcvfile(name) /* receive file */
char*name; /* name of file */
{
intc; /* received character */
inttries; /* retry counter */
longt1, timerset(); /* timer */
intblknum; /* desired block number */
intinblk; /* this block number */
FILE*f, *fopen(); /* file, opener */
charbuf[128]; /* data buffer */
chartmpname[100]; /* name of temporary file */
staticcharoutname[100]; /* name of final file */
structzeroszero; /* file header data storage */
intendblk; /* block number of EOT, if known */
longleft; /* bytes left to output */
intn; /* index */
char*stat="Init"; /* receive block status */
char*getblock(), *why; /* single block receiver, status */

if(name&&*name) /* figure out names to use */
 { makefnam("X:\\",name,outname);
outname[2] ='-';
makefnam(outname+2,name,tmpname);
strcpy(outname,name);
 }
else
 { *outname='\0';
strcpy(tmpname,"-TMPFILE.$$$");
 }

if(!(f=fopen(tmpname,"wb"))) /* open output file */
 { printf(" Cannot create %s\n",tmpname);
returnNULL;
 }

blknum=*outname? 1 : 0; /* first block we must get */
tries=-10; /* kludge for first time around */
chktec=1; /* try for CRC error checking */
toterr=0; /* no errors yet */
endblk=0; /* we don't know the size yet */
ackless=0; /* we don't know about this yet */
setmem(&zero,sizeof(zero),0); /* or much of anything else */

if(com_scan()==SOH) /* kludge for adaptive Modem7 */
 goto nextblock;

nakblock: /* we got a bad block */
if(blknum>1) toterr++;
if(++tries>10)
 { printf("\n Too many errors\n");
 goto abort;
 }
if(tries==0) /* if CRC isn't going */
chktec=0; /* then give checksum a try */

sendack(0,blknum); /* send the NAK */
printf(" NAK block %d %-5s\r",blknum,stat);

if(ackless&&toterr>20) /* if ackless mode isn't working */
 { ackless=0; /* then shut it off */
printf("- Overdrive disengaged\n");
 }
 goto nextblock;

ackblock: /* we got a good block */
if(!ackless)
printf(" ACK block %d %-5s\r",blknum-1,stat);
elseif(!(blknum%10))
printf(" Got block %d \r",blknum);

nextblock: /* start of "get a block" */
stat="";
if(!carrier())
 { printf("\n Lost carrier\n");
 goto abort;
 }
if(key_scan()!=EOF)
 { if((key_getc()&0xff)==27)
 { printf("\n Aborted by operator\n");
 goto abort;
 }
 }
t1=timerset(30); /* timer to start of block */
while(!timeup(t1))
 { c=com_getc(0);
if(c==EOT)
 { if(!endblk||endblk==blknum)
 goto endrcv;
 }
elseif(c==SOH)
 { inblk=com_getc(5);
if(com_getc(5) == (inblk^0xff))
 goto blockstart; /* we found a start */
 }
 }
stat="Time";
 goto nakblock;

blockstart: /* start of block detected */
c=blknum&0xff;
if(inblk==0&&blknum<=1) /* if this is the header */
 { if(!(why=getblock(&zero)))
 { sendack(1,inblk); /* ack the header */
if(!*name) /* given name takes precedence */
strcpy(outname,zero.fnam);
if(left=zero.flen) /* length to transfer */
endblk= (left+127)/128+1;
if(ackless!=zero.noacks) /* note variant employed */
printf("+ Overdrive %sengaged\n",zero.noacks?"":"dis");
ackless=zero.noacks;

printf(" Receiving");
if(endblk)
printf(" %d blocks of",endblk-1);
printf(" %s",outname);
if(*zero.prog)
printf(" from %s",zero.prog);
printf("\n");
blknum=1; /* now we want first data block */
 goto ackblock;
 }
else
 { stat=why;
 goto nakblock; /* bad header block */
 }
 }
elseif(inblk==c) /* if this is the one we want */
 { if(!(why=getblock(buf))) /* else if we get it okay */
 { if(!ackless) /* if we're sending ACKs */
sendack(1,inblk); /* then ACK the good data */
for(n=0; n<128; n++)
 { if(endblk) /* limit file size if known */
 { if(!left)
break;
left--;
 }
if(fputc(buf[n],f)==EOF)
 { printf("\n Write error (disk full?)\n");
 goto abort;
 }
 }
tries=0; /* reset try count */
blknum++; /* we want the next block */
 goto ackblock;
 }
else
 { stat=why;
 goto nakblock; /* ask for a resend */
 }
 }
elseif(inblk<c||inblk>c+100) /* else if resending what we have */
 { getblock(buf); /* ignore it */
sendack(1,inblk); /* but ack it */
stat="Dup";
 goto ackblock;
 }
else goto nextblock; /* else if running ahead */

endrcv:
sendack(0,blknum);
printf(" NAK EOT \r");
if(com_getc(20)!=EOT)
 goto nakblock;
sendack(1,blknum);
printf(" ACK EOT\r");

if(blknum>1) /* if we really got anything */
 { if(toterr>2)
printf(" %d errors detected and fixed in %d blocks.\n",
toterr,blknum-1);
if(zero.fstamp) /* set stamp, if known */
setstamp(f,zero.fstamp);
fclose(f);
unlink(outname); /* rename temp to proper name */
rename(tmpname,outname);
returnoutname; /* signal what file we got */
 }
else/* else no real file */
 { fclose(f);
unlink(tmpname); /* discard empty file */
returnNULL; /* signal end of transfer */
 }

abort:
if(toterr)
printf(" %d errors detected and fixed in %d blocks.\n",
toterr,blknum-1);
fclose(f);
returnNULL;
}

staticsendack(acknak,blknum) /* send an ACK or a NAK */
intacknak; /* 1=ACH, 0=NAK */
intblknum; /* block number */
{
if(acknak) /* send the right signal */
com_putc(ACK);
elseif(chktec)
com_putc('C');
elsecom_putc(NAK);

com_putc(blknum); /* block number */
com_putc(blknum^0xff); /* block number check */
}

staticchar*getblock(buf) /* read a block of data */
char*buf; /* data buffer */
{
intourcrc=0, hiscrc; /* CRC check values */
intc; /* one byte of data */
intn; /* index */
inttimeout=ackless? 200 : 5; /* short block timeout */

for(n=0; n<128; n++)
 { if((c=com_getc(timeout))==EOF)
return"Short";

if(chktec)
ourcrc=crc_update(ourcrc,c);
elseourcrc+=c;
*buf++=c;
 }

if(chktec)
 { ourcrc=crc_finish(ourcrc);
hiscrc= (com_getc(timeout)<<8) | com_getc(timeout);
 }
else
 { ourcrc &= 0xff;
hiscrc=com_getc(timeout) &0xff;
 }

if(ourcrc==hiscrc)
returnNULL; /* block is good */
elseif(chktec)
return"CRC"; /* else CRC error */
elsereturn"Check"; /* or maybe checksum error */
}