## diffname port/sturp.c 1990/0227
## diff -e /dev/null /n/bootesdump/1990/0227/sys/src/9/mips/sturp.c
0a
#include "syslibc.h"
#include "lock.h"
#include "chan.h"
#include "proc.h"
#include "user.h"
#include "errno.h"
#include "lint.h"
#include "mem.h"
#include "mempool.h"
#include "stream.h"
#include "dkparam.h"
#include "misc.h"

enum {
	Nurp=		32,
	MSrexmit=	1000,
};

typedef struct Urp	Urp;

/*
 * URP status
 */
struct urpstat {
	ulong	input;		/* bytes read from urp */
	ulong	output;		/* bytes output to urp */
	ulong	rxmit;		/* retransmit rejected urp msg */
	ulong	rjtrs;		/* reject, trailer size */
	ulong	rjpks;		/* reject, packet size */
	ulong	rjseq;		/* reject, sequence number */
	ulong	levelb;		/* unknown level b */
	ulong	enqsx;		/* enqs sent */
	ulong	enqsr;		/* enqs rcved */
} urpstat;

struct Urp {
	Qlock;
	short	state;		/* flags */

	/* input */

	ulong	iwindow;	/* input window */
	uchar	iseq;		/* last good input sequence number */
	uchar	lastecho;	/* last echo/rej sent */
	uchar	trbuf[3];	/* trailer being collected */
	short	trx;		/* # bytes in trailer being collected */

	/* output */

	Queue	*rq;
	Queue	*wq;
	int	XW;		/* blocks per xmit window */
	int	maxblock;	/* max block size */
	int	timeout;	/* a timeout has occurred */
	int	WS;		/* start of current window */
	int	WACK;		/* first non-acknowledged message */
	int	WNX;		/* next message to be sent */
	Rendez	r;		/* process waiting in urpoput */
	Rendez	kr;		/* process waiting in urpoput */
	Block	*xb[8];		/* the xmit window buffer */
	uchar	timer;		/* timeout for xmit */
};
#define WINDOW(u) ((u->WS + u->XW - u->WNX)%8)
#define BETWEEN(x, s, n) (s<=n ? x>=s && x<n : x<n || x>=s)
#define UNACKED(x, u) (BETWEEN(x, u->WACK, u->WNX)

/*
 *  Protocol control bytes
 */
#define	SEQ	0010		/* sequence number, ends trailers */
#undef	ECHO
#define	ECHO	0020		/* echos, data given to next queue */
#define	REJ	0030		/* rejections, transmission error */
#define	ACK	0040		/* acknowledgments */
#define	BOT	0050		/* beginning of trailer */
#define	BOTM	0051		/* beginning of trailer, more data follows */
#define	BOTS	0052		/* seq update algorithm on this trailer */
#define	SOU	0053		/* start of unsequenced trailer */
#define	EOU	0054		/* end of unsequenced trailer */
#define	ENQ	0055		/* xmitter requests flow/error status */
#define	CHECK	0056		/* xmitter requests error status */
#define	INITREQ 0057		/* request initialization */
#define	INIT0	0060		/* disable trailer processing */
#define	INIT1	0061		/* enable trailer procesing */
#define	AINIT	0062		/* response to INIT0/INIT1 */
#undef	DELAY
#define	DELAY	0100		/* real-time printing delay */
#define	BREAK	0110		/* Send/receive break (new style) */

#define	REXMITING	0001
#define	REXMIT		0002
#define	INITING 	0004

Urp	urp[Nurp];

/*
 *  predeclared
 */
static void	urpiput(Queue*, Block*, Rendez*);
static void	urpoput(Queue*, Block*, Rendez*);
static void	urpopen(Queue*, Stream*);
static void	urpclose(Queue *);
static void	rcvack(Urp*, int);
static void	flushinput(Urp*);
static void	sendctl(Queue*, int);
static void	queuectl(Urp*, int);
static void	initoutput(Urp*, int);
static void	initinput(Urp*, int);

Qinfo urpinfo = { urpiput, urpoput, urpopen, urpclose, "urp" };

int
urpopen(Queue *q, Stream *s)
{
	Urp *up;
	int i;

	/*
	 *  find a free urp structure
	 */
	for(up = urp; up < &urp[Nurp]; up++){
		qlock(up);
		if(up->state == 0)
			break;
		qunlock(up);
	}
	if(up == &urp[Nurp])
		error(0, Egreg);

	q->ptr = = q->other->ptr = up;
	up->rq = q;
	up->wq = WR(q);
	q->put = urpciput;
	qunlock(up);
	initinput(up, 0);
	initoutput(up, 0);
}

/*
 *  Shut it down.
 */
static int
allacked(void *a)
{
	Urp *up;

	up = (Urp *)a;
	return up->WACK == up->WNX;
}
urpclose(Queue *q)
{
	Block *bp;
	Urp *up;
	int i;

	up = (Urp *)q->ptr;
	up->state |= LCLOSE;

	/*
	 *  wait for output to get acked
	 */
	while(!urpdone(up))
		sleep(&up->r, urpdone, up);
	up->state = 0;
}

/*
 *  upstream control messages
 */
static void
urpctliput(Urp *up, Queue *q, Block *bp)
{
	switch(bp->type){
	case M_HANGUP:
		/*
		 *  ack all outstanding messages
		 */
		lock(up);
		up->state &= ~(INITING);
		up->state |= RCLOSE;
		unlock(up);
		if(up->WS<up->WNX)
			urprack(up, ECHO+((up->WNX-1)&07));
	}
	PUTNEXT(q, bp);
}

/*
 *  character mode input.  the last character in EVERY block is
 *  a control character.
 */
void
urpciput(Queue *q, Block *bp, Rendez *rp)
{
	Urp *up;
	int i, full;
	Block *nbp;

	up = (Urp *)q->ptr;
	if(bp->type != M_DATA){
		urpctliput(up, q, bp);
		return;
	}

	/*
	 *  get the control character
	 */
	if(bp->wptr > bp->rptr)
		ctl = *(--bp->wptr);
	else
		ctl = 0;

	/*
	 *  send the block upstream
	 */
	if(bp->wptr > bp->rptr)
		PUTNEXT(q, bp);
	else
		freeb(bp);

	/*
	 *  handle the control character
	 */
	switch(ctl){
	case 0:
		break;

	case ENQ:
		urpstat.enqsr++;
		queuectl(up, up->lastecho);
		queuectl(up, ACK+up->iseq);
		flushinput(up);
		break;

	case CHECK:
		queuectl(up, ACK+up->iseq);
		break;

	case AINIT:
		up->state &= ~INITING;
		flushinput(up);
		wakeup(&cp->kr);
		break;

	case INIT0:
	case INIT1:
		queuectl(up, AINIT);
		if(*bp->rptr == INIT1)
			q->put = urpbiput;
		initinput(up, 0);
		break;

	case INITREQ:
		initoutput(up, 0);
		break;

	case BREAK:
		break;

	case ACK+0: case ACK+1: case ACK+2: case ACK+3:
	case ACK+4: case ACK+5: case ACK+6: case ACK+7:
	case ECHO+0: case ECHO+1: case ECHO+2: case ECHO+3:
	case ECHO+4: case ECHO+5: case ECHO+6: case ECHO+7:
		rcvack(up, ctl);
		break;

	case SEQ+0: case SEQ+1: case SEQ+2: case SEQ+3:
	case SEQ+4: case SEQ+5: case SEQ+6: case SEQ+7:
		/*
		 *  acknowledge receipt
		 */
		ctl = ctl & 07;
		if(q->next->len < Streamhi){
			queuectl(up, ECHO+ctl);
			up->lastecho = ECHO+ctl;
			wakeup(&cp->kr);
		}
		up->iseq = ctl;
		break;
	}
}

/*
 *  block mode input.  the last character in EVERY block is a control character.
 */
