static char sccsid[] = "@(#)prot.c	4.1	(Berkeley)	9/12/82";

/* Protocol driver, user level, Berkeley network */
/*
	This code is a little complicated because of a number of different
	protocols used.  Here is an explanation:

Level	Description

0	Normal Case (6 bit with no kernel driver support)

1	Line Discipline -- uses NETLDISP in sgtty.h and ioctl to set the
	line discipline.  At Berkeley this means avoiding interrupting on
	every character by using a Silo on a DH or DZ board, and (optionally)
	bypassing the canonicalization in the tty code by putting the charactars
	directly in a buffer.
	condition (netd.dp_bnetldis != 0)

2	8-bit TTY protocol -- implies Level 1 and inserts record separators(012)
	and escapes other occurrences of 012.  Since the driver on the other
	end must interpolate the escapes, this is an asymmetric protocol where
	the sender puts in the escapes but the receiver at the user level knows
	they have already been removed.
	condition (netd.dp_bnetldis != 0 && netd.dp_use8bit != 0)

3	8-bit Block Device protocol -- this is for a DMC-11, it writes fixed
	length blocks in both directions with no quoting.
	condition (netd.dp_bnetldis != 0 && netd.dp_usehighspeed != 0)

4	RAND 8-bit protocol -- included for completeness, is not
	correctly specified here.
	Specified by an IFDEF.

If the daemons are being simulated by pipes, then netd.dp_pipesim != 0
and each of the 4 levels (except RAND) are simulated.
In this case at level 2 (use8bit) on the receiver end it does the quoting.

Timing statistics: We estimate 300 micros for queue/dequeue and then
	20 micros per interrupt for 30 cps => 2.5% of system for 9600 Baud line

Max packet lengths=> to CSVAX with 1k buffers and 6-bit prot = 758 chars
	to Ing70 with 512 byte buffers and no NETLDISC, only 182 chars

*/
# include "defs.h"

/* global */
struct dumpstruc dump;
struct daemonparms netd;

/* local */
static int bufleft;
static char retransmit;
static jmp_buf env;
static short masterseqno, lastseqno;
/* writing packet */
static char wpack[MAXNBUF];

/*
   one problem has been character loss on
   overloaded systems due to the daemon
   taking too long to swap in
   and losing characters.
   A high priority process of small size
   with a pipe would do the job.
*/
alarmint(){
	errno = 100;
	signal(SIGALRM,SIG_IGN);		/* alarm off */
	longjmp(env,0);			/* ugh */
	}
/* returns number of bytes written, error returns WRITEFAIL (-3) */
/* inbuf is buffer of amt chars to be written */
xwrite(inbuf,amt)
  char *inbuf;
{
	register char *p, *b;
	register int i;
	int cnt, num, savetime;
	struct packet *rpp, *xptr;

	xptr = (struct packet *)wpack;
	cnt = 0;
	retransmit = 0;
	savetime = netd.dp_atime;
	while(amt > 0){
		if(retransmit > netd.dp_maxbread){
			debug("xwrite fail");
			return(WRITEFAIL);
			}
		/* format the packet to send */
		num = min(netd.dp_datasize,amt);
		/* set the length down if escapes are being used */
		if(netd.dp_use8bit)num = min(num,MAXNBUF/2);
		xptr->pcode = REQUEST;
		xptr->seqno = masterseqno;
		xptr->len = num;
		p = xptr->data;
		i = num;
		b = inbuf+cnt;
		while(i--)*p++ = *b++;
		/* send it */
		sendpacket(xptr);
		rpp = getpacket();
		if(rpp == NULL){
			netd.dp_atime += 3;	/* wait three more secs */
			retransmit++;
			dump.nretrans++;
			continue;
			}
		/* various errors */
		if(rpp->chksum != 0 || rpp->pcode != ACK
			|| rpp->seqno != xptr->seqno ){
			if(rpp->seqno == 1 && rpp->pcode == REQUEST){
				error("collision");
				return(WRITEFAIL);
				}
			if(rpp->chksum != 0)
				error("chksum %d",rpp->seqno);
			else if(rpp->pcode != ACK)
				error("not ack %d %d",rpp->pcode,rpp->seqno);
			else if(rpp->seqno != xptr ->seqno)
				error("WRSQNO got %d request %d",rpp->seqno,
					xptr->seqno);
			netd.dp_atime += 3;
			retransmit++;
			dump.nretrans++;
			continue;
			}
		masterseqno++;
		retransmit = 0;
		amt -= num;
		cnt += num;
		}
	netd.dp_atime = savetime;
	return(cnt);
	}
