## diffname port/devdk.c 1990/0312
## diff -e /dev/null /n/bootesdump/1990/0312/sys/src/9/mips/devdk.c
0a
#include	"u.h"
#include	"lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"errno.h"

#define NOW (MACHP(0)->ticks)
#define DPRINT if(0)

enum {
	/*
	 *  configuration parameters
	 */
	Ndk = 2,		/* max dks */

	/*
	 *  relative or immutable
	 */
	Nline = 256,		/* max lines per dk */
	Ndir = Nline + 1,	/* entries in the dk directory */
	Nsubdir = 5,		/* entries in the sub directory */
};

typedef struct Dkmsg	Dkmsg;
typedef struct Line	Line;
typedef struct Dk	Dk;

/*
 *  types of possible dkcalls
 */
enum {
	Dial,
	Announce,
	Redial
};

/*
 *  format of messages to/from the datakit controller on the common
 *  signalling line
 */
struct Dkmsg {
	uchar	type;
	uchar	srv;
	uchar	param0l;
	uchar	param0h;
	uchar	param1l;
	uchar	param1h;
	uchar	param2l;
	uchar	param2h;
	uchar	param3l;
	uchar	param3h;
	uchar	param4l;
	uchar	param4h;
};

/*
 *  message codes (T_xxx == dialin.type, D_xxx == dialin.srv)
 */
#define	T_SRV	1		/* service request */
#define   D_SERV	1		/* (host to dkmux) announce a service */
#define   D_DIAL	2		/* (host to dkmux) connect to a service */
#define   D_XINIT	7		/* (dkmux to host) line has been spliced */
#define	T_REPLY	2		/* reply to T_SRV/D_SERV or T_SRV/D_DIAL */
#define	  D_OK		1		/* not used */
#define	  D_OPEN	2		/* (dkmux to host) connection established */
#define	  D_FAIL	3		/* (dkmux to host) connection failed */
#define	T_CHG	3		/* linege the status of a connection */
#define	  D_CLOSE	1		/* close the connection */
#define	  D_ISCLOSED	2		/* (dkmux to host) confirm a close */
#define	  D_CLOSEALL	3		/* (dkmux to host) close all connections */
#define	  D_REDIAL	6		/* (host to dkmux) redial a call */
#define	T_ALIVE	4		/* (host to dkmux) keep alive message */
#define	  D_CONTINUE	0		/* host has not died since last msg */
#define	  D_RESTART	1		/* host has restarted */
#define   D_MAXCHAN	2		/* request maximum line number */
#define	T_RESTART 8		/* (dkmux to host) datakit restarted */

/*
 *  macros for cracking/forming the window negotiation parameter
 */
#define MIN(x,y)  (x < y ? x : y)
#define W_WINDOW(o,d,t)  ((o<<8) | (d<<4) | t | 0100000)
#define W_VALID(x)  ((x) & 0100000)
#define W_ORIG(x)  (((x)>>8) & 017)
#define W_DEST(x)  (((x)>>4) & 017)
#define W_TRAF(x)  ((x) & 017)
#define W_DESTMAX(x,y)  (W_WINDOW(W_ORIG(x),MIN(W_DEST(x),y),W_TRAF(x)))
#define W_LIMIT(x,y)  (W_WINDOW(MIN(W_ORIG(x),y),MIN(W_DEST(x),y),W_TRAF(x)))
#define	W_VALUE(x)	(1<<((x)+4))
#define WS_2K	7

/*
 *  one per datakit line
 */
struct Line {
	QLock;
	Rendez	r;		/* wait here for dial */
	int	state;		/* dial state */
	int	err;		/* dialing error (if non zero) */
	int	window;		/* negotiated window */
	int	timestamp;	/* timestamp of last call received on this line */
	int	calltolive;	/* multiple of 15 seconds for dialing state to last */
	Queue	*rq;
	char	addr[64];
	char	raddr[64];
	char	ruser[32];
	char	other[64];
	Dk *dp;			/* interface contianing this line */
};

/*
 *  a dkmux dk.  one exists for every stream that a 
 *  dkmux line disilpline is pushed onto.
 */
struct Dk {
	QLock;
	int	ref;
	char	name[64];	/* dk name */	
	Queue	*wq;		/* dk output queue */
	int	lines;		/* number of lines */
	int	ncsc;		/* csc line number */
	Chan	*csc;		/* common signalling line */
	Line	line[Nline];
};
static Dk dk[Ndk];

/*
 *  conversation states (for Line.state)
 */
typedef enum {
	Lclosed=0,
	Lopened,		/* opened but no call out */
	Lconnected,		/* opened and a call set up on htis line */
	Lrclose,		/* remote end has closed down */
	Llclose,		/* local end has closed down */
	Ldialing,		/* dialing a new call */
	Llistening,		/* this line listening for calls */
	Lackwait,		/* incoming call waiting for ack/nak */
	Laccepting,		/* waiting for user to accept or reject the call */
} Lstate;

/*
 *  datakit error to errno 
 */
enum {
	DKok,
	DKbusy,
	DKnetotl,
	DKdestotl,
	DKbadnet,
	DKnetbusy,
	DKinuse,
	DKreject,
};
int dkerr[]={
	[DKok]Egreg,
	[DKbusy]Einuse,		/* destination busy */
	[DKnetotl]Enetotl,	/* network not answering */
	[DKdestotl]Edestotl,	/* destination not answering */ 
	[DKbadnet]Ebadnet,	/* unassigned destination */
	[DKnetbusy]Enetbusy,	/* network overload */
	[DKinuse]Einuse,	/* server already exists */
	[DKreject]Erejected	/* call rejected by destination */
};
#define DKERRS sizeof(dkerr)/sizeof(int)

/*
 *  imported
 */
extern Qinfo urpinfo;

/*
 *  predeclared
 */
Chan*		dkattach(char*);
static void	dkmuxconfig(Dk*, Block*);
static int	dkmesg(Dk*, int, int, int, int);
static void	dkcsckproc(void*);
static int	dklisten(Chan*);
static void	dkanswer(Chan*, int, int);
static void	dkwindow(Chan*);
static void	dkcall(int, Chan*, char*, char*, char*);
static void	dktimer(void*);
static void	dkchgmesg(Dk*, Dkmsg*, int);
static void	dkreplymesg(Dk*, Dkmsg*, int);
Chan*		dkopen(Chan*, int);

/*
 *  the datakit multiplexor stream module definition
 */
static void dkmuxopen(Queue *, Stream *);
static void dkmuxclose(Queue *);
static void dkmuxoput(Queue *, Block *);
static void dkmuxiput(Queue *, Block *);
Qinfo dkmuxinfo = { dkmuxiput, dkmuxoput, dkmuxopen, dkmuxclose, "dkmux" };

/*
 *  a new dkmux.  find a free dk structure and assign it to this queue.
 */
static void
dkmuxopen(Queue *q, Stream *s)
{
	Dk *dp;
	int i;

	for(dp = dk; dp < &dk[Ndk]; dp++){
		if(dp->wq == 0){
			qlock(dp);
			if(dp->wq) {
				/* someone was faster than us */
				qunlock(dp);
				continue;
			}
			q->ptr = q->other->ptr = (void *)dp;
			dp->csc = 0;
			dp->ncsc = 4;
			dp->lines = 16;
			dp->name[0] = 0;
			dp->wq = WR(q);
			qunlock(dp);
			return;
		}
	}
	error(0, Enoifc);
}

/*
 *  close down a dkmux
 */
static void
dkmuxclose(Queue *q)
{
	Dk *dp;

	dp = (Dk *)q->ptr;
	qlock(dp);
	if(dp->csc)
		close(dp->csc);
	dp->wq = 0;
	qunlock(dp);
}

/*
 *  handle configuration
 */
static void
dkmuxoput(Queue *q, Block *bp)
{
	Dk *dp;

	dp = (Dk *)q->ptr;
	if(bp->type != M_DATA){
		if(streamparse("config", bp))
			dkmuxconfig(dp, bp);
		else
			PUTNEXT(q, bp);
		return;
	}
	PUTNEXT(q, bp);
}

/*
 *  gather a message and send it up the appropriate stream
 *
 *  The first two bytes of each message contains the channel
 *  number, low order byte first.
 *
 *  Simplifying assumption:  one put == one message && the channel number
 *	is in the first block.  If this isn't true, demultiplexing will not
  *	work.
 */
static void
dkmuxiput(Queue *q, Block *bp)
{
	Dk *dp;
	Line *lp;
	int line;

	dp = (Dk *)q->ptr;
	if(bp->type != M_DATA){
		PUTNEXT(q, bp);
		return;
	}

	line = *bp->rptr++ | (*bp->rptr++<<8);
	if(line<0 || line>=dp->lines){
		print("dkmuxiput bad line %d\n", line);
		freeb(bp);
		return;
	}

	lp = &dp->line[line];
	if(canqlock(lp)){
		if(lp->rq)
			PUTNEXT(lp->rq, bp);
		else{
			print("dkmuxiput unopened line %d\n", line);
			freeb(bp);
		}
		qunlock(lp);
	} else {
		print("dkmuxiput unopened line %d\n", line);
		freeb(bp);
	}
}

/*
 *  the datakit line stream module definition
 */
static void dkstopen(Queue *, Stream *);
static void dkstclose(Queue *);
static void dkoput(Queue *, Block *);
static void dkiput(Queue *, Block *);
Qinfo dkinfo = { dkiput, dkoput, dkstopen, dkstclose, "dk" };

/*
 *  open and save a pointer to the conversation
 */
static void
dkstopen(Queue *q, Stream *s)
{
	Dk *dp;
	Line *lp;

	dp = &dk[s->dev];
	q->other->ptr = q->ptr = lp = &dp->line[s->id];
	lp->dp = dp;
	lp->rq = q;
}

/*
 *  close down a datakit conversation
 */
static void
dkstclose(Queue *q)
{
	Dk *dp;
	Line *lp;

	lp = (Line *)q->ptr;
	dp = lp->dp;

	/*
	 *  shake hands with dk
	 */
	switch(lp->state){
	case Lclosed:
	case Llclose:
		break;

	case Lrclose:
		dkmesg(dp, T_CHG, D_CLOSE, lp - dp->line, 0);
		lp->state = Lclosed;
		break;

	case Lackwait:
		dkmesg(dp, T_CHG, D_CLOSE, lp - dp->line, 0);
		lp->state = Llclose;
		break;

	case Llistening:
		dkmesg(dp, T_CHG, D_CLOSE, lp - dp->line, 0);
		lp->state = Llclose;
		break;

	case Lconnected:
		dkmesg(dp, T_CHG, D_CLOSE, lp - dp->line, 0);
		lp->state = Llclose;
		break;

	case Lopened:
		lp->state = Lclosed;
	}

	qlock(lp);
	lp->rq = 0;
	qunlock(lp);
}

/*
 *  this is only called by hangup
 */
static void
dkiput(Queue *q, Block *bp)
{
	PUTNEXT(q, bp);
}

/*
 *  we assume that each put is a message.
 *
 *  add a 2 byte channel number to the start of each message
 */
static void
dkoput(Queue *q, Block *bp)
{
	Line *lp;
	Dk *dp;
	int line;

	if(bp->type != M_DATA){
		freeb(bp);
		error(0, Ebadarg);
	}

	lp = (Line *)q->ptr;
	dp = lp->dp;
	line = lp - dp->line;

	if(bp->base && bp->rptr - bp->base >= 2)
		bp->rptr -= 2;
	bp->rptr[0] = line;
	bp->rptr[1] = line>>8;

	PUTNEXT(dp->wq, bp);
}

/*
 *  configure a datakit multiplexor.  this takes 3 arguments separated
 *  by spaces:
 *	the line number of the common signalling channel (must be > 0)
 *	the number of lines in the device (optional)
 *	the name of the dk (optional)
 *
 *  we can configure only once
 */
