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

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

通讯/手机编程

开发平台：

C/C++

ZMISC.C：源码内容
  1. /*--------------------------------------------------------------------------*/
  2. /* FILE: zmisc.c    (Opus zmodem routines used by send and receive)         */
  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"
  47. static int Rxtype;               /* Type of header received                 */
  48. static int Rxframeind;           /* ZBIN ZBIN32,ZHEX type of frame received */
  50. static char hex[] = "0123456789abcdef";
  52. /* Send a byte as two hex digits */
  53. #define Z_PUTHEX(i,c) {i=(c);SENDBYTE(hex[((i)&0xF0)>>4]);SENDBYTE(hex[(i)&0xF]);}
  57. /*--------------------------------------------------------------------------*/
  58. /* Routines used by other ZModem modules...                                 */
  59. /*--------------------------------------------------------------------------*/
  60. int  pascal Z_GetByte(int);
  61. void pascal Z_PutString(unsigned char *);
  62. void pascal Z_SendHexHeader(unsigned short,unsigned char *);
  63. int  pascal Z_GetHeader(unsigned char *);
  64. int  pascal Z_GetZDL(void);
  65. void pascal Z_PutLongIntoHeader(long);
  66. unsigned short pascal Z_UpdateCRC(unsigned short,unsigned short);
  69. /*--------------------------------------------------------------------------*/
  70. /* Private routines                                                         */
  71. /*--------------------------------------------------------------------------*/
  72. static int  pascal _Z_qk_read(void);
  73. static int  pascal _Z_GetBinaryHeader(unsigned char *);
  74. static int  pascal _Z_GetHexHeader(unsigned char *);
  75. static int  pascal _Z_GetHex(void);
  76. static int  pascal _Z_TimedRead(void);
  77. static long pascal _Z_PullLongFromHeader(unsigned char *);
  81. extern byte *local_CEOL;
  82. extern char *KBD_msg;
  85. void pascal z_message( s )
  86.    byte *s;
  87.    begin
  88.     gotoxy( locate_x+20, locate_y );
  89.       if (s) cputs(s);
  90.       cputs( local_CEOL );
  91.    end
  94. void z_log(s)
  95.    byte *s;
  96.    begin
  97.       word x, y;
  99.       z_message(s);
  101.       x  = locate_x;
  102.       y  = locate_y;
  103.       status_line(s); /* also does disk file logging */
  104.       locate_x = x;
  105.       locate_y = y;
  107.    end
  110. void show_loc(l,w)
  111.    unsigned long  l;
  112.    unsigned int   w;
  113.    begin
  114.       gotoxy( locate_x+35, locate_y );
  115.       cprintf("Ofs=%ld Retries=%d%s",l,w,local_CEOL);
  116.    end
  119. byte * pascal zalloc()
  120.    begin
  121.       byte *sptr;
  123.       sptr  = malloc(WAZOOMAX);
  124.       if (!sptr)
  125.          begin
  126.           status_line("!Z-MEMOVFL");
  127.             adios(2);
  128.          end
  129.       return sptr;
  130.    end
  138. /*--------------------------------------------------------------------------*/
  139. /* Z GET BYTE                                                               */
  140. /* Get a byte from the modem;                                               */
  141. /* return TIMEOUT if no read within timeout tenths,                         */
  142. /* return RCDO if carrier lost                                              */
  143. /*--------------------------------------------------------------------------*/
  144. int pascal Z_GetByte(tenths)
  145.    register int tenths;
  146.    begin
  147.       register int i;
  149.       i^=i;
  150.       do
  151.        begin
  152.             if (CHAR_AVAIL()) return MODEM_IN();
  153.          end
  154.       while((i++)<2000);
  157.       i   = tenths/10;
  158.       if (i<1)   i =  1;
  159.       if (i>58)  i = 58;
  161.       i = set_timer(i);
  163.       while(!CHAR_AVAIL())
  164.          begin
  165.             if (!CARRIER)     return RCDO;
  167.             time_release();
  168.             if (time_gone(i)) return TIMEOUT;
  169.          end
  171.       return MODEM_IN();
  173.    end
  181. /*--------------------------------------------------------------------------*/
  182. /* QK_READ  (like Z_GetByte, but assumes the time to be Rxtimeout)          */
  183. /* Get a byte from the modem;                                               */
  184. /* return TIMEOUT if no read within timeout tenths,                         */
  185. /* return RCDO if carrier lost                                              */
  186. /*--------------------------------------------------------------------------*/
  187. static int pascal _Z_qk_read()
  188.    begin
  189.       register int i;
  190.       register int time_val;
  192.       time_val^=time_val;
  193.       do
  194.        begin
  195.             if ((i=MODEM_STATUS())&DATA_READY)  return MODEM_IN();
  196.             if (!(i&ctl.carrier_mask))          return RCDO;
  197.          end
  198.       while((time_val++)<2000);
  200.       time_val = set_timer(Rxtimeout);
  201.       do
  202.          begin
  203.             if ((i=MODEM_STATUS())&DATA_READY)  return MODEM_IN();
  204.             if (!(i&ctl.carrier_mask))          return RCDO;
  205.             time_release();
  206.          end
  207.       while(time_left(time_val));
  209.       return TIMEOUT;
  211.    end
  219. /*--------------------------------------------------------------------------*/
  220. /* Z PUT STRING                                                             */
  221. /* Send a string to the modem, processing for 336 (sleep 1 sec)            */
  222. /* and 335 (break signal, ignored)                                         */
  223. /*--------------------------------------------------------------------------*/
  224. void pascal Z_PutString(s)
  225.    register unsigned char *s;
  226.    begin
  227.       register int c;
  229.       while (*s)
  230.          begin
  231.             switch (c = *s++)
  232.                begin
  233.                   case '336':   big_pause(2);
  234.                   case '335':   break;
  235.                   default:       SENDBYTE(c);
  236.                end /* switch */
  238.          end /* while */
  240.    end /* Z_PutString */
  250. /*--------------------------------------------------------------------------*/
  251. /* Z UPDATE CRC                                                             */
  252. /* update CRC                                                               */
  253. /*--------------------------------------------------------------------------*/
  254. unsigned short pascal Z_UpdateCRC(c, crc)
  255.    unsigned short c;
  256.    unsigned short crc;
  257.    begin
  258.       register int    count;
  259.       register word   temp;
  261.       temp   = crc;
  263.       for (count=8; --count>=0; )
  264.          begin
  265.             if (temp & 0x8000)
  266.                begin
  267.                   temp <<= 1;
  268.                   temp += (((c<<=1) & 0400)  !=  0);
  269.                   temp ^= 0x1021;
  270.                end
  271.             else
  272.                begin
  273.                   temp <<= 1;
  274.                   temp += (((c<<=1) & 0400)  !=  0);
  275.                end
  276.          end /* for */
  278.       return temp;
  280.    end /* z_crc update */
  285. /*--------------------------------------------------------------------------*/
  286. /* Z SEND HEX HEADER                                                        */
  287. /* Send ZMODEM HEX header hdr of type type                                  */
  288. /*--------------------------------------------------------------------------*/
  289. void pascal Z_SendHexHeader(type, hdr)
  290.    unsigned short type;
  291.    unsigned char *hdr;
  292.    begin
  293.       register int   n;
  294.       register int   i;
  295.       unsigned short crc;
  297.       SENDBYTE(ZPAD);
  298.       SENDBYTE(ZPAD);
  299.       SENDBYTE(ZDLE);
  300.       SENDBYTE(ZHEX);
  301.       Z_PUTHEX(i,type);
  303.       crc = Z_UpdateCRC(type, 0);
  304.       for (n=4; --n >= 0;)
  305.          begin
  306.             Z_PUTHEX(i,(*hdr));
  307.             crc = Z_UpdateCRC(((unsigned short)(*hdr++)), crc);
  308.          end
  309.       crc = Z_UpdateCRC(0,crc);
  310.       crc = Z_UpdateCRC(0,crc);
  311.       Z_PUTHEX(i,(crc>>8));
  312.       Z_PUTHEX(i,crc);
  314.       /* Make it printable on remote machine */
  315.       SENDBYTE('r');
  316.       SENDBYTE('n');
  318.       /* Uncork the remote in case a fake XOFF has stopped data flow */
  319.       if (type != ZFIN) SENDBYTE(021);
  321.       wait_for_clear();
  323.    end /* Z_SendHexHeader */
  329. /*--------------------------------------------------------------------------*/
  330. /* Z GET HEADER                                                             */
  331. /* Read a ZMODEM header to hdr, either binary or hex.                       */
  332. /*   On success, set Zmodem to 1 and return type of header.                 */
  333. /*   Otherwise return negative on error                                     */
  334. /*--------------------------------------------------------------------------*/
  335. int pascal Z_GetHeader(hdr)
  336.    byte *hdr;
  337.    begin
  339.       register int   c;
  340.       register int   n;
  341.       int            cancount;
  344.       n        = cur_baud;   /* Max characters before start of frame */
  345.       cancount = 5;
  347. Again:
  349.       if (((KEYPRESS()) and (READKB()==27)))
  350.          begin
  351.             send_can();
  352.             z_log( KBD_msg );
  353.             return ZCAN;
  354.          end
  356.       Rxframeind = Rxtype = 0;
  358.       switch (c = _Z_TimedRead())
  359.          begin
  361.             case ZPAD:     /*-----------------------------------------------*/
  362.                            /* This is what we want.                         */
  363.                            /*-----------------------------------------------*/
  364.                            break;
  366.             case RCDO:
  367.             case TIMEOUT:  /*-----------------------------------------------*/
  368.                            /*                                               */
  369.                            /*-----------------------------------------------*/
  370.                            goto Done;
  372.             case CAN:      /*-----------------------------------------------*/
  373.                            /*                                               */
  374.                            /*-----------------------------------------------*/
  375.                            if (--cancount <= 0)
  376.                               begin
  377.                                  c = ZCAN;
  378.                                  goto Done;
  379.                               end
  381.                            /* fallthrough... */
  383.             default:       /*-----------------------------------------------*/
  384.                            /*                                               */
  385.                            /*-----------------------------------------------*/
  386. Agn2:
  388.                            if (--n <= 0)
  389.                               begin
  390.                                  z_log( FUBAR_msg );
  391.                                  send_can();
  392.                                  return ZCAN;
  393.                               end
  395.                            if (c != CAN) cancount = 5;
  396.                            goto Again;
  398.          end /* switch */
  400.       cancount = 5;
  402. Splat:
  404.       switch (c = _Z_TimedRead())
  405.          begin
  406.             case ZDLE:     /*-----------------------------------------------*/
  407.                            /* This is what we want.                         */
  408.                            /*-----------------------------------------------*/
  409.                            break;
  411.             case ZPAD:     /*-----------------------------------------------*/
  412.                            /*                                               */
  413.                            /*-----------------------------------------------*/
  414.                            goto Splat;
  416.             case RCDO:
  417.             case TIMEOUT:  /*-----------------------------------------------*/
  418.                            /*                                               */
  419.                            /*-----------------------------------------------*/
  420.                            goto Done;
  422.             default:       /*-----------------------------------------------*/
  423.                            /*                                               */
  424.                            /*-----------------------------------------------*/
  425.                            goto Agn2;
  427.          end /* switch */
  430.       switch (c = _Z_TimedRead())
  431.          begin
  433.             case ZBIN:     /*-----------------------------------------------*/
  434.                            /*                                               */
  435.                            /*-----------------------------------------------*/
  436.                            Rxframeind = ZBIN;
  437.                            c =  _Z_GetBinaryHeader(hdr);
  438.                            break;
  440.             case ZHEX:     /*-----------------------------------------------*/
  441.                            /*                                               */
  442.                            /*-----------------------------------------------*/
  443.                            Rxframeind = ZHEX;
  444.                            c =  _Z_GetHexHeader(hdr);
  445.                            break;
  447.             case CAN:      /*-----------------------------------------------*/
  448.                            /*                                               */
  449.                            /*-----------------------------------------------*/
  450.                            if (--cancount <= 0)
  451.                               begin
  452.                                  c = ZCAN;
  453.                                  goto Done;
  454.                               end
  455.                            goto Agn2;
  457.             case RCDO:
  458.             case TIMEOUT:  /*-----------------------------------------------*/
  459.                            /*                                               */
  460.                            /*-----------------------------------------------*/
  461.                            goto Done;
  463.             default:       /*-----------------------------------------------*/
  464.                            /*                                               */
  465.                            /*-----------------------------------------------*/
  466.                            goto Agn2;
  468.          end /* switch */
  470.       Rxpos = _Z_PullLongFromHeader(hdr);
  472. Done:
  474.       return c;
  476.    end /* Z_GetHeader */
  482. /*--------------------------------------------------------------------------*/
  483. /* Z GET BINARY HEADER                                                      */
  484. /* Receive a binary style header (type and position)                        */
  485. /*--------------------------------------------------------------------------*/
  486. static int pascal _Z_GetBinaryHeader(hdr)
  487.    byte *hdr;
  488.    begin
  489.       register int    c;
  490.       register word   crc;
  491.       int             n;
  493.       if ((c   = Z_GetZDL()) & ~0xFF)   return c;
  494.       Rxtype   = c;
  495.       crc      = Z_UpdateCRC(c, 0);
  497.       for (n=4; --n >= 0;)
  498.          begin
  499.             if ((c = Z_GetZDL()) & ~0xFF) return c;
  500.             crc = Z_UpdateCRC(c, crc);
  501.             *hdr++ = c;
  502.          end
  503.       if ((c   = Z_GetZDL()) & ~0xFF) return c;
  505.       crc      = Z_UpdateCRC(c, crc);
  506.       if ((c   = Z_GetZDL()) & ~0xFF) return c;
  508.       crc = Z_UpdateCRC(c, crc);
  509.       if (crc & 0xFFFF)
  510.          begin
  511.             z_message( CRC_msg );
  512.             return ERROR;
  513.          end
  515.       return Rxtype;
  517.    end /* _Z_GetBinaryHeader */
  522. /*--------------------------------------------------------------------------*/
  523. /* Z GET HEX HEADER                                                         */
  524. /* Receive a hex style header (type and position)                           */
  525. /*--------------------------------------------------------------------------*/
  526. static int pascal _Z_GetHexHeader(hdr)
  527.    unsigned char *hdr;
  528.    begin
  529.       register int   c;
  530.       register word  crc;
  531.       int            n;
  533.       if ((c   = _Z_GetHex()) < 0) return c;
  534.       Rxtype   = c;
  535.       crc      = Z_UpdateCRC(c, 0);
  537.       for (n=4; --n >= 0;)
  538.          begin
  539.             if ((c = _Z_GetHex()) < 0) return c;
  540.             crc      = Z_UpdateCRC(c, crc);
  541.             *hdr++   = c;
  542.          end
  544.       if ((c = _Z_GetHex()) < 0) return c;
  545.       crc = Z_UpdateCRC(c, crc);
  546.       if ((c = _Z_GetHex()) < 0) return c;
  547.       crc = Z_UpdateCRC(c, crc);
  548.       if (crc & 0xFFFF)
  549.          begin
  550.             z_message( CRC_msg );
  551.             return ERROR;
  552.          end
  553.       if (Z_GetByte(1) == 'r') Z_GetByte(1);  /* Throw away possible cr/lf */
  555.       return Rxtype;
  557.    end
  563. /*--------------------------------------------------------------------------*/
  564. /* Z GET HEX                                                                */
  565. /* Decode two lower case hex digits into an 8 bit byte value                */
  566. /*--------------------------------------------------------------------------*/
  567. static int pascal _Z_GetHex()
  568.    begin
  569.       register int c, n;
  571.       if ((n = _Z_TimedRead()) < 0) return n;
  572.       n -= '0';
  573.       if (n > 9) n -= ('a' - ':');
  574.       if (n & ~0xF) return ERROR;
  576.       if ((c = _Z_TimedRead()) < 0) return c;
  577.       c -= '0';
  578.       if (c > 9) c -= ('a' - ':');
  579.       if (c & ~0xF) return ERROR;
  581.       return (n<<4 | c);
  582.    end
  587. /*--------------------------------------------------------------------------*/
  588. /* Z GET ZDL                                                                */
  589. /* Read a byte, checking for ZMODEM escape encoding                         */
  590. /* including CAN*5 which represents a quick abort                           */
  591. /*--------------------------------------------------------------------------*/
  592. int pascal Z_GetZDL()
  593.    begin
  594.       register int c;
  596.       if ((c = _Z_qk_read()) != ZDLE)         return c;
  598.       switch (c=_Z_qk_read())
  599.          begin
  600.             case CAN:   return ((c=_Z_qk_read())<0)?               c :
  601.                                ((c==CAN) && ((c=_Z_qk_read())<0))? c :
  602.                                ((c==CAN) && ((c=_Z_qk_read())<0))? c : (GOTCAN);
  604.             case ZCRCE:
  605.             case ZCRCG:
  606.             case ZCRCQ:
  607.             case ZCRCW: return (c | GOTOR);
  609.             case ZRUB0: return 0x7F;
  611.             case ZRUB1: return 0xFF;
  613.             default:    return   (c<0)?            c :
  614.                                  ((c&0x60)==0x40)? (c ^ 0x40)  : ERROR;
  616.          end /* switch */
  618.    end /* Z_GetZDL */
  624. /*--------------------------------------------------------------------------*/
  625. /* Z TIMED READ                                                             */
  626. /* Read a character from the modem line with timeout.                       */
  627. /*  Eat parity, XON and XOFF characters.                                    */
  628. /*--------------------------------------------------------------------------*/
  629. static int pascal _Z_TimedRead()
  630.    begin
  631.       register int c;
  633.       for (;;)
  634.          begin
  635.             if ((c = _Z_qk_read()) < 0) return c;
  637.             switch (c &= 0x7F)
  638.                begin
  639.                   case XON:
  640.                   case XOFF:  continue;
  642.                   default:    return c;
  643.                end /* switch */
  645.          end /* for */
  647.    end /* _Z_TimedRead */
  652. /*--------------------------------------------------------------------------*/
  653. /* Z LONG TO HEADER                                                         */
  654. /* Store long integer pos in Txhdr                                          */
  655. /*--------------------------------------------------------------------------*/
  656. void pascal Z_PutLongIntoHeader(pos)
  657.    long pos;
  658.    begin
  659.       Txhdr[ZP0] = pos;
  660.       Txhdr[ZP1] = pos>>8;
  661.       Txhdr[ZP2] = pos>>16;
  662.       Txhdr[ZP3] = pos>>24;
  663.    end /* Z_PutLongIntoHeader */
  668. /*--------------------------------------------------------------------------*/
  669. /* Z PULL LONG FROM HEADER                                                  */
  670. /* Recover a long integer from a header                                     */
  671. /*--------------------------------------------------------------------------*/
  672. static long pascal _Z_PullLongFromHeader(hdr)
  673.    unsigned char *hdr;
  674.    begin
  675.       long l;
  677.       l = hdr[ZP3];
  678.       l = (l << 8) | hdr[ZP2];
  679.       l = (l << 8) | hdr[ZP1];
  680.       l = (l << 8) | hdr[ZP0];
  681.       return l;
  682.    end /* _Z_PullLongFromHeader */
  685. /* END OF FILE: n_zmodem.c */