/*--------------------------------------------------------------------------*/
/*                                                                          */
/*                                                                          */
/*      ------------         Bit-Bucket Software, Co.                       */
/*      \ 10001101 /         Writers and Distributors of                    */
/*       \ 011110 /          Freely Available<tm> Software.                 */
/*        \ 1011 /                                                          */
/*         ------                                                           */
/*                                                                          */
/*              (C) Copyright 1987-96, Bit Bucket Software Co.              */
/*                                                                          */
/*                  This module was written by Bob Hartman                  */
/*                                                                          */
/*                 BinkleyTerm Xmodem Sender State Machine                  */
/*                                                                          */
/*                                                                          */
/*    For complete  details  of the licensing restrictions, please refer    */
/*    to the License  agreement,  which  is published in its entirety in    */
/*    the MAKEFILE and BT.C, and also contained in the file LICENSE.260.    */
/*                                                                          */
/*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
/*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
/*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
/*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
/*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
/*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
/*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
/*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
/*                                                                          */
/*                                                                          */
/* You can contact Bit Bucket Software Co. at any one of the following      */
/* addresses:                                                               */
/*                                                                          */
/* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
/* P.O. Box 460398                AlterNet 7:42/1491                        */
/* Aurora, CO 80046               BBS-Net  86:2030/1                        */
/*                                Internet f491.n343.z1.fidonet.org         */
/*                                                                          */
/* Please feel free to contact us at any time to share your comments about  */
/* our software and/or licensing policies.                                  */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Include this file before any other includes or defines! */

#include "includes.h"

void 
Build_Header_Block (XMARGSP args, char type)
{
	struct FILEINFO dta = {0};
	SEADATAP ttmp;

	(void) dfind (&dta, args->filename, 0);
	args->save_header = type;
	ttmp = (SEADATAP) & (args->header);

	(void) memset (ttmp, 0, sizeof (XMDATA));
	ttmp->header = type;
	ttmp->block_num = 0;
	ttmp->block_num_comp = 0xff;
	ttmp->filelength = args->filelen;
	(void) strncpy (ttmp->sendingprog, xfer_id, 14);
	if (type == SYN)
	{
		(void) memset (ttmp->filename, ' ', 16);
		ttmp->timedate = dta.time;
		/* This is the CRC bit in the TeLink header */
		ttmp->Resync = 1;
	}
	else
	{
#ifdef ANSI_TIME_T
		ttmp->timedate = args->save_filetime.oneword.timedate - ANSI_TIME_T_DELTA;
#else
		ttmp->timedate = args->save_filetime.oneword.timedate;
#endif
		ttmp->SLO = (unsigned char) (((cur_baud.rate_value >= 9600L) && !no_overdrive) ? 1 : 0);
		ttmp->Resync = (unsigned char) (no_resync ? 0 : 1);
		ttmp->MACFLOW = 1;
	}
	if (args->temp_name != NULL)
		(void) strncpy (ttmp->filename, args->temp_name, strlen (args->temp_name));
	else
		(void) strncpy (ttmp->filename, (char *) (dta.name), strlen (dta.name));

	(void) dfind (&dta, NULL, 2);
}

void XSSetVars (XMARGSP);
int XSInit (XMARGSP);
int XSEnd (XMARGSP);
int XSXmtStart (XMARGSP);
int XSXmTeStrt (XMARGSP);
int XSCheckACK (XMARGSP);
int XSSendBlk (XMARGSP);
int XSWaitEnd (XMARGSP);

typedef struct
{
	char *state_name;
	int (*state_func) (XMARGSP);
} XSTATES, *XSTATEP;

XSTATES Xmodem_Sender[] =
{
	{"XSInit", XSInit},
	{"XSEnd", XSEnd},
	{"XS0", XSXmtStart},
	{"XS0T", XSXmTeStrt},
	{"XS1", XSCheckACK},
	{"XS2", XSSendBlk},
	{"XS3", XSWaitEnd}
};

