implement Styxconv;

include "sys.m";
	sys: Sys;
include "osys.m";
include "nsys.m";
include "draw.m";
include "styx.m";
	nstyx: Styx;
	Tmsg, Rmsg: import nstyx;
include "ostyx.m";
	ostyx: OStyx;
	OTmsg, ORmsg: import ostyx;
include "styxconv.m";

DEBUG: con 0;

# convert from old styx client to new styx server.
# more straightforward than the other way around
# because there's an almost exactly 1-1 mapping
# between message types. (the exception is Tversion,
# but we do that synchronously anyway).

# todo: map qids > ffffffff into 32 bits.

Msize: con nstyx->IOHDRSZ + OSys->ATOMICIO;
Fid: adt
{
	fid: int;
	isdir: int;
	n: int;			# size of last new client dirread request.
	soff: int;			# dir offset on new server.
	coff: int;			# dir offset on old client.
	next: cyclic ref Fid;
	extras: array of byte;	# packed old styx dir structures
};

Req: adt {
	tag: int;
	fid: int;
	oldtag: int;			# if it's a flush.
	newfid: int;			# if it's a clone
	next: cyclic ref Req;
};

tags: ref Req;
fids: ref Fid;

init()
{
	sys = load Sys Sys->PATH;
	if(sys == nil)
		nomod("Sys", Sys->PATH);
	nstyx = load Styx Styx->PATH;
	if(nstyx == nil)
		nomod("Styx", Styx->PATH);
	ostyx = load OStyx OStyx->PATH;
	if(ostyx == nil)
		nomod("OStyx", OStyx->PATH);

	ostyx->init();
	nstyx->init();
}

styxconv(oldclient, newsrv: ref Sys->FD)
{
	oldtmsg := chan of ref OTmsg;
	newrmsg := chan of ref Rmsg;

	killpids := chan[2] of int;
	spawn readoldtmsgs(killpids, oldclient, oldtmsg);
	spawn readnewrmsgs(killpids, newsrv, newrmsg);
	# XXX difficulty: what happens if the server isn't responding
	# and the client hangs up? we won't know about it.
	# but we don't want to know about normal t-messages
	# piling up either, so we don't want to alt on oldtmsg too.
	NTsend(newsrv, ref Tmsg.Version(nstyx->NOTAG, Msize, "9P2000"));
	pick nrm := <-newrmsg {
	Version =>
		if(DEBUG)
			sys->fprint(sys->fildes(2), "	<- %s\n", nrm.text());
		if(nrm.msize < Msize)
			fatal("message size too small");
	Error =>
		fatal("versioning failed: " + nrm.ename);
	* =>
		fatal("bad response to Tversion: " + nrm.text());
	}

converting:
	for(;;)alt{
	otm := <-oldtmsg =>
		if(DEBUG)
			sys->fprint(sys->fildes(2), "-> %s\n", ostyx->tmsg2s(otm));
		if(otm == nil || tagof(otm) == tagof(OTmsg.Readerror))
			break converting;
		oc2ns(otm, oldclient, newsrv);
	nrm := <-newrmsg =>
		if(DEBUG)
			sys->fprint(sys->fildes(2), "	<- %s\n", nrm.text());
		if(nrm == nil || tagof(nrm) == tagof(Rmsg.Readerror))
			break converting;
		t := looktag(nrm.tag);
		if(t == nil){
			warning("reply by new-server to non-existent tag");
			break;
		}
		ns2oc(t, nrm, oldclient);
		deletetag(nrm.tag);
	}

	kill(<-killpids);
	kill(<-killpids);
}

