## diffname ip/rudp.c 1998/0630
## diff -e /dev/null /n/emeliedump/1998/0630/sys/src/brazil/ip/rudp.c
0a

#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"../port/error.h"

#include	"ip.h"

#define DPRINT if(1)print

enum
{
	RUDP_PHDRSIZE	= 12,
	RUDP_HDRSIZE	= 36,
	RUDP_RHDRSIZE	= 16,
	RUDP_IPHDR	= 8,
	IP_RUDPPROTO	= 254,
	RUDP_USEAD6	= 36,
	RUDP_USEAD4	= 12,

	Rudprxms	= 200,
	Rudptickms	= 100,
	Rudpmaxxmit	= 1,

};

/*
 *  reliable header
 */
typedef struct Relhdr Relhdr;
struct Relhdr
{
	uchar	relseq[4];	/* id of this packet (or 0) */
	uchar	relsgen[4];	/* generation/time stamp */
	uchar	relack[4];	/* packet being acked (or 0) */
	uchar	relagen[4];	/* generation/time stamp */
};

typedef struct Rudphdr Rudphdr;
struct Rudphdr
{
	/* ip header */
	uchar	vihl;		/* Version and header length */
	uchar	tos;		/* Type of service */
	uchar	length[2];	/* packet length */
	uchar	id[2];		/* Identification */
	uchar	frag[2];	/* Fragment information */
	uchar	Unused;	
	uchar	rudpproto;	/* Protocol */
	uchar	rudpplen[2];	/* Header plus data length */
	uchar	rudpsrc[4];	/* Ip source */
	uchar	rudpdst[4];	/* Ip destination */

	/* rudp header */
	uchar	rudpsport[2];	/* Source port */
	uchar	rudpdport[2];	/* Destination port */
	Relhdr	rhdr;		/* reliable header */
	uchar	rudplen[2];	/* data length */
	uchar	rudpcksum[2];	/* Checksum */
};


/*
 *  one state structure per destination
 */
typedef struct Reliable Reliable;
struct Reliable
{
	Reliable *next;

	uchar addr[IPaddrlen];	/* always V6 when put here */
	ushort	port;


	Block	*unacked;	/* unacked msg list */
	Block	*unackedtail;	/*  and its tail */

	int	timeout;	/* time since first unacked msg sent */
	int	xmits;		/* number of times first unacked msg sent */

	ulong	sndseq;		/* next packet to be sent */
	ulong	sndgen;		/*  and its generation */

	ulong	rcvseq;		/* last packet received */
	ulong	rcvgen;		/*  and its generation */

	ulong	acksent;	/* last ack sent */
	ulong	ackrcvd;	/* last msg for which ack was rcvd */
};



/* MIB II counters */
typedef struct Rudpstats Rudpstats;
struct Rudpstats
{
	ulong	rudpInDatagrams;
	ulong	rudpNoPorts;
	ulong	rudpInErrors;
	ulong	rudpOutDatagrams;
};

typedef struct Rudppriv Rudppriv;
struct Rudppriv
{


	/* MIB counters */
	Rudpstats	ustats;

	/* non-MIB stats */
	ulong		csumerr;		/* checksum errors */
	ulong		lenerr;			/* short packet */

};


static ulong generation = 0;
static Rendez rend;
/*
 *  protocol specific part of Conv
 */
typedef struct Rudpcb Rudpcb;
struct Rudpcb
{
	QLock;
	uchar	headers;
	Reliable *r;
};

/*
 * local functions 
 */
void	relsendack( Conv *, Reliable * );
int	reliput( Conv *, Block *, uchar *, ushort );
Reliable *relstate( Rudpcb *, uchar *, ushort );
void	relackproc( void * );
void	relackq( Reliable *, Block * );
void	relhangup( Conv *, Reliable * );
void	relrexmit( Conv *, Reliable * );

static char*
rudpconnect(Conv *c, char **argv, int argc)
{
	char *e;

	e = Fsstdconnect(c, argv, argc);
	Fsconnected(c, e);

	return e;
}


static int
rudpstate(Conv *c, char *state, int n)
{
	USED(c);
	return snprint(state, n, "%s", "Reliable UDP");
}

static char*
rudpannounce(Conv *c, char** argv, int argc)
{
	char *e;

	e = Fsstdannounce(c, argv, argc);
	if(e != nil)
		return e;
	Fsconnected(c, nil);

	return nil;
}

static void
rudpcreate(Conv *c)
{
	c->rq = qopen(64*1024, 1, 0, 0);
	c->wq = qopen(64*1024, 0, 0, 0);
}

static void
rudpclose(Conv *c)
{
	Rudpcb *ucb;
	Reliable *r, *nr;

	qclose(c->rq);
	qclose(c->wq);
	qclose(c->eq);
	ipmove(c->laddr, IPnoaddr);
	ipmove(c->raddr, IPnoaddr);
	c->lport = 0;
	c->rport = 0;

	ucb = (Rudpcb*)c->ptcl;
	ucb->headers = 0;
	qlock( ucb );
	for( r = ucb->r; r; r = nr ){
		nr = r->next;
		relhangup( c, r );
		free( r );
	}
	ucb->r = 0;

	qunlock( ucb );

	unlock(c);
}