int 
XSInit (XMARGSP args)
{
	struct stat st;
	char junkbuff[100];

	/* Get the file information */
	if (stat (args->filename, &st))
	{
		/* Print error message */
		return (OPEN_ERR);
	}

	if ((args->file_pointer = share_fopen (args->filename, read_binary, DENY_WRITE)) == NULL)
	{
		/* Print error message */
		return (OPEN_ERR);
	}

	/* Get important information out of it */
	args->filelen = st.st_size;
	args->LastBlk = (st.st_size + 127) / 128;
	args->save_filetime.oneword.timedate = st.st_atime;
	args->prev_bytes = 0L;
	args->tot_errs = 0;

	(void) sprintf (junkbuff, MSG_TXT (M_SEND_MSG), args->LastBlk, args->filename, st.st_size);
	if (un_attended && fullscreen)
	{
		clear_filetransfer ();
		sb_move (filewin, 1, 2);
		sb_puts (filewin, junkbuff);
		elapse_time ();
		sb_show ();
	}
	else
	{
		status_line ("+%s", junkbuff);
		(void) printf ("\n");
	}

	locate_y = wherey ();
	locate_x = wherex ();

	/* Start the throughput calculations */
	throughput (0, 0L);
	return ((int) args->control);
}

int 
XSEnd (XMARGSP args)
{
	args->result = (int) args->control;

	/* Close file */
	(void) fclose (args->file_pointer);

	if (args->tot_errs > 3)
		status_line (MSG_TXT (M_CORRECTED_ERRORS), args->tot_errs, args->LastBlk);

	/* Log that we sent it */
	if (args->result == SUCCESS)
	{
		long lTime, lSize;

		lSize = args->filelen - args->prev_bytes;
		lTime = throughput (1, (unsigned long) lSize);
		status_line ("%s: %s", MSG_TXT (M_FILE_SENT), args->filename);
		update_files (1, args->filename, lSize, lTime, 0);
	}

	return (args->result);
}

void 
XSSetVars (XMARGSP args)
{
	if (no_sealink)
	{
		args->options.SLO = 0;
		args->options.Resync = 0;
	}
	else
	{
		args->options.SLO = ((cur_baud.rate_value >= 9600L) && !no_overdrive) ? 1 : 0;
		args->options.Resync = (~no_resync) & 1;
	}

	args->options.SEAlink = 0;
	args->SendBLK = 1;
	args->curr_byte = 0L;
	args->NextBLK = 1;
	args->ACKST = 0;
	args->ACKBLK = -1L;
	args->Window = 1;
	args->ACKsRcvd = 0;
	args->NumNAK = 0;
	args->T1 = timerset (3000);
}

int 
XSXmtStart (XMARGSP args)
{
	XSSetVars (args);
	Build_Header_Block (args, SOH);
	return (XS1);
}

int 
XSXmTeStrt (XMARGSP args)
{
	XSSetVars (args);
	Build_Header_Block (args, SYN);
	return (XS1);
}

int 
XSCheckACK (XMARGSP args)
{
	Check_ACKNAK (args);
	return (XS2);
}

int 
XSSendBlk (XMARGSP args)
{
	if (!CARRIER)
		return (CARRIER_ERR);

	if (got_ESC ())
	{
		status_line (MSG_TXT (M_KBD_MSG));
		return (KBD_ERR);
	}

	if ((args->NumNAK > 4) && (args->SendBLK == 0))
	{
		if (args->save_header == SOH)
			return (XS0T);
		else
		{
			args->NumNAK = 0;
			++(args->ACKBLK);
			++(args->SendBLK);
			return (XS2);
		}
	}

	if (args->NumNAK > 10)
	{
		/* Too Many Errors */
		return (SEND_RETRY_ERR);
	}

	if (timeup (args->T1))
	{
		/* Fatal Timeout */
		return (SEND_TIMEOUT);
	}

	if (args->SendBLK > (args->LastBlk + 1))
		return (XS3);

	if (args->SendBLK > (args->ACKBLK + args->Window))
	{
		time_release ();
		return (XS1);
	}

	if (args->SendBLK == (args->LastBlk + 1))
	{
		SENDBYTE (EOT);
		++(args->SendBLK);
		args->T1 = timerset (3000);
		show_sending_blocks (args);
		time_release ();
		return (XS1);
	}

	/*
        Increment the block count before sending because we read the next
        block immediately after sending this block.  On error free connects
        we have a big net win because we never do a seek, and while we are
        sending one block, we read the next.  If we do get errors, then we
        have to seek back to the previous block, and that will be a bother.
        With today's phone lines and modems, we'll assume error free is more
        often than not, and take our chances.
    */
	if (args->options.SLO && args->options.SEAlink)
	{
		args->ACKBLK = args->SendBLK;
	}

	++(args->SendBLK);
	args->curr_byte += 128L;
	Send_Block (args);
	args->T1 = timerset (6000);
	return (XS1);
}