static void
dkmuxconfig(Dk *dp, Block *bp)
{
	Chan *c;
	char *fields[3];
	int n;
	char buf[64];
	static int dktimeron;

	if(dp->csc != 0){
		freeb(bp);
		error(0, Ebadarg);
	}

	/*
	 *  parse
	 */
	n = getfields((char *)bp->rptr, fields, 3, ' ');
	switch(n){
	case 3:
		strncpy(dp->name, fields[2], sizeof(dp->name));
	case 2:
		dp->lines = strtoul(fields[1], 0, 0);
	case 1:
		dp->ncsc = strtoul(fields[0], 0, 0);
		break;
	default:
		freeb(bp);
		error(0, Ebadarg);
	}
	freeb(bp);
	if(dp->ncsc <= 0 || dp->lines <= dp->ncsc){
		dp->lines = 16;
		error(0, Ebadarg);
	}

	/*
	 *  open a stream for the csc and push urp onto it
	 */
	c = 0;
	if(waserror()){
		if(c)
			close(c);
		nexterror();
	}
	c = dkattach(dp->name);
	c->qid = STREAMQID(dp->ncsc, Sdataqid);
	dkopen(c, ORDWR);
	dp->csc = c;

	/*
	 *  start a process to deal with it
	 */
	sprint(buf, "**csckproc%d**", dp->ncsc);
	kproc(buf, dkcsckproc, dp);
	poperror();

	/*
	 *  start a keepalive process if one doesn't exist
	 */
	if(dktimeron == 0){
		dktimeron = 1;
		kproc("**dktimer**", dktimer, 0);
	}
}

/*
 *  qid's
 */
enum {
	/*
	 *  per line
	 */
	Daddrqid,
	Dlistenqid,
	Draddrqid,
	Duserqid,
	Dotherqid,
	Dlineqid,

	/*
	 *  per device
	 */
	Dcloneqid,
};

/*
 *  the dk directory
 */
Dirtab dkdir[Ndir];

/*
 *  the per stream directory structure
 */
Dirtab dksubdir[]={
	"addr",		Daddrqid,	0,	0600,
	"listen",	Dlistenqid,	0,	0600,
	"other",	Dotherqid,	0,	0600,
	"raddr",	Draddrqid,	0, 	0600,
	"ruser",	Duserqid,	0, 	0600,
};

/*
 *  dk file system.  most of the calls use dev.c to access the dk
 *  directory and stream.c to access the dk devices.
 */
void
dkreset(void)
{
}

/*
 *  create the dk directory.  the files are `clone' and stream
 *  directories '1' to '32' (or whatever Nline is in decimal)
 */
void
dkinit(void)
{
	int i;

	/*
	 *  create the directory.
	 */
	/*
	 *  the circuits
	 */
	for(i = 1; i < Nline; i++) {
		sprint(dkdir[i].name, "%d", i);
		dkdir[i].qid = CHDIR|STREAMQID(i, Dlineqid);
		dkdir[i].length = 0;
		dkdir[i].perm = 0600;
	}

	/*
	 *  the clone device
	 */
	strcpy(dkdir[0].name, "clone");
	dkdir[0].qid = Dcloneqid;
	dkdir[0].length = 0;
	dkdir[0].perm = 0600;
}

Chan*
dkattach(char *spec)
{
	Chan *c;
	Dk *dp;

	/*
	 *  find a multiplexor with the same name
	 */
	for(dp = dk; dp < &dk[Ndk]; dp++){
		qlock(dp);
		if(dp->wq && strcmp(spec, dp->name)==0) {
			dp->ref++;
			qunlock(dp);
			break;
		}
		qunlock(dp);
	}
	if(dp == &dk[Ndk])
		error(0, Enoifc);
	c = devattach('k', spec);
	c->dev = dp - dk;

	return c;
}

Chan*
dkclone(Chan *c, Chan *nc)
{
	Dk *dp;

	dp = &dk[c->dev];
	qlock(dp);
	dp->ref++;
	qunlock(dp);
	return devclone(c, nc);
}

int	 
dkwalk(Chan *c, char *name)
{
	if(c->qid == CHDIR)
		return devwalk(c, name, dkdir, dk[c->dev].lines, devgen);
	else
		return devwalk(c, name, dksubdir, Nsubdir, streamgen);
}

void	 
dkstat(Chan *c, char *dp)
{
	if(c->qid == CHDIR)
		devstat(c, dp, dkdir, dk[c->dev].lines, devgen);
	else
		devstat(c, dp, dksubdir, Nsubdir, streamgen);
}

/*
 *  opening a dk device allocates a Line.  Opening the `clone'
 *  device is a ``macro'' for finding a free Line and opening
 *  it's ctl file.
 *
 *  opening the `listen' sub device is a macro for listening for
 *  a new call.  Lile `clone' the ctl file of the new channel is
 *  returned.
 */
Chan*
dkopen(Chan *c, int omode)
{
	extern Qinfo dkinfo;
	Stream *s;
	Line *lp, *end;
	Dk *dp;
	int line;

	if(c->qid == Dcloneqid){
		/*
		 *  get an unused device and open it's control file
		 */
		dp = &dk[c->dev];
		end = &dp->line[dp->lines];
		for(lp = &dp->line[dp->ncsc+1]; lp < end; lp++){
			if(lp->state == Lclosed && canqlock(lp)){
				if(lp->state != Lclosed){
					qunlock(lp);
					continue;
				}
				c->qid = STREAMQID(lp-dp->line, Sctlqid);
				qunlock(lp);
				break;
			}
		}
		if(lp == end)
			error(0, Enodev);
		streamopen(c, &dkinfo);
		pushq(c->stream, &urpinfo);
	} else if(STREAMTYPE(c->qid) == Dlistenqid){
		/*
		 *  listen for a call and open the control file for the
		 *  channel on which the call arrived.
		 */
		line = dklisten(c);
		c->qid = STREAMQID(line, Sctlqid);
		streamopen(c, &dkinfo);
		pushq(c->stream, &urpinfo);
		dkwindow(c);
	} else if(c->qid != CHDIR){
		/*
		 *  open whatever c points to, make sure it has an urp
		 */
		streamopen(c, &dkinfo);
		if(strcmp(c->stream->procq->next->info->name, "urp")!=0)
			pushq(c->stream, &urpinfo);
	}

	c->mode = openmode(omode);
	c->flag |= COPEN;
	c->offset = 0;
	return c;
}

void	 
dkcreate(Chan *c, char *name, int omode, ulong perm)
{
	error(0, Eperm);
}

void	 
dkclose(Chan *c)
{
	Dk *dp;

	/* real closing happens in lancestclose */
	if(c->qid != CHDIR)
		streamclose(c);

	dp = &dk[c->dev];
	qlock(dp);
	dp->ref--;
	qunlock(dp);
}

long	 
dkread(Chan *c, void *a, long n)
{
	int t;
	Line *lp;

	t = STREAMTYPE(c->qid);
	if(t>=Slowqid || t==Dlineqid)
		return streamread(c, a, n);
	if(c->qid == CHDIR)
		return devdirread(c, a, n, dkdir, dk[c->dev].lines, devgen);

	lp = &dk[c->dev].line[STREAMID(c->qid)];
	switch(t){
	case Daddrqid:
		return stringread(c, a, n, lp->addr);
	case Draddrqid:
		return stringread(c, a, n, lp->raddr);
	case Duserqid:
		return stringread(c, a, n, lp->ruser);
	}
	error(0, Eperm);
}

long	 
dkwrite(Chan *c, void *a, long n)
{
	int t;
	char buf[256];
	char *field[5];
	int m;

	t = STREAMTYPE(c->qid);

	/*
	 *  get data dispatched as quickly as possible
	 */
	if(t == Sdataqid)
		return streamwrite(c, a, n, 0);

	/*
	 *  easier to do here than in dkoput
	 */
	if(t == Sctlqid){
		strncpy(buf, a, sizeof buf);
		m = getfields(buf, field, 5, ' ');
		if(strcmp(field[0], "connect")==0){
			if(m < 2)
				error(0, Ebadarg);
			dkcall(Dial, c, field[1], 0, 0);
		} else if(strcmp(field[0], "announce")==0){
			if(m < 2)
				error(0, Ebadarg);
			dkcall(Announce, c, field[1], 0, 0);
		} else if(strcmp(field[0], "redial")==0){
			if(m < 4)
				error(0, Ebadarg);
			dkcall(Redial, c, field[1], field[2], field[3]);
		} else if(strcmp(field[0], "accept")==0){
			if(m < 2)
				error(0, Ebadarg);
			dkanswer(c, strtoul(field[1], 0, 0), 0);
		} else if(strcmp(field[0], "reject")==0){
			if(m < 3)
				error(0, Ebadarg);
			dkanswer(c, strtoul(field[1], 0, 0), strtoul(field[2], 0, 0));
		} else
			return streamwrite(c, a, n, 0);
		return n;
	}

	if(t >= Slowqid)
		return streamwrite(c, a, n, 0);

	error(0, Eperm);
}

void	 
dkremove(Chan *c)
{
	error(0, Eperm);
}

void	 
dkwstat(Chan *c, char *dp)
{
	error(0, Eperm);
}

void	 
dkerrstr(Error *e, char *buf)
{
	rooterrstr(e, buf);
}

void	 
dkuserstr(Error *e, char *buf)
{
	extern consuserstr(Error *, char *);

	consuserstr(e, buf);
}

/*
 *  send a message to the datakit on the common signaling line
 */
static int
dkmesg(Dk *dp, int type, int srv, int p0, int p1)
{
	Dkmsg d;
	Block *bp;

	if(dp->csc == 0)
		return -1;
	if(waserror())
		return -1;
	d.type = type;
	d.srv = srv;
	d.param0l = p0;
	d.param0h = p0>>8;
	d.param1l = p1;
	d.param1h = p1>>8;
	d.param2l = 0;
	d.param2h = 0;
	d.param3l = 0;
	d.param3h = 0;
	d.param4l = 0;
	d.param4h = 0;
	streamwrite(dp->csc, (char *)&d, sizeof(Dkmsg), 1);
	poperror();
	return 0;
}

/*
 *  call out on a datakit
 */
