zmodem.c

vxworks不支持ZMODEM协议

    iCharHigh = zTimedRead( ); 
    if ( gbTimeOut )
    {
    	return ZZTIMEOUT;
    }
    iCharHigh -= '0';
    if ( iCharHigh > 9 )
    {
    	iCharHigh -= ( 'a' - ':' );
    }
    if ( iCharHigh & 0xf0 )
    {
    	return ZZERROR;
    }
    iCharLow = zTimedRead( );
    if ( gbTimeOut )
    {
    	return ZZTIMEOUT;
    }
    iCharLow -= '0';
    if ( iCharLow > 9 )
    {
    	iCharLow -= ( 'a' - ':' );
    }
    if ( iCharLow & 0xf0 )
    {
    	return ( ZZERROR );
    }
    return ( ( iCharHigh << 4) | iCharLow );
}

/*--------------------------------------------------------------------------*/
/* Z GET HEX HEADER                                                         */
/* Receive a hex style header (type and position)                           */
/*--------------------------------------------------------------------------*/
static int zGetHexHeader( char *pcHdr )
{
	 int iRecChar, iHdrBits; 
	 unsigned short int usCrc;

     if ( ( iRecChar   = zGetHex() ) < 0 ) 
     {
     	 return ( iRecChar );
     }
     giRxType   = iRecChar;
     usCrc      = Z_UpdateCRC( iRecChar, 0 );
     for ( iHdrBits=4; --iHdrBits >= 0; ) 
     {
        if ( ( iRecChar = zGetHex() ) < 0 )
        {
        	return ( iRecChar );
        }	
        usCrc      = Z_UpdateCRC( iRecChar, usCrc );
        *pcHdr++   = iRecChar;
     }
     if ( ( iRecChar = zGetHex() ) < 0 ) 
     {
         return ( iRecChar );
     }
     usCrc = Z_UpdateCRC( iRecChar, usCrc );
     if ( ( iRecChar = zGetHex() ) < 0 ) 
     {
         return ( iRecChar );
     }
     usCrc = Z_UpdateCRC( iRecChar, usCrc );
     if ( usCrc & 0xFFFF )
     {
     	 return ( ZZERROR );                          /*CRC错误*/
     }
     iRecChar = zGetByte( 1000 );
     if ( !gbTimeOut ) 
     { 
     	 if ( iRecChar == '\x0d' ) 
     	 {
     	 	 zGetByte( 1000 );                  /*丢弃可能的cr/lf*/
         }
     }
     return ( giRxType );
}


/*--------------------------------------------------------------------------*/
/* Z PULL LONG FROM HEADER                                                  */
/* Recover a long integer from a header                                     */         
/*--------------------------------------------------------------------------*/
static int zPullLongFromHeader( char *pcHdr )
{
    int iPos;

    ipos = pcHdr[ZP3];
    ipos = ( iPos << 8 ) | pcHdr[ZP2];
    ipos = ( iPos << 8 ) | pcHdr[ZP1];
    ipos = ( iPos << 8 ) | pcHdr[ZP0];
    return ( iPos );
}


/*--------------------------------------------------------------------------*/
/* Z LONG TO HEADER                                                         */
/* Store long integer pos in gpcTxhdr                                       */
/*--------------------------------------------------------------------------*/
static void zPutLongIntoHeader( int ipos )
{
  gpcTxhdr[ZP0] = ipos;
  gpcTxhdr[ZP1] = ipos>>8;
  gpcTxhdr[ZP2] = ipos>>16;
  gpcTxhdr[ZP3] = ipos>>24;
}


/*--------------------------------------------------------------------------*/
/* Z GET HEADER                                                             */
/* Read a ZMODEM header to hdr, either binary or hex.                       */
/*   On success, set Zmodem to 1 and return type of header.                 */ 
/*   Otherwise return negative on error                                     */ 
/*--------------------------------------------------------------------------*/
/*将zodem设为1，然后返回header的类型,否则返回negative on error*/

