zmodem.c

/* zmodem.c */

/* Synchronet ZMODEM Functions */

/******************************************************************************/
/* Project : Unite!       File : zmodem general        Version : 1.02         */
/*                                                                            */
/* (C) Mattheij Computer Service 1994                                         */
/*
 *	Date: Thu, 19 Nov 2015 10:10:02 +0100
 *	From: Jacques Mattheij
 *	Subject: Re: zmodem license
 *	To: Stephen Hurd, Fernando Toledo
 *	CC: Rob Swindell
 *
 *	Hello there to all of you,
 *
 *	So, this email will then signify as the transfer of any and all rights I
 *	held up to this point with relation to the copyright of the zmodem
 *	package as released by me many years ago and all associated files to
 *	Stephen Hurd. Fernando Toledo and Rob Swindell are named as
 *	witnesses to this transfer.
 *
 *	...
 *
 *	best regards,
 *
 *	Jacques Mattheij
 ******************************************************************************/

/*
 * zmodem primitives and other code common to zmtx and zmrx
 */

#include <stdio.h>
#include <string.h>
#include <stdarg.h>	/* va_list */
#include <sys/stat.h>	/* struct stat */

#include "genwrap.h"
#include "dirwrap.h"	/* getfname() */
#include "filewrap.h"	/* filelength() */

#include "zmodem.h"
#include "crc16.h"
#include "crc32.h"

#include "sexyz.h"
#include "telnet.h"

#define ENDOFFRAME	2
#define FRAMEOK		1
#define TIMEOUT			-1	/* rx routine did not receive a character within timeout */
#define INVHDR			-2	/* invalid header received; but within timeout */
#define ABORTED			-3	/* Aborted *or* disconnected */
#define SUBPKTOVERFLOW  -4	/* Subpacket received more than block length */
#define CRCFAILED		-5	/* Failed CRC comparison */
#define INVALIDSUBPKT	-6	/* Invalid Subpacket Type */
#define ZDLEESC 0x8000	/* one of ZCRCE; ZCRCG; ZCRCQ or ZCRCW was received; ZDLE escaped */

#define BADSUBPKT	0x80

#define SEND_SUCCESS	0

#define HDRLEN     5	/* size of a zmodem header */

#define STRIPPED_PARITY(c)	((c) & 0x7f)

static int lprintf(zmodem_t* zm, int level, const char *fmt, ...)
{
	va_list argptr;
	char	sbuf[1024];

	if(zm->lputs==NULL)
		return(-1);
	if(zm->log_level != NULL)
		if(level > *zm->log_level)
			return 0;

    va_start(argptr,fmt);
    vsnprintf(sbuf,sizeof(sbuf),fmt,argptr);
	sbuf[sizeof(sbuf)-1]=0;
    va_end(argptr);
    return(zm->lputs(zm->cbdata,level,sbuf));
}

static BOOL is_connected(zmodem_t* zm)
{
	if(zm->is_connected!=NULL)
		return(zm->is_connected(zm->cbdata));
	return(TRUE);
}

static BOOL is_cancelled(zmodem_t* zm)
{
	if(zm->is_cancelled!=NULL)
		return(zm->cancelled=zm->is_cancelled(zm->cbdata));
	return(zm->cancelled);
}

static BOOL is_data_waiting(zmodem_t* zm, unsigned timeout)
{
	if(zm->data_waiting)
		return(zm->data_waiting(zm->cbdata, timeout));
	return(FALSE);
}

