/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1994 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "uucp.h"

#ifdef	E_PROTOCOL

#ifndef MIN
#define     MIN(a,b) (((a)<(b))?(a):(b))
#endif

#if defined(BSD4_2) || defined (ATTSVR4)
#include <netinet/in.h>
#endif /* BSD4_2 || ATTSVR4 */

#define	EBUFSIZ	1024
#define	EMESGLEN 20

#define TBUFSIZE 1024
#define TPACKSIZE	512

extern long lseek();	/* Find offset into the file. */
static jmp_buf Failbuf;
extern int erdblk();
extern unsigned msgtime;

static char Erdstash[EBUFSIZ];
static int Erdlen;

/*
 * error-free channel protocol
 */
/* ARGSUSED */
static void
ealarm(sig)
int sig;
{
	longjmp(Failbuf, 1);
}
static void (*esig)();

/*
 * turn on protocol timer
 */
int
eturnon()
{
	esig=signal(SIGALRM, ealarm);
	return(0);
}

int
eturnoff()
{
	signal(SIGALRM, esig);
	return(0);
}

/*
 * write message across link
 *	type	-> message type
 *	str	-> message body (ascii string)
 *	fn	-> link file descriptor
 * return
 *	FAIL	-> write failed
 *	SUCCESS	-> write succeeded
 */
int
ewrmsg(type, str, fn)
register char *str;
int fn;
char type;
{
	return(etwrmsg(type, str, fn, 0));
}

/*
 * read message from link
 *	str	-> message buffer
 *	fn	-> file descriptor
 * return
 *	FAIL	-> read timed out
 *	SUCCESS	-> ok message in str
 */
int
erdmsg(str, fn)
register char *str;
{
	return(etrdmsg(str, fn, 0));
}

/*
 * read data from file fp1 and write
 * on link
 *	fp1	-> file descriptor
 *	fn	-> link descriptor
 * returns:
 *	FAIL	->failure in link
 *	SUCCESS	-> ok
 */
int
ewrdata(fp1, fn)
register FILE *fp1;
int	fn;
{
	register int ret;
	int	fd1;
	int len;
	unsigned long bytes;
	char bufr[EBUFSIZ];
	struct stat	statbuf;
	off_t	msglen;
	char	cmsglen[EMESGLEN];
	off_t	startPoint;	/* Offset from begining of the file in
				 *   case we are restarting from a check
				 *   point.
				 */

	if (setjmp(Failbuf)) {
		DEBUG(7, "ewrdata failed\n%s", "");
		return(FAIL);
	}
	bytes = 0L;
	fd1 = fileno(fp1);
	fstat(fd1, &statbuf);
	startPoint = lseek(fd1, 0L, 1);
	if (startPoint < 0)
	{
		DEBUG(7, "ewrdata lseek failed.  Errno=%d\n", errno);
		return(FAIL);
	}
	msglen = statbuf.st_size - startPoint;
	if (msglen < 0)
	{
		DEBUG(7, "ewrdata: startPoint past end of file.\n%s", "");
		return(FAIL);
	}
	sprintf(cmsglen, "%ld", (long) msglen);
	DEBUG(9, "ewrdata writing %d ...", sizeof(cmsglen));
	alarm(msgtime);
	ret = (*Write)(fn, cmsglen, sizeof(cmsglen));
	alarm(0);
	DEBUG(9, "ret %d\n", ret);
	if (ret != sizeof(cmsglen))
		return(FAIL);
	DEBUG(7, "ewrdata planning to send %ld bytes to remote.\n", msglen);
	while ((len = read( fd1, bufr, EBUFSIZ )) > 0) {
		DEBUG(9, "ewrdata writing %d ...", len);
		alarm(msgtime);
		bytes += len;
		putfilesize(bytes);
		ret = (*Write)(fn, bufr, (unsigned) len);
		alarm(0);
		DEBUG(9, "ewrdata ret %d\n", ret);
		if (ret != len)
			return(FAIL);
		if ((msglen -= len) <= 0)
			break;
	}
	if (len < 0 || (len == 0 && msglen != 0)) return(FAIL);
	return(SUCCESS);
}

/*
 * read data from link and
 * write into file
 *	fp2	-> file descriptor
 *	fn	-> link descriptor
 * returns:
 *	SUCCESS	-> ok
 *	FAIL	-> failure on link
 */