int 
XSWaitEnd (XMARGSP args)
{
	show_sending_blocks (args);

	if (args->ACKBLK < (args->LastBlk + 1))
	{
		time_release ();
		return (XS1);
	}

	if (!CARRIER)
		return (CARRIER_ERR);

	return (SUCCESS);
}

int 
SEAlink_Send_File (char *filename, char *sendname)
{
	XMARGS xm;

	xm.filename = filename;
	xm.temp_name = sendname;
	return (state_machine ((STATEP) Xmodem_Sender, &xm, XS0));
}

int 
Xmodem_Send_File (char *filename, char *sendname)
{
	return (SEAlink_Send_File (filename, sendname));
}

int 
Telink_Send_File (char *filename, char *sendname)
{
	XMARGS xm;

	xm.filename = filename;
	xm.temp_name = sendname;
	return (state_machine ((STATEP) Xmodem_Sender, &xm, XS0T));
}

void 
Get_Block (XMARGSP args)
{
	XMDATAP xtmp;

	if (args->SendBLK == 0)
	{
		Build_Header_Block (args, args->save_header);
		args->NextBLK = -1L;
		return;
	}

	xtmp = (XMDATAP) & (args->header);

	/* Set up buffer as all ^Zs for EOF */
	(void) memset (xtmp, SUB, sizeof (XMDATA));

	/* Now set up the header stuff */
	xtmp->header = SOH;
	xtmp->block_num = (unsigned char) (args->SendBLK & 0xff);
	xtmp->block_num_comp = (unsigned char) ~xtmp->block_num;

	if (args->NextBLK != args->SendBLK)
	{
		(void) fseek (args->file_pointer, (args->SendBLK - 1) * 128, SEEK_SET);
	}

	args->NextBLK = args->SendBLK + 1;

	/* Can we read any data? */
	if (fread ((char *) xtmp->data_bytes, 1, 128, args->file_pointer) <= 0)
		return;

	/* Looks good */
	return;
}

void 
Send_Block (XMARGSP args)
{
	if (args->header == SYN)
	{
		Data_Check ((XMDATAP) & (args->header), CHECKSUM);
	}
	else
	{
		Data_Check ((XMDATAP) & (args->header), args->options.do_CRC ? CRC : CHECKSUM);
	}

	if ((!(args->options.do_CRC)) || (args->header == SYN))
	{
		SENDCHARS ((char *) &(args->header), sizeof (XMDATA) - 1, 1);
	}
	else
	{
		SENDCHARS ((char *) &(args->header), sizeof (XMDATA), 1);
	}

	UNBUFFER_BYTES ();

	show_sending_blocks (args);

	Get_Block (args);
}

char *
show_num (XMARGSP args, long b)
{
	char *Rtn;

	Rtn = "EOT";
	if (b > args->LastBlk)
	{
		if (!(fullscreen && un_attended))
			(void) cputs (Rtn);
	}
	else if (b >= 0L)
	{
		Rtn = ultoa (((unsigned long) b), e_input, 10);
		if (!(fullscreen && un_attended))
			(void) cputs (Rtn);
	}
	return Rtn;
}

void 
show_sending_blocks (XMARGSP args)
{
	char *TmpPtr = (char *) &happy_compiler;
	char j[100];
	long k;

	k = args->filelen - args->curr_byte;
	if (k < 0L)
		k = 0L;

	(void) sprintf (j, "%3d min",
		((k * 10L / cur_baud.rate_value * 100L /
		((args->save_header == SOH) ? 94L : 70L) + 59L) / 60L));

	if (args->options.SLO)
	{
		if ((!((args->SendBLK - 1) & 0x1f)) || ((args->SendBLK - 1) > args->LastBlk))
		{
			if (fullscreen && un_attended)
			{
				elapse_time ();
				sb_move (filewin, 2, 2);
				TmpPtr = show_num (args, args->SendBLK - 1);
				sb_puts (filewin, TmpPtr);
				(void) sb_putc (filewin, ':');
				TmpPtr = show_num (args, args->ACKBLK);
				sb_puts (filewin, TmpPtr);
				sb_puts (filewin, " *Overdrive*  ");
				sb_move (filewin, 2, 69);
				sb_puts (filewin, j);
				sb_show ();
			}
			else
			{
				gotoxy (locate_x, locate_y);
				(void) show_num (args, args->SendBLK - 1);
				(void) cputs (":");
				(void) show_num (args, args->ACKBLK);
				(void) cputs (" *Overdrive*  ");
			}
		}
	}
	else
	{
		if (fullscreen && un_attended)
		{
			elapse_time ();

			sb_move (filewin, 2, 2);
			TmpPtr = show_num (args, args->SendBLK - 1);
			sb_puts (filewin, TmpPtr);
			(void) sb_putc (filewin, ':');
			TmpPtr = show_num (args, args->ACKBLK);
			sb_puts (filewin, TmpPtr);

			sb_puts (filewin, "              ");
			sb_move (filewin, 2, 69);
			sb_puts (filewin, j);
			sb_show ();
		}
		else
		{
			gotoxy (locate_x, locate_y);
			(void) show_num (args, args->SendBLK - 1);
			(void) cputs (":");
			(void) show_num (args, args->ACKBLK);
			(void) cputs ("              ");
		}
	}
	happy_compiler = *(int *) TmpPtr;	/* Makes the compiler happy! */
}