static char *chr(int ch)
{
	static char str[25];

	switch(ch) {
		case TIMEOUT:			return("TIMEOUT");
		case ABORTED:			return("ABORTED");
		case SUBPKTOVERFLOW:	return "Subpacket Overflow";
		case CRCFAILED:			return "CRC ERROR";
		case INVALIDSUBPKT:		return "Invalid Subpacket";
		case ZRQINIT:			return("ZRQINIT");
		case ZRINIT:			return("ZRINIT");
		case ZSINIT:			return("ZSINIT");
		case ZACK:				return("ZACK");
		case ZFILE:				return("ZFILE");
		case ZSKIP:				return("ZSKIP");
		case ZCRC:				return("ZCRC");
		case ZNAK:				return("ZNAK");
		case ZABORT:			return("ZABORT");
		case ZFIN:				return("ZFIN");
		case ZRPOS:				return("ZRPOS");
		case ZDATA:				return("ZDATA");
		case ZEOF:				return("ZEOF");
		case ZFERR:				return("ZFERR");
		case ZPAD:				return("ZPAD");
		case ZCAN:				return("ZCAN");
		case ZDLE:				return("ZDLE");
		case ZDLEE:				return("ZDLEE");
		case ZBIN:				return("ZBIN");
		case ZHEX:				return("ZHEX");
		case ZBIN32:			return("ZBIN32");
		case ZRESC:				return("ZRESC");
		case ZCRCE:				return("ZCRCE");
		case ZCRCG:				return("ZCRCG");
		case ZCRCQ:				return("ZCRCQ");
		case ZCRCW:				return("ZCRCW");
		case XON:				return "XON";
		case XOFF:				return "XOFF";
	}
	if(ch<0)
		sprintf(str,"%d",ch);
	else if(ch>=' ' && ch<='~')
		sprintf(str,"'%c' (%02Xh)",(uchar)ch,(uchar)ch);
	else
		sprintf(str,"%u (%02Xh)",(uchar)ch,(uchar)ch);
	return(str);
}

static char* frame_desc(int frame)
{
	static char str[25];

	if(frame==TIMEOUT)
		return "TIMEOUT";

	if(frame==INVHDR)
		return "Invalid Header";

	if(frame==ABORTED)
		return "Aborted";

	if(frame >= 0 && (frame&BADSUBPKT)) {
		strcpy(str,"BAD ");
		switch(frame&~BADSUBPKT) {
			case ZRQINIT:		strcat(str,"ZRQINIT");		break;
			case ZRINIT:		strcat(str,"ZRINIT");		break;
			case ZSINIT:		strcat(str,"ZSINIT");		break;
			case ZACK:			strcat(str,"ZACK");			break;
			case ZFILE:			strcat(str,"ZFILE");		break;
			case ZSKIP:			strcat(str,"ZSKIP");		break;
			case ZNAK:			strcat(str,"ZNAK");			break;
			case ZABORT:		strcat(str,"ZABORT");		break;
			case ZFIN:			strcat(str,"ZFIN");			break;
			case ZRPOS:			strcat(str,"ZRPOS");		break;
			case ZDATA:			strcat(str,"ZDATA");		break;
			case ZEOF:			strcat(str,"ZEOF");			break;
			case ZFERR:			strcat(str,"ZFERR");		break;
			case ZCRC:			strcat(str,"ZCRC");			break;
			case ZCHALLENGE:	strcat(str,"ZCHALLENGE");	break;
			case ZCOMPL:		strcat(str,"ZCOMPL");		break;
			case ZCAN:			strcat(str,"ZCAN");			break;
			case ZFREECNT:		strcat(str,"ZFREECNT");		break;
			case ZCOMMAND:		strcat(str,"ZCOMMAND");		break;
			case ZSTDERR:		strcat(str,"ZSTDERR");		break;
			default:
				sprintf(str,"Unknown (%08X)", frame);
				break;
		}
	} else
		return chr(frame);
	return(str);
}

ulong frame_pos(zmodem_t* zm, int type)
{
	switch(type) {
		case ZRPOS:
		case ZACK:
		case ZEOF:
		case ZDATA:
			return(zm->rxd_header_pos);
	}

	return 0;
}

/*
 * read bytes as long as rdchk indicates that
 * more data is available.
 */