# T messages: forward on or reply immediately
oc2ns(tm0: ref OTmsg, oldclient, newsrv: ref Sys->FD)
{
	ntm: ref Tmsg;

	t := ref Req(tm0.tag, -1, -1, -1, nil);
	pick tm := tm0{
	Nop =>
		ORsend(oldclient, ref ORmsg.Nop(tm.tag));
		return;
	Attach =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Attach(tm.tag, tm.fid, nstyx->NOFID, tm.uname, tm.aname);
	Clone =>
		t.fid = tm.fid;
		t.newfid = tm.newfid;
		ntm = ref Tmsg.Walk(tm.tag, tm.fid, tm.newfid, nil);
	Walk =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Walk(tm.tag, tm.fid, tm.fid, array[] of {tm.name});
	Flush =>
		t.oldtag = tm.oldtag;
		ntm = ref Tmsg.Flush(tm.tag, tm.oldtag);
	Open =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Open(tm.tag, tm.fid, tm.mode);
	Create =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Create(tm.tag, tm.fid, tm.name, tm.perm, tm.mode);
	Read =>
		t.fid = tm.fid;
		fp := findfid(tm.fid);
		count := tm.count;
		offset := tm.offset;
		if(fp.isdir){
			count = (count/OStyx->DIRLEN)*OStyx->DIRLEN;
			# if we got some extra entries last time,
			# then send 'em back this time.
			extras := fp.extras;
			if(len extras > 0){
				if(count > len extras)
					count = len extras;
				ORsend(oldclient, ref ORmsg.Read(tm.tag, t.fid, fp.extras[0:count]));
				fp.extras = extras[count:];
				fp.coff += count;
				return;
			}
			fp.n = count;
			if(int offset != fp.coff){
				ORsend(oldclient, ref ORmsg.Error(tm.tag, "unexpected offset in dirread"));
				return;
			}
			offset = big fp.soff;
		}
		ntm = ref Tmsg.Read(tm.tag, tm.fid, offset, count);
	Write =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Write(tm.tag, tm.fid, tm.offset, tm.data);
	Clunk =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Clunk(tm.tag, tm.fid);
	Remove =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Remove(tm.tag, tm.fid);
	Stat =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Stat(tm.tag, tm.fid);
	Wstat =>
		t.fid = tm.fid;
		ntm = ref Tmsg.Wstat(tm.tag, tm.fid, od2nd(tm.stat));
	* =>
		fatal("bad T message");
	}
	storetag(t);
	NTsend(newsrv, ntm);
}

# R messages: new to old
ns2oc(t: ref Req, nrm0: ref Rmsg, oldclient: ref Sys->FD)
{
	rm: ref ORmsg;
	pick nrm := nrm0{
	Error =>
		rm = ref ORmsg.Error(nrm.tag, nrm.ename);
	Flush =>
		rm = ref ORmsg.Flush(nrm.tag);
		deletetag(t.oldtag);
	Walk =>
		if(len nrm.qids == 0){
			clonefid(t.fid, t.newfid);
			rm = ref ORmsg.Clone(nrm.tag, t.fid);
		}else{
			q := nrm.qids[0];
			setfid(t.fid, q);
			rm = ref ORmsg.Walk(nrm.tag, t.fid, nq2oq(q));
		}
	Open =>
		setfid(t.fid, nrm.qid);
		rm = ref ORmsg.Open(nrm.tag, t.fid, nq2oq(nrm.qid));
	Create =>
		setfid(t.fid, nrm.qid);
		rm = ref ORmsg.Create(nrm.tag, t.fid, nq2oq(nrm.qid));
	Read =>
		fp := findfid(t.fid);
		data := nrm.data;
		if(fp != nil && fp.isdir){
			data = nds2ods(data);
			if(len data > fp.n){
				fp.extras = data[fp.n:];
				data = data[0:fp.n];
			}
			fp.coff += len data;
			fp.soff += len nrm.data;
		}
		rm = ref ORmsg.Read(nrm.tag, t.fid, data);
	Write =>
		rm = ref ORmsg.Write(nrm.tag, t.fid, nrm.count);
	Clunk =>
		deletefid(t.fid);
		rm = ref ORmsg.Clunk(nrm.tag, t.fid);
	Remove =>
		deletefid(t.fid);
		rm = ref ORmsg.Remove(nrm.tag, t.fid);
	Stat =>
		rm = ref ORmsg.Stat(nrm.tag, t.fid, nd2od(nrm.stat));
	Wstat =>
		rm = ref ORmsg.Wstat(nrm.tag, t.fid);
	Attach =>
		newfid(t.fid, nrm.qid.qtype & NSys->QTDIR);
		rm = ref ORmsg.Attach(nrm.tag, t.fid, nq2oq(nrm.qid));
	* =>
		fatal("bad R message");
	}
	ORsend(oldclient, rm);
}

storetag(t: ref Req)
{
	t.next = tags;
	tags = t;
}

looktag(tag: int): ref Req
{
	for(t := tags; t != nil; t = t.next)
		if(t.tag == tag)
			return t;
	return nil;
}

deletetag(tag: int)
{
	prev: ref Req;
	t := tags;
	while(t != nil){
		if(t.tag == tag){
			next := t.next;
			t.next = nil;
			if(prev != nil)
				prev.next = next;
			else
				tags = next;
			t = next;
		}else{
			prev = t;
			t = t.next;
		}
	}
}

newfid(fid: int, isdir: int): ref Fid
{
	f := ref Fid;
	f.fid = fid;
	f.isdir = isdir;
	f.n = f.soff = f.coff = 0;
	f.next = fids;
	fids = f;
	return f;
}

clonefid(ofid: int, fid: int): ref Fid
{
	if((f := findfid(ofid)) != nil)
		return newfid(fid, f.isdir);
	warning("clone of non-existent fid");
	return newfid(fid, 0);
}