void
rudpkick(Conv *c, int)
{
	Rudphdr *uh;
	ushort rport;
	uchar laddr[IPaddrlen], raddr[IPaddrlen];
	Block *bp;
	Rudpcb *ucb;
	Relhdr *rh;
	Reliable *r;
	int dlen, ptcllen;
	Rudppriv *upriv;
	Fs *f;

	upriv = c->p->priv;
	f = c->p->f;

	netlog(c->p->f, Logrudp, "rudp: kick\n");
	bp = qget(c->wq);
	if(bp == nil)
		return;

	ucb = (Rudpcb*)c->ptcl;
	switch(ucb->headers) {
	case 6:
		/* get user specified addresses */
		bp = pullupblock(bp, RUDP_USEAD6);
		if(bp == nil)
			return;
		ipmove(raddr, bp->rp);
		bp->rp += IPaddrlen;
		ipmove(laddr, bp->rp);
		bp->rp += IPaddrlen;
		/* pick interface closest to dest */
		if(ipforme(f, laddr) != Runi)
			findlocalip(f, laddr, raddr);
		rport = nhgets(bp->rp);

		bp->rp += 4;			/* Igonore local port */
		break;
	case 4:
		bp = pullupblock(bp, RUDP_USEAD4);
		if(bp == nil)
			return;
		v4tov6(raddr, bp->rp);
		bp->rp += IPv4addrlen;
		v4tov6(laddr, bp->rp);
		bp->rp += IPv4addrlen;
		if(ipforme(f, laddr) != Runi)
			findlocalip(f, laddr, raddr);
		rport = nhgets(bp->rp);

		bp->rp += 4;			/* Igonore local port */
		break;
	default:
		rport = 0;

		break;
	}

	dlen = blocklen(bp);

	/* Make space to fit rudp & ip header */
	bp = padblock(bp, RUDP_IPHDR+RUDP_HDRSIZE);
	if(bp == nil)
		return;

	uh = (Rudphdr *)(bp->rp);

	rh = &(uh->rhdr);

	ptcllen = dlen + (RUDP_HDRSIZE-RUDP_PHDRSIZE);
	uh->Unused = 0;
	uh->rudpproto = IP_RUDPPROTO;
	uh->frag[0] = 0;
	uh->frag[1] = 0;
	hnputs(uh->rudpplen, ptcllen);
	switch(ucb->headers){
	case 4:
	case 6:
		v6tov4(uh->rudpdst, raddr);
		hnputs(uh->rudpdport, rport);
		v6tov4(uh->rudpsrc, laddr);
		break;
	default:
		v6tov4(uh->rudpdst, c->raddr);
		hnputs(uh->rudpdport, c->rport);
		if(ipcmp(c->laddr, IPnoaddr) == 0)
			findlocalip(f, c->laddr, c->raddr);
		v6tov4(uh->rudpsrc, c->laddr);
		break;
	}
	hnputs(uh->rudpsport, c->lport);
	hnputs(uh->rudplen, ptcllen);
	uh->rudpcksum[0] = 0;
	uh->rudpcksum[1] = 0;


	qlock( ucb );
	r = relstate( ucb, raddr, rport );
	r->sndseq++;
	hnputl( rh->relseq, r->sndseq );
	hnputl( rh->relsgen, r->sndgen );

	hnputl( rh->relack, r->rcvseq );  /* ACK last rcvd packet */
	hnputl( rh->relagen, r->rcvgen );

	if(r->rcvseq < r->acksent)
		r->acksent = r->rcvseq;

	hnputs(uh->rudpcksum, ptclcsum(bp, RUDP_IPHDR, dlen+RUDP_HDRSIZE));

	relackq( r, bp );
	qunlock( ucb );

	upriv->ustats.rudpOutDatagrams++;



	DPRINT( "sent: %d/%d, %d/%d\n", 
		r->sndseq, r->sndgen, r->rcvseq, r->rcvgen );

	ipoput(f, bp, 0, c->ttl);
}

void
rudpiput(Proto *rudp, uchar *ia, Block *bp)
{
	int len, olen, ottl;
	Rudphdr *uh;
	Conv *c, **p;
	Rudpcb *ucb;
	uchar raddr[IPaddrlen], laddr[IPaddrlen];
	ushort rport, lport;
	Rudppriv *upriv;
	Fs *f;

	upriv = rudp->priv;
	f = rudp->f;

	upriv->ustats.rudpInDatagrams++;

	uh = (Rudphdr*)(bp->rp);

	/* Put back pseudo header for checksum 
	 * (remember old values for icmpnoconv()) 
	 */
	ottl = uh->Unused;
	uh->Unused = 0;
	len = nhgets(uh->rudplen);
	olen = nhgets(uh->rudpplen);
	hnputs(uh->rudpplen, len);

	v4tov6(raddr, uh->rudpsrc);
	v4tov6(laddr, uh->rudpdst);
	lport = nhgets(uh->rudpdport);
	rport = nhgets(uh->rudpsport);



	if(nhgets(uh->rudpcksum)) {
		if(ptclcsum(bp, RUDP_IPHDR, len+RUDP_PHDRSIZE)) {
			upriv->ustats.rudpInErrors++;
			netlog(f, Logrudp, "rudp: checksum error %I\n", raddr);
			DPRINT("rudp: checksum error %I\n", raddr);
			freeblist(bp);
			return;
		}
	}

	/* Look for a conversation structure for this port */
	c = nil;
	for(p = rudp->conv; *p; p++) {
		c = *p;
		if(c->inuse == 0)
			continue;
		if(c->lport == lport && (c->rport == 0 || c->rport == rport))
			break;
	}

	if(*p == nil) {
		upriv->ustats.rudpNoPorts++;
		netlog(f, Logrudp, "rudp: no conv %I!%d -> %I!%d\n", raddr, rport,
			laddr, lport);
		DPRINT( "rudp: no conv %I!%d -> %I!%d\n", raddr, rport,
			laddr, lport);
		uh->Unused = ottl;
		hnputs(uh->rudpplen, olen);
		icmpnoconv(f, bp);
		freeblist(bp);
		return;
	}

	ucb = (Rudpcb*)c->ptcl;

	qlock( ucb );
	if( reliput( c, bp, raddr, rport ) < 0 ){
		qunlock( ucb );
		freeb( bp );
		return;
	}

	/*
	 * Trim the packet down to data size
	 */

	len -= (RUDP_HDRSIZE-RUDP_PHDRSIZE);
	bp = trimblock(bp, RUDP_IPHDR+RUDP_HDRSIZE, len);
	if(bp == nil){
		netlog(f, Logrudp, "rudp: len err %I.%d -> %I.%d\n", 
			raddr, rport, laddr, lport);
		DPRINT( "rudp: len err %I.%d -> %I.%d\n", 
			raddr, rport, laddr, lport);
		upriv->lenerr++;
		return;
	}

	netlog(f, Logrudpmsg, "rudp: %I.%d -> %I.%d l %d\n", 
		raddr, rport, laddr, lport, len);



	switch(ucb->headers){
	case 6:
		/* pass the src address */
		bp = padblock(bp, RUDP_USEAD6);
		ipmove(bp->rp, raddr);
		if(ipforme(f, laddr) == Runi)
			ipmove(bp->rp+IPaddrlen, laddr);
		else
			ipmove(bp->rp+IPaddrlen, ia);
		hnputs(bp->rp+2*IPaddrlen, rport);
		hnputs(bp->rp+2*IPaddrlen+2, lport);
		break;
	case 4:
		/* pass the src address */
		bp = padblock(bp, RUDP_USEAD4);
		v6tov4(bp->rp, raddr);
		if(ipforme(f, laddr) == Runi)
			v6tov4(bp->rp+IPv4addrlen, laddr);
		else
			v6tov4(bp->rp+IPv4addrlen, ia);
		hnputs(bp->rp + 2*IPv4addrlen, rport);
		hnputs(bp->rp + 2*IPv4addrlen + 2, lport);
		break;
	default:
		/* connection oriented rudp */
		if(c->raddr == 0){
			/* save the src address in the conversation */
		 	ipmove(c->raddr, raddr);
			c->rport = rport;

			/* reply with the same ip address (if not broadcast) */
			if(ipforme(f, laddr) == Runi)
				ipmove(c->laddr, laddr);
			else
				v4tov6(c->laddr, ia);
		}
		break;
	}
	if(bp->next)
		bp = concatblock(bp);

	if(qfull(c->rq)){
		netlog(f, Logrudp, "rudp: qfull %I.%d -> %I.%d\n", raddr, rport,
			laddr, lport);
		freeblist(bp);
	}
	else
		qpass(c->rq, bp);
	
	qunlock( ucb );
}

char*
rudpctl(Conv *c, char **f, int n)
{
	Rudpcb *ucb;

	ucb = (Rudpcb*)c->ptcl;
	if(n == 1){
		if(strcmp(f[0], "headers4") == 0){
			ucb->headers = 4;
			return nil;
		} else if(strcmp(f[0], "headers") == 0){
			ucb->headers = 6;
			return nil;
		}
	}
	return "unknown control request";
}