void zmodem_recv_purge(zmodem_t* zm, unsigned timeout)
{
	int c;

	while((c = zm->recv_byte(zm->cbdata, timeout)) >= 0) {
		lprintf(zm, LOG_DEBUG, "Purging data in receive buffer: %s", chr(c));
	}
}

/*
 * Flush the output buffer
 */
void zmodem_flush(zmodem_t* zm)
{
	if(zm->flush!=NULL)
		zm->flush(zm);
}

/*
 * transmit a character.
 * this is the raw modem interface
 */
/* Returns 0 on success */
int zmodem_send_raw(zmodem_t* zm, unsigned char ch)
{
	int	result;

	if((result = zm->send_byte(zm->cbdata, ch, zm->send_timeout)) != SEND_SUCCESS)
		lprintf(zm, LOG_ERR, "%s ERROR: %d", __FUNCTION__, result);
	else
		zm->last_sent = ch;

	return result;
}

/*
 * transmit a character ZDLE escaped
 */

int zmodem_send_esc(zmodem_t* zm, unsigned char c)
{
	int	result;

	if((result = zmodem_send_raw(zm, ZDLE)) != SEND_SUCCESS) {
		lprintf(zm, LOG_ERR, "%s ERROR: %d", __FUNCTION__, result);
		return result;
	}
	/*
	 * exclusive or; not an or so ZDLE becomes ZDLEE
	 */
	return zmodem_send_raw(zm, (uchar)(c ^ 0x40));
}

/*
 * transmit a character; ZDLE escaping if appropriate
 */

int zmodem_tx(zmodem_t* zm, unsigned char c)
{
	int result;

	switch (c) {
		case DLE:
		case DLE|0x80:          /* even if high-bit set */
		case XON:
		case XON|0x80:
		case XOFF:
		case XOFF|0x80:
		case ZDLE:
			return zmodem_send_esc(zm, c);
		case CR:
		case CR|0x80:
			if(zm->escape_ctrl_chars && (zm->last_sent&0x7f) == '@')
				return zmodem_send_esc(zm, c);
			break;
		case TELNET_IAC:
			if(zm->escape_telnet_iac) {
				if((result=zmodem_send_raw(zm, ZDLE)) != SEND_SUCCESS)
					return(result);
				return zmodem_send_raw(zm, ZRUB1);
			}
			break;
		default:
			if(zm->escape_ctrl_chars && (c&0x60)==0)
				return zmodem_send_esc(zm, c);
			break;
	}
	/*
	 * anything that ends here is so normal we might as well transmit it.
	 */
	return zmodem_send_raw(zm, c);
}

/**********************************************/
/* Output single byte as two hex ASCII digits */
/**********************************************/
int zmodem_send_hex(zmodem_t* zm, uchar val)
{
	char* xdigit="0123456789abcdef";
	int	result;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %02X",val);

	if((result=zmodem_send_raw(zm, xdigit[val>>4])) != SEND_SUCCESS)
		return result;
	return zmodem_send_raw(zm, xdigit[val&0xf]);
}

int zmodem_send_padded_zdle(zmodem_t* zm)
{
	int result;

	if((result=zmodem_send_raw(zm, ZPAD)) != SEND_SUCCESS)
		return result;
	if((result=zmodem_send_raw(zm, ZPAD)) != SEND_SUCCESS)
		return result;
	return zmodem_send_raw(zm, ZDLE);
}

/*
 * transmit a hex header.
 * these routines use tx_raw because we're sure that all the
 * characters are not to be escaped.
 */