static int
calldone(void *a)
{
	Line *lp;

	lp = (Line *)a;
	return lp->state != Ldialing;
}
static void
dkcall(int type, Chan *c, char *addr, char *nuser, char *machine)
{
 	char dialstr[66];
	int line;
	char dialtone;
	int t_val, d_val;
	Dk *dp;
	Line *lp;
	Chan *dc;

	line = STREAMID(c->qid);
	dp = &dk[c->dev];
	lp = &dp->line[line];

	/*
	 *  only dial on virgin lines
	 */
	if(lp->state != Lclosed)
		error(0, Ebadarg);

	DPRINT("dkcall(line=%d, type=%d, dest=%s)\n", line, type, addr);

	/*
	 *  build dial string (guard against new lines)
	 */
	if(strchr(addr, '\n'))
		error(0, Ebadarg);
	if(strlen(addr)+strlen(u->p->pgrp->user)+2 >= sizeof(dialstr))
		error(0, Ebadarg);
	strcpy(dialstr, addr);
	switch(type){
	case Dial:
		t_val = T_SRV;
		d_val = D_DIAL;
		strcat(dialstr, "\n");
		strcat(dialstr, u->p->pgrp->user);
		strcat(dialstr, "\n");
		break;
	case Announce:
		t_val = T_SRV;
		d_val = D_SERV;
		break;
	case Redial:
		t_val = T_CHG;
		d_val = D_REDIAL;
		strcat(dialstr, "\n");
		strcat(dialstr, nuser);
		strcat(dialstr, "\n");
		strcat(dialstr, machine);
		strcat(dialstr, "\n");
		break;
	}

	/*
	 *  open the data file
	 */
	dc = dkattach(dp->name);
	if(waserror()){
		close(dc);
		nexterror();
	}
	dc->qid = STREAMQID(line, Sdataqid);
	dkopen(dc, ORDWR);

	lp->calltolive = 4;
	lp->state = Ldialing;

	/*
	 *  tell the controller we want to make a call
	 */
	DPRINT("dialout\n");
	dkmesg(dp, t_val, d_val, line, W_WINDOW(WS_2K,WS_2K,2));

	/*
	 *  if redial, wait for a dial tone (otherwise we might send
	 *  the dialstr to the previous other end and not the controller)
	 */
	if(type==Redial){
		if(streamread(dc, &dialtone, 1L) != 1L){
			lp->state = Lconnected;
			error(0, Ebadarg);
		}
	}

	/*
	 *  make the call
	 */
	DPRINT("dialstr %s\n", dialstr);
	streamwrite(dc, dialstr, (long)strlen(dialstr), 1);
	close(dc);
	poperror();

	/*
	 *  redial's never get a reply, assume it worked
	 */
	if(type == Redial) {
		lp->state = Lconnected;
		return;
	}

	/*
	 *  wait for a reply
	 */
	DPRINT("reply wait\n");
	sleep(&lp->r, calldone, lp);

	/*
	 *  if there was an error, translate it to a plan 9
	 *  errno and report it to the user.
	 */
	DPRINT("got reply %d\n", lp->state);
	if(lp->state != Lconnected) {
		if(lp->err >= DKERRS)
			error(0, dkerr[0]);
		else
			error(0, dkerr[lp->err]);
	}

	/*
	 *  linege state if serving
	 */
	if(type == D_SERV){
		lp->state = Llistening;
	}
	DPRINT("connected!\n");

	/*
	 *  decode the window size
	 */
	if (W_VALID(lp->window)){
		/*
		 *  a 1127 window negotiation
		 */
		lp->window = W_VALUE(W_DEST(lp->window));
	} else if(lp->window>2 && lp->window<31){
		/*
		 *  a generic window negotiation
		 */
		lp->window = 1<<lp->window;
	} else
		lp->window = 0;

	/*
	 *  tag the connection
	 */
	strncpy(lp->addr, addr, sizeof(lp->addr)-1);
	strncpy(lp->raddr, addr, sizeof(lp->raddr)-1);

	/*
	 *  reset the protocol
	 */
	dkwindow(c);
}

/*
 *  listen for a call, reflavor the 
 */
static int
dklisten(Chan *c)
{
	char dialstr[512];
	char *line[12];
	char *field[8];
	Line *lp;
	Dk *dp;
	int n, lineno, ts, window;
	Chan *dc;

	dp = &dk[c->dev];

	/*
	 *  open the data file
	 */
	dc = dkattach(dp->name);
	if(waserror()){
		close(dc);
		nexterror();
	}
	dc->qid = STREAMQID(STREAMID(c->qid), Sdataqid);
	dkopen(dc, ORDWR);

	/*
	 *  wait for a call in
	 */
	for(;;){
		/*
		 *  read the dialstring and null terminate it
		 */
		n = streamread(dc, dialstr, sizeof(dialstr)-1);
		DPRINT("returns %d\n", n);
		if(n <= 0)
			error(0, Eio);
		dialstr[n] = 0;
		DPRINT("dialstr = %s\n", dialstr);

		/*
		 *  break the dial string into lines
		 */
		n = getfields(dialstr, line, 12, '\n');
		if (n < 2) {
			DPRINT("bad dialstr from dk (1 line)\n");
			error(0, Eio);
		}

		/*
		 * line 0 is `line.tstamp.traffic[.urpparms.window]'
		 */
		window = 0;
		switch(getfields(line[0], field, 5, '.')){
		case 5:
			/*
			 *  generic way of passing window
			 */
			window = strtoul(field[4], 0, 0);
			if(window > 0 && window <31)
				window = 1<<window;
			else
				window = 0;
			/*
			 *  intentional fall through
			 */
		case 3:
			/*
			 *  1127 way of passing window
			 */
			if(window == 0){
				window = strtoul(field[2], 0, 0);
				if(W_VALID(window))
					window = W_VALUE(W_ORIG(window));
				else
					window = 0;
			}
			break;
		default:
			print("bad message from dk(bad first line)\n");
			continue;
		}
		lineno = strtoul(field[0], 0, 0);
		if(lineno >= dp->lines){
			print("dklisten: illegal line %d\n", lineno);
			continue;
		}
		lp = &dp->line[lineno];
		ts = strtoul(field[1], 0, 0);

		/*
		 *  this could be a duplicate request
		 */
		if(ts == lp->timestamp){
			print("dklisten: repeat timestamp %d\n", lineno);
			continue;
		}
	
		/*
		 *  take care of glare (datakit picked an inuse channel
		 *  for the call to come in on).
		 */
		if(!canqlock(lp)){
			print("DKbusy1\n");
			dkanswer(c, lineno, DKbusy);
			continue;
		} else {
			if(lp->state != Lclosed){
				qunlock(lp);
				print("DKbusy2 %ux\n", lp->state);
				dkanswer(c, lineno, DKbusy);
				continue;
			}
		}
		lp->window = window;

		/*
		 *  Line 1 is `my-dk-name.service[.more-things]'.
		 *  Special characters are escaped by '\'s.
		 */
		strncpy(lp->addr, line[1], sizeof(lp->addr)-1);
	
		/*
		 *  the rest is variable length
		 */
		switch(n) {
		case 2:
			/* no more lines */
			lp->ruser[0] = 0;
			lp->raddr[0] = 0;
			break;
		case 3:
			/* line 2 is `source.user.param1.param2' */
			getfields(line[2], field, 3, '.');
			strncpy(lp->raddr, field[0], sizeof(lp->raddr)-1);
			strncpy(lp->ruser, field[1], sizeof(lp->ruser)-1);
			break;
		case 4:
			/* line 2 is `user.param1.param2' */
			getfields(line[2], field, 2, '.');
			strncpy(lp->ruser, field[0], sizeof(lp->ruser)-1);
	
			/* line 3 is `source.node.mod.line' */
			strncpy(lp->raddr, line[3], sizeof(lp->raddr)-1);
			break;
		default:
			print("bad message from dk(>4 line)\n");
			qunlock(lp);
			error(0, Ebadarg);
		}

		sprint(lp->other, "w(%d)", W_TRAF(lp->window));
		DPRINT("src(%s)user(%s)dest(%s)other(%s)\n", lp->raddr, lp->ruser,
			lp->addr, lp->other);

		lp->timestamp = ts;
		lp->state = Lconnected;
		qunlock(lp);
		close(dc);
		poperror();
		DPRINT("dklisten returns %d\n", lineno);
		return lineno;
	}
}

/*
 *  answer a call
 */
static void
dkanswer(Chan *c, int line, int code)
{
	char reply[64];
	Dk *dp;
	Chan *dc;
	Line *lp;

	dp = &dk[c->dev];
	lp = &dp->line[line];

	/*
	 *  open the data file (c is a control file)
	 */
	dc = dkattach(dp->name);
	if(waserror()){
		close(dc);
		nexterror();
	}
	dc->qid = STREAMQID(STREAMID(c->qid), Sdataqid);
	dkopen(dc, ORDWR);

	/*
	 *  send the reply
	 */
	sprint(reply, "%ud.%ud.%ud", line, lp->timestamp, code);
	DPRINT("dkanswer %s\n", reply);
	streamwrite(dc, reply, strlen(reply), 1);
	close(dc);
	poperror();
}

/*
 *  set the window size and reset the protocol
 */
static void
dkwindow(Chan *c)
{
	char buf[64];
	long wins;
	Line *lp;

	lp = &dk[c->dev].line[STREAMID(c->qid)];
	if(lp->window == 0)
		lp->window = 64;
	sprint(buf, "init %d %d", lp->window, Streamhi);
	streamwrite(c, buf, strlen(buf), 1);
}

/*
 *  hangup a datakit connection
 */
static void
dkhangup(Line *lp)
{
	Block *bp;

	qlock(lp);
	if(lp->rq){
		bp = allocb(0);
		bp->type = M_HANGUP;
		PUTNEXT(lp->rq, bp);
	}
	qunlock(lp);
}

/*
 *  A process which listens to all input on a csc line
 */
static void
dkcsckproc(void *a)
{
	long n;
	Dk *dp;
	Dkmsg d;
	int line;
	int i;

	dp = (Dk *)a;

	/*
	 *  loop forever listening
	 */
	for(;;){
		n = streamread(dp->csc, (char *)&d, (long)sizeof(d));
		if(n != sizeof(d)){
			print("strange csc message %d\n", n);
			continue;
		}
		line = (d.param0h<<8) + d.param0l;
/*		print("t(%d)s(%d)l(%d)\n", d.type, d.srv, line); /**/
		switch (d.type) {

		case T_CHG:	/* controller wants to close a line */
			dkchgmesg(dp, &d, line);
			break;
		
		case T_REPLY:	/* reply to a dial request */
			dkreplymesg(dp, &d, line);
			break;
		
		case T_SRV:	/* ignore it, it's useless */
			print("dksrvmesg(%d)\n", line);
			break;
		
		case T_RESTART:	/* datakit reboot */
			print("dk restart\n");
			if(line >=0 && line<dp->lines){
				print("maxlines=%d\n", line+1);
				dp->lines=line+1;
			}
			break;
		
		default:
			DPRINT("unrecognized csc message %o(%o)\n", d.type, line);
			break;
		}
	}
}

/*
 *  datakit requests or confirms closing a line
 */
static void
dkchgmesg(Dk *dp, Dkmsg *dialp, int line)
{
	Line *lp;

	if (line <= 0 || line >= dp->lines) {
		/* tell controller this line is not in use */
		dkmesg(dp, T_CHG, D_CLOSE, line, 0);
		return;
	}
	lp = &dp->line[line];
	switch (dialp->srv) {

	case D_CLOSE:		/* remote shutdown */
		switch (lp->state) {

		case Ldialing:
			/* simulate a failed connection */
			dkreplymesg(dp, (Dkmsg *)0, line);
			lp->state = Lrclose;
			break;

		case Lrclose:
		case Lconnected:
		case Llistening:
		case Lackwait:
			dkhangup(lp);
			lp->state = Lrclose;
			break;

		case Lopened:
			dkmesg(dp, T_CHG, D_CLOSE, line, 0);
			break;

		case Llclose:
		case Lclosed:
			dkhangup(lp);
			dkmesg(dp, T_CHG, D_CLOSE, line, 0);
			lp->state = Lclosed;
			break;
		}
		break;
	
	case D_ISCLOSED:	/* acknowledging a local shutdown */
		switch (lp->state) {
		case Llclose:
		case Lclosed:
			lp->state = Lclosed;
			break;

		case Lrclose:
		case Lconnected:
		case Llistening:
		case Lackwait:
			break;
		}
		break;

	default:
		print("unrecognized T_CHG\n");
	}
}

/*
 *  datakit replies to a dialout.  capture reply code and traffic parameters
 */
static void
dkreplymesg(Dk *dp, Dkmsg *dialp, int line)
{
	Proc *p;
	Line *lp;

	DPRINT("dkreplymesg(%d)\n", line);

	if(line < 0 || line >= dp->lines)
		return;

	lp=&dp->line[line];
	if(lp->state != Ldialing)
		return;

	if(dialp){
		/*
		 *  a reply from the dk
		 */
		lp->state = (dialp->srv==D_OPEN) ? Lconnected : Lrclose;
		lp->err = (dialp->param1h<<8) + dialp->param1l;
		lp->window = lp->err;
		DPRINT("dkreplymesg: %d\n", lp->state);
	} else {
		/*
		 *  a local abort
		 */
		lp->state = Lrclose;
		lp->err = 0;
	}

	if(lp->state==Lrclose){
		dkhangup(lp);
	}
	wakeup(&lp->r);
}

/*
 *  15-second timer for all interfaces
 */
