/************************************************************************/
/*									*/
/*			RZMP: Remote ZMODEM program			*/
/*									*/
/*	Developed from Hal Maney's HMODEM II via ZMP by Ron Murray	*/
/*									*/
/*		Usage: RZMP [options] [count]				*/
/*		Options are:						*/
/*			R - Receive files				*/
/*			S - Send files					*/
/*			F - Send files listed in RZMP.DAT		*/
/*			Q - Shutup flag: No non-error messages		*/
/*									*/
/*		count is number of files in RZMP.DAT (F option only)	*/
/*									*/
/*	V1.0 rjm 7/9/88							*/
/*									*/
/*	Finally released as v1.3 (after extensive debugging)		*/
/*		rjm 12/10/88						*/
/*									*/
/*	v1.4 rjm 15/10/88						*/
/*		- Read a file to determine files to send to work with	*/
/*			ZMSELECT					*/
/*		- Shutup flag						*/
/*		- produces output file of files transferred for use by	*/
/*			RZMPLOG						*/
/*									*/
/*	v1.5 rjm 3/3/89							*/
/*		- Fixed bug in zmodem transfer routines			*/
/*									*/
/*	v1.6 rjm 6/6/89							*/
/*		- Chain to .COM file for logging			*/
/*                                                                      */
/*  v1.7 rjm 4/2/90                                                     */
/*      - Fixed bug in checkpath                                        */
/*      - (This is probably the version issued as v1.6a)  lja           */
/*                                                                      */
/*  v1.7 lja 18/12/93                                                   */
/*      - Ron did not issue v1.7 so this number is being used           */
/*        again with his source code collected from various disks       */
/*                                                                      */
/************************************************************************/
/*                                                                      */
/*  This source code may be distributed freely without restriction      */
/*  for the express purpose of promoting the use of the ZMODEM          */
/*  file transfer protocol.  Programmers are requested to include       */
/*  credit (in the source code) to the developers for any code          */
/*  incorporated from this program.                                     */
/*                                                                      */
/************************************************************************/
/*									*/
/* The following files in this library are required to compile RZMP:	*/
/*									*/
/*	rzmp.c		-- This file. Contains nucleus routines		*/
/*				common to both send and receive.	*/
/*	rzmp2.c		-- Second half of nucleus routines.		*/
/*	rzmp3.c		-- Send routines.				*/
/*	rzmp4.c		-- Receive routines.				*/
/*									*/
/* The following files are also necessary to compile RZMP, but are	*/
/*   not contained in this library. They are in ZMP-SRC.LBR, as they	*/
/*   are common to both ZMP and RZMP:					*/
/*									*/
/*	zmp.h		-- Header file. Contains #defines etc. for	*/
/*				both ZMP and RZMP.			*/
/*	zmodem.h	-- zmodem header file				*/
/*	zzm.c		-- Chuck Forsberg's zm.c modified for cp/m by	*/
/*				Hal Maney and Ron Murray		*/
/*	zzm2.c		-- Part 2 of the above				*/
/*									*/
/*									*/
/*	These files are designed to be compiled by Hi-Tech C.		*/
/*									*/
/************************************************************************/


#define MAIN
#define RZMP

#include "zmp.h"
#include <stdio.h>
#include <signal.h>