void
rudpadvise(Proto *rudp, Block *bp, char *msg)
{
	Rudphdr *h;
	uchar source[IPaddrlen], dest[IPaddrlen];
	ushort psource, pdest;
	Conv *s, **p;

	h = (Rudphdr*)(bp->rp);

	v4tov6(dest, h->rudpdst);
	v4tov6(source, h->rudpsrc);
	psource = nhgets(h->rudpsport);
	pdest = nhgets(h->rudpdport);

	/* Look for a connection */
	for(p = rudp->conv; *p; p++) {
		s = *p;
		if(s->rport == pdest)
		if(s->lport == psource)
		if(ipcmp(s->raddr, dest) == 0)
		if(ipcmp(s->laddr, source) == 0){
			qhangup(s->rq, msg);
			qhangup(s->wq, msg);
			break;
		}
	}
	freeblist(bp);
}

int
rudpstats(Proto *rudp, char *buf, int len)
{
	Rudppriv *upriv;

	upriv = rudp->priv;
	return snprint(buf, len, "%d %d %d %d\n",
		upriv->ustats.rudpInDatagrams,
		upriv->ustats.rudpNoPorts,
		upriv->ustats.rudpInErrors,
		upriv->ustats.rudpOutDatagrams);
}

void
rudpinit(Fs *fs)
{

	Proto *rudp;

	rudp = smalloc(sizeof(Proto));
	rudp->priv = smalloc(sizeof(Rudppriv));
	rudp->name = "rudp";
	rudp->kick = rudpkick;
	rudp->connect = rudpconnect;
	rudp->announce = rudpannounce;
	rudp->ctl = rudpctl;
	rudp->state = rudpstate;
	rudp->create = rudpcreate;
	rudp->close = rudpclose;
	rudp->rcv = rudpiput;
	rudp->advise = rudpadvise;
	rudp->stats = rudpstats;
	rudp->ipproto = IP_RUDPPROTO;
	rudp->nc = 16;
	rudp->ptclsize = sizeof(Rudpcb);

	Fsproto(fs, rudp);

	kproc( "relackproc", relackproc, rudp );
	
}

/*********************************************/
/* Here starts the reliable helper functions */
/*********************************************/
/*
 *  Enqueue a copy of an unacked block for possible retransmissions
 */
void
relackq(Reliable *r, Block *bp)
{
	Block *np;

	np = copyblock(bp, blocklen(bp));
	if(r->unacked)
		r->unackedtail->list = np;
	else {
		/* restart timer */
		r->timeout = 0;
		r->xmits = 1;
		r->unacked = np;
	}
	r->unackedtail = np;
	np->list = nil;
}

/*
 *  retransmit unacked blocks
 */
void
relackproc(void *a)
{
	Rudpcb *ucb;
	Proto *rudp;
	Reliable *r;
	Conv **s, *c;

	rudp = (Proto *)a;
loop:
	tsleep(&rend, return0, 0, Rudptickms);

	for(s = rudp->conv; *s; s++) {
		c = *s;
		ucb = (Rudpcb*)c->ptcl;
		qlock( ucb );

		for(r = ucb->r; r; r = r->next){

			if(r->unacked != nil){
				r->timeout += Rudptickms;
				if(r->timeout > Rudprxms*r->xmits)
					relrexmit(c, r);
			}
			if(r->acksent < r->rcvseq)
				relsendack(c, r);
		}
		qunlock( ucb );
	}
	goto loop;
}

/*
 *  get the state record for a conversation
 */
Reliable*
relstate(Rudpcb *ucb, uchar *addr, ushort port)
{
	Reliable *r, **l;


	l = &ucb->r;
	for(r = *l; r; r = *l){
		if( memcmp( addr, r->addr, IPaddrlen) == 0 && 
		    port == r->port)
			break;
		l = &r->next;
	}

	/* no state for this addr/port, create some */
	if(r == nil){
		DPRINT( "new state %d\n", generation );
		if(generation == 0)
			generation = TK2SEC(MACHP(0)->ticks);
		r = smalloc( sizeof( Reliable ) );
		*l = r;
		memmove( r->addr, addr, IPaddrlen);
		r->port = port;
		r->unacked = 0;
		r->sndgen = generation++;
		r->sndseq = 0;
		r->ackrcvd = 0;
		r->rcvgen = 0;
		r->rcvseq = 0;
		r->acksent = 0;
		r->xmits = 0;
		r->timeout = 0;
	}

	return r;
}


/* 
 *  process a rcvd reliable packet. return -1 if not to be passed to user process,
 *  0 therwise.
 */
int
reliput(Conv *c, Block *bp, uchar *addr, ushort port)
{
	Block *nbp;
	Rudpcb *ucb;
	Rudphdr *uh;
	Reliable *r;
	Relhdr *rh;
	ulong seq, ack, sgen, agen, ackreal;



	/* get fields */
	uh = (Rudphdr *)(bp->rp);
	rh = &(uh->rhdr);
	seq = nhgetl(rh->relseq);
	sgen = nhgetl(rh->relsgen);
	ack = nhgetl(rh->relack);
	agen = nhgetl(rh->relagen);



	ucb = (Rudpcb*)c->ptcl;
	r = relstate(ucb, addr, port);
	

	DPRINT("rcvd %d/%d, %d/%d, r->sndgen = %d, r->ackrcvd = %d\n", 
		seq, sgen, ack, agen, r->sndgen, r->ackrcvd);

	/* dequeue acked packets */
	if(ack && agen == r->sndgen){
		DPRINT( "Here\n" );
		ackreal = 0;
		while(r->unacked != nil && ack > r->ackrcvd){
			nbp = r->unacked;
			r->unacked = nbp->list;
			DPRINT("%d/%d acked\n", ack, agen);
			freeb(nbp);
			r->ackrcvd++;
			ackreal = 1;
		}

		/*
		 *  retransmit next packet if the acked packet
		 *  was transmitted more than once
		 */
		if(ackreal && r->unacked != nil){
			r->timeout = 0;
			if(r->xmits > 1){
				r->xmits = 1;
				relrexmit(c, r);
			}
		}
		
	}

	/* make sure we're not talking to a new remote side */
	if(r->rcvgen != sgen){
		if(seq != 1)
			return -1;


		/* new connection */
		if(r->rcvgen != 0){
			DPRINT("new con r->rcvgen = %d, sgen = %d\n", r->rcvgen, sgen);
			relhangup(c, r);
		}
		r->rcvgen = sgen;
	}

	/* no message */
	if(seq == 0)
		return -1;

	/* refuse out of order delivery */
	if(seq != r->rcvseq + 1){
		DPRINT("out of sequence %d not %d\n", seq, r->rcvseq + 1);
		return -1;
	}
	r->rcvseq = seq;

	return 0;
}

