## diffname gnot/devdk.c 1990/0312
## diff -e /dev/null /n/bootesdump/1990/0312/sys/src/9/68020/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 discipline 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[0] | (bp->rptr[1]<<8);
	bp->rptr += 2;
	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;
print("attach\n");

	/*
	 *  find a multiplexor with the same name
	 */
	for(dp = dk; dp < &dk[Ndk]; dp++){
		qlock(dp);
print("name %s %lux\n", dp->name, dp->wq);
		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;
print("attach done\n");
	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 gnot/devdk.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/68020/devdk.c /n/bootesdump/1990/0315/sys/src/9/68020/devdk.c
1124c
				DPRINT("DKbusy2 %ux\n", lp->state);
.
1118c
			DPRINT("DKbusy1\n");
.
596d
584d
577d
414a
	else
		panic("dkoput");
.
305c
		DPRINT("dkmuxiput unopened line %d\n", line);
.
300c
			DPRINT("dkmuxiput unopened line %d\n", line);
.
290c
		DPRINT("dkmuxiput bad line %d\n", line);
.
## diffname gnot/devdk.c 1990/0319
## diff -e /n/bootesdump/1990/0315/sys/src/9/68020/devdk.c /n/bootesdump/1990/0319/sys/src/9/68020/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 gnot/devdk.c 1990/0321
## diff -e /n/bootesdump/1990/0319/sys/src/9/68020/devdk.c /n/bootesdump/1990/0321/sys/src/9/68020/devdk.c
540a
	newqinfo(&dkmuxinfo);
	newqinfo(&urpinfo);
.
## diffname gnot/devdk.c 1990/0331
## diff -e /n/bootesdump/1990/0321/sys/src/9/68020/devdk.c /n/bootesdump/1990/0331/sys/src/9/68020/devdk.c
420c
	if(dp->wq->len >= Streamhi){
		print("dkoput free\n");
		freeb(bp);
	} else
		PUTNEXT(dp->wq, bp);
.
## diffname gnot/devdk.c 1990/0403
## diff -e /n/bootesdump/1990/0331/sys/src/9/68020/devdk.c /n/bootesdump/1990/0403/sys/src/9/68020/devdk.c
1134a
			if(lp->state != Lconnected)
				dkanswer(c, lineno, DKbusy);
.
420,424c
	PUTNEXT(dp->wq, bp);
.
## diffname gnot/devdk.c 1990/05313
## diff -e /n/bootesdump/1990/0403/sys/src/9/68020/devdk.c /n/bootesdump/1990/05313/sys/src/9/68020/devdk.c
1200a
	panic("dklisten terminates strangely\n");
.
898c
	if(lp->state != Lopened)
.
726c
	/* real closing happens in dkstclose */
.
676a
		qunlock(lp);
.
669d
420c
	if(QFULL(dp->wq->next)){
		print("dk wq full\n");
		freeb(bp);
	} else
		PUTNEXT(dp->wq, bp);
.
331a
	if(lp->state == Lclosed)
		lp->state = Lopened;
.
## diffname gnot/devdk.c 1990/0617
## diff -e /n/bootesdump/1990/05313/sys/src/9/68020/devdk.c /n/bootesdump/1990/0617/sys/src/9/68020/devdk.c
1291a

	/*
	 *  tell datakit we've rebooted. It should close all channels.
	 */
	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 gnot/devdk.c 1990/0707
## diff -e /n/bootesdump/1990/0617/sys/src/9/68020/devdk.c /n/bootesdump/1990/0707/sys/src/9/68020/devdk.c
1298a
	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 gnot/devdk.c 1990/0717
## diff -e /n/bootesdump/1990/0707/sys/src/9/68020/devdk.c /n/bootesdump/1990/0717/sys/src/9/68020/devdk.c
554c
	urpreset();
.
## diffname gnot/devdk.c 1990/0725
## diff -e /n/bootesdump/1990/0717/sys/src/9/68020/devdk.c /n/bootesdump/1990/0725/sys/src/9/68020/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 gnot/devdk.c 1990/0726
## diff -e /n/bootesdump/1990/0725/sys/src/9/68020/devdk.c /n/bootesdump/1990/0726/sys/src/9/68020/devdk.c
598,599d
596c
	 *  find a multiplexor with the same name
.
507c
		kproc("**dktimer**", dktimer, 0);
.
498c
	sprint(buf, "**csckproc%d**", dp->ncsc);
.
459d
## diffname gnot/devdk.c 1990/0728
## diff -e /n/bootesdump/1990/0726/sys/src/9/68020/devdk.c /n/bootesdump/1990/0728/sys/src/9/68020/devdk.c
1480c
	while(waserror())
		print("dktimer: error\n");
.
863a
	}