main(argc,argv)
int argc;
char **argv;
{
	char *p, *r, filename[18], *malloc(), *list, *index();
	int fd;
	short i, drive, user, nactim, count, size;
	unsigned short bytes;

	signal(SIGINT,SIG_IGN);		/* Ignore control-c's */

	setup(argc,argv[1]); /* Set up globals from overlay and command line */
	userin();			/* user-defined entry routine */

	if (!Shutup)
		printf("\nRZMP %s\n\n",Version);

		/* abort if he hasn't typed RZMP R or RZMP S */

	if (!Receive && !Transmit) {
		dohelp();	/* tell him what he SHOULD have said */
		doexit();		/* then quit */
	}
	if(bdos(32,241) != 77) {	/* BYE existence test */
		printf("BYE not running: aborted.\n");
		doexit();
	}

	Current.cbaudindex = *Mspeed; /* set current baud rate */
	Invokdrive = bdos(GETCUR) + 'A'; /* current drive .. */
	Invokuser = getuid();	/* .. and user area */
	drive = Currdrive = Invokdrive; /* set default du: to current */
	user = Curruser = Invokuser;
	MAdrive = bdos(69,255) + 'A';	/* set max drive and user */
	MAuser = bdos(70,255);
	nactim = bdos(71,255);	/* get current value of no-activity timer */
	bdos(71,254);		/* disable non-activity timeout */
	bdos(89,1);		/* disable non-activity beeps */
	openlog();		/* try to open .LOG file */

	if (Receive) {	/* receive files */
		if (!(*Wheel))
			if (!Private) { /* Non-wheels get B0: */
				drive = Currdrive = Upldrive;
				user = Curruser = Upluser;
				bdos(SELDSK,Currdrive - 'A');
				setuid(Curruser);
			}
			else {  /* private area upload */
				drive = Uprivdrive;
				user = Uprivuser;
			}
		if (!Shutup)
			printf("File will be received on %c%d:\n",
				drive,user);
		repready();
		bringin();
	}

	if (Transmit) {			/* send files */
		if (!Filemode) {	/* send from command line */
			if (argc < 3)
				printf("You must specify filenames.\n");
			else {
				Pathname[0] = '\0';	/* Put filenames in Pathname */
				for (i = 2; i < argc; i++) {
					strcat(Pathname, argv[i]);
					if (i != argc-1) /* separate with spaces */
						strcat(Pathname," "); /* except the last*/
				}
				sendout(Pathname);
			}
		}
		else if (argc > 2) { /* list of send files from disk file */
			strcat(filename,Infile);	/* get filename */
			addu(filename,Tempdrive,Tempuser);	/* add du: */
			if ((fd = open(filename,0)) != UBIOT) {	/* open file */
				sscanf(argv[2],"%d",&count);
				size = count * 18 + 1;
					/* now get some memory to put it in */
				if (count && !allocerror(r = list = malloc(size))) {
					if (bytes = read(fd,list,size)) {

		/* need to go through buffer and change cr/lf to space */
			/* then move rest of file down */
						list[bytes - 1] = '\0';
						for (i = 0; i < count; i++)
							if (p = index(list, '\r')) {
								*p = ' ';
								strcpy(p + 1, p + 2);
								r = p;
							}
							else
								break;
							*r = '\0'; /* terminate */
						sendout(list);	/* send it all */
					}
					free(list);
				}
				fclose(fd);
				unlink(filename);	/* erase the file */
			}
			else
				printf("Command file not found.\n");
		}
	}
	closelog();			/* close output log */
	bdos(SELDSK,Invokdrive - 'A');
	setuid(Invokuser);
	bdos(71,nactim);		/* re-enable non-activity timeout */
	bdos(89,0);			/* and bells */
	if (Outopen) 			/* chain to log program if any */
		execl(Logprog, Transmit ? "S" : "R", 0);
	doexit();			/* else normal exit */
}