int zmodem_send_hex_header(zmodem_t* zm, unsigned char * p)
{
	int i;
	int result;
	uchar type=*p;
	unsigned short int crc;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %s", chr(type));

	if((result=zmodem_send_padded_zdle(zm)) != SEND_SUCCESS)
		return result;

	if((result=zmodem_send_raw(zm, ZHEX)) != SEND_SUCCESS)
		return result;

	/*
 	 * initialise the crc
	 */

	crc = 0;

	/*
 	 * transmit the header
	 */

	for(i=0;i<HDRLEN;i++) {
		if((result=zmodem_send_hex(zm, *p)) != SEND_SUCCESS)
			return result;
		crc = ucrc16(*p, crc);
		p++;
	}

	/*
 	 * update the crc as though it were zero
	 */

	/*
	 * transmit the crc
	 */

	if((result=zmodem_send_hex(zm, (uchar)(crc>>8))) != SEND_SUCCESS)
		return result;
	if((result=zmodem_send_hex(zm, (uchar)(crc&0xff))) != SEND_SUCCESS)
		return result;

	/*
	 * end of line sequence
	 */

	if((result=zmodem_send_raw(zm, '\r')) != SEND_SUCCESS)
		return result;
	if((result=zmodem_send_raw(zm, '\n')) != SEND_SUCCESS)	/* FDSZ sends 0x8a instead of 0x0a */
		return result;

	if(type!=ZACK && type!=ZFIN)
		result=zmodem_send_raw(zm, XON);

	zmodem_flush(zm);

	return(result);
}

/*
 * Send ZMODEM binary header hdr
 */

int zmodem_send_bin32_header(zmodem_t* zm, unsigned char * p)
{
	int i;
	int result;
	uint32_t crc;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %s", chr(*p));

	if((result=zmodem_send_padded_zdle(zm)) != SEND_SUCCESS)
		return result;

	if((result=zmodem_send_raw(zm, ZBIN32)) != SEND_SUCCESS)
		return result;

	crc = 0xffffffffL;

	for(i=0;i<HDRLEN;i++) {
		crc = ucrc32(*p,crc);
		if((result=zmodem_tx(zm, *p++)) != SEND_SUCCESS)
			return result;
	}

	crc = ~crc;

	if((result=	zmodem_tx(zm, (uchar)((crc      ) & 0xff))) != SEND_SUCCESS)
		return result;
	if((result=	zmodem_tx(zm, (uchar)((crc >>  8) & 0xff))) != SEND_SUCCESS)
		return result;
	if((result=	zmodem_tx(zm, (uchar)((crc >> 16) & 0xff))) != SEND_SUCCESS)
		return result;
	return		zmodem_tx(zm, (uchar)((crc >> 24) & 0xff));
}

int zmodem_send_bin16_header(zmodem_t* zm, unsigned char * p)
{
	int i;
	int result;
	unsigned int crc;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %s", chr(*p));

	if((result=zmodem_send_padded_zdle(zm)) != SEND_SUCCESS)
		return result;

	if((result=zmodem_send_raw(zm, ZBIN)) != SEND_SUCCESS)
		return result;

	crc = 0;

	for(i=0;i<HDRLEN;i++) {
		crc = ucrc16(*p,crc);
		if((result=zmodem_tx(zm, *p++)) != SEND_SUCCESS)
			return result;
	}

	if((result=	zmodem_tx(zm, (uchar)(crc >> 8))) != SEND_SUCCESS)
		return result;
	return		zmodem_tx(zm, (uchar)(crc&0xff));
}


/*
 * transmit a header using either hex 16 bit crc or binary 32 bit crc
 * depending on the receivers capabilities
 * we dont bother with variable length headers. I dont really see their
 * advantage and they would clutter the code unneccesarily
 */

int zmodem_send_bin_header(zmodem_t* zm, unsigned char * p)
{
	if(zm->can_fcs_32 && !zm->want_fcs_16)
		return zmodem_send_bin32_header(zm, p);
	return zmodem_send_bin16_header(zm, p);
}

/*
 * data subpacket transmission
 */