.
862c
	if(waserror()){
		print("dkmesg: error\n");
.
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 gnot/devdk.c 1990/08101
## diff -e /n/bootesdump/1990/0728/sys/src/9/68020/devdk.c /n/bootesdump/1990/08101/sys/src/9/68020/devdk.c
1320a
	}
	DPRINT("dkcsckproc: closeall %s\n", dp->name);
.
1319c
	if(dp->restart) {
		DPRINT("dkcsckproc: restart %s\n", dp->name);
.
498c
	sprint(buf, "csc.%s.%d", dp->name, dp->ncsc);
.
479a
	DPRINT("dkmuxconfig: ncsc=%d, lines=%d, restart=%d, name=\"%s\"\n",
		dp->ncsc, dp->lines, dp->restart, dp->name);
.
11a
#define	NOW	(MACHP(0)->ticks)

.
9,10c
#define	DPRINT	if(0)	/*kprint*/
.
## diffname gnot/devdk.c 1990/08163
## diff -e /n/bootesdump/1990/08101/sys/src/9/68020/devdk.c /n/bootesdump/1990/08163/sys/src/9/68020/devdk.c
981c
	dkmesg(dp, t_val, d_val, line, W_WINDOW(dp->urpwindow,dp->urpwindow,2));
.
461a
	case 5:
		dp->urpwindow = strtoul(fields[4], 0, 0);
.
460a
	dp->urpwindow = WS_2K;
.
459c
	n = getfields((char *)bp->rptr, fields, 5, ' ');
.
445c
	char *fields[5];
.
437c
 *	the name of the dk (default==dk)
 *	the urp window size (default==WS_2K)
.
432c
 *  configure a datakit multiplexor.  this takes 5 arguments separated
.
127a
	int	urpwindow;
.
## diffname gnot/devdk.c 1990/0905
## diff -e /n/bootesdump/1990/08163/sys/src/9/68020/devdk.c /n/bootesdump/1990/0905/sys/src/9/68020/devdk.c
418,421c
	bp = padb(bp, 2);
.
400c
 *  add a 2 byte channel number to the start of each message,
 *  low order byte first.
.
## diffname gnot/devdk.c 1990/0911
## diff -e /n/bootesdump/1990/0905/sys/src/9/68020/devdk.c /n/bootesdump/1990/0911/sys/src/9/68020/devdk.c
561d
## diffname gnot/devdk.c 1990/1004
## diff -e /n/bootesdump/1990/0911/sys/src/9/68020/devdk.c /n/bootesdump/1990/1004/sys/src/9/68020/devdk.c
1320,1329d
1115d
1105d
1103d
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 gnot/devdk.c 1990/1018
## diff -e /n/bootesdump/1990/1004/sys/src/9/68020/devdk.c /n/bootesdump/1990/1018/sys/src/9/68020/devdk.c
423,427c
	FLOWCTL(dp->wq);
	PUTNEXT(dp->wq, bp);
.
121c
	char	name[64];	/* dk name */
.
## diffname gnot/devdk.c 1990/1020
## diff -e /n/bootesdump/1990/1018/sys/src/9/68020/devdk.c /n/bootesdump/1990/1020/sys/src/9/68020/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 gnot/devdk.c 1990/1022
## diff -e /n/bootesdump/1990/1020/sys/src/9/68020/devdk.c /n/bootesdump/1990/1022/sys/src/9/68020/devdk.c
226,228d
209d
## diffname gnot/devdk.c 1990/1024
## diff -e /n/bootesdump/1990/1022/sys/src/9/68020/devdk.c /n/bootesdump/1990/1024/sys/src/9/68020/devdk.c
1555a
			unlock(dp);
.
1531a
			if(dp->csc==0){
				unlock(dp);
				continue;
			}
.
1530c
			if(!canlock(dp))
.
1328a
			if(n == 0)
				error(0, Ehungup);
.
1322a
	if(waserror()){
		Chan *csc;

		csc = dp->csc;
		lock(dp);
		dp->csc = 0;
		unlock(dp);
		close(csc);
		return;
	}

.
756,758c
	if(streamexit(dp->s, 0) == 0)
		dp->name[0] = 0;
.
754a
	/*
	 *  Let go of the mulitplexed stream.  If we're the last out,
	 *  free dp.
	 */
.
685d
681a
		dp = &dk[c->dev];
.
632,634c
	if(streamenter(dp->s) < 0)
		error(0, Ehungup);
.
625a
/*
 *  clone as long as the multiplexed channel is not closing
 *  down
 */
.
622a
	unlock(dp);
	poperror();
.
620a

	/*
	 *  don't let the multiplexed stream disappear under us
	 */
	if(streamenter(dp->s) < 0){
		/*
		 *  it's closing down, forget it
		 */
		unlock(dp);
		error(0, Ehungup);
	}

	/*
	 *  return the new channel
	 */
	if(waserror()){
		if(streamexit(dp->s, 0) == 0)
			dp->name[0] = 0;
		unlock(dp);
		nexterror();
	}
.
616,617c
		unlock(dp);
.
611,614c
		lock(dp);
		if(strcmp(spec, dp->name)==0)
.
275c
 *	work.
.
241,245c

	/*
	 *  if we're the last user of the stream,
	 *  free the Dk structure
	 */
	if(dp->s->inuse == 1)
		dp->name[0] = 0;

	/*
	 *  hang up all datakit connections
	 */
	for(i=dp->ncsc; i < dp->lines; i++)
		dkhangup(&dp->line[i]);
.
238a
	int i;
.
225c
			dp->s = s;
			unlock(dp);
.
223c
			strcpy(dp->name, "/");
.
216c
				unlock(dp);
.
212,214c
		if(dp->name[0]==0){
			lock(dp);
			if(dp->name[0]){
.
203a
 *  when we get though here dp->s is meaningful and the name is set to "/".
.
191a
static void	dkhangup(Line*);
.
122a
	Stream	*s;
.
119,120c
	Lock;
.
## diffname gnot/devdk.c 1990/1026
## diff -e /n/bootesdump/1990/1024/sys/src/9/68020/devdk.c /n/bootesdump/1990/1026/sys/src/9/68020/devdk.c
1613c
		tsleep(&dp->timer, return0, 0, 7500);
.
1611d
1603,1609c
				dkreplymesg(dp, (Dkmsg *)0, i);
				break;
.
1593,1601c
			case Ldialing:
				if(lp->calltolive==0 || --lp->calltolive!=0)
.
1588,1591c
		/*
		 *  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;
.
1579,1586c
		dkmesg(c, T_ALIVE, D_CONTINUE, 0, 0);
.
1577c
		 * send keep alive
.
1575a
		if(dp->opened==0)
			error(0, Ehungup);

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

.
1572,1573c
	c = 0;
	if(waserror()){
		if(c)
			close(c);
		return;
	}
.
1570a
	Chan *c;
.
1559,1564d
1557c
 *  send a I'm alive message every 7.5 seconds and remind the dk of
 *  any closed channels it hasn't acknowledged.
.
1463c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1454c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1448c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1427c
			dkmesg(c, T_CHG, D_CLOSE, line, 0);
.
1418c
dkchgmesg(Chan *c, Dk *dp, Dkmsg *dialp, int line)
.
1388c
			dkchgmesg(dp->csc, dp, &d, line);
.
1362,1368c
		close(dp->csc);
.
1359c
	dp = a;
.
1357d
1026c
	csc = dkopenline(dp, dp->ncsc);
	dkmesg(csc, t_val, d_val, line, W_WINDOW(dp->urpwindow,dp->urpwindow,2));
	close(csc);
	csc = 0;
.
1018a
	/*
	 *  open the data file
	 */
	dc = dkopenline(dp, line);
.
1016,1017d
1013c
		if(csc)
			close(csc);
		if(dc)
			close(dc);
.
1011c
	dc = 0;
	csc = 0;
.
1009c
	 *  close temporary channels on error
.
956c
	
.
954a
	Chan *csc;
.
929c
	streamwrite(c, (char *)&d, sizeof(Dkmsg), 1);
.
911,912d
909d
906c
dkmesg(Chan *c, int type, int srv, int p0, int p1)
.
902a
 *  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;
}

/*
.
789,796d
786d
665,669d
658,661d
653,654d
645,650d
632,642d
622,629c
	dp = dkalloc(spec);
.
528,531c
	sprint(buf, "timer.%s.%d", dp->name, dp->ncsc);
	kproc(buf, dktimer, dp);
.
526c
	 *  start a keepalive process
.
523d
519c
	 *  start a process to listen to csc messages
.
514,515c
		DPRINT("dktimer: restart %s\n", dp->name);
		dkmesg(dp->csc, T_ALIVE, D_RESTART, 0, 0);
.
511a
	 *  do this here to get it done before trying to open a channel.
.
510a
	 *  open csc here so that boot, dktimer, and dkcsckproc aren't
	 *  all fighting for it at once.
	 */
	dp->csc = dkopenline(dp, dp->ncsc);

	/*
.
505,508c
	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);
.
499,503c
	dp = dkalloc(name);
	lock(dp);
	if(dp->opened){
		unlock(dp);
		error(0, Ebadarg);
.
497c
	 *  set up
.
492,494d
489,490c
	if(ncsc <= 0 || lines <= ncsc)
.
482c
		ncsc = strtoul(fields[0], 0, 0);
.
480c
		lines = strtoul(fields[1], 0, 0);
.
478c
			restart = 0;
.
475c
		strncpy(name, fields[3], sizeof(name));
.
473c
		window = strtoul(fields[4], 0, 0);
.
469,470d
467d
464a
	 *  defaults
	 */
	ncsc = 1;
	restart = 1;
	lines = 16;
	window = WS_2K;
	strcpy(name, "dk");

	/*
.
461c
		error(0, Egreg);
.
459c
	if(WR(q)->ptr){
.
457c
	char name[NAMELEN];
	int lines;
	int ncsc;
	int restart;
	int window;
.
453c
	Dk *dp;
.
451c
dkmuxconfig(Queue *q, Block *bp)
.
394a
out:
.
393a
	poperror();
	close(c);
.
387c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
382c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
377c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
372c
		dkmesg(c, T_CHG, D_CLOSE, lp - dp->line, 0);
.
363a
	 *  decrement ref count on mux'd line
	 */
	streamexit(dp->s, 0);

	/*
	 *  don't tell controller about closing down the csc
	 */
	if(lp - dp->line == dp->ncsc)
		goto out;

	c = 0;
	if(waserror()){
		if(c)
			close(c);
		lp->state = Lclosed;
		goto out;
	}	
	c = dkopenline(dp, dp->ncsc);

	/*
.
358a
	Chan *c;
.
343a
	lock(dp);
	if(dp->opened==0 || streamenter(dp->s)<0){
		unlock(dp);
		error(0, Ehungup);
	}
	unlock(dp);
.
295a
	/*
	 *  not configured yet
	 */
	if(q->other->ptr == 0){
		freeb(bp);
		return;
	}

.
271c
			dkmuxconfig(q, bp);
.
266,268d
257a

	/*
	 *  wakeup the timer so it can die
	 */
	wakeup(&dp->timer);
.
250,251c
	lock(dp);
	dp->opened = 0;
	unlock(dp);
.
247,248c
	 *  disallow new dkstopens() on this line.
	 *  the lock syncs with dkstopen().
.
244c
	dp = WR(q)->ptr;
	if(dp == 0)
		return;
.
235a
 *  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;
}

/*
.
232c
	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;
.
230a
		if(dp->name[0] == 0)
			freep = dp;
.
214,229c
		if(strcmp(name, dp->name) == 0){
			unlock(&dklock);
			return dp;
.
212a
	lock(&dklock);
	freep = 0;
.
211c
	Dk *freep;
.
204,208c
 *  Look for a dk struct with a name.  If none exists,  create one.
 */ 
static Dk *
dkalloc(char *name)
.
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;
.
119a
	int	opened;
.
## diffname gnot/devdk.c 1990/1101
## diff -e /n/bootesdump/1990/1026/sys/src/9/68020/devdk.c /n/bootesdump/1990/1101/sys/src/9/68020/devdk.c
1620a
		/*
		 *  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;

			case Ldialing:
				dkreplymesg(dp, (Dkmsg *)0, i);
				break;
			}
		}
.
1548a
				dkhangup(lp);
.
1547d
1532a
		/*
		 *  datakit wants us to close all lines
		 */
.
1455d
1451,1453c
			if(line >=0 && line<dp->lines)
.
1191,1192d
1186c
	dc = dkopenline(dp, STREAMID(c->qid));
.
822,823d
774d
771a
		lp->state = Lopened;
		qunlock(lp);
.
445,447d
422,425d
413d
410a
		lp->state = Lclosed;
.
407a
	}