/* return the number of bytes read, or error = BROKENREAD (-2) */
nread(bptr,num)
	register char *bptr;
{
	register char *p;
	register struct packet *pp;
    	register char *q;
	int bcnt = 0;
	int n,j,cnt;
	static char savebuf[MAXNBUF];

	/* first see if theres any left from the last packet */
	cnt = 0;
	if(bufleft > 0){
		p = savebuf;
		cnt = n = min(bufleft,num);
		while(n--)*bptr++ = *p++;
		num -= cnt;
		bufleft -= cnt;
		if(bufleft > 0){
			q = savebuf;
			n = bufleft;
			while(n--)*q++ = *p++;
			}
		}
	if(num <= 0)
		return(cnt);
	/* now read a packet */
	retransmit = 0;
	for(;;){
		pp = getpacket();
		if(pp == NULL){
			if(++bcnt >= netd.dp_maxbread){
				debug("read timeout");
				return(BROKENREAD);
				}
			continue;
			}
		/* various errors */
		if(pp->chksum != 0){
			error("chksum %d",pp->seqno);
			retransmit++;
			continue;
			}
		if(pp->pcode & ~REQUEST){
			error("pcode %d %d",pp->pcode,pp->seqno);
			retransmit++;
			continue;
			}
		/* this is the normal case, so we ack it */
		else {		/* else was a REQUEST packet, no chksum errs */
			/*
			if(pp->seqno == 1)debug("^R ");
			*/
			pp->pcode = ACK;
			n = pp->len;
			pp->len = 0;
			sendpacket(pp);		/* send ACK */
			pp->len = n;
			break;
			}
		}
	/* now process this packet, bptr points to where we left off */
	retransmit = 0;
	j = n = min(num,pp->len);
	cnt += j;
	p = pp->data;
	while(n--)*bptr++ = *p++;
	if(pp->len > num){
		n = bufleft = pp->len - num;
		bptr = savebuf;
		while(n--)*bptr++ = *p++;
		}
	return(cnt);
	}
printpacket(pp,dest)
  char *dest;
  struct packet *pp; {
	char *s;
	int i;
	char c;
	dest[0] = 0;
	if(pp == NULL)return;
	if(pp->pcode == REQUEST)c='r';
	else if(pp->pcode == ACK)c = 'a';
	else if(pp->pcode == PURGE)c = 'p';
	else c = 'u';
	sprintf(dest,"p:%d len:%d c:%c d:", pp->seqno, pp->len, c);
	s = dest + strlen(dest);
	for(i=0; i<pp->len && pp->data[i]; i++)*s++ = pp->data[i];
	*s = 0;
	}
/*
 * A purge can always be sent -
 * the receiver totally ignores it.
 * It is used to push the packet terminator
 * down the wire in case of a crash
 * leaving the receiver half reading.
 */
sendpurge()
  {
	struct packet *xptr;
	xptr = (struct packet *)wpack;
	xptr->pcode = PURGE;
	xptr->seqno = 0;
	xptr->len = 0;
	debug("send purge");
	sendpacket(xptr);
	}
/* init sequence numbers */
initseqno(){
	masterseqno = 1;
	lastseqno = 0;
	bufleft = 0;		/* if any chars are left in buffer, flush them*/
	netd.dp_atime = netd.dp_oatime + ((rand()>>8)%15);
	}
/*
 *	Just sends packet pp
 *	Calculates the chksum
 */