void
relsendack(Conv *c, Reliable *r)
{
	Rudphdr *uh;
	Block *bp;
	Relhdr *rh;
	int ptcllen;
	Fs *f;

	bp = allocb(RUDP_IPHDR + RUDP_HDRSIZE);
	if(bp == nil)
		return;
	bp->wp += RUDP_IPHDR + RUDP_HDRSIZE;
	f = c->p->f;
	uh = (Rudphdr *)(bp->rp);
	rh = &(uh->rhdr);

	ptcllen = (RUDP_HDRSIZE-RUDP_PHDRSIZE);
	uh->Unused = 0;
	uh->rudpproto = IP_RUDPPROTO;
	uh->frag[0] = 0;
	uh->frag[1] = 0;
	hnputs(uh->rudpplen, ptcllen);



	v6tov4( uh->rudpdst, r->addr );
	hnputs(uh->rudpdport, r->port);
	hnputs(uh->rudpsport, c->lport);
	if(ipcmp(c->laddr, IPnoaddr) == 0)
		findlocalip(f, c->laddr, c->raddr);
	v6tov4(uh->rudpsrc, c->laddr);
	hnputs(uh->rudplen, ptcllen);



	hnputl(rh->relsgen, r->sndgen);
	hnputl(rh->relseq, 0);
	hnputl(rh->relagen, r->rcvgen);
	hnputl(rh->relack, r->rcvseq);

	if(r->acksent < r->rcvseq)
		r->acksent = r->rcvseq;

	uh->rudpcksum[0] = 0;
	uh->rudpcksum[1] = 0;
	hnputs(uh->rudpcksum, ptclcsum(bp, RUDP_IPHDR, RUDP_HDRSIZE));

	DPRINT( "sendack: %d/%d, %d/%d\n", 0, r->sndgen, r->rcvseq, r->rcvgen );
	ipoput(f, bp, 0, c->ttl);
}

/*
 *  called with ucb locked (and c locked if user initiated close)
 */
void
relhangup( Conv *, Reliable *r )
{
	Block *bp;

	/*
	 *  dump any unacked outgoing messages
	 */
	for(bp = r->unacked; bp != nil; bp = r->unacked){
		r->unacked = bp->list;
		bp->list = nil;
		freeb(bp);
	}

	r->rcvgen = 0;
	r->rcvseq = 0;
	r->acksent = 0;
	r->sndgen = generation++;
	r->sndseq = 0;
	r->ackrcvd = 0;
	r->xmits = 0;
	r->timeout = 0;
}

/*
 *  called with ucb locked
 */
void
relrexmit(Conv *c, Reliable *r)
{
	Block *np;
	Fs *f;
	f = c->p->f;
	r->timeout = 0;
	if(r->xmits++ > Rudpmaxxmit){
		relhangup(c, r);
		return;
	}

	np = copyblock(r->unacked, blocklen(r->unacked));
	//DPRINT("rxmit r->ackrvcd+1 = %d\n", r->ackrcvd+1);
	ipoput(f, np, 0, c->ttl);
}
.
## diffname ip/rudp.c 1998/0726
## diff -e /n/emeliedump/1998/0630/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0726/sys/src/brazil/ip/rudp.c
859c
	DPRINT("rxmit r->ackrvcd+1 = %d\n", r->ackrcvd+1);
.
857a
	upriv->rxmits++;
.
850a

	upriv = c->p->priv;
.
848a
	Rudppriv *upriv;
.
755a
		upriv->orders++;
.
753a
	if( DEBUG && ++drop == drop_rate ){
		DPRINT( "drop pkt on purpose\n" );
		drop = 0;
		return -1;
	}

.
716c
			DPRINT("%d/%d acked, r->sndgen = %d\n", 
			       ack, agen, r->sndgen);
.
711d
706,707c
	DPRINT("rcvd %d/%d, %d/%d, r->sndgen = %d\n", 
		seq, sgen, ack, agen, r->sndgen);
.
703c
	r = relstate(ucb, addr, port, "input" );
.
701c
	upriv = c->p->priv;
.
684a
	Rudppriv *upriv;
.
656a
		DPRINT( "from %s new state %d for %I!%d\n", 
		        from, generation, addr, port );
.
654d
643a

.
639c
relstate(Rudpcb *ucb, uchar *addr, ushort port, char *from )
.
630c
		qunlock(ucb);
.
620,621c
		for(r = ucb->r; r; r = r->next) {
.
618c
		qlock(ucb);
.
613c
	tsleep(&upriv->vous, return0, 0, Rudptickms);
.
611a
	upriv = rudp->priv;

.
609a
	Rudppriv *upriv;
.
572c
	kproc("relackproc", relackproc, rudp);
.
544c
		upriv->ustats.rudpOutDatagrams,
		upriv->rxmits,
		upriv->orders);