.
406c
	switch(lp->state){
	case Lclosed:
	case Llclose:
	case Lopened:
		lp->state = Lclosed;
.
404c
	 *  these states don't need the datakit
.
398a
	 *  if we never got going, we're done
	 */
	if(lp->rq == 0){
		lp->state = Lclosed; 
		return;
	}

	/*
.
382a
	lp->rq = q;
.
378,381c
	if(lp->state==Lclosed)
.
371a
	q->other->ptr = q->ptr = lp = &dp->line[s->id];
	lp->dp = dp;
.
## diffname gnot/devdk.c 1990/1104
## diff -e /n/bootesdump/1990/1101/sys/src/9/68020/devdk.c /n/bootesdump/1990/1104/sys/src/9/68020/devdk.c
382d
379a
	lp->rq = q;
.
## diffname gnot/devdk.c 1990/11151
## diff -e /n/bootesdump/1990/1104/sys/src/9/68020/devdk.c /n/bootesdump/1990/11151/sys/src/9/68020/devdk.c
360c
Qinfo dkinfo =
{
	dkiput,
	dkoput,
	dkstopen,
	dkstclose,
	"dk"
};
.
205c
Qinfo dkmuxinfo =
{
	dkmuxiput,
	dkmuxoput,
	dkmuxopen,
	dkmuxclose,
	"dkmux"
};
.
## diffname gnot/devdk.c 1990/11211
## diff -e /n/bootesdump/1990/11151/sys/src/9/68020/devdk.c /n/bootesdump/1990/11211/sys/src/9/68020/devdk.c
1670a
		DPRINT("keep alive\n");
.
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);
.
9c
#define	DPRINT	if(0) print
.
## diffname gnot/devdk.c 1990/1126
## diff -e /n/bootesdump/1990/11211/sys/src/9/68020/devdk.c /n/bootesdump/1990/1126/sys/src/9/68020/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 gnot/devdk.c 1990/1210 # deleted
## diff -e /n/bootesdump/1990/1126/sys/src/9/68020/devdk.c /n/bootesdump/1990/1210/sys/src/9/68020/devdk.c
1,1684d