deletefid(fid: int)
{
	lf: ref Fid;

	for(f := fids; f != nil; f = f.next){
		if(f.fid == fid){
			if(lf == nil)
				fids = f.next;
			else
				lf.next = f.next;
			return;
		}
		lf = f;
	}
}

findfid(fid: int): ref Fid
{
	for(f := fids; f != nil && f.fid != fid; f = f.next)
		;
	return f;
}

setfid(fid: int, qid: NSys->Qid)
{
	if((f := findfid(fid)) != nil)
		f.isdir = qid.qtype & NSys->QTDIR;
}

om2nm(om: int): int
{
	# DMDIR == CHDIR
	return om;
}

nm2om(m: int): int
{
	# DMDIR == CHDIR
	return m&~(NSys->DMAPPEND|NSys->DMEXCL|NSys->DMAUTH);
}

oq2nq(oq: OSys->Qid): NSys->Qid
{
	q: NSys->Qid;

	isdir := oq.path&OSys->CHDIR;
	q.path = big (oq.path&~OSys->CHDIR);
	q.vers = oq.vers;
	q.qtype = 0;
	if(isdir)
		q.qtype |= NSys->QTDIR;
	return q;
}
	
nq2oq(q: NSys->Qid): OSys->Qid
{
	oq: OSys->Qid;

	isdir := q.qtype&NSys->QTDIR;
	oq.path = int q.path;
	oq.vers = q.vers;
	if(isdir)
		oq.path |= OSys->CHDIR;
	return oq;
}

od2nd(od: OSys->Dir): NSys->Dir
{
	d: NSys->Dir;

	d.name = od.name;
	d.uid = od.uid;
	d.gid = od.gid;
	d.muid = od.uid;
	d.qid = oq2nq(od.qid);
	d.mode = om2nm(od.mode);
	d.atime = od.atime;
	d.mtime = od.mtime;
	d.length = big od.length;
	d.dtype = od.dtype;
	d.dev = od.dev;
	return d;
}

nd2od(d: NSys->Dir): OSys->Dir
{
	od: OSys->Dir;

	od.name = d.name;
	od.uid = d.uid;
	od.gid = d.gid;
	od.qid = nq2oq(d.qid);
	od.mode = nm2om(d.mode);
	od.atime = d.atime;
	od.mtime = d.mtime;
	od.length = int d.length;
	od.dtype = d.dtype;
	od.dev = d.dev;
	return od;
}

nds2ods(ob: array of byte): array of byte
{
	i := 0;
	n := 0;
	ds: list of NSys->Dir;
	while(i < len ob){
		(size, d) := nstyx->unpackdir(ob[i:]);
		if(size == 0)
			break;
		ds = d :: ds;
		i += size;
		n++;
	}
	b := array[OStyx->DIRLEN * n] of byte;
	for(i = (n - 1) * OStyx->DIRLEN; i >= 0; i -= OStyx->DIRLEN){
		ostyx->convD2M(b[i:], nd2od(hd ds));
		ds = tl ds;
	}
	return b;
}

NTsend(fd: ref Sys->FD, ntm: ref Tmsg)
{
	if(DEBUG)
		sys->fprint(sys->fildes(2), "	-> %s\n", ntm.text());
	s := ntm.pack();
	sys->write(fd, s, len s);
}

ORsend(fd: ref Sys->FD, orm: ref ORmsg)
{
	if(DEBUG)
		sys->fprint(sys->fildes(2), "<- %s\n", ostyx->rmsg2s(orm));
	s := array[OStyx->MAXRPC] of byte;
	n := ostyx->rmsg2d(orm, s);
	if(n > 0)
		sys->write(fd, s, n);
}

readoldtmsgs(pidc: chan of int, oldclient: ref Sys->FD, oldtmsg: chan of ref OTmsg)
{
	pidc <-= sys->pctl(0, nil);
	for(;;){
		oldtmsg <-= OTmsg.read(oldclient);
	}
}

readnewrmsgs(pidc: chan of int, newsrv: ref Sys->FD, newrmsg: chan of ref Rmsg)
{
	pidc <-= sys->pctl(0, nil);
	for(;;){
		newrmsg <-= Rmsg.read(newsrv, Msize);
	}
}

warning(err: string)
{
	sys->fprint(sys->fildes(2), "warning: %s\n", err);
}

fatal(err: string)
{
	sys->fprint(sys->fildes(2), "%s\n", err);
	exit;
}

nomod(mod: string, path: string)
{
	fatal(sys->sprint("can't load %s(%s): %r", mod, path));
}

kill(pid: int)
{
	sys->fprint(sys->open("#p/"+string pid+"/ctl", Sys->OWRITE), "kill");
}