int ACInit (XMARGSP);
int ACEnd (XMARGSP);
int ACChkRcvd (XMARGSP);
int ACSLCheck (XMARGSP);
int ACSLVerify (XMARGSP);
int ACSLACKNAK (XMARGSP);
int ACXMCheck (XMARGSP);
int ACSLOCheck (XMARGSP);
int ACSL1Check (XMARGSP);
int ACACKNAK (XMARGSP);
int ACXMACK (XMARGSP);
int ACXMNAK (XMARGSP);
int ACRESYNC (XMARGSP);

typedef struct
{
	char *state_name;
	int (*state_func) (XMARGSP);
} ASTATES, *ASTATEP;

ASTATES ACKNAK_Check[] =
{
	{"ACInit", ACInit},
	{"ACEnd", ACEnd},
	{"AC0", ACChkRcvd},
	{"AC1", ACSLCheck},
	{"AC2", ACSLVerify},
	{"AC3", ACSLACKNAK},
	{"AC4", ACXMCheck},
	{"AC5", ACSLOCheck},
	{"AC6", ACSL1Check},
	{"AC7", ACACKNAK},
	{"AC8", ACXMACK},
	{"AC9", ACXMNAK},
	{"AC10", ACRESYNC}
};

int 
ACInit (XMARGSP args)
{
	args->result = 0;
	return ((int) args->control);
}

int 
ACEnd (XMARGSP args)
{
	args->result = (int) args->control;
	return (args->result);
}

int 
ACChkRcvd (XMARGSP args)
{
	if (PEEKBYTE () >= 0)
	{
		args->CHR = TIMED_READ (0);
		return (AC1);
	}

	return (SUCCESS);
}

int 
ACSLCheck (XMARGSP args)
{
	if (args->ACKST > 2)
		return (AC2);

	return (AC6);
}

int 
ACSLVerify (XMARGSP args)
{
	if (args->ARBLK8 == (unsigned char) ((~args->CHR) & 0xff))
	{
		args->ARBLK = args->SendBLK - ((args->SendBLK - args->ARBLK8) & 0xff);
		return (AC3);
	}

	args->options.SEAlink = 0;
	args->Window = 1;
	args->ACKST = 0;
	return (AC6);
}

int 
ACSLACKNAK (XMARGSP args)
{
	if ((args->ARBLK < 0)
		|| (args->ARBLK > args->SendBLK)
		|| (args->ARBLK <= (args->SendBLK - 128)))
	{
		return (AC0);
	}

	if (args->ACKST == 3)
	{
		args->options.SEAlink = (~no_sealink) & 1;
		args->Window = calc_window ();
		args->ACKBLK = args->ARBLK;
		++(args->ACKsRcvd);
		args->ACKST = 0;
		return (AC5);
	}

	args->SendBLK = args->ARBLK;
	args->curr_byte = (args->SendBLK - 1) * 128L;
	if (args->curr_byte < 0L)
		args->curr_byte = 0L;

	if (args->SendBLK > 0)
		++(args->tot_errs);

	Get_Block (args);
	args->ACKST = 0;

	return (AC4);
}

int 
ACXMCheck (XMARGSP args)
{
	if (args->NumNAK < 4)
	{
		args->options.SEAlink = (~no_sealink) & 1;
		args->Window = calc_window ();
	}
	else
	{
		args->options.SEAlink = 0;
		args->Window = 1;
	}
	return (SUCCESS);
}

int 
ACSLOCheck (XMARGSP args)
{
	if ((args->options.SLO == 0) || (args->ACKsRcvd < 10))
		return (SUCCESS);

	args->options.SLO = 0;
	return (SUCCESS);
}

