/*********************** YAPP overlay for ZMP ***************************/
/*									*/
/*	rjm 8/1/89							*/
/*									*/
/*									*/
/*	This code is translated from the Pascal code originally written */
/*	by Jeffrey B. Jacobsen, 1986					*/
/*									*/
/************************************************************************/

#define YM

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

ovmain()
{
	char c;

	Errors = 0;
	QuitFlag = FALSE;
	printf("\n\t\tYAPP Transfer\n");
	do
		printf("\n<S>end or <R>eceive, cr to abort? ");
	while ((c = toupper(chrin())) != 'S' && c != 'R' && c != CR);
	if (c == 'S')
		yapptx();
	else
		if (c == 'R')
			yapprx();
}

/* Perform YAPP send */
yapptx()
{
	short count, i;
	unsigned short length;

	if (count = getpathname("(s) to send")) {
		Txbuf = malloc(256);
		if (allocerror(Txbuf))
			return NERROR;
		Cpmbuf = grabmem(&Cpbufsize);
		if (allocerror(Cpmbuf)) {
			free(Txbuf);
			return NERROR;
		}
		putlabel("SEND FILE Mode:  Press ESC to Abort...");
		savecurs();
		hidecurs();
		box();
		report(PROTOCOL,"YAPP Send");
		for (i = 0; i < count; i++) {
			Cpindex = Incnt = 0;
			strcpy(Pathname, Pathlist[i]);
			if ((Fd = open(Pathname, 0)) == UBIOT) {
				zperr("Can't open file.",TRUE);
				wait(2);
			}
			else {
				fstat(Pathname, &Fs);
				length = Fs.records;
				Nrbytes = (long) length * 128L;
				report(PATHNAME, Pathname);
				lreport(FILESIZE, Nrbytes);
				State = S;
				xfer();
			}
			if (Fd >= 0)
				close(Fd);
			Fd = -1;
			clrreports();
		}
		showcurs();
		restcurs();
		free(Cpmbuf);
		free(Txbuf);
	}
}


/* Perform YAPP receive */
yapprx()
{
	Cpmbuf = grabmem(&Cpbufsize);
	if (allocerror(Cpmbuf)) {
		free(Secbuf);
		return NERROR;
	}
	putlabel("RECEIVE FILE Mode:  Press ESC to Abort...");
	savecurs();
	hidecurs();
	box();
	report(PROTOCOL,"YAPP Receive");
	Cpindex = 0;
	Rxptr = Cpmbuf;
	State = R;
	Xferok = FALSE;
	xfer();
	if (!Xferok)
		unlink(Pathname);	/* bad transfer, erase it */
	free(Cpmbuf);
	showcurs();
	restcurs();
}

/* Do transfer (either way */
xfer()
{
	Oldstate = Null;
	*Xferhdr = '\0';
	Xfercnt = 0L;
	mcharout('\003');	/* Ensure TNC in command mode */
	mswait(500);
	mstrout("T\r",FALSE);	/* Put TNC into transparent mode */
	mswait(50);
	*Txtbuff = '\0';
	do {
		showstate();	/* display State */
		switch (State) {

			case S:
				sendinit();
				break;

			case S1:
				Snd_i_retry();
				break;

			case SH:
				sendhdr();
				break;

			case SD:
				senddata();
				break;

			case SE:
				sendeof();
				break;

			case ST:
				sendeot();
				break;

			case R:
				receive();
				break;

			case RH:
				rcvhdr();
				break;

			case RD:
				rcvdata();
				break;

			case Abort:
				cancel();
				break;

			case CW:
				canwait();
				break;

			case C:
				canrecd();
				break;

			default:
				break;

		}
	}
		while (State != Start && !opabort());
	if (opabort())
		cancel();
	putchar('\007');
	mswait(1000);
	cmdmode();		/* Return TNC to command mode */
	mstrout("conv\r", FALSE);	/* and then to converse mode */
}

/* Initialise send */
sendinit()
{
	Snd_i_count = 0;
	Outstr[0] = ENQ;
	Outstr[1] = 1;
	xmitstr(Outstr,2);
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case TM:
			State = S1;
			break;

		case RI:
			State = S;
			break;

		case RR:
			State = SH;
			break;

		case RF:
			State = SD;
			break;

		case CN:
			State = C;
			break;

		case NR:
			State = Start;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg(13);
	}
}

/* Send initialise retry */
Snd_i_retry()
{
	if (++Snd_i_count > 6) {
		State = Abort;
		showmsg(12);
	}
	else {
		Outstr[0] = ENQ;
		Outstr[1] = 1;
		xmitstr(Outstr, 2);
		getpack();
		if (opabort())
			return;		/* operator abort */
		switch (Ptype) {

			case TM:
				State = S1;
				break;

			case RI:
				State = S;
				break;

			case RR:
				State = SH;
				break;

			case RF:
				State = SD;
				break;

			case CN:
				State = C;
				break;

			case NR:
				State = Start;
				break;

			case TX:
				disppacket();
				break;

			default:
				State = Abort;
				showmsg(13);
				break;

		}
	}
}

/* Send header */
sendhdr()
{
	short headerlen, i;
	unsigned char *p;
	char buf[20];

	strcpy(Xferhdr, Pathname);
	deldrive(Pathname);		/* remove any drive id */
	p = Xferhdr + strlen(Xferhdr);
	++p;
	strcpy(p, ltoa(Nrbytes, buf));
	showheader();
	Outstr[0] = SOH;
	Outstr[1] = headerlen = strlen(Xferhdr) + strlen(p) + 2;

	xmitstr(Outstr, 2);		/* send SOH and length */
	for (i = 0; i < headerlen; i++)
		mcharout(Xferhdr[i]);	/* send header */
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case RF:
			State = SD;
			break;

		case CN:
			State = C;
			break;

		case NR:
			State = Start;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg((Ptype == TM) ? 10 : 13);
			break;
	}
}