.
540c
	return snprint(buf, len, "%d %d %d %d %d %d\n",
.
374a
			upriv->csumerr++;
.
331,332c
	DPRINT( "sent: %d/%d, %d/%d, r->sndgen = %d\n", 
		r->sndseq, r->sndgen, r->rcvseq, r->rcvgen, r->sndgen );
.
311c
	r = relstate( ucb, raddr, rport, "kick" );
.
282a

.
267c
		ipmove( raddr, c->raddr );
		ipmove( laddr, c->laddr );
		rport = c->rport;
.
160c
	return snprint(state, n, "%s", "Reliable UDP V0.1");
.
138c
Reliable *relstate( Rudpcb *, uchar *, ushort, char *from );
.
121a

/* Used only for debugging */
static ushort drop = 0;
static ushort drop_rate = 10;

.
114,115c
	ulong	csumerr;		/* checksum errors */
	ulong	lenerr;			/* short packet */
	ulong	rxmits;			/* # of retransmissions */
	ulong	orders;			/* # of out of order pkts */
.
109d
107a
	Rendez	vous;
.
25c
	Rudpmaxxmit	= 10,
.
11c
#define DEBUG	0
#define DPRINT if(DEBUG)print
.
## diffname ip/rudp.c 1998/0728
## diff -e /n/emeliedump/1998/0726/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0728/sys/src/brazil/ip/rudp.c
846c
relhangup(Conv *, Reliable *r)
.
838c
	DPRINT("sendack: %d/%d, %d/%d\n", 0, r->sndgen, r->rcvseq, r->rcvgen);
.
834,836c
	uh->udpcksum[0] = 0;
	uh->udpcksum[1] = 0;
	hnputs(uh->udpcksum, ptclcsum(bp, UDP_IPHDR, UDP_RHDRSIZE));
.
824,825d
821,822c
	v6tov4(uh->udpsrc, c->laddr);
	hnputs(uh->udplen, ptcllen);
.
814,818c
	v6tov4(uh->udpdst, r->addr);
	hnputs(uh->udpdport, r->port);
	hnputs(uh->udpsport, c->lport);
.
812c
	hnputs(uh->udpplen, ptcllen);
.
809c
	uh->udpproto = IP_UDPPROTO;
.
807c
	ptcllen = (UDP_RHDRSIZE-UDP_PHDRSIZE);
.
804,805c
	uh = (Udphdr *)(bp->rp);
	rh = (Rudphdr*)uh;
.
802c
	bp->wp += UDP_IPHDR + UDP_RHDRSIZE;
.
799c
	bp = allocb(UDP_IPHDR + UDP_RHDRSIZE);
.
795c
	Rudphdr *rh;
.
793c
	Udphdr *uh;
.
773,774c
	if(DEBUG && ++drop == drop_rate){
		DPRINT("drop pkt on purpose\n");
.
722c
	r = relstate(ucb, addr, port, "input");
.
712,713c
	uh = (Udphdr*)(bp->rp);
	rh = (Rudphdr*)uh;
.
706c
	Rudphdr *rh;
.
704c
	Udphdr *uh;
.
677c
		memmove(r->addr, addr, IPaddrlen);
.
673,675c
		DPRINT("from %s new state %d for %I!%d\n", 
		        from, generation, addr, port);
		r = smalloc(sizeof(Reliable));
.
663c
		if(memcmp(addr, r->addr, IPaddrlen) == 0 && 
.
659,660d
655c
relstate(Rudpcb *ucb, uchar *addr, ushort port, char *from)
.
580c
	rudp->ipproto = IP_UDPPROTO;
.
526,529c
	v4tov6(dest, h->udpdst);
	v4tov6(source, h->udpsrc);
	psource = nhgets(h->udpsport);
	pdest = nhgets(h->udpdport);
.
524c
	h = (Udphdr*)(bp->rp);
.
519c
	Udphdr *h;
.
495c
	qunlock(ucb);
.
460c
		bp = padblock(bp, UDP_USEAD4);
.
449c
		bp = padblock(bp, UDP_USEAD6);
.
444,445d
435c
		DPRINT("rudp: len err %I.%d -> %I.%d\n", 
.
430,431c
	len -= (UDP_RHDRSIZE-UDP_PHDRSIZE);
	bp = trimblock(bp, UDP_IPHDR+UDP_RHDRSIZE, len);
.
419,422c
	qlock(ucb);
	if(reliput(c, bp, raddr, rport) < 0){
		qunlock(ucb);
		freeb(bp);
.
411c
		hnputs(uh->udpplen, olen);
.
408c
		DPRINT("rudp: no conv %I!%d -> %I!%d\n", raddr, rport,
.
400,401c
		if(c->lport == lport){
			ucb = (Rudpcb*)c->ptcl;

			/* with headers turned on, descriminate only on local port */
			if(ucb->headers)
				break;

			/* otherwise discriminate on lport, rport, and raddr */
			if(c->rport == 0 || c->rport == rport)
			if(ipisbm(c->raddr) || ipcmp(c->raddr, IPnoaddr) == 0
			   || ipcmp(c->raddr, raddr) == 0)
				break;
		}
.
381,384c
	if(nhgets(uh->udpcksum)) {
		if(ptclcsum(bp, UDP_IPHDR, len+UDP_PHDRSIZE)) {
.
376,379c
	v4tov6(raddr, uh->udpsrc);
	v4tov6(laddr, uh->udpdst);
	lport = nhgets(uh->udpdport);
	rport = nhgets(uh->udpsport);
.
372,374c
	len = nhgets(uh->udplen);
	olen = nhgets(uh->udpplen);
	hnputs(uh->udpplen, len);
.
365c
	uh = (Udphdr*)(bp->rp);
.
352c
	Udphdr *uh;
.
341,344d
339a
	DPRINT("sent: %d/%d, %d/%d, r->sndgen = %d\n", 
		r->sndseq, r->sndgen, r->rcvseq, r->rcvgen, r->sndgen);
.
335,336c
	relackq(r, bp);
	qunlock(ucb);
.
333c
	hnputs(uh->udpcksum, ptclcsum(bp, UDP_IPHDR, dlen+UDP_RHDRSIZE));
.
327,328c
	hnputl(rh->relack, r->rcvseq);  /* ACK last rcvd packet */
	hnputl(rh->relagen, r->rcvgen);
.
324,325c
	hnputl(rh->relseq, r->sndseq);
	hnputl(rh->relsgen, r->sndgen);
.
320,322c
	qlock(ucb);
	r = relstate(ucb, raddr, rport, "kick");
.
315,318c
	hnputs(uh->udpsport, c->lport);
	hnputs(uh->udplen, ptcllen);
	uh->udpcksum[0] = 0;
	uh->udpcksum[1] = 0;
.
312c
		v6tov4(uh->udpsrc, c->laddr);
.
308,309c
		v6tov4(uh->udpdst, c->raddr);
		hnputs(uh->udpdport, c->rport);
.
303,305c
		v6tov4(uh->udpdst, raddr);
		hnputs(uh->udpdport, rport);
		v6tov4(uh->udpsrc, laddr);
.
299c
	hnputs(uh->udpplen, ptcllen);
.
296c
	uh->udpproto = IP_UDPPROTO;
.
293,294c
	ptcllen = dlen + (UDP_RHDRSIZE-UDP_PHDRSIZE);
.
291c
	rh = (Rudphdr*)uh;
.
289c
	uh = (Udphdr *)(bp->rp);
.
285c
	bp = padblock(bp, UDP_IPHDR+UDP_RHDRSIZE);
.
275,276c
		ipmove(raddr, c->raddr);
		ipmove(laddr, c->laddr);
.
261c
		bp = pullupblock(bp, UDP_USEAD4);
.
246c
		bp = pullupblock(bp, UDP_USEAD6);
.
228c
	Rudphdr *rh;
.
223c
	Udphdr *uh;
.
215c
	qunlock(ucb);
.
210,211c
		relhangup(c, r);
		free(r);
.
207,208c
	qlock(ucb);
	for(r = ucb->r; r; r = nr){
.
144,150c
void	relsendack(Conv *, Reliable *);
int	reliput(Conv *, Block *, uchar *, ushort);
Reliable *relstate(Rudpcb *, uchar *, ushort, char *from);
void	relackproc(void *);
void	relackq(Reliable *, Block *);
void	relhangup(Conv *, Reliable *);
void	relrexmit(Conv *, Reliable *);
.
77d
58,62c
	uchar	relseq[4];	/* id of this packet (or 0) */
	uchar	relsgen[4];	/* generation/time stamp */
	uchar	relack[4];	/* packet being acked (or 0) */
	uchar	relagen[4];	/* generation/time stamp */
.
56a
	/* pseudo header starts here */
	uchar	Unused;
	uchar	udpproto;	/* Protocol */
	uchar	udpplen[2];	/* Header plus data length */
	uchar	udpsrc[4];	/* Ip source */
	uchar	udpdst[4];	/* Ip destination */

	/* udp header */
	uchar	udpsport[2];	/* Source port */
	uchar	udpdport[2];	/* Destination port */
	uchar	udplen[2];	/* data length (includes rudp header) */
	uchar	udpcksum[2];	/* Checksum */

.
51,55d
36,39c
	/* ip header */
	uchar	vihl;		/* Version and header length */
	uchar	tos;		/* Type of service */
	uchar	length[2];	/* packet length */
	uchar	id[2];		/* Identification */
	uchar	frag[2];	/* Fragment information */

	/* pseudo header starts here */
	uchar	Unused;
	uchar	udpproto;	/* Protocol */
	uchar	udpplen[2];	/* Header plus data length */
	uchar	udpsrc[4];	/* Ip source */
	uchar	udpdst[4];	/* Ip destination */

	/* udp header */
	uchar	udpsport[2];	/* Source port */
	uchar	udpdport[2];	/* Destination port */
	uchar	udplen[2];	/* data length */
	uchar	udpcksum[2];	/* Checksum */
.
30,34c
typedef struct Udphdr Udphdr;
struct Udphdr
.
16,22c
	UDP_HDRSIZE	= 20,	/* pseudo header + udp header */
	UDP_PHDRSIZE	= 12,	/* pseudo header */
	UDP_RHDRSIZE	= 36,	/* pseudo header + udp header + rudp header */
	UDP_IPHDR	= 8,	/* ip header */
	IP_UDPPROTO	= 254,
	UDP_USEAD6	= 36,
	UDP_USEAD4	= 12,
.
1c
/*
 *  This protocol is compatible with UDP's packet format.
 *  It could be done over UDP if need be.
 */
.
## diffname ip/rudp.c 1998/0731
## diff -e /n/emeliedump/1998/0728/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0731/sys/src/brazil/ip/rudp.c
730,731d
694c
			generation = rand();
.
495c
		if(ipcmp(c->raddr, IPnoaddr) == 0){
.
## diffname ip/rudp.c 1998/0801
## diff -e /n/emeliedump/1998/0731/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0801/sys/src/brazil/ip/rudp.c
882a
	wakeup(&r->vous);
.
802c
		DPRINT("out of sequence %d not %d\n", seq, NEXTSEQ(r->rcvseq));
.
800c
	if(seq != NEXTSEQ(r->rcvseq)){
.
789,790c
	/* no message or input queue full */
	if(seq == 0 || qfull(c->rq))
.
780d
760a
		/* flow control */
		if(UNACKED(r) < Maxunacked/8 && r->blocked)
			wakeup(&r->vous);

.
757c
			r->ackrcvd = NEXTSEQ(r->ackrcvd);
.
751c
		while(r->unacked != nil && INSEQ(ack, r->ackrcvd, r->sndseq)){
.
739d
667c
			if(r->acksent != r->rcvseq)
.
362a

	/* flow control of sorts */
	qlock(&r->lock);
	if(UNACKED(r) > Maxunacked){
		r->blocked = 1;
		sleep(&r->vous, flow, r);
		r->blocked = 0;
	}
	qunlock(&r->lock);
.
349c
	if(r->rcvseq != r->acksent)
.
342c
	r->sndseq = NEXTSEQ(r->sndseq);
.
240a
int
flow(Reliable *r)
{
	return UNACKED(r) <= Maxunacked;
}

.
188,189c
	Rudpcb *ucb;
	Reliable *r;
	int m;

	m = snprint(state, n, "%s", c->inuse?"Open":"Closed");
	ucb = (Rudpcb*)c->ptcl;
	qlock(ucb);
	for(r = ucb->r; r; r = r->next)
		m += snprint(state+m, n-m, " %I/%d", r->addr, UNACKED(r));
	qunlock(ucb);
	return m;
.
112a

	/* flow control */
	QLock	lock;
	Rendez	vous;
	int	blocked;
.
96c
	uchar	addr[IPaddrlen];	/* always V6 when put here */
.
30c
	Maxunacked	= 100,
.
16a
#define SEQDIFF(a,b) ( (a)>=(b)?\
			(a)-(b):\
			0xffffffffUL-((b)-(a)) )
#define INSEQ(a,start,end) ( (start)<=(end)?\
				((a)>(start)&&(a)<=(end)):\
				((a)>(start)||(a)<=(end)) )
#define UNACKED(r) SEQDIFF(r->sndseq, r->ackrcvd)
#define NEXTSEQ(a) ( (a)+1 == 0 ? 1 : (a)+1 )

.
## diffname ip/rudp.c 1998/0825
## diff -e /n/emeliedump/1998/0801/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0825/sys/src/brazil/ip/rudp.c
946c
	DPRINT("rxmit r->ackrvcd+1 = %lud\n", r->ackrcvd+1);
.
894c
	DPRINT("sendack: %lud/%lud, %lud/%lud\n", 0L, r->sndgen, r->rcvseq, r->rcvgen);
.
842c
		DPRINT("out of sequence %lud not %lud\n", seq, NEXTSEQ(r->rcvseq));
.
823c
			DPRINT("new con r->rcvgen = %lud, sgen = %lud\n", r->rcvgen, sgen);
.
791c
			DPRINT("%lud/%lud acked, r->sndgen = %lud\n", 
.
782c
	DPRINT("rcvd %lud/%lud, %lud/%lud, r->sndgen = %lud\n", 
.
733c
		DPRINT("from %s new state %lud for %I!%ud\n", 
.
614c
	return snprint(buf, len, "%lud %lud %lud %lud %lud %lud\n",
.
388,389c
	DPRINT("sent: %lud/%lud, %lud/%lud\n", 
		r->sndseq, r->sndgen, r->rcvseq, r->rcvgen);
.
210c
		m += snprint(state+m, n-m, " %I/%ld", r->addr, UNACKED(r));
.
## diffname ip/rudp.c 1998/0924
## diff -e /n/emeliedump/1998/0825/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/0924/sys/src/brazil/ip/rudp.c
647,649d
219a
	rudpstartackproc(c->p);
.
191a
	rudpstartackproc(c->p);
.
186a
static void
rudpstartackproc(Proto *rudp)
{
	Rudppriv *rpriv;
	char kpname[NAMELEN];

	rpriv = rudp->priv;
	if(rpriv->ackprocstarted == 0){
		qlock(&rpriv->apl);
		if(rpriv->ackprocstarted == 0){
			sprint(kpname, "#I%drudpack", rudp->f->dev);
			kproc(kpname, relackproc, rudp);
			rpriv->ackprocstarted = 1;
		}
		qunlock(&rpriv->apl);
	}
}

.
154a
	/* keeping track of the ack kproc */
	int	ackprocstarted;
	QLock	apl;
.
## diffname ip/rudp.c 1998/1117
## diff -e /n/emeliedump/1998/0924/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/1117/sys/src/brazil/ip/rudp.c
860a
		relsendack(c, r);	/* tell him we got it already */
.
37c
	Rudptickms	= 50,
.
## diffname ip/rudp.c 1998/1118
## diff -e /n/emeliedump/1998/1117/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/1118/sys/src/brazil/ip/rudp.c
968c
	doipoput(c, f, np, 0, c->ttl);
.
926a
	n = snprint(hup, sizeof(hup), "hangup %I!%d", r->addr, r->port);
	qproduce(c->eq, hup, n);

.
925a
	char hup[ERRLEN];
.
924a
	int n;
.
923c
relhangup(Conv *c, Reliable *r)
.
916c
	doipoput(c, f, bp, 0, c->ttl);
.
853,858d
836,848d
804a
	/* make sure we're not talking to a new remote side */
	if(r->rcvgen != sgen){
		if(seq != 1)
			return -1;

		/* new connection */
		if(r->rcvgen != 0){
			DPRINT("new con r->rcvgen = %lud, sgen = %lud\n", r->rcvgen, sgen);
			relhangup(c, r);
		}
		r->rcvgen = sgen;
	}

.
595a
		} else if(strcmp(f[0], "randdrop") == 0){
			ucb->randdrop = 1;
			return nil;
.
414c
	doipoput(c, f, bp, 0, c->ttl);
.
286a
/*
 *  randomly don't send packets
 */
static void
doipoput(Conv *c, Fs *f, Block *bp, int x, int ttl)
{
	Rudpcb *ucb;

	ucb = (Rudpcb*)c->ptcl;
	if(ucb->randdrop && nrand(10) == 1)
		freeblist(bp);
	else
		ipoput(f, bp, x, ttl);
}

.
275a
		if(r->acksent != r->rcvseq)
			relsendack(c, r);
.
273a
	ucb->randdrop = 0;
.
272d
263a
	/* force out any delayed acks */
	ucb = (Rudpcb*)c->ptcl;
	qlock(ucb);
	for(r = ucb->r; r; r = r->next){
		if(r->acksent != r->rcvseq)
			relsendack(c, r);
	}
	qunlock(ucb);

.
175a
	uchar	randdrop;
.
164,167d
## diffname ip/rudp.c 1998/1124
## diff -e /n/emeliedump/1998/1118/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/1124/sys/src/brazil/ip/rudp.c
830a
	/* if acking an incorrect generation, ignore */
	if(ack && agen != r->sndgen)
		return -1;

.
## diffname ip/rudp.c 1998/1127
## diff -e /n/emeliedump/1998/1124/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/1127/sys/src/brazil/ip/rudp.c
837c
		if(seq != 0 && seq != 1)
.
777c
		while(generation == 0)
.
## diffname ip/rudp.c 1998/1230
## diff -e /n/emeliedump/1998/1127/sys/src/brazil/ip/rudp.c /n/emeliedump/1998/1230/sys/src/brazil/ip/rudp.c
624c
	return rudpunknown;
.
612,622c
	if(n < 1)
		return rudpunknown;

	if(strcmp(f[0], "headers4") == 0){
		ucb->headers = 4;
		return nil;
	} else if(strcmp(f[0], "headers") == 0){
		ucb->headers = 6;
		return nil;
	} else if(strcmp(f[0], "randdrop") == 0){
		x = 10;		/* default is 10% */
		if(n > 1)
			x = atoi(f[1]);
		if(x > 100 || x < 0)
			return "illegal rudp drop rate";
		ucb->randdrop = x;
		return nil;
.
609a
	int x;
.
605a
static char *rudpunknown = "unknown rudp ctl request";

.
304c
	if(ucb->randdrop && nrand(100) < ucb->randdrop)
.
## diffname ip/rudp.c 1999/0302
## diff -e /n/emeliedump/1998/1230/sys/src/brazil/ip/rudp.c /n/emeliedump/1999/0302/sys/src/brazil/ip/rudp.c
529a
	qunlock(rudp);

.
528d
514a
		qunlock(rudp);
.
492a
	qlock(rudp);

.
292c
	qunlock(c);
.
## diffname ip/rudp.c 1999/0320
## diff -e /n/emeliedump/1999/0302/sys/src/brazil/ip/rudp.c /n/emeliedump/1999/0320/sys/src/brazil/ip/rudp.c
312a
	Reliable *r = v;

.
311c
flow(void *v)
.
## diffname ip/rudp.c 1999/0817
## diff -e /n/emeliedump/1999/0320/sys/src/brazil/ip/rudp.c /n/emeliedump/1999/0817/sys/src/brazil/ip/rudp.c
1012c
	doipoput(c, f, np, 0, c->ttl, c->tos);
.
955c
	doipoput(c, f, bp, 0, c->ttl, c->tos);
.
439c
	doipoput(c, f, bp, 0, c->ttl, c->tos);
.
307c
		ipoput(f, bp, x, ttl, tos);
.
299c
doipoput(Conv *c, Fs *f, Block *bp, int x, int ttl, int tos)
.
## diffname ip/rudp.c 2000/0317
## diff -e /n/emeliedump/1999/0817/sys/src/brazil/ip/rudp.c /n/emeliedump/2000/0317/sys/src/9/ip/rudp.c
982a
	if(generation == Hangupgen)
		generation++;
.
957a

.
942c
	if(hangup)
		hnputl(rh->relsgen, Hangupgen);
	else
		hnputl(rh->relsgen, r->sndgen);
.
911c
relsendack(Conv *c, Reliable *r, int hangup)
.
907c
	rv = 0;
out:
	relput(r);
	qunlock(ucb);
	return rv;
.
903c
		goto out;
.
900c
		relsendack(c, r, 0);	/* tell him we got it already */
.
896c
		goto out;
.
853c
			goto out;
.
849a
	/* Look for a hangup */
	if(sgen == Hangupgen) {
		if(agen == r->sndgen)
			relforget(c, addr, port, 0);
		goto out;
	}

.
848c
		goto out;
.
841d
839a
	qlock(ucb);
.
828a
	int rv = -1;
.
814a
void
relforget(Conv *c, uchar *ip, int port, int originator)
{
	Rudpcb *ucb;
	Reliable *r, **l;

	ucb = (Rudpcb*)c->ptcl;

	l = &ucb->r;
	for(r = *l; r; r = *l){
		if(ipcmp(ip, r->addr) == 0 && port == r->port){
			*l = r->next;
			if(originator)
				relsendack(c, r, 1);
			relhangup(c, r);
			relput(r);	/* remove from the list */
			break;
		}
		l = &r->next;
	}
}

.
813a
void
relput(Reliable *r)
{
	if(decref(r) == 0)
		free(r);
}
.
810c
	incref(r);
.
808a
		r->ref = 0;
		incref(r);	/* one reference for being in the list */
.
800a
		if(generation == Hangupgen)
			generation++;
.
767c
				relsendack(c, r, 0);
.
629a
	} else if(strcmp(f[0], "hangup") == 0){
		if(n < 3)
			return "bad syntax";
		parseip(ip, f[1]);
		x = atoi(f[2]);
		qlock(ucb);
		relforget(c, ip, x, 1);
		qunlock(ucb);
		return nil;
.
617a
	uchar ip[IPaddrlen];
.
448c
	relput(r);
	qunlock(ucb);
.
442d
432d
283c
			relsendack(c, r, 0);
.
266c
			relsendack(c, r, 0);
.
181a
void	relput(Reliable *);
void	relforget(Conv *, uchar *, int, int);
.
179c
void	relsendack(Conv *, Reliable *, int);
.
124d
102a
	Ref;

.
41a
#define Hangupgen	0xffffffff	/* used only in hangup messages */

.
39a

.
## diffname ip/rudp.c 2000/0328
## diff -e /n/emeliedump/2000/0317/sys/src/9/ip/rudp.c /n/emeliedump/2000/0328/sys/src/9/ip/rudp.c
453d
451a
	qunlock(&r->lock);
.
446a
	qlock(&r->lock);
.
437a
	qunlock(ucb);
.
128a
	QLock	lock;
.
## diffname ip/rudp.c 2000/0403
## diff -e /n/emeliedump/2000/0328/sys/src/9/ip/rudp.c /n/emeliedump/2000/0403/sys/src/9/ip/rudp.c
968d
891d
867a
 *
 *  called with ucb locked.
.
842a
/*
 *  forget a Reliable state
 */
.
830a

		*l = r;
.
815d
813a

.
455a

.
293c
		relput(r);
.
## diffname ip/rudp.c 2000/0605
## diff -e /n/emeliedump/2000/0403/sys/src/9/ip/rudp.c /n/emeliedump/2000/0605/sys/src/9/ip/rudp.c
834a

.
812a

.
610c
	if(qfull(c->rq)) {
.
557c
	if(bp == nil) {
.
457a
	poperror();
.
456a
	qunlock(&r->lock);
.
455d
447a
	if(waserror()) {
		relput(r);
		qunlock(&r->lock);
		nexterror();
	}

.
298d
190,192c
void	relackq(Reliable *, Block*);
void	relhangup(Conv *, Reliable*);
void	relrexmit(Conv *, Reliable*);
void	relput(Reliable*);
.
184,188c
void	relsendack(Conv*, Reliable*, int);
int	reliput(Conv*, Block*, uchar*, ushort);
Reliable *relstate(Rudpcb*, uchar*, ushort, char*);
void	relput(Reliable*);
void	relforget(Conv *, uchar*, int, int);
.
## diffname ip/rudp.c 2000/1220
## diff -e /n/emeliedump/2000/0605/sys/src/9/ip/rudp.c /n/emeliedump/2000/1220/sys/src/9/ip/rudp.c
299d
## diffname ip/rudp.c 2001/0301
## diff -e /n/emeliedump/2000/1220/sys/src/9/ip/rudp.c /n/emeliedump/2001/0301/sys/src/9/ip/rudp.c
546d
538,539d
536c
		qunlock(rudp);
		netlog(f, Logudp, "udp: no conv %I!%d -> %I!%d\n", raddr, rport,
.
512,534c
	c = iphtlook(&upriv->ht, raddr, rport, laddr, lport);
	if(c == nil){
		/* no converstation found */
.
471c
	Conv *c;
.
268a
	upriv = c->p->priv;
	iphtrem(&upriv->ht, c);

.
267a
	Rudppriv *upriv;
.
251a
	iphtadd(&upriv->ht, c);
.
246a
	upriv = c->p->priv;
.
245a
	Rudppriv *upriv;
.
220a
	iphtadd(&upriv->ht, c);
.
217a
	upriv = c->p->priv;
.
216a
	Rudppriv *upriv;
.
149a
	Ipht	ht;
.
## diffname ip/rudp.c 2001/0306
## diff -e /n/emeliedump/2001/0301/sys/src/9/ip/rudp.c /n/emeliedump/2001/0306/sys/src/9/ip/rudp.c
336c
rudpkick(Conv *c)
.
## diffname ip/rudp.c 2001/0623
## diff -e /n/emeliedump/2001/0306/sys/src/9/ip/rudp.c /n/emeliedump/2001/0623/sys/src/9/ip/rudp.c
598c
				v4tov6(c->laddr, ifc->lifc->local);
.
583c
			v6tov4(bp->rp+IPv4addrlen, ifc->lifc->local);
.
572c
			ipmove(bp->rp+IPaddrlen, ifc->lifc->local);
.
478c
rudpiput(Proto *rudp, Ipifc *ifc, Block *bp)
.
## diffname ip/rudp.c 2001/0918
## diff -e /n/emeliedump/2001/0623/sys/src/9/ip/rudp.c /n/emeliedump/2001/0918/sys/src/9/ip/rudp.c
1035c
	char hup[ERRMAX];
.
200c
	char kpname[KNAMELEN];
.
## diffname ip/rudp.c 2002/0507
## diff -e /n/emeliedump/2001/0918/sys/src/9/ip/rudp.c /n/emeliedump/2002/0507/sys/src/9/ip/rudp.c
989a
	uh->vihl = IP_VER4;
.
404a
	uh->vihl = IP_VER4;
.
324c
		ipoput4(f, bp, x, ttl, tos);
.
## diffname ip/rudp.c 2002/0711
## diff -e /n/emeliedump/2002/0507/sys/src/9/ip/rudp.c /n/emeliedump/2002/0711/sys/src/9/ip/rudp.c
266c
	c->rq = qopen(64*1024, Qmsg, 0, 0);
.
## diffname ip/rudp.c 2002/0712
## diff -e /n/emeliedump/2002/0711/sys/src/9/ip/rudp.c /n/emeliedump/2002/0712/sys/src/9/ip/rudp.c
711d
337a
	Conv *c = x;
.
336c
rudpkick(void *x)
.
267c
	c->wq = qopen(64*1024, Qkick, rudpkick, c);
.
194a
void	rudpkick(void *x);
.
## diffname ip/rudp.c 2003/0308
## diff -e /n/emeliedump/2002/0712/sys/src/9/ip/rudp.c /n/emeliedump/2003/0308/sys/src/9/ip/rudp.c
325c
		ipoput4(f, bp, x, ttl, tos, nil);
.
## diffname ip/rudp.c 2003/0407
## diff -e /n/emeliedump/2003/0308/sys/src/9/ip/rudp.c /n/emeliedump/2003/0407/sys/src/9/ip/rudp.c
769c
	tsleep(&up->sleep, return0, 0, Rudptickms);
.
149d
## diffname ip/rudp.c 2003/0409
## diff -e /n/emeliedump/2003/0407/sys/src/9/ip/rudp.c /n/emeliedump/2003/0409/sys/src/9/ip/rudp.c
765d
762d
## diffname ip/rudp.c 2003/0419
## diff -e /n/emeliedump/2003/0409/sys/src/9/ip/rudp.c /n/emeliedump/2003/0419/sys/src/9/ip/rudp.c
631,632c
	if(strcmp(f[0], "headers++4") == 0){
		ucb->headers = 7;
.
578,588d
570,576c
		p = bp->rp;
		ipmove(p, raddr); p += IPaddrlen;
		ipmove(p, ipforme(f, laddr)==Runi ? laddr : ifc->lifc->local); p += IPaddrlen;
		hnputs(p, rport); p += 2;
		hnputs(p, lport);
.
566a
	case 7:
		/* pass the src address */
		bp = padblock(bp, UDP_USEAD7);
		p = bp->rp;
		ipmove(p, raddr); p += IPaddrlen;
		ipmove(p, laddr); p += IPaddrlen;
		ipmove(p, ifc->lifc->local); p += IPaddrlen;
		hnputs(p, rport); p += 2;
		hnputs(p, lport);
		break;
.
489a
	uchar *p;
.
418a
	case 7:
.
417d
380,383c
		ipmove(raddr, bp->rp);
		bp->rp += IPaddrlen;
		ipmove(laddr, bp->rp);
		bp->rp += IPaddrlen;
		/* pick interface closest to dest */
.
376,377c
	case 6:
		/* get user specified addresses */
		bp = pullupblock(bp, UDP_USEAD6);
.
373,374c
		bp->rp += 2+2;			/* Ignore local port */
.
371a
		bp->rp += IPaddrlen;		/* Ignore ifc address */
.
362c
		bp = pullupblock(bp, UDP_USEAD7);
.
360c
	case 7:
.
32a
	UDP_USEAD7	= 52,
.