sendpacket(pp)
  struct packet *pp; {
	register char *q, *p;
	register int j;
	char *finalp;
	static char raw[MAXNBUF];
	int len, n, i;

	/* writes the data to be sent in array raw */
	/* finalp will point to either pp or raw */
	dump.nbytesent += pp->len;
	dump.npacksent++;
	pp->chksum = 0;
	n = 0;
	p = (char *)pp;
	len = ACKLENGTH + pp->len;
	for(j = 0; j < len; j++)n ^= *p++;
	pp->chksum = n;
# ifdef SWAB
	switchem(pp);
# endif
# ifndef RAND
	if(netd.dp_usehispeed)finalp = (char *)pp;
	else if(netd.dp_use8bit){
		if(len >= MAXNBUF){
			fprintf(stderr,"Packet size too big- error\n");
			exit(1);
		}
		/* add escapes */
		p = (char *)pp;
		q = raw;
		i = len;
		len = 0;
		for(j = 0; j < i; j++){
			if(*p == '\n' || *p == '\\'){
				*q++ = '\\';
				*q++ = *p++;
				len++;
				len++;
			}
			else {
				*q++ = *p++;
				len++;
			}
		}
		*q = '\n';
		len++;
		finalp = raw;
	}
	else {
		/* now change 8-bit data to 6-bit data */
		if(((len+2)*4)/3 >= MAXNBUF){
			fprintf(stderr,"Packet size too big- error\n");
			exit(1);
			}
		p = raw;
		q = (char *)pp;
		len = n = (len+2)/3;
		while(n--){
			*p++ = (*q & 077) + INCR;
			j =    (*q++ >> 6) &03;
			*p++ = (((*q << 2) | j) & 077) + INCR;
			j =    (*q++ >> 4) & 017;
			*p++ = (((*q << 4) | j) & 077) + INCR;
			*p++ = ((*q++ >> 2) & 077) + INCR;
			}
		*p++ = '\n';
		*p = 0;
	/*	because of bugs in processing around erase and kill in v6 */
		for(p=raw; *p; p++)
			if(*p == '\\')*p = '}';
		len = len * 4 + 1;
		finalp = raw;
	}
	/*
	debug("send %d <<%s>>",len,raw);
	*/
	if(netd.dp_usehispeed){
		if(len > SENDLEN)error("send length too long");
		len = SENDLEN;
		}
	if(netd.dp_pipesim) i = write(netd.dp_pwritefd,finalp,len);
	else i = write(netd.dp_linefd,finalp,len);
	dump.braw += i;
	dump.brawtot += i;
# ifdef SWAB
	switchem(pp);
# endif
# else
	/* for RAND */
	i = write(netd.dp_linefd, (char *)pp,len);
# endif
	/*
	debug("count %d",i);
	*/
	}

static int tooshort;
/*
 *	returns NULL if couldn't get a packet with correct seqno
 *	chksum not checked here
 * 	because other programs may want to interrogate checksum
 */
struct packet *getpacket() {
	register struct packet *gptr;
	register char *p;
	register int i;
	int n, bcnt, len;
	struct packet *decpacket();

