开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 查看源码
ZSEND.C
资源名称：zmodem.zip　[点击查看]
上传用户：haiyue
上传日期：2007-01-05
资源大小：21k
文件大小：34k
源码类别：

通讯/手机编程

开发平台：

C/C++

ZSEND.C：源码内容
  1. /*--------------------------------------------------------------------------*/
  2. /* FILE: zsend.c    (Opus zmodem transmitter)                               */
  3. /*                                                                          */
  4. /*                                                                          */
  5. /*               The Opus Computer-Based Conversation System                */
  6. /*       (c) Copyright 1986, Wynn Wagner III, All Rights Reserved           */
  7. /*                                                                          */
  8. /*      This implementation of Chuck Forsberg's ZMODEM protocol was         */
  9. /*              for Opus by Rick Huebner and Wynn Wagner III                */
  10. /*                                                                          */
  11. /* (MSC/4 with /Zp /Ox)                                                     */
  12. /*                                                                          */
  13. /*                                                                          */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*  This module is similar to a routine used by Opus-Cbcs (1.00).  It is    */
  17. /*  provided for your information only.  You will find routines that need   */
  18. /*  to be coded and identifiers to be resolved.                             */
  19. /*                                                                          */
  20. /*  There is absolutely no guarantee that anything here will work.  If you  */
  21. /*  break this routine, you own both pieces.                                */
  22. /*                                                                          */
  23. /*  USAGE:  You may use this material in any program with no obligation     */
  24. /*          as long as there is no charge for your program.  For more       */
  25. /*          information about commercial use, contact the "OPUSinfo HERE"   */
  26. /*          BBS (124/111).                                                  */
  27. /*                                                                          */
  28. /*  NOTE:   There are a couple of things the Opus implementation does that  */
  29. /*          aren't part of the original ZModem protocol.  They all deal     */
  30. /*          with WaZOO type ("ZedZap") netmail and should only show up when */
  31. /*          used under that condition.                                      */
  32. /*                                                                          */
  33. /*             * The maximum packet size can grow larger than 1k.  It is    */
  34. /*               sensitive to the baud rate.  (2400b=2048k; 9600b=8192k)    */
  35. /*             * The sender must be able to send nothing.  In other words,  */
  36. /*               the sending system must be able to initiate and terminate  */
  37. /*               a zmodem send session without having to actually send a    */
  38. /*               file.  Normally this kind of thing would never happen in   */
  39. /*               zmodem.                                                    */
  40. /*                                                                          */
  41. /*                                                                          */
  42. /*--------------------------------------------------------------------------*/
  44. #include "zmodem.h"
  47. /*--------------------------------------------------------------------------*/
  48. /* Global routines                                                          */
  49. /*--------------------------------------------------------------------------*/
  50. int cdecl send_Zmodem(byte *,byte *,int,int,int);
  53. /*--------------------------------------------------------------------------*/
  54. /* Private routines                                                         */
  55. /*--------------------------------------------------------------------------*/
  56. static void pascal ZS_SendBinaryHeader(unsigned short ,byte *);
  57. static void pascal ZS_SendData(byte *,int,unsigned short);
  58. static void pascal ZS_SendByte(byte);
  59. static int  pascal ZS_GetReceiverInfo(void);
  60. static int  pascal ZS_SendFile(int,int);
  61. static int  pascal ZS_SendFileData(int);
  62. static int  pascal ZS_SyncWithReceiver(void);
  63. static void pascal ZS_EndSend(void);
  67. /*--------------------------------------------------------------------------*/
  68. /* Private data                                                             */
  69. /*--------------------------------------------------------------------------*/
  70. static FILE *Infile;             /* Handle of file being sent               */
  71. static byte *Txbuf;              /* Pointer to transmit buffer              */
  72. static long  Strtpos;            /* Starting byte position of download      */
  73. static long  Txpos;              /* Transmitted file position               */
  74. static int Rxbuflen;             /* Receiver's max buffer length            */
  77. /*--------------------------------------------------------------------------*/
  78. /* External data not otherwise declared                                     */
  79. /*--------------------------------------------------------------------------*/
  80. extern char *FLAGGING_msg;
  81. extern char *NOTSENT_msg;
  82. extern char *TRUNC_msg;
  83. extern char *KBD_msg;
  90. /*--------------------------------------------------------------------------*/
  91. /* SEND ZMODEM (send a file)                                                */
  92. /*   returns TRUE (1) for good xfer, FALSE (0) for bad                      */
  93. /*   sends one file per call; 'fsent' flags start and end of batch          */
  94. /*--------------------------------------------------------------------------*/
  95. int cdecl send_Zmodem(fname,alias,doafter,fsent,wazoo)
  96.    byte  *fname;
  97.    byte  *alias;
  98.    int   doafter;
  99.    int   fsent;
  100.    int   wazoo;
  101.    begin
  102.       register byte *p;
  103.       register byte *q;
  104.       struct stat    f;
  106.       int   i;
  107.       int   rc;
  110.       _BRK_DISABLE();
  111.       XON_ENABLE();
  113.       errno    =
  114.       z_size   = 0;
  115.       Infile   = NULL;
  116.       Txbuf    = NULL;
  120.       if (fname) set_xy("");
  122.       switch(fsent)
  123.          begin
  124.             case 0:
  125.             case NOTHING_TO_DO:  n_disable();
  126.                                  if (!wazoo)
  127.                                     begin
  128.                                        Z_PutString("rzr");
  129.                                        Z_PutLongIntoHeader(0L);
  130.                                        Z_SendHexHeader(ZRQINIT, Txhdr);
  131.                                     end
  132.                                  Rxtimeout   = 20;
  133.                                  if (ZS_GetReceiverInfo() == ERROR) return FALSE;
  134.          end
  137.       Rxtimeout   = (int )(614400L/(long )cur_baud);
  138.       Rxtimeout  /= 10;
  140.       if (Rxtimeout < 10) Rxtimeout = 10;
  141.       if (Rxtimeout > 58) Rxtimeout = 58;
  144.       if (fname == NULL) goto Done;
  146.       /*--------------------------------------------------------------------*/
  147.       /* Prepare the file for transmission.  Just ignore file open errors   */
  148.       /* because there may be other files that can be sent.                 */
  149.       /*--------------------------------------------------------------------*/
  150.       Filename = fname;
  151.       CLEAR_IOERR();
  152.       Infile   = fopen(Filename,read_binary);
  153.       if (had_error(OPEN_msg,Filename)) return OK;
  154.       
  155.       Txbuf    = zalloc();
  157.       /*--------------------------------------------------------------------*/
  158.       /* Send the file                                                      */
  159.       /*--------------------------------------------------------------------*/
  160.       rc       = TRUE;
  163.       /*--------------------------------------------------------------------*/
  164.       /* Display outbound filename, size, and ETA for sysop                 */
  165.       /*--------------------------------------------------------------------*/
  166.       fstat(fileno(Infile), &f);
  168.       message(NULL);
  169.       cprintf( "Z-Send %s, %ldb",Filename,f.st_size);
  171.       i  = (int)(f.st_size*10/cur_baud+27)/54;
  172.       if (i) cprintf(", %d min.",i);
  174.       set_xy(NULL);
  176.       /*--------------------------------------------------------------------*/
  177.       /* Get outgoing file name; no directory path, lower case              */
  178.       /*--------------------------------------------------------------------*/
  179.       for (p=(alias!=NULL)?alias:Filename, q=Txbuf ; *p; )
  180.          begin
  181.             if ((*q++ = tolower(*p)) == '\') q = Txbuf;
  182.             p++;
  183.          end
  185.       *q++  = '';
  186.       p     = q;
  188.       /*--------------------------------------------------------------------*/
  189.       /* Zero out remainder of file header packet                           */
  190.       /*--------------------------------------------------------------------*/
  191.       while (q < (Txbuf + KSIZE)) *q++ = '';
  193.       /*--------------------------------------------------------------------*/
  194.       /* Store filesize, time last modified, and file mode in header packet */
  195.       /*--------------------------------------------------------------------*/
  196.       sprintf(p, "%lu %lo %o", f.st_size, f.st_mtime, f.st_mode);
  198.       /*--------------------------------------------------------------------*/
  199.       /* Transmit the filename block and begin the download                 */
  200.       /*--------------------------------------------------------------------*/
  201.       throughput(0,0L);
  204.       /*--------------------------------------------------------------------*/
  205.       /* Check the results                                                  */
  206.       /*--------------------------------------------------------------------*/
  207.       switch( ZS_SendFile(1+strlen(p)+(p-Txbuf), wazoo) )
  208.          begin
  210.             case ERROR: /*--------------------------------------------------*/
  211.                         /* Something tragic happened                        */
  212.                         /*--------------------------------------------------*/
  213.                         if (wazoo)
  214.                            begin
  215.                               status_line( NOTSENT_msg );
  216.                               mdm_hangup();
  217.                            end
  218.                         goto Err_Out;
  221.             case OK:    /*--------------------------------------------------*/
  222.                         /* File was sent                                    */
  223.                         /*--------------------------------------------------*/
  224.                         CLEAR_IOERR();
  225.                         fclose(Infile);
  226.                         had_error(CLOSE_msg,Filename);
  227.                         Infile   = NULL;
  229.                         status_line( "=DL %s", Filename );
  231.                         /*--------------------------------------------------*/
  232.                         /* Special WaZOO file handling following a          */
  233.                         /* successful transmission.                         */
  234.                         /*--------------------------------------------------*/
  235.                         switch(doafter)
  236.                            begin
  237.                               case DELETE_AFTER:   /*-----------------------*/
  238.                                                    /* Delete File           */
  239.                                                    /*-----------------------*/
  240.                                                    CLEAR_IOERR();
  241.                                                    unlink(Filename);
  242.                                                    had_error(UNLINK_msg,Filename);
  243.                                                    break;
  244.    
  245.                               case TRUNC_AFTER:    /*-----------------------*/
  246.                                                    /* Truncate File         */
  247.                                                    /*-----------------------*/
  248.                                                    CLEAR_IOERR();
  249.                                                    i = open(Filename,O_TRUNC,S_IWRITE);
  250.                                                    had_error( TRUNC_msg, Filename );
  251.                                                    status_line(FLAGGING_msg,Filename);
  252.                                                    close(i);
  253.                                                    break;
  254.                            end /* switch */
  257.             default:    /*--------------------------------------------------*/
  258.                         /* Probably a ZSKIP                                 */
  259.                         /*--------------------------------------------------*/
  260.                         goto Done;
  262.          end /* switch */
  264. Err_Out:
  265.       rc = FALSE;
  267. Done:
  268.       if (Infile) fclose(Infile);
  269.       if (Txbuf)  free(Txbuf);
  271.       if (fsent < 0) ZS_EndSend();
  273.       return rc;
  275.    end /* send_Zmodem */
  282. /*--------------------------------------------------------------------------*/
  283. /* ZS SEND BINARY HEADER                                                    */
  284. /* Send ZMODEM binary header hdr of type type                               */
  285. /*--------------------------------------------------------------------------*/
  286. static void pascal ZS_SendBinaryHeader(type, hdr)
  287.    unsigned short type;
  288.    byte          *hdr;
  289.    begin
  290.       register byte          *hptr;
  291.       register unsigned short crc;
  292.       int                     n;
  294.       SENDBYTE(ZPAD);
  295.       SENDBYTE(ZDLE);
  297.       SENDBYTE(ZBIN);
  298.       ZS_SendByte(type);
  300.       crc = Z_UpdateCRC(type, 0);
  302.       hptr  = hdr;
  303.       for (n=4; --n >= 0;)
  304.          begin
  305.             ZS_SendByte(*hptr);
  306.             crc = Z_UpdateCRC(((unsigned short)(*hptr++)), crc);
  307.          end
  309.       crc = Z_UpdateCRC(0,crc);
  310.       crc = Z_UpdateCRC(0,crc);
  312.       ZS_SendByte(crc>>8);
  313.       ZS_SendByte(crc);
  315.       if (type != ZDATA) wait_for_clear();
  317.    end /* ZS_SendBinaryHeader */
  323. /*--------------------------------------------------------------------------*/
  324. /* ZS SEND DATA                                                             */
  325. /* Send binary array buf with ending ZDLE sequence frameend                 */
  326. /*--------------------------------------------------------------------------*/
  327. static void pascal ZS_SendData(buf, length, frameend)
  328.    byte          *buf;
  329.    int            length;
  330.    unsigned short frameend;
  331.    begin
  333.       register unsigned short crc;
  334.       int                     t;
  336.       crc = 0;
  337.       for (;--length >= 0;)
  338.          begin
  339.             ZS_SendByte(*buf);
  340.             crc = Z_UpdateCRC(((unsigned short)(*buf++)), crc);
  341.          end
  343.       SENDBYTE(ZDLE);
  344.       SENDBYTE(frameend);
  345.       crc = Z_UpdateCRC(frameend, crc);
  347.       crc = Z_UpdateCRC(0,crc);
  348.       crc = Z_UpdateCRC(0,crc);
  349.       ZS_SendByte(crc>>8);
  350.       ZS_SendByte(crc);
  352.       if (frameend == ZCRCW)
  353.          begin
  354.             SENDBYTE(XON);
  355.             wait_for_clear();
  356.          end
  358.    end /* ZS_SendData */
  365. /*--------------------------------------------------------------------------*/
  366. /* ZS SEND BYTE                                                             */
  367. /* Send character c with ZMODEM escape sequence encoding.                   */
  368. /* Escape XON, XOFF. Escape CR following @ (Telenet net escape)             */
  369. /*--------------------------------------------------------------------------*/
  370. static void pascal ZS_SendByte(c)
  371.    register byte c;
  372.    begin
  373.       static byte lastsent;
  375.       switch (c)
  376.          begin
  377.             case 015:
  378.             case 0215:  /*--------------------------------------------------*/
  379.                         /*                                                  */
  380.                         /*--------------------------------------------------*/
  381.                         if ((lastsent & 0x7F) != '@') goto SendIt;
  382.             case 020:
  383.             case 021:
  384.             case 023:
  385.             case 0220:
  386.             case 0221:
  387.             case 0223:
  388.             case ZDLE:  /*--------------------------------------------------*/
  389.                         /* Quoted characters                                */
  390.                         /*--------------------------------------------------*/
  391.                         SENDBYTE(ZDLE);
  392.                         c ^= 0x40;
  394.             default:    /*--------------------------------------------------*/
  395.                         /* Normal character output                          */
  396. SendIt:                 /*--------------------------------------------------*/
  397.                         SENDBYTE(lastsent = c);
  399.          end /* switch */
  401.    end /* ZS_SendByte */
  408. /*--------------------------------------------------------------------------*/
  409. /* ZS GET RECEIVER INFO                                                     */
  410. /* Get the receiver's init parameters                                       */
  411. /*--------------------------------------------------------------------------*/
  412. static int pascal ZS_GetReceiverInfo()
  413.    begin
  414.       int   n;
  415.       int   rxflags;
  417.       for (n=10; --n>=0; )
  418.          begin
  420.             switch ( Z_GetHeader(Rxhdr) )
  421.                begin
  422.                   case ZCHALLENGE:  /*--------------------------------------*/
  423.                                     /* Echo receiver's challenge number     */
  424.                                     /*--------------------------------------*/
  425.                                     Z_PutLongIntoHeader(Rxpos);
  426.                                     Z_SendHexHeader(ZACK, Txhdr);
  427.                                     continue;
  429.                   case ZCOMMAND:    /*--------------------------------------*/
  430.                                     /* They didn't see our ZRQINIT          */
  431.                                     /*--------------------------------------*/
  432.                                     Z_PutLongIntoHeader(0L);
  433.                                     Z_SendHexHeader(ZRQINIT, Txhdr);
  434.                                     continue;
  436.                   case ZRINIT:      /*--------------------------------------*/
  437.                                     /*                                      */
  438.                                     /*--------------------------------------*/
  439.                                     Rxbuflen = ((word )Rxhdr[ZP1]<<8)|Rxhdr[ZP0];
  440.                                     return OK;
  442.                   case ZCAN:
  443.                   case RCDO:
  444.                   case TIMEOUT:     /*--------------------------------------*/
  445.                                     /*                                      */
  446.                                     /*--------------------------------------*/
  447.                                     return ERROR;
  449.                   case ZRQINIT:     /*--------------------------------------*/
  450.                                     /*                                      */
  451.                                     /*--------------------------------------*/
  452.                                     if (Rxhdr[ZF0] == ZCOMMAND) continue;
  454.                   default:          /*--------------------------------------*/
  455.                                     /*                                      */
  456.                                     /*--------------------------------------*/
  457.                                     Z_SendHexHeader(ZNAK, Txhdr);
  458.                                     continue;
  459.                end /* switch */
  461.          end /* for */
  463.       return ERROR;
  465.    end /* ZS_GetReceiverInfo */
  471. /*--------------------------------------------------------------------------*/
  472. /* ZS SEND FILE                                                             */
  473. /* Send ZFILE frame and begin sending ZDATA frame                           */
  474. /*--------------------------------------------------------------------------*/
  475. static int pascal ZS_SendFile(blen, wazoo)
  476.    int blen;
  477.    int wazoo;
  478.    begin
  479.       register int c;
  481.       while(1)
  483.          begin
  485.             if (((KEYPRESS()) and (READKB()==27)))
  486.                begin
  487.                   send_can();
  488.                   z_log( KBD_msg );
  489.                   return ERROR;
  490.                end
  491.             else if (!CARRIER) return ERROR;
  493.    
  494.             Txhdr[ZF0] = LZCONV;    /* Default file conversion mode */
  495.             Txhdr[ZF1] = LZMANAG;   /* Default file management mode */
  496.             Txhdr[ZF2] = LZTRANS;   /* Default file transport mode */
  497.             Txhdr[ZF3] = 0;
  498.             ZS_SendBinaryHeader(ZFILE, Txhdr);
  499.             ZS_SendData(Txbuf, blen, ZCRCW);
  500.    
  501. Again:
  502.             switch (c = Z_GetHeader(Rxhdr))
  503.                begin
  505.                   case ZRINIT:   /*-----------------------------------------*/
  506.                                  /*                                         */
  507.                                  /*-----------------------------------------*/
  508.                                  goto Again;
  510.                   case ZCAN:     
  511.                   case ZCRC:     
  512.                   case RCDO:     
  513.                   case TIMEOUT:  
  514.                   case ZFIN:
  515.                   case ZABORT:   
  516.                                  /*-----------------------------------------*/
  517.                                  /*                                         */
  518.                                  /*-----------------------------------------*/
  519.                                  return ERROR;
  520.    
  521.                   case ZSKIP:    /*-----------------------------------------*/
  522.                                  /* Other system wants to skip this file    */
  523.                                  /*-----------------------------------------*/
  524.                                  return c;
  525.    
  526.                   case ZRPOS:    /*-----------------------------------------*/
  527.                                  /* Resend from this position...            */
  528.                                  /*-----------------------------------------*/
  529.                                  fseek(Infile, Rxpos, SEEK_SET);
  530.                                  Strtpos = Txpos = Rxpos;
  531.                                  CLEAR_INBOUND();
  532.                                  return ZS_SendFileData(wazoo);
  533.                end /* switch */
  535.          end /* while */
  537.    end /* ZS_SendFile */
  542. /*--------------------------------------------------------------------------*/
  543. /* ZS SEND FILE DATA                                                        */
  544. /* Send the data in the file                                                */
  545. /*--------------------------------------------------------------------------*/
  546. static int pascal ZS_SendFileData(wazoo)
  547.    int wazoo;
  548.    begin
  550.       register int c, e;
  551.       word         newcnt, blklen, maxblklen, goodblks, goodneeded = 1;
  552.       byte        *p;
  555.       maxblklen = (cur_baud<300) ? 128 : cur_baud/300*256;
  557.       if (maxblklen>WAZOOMAX)              maxblklen = WAZOOMAX;
  558.       if (!wazoo && maxblklen>KSIZE)       maxblklen = KSIZE;
  559.       if (Rxbuflen && maxblklen>Rxbuflen)  maxblklen = Rxbuflen;
  560.       blklen = maxblklen;
  563. SomeMore:
  565.       if (CHAR_AVAIL())
  566.          begin
  567. WaitAck:
  569.             switch (c = ZS_SyncWithReceiver())
  570.                begin
  571.                   default:       /*-----------------------------------------*/
  572.                                  /*                                         */
  573.                                  /*-----------------------------------------*/
  574.                                  z_log(Cancelled_msg);
  575.                                  errno = 0;
  576.                                  fclose(Infile);
  577.                                  had_error(CLOSE_msg,Filename);
  578.                                  return ERROR;
  580.                   case ZSKIP:    /*-----------------------------------------*/
  581.                                  /* Skip this file                          */
  582.                                  /*-----------------------------------------*/
  583.                                  return c;
  585.                   case ZACK:     /*-----------------------------------------*/
  586.                                  /*                                         */
  587.                                  /*-----------------------------------------*/
  588.                                  break;
  590.                   case ZRPOS:    /*-----------------------------------------*/
  591.                                  /* Resume at this position                 */
  592.                                  /*-----------------------------------------*/
  593.                                  blklen = (blklen>>2 > 64) ? blklen>>2 : 64;
  594.                                  goodblks = 0;
  595.                                  goodneeded = (goodneeded<<1) | 1;
  596.                                  break;
  598.                   case ZRINIT:   /*-----------------------------------------*/
  599.                                  /* Receive init                            */
  600.                                  /*-----------------------------------------*/
  601.                                  throughput(1,Txpos-Strtpos);
  602.                                  return OK;
  603.                end /* switch */
  605.             while (CHAR_AVAIL())
  606.                begin
  607.                   switch (MODEM_IN())
  608.                      begin
  609.                         case CAN:
  610.                         case RCDO:
  611.                         case ZPAD:  goto WaitAck;
  612.                      end /* switch */
  613.                end /* while */
  615.          end /* while */
  617.       newcnt = Rxbuflen;
  618.       Z_PutLongIntoHeader(Txpos);
  619.       ZS_SendBinaryHeader(ZDATA, Txhdr);
  621.       do
  622.          begin
  624.             if (((KEYPRESS()) and (READKB()==27)))
  625.                begin
  626.                   send_can();
  627.                   z_log( KBD_msg );
  628.                   goto oops;
  629.                end
  631.             if (!CARRIER) goto oops;
  633.             if ((c=fread(Txbuf,1,blklen,Infile))!=z_size)
  634.                begin
  635.                   gotoxy( locate_x+10, locate_y );
  636.                   cputs( ultoa(((unsigned long )(z_size=c)),e_input,10) );
  637.                   putch(' ');
  638.                end
  640.             if (c < blklen) e = ZCRCE;
  641.             else if (Rxbuflen && (newcnt -= c) <= 0) e = ZCRCW;
  642.             else e = ZCRCG;
  644.             ZS_SendData(Txbuf, c, e);
  646.             gotoxy( locate_x, locate_y );
  647.             cputs( ultoa(((unsigned long )Txpos),e_input,10) );
  648.             putch(' ');
  650.             Txpos += c;
  651.             if (blklen<maxblklen && ++goodblks>goodneeded)
  652.                begin
  653.                   blklen = (blklen<<1 < maxblklen) ? blklen<<1 : maxblklen;
  654.                   goodblks = 0;
  655.                end
  657.             if (e == ZCRCW) goto WaitAck;
  659.             while (CHAR_AVAIL())
  660.                begin
  661.                   switch (MODEM_IN())
  662.                      begin
  663.                         case CAN:
  664.                         case RCDO:
  665.                         case ZPAD:  /*--------------------------------------*/
  666.                                     /* Interruption detected;               */
  667.                                     /* stop sending and process complaint   */
  668.                                     /*--------------------------------------*/
  669.                                     z_message("Trouble?");
  670.                                     CLEAR_OUTBOUND();
  671.                                     ZS_SendData(Txbuf, 0, ZCRCE);
  672.                                     goto WaitAck;
  673.                      end /* switch */
  674.                end /* while */
  675.       
  676.          end /* do */
  677.       while (e == ZCRCG);
  679.       while(1)
  680.          begin
  681.             Z_PutLongIntoHeader(Txpos);
  682.             ZS_SendBinaryHeader(ZEOF, Txhdr);
  684.             switch (ZS_SyncWithReceiver())
  685.                begin
  686.                   case ZACK:     /*-----------------------------------------*/
  687.                                  /*                                         */
  688.                                  /*-----------------------------------------*/
  689.                                  continue;
  691.                   case ZRPOS:    /*-----------------------------------------*/
  692.                                  /* Resume at this position...              */
  693.                                  /*-----------------------------------------*/
  694.                                  goto SomeMore;
  696.                   case ZRINIT:   /*-----------------------------------------*/
  697.                                  /* Receive init                            */
  698.                                  /*-----------------------------------------*/
  699.                                  throughput(1,Txpos-Strtpos);
  700.                                  return OK;
  702.                   case ZSKIP:    /*-----------------------------------------*/
  703.                                  /* Request to skip the current file        */
  704.                                  /*-----------------------------------------*/
  705.                                  z_log(Skip_msg);
  706.                                  CLEAR_IOERR();
  707.                                  fclose(Infile);
  708.                                  had_error(CLOSE_msg,Filename);
  709.                                  return c;
  711.                   default:       /*-----------------------------------------*/
  712.                                  /*                                         */
  713.                                  /*-----------------------------------------*/
  714. oops:                            z_log(Cancelled_msg);
  715.                                  errno = 0;
  716.                                  fclose(Infile);
  717.                                  had_error(CLOSE_msg,Filename);
  718.                                  return ERROR;
  719.                end /* switch */
  720.          end /* while */
  722.    end /* ZS_SendFileData */
  729. /*--------------------------------------------------------------------------*/
  730. /* ZS SYNC WITH RECEIVER                                                    */
  731. /* Respond to receiver's complaint, get back in sync with receiver          */
  732. /*--------------------------------------------------------------------------*/
  733. static int pascal ZS_SyncWithReceiver()
  734.    begin
  735.       register int c;
  736.       int          num_errs   = 7;
  738.       while(1)
  739.          begin
  740.             c = Z_GetHeader(Rxhdr);
  741.             CLEAR_INBOUND();
  742.             switch (c)
  743.                begin
  744.                   case TIMEOUT:  z_message( TIME_msg );
  745.                                  if ((num_errs--) >= 0) break;
  747.                   case ZCAN:
  748.                   case ZABORT:
  749.                   case ZFIN:
  750.                   case RCDO:
  751.                                  /*-----------------------------------------*/
  752.                                  /*                                         */
  753.                                  /*-----------------------------------------*/
  754.                                  z_log("Err");
  755.                                  return ERROR;
  757.                   case ZRPOS:    /*-----------------------------------------*/
  758.                                  /*                                         */
  759.                                  /*-----------------------------------------*/
  760.                                  rewind(Infile);   /* In case file EOF seen */
  761.                                  fseek(Infile, Rxpos, SEEK_SET);
  762.                                  Txpos = Rxpos;
  763.                                  z_message(NULL);
  764.                                  cputs("Resending from ");
  765.                                  cputs( ultoa(((unsigned long )(Txpos)),e_input,10) );
  766.                                  return c;
  768.                   case ZSKIP:    /*-----------------------------------------*/
  769.                                  /*                                         */
  770.                                  /*-----------------------------------------*/
  771.                                  z_log(Skip_msg);
  773.                   case ZRINIT:   /*-----------------------------------------*/
  774.                                  /*                                         */
  775.                                  /*-----------------------------------------*/
  776.                                  CLEAR_IOERR();
  777.                                  fclose(Infile);
  778.                                  had_error(CLOSE_msg,Filename);
  779.                                  return c;
  781.                   case ZACK:     /*-----------------------------------------*/
  782.                                  /*                                         */
  783.                                  /*-----------------------------------------*/
  784.                                  z_message( NULL );
  785.                                  return c;
  787.                   default:       /*-----------------------------------------*/
  788.                                  /*                                         */
  789.                                  /*-----------------------------------------*/
  790.                                  z_message( IDUNNO_msg );
  791.                                  ZS_SendBinaryHeader(ZNAK, Txhdr);
  792.                                  continue;
  793.                end /* switch */
  794.          end /* while */
  795.    end /* ZS_SyncWithReceiver */
  800. /*--------------------------------------------------------------------------*/
  801. /* ZS END SEND                                                              */
  802. /* Say BIBI to the receiver, try to do it cleanly                           */
  803. /*--------------------------------------------------------------------------*/
  804. static void pascal ZS_EndSend()
  805.    begin
  807.       while(1)
  808.          begin
  809.             Z_PutLongIntoHeader(0L);
  810.             ZS_SendBinaryHeader(ZFIN, Txhdr);
  812.             switch (Z_GetHeader(Rxhdr))
  813.                begin
  814.                   case ZFIN:     /*-----------------------------------------*/
  815.                                  /*                                         */
  816.                                  /*-----------------------------------------*/
  817.                                  SENDBYTE('O');
  818.                                  SENDBYTE('O');
  819.                                  wait_for_clear();
  820.                                  /* fallthrough... */
  821.                   case ZCAN:
  822.                   case RCDO:
  823.                   case TIMEOUT:  /*-----------------------------------------*/
  824.                                  /*                                         */
  825.                                  /*-----------------------------------------*/
  826.                                  return;
  827.                end /* switch */
  828.          end /* while */
  829.    end /* ZS_EndSend */
  832. /* END OF FILE: z_send.c */