static int zGetHeader( char *pcHdr )                 /* 收一个二进制或十六进制的HEAD */
{ 
	int iRecChar, iMaxChars, iCanCount;
    iMaxChars = 10;                            /* Max characters before start of frame */
    iCanCount = 5;

Again:
    gcRxframeType = giRxType = 0;
    iRecChar   = zTimedRead( );
    if ( gbTimeOut )
    {
    	iRecChar = ZZTIMEOUT;
    }
    switch ( iRecChar )
    {
        case ZPAD:
        	break;                              /*这是我们要求的*/
        case ZZRCDO:
        case ZZTIMEOUT:
        	goto Done;                          /*时间用完*/
        case CAN:
        	if ( --iCanCount <= 0 )
        	{
        		iRecChar = ZCAN;
        	    goto Done;                      /*取消，而不是间断*/     
        	}
        default:
Agn2:
	    if ( --iMaxChars <= 0 )
	    {
	    	return ( ZCAN );
	    }
        if ( iRecChar != CAN )
        {
        	iCanCount = 5;
        }
        goto Again;
    }
    iCanCount = 5;
Splat:
    iRecChar = zTimedRead( );
    if ( gbTimeOut )
    {
    	iRecChar = ZZTIMEOUT;
    }
    switch ( iRecChar )
    {
        case ZDLE:
        	break;                              /*这是我们要求的*/
        case ZPAD:
        	goto Splat;
        case ZZRCDO:
        case ZZTIMEOUT:
        	goto Done;                          /*时间用完*/
        default:
        	goto Agn2;
    }
    iRecChar = zTimedRead( );
    if ( gbTimeOut )
    {
    	iRecChar = ZZTIMEOUT;
    }
    switch ( iRecChar )
    {
        case ZBIN:                     /*BIN head*/
            gcRxframeType = ZBIN;
            iRecChar =  zGetBinaryHeader( pcHdr );
            break;
        case ZHEX:                     /*HEX head*/
            gcRxframeType = ZHEX;
            iRecChar =  zGetHexHeader( pcHdr );
            break;
        case CAN:                      /*Cancel*/
            if ( --iCanCount <= 0 )
            {
            	iRecChar = ZCAN;
            	goto Done;
            }
            goto Agn2;
        case ZZRCDO:
        case ZZTIMEOUT:
        	goto Done;                 /*Timeout*/
        default:
        	goto Agn2;
    }
    giRxpos = zPullLongFromHeader( pcHdr );
Done:
    return ( iRecChar );
}


/*--------------------------------------------------------------------------*/
/* RZ RECEIVE DATA(Subpacket)                                               */
/* Receive array buf of max length with ending ZDLE sequence                */ 
/* and CRC.  Returns the ending character or error code.                    */
/*--------------------------------------------------------------------------*/
/*RZ接收数据*/
/*用zdle和CRC接收阵列缓存，返回结束字符或错误*/

static int zReceiveData( char *pcBuf, int iLength )        /* 收data subpacket文件数据 */
{
    int iRecChar, iTempChar;
    unsigned short int usCrc;

    usCrc   = giRxCount   = 0;
    while( 1 ) 
    {
        if ( ( iRecChar = zGetZDL() ) & ~0xff )
        {
CRCfoo:
            switch ( iRecChar ) 
            {
                case GOTCRCE:
                case GOTCRCG:
                case GOTCRCQ:
                case GOTCRCW:                 /* C R C s */
                    usCrc = Z_UpdateCRC( ( ( iTempChar = iRecChar ) & 0xff ), usCrc );
                    if ( ( iRecChar = zGetZDL() ) & ~0xff ) 
                    {
                    	goto CRCfoo;
                    }
                    usCrc = Z_UpdateCRC( iRecChar, usCrc );
                    if ( ( iRecChar = zGetZDL() ) & ~0xff ) 
                    {
                    	goto CRCfoo;
                    }
                    usCrc = Z_UpdateCRC( iRecChar, usCrc );
                    if ( usCrc & 0xffff ) 
                    {
                    	return ( ZZERROR );
                    }
                    return ( iTempChar );
                case GOTCAN:
                	return ( ZCAN );           /* Cancel  */
                case ZZTIMEOUT:
                	return ( iRecChar );       /* Timeout  */
                case ZZRCDO:
                	return ( iRecChar );       /* No Carrier           没有载体*/
                default:
                	return ( iRecChar );       /* Something bizarre    有异常*/
            }
        }
      if ( --iLength < 0 )
      {
      	  return ( ZZERROR );                  /* Long pkt */
          ++giRxCount;
          *pcBuf ++= iRecChar;
          usCrc = Z_UpdateCRC( iRecChar, usCrc );
          continue;
      }
    }
}

/*--------------------------------------------------------------------------*/
/* RZ ACK BIBI                                                              */
/* Ack a ZFIN packet, let byegones be byegones                              */
/*--------------------------------------------------------------------------*/
static void zAckBibi( void )                 /*Ack a ZFIN packet*/
{
	int iHdrBits;
    zPutLongIntoHeader( 0L );
    for ( iHdrBits = 4; --iHdrBits; )
    {
    	 char cRecChar;
         zSendHexHeader( ZFIN, gpcTxhdr );
         cRecChar = zGetByte( 1000 );
         if ( gbTimeOut )
         {
             return;
         }
         if ( cRecChar == 'O' )
         { 
             zGetByte( 1000 );            /* Discard 2nd 'O' */
         }
    }
}


/*--------------------------------------------------------------------------*/
/* RZ INIT RECEIVER                                                         */
/* Initialize for Zmodem receive attempt, try to activate Zmodem sender     */
/* Handles ZSINIT, ZFREECNT, and ZCOMMAND frames                            */
/*                                                                          */
/* Return codes:                                                            */