home *** CD-ROM | disk | FTP | other *** search
/ Programmer Power Tools / Programmer Power Tools.iso / modem / clink120.arc / SEALINK.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-08-24  |  22.7 KB  |  608 lines
  1. /*  SEAlink - Sliding window file transfer protocol
  2.  
  3.     Version 1.20, created on 08/05/87 at 17:51:40
  4.  
  5.     Copyright 1986,87 by System Enhancement Associates; ALL RIGHTS RESERVED
  6.  
  7.     By:  Thom Henderson
  8.  
  9.     Description:
  10.  
  11.          This file contains a set of routines to illustrate the SEAlink
  12.          sliding window file transfer protocol.  SEAlink is fully backward
  13.          compatible to XMODEM, and can be easily adapted to most XMODEM
  14.          variants.
  15.  
  16.          The intent of SEAlink is to provide a file transfer protocol that
  17.          does not suffer from propagation delays, such as are introduced
  18.          by satellite relays or packet switched networks.
  19.  
  20.     Instructions:
  21.  
  22.          Two routines are provided to implement SEAlink file transfers.
  23.  
  24.          int xmtfile(name)             /+ transmit a file +/
  25.          char *name;                   /+ name of file to transmit +/
  26.  
  27.          This routine is used to send a file.  One file is sent at a time.
  28.          If the name is blank (name is null or *name points to a null),
  29.          then only an end of transmission marker is sent.
  30.  
  31.          This routine returns a one if the file is successfully
  32.          transmitted, or a zero if a fatal error occurs.
  33.  
  34.          char *rcvfile(name)           /+ receive a file +/
  35.          char *name;                   /+ name of file (optional) +/
  36.  
  37.          This routine is used to receive a file.  One file is received.
  38.          The name, if given, takes precedence and will be the name of
  39.          the resulting file.  If the name is blank (name is null or *name
  40.          points to a null), then the name given by the transmitter is used.
  41.          If the transmitter does not give a name, then the file transfer
  42.          is aborted.
  43.  
  44.          This routine returns a pointer to the name of the file that
  45.          was received.  If the file transfer is not successful, then
  46.          a null pointer is returned.
  47.  
  48.          The pointer returned by rcvfile() points to a static data buffer.
  49.          This does not have to be freed (and should not be), but it will
  50.          be overwritten the next time rcvfile() is called.
  51.  
  52.          The rcvfile() function works on a temporary file whose name is
  53.          the same as the final file, but with a dash ("-") added at the
  54.          beginning.  If a file transfer is aborted, then this temporary
  55.          file will be retained.  An aborted file transfer will not harm
  56.          a pre-existing file of the same name.
  57.  
  58.     Programming notes:
  59.  
  60.          These routines can be used for either single or multiple file
  61.          transfers.
  62.  
  63.          To send multiple files, send each one one at a time until either
  64.          a transmit fails or all files are sent.  If all files are sent,
  65.          then signal the end by calling xmtfile() with a null pointer.
  66.  
  67.          To receive multiple files, call rcvfile() repeatedly until it
  68.          returns a null pointer.
  69.  
  70.          These routines pass a "block zero", which contains information
  71.          about the original file name, size, and date/time of last
  72.          modification.  If you cannot implement block zero, then you can
  73.          leave it out.  If you cannot set any given field in block zero
  74.          when transmitting, then you should leave it set to zeros.  If you
  75.          cannot use any given field of block zero when receiving, then
  76.          you should ignore it.
  77.  
  78.          These routines are fully compatible with XMODEM, including the
  79.          original checksum method and later CRC adaptations.  It can be
  80.          easily adapted to Modem7 protocol by adding a Modem7 filename
  81.          transfer shell, though we do not recommend it.  The underlying
  82.          logic, of course, can be adapted to almost any variant of XMODEM.
  83.  
  84.     License:
  85.  
  86.          You are granted a license to use this code in your programs, and
  87.          to adapt it to your particular situation and needs, subject only
  88.          to the following conditions:
  89.  
  90.          1)   You must refer to it as the SEAlink protocol, and you must
  91.               give credit to System Enhancement Associates.
  92.  
  93.          2)   If you modify it in such a way that your version cannot
  94.               converse with the original code as supplied by us, then
  95.               you should refer to it as "SEAlink derived", or as a
  96.               "variation of SEAlink", or words to that effect.
  97.  
  98.          In short, we're not asking for any money, but we'd like to
  99.          get some credit for our work.
  100.  
  101.     Language:
  102.          Computer Innovations Optimizing C86
  103. */
  104. #include <stdio.h>
  105. #include "fstat.h"
  106. #include <time.h>
  107.  
  108. struct zeros                           /* block zero data structure */
  109. {   long flen;                         /* file length */
  110.     long fstamp;                       /* file date/time stamp */
  111.     char fnam[17];                     /* original file name */
  112.     char prog[15];                     /* sending program name */
  113.     char noacks;                       /* true if ACKing not required */
  114.     char fill[87];                     /* reserved for future use */
  115. }   ;
  116.  
  117. #define ACK 0x06
  118. #define NAK 0x15
  119. #define SOH 0x01
  120. #define EOT 0x04
  121.  
  122. #define WINDOW 6                       /* normal window size */
  123.  
  124. static int outblk;                     /* number of next block to send */
  125. static int ackblk;                     /* number of last block ACKed */
  126. static int blksnt;                     /* number of last block sent */
  127. static int slide;                      /* true if sliding window */
  128. static int ackst;                      /* ACK/NAK state */
  129. static int numnak;                     /* number of sequential NAKs */
  130. static int chktec;                     /* check type, 1=CRC, 0=checksum */
  131. static int toterr;                     /* total number of errors */
  132. static int ackrep;                     /* true when ACK or NAK reported */
  133. static int ackseen;                    /* count of sliding ACKs seen */
  134.  
  135. char *progname = "Your name here";     /* name of sending program */
  136. int ackless = 0;                       /* true if ACKs not required */
  137.  
  138. /*  File transmitter logic */
  139.  
  140. int xmtfile(name)                      /* transmit a file */
  141. char *name;                            /* name of file to send */
  142. {
  143.     FILE *f, *fopen();                 /* file to send */
  144.     long t1, timerset();               /* timers */
  145.     int endblk;                        /* block number of EOT */
  146.     struct filstat fst;                /* data about file */
  147.     struct zeros zero;                 /* block zero data */
  148.  
  149.     if(name && *name)                  /* if sending a file */
  150.     {    if(!(f=fopen(name,"rb")))
  151.          {    printf("  Can't read %s\n",name);
  152.               return 0;
  153.          }
  154.  
  155.          setmem(&zero,sizeof(zero),0); /* clear out data block */
  156.  
  157.          filestat(name,&fst);          /* get file statistics */
  158.          zero.flen = fst.fs_fsize;
  159.          zero.fstamp = fst.fs_abs;
  160.          strcpy(zero.fnam,fst.fs_fname);
  161.          strcpy(zero.prog,progname);
  162.          zero.noacks = ackless;
  163.  
  164.          endblk = ((zero.flen+127)/128) + 1;
  165.          printf("  Ready to send %d blocks of %s\n",endblk-1,zero.fnam);
  166.     }
  167.     else endblk = 0;                   /* fake for no file */
  168.  
  169.     outblk = 1;                        /* set starting state */
  170.     ackblk = -1;
  171.     blksnt = slide = ackst = numnak = toterr = ackrep = ackseen = 0;
  172.     chktec = 2;                        /* undetermined */
  173.  
  174.     t1 = timerset(300);                /* time limit for first block */
  175.     printf("  Waiting...\r");
  176.  
  177.     while(ackblk<endblk)               /* while not all there yet */
  178.     {    if(!carrier())
  179.          {    printf("\n  Lost carrier\n");
  180.               goto abort;
  181.          }
  182.          if(key_scan()!=EOF)
  183.          {    if((key_getc()&0xff)==27)
  184.               {    printf("\n  Aborted by operator\n");
  185.                    goto abort;
  186.               }
  187.          }
  188.          if(timeup(t1))
  189.          {    printf("\n  Fatal timeout\n");
  190.               goto abort;
  191.          }
  192.  
  193.          if(outblk <= ackblk + (slide? WINDOW : 1))
  194.          {    if(outblk<endblk)
  195.               {    if(outblk>0)
  196.                         sendblk(f,outblk);
  197.                    else shipblk(&zero,0);
  198.  
  199.                    if(ackrep)
  200.                         printf(" Sending block #%d \r",outblk);
  201.  
  202.                    if(ackless && slide)
  203.                    {    if(!(outblk%10))
  204.                              printf("\r  Passing block %d \t\t\r",outblk);
  205.                         ackblk = outblk;
  206.                    }
  207.               }
  208.               else if(outblk==endblk)
  209.               {    com_putc(EOT);
  210.                    if(ackrep)
  211.                         printf(" Sending EOT         \r");
  212.               }
  213.               outblk++;
  214.               t1 = timerset(300);      /* time limit between blocks */
  215.          }
  216.  
  217.          ackchk();
  218.          if(numnak>10)
  219.          {    printf("\n  Too many errors\n");
  220.               goto abort;
  221.          }
  222.     }
  223.  
  224.     printf(" End of file        \n");
  225.     if(endblk)
  226.          fclose(f);
  227.     if(toterr>2)
  228.          printf("  %d errors detected and fixed in %d blocks.\n",
  229.               toterr,blksnt);
  230.     return 1;                          /* exit with good status */
  231.  
  232. abort:
  233.     if(endblk)
  234.          fclose(f);
  235.     if(toterr)
  236.          printf("  %d errors detected and fixed in %d blocks.\n",
  237.               toterr,blksnt);
  238.     return 0;                          /* exit with bad status */
  239. }
  240.  
  241. /*  The various ACK/NAK states are:
  242.     0:   Ground state, ACK or NAK expected.
  243.     1:   ACK received
  244.     2:   NAK received
  245.     3:   ACK, block# received
  246.     4:   NAK, block# received
  247.     5:   Returning to ground state
  248. */
  249.  
  250. static ackchk()                        /* check for ACK or NAK */
  251. {
  252.     int c;                             /* one byte of data */
  253.     static int rawblk;                 /* raw block number */
  254.  
  255.     ackrep = 0;                        /* nothing reported yet */
  256.  
  257.     while((c=com_getc(0))!=EOF)
  258.     {    if(ackst==3 || ackst==4)
  259.          {    slide = 0;               /* assume this will fail */
  260.               if(rawblk == (c^0xff))   /* see if we believe the number */
  261.               {    rawblk = outblk - ((outblk-rawblk)&0xff);
  262.                    if(rawblk >= 0 && rawblk<=outblk && rawblk>outblk-128)
  263.                    {    if(ackst==3)   /* advance for an ACK */
  264.                         {    ackblk = ackblk>rawblk? ackblk : rawblk;
  265.                              slide = 1;
  266.                              if(ackless && ++ackseen>10)
  267.                              {    ackless = 0;   /* receiver not ACKless */
  268.                                   printf("- Overdrive disengaged     \n");
  269.                              }
  270.                              printf("\r  ACK %d ==",rawblk);
  271.                         }
  272.                         else           /* else retransmit for a NAK */
  273.                         {    outblk = rawblk<0? 0 : rawblk;
  274.                              slide = numnak<4;
  275.                              printf("\r  NAK %d ==",rawblk);
  276.                         }
  277.                         ackrep = 1;    /* we reported something */
  278.                    }
  279.               }
  280.               ackst = 5;               /* return to ground state */
  281.          }
  282.  
  283.          if(ackst==1 || ackst==2)
  284.          {    rawblk = c;
  285.               ackst += 2;
  286.          }
  287.  
  288.          if(!slide || ackst==0)
  289.          {    if(c==ACK)
  290.               {    if(!slide)
  291.                    {    ackblk++;
  292.                         printf("\r  ACK %d --",ackblk);
  293.                         ackrep = 1;    /* we reported an ACK */
  294.                    }
  295.                    ackst = 1;
  296.                    numnak = 0;
  297.               }
  298.  
  299.               else if(c=='C' || c==NAK)
  300.               {    if(chktec>1)        /* if method not determined yet */
  301.                         chktec = (c=='C');  /* then do what rcver wants */
  302.  
  303.                    com_dump();         /* purge pending output */
  304.                    delay(6);           /* resynch */
  305.                    if(!slide)
  306.                    {    outblk = ackblk+1;
  307.                         printf("\r  NAK %d --",ackblk+1);
  308.                         ackrep = 1;    /* we reported a negative ACK */
  309.                    }
  310.                    ackst = 2;
  311.                    numnak++;
  312.                    if(blksnt) toterr++;
  313.               }
  314.          }
  315.  
  316.          if(ackst==5)
  317.               ackst = 0;
  318.     }
  319. }
  320.  
  321. static sendblk(f,blknum)               /* send one block */
  322. FILE *f;                               /* file to read from */
  323. int blknum;                            /* block to send */
  324. {
  325.     long blkloc;                       /* address of start of block */
  326.     char buf[128];                     /* one block of data */
  327.  
  328.     if(blknum != blksnt+1)             /* if jumping */
  329.     {    blkloc = (long)(blknum-1) * 128L;
  330.          fseek(f,blkloc,0);            /* move where to */
  331.     }
  332.     blksnt = blknum;
  333.  
  334.     setmem(buf,128,26);                /* fill buffer with control Zs */
  335.     fread(buf,1,128,f);                /* read in some data */
  336.     shipblk(buf,blknum);               /* pump it out the comm port */
  337. }
  338.  
  339. static int shipblk(blk,blknum)         /* physically ship a block */
  340. char *blk;                             /* data to be shipped */
  341. int blknum;                            /* number of block */
  342. {
  343.     char *b = blk;                     /* data pointer */
  344.     int crc = 0;                       /* CRC check value */
  345.     int n;                             /* index */
  346.  
  347.     com_putc(SOH);                     /* block header */
  348.     com_putc(blknum);                  /* block number */
  349.     com_putc(blknum^0xff);             /* block number check value */
  350.  
  351.     for(n=0; n<128; n++)               /* ship the data */
  352.     {    if(chktec)
  353.               crc = crc_update(crc,*b);
  354.          else crc += *b;
  355.          com_putc(*b++);
  356.     }
  357.  
  358.     if(chktec)                         /* send proper check value */
  359.     {    crc = crc_finish(crc);
  360.          com_putc(crc>>8);
  361.          com_putc(crc&0xff);
  362.     }
  363.     else com_putc(crc);
  364.  
  365.     return 1;
  366. }
  367.  
  368. /*  File receiver logic */
  369.  
  370. char *rcvfile(name)                    /* receive file */
  371. char *name;                            /* name of file */
  372. {
  373.     int c;                             /* received character */
  374.     int tries;                         /* retry counter */
  375.     long t1, timerset();               /* timer */
  376.     int blknum;                        /* desired block number */
  377.     int inblk;                         /* this block number */
  378.     FILE *f, *fopen();                 /* file, opener */
  379.     char buf[128];                     /* data buffer */
  380.     char tmpname[100];                 /* name of temporary file */
  381.     static char outname[100];          /* name of final file */
  382.     struct zeros zero;                 /* file header data storage */
  383.     int endblk;                        /* block number of EOT, if known */
  384.     long left;                         /* bytes left to output */
  385.     int n;                             /* index */
  386.     char *stat = "Init";               /* receive block status */
  387.     char *getblock(), *why;            /* single block receiver, status */
  388.  
  389.     if(name && *name)                  /* figure out names to use */
  390.     {    makefnam("X:\\",name,outname);
  391.          outname[2] = '-';
  392.          makefnam(outname+2,name,tmpname);
  393.          strcpy(outname,name);
  394.     }
  395.     else
  396.     {    *outname = '\0';
  397.          strcpy(tmpname,"-TMPFILE.$$$");
  398.     }
  399.  
  400.     if(!(f=fopen(tmpname,"wb")))       /* open output file */
  401.     {    printf("  Cannot create %s\n",tmpname);
  402.          return NULL;
  403.     }
  404.  
  405.     blknum = *outname? 1 : 0;          /* first block we must get */
  406.     tries = -10;                       /* kludge for first time around */
  407.     chktec = 1;                        /* try for CRC error checking */
  408.     toterr = 0;                        /* no errors yet */
  409.     endblk = 0;                        /* we don't know the size yet */
  410.     ackless = 0;                       /* we don't know about this yet */
  411.     setmem(&zero,sizeof(zero),0);      /* or much of anything else */
  412.  
  413.     if(com_scan()==SOH)                /* kludge for adaptive Modem7 */
  414.          goto nextblock;
  415.  
  416. nakblock:                              /* we got a bad block */
  417.     if(blknum>1) toterr++;
  418.     if(++tries>10)
  419.     {    printf("\n  Too many errors\n");
  420.          goto abort;
  421.     }
  422.     if(tries==0)                       /* if CRC isn't going */
  423.          chktec = 0;                   /* then give checksum a try */
  424.  
  425.     sendack(0,blknum);                 /* send the NAK */
  426.     printf("  NAK block %d %-5s\r",blknum,stat);
  427.  
  428.     if(ackless && toterr>20)           /* if ackless mode isn't working */
  429.     {    ackless = 0;                  /* then shut it off */
  430.          printf("- Overdrive disengaged\n");
  431.     }
  432.     goto nextblock;
  433.  
  434. ackblock:                              /* we got a good block */
  435.     if(!ackless)
  436.          printf("  ACK block %d %-5s\r",blknum-1,stat);
  437.     else if(!(blknum%10))
  438.          printf("  Got block %d      \r",blknum);
  439.  
  440. nextblock:                             /* start of "get a block" */
  441.     stat = "";
  442.     if(!carrier())
  443.     {    printf("\n  Lost carrier\n");
  444.          goto abort;
  445.     }
  446.     if(key_scan()!=EOF)
  447.     {    if((key_getc()&0xff)==27)
  448.          {    printf("\n  Aborted by operator\n");
  449.               goto abort;
  450.          }
  451.     }
  452.     t1 = timerset(30);                 /* timer to start of block */
  453.     while(!timeup(t1))
  454.     {    c = com_getc(0);
  455.          if(c==EOT)
  456.          {    if(!endblk || endblk==blknum)
  457.                    goto endrcv;
  458.          }
  459.          else if(c==SOH)
  460.          {    inblk = com_getc(5);
  461.               if(com_getc(5) == (inblk^0xff))
  462.                    goto blockstart;    /* we found a start */
  463.          }
  464.     }
  465.     stat = "Time";
  466.     goto nakblock;
  467.  
  468. blockstart:                            /* start of block detected */
  469.     c = blknum&0xff;
  470.     if(inblk==0 && blknum<=1)          /* if this is the header */
  471.     {    if(!(why=getblock(&zero)))
  472.          {    sendack(1,inblk);        /* ack the header */
  473.               if(!*name)               /* given name takes precedence */
  474.                    strcpy(outname,zero.fnam);
  475.               if(left=zero.flen)       /* length to transfer */
  476.                    endblk = (left+127)/128 + 1;
  477.               if(ackless!=zero.noacks) /* note variant employed */
  478.                    printf("+ Overdrive %sengaged\n",zero.noacks?"":"dis");
  479.               ackless = zero.noacks;
  480.  
  481.               printf("  Receiving");
  482.               if(endblk)
  483.                    printf(" %d blocks of",endblk-1);
  484.               printf(" %s",outname);
  485.               if(*zero.prog)
  486.                    printf(" from %s",zero.prog);
  487.               printf("\n");
  488.               blknum = 1;              /* now we want first data block */
  489.               goto ackblock;
  490.          }
  491.          else
  492.          {    stat = why;
  493.               goto nakblock;           /* bad header block */
  494.          }
  495.     }
  496.     else if(inblk==c)                  /* if this is the one we want */
  497.     {    if(!(why=getblock(buf)))      /* else if we get it okay */
  498.          {    if(!ackless)             /* if we're sending ACKs */
  499.                    sendack(1,inblk);   /* then ACK the good data */
  500.               for(n=0; n<128; n++)
  501.               {    if(endblk)          /* limit file size if known */
  502.                    {    if(!left)
  503.                              break;
  504.                         left--;
  505.                    }
  506.                    if(fputc(buf[n],f)==EOF)
  507.                    {    printf("\n  Write error (disk full?)\n");
  508.                         goto abort;
  509.                    }
  510.               }
  511.               tries = 0;               /* reset try count */
  512.               blknum++;                /* we want the next block */
  513.               goto ackblock;
  514.          }
  515.          else
  516.          {    stat = why;
  517.               goto nakblock;           /* ask for a resend */
  518.          }
  519.     }
  520.     else if(inblk<c || inblk>c+100)    /* else if resending what we have */
  521.     {    getblock(buf);                /* ignore it */
  522.          sendack(1,inblk);             /* but ack it */
  523.          stat = "Dup";
  524.          goto ackblock;
  525.     }
  526.     else goto nextblock;               /* else if running ahead */
  527.  
  528. endrcv:
  529.     sendack(0,blknum);
  530.     printf("  NAK EOT         \r");
  531.     if(com_getc(20)!=EOT)
  532.          goto nakblock;
  533.     sendack(1,blknum);
  534.     printf("  ACK EOT\r");
  535.  
  536.     if(blknum>1)                       /* if we really got anything */
  537.     {    if(toterr>2)
  538.               printf("  %d errors detected and fixed in %d blocks.\n",
  539.                    toterr,blknum-1);
  540.          if(zero.fstamp)               /* set stamp, if known */
  541.               setstamp(f,zero.fstamp);
  542.          fclose(f);
  543.          unlink(outname);              /* rename temp to proper name */
  544.          rename(tmpname,outname);
  545.          return outname;               /* signal what file we got */
  546.     }
  547.     else                               /* else no real file */
  548.     {    fclose(f);
  549.          unlink(tmpname);              /* discard empty file */
  550.          return NULL;                  /* signal end of transfer */
  551.     }
  552.  
  553. abort:
  554.     if(toterr)
  555.          printf("  %d errors detected and fixed in %d blocks.\n",
  556.               toterr,blknum-1);
  557.     fclose(f);
  558.     return NULL;
  559. }
  560.  
  561. static sendack(acknak,blknum)          /* send an ACK or a NAK */
  562. int acknak;                            /* 1=ACH, 0=NAK */
  563. int blknum;                            /* block number */
  564. {
  565.     if(acknak)                         /* send the right signal */
  566.          com_putc(ACK);
  567.     else if(chktec)
  568.          com_putc('C');
  569.     else com_putc(NAK);
  570.  
  571.     com_putc(blknum);                  /* block number */
  572.     com_putc(blknum^0xff);             /* block number check */
  573. }
  574.  
  575. static char *getblock(buf)             /* read a block of data */
  576. char *buf;                             /* data buffer */
  577. {
  578.     int ourcrc = 0, hiscrc;            /* CRC check values */
  579.     int c;                             /* one byte of data */
  580.     int n;                             /* index */
  581.     int timeout = ackless? 200 : 5;    /* short block timeout */
  582.  
  583.     for(n=0; n<128; n++)
  584.     {    if((c=com_getc(timeout))==EOF)
  585.               return "Short";
  586.  
  587.          if(chktec)
  588.               ourcrc = crc_update(ourcrc,c);
  589.          else ourcrc += c;
  590.          *buf++ = c;
  591.     }
  592.  
  593.     if(chktec)
  594.     {    ourcrc = crc_finish(ourcrc);
  595.          hiscrc = (com_getc(timeout)<<8) | com_getc(timeout);
  596.     }
  597.     else
  598.     {    ourcrc &= 0xff;
  599.          hiscrc = com_getc(timeout) & 0xff;
  600.     }
  601.  
  602.     if(ourcrc == hiscrc)
  603.          return NULL;                  /* block is good */
  604.     else if(chktec)
  605.          return "CRC";                 /* else CRC error */
  606.     else return "Check";               /* or maybe checksum error */
  607. }
  608.