/* Set up global variables */
setup(i,options)
short i;
char *options;
{
	char *p;
	int *q, *getvarsr();

	q = getvarsr();			/* pointer to data */
	Wheel = (char *) *q++;
	Mspeed = (char *) *q++;
	Uploads = (char *) *q++;	/* and upload/download count */
	Downloads = (char *) *q++;
	Badtypes = (char *) *q++;	/* Pointer to bad filetype list */
	Logprog = (char *) *q++;	/* Pointer to log program filename */
	p = (char *) (q + 5);		/* 5 spares */
	Upldrive = (int) *p++;		/* system configuration */
	Upluser = (int) *p++;		/* non-wheel upload area */
	Logdrive = (int) *p++;		/* .LOG area */
	Loguser = (int) *p++;
	Uprivdrive = (int) *p++;	/* private upload area */
	Uprivuser = (int) *p++;
	Dprivdrive = (int) *p++;	/* private download area */
	Dprivuser = (int) *p++;
	Tempdrive = (int) *p++;		/* scratch area */
	Tempuser = (int) *p++;
	Logwheel = (int) *p++;		/* Flag: log wheel transfers */

	Filemode = Private = Shutup = Receive = Transmit = FALSE;
	if (i > 1) {		/* get options */
		Filemode = (int) index(options,'F');
		Private = (int) index(options,'P');
		Shutup = (int) index(options,'Q');
		Receive = (int) index(options,'R');
		Transmit = (int) index(options,'S');
	}
}

/* Done. */
doexit()
{
	userout();		/* user-defined exit routine */
	exit(0);
}

/* User is confused: tell him off */
dohelp()
{
	printf("\n\tRZMP commands:\n\n");
	printf("RZMP R -- Receive files using ZMODEM\n");
	printf("RZMP S <filename list> -- Send files\n");
	printf("RZMP RP -- Receive files to the private area\n");
	printf("RZMP SP <filename list > -- Send files from the private area\n");
	printf("  Filenames in <filename list> should be separated ");
	printf("by spaces.\n");
	printf("  Wildcards and du:references are allowed.\n");
}

sendout(list)
char *list;
{
	static int count, result;

	result = NERROR;
	flush();
	count = linetolist(list);	/* process filenames */
	if (count) {
		Zmodem = TRUE;
		Xmodem = FALSE;
		if ((result = checktime(count,Pathlist)) != NERROR) {
			repready();
			result = wcsend(count,Pathlist);
		}
	}
	endstat(result,count);
	return result;
}

bringin()
{
	static int result;

	result = NERROR;
	flush();
	Zmodem = TRUE;
	Nozmodem = Xmodem = FALSE;
	result = wcreceive(NULL);
	endstat(result, 0);
	return result;
}

/* Report to user that we're ready */
repready()
{
	if (!Shutup) {
		printf("Ready to %s. Repeated control-X to abort.\n",
			Transmit ? "send" : "receive");
		wait(2);
	}
}

/* Clean up at end and report status */
endstat(result, count)
int result, count;
{
	freepath(count);
	LOCATE(BR+2,1);
	if (!Shutup)
		printf("\nTransfer %s\n",result==OK?"Successful":"Aborted");
	flush();
}