int
erddata(fn, fp2)
register FILE *fp2;
{
	register int ret;
	int	fd2;
	char bufr[EBUFSIZ];
	int	len;
	long	msglen, bytes;
	char	cmsglen[EMESGLEN], *cptr, *erdptr = Erdstash;

	DEBUG(9, "erddata wants %d\n", sizeof(cmsglen));
	if (Erdlen > 0) {
		DEBUG(9, "%d bytes stashed\n", Erdlen);
		if (Erdlen >= sizeof(cmsglen)) {
			memcpy(cmsglen, erdptr, sizeof(cmsglen));
			Erdlen -= sizeof(cmsglen);
			erdptr += sizeof(cmsglen);
			ret = len = 0;
		} else {
			memcpy(cmsglen, Erdstash, Erdlen);
			cptr = cmsglen + Erdlen;
			len = sizeof(cmsglen) - Erdlen;
			ret = erdblk(cptr, len, fn);
			Erdlen = 0;
		}
	} else {
		len = sizeof(cmsglen);
		ret = erdblk(cmsglen, sizeof(cmsglen), fn);
	}
	if (ret != len)
		return(FAIL);
	ret = SUCCESS;
	sscanf(cmsglen, "%ld", &msglen);
	if ( ((msglen-1)/512 +1) > Ulimit )
		ret = EFBIG;
	DEBUG(7, "erddata file is %ld bytes\n", msglen);
	fd2 = fileno( fp2 );

	if (Erdlen > 0) {
		DEBUG(9, "%d bytes stashed\n", Erdlen);
		if (write(fileno(fp2), erdptr, Erdlen) != Erdlen)
			return(FAIL);
		msglen -= Erdlen;
		Erdlen = 0;
		DEBUG(7, "erddata remainder is %ld bytes\n", msglen);
	}	

	for (;;) {
		len = erdblk(bufr, (int) MIN(msglen, EBUFSIZ), fn);
		DEBUG(9, "erdblk ret %d\n", len);
		if (len < 0) {
			DEBUG(7, "erdblk failed\n%s", "");
			return(FAIL);
		}
		bytes += len;
		putfilesize(bytes);
		if ((msglen -= len) < 0) {
			DEBUG(7, "erdblk read too much\n%s", "");
			return(FAIL);
		}
		/* this write is to file -- use write(2), not (*Write) */
		if ( ret == SUCCESS && write( fd2, bufr, len ) != len ) {
			ret = errno;
			DEBUG(7, "erddata: write to file failed, errno %d\n", ret);
		}
		if (msglen == 0)
			break;
	}
	return(ret);
}

/*
 * read block from link
 * reads are timed
 *	blk	-> address of buffer
 *	len	-> size to read
 *	fn	-> link descriptor
 * returns:
 *	FAIL	-> link error timeout on link
 *	i	-> # of bytes read (must not be 0)
 */
int
erdblk(blk, len,  fn)
register char *blk;
{
	register int i, ret;

	if(setjmp(Failbuf)) {
		DEBUG(7, "timeout (%d sec)\n", msgtime);
		return(FAIL);
	}

	alarm(msgtime);
	for (i = 0; i < len; i += ret) {
		DEBUG(9, "erdblk ask %d ", len - i);
		if ((ret = (*Read)(fn, blk, (unsigned) len - i)) < 0) {
			alarm(0);
			DEBUG(7, "erdblk read failed\n%s", "");
			return(FAIL);
		}
		DEBUG(9, "erdblk got %d\n", ret);
		if (ret == 0)
			break;
		blk += ret;
	}
	alarm(0);
	return(i);
}

struct tbuf {
	long t_nbytes;
	char t_data[TBUFSIZE];
};

/*
 * read message from link
 *	str	-> message buffer
 *	fn	-> file descriptor
 * return
 *	FAIL	-> read timed out
 *	SUCCESS	-> ok message in str
 */
trdmsg(str, fn)
char *str;
{
	return(etrdmsg(str, fn, TPACKSIZE));
}

/*
 * write message across link
 *	type	-> message type
 *	str	-> message body (ascii string)
 *	fn	-> link file descriptor
 * return
 *	FAIL	-> write failed
 *	SUCCESS	-> write succeeded
 */
twrmsg(type, str, fn)
char type;
char *str;
{
	return(etwrmsg(type, str, fn, TPACKSIZE));
}

/*
 * read data from file fp1 and write on link
 *	fp1	-> file descriptor
 *	fn	-> link descriptor
 * returns:
 *	FAIL	->failure in link
 *	SUCCESS	-> ok
 */
twrdata(fp1, fn)
register FILE *fp1;
int	fn;
{
	register int ret;
	int len;
	unsigned long bytes;
	struct tbuf bufr;
	struct stat statbuf;

	if (setjmp(Failbuf)) {
		DEBUG(7, "twrdata failed\n", 0);
		return(FAIL);
	}
	fstat(fileno(fp1), &statbuf);
	bytes = 0L;
	while ((len = read(fileno(fp1), bufr.t_data, TBUFSIZE)) > 0) {
		bufr.t_nbytes = htonl((long)len);
		DEBUG(7, "twrdata writing %d ...", len);
		bytes += len;
		putfilesize(bytes);
		len += sizeof(long);
		alarm(msgtime);
		ret = (*Write)(fn, (char *)&bufr, (unsigned) len);
		alarm(0);
		DEBUG(7, "ret %d\n", ret);
		if (ret != len)
			return(FAIL);
		if (len != TBUFSIZE+sizeof(long))
			break;
	}
	bufr.t_nbytes = 0;
	alarm(msgtime);
	ret = write(fn, (char *)&bufr, sizeof(long));
	alarm(0);
	if (ret != sizeof(long))
		return FAIL;
	return(SUCCESS);
}