int zmodem_send_data32(zmodem_t* zm, uchar subpkt_type, unsigned char * p, size_t l)
{
	int	result;
	uint32_t crc;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %s (%u bytes)", chr(subpkt_type), l);

	crc = 0xffffffffl;

	while(l > 0) {
		crc = ucrc32(*p,crc);
		if((result=zmodem_tx(zm, *p++)) != SEND_SUCCESS)
			return result;
		l--;
	}

	crc = ucrc32(subpkt_type, crc);

	if((result=zmodem_send_raw(zm, ZDLE)) != SEND_SUCCESS)
		return result;
	if((result=zmodem_send_raw(zm, subpkt_type)) != SEND_SUCCESS)
		return result;

	crc = ~crc;

	if((result=	zmodem_tx(zm, (uchar) ((crc      ) & 0xff))) != SEND_SUCCESS)
		return result;
	if((result=	zmodem_tx(zm, (uchar) ((crc >> 8 ) & 0xff))) != SEND_SUCCESS)
		return result;
	if((result=	zmodem_tx(zm, (uchar) ((crc >> 16) & 0xff))) != SEND_SUCCESS)
		return result;
	return		zmodem_tx(zm, (uchar) ((crc >> 24) & 0xff));
}

int zmodem_send_data16(zmodem_t* zm, uchar subpkt_type,unsigned char * p, size_t l)
{
	int	result;
	unsigned short crc;

//	lprintf(zm, LOG_DEBUG, __FUNCTION__ " %s (%u bytes)", chr(subpkt_type), l);

	crc = 0;

	while(l > 0) {
		crc = ucrc16(*p,crc);
		if((result=zmodem_tx(zm, *p++)) != SEND_SUCCESS)
			return result;
		l--;
	}

	crc = ucrc16(subpkt_type,crc);

	if((result=zmodem_send_raw(zm, ZDLE)) != SEND_SUCCESS)
		return result;
	if((result=zmodem_send_raw(zm, subpkt_type)) != SEND_SUCCESS)
		return result;

	if((result=	zmodem_tx(zm, (uchar)(crc >> 8))) != SEND_SUCCESS)
		return result;
	return		zmodem_tx(zm, (uchar)(crc&0xff));
}

BOOL zmodem_end_of_frame(int subpkt_type)
{
	return subpkt_type == ZCRCW || subpkt_type == ZCRCE;
}

/*
 * send a data subpacket using crc 16 or crc 32 as desired by the receiver
 */

int zmodem_send_data_subpkt(zmodem_t* zm, uchar subpkt_type, unsigned char* data, size_t len)
{
	int result;

	if(zmodem_end_of_frame(subpkt_type))
		zm->frame_in_transit=FALSE;
	else	/* other subpacket (mid-frame) */
		zm->frame_in_transit=TRUE;

	if(!zm->want_fcs_16 && zm->can_fcs_32) {
		if((result=zmodem_send_data32(zm, subpkt_type, data, len)) != SEND_SUCCESS)
			return result;
	}
	else {
		if((result=zmodem_send_data16(zm, subpkt_type, data, len)) != SEND_SUCCESS)
			return result;
	}

	if(subpkt_type == ZCRCW)
		result=zmodem_send_raw(zm, XON);

	zmodem_flush(zm);

	return result;
}

int zmodem_send_data(zmodem_t* zm, uchar subpkt_type, unsigned char* data, size_t len)
{
	if(!zm->frame_in_transit)	{ /* Start of frame, include ZDATA header */
		lprintf(zm, LOG_DEBUG, "%lu %s Start of frame: %s"
			,(ulong)zm->current_file_pos, __FUNCTION__, chr(subpkt_type));
		zmodem_send_pos_header(zm, ZDATA, (uint32_t)zm->current_file_pos, /* Hex? */ FALSE);
	}

	return zmodem_send_data_subpkt(zm, subpkt_type, data, len);
}