static Rendez dkt;
static int
fuckit(void *a)
{
	return 0;
}
static void
dktimer(void *a)
{
	int dki, i;
	Dk *dp;
	Line *lp;

	waserror();

	for(;;){
		/*
		 *  loop through the active dks
		 */
		for(dki=0; dki<Ndk; dki++){
			dp = &dk[dki];
			if(dp->csc==0)
				continue;

			/*
			 * send keep alive
			 */
			dkmesg(dp, T_ALIVE, D_CONTINUE, 0, 0);

			/*
			 *  remind controller of dead lines and
			 *  timeout calls that take to long
			 */
			for (i=0; i<dp->lines; i++){
				lp = &dp->line[i];
				switch(lp->state){
				case Llclose:
					dkmesg(dp, T_CHG, D_CLOSE, i, 0);
					break;

				case Ldialing:
					if(lp->calltolive==0 || --lp->calltolive!=0)
						break;
					dkreplymesg(dp, (Dkmsg *)0, i);
					break;
				}
			}
		}
		tsleep(&dkt, fuckit, 0, 7500);
	}
}
.
## diffname port/devdk.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/mips/devdk.c /n/bootesdump/1990/0315/sys/src/9/mips/devdk.c
1121c
				DPRINT("DKbusy2 %ux\n", lp->state);
.
1115c
			DPRINT("DKbusy1\n");
.
593d
413a
	else
		panic("dkoput");
.
304c
		DPRINT("dkmuxiput unopened line %d\n", line);
.
299c
			DPRINT("dkmuxiput unopened line %d\n", line);
.
289c
		DPRINT("dkmuxiput bad line %d\n", line);
.
287c
	line = bp->rptr[0] | (bp->rptr[1]<<8);
	bp->rptr += 2;
.
115c
 *  dkmux line discipline is pushed onto.
.
## diffname port/devdk.c 1990/0319
## diff -e /n/bootesdump/1990/0315/sys/src/9/mips/devdk.c /n/bootesdump/1990/0319/sys/src/9/mips/devdk.c
784,786d
727c
	switch(STREAMTYPE(c->qid)){
.
725a
	if(c->qid & CHDIR){
		if(c->qid == CHDIR)
			return devdirread(c, a, n, dkdir, dk[c->dev].lines, devgen);
		else
			return devdirread(c, a, n, dksubdir, Nsubdir, streamgen);
	}

.
723,724d
720,721c
	if(c->stream)
.
717d
705c
	if(c->stream)
.
684a
		break;
.
679a
		 *  read only files
		 */
		if(omode != OREAD)
			error(0, Ebadarg);
		break;
	default:
		/*
.
678c
		break;
	case Daddrqid:
	case Draddrqid:
	case Duserqid:
	case Dotherqid:
.
668c
		break;
	case Dlistenqid:
.
648a
		 *  directories are read only
		 */
		if(omode != OREAD)
			error(0, Ebadarg);
	} else switch(STREAMTYPE(c->qid)){
	case Dcloneqid:
		/*
.
647c
	if(c->qid & CHDIR){
.
## diffname port/devdk.c 1990/0321
## diff -e /n/bootesdump/1990/0319/sys/src/9/mips/devdk.c /n/bootesdump/1990/0321/sys/src/9/mips/devdk.c
540a
	newqinfo(&dkmuxinfo);
	newqinfo(&urpinfo);
.
## diffname port/devdk.c 1990/0403
## diff -e /n/bootesdump/1990/0321/sys/src/9/mips/devdk.c /n/bootesdump/1990/0403/sys/src/9/mips/devdk.c
1130a
			if(lp->state != Lconnected)
				dkanswer(c, lineno, DKbusy);
.
## diffname port/devdk.c 1990/0509
## diff -e /n/bootesdump/1990/0403/sys/src/9/mips/devdk.c /n/bootesdump/1990/0509/sys/src/9/mips/devdk.c
420c
	if(QFULL(dp->wq->next)){
		print("dk wq full\n");
		freeb(bp);
	} else
		PUTNEXT(dp->wq, bp);
.
## diffname port/devdk.c 1990/0511
## diff -e /n/bootesdump/1990/0509/sys/src/9/mips/devdk.c /n/bootesdump/1990/0511/sys/src/9/mips/devdk.c
1204a
	panic("dklisten terminates strangely\n");
.
902c
	if(lp->state != Lopened)
.
730c
	/* real closing happens in dkstclose */
.
680a
		qunlock(lp);
.
673d
331a
	if(lp->state == Lclosed)
		lp->state = Lopened;
.
## diffname port/devdk.c 1990/0617
## diff -e /n/bootesdump/1990/0511/sys/src/9/mips/devdk.c /n/bootesdump/1990/0617/sys/src/9/mips/devdk.c
1291a

	/*
	 *  tell datakit we've rebooted. It should close all channels.
	 */
	dkmesg(dp, T_ALIVE, D_RESTART, 0, 0);	/* do this on mips but not 68020 */
	dkmesg(dp, T_CHG, D_CLOSEALL, 0, 0);
.
1087a
print("bad dialstr %d '%s'\n", n, dialstr);
.
1078a
}
.
1077a
{print("bad n\n");
.
1006c
	 *  change state if serving
.
69c
#define	T_CHG	3		/* change the status of a connection */
.
## diffname port/devdk.c 1990/0707
## diff -e /n/bootesdump/1990/0617/sys/src/9/mips/devdk.c /n/bootesdump/1990/0707/sys/src/9/mips/devdk.c
1299c
	if(dp->restart)
		dkmesg(dp, T_ALIVE, D_RESTART, 0, 0);
.
916a
	bang = strchr(dialstr, '!');
	if(bang){
		dot = strchr(dialstr, '.');
		if(dot==0 || dot > bang)
			*bang = '.';
	}
.
910c
	 *  build dial string
	 *	- guard against new lines
	 *	- change ! into . to delimit service
.
895a
	char *bang, *dot;
.
458c
		if(strcmp(fields[2], "restart")!=0)
			dp->restart = 0;
.
456a
	case 4:
		strncpy(dp->name, fields[3], sizeof(dp->name));
.
455c
	dp->restart = 1;
	n = getfields((char *)bp->rptr, fields, 4, ' ');
.
442c
	char *fields[4];
.
433a
 *	the word `restart' or `norestart' (optional/default==restart)
.
430c
 *  configure a datakit multiplexor.  this takes 4 arguments separated
.
125a
	int	restart;
.
## diffname port/devdk.c 1990/0717
## diff -e /n/bootesdump/1990/0707/sys/src/9/mips/devdk.c /n/bootesdump/1990/0717/sys/src/9/mips/devdk.c
554c
	urpreset();
.
## diffname port/devdk.c 1990/0722
## diff -e /n/bootesdump/1990/0717/sys/src/9/mips/devdk.c /n/bootesdump/1990/0722/sys/src/9/mips/devdk.c
596a
	if(*spec == 0)
		spec = "dk";
.
595c
	 *  find a multiplexor with the same name (default dk)
.
506c
		kproc("dktimer", dktimer, 0);
.
497c
	sprint(buf, "csckproc%d", dp->ncsc);
.
458a
	strcpy(dp->name, "dk");
.
## diffname port/devdk.c 1990/0830
## diff -e /n/bootesdump/1990/0722/sys/src/9/mips/devdk.c /n/bootesdump/1990/0830/sys/src/9/mips/devdk.c
418,419c
	else {
		print("dkoput l %d b %ux r %ux w %ux\n", line, bp->base, bp->rptr,
			bp->wptr);
		freeb(bp);
		return;
	}
.
## diffname port/devdk.c 1990/0911
## diff -e /n/bootesdump/1990/0830/sys/src/9/mips/devdk.c /n/bootesdump/1990/0911/sys/src/9/mips/devdk.c
1487c
	while(waserror())
		print("dktimer: error\n");
.
1322a
	}
	DPRINT("dkcsckproc: closeall %s\n", dp->name);
.
1321c
	if(dp->restart) {
		DPRINT("dkcsckproc: restart %s\n", dp->name);
.
980c
	dkmesg(dp, t_val, d_val, line, W_WINDOW(dp->urpwindow,dp->urpwindow,2));
.
870a
	}