int 
ACSL1Check (XMARGSP args)
{
	if ((args->ACKST == 1) || (args->ACKST == 2))
	{
		args->ARBLK8 = (unsigned char) args->CHR;
		args->ACKST += 2;
		return (AC6);
	}

	if ((args->options.SEAlink == 0) || (args->ACKST == 0))
		return (AC7);

	return (AC0);
}

int 
ACACKNAK (XMARGSP args)
{
	long mac_timer;

	switch (args->CHR)
	{
	case ACK:
		args->ACKST = 1;
		args->NumNAK = 0;
		return (AC8);

	case WANTCRC:
		args->options.do_CRC = 1;

		/* Fallthrough */

	case NAK:
		args->ACKST = 2;
		++(args->NumNAK);
		CLEAR_OUTBOUND ();
		timer (6);
		return (AC9);

	case SYN:
		CLEAR_OUTBOUND ();
		if (!no_resync)
		{
			args->result = Receive_Resync (&(args->resync_block));
			args->ACKST = 0;
			return (AC10);
		}
		else
		{
			return (AC0);
		}

	case DC3:					/* ^S */
		if (args->options.SEAlink && (args->ACKST == 0))
		{
			mac_timer = timerset (1000);
			while (CARRIER && !timeup (mac_timer))
			{
				if (TIMED_READ (0) == DC1)
					break;

				time_release ();
			}
			return (AC0);
		}

		/* Otherwise, fallthrough */

	default:
		break;
	}
	return (AC0);
}

int 
ACXMACK (XMARGSP args)
{
	if (!args->options.SEAlink)
		++(args->ACKBLK);

	return (AC0);
}

int 
ACXMNAK (XMARGSP args)
{
	if (!args->options.SEAlink)
	{
		args->SendBLK = args->ACKBLK + 1;
		args->curr_byte = (args->SendBLK - 1) * 128L;
		if (args->curr_byte < 0L)
			args->curr_byte = 0L;

		if (args->SendBLK > 0)
			++(args->tot_errs);

		Get_Block (args);
	}

	return (AC0);
}

int 
ACRESYNC (XMARGSP args)
{
	CLEAR_OUTBOUND ();
	if (args->result != SUCCESS)
	{
		SENDBYTE (NAK);
		return (SUCCESS);
	}

	if (args->SendBLK == 1)
	{
		args->prev_bytes = (args->resync_block - 1) * 128;
		if (args->prev_bytes > args->filelen)
			args->prev_bytes = args->filelen;
		status_line (MSG_TXT (M_SYNCHRONIZING), args->prev_bytes);
	}
	else
	{
		++(args->tot_errs);
	}

	args->options.SEAlink = 1;
	args->Window = calc_window ();
	args->SendBLK = args->resync_block;
	args->curr_byte = (args->SendBLK - 1) * 128L;
	if (args->curr_byte < 0L)
		args->curr_byte = 0L;

	Get_Block (args);
	args->ACKBLK = args->SendBLK - 1;
	SENDBYTE (ACK);
	return (SUCCESS);
}

void 
Check_ACKNAK (XMARGSP args)
{
	(void) state_machine ((STATEP) ACKNAK_Check, args, AC0);
}

int 
Receive_Resync (long *resync_block)
{
	unsigned char resyncit[30];
	unsigned char *p;
	unsigned char a, b;
	unsigned short nak_crc, his_crc;

	p = resyncit;

	while ((*p = (unsigned char) TIMED_READ (1)) != ETX)
	{
		if ((*p < '0') || (*p > '9'))
		{
			status_line (">SEAlink Send: Resync bad byte '%02x'", *p);
			return (RESYNC_ERR);
		}
		++p;
	}
	*p = '\0';
	nak_crc = crc_block ((unsigned char *) resyncit, (int) strlen ((char *) resyncit));
	a = (unsigned char) TIMED_READ (1);
	b = (unsigned char) TIMED_READ (1);
	his_crc = (b << 8) | a;

	if (nak_crc != his_crc)
	{
		status_line (">SEAlink Send: Resync bad crc %04hx/%04hx", nak_crc, his_crc);
		return (CRC_ERR);
	}

	*resync_block = atol ((char *) resyncit);

	status_line (">SEAlink Send: Resync to %ld", *resync_block);
	return (SUCCESS);
}

int 
calc_window ()
{
	long window;

	window = cur_baud.rate_value / 400L;
	if (window <= 0L)
		window = 2L;
	if (small_window)
		window = (window > 6L) ? 6L : window;
	else
		window = (window > 2000L) ? 2000L : window;

	return (int) window;
}