/* crctab calculated by Mark G. Mendel, Network Systems Corporation */
static unsigned crctab[256] = {
	0x0000,  0x1021,  0x2042,  0x3063,  0x4084,  0x50a5,  0x60c6,  0x70e7,
	0x8108,  0x9129,  0xa14a,  0xb16b,  0xc18c,  0xd1ad,  0xe1ce,  0xf1ef,
	0x1231,  0x0210,  0x3273,  0x2252,  0x52b5,  0x4294,  0x72f7,  0x62d6,
	0x9339,  0x8318,  0xb37b,  0xa35a,  0xd3bd,  0xc39c,  0xf3ff,  0xe3de,
	0x2462,  0x3443,  0x0420,  0x1401,  0x64e6,  0x74c7,  0x44a4,  0x5485,
	0xa56a,  0xb54b,  0x8528,  0x9509,  0xe5ee,  0xf5cf,  0xc5ac,  0xd58d,
	0x3653,  0x2672,  0x1611,  0x0630,  0x76d7,  0x66f6,  0x5695,  0x46b4,
	0xb75b,  0xa77a,  0x9719,  0x8738,  0xf7df,  0xe7fe,  0xd79d,  0xc7bc,
	0x48c4,  0x58e5,  0x6886,  0x78a7,  0x0840,  0x1861,  0x2802,  0x3823,
	0xc9cc,  0xd9ed,  0xe98e,  0xf9af,  0x8948,  0x9969,  0xa90a,  0xb92b,
	0x5af5,  0x4ad4,  0x7ab7,  0x6a96,  0x1a71,  0x0a50,  0x3a33,  0x2a12,
	0xdbfd,  0xcbdc,  0xfbbf,  0xeb9e,  0x9b79,  0x8b58,  0xbb3b,  0xab1a,
	0x6ca6,  0x7c87,  0x4ce4,  0x5cc5,  0x2c22,  0x3c03,  0x0c60,  0x1c41,
	0xedae,  0xfd8f,  0xcdec,  0xddcd,  0xad2a,  0xbd0b,  0x8d68,  0x9d49,
	0x7e97,  0x6eb6,  0x5ed5,  0x4ef4,  0x3e13,  0x2e32,  0x1e51,  0x0e70,
	0xff9f,  0xefbe,  0xdfdd,  0xcffc,  0xbf1b,  0xaf3a,  0x9f59,  0x8f78,
	0x9188,  0x81a9,  0xb1ca,  0xa1eb,  0xd10c,  0xc12d,  0xf14e,  0xe16f,
	0x1080,  0x00a1,  0x30c2,  0x20e3,  0x5004,  0x4025,  0x7046,  0x6067,
	0x83b9,  0x9398,  0xa3fb,  0xb3da,  0xc33d,  0xd31c,  0xe37f,  0xf35e,
	0x02b1,  0x1290,  0x22f3,  0x32d2,  0x4235,  0x5214,  0x6277,  0x7256,
	0xb5ea,  0xa5cb,  0x95a8,  0x8589,  0xf56e,  0xe54f,  0xd52c,  0xc50d,
	0x34e2,  0x24c3,  0x14a0,  0x0481,  0x7466,  0x6447,  0x5424,  0x4405,
	0xa7db,  0xb7fa,  0x8799,  0x97b8,  0xe75f,  0xf77e,  0xc71d,  0xd73c,
	0x26d3,  0x36f2,  0x0691,  0x16b0,  0x6657,  0x7676,  0x4615,  0x5634,
	0xd94c,  0xc96d,  0xf90e,  0xe92f,  0x99c8,  0x89e9,  0xb98a,  0xa9ab,
	0x5844,  0x4865,  0x7806,  0x6827,  0x18c0,  0x08e1,  0x3882,  0x28a3,
	0xcb7d,  0xdb5c,  0xeb3f,  0xfb1e,  0x8bf9,  0x9bd8,  0xabbb,  0xbb9a,
	0x4a75,  0x5a54,  0x6a37,  0x7a16,  0x0af1,  0x1ad0,  0x2ab3,  0x3a92,
	0xfd2e,  0xed0f,  0xdd6c,  0xcd4d,  0xbdaa,  0xad8b,  0x9de8,  0x8dc9,
	0x7c26,  0x6c07,  0x5c64,  0x4c45,  0x3ca2,  0x2c83,  0x1ce0,  0x0cc1,
	0xef1f,  0xff3e,  0xcf5d,  0xdf7c,  0xaf9b,  0xbfba,  0x8fd9,  0x9ff8,
	0x6e17,  0x7e36,  0x4e55,  0x5e74,  0x2e93,  0x3eb2,  0x0ed1,  0x1ef0
};

/*
 * updcrc macro derived from article Copyright (C) 1986 Stephen Satchell. 
 *  NOTE: First argument must be in range 0 to 255.
 *        Second argument is referenced twice.
 * 
 * Programmers may incorporate any or all code into their programs, 
 * giving proper credit within the source. Publication of the 
 * source routines is permitted so long as proper credit is given 
 * to Stephen Satchell, Satchell Evaluations and Chuck Forsberg, 
 * Omen Technology.
 */

updcrc(cp, crc)
unsigned cp, crc;
{
   return ( crctab[((crc >> 8) & 255)] ^ (crc << 8) ^ cp);
}

/*			End of RZMP file #1				*/