int zmodem_send_pos_header(zmodem_t* zm, int type, int32_t pos, BOOL hex)
{
	uchar header[5];

	lprintf(zm, LOG_DEBUG, "%lu %s %s", (ulong)pos, __FUNCTION__, chr(type));
	header[0]   = type;
	header[ZP0] = (uchar) (pos        & 0xff);
	header[ZP1] = (uchar)((pos >>  8) & 0xff);
	header[ZP2] = (uchar)((pos >> 16) & 0xff);
	header[ZP3] = (uchar)((pos >> 24) & 0xff);

	if(hex)
		return zmodem_send_hex_header(zm, header);
	else
		return zmodem_send_bin_header(zm, header);
}

int zmodem_send_ack(zmodem_t* zm, int32_t pos)
{
	return zmodem_send_pos_header(zm, ZACK, pos, /* Hex? */ TRUE);
}

int zmodem_send_zfin(zmodem_t* zm)
{
	unsigned char zfin_header[] = { ZFIN, 0, 0, 0, 0 };

	lprintf(zm, LOG_NOTICE, "%lu Finishing Session (Sending ZFIN)", (ulong)zm->current_file_pos);
	return zmodem_send_hex_header(zm,zfin_header);
}

int zmodem_send_zabort(zmodem_t* zm)
{
	lprintf(zm, LOG_WARNING, "%lu Aborting Transfer (Sending ZABORT)", (ulong)zm->current_file_pos);
	return zmodem_send_pos_header(zm, ZABORT, 0, /* Hex? */ TRUE);
}

int zmodem_send_znak(zmodem_t* zm)
{
	lprintf(zm, LOG_INFO, "%lu Sending ZNAK", (ulong)zm->current_file_pos);
	return zmodem_send_pos_header(zm, ZNAK, 0, /* Hex? */ TRUE);
}

int zmodem_send_zskip(zmodem_t* zm)
{
	lprintf(zm, LOG_INFO, "%lu Sending ZSKIP", (ulong)zm->current_file_pos);
	return zmodem_send_pos_header(zm, ZSKIP, 0L, /* Hex? */ TRUE);
}

int zmodem_send_zeof(zmodem_t* zm)
{
	lprintf(zm, LOG_INFO, "%lu Sending End-of-File (ZEOF) frame", (ulong)zm->current_file_pos);
	return zmodem_send_pos_header(zm, ZEOF, (int32_t)zm->current_file_pos, /* Hex? */ TRUE);
}


/*
 * rx_raw ; receive a single byte from the line.
 * reads as many are available and then processes them one at a time
 * check the data stream for 5 consecutive CAN characters;
 * and if you see them abort. this saves a lot of clutter in
 * the rest of the code; even though it is a very strange place
 * for an exit. (but that was what session abort was all about.)
 */

int zmodem_recv_raw(zmodem_t* zm)
{
	int c;
	unsigned attempt;

	for(attempt=0; attempt < zm->recv_timeout; attempt++) {
		if((c=zm->recv_byte(zm->cbdata,1 /* second timeout */)) >= 0)
			break;
		if(is_cancelled(zm))
			return(ZCAN);
		if(!is_connected(zm))
			return(ABORTED);
		lprintf(zm, LOG_DEBUG, "%s Received NO INPUT (attempt %u of %u)"
			,__FUNCTION__, attempt + 1, zm->recv_timeout);
	}
	if(attempt >= zm->recv_timeout) {
		lprintf(zm, LOG_WARNING, "%lu %s TIMEOUT (%u seconds)"
			,(ulong)zm->current_file_pos, __FUNCTION__, attempt);
		return TIMEOUT;
	}

	if(c == CAN) {
		zm->n_cans++;
		if(zm->n_cans == 5) {
			zm->cancelled=TRUE;
			lprintf(zm, LOG_WARNING, "%lu Canceled remotely", (ulong)zm->current_file_pos);
/*			return(TIMEOUT);	removed June-12-2005 */
		}
	}
	else {
		zm->n_cans = 0;
	}

	return c;
}

/*
 * rx; receive a single byte undoing any escaping at the
 * sending site. this bit looks like a mess. sorry for that
 * but there seems to be no other way without incurring a lot
 * of overhead. at least like this the path for a normal character
 * is relatively short.
 */