/*
 * read data from link and write into file
 *	fp2	-> file descriptor
 *	fn	-> link descriptor
 * returns:
 *	SUCCESS	-> ok
 *	FAIL	-> failure on link
 */
trddata(fn, fp2)
register FILE *fp2;
{
	register int len, nread;
	long Nbytes;
	unsigned long bytes = 0L;
	char bufr[TBUFSIZE];

	for (;;) {
		len = erdblk((char *)&Nbytes, sizeof(Nbytes), fn);
		DEBUG(7, "trddata ret %d\n", len);
		if (len != sizeof(Nbytes))
			return(FAIL);
		Nbytes = ntohl(Nbytes);
		DEBUG(7,"trddata expecting %ld bytes\n", Nbytes);
		nread = Nbytes;
		if (nread == 0)
			break;
		len = erdblk(bufr, nread, fn);
		if (len != Nbytes)
			return(FAIL);
		bytes += len;
		putfilesize(bytes);
		if (write(fileno(fp2), bufr, len) != len)
			return(FAIL);
	}
	return(SUCCESS);
}

/*
 * read message from link
 *	str	-> message buffer
 *	fn	-> file descriptor
 *	i	-> if non-zero, amount to read; o.w., read up to '\0'
 * return
 *	FAIL	-> read timed out
 *	SUCCESS	-> ok message in str
 *
 * 'e' is fatally flawed -- in a byte stream world, rdmsg can pick up
 * the cmsglen on a R request.  if this happens, we stash the excess
 * where rddata can pick it up.
 */

etrdmsg(str, fn, i)
register char *str;
register int i;
{
	register int len;
	int nullterm = 0;
	char *null, *argstr;


	if (i == 0) {
		DEBUG(9, "etrdmsg looking for null terminator\n", 0);
		nullterm++;
		i = EBUFSIZ;
		argstr = str;
	}

	if(setjmp(Failbuf)) {
		DEBUG(7, "timeout (%d sec)\n", msgtime);
		return(FAIL);
	}

	alarm(msgtime);
	for (;;) {
		DEBUG(9, "etrdmsg want %d ...", i);
		len = (*Read)(fn, str, i);
		DEBUG(9, "got %d\n", len);
		if (len == 0)
			continue;	/* timeout will get this */
		if (len < 0) {
			alarm(0);
			return(FAIL);
		}
		str += len;
		i -= len;
		if (nullterm) {
			/* no way can a msg be as long as EBUFSIZ-1 ... */
			*str = 0;
			null = strchr(argstr, '\0');
			if (null != str) {
				null++;	/* start of stash */
				memcpy(Erdstash + Erdlen, null, str - null);
				Erdlen += str - null;
				break;
			} else
				argstr = str;
		} else {
			if (i == 0)
				break;
		}
	}
	alarm(0);
	return(SUCCESS);
}

/*
 * write message across link
 *	type	-> message type
 *	str	-> message body (ascii string)
 *	fn	-> link file descriptor
 *	len	-> if non-zero, amount to write;
		   o.w., write up to '\0' (inclusive)
 * return
 *	FAIL	-> write failed
 *	SUCCESS	-> write succeeded
 */
etwrmsg(type, str, fn, len)
char type;
register char *str;
int fn, len;
{
	char bufr[EBUFSIZ], *endstr;
	int ret;

	bufr[0] = type;

	/* point endstr to last character to be sent */
	if ((endstr = strchr(str, '\n')) != 0)
		*endstr = 0;
	else
		endstr = str + strlen(str);

	memcpy(bufr+1, str, (endstr - str) + 1);	/* include '\0' */
	if (len == 0)
		len = (endstr - str) + 2;	/* include bufr[0] and '\0' */
	else
		bufr[len-1] = 0;		/* 't' needs this terminator */


	if (setjmp(Failbuf)) {
		DEBUG(7, "etwrmsg write failed\n", 0);
		return(FAIL);
	}
	DEBUG(9, "etwrmsg want %d ... ", len);
	alarm(msgtime);
	ret = (*Write)(fn, bufr, (unsigned) len);
	alarm(0);
	DEBUG(9, "sent %d\n", ret);
	if (ret != len)
		return(FAIL);
	return(SUCCESS);
}
#endif	/* E_PROTOCOL */