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

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

通讯/手机编程

开发平台：

C/C++

ZRECEIVE.C：源码内容
  1. /*--------------------------------------------------------------------------*/
  2. /* FILE: zreceive.c (Opus zmodem receiver)                                  */
  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. /*--------------------------------------------------------------------------*/
  43. #include "zmodem.h"
  46. /*--------------------------------------------------------------------------*/
  47. /* External material                                                        */
  48. /*--------------------------------------------------------------------------*/
  49. extern int  dexists(byte *);
  53. /*--------------------------------------------------------------------------*/
  54. /* Local routines                                                           */
  55. /*--------------------------------------------------------------------------*/
  56. int cdecl get_Zmodem(byte *,FILE *);
  58. static int  pascal RZ_ReceiveData(byte *,int );
  59. static int  pascal RZ_InitReceiver(void);
  60. static int  pascal RZ_ReceiveBatch(FILE *);
  61. static int  pascal RZ_ReceiveFile(FILE *);
  62. static int  pascal RZ_GetHeader(void);
  63. static int  pascal RZ_SaveToDisk(unsigned long *);
  64. static void pascal RZ_AckBibi(void);
  67. /*--------------------------------------------------------------------------*/
  68. /* Private declarations                                                     */
  69. /*--------------------------------------------------------------------------*/
  70. static long DiskAvail;
  73. /*--------------------------------------------------------------------------*/
  74. /* Private data                                                             */
  75. /*--------------------------------------------------------------------------*/
  77. /* Parameters for ZSINIT frame */
  78. #define ZATTNLEN 32              /* Max length of attention string          */
  80. static char  Attn[ZATTNLEN+1];   /* String rx sends to tx on err            */
  81. static FILE *Outfile;            /* Handle of file being received           */
  82. static byte *Secbuf;             /* Pointer to receive buffer               */
  83. static int   Tryzhdrtype;        /* Hdr type to send for Last rx close      */
  84. static char  isBinary;           /* Current file is binary mode             */
  85. static char  EOFseen;            /* indicates cpm eof (^Z) was received     */
  86. static char  Zconv;              /* ZMODEM file conversion request          */
  87. static int   RxCount;            /* Count of data bytes received            */
  92. /*--------------------------------------------------------------------------*/
  93. /* GET ZMODEM                                                               */
  94. /* Receive a batch of files.                                                */
  95. /* returns TRUE (1) for good xfer, FALSE (0) for bad                        */
  96. /* can be called from f_upload or to get mail from a WaZOO Opus             */
  97. /*--------------------------------------------------------------------------*/
  98. int cdecl get_Zmodem(rcvpath, xferinfo)
  99.    byte *rcvpath;
  100.    FILE *xferinfo;
  101.    begin
  102.       byte        namebuf[PATHLEN];
  103.       int         i;
  105.       errno = 0;
  107.       _BRK_DISABLE();
  108.       XON_ENABLE();
  109.       n_disable();
  111.       Secbuf      = NULL;
  112.       Outfile     = NULL;
  113.       z_size      = 0;
  115.       DiskAvail   = freespace(toupper(sys.uppath[0])-'@');
  117.       Rxtimeout   = 10;
  118.       Tryzhdrtype = ZRINIT;
  119.       Secbuf      = zalloc();
  121.       strcpy(namebuf, rcvpath);
  122.       Filename = namebuf;
  124.       if (((i=RZ_InitReceiver())==ZCOMPL) or
  125.           ((i==ZFILE) and ((RZ_ReceiveBatch(xferinfo))==OK)) )
  126.          begin
  127.             free(Secbuf);
  128.             return 1;
  129.          end
  131.       CLEAR_OUTBOUND();
  132.       send_can();          /* transmit at least 10 cans */
  133.       wait_for_clear();
  135.       if (Secbuf)    free(Secbuf);
  136.       if (Outfile)   fclose(Outfile);
  137.       return 0;
  139.    end /* get_Zmodem */
  145. /*--------------------------------------------------------------------------*/
  146. /* RZ RECEIVE DATA                                                          */
  147. /* Receive array buf of max length with ending ZDLE sequence                */
  148. /* and CRC.  Returns the ending character or error code.                    */
  149. /*--------------------------------------------------------------------------*/
  150. static int pascal RZ_ReceiveData(buf, length)
  151.    byte *buf;
  152.    int length;
  153.    begin
  154.       register int   c;
  155.       register word  crc;
  156.       int            d;
  158.       crc   = RxCount   = 0;
  159.       while(1)
  160.          begin
  161.             if ((c = Z_GetZDL()) & ~0xFF)
  162.                begin
  163. CRCfoo:
  164.                   switch (c)
  165.                      begin
  166.                         case GOTCRCE:
  167.                         case GOTCRCG:
  168.                         case GOTCRCQ:
  169.                         case GOTCRCW:  /*-----------------------------------*/
  170.                                        /* C R C s                           */
  171.                                        /*-----------------------------------*/
  172.                                        crc = Z_UpdateCRC(((d=c)&0xFF), crc);
  173.                                        if ((c=Z_GetZDL()) & ~0xFF) goto CRCfoo;
  175.                                        crc = Z_UpdateCRC(c, crc);
  176.                                        if ((c=Z_GetZDL()) & ~0xFF) goto CRCfoo;
  178.                                        crc = Z_UpdateCRC(c, crc);
  179.                                        if (crc & 0xFFFF)
  180.                                           begin
  181.                                              z_message( CRC_msg );
  182.                                              return ERROR;
  183.                                           end
  184.                                        return d;
  186.                         case GOTCAN:   /*-----------------------------------*/
  187.                                        /* Cancel                            */
  188.                                        /*-----------------------------------*/
  189.                                        z_log(Cancelled_msg);
  190.                                        return ZCAN;
  192.                         case TIMEOUT:  /*-----------------------------------*/
  193.                                        /* Timeout                           */
  194.                                        /*-----------------------------------*/
  195.                                        z_message( TIME_msg );
  196.                                        return c;
  198.                         case RCDO:     /*-----------------------------------*/
  199.                                        /* No carrier                        */
  200.                                        /*-----------------------------------*/
  201.                                        z_log( CARRIER_msg );
  202.                                        return c;
  204.                         default:       /*-----------------------------------*/
  205.                                        /* Something bizarre                 */
  206.                                        /*-----------------------------------*/
  207.                                        z_message("Debris");
  208.                                        return c;
  209.                      end /* switch */
  210.                end /* if */
  212.             if (--length < 0)
  213.                begin
  214.                   z_message("Long pkt");
  215.                   return ERROR;
  216.                end
  218.             ++RxCount;
  219.             *buf++ = c;
  220.             crc = Z_UpdateCRC(c, crc);
  221.             continue;
  222.          end /* while(1) */
  224.    end /* RZ_ReceiveData */
  232. /*--------------------------------------------------------------------------*/
  233. /* RZ INIT RECEIVER                                                         */
  234. /* Initialize for Zmodem receive attempt, try to activate Zmodem sender     */
  235. /* Handles ZSINIT, ZFREECNT, and ZCOMMAND frames                            */
  236. /*                                                                          */
  237. /* Return codes:                                                            */
  238. /*    ZFILE .... Zmodem filename received                                   */
  239. /*    ZCOMPL ... transaction finished                                       */
  240. /*    ERROR .... any other condition                                        */
  241. /*--------------------------------------------------------------------------*/
  242. static int pascal RZ_InitReceiver()
  243.    begin
  244.       register int   n;
  245.       int            errors = 0;
  248.       for (n=10; --n>=0; )
  249.          begin
  251.             /*--------------------------------------------------------------*/
  252.             /* Set buffer length (0=unlimited, don't wait).                 */
  253.             /* Also set capability flags                                    */
  254.             /*--------------------------------------------------------------*/
  255.             Z_PutLongIntoHeader(0L);
  256.             Txhdr[ZF0] = CANFDX|CANOVIO;
  257.             Z_SendHexHeader(Tryzhdrtype, Txhdr);
  259. AGAIN:
  261.             switch (Z_GetHeader(Rxhdr))
  262.                begin
  263.                   case ZFILE:    /*-----------------------------------------*/
  264.                                  /*                                         */
  265.                                  /*-----------------------------------------*/
  266.                                  Zconv = Rxhdr[ZF0];
  267.                                  Tryzhdrtype = ZRINIT;
  268.                                  if (RZ_ReceiveData(Secbuf,WAZOOMAX)==GOTCRCW)
  269.                                     return ZFILE;
  270.                                  Z_SendHexHeader(ZNAK, Txhdr);
  271.                                  goto AGAIN;
  273.                   case ZSINIT:   /*-----------------------------------------*/
  274.                                  /*                                         */
  275.                                  /*-----------------------------------------*/
  276.                                  if (RZ_ReceiveData(Attn, ZATTNLEN) == GOTCRCW)
  277.                                     Z_SendHexHeader(ZACK, Txhdr);
  278.                                  else Z_SendHexHeader(ZNAK, Txhdr);
  279.                                  goto AGAIN;
  281.                   case ZFREECNT: /*-----------------------------------------*/
  282.                                  /*                                         */
  283.                                  /*-----------------------------------------*/
  284.                                  Z_PutLongIntoHeader(DiskAvail);
  285.                                  Z_SendHexHeader(ZACK, Txhdr);
  286.                                  goto AGAIN;
  288.                   case ZCOMMAND: /*-----------------------------------------*/
  289.                                  /* Paranoia is good for you...             */
  290.                                  /* Ignore command from remote, but lie and */
  291.                                  /* say we did the command ok.              */
  292.                                  /*-----------------------------------------*/
  293.                                  if (RZ_ReceiveData(Secbuf,WAZOOMAX)==GOTCRCW)
  294.                                     begin
  295.                                        status_line("!Ignoring `%s'", Secbuf);
  296.                                        Z_PutLongIntoHeader(0L); 
  297.                                        do
  298.                                           begin
  299.                                              Z_SendHexHeader(ZCOMPL, Txhdr);
  300.                                           end
  301.                                        while (++errors<10 && Z_GetHeader(Rxhdr) != ZFIN);
  302.                                        RZ_AckBibi();
  303.                                        return ZCOMPL;
  304.                                     end
  305.                                  else Z_SendHexHeader(ZNAK, Txhdr);
  306.                                  goto AGAIN;
  308.                   case ZCOMPL:   /*-----------------------------------------*/
  309.                                  /*                                         */
  310.                                  /*-----------------------------------------*/
  311.                                  goto AGAIN;
  313.                   case ZFIN:     /*-----------------------------------------*/
  314.                                  /*                                         */
  315.                                  /*-----------------------------------------*/
  316.                                  RZ_AckBibi();
  317.                                  return ZCOMPL;
  319.                   case ZCAN:
  320.                   case RCDO:     /*-----------------------------------------*/
  321.                                  /*                                         */
  322.                                  /*-----------------------------------------*/
  323.                                  return ERROR;
  324.                end /* switch */
  326.          end /* for */
  328.       return ERROR;
  330.    end /* RZ_InitReceiver */
  335. /*--------------------------------------------------------------------------*/
  336. /* RZFILES                                                                  */
  337. /* Receive a batch of files using ZMODEM protocol                           */
  338. /*--------------------------------------------------------------------------*/
  339. static int pascal RZ_ReceiveBatch(xferinfo)
  340.    FILE *xferinfo;
  341.    begin
  342.       register int c;
  344.       set_xy("");
  345.       while(1)
  346.          begin
  347.             switch (c = RZ_ReceiveFile(xferinfo))
  348.                begin
  349.                   case ZEOF:
  350.                   case ZSKIP:
  351.                               switch (RZ_InitReceiver())
  352.                                  begin
  353.                                     case ZCOMPL:   return OK;
  354.                                     default:       return ERROR;
  355.                                     case ZFILE:    break;
  356.                                  end /* switch */
  357.                               break;
  359.                   default:
  360.                               fclose(Outfile);
  361.                               Outfile  = NULL;
  362.                               unlink(Filename);
  363.                               errno    = 0;
  364.                               return c;
  365.                end /* switch */
  367.          end /* while */
  369.    end /* RZ_ReceiveBatch */
  374. /*--------------------------------------------------------------------------*/
  375. /* RZ RECEIVE FILE                                                          */
  376. /* Receive one file; assumes file name frame is preloaded in Secbuf         */
  377. /*--------------------------------------------------------------------------*/
  378. static int pascal RZ_ReceiveFile(xferinfo)
  379.    FILE *xferinfo;
  380.    begin
  381.       register int   c;
  382.       int            n;
  383.       long           rxbytes;
  385.       EOFseen=FALSE;
  386.       if (RZ_GetHeader() == ERROR)  return (Tryzhdrtype = ZSKIP);
  388.       n        = 10;
  389.       rxbytes  = 0L;
  391.       while(1)
  392.          begin
  393.             Z_PutLongIntoHeader(rxbytes);
  394.             Z_SendHexHeader(ZRPOS, Txhdr);
  395. NxtHdr:
  396.             switch (c = Z_GetHeader(Rxhdr))
  397.                begin
  398.                   case ZDATA:    /*-----------------------------------------*/
  399.                                  /* Data Packet                             */
  400.                                  /*-----------------------------------------*/
  401.                                  if (Rxpos != rxbytes)
  402.                                     begin
  403.                                        if ( --n < 0) return ERROR;
  404.                                        z_message(NULL);
  405.                                        cprintf("Bad pos; %ld/%ld",rxbytes,Rxpos);
  406.                                        Z_PutString(Attn);
  407.                                        continue;
  408.                                     end
  409. MoreData:
  410.                                  switch (c = RZ_ReceiveData(Secbuf,WAZOOMAX))
  411.                                     begin
  412.                                        case ZCAN:
  413.                                        case RCDO:  /*-----------------------*/
  414.                                                    /* CAN or CARRIER        */
  415.                                                    /*-----------------------*/
  416.                                                    z_log(Cancelled_msg);
  417.                                                    return ERROR;
  419.                                        case ERROR: /*-----------------------*/
  420.                                                    /* CRC error             */
  421.                                                    /*-----------------------*/
  422.                                                    if (--n<0)
  423.                                                       begin
  424.                                                          z_log( FUBAR_msg );
  425.                                                          return ERROR;
  426.                                                       end
  427.                                                    show_loc(rxbytes,n);
  428.                                                    Z_PutString(Attn);
  429.                                                    continue;
  431.                                        case TIMEOUT: /*---------------------*/
  432.                                                    /*                       */
  433.                                                    /*-----------------------*/
  434.                                                    if (--n<0)
  435.                                                       begin
  436.                                                          z_log( TIME_msg );
  437.                                                          return ERROR;
  438.                                                       end
  439.                                                    show_loc(rxbytes,n);
  440.                                                    continue;
  442.                                        case GOTCRCW: /*---------------------*/
  443.                                                    /* End of frame          */
  444.                                                    /*-----------------------*/
  445.                                                    n = 10;
  446.                                                    if (RZ_SaveToDisk(&rxbytes)==ERROR)
  447.                                                       return ERROR;
  448.                                                    Z_PutLongIntoHeader(rxbytes);
  449.                                                    Z_SendHexHeader(ZACK, Txhdr);
  450.                                                    goto NxtHdr;
  452.                                        case GOTCRCQ: /*---------------------*/
  453.                                                    /* Zack expected         */
  454.                                                    /*-----------------------*/
  455.                                                    n = 10;
  456.                                                    if (RZ_SaveToDisk(&rxbytes)==ERROR)
  457.                                                       return ERROR;
  458.                                                    Z_PutLongIntoHeader(rxbytes);
  459.                                                    Z_SendHexHeader(ZACK, Txhdr);
  460.                                                    goto MoreData;
  462.                                        case GOTCRCG: /*---------------------*/
  463.                                                    /* Non-stop              */
  464.                                                    /*-----------------------*/
  465.                                                    n = 10;
  466.                                                    if (RZ_SaveToDisk(&rxbytes)==ERROR)
  467.                                                       return ERROR;
  468.                                                    goto MoreData;
  470.                                        case GOTCRCE: /*---------------------*/
  471.                                                    /* Header to follow      */
  472.                                                    /*-----------------------*/
  473.                                                    n = 10;
  474.                                                    if (RZ_SaveToDisk(&rxbytes)==ERROR)
  475.                                                       return ERROR;
  476.                                                    goto NxtHdr;
  477.                                     end /* switch */
  479.                   case ZNAK:
  480.                   case TIMEOUT:  /*-----------------------------------------*/
  481.                                  /* Packed was probably garbled             */
  482.                                  /*-----------------------------------------*/
  483.                                  if ( --n < 0)
  484.                                     begin
  485.                                        z_log( "Garbled packet" );
  486.                                        return ERROR;
  487.                                     end
  488.                                  show_loc(rxbytes,n);
  489.                                  continue;
  491.                   case ZFILE:    /*-----------------------------------------*/
  492.                                  /* Sender didn't see our ZRPOS yet         */
  493.                                  /*-----------------------------------------*/
  494.                                  RZ_ReceiveData(Secbuf, WAZOOMAX);
  495.                                  continue;
  497.                   case ZEOF:     /*-----------------------------------------*/
  498.                                  /* End of the file                         */
  499.                                  /*-----------------------------------------*/
  500.                                  if (Rxpos != rxbytes)
  501.                                     begin
  502.                                        status_line("-Bad EOF; %ld/%ld", rxbytes, Rxpos);
  503.                                        continue;
  504.                                     end
  505.                                  throughput(2,rxbytes);
  506.                                  errno = 0;
  508.                                  fclose(Outfile);
  509.                                  had_error(CLOSE_msg,Filename);
  511.                                  status_line("=UL %s",Filename);
  513.                                  Outfile  = NULL;
  514.                                  if (xferinfo != NULL)
  515.                                     begin
  516.                                        fprintf(xferinfo, "%sn", Filename);
  517.                                        had_error(WRITE_msg,"XferInfo");
  518.                                     end
  519.                                  return c;
  521.                   case ERROR:    /*-----------------------------------------*/
  522.                                  /* Too much garbage in header search error */
  523.                                  /*-----------------------------------------*/
  524.                                  if ( --n < 0) return ERROR;
  525.                                  show_loc(rxbytes,n);
  526.                                  Z_PutString(Attn);
  527.                                  continue;
  529.                   default:       /*-----------------------------------------*/
  530.                                  /*                                         */
  531.                                  /*-----------------------------------------*/
  532.                                  z_log( IDUNNO_msg );
  533.                                  return ERROR;
  535.                end /* switch */
  537.          end /* while */
  539.    end /* RZ_ReceiveFile */
  545. /*--------------------------------------------------------------------------*/
  546. /* RZ GET HEADER                                                            */
  547. /* Process incoming file information header                                 */
  548. /*--------------------------------------------------------------------------*/
  549. static int pascal RZ_GetHeader()
  550.    begin
  552.       static char    suffix[] = ".001";
  554.       register byte *p;
  555.       register int   n;
  557.       byte          *ourname;
  558.       byte          *theirname;
  559.       unsigned long  filesize;
  562.       /*--------------------------------------------------------------------*/
  563.       /* Setup the transfer mode                                            */
  564.       /*--------------------------------------------------------------------*/
  565.       isBinary  = (!RXBINARY && Zconv == ZCNL)? 0 : 1;
  568.       /*--------------------------------------------------------------------*/
  569.       /* Extract and verify filesize, if given.                             */
  570.       /* Reject file if not at least 10K free                               */
  571.       /*--------------------------------------------------------------------*/
  572.       filesize = 0L;
  573.       p        = Secbuf + 1 + strlen(Secbuf);
  574.       if (*p) sscanf(p, "%ld", &filesize);
  575.       if (filesize+10240 > DiskAvail)
  576.          begin
  577.             status_line("!Disk space");
  578.             return ERROR;
  579.          end
  581.       /*--------------------------------------------------------------------*/
  582.       /* Get and/or fix filename for uploaded file                          */
  583.       /*--------------------------------------------------------------------*/
  584.       p  = Filename+strlen(Filename)-1;     /* Find end of Opus upload path */
  585.       while (p>=Filename && *p!='\') p--;
  586.       ourname = ++p;
  588.       p = Secbuf+strlen(Secbuf)-1;      /* Find transmitted simple filename */
  589.       while (p >= Secbuf && *p!='\' && *p!='/' && *p!=':') p--;
  590.       theirname = ++p;
  593.       strcpy(ourname,theirname);          /* Start w/ our path & their name */
  595.       if (dexists(Filename))
  596.          begin                            /* If file already exists...      */
  597.             p = ourname;
  598.             while (*p && *p!='.') p++;    /* ...find the extension, if any  */
  599.             for (n=0; n<4; n++)           /* ...fill it out if neccessary   */
  600.                if (!*p)
  601.                   begin
  602.                      *p       = suffix[n];
  603.                      *(++p)   = '';
  604.                   end
  605.                else p++;
  607.             while (dexists(Filename))    /* ...If 'file.ext' exists suffix++ */
  608.                begin
  609.                   p = ourname+strlen(ourname)-1;
  610.                   for (n=3; n--;)
  611.                      begin
  612.                         if (!isdigit(*p)) *p = '0';
  613.                         if (++(*p) <= '9') break;
  614.                         else *p-- = '0';
  615.                      end /* for */
  616.                end /* while */
  617.          end /* if exist */
  620.       errno = 0;
  621.       if (strcmp(ourname,theirname))
  622.          status_line("+Dupe renamed: %s",ourname);
  623.    
  624.       errno = 0;
  625.       Outfile = fopen( Filename, write_binary );
  626.       if (had_error(OPEN_msg,Filename)) return ERROR;
  628.     set_xy(NULL);
  629.       cprintf("Z-Recv %s, %s%ldb, %d min.",
  630.                   Filename,
  631.                   (isBinary)? "": "ASCII ",
  632.                   filesize,
  633.                   (int)(filesize*10/cur_baud+27)/54);
  635.       set_xy(NULL);
  637.       throughput(0,0L);
  639.       return OK;
  641.    end /* RZ_GetHeader */
  647. /*--------------------------------------------------------------------------*/
  648. /* RZ SAVE TO DISK                                                          */
  649. /* Writes the received file data to the output file.                        */
  650. /* If in ASCII mode, stops writing at first ^Z, and converts all            */
  651. /*   solo CR's or LF's to CR/LF pairs.                                      */
  652. /*--------------------------------------------------------------------------*/
  653. static int pascal RZ_SaveToDisk(rxbytes)
  654.    unsigned long *rxbytes;
  655.    begin
  656.       static byte    lastsent;
  658.       register byte *p;
  659.       register int   count;
  661.       count = RxCount;
  663.       if (((KEYPRESS()) and (READKB()==27)))
  664.          begin
  665.             send_can();
  666.             z_log( KBD_msg );
  667.             return ERROR;
  668.          end
  670.       if (count!=z_size)
  671.          begin
  672.             gotoxy( locate_x+10, locate_y );
  673.             cputs( ultoa(((unsigned long )(z_size=count)),e_input,10) );
  674.             putch(' ');
  675.          end
  677.       errno = 0;
  679.       if (isBinary)
  680.          begin
  681.             fwrite( Secbuf, count, 1, Outfile );
  682.             if (errno) goto oops;
  683.          end
  684.       else
  685.          begin
  686.             if (EOFseen) return OK;
  687.             for (p=Secbuf; --count>=0; ++p )
  688.                begin
  689.                   if ( *p == CPMEOF)
  690.                      begin
  691.                         EOFseen = TRUE;
  692.                         return OK;
  693.                      end
  694.                   if ( *p=='n' ) {
  695.                      if (lastsent!='r' && putc('r', Outfile) == EOF)
  696.                         goto oops;
  697.                   } else {
  698.                      if (lastsent=='r' && putc('n', Outfile) == EOF)
  699.                         goto oops;
  700.                   }
  701.                   if (putc((lastsent=*p), Outfile) == EOF)  goto oops;
  702.                end
  703.          end
  705.       *rxbytes += RxCount;
  706.       
  707.       gotoxy( locate_x, locate_y );
  708.       cputs( ultoa(((unsigned long )(*rxbytes)),e_input,10) );
  709.       return OK; 
  711. oops:
  712.       had_error(WRITE_msg,Filename);
  713.       return ERROR;
  715.    end /* RZ_SaveToDisk */
  719. /*--------------------------------------------------------------------------*/
  720. /* RZ ACK BIBI                                                              */
  721. /* Ack a ZFIN packet, let byegones be byegones                              */
  722. /*--------------------------------------------------------------------------*/
  723. static void pascal RZ_AckBibi()
  724.    begin
  725.       register int n;
  727.       Z_PutLongIntoHeader(0L);
  728.       for (n=4; --n;)
  729.          begin
  730.             Z_SendHexHeader(ZFIN, Txhdr);
  731.             switch (Z_GetByte(100))
  732.                begin
  733.                   case 'O':      Z_GetByte(1);    /* Discard 2nd 'O' */
  735.                   case TIMEOUT:
  736.                   case RCDO:     return;
  737.                end /* switch */
  738.          end /* for */
  740.    end /* RZ_AckBibi */