.
869c
	if(waserror()){
		print("dkmesg: error\n");
.
559d
502c
	sprint(buf, "csc.%s.%d", dp->name, dp->ncsc);
.
483a
	DPRINT("dkmuxconfig: ncsc=%d, lines=%d, restart=%d, name=\"%s\"\n",
		dp->ncsc, dp->lines, dp->restart, dp->name);
.
464a
	case 5:
		dp->urpwindow = strtoul(fields[4], 0, 0);
.
463a
	dp->urpwindow = WS_2K;
.
462c
	n = getfields((char *)bp->rptr, fields, 5, ' ');
.
448c
	char *fields[5];
.
440c
 *	the name of the dk (default==dk)
 *	the urp window size (default==WS_2K)
.
435c
 *  configure a datakit multiplexor.  this takes 5 arguments separated
.
416,423c
	bp = padb(bp, 2);
.
398c
 *  add a 2 byte channel number to the start of each message,
 *  low order byte first.
.
126a
	int	urpwindow;
.
11a
#define	NOW	(MACHP(0)->ticks)

.
9,10c
#define	DPRINT	if(0)	/*kprint*/
.
## diffname port/devdk.c 1990/0925
## diff -e /n/bootesdump/1990/0911/sys/src/9/mips/devdk.c /n/bootesdump/1990/0925/sys/src/9/mips/devdk.c
1115d
1105d
1103d
## diffname port/devdk.c 1990/1004
## diff -e /n/bootesdump/1990/0925/sys/src/9/mips/devdk.c /n/bootesdump/1990/1004/sys/src/9/mips/devdk.c
1317,1326d
501a
	 *  tell datakit we've rebooted. It should close all channels.
	 */
	if(dp->restart) {
		DPRINT("dkmuxconfig: restart %s\n", dp->name);
		dkmesg(dp, T_ALIVE, D_RESTART, 0, 0);
	}

	/*
.
## diffname port/devdk.c 1990/1011
## diff -e /n/bootesdump/1990/1004/sys/src/9/mips/devdk.c /n/bootesdump/1990/1011/sys/src/9/mips/devdk.c
424c
/*		print("dk wq full\n");/**/
.
## diffname port/devdk.c 1990/1018
## diff -e /n/bootesdump/1990/1011/sys/src/9/mips/devdk.c /n/bootesdump/1990/1018/sys/src/9/mips/devdk.c
423,427c
	FLOWCTL(dp->wq);
	PUTNEXT(dp->wq, bp);
.
121c
	char	name[64];	/* dk name */
.
## diffname port/devdk.c 1990/1022
## diff -e /n/bootesdump/1990/1018/sys/src/9/mips/devdk.c /n/bootesdump/1990/1022/sys/src/9/mips/devdk.c
1506c
			for (i=dp->ncsc+1; i<dp->lines; i++){
.
1423a
	case D_CLOSEALL:
		for(line = dp->ncsc+1; line < dp->lines; line++){
			lp = &dp->line[line];
			switch (lp->state) {
	
			case Ldialing:
				/* simulate a failed connection */
				dkreplymesg(dp, (Dkmsg *)0, line);
				lp->state = Lrclose;
				break;
	
			case Lrclose:
			case Lconnected:
			case Llistening:
			case Lackwait:
				dkhangup(lp);
				lp->state = Lrclose;
				break;
	
			case Lopened:
				break;
	
			case Llclose:
			case Lclosed:
				lp->state = Lclosed;
				break;
			}
		}
		break;

.
1409a
		if (line <= 0 || line >= dp->lines) {
			/* tell controller this line is not in use */
			dkmesg(dp, T_CHG, D_CLOSE, line, 0);
			return;
		}
		lp = &dp->line[line];
.
1379a
		if (line <= 0 || line >= dp->lines) {
			/* tell controller this line is not in use */
			dkmesg(dp, T_CHG, D_CLOSE, line, 0);
			return;
		}
		lp = &dp->line[line];
.
1371,1376d
224a
			for(lp = dp->line; lp < &dp->line[Nline]; lp++)
				if(lp->state != 0)
					panic("dkmuxopen l %d s %lux", lp-dp->line, lp->state);
.
208a
	Line *lp;
.
## diffname port/devdk.c 1990/1024
## diff -e /n/bootesdump/1990/1022/sys/src/9/mips/devdk.c /n/bootesdump/1990/1024/sys/src/9/mips/devdk.c
226,228d
209d
## diffname port/devdk.c 1990/1101
## diff -e /n/bootesdump/1990/1024/sys/src/9/mips/devdk.c /n/bootesdump/1990/1101/sys/src/9/mips/devdk.c
1557c
		tsleep(&dp->timer, return0, 0, 7500);
.
1548,1554c
				dkreplymesg(dp, (Dkmsg *)0, i);
				break;
.
1538,1546c
			case Ldialing:
				if(lp->calltolive==0 || --lp->calltolive!=0)
.
1533,1536c
		/*
		 *  remind controller of dead lines and
		 *  timeout calls that take to long
		 */
		for (i=dp->ncsc+1; i<dp->lines; i++){
			lp = &dp->line[i];
			switch(lp->state){
			case Llclose:
				dkmesg(c, T_CHG, D_CLOSE, i, 0);
				break;
.
1528,1531c
		dkmesg(c, T_ALIVE, D_CONTINUE, 0, 0);
.
1526c
		 * send keep alive
.
1524a
		if(dp->opened==0)
			error(0, Ehungup);

.
1523a
			case Ldialing:
				dkreplymesg(dp, (Dkmsg *)0, i);
				break;
			}
		}
		if(c)
			close(c);
		return;
	}

	/*
	 *  open csc
	 */
	dp = (Dk *)a;
	c = dkopenline(dp, dp->ncsc);

.
1521,1522c
	c = 0;
	if(waserror()){
		/*
		 *  hang up any calls waiting for the dk
		 */
		for (i=dp->ncsc+1; i<dp->lines; i++){
			lp = &dp->line[i];
			switch(lp->state){
			case Llclose:
				lp->state = Lclosed;
				break;
.
1519a
	Chan *c;
.
1508,1513d
1506c
 *  send a I'm alive message every 7.5 seconds and remind the dk of
 *  any closed channels it hasn't acknowledged.
.
1446a
				dkhangup(lp);
.
1445d
1430a
		/*
		 *  datakit wants us to close all lines
		 */
.
1412c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1403c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1397c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1376c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1367c
dkchgmesg(Chan *c, Dk *dp, Dkmsg *dialp, int line)
.
1353d
1349,1351c
			if(line >=0 && line<dp->lines)
.
1337c
			dkchgmesg(dp->csc, dp, &d, line);
.
1328a
			if(n == 0)
				error(0, Ehungup);
.
1322a
	if(waserror()){
		close(dp->csc);
		return;
	}

.
1321c
	dp = a;
.
1319d
1095,1096d
1090c
	dc = dkopenline(dp, STREAMID(c->qid));
.
988c
	csc = dkopenline(dp, dp->ncsc);
	dkmesg(csc, t_val, d_val, line, W_WINDOW(dp->urpwindow,dp->urpwindow,2));
	close(csc);
	csc = 0;
.
980a
	/*
	 *  open the data file
	 */
	dc = dkopenline(dp, line);
.
978,979d
975c
		if(csc)
			close(csc);
		if(dc)
			close(dc);
.
973c
	dc = 0;
	csc = 0;
.
971c
	 *  close temporary channels on error
.
918c
	
.
916a
	Chan *csc;
.
891c
	streamwrite(c, (char *)&d, sizeof(Dkmsg), 1);
.
873,874d
871d
868c
dkmesg(Chan *c, int type, int srv, int p0, int p1)
.
864a
 *  open the common signalling channel
 */
static Chan*
dkopenline(Dk *dp, int line)
{
	Chan *c;

	c = 0;
	if(waserror()){
		if(c)
			close(c);
		nexterror();
	}
	c = dkattach(dp->name);
	c->qid = STREAMQID(line, Sdataqid);
	dkopen(c, ORDWR);
	poperror();

	return c;
}

/*
.
754,758d
749,751d
701d
698a
		lp->state = Lopened;
		qunlock(lp);
.
685d
681a
		dp = &dk[c->dev];
.
629,634d
610,620c
	dp = dkalloc(spec);

	/*
	 *  return the new channel
	 */
.
516,519c
	sprint(buf, "timer.%s.%d", dp->name, dp->ncsc);
	kproc(buf, dktimer, dp);
.
514c
	 *  start a keepalive process
.
511d
507c
	 *  start a process to listen to csc messages
.
502,503c
		DPRINT("dktimer: restart %s\n", dp->name);
		dkmesg(dp->csc, T_ALIVE, D_RESTART, 0, 0);
.
499a
	 *  do this here to get it done before trying to open a channel.
.
498a
	 *  open csc here so that boot, dktimer, and dkcsckproc aren't
	 *  all fighting for it at once.
	 */
	dp->csc = dkopenline(dp, dp->ncsc);

	/*
.
493,496c
	dp->ncsc = ncsc;
	dp->lines = lines;
	dp->restart = restart;
	dp->urpwindow = window;
	dp->s = RD(q)->ptr;
	q->ptr = q->other->ptr = dp;
	dp->opened = 1;
	dp->wq = WR(q);
	unlock(dp);
.
487,491c
	dp = dkalloc(name);
	lock(dp);
	if(dp->opened){
		unlock(dp);
		error(0, Ebadarg);
.
485c
	 *  set up
.
480,482d
477,478c
	if(ncsc <= 0 || lines <= ncsc)
.
470c
		ncsc = strtoul(fields[0], 0, 0);
.
468c
		lines = strtoul(fields[1], 0, 0);
.
466c
			restart = 0;
.
463c
		strncpy(name, fields[3], sizeof(name));
.
461c
		window = strtoul(fields[4], 0, 0);
.
457,458d
455d
452a
	 *  defaults
	 */
	ncsc = 1;
	restart = 1;
	lines = 16;
	window = WS_2K;
	strcpy(name, "dk");

	/*
.
449c
		error(0, Egreg);
.
447c
	if(WR(q)->ptr){
.
445c
	char name[NAMELEN];
	int lines;
	int ncsc;
	int restart;
	int window;
.
441c
	Dk *dp;
.
439c
dkmuxconfig(Queue *q, Block *bp)
.
382a
out:
.
381a
	poperror();
	close(c);
.
378,380d
375c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
370c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
365c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
360c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
358a
	c = 0;
	if(waserror()){
		lp->state = Lclosed;
		if(c)
			close(c);
		goto out;
	}	
	c = dkopenline(dp, dp->ncsc);

	/*
	 *  shake hands with dk
	 */
	switch(lp->state){
.
357c
	case Lopened:
		lp->state = Lclosed;
		goto out;
	}
.
353a
	if(lp->rq == 0){
		lp->state = Lclosed; 
		return;
	}

	/*
	 *  decrement ref count on mux'd line
	 */
	streamexit(dp->s, 0);

	/*
	 *  these states don't need the datakit
	 */
.
352c
	 *  if we never got going, we're done
.
346a
	Chan *c;
.
336a
	lp->rq = q;
.
334,335c
	lock(dp);
	if(dp->opened==0 || streamenter(dp->s)<0){
		unlock(dp);
		error(0, Ehungup);
	}
	unlock(dp);
	if(lp->state==Lclosed)
.
283a
	/*
	 *  not configured yet
	 */
	if(q->other->ptr == 0){
		freeb(bp);
		return;
	}

.
275c
 *	work.
.
259c
			dkmuxconfig(q, bp);
.
254,256d
240,245c
	dp = WR(q)->ptr;
	if(dp == 0)
		return;

	/*
	 *  disallow new dkstopens() on this line.
	 *  the lock syncs with dkstopen().
	 */
	lock(dp);
	dp->opened = 0;
	unlock(dp);

	/*
	 *  hang up all datakit connections
	 */
	for(i=dp->ncsc; i < dp->lines; i++)
		dkhangup(&dp->line[i]);

	/*
	 *  wakeup the timer so it can die
	 */
	wakeup(&dp->timer);
.
238a
	int i;
.
232a
 *  a new dkmux.  find a free dk structure and assign it to this queue.
 *  when we get though here dp->s is meaningful and the name is set to "/".
 */
static void
dkmuxopen(Queue *q, Stream *s)
{
	RD(q)->ptr = s;
	WR(q)->ptr = 0;
}

/*
.
229c
	if(freep == 0){
		unlock(&dklock);
		error(0, Enoifc);
	}
	dp = freep;
	dp->opened = 0;
	dp->s = 0;
	dp->ncsc = 1;
	strncpy(dp->name, name, sizeof(freep->name));
	unlock(&dklock);
	return dp;
.
227a
		if(dp->name[0] == 0)
			freep = dp;
.
212,226c
		if(strcmp(name, dp->name) == 0){
			unlock(&dklock);
			return dp;
.
210a
	lock(&dklock);
	freep = 0;
.
209c
	Dk *freep;
.
203,206c
 *  Look for a dk struct with a name.  If none exists,  create one.
 */ 
static Dk *
dkalloc(char *name)
.
191a
static void	dkhangup(Line*);
.
189c
static void	dkchgmesg(Chan*, Dk*, Dkmsg*, int);
.
181,182c
static void	dkmuxconfig(Queue*, Block*);
static Chan*	dkopenline(Dk*, int);
static int	dkmesg(Chan*, int, int, int, int);
.
130a
static Lock dklock;
.
128a
	Rendez	timer;
.
125c
	Chan	*csc;
.
122a
	Stream	*s;
.
119,120c
	Lock;
	int	opened;
.
## diffname port/devdk.c 1990/1104
## diff -e /n/bootesdump/1990/1101/sys/src/9/mips/devdk.c /n/bootesdump/1990/1104/sys/src/9/mips/devdk.c
382d
379a
	lp->rq = q;
.
## diffname port/devdk.c 1990/1113
## diff -e /n/bootesdump/1990/1104/sys/src/9/mips/devdk.c /n/bootesdump/1990/1113/sys/src/9/mips/devdk.c
360c
Qinfo dkinfo =
{
	dkiput,
	dkoput,
	dkstopen,
	dkstclose,
	"dk"
};
.
205c
Qinfo dkmuxinfo =
{
	dkmuxiput,
	dkmuxoput,
	dkmuxopen,
	dkmuxclose,
	"dkmux"
};
.
## diffname port/devdk.c 1990/11161
## diff -e /n/bootesdump/1990/1113/sys/src/9/mips/devdk.c /n/bootesdump/1990/11161/sys/src/9/mips/devdk.c
1670a
		DPRINT("keep alive\n");
.
9c
#define	DPRINT	if(0) print
.
## diffname port/devdk.c 1990/11211
## diff -e /n/bootesdump/1990/11161/sys/src/9/mips/devdk.c /n/bootesdump/1990/11211/sys/src/9/mips/devdk.c
1666c
			error(Ehungup);
.
1447c
				error(Ehungup);
.
1398c
	lp = &dk[c->dev].line[STREAMID(c->qid.path)];
.
1375c
	dc->qid.path = STREAMQID(STREAMID(c->qid.path), Sdataqid);
.
1335c
			error(Ebadarg);
.
1231c
			error(Eio);
.
1221c
			error(Eio);
.
1205c
	dc = dkopenline(dp, STREAMID(c->qid.path));
.
1147c
			error(dkerr[lp->err]);
.
1145c
			error(dkerr[0]);
.
1112c
			error(Ebadarg);
.
1045c
		error(Ebadarg);
.
1043c
		error(Ebadarg);
.
1033c
		error(Ebadarg);
.
1025c
	line = STREAMID(c->qid.path);
.
965c
	c->qid.path = STREAMQID(line, Sdataqid);
.
936,949d
933c
	error(Eperm);
.
927c
	error(Eperm);
.
921c
	error(Eperm);
.
914c
				error(Ebadarg);
.
910c
				error(Ebadarg);
.
906c
				error(Ebadarg);
.
902c
				error(Ebadarg);
.
898c
				error(Ebadarg);
.
882c
	t = STREAMTYPE(c->qid.path);
.
871c
	error(Eperm);
.
862,863c
	lp = &dk[c->dev].line[STREAMID(c->qid.path)];
	switch(STREAMTYPE(c->qid.path)){
.
855,856c
	if(c->qid.path & CHDIR){
		if(c->qid.path == CHDIR)
.
837c
	error(Eperm);
.
816c
			error(Ebadarg);
.
803c
		c->qid.path = STREAMQID(line, Sctlqid);
.
791c
			error(Enodev);
.
786c
				c->qid.path = STREAMQID(lp-dp->line, Sctlqid);
.
772,773c
			error(Ebadarg);
	} else switch(STREAMTYPE(c->qid.path)){
.
767c
	if(c->qid.path & CHDIR){
.
743c
	if(c->qid.path == CHDIR)
.
734c
	if(c->qid.path == CHDIR)
.
699c
	dkdir[0].qid.path = Dcloneqid;
	dkdir[0].qid.vers = 0;
.
690c
		dkdir[i].qid.path = CHDIR|STREAMQID(i, Dlineqid);
		dkdir[i].qid.vers = 0;
.
656,660c
	"addr",		{Daddrqid},	0,	0600,
	"listen",	{Dlistenqid},	0,	0600,
	"other",	{Dotherqid},	0,	0600,
	"raddr",	{Draddrqid},	0, 	0600,
	"ruser",	{Duserqid},	0, 	0600,
.
587c
		error(Ebadarg);
.
578c
		error(Ebadarg);
.
574c
		error(Ebadarg);
.
543c
		error(Egreg);
.
502c
		error(Ebadarg);
.
391c
		error(Ehungup);
.
235c
		error(Enoifc);
.
## diffname port/devdk.c 1990/1126
## diff -e /n/bootesdump/1990/11211/sys/src/9/mips/devdk.c /n/bootesdump/1990/1126/sys/src/9/mips/devdk.c
779c
		 *  get an unused device and open its control file
.
746a
	else if(c->qid.path == Dcloneqid)
		devstat(c, dp, dkdir, 1, devgen);
.
## diffname port/devdk.c 1990/1202
## diff -e /n/bootesdump/1990/1126/sys/src/9/mips/devdk.c /n/bootesdump/1990/1202/sys/src/9/mips/devdk.c
1566a
		dp->allclosedp = 1;
		wakeup(&dp->rallclosed);
.
624a

	/*
	 *  wait for closeall in response to D_RESTART
	 */
	if(dp->restart)
		tsleep(&dp->rallclosed, allclosed, dp, 10000);
.
615,620d
605a
	 *  start a process to listen to csc messages
	 */
	sprint(buf, "csc.%s.%d", dp->name, dp->ncsc);
	kproc(buf, dkcsckproc, dp);

	/*
	 *  wait for first possible closeall (may not come)
	 */
	tsleep(&dp->rallclosed, allclosed, dp, 2000);

	/*
.
527a
static int
allclosed(void *arg)
{
	Dk *dp;

	dp = arg;
	return dp->allclosedp;
}
.
130a
	Rendez	rallclosed;
	int	allclosedp;	/* true once a closeall has been seen */
.
## diffname port/devdk.c 1990/1210
## diff -e /n/bootesdump/1990/1210/sys/src/9/mips/devdk.c /n/bootesdump/1990/1210/sys/src/9/port/devdk.c
1588,1589c
		dp->closeall = 1;
		wakeup(&dp->closeallr);
.
640,645d
632a
		tsleep(&dp->closeallr, haveca, dp, 5000); /* wait for restart closeall */
.
631a
		dp->closeall = 0;
.
622,626d
619a
	tsleep(&dp->closeallr, haveca, dp, 5000);	/* wait for initial closeall */
.
612a
	dp->closeall = 0;
.
536c
	return dp->closeall;
.
531c
haveca(void *arg)
.
131,132c
	int	closeall;	/* set when we receive a closeall message */
	Rendez	closeallr;	/* wait here for a closeall */
.
## diffname port/devdk.c 1990/1214
## diff -e /n/bootesdump/1990/1210/sys/src/9/port/devdk.c /n/bootesdump/1990/1214/sys/src/9/port/devdk.c
1667d
1641a
	dp = (Dk *)a;
.
1107d
1105a
	poperror();
.
1104a
	if(waserror()){
		close(csc);
		nexterror();
	}
.
1092,1096d
1086,1089c
		close(dc);
.
1083,1084c
	dc = dkopenline(dp, line);
.
1081c
	 *  open the data file
.
1077a
	default:
		t_val = 0;
		d_val = 0;
		panic("bad dial type");
.
## diffname port/devdk.c 1991/0411
## diff -e /n/bootesdump/1990/1214/sys/src/9/port/devdk.c /n/bootesdump/1991/0411/sys/src/9/port/devdk.c
893c
dkwrite(Chan *c, void *a, long n, ulong offset)
.
887c
		return stringread(c, a, n, lp->ruser, offset);
.
885c
		return stringread(c, a, n, lp->raddr, offset);
.
883c
		return stringread(c, a, n, lp->addr, offset);
.
866c
dkread(Chan *c, void *a, long n, ulong offset)
.
## diffname port/devdk.c 1991/0419
## diff -e /n/bootesdump/1991/0411/sys/src/9/port/devdk.c /n/bootesdump/1991/0419/sys/src/9/port/devdk.c
755a
Chan*
dkclwalk(Chan *c, char *name)
{
	return devclwalk(c, name);
}

.
## diffname port/devdk.c 1991/0427
## diff -e /n/bootesdump/1991/0419/sys/src/9/port/devdk.c /n/bootesdump/1991/0427/sys/src/9/port/devdk.c
756,761d
## diffname port/devdk.c 1991/0706
## diff -e /n/bootesdump/1991/0427/sys/src/9/port/devdk.c /n/bootesdump/1991/0706/sys/src/9/port/devdk.c
1476c
			print("unrecognized csc message %o.%o(%o)\n",
				d.type, d.srv, line);
.
770c
 *  its ctl file.
.
## diffname port/devdk.c 1991/0723
## diff -e /n/bootesdump/1991/0706/sys/src/9/port/devdk.c /n/bootesdump/1991/0723/sys/src/9/port/devdk.c
1467c
/*			print("dksrvmesg(%d)\n", line);		/**/
.
## diffname port/devdk.c 1991/0828
## diff -e /n/bootesdump/1991/0723/sys/src/9/port/devdk.c /n/bootesdump/1991/0828/sys/src/9/port/devdk.c
1472c
				dp->lines = line+1;
.
## diffname port/devdk.c 1991/1105
## diff -e /n/bootesdump/1991/0828/sys/src/9/port/devdk.c /n/bootesdump/1991/1105/sys/src/9/port/devdk.c
1062c
		strcat(dialstr, u->p->user);
.
1048c
	if(strlen(addr)+strlen(u->p->user)+2 >= sizeof(dialstr))
.
## diffname port/devdk.c 1991/1107
## diff -e /n/bootesdump/1991/1105/sys/src/9/port/devdk.c /n/bootesdump/1991/1107/sys/src/9/port/devdk.c
1685c
			lp = dp->linep[i];
.
1661a
		freeb(dp->alloc);
.
1649c
			lp = dp->linep[i];
.
1604c
	lp = dp->linep[line];
.
1555c
			lp = dp->linep[line];
.
1535c
		lp = dp->linep[line];
.
1499c
		lp = dp->linep[line];
.
1401c
	lp = dk[c->dev].linep[STREAMID(c->qid.path)];
.
1368c
	lp = dp->linep[line];
.
1341,1343c
		DPRINT("src(%s)user(%s)dest(%s)w(%d)\n", lp->raddr, lp->ruser,
			lp->addr, W_TRAF(lp->window));
.
1275c
		lp = dp->linep[lineno];
.
1031c
	lp = dp->linep[line];
.
880c
	lp = dk[c->dev].linep[STREAMID(c->qid.path)];
.
829d
810,811d
808c
		if(line == dp->lines)
.
804c
				c->qid.path = STREAMQID(line, Sctlqid);
				lp->state = Lopened;
				qunlock(lp);
.
797,798c
		for(line = dp->ncsc+1; line < dp->lines; line++){
			lp = dp->linep[line];
.
781c
	Line *lp;
.
731c
	dp = dkalloc(spec, 0, 0);
.
683a
	dk = (Dk*)ialloc(conf.dkif*sizeof(Dk), 0);
.
672d
652d
599,600d
593c
	dp = dkalloc(name, ncsc, lines);
.
509c
	line = lp->lineno;
.
467c
		dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
.
462c
		dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
.
457c
		dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
.
452c
		dkmesg(c, T_CHG, D_CLOSE, lp->lineno, 0);
.
388c
	q->other->ptr = q->ptr = lp = dp->linep[s->id];
.
347c
	lp = dp->linep[line];
.
284c
		dkhangup(dp->linep[i]);
.
243a

	/*
	 *  allocate memory for line structures
	 */
	n = sizeof(Line*)*dp->lines;
	bp = allocb(n);
	if(bp->lim - bp->base < n){
		unlock(&dklock);
		errors("too many lines");
	}
	dp->linep = (Line **)bp->base;
	bp->wptr += n;
	dp->alloc = bp;
	for(i = 0; i < n; i++){
		if(bp->lim - bp->wptr < sizeof(Line)){
			bp = allocb(sizeof(Line)*n);
			bp->next = dp->alloc;
			dp->alloc = bp;
		}
		dp->linep[i] = (Line*)bp->wptr;
		dp->linep[i]->lineno = i;
		bp->wptr += sizeof(Line);
	}
		
.
242c
	dp->ncsc = ncsc;
	dp->lines = lines;
.
238a
	if(lines == 0)
		errors("unknown dk interface");

	/*
 	 *  init the structures
	 */
.
227c
	for(dp = dk; dp < &dk[conf.dkif]; dp++){
.
223a
	Block *bp;
	int i, n;
.
220c
dkalloc(char *name, int ncsc, int lines)
.
134c
static Dk *dk;
.
132a

	Block	*alloc;
.
127c
	Line	**linep;
.
110d
99a
	int	lineno;
.
15,19d
## diffname port/devdk.c 1991/1108
## diff -e /n/bootesdump/1991/1107/sys/src/9/port/devdk.c /n/bootesdump/1991/1108/sys/src/9/port/devdk.c
1480c
		DPRINT("t(%d)s(%d)l(%d)\n", d.type, d.srv, line);
.
1466a
	DPRINT("dkcsckproc: %d\n", dp->ncsc);
.
1002a
 *  return the contents of the info files
 */
void
dkfilladdr(Chan *c, char *buf, int len)
{
	strncpy(buf, dk[c->dev].linep[STREAMID(c->qid.path)]->addr, len);
}
void
dkfillraddr(Chan *c, char *buf, int len)
{
	strncpy(buf, dk[c->dev].linep[STREAMID(c->qid.path)]->raddr, len);
}
void
dkfillruser(Chan *c, char *buf, int len)
{
	strncpy(buf, dk[c->dev].linep[STREAMID(c->qid.path)]->ruser, len);
}

/*
.
980a
 *  return the number of an unused line (reserve it)
 */
static int
dkcloneline(Chan *c)
{
	Line *lp;
	Dk *dp;
	int line;

	dp = &dk[c->dev];
	/*
	 *  get an unused device and open its control file
	 */
	for(line = dp->ncsc+1; line < dp->lines; line++){
		lp = dp->linep[line];
		if(lp->state == Lclosed && canqlock(lp)){
			if(lp->state != Lclosed){
				qunlock(lp);
				continue;
			}
			lp->state = Lopened;
			qunlock(lp);
			return lp->lineno;
		}
	}
	error(Enodev);
}

/*
.
894,915c
	return netread(c, a, n, offset,  &dk[c->dev].net);
.
806,875c
	return netopen(c, omode, &dk[c->dev].net);
.
794,802d
786,791c
	netstat(c, dp, &dk[c->dev].net);
.
777,780c
	return netwalk(c, name, &dk[c->dev].net);
.
721,744d
714,717d
669,706d
273c

	/*
	 *  fill in the network structure
	 */
	dp->net.name = dp->name;
	dp->net.nconv = dp->lines+1;
	dp->net.devp = &dkinfo;
	dp->net.protop = &urpinfo;
	dp->net.listen = dklisten;
	dp->net.clone = dkcloneline;
	dp->net.ninfo = 3;
	dp->net.info[0].name = "addr";
	dp->net.info[0].fill = dkfilladdr;
	dp->net.info[1].name = "raddr";
	dp->net.info[1].fill = dkfillraddr;
	dp->net.info[2].name = "ruser";
	dp->net.info[2].fill = dkfillruser;

.
271a
		n -= sizeof(Line);
.
265a
			memset(bp->base, 0, bp->lim-bp->base);
.
263c
	n = sizeof(Line)*(dp->lines);
	for(i = 1; i <= dp->lines; i++){
.
259a
	memset(bp->base, 0, bp->lim-bp->base);
.
254c
	n = sizeof(Line*)*(dp->lines+1);
.
239a
	}
.
238c
	if(lines == 0){
		unlock(&dklock);
.
222a
	Line *lp;
.
197a
 *  for standard network interface (net.c)
 */
static int	dkcloneline(Chan*);
static int	dklisten(Chan*);
static void	dkfilladdr(Chan*, char*, int);
static void	dkfillraddr(Chan*, char*, int);
static void	dkfillruser(Chan*, char*, int);

extern Qinfo dkinfo;

/*
.
187d
127a
	Network	net;
.
13,21d
## diffname port/devdk.c 1991/1114
## diff -e /n/bootesdump/1991/1108/sys/src/9/port/devdk.c /n/bootesdump/1991/1114/sys/src/9/port/devdk.c
270c
	for(i = 0; i <= dp->lines; i++){
.
## diffname port/devdk.c 1991/1115
## diff -e /n/bootesdump/1991/1114/sys/src/9/port/devdk.c /n/bootesdump/1991/1115/sys/src/9/port/devdk.c
1272a

		/* listener becomes owner */
		netown(&dp->net, lp->lineno, dp->prot[from].owner, 0);

.
1130a
	from = STREAMID(c->qid.path);
.
1127a
	int from;
.
854a

			/* current user becomes owner */
			netown(&dp->net, lp->lineno, u->p->user, 0);

.
830c
	netwstat(c, dp, &dk[c->dev].net);
.
698a
	for(i = 0; i < conf.dkif; i++)
		dk[i].prot = (Netprot*)ialloc(conf.nurp*sizeof(Netprot), 0);
.
697a
	int i;
.
532a
	netdisown(&dp->net, lp->lineno);
.
291a
	dp->net.prot = dp->prot;
.
287c
	dp->net.nconv = dp->lines;
.
270c
	for(i = 0; i < dp->lines; i++){
.
259c
	n = sizeof(Line*)*(dp->lines);
.
119a
	Netprot *prot;
.
16a
enum {
	Maxlines = 256,
};

.
## diffname port/devdk.c 1991/1116
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/devdk.c /n/bootesdump/1991/1116/sys/src/9/port/devdk.c
1613,1616c
	c = dkopencsc(dp);
.
1040c
	csc = dkopencsc(dp);
.
898a
 *  open the common signalling channel
 */
static Chan*
dkopencsc(Dk *dp)
{
	qlock(dp);
	if(dp->csc == 0)
		dp->csc = dkopenline(dp, dp->ncsc);
	else
		incref(dp->csc);
	qunlock(dp);
	return dp->csc;
}

/*
.
876,878d
675c
	dkopencsc(dp);
.
540a

	if(lp->lineno == dp->ncsc)
		dp->csc = 0;
	netdisown(&dp->net, lp->lineno);
.
539d
507c
	c = dkopencsc(dp);
.
181a
static Chan*	dkopencsc(Dk*);
.
126c
	Block	*alloc;		/* blocks containing Line structs */
.
116c
	int	lines;		/* number of lines */
.
114d
110a

.
108a
	QLock;
	Chan	*csc;

.
## diffname port/devdk.c 1991/1120
## diff -e /n/bootesdump/1991/1116/sys/src/9/port/devdk.c /n/bootesdump/1991/1120/sys/src/9/port/devdk.c
1628d
547a

	lock(dp);
	dp->ref--;
	if(dp->ref == 0)
		freeb(dp->alloc);
	unlock(dp);
.
456a
	dp->ref++;
.
336a
	dp->name[0] = 0;
.
243c
		if(dp->name[0] == 0 && dp->ref == 0)
.
112a
	int	ref;
.
## diffname port/devdk.c 1991/1122
## diff -e /n/bootesdump/1991/1120/sys/src/9/port/devdk.c /n/bootesdump/1991/1122/sys/src/9/port/devdk.c
309a
	dp->net.info[3].name = "stats";
	dp->net.info[3].fill = urpfillstats;
.
303c
	dp->net.ninfo = 4;
.
## diffname port/devdk.c 1991/1206
## diff -e /n/bootesdump/1991/1122/sys/src/9/port/devdk.c /n/bootesdump/1991/1206/sys/src/9/port/devdk.c
1121c
			errors(dkerr[lp->err]);
.
1119c
			errors(dkerr[0]);
.
840c
			for(m = 0; m < DKERRS-1; m++)
				if(strcmp(field[2], dkerr[m]) == 0)
					break;
			dkanswer(c, strtoul(field[1], 0, 0), m);
.
173c
#define DKERRS sizeof(dkerr)/sizeof(char*)
.
163,171c
char* dkerr[]={
	[DKok]"",
	[DKbusy]"host overloaded",
	[DKnetotl]"network not answering",
	[DKdestotl]"host not answering",
	[DKbadnet]"unknown address",
	[DKnetbusy]"network overloaded",
	[DKinuse]"server in use",
	[DKreject]"connection refused", 
.
151c
 *  map datakit error to errno 
.
85,87d
## diffname port/devdk.c 1991/1214
## diff -e /n/bootesdump/1991/1206/sys/src/9/port/devdk.c /n/bootesdump/1991/1214/sys/src/9/port/devdk.c
851a
	USED(c);
.
779a
	USED(c);
.
## diffname port/devdk.c 1991/1228
## diff -e /n/bootesdump/1991/1214/sys/src/9/port/devdk.c /n/bootesdump/1991/1228/sys/src/9/port/devdk.c
166,167c
	[DKnetbusy]"network busy",
	[DKinuse]"service in use",
.
164c
	[DKdestotl]"destination not answering",
.
162c
	[DKbusy]"destination busy",
.
## diffname port/devdk.c 1992/0111
## diff -e /n/bootesdump/1991/1228/sys/src/9/port/devdk.c /n/bootesdump/1992/0111/sys/src/9/port/devdk.c
1123c
			error(dkerr[lp->err]);
.
1121c
			error(dkerr[0]);
.
270c
		error(Ebadarg);
.
248,251d
244c
	if(freep == 0 || lines == 0){
.
7c
#include	"../port/error.h"
.
## diffname port/devdk.c 1992/0130
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/devdk.c /n/bootesdump/1992/0130/sys/src/9/port/devdk.c
813c
		if(n > sizeof buf - 1)
			n = sizeof buf - 1;
		strncpy(buf, a, n);
		buf[n] = '\0';
.
## diffname port/devdk.c 1992/0219
## diff -e /n/bootesdump/1992/0130/sys/src/9/port/devdk.c /n/bootesdump/1992/0219/sys/src/9/port/devdk.c
318a

	s->opens++;		/* Hold this queue in place */
	s->inuse++;
.
## diffname port/devdk.c 1992/0221
## diff -e /n/bootesdump/1992/0219/sys/src/9/port/devdk.c /n/bootesdump/1992/0221/sys/src/9/port/devdk.c
1259c
			if((dts++ % 1000) == 0)
				print("dklisten: repeat timestamp %d\n", lineno);
.
1177a
	static int dts;
.
## diffname port/devdk.c 1992/0223
## diff -e /n/bootesdump/1992/0221/sys/src/9/port/devdk.c /n/bootesdump/1992/0223/sys/src/9/port/devdk.c
325c
 *  close down a dkmux, this shouldn't happen
.
311,312c
 *  a new dkmux.  hold the stream in place so it can never be closed down.
.
## diffname port/devdk.c 1992/0305
## diff -e /n/bootesdump/1992/0223/sys/src/9/port/devdk.c /n/bootesdump/1992/0305/sys/src/9/port/devdk.c
591,592c
	FLOWCTL(dp->wq, bp);
.
109d
106a
	Lock;
.
## diffname port/devdk.c 1992/0321
## diff -e /n/bootesdump/1992/0305/sys/src/9/port/devdk.c /n/bootesdump/1992/0321/sys/src/9/port/devdk.c
2c
#include	"../port/lib.h"
.
## diffname port/devdk.c 1992/0409
## diff -e /n/bootesdump/1992/0321/sys/src/9/port/devdk.c /n/bootesdump/1992/0409/sys/src/9/port/devdk.c
1368a

	/*
 	 *  set window size
	 */
	if(code == 0){
		if(waserror()){
			close(dc);
			nexterror();
		}
		sprint(reply, "init %d %d", lp->window, Streamhi);
		dc = dkopenline(dp, line);
		dc->qid.path = STREAMQID(line, Sctlqid);
		streamwrite(dc, reply, strlen(reply), 1);
		close(dc);
		poperror();
	}
.
1154a
	sprint(lp->other, "w=%d", lp->window);
.
947a
void
dkfillother(Chan *c, char *buf, int len)
{
	strncpy(buf, dk[c->dev].linep[STREAMID(c->qid.path)]->other, len);
}
.
547a
	lp->window = 0;
.
304a
	dp->net.info[4].name = "other";
	dp->net.info[4].fill = dkfillother;
.
296c
	dp->net.ninfo = 5;
.
202a
static void	dkfillother(Chan*, char*, int);
.
97a
	char	other[32];
.
## diffname port/devdk.c 1992/0520
## diff -e /n/bootesdump/1992/0409/sys/src/9/port/devdk.c /n/bootesdump/1992/0520/sys/src/9/port/devdk.c
1344a
	return -1;		/* never reached */
.
898a
	return -1;		/* never reached */
.
852a
	return -1;		/* never reached */
.
## diffname port/devdk.c 1992/0601
## diff -e /n/bootesdump/1992/0520/sys/src/9/port/devdk.c /n/bootesdump/1992/0601/sys/src/9/port/devdk.c
163,169c
	[DKbusy]"devdk: destination busy",
	[DKnetotl]"devdk: network not answering",
	[DKdestotl]"devdk: destination not answering",
	[DKbadnet]"devdk: unknown address",
	[DKnetbusy]"devdk: network busy",
	[DKinuse]"devdk: service in use",
	[DKreject]"devdk: connection refused", 
.
## diffname port/devdk.c 1992/0622
## diff -e /n/bootesdump/1992/0601/sys/src/9/port/devdk.c /n/bootesdump/1992/0622/sys/src/9/port/devdk.c
725c
		dk[i].prot = (Netprot*)xalloc(conf.nurp*sizeof(Netprot));
.
723c
	dk = (Dk*)xalloc(conf.dkif*sizeof(Dk));
.
270,286d
264,268c
	dp->linep = (Line **)xalloc(sizeof(Line*) * dp->lines);
	if(dp->linep == 0)
		error(Enomem);
	lp = xalloc(dp->lines*sizeof(Line));
	if(lp == 0)
		error(Enomem);
	for(i = 0; i < dp->lines; i++) {
		lp->lineno = i;
		dp->linep[i] = lp++;
.
232d
162,169c
	[DKok]		"",
	[DKbusy]	"devdk: destination busy",
	[DKnetotl]	"devdk: network not answering",
	[DKdestotl]	"devdk: destination not answering",
	[DKbadnet]	"devdk: unknown address",
	[DKnetbusy]	"devdk: network busy",
	[DKinuse]	"devdk: service in use",
	[DKreject]	"devdk: connection refused", 
.
## diffname port/devdk.c 1992/0623
## diff -e /n/bootesdump/1992/0622/sys/src/9/port/devdk.c /n/bootesdump/1992/0623/sys/src/9/port/devdk.c
1679a
			if(lp == 0)
				continue;
.
1667a
	for(;;){
.
1664,1666c
	while(waserror());
.
1640,1661d
1601d
1598c
	if(line < 0 || line >= dp->lines || (lp = dp->linep[line]) == 0)
.
1552a
			if(lp == 0)
				continue;
.
1532d
1527c
		if (line <= 0 || line >= dp->lines || (lp = dp->linep[line]) == 0) {
.
1496d
1491c
		if (line <= 0 || line >= dp->lines || (lp = dp->linep[line]) == 0) {
.
1397c
	lp = linealloc(&dk[c->dev], STREAMID(c->qid.path), 1);
.
1348c
	lp = linealloc(dp, line, 1);
.
1345a
	Dk *dp;
.
1343d
1324c
		netown(lp, dp->linep[from]->owner, 0);
.
1250c
		lp = linealloc(dp, lineno, 1);
.
1002c
	lp = linealloc(dp, line, 1);
.
919c
	qunlock(&dp->csclock);
.
914c
	Line *lp;

	qlock(&dp->csclock);
.
884a
	qunlock(&dp->netlock);
.
881c
			qunlock(&dp->netlock);
.
879c
			netown(lp, u->p->user, 0);
.
871,875c
		if(lp == 0 || lp->state == Lclosed){
			lp = linealloc(dp, line, 0);
.
868a
	qlock(&dp->netlock);
.
762c
	Dk *dp;

	dp = &dk[c->dev];
	linealloc(dp, STREAMID(c->qid.path), 1);
	return netopen(c, omode, &dp->net);
.
709,711c

	dk = (Dk*)xalloc(Maxdk*sizeof(Dk));
.
560c
 *  low order byte first.  Make sure the first block contains
 *  both the 2 channel bytes and the control byte.
.
539,544d
537c
	netdisown(lp);
.
479,483d
445,451d
402,403c
	lp = linealloc(dp, line, 1);
	if(lp && canqlock(lp)){
.
314,347d
300a
 *  allocate a line if it doesn't exist
 */
static Line*
linealloc(Dk *dp, int lineno, int dolock)
{
	Line *lp;

	if(dp->opened == 0)
		error(Enoifc);
	if(dolock)
		qlock(&dp->netlock);
	if(lineno > dp->lines)
		panic("linealloc");
	lp = dp->linep[lineno];
	if(lp == 0){
		lp = smalloc(sizeof(Line));
		lp->lineno = lineno;
		netadd(&dp->net, lp, lineno);
		dp->linep[lineno] = lp;
	}
	if(dolock)
		qunlock(&dp->netlock);
	return lp;
}

/*
.
283d
263,272c
	dp->linep = smalloc(sizeof(Line*) * dp->lines);
.
261c
	 *  allocate memory for array of pointers to lines.
	 *  line structures are allocated as needed.
.
250,252d
242c
		if(dp->name[0] == 0)
.
237c
	for(dp = dk; dp < &dk[Maxdk]; dp++){
.
227c
static Dk*
.
220c
	0,
.
212d
125,128d
111c
	Lock;
.
107,108c
	QLock	netlock;
	Network	net;

	QLock	csclock;
.
86a
	Netprot;		/* stat info */
.
18c
	Maxdk = 4,
.
## diffname port/devdk.c 1992/0625
## diff -e /n/bootesdump/1992/0623/sys/src/9/port/devdk.c /n/bootesdump/1992/0625/sys/src/9/port/devdk.c
1495d
1491,1493c
		if (line <= 0 || line >= dp->lines || (lp = dp->linep[line]) == 0)
.
1362c
	lp = linealloc(dk[c->dev], STREAMID(c->qid.path), 1);
.
1312c
	dp = dk[c->dev];
.
1142c
	dp = dk[c->dev];
.
966c
	dp = dk[c->dev];
.
909c
	strncpy(buf, dk[c->dev]->linep[STREAMID(c->qid.path)]->other, len);
.
904c
	strncpy(buf, dk[c->dev]->linep[STREAMID(c->qid.path)]->ruser, len);
.
899c
	strncpy(buf, dk[c->dev]->linep[STREAMID(c->qid.path)]->raddr, len);
.
894c
	strncpy(buf, dk[c->dev]->linep[STREAMID(c->qid.path)]->addr, len);
.
882,883c
	incref(dp->csc);
.
872c
 *  open the common signalling channel (dp->csc's reference count never goes below 1)
.
829c
	dp = dk[c->dev];
.
816c
	netwstat(c, dp, &dk[c->dev]->net);
.
746c
	return netread(c, a, n, offset, &dk[c->dev]->net);
.
724c
	dp = dk[c->dev];
.
716c
	netstat(c, dp, &dk[c->dev]->net);
.
710c
	return netwalk(c, name, &dk[c->dev]->net);
.
697c
	c->dev = dev;
.
691c
	for(dev = 0; dev < Maxdk; dev++){
		dp = dk[dev];
		if(dp && strcmp(dp->name, spec) == 0)
			break;
	}
	if(dev == Maxdk)
		error(Enoifc);
.
684a
	int dev;
.
669,671d
657a
	tsleep(&dp->closeallr, haveca, dp, 15000);
.
656d
646d
638d
632c
	q->ptr = q->other->ptr = dp;
	dk[n] = dp;
	unlock(&dklock);
	poperror();
.
628,630d
625a
	for(n = 0; n < Maxdk; n++){
		dp = dk[n];
		if(dp == 0)
			break;
		if(strcmp(name, dp->name) == 0)
			error(Einuse);
	}
	if(n == Maxdk)
		error(Enoifc);

	/*
	 *  allocate both a dk structure and an array of pointers to line
	 *  structures
	 */
	dp = smalloc(sizeof(Dk));
	dp->ncsc = ncsc;
	dp->lines = lines;
	dp->linep = smalloc(sizeof(Line*) * dp->lines);
	strcpy(dp->name, name);
	dp->net.name = dp->name;
	dp->net.nconv = dp->lines;
	dp->net.devp = &dkinfo;
	dp->net.protop = &urpinfo;
	dp->net.listen = dklisten;
	dp->net.clone = dkcloneline;
	dp->net.ninfo = 5;
	dp->net.info[0].name = "addr";
	dp->net.info[0].fill = dkfilladdr;
	dp->net.info[1].name = "raddr";
	dp->net.info[1].fill = dkfillraddr;
	dp->net.info[2].name = "ruser";
	dp->net.info[2].fill = dkfillruser;
	dp->net.info[3].name = "stats";
	dp->net.info[3].fill = urpfillstats;
	dp->net.info[4].name = "other";
	dp->net.info[4].fill = dkfillother;
.
620,624c
	lock(&dklock);
	if(waserror()){
		unlock(&dklock);
		nexterror();
.
618c
	 *  find a free dk slot.  it name is already configured
	 *  or no slots are left, error.
.
600a
		name[sizeof(name)-1] = 0;
.
501,502d
420c
	dp = dk[s->dev];
.
398,401c
static Streamopen dkstopen;
static Streamclose dkstclose;
static Streamput dkoput, dkiput;
.
321,322c
	naildownstream(s);
.
318c
	RD(q)->ptr = 0;
.
294,295d
223,286d
210,212c
static Streamopen dkmuxopen;
static Streamput dkmuxoput;
static Streamput dkmuxiput;
.
129,130c
Lock	dklock;
Dk	*dk[Maxdk];
.
122d
119d
114,116d
109c
	Network	net;		/* stat info */
	Line	**linep;	/* array of line structures */
.
107c
struct Dk
{
.
## diffname port/devdk.c 1992/0711
## diff -e /n/bootesdump/1992/0625/sys/src/9/port/devdk.c /n/bootesdump/1992/0711/sys/src/9/port/devdk.c
1560c
	int i;
.
1520d
1324d
843,844d
722a
	USED(offset);
.
698a
	USED(name);
	USED(omode);
	USED(perm);
.
## diffname port/devdk.c 1992/0717
## diff -e /n/bootesdump/1992/0711/sys/src/9/port/devdk.c /n/bootesdump/1992/0717/sys/src/9/port/devdk.c
1218a
		if(cp = strchr(lp->addr, '.')){
			*cp = '!';
			if(cp = strchr(cp, '.'))
				*cp = 0;
		}
.
1216c
		 *  Special characters are escaped by '\'s.  Convert to
		 *  a plan 9 address, i.e. system!service.
.
1107a
	char *cp;
.
1085d
876c
	Dk *dp;
	Line *lp;
	int line;
	char lbuf[65];

	line = STREAMID(c->qid.path);
	dp = dk[c->dev];
	lp = linealloc(dp, line, 1);
	sprint(lbuf, "%s/%d %d %s window %d\n", dp->name, line,
		lp->state != Lclosed ? 1 : 0, dkstate[lp->state], lp->window);
	strncpy(buf, lbuf, len);
.
874c
dkfillstatus(Chan *c, char *buf, int len)
.
871c
	if(len < sizeof(dk[0]->linep[0]->ruser)+2)
		error(Ebadarg);
	sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->ruser);
.
866c
	if(len < sizeof(dk[0]->linep[0]->raddr)+2)
		error(Ebadarg);
	sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->raddr);
.
861c
	if(len < sizeof(dk[0]->linep[0]->addr)+2)
		error(Ebadarg);
	sprint(buf, "%s\n", dk[c->dev]->linep[STREAMID(c->qid.path)]->addr);
.
588,589c
	dp->net.info[4].name = "status";
	dp->net.info[4].fill = dkfillstatus;
.
586c
	dp->net.info[3].name = "urpstats";
.
582c
	dp->net.info[1].name = "remote";
.
580c
	dp->net.info[0].name = "local";
.
200c
static void	dkfillstatus(Chan*, char*, int);
.
142a
char *dkstate[] =
{
	[Lclosed]	"Closed",
	[Lopened]	"Opened",
	[Lconnected]	"Established",
	[Lrclose]	"Rclose",
	[Llclose]	"Lclose",
	[Ldialing]	"Dialing",
	[Llistening]	"Listen",
	[Lackwait]	"Ackwait",
	[Laccepting]	"Accepting",
};
.
99d
## diffname port/devdk.c 1992/1030
## diff -e /n/bootesdump/1992/0717/sys/src/9/port/devdk.c /n/bootesdump/1992/1030/sys/src/9/port/devdk.c
1034c
	for(win = 0; ; win++)
		if(W_VALUE(win) >= dp->urpwindow || win == 15)
			break;
	dkmesg(csc, t_val, d_val, line, W_WINDOW(win, win, 2));
.
950c
	int line, win;
.
## diffname port/devdk.c 1992/1031
## diff -e /n/bootesdump/1992/1030/sys/src/9/port/devdk.c /n/bootesdump/1992/1031/sys/src/9/port/devdk.c
536a
		if(window < 16)
			window = 1<<(window+4);
.
527c
	window = 2048;
.
491c
 *	the urp window size (default==2048)
.
83d
## diffname port/devdk.c 1993/0501
## diff -e /n/bootesdump/1992/1031/sys/src/9/port/devdk.c /n/fornaxdump/1993/0501/sys/src/brazil/port/devdk.c
993c
		strcat(dialstr, up->user);
.
979c
	if(strlen(addr)+strlen(up->user)+2 >= sizeof(dialstr))
.
823c
			netown(lp, up->user, 0);
.
## diffname port/devdk.c 1993/0804 # deleted
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/devdk.c /n/fornaxdump/1993/0804/sys/src/brazil/port/devdk.c
1,1636d