/* Send data packet */

senddata()
{
	short i, cnt;

	if (mrd()) {		/* we shouldn't be getting a packet */
		getpack();	/* unless they sent a cancel or text */
		if (opabort())
			return;		/* operator abort */
		switch (Ptype) {

			case CN:
				State = C;
				return;
				break;

			case TX:
				disppacket();
				break;

			default:
				printf("\nUnexpected packet type during send.\n");
				State = Abort;
				return;
				break;
		}
	}
	if (cnt = filbuf(Txbuf, 256)) {
		Outstr[0] = STX;
		Outstr[1] = cnt;
		xmitstr(Outstr, 2);
		for (i = 0; i < cnt; i++)
			mcharout(Txbuf[i]);	/* send the data */
	}
	if (cnt < 256)
		State = SE;
	Xfercnt += (long) cnt;
	lreport(KBYTES, Xfercnt);
}

/* Send EOF */

sendeof()
{
	Outstr[0] = ETX;
	Outstr[1] = 1;
	xmitstr(Outstr, 2);
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case AF:
			State = ST;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg((Ptype == TM) ? 10 : 13);
			break;				
	}
}

/* Send EOT */

sendeot()
{
	Outstr[0] = EOT;
	Outstr[1] = 1;
	xmitstr(Outstr, 2);
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case AT:
			State = Start; /* ACK ok */
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Start; /* They sent AF -- don't worry about it */
			break;
	}
}

/* Receive */

receive()
{
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case SI:
			showmsg(1);
			Outstr[0] = ACK;
			Outstr[1] = 1;
			xmitstr(Outstr, 2);
			State = RH;
			break;

		case CN:
			State = C;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg((Ptype == TM) ? 10 : 13);
			break;
	}
}

/* Receive a header */

rcvhdr()
{
	short i;
	unsigned char *p, *q;
	char *r, *s, *index(), c;

	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case HD:
			clrreports();
			for (i = 0, p = Pkbuff, q = Xferhdr; i < Pklen; i++)
				*q++ = *p++;
			*q = '\0';		/* null-terminate 2 B sure */
			showheader();
			strcpy(Pathname, Xferhdr);	/* get filename */
			while (r = index(Pathname, '\\'))
				strcpy(Pathname, r + 1); /* remove any path */
			while (r = index(Pathname, ':'))
				strcpy(Pathname, r + 1);	/* or du: */
			checkpath(Pathname);
			testexist(Pathname);
			s = (char *) Xferhdr + ((strlen(Xferhdr) + 1));
			while ((c = *s) && c == ' ')	/* get filesize */
				s++;	/* remove leading spaces */
			if (c)		/* print if there is one */
				report(FILESIZE, s);
			Fd = creat(Pathname, 0);
			if (openerror(Fd, Pathname, UBIOT)) {
				Outstr[0] = NAK;	/* open error, */
				Outstr[1] = '\0';	/* Send NR */
				xmitstr(Outstr,2);
				State = Start;
				return;			/* and quit */
			}
			Outstr[0] = ACK;	/* ok, ack it */
			Outstr[1] = 2;
			xmitstr(Outstr, 2);
			State = RD;	/* and report ready for data */
			break;

		case SI:
			State = RH;
			break;

		case CN:
			State = C;
			break;

		case ET:
			Outstr[0] = ACK;
			Outstr[1] = 4;
			xmitstr(Outstr, 2);
			State = Start;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg((Ptype == TM) ? 10 : 13);
			break;
	}
}

/* Receive data */

rcvdata()
{
	short status;
	unsigned short size;

	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case DT:
			Xfercnt += (long) Pklen;
			if (Cpindex >= Cpbufsize) {	/* write to disk */
				size = (Cpindex > Cpbufsize) ? Cpbufsize : Cpindex;
				status = write(Fd, Cpmbuf, size);
				if (status != size) {
					zperr("Disk write error",TRUE);
					status = NERROR;
				}
				Cpindex = 0;
				Rxptr = Cpmbuf;
				lreport(KBYTES, Xfercnt);
			}
			showbytes();
			State = RD;
			break;

		case EF:
			lreport(KBYTES, Xfercnt);
			closeit();
			Xferok = TRUE;
			showmsg(8);
			Outstr[0] = ACK;
			Outstr[1] = 3;
			xmitstr(Outstr, 2);
			State = RH;
			break;

		case CN:
			State = C;
			break;

		case TX:
			disppacket();
			break;

		default:
			State = Abort;
			showmsg((Ptype == TM) ? 10 : 13);
			break;
	}
}

/* Cancel */

cancel()
{
	Outstr[0] = CAN;
	Outstr[1] = '\0';
	xmitstr(Outstr, 2);
	State = CW;
}

/* Wait after cancel (?) */

canwait()
{
	escmsg(10);
	getpack();
	if (opabort())
		return;		/* operator abort */
	switch (Ptype) {

		case CA :
		case TM:
		case UK:
			State = Start;
			break;

		case CN:
			Outstr[0] = ACK;
			Outstr[1] = 5;
			xmitstr(Outstr, 2);
			break;

		case TX:
			disppacket();
			break;

		default:
			break;
	}
}

/* CANcel received */

canrecd()
{
	showmsg(11);
	Outstr[0] = ACK;
	Outstr[1] = 5;
	xmitstr(Outstr, 2);
	mswait(3000);
	State = Start;
}

/************************* End of part 1 ************************************/