home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d02xx / d0236.lha / XprZmodem / send.c < prev    next >
C/C++ Source or Header  |  1989-08-09  |  13KB  |  455 lines
  1. /*  Send.c: File transmission routines for xprzmodem.library;
  2.     Version 1.0, 29 July 1989, by Rick Huebner.
  3.     Based closely on Chuck Forsberg's sz.c example ZModem code,
  4.     but too pervasively modified to even think of detailing the changes.
  5.     Released to the Public Domain; do as you like with this code.  */
  6.  
  7.  
  8. #include "aztec.h"
  9. #include "xproto.h"
  10. #include "zmodem.h"
  11. #include "defs.h"
  12.  
  13. #ifdef DEBUG
  14. extern long DebugLog;
  15. #endif
  16.  
  17.  
  18. /* Main file transmission routine; called by terminal program */
  19. long XProtocolSend(io)
  20. struct XPR_IO *io;
  21. {
  22.   register struct Vars *v;
  23.   register short err = FALSE;
  24.  
  25.   /* Perform common setup and initializations */
  26.   if (!(v = setup(io))) return 0;
  27.   v->Rxtimeout = 300;
  28.  
  29.   /* Transfer the files */  
  30.   zmputs(v,"rz\r");
  31.   stohdr(v,0L);
  32.   zshhdr(v,ZRQINIT);
  33.   if (getzrxinit(v) == ERROR) upderr(v,"Upload cancelled or timed out");
  34.   else sendbatch(v);
  35.  
  36.   /* Clean up and return */
  37.   if (err = v->Errcnt) upderr(v,"One or more files skipped due to errors");
  38.   else updmsg(v,"Done.");
  39.   if (v->io.xpr_setserial) calld(v->io.xpr_setserial,v->Oldstatus);
  40.   FreeMem(v->Filebuf,v->Filebufmax);
  41.   FreeMem(v,(long)sizeof(struct Vars));
  42.   
  43. #ifdef DEBUG
  44.   if (DebugLog) {
  45.     calla(v->io.xpr_fclose,DebugLog);
  46.     DebugLog = NULL;
  47.   }
  48. #endif
  49.  
  50.   return (err) ? 0 : 1;
  51. }
  52.  
  53.  
  54. /* Negotiate with receiver to start a file transfer */
  55. short getzrxinit(v)
  56. register struct Vars *v;
  57. {
  58.   register short n;
  59.  
  60.   for (n=10; --n>=0; ) {
  61.     switch (zgethdr(v)) {
  62.       case ZCHALLENGE:        /* Echo receiver's challenge number */
  63.         stohdr(v,v->Rxpos);
  64.         zshhdr(v,ZACK);
  65.         continue;
  66.       case ZCOMMAND:          /* They didn't see our ZRQINIT; try again */
  67.         stohdr(v,0L);
  68.         zshhdr(v,ZRQINIT);
  69.         continue;
  70.       case ZRINIT:            /* Receiver ready; get transfer parameters */
  71.         v->Rxbuflen = ((USHORT)v->Rxhdr[ZP1]<<8) | v->Rxhdr[ZP0];
  72. #ifdef DEBUG
  73.         sprintf(v->Msgbuf, "Rxbuflen=%d Tframlen=%d\n", v->Rxbuflen, v->Tframlen);
  74.         dlog(v,v->Msgbuf);
  75. #endif
  76.         /* Use shortest of the two side's max frame lengths */
  77.         if (v->Tframlen && (!v->Rxbuflen || v->Tframlen < v->Rxbuflen))
  78.           v->Rxbuflen = v->Tframlen;
  79. #ifdef DEBUG
  80.         sprintf(v->Msgbuf, "Rxbuflen=%d\n", v->Rxbuflen);
  81.         dlog(v,v->Msgbuf);
  82. #endif
  83.         return OK;
  84.       case ZCAN:
  85.       case RCDO:
  86.       case TIMEOUT:
  87.         return ERROR;
  88.       case ZRQINIT:
  89.         if (v->Rxhdr[ZF0] == ZCOMMAND) continue;
  90.         /* fallthrough... */
  91.       default:
  92.         zshhdr(v,ZNAK);
  93.         continue;
  94.     }
  95.   }
  96.   return ERROR;
  97. }
  98.  
  99.  
  100. /* Send a batch of files */
  101. void sendbatch(v)
  102. register struct Vars *v;
  103. {
  104.   register short single, done = FALSE;
  105.   register long fstate;
  106.  
  107.   /* If template routines not provided, must be single filename */
  108.   if (!v->io.xpr_ffirst || !v->io.xpr_fnext) {
  109.     single = TRUE;
  110.     strcpy(v->Filename,v->io.xpr_filename);
  111.   /* Else use the template routines to get the first filename */
  112.   } else {
  113.     single = FALSE;
  114.     fstate = callaa(v->io.xpr_ffirst,v->Filename,v->io.xpr_filename);
  115.     if (!fstate) {
  116.       upderr(v,"No files match template");
  117.       return;
  118.     }
  119.   }
  120.  
  121.   /* If using templates, keep getting names & sending until done */
  122.   while (!done) {
  123.     if (sendone(v) == ERROR) return;
  124.     if (single) break;
  125.     fstate = calldaa(v->io.xpr_fnext,fstate,v->Filename,v->io.xpr_filename);
  126.     done = !fstate;
  127.   }
  128.  
  129.   /* End batch and return; if we never got started, just cancel receiver */
  130.   if (v->Filcnt) saybibi(v);
  131.   else canit(v);
  132. }
  133.  
  134.  
  135. /* Send the file named in v->Filename */
  136. short sendone(v)
  137. register struct Vars *v;
  138. {
  139.  
  140. #ifdef DEBUG
  141.   sprintf(v->Msgbuf, "*** Sending %s\n", v->Filename);
  142.   dlog(v,v->Msgbuf);
  143. #endif
  144.  
  145.   /* Display name of file being sent for user */
  146.   v->xpru.xpru_updatemask = XPRU_FILENAME;
  147.   v->xpru.xpru_filename = (char *)v->Filename;
  148.   calla(v->io.xpr_update,&v->xpru);
  149.  
  150.   /* Open the file, if possible */
  151.   if (!(v->File = bfopen(v,"r"))) {
  152.     ++v->Errcnt;
  153.     upderr(v,"Can't open file; skipping");
  154.     return OK;      /* pass over it, there may be others */
  155.   }
  156.   ++v->Filcnt;
  157.   v->Starttime = time(NULL);
  158.  
  159.   /* Kick off the file transfer */
  160.   switch (sendname(v)) {
  161.     case ERROR:
  162.       ++v->Errcnt;
  163.       return ERROR;
  164.     case OK:
  165.       bfclose(v);
  166.       break;
  167.   }
  168.   return OK;
  169. }
  170.  
  171.  
  172. /* Build file info block consisting of file name, length, time, and mode */
  173. short sendname(v)
  174. register struct Vars *v;
  175. {
  176.   register UBYTE *p, *q;
  177.  
  178.   /* Initialize term program transfer status display */
  179.   v->Fsize =  (v->io.xpr_finfo) ? callad(v->io.xpr_finfo,v->Filename,1L) : -1;
  180.   v->xpru.xpru_updatemask = XPRU_PROTOCOL | XPRU_FILESIZE | XPRU_MSG | XPRU_BLOCKS |
  181.                             XPRU_ERRORS | XPRU_TIMEOUTS | XPRU_BLOCKCHECK | XPRU_BYTES |
  182.                             XPRU_EXPECTTIME | XPRU_ELAPSEDTIME | XPRU_DATARATE;
  183.   v->xpru.xpru_protocol = "ZModem";
  184.   v->xpru.xpru_filesize = v->Fsize;
  185.   v->xpru.xpru_msg = "Sending...";
  186.   v->xpru.xpru_blocks = v->xpru.xpru_errors = v->xpru.xpru_timeouts = 0;
  187.   v->xpru.xpru_blockcheck = "CRC-16";
  188.   v->xpru.xpru_bytes = v->Strtpos = 0;
  189.   update_rate(v);
  190.   calla(v->io.xpr_update,&v->xpru);
  191.  
  192.   /* Extract outgoing file name; no directory path, lower case */
  193.   for (p=v->Filename, q=v->Pktbuf ; *p; ++p, ++q)
  194.     if ((*q = tolower(*p)) == '/' || *q == ':') q = v->Pktbuf - 1;
  195.   *q = '\0';
  196.   p = ++q;
  197.  
  198.   /* Zero out remainder of file info packet */
  199.   setmem(q,sizeof(v->Pktbuf) - (q - v->Pktbuf),'\0');
  200.  
  201.   /* Store file size, timestamp, and mode in info packet */
  202.   /* XPR spec doesn't provide a way to get the file timestamp or file mode,
  203.      so we'll just fake it with the current time and a dummy 0. */
  204.   sprintf(p,"%lu %lo %o",(v->Fsize < 0) ? 0L : v->Fsize,time(NULL),0);
  205.                 /* ^  ^ Yes, octal; Forsberg likes octal, don't ask me why */
  206.  
  207.   /* Send filename packet */
  208.   return zsendfile(v,p - v->Pktbuf + strlen(p) + 1);
  209. }
  210.  
  211.  
  212. /* Send the filename packet and see if receiver will accept file */
  213. short zsendfile(v,blen)
  214. register struct Vars *v;
  215. short blen;
  216. {
  217.   register short c;
  218.  
  219.   while (TRUE) {
  220.     v->Txhdr[ZF0] = v->Lzconv; /* Text or Binary mode; from config string */
  221.     v->Txhdr[ZF1] = LZMANAG;   /* Default file management mode */
  222.     v->Txhdr[ZF2] = LZTRANS;   /* Default file transport mode */
  223.     v->Txhdr[ZF3] = 0;
  224.     zsbhdr(v,ZFILE);
  225.     zsdata(v,blen,ZCRCW);
  226. again:
  227.     switch (c = zgethdr(v)) {
  228.       case ZRINIT:
  229.         goto again;
  230.       case ZCAN:
  231.       case ZCRC:
  232.       case RCDO:
  233.       case TIMEOUT:
  234.       case ZABORT:
  235.       case ZFIN:
  236.         return ERROR;
  237.       case ZSKIP:             /* Receiver doesn't want this one */
  238.         upderr(v,"SKIP command received");
  239.         bfclose(v);
  240.         return c;
  241.       case ZRPOS:             /* Receiver wants it; this is starting position */
  242.         bfseek(v,v->Rxpos);
  243.         v->Strtpos = v->Txpos = v->Rxpos;
  244.         /* WARNING: comment out following line if using VLT 4.058 */
  245.         if (v->io.xpr_sflush) (*v->io.xpr_sflush)();
  246.         return zsendfdata(v);
  247.     }
  248.   }
  249. }
  250.  
  251.  
  252. /* Send the file data */
  253. short zsendfdata(v)
  254. register struct Vars *v;
  255. {
  256.   register short c, e, blklen, goodbytes;
  257.   USHORT framelen, maxblklen, goodneeded = 512;
  258.  
  259.   /* Figure out max data packet size to send */
  260.   maxblklen = KSIZE;
  261.   if (v->Rxbuflen && maxblklen > v->Rxbuflen) maxblklen = v->Rxbuflen;
  262.   blklen = (v->Baud < 1200) ? 256 : KSIZE;
  263.   if (blklen > maxblklen) blklen = maxblklen;
  264. #ifdef DEBUG
  265.   sprintf(v->Msgbuf, "Rxbuflen=%d blklen=%d\n", v->Rxbuflen, blklen);
  266.   dlog(v,v->Msgbuf);
  267. #endif
  268.  
  269.   /* If an interruption happened, handle it; else keep sending data */
  270. somemore:
  271.   if (char_avail(v)) {
  272. waitack:
  273. #ifdef DEBUG
  274.     dlog(v,"--- At waitack\n");
  275. #endif
  276.     switch (c = getinsync(v)) {
  277.       default:
  278.         upderr(v,"Transfer cancelled");
  279.         bfclose(v);
  280.         return ERROR;
  281.       case ZSKIP:  /* Receiver changed its mind and wants to skip the file */
  282.         return c;
  283.       case ZACK:   /* ACK at end of frame; resume sending data */
  284.         break;
  285.       case ZRPOS:  /* An error; resend data from last good point */
  286.         blklen >>= 2;
  287.         if (blklen < MINBLOCK) blklen = MINBLOCK;
  288.         if (goodneeded < MAXGOODNEEDED) goodneeded <<= 1;
  289.         v->xpru.xpru_updatemask = XPRU_ERRORS;
  290.         ++v->xpru.xpru_errors;
  291.         calla(v->io.xpr_update,&v->xpru);
  292.         break;
  293.       case ZRINIT:
  294.         updmsg(v,"Done.");
  295.         return OK;
  296.     }
  297.     /* Check for another incoming packet while discarding line noise */
  298.     while (char_avail(v)) {
  299.       switch (readock(v,1)) {
  300.         case CAN:
  301.         case RCDO:
  302.         case ZPAD:
  303.           goto waitack;
  304.       }
  305.     }
  306.   }
  307.  
  308.   /* Transmit ZDATA frame header */
  309.   framelen = v->Rxbuflen;
  310.   stohdr(v,v->Txpos);
  311.   zsbhdr(v,ZDATA);
  312.  
  313.   /* Keep sending data packets until finished or interrupted */
  314.   do {
  315.     /* Read next chunk of file data */
  316.     c = bfread(v,v->Pktbuf,(long)blklen);
  317.  
  318.     /* Figure out how to handle this data packet */
  319.     if (c < blklen) e = ZCRCE;   /* If end of file, this is last data packet */
  320.     else if (v->Rxbuflen && (framelen -= c) <= 0) e = ZCRCW; /* If end of frame, ask for ACK */
  321.     else e = ZCRCG;  /* Else tell receiver to expect more data packets */
  322.  
  323.     zsdata(v,c,e);  /* Send the packet */
  324.  
  325.     /* Update terminal program status display */
  326.     v->xpru.xpru_updatemask = XPRU_BLOCKS | XPRU_BLOCKSIZE | XPRU_BYTES |
  327.                               XPRU_EXPECTTIME | XPRU_ELAPSEDTIME | XPRU_DATARATE;
  328.     ++v->xpru.xpru_blocks;
  329.     v->xpru.xpru_blocksize = c;
  330.     v->xpru.xpru_bytes = v->Txpos += c;
  331.     update_rate(v);
  332.     calla(v->io.xpr_update,&v->xpru);
  333.  
  334.     /* If we've been sending smaller than normal packets, see if it's
  335.        time to bump the packet size up a notch yet */
  336.     if (blklen < maxblklen && (goodbytes += c) >= goodneeded) {
  337.       blklen <<= 1;
  338.       if (blklen > maxblklen) blklen = maxblklen;
  339.       goodbytes = 0;
  340. #ifdef DEBUG
  341.       sprintf(v->Msgbuf,"Bumping packet size to %d at %ld\n",blklen,v->Txpos);
  342.       dlog(v,v->Msgbuf);
  343. #endif
  344.     }
  345.  
  346.     /* Give terminal program its timeslice if it needs one */
  347.     if (v->io.xpr_chkmisc) (*v->io.xpr_chkmisc)();
  348.     /* Check for abort from terminal program */
  349.     if (v->io.xpr_chkabort && (*v->io.xpr_chkabort)()) goto aborted;
  350.     /* If this was last packet in frame, go wait for ACK from receiver */
  351.     if (e == ZCRCW) goto waitack;
  352.  
  353.     /* Check if receiver trying to interrupt us; look for incoming packet
  354.        while discarding line noise */
  355.     while (char_avail(v)) {
  356.       switch (readock(v,1)) {
  357.         case CAN:
  358.         case RCDO:
  359.         case ZPAD:
  360.           /* Interruption detected; stop sending and process complaint */
  361. #ifdef DEBUG
  362.           dlog(v,"--- Interrupted send\n");
  363. #endif
  364.           zsdata(v,0,ZCRCE);
  365.           goto waitack;
  366.       }
  367.     }
  368.   } while (e == ZCRCG);  /* If no interruption, keep sending data packets */
  369.  
  370.   /* Done sending file data; send EOF and wait for receiver to acknowledge */
  371.   while (TRUE) {
  372.     updmsg(v,"Sending EOF");
  373.     stohdr(v,v->Txpos);
  374.     zsbhdr(v,ZEOF);
  375.     switch (c = getinsync(v)) {
  376.       case ZACK:
  377.         continue;
  378.       case ZRPOS:
  379.         goto somemore;
  380.       case ZRINIT:
  381.         updmsg(v,"EOF acknowledged");
  382.         return OK;
  383.       case ZSKIP:
  384.         return c;
  385.       default:
  386. aborted: upderr(v,"Transfer cancelled");
  387.         bfclose(v);
  388.         return ERROR;
  389.     }
  390.   }
  391. }
  392.  
  393.  
  394. /* Respond to receiver's complaint, get back in sync with receiver */
  395. short getinsync(v)
  396. register struct Vars *v;
  397. {
  398.   register short c;
  399.  
  400.   while (TRUE) {
  401. #ifdef DEBUG
  402.     dlog(v,"--- At getinsync\n");
  403. #endif
  404.     c = zgethdr(v);
  405.     /* WARNING: comment out following line if using VLT 4.058 */
  406.     if (v->io.xpr_sflush) (*v->io.xpr_sflush)();
  407.     switch (c) {
  408.       case ZCAN:
  409.       case ZABORT:
  410.       case ZFIN:
  411.       case RCDO:
  412.       case TIMEOUT:
  413.         return ERROR;
  414.       case ZRPOS:
  415.         bfseek(v,v->Rxpos);
  416.         v->Txpos = v->Rxpos;
  417.         sprintf(v->Msgbuf,"Error reported; resending from byte %ld",v->Txpos);
  418.         upderr(v,v->Msgbuf);
  419.         return c;
  420.       case ZSKIP:
  421.         upderr(v,"SKIP command received");
  422.         /* fallthrough... */
  423.       case ZRINIT:
  424.         bfclose(v);
  425.         /* fallthrough... */
  426.       case ZACK:
  427.         return c;
  428.       default:
  429.         zsbhdr(v,ZNAK);
  430.         continue;
  431.     }
  432.   }
  433. }
  434.  
  435.  
  436. /* End of batch transmission; disengage cleanly from receiver */
  437. void saybibi(v)
  438. register struct Vars *v;
  439. {
  440.   while (TRUE) {
  441.     stohdr(v,0L);
  442.     zsbhdr(v,ZFIN);
  443.     switch (zgethdr(v)) {
  444.       case ZFIN:
  445.         sendline(v,'O');
  446.         sendline(v,'O');
  447.         /* fallthrough... */
  448.       case ZCAN:
  449.       case RCDO:
  450.       case TIMEOUT:
  451.         return;
  452.     }
  453.   }
  454. }
  455.