	bcnt = 0;
	errno = 0;
	setjmp(env);
	alarm(0);
	signal(SIGALRM,alarmint);
	for(;;){
		if(bcnt++ > netd.dp_maxbread)errno = 100;	/* give up */
		if(errno == 100){
			if(debugflg)putchar('^');
			return(NULL);
			}
		/* decode the buffer, including 6-8 bit conv, etc. */
		gptr = decpacket();
		if(gptr == NULL){
			error("getpacket fails");
			return(NULL);
		}
		if(tooshort || gptr->len < 0 || gptr->len > MAXNBUF){
			error("too short p:%d l:%d",gptr->seqno,gptr->len);
			continue;
		}
		if(gptr->seqno == 1 && gptr->pcode != ACK){
			debug("got reset");
			addtolog(remote,"^R ");
			}
		if(gptr->pcode == PURGE){
			debug("got purge");
			continue;		/* never seen */
			}
		if(gptr->seqno == lastseqno){
			if(retransmit)break;
			/* send ACK - it was lost first time thru */
			len = gptr->len;
			n = gptr->pcode;
			gptr->len = 0;
			gptr->pcode = ACK;
			sendpacket(gptr);
			gptr->len = len;
			gptr->pcode = n;
			error("sendlostack %d",lastseqno);
			break;
			}
		/* this is the correct case */
		if(gptr->seqno == lastseqno + 1)break;
		error("Wrong seq no g: %d last: %d",gptr->seqno,
			lastseqno);
		}
	lastseqno = gptr->seqno;
	n = 0;
	len = gptr->len + ACKLENGTH;
	p = (char *)gptr;
	for(i=0; i < len; i++)n ^= *p++;
	gptr->chksum = n;
	if(n != 0)dump.ncksum++;
	dump.nbytercv += gptr->len;
	dump.npackrcv++;
	return(gptr);
}
/* read in and decode packet */
/* as a side effect sets "tooshort" */
static struct packet *decpacket()
{
# ifndef RAND
	register char *p, *q;
	register int i,j;
	int n, len, ch;
	struct packet *pp;
	static char cooked[MAXNBUF], raw[MAXNBUF];

	/* read in chars to raw, if processed then return in cooked, otherwise
	return in raw */
	alarm(netd.dp_atime);
	tooshort = 0;
	if(netd.dp_pipesim){
		if(netd.dp_usehispeed)
			len = read(fileno(netd.dp_rdfile),raw,SENDLEN);
		else {
			q = raw;
			len = 0;
			for(;;){
				ch = getc(netd.dp_rdfile);
				len++;
				if(ch == '\n'){
					*q++ = '\n';
					break;
				}
				/* eat up the backslashes */
				if(ch == '\\' && netd.dp_use8bit)
					ch = getc(netd.dp_rdfile);
				*q++ = ch;
			}
			if(netd.dp_use8bit)len--;
		}
	}
	else if(netd.dp_usehispeed)
		len = read(fileno(netd.dp_rdfile),raw,SENDLEN);
	else len = read(netd.dp_linefd,raw,MAXNBUF);
	alarm(0);
	if(len == 0)fprintf(stderr,"eof pip %d\n",fileno(netd.dp_rdfile));
	if(len <= 0)return(NULL);
	raw[len] = 0;
	dump.braw += len;
	dump.brawtot += len;
	/*
	debug("receive %d <<%s>>",len,raw);
	*/
	/* if 8 bit the all we need to do is return */
	if(netd.dp_usehispeed)return((struct packet *)raw);
	if(netd.dp_use8bit){
		pp = (struct packet *)raw;
		if(len != ACKLENGTH + pp->len)tooshort = 1;
		return(pp);
	}
	/* remove this loop later */
	for(p=raw; *p; p++)
		if(*p == '}')*p = '\\';
	p = raw;
	q = cooked;
	n = (len+3) /4;
	while(n--){
		if(*p == '\n')break;
		if(*p < INCR || *p & 0200)error("bad char %o\n",*p);
		i =  *p++ - INCR;
		j =  *p++ - INCR;
		*q++ = ((j & 03) << 6) | (i & 077);
		i =  *p++ -INCR;
		*q++ = ((i & 017) << 4) | ((j >> 2) & 017);
		j =  *p++ - INCR;
		*q++ = ((j & 077) << 2) | ((i >> 4) & 03);
		}
	*q = 0;
	pp = (struct packet *)cooked;
# ifdef SWAB
	switchem(pp);
# endif
	if(len != ((ACKLENGTH + pp->len + 2)/3)*4 + 1) tooshort = 1;
# else
	/* for RAND */
	/* not sure of the length computation */
	if(len != ACKLENGTH + gptr->len) tooshort = 1;
# endif
	return((struct packet *)cooked);
}

# ifdef SWAB
switchem(pp)
register struct packet *pp; {
	register short *p;
	p = &(pp->seqno);
	swab(p, p, 2);
	p = &(pp->len);
	swab(p, p, 2);
}
# endif