/****************************************************************************/
/*									    */
/*		ZMP YAPP Overlay :-- Module 2				    */
/*									    */
/****************************************************************************/

#include "zmp.h"
#include "zmyapp.h"

/* Wait for a character -- return TRUE if timeout */
waitready()
{
	short timeout, status;

	status = FALSE;
	timeout = (State == S || State == S1) ? 200 : 1200;
	if (!mread(&Recvchar, 1, timeout)) { /* timed out */
		Ptype = TM;
		status = TRUE;
	}
	return status;
}

/* Get packet string */
getpkstr()
{
	short i;

	if (!waitready()) {
		Pklen = (unsigned short) Recvchar;
		if (Ptype == DT) {		/* don't buffer data packet */
 			if (Pklen == 0)
				Pklen = 256;
			for (i = 0; i < Pklen; i++) {
				if (waitready())
					return;
				*Rxptr++ = Recvchar;
			}
			Cpindex += Pklen;
		}
		else if (Pklen) {
			for (i = 0; i < Pklen; i++) {
				if (waitready())
					return;
				Pkbuff[i] = Recvchar;
			}
		}
	}
}


/* Get a packet */
getpack()
{
	Ptype = UK;
	if (!waitready()) {
		switch (Recvchar) {

			case ACK:
				if (!waitready()) {
					switch (Recvchar) {

						case 1:
							Ptype = RR;
							break;

						case 2:
							Ptype = RF;
							break;

						case 3:
							Ptype = AF;
							break;

						case 4:
							Ptype = AT;
							break;

						case 5:
							Ptype = CA;
							break;

						default:
							break;
					}
				}
				break;

			case ENQ:
				if (!waitready()) {
					switch (Recvchar) {
						case 1:
							Ptype = SI;
							break;

						case 2:
							Ptype = RI;
							break;

						default:
						/* un-implemented command */
							Ptype = UU;
							break;
					}
				}
				break;

			case SOH:
				Ptype = HD;
				getpkstr();
				break;

			case STX:
				Ptype = DT;
				getpkstr();
				break;

			case ETX:
				if (!waitready() && (Recvchar == 1))
					Ptype = EF;
				break;

			case EOT:
				if (!waitready() && (Recvchar == 1))
					Ptype = ET;
				break;

			case NAK:
				Ptype = NR;
				getpkstr();
				break;

			case CAN:
				Ptype = CN;
				getpkstr();
				break;

			case DLE:
				Ptype = TX;
				getpkstr();
				break;

			default:
				break;

		}
	}
	return (opabort());
}

/* Fill buf with count characters, padding with CTRL-Z */

filbuf(buf, count)
char *buf;
short count;
{
	static short c, m;

	c = m = newload(buf, count);
	if (m <= 0)
		return 0;
	while (m < count)
		buf[m++] = CTRLZ;
	return c;
}

/* Load buffer from disk */

newload(buf, count)
char *buf;
short count;
{
	static short j;

	j = 0;
	while (count--) {
		if (Incnt <= 0) {
			Incnt = read(Fd, Cpmbuf, Cpbufsize);
			Cpindex = 0;
			if (Incnt <= 0)
				break;
		}
		buf[j++] = Cpmbuf[Cpindex++];
		--Incnt;
	}
	return (j ? j : -1);
}

/*
 * Close the receive dataset, return OK or NERROR
 */
closeit()
{  
	static int status;
	int length;

	status = OK;
	if (Cpindex) {
		length = 128*roundup(Cpindex,128);
		status = ((write(Fd,Cpmbuf,length) == length) ? OK : NERROR);
		Cpindex = 0;
		Rxptr = Cpmbuf;
	}
	if (status == NERROR)
		zperr("Disk write error",TRUE);
	if (close(Fd)==NERROR) {
		Fd = -1;
		zperr("File close error",TRUE);
		return NERROR;
	}
	return status;
}

/* Display text in TX packet */

disppacket()
{
	short i;
	char temp[258];

	for (i = 0; i < Pklen; i++)
		temp[i] = Pkbuff[i];
	temp[i] = '\0';		/* null-terminate */
	printf("\n%s\n",temp);
}

