## diffname port/devnonet.c 1990/1210
## diff -e /dev/null /n/bootesdump/1990/1210/sys/src/9/port/devnonet.c
0a
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "errno.h"
#define DPRINT if(0)
#define NOW (MACHP(0)->ticks*MS2HZ)
static Noifc *noifc;
enum {
/*
* tuning parameters
*/
MSrexmit = 500, /* retranmission interval in ms */
MSack = 50, /* ms to sit on an ack */
/*
* relative or immutable
*/
Nsubdir = 5, /* entries in the nonet directory */
Nmask = Nnomsg - 1, /* mask for log(Nnomsg) bits */
};
/* predeclared */
static void hangup(Noconv*);
static Block* mkhdr(Noconv*, int);
static void listen(Chan*, Noifc*);
static void announce(Chan*, char*);
static void connect(Chan*, char*);
static void rcvack(Noconv*, int);
static void sendctlmsg(Noconv*, int, int);
static void sendmsg(Noconv*, Nomsg*);
static void startconv(Noconv*, int, char*, int);
static void queueack(Noconv*, int);
static void nonetiput(Queue*, Block*);
static void nonetoput(Queue*, Block*);
static void nonetstclose(Queue*);
static void nonetstopen(Queue*, Stream*);
extern Qinfo noetherinfo;
extern Qinfo nonetinfo;
/*
* nonet directory and subdirectory
*/
enum {
/*
* per conversation
*/
Naddrqid,
Nlistenqid,
Nraddrqid,
Nruserqid,
Nstatsqid,
Nchanqid,
/*
* per noifc
*/
Ncloneqid,
};
Dirtab *nonetdir;
Dirtab nosubdir[]={
"addr", {Naddrqid}, 0, 0600,
"listen", {Nlistenqid}, 0, 0600,
"raddr", {Nraddrqid}, 0, 0600,
"ruser", {Nruserqid}, 0, 0600,
"stats", {Nstatsqid}, 0, 0600,
};
/*
* Nonet conversation states (for Noconv.state)
*/
enum {
Cclosed,
Copen,
Cannounced,
Cconnected,
Cconnecting,
Chungup,
Cclosing,
};
/*
* nonet file system. most of the calls use dev.c to access the nonet
* directory and stream.c to access the nonet devices.
* create the nonet directory. the files are `clone' and stream
* directories '1' to '32' (or whatever conf.noconv is in decimal)
*/
void
nonetreset(void)
{
int i;
/*
* allocate the interfaces
*/
noifc = (Noifc *)ialloc(sizeof(Noifc) * conf.nnoifc, 0);
for(i = 0; i < conf.nnoconv; i++)
noifc[i].conv = (Noconv *)ialloc(sizeof(Noconv) * conf.nnoconv, 0);
/*
* create the directory.
*/
nonetdir = (Dirtab *)ialloc(sizeof(Dirtab) * (conf.nnoconv+1), 0);
/*
* the circuits
*/
for(i = 0; i < conf.nnoconv; i++) {
sprint(nonetdir[i].name, "%d", i);
nonetdir[i].qid.path = CHDIR|STREAMQID(i, Nchanqid);
nonetdir[i].qid.vers = 0;
nonetdir[i].length = 0;
nonetdir[i].perm = 0600;
}
/*
* the clone device
*/
strcpy(nonetdir[i].name, "clone");
nonetdir[i].qid.path = Ncloneqid;
nonetdir[i].qid.vers = 0;
nonetdir[i].length = 0;
nonetdir[i].perm = 0600;
}
void
nonetinit(void)
{
}
/*
* find an noifc and increment its count
*/
Chan*
nonetattach(char *spec)
{
Noifc *ifc;
Chan *c;
/*
* find an noifc with the same name
*/
if(*spec == 0)
spec = "nonet";
for(ifc = noifc; ifc < &noifc[conf.nnoifc]; ifc++){
lock(ifc);
if(strcmp(spec, ifc->name)==0 && ifc->wq) {
ifc->ref++;
unlock(ifc);
break;
}
unlock(ifc);
}
if(ifc == &noifc[conf.nnoifc])
error(Enoifc);
c = devattach('n', spec);
c->dev = ifc - noifc;
return c;
}
/*
* up the reference count to the noifc
*/
Chan*
nonetclone(Chan *c, Chan *nc)
{
Noifc *ifc;
c = devclone(c, nc);
ifc = &noifc[c->dev];
lock(ifc);
ifc->ref++;
unlock(ifc);
return c;
}
int
nonetwalk(Chan *c, char *name)
{
if(c->qid.path == CHDIR)
return devwalk(c, name, nonetdir, conf.nnoconv+1, devgen);
else
return devwalk(c, name, nosubdir, Nsubdir, streamgen);
}
void
nonetstat(Chan *c, char *dp)
{
if(c->qid.path == CHDIR)
devstat(c, dp, nonetdir, conf.nnoconv+1, devgen);
else if(c->qid.path == Ncloneqid)
devstat(c, dp, nonetdir, 1, devgen);
else
devstat(c, dp, nosubdir, Nsubdir, streamgen);
}
/*
* opening a nonet device allocates a Noconv. Opening the `clone'
* device is a ``macro'' for finding a free Noconv and opening
* it's ctl file.
*/
Noconv *
nonetopenclone(Chan *c, Noifc *ifc)
{
Noconv *cp;
Noconv *ep;
ep = &ifc->conv[conf.nnoconv];
for(cp = &ifc->conv[0]; cp < ep; cp++){
if(cp->state == Cclosed && canqlock(cp)){
if(cp->state != Cclosed){
qunlock(cp);
continue;
}
c->qid.path = CHDIR|STREAMQID(cp-ifc->conv, Nchanqid);
devwalk(c, "ctl", 0, 0, streamgen);
streamopen(c, &nonetinfo);
qunlock(cp);
break;
}
}
if(cp == ep)
error(Enodev);;
return cp;
}
Chan*
nonetopen(Chan *c, int omode)
{
Stream *s;
Noconv *cp;
Noifc *ifc;
int line;
if(c->qid.path & CHDIR){
/*
* directories are read only
*/
if(omode != OREAD)
error(Ebadarg);
} else switch(STREAMTYPE(c->qid.path)){
case Ncloneqid:
/*
* get an unused device and open it's control file
*/
ifc = &noifc[c->dev];
cp = nonetopenclone(c, ifc);
break;
case Nlistenqid:
/*
* listen for a call and open the control file for the
* channel on which the call arrived.
*/
line = STREAMID(c->qid.path);
ifc = &noifc[c->dev];
if(ifc->conv[line].state != Cannounced)
error(Enoannounce);
listen(c, ifc);
break;
case Nraddrqid:
/*
* read only files
*/
if(omode != OREAD)
error(Ebadarg);
break;
default:
/*
* open whatever c points to
*/
streamopen(c, &nonetinfo);
break;
}
c->mode = openmode(omode);
c->flag |= COPEN;
c->offset = 0;
return c;
}
void
nonetcreate(Chan *c, char *name, int omode, ulong perm)
{
error(Eperm);
}
void
nonetclose(Chan *c)
{
Noifc *ifc;
/*
* real closing happens in nonetstclose
*/
if(c->qid.path != CHDIR)
streamclose(c);
/*
* let go of the multiplexor
*/
nonetfreeifc(&noifc[c->dev]);
}
long
nonetread(Chan *c, void *a, long n)
{
int t;
Noconv *cp;
char stats[256];
/*
* pass data/ctl reads onto the stream code
*/
t = STREAMTYPE(c->qid.path);
if(t >= Slowqid)
return streamread(c, a, n);
if(c->qid.path == CHDIR)
return devdirread(c, a, n, nonetdir, conf.nnoconv+1, devgen);
if(c->qid.path & CHDIR)
return devdirread(c, a, n, nosubdir, Nsubdir, streamgen);
cp = &noifc[c->dev].conv[STREAMID(c->qid.path)];
switch(t){
case Nraddrqid:
return stringread(c, a, n, cp->raddr);
case Naddrqid:
return stringread(c, a, n, cp->addr);
case Nruserqid:
return stringread(c, a, n, cp->ruser);
case Nstatsqid:
sprint(stats, "sent: %d\nrcved: %d\nrexmit: %d\nbad: %d\n",
cp->sent, cp->rcvd, cp->rexmit, cp->bad);
return stringread(c, a, n, stats);
}
error(Eperm);
}
long
nonetwrite(Chan *c, void *a, long n)
{
int t;
int m;
char buf[256];
char *field[5];
t = STREAMTYPE(c->qid.path);
/*
* get data dispatched as quickly as possible
*/
if(t == Sdataqid)
return streamwrite(c, a, n, 0);
/*
* easier to do here than in nonetoput
*/
if(t == Sctlqid){
strncpy(buf, a, sizeof buf);
m = getfields(buf, field, 5, ' ');
if(strcmp(field[0], "connect")==0){
if(m < 2)
error(Ebadarg);
connect(c, field[1]);
} else if(strcmp(field[0], "announce")==0){
announce(c, field[1]);
} else if(strcmp(field[0], "accept")==0){
/* ignore */;
} else if(strcmp(field[0], "reject")==0){
/* ignore */;
} else
return streamwrite(c, a, n, 0);
return n;
}
error(Eperm);
}
void
nonetremove(Chan *c)
{
error(Eperm);
}
void
nonetwstat(Chan *c, char *dp)
{
error(Eperm);
}
/*
* the device stream module definition
*/
Qinfo nonetinfo =
{
nonetiput,
nonetoput,
nonetstopen,
nonetstclose,
"nonet"
};
/*
* store the device end of the stream so that the multiplexor can
* send blocks upstream.
*/
static void
nonetstopen(Queue *q, Stream *s)
{
Noifc *ifc;
Noconv *cp;
ifc = &noifc[s->dev];
cp = &ifc->conv[s->id];
cp->s = s;
cp->ifc = ifc;
cp->rq = RD(q);
cp->state = Copen;
RD(q)->ptr = WR(q)->ptr = (void *)cp;
}
/*
* wait until a hangup is received.
* then send a hangup message (until one is received).
*/
static int
ishungup(void *a)
{
Noconv *cp;
cp = (Noconv *)a;
return cp->state == Chungup;
}
static void
nonetstclose(Queue *q)
{
Noconv *cp;
Nomsg *mp;
int i;
cp = (Noconv *)q->ptr;
if(waserror()){
cp->rcvcircuit = -1;
cp->state = Cclosed;
nexterror();
}
/*
* send hangup messages to the other side
* until it hangs up or we get tired.
*/
if(cp->state >= Cconnected){
sendctlmsg(cp, NO_HANGUP, 1);
for(i=0; i<10 && !ishungup(cp); i++){
sendctlmsg(cp, NO_HANGUP, 1);
tsleep(&cp->r, ishungup, cp, MSrexmit);
}
}
cp->rcvcircuit = -1;
cp->state = Cclosed;
poperror();
}
/*
* send all messages up stream. this should only be control messages
*/
static void
nonetiput(Queue *q, Block *bp)
{
Noconv *cp;
if(bp->type == M_HANGUP){
cp = (Noconv *)q->ptr;
cp->state = Chungup;
}
PUTNEXT(q, bp);
}
/*
* queue a block
*/
static int
windowopen(void *a)
{
Noconv *cp;
cp = (Noconv *)a;
return cp->out[cp->next].inuse == 0;
}
static int
acked(void *a)
{
Nomsg *mp;
mp = (Nomsg *)a;
return mp->acked;
}
static void
nonetoput(Queue *q, Block *bp)
{
Noconv *cp;
int next;
Nomsg *mp;
cp = (Noconv *)(q->ptr);
/*
* do all control functions
*/
if(bp->type != M_DATA){
freeb(bp);
error(Ebadctl);
}
/*
* collect till we see a delim
*/
qlock(&cp->mlock);
if(!putb(q, bp)){
qunlock(&cp->mlock);
return;
}
mp = 0;
if(waserror()){
if(mp){
if(mp->first){
freeb(mp->first);
mp->first = 0;
}
mp->inuse = 0;
} else
qunlock(&cp->mlock);
}
/*
* block till we get a buffer
*/
while(cp->out[cp->next].inuse)
sleep(&cp->r, windowopen, cp);
mp = &cp->out[cp->next];
mp->inuse = 1;
cp->next = (cp->next+1)%Nnomsg;
/*
* stick the message in a Nomsg structure
*/
mp->time = NOW + MSrexmit;
mp->first = q->first;
mp->last = q->last;
mp->len = q->len;
mp->mid ^= Nnomsg;
mp->acked = 0;
/*
* init the queue for new messages
*/
q->len = 0;
q->first = q->last = 0;
cp->sent++;
qunlock(&cp->mlock);
/*
* wait for acknowledgement
*/
while(!mp->acked && cp->state!=Chungup){
sendmsg(cp, mp);
tsleep(&mp->r, acked, mp, MSrexmit);
}
/*
* free buffer
*/
freeb(mp->first);
mp->first = 0;
mp->inuse = 0;
wakeup(&cp->r);
poperror();
}
/*
* start a new conversation. start an ack/retransmit process if
* none already exists for this circuit.
*/
void
startconv(Noconv *cp, int circuit, char *raddr, int state)
{
int i;
char name[32];
Noifc *ifc;
ifc = cp->ifc;
/*
* allocate the prototype header
*/
cp->media = allocb(ifc->hsize + NO_HDRSIZE);
cp->media->wptr += ifc->hsize + NO_HDRSIZE;
cp->hdr = (Nohdr *)(cp->media->rptr + ifc->hsize);
/*
* fill in the circuit number
*/
cp->hdr->flag = NO_NEWCALL|NO_ACKME;
cp->hdr->circuit[2] = circuit>>16;
cp->hdr->circuit[1] = circuit>>8;
cp->hdr->circuit[0] = circuit;
/*
* set the state variables
*/
cp->state = state;
for(i = 1; i < Nnomsg; i++){
cp->in[i].mid = i;
cp->in[i].acked = 0;
cp->in[i].rem = 0;
cp->out[i].mid = i | Nnomsg;
cp->out[i].acked = 1;
cp->out[i].rem = 0;
cp->out[i].inuse = 0;
}
cp->in[0].mid = Nnomsg;
cp->in[0].acked = 0;
cp->in[0].rem = 0;
cp->out[0].mid = 0;
cp->out[0].acked = 1;
cp->out[0].rem = 0;
cp->first = cp->next = 1;
cp->rexmit = cp->bad = cp->sent = cp->rcvd = cp->lastacked = 0;
/*
* used for demultiplexing
*/
cp->rcvcircuit = circuit ^ 1;
/*
* media dependent header
*/
(*ifc->connect)(cp, raddr);
/*
* status files
*/
strncpy(cp->raddr, raddr, sizeof(cp->raddr));
strcpy(cp->ruser, "none");
}
/*
* announce willingness to take calls
*/
static void
announce(Chan *c, char *addr)
{
Noconv *cp;
cp = (Noconv *)(c->stream->devq->ptr);
if(cp->state != Copen)
error(Einuse);
cp->state = Cannounced;
}
/*
* connect to the destination whose name is pointed to by bp->rptr.
*
* a service is separated from the destination system by a '!'
*/
static void
connect(Chan *c, char *addr)
{
Noifc *ifc;
Noconv *cp;
char *service;
char buf[2*NAMELEN+2];
cp = (Noconv *)(c->stream->devq->ptr);
if(cp->state != Copen)
error(Einuse);
ifc = cp->ifc;
service = strchr(addr, '!');
if(service){
*service++ = 0;
if(strchr(service, ' '))
error(Ebadctl);
if(strlen(service) > NAMELEN)
error(Ebadctl);
}
startconv(cp, 2*(cp - ifc->conv), addr, Cconnecting);
if(service){
/*
* send service name and user name
*/
cp->hdr->flag |= NO_SERVICE;
sprint(buf, "%s %s", service, u->p->pgrp->user);
c->qid.path = STREAMQID(STREAMID(c->qid.path), Sdataqid);
streamwrite(c, buf, strlen(buf), 1);
c->qid.path = STREAMQID(STREAMID(c->qid.path), Sctlqid);
}
}
/*
* listen for a call. There can be many listeners, but only one can sleep
* on the circular queue at a time. ifc->listenl lets only one at a time into
* the sleep.
*/
static int
iscall(void *a)
{
Noifc *ifc;
ifc = (Noifc *)a;
return ifc->rptr != ifc->wptr;
}
static void
listen(Chan *c, Noifc *ifc)
{
Noconv *cp, *ep;
Nocall call;
int f;
char buf[2*NAMELEN+4];
char *user;
long n;
call.msg = 0;
if(waserror()){
if(call.msg)
freeb(call.msg);
qunlock(&ifc->listenl);
nexterror();
}
for(;;){
/*
* one listener at a time
*/
qlock(&ifc->listenl);
/*
* wait for a call
*/
sleep(&ifc->listenr, iscall, ifc);
call = ifc->call[ifc->rptr];
ifc->rptr = (ifc->rptr+1) % Nnocalls;
qunlock(&ifc->listenl);
/*
* make sure we aren't already using this circuit
*/
ep = &ifc->conv[conf.nnoconv];
for(cp = &ifc->conv[0]; cp < ep; cp++){
if(cp->state>Cannounced && call.circuit==cp->rcvcircuit
&& strcmp(call.raddr, cp->raddr)==0)
break;
}
if(cp != ep){
freeb(call.msg);
call.msg = 0;
continue;
}
/*
* get a free channel
*/
cp = nonetopenclone(c, ifc);
c->qid.path = STREAMQID(cp - ifc->conv, Sctlqid);
/*
* start the protocol and
* stuff the connect message into it
*/
f = ((Nohdr *)(call.msg->rptr))->flag;
startconv(cp, call.circuit, call.raddr, Cconnecting);
print("rcving %d byte message\n", call.msg->wptr - call.msg->rptr);
nonetrcvmsg(cp, call.msg);
call.msg = 0;
/*
* if a service and remote user were specified,
* grab them
*/
if(f & NO_SERVICE){
print("reading service\n");
c->qid.path = STREAMQID(cp - ifc->conv, Sdataqid);
n = streamread(c, buf, sizeof(buf));
c->qid.path = STREAMQID(cp - ifc->conv, Sctlqid);
print("read %d bytes\n", n);
if(n <= 0)
error(Ebadctl);
buf[n] = 0;
print("read %s\n", buf);
user = strchr(buf, ' ');
if(user){
*user++ = 0;
strncpy(cp->ruser, user, NAMELEN);
} else
strcpy(cp->ruser, "none");
strncpy(cp->addr, buf, NAMELEN);
}
break;
}
poperror();
}
/*
* send a hangup signal up the stream to get all line disciplines
* to cease and desist
*/
static void
hangup(Noconv *cp)
{
Block *bp;
Queue *q;
cp->state = Chungup;
bp = allocb(0);
bp->type = M_HANGUP;
q = cp->rq;
PUTNEXT(q, bp);
wakeup(&cp->r);
}
/*
* process a message acknowledgement. if the message
* has any xmit buffers queued, free them.
*/
static void
rcvack(Noconv *cp, int mid)
{
Nomsg *mp;
Block *bp;
int i;
mp = &cp->out[mid & Nmask];
/*
* if already acked, ignore
*/
if(mp->acked || mp->mid != mid)
return;
/*
* wakeup the sender
*/
mp->acked = 1;
wakeup(&mp->r);
cp->lastacked = mid;
}
/*
* queue an acknowledgement to be sent. ignore it if we already have Nnomsg
* acknowledgements queued.
*/
static void
queueack(Noconv *cp, int mid)
{
int next;
ulong now;
now = NOW;
next = (cp->anext + 1)&Nmask;
if(next != cp->afirst){
cp->ack[cp->anext] = mid;
cp->anext = next;
}
}
/*
* make a packet header
*/
Block *
mkhdr(Noconv *cp, int rem)
{
Block *bp;
Nohdr *hp;
bp = allocb(cp->ifc->hsize + NO_HDRSIZE + cp->ifc->mintu);
memcpy(bp->wptr, cp->media->rptr, cp->ifc->hsize + NO_HDRSIZE);
bp->wptr += cp->ifc->hsize + NO_HDRSIZE;
hp = (Nohdr *)(bp->rptr + cp->ifc->hsize);
hp->remain[1] = rem>>8;
hp->remain[0] = rem;
hp->sum[0] = hp->sum[1] = 0;
return bp;
}
/*
* transmit a message. this involves breaking a possibly multi-block message into
* a train of packets on the media.
*
* called by nonetoput(). the qlock(mp) synchronizes these two
* processes.
*/
static void
sendmsg(Noconv *cp, Nomsg *mp)
{
Noifc *ifc;
Queue *wq;
int msgrem;
int pktrem;
int n;
Block *bp, *pkt, *last;
uchar *rptr;
ifc = cp->ifc;
if(ifc == 0)
return;
wq = ifc->wq->next;
/*
* one transmitter at a time
*/
qlock(&cp->xlock);
if(waserror()){
qunlock(&cp->xlock);
return;
}
/*
* get the next acknowledge to use if the next queue up
* is not full.
*/
if(cp->afirst != cp->anext && cp->rq->next->len < 16*1024){
cp->hdr->ack = cp->ack[cp->afirst];
cp->afirst = (cp->afirst+1)&Nmask;
}
cp->hdr->mid = mp->mid;
if(ifc->mintu > mp->len) {
/*
* short message:
* copy the whole message into the header block
*/
last = pkt = mkhdr(cp, mp->len);
for(bp = mp->first; bp; bp = bp->next){
memcpy(pkt->wptr, bp->rptr, n = BLEN(bp));
pkt->wptr += n;
}
memset(pkt->wptr, 0, n = ifc->mintu - mp->len);
pkt->wptr += n;
} else {
/*
* long message:
* break up the message into noifc packets and send them.
* once around this loop for each non-header block generated.
*/
msgrem = mp->len;
pktrem = msgrem > ifc->maxtu ? ifc->maxtu : msgrem;
bp = mp->first;
if(bp)
rptr = bp->rptr;
last = pkt = mkhdr(cp, msgrem);
while(bp){
/*
* if pkt full, send and create new header block
*/
if(pktrem == 0){
nonetcksum(pkt, ifc->hsize);
last->flags |= S_DELIM;
(*wq->put)(wq, pkt);
last = pkt = mkhdr(cp, -msgrem);
pktrem = msgrem > ifc->maxtu ? ifc->maxtu : msgrem;
}
n = bp->wptr - rptr;
if(n > pktrem)
n = pktrem;
last = last->next = allocb(0);
last->rptr = rptr;
last->wptr = rptr = rptr + n;
msgrem -= n;
pktrem -= n;
if(rptr >= bp->wptr){
bp = bp->next;
if(bp)
rptr = bp->rptr;
}
}
}
nonetcksum(pkt, ifc->hsize);
last->flags |= S_DELIM;
(*wq->put)(wq, pkt);
mp->time = NOW + MSrexmit;
qunlock(&cp->xlock);
poperror();
}
/*
* send a control message (hangup or acknowledgement).
*/
static void
sendctlmsg(Noconv *cp, int flag, int new)
{
cp->ctl.len = 0;
cp->ctl.first = 0;
cp->ctl.acked = 0;
if(new)
cp->ctl.mid = Nnomsg^cp->out[cp->next].mid;
else
cp->ctl.mid = cp->lastacked;
cp->hdr->flag |= flag;
sendmsg(cp, &cp->ctl);
}
/*
* receive a message (called by the multiplexor; noetheriput, nofddiiput, ...)
*/
void
nonetrcvmsg(Noconv *cp, Block *bp)
{
Block *nbp;
Nohdr *h;
short r;
int c;
Nomsg *mp;
int f;
Queue *q;
q = cp->rq;
/*
* grab the packet header, push the pointer past the nonet header
*/
h = (Nohdr *)bp->rptr;
bp->rptr += NO_HDRSIZE;
mp = &cp->in[h->mid & Nmask];
r = (h->remain[1]<<8) | h->remain[0];
f = h->flag;
/*
* if a new call request comes in on a connected channel, hang up the call
*/
if(h->mid==0 && (f & NO_NEWCALL) && cp->state==Cconnected){
freeb(bp);
hangup(cp);
return;
}
/*
* ignore old messages and process the acknowledgement
*/
if(h->mid != mp->mid){
DPRINT("old msg %d instead of %d\n", h->mid, mp->mid);
if(r == 0){
rcvack(cp, h->ack);
if(f & NO_HANGUP)
hangup(cp);
} else {
if(r>0)
queueack(cp, h->mid);
cp->bad++;
}
freeb(bp);
return;
}
if(r>=0){
/*
* start of message packet
*/
if(mp->first){
DPRINT("mp->mid==%d mp->rem==%d buf r==%d\n", mp->mid, mp->rem, r);
cp->bad++;
freeb(bp);
return;
}
mp->rem = r;
} else {
/*
* a continuation
*/
if(-r != mp->rem) {
DPRINT("mp->mid==%d mp->rem==%d buf r==%d\n", mp->mid, mp->rem, r);
cp->bad++;
freeb(bp);
return;
}
}
/*
* take care of packets that were padded up
*/
mp->rem -= BLEN(bp);
if(mp->rem < 0){
if(-mp->rem <= BLEN(bp)){
bp->wptr += mp->rem;
mp->rem = 0;
} else
panic("nonetrcvmsg: short packet");
}
putb(mp, bp);
/*
* if the last chunk - pass it up the stream and wake any
* waiting process.
*
* if not, strip off the delimiter.
*/
if(mp->rem == 0){
rcvack(cp, h->ack);
if(f & NO_ACKME)
queueack(cp, h->mid);
mp->last->flags |= S_DELIM;
PUTNEXT(q, mp->first);
mp->first = mp->last = 0;
mp->len = 0;
cp->rcvd++;
/*
* cycle bufffer to next expected mid
*/
mp->mid ^= Nnomsg;
/*
* stop xmitting the NO_NEWCALL flag
*/
if(cp->state==Cconnecting && !(f & NO_NEWCALL))
cp->state = Cconnected;
} else
mp->last->flags &= ~S_DELIM;
}
/*
* noifc
*/
/*
* Create an ifc.
*/
Noifc *
nonetnewifc(Queue *q, Stream *s, int maxtu, int mintu, int hsize,
void (*connect)(Noconv *, char *))
{
Noifc *ifc;
int i;
for(ifc = noifc; ifc < &noifc[conf.nnoifc]; ifc++){
if(ifc->ref == 0){
lock(ifc);
if(ifc->ref) {
/* someone was faster than us */
unlock(ifc);
continue;
}
RD(q)->ptr = WR(q)->ptr = (void *)ifc;
for(i = 0; i < conf.nnoconv; i++)
ifc->conv[i].rcvcircuit = -1;
ifc->maxtu = maxtu - hsize - NO_HDRSIZE;
ifc->mintu = mintu - hsize - NO_HDRSIZE;
ifc->hsize = hsize;
ifc->connect = connect;
ifc->name[0] = 0;
ifc->wq = WR(q);
ifc->ref = 1;
unlock(ifc);
return ifc;
}
}
error(Enoifc);
}
/*
* Free an noifc.
*/
void
nonetfreeifc(Noifc *ifc)
{
lock(ifc);
ifc->ref--;
if(ifc->ref == 0)
ifc->wq = 0;
unlock(ifc);
}
/*
* calculate the checksum of a list of blocks. ignore the first `offset' bytes.
*/
int
nonetcksum(Block *bp, int offset)
{
Block *nbp = bp;
uchar *ep, *p;
int n;
ulong s;
Nohdr *hp;
s = 0;
p = bp->rptr + offset;
n = bp->wptr - p;
hp = (Nohdr *)p;
hp->sum[0] = hp->sum[1] = 0;
for(;;){
ep = p+(n&~0x7);
while(p < ep) {
s = s + s + p[0];
s = s + s + p[1];
s = s + s + p[2];
s = s + s + p[3];
s = s + s + p[4];
s = s + s + p[5];
s = s + s + p[6];
s = s + s + p[7];
s = (s&0xffff) + (s>>16);
p += 8;
}
ep = p+(n&0x7);
while(p < ep) {
s = s + s + *p;
p++;
}
s = (s&0xffff) + (s>>16);
bp = bp->next;
if(bp == 0)
break;
p = bp->rptr;
n = BLEN(bp);
}
s = (s&0xffff) + (s>>16);
hp->sum[1] = s>>8;
hp->sum[0] = s;
return s & 0xffff;
}
.
## diffname port/devnonet.c 1990/1214
## diff -e /n/bootesdump/1990/1210/sys/src/9/port/devnonet.c /n/bootesdump/1990/1214/sys/src/9/port/devnonet.c
1192d
961a
SET(rptr);
.
871d
869d
255c
nonetopenclone(c, ifc);
.
239d
## diffname port/devnonet.c 1990/1229
## diff -e /n/bootesdump/1990/1214/sys/src/9/port/devnonet.c /n/bootesdump/1990/1229/sys/src/9/port/devnonet.c
1229a
}
nonettoggle()
{
pnonet ^= 1;
.
1042a
DPRINT("new call on connected channel\n");
.
105c
for(i = 0; i < conf.nnoifc; i++)
.
18c
MSrexmit = 500, /* retranmission interval in ms */
.
12a
int pnonet;
.
9c
#define DPRINT if(pnonet)print
.
## diffname port/devnonet.c 1990/1231
## diff -e /n/bootesdump/1990/1229/sys/src/9/port/devnonet.c /n/bootesdump/1990/1231/sys/src/9/port/devnonet.c
1061c
sendack(cp, h->mid);
.
1015a
* send an acknowledgement
*/
static void
sendack(Noconv *cp, int ack)
{
cp->ackmsg.len = 0;
cp->ackmsg.first = 0;
cp->ackmsg.acked = ack;
cp->ackmsg.mid = cp->lastacked;
sendmsg(cp, &cp->ctl);
}
/*
.
783a
print("call from %d %s\n", call.circuit, call.raddr);
.
707a
print("request sent\n");
.
706a
print("sending request\n");
.
39a
static void sendack(Noconv*, int);
.
## diffname port/devnonet.c 1991/0102
## diff -e /n/bootesdump/1990/1231/sys/src/9/port/devnonet.c /n/bootesdump/1991/0102/sys/src/9/port/devnonet.c
1077,1078c
if(r>0){
queueack(cp, h->mid);
sendctlmsg(cp, 0, 0);
}
.
1020,1032d
1016c
sendmsg(cp, &ctl);
.
1014c
ctl.mid = cp->lastacked;
.
1012c
ctl.mid = Nnomsg^cp->out[cp->next].mid;
.
1008,1010c
Nomsg ctl;
ctl.len = 0;
ctl.first = 0;
ctl.acked = 0;
.
924c
* one transmitter at a time for this connection
.
40d
## diffname port/devnonet.c 1991/0108
## diff -e /n/bootesdump/1991/0102/sys/src/9/port/devnonet.c /n/bootesdump/1991/0108/sys/src/9/port/devnonet.c
1244a
.
1240a
/*
* send acknowledges that need to be sent. this happens at 1/2
* the retransmission interval.
*/
static void
nonetkproc(void *arg)
{
Noifc *ifc;
Noconv *cp, *ep;
cp = 0;
ifc = 0;
if(waserror()){
if(ifc)
unlock(ifc);
if(cp)
qunlock(cp);
}
loop:
for(ifc = noifc; ifc < &noifc[conf.nnoifc]; ifc++){
if(ifc->wq==0 || !canlock(ifc))
continue;
ep = ifc->conv + conf.nnoconv;
for(cp = ifc->conv; cp < ep; cp++){
if(cp->state==Cclosed || !canqlock(cp))
continue;
if(cp->afirst != cp->anext){
DPRINT("sending ack %d\n", cp->ack[cp->afirst]);
sendctlmsg(cp, 0, 0);
}
qunlock(cp);
}
unlock(ifc);
}
tsleep(&nonetkr, return0, 0, MSrexmit/2);
goto loop;
}
.
1067d
1065a
rcvack(cp, h->ack);
.
1059c
DPRINT("old msg %d instead of %d r==%d\n", h->mid, mp->mid, r);
.
805d
801d
797c
DPRINT("reading service\n");
.
788c
DPRINT("rcving %d byte message\n", call.msg->wptr - call.msg->rptr);
.
786c
DPRINT("call from %d %s\n", call.circuit, call.raddr);
.
709c
DPRINT("request sent\n");
.
707c
DPRINT("sending request\n");
.
578a
if(retries++ > 100)
errors("to many nonet rexmits");
.
575a
retries = 0;
.
513a
int retries;
.
470a
qunlock(cp);
.
468a
qlock(cp);
.
242a
if(!kstarted){
kproc("nonetack", nonetkproc, 0);
kstarted = 1;
}
.
166a
.
91a
* nonet kproc
*/
static int kstarted;
static Rendez nonetkr;
/*
.
40c
static void nonetkproc(void*);
.
19c
MSrexmit = 250, /* retranmission interval in ms */
.
## diffname port/devnonet.c 1991/0109
## diff -e /n/bootesdump/1991/0108/sys/src/9/port/devnonet.c /n/bootesdump/1991/0109/sys/src/9/port/devnonet.c
606d
597a
poperror();
.
596c
errors("too many nonet rexmits");
.
557,558c
}
qunlock(&cp->mlock);
nexterror();
.
## diffname port/devnonet.c 1991/0112
## diff -e /n/bootesdump/1991/0109/sys/src/9/port/devnonet.c /n/bootesdump/1991/0112/sys/src/9/port/devnonet.c
784c
if(cp->state>Cannounced && (call.circuit^1)==cp->rcvcircuit
.
## diffname port/devnonet.c 1991/01151
## diff -e /n/bootesdump/1991/0112/sys/src/9/port/devnonet.c /n/bootesdump/1991/01151/sys/src/9/port/devnonet.c
1297c
void
nonettoggle(void)
.
1284a
if(cp->state == Cclosed){
qunlock(cp);
continue;
}
/*
* resend the first message
*/
if(cp->first!=cp->next && cp->out[cp->first].time>=NOW){
if(cp->rexmit++ > 100){
print("hanging up\n");
hangup(cp);
} else
sendmsg(cp, &(cp->out[cp->first]));
}
/*
* resend an acknowledge
*/
.
1280a
/*
* loop through all active conversations
*/
.
1277a
/*
* loop through all active interfaces
*/
.
1108c
DPRINT("mp->mid==%d mp->rem==%d r==%d\n", mp->mid, mp->rem, r);
.
1097,1100c
DPRINT("mp->mid==%d mp->rem==%d r==%d\n", mp->mid, mp->rem, r);
freeb(mp->first);
mp->first = mp->last = 0;
mp->len = 0;
.
878a
freeb(mp->first);
mp->first = 0;
mp->inuse = 0;
/*
* advance first if this is the first
*/
if((mid&Nmask) == cp->first){
while(cp->first != cp->next){
if(cp->out[cp->first].acked == 0)
break;
cp->first = (cp->first+1) % Nnomsg;
}
}
.
877d
875a
cp->rexmit = 0;
.
874c
* free it
.
600,607d
592,598c
sendmsg(cp, mp);
qunlock(&cp->mlock);
.
590c
* send the message, the kproc will retry
.
587d
556a
mp->acked = 0;
if(((cp->first+1)%Nnomsg) == cp->next)
cp->first = cp->next;
.
551a
q->len = 0;
q->first = q->last = 0;
.
520c
return mp->inuse;
.
## diffname port/devnonet.c 1991/0118
## diff -e /n/bootesdump/1991/01151/sys/src/9/port/devnonet.c /n/bootesdump/1991/0118/sys/src/9/port/devnonet.c
1309,1310c
} else {
mp = &(cp->out[cp->first]);
sendmsg(cp, mp);
}
.
1305,1306c
if(cp->first!=cp->next && NOW>=cp->out[cp->first].time){
if(cp->rexmit++ > 60){
.
1271a
Nomsg *mp;
.
1073c
if(cp->state != Csuperceded){
cp->state = Csuperceded;
hangup(cp);
}
.
1070c
if(h->mid==0 && (f & NO_NEWCALL)
&& (cp->state==Cconnected || cp->state==Csuperceded)){
.
1018d
1016a
if(cp->rexmit > 10)
mp->time = NOW + 10*MSrexmit;
else
mp->time = NOW + (cp->rexmit+1)*MSrexmit;
DPRINT("xmit %d %lud %lud\n", cp->rexmit, NOW, mp->time);
.
1013a
/*
* round up last packet to mintu
*/
if(n < ifc->mintu){
n = ifc->mintu - n;
last = last->next = allocb(n);
memset(last->wptr, 0, n);
last->wptr += n;
}
.
988a
n = 0;
.
974c
/*
* round up to mintu
*/
memset(pkt->wptr, 0, n = ifc->mintu-mp->len);
.
963a
/*
* package n blocks into m packets. make sure
* no packet is < mintu or > maxtu in length.
*/
.
473c
if(cp->state>=Cconnected && cp->state!=Csuperceded){
.
88a
Csuperceded,
.
## diffname port/devnonet.c 1991/0119
## diff -e /n/bootesdump/1991/0118/sys/src/9/port/devnonet.c /n/bootesdump/1991/0119/sys/src/9/port/devnonet.c
1347c
nosendctl(cp, 0, 0);
.
1338c
nosend(cp, mp);
.
1335c
nohangup(cp);
.
1294c
nokproc(void *arg)
.
1189a
.
1184a
/*
* hangup (after processing message)
*/
if(f & NO_RESET){
DPRINT("reset with message\n");
noreset(cp);
} else if(f & NO_HANGUP){
DPRINT("hangup with message\n");
nohangup(cp);
}
.
1183c
if(cp->state==Cconnecting && !(f&NO_NEWCALL))
.
1181c
* any NO_NEWCALL after this is another call
.
1168c
noqack(cp, h->mid);
.
1166c
cp->hdr->flag &= ~(NO_NEWCALL|NO_SERVICE);
norack(cp, h->ack);
.
1114,1115c
norack(cp, h->ack);
noqack(cp, h->mid);
.
1109,1111c
norack(cp, h->ack);
if(f & NO_RESET)
noreset(cp);
else if(f & NO_HANGUP)
nohangup(cp);
.
1096,1099c
noreset(cp);
.
1092,1093c
if((f&NO_NEWCALL) && cp->state==Cconnected){
.
1065a
*
* State Transition: (no NO_NEWCALL in msg) Cconnecting -> Cconnected
.
1061c
nosend(cp, &ctl);
.
1049c
nosendctl(Noconv *cp, int flag, int new)
.
1039d
1006c
last = pkt = nohdr(cp, -msgrem);
.
996c
last = pkt = nohdr(cp, msgrem);
.
974c
last = pkt = nohdr(cp, mp->len);
.
930c
nosend(Noconv *cp, Nomsg *mp)
.
926c
* called by nooput(). the qlock(mp) synchronizes these two
.
907c
nohdr(Noconv *cp, int rem)
.
892c
noqack(Noconv *cp, int mid)
.
851c
norack(Noconv *cp, int mid)
.
846a
* send a hangup signal up the stream to get all line disciplines
* to cease and desist. The Creset state makes any subsequent close not
* send hangup messages.
*
* State Transition: {Cconnected, Cconnecting} -> Creset
*/
static void
noreset(Noconv *cp)
{
Block *bp;
Queue *q;
switch(cp->state){
case Cconnected:
case Cconnecting:
cp->state = Creset;
bp = allocb(0);
bp->type = M_HANGUP;
q = cp->rq;
PUTNEXT(q, bp);
break;
}
wakeup(&cp->r);
}
/*
.
838,842c
switch(cp->state){
case Cconnected:
case Cconnecting:
cp->state = Chungup;
bp = allocb(0);
bp->type = M_HANGUP;
q = cp->rq;
PUTNEXT(q, bp);
break;
}
.
833c
nohangup(Noconv *cp)
.
830a
*
* State Transition: {Cconnected, Cconnecting} -> Chungup
.
798c
nostartconv(cp, call.circuit, call.raddr, Cconnecting);
.
739c
nolisten(Chan *c, Noifc *ifc)
.
728a
*
* State Transition: Cclosed -> Copen -> Cconnecting
.
720d
718d
709c
nostartconv(cp, 2*(cp - ifc->conv), addr, Cconnecting);
.
689c
noconnect(Chan *c, char *addr)
.
686a
*
* State Transition: Copen -> Cconnecting
.
673c
noannounce(Chan *c, char *addr)
.
670a
*
* State Transition: Copen -> Chungup
.
650c
cp->rexmit = cp->bad = cp->sent = cp->rcvd = 0;
cp->lastacked = Nnomsg|(Nnomsg-1);
.
607c
nostartconv(Noconv *cp, int circuit, char *raddr, int state)
.
597c
nosend(cp, mp);
.
524c
nooput(Queue *q, Block *bp)
.
493c
noiput(Queue *q, Block *bp)
.
490a
*
* State Transition: (on M_HANGUP) * -> Chungup
.
479a
break;
case Chungup:
/*
* ack any close
*/
nosendctl(cp, NO_HANGUP, 1);
break;
.
477c
nosendctl(cp, NO_HANGUP, 1);
.
474,475c
switch(cp->state){
case Cconnected:
/*
* send close till we get one back
*/
nosendctl(cp, NO_HANGUP, 1);
.
456c
noclose(Queue *q)
.
453c
switch(cp->state){
case Chungup:
case Creset:
case Cclosed:
return 1;
}
return 0;
.
445a
*
* State Transitions: * -> Cclosed
.
429c
noopen(Queue *q, Stream *s)
.
426a
*
* State Transition: Cclosed -> Copen
.
417,420c
noiput,
nooput,
noopen,
noclose,
.
387c
noannounce(c, field[1]);
.
385c
noconnect(c, field[1]);
.
377c
* easier to do here than in nooput
.
314c
* real closing happens in noclose
.
279c
nolisten(c, ifc);
.
252c
kproc("nonetack", nokproc, 0);
.
88,89c
Creset,
.
30,44c
static void nohangup(Noconv*);
static void noreset(Noconv*);
static Block* nohdr(Noconv*, int);
static void nolisten(Chan*, Noifc*);
static void noannounce(Chan*, char*);
static void noconnect(Chan*, char*);
static void norack(Noconv*, int);
static void nosendctl(Noconv*, int, int);
static void nosend(Noconv*, Nomsg*);
static void nostartconv(Noconv*, int, char*, int);
static void noqack(Noconv*, int);
static void nokproc(void*);
static void noiput(Queue*, Block*);
static void nooput(Queue*, Block*);
static void noclose(Queue*);
static void noopen(Queue*, Stream*);
.
## diffname port/devnonet.c 1991/0206
## diff -e /n/bootesdump/1991/0119/sys/src/9/port/devnonet.c /n/bootesdump/1991/0206/sys/src/9/port/devnonet.c
1418c
while(cp->afirst != cp->anext){
.
1416c
* get the acknowledges out
.
1412d
1409,1410c
} else
.
1407c
norack(cp, mp->mid);
.
1405a
mp = &(cp->out[cp->first]);
.
944a
wakeup(&cp->r);
.
943c
cp->first = MSUCC(cp->first);
.
934d
931a
mp->acked = 1;
.
930d
664d
621c
qunlock(cp);
.
619a
if(waserror()){
/* throw out the message */
freeb(mp->first);
mp->first = 0;
mp->acked = 0;
if(MSUCC(cp->first) == cp->next)
cp->first = cp->next;
qunlock(cp);
nexterror();
}
.
613c
q->len = q->nb = 0;
.
611c
* take the message out of the queue
.
601c
* point the output buffer to the message
.
597,598c
cp->next = MSUCC(cp->next);
qlock(cp);
qunlock(&cp->mlock);
poperror();
.
590,594c
while(!windowopen(cp))
.
575,586c
/* throw out the message */
while(bp = getb(q))
freeb(bp);
.
573c
/*
* block till we get an output buffer
*/
.
538,545d
536c
return MSUCC(cp->next) != cp->first;
.
506a
.
503a
/*
* we give up, ack any unacked messages
*/
for(i = cp->first; i != cp->next; i = MSUCC(i))
norack(cp, cp->out[i].mid);
.
10a
#define MSUCC(x) (((x)+1)%Nnomsg)
.
## diffname port/devnonet.c 1991/0207
## diff -e /n/bootesdump/1991/0206/sys/src/9/port/devnonet.c /n/bootesdump/1991/0207/sys/src/9/port/devnonet.c
1416c
while(cp->afirst!=cp->anext && cp->rq->next->len<16*1024){
.
543c
i = cp->next - cp->first;
if(i>=0 && i<32)
return 1;
if(i<0 && Nnomsg+i<32)
return 1;
return 0;
.
540a
int i;
.
## diffname port/devnonet.c 1991/0209
## diff -e /n/bootesdump/1991/0207/sys/src/9/port/devnonet.c /n/bootesdump/1991/0209/sys/src/9/port/devnonet.c
1414c
noreset(cp);
.
1412c
if(cp->rexmit++ > 15){
.
1106,1107d
1025c
if(cp->afirst!=cp->anext && cp->rq->next->len<16*1024){
.
1012,1021d
492c
nosendctl(cp, NO_HANGUP, 0);
.
## diffname port/devnonet.c 1991/0316
## diff -e /n/bootesdump/1991/0209/sys/src/9/port/devnonet.c /n/bootesdump/1991/0316/sys/src/9/port/devnonet.c
279c
errors("channel not announced");
.
## diffname port/devnonet.c 1991/0318
## diff -e /n/bootesdump/1991/0316/sys/src/9/port/devnonet.c /n/bootesdump/1991/0318/sys/src/9/port/devnonet.c
1094a
.
1032c
memmove(pkt->wptr, bp->rptr, n = BLEN(bp));
.
984a
.
979c
memmove(bp->wptr, cp->media->rptr, cp->ifc->hsize + NO_HDRSIZE);
.
## diffname port/devnonet.c 1991/0320
## diff -e /n/bootesdump/1991/0318/sys/src/9/port/devnonet.c /n/bootesdump/1991/0320/sys/src/9/port/devnonet.c
1150c
print("new call on connected channel\n");
.
465a
/*
* wait until a hangup is received.
* then send a hangup message (until one is received).
*
* State Transitions: * -> Cclosed
*/
.
446,451c
.
## diffname port/devnonet.c 1991/0328
## diff -e /n/bootesdump/1991/0320/sys/src/9/port/devnonet.c /n/bootesdump/1991/0328/sys/src/9/port/devnonet.c
1246,1249c
if(f & NO_HANGUP){
.
1164,1166c
if(f & NO_HANGUP)
.
1157a
* A new call request (maybe), treat it as a reset if seen on a
* connected, hungup, or reset channel.
*
* On a connecting channel, treat as a reset if this is an
* invalid message ID.
*/
if(f & NO_NEWCALL){
switch(cp->state){
case Cclosed:
case Copen:
case Cannounced:
case Creset:
panic("nonetrcvmsg %d %d\n", cp->rcvcircuit, cp - cp->ifc->conv);
case Chungup:
case Cconnected:
print("Nonet call on connected/hanging-up circ %d conv %d\n",
cp->rcvcircuit, cp - cp->ifc->conv);
freeb(bp);
noreset(cp);
return;
case Cconnecting:
if(h->mid != mp->mid){
print("Nonet call on connecting circ %d conv %d\n",
cp->rcvcircuit, cp - cp->ifc->conv);
freeb(bp);
noreset(cp);
return;
}
break;
}
}
/*
.
1153a
freeb(bp);
.
1150,1152c
if(f & NO_RESET){
print("reset received\n");
.
1148c
* Obey reset even if the message id is bogus
.
904c
cp->rcvcircuit = -1;
bp = allocb(0);
.
902a
case Chungup:
print("resetting connection\n");
.
892c
* State Transition: {Cconnected, Cconnecting, Chungup} -> Creset
.
888,890c
* Send a hangup signal up the stream to get all line disciplines
* to cease and desist. Disassociate this conversation from a circuit
* number. Any subsequent close of the conversation will
* not send hangup messages.
.
512a
if(cp->media){
freeb(cp->media);
cp->media = 0;
}
.
7a
#include "../port/nonet.h"
.
## diffname port/devnonet.c 1991/0411
## diff -e /n/bootesdump/1991/0328/sys/src/9/port/devnonet.c /n/bootesdump/1991/0411/sys/src/9/port/devnonet.c
363c
nonetwrite(Chan *c, void *a, long n, ulong offset)
.
357c
return stringread(c, a, n, stats, offset);
.
353c
return stringread(c, a, n, cp->ruser, offset);
.
351c
return stringread(c, a, n, cp->addr, offset);
.
349c
return stringread(c, a, n, cp->raddr, offset);
.
328c
nonetread(Chan *c, void *a, long n, ulong offset)
.
## diffname port/devnonet.c 1991/0412
## diff -e /n/bootesdump/1991/0411/sys/src/9/port/devnonet.c /n/bootesdump/1991/0412/sys/src/9/port/devnonet.c
211c
devstat(c, dp, &nonetdir[conf.nnoconv], 1, devgen);
.
## diffname port/devnonet.c 1991/0413
## diff -e /n/bootesdump/1991/0412/sys/src/9/port/devnonet.c /n/bootesdump/1991/0413/sys/src/9/port/devnonet.c
1430c
if(cp->state <= Copen){
.
1428c
if(cp->state<=Copen || !canqlock(cp))
.
682a
cp->afirst = cp->anext = 0;
.
85,91c
Cclosed= 0,
Copen= 1,
Cannounced= 2,
Cconnected= 3,
Cconnecting= 4,
Chungup= 5,
Creset= 6,
.
## diffname port/devnonet.c 1991/0419
## diff -e /n/bootesdump/1991/0413/sys/src/9/port/devnonet.c /n/bootesdump/1991/0419/sys/src/9/port/devnonet.c
204a
Chan*
nonetclwalk(Chan *c, char *name)
{
return devclwalk(c, name);
}
.
## diffname port/devnonet.c 1991/0427
## diff -e /n/bootesdump/1991/0419/sys/src/9/port/devnonet.c /n/bootesdump/1991/0427/sys/src/9/port/devnonet.c
205,210d
## diffname port/devnonet.c 1991/0502
## diff -e /n/bootesdump/1991/0427/sys/src/9/port/devnonet.c /n/bootesdump/1991/0502/sys/src/9/port/devnonet.c
1393c
s &= 0xffff;
switch(s){
case 0xac9f:
case 0xc1a4:
case 0xc41c:
case 0xc46d:
{ int i;
print("%lux s,", s);
for(bp = first; bp; bp = bp->next)
for(i = 0; i < BLEN(bp); i++)
print(" %ux", bp->rptr[i]);
}
}
return s;
.
1357a
Block *first;
.
553c
if(i<0 && Nnomsg+i<Window)
.
551c
if(i>=0 && i<Window)
.
542a
enum {
Window= 1,
};
.
## diffname port/devnonet.c 1991/0503
## diff -e /n/bootesdump/1991/0502/sys/src/9/port/devnonet.c /n/bootesdump/1991/0503/sys/src/9/port/devnonet.c
1398a
if(0)
.
## diffname port/devnonet.c 1991/0604
## diff -e /n/bootesdump/1991/0503/sys/src/9/port/devnonet.c /n/bootesdump/1991/0604/sys/src/9/port/devnonet.c
1463c
} else /**/
.
1460c
/* if(cp->rexmit++ > 15){
.
## diffname port/devnonet.c 1991/0606
## diff -e /n/bootesdump/1991/0604/sys/src/9/port/devnonet.c /n/bootesdump/1991/0606/sys/src/9/port/devnonet.c
1472c
nosendctl(cp, NO_NULL, 0);
.
1207c
if(h->mid!=mp->mid || (f&NO_NULL)){
.
## diffname port/devnonet.c 1991/0608
## diff -e /n/bootesdump/1991/0606/sys/src/9/port/devnonet.c /n/bootesdump/1991/0608/sys/src/9/port/devnonet.c
1472c
nosendctl(cp, /*NO_NULL*/0, 0);
.
1463c
} else
.
1460c
if(cp->rexmit++ > 15){
.
1268a
noqack(cp, h->mid);
.
1194c
DPRINT("Nonet call on connecting circ %d conv %d\n",
.
1187c
DPRINT("Nonet call on connected/hanging-up circ %d conv %d\n",
.
1184c
DPRINT("nonetrcvmsg %d %d\n", cp->rcvcircuit, cp - cp->ifc->conv);
freeb(bp);
return;
.
1165c
DPRINT("reset received\n");
.
915d
## diffname port/devnonet.c 1991/0904
## diff -e /n/bootesdump/1991/0608/sys/src/9/port/devnonet.c /n/bootesdump/1991/0904/sys/src/9/port/devnonet.c
951c
if(mp->first)
freeb(mp->first);
.
## diffname port/devnonet.c 1991/0925
## diff -e /n/bootesdump/1991/0904/sys/src/9/port/devnonet.c /n/bootesdump/1991/0925/sys/src/9/port/devnonet.c
638d
636d
626,634c
if(!waserror()){
nosend(cp, mp);
poperror();
.
## diffname port/devnonet.c 1991/0926
## diff -e /n/bootesdump/1991/0925/sys/src/9/port/devnonet.c /n/bootesdump/1991/0926/sys/src/9/port/devnonet.c
1473,1474d
1471c
tsleep(&nonetkr, return0, 0, MSrexmit/2);
.
1461,1469c
unlock(ifc);
.
1453,1459c
ep = ifc->conv + conf.nnoconv;
for(cp = ifc->conv; cp < ep; cp++){
if(cp->state<=Copen || !canqlock(cp))
continue;
if(cp->state <= Copen){
qunlock(cp);
continue;
}
/*
* resend the first message
*/
if(cp->first!=cp->next && NOW>=cp->out[cp->first].time){
mp = &(cp->out[cp->first]);
if(cp->rexmit++ > 15){
norack(cp, mp->mid);
noreset(cp);
} else
nosend(cp, mp);
}
/*
* get the acknowledges out
*/
while(cp->afirst!=cp->anext && cp->rq->next->len<16*1024){
DPRINT("sending ack %d\n", cp->ack[cp->afirst]);
nosendctl(cp, /*NO_NULL*/0, 0);
}
qunlock(cp);
.
1451c
* loop through all active conversations
.
1445,1449c
.
1441,1443c
for(ifc = noifc; ifc < &noifc[conf.nnoifc]; ifc++){
if(ifc->wq==0 || !canlock(ifc))
.
1439c
* loop through all active interfaces
.
1430,1437c
for(;;){
.
616,620d
610,612c
mp->first = first;
mp->last = last;
mp->len = len;
.
592,594c
freeb(first);
.
588a
* take the collected message out of the queue
*/
first = q->first;
last = q->last;
len = q->len;
q->len = q->nb = 0;
q->first = q->last = 0;
if(len == 0){
freeb(first);
qunlock(&cp->mlock);
return;
}
/*
.
567c
Block *first, *last;
int len;
.
## diffname port/devnonet.c 1991/1101
## diff -e /n/bootesdump/1991/0926/sys/src/9/port/devnonet.c /n/bootesdump/1991/1101/sys/src/9/port/devnonet.c
1473,1474c
if(cp->sendack){
DPRINT("sending ack %d\n", cp->ack);
.
1271d
1031,1034c
cp->sendack = 0;
cp->hdr->ack = cp->ack;
.
975,981c
cp->ack = mid;
cp->sendack = 1;
.
687c
cp->ack = 0;
cp->sendack = 0;
.
22d
## diffname port/devnonet.c 1991/1105
## diff -e /n/bootesdump/1991/1101/sys/src/9/port/devnonet.c /n/bootesdump/1991/1105/sys/src/9/port/devnonet.c
760c
sprint(buf, "%s %s", service, u->p->user);
.
## diffname port/devnonet.c 1991/1112
## diff -e /n/bootesdump/1991/1105/sys/src/9/port/devnonet.c /n/bootesdump/1991/1112/sys/src/9/port/devnonet.c
1471c
nonetfreeifc(ifc);
.
1436a
lock(ifc);
if(ifc->wq==0){
unlock(ifc);
continue;
}
ifc->ref++;
unlock(ifc);
.
1435c
if(ifc->wq==0)
.
140c
nonetdir[i].perm = 0666;
.
130c
nonetdir[i].perm = 0777;
.
73,77c
"addr", {Naddrqid}, 0, 0666,
"listen", {Nlistenqid}, 0, 0666,
"raddr", {Nraddrqid}, 0, 0666,
"ruser", {Nruserqid}, 0, 0666,
"stats", {Nstatsqid}, 0, 0666,
.
## diffname port/devnonet.c 1991/1114
## diff -e /n/bootesdump/1991/1112/sys/src/9/port/devnonet.c /n/bootesdump/1991/1114/sys/src/9/port/devnonet.c
1480c
tsleep(&nonetkr, return0, 0, MSrexmit);
.
## diffname port/devnonet.c 1991/1115
## diff -e /n/bootesdump/1991/1114/sys/src/9/port/devnonet.c /n/bootesdump/1991/1115/sys/src/9/port/devnonet.c
1420a
USED(arg);
.
409a
USED(c, dp);
.
403a
USED(c);
.
356c
return stringread(a, n, stats, offset);
.
352c
return stringread(a, n, cp->ruser, offset);
.
350c
return stringread(a, n, cp->addr, offset);
.
348c
return stringread(a, n, cp->raddr, offset);
.
305a
USED(c, name, omode, perm);
.
## diffname port/devnonet.c 1991/1121
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/devnonet.c /n/bootesdump/1991/1121/sys/src/9/port/devnonet.c
1456c
if(cp->state != Cconnected && cp->state != Cconnecting){
.
1295c
return 0;
}
.
1293c
return r;
} else {
.
1291a
return -1;
.
1270a
r = mp->len;
.
1241c
return -1;
.
1219c
return -1;
.
1191,1197d
1189c
return -1;
.
1182c
return -1;
.
1164c
return -1;
.
1135c
int
.
849,868c
switch(nonetrcvmsg(cp, bp)){
case -1:
print("bad call message");
streamclose(c);
continue;
case 0:
if(f & NO_SERVICE){
streamclose(c);
print("bad call message");
continue;
}
break;
default:
if(f & NO_SERVICE){
c->qid.path = STREAMQID(cp - ifc->conv, Sdataqid);
n = streamread(c, buf, sizeof(buf));
c->qid.path = STREAMQID(cp - ifc->conv, Sctlqid);
if(n <= 0)
error(Ebadctl);
buf[n] = 0;
user = strchr(buf, ' ');
if(user){
*user++ = 0;
strncpy(cp->ruser, user, NAMELEN);
} else
strcpy(cp->ruser, "none");
strncpy(cp->addr, buf, NAMELEN);
}
break;
.
846,847c
bp = call.msg;
.
844d
793a
Block *bp;
.
521,522d
511a
qlock(cp);
.
508d
504,505c
switch(cp->state){
case Cconnecting:
case Cconnected:
/*
* send close till we get one back
*/
nosendctl(cp, NO_HANGUP, 1);
for(i=0; i<10 && !ishungup(cp); i++){
nosendctl(cp, NO_HANGUP, 0);
tsleep(&cp->r, ishungup, cp, MSrexmit);
}
break;
case Chungup:
/*
* ack any close
*/
nosendctl(cp, NO_HANGUP, 1);
break;
}
poperror();
.
502c
* send hangup messages to the other side
* until it hangs up or we get tired.
.
494,500c
while(!isempty(cp))
tsleep(&cp->r, isempty, cp, MSrexmit);
.
492c
* wait till we have nothing to transmit
.
479,490c
if(!waserror()){
.
464,469c
static int
isempty(void *a)
{
Noconv *cp;
cp = (Noconv *)a;
switch(cp->state){
case Cconnecting:
case Cconnected:
return cp->first == cp->next;
default:
return 1;
}
}
.
449c
/*
* wait until a hangup is received.
* then send a hangup message (until one is received).
*
* State Transitions: * -> Cclosed
*/
.
315,318c
if(c->stream)
.
## diffname port/devnonet.c 1992/0111
## diff -e /n/bootesdump/1991/1121/sys/src/9/port/devnonet.c /n/bootesdump/1992/0111/sys/src/9/port/devnonet.c
7c
#include "../port/error.h"
.
## diffname port/devnonet.c 1992/0113
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/devnonet.c /n/bootesdump/1992/0113/sys/src/9/port/devnonet.c
279c
error(Enolisten);
.
241c
error(Enodev);
.
## diffname port/devnonet.c 1992/0129
## diff -e /n/bootesdump/1992/0113/sys/src/9/port/devnonet.c /n/bootesdump/1992/0129/sys/src/9/port/devnonet.c
379c
if(n > sizeof buf - 1)
n = sizeof buf - 1;
strncpy(buf, a, n);
buf[n] = '\0';
.
## diffname port/devnonet.c 1992/0219 # deleted
## diff -e /n/bootesdump/1992/0129/sys/src/9/port/devnonet.c /n/bootesdump/1992/0219/sys/src/9/port/devnonet.c
1,1513d
|
