// Zmodem.cpp: implementation of the Zmodem class. // ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include "Zmodem.h" #include "CtrlProtocolDef.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif extern SYSTEMTIME g_sysCurTime; extern int g_iUILanguage; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// // // Zmodem::Zmodem() // { // // } // Zmodem::~Zmodem() { //str = NULL; } Zmodem::Zmodem( CSComPort *rs232_port ) { port = rs232_port; // str = NULL; // m_BuffCount = 0; // m_BufReadIndex = 0; ClearReadBuf(); file_count = 0; file_name[ 0 ] = '\0'; file_length = -1L; file = NULL; receiver_buffer_length = 16384; wake_up_sender_header_type = ZRINIT; memset(m_WriteBuff, 0, 8192); m_WriteBuffLength = 0; m_ByteTransfer = 0; m_FileSize = 0; nIndex = 0; // nTestID = 123456; } // The public Send functionsends a batch of files one at a time // via the SendSingleFile function. When a normal completion // occurs, it is flagged with a ZFIN frame. BOOL Zmodem::Send( char *files[] ) { //log zmodemLog = fopen("log\\zmodemSZLog.txt","ab"); if (!zmodemLog) { zmodemLog = fopen("zmodemSZLog.txt","ab"); } dwBegin = GetTickCount(); memset(cReadLog,0,2048); nLogLength = sprintf(cReadLog,"\r\n"); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); nLogLength = sprintf(cReadLog,*files); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); nLogLength = sprintf(cReadLog,"\r\n"); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); //log PackLongIntoHeader( 0L ); SendHexHeader(4, ZRQINIT, transmitted_header); GetRinitHeader(); byte_count = -1; while ( *files ) { int n = SendSingleFile( *files ); if ( n == ZERROR ) { if (file) { //log nLogLength = sprintf(cReadLog,"SendSingleFile = %d\r\n",n); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); //log fclose(file); fclose(zmodemLog); return FALSE; } //log nLogLength = sprintf(cReadLog,"SendSingleFile = %d\r\n",n); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); //log } files++; } SendZFIN(); if (file) fclose(file); if (zmodemLog) fclose(zmodemLog); return TRUE; } // This function is used *everywhere*, and benefits from being // declared as inline. inline int Zmodem::ReadChar( long timeout ) { // int c = ReadBuff( timeout ); // return ( c < 0 ) ? TIMEOUT : c; if ((0 == m_BuffCount) || (m_nBufReadIndex == m_BuffCount))//除非已经读取完毕，再进行缓存的读取 { if (ReadBuff(timeout) != TIMEOUT) { return buff[m_nBufReadIndex++ ] & 0377; } else return TIMEOUT; } return buff[m_nBufReadIndex++ ] & 0377; } // This is the worker routine that transmits a single file. int Zmodem::SendSingleFile( char *name ) { int c; unsigned long crc_value; long lastcrcrq = -1; int length; //add by waston int nnlen;//log char *FileName; int nLogCode = 0; CString strLogTmp = _T(""); //add by waston file = fopen( name, "rb" ); FileName = strrchr(name,'\\'); FileName++; if ( file == NULL) { error( "Failed to open %s", name ); return OK; } file_at_eof = 0; fseek( file, 0, SEEK_END ); file_length = ftell( file ); fseek( file, 0, SEEK_SET ); m_FileSize = file_length; //将文件大小写到接口 length = sprintf( buffer, "%s%c%u 0 0 0 0 0", FileName, 0, file_length ); for ( ; ; ) { PackLongIntoHeader( 0L ); SendBinaryHeader( 4, ZFILE, transmitted_header ); SendDataFrame( buffer, length, ZCRCW ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRUN: send ZFILE DATA FRAME: %s"), __LINE__, GetTickCount() - dwBegin,buffer); PrintLogLast(strLogTmp); //log again: c = ReadHeader( received_header ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tswitch = %d"), __LINE__, GetTickCount() - dwBegin, c); PrintLogLast(strLogTmp); //log switch ( c ) { case ZRINIT: while ( ( c = ReadChar( 5000L ) ) > 0 ) if ( c == ZPAD ) goto again; /* **** FALL THRU TO **** */ default: continue; case ZCAN: case TIMEOUT: case ZABORT: case ZFIN: return ZERROR; case ZCRC: if ( received_file_position != lastcrcrq ) { Crc32 crc( 0xFFFFFFFFL ); lastcrcrq = received_file_position; fseek( file, 0L, SEEK_SET ); while ( ( ( c = getc( file ) ) != EOF ) && --lastcrcrq ) crc.update(c ); crc_value = ~crc.value(); fseek( file, 0L, SEEK_SET ); lastcrcrq = received_file_position; } PackLongIntoHeader( crc_value ); SendBinaryHeader( 4, ZCRC, transmitted_header ); goto again; case ZSKIP: fclose( file ); return OK; case ZRPOS: nLogCode = fseek(file,received_file_position,SEEK_SET); if (nLogCode) { //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\t case ZRPOS = %d,fseek = %d"), __LINE__, GetTickCount() - dwBegin, received_file_position,nLogCode); PrintLogLast(strLogTmp); //log return ZERROR; } last_sync_position = (byte_count=transmitted_file_position= last_reported_position= received_file_position) - 1; return SendFileContents(); } } } int Zmodem::SendFileContents( void ) { int c; int e; int n; int junkcount; int newcnt; junkcount = 0; CString strLogTmp = _T(""); start_read: receiver_buffer_length = 2048; newcnt = receiver_buffer_length; PackLongIntoHeader( transmitted_file_position ); SendBinaryHeader( 4, ZDATA, transmitted_header ); do { n = fread( buffer, 1, 1024, file ); if ( n < 1024 ) file_at_eof = 1; if ( file_at_eof ) e = ZCRCE; else if ( junkcount > 3 ) e = ZCRCW; else if ( byte_count == last_sync_position ) e = ZCRCW; else if ( receiver_buffer_length && ( newcnt -= n ) <= 0 ) e = ZCRCW; else e = ZCRCG; SendDataFrame( buffer, n, e ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tSendData: %d, fread = %d"), __LINE__, GetTickCount() - dwBegin, e,n); PrintLogLast(strLogTmp); //log m_ByteTransfer = byte_count = transmitted_file_position += n; if ( e == ZCRCW ) goto waitack; while ( /*port->RXSpaceUsed()*/ m_nBufReadIndex < m_BuffCount) { switch ( ReadChar( 100 ) ) { case CAN: case ZPAD: c = SyncWithReceiver( 1 ); if ( c == ZACK ) break; SendDataFrame( buffer, 0, ZCRCE ); goto gotack; case XOFF: case XOFF | 0x80 : ReadChar( 10000L ); default: junkcount++; } } } while ( !file_at_eof ); int nnlen; for ( ; ; ) { PackLongIntoHeader( transmitted_file_position ); SendBinaryHeader( 4, ZEOF, transmitted_header ); switch ( SyncWithReceiver( 0 ) ) { case ZACK: continue; case ZRPOS: goto start_read; case ZRINIT: return OK; case ZSKIP: fclose( file ); return c; default: fclose( file ); return ZERROR; } } //Backchannel processing waitack: junkcount = 0; c = SyncWithReceiver( 0 ); gotack: switch ( c ) { default: case ZCAN: fclose( file ); return ZERROR; case ZSKIP: fclose( file ); return c; case ZACK: case ZRPOS: break; case ZRINIT: return OK; } while ( /*port->RXSpaceUsed()*/ m_nBufReadIndex < m_BuffCount) { switch ( ReadChar( 100 ) ) { case CAN: case ZPAD: c = SyncWithReceiver( 1 ); goto gotack; case XOFF : case XOFF | 0x80 : ReadChar( 10000L ); } } goto start_read; } // If all goes well, the public receive function just calls // WakeUpSender(), then ReceiveFiles(). If both of those // do what they are supposed to do, a batch of files will // have been properly transferred. BOOL Zmodem::Receive( CString Path ) { //log zmodemLog = fopen("log\\zmodemRZLog.txt","ab"); if (!zmodemLog) { zmodemLog = fopen("zmodemRZLog.txt","ab"); } dwBegin = GetTickCount(); memset(cReadLog,0,2048); nLogLength = sprintf(cReadLog,"\r\n"); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); nLogLength = sprintf(cReadLog,"\r\n"); fwrite(cReadLog,nLogLength,1,zmodemLog); fflush(zmodemLog); //log memset(buffer,0,BUFFSIZE); static char CancelString[] = { CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS }; switch ( WakeUpSender() ) { case 0 : case ZCOMPL : return OK; case ZERROR : break; default : if ( ReceiveFiles(Path) == OK ) { if ( file ) { if (0 != fclose(file)) { CString strTmp = _T(""); strTmp.Format(_T("{Zmodem} [%d] close file failed!!!,ErrorNo = %d"), __LINE__, GetLastError()); PrintLogLast(strTmp); } file = NULL; } fclose(zmodemLog);//log; return TRUE; } } port->ZmodemSendDataDirectly( CancelString, sizeof CancelString);//tmp if ( file ) { if (0 != fclose(file)) { CString strTmp = _T(""); strTmp.Format(_T("{Zmodem} [%d] close file failed!!!,ErrorNo = %d"), __LINE__, GetLastError()); PrintLogLast(strTmp); } file = NULL; } fclose(zmodemLog);//log; return FALSE; } // This is the general purpose receiver function. It calls the // ReceiveSingleFile function repeatedly as long as the wakeup // function keeps receiving ZFILE frames. int Zmodem::ReceiveFiles( CString Path ) { int return_status ; for ( ; ; ) { switch ( return_status = ReceiveSingleFile(Path) ) { case ZEOF: case ZSKIP: switch ( WakeUpSender() ) { case ZCOMPL: return OK; default: return ZERROR; case ZFILE: break; } continue; default: return return_status; case ZERROR: return ZERROR; } } } // Some data used various places in the class static char *Zendnames[] = { "ZCRCE", "ZCRCG", "ZCRCQ", "ZCRCW"}; static char *frametypes[] = { "No Response to Error Correction Request", "No Carrier Detect", "TIMEOUT", "ZERROR", "ZRQINIT", "ZRINIT", "ZSINIT", "ZACK", "ZFILE", "ZSKIP", "ZNAK", "ZABORT", "ZFIN", "ZRPOS", "ZDATA", "ZEOF", "ZFERR", "ZCRC", "ZCHALLENGE", "ZCOMPL", "ZCAN", "ZFREECNT", "ZCOMMAND", "ZSTDERR" }; // This function is used when receiving files. It sends out the // initial frame and waits for a response from the sender. If // things go properly it will get the file data subpacket and // return ZFILE. If the sender has no more files it will send a // ZFIN, which is handled here. int Zmodem::WakeUpSender( void ) { int c; int n; for ( n = 0 ; n < 16 ; n++ ) { PackLongIntoHeader( 3072L ); transmitted_header[ZF0] = CANFC32|CANFDX|CANOVIO|CANBRK; SendHexHeader( 4, wake_up_sender_header_type, transmitted_header ); if ( wake_up_sender_header_type == ZSKIP ) wake_up_sender_header_type = ZRINIT; for ( int try_again = 1 ; try_again ; ) { switch ( ReadHeader( received_header ) ) { case ZRQINIT : case ZEOF : case TIMEOUT : default : try_again = 0; break; case ZFILE : wake_up_sender_header_type = ZRINIT; c = ReadDataFrame( buffer, 1024 ); if ( c == GOTCRCW ) return ZFILE; SendHexHeader( 4, ZNAK, transmitted_header ); break; case ZSINIT : if (ReadDataFrame(attention_string, ZATTNLEN) == GOTCRCW ) { PackLongIntoHeader( 1L ); SendHexHeader(4,ZACK,transmitted_header); } else SendHexHeader(4,ZNAK,transmitted_header); break; case ZCOMPL : break; case ZFIN : AckZFIN(); return ZCOMPL; case ZCAN : return ZERROR; } } } return 0; } // This is the workhorse routine that reads a single file from the // sender. It reads in headers until it gets a ZDATA header, then // it switches over to reading data subpackets until it gets one // of the end of supbacket codes. int Zmodem::ReceiveSingleFile( CString Path ) { int c; int error_count; long rxbytes; if ( OpenInputFile( Path, buffer ) == ZERROR ) return wake_up_sender_header_type = ZSKIP; error_count = 0; rxbytes = 0L; long log_data2; // char chLog[200] = ""; CString strLogTmp = _T(""); for ( ; ; ) { PackLongIntoHeader( rxbytes ); SendHexHeader( 4, ZRPOS, transmitted_header ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRUN: send ZPROS:rxbytes = %d"), __LINE__, GetTickCount() - dwBegin, rxbytes); PrintLogLast(strLogTmp); //log nxthdr: c = ReadHeader( received_header ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRUN: read ReadHeader c = %d"), __LINE__, GetTickCount() - dwBegin, c); PrintLogLast(strLogTmp); //log switch (c) { default: error( "ReceiveSingleFile: ReadHeader returned %d", c ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRUN: default:"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log // return ZERROR;3 goto nxthdr; case ZNAK: { strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\ Receice ZANK!!!"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); continue; } case TIMEOUT: if ( ++error_count >= 20 ) { error("ReceiveSingleFile: ReadHeader returned %d", c ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\ Receice TIMEOUT"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return ZERROR; } continue; case ZFILE: ReadDataFrame( buffer, 1024 ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: ZFILE:"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log continue; case ZEOF: log_data2 = UnpackHeaderIntoLong(received_header); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: ZEOF:log_data2 = %d, rxbytes = %d"), __LINE__, GetTickCount() - dwBegin, log_data2, rxbytes); PrintLogLast(strLogTmp); //log if (log_data2 != rxbytes) goto nxthdr; // continue; // if ( fclose( file ) != 0 ) // { // wake_up_sender_header_type = ZFERR; // error( "ReceiveSingleFile: fclose() " // "returned error" ); // return ZERROR; // } return c; case ZERROR: //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: ZERROR:"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log if ( ++error_count >= 20 ) { error( "ReceiveSingleFile: ReadHeader " "returned %d", c ); return ZERROR; } // SendAttentionString(); // continue;1 goto nxthdr; case ZSKIP: //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: ZSKIP:"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log status("ReceiveSingleFile: Sender SKIPPED file"); return c; case ZDATA: long log_data = UnpackHeaderIntoLong( received_header ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: recv ZDATA:log_data = %d, rxbytes = %d"), __LINE__, GetTickCount() - dwBegin, log_data,rxbytes); PrintLogLast(strLogTmp); //log if ( log_data != rxbytes ) { if ( ++error_count >= 20 ) return ZERROR; // SendAttentionString(); continue; } // if ( UnpackHeaderIntoLong( received_header ) != rxbytes ) // { // if ( ++error_count >= 20 ) // return ZERROR; // // SendAttentionString(); // continue; // } moredata: switch ( c = ReadDataFrame( buffer, 1024 ) ) { case ZCAN: error( "ReceiveSingleFile: ReadData returned %d", c ); return ZERROR; case ZERROR: if ( ++error_count >= 20 ) { error( "ReceiveSingleFile: ReadData " "returned %d", c ); return ZERROR; } // SendAttentionString(); continue; case TIMEOUT: if ( ++error_count >= 20 ) { error( "ReceiveSingleFile: ReadData " "returned %d", c ); return ZERROR; } continue; case GOTCRCW: error_count = 0; fwrite( buffer, 1, Rxcount, file ); rxbytes += Rxcount; m_ByteTransfer = rxbytes; PackLongIntoHeader( rxbytes ); SendHexHeader( 4, ZACK, transmitted_header ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: send ZACK:rxbytes = %d"), __LINE__, GetTickCount() - dwBegin, rxbytes); PrintLogLast(strLogTmp); //log SendChar( XON ); SendCharToComm(); goto nxthdr; case GOTCRCQ: error_count = 0; fwrite( buffer, 1, Rxcount, file ); rxbytes += Rxcount; m_ByteTransfer = rxbytes; PackLongIntoHeader( rxbytes ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d \t\t\t\t\t\tRUN: send ZACK:rxbytes = %d"), __LINE__, GetTickCount() - dwBegin, rxbytes); PrintLogLast(strLogTmp); //log SendHexHeader( 4, ZACK, transmitted_header ); goto moredata; case GOTCRCG: error_count = 0; fwrite( buffer, 1, Rxcount, file ); rxbytes += Rxcount; m_ByteTransfer = rxbytes; goto moredata; case GOTCRCE: error_count = 0; fwrite( buffer, 1, Rxcount, file ); rxbytes += Rxcount; m_ByteTransfer = rxbytes; goto nxthdr; } // return ZERROR; } } #ifdef _MSC_VER return 0; // MSC 7.0 generates an error w/o this line, // although it can never be reached #endif } // This routine just has to decide whether to send the binary // header using CRC-16 or CRC-32. After that it just spits out // the data. void Zmodem::SendBinaryHeader( int length, int type, char *header ) { CString strLogTmp = _T(""); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tSend: %d"), __LINE__, GetTickCount() - dwBegin, type); PrintLogLast(strLogTmp); //log int i; Crc32 crc32( 0xFFFFFFFFL ); unsigned long crc32val; Crc16 crc16( 0 ); status( "SendBinaryHeader: %d %s %lx", length, frametypes[ type + 4 ], UnpackHeaderIntoLong( header ) ); SendChar( ZPAD ); SendChar( ZDLE ); if ( receiver_wants_crc32 ) { SendChar( ZBIN32 ); SendEncodedChar( type ); crc32.update( type ); for ( i = 0; i < length; i++ ) { crc32.update( 0xff & header[ i ] ); SendEncodedChar( header[ i ] ); } crc32val = ~crc32.value(); for ( i = 0 ; i < 4 ; i++ ) { SendEncodedChar( (int) crc32val ); crc32val >>= 8; } } else { SendChar( ZBIN ); SendEncodedChar( type ); crc16.update( type ); for ( i = 0 ; i < length ; i++ ) { SendEncodedChar( header[ i ] ); crc16.update( header[ i ] & 0xff ); } crc16.update( 0 ); crc16.update( 0 ); SendEncodedChar( crc16.value() >> 8 ); SendEncodedChar( crc16.value() ); } SendCharToComm(); } // Sending the hex header involves no decisions whatsoever. void Zmodem::SendHexHeader( int len, int type, char *header ) { CString strLogTmp = _T(""); if (type == ZRPOS) { //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tSend:%d\tZrposIndex = %d"), __LINE__, GetTickCount() - dwBegin, type,nIndex); PrintLogLast(strLogTmp); //log nIndex++; } else { //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tSend: %d"), __LINE__, GetTickCount() - dwBegin, type); PrintLogLast(strLogTmp); //log } int n; Crc16 crc( 0 ); status( "SendHexHeader: %d %s %lx", len, frametypes[type+4], UnpackHeaderIntoLong( header ) ); SendChar( ZPAD ); SendChar( ZPAD ); SendChar( ZDLE ); SendChar( ZHEX ); SendHexEncodedChar( type ); crc.update( type ); for ( n = 0 ; n < len ; n++ ) { SendHexEncodedChar( header[ n ] ); crc.update( 0xff & header[ n ] ); } crc.update( 0 ); crc.update( 0 ); SendHexEncodedChar( crc.value() >> 8 ); SendHexEncodedChar( crc.value() ); SendChar( CR ); SendChar( LF | 0x80 ); if ( type != ZFIN && type != ZACK ) SendChar( XON ); SendCharToComm(); } // Reading in headers and data subpackets is a relatively // difficult job. The next four routines combine to read in // headers. The first routine dispatches one of the next three, // depending on what the header type is. int Zmodem::ReadHeader( char *header ) { int c; int n; int cancount; Settings settings; ReadSettings( settings ); n = 1400; n += ( settings.BaudRate > 19200L ) ? 19200 : (int) settings.BaudRate; startover: cancount = 0; again: switch ( c = ReadChar( 10000L ) ) { case TIMEOUT: goto finished; case CAN: gotcan: if ( ++cancount >= 5 ) { c = ZCAN; goto finished; } switch ( c = ReadChar( 100 ) ) { case TIMEOUT: goto again; case ZCRCW: switch ( ReadChar( 100 ) ) { case TIMEOUT: c = ZERROR; goto finished; default: goto agn2; } default: break; case CAN: if ( ++cancount >= 5 ) { c = ZCAN; goto finished; } goto again; } default: agn2: if ( --n == 0 ) { c = GARBAGE_COUNT; goto finished; } goto startover; case ZPAD | 0x80: /* This is what we want. */ case ZPAD: break; } cancount = 0; splat: switch ( c = ReadUnencodedByte() ) { case ZPAD: goto splat; case TIMEOUT: goto finished; default: goto agn2; case ZDLE: /* This is what we want. */ break; } c = ReadUnencodedByte(); switch ( c ) { case ZBIN32: current_frame_uses_crc32 = 1; c = ReadBinaryHeaderCRC32( header ); break; case TIMEOUT: goto finished; case ZBIN: current_frame_uses_crc32 = 0; c = ReadBinaryHeaderCRC16( header ); break; case ZHEX: current_frame_uses_crc32 = 0; c = ReadHexHeaderCRC16( header ); break; case CAN: goto gotcan; default: goto agn2; } received_file_position = header[ ZP3 ] & 0xff; received_file_position <<= 8; received_file_position += header[ ZP2 ] & 0xff; received_file_position <<= 8; received_file_position += header[ ZP1 ] & 0xff; received_file_position <<= 8; received_file_position += header[ ZP0 ] & 0xff; finished: switch ( c ) { case GOTCAN: c = ZCAN; /* **** FALL THRU TO **** */ case ZNAK: case ZCAN: case ZERROR: case TIMEOUT: case GARBAGE_COUNT: error( "Got %s", frametypes[ c + 4 ] ); /* **** FALL THRU TO **** */ default: if ( c >= -4 && c <= 22 ) error( "ReadHeader: %s %lx", frametypes[ c + 4 ], received_file_position ); else error( "ReadHeader: %d %lx", c, received_file_position ); } return c; } // At this point most of the hard work has been done. The next //three routines just read in the type of header and the data // associated with it, then check to see if the CRC is correct. int Zmodem::ReadBinaryHeaderCRC16( char *header ) { int c; int i; Crc16 crc( 0 ); int header_type; CString strLogTmp=_T(""); if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; header_type = c; //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %d\t\t\t\tin ReadBinaryHeaderCRC16"), __LINE__, GetTickCount() - dwBegin, header_type); PrintLogLast(strLogTmp); //log crc.update( c ); for ( i = 0 ; i < 4 ; i++ ) { if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; crc.update( c ); header[ i ] = (char) c; } if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; crc.update( c ); if ( crc.value() & 0xFFFF ) { error( "Bad CRC" ); return ZERROR; } return header_type; } int Zmodem::ReadBinaryHeaderCRC32( char *header ) { int c; int i; Crc32 crc( 0xFFFFFFFFL ); int header_type; CString strLogTmp=_T(""); if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; header_type = c; //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %d\t\t\t\tin ReadBinaryHeaderCRC32"), __LINE__, GetTickCount() - dwBegin, header_type); PrintLogLast(strLogTmp); //log crc.update( c ); for ( i = 0 ; i < 4 ; i++ ) { if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; crc.update( c ); header[ i ] = (char) c; } for ( i = 0; i < 4 ; i++ ) { if ( ( c = ReadEncodedByte() ) & ~0xff ) return c; crc.update( c ); } if ( crc.value() != 0xDEBB20E3L ) { error( "Bad CRC" ); return ZERROR; } return header_type; } int Zmodem::ReadHexHeaderCRC16( char *header ) { int c; Crc16 crc( 0 ); int i; int header_type; CString strLogTmp = _T(""); if ( ( c = ReadHexByte() ) < 0 ) return c; header_type = c; //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %d\t\t\t\tin ReadHexHeaderCRC16"), __LINE__, GetTickCount() - dwBegin, header_type); PrintLogLast(strLogTmp); //log crc.update( c ); for ( i = 0 ; i < 4 ; i++ ) { if ( ( c = ReadHexByte() ) < 0 ) return c; crc.update( c ); header[ i ] = (char) c; } if ( ( c = ReadHexByte() ) < 0 ) return c; crc.update( c ); if ( ( c = ReadHexByte() ) < 0 ) return c; crc.update( c ); if ( crc.value() & 0xFFFF ) { error( "Bad CRC" ); return ZERROR; } switch ( c = ReadChar( 100 ) ) { case CR : case CR | 0x80 : ReadChar( 100 ); } return header_type; } // The next three routines are used to read in binary data // subpackets. This code is somewhat simpler than the code // used to read in a header, mostly because there are fewer // things to go wrong. int Zmodem::ReadDataFrame( char *buffer, int length ) { int typee; CString strLogTmp = _T(""); if ( current_frame_uses_crc32 ) { typee = ReadDataFrameCRC32( buffer, length ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %d\t\t\t\tin ReadDataFrame CRC32"), __LINE__, GetTickCount() - dwBegin, typee); PrintLogLast(strLogTmp); //log return typee; } else { typee = ReadDataFrameCRC16( buffer, length ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %d\t\t\t\tin ReadDataFrame CRC16"), __LINE__, GetTickCount() - dwBegin, typee); PrintLogLast(strLogTmp); //log return typee; } } int Zmodem::ReadDataFrameCRC32( char *buffer, int length ) { int c; Crc32 crc( 0xFFFFFFFFL ); char *end; int d; CString strLogTmp = _T(""); Rxcount = 0; end = buffer + length; while ( buffer <= end ) { if ( ( c = ReadEncodedByte() ) & ~0xff ) { crcfoo: switch ( c ) { case GOTCRCE: case GOTCRCG: case GOTCRCQ: case GOTCRCW: d = c; c &= 0xff; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) goto crcfoo; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) goto crcfoo; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) goto crcfoo; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) goto crcfoo; crc.update( c ); if ( crc.value() != 0xDEBB20E3L ) { error( "Bad CRC" ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC32:Bad CRC"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return ZERROR; } Rxcount = (int) ( length - (end - buffer) ); error( "ReadDataFrameCRC32: %d %s", Rxcount, Zendnames[ d - GOTCRCE & 3 ] ); return d; case GOTCAN: error( "Sender Canceled" ); return ZCAN; case TIMEOUT: error( "TIMEOUT" ); return c; default: error( "Garbled data subpacket" ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC32:Garbled data subpacket"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return c; } } *buffer++ = (char) c; crc.update( c ); } error( "Data subpacket too long" ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC32:subpacket too long"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return ZERROR; } int Zmodem::ReadDataFrameCRC16( char *buffer, int length ) { int c; Crc16 crc( 0 ); char *end; int d; CString strLogTmp = _T(""); Rxcount = 0; end = buffer + length; while ( buffer <= end ) { if ( ( c = ReadEncodedByte() ) & ~0xff ) { crcfoo: switch ( c ) { case GOTCRCE: case GOTCRCG: case GOTCRCQ: case GOTCRCW: crc.update( (d = c) & 0xff ); if ( ( c = ReadEncodedByte()) & ~0xff ) goto crcfoo; crc.update( c ); if ( ( c = ReadEncodedByte() ) & ~0xff ) goto crcfoo; crc.update( c ); if ( crc.value() & 0xFFFF ) { error( "Bad CRC"); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC16:Bad CRC"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return ZERROR; } Rxcount = (int) ( length - ( end - buffer ) ); error( "ReadDataFrame: %d %s", Rxcount, Zendnames[ d - GOTCRCE & 3 ] ); return d; case GOTCAN: error( "Sender Canceled" ); return ZCAN; case TIMEOUT: error( "TIMEOUT" ); return c; default: error( "Garbled data subpacket" ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC16:Garbled data subpacket"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return c; } } *buffer++ = (char) c; crc.update( c ); } error( "Data subpacket too long" ); //log strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead:\t\tCRC16:subpacket too long"), __LINE__, GetTickCount() - dwBegin); PrintLogLast(strLogTmp); //log return ZERROR; } // The attention string processor has to process a couple of // special characters used to sleep and send breaks. void Zmodem::SendAttentionString() { int i = 0; int c; long timer; while ( TXSpaceUsed() > 0 ) //port->IdleFunction(); while ( ( c = attention_string[ i++ ] ) != 0 ) { switch ( c ) { case 0xde : timer = ReadTime() + 1000L; while ( ReadTime() < timer ) // port->IdleFunction(); break; case 0xdd : //port->Break(); break; default: SendChar( c ); } } } // This function is called by the receiver before exiting. void Zmodem::AckZFIN( void ) { int n; status( "AckZFIN" ); PackLongIntoHeader( 0L ); for ( n = 0 ; n < 7 ; n++ ) { /*port->FlushRXBuffer();*/ SendHexHeader( 4, ZFIN, transmitted_header ); switch ( ReadChar( 10000L ) ) { case 'O': ReadChar( 120 ); /* Discard 2nd 'O' */ status( "AckZFIN complete" ); return; case TIMEOUT: default: break; } } } // This utility routine has to scan the incoming data subpacket // for the file name and length. int Zmodem::OpenInputFile( CString Path, char *data ) { CString szFileName(data); Path+=szFileName; m_FileSize = GetFileSize(data + szFileName.GetLength() + 1);//这个地方把文件名之后的信息传进去 //log CString strLogTmp = _T(""); // strcpy( file_name, data ); strLogTmp.Empty(); strLogTmp.Format(_T("[%d] Duration: %d\t\t\t\t\t\tRead: %s"), __LINE__, GetTickCount() - dwBegin,data); PrintLogLast(strLogTmp); //log strcpy( file_name, data ); if (sscanf(data+strlen(data)+1, "%ld", &file_length ) < 1 ) file_length = -1L; file = fopen( Path.GetBuffer(Path.GetLength()), "wb" ); if (NULL == file) { DWORD dwErrNo = GetLastError(); CString strTmp = _T(""); if (LANG_ZHCN == g_iUILanguage) { strTmp.Format(_T("[%d] 打开文件失败!, 错误码 = %d"), __LINE__, dwErrNo); AfxMessageBox(strTmp.GetBuffer(0)); } else { strTmp.Format(_T("[%d] Open file failed!, error = %d"), __LINE__, dwErrNo); MessageBoxEx(NULL, strTmp, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)); } PrintLogLast(strTmp); return ZERROR; } return OK; } // File position values are longs packed into a four byt header. // The following two routines are resposible for packing and // unpacking the data. void Zmodem::PackLongIntoHeader( long header_data ) { transmitted_header[ ZP0 ] = (char) header_data; transmitted_header[ ZP1 ] = (char) ( header_data >> 8 ); transmitted_header[ ZP2 ] = (char) ( header_data >> 16 ); transmitted_header[ ZP3 ] = (char) ( header_data >> 24 ); } long Zmodem::UnpackHeaderIntoLong( char *header ) { long l; l = header[ ZP3 ] & 0xff; l = ( l << 8 ) | ( header[ ZP2 ] & 0xff ); l = ( l << 8 ) | ( header[ ZP1 ] & 0xff ); l = ( l << 8 ) | ( header[ ZP0 ] & 0xff ); return l; } // Hex headers need to send data in hex format. void Zmodem::SendHexEncodedChar( int c ) { static char *digits = "0123456789abcdef"; SendChar( digits[ ( c & 0xF0 ) >> 4 ] ); SendChar( digits[ c & 0xF ] ); } // This routine handles all the escape sequences necessary to send // control characters. void Zmodem::SendEncodedChar( int c ,bool b) { if ( c & 0x60 ) SendChar( last_char_sent = c ,b); else { switch ( c &= 0xff ) { case CR : case CR | 0x80 : if ( ( last_char_sent & 0x7f ) != '@' ) { SendChar( last_char_sent = c ,b); break; } // else fall through case ZDLE : case DLE : case XON : case XOFF : case DLE | 0x80 : case XON | 0x80 : case XOFF | 0x80 : SendChar( ZDLE ,b); c ^= 0x40; SendChar( last_char_sent = c ,b); break; default: SendChar( last_char_sent = c ,b); } } } // Read a byte, taking into account escape sequences, and checking // for the 5*CAN abort sequence. int Zmodem::ReadEncodedByte( void ) { int c; for ( ; ; ) { c = ReadChar( 10000L ); if ( c == ZDLE ) break; switch ( c ) { case XON : case XON | 0x80 : case XOFF : case XOFF | 0x80 : break; default: return c; } } for ( ; ; ) { if ( ( c = ReadChar( 10000L ) ) < 0 ) return c; if ( c == CAN && ( c = ReadChar( 10000L ) ) < 0 ) return c; if ( c == CAN && ( c = ReadChar( 10000L ) ) < 0 ) return c; if ( c == CAN && ( c = ReadChar( 10000L ) ) < 0 ) return c; switch ( c ) { case CAN: return GOTCAN; case ZCRCE: case ZCRCG: case ZCRCQ: case ZCRCW: return c | GOTFLAG; case ZRUB0: return 0x7f; case ZRUB1: return 0xff; case XOFF : case XOFF | 0x80 : case XON : case XON | 0x80 : break; default: if ( ( c & 0x60 ) == 0x40 ) return ( c ^ 0x40 ); else return ZERROR; } } } // This routine reads a raw data byte, throws out the parity bit and // ignores handshaking characters. int Zmodem::ReadUnencodedByte( void ) { int c; for ( ; ; ) { if ( ( c = ReadChar( 10000L ) ) < 0 ) return c; switch ( c &= 0x7f ) { case XON: case XOFF: continue; default: return c; } } } // When reading Hex headers, we need to convert hex values to a // usable format. int Zmodem::ReadHexByte( void ) { int c; int n; if ( ( c = ReadUnencodedByte() ) < 0 ) return c; n = c - '0'; if ( n > 9 ) n -= ( 'a' - ':' ); if ( n & ~0xF ) return ZERROR; if ( ( c = ReadUnencodedByte( )) < 0 ) return c; c -= '0'; if ( c > 9 ) c -= ( 'a' - ':' ); if ( c & ~0xF ) return ZERROR; c += ( n << 4 ); return c; } // The sender needs to get the RINIT frame before it can start // sending the file. This routine takes care of that. int Zmodem::GetRinitHeader( void ) { int i; for ( i = 0 ; i < 10 ; i++ ) { switch ( ReadHeader( received_header ) ) { case ZCHALLENGE: // Echo receiver's challenge number PackLongIntoHeader( received_file_position ); SendHexHeader( 4, ZACK, transmitted_header ); continue; case ZCOMMAND: // They didn't see our ZRQINIT PackLongIntoHeader( 0L ); SendHexHeader( 4, ZRQINIT, transmitted_header ); continue; case ZRINIT: receiver_wants_crc32 = received_header[ ZF0 ] & CANFC32; receiver_buffer_length = ( received_header[ ZP0 ] & 0xff ) + ( ( received_header[ ZP1 ] & 0xff ) << 8 ); return OK; case ZCAN: case TIMEOUT: return ZERROR; case ZRQINIT: if ( received_header[ ZF0 ] == ZCOMMAND ) continue; default: SendHexHeader( 4, ZNAK, transmitted_header ); continue; } } return ZERROR; } // This routine sends a data subpacket, which is used here to send // file names and file data. void Zmodem::SendDataFrame( char *buffer, int length, int frameend ) { Crc32 crc32( 0xFFFFFFFFL ); unsigned long crc32val; Crc16 crc16( 0 ); int i; status( "SendDataFrame: %d %s", length, Zendnames[ frameend - ZCRCE & 3 ] ); int nnlen = 0; if ( receiver_wants_crc32 ) { for ( i = 0 ; i < length ; i++ ) { SendEncodedChar( buffer[ i ] ,TRUE); crc32.update( buffer[ i ] & 0xff ); } SendChar( ZDLE ,TRUE); SendChar( frameend ,TRUE); crc32.update( frameend ); crc32val = ~crc32.value(); for ( i = 0 ; i < 4 ; i++ ) { SendEncodedChar( (int) crc32val ,TRUE); crc32val >>= 8; } } else { for ( i = 0 ; i < length ; i++ ) { SendEncodedChar( buffer[ i ] ,TRUE); crc16.update( buffer[ i ] & 0xff ); } SendChar( ZDLE ,TRUE); SendChar( frameend ,TRUE); crc16.update( frameend ); crc16.update( 0 ); crc16.update( 0 ); SendEncodedChar( crc16.value() >> 8 ,TRUE); SendEncodedChar( crc16.value() ,TRUE); } if ( frameend == ZCRCW ) SendChar( XON ,TRUE); SendCharToComm(); } // The sender sends a ZFIN frame just before exiting. void Zmodem::SendZFIN( void ) { for ( ; ; ) { PackLongIntoHeader( 0L ); SendHexHeader( 4, ZFIN, transmitted_header ); switch ( ReadHeader( received_header ) ) { case ZFIN: SendChar( 'O'); SendChar( 'O'); SendCharToComm(); case ZCAN: case TIMEOUT: return; } } } int Zmodem::SyncWithReceiver( int flag ) { int c; for ( ; ; ) { c = ReadHeader( received_header ); switch ( c ) { case ZCAN: case ZABORT: case ZFIN: case TIMEOUT: return ZERROR; case ZRPOS: if ( fseek( file, received_file_position, SEEK_SET ) ) return ZERROR; file_at_eof = 0; byte_count = last_reported_position = transmitted_file_position = received_file_position; last_sync_position = received_file_position; return c; case ZACK: last_reported_position = received_file_position; if ( flag || transmitted_file_position == received_file_position ) return ZACK; continue; case ZRINIT: case ZSKIP: fclose( file ); return c; case ZERROR: default: SendBinaryHeader( 4, ZNAK, transmitted_header ); continue; } } } long Zmodem::ReadTime( void ) { return 0; } //---------------------------------------------------------------------------------- int Zmodem::ReadBuff(long timeout) { /*暂时注释用新写法来写 int nCountError; nCountError = 0; if (m_BuffCount > 0) { m_BuffCount -= 1; if(m_BuffCount == 0) { return (*str & 0377); } else { return (*str++ & 0377); } } m_BuffCount = 0; memset(buff,0,BUFFSIZE); do { port->ZmodemReceiveDataDirectly(buff,&m_BuffCount); if (m_BuffCount != 0) { nCountError = 0; str = buff; break; } else { nCountError++; Sleep(50); } }while(nCountError < 40); if( nCountError == 40 ) { return TIMEOUT; } m_BuffCount -=1; if(m_BuffCount == 0) { return (*str & 0377); } else { return (*str++ & 0377); } */ int nCountError = 0; CString strTmp = _T(""); ClearReadBuf(); do { port->ZmodemReceiveDataDirectly(buff,&m_BuffCount); if (0 == m_BuffCount) { nCountError++; Sleep(50); } else if (m_BuffCount > BUFFSIZE) { strTmp.Format(_T("[%d] read buffersize is too big than 8K, read_buffer_size = %d"), __LINE__, m_BuffCount); PrintLogLast(strTmp); return 1; } else { return 1; } }while(nCountError < 240); strTmp.Format(_T("[%d] read buffersize is TIMEOUT"), __LINE__); PrintLogLast(strTmp); return TIMEOUT; } void Zmodem::ReadSettings(Settings ©) { copy.BaudRate = 115200; copy.Parity = 'N'; copy.WordLength = 8; copy.StopBits = 1; copy.Dtr = 1; copy.Rts = 0; copy.XonXoff = 0; copy.RtsCts = 0; copy.DtrDsr = 0; } int Zmodem::TXSpaceUsed( void ) { return (m_BuffCount - BUFFSIZE); } int Zmodem::GetFileSize(char *buffer) { char cFileSize[64]; memset(cFileSize, 0, 64); int nIndex = 0; while(buffer[nIndex] != ' ') { cFileSize[nIndex] = buffer[nIndex]; nIndex++; } return atoi(cFileSize); } void Zmodem::SendCharToComm() { port->ZmodemSendDataDirectly(m_WriteBuff, m_WriteBuffLength); memset(m_WriteBuff, 0, 8192); m_WriteBuffLength = 0; } void Zmodem::ClearReadBuf() { m_BuffCount = 0; m_nBufReadIndex = 0; memset(buff,0,BUFFSIZE); } void Zmodem::PrintLog(char *chPrtlog, int nLogLen) { ASSERT(NULL != chPrtlog); fwrite(chPrtlog,nLogLen,1,zmodemLog); fflush(zmodemLog); } void Zmodem::PrintLogLast(CString& strLog) { if (NULL == zmodemLog) { if (LANG_ZHCN == g_iUILanguage) AfxMessageBox(_T("无法写入device_log，日志文件点为空")); else MessageBoxEx(NULL, _T("Can't write device_log, log File point is NULL"), _T("LOG_ERROR"), MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)); return; } CString strOutPut = _T(""); strOutPut.Format(_T("%04d-%02d-%02d %02d:%02d:%02d.%03d %s \r\n"),g_sysCurTime.wYear, g_sysCurTime.wMonth, g_sysCurTime.wDay, g_sysCurTime.wHour, g_sysCurTime.wMinute, g_sysCurTime.wSecond, g_sysCurTime.wMilliseconds, strLog.GetBuffer(0)); fwrite(strOutPut.GetBuffer(0), 1, strOutPut.GetLength(), zmodemLog); fflush(zmodemLog); } int Zmodem::GetFileSize() { return m_FileSize; } int Zmodem::GetTransferPosit() { return m_ByteTransfer; } BOOL Zmodem::SendCancelString() { char chCancelString[] = { CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, CAN, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS }; return port->ZmodemSendDataDirectly( chCancelString, sizeof(chCancelString));//tmp }