int zmodem_rx(zmodem_t* zm)
{
	int c;

	/*
	 * outer loop for ever so for sure something valid
	 * will come in; a timeout will occur or a session abort
	 * will be received.
	 */

	while(is_connected(zm) && !is_cancelled(zm)) {

		do {
			switch(c = zmodem_recv_raw(zm)) {
				case ZDLE:
					break;
				case XON:
				case XON|0x80:
				case XOFF:
				case XOFF|0x80:
					lprintf(zm,LOG_WARNING, "%lu Dropping flow ctrl char: %s"
						,(ulong)zm->current_file_pos, chr(c));
					continue;
				default:
					if(c < 0)
						return c;
					/*
	 				 * if all control characters should be escaped and
					 * this one wasn't then its spurious and should be dropped.
					 */
					if(zm->escape_ctrl_chars && (c >= 0) && (c & 0x60) == 0) {
						lprintf(zm,LOG_WARNING, "%lu Dropping unescaped ctrl char: %s"
							,(ulong)zm->current_file_pos, chr(c));
						continue;
					}
					/*
					 * normal character; return it.
					 */
					return c;
			}
			break;
		} while(!is_cancelled(zm));

		/*
	 	 * ZDLE encoded sequence or session abort.
		 * (or something illegal; then back to the top)
		 */

		while(!is_cancelled(zm)) {

			switch(c=zmodem_recv_raw(zm)) {
				case XON:
				case XON|0x80:
				case XOFF:
				case XOFF|0x80:
				case ZDLE:
					lprintf(zm,LOG_WARNING, "%lu Dropping escaped flow ctrl char: %s"
						,(ulong)zm->current_file_pos, chr(c));
					continue;
				/*
				 * these four are really nasty.
				 * for convenience we just change them into
				 * special characters by setting a bit outside the
				 * first 8. that way they can be recognized and still
				 * be processed as characters by the rest of the code.
				 */
				case ZCRCE:
				case ZCRCG:
				case ZCRCQ:
				case ZCRCW:
//					lprintf(zm,LOG_DEBUG, "%lu Encoding data subpacket type: %s", (ulong)zm->current_file_pos, chr(c));
					return (c | ZDLEESC);
				case ZRUB0:
					return 0x7f;
				case ZRUB1:
					return 0xff;
				default:
					if(c < 0)
						return c;

					if(zm->escape_ctrl_chars && (c & 0x60) == 0) {
						/*
						 * a not escaped control character; probably
						 * something from a network. just drop it.
						 */
						lprintf(zm,LOG_WARNING, "%lu Dropping unescaped ctrl char: %s"
							,(ulong)zm->current_file_pos, chr(c));
						continue;
					}
					/*
					 * legitimate escape sequence.
					 * rebuild the original and return it.
					 */
					if((c & 0x60) == 0x40) {
						return c ^ 0x40;
					}
					lprintf(zm,LOG_WARNING, "%lu Illegal sequence: ZDLE %s"
						,(ulong)zm->current_file_pos, chr(c));
					break;
			}
			break;
		}
	}

	/*
	 * not reached (unless canceled).
	 */

	return ABORTED;
}

/*
 * receive a data subpacket as dictated by the last received header.
 * return 2 with correct packet and end of frame
 * return 1 with correct packet frame continues
 * return 0 with incorrect frame.
 * return TIMEOUT with a timeout
 * if an acknowledgment is requested it is generated automatically
 * here.
 */

/*
 * data subpacket reception
 */

int zmodem_recv_data32(zmodem_t* zm, unsigned char * p, unsigned maxlen, unsigned* len, int* type)
{
	int c;
	uint32_t rxd_crc;
	uint32_t crc;
	int subpkt_type;

//	lprintf(zm,LOG_DEBUG, __FUNCTION___);

	*type = INVALIDSUBPKT;