/* Prints message from list (which we don't have) */
showmsg(i)
short i;
{
	report(MESSAGE, Messages[i]);
}

/* Display header */
showheader()
{
	/* Leave null for now */
}

/* Display bytes */
showbytes()
{
	/* Leave null for now */
}

/* Display StateDesc[i] (?) */
escmsg(i)
short i;
{
	report(STATUS, StateDesc[i]);
}

/* Display current value of State if changed from last time */
showstate()
{
	if (State != Oldstate) {
		escmsg((short) State);
		Oldstate = State;
	}
}

/* Return TNC to command mode */
cmdmode()
{
	mswait(2000);		/* wait 2 secs */
	mcharout('\003');
	mswait(50);
	mcharout('\003');	/* 3 x ctl-C */
	mswait(50);
	mcharout('\003');
	mswait(2000);		/* wait 2 secs */
}

zperr(string,incrflag)
char *string;
int incrflag;
{
	clrline(MESSAGE);
	report(MESSAGE,string);
	if (incrflag)
		dreport(ERRORS,++Errors);
}

dreport(row,value)
int row, value;
{
	static char buf[7];

	report(row,itoa(value,buf));
}

lreport(row, value)
short row;
long value;
{
	char buf[20];

	report(row, ltoa(value, buf));
}

clrline(line)
int line;
{
	report(line,"                ");
}

clrreports()
{
	static short i;

	for (i = 4; i < 14; i++)
		clrline(i);
}

/* Test if file exists, rename to .BAK if so */
testexist(filename)
char *filename;
{
	int fd;
	char *p, newfile[20], *index();

	if ((fd = open(filename,0)) != UBIOT) {
		close(fd);
		strcpy(newfile,filename);
		if (p = index(newfile,'.'))
			*p = '\0';	/* stop at dot */
		strcat(newfile,".bak");
		unlink(newfile);	/* remove any .bak already there */
		rename(filename,newfile);
	}
}

checkpath(name)  /* eliminate bad paths in receive */
char *name;
{
	char *p, c, *index();
	short i;
	static char badchar[] = ",;:_[]=<>/";	/* disallowed f/n characters */

	for (p=name; *p; p++) {             /* dump strange characters */
		if (!(((c = *p) > '!') && (c < 0x7f) && !index(badchar,c))) {
			*p = '\0';
			strcat(name,p+1);
		}
	}
	if ((i = index(name,'.') - name) > 8) {
		p = name + i;
		name[8] = '.';
		name[9] = '\0';
		p[3] = '\0';
		strcat(name,p);
	}
	name[12] = '\0';
	report(PATHNAME,name);
}

/* Output a string of length l to the modem */
xmitstr(str, l)
char *str;
short l;
{
	while (l--)
		mcharout(*str++);
}

/* itoa - convert n to characters in s. */
char *itoa(n, s)
char s[];
short n;
{
	static short c, k;
	static char *p, *q;

	if ((k = n) < 0)	/* record sign */
		n = -n; 	/* make n positive */
	q = p = s;
	do {		/* generate digits in reverse order */
		*p++ = n % 10 + '0';  /* get next digit */
	} while ((n /= 10) > 0);	/* delete it */
	if (k < 0) *p++ = '-';
	*p = 0;
/* reverse string in place */
	while (q < --p) {
		c = *q; *q++ = *p; *p = c; }
	return (s);
}

/* ltoa - convert n to characters in s. */
char *ltoa(n, s)
char s[];
long n;
{
	static long c, k;
	static char *p, *q;

	if ((k = n) < 0)	/* record sign */
		n = -n; 	/* make n positive */
	q = p = s;
	do {		/* generate digits in reverse order */
		*p++ = n % 10 + '0';  /* get next digit */
	} while ((n /= 10) > 0);	/* delete it */
	if (k < 0) *p++ = '-';
	*p = 0;
/* reverse string in place */
	while (q < --p) {
		c = *q; *q++ = *p; *p = c; }
	return (s);
}

/************************* End of Part 2 *************************************/