void
urpbiput(Queue *q, Block *bp, Rendez *rp)
{
	Urp *up;
	int i, full;
	Block *nbp;

	up = (Urp *)q->ptr;
	if(bp->type != M_DATA){
		urpctliput(up, q, bp);
		return;
	}

	/*
	 *  get the control character
	 */
	if(bp->wptr > bp->rptr)
		ctl = *(--bp->wptr);
	else
		ctl = 0;

	/*
	 *  take care of any block count(trx)
	 */
	while(bp->wptr > bp->rptr && up->trx){
		switch (up->trx) {
		case 1:
		case 2:
			up->trbuf[up->trx++] = *bp->rptr++;
			continue;
		default:
			up->trx = 0;
		case 0:
			break;
		}
	}

	/*
	 *  queue the block
	 */
	if(bp->wptr > bp->rptr){
		if(q->len > up->iwindow){
			flushinput(up);
			freeb(bp);
			return;
		}
		putq(q, bp);
	} else
		freeb(bp);

	/*
	 *  handle the control character
	 */
	switch(ctl){
	case 0:
		break;
	case ENQ:
		urpstat.enqsr++;
		queuectl(up, up->lastecho);
		queuectl(up, ACK+up->iseq);
		flushinput(up);
		break;

	case CHECK:
		queuectl(WR(q)->next, ACK+up->iseq);
		break;

	case AINIT:
		up->state &= ~INITING;
		flushinput(up);
		wakeup(&cp->kr);
		break;

	case INIT0:
	case INIT1:
		queuectl(up, AINIT);
		if(*bp->rptr == INIT0)
			q->put = urpciput;
		initinput(up, 0);
		break;

	case INITREQ:
		initoutput(up, 0);
		break;

	case BREAK:
		break;

	case BOT:
	case BOTS:
	case BOTM:
		up->trx = 1;
		up->trbuf[0] = ctl;
		break;

	case REJ+0: case REJ+1: case REJ+2: case REJ+3:
	case REJ+4: case REJ+5: case REJ+6: case REJ+7:
		rcvack(up, ctl);
		break;
	
	case ACK+0: case ACK+1: case ACK+2: case ACK+3:
	case ACK+4: case ACK+5: case ACK+6: case ACK+7:
	case ECHO+0: case ECHO+1: case ECHO+2: case ECHO+3:
	case ECHO+4: case ECHO+5: case ECHO+6: case ECHO+7:
		rcvack(up, ctl);
		break;

	/*
	 *  this case is extremely ugliferous
	 */
	case SEQ+0: case SEQ+1: case SEQ+2: case SEQ+3:
	case SEQ+4: case SEQ+5: case SEQ+6: case SEQ+7:
		i = ctl & 07;
		if(up->trx != 3){
			urpstat.rjtrs++;
			flushinput(up);
			break;
		} else if(q->len != up->trbuf[1] + (up->trbuf[2]<<8)){
			urpstat.rjpks++;
			flushinput(up);
			break;
		} else if(i != ((up->iseq+1)&07))) {
			urpstat.rjseq++;
			flushinput(up);
			break;
		}

		/*
		 *  send data upstream
		 */
		if(q->first) {
			q->first->flags |= S_DELIM;
			while(bp = getq(q))
				PUTNEXT(q, nbp);
		} else {
			bp = allocb(0);
			bp->flag |= S_DELIM;
			PUTNEXT(q, bp);
		{
		up->trx = 0;

		/*
		 *  acknowledge receipt
		 */
		ctl = ctl & 07;
		if(q->next->len < Streamhi){
			queuectl(up, ECHO+ctl);
			up->lastecho = ECHO+ctl;
			wakeup(&cp->kr);
		}
		up->iseq = ctl;
		break;
	}
}

/*
 *  downstream control
 */
static void
urpctloput(Urp *up, Queue *q, Block *bp)
{
	int fields[2];
	int n;
	int inwin=0, outwin=0;

	switch(bp->type){
	case M_CTL:
		if(streamparse("init", bp)){
			switch(getfields(bp->rptr, fields, 2, ' ')){
			case 2:
				inwin = strtoul(fields[1], 0, 0);
			case 1:
				outwin = strtoul(fields[0], 0, 0);
			}
			initinput(up, inwin);
			initoutput(up, outwin);
			freeb(bp);
			return;
		}
	}
	PUTNEXT(q, bp);
}

/*
 * accept data from writer
 */
urpoput(Queue *q, Block *bp)
{
	Urp *up;

	up = (Urp *)q->ptr;

	if(bp->type != M_DATA){
		urpctloput(up, q, bp);
		return;
	}

	urpstat.output + =  bp->wptr - bp->rptr;

	for(;;){
	}
}

/*
 * wait for an AINIT
 */
void
urpopenwait(Urp *up, Queue *q)
{
	while((up->state&ISOPENING) && !(up->state&RCLOSE)) {
		proc->state = Waiting;
		up->proc = proc;
		putctl1(q->next, M_RDATA, INIT1);
		if((up->state&ISOPENING) == 0){
			up->proc = 0;
			if(proc->state == Waiting){
				proc->state = Running;
				return;
			}
		}
		sched();
		up->proc = 0;
	}
}

/*
 *  wait till transmission is complete
 */
void
urpxmitwait(Urp *up, Queue *q)
{
	Block *bp;
	int debug;

	debug = (q->flag&QDEBUG);

	up->timeout = 0;
	while(!EMPTY(q) || up->WS<up->WNX){
		/*
		 *  clean up if the channel closed
		 */
		if (up->state & RCLOSE) {
			while(bp = getq(q))
				freeb(bp);
			up->WACK = up->WS = up->WNX;
		}
		/*
		 * free acked blocks
		 */
		urpfreeacked(up);
		/*
		 * retransmit if requested
		 */
		if(up->state&REXMIT)
			urprexmit(up, q);
		/*
		 * fill up the window
		 */
		if(!EMPTY(q) && WINDOW(up))
			urpfillwindow(up, q);
		/*
		 * ask other end for its status
		 */
		if(up->timeout){
			urpstat.enqsx++;
			putctl1(q->next, M_RDATA, ENQ);
			up->timeout = 0;
		}
		lock(up->olock);
		if((up->state&RCLOSE) == 0 && up->WS! = up->WNX) {
			proc->state = Waiting;
			up->proc = proc;
			unlock(up->olock);
			sched();
		} else
			unlock(up->olock);
	}
	urpfreeacked(up);
	up->WS = up->WACK = up->WF = up->WNX = up->WNX&07;
}

/*
 * fill up the urp output window
 */
void
urpfillwindow(Urp *up, Queue *q)
{
	Block *bp, *xbp;
	int debug;

	debug = (q->flag&QDEBUG);

	/*
	 * now process any thing that fits in the flow control window
	 */
	while (WINDOW(up)) {
		bp = getq(q);
		if (bp  ==  NULL)
			break;
		/* force MAXBLOCK length segments */
		if (bp->rptr+up->maxblock < bp->wptr) {
			xbp = allocb(0);
			if (xbp == NULL) {
				putbq(q, bp);
				break;
			}
			xbp->rptr = bp->rptr;
			bp->rptr + =  up->maxblock;
			xbp->wptr = bp->rptr;
			putbq(q, bp);
			bp = xbp;
		}
		/*
		 *  put new block in the block array.  if something is already
		 *  there, it should be because we haven't gotten around to freeing
		 *  it yet.  If not, complain.
		 */
		if (up->xb[up->WNX&07]) {
			urpfreeacked(up);
			if (up->xb[up->WNX&07]) {
				uprint(up, "urpfillwindow: overlap");
				freeb(up->xb[up->WNX&07]);
			}
		}
		up->xb[up->WNX&07] = bp;
		up->WNX++;
		urpxmit(q, bp, up->WNX-1);
	}
}

/*
 *  Send out a message, with trailer.
 */
void
urpxmit(Queue *q, Block *bp, int seqno)
{
	Urp *up = (Urp *)q->ptr;
	int size;
	Block *xbp;
	int debug;

	if (bp == NULL) {
		print("null bp in urpxmit\n");
		return;
	}
	debug = (q->flag&QDEBUG);
	size = bp->wptr - bp->rptr;
	seqno & =  07;
	/* send ptr to block, if non-empty */
	if (size) {
		if ((xbp = allocb(0))  ==  NULL){
			print("can't xmit\n");
			return;
		}
		xbp->rptr = bp->rptr;
		xbp->wptr = bp->wptr;
		xbp->type = bp->type;
		PUTNEXT(q, xbp);
	}
	/* send trailer */
	if ((xbp = allocb(3))  ==  NULL){
		print("can't xmit2\n");
		return;
	}
	xbp->type = M_RDATA;
	*xbp->wptr++ = (bp->class&S_DELIM) ? BOT: BOTM;
	*xbp->wptr++ = size;
	*xbp->wptr++ = size >> 8;
	PUTNEXT(q, xbp);
	putctl1(q->next, M_RDATA, SEQ + seqno);
	up->timer = DKPTIME;
}

void
urprexmit(Urp *up, Queue *q)
{
	int i;

	for (i = up->WACK; i<up->WNX; i++) {
		urpxmit(q, up->xb[i&07], i);
		urpstat.rxmit++;
	}
	up->state & =  ~REXMIT;
}

/*
 *  receive an acknowledgement
 */
static void
rcvack(Urp *up, int msg)
{
	int seqno;
	int next;

	seqno = msg&07;
	next = (seqno+1) & 0x7

	lock(up);
	if(BETWEEN(seqno, up->WACK, up->WNX))
		up->WACK = next;

	switch(msg & 0370){
	case ECHO:
		up->timer = MSrexmit;	/* push off ENQ timeout */
		if(BETWEEN(seqno, up->WS, up->WNX)){
			up->WS = next;
			wakeup(&up->r);
		}
		break;
	case REJ:
	case ACK:
		if(up->WACK == next){
			up->state |= REXMIT;
			wakeup(&up->r);
		}
		break;
	}
	unlock(up);
}

/*
 * throw away any partially collected input
 */
static void
flushinput(Urp *up)
{
	Block *bp;

	while (bp = getq(up->rq))
		freeb(bp);
	up->trx = 0;
}

/*
 *  send a control character down stream
 */
static void
sendctl(Queue *q, int x)
{
	Block *bp;

	/*
	 *  send anything queued
	 */
	while(bp = getq(q))
		PUTNEXT(q, bp);

	/*
	 *  send the new byte
	 */
	bp = allocb(1);
	*bp->wptr++ = x;
	PUTNEXT(q, bp);
}

/*
 *  queue a control character to be sent down stream
 */
static void
queuectl(Urp *up, int x)
{
	Block *bp;
	Queue *q;

	q = up->wq;
	bp = allocb(1);
	*bp->wptr++ = x;
	putq(q, bp);
	wakeup(&up->r);
}

/*
 *  initialize output
 */
static void
initoutput(Urp *up, int window)
{
	/*
	 *  ack any outstanding blocks
	 */
	if(up->WS<up->WNX)
		urprack(up, ECHO+((up->WNX-1)&07));

	/*
	 *  set output window
	 */
	up->maxblock = window/4;
	if(up->maxblock < 64)
		up->maxblock = 64;
	if(up->maxblock > Streamhi/4)
		up->maxblock = Streamhi/4;
	up->XW = 4;

	/*
	 *  set sequence varialbles
	 */
	up->WS = 1;
	up->WACK = 1;
	up->WNX = 1;

	/*
	 *  tell the other side we've inited
	 */
	up->state |= ISOPENING;
	up->timer = MSrexmit;
	sendctl(q->next, INIT1);
}

/*
 *  initialize input
 */
static void
initinput(Urp *up, int window)
{
	/*
	 *  restart all sequence parameters
	 */
	up->trx = 0;
	up->iseq = 0;
	up->lastecho = ECHO+0;
	up->WF = 1;
	flushinput(up);
}
.
## diffname port/sturp.c 1990/0312
## diff -e /n/bootesdump/1990/0227/sys/src/9/mips/sturp.c /n/bootesdump/1990/0312/sys/src/9/mips/sturp.c
807a
}

/*
 *  do retransmissions etc
 */
static int
todo(void *arg)
{
	Urp *up;

	up = (Urp *)arg;
	return (WINDOW(up)>0 && up->wq->len>0 && !(up->state&INITING));
}
static void
urpkproc(void *arg)
{
	Urp *up;

	up = (Urp *)arg;

	for(;;){
		if(up->state & (HUNGUP|CLOSING)){
			if(isflushed(up))
				wakeup(&up->r);
			if(up->state & HUNGUP)
				break;
		}
		if((up->lastecho&Nmask)!=up->iseq && up->rq->next->len<Streamhi)
			sendctl(up, up->lastecho = ECHO+up->iseq);
		output(up);
		tsleep(&up->rq->r, todo, up, MSrexmit/2);
	}
	DPRINT("urpkproc exiting %ux\n", up);
	up->kstarted = 0;
	up->state = 0;
.
806d
789,791c
	up->state |= INITING;
	up->timer = NOW + MSrexmit;
	sendctl(up, INIT1);
.
786a
	 *  free any outstanding blocks
	 */
	for(i = 0; i < 8; i++){
		qlock(&up->xl[i]);
		if(up->xb[i])
			freeb(up->xb[i]);
		qunlock(&up->xl[i]);
	}

	/*
.
782,784c
	up->unechoed = 1;
	up->unacked = 1;
	up->next = 1;
	up->nxb = 1;
.
777c
	up->maxblock -= 4;
	up->maxout = 3;
.
763,767c
	int i;
.
720,757d
703c

	wakeup(&up->rq->r);
.
697,699c
		/*
		 *  start a retransmission if we aren't retransmitting
		 *  and this is the start of a window.
		 */
		if(up->unechoed==next && !(up->state & REJECTING)){
			up->state |= REJECTING;
			up->next = next;
.
695a
		if(IN(seqno, up->unechoed, up->next))
			up->unechoed = next;
		/*
		 *  ... FALL THROUGH ...
		 */
.
693a
		/*
		 *  the next reject at the start of a window starts a 
		 *  retransmission.
		 */
		up->state &= ~REJECTING;
.
689,692c
		if(IN(seqno, up->unechoed, up->next)) {
			up->unechoed = next;
.
683,685c
	/*
	 *  release any acknowledged blocks
	 */
	if(IN(seqno, up->unacked, up->next)){
		for(; up->unacked != next; up->unacked = NEXT(up->unacked)){
			qlock(&up->xl[up->unacked]);
			if(up->xb[up->unacked])
				freeb(up->xb[up->unacked]);
			up->xb[up->unacked] = 0;
			qunlock(&up->xl[up->unacked]);
		}
	}
.
680,681c
	seqno = msg&Nmask;
	next = NEXT(seqno);
.
664,668c
	up->timer = NOW + MSrexmit;
	if(up->wq->next->len > Streamhi)
		return;

	/*
	 *  message 1, the BOT and the data
	 */
	bp = up->xb[bn];
	m = allocb(1);
	m->rptr = m->lim - 1;
	m->wptr = m->lim;
	*m->rptr = (bp->flags & S_DELIM) ? BOT : BOTM;
	nbp = m->next = allocb(0);
	nbp->rptr = bp->rptr;
	nbp->wptr = bp->wptr;
	nbp->flags |= S_DELIM;
	PUTNEXT(up->wq, m);

	/*
	 *  message 2, the block length and the SEQ
	 */
	m = allocb(3);
	m->rptr = m->lim - 3;
	m->wptr = m->lim;
	n = BLEN(bp);
	m->rptr[0] = SEQ | bn;
	m->rptr[1] = n;
	m->rptr[2] = n<<8;
	m->flags |= S_DELIM;
	PUTNEXT(up->wq, m);
.
662c
	Block *bp, *m, *nbp;
	int n;
.
659,660c
/*
 *  send a block.
 */
static void
sendblock(Urp *up, int bn)
.
630,656c
	bp = allocb(1);
	bp->wptr = bp->lim;
	bp->rptr = bp->lim-1;
	*bp->rptr = ctl;
	bp->flags |= S_DELIM;
	PUTNEXT(up->wq, bp);
.
627,628c
	if(up->wq->next->len > Streamhi)
.
622,625c
	Block *bp;
.
619,620c
static void
sendctl(Urp *up, int ctl)
.
617c
 *  send a control byte, put the byte at the end of the allocated
 *  space in case a lower layer needs header room.
.
613a
	if(bp)
		putbq(q, bp);
/*	print("output w(%d) up->xb[%d](%ux) up->nxb(%d) up->state(%ux)\n",
		WINDOW(up), up->next, up->xb[up->next], up->nxb, up->state);
/**/
	/*
	 *  if a retransmit time has elapsed since a transmit, send an ENQ
	 */
	if(up->unechoed != up->next && NOW > up->timer){
		print("sENQ\n");
		up->timer = NOW + MSrexmit;
		up->state &= ~REJECTING;
		sendctl(up, ENQ);
		qunlock(&up->xmit);
		poperror();
		return;
	}

	/*
	 *  if there's a window open, push some blocks out
	 */
	while(WINDOW(up)>0 && up->xb[up->next]!=0 && canqlock(&up->xl[up->next])){
		if(up->xb[up->next])
			sendblock(up, up->next);
		qunlock(&up->xl[up->next]);
		up->next = NEXT(up->next);
	}
	qunlock(&up->xmit);
	poperror();
.
598,612d
581,596c
	q = up->wq;
	for(bp = getq(q); bp && up->xb[up->nxb]==0; up->nxb = NEXT(up->nxb)){
		if(BLEN(bp) > up->maxblock){
			nbp = up->xb[up->nxb] = allocb(0);
			nbp->rptr = bp->rptr;
			nbp->wptr = bp->rptr = bp->rptr + up->maxblock;
		} else {
			up->xb[up->nxb] = bp;
			bp = getq(q);
.
579c
	 *  fill the transmit buffers
.
567,577d
563,565d
532,561c
		qunlock(&up->xmit);
		poperror();
		return;
.
522,530c
	/*
	 *  if still initing and it's time to rexmit, send an INIT1
	 */
	now = NOW;
	if(up->state & INITING){
		if(now > up->timer){
			sendctl(up, INIT1);
			up->timer = now + MSrexmit;
.
520c
	if(waserror()){
		print("urp output error\n");
		qunlock(&up->xmit);
		nexterror();
	}
.
511,518c
	if(!canqlock(&up->xmit))
		return;
.
495,509c
	Block *bp, *nbp;
	ulong now;
	Queue *q;
	int n;
.
492,493c
static void
output(Urp *up)
.
490c
 *  start output
.
483,486c
	urpstat.output += BLEN(bp);
	putq(q, bp);
	output(up);
.
471a
static void
.
470c
 *  accept data from a writer
.
460c
/*			initinput(up, inwin); */
			DPRINT("initoutput %d\n", outwin);
.
454c
			switch(getfields((char *)bp->rptr, fields, 2, ' ')){
.
447c
	char *fields[2];
.
436c
		up->iseq = i;
.
432,434c
			sendctl(up, ECHO+i);
			up->lastecho = ECHO+i;
			wakeup(&up->rq->r);
.
430d
424c
		}
.
422c
			bp->flags |= S_DELIM;
.
419c
				PUTNEXT(q, bp);
.
417c
			if(up->trbuf[0] != BOTM)
				q->last->flags |= S_DELIM;
.
409a
			print("sREJ\n");
			sendctl(up, up->lastecho = REJ+up->iseq);
.
407c
		} else if(i != ((up->iseq+1)&Nmask)) {
.
405a
			print("sREJ\n");
			sendctl(up, up->lastecho = REJ+up->iseq);
.
401a
			print("sREJ\n");
			sendctl(up, up->lastecho = REJ+up->iseq);
.
398c
		i = ctl & Nmask;
.
394c
	 *  if the seuence number is the next expected
	 *	and te trailer length == 3
	 *	and the block count matches the bytes received
	 *  then send the bytes upstream.
.
382a
		print("rREJ\n");
.
361,362c
		sendctl(up, AINIT);
		if(ctl == INIT0)
.
356c
		wakeup(&up->rq->r);
.
350c
		sendctl(up, ACK+up->iseq);
.
344,345c
		sendctl(up, up->lastecho);
		sendctl(up, ACK+up->iseq);
.
342a
		print("rENQ\n");
.
332d
329d
326,327c
	if(BLEN(bp) > 0){
		putq(q, bp);
		q->last->flags &= ~S_DELIM;
		if(q->len > 4*1024){
.
324c
	 *  queue the block(s)
.
318d
310c
	while(up->trx){
		if(BLEN(bp)<=0)
			break;
.
302,305c
	ctl = *bp->rptr++;
.
290,291c
	int i;
	int ctl;
.
287c
urpiput(Queue *q, Block *bp)
.
284c
 *  block mode input.
 *
 *  the first byte in every message is a ctl byte (which belongs at the end).
 *
 *  Simplifying assumption:  one put == one message && the control byte
 *	is in the first block.  If this isn't true, strange bytes will be
 *	used as control bytes.
.
269,278c
		i = ctl & Nmask;
		if(q->next->len < Streamhi)
			sendctl(up, up->lastecho = ECHO+i);
		up->iseq = i;
.
259a
	case REJ+0: case REJ+1: case REJ+2: case REJ+3:
	case REJ+4: case REJ+5: case REJ+6: case REJ+7:
		rcvack(up, ctl);
		break;
	
.
247,249c
		sendctl(up, AINIT);
		if(ctl == INIT1)
			q->put = urpiput;
.
242c
		wakeup(&up->rq->r);
.
236c
		sendctl(up, ACK+up->iseq);
.
230,232c
		sendctl(up, up->lastecho);
		sendctl(up, ACK+up->iseq);
.
227d
216c
	if(BLEN(bp)>0 && q->next->len<Streamhi)
.
214c
	 *  take care of any data
.
208,211c
	ctl = *bp->rptr++;
	if(ctl < 0)
		return;
.
196,197c
	int i;
	int ctl;
.
193c
urpciput(Queue *q, Block *bp)
.
189,190c
 *  character mode input.
 *
 *  the first byte in every message is a ctl byte (which belongs at the end).
.
175,183c
		up->state |= HUNGUP;
		wakeup(&up->r);
		wakeup(&up->rq->r);
		break;
.
162,164c
	up->state |= CLOSING;
	sleep(&up->r, isflushed, up);

	/*
	 *  ack all outstanding messages
	 */
	qlock(&up->xmit);
	up->state |= HUNGUP;
	i = up->next - 1;
	if(i < 0)
		i = 7;
	rcvack(up, ECHO+i);
	qunlock(&up->xmit);
	DPRINT("urpclose(%ux)\n", up);

	/*
	 *  kill off the kernel process
	 */
	wakeup(&up->rq->r);
	DPRINT("urpclosed(%ux)\n", up);
.
160c
	 *  wait for all outstanding messages to drain, tell kernel
	 *  process we're closing.
.
157d
149a
static int
isdead(void *a)
{
	Urp *up;

	up = (Urp *)a;
	return up->kstarted == 0;
}
static void
.
148c
	return (up->state&HUNGUP) || (up->unechoed==up->next && up->wq->len==0);
.
143c
isflushed(void *a)
.
140c
 *  Shut down the connection and kill off the kernel process
.
136a

	/*
	 *  start the ack/(re)xmit process
	 */
	if(up->kstarted == 0){
		up->kstarted = 1;
		sprint(name, "**urp%d**", up - urp);
		kproc(name, urpkproc, up);
	}
.
132,133c
	up->wq = q->other;
	up->state = OPEN;
.
130c
	q->ptr = q->other->ptr = up;
.
116a
	char name[128];
.
112c
static void
.
110c
Qinfo urpinfo = { urpciput, urpoput, urpopen, urpclose, "urp" };
.
108a
static void	urpkproc(void *arg);
.
105,106c
static void	sendctl(Urp*, int);
.
102a
static void	output(Urp*);
static void	sendblock(Urp*, int);
.
99,100c
static void	urpciput(Queue*, Block*);
static void	urpiput(Queue*, Block*);
static void	urpoput(Queue*, Block*);
.
90,92c
#define	REJECTING	0x1
#define	INITING 	0x2
#define HUNGUP		0x4
#define	OPEN		0x8
#define CLOSING		0x10
.
63,65c
#define WINDOW(u) ((u->unechoed + u->maxout - u->next)%8)
#define IN(x, f, n) (f<=n ? x>=f && x<n : x<n || x>=f)
#define NEXT(x) (((x)+1)&Nmask)
.
61c
	QLock	xl[8];
	ulong	timer;		/* timeout for xmit */

	int	kstarted;
.
54,59c
	int	next;		/* next block to send */
	int	unechoed;	/* first unechoed block */
	int	unacked;	/* first unacked block */
	int	nxb;		/* next xb to use */
.
50,52c
	QLock	xmit;		/* output lock, only one process at a time */
	Queue	*wq;		/* output queue */
	int	maxout;		/* maximum outstanding unacked blocks */
.
42c
	Queue	*rq;		/* input queue */
.
38a
	Rendez	r;		/* process waiting for close */
.
37c
	QLock;
.
20a
#define NOW (MACHP(0)->ticks*MS2HZ)

.
18a
#define DPRINT if(0)

.
16a
	Nmask=		0x7,
.
1,12c
#include	"u.h"
#include	"lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"errno.h"
.
## diffname port/sturp.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/mips/sturp.c /n/bootesdump/1990/0315/sys/src/9/mips/sturp.c
825a
	DPRINT("urpkproc started\n");
.
782a
		up->xb[i] = 0;
.
458c
			print("sREJ3 %d %d\n", i, up->iseq);
.
452c
			print("sREJ2 %d\n", up->iseq);
.
446c
			print("sREJ1 %d\n", up->iseq);
.
382c
		print("rENQ %uo %uo\n", up->lastecho, ACK+up->iseq);
.
125a
	DPRINT("urpopen\n");

.
## diffname port/sturp.c 1990/0321
## diff -e /n/bootesdump/1990/0315/sys/src/9/mips/sturp.c /n/bootesdump/1990/0321/sys/src/9/mips/sturp.c
843d
838,839c
		sendack(up);
.
829d
805a
	up->blocks = 0;
.
640a
 *  send a reject
 */
static void
sendrej(Urp *up)
{
	flushinput(up);
	qlock(&up->ack);
	if((up->lastecho&~Nmask) == ECHO){
		DPRINT("REJ %d\n", up->iseq);
		sendctl(up, up->lastecho = REJ|up->iseq);
	}
	qunlock(&up->ack);
}

/*
 *  send an acknowledge
 */
static void
sendack(Urp *up)
{
	Block *bp;

	/*
	 *  check the precondition for acking
	 */
	if(up->rq->next->len>=Streamhi || (up->lastecho&Nmask)==up->iseq)
		return;

	if(!canqlock(&up->ack))
		return;

	/*
	 *  check again now that we've locked
	 */
	if(up->rq->next->len>=Streamhi || (up->lastecho&Nmask)==up->iseq){
		qunlock(&up->ack);
		return;
	}

	/*
	 *  send the ack
	 */
	sendctl(up, up->lastecho = ECHO|up->iseq);
	qunlock(&up->ack);
}

/*
.
599c
		DPRINT("sENQ\n");
.
513d
488a
		if(q->next->len < Streamhi)
			sendctl(up, up->lastecho = ECHO|i);
		qunlock(&up->ack);
.
483,487c
		qlock(&up->ack);
.
459,461c
			sendrej(up);
.
453,455c
			sendrej(up);
.
447,449c
			sendrej(up);
.
425c
		DPRINT("rREJ\n");
.
384c
		DPRINT("rENQ %d %uo %uo\n", up->blocks, up->lastecho, ACK+up->iseq);
		up->blocks = 0;
.
315a
		qunlock(&up->ack);
.
311a
		qlock(&up->ack);
.
209d
203d
126,127d
112a
static void	sendack(Urp*);
static void	sendrej(Urp*);
.
47a
	int	blocks;
.
42c
	QLock	ack;		/* ack lock */
.
## diffname port/sturp.c 1990/0331
## diff -e /n/bootesdump/1990/0321/sys/src/9/mips/sturp.c /n/bootesdump/1990/0331/sys/src/9/mips/sturp.c
66c
#define WINDOW(u) ((u)->unechoed>(u)->next ? (u)->unechoed+(u)->maxout-(u)->next-8 :\
			(u)->unechoed+(u)->maxout-(u)->next)
.
## diffname port/sturp.c 1990/0403
## diff -e /n/bootesdump/1990/0331/sys/src/9/mips/sturp.c /n/bootesdump/1990/0403/sys/src/9/mips/sturp.c
885a
	up->kstarted = 0;
.
884d
872a
	if(waserror()){
		up->state = 0;
		up->kstarted = 0;
		wakeup(&up->r);
		return;
	}
.
807,808d
692c
	if(QFULL(up->wq->next))
.
670c
	if(QFULL(up->rq->next) || (up->lastecho&Nmask)==up->iseq){
.
661c
	if(QFULL(up->rq->next) || (up->lastecho&Nmask)==up->iseq)
.
625c
	if(QFULL(up->wq->next))
.
582c
			bp = 0;
.
575c
	for(bp = getq(q); q->first && up->xb[up->nxb]==0; up->nxb = NEXT(up->nxb)){
		if(bp == 0)
			bp = getq(q);
.
482c
		if(!QFULL(q->next))
.
314c
		if(!QFULL(q->next))
.
256c
	if(BLEN(bp)>0 && !QFULL(q->next))
.
209a

	if(up->kstarted == 0)
		up->state = 0;
.
## diffname port/sturp.c 1990/0406
## diff -e /n/bootesdump/1990/0403/sys/src/9/mips/sturp.c /n/bootesdump/1990/0406/sys/src/9/mips/sturp.c
590,591d
588a
		if(bp)
			putbq(q, bp);
.
578,587c
	if(up->xb[up->nxb]==0) {
		for(bp=getq(q); bp && up->xb[up->nxb]==0; up->nxb=NEXT(up->nxb)){
			if(BLEN(bp) > up->maxblock){
				nbp = up->xb[up->nxb] = allocb(0);
				nbp->rptr = bp->rptr;
				nbp->wptr = bp->rptr = bp->rptr + up->maxblock;
			} else {
				up->xb[up->nxb] = bp;
				bp = getq(q);
			}
.
## diffname port/sturp.c 1990/0424
## diff -e /n/bootesdump/1990/0406/sys/src/9/mips/sturp.c /n/bootesdump/1990/0424/sys/src/9/mips/sturp.c
475c
			if(up->trbuf[0] != BOTM)
				bp->flags |= S_DELIM;
.
374d
372a
		bp->flags &= ~S_DELIM;
.
## diffname port/sturp.c 1990/0505
## diff -e /n/bootesdump/1990/0424/sys/src/9/mips/sturp.c /n/bootesdump/1990/0505/sys/src/9/mips/sturp.c
193c
	tsleep(&up->r, isflushed, up, 60*1000);
.
## diffname port/sturp.c 1990/0509
## diff -e /n/bootesdump/1990/0505/sys/src/9/mips/sturp.c /n/bootesdump/1990/0509/sys/src/9/mips/sturp.c
209c
	for(i = 0; i < 7; i++)
		if(up->xb[i]){
			freeb(up->xb[i]);
			up->xb[i] = 0;
		}
	qunlock(&up->xmit);
.
207c
	 *  free all staged but unsent messages
.
204d
199a
	wakeup(&up->rq->r);

	qlock(&up->xmit);
	/*
	 *  ack all outstanding messages
	 */
.
198d
196c
	 *  kill off the kernel process
.
193c
	tsleep(&up->r, isflushed, up, 2*60*1000);
.
190a
	 *
	 *  if 2 minutes elapse, give it up
.
169c
	return (up->state&HUNGUP) || (up->unechoed==up->nxb && up->wq->len==0);
.
## diffname port/sturp.c 1990/0511
## diff -e /n/bootesdump/1990/0509/sys/src/9/mips/sturp.c /n/bootesdump/1990/0511/sys/src/9/mips/sturp.c
906a
	DPRINT("urpkproc %ux\n", up);
.
901c
		if(up->state == 0){
			DPRINT("urpkproc: %ux->state == 0\n", up);
			break;
		}
		if(!QFULL(up->rq->next))
			sendack(up);
.
888a
		print("urpkproc error %ux\n", up);
.
833a
	up->rexmit = 0;
.
789c
			up->rexmit = 1;
.
757,761c
			i = up->unacked;
			qlock(&up->xl[i]);
			if(up->xb[i])
				freeb(up->xb[i]);
			up->xb[i] = 0;
			qunlock(&up->xl[i]);
.
747a
	int i;
.
627a
		poperror();
.
623,626c
	if(up->rexmit){
		up->rexmit = 0;
		up->next = up->unechoed;
	}
	while(WINDOW(up)>0 && up->xb[up->next]!=0){
		i = up->next;
		qlock(&up->xl[i]);
		if(waserror()){
			qunlock(&up->xl[i]);
			nexterror();
		}
		sendblock(up, i);
		qunlock(&up->xl[i]);
.
610,611c
	if(up->unechoed!=up->next && NOW>up->timer){
.
561a
	int i;
.
473a
		} else if(q->next->len > (3*Streamhi)/2
			|| q->next->nb > (3*Streambhi)/2) {
			flushinput(up);
			break;
.
223a
	}
.
222c
	if(up->kstarted == 0){
		DPRINT("urpclose %ux\n", up);
.
171,178d
62a
	int	rexmit;
.
51d
## diffname port/sturp.c 1990/0601
## diff -e /n/bootesdump/1990/0511/sys/src/9/mips/sturp.c /n/bootesdump/1990/0601/sys/src/9/mips/sturp.c
266c
	} else
.
264c
	if(BLEN(bp)>0  && q->next->len<2*Streamhi && q->next->nb<2*Streambhi){
		bp->flags |= S_DELIM;
.
## diffname port/sturp.c 1990/0629
## diff -e /n/bootesdump/1990/0601/sys/src/9/mips/sturp.c /n/bootesdump/1990/0629/sys/src/9/mips/sturp.c
925a
}

/*
 *  urp got very confused, complain
 */
static void
urpvomit(char *msg, Urp* up)
{
	print("urpvomit: %s %ux next %d unechoed %d unacked %d nxb %d\n",
		msg, up, up->next, up->unechoed, up->unacked, up->nxb);
	print("\txb: %ux %ux %ux %ux %ux %ux %ux %ux\n",
		up->xb[0], up->xb[1], up->xb[2], up->xb[3], up->xb[4], 
		up->xb[5], up->xb[6], up->xb[7]);
	print("\tiseq: %uo lastecho: %uo trx: %d trbuf: %uo %uo %uo\n",
		up->iseq, up->lastecho, up->trx, up->trbuf[0], up->trbuf[1],
		up->trbuf[2]);
	print("\tupq: %ux %d %d\n", up->rq->next->first,  up->rq->next->nb,
		up->rq->next->len);
}

int
urpdump(void)
{
	Urp *up;

	for(up = urp; up < &urp[Nurp]; up++)
		if(up->rq)
			urpvomit("", up);
.
770a
			else
				urpvomit("rcvack", up);
.
724a
	if(bp == 0){
		urpvomit("sendblock", up);
		return;
	}
.
622,626c
	while(WINDOW(up)>0 && up->next!=up->nxb){
.
620a
	 *
	 *  the lock is to synchronize with acknowledges that free
	 *  blocks.
.
610c
	if(up->rexmit){
		/*
		 *  if a retransmit is requested, move next back to
		 *  the unacked blocks
		 */
		up->rexmit = 0;
		up->next = up->unacked;
	} else if(up->unacked!=up->next && NOW>up->timer){
		/*
		 *  if a retransmit time has elapsed since a transmit,
		 *  send an ENQ
		 */
.
608c
	 *  retransmit cruft
.
604,606c

.
599a
			up->nxb = i;
.
590,591c
	i = NEXT(up->nxb);
	if(i != up->unechoed) {
		for(bp = getq(q); bp && i!=up->unechoed; i = NEXT(i)){
			if(up->xb[up->nxb] != 0)
				urpvomit("output", up);
.
587c
	 *  fill the transmit buffers, `nxb' can never overtake `unechoed'
.
119a
static void	urpvomit(char*, Urp*);
.
68c
#define IN(x, f, n) (f<=n ? (x>=f && x<n) : (x<n || x>=f))
.
## diffname port/sturp.c 1990/0702
## diff -e /n/bootesdump/1990/0629/sys/src/9/mips/sturp.c /n/bootesdump/1990/0702/sys/src/9/mips/sturp.c
962a
	lock(up->rq->next);
	for(bp = up->rq->next->first; bp; bp = bp->next){
		print("%d%c:\t", bp->wptr - bp->rptr, (bp->flags&S_DELIM)?'D':' ');
		
		for(cp = bp->rptr; cp<bp->wptr && cp<bp->rptr+10; cp++)
			print(" %uo", *cp);
		print("\n");
	}
	unlock(up->rq->next);
.
961c
	print("\tupq: %ux %d %d\n", &up->rq->next->r,  up->rq->next->nb,
.
952a
	Block *bp;
	uchar *cp;

.
## diffname port/sturp.c 1990/0707
## diff -e /n/bootesdump/1990/0702/sys/src/9/mips/sturp.c /n/bootesdump/1990/0707/sys/src/9/mips/sturp.c
966,974d
953,955d
## diffname port/sturp.c 1990/0717
## diff -e /n/bootesdump/1990/0707/sys/src/9/mips/sturp.c /n/bootesdump/1990/0717/sys/src/9/mips/sturp.c
970c
	for(up = urp; up < &urp[conf.nurp]; up++)
.
179a
	if(up == 0)
		return;
.
141a
	}
.
140c
	if(up == &urp[conf.nurp]){
		q->ptr = 0;
		WR(q)->ptr = 0;
.
134c
	for(up = urp; up < &urp[conf.nurp]; up++){
.
123a
void
urpreset(void)
{
	newqinfo(&urpinfo);
	urp = (Urp *)ialloc(conf.nurp*sizeof(Urp), 0);
}

.
100c
Urp	*urp;
.
10d
## diffname port/sturp.c 1990/0721
## diff -e /n/bootesdump/1990/0717/sys/src/9/mips/sturp.c /n/bootesdump/1990/0721/sys/src/9/mips/sturp.c
928a
	q = up->wq;
.
926c
	Urp *up; Queue *q;
.
690a
	Queue *q = up->wq;
.
538a
		if(streamparse("debug", bp)){
			switch(getfields((char *)bp->rptr, fields, 2, ' ')){
			case 1:
				if (strcmp(fields[0], "on") == 0) {
					q->flag |= QDEBUG;
					q->other->flag |= QDEBUG;
				}
				if (strcmp(fields[0], "off") == 0) {
					q->flag &= ~QDEBUG;
					q->other->flag &= ~QDEBUG;
				}
			}
			freeb(bp);
			return;
		}
.
485a
		DPRINT("rSEQ%d accept %d\n", i, q->len);
.
461,462c
	 *  if the sequence number is the next expected
	 *	and the trailer length == 3
.
442a
	case BOTS:
		DPRINT("rBOT%d...", ctl-BOT);
.
441d
14c
#define DPRINT /*if(q->flag&QDEBUG)kprint*/
.
## diffname port/sturp.c 1990/0722
## diff -e /n/bootesdump/1990/0721/sys/src/9/mips/sturp.c /n/bootesdump/1990/0722/sys/src/9/mips/sturp.c
165c
		sprint(name, "urp%d", up - urp);
.
## diffname port/sturp.c 1990/0725
## diff -e /n/bootesdump/1990/0722/sys/src/9/mips/sturp.c /n/bootesdump/1990/0725/sys/src/9/mips/sturp.c
974a
}

/*
 *  timer to wakeup urpkproc's for retransmissions
 */
static void
urptimer(Alarm *a)
{
	Urp *up;
	Urp *last;
	Queue *q;

	urptiming = 0;
	for(up = urp, last = &urp[conf.nurp]; up < last; up++){
		if(up->state==0)
			continue;
		if(up->unacked!=up->next && NOW>up->timer){
			q = up->rq;
			if(q)
				wakeup(&q->r);
		}
	}
.
970c
		sleep(&up->rq->r, todo, up);
.
591a
	/*
	 *  start the urptimer if it isn't already
	 */
	if(urptiming==0){
		if(canlock(&urptlock)){
			if(urptiming == 0)
				urptiming = alarm(500, urptimer, 0);
			unlock(&urptlock);
		}
	}

.
167a

	/*
	 *  start the urptimer if it isn't already
	 */
	if(urptiming==0){
		if(canlock(&urptlock)){
			if(urptiming == 0)
				urptiming = alarm(500, urptimer, 0);
			unlock(&urptlock);
		}
	}
.
118a
static void	urptimer(Alarm*);
.
70a
 *  Alarm for urptiming
 */
Alarm	*urptiming;
Lock	urptlock;

/*
.
## diffname port/sturp.c 1990/0726
## diff -e /n/bootesdump/1990/0725/sys/src/9/mips/sturp.c /n/bootesdump/1990/0726/sys/src/9/mips/sturp.c
1015a
	cancel(a);
.
## diffname port/sturp.c 1990/0728
## diff -e /n/bootesdump/1990/0726/sys/src/9/mips/sturp.c /n/bootesdump/1990/0728/sys/src/9/mips/sturp.c
1017c
	alarm(500, urptimer, 0);
.
1002a
	wakeup(&up->r);
	poperror();
.
1001d
995d
986,993c
		if(up->state & HUNGUP)
.
980d
976c
	up->kstarted = 1;
.
973c
	Urp *up;
.
707a
out:
.
685,687c
		goto out;
.
639,641c
		goto out;
.
610,620d
244,247c
	/*
	 *  wait for kernel process to die
	 */
	while(up->kstarted)
		sleep(&up->r, isdead, up);

	up->state = 0;
.
220c
	 *  tell kernel process to die
.
191a
isdead(void *a)
{
	Urp *up;

	up = (Urp *)a;
	return up->kstarted==0;
}
static int
.
170,185c
	sprint(name, "urp%d", up - urp);
	kproc(name, urpkproc, up);
.
134a
	alarm(500, urptimer, 0);
.
71,76d
## diffname port/sturp.c 1990/0731
## diff -e /n/bootesdump/1990/0728/sys/src/9/mips/sturp.c /n/bootesdump/1990/0731/sys/src/9/mips/sturp.c
991c
		if((up->unacked!=up->next || (up->state&INITING)) && NOW>up->timer){
.
## diffname port/sturp.c 1990/0804
## diff -e /n/bootesdump/1990/0731/sys/src/9/mips/sturp.c /n/bootesdump/1990/0804/sys/src/9/mips/sturp.c
991,995c
		if(up->rq && todo(up))
			wakeup(&up->rq->r);
.
973d
946c

	return (up->state&INITING)
	? NOW>up->timer					/* time to INIT1 */
	: ((up->unacked!=up->next && NOW>up->timer)	/* time to ENQ */
	  || (!QFULL(up->rq->next) && up->iseq!=(up->lastecho&7))); /* time to ECHO */
.
## diffname port/sturp.c 1990/0814
## diff -e /n/bootesdump/1990/0804/sys/src/9/mips/sturp.c /n/bootesdump/1990/0814/sys/src/9/mips/sturp.c
949a
	  || WINDOW(up)>0 && up->next!=up->nxb
.
777d
774,775c
	if(bp == 0)
.
## diffname port/sturp.c 1990/0911
## diff -e /n/bootesdump/1990/0814/sys/src/9/mips/sturp.c /n/bootesdump/1990/0911/sys/src/9/mips/sturp.c
127d
124c
static void
.
122c
Qinfo urpinfo = { urpciput, urpoput, urpopen, urpclose, "urp", urpreset };
.
103a
static void	urpreset(void);
.
14c
#define DPRINT if(q->flag&QDEBUG)print
.
## diffname port/sturp.c 1990/0930
## diff -e /n/bootesdump/1990/0911/sys/src/9/mips/sturp.c /n/bootesdump/1990/0930/sys/src/9/mips/sturp.c
947c
	: ((up->unechoed!=up->next && NOW>up->timer)	/* time to ENQ */
.
656c
	} else if(up->unechoed!=up->next && NOW>up->timer){
.
## diffname port/sturp.c 1990/1004
## diff -e /n/bootesdump/1990/0930/sys/src/9/mips/sturp.c /n/bootesdump/1990/1004/sys/src/9/mips/sturp.c
993,994c
		if(up->rq && canlock(up)){
			if(up->rq && NOW>up->timer
			   && ((up->state&INITING) || up->unechoed!=up->next))
				wakeup(&up->rq->r);
			unlock(up);
		}
.
986d
948,949c
	  || (WINDOW(up)>0 && (up->next!=up->nxb || up->wq->first)) /* open xmit window */
	  || (up->iseq!=(up->lastecho&7) && !QFULL(up->rq->next))); /* time to ECHO */
.
797c
	PUTNEXT(q, m);
	DPRINT("sb %d\n", bn);
.
784c
	PUTNEXT(q, m);
.
767c
	if(QFULL(q->next))
.
765a
	q = up->wq;
.
764a
	Queue *q;
.
706c
	PUTNEXT(q, bp);
	DPRINT("sCTL %ulx\n", ctl);
.
699c
	q = up->wq;
	if(QFULL(q->next))
.
697a
	Queue *q;
.
467a
		DPRINT("rACK %ux\n", ctl);
.
239a
	up->rq = 0;
	unlock(up);
.
238a
	lock(up);
.
158c
	unlock(up);
.
146c
		unlock(up);
.
143c
		lock(up);
.
36c
	Lock;
.
## diffname port/sturp.c 1990/11151
## diff -e /n/bootesdump/1990/1004/sys/src/9/mips/sturp.c /n/bootesdump/1990/11151/sys/src/9/mips/sturp.c
123c
Qinfo urpinfo =
{
	urpciput,
	urpoput,
	urpopen,
	urpclose,
	"urp",
	urpreset
};
.
## diffname port/sturp.c 1990/11211
## diff -e /n/bootesdump/1990/11151/sys/src/9/mips/sturp.c /n/bootesdump/1990/11211/sys/src/9/mips/sturp.c
159c
		error(Egreg);
.
## diffname port/sturp.c 1990/1206
## diff -e /n/bootesdump/1990/11211/sys/src/9/mips/sturp.c /n/bootesdump/1990/1206/sys/src/9/mips/sturp.c
1015a
		tsleep(&urpkr, return0, 0, 1000);
.
984,1014c
		for(up = urp; up < eup; up++){
			if(up->state==0 || (up->state&HUNGUP))
				break;
			if(!canqlock(up))
				continue;
			if(up->state==0 || (up->state&HUNGUP))
				break;
			if(up->iseq!=(up->lastecho&7) && !QFULL(up->rq->next))
				sendack(up);
			output(up);
			qunlock(up);
.
977,982c
	eup = urp + conf.nurp;
.
974,975c
	if(waserror())
		;
.
972c
	Urp *up, *eup;
.
953,968d
876c
	wakeup(&urpkr);
.
443c
		wakeup(&urpkr);
.
322c
		wakeup(&urpkr);
.
263d
249,250c
	qunlock(up);
.
241,247c
	qlock(up);
.
220d
215,218d
181,188d
169,174d
166c
	qunlock(up);
.
154c
		qunlock(up);
.
151c
		qlock(up);
.
146a
	if(!urpkstarted){
		qlock(&urpkl);
		if(!urpkstarted){
			urpkstarted = 1;
			kproc("urpkproc", urpkproc, 0);
		}
		qunlock(&urpkl);
	}

.
137d
120d
99,100d
64a
Urp	*urp;

Rendez	urpkr;
QLock	urpkl;
int	urpkstarted;

.
62,63d
38c
	Rendez	r;		/* process waiting for output to finish */
.
36c
	QLock;
.
## diffname port/sturp.c 1990/1210
## diff -e /n/bootesdump/1990/1210/sys/src/9/mips/sturp.c /n/bootesdump/1990/1210/sys/src/9/port/sturp.c
955a
			poperror();
.
950,951c
			if(waserror()){
				qunlock(up);
				continue;
			}
			if(up->state==0 || (up->state&HUNGUP)){
				qunlock(up);
				poperror();
				continue;
			}
.
947c
				continue;
.
209c
	if(!waserror()){
		tsleep(&up->r, isflushed, up, 2*60*1000);
		poperror();
	}
.
## diffname port/sturp.c 1990/1212
## diff -e /n/bootesdump/1990/1210/sys/src/9/port/sturp.c /n/bootesdump/1990/1212/sys/src/9/port/sturp.c
171a
	q->rp = &urpkr;
.
## diffname port/sturp.c 1990/1214
## diff -e /n/bootesdump/1990/1212/sys/src/9/port/sturp.c /n/bootesdump/1990/1214/sys/src/9/port/sturp.c
543a
			USED(inwin);
.
## diffname port/sturp.c 1991/0426
## diff -e /n/bootesdump/1990/1214/sys/src/9/port/sturp.c /n/bootesdump/1991/0426/sys/src/9/port/sturp.c
863a
	wakeup(&up->r);
.
## diffname port/sturp.c 1991/0605
## diff -e /n/bootesdump/1991/0426/sys/src/9/port/sturp.c /n/bootesdump/1991/0605/sys/src/9/port/sturp.c
366a
	if(up == 0)
		return;
.
267a
	if(up == 0)
		return;
.
160,163c
		if(up->state == 0){
			qlock(up);
			if(up->state == 0)
				break;
			qunlock(up);
		}
.
## diffname port/sturp.c 1991/0626
## diff -e /n/bootesdump/1991/0605/sys/src/9/port/sturp.c /n/bootesdump/1991/0626/sys/src/9/port/sturp.c
14c
#define DPRINT if(q->flag&QDEBUG)kprint
.
## diffname port/sturp.c 1991/0705
## diff -e /n/bootesdump/1991/0626/sys/src/9/port/sturp.c /n/bootesdump/1991/0705/sys/src/9/port/sturp.c
14c
#define DPRINT if(q->flag&QDEBUG)print
.
## diffname port/sturp.c 1991/1115
## diff -e /n/bootesdump/1991/0705/sys/src/9/port/sturp.c /n/bootesdump/1991/1115/sys/src/9/port/sturp.c
170c
		errors("out of urp structures");
.
## diffname port/sturp.c 1991/1122
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/sturp.c /n/bootesdump/1991/1122/sys/src/9/port/sturp.c
1006a
}

void
urpfillstats(Chan *c, char *buf, int len)
{
	char b[256];

	USED(c);
	sprint(b, "in: %d\nout: %d\nrexmit: %d\nrjtrs: %d\nrjpks: %d\nrjseq: %d\nenqsx: %d\nenqsr: %d\n",
		urpstat.input, urpstat.output, urpstat.rexmit, urpstat.rjtrs,
		urpstat.rjpks, urpstat.rjseq, urpstat.enqsr, urpstat.enqsr);
	strncpy(buf, b, len);
.
667a
		urpstat.enqsx++;
.
658a
		urpstat.rexmit++;
.
510a
			}
.
509c
			while(bp = getq(q)){
				urpstat.input += BLEN(bp);
.
288a
		urpstat.input += BLEN(bp);
.
26c
	ulong	rexmit;		/* retransmit rejected urp msg */
.
## diffname port/sturp.c 1991/1216
## diff -e /n/bootesdump/1991/1122/sys/src/9/port/sturp.c /n/bootesdump/1991/1216/sys/src/9/port/sturp.c
956a
	USED(arg);

.
## diffname port/sturp.c 1992/0111
## diff -e /n/bootesdump/1991/1216/sys/src/9/port/sturp.c /n/bootesdump/1992/0111/sys/src/9/port/sturp.c
7c
#include	"../port/error.h"
.
## diffname port/sturp.c 1992/0114
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/sturp.c /n/bootesdump/1992/0114/sys/src/9/port/sturp.c
170c
		exhausted("urp structures");
.
## diffname port/sturp.c 1992/0205
## diff -e /n/bootesdump/1992/0114/sys/src/9/port/sturp.c /n/bootesdump/1992/0205/sys/src/9/port/sturp.c
1024c
		urpstat.rjpks, urpstat.rjseq, urpstat.enqsx, urpstat.enqsr);
.
932a
	{ Queue *q = up->wq; DPRINT("initoutput (%d): ", up->timer); }
.
813c
	DPRINT("sb %d (%d)\n", bn, up->timer);
.
765a
	{ Queue *q = up->wq; DPRINT("sendack: "); }
.
719a
	PUTNEXT(q, bp);
.
718d
669a
		DPRINT("OUTPUT timer (%d, %d): ", NOW, up->timer);
.
624a
			q = up->wq;
			DPRINT("INITING timer (%d, %d): ", now, up->timer);
.
502c
		DPRINT("accept %d\n", q->len);
.
483a
		DPRINT("rSEQ%d...", ctl-SEQ);
.
472c
		DPRINT("%s%d\n", (ctl&ECHO)?"rECHO":"rACK", ctl&7);
.
464c
		DPRINT("rREJ%d\n", ctl-REJ);
.
457c
		DPRINT("rBOT%c...", " MS"[ctl-BOT]);
.
447a
		DPRINT("rINITREQ\n");
.
440a
		DPRINT("rINIT%d\n", ctl-INIT0);
.
433a
		DPRINT("rAINIT\n");
.
429a
		DPRINT("rCHECK\n");
.
344a
		DPRINT("rSEQ%d(c)\n", ctl-SEQ);
.
339a
		DPRINT("%s%d(c)\n", (ctl&ECHO)?"rECHO":"rACK", ctl&7);
.
332a
		DPRINT("rREJ%d(c)\n", ctl-REJ);
.
324a
		DPRINT("rINITREQ(c)\n");
.
317a
		DPRINT("rINIT%d(c)\n", ctl-INIT0);
.
310a
		DPRINT("rAINIT(c)\n");
.
306a
		DPRINT("rCHECK(c)\n");
.
300a
		DPRINT("rENQ(c)\n");
.
172c
/*
	q->flag |= QDEBUG;
	q->other->flag |= QDEBUG;
*/
.
## diffname port/sturp.c 1992/0206
## diff -e /n/bootesdump/1992/0205/sys/src/9/port/sturp.c /n/bootesdump/1992/0206/sys/src/9/port/sturp.c
505a
			DPRINT("rej %d rcvd %d xpctd\n", q->len,
				up->trbuf[1] + (up->trbuf[2]<<8));
.
## diffname port/sturp.c 1992/0208
## diff -e /n/bootesdump/1992/0206/sys/src/9/port/sturp.c /n/bootesdump/1992/0208/sys/src/9/port/sturp.c
515,516c
		}else if(q->next->len > (3*Streamhi)/2
			|| q->next->nb > (3*Streambhi)/2){
			DPRINT("next->len=%d, next->nb=%d\n",
				q->next->len, q->next->nb);
.
511c
		}else if(i != ((up->iseq+1)&Nmask)){
.
505,507c
		}else if(q->len != len){
.
499c
		len = up->trbuf[1] + (up->trbuf[2]<<8);
		DPRINT("rSEQ%d(%d,%d,%d)...", ctl-SEQ, up->trx, len, q->len);
.
379c
	int i, len;
.
14c
#define DPRINT if(q->flag&QDEBUG)kprint
.
## diffname port/sturp.c 1992/0321
## diff -e /n/bootesdump/1992/0208/sys/src/9/port/sturp.c /n/bootesdump/1992/0321/sys/src/9/port/sturp.c
2c
#include	"../port/lib.h"
.
## diffname port/sturp.c 1992/0408
## diff -e /n/bootesdump/1992/0321/sys/src/9/port/sturp.c /n/bootesdump/1992/0408/sys/src/9/port/sturp.c
1008c
		tsleep(&urpkr, return0, 0, 500);
.
897,898c
	tryoutput(up);
	if(up->state & CLOSING)
		wakeup(&up->r);
.
722a
 *  try output, this is called by an input process
 */
void
tryoutput(Urp *up)
{
	if(!waserror()){
		output(up);
		poperror();
	}
}

/*
.
449c
		tryoutput(up);
.
373a
 *
 *	There's no input lock.  The channel could be closed while we're
 *	processing a message.
.
319c
		tryoutput(up);
.
122a
static void	tryoutput(Urp*);
.
## diffname port/sturp.c 1992/0409
## diff -e /n/bootesdump/1992/0408/sys/src/9/port/sturp.c /n/bootesdump/1992/0409/sys/src/9/port/sturp.c
946c
	up->maxout = 4;
.
## diffname port/sturp.c 1992/0520
## diff -e /n/bootesdump/1992/0409/sys/src/9/port/sturp.c /n/bootesdump/1992/0520/sys/src/9/port/sturp.c
1054a
	return 0;
.
## diffname port/sturp.c 1992/0622
## diff -e /n/bootesdump/1992/0520/sys/src/9/port/sturp.c /n/bootesdump/1992/0622/sys/src/9/port/sturp.c
138c
	urp = (Urp *)xalloc(conf.nurp*sizeof(Urp));
.
## diffname port/sturp.c 1992/0623
## diff -e /n/bootesdump/1992/0622/sys/src/9/port/sturp.c /n/bootesdump/1992/0623/sys/src/9/port/sturp.c
1045,1055d
1005c
		for(up = urpalloc.urp; up; up = up->list){
.
1003d
996c
	Urp *up;
.
173,176d
168,171c
	if(up == 0){
		/*
		 *  none available, create a new one, they are never freed
		 */
		up = smalloc(sizeof(Urp));
		qlock(up);
		lock(&urpalloc);
		up->list = urpalloc.urp;
		urpalloc.urp = up;
		unlock(&urpalloc);
.
160c
	for(up = urpalloc.urp; up; up = up->list){
.
158c
	 *  find an unused urp structure
.
138d
64a
/* list of allocated urp structures (never freed) */
struct
{
	Lock;
	Urp	*urp;
} urpalloc;

.
63d
36a
	Urp	*list;		/* list of all urp structures */
.
## diffname port/sturp.c 1992/0711
## diff -e /n/bootesdump/1992/0623/sys/src/9/port/sturp.c /n/bootesdump/1992/0711/sys/src/9/port/sturp.c
989c
initinput(Urp *up)
.
790,791d
638d
578,585c
			outwin = strtoul((char*)bp->rptr, 0, 0);
.
572,573c
	int outwin;
.
470c
		initinput(up);
.
337c
		initinput(up);
.
209d
191c
	initinput(up);
.
153a
	USED(s);
.
151,152d
127c
static void	initinput(Urp*);
.
## diffname port/sturp.c 1992/1026
## diff -e /n/bootesdump/1992/0711/sys/src/9/port/sturp.c /n/bootesdump/1992/1026/sys/src/9/port/sturp.c
573a
		if(streamparse("break", bp)){
			sendctl(up, BREAK);
			freeb(bp);
			return;
		}
.
## diffname port/sturp.c 1992/1027
## diff -e /n/bootesdump/1992/1026/sys/src/9/port/sturp.c /n/bootesdump/1992/1027/sys/src/9/port/sturp.c
838c
	if(bp->type == M_CTL){
		PUTNEXT(q, nbp);
		m->flags |= S_DELIM;
		PUTNEXT(q, m);
	} else {
		m->next = nbp;
		PUTNEXT(q, m);
	}
.
836a
	nbp->base = bp->base;
	nbp->lim = bp->lim;
.
834c
	nbp = allocb(0);
.
575,576c
			/*
			 *  send a break as part of the data stream
			 */
			urpstat.output++;
			bp->wptr = bp->lim;
			bp->rptr = bp->wptr - 1;
			*bp->rptr = BREAK;
			putq(q, bp);
			output(up);
.
## diffname port/sturp.c 1993/0116
## diff -e /n/bootesdump/1992/1027/sys/src/9/port/sturp.c /n/bootesdump/1993/0116/sys/src/9/port/sturp.c
893,894d
244a
		qunlock(&up->xl[i]);
	}
.
240c
	for(i = 0; i < 7; i++){
		qlock(&up->xl[i]);
.
## diffname port/sturp.c 1993/0418
## diff -e /n/bootesdump/1993/0116/sys/src/9/port/sturp.c /n/bootesdump/1993/0418/sys/src/9/port/sturp.c
868c
	m->rptr[2] = n>>8;
.
## diffname port/sturp.c 1993/0501
## diff -e /n/bootesdump/1993/0418/sys/src/9/port/sturp.c /n/fornaxdump/1993/0501/sys/src/brazil/port/sturp.c
1057,1060c
		urp->iseq, urp->lastecho, urp->trx, urp->trbuf[0], urp->trbuf[1],
		urp->trbuf[2]);
	print("\tupq: %ux %d %d\n", &urp->rq->next->r,  urp->rq->next->nb,
		urp->rq->next->len);
.
1054,1055c
		urp->xb[0], urp->xb[1], urp->xb[2], urp->xb[3], urp->xb[4], 
		urp->xb[5], urp->xb[6], urp->xb[7]);
.
1052c
		msg, urp, urp->next, urp->unechoed, urp->unacked, urp->nxb);
.
1049c
urpvomit(char *msg, Urp* urp)
.
1035,1038c
			if(urp->iseq!=(urp->lastecho&7) && !QFULL(urp->rq->next))
				sendack(urp);
			output(urp);
			qunlock(urp);
.
1030,1031c
			if(urp->state==0 || (urp->state&HUNGUP)){
				qunlock(urp);
.
1027c
				qunlock(urp);
.
1024c
			if(!canqlock(urp))
.
1021,1022c
		for(urp = urpalloc.urp; urp; urp = urp->list){
			if(urp->state==0 || (urp->state&HUNGUP))
.
1013c
	Urp *urp;
.
1003,1007c
	urp->blocks = 0;
	urp->trx = 0;
	urp->iseq = 0;
	urp->lastecho = ECHO+0;
	flushinput(urp);
.
998c
initinput(Urp *urp)
.
988,991c
	urp->state |= INITING;
	urp->timer = NOW + MSrexmit;
	{ Queue *q = urp->wq; DPRINT("initoutput (%d): ", urp->timer); }
	sendctl(urp, INIT1);
.
978,982c
		qlock(&urp->xl[i]);
		if(urp->xb[i])
			freeb(urp->xb[i]);
		urp->xb[i] = 0;
		qunlock(&urp->xl[i]);
.
968,972c
	urp->unechoed = 1;
	urp->unacked = 1;
	urp->next = 1;
	urp->nxb = 1;
	urp->rexmit = 0;
.
959,963c
	urp->maxblock = window/4;
	if(urp->maxblock < 64)
		urp->maxblock = 64;
	urp->maxblock -= 4;
	urp->maxout = 4;
.
952c
initoutput(Urp *urp, int window)
.
945c
	urp->trx = 0;
.
943c
	while (bp = getq(urp->rq))
.
939c
flushinput(Urp *urp)
.
930,932c
	tryoutput(urp);
	if(urp->state & CLOSING)
		wakeup(&urp->r);
.
923,925c
		if(urp->unechoed==next && !(urp->state & REJECTING)){
			urp->state |= REJECTING;
			urp->rexmit = 1;
.
913,914c
		if(IN(seqno, urp->unechoed, urp->next))
			urp->unechoed = next;
.
910c
		urp->state &= ~REJECTING;
.
903,904c
		if(IN(seqno, urp->unechoed, urp->next)) {
			urp->unechoed = next;
.
890,897c
	if(IN(seqno, urp->unacked, urp->next)){
		for(; urp->unacked != next; urp->unacked = NEXT(urp->unacked)){
			i = urp->unacked;
			qlock(&urp->xl[i]);
			if(urp->xb[i])
				freeb(urp->xb[i]);
			else
				urpvomit("rcvack", urp);
			urp->xb[i] = 0;
			qunlock(&urp->xl[i]);
.
878c
rcvack(Urp *urp, int msg)
.
871c
	DPRINT("sb %d (%d)\n", bn, urp->timer);
.
868c
	m->rptr[2] = n<<8;
.
837c
	bp = urp->xb[bn];
.
829,830c
	q = urp->wq;
	urp->timer = NOW + MSrexmit;
.
827a
	Block *bp, *m, *nbp;
.
825d
823c
sendblock(Urp *urp, int bn)
.
814,816c
	{ Queue *q = urp->wq; DPRINT("sendack: "); }
	sendctl(urp, urp->lastecho = ECHO|urp->iseq);
	qunlock(&urp->ack);
.
806,807c
	if(QFULL(urp->rq->next) || (urp->lastecho&Nmask)==urp->iseq){
		qunlock(&urp->ack);
.
800c
	if(!canqlock(&urp->ack))
.
797c
	if(QFULL(urp->rq->next) || (urp->lastecho&Nmask)==urp->iseq)
.
792c
sendack(Urp *urp)
.
785c
	qunlock(&urp->ack);
.
778,783c
	Queue *q = urp->wq;
	flushinput(urp);
	qlock(&urp->ack);
	if((urp->lastecho&~Nmask) == ECHO){
		DPRINT("REJ %d\n", urp->iseq);
		sendctl(urp, urp->lastecho = REJ|urp->iseq);
.
776c
sendrej(Urp *urp)
.
760c
	q = urp->wq;
.
755c
sendctl(Urp *urp, int ctl)
.
745c
		output(urp);
.
742c
tryoutput(Urp *urp)
.
734c
	qunlock(&urp->xmit);
.
728,730c
		sendblock(urp, i);
		qunlock(&urp->xl[i]);
		urp->next = NEXT(urp->next);
.
725c
			qunlock(&urp->xl[i]);
.
721,723c
	while(WINDOW(urp)>0 && urp->next!=urp->nxb){
		i = urp->next;
		qlock(&urp->xl[i]);
.
711c
		sendctl(urp, ENQ);
.
707,709c
		DPRINT("OUTPUT timer (%d, %d): ", NOW, urp->timer);
		urp->timer = NOW + MSrexmit;
		urp->state &= ~REJECTING;
.
700,702c
		urp->rexmit = 0;
		urp->next = urp->unacked;
	} else if(urp->unechoed!=urp->next && NOW>urp->timer){
.
694c
	if(urp->rexmit){
.
685c
			urp->nxb = i;
.
682c
				urp->xb[urp->nxb] = bp;
.
680c
				nbp->wptr = bp->rptr = bp->rptr + urp->maxblock;
.
671,678c
	q = urp->wq;
	i = NEXT(urp->nxb);
	if(i != urp->unechoed) {
		for(bp = getq(q); bp && i!=urp->unechoed; i = NEXT(i)){
			if(urp->xb[urp->nxb] != 0)
				urpvomit("output", urp);
			if(BLEN(bp) > urp->maxblock){
				nbp = urp->xb[urp->nxb] = allocb(0);
.
658,663c
	if(urp->state & INITING){
		if(now > urp->timer){
			q = urp->wq;
			DPRINT("INITING timer (%d, %d): ", now, urp->timer);
			sendctl(urp, INIT1);
			urp->timer = now + MSrexmit;
.
650c
		qunlock(&urp->xmit);
.
645c
	if(!canqlock(&urp->xmit))
.
638c
output(Urp *urp)
.
631c
	output(urp);
.
625c
		urpctloput(urp, q, bp);
.
622c
	urp = (Urp *)q->ptr;
.
620c
	Urp *urp;
.
591c
			initoutput(urp, outwin);
.
586c
			output(urp);
.
570c
urpctloput(Urp *urp, Queue *q, Block *bp)
.
560,561c
			sendctl(urp, urp->lastecho = ECHO|i);
		qunlock(&urp->ack);
.
557,558c
		qlock(&urp->ack);
		urp->iseq = i;
.
552c
		urp->trx = 0;
.
548c
			if(urp->trbuf[0] != BOTM)
.
540c
			if(urp->trbuf[0] != BOTM)
.
531c
			flushinput(urp);
.
525c
			sendrej(urp);
.
523c
		}else if(i != ((urp->iseq+1)&Nmask)){
.
521c
			sendrej(urp);
.
517c
			sendrej(urp);
.
515c
		if(urp->trx != 3){
.
512,513c
		len = urp->trbuf[1] + (urp->trbuf[2]<<8);
		DPRINT("rSEQ%d(%d,%d,%d)...", ctl-SEQ, urp->trx, len, q->len);
.
501c
		rcvack(urp, ctl);
.
493c
		rcvack(urp, ctl);
.
486,487c
		urp->trx = 1;
		urp->trbuf[0] = ctl;
.
476c
		initoutput(urp, 0);
.
471c
		initinput(urp);
.
468c
		sendctl(urp, AINIT);
.
460,462c
		urp->state &= ~INITING;
		flushinput(urp);
		tryoutput(urp);
.
455c
		sendctl(urp, ACK+urp->iseq);
.
448,450c
		sendctl(urp, urp->lastecho);
		sendctl(urp, ACK+urp->iseq);
		flushinput(urp);
.
445,446c
		DPRINT("rENQ %d %uo %uo\n", urp->blocks, urp->lastecho, ACK+urp->iseq);
		urp->blocks = 0;
.
432c
			flushinput(urp);
.
420c
			urp->trx = 0;
.
417c
			urp->trbuf[urp->trx++] = *bp->rptr++;
.
414c
		switch (urp->trx) {
.
411c
	while(urp->trx){
.
399c
		urpctliput(urp, q, bp);
.
395,396c
	urp = (Urp *)q->ptr;
	if(urp == 0)
.
391c
	Urp *urp;
.
369,371c
			sendctl(urp, urp->lastecho = ECHO+i);
		urp->iseq = i;
		qunlock(&urp->ack);
.
366c
		qlock(&urp->ack);
.
360c
		rcvack(urp, ctl);
.
352c
		rcvack(urp, ctl);
.
343c
		initoutput(urp, 0);
.
338c
		initinput(urp);
.
335c
		sendctl(urp, AINIT);
.
327,329c
		urp->state &= ~INITING;
		flushinput(urp);
		tryoutput(urp);
.
322c
		sendctl(urp, ACK+urp->iseq);
.
316,317c
		sendctl(urp, urp->lastecho);
		sendctl(urp, ACK+urp->iseq);
.
286c
		urpctliput(urp, q, bp);
.
282,283c
	urp = (Urp *)q->ptr;
	if(urp == 0)
.
278c
	Urp *urp;
.
263,264c
		urp->state |= HUNGUP;
		wakeup(&urp->r);
.
259c
urpctliput(Urp *urp, Queue *q, Block *bp)
.
250,252c
	qlock(urp);
	urp->state = 0;
	qunlock(urp);
.
246,248c
	qunlock(&urp->xmit);
.
240,244c
	for(i = 0; i < 7; i++)
		if(urp->xb[i]){
			freeb(urp->xb[i]);
			urp->xb[i] = 0;
.
235c
	rcvack(urp, ECHO+i);
.
232c
	i = urp->next - 1;
.
228c
	qlock(&urp->xmit);
.
226c
	urp->state |= HUNGUP;
.
223c
		tsleep(&urp->r, isflushed, urp, 2*60*1000);
.
221c
	urp->state |= CLOSING;
.
211,212c
	urp = (Urp *)q->ptr;
	if(urp == 0)
.
208c
	Urp *urp;
.
202,203c
	urp = (Urp *)a;
	return (urp->state&HUNGUP) || (urp->unechoed==urp->nxb && urp->wq->len==0);
.
200c
	Urp *urp;
.
186,191c
	urp->rq = q;
	urp->wq = q->other;
	urp->state = OPEN;
	qunlock(urp);
	initinput(urp);
	initoutput(urp, 0);
.
184c
	q->ptr = q->other->ptr = urp;
.
180,181c
		urp->list = urpalloc.urp;
		urpalloc.urp = urp;
.
177,178c
		urp = smalloc(sizeof(Urp));
		qlock(urp);
.
173c
	if(urp == 0){
.
170c
			qunlock(urp);
.
165,168c
	for(urp = urpalloc.urp; urp; urp = urp->list){
		if(urp->state == 0){
			qlock(urp);
			if(urp->state == 0)
.
150c
	Urp *urp;
.
## diffname port/sturp.c 1993/0804 # deleted
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/sturp.c /n/fornaxdump/1993/0804/sys/src/brazil/port/sturp.c
1,1072d