implement Dossrv;

include "sys.m";
	sys: Sys;

include "draw.m";

include "arg.m";

include "daytime.m";
	daytime: Daytime;

include "styx.m";
	styx: Styx;
	Tmsg, Rmsg: import styx;

Dossrv: module
{
        init:   fn(ctxt: ref Draw->Context, args: list of string);
        system:   fn(ctxt: ref Draw->Context, args: list of string): string;
};

arg0 := "dossrv";

deffile: string;
pflag := 0;
debug := 0;

usage(iscmd: int): string
{
	sys->fprint(sys->fildes(2), "usage: %s [-v] [-s] [-F] [-c] [-S secpertrack] [-f devicefile] [-m mountpoint]\n", arg0);
	if(iscmd)
		raise "fail:usage";
	return "usage";
}

init(nil: ref Draw->Context, args: list of string)
{
	e := init2(nil, args, 1);
	if(e != nil){
		sys->fprint(sys->fildes(2), "%s: %s\n", arg0, e);
		raise "fail:error";
	}
}

system(nil: ref Draw->Context, args: list of string): string
{
	e := init2(nil, args, 0);
	if(e != nil)
		sys->fprint(sys->fildes(2), "%s: %s\n", arg0, e);
	return e;
}

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

init2(nil: ref Draw->Context, args: list of string, iscmd: int): string
{
	sys = load Sys Sys->PATH;

	pipefd := array[2] of ref Sys->FD;

	srvfile := "/n/dos"; 
	deffile = "";	# no default, for safety
	sectors := 0;
	stdin := 0;

	arg := load Arg Arg->PATH;
	if(arg == nil)
		return nomod(Arg->PATH);
	arg->init(args);
	arg0 = arg->progname();
	while((o := arg->opt()) != 0) {
		case o {
		'v' =>
			if(debug & STYX_MESS)
				debug |= VERBOSE;
			debug |= STYX_MESS;
		'F' =>
			debug |= FAT_INFO;
		'c' =>
			debug |= CLUSTER_INFO;
			iodebug = 1;
		'S' =>
			s := arg->arg();
			if(s != nil && s[0]>='0' && s[0]<='9')
				sectors = int s;
			else
				return usage(iscmd);
		's' =>
			stdin = 1;
		'f' =>
			deffile = arg->arg();
			if(deffile == nil)
				return usage(iscmd);
		'm' =>
			srvfile = arg->arg();
			if(srvfile == nil)
				return usage(iscmd);
		'p' =>
			pflag++;
		* =>
			return usage(iscmd);
		}
	}
	args = arg->argv();
	arg = nil;

	if(deffile == "" || !stdin && srvfile == "")
		return usage(iscmd);

	styx = load Styx Styx->PATH;
	if(styx == nil)
		return nomod(Styx->PATH);
	styx->init();

	daytime = load Daytime Daytime->PATH;
	if(daytime == nil)
		return nomod(Daytime->PATH);

	iotrackinit(sectors);

	if(!stdin) {
		if(sys->pipe(pipefd) < 0)
			return sys->sprint("can't create pipe: %r");
	}else{
		pipefd[0] = nil;
		pipefd[1] = sys->fildes(1);
	}

	dossetup();

	spawn dossrv(pipefd[1]);

	if(!stdin) {
		if(sys->mount(pipefd[0], nil, srvfile, sys->MREPL|sys->MCREATE, deffile) < 0)
			return sys->sprint("mount %s: %r", srvfile);
	}

	return nil;
}

#
# Styx server
#

	Enevermind,
	Eformat,
	Eio,
	Enomem,
	Enonexist,
	Enotdir,
	Enofid,
	Efidopen,
	Efidinuse,
	Eexist,
	Eperm,
	Enofilsys,
	Eauth,
	Econtig,
	Efull,
	Eopen,
	Ephase: con iota;

errmsg := array[] of {
	Enevermind	=> "never mind",
	Eformat		=> "unknown format",
	Eio		=> "I/O error",
	Enomem		=> "server out of memory",
	Enonexist	=> "file does not exist",
	Enotdir => "not a directory",
	Enofid => "no such fid",
	Efidopen => "fid already open",
	Efidinuse => "fid in use",
	Eexist		=> "file exists",
	Eperm		=> "permission denied",
	Enofilsys	=> "no file system device specified",
	Eauth		=> "authentication failed",
	Econtig =>	"out of contiguous disk space",
	Efull =>	"file system full",
	Eopen =>	"invalid open mode",
	Ephase => "phase error -- directory entry not found",
};

e(n: int): ref Rmsg.Error
{
	if(n < 0 || n >= len errmsg)
		return ref Rmsg.Error(0, "it's thermal problems");
	return ref Rmsg.Error(0, errmsg[n]);
}

dossrv(rfd: ref Sys->FD)
{
	sys->pctl(Sys->NEWFD, rfd.fd :: 2 :: nil);
	rfd = sys->fildes(rfd.fd);
	while((t := Tmsg.read(rfd, 0)) != nil){
		if(debug & STYX_MESS)
			chat(sys->sprint("%s...", t.text()));

		r: ref Rmsg;
		pick m := t {
		Readerror =>
			panic(sys->sprint("mount read error: %s", m.error));
		Version =>
 			r = rversion(m);
		Auth =>
			r = rauth(m);
		Flush =>
 			r = rflush(m);
		Attach =>
 			r = rattach(m);
		Walk =>
 			r = rwalk(m);
		Open =>
 			r = ropen(m);
		Create =>
 			r = rcreate(m);
		Read =>
 			r = rread(m);
		Write =>
 			r = rwrite(m);
		Clunk =>
 			r = rclunk(m);
		Remove =>
 			r = rremove(m);
		Stat =>
 			r = rstat(m);
		Wstat =>
 			r = rwstat(m);
		* =>
			panic("Styx mtype");
		}
		pick m := r {
		Error =>
			r.tag = t.tag;
		}
		rbuf := r.pack();
		if(rbuf == nil)
			panic("Rmsg.pack");
		if(debug & STYX_MESS)
			chat(sys->sprint("%s\n", r.text()));
		if(sys->write(rfd, rbuf, len rbuf) != len rbuf)
			panic("mount write");
	}

	if(debug & STYX_MESS)
		chat("server EOF\n");
}

rversion(t: ref Tmsg.Version): ref Rmsg
{
	(msize, version) := styx->compatible(t, Styx->MAXRPC, Styx->VERSION);
	return ref Rmsg.Version(t.tag, msize, version);
}

rauth(t: ref Tmsg.Auth): ref Rmsg
{
	return ref Rmsg.Error(t.tag, "authentication not required");
}

rflush(t: ref Tmsg.Flush): ref Rmsg
{
	return ref Rmsg.Flush(t.tag);
}

rattach(t: ref Tmsg.Attach): ref Rmsg
{
	root := xfile(t.fid, Clean);
	if(root == nil)
		return e(Eio);
	if(t.aname == nil)
		t.aname = deffile;
	(xf, ec) := getxfs(t.aname);
	root.xf = xf;
	if(xf == nil) {
		if(root!=nil)
			xfile(t.fid, Clunk);
		return ref Rmsg.Error(t.tag, ec);
	}
	if(xf.fmt == 0 && dosfs(xf) < 0){
		if(root!=nil)
			xfile(t.fid, Clunk);
		return e(Eformat);
	}

	root.qid = Sys->Qid(big 0, 0, Sys->QTDIR);
	root.xf.rootqid = root.qid;
	return ref Rmsg.Attach(t.tag, root.qid);
}

clone(ofl: ref Xfile, newfid: int): ref Xfile
{
	nfl := xfile(newfid, Clean);
	next := nfl.next;
	*nfl = *ofl;
	nfl.ptr = nil;
	nfl.next = next;
	nfl.fid = newfid;
	refxfs(nfl.xf, 1);
	if(ofl.ptr != nil){
		dp := ref *ofl.ptr;
		dp.p = nil;
		dp.d = nil;
		nfl.ptr = dp;
	}
	return nfl;
}

walk1(f: ref Xfile, name: string): ref Rmsg.Error
{
	if((f.qid.qtype & Sys->QTDIR) == 0){
		if(debug)
			chat(sys->sprint("qid.path=0x%bx...", f.qid.path));
		return e(Enotdir);
	}

	if(name == ".")	# can't happen
		return nil;

	if(name== "..") {
		if(f.qid.path == f.xf.rootqid.path) {
			if (debug)
				chat("walkup from root...");
			return nil;
		}
		(r,dp) := walkup(f);
		if(r < 0)
			return e(Enonexist);

		f.ptr = dp;
		if(dp.addr == 0) {
			f.qid.path = f.xf.rootqid.path;
			f.qid.qtype = Sys->QTFILE;
		} else {
			f.qid.path = QIDPATH(dp);
			f.qid.qtype = Sys->QTDIR;
		}
	} else {
		if(getfile(f) < 0)
			return e(Enonexist);
		(r,dp) := searchdir(f, name, 0,1);
		putfile(f);
		if(r < 0)
			return e(Enonexist);

		f.ptr = dp;
		f.qid.path = QIDPATH(dp);
		f.qid.qtype = Sys->QTFILE;
		if(dp.addr == 0)
			f.qid.path = f.xf.rootqid.path;
		else {
			d := Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
			if((int d.attr & DDIR) !=  0)
				f.qid.qtype = Sys->QTDIR;
		}
		putfile(f);
	}
	return nil;
}

rwalk(t: ref Tmsg.Walk): ref Rmsg
{
	f := xfile(t.fid, Asis);
	if(f==nil) {
		if(debug)
			chat("no xfile...");
		return e(Enofid);
	}
	nf: ref Xfile;
	if(t.newfid != t.fid)
		f = nf = clone(f, t.newfid);
	qids: array of Sys->Qid;
	if(len t.names > 0){
		savedqid := f.qid;
		savedptr := f.ptr;
		qids = array[len t.names] of Sys->Qid;
		for(i := 0; i < len t.names; i++){
			e := walk1(f, t.names[i]);
			if(e != nil){
				f.qid = savedqid;
				f.ptr = savedptr;
				if(nf != nil)
					xfile(t.newfid, Clunk);
				if(i == 0)
					return e;
				return ref Rmsg.Walk(t.tag, qids[0:i]);
			}
			qids[i] = f.qid;
		}
	}
	return ref Rmsg.Walk(t.tag, qids);
}

ropen(t: ref Tmsg.Open): ref Rmsg
{
	attr: int;

	omode := 0;
	f := xfile(t.fid, Asis);
	if(f == nil)
		return e(Enofid);
	if((f.flags&Omodes) != 0)
		return e(Efidopen);

	dp := f.ptr;
	if(dp.paddr && (t.mode & Styx->ORCLOSE) != 0) {
		# check on parent directory of file to be deleted
		p := getsect(f.xf, dp.paddr);
		if(p == nil)
			return e(Eio);
		# 11 is the attr byte offset in a FAT directory entry
		attr = int p.iobuf[dp.poffset+11];
		putsect(p);
		if((attr & int DRONLY) != 0)
			return e(Eperm);
		omode |= Orclose;
	} else if(t.mode & Styx->ORCLOSE)
		omode |= Orclose;

	if(getfile(f) < 0)
		return e(Enonexist);

	if(dp.addr != 0) {
		d := Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
		attr = int d.attr;
	} else
		attr = int DDIR;

	case t.mode & 7 {
	Styx->OREAD or
	Styx->OEXEC =>
		omode |= Oread;
	Styx->ORDWR =>
		omode |= Oread;
		omode |= Owrite;
		if(attr & int (DRONLY|DDIR)) {
			putfile(f);
			return e(Eperm);
		}
	Styx->OWRITE =>
		omode |= Owrite;
		if(attr & int (DRONLY|DDIR)) {
			putfile(f);
			return e(Eperm);
		}
	* =>
		putfile(f);
		return e(Eopen);
	}

	if(t.mode & Styx->OTRUNC) {
		if((attr & int DDIR)!=0 || (attr & int DRONLY) != 0) {
			putfile(f);
			return e(Eperm);
		}

		if(truncfile(f) < 0) {
			putfile(f);
			return e(Eio);
		}
	}

	f.flags |= omode;
	putfile(f);
	return ref Rmsg.Open(t.tag, f.qid, Styx->MAXFDATA);
}

mkdentry(xf: ref Xfs, ndp: ref Dosptr, name: string, sname: string, islong: int, nattr: byte, start: array of byte, length: array of byte): int
{
	ndp.p = getsect(xf, ndp.addr);
	if(ndp.p == nil)
		return Eio;
	if(islong && (r := putlongname(xf, ndp, name, sname)) < 0){
		putsect(ndp.p);
		if(r == -2)
			return Efull;
		return Eio;
	}

	nd := ref Dosdir(".       ","   ",byte 0,array[10] of { * => byte 0},
			array[2] of { * => byte 0}, array[2] of { * => byte 0},
			array[2] of { * => byte 0},array[4] of { * => byte 0});

	nd.attr = nattr;
	puttime(nd);
	nd.start[0: ] = start[0: 2];
	nd.length[0: ] = length[0: 4];

	if(islong)
		putname(sname[0:8]+"."+sname[8:11], nd);
	else
		putname(name, nd);
	ndp.p.iobuf[ndp.offset: ] = Dosdir.Dd2arr(nd);
	ndp.p.flags |= BMOD;
	return 0;
}

rcreate(t: ref Tmsg.Create): ref Rmsg
{
	bp: ref Dosbpb;
	omode:=0;
	start:=0;
	sname := "";
	islong :=0;

	f := xfile(t.fid, Asis);
	if(f == nil)
		return e(Enofid);
	if((f.flags&Omodes) != 0)
		return e(Efidopen);
	if(getfile(f)<0)
		return e(Eio);

	pdp := f.ptr;
	if(pdp.addr != 0)
		pd := Dosdir.arr2Dd(pdp.p.iobuf[pdp.offset:pdp.offset+DOSDIRSIZE]);
	else
		pd = nil;

	if(pd != nil)
		attr := int pd.attr;
	else
		attr = DDIR;

	if(!(attr & DDIR) || (attr & DRONLY)) {
		putfile(f);
		return e(Eperm);
	}

	if(t.mode & Styx->ORCLOSE)
		omode |= Orclose;

	case (t.mode & 7) {
	Styx->OREAD or
	Styx->OEXEC =>
		omode |= Oread;
	Styx->OWRITE or
	Styx->ORDWR =>
		if ((t.mode & 7) == Styx->ORDWR)
			omode |= Oread;
		omode |= Owrite;
		if(t.perm & Sys->DMDIR){
			putfile(f);
			return e(Eperm);
		}
	* =>
		putfile(f);
		return e(Eopen);
	}

	if(t.name=="." || t.name=="..") {
		putfile(f);
		return e(Eperm);
	}

	(r,ndp) := searchdir(f, t.name, 1, 1);
	if(r < 0) {
		putfile(f);
		if(r == -2)
			return e(Efull);
		return e(Eexist);
	}

	nds := name2de(t.name);
	if(nds > 0) {
		# long file name, find "new" short name
		i := 1;
		for(;;) {
			sname = long2short(t.name, i);
			(r1, tmpdp) := searchdir(f, sname, 0, 0);
			if(r1 < 0)
				break;
			putsect(tmpdp.p);
			i++;
		}
		islong = 1;
	}

	# allocate first cluster, if making directory
	if(t.perm & Sys->DMDIR) {
		bp = f.xf.ptr;
		start = falloc(f.xf);
		if(start <= 0) {
			putfile(f);
			return e(Efull);
		}
	}

	 # now we're committed
	if(pd != nil) {
		puttime(pd);
		pdp.p.flags |= BMOD;
	}

	f.ptr = ndp;
	ndp.p = getsect(f.xf, ndp.addr);
	if(ndp.p == nil ||
	   islong && putlongname(f.xf, ndp, t.name, sname) < 0){
		putsect(pdp.p);
		if(ndp.p != nil)
			putsect(ndp.p);
		return e(Eio);
	}

	nd := ref Dosdir(".       ","   ",byte 0,array[10] of { * => byte 0},
			array[2] of { * => byte 0}, array[2] of { * => byte 0},
			array[2] of { * => byte 0},array[4] of { * => byte 0});

	if((t.perm & 8r222) == 0)
		nd.attr |= byte DRONLY;

	puttime(nd);
	nd.start[0] = byte start;
	nd.start[1] = byte (start>>8);

	if(islong)
		putname(sname[0:8]+"."+sname[8:11], nd);
	else
		putname(t.name, nd);

	f.qid.path = QIDPATH(ndp);
	if(t.perm & Sys->DMDIR) {
		nd.attr |= byte DDIR;
		f.qid.qtype |= Sys->QTDIR;
		xp := getsect(f.xf, bp.dataaddr+(start-2)*bp.clustsize);
		if(xp == nil) {
			if(ndp.p!=nil)
				putfile(f);
			putsect(pdp.p);
			return e(Eio);
		}
		xd := ref *nd;
		xd.name = ".       ";
		xd.ext = "   ";
		xp.iobuf[0:] = Dosdir.Dd2arr(xd);
		if(pd!=nil)
			xd = ref *pd;
		else{
			xd = ref Dosdir("..      ","   ",byte 0,
				array[10] of { * => byte 0},
				array[2] of { * => byte 0},
				array[2] of { * => byte 0},
				array[2] of { * => byte 0},
				array[4] of { * => byte 0});

			puttime(xd);
			xd.attr = byte DDIR;
		}
		xd.name="..      ";
		xd.ext="   ";
		xp.iobuf[DOSDIRSIZE:] = Dosdir.Dd2arr(xd);
		xp.flags |= BMOD;
		putsect(xp);
	}else
		f.qid.qtype = Sys->QTFILE;

	ndp.p.flags |= BMOD;
	tmp := Dosdir.Dd2arr(nd);
	ndp.p.iobuf[ndp.offset:]= tmp;
	putfile(f);
	putsect(pdp.p);

	f.flags |= omode;
	return ref Rmsg.Create(t.tag, f.qid, Styx->MAXFDATA);
}

rread(t: ref Tmsg.Read): ref Rmsg
{
	r: int;
	data: array of byte;

	if(((f:=xfile(t.fid, Asis))==nil) ||
	    (f.flags&Oread == 0))
		return e(Eio);

	if((f.qid.qtype & Sys->QTDIR) != 0) {
		if(getfile(f) < 0)
			return e(Eio);
		(r, data) = readdir(f, int t.offset, t.count);
	} else {
		if(getfile(f) < 0)
			return e(Eio);
		(r,data) = readfile(f, int t.offset, t.count);
	}
	putfile(f);

	if(r < 0)
		return e(Eio);
	return ref Rmsg.Read(t.tag, data[0:r]);
}

rwrite(t: ref Tmsg.Write): ref Rmsg
{
	if(((f:=xfile(t.fid, Asis))==nil) ||
	   !(f.flags&Owrite))
		return e(Eio);
	if(getfile(f) < 0)
		return e(Eio);
	r := writefile(f, t.data, int t.offset, len t.data);
	putfile(f);
	if(r < 0){
		if(r == -2)
			return e(Efull);
		return e(Eio);
	}
	return ref Rmsg.Write(t.tag, r);
}

rclunk(t: ref Tmsg.Clunk): ref Rmsg
{
	xfile(t.fid, Clunk);
	sync();
	return ref Rmsg.Clunk(t.tag);
}

doremove(f: ref Xfs, dp: ref Dosptr)
{
	dp.p.iobuf[dp.offset] = byte DOSEMPTY;
	dp.p.flags |= BMOD;
	for(prevdo := dp.offset-DOSDIRSIZE; prevdo >= 0; prevdo-=DOSDIRSIZE){
		if (dp.p.iobuf[prevdo+11] != byte DLONG)
			break;
		dp.p.iobuf[prevdo] = byte DOSEMPTY;
	}

	if (prevdo <= 0 && dp.prevaddr != -1){
		p := getsect(f,dp.prevaddr);
		for(prevdo = f.ptr.sectsize-DOSDIRSIZE; prevdo >= 0; prevdo-=DOSDIRSIZE) {
			if(p.iobuf[prevdo+11] != byte DLONG)
				break;
			p.iobuf[prevdo] = byte DOSEMPTY;
			p.flags |= BMOD;
		}
		putsect(p);
	}
}

rremove(t: ref Tmsg.Remove): ref Rmsg
{
	f := xfile(t.fid, Asis);
	if(f == nil)
		return e(Enofid);

	if(!f.ptr.addr) {
		if(debug)
			chat("root...");
		xfile(t.fid, Clunk);
		sync();
		return e(Eperm);
	}

	# check on parent directory of file to be deleted
	parp := getsect(f.xf, f.ptr.paddr);
	if(parp == nil) {
		xfile(t.fid, Clunk);
		sync();
		return e(Eio);
	}

	pard := Dosdir.arr2Dd(parp.iobuf[f.ptr.poffset:f.ptr.poffset+DOSDIRSIZE]);
	if(f.ptr.paddr && (int pard.attr & DRONLY)) {
		if(debug)
			chat("parent read-only...");
		putsect(parp);
		xfile(t.fid, Clunk);
		sync();
		return e(Eperm);
	}

	if(getfile(f) < 0){
		if(debug)
			chat("getfile failed...");
		putsect(parp);
		xfile(t.fid, Clunk);
		sync();
		return e(Eio);
	}

	dattr := int f.ptr.p.iobuf[f.ptr.offset+11];
	if(dattr & DDIR && emptydir(f) < 0){
		if(debug)
			chat("non-empty dir...");
		putfile(f);
		putsect(parp);
		xfile(t.fid, Clunk);
		sync();
		return e(Eperm);
	}
	if(f.ptr.paddr == 0 && dattr&DRONLY) {
		if(debug)
			chat("read-only file in root directory...");
		putfile(f);
		putsect(parp);
		xfile(t.fid, Clunk);
		sync();
		return e(Eperm);
	}

	doremove(f.xf, f.ptr);

	if(f.ptr.paddr) {
		puttime(pard);
		parp.flags |= BMOD;
	}

	parp.iobuf[f.ptr.poffset:] = Dosdir.Dd2arr(pard);
	putsect(parp);
	err := 0;
	if(truncfile(f) < 0)
		err = Eio;

	putfile(f);
	xfile(t.fid, Clunk);
	sync();
	if(err)
		return e(err);
	return ref Rmsg.Remove(t.tag);
}

rstat(t: ref Tmsg.Stat): ref Rmsg
{
	f := xfile(t.fid, Asis);
	if(f == nil)
		return e(Enofid);
	if(getfile(f) < 0)
		return e(Eio);
	dir := dostat(f);
	putfile(f);
	return ref Rmsg.Stat(t.tag, *dir);
}

dostat(f: ref Xfile): ref Sys->Dir
{
	islong :=0;
	prevdo: int;
	longnamebuf:="";

	# get file info.
	dir := getdir(f.ptr.p.iobuf[f.ptr.offset:f.ptr.offset+DOSDIRSIZE],
					f.ptr.addr, f.ptr.offset);
	# get previous entry
	if(f.ptr.prevaddr == -1) {
		# maybe extended, but will never cross sector boundary...
		# short filename at beginning of sector..
		if(f.ptr.offset!=0) {
			for(prevdo = f.ptr.offset-DOSDIRSIZE; prevdo >=0; prevdo-=DOSDIRSIZE) {
				prevdattr := f.ptr.p.iobuf[prevdo+11];
				if(prevdattr != byte DLONG)
					break;
				islong = 1;
				longnamebuf += getnamesect(f.ptr.p.iobuf[prevdo:prevdo+DOSDIRSIZE]);
			}
		}
	} else {
		# extended and will cross sector boundary.
		for(prevdo = f.ptr.offset-DOSDIRSIZE; prevdo >=0; prevdo-=DOSDIRSIZE) {
			prevdattr := f.ptr.p.iobuf[prevdo+11];
			if(prevdattr != byte DLONG)
				break;
			islong = 1;
			longnamebuf += getnamesect(f.ptr.p.iobuf[prevdo:prevdo+DOSDIRSIZE]);
		}
		if (prevdo < 0) {
			p := getsect(f.xf,f.ptr.prevaddr);
			for(prevdo = f.xf.ptr.sectsize-DOSDIRSIZE; prevdo >=0; prevdo-=DOSDIRSIZE){
				prevdattr := p.iobuf[prevdo+11];
				if(prevdattr != byte DLONG)
					break;
				islong = 1;
				longnamebuf += getnamesect(p.iobuf[prevdo:prevdo+DOSDIRSIZE]);
			}
			putsect(p);
		}
	}
	if(islong)
		dir.name = longnamebuf;
	return dir;
}

nameok(elem: string): int
{
	isfrog := array[256] of {
	# NUL
	1, 1, 1, 1, 1, 1, 1, 1,
	# BKS
	1, 1, 1, 1, 1, 1, 1, 1,
	# DLE
	1, 1, 1, 1, 1, 1, 1, 1,
	# CAN
	1, 1, 1, 1, 1, 1, 1, 1,
#	' ' =>	1,
	'/' =>	1, 16r7f =>	1, * => 0
	};

	for(i:=0; i < len elem; i++) {
		if(isfrog[elem[i]])
			return -1;
	}
	return 0;
}

rwstat(t: ref Tmsg.Wstat): ref Rmsg
{
	f := xfile(t.fid, Asis);
	if(f == nil)
		return e(Enofid);

	if(getfile(f) < 0)
		return e(Eio);

	dp := f.ptr;

	if(dp.addr == 0){	# root
		putfile(f);
		return e(Eperm);
	}

	changes := 0;
	dir := dostat(f);
	wdir := ref t.stat;

	if(dir.uid != wdir.uid || dir.gid != wdir.gid){
		putfile(f);
		return e(Eperm);
	}

	if(dir.mtime != wdir.mtime || ((dir.mode^wdir.mode) & 8r777))
		changes = 1;

	if((wdir.mode & 7) != ((wdir.mode >> 3) & 7)
	|| (wdir.mode & 7) != ((wdir.mode >> 6) & 7)){
		putfile(f);
		return e(Eperm);
	}

	if(dir.name != wdir.name){
		# temporarily disable this
		# g.errno = Eperm;
		# putfile(f);
		# return;

		#
		# grab parent directory of file to be changed and check for write perm
		# rename also disallowed for read-only files in root directory
		#
		parp := getsect(f.xf, dp.paddr);
		if(parp == nil){
			putfile(f);
			return e(Eio);
		}
		# pard := Dosdir.arr2Dd(parp.iobuf[dp.poffset: dp.poffset+DOSDIRSIZE]);
		pardattr := int parp.iobuf[dp.poffset+11];
		dpd := Dosdir.arr2Dd(dp.p.iobuf[dp.offset: dp.offset+DOSDIRSIZE]);
		if(dp.paddr != 0 && int pardattr & DRONLY
		|| dp.paddr == 0 && int dpd.attr & DRONLY){
			putsect(parp);
			putfile(f);
			return e(Eperm);
		}

		#
		# retrieve info from old entry
		#
		oaddr := dp.addr;
		ooffset := dp.offset;
		d := dpd;
#		od := *d;
		# start := getstart(f.xf, d);
		start := d.start;
		length := d.length;
		attr := d.attr;

		#
		# temporarily release file to allow other directory ops:
		# walk to parent, validate new name
		# then remove old entry
		#
		putfile(f);
		pf := ref *f;
		pdp := ref Dosptr(dp.paddr, dp.poffset, 0, 0, 0, 0, -1, -1, parp, nil);
		# if(pdp.addr != 0)
		# 	pdpd := Dosdir.arr2Dd(parp.iobuf[pdp.offset: pdp.offset+DOSDIRSIZE]);
		# else
		# 	pdpd = nil;
		pf.ptr = pdp;
		if(wdir.name == "." || wdir.name == ".."){
			putsect(parp);
			return e(Eperm);
		}
		islong := 0;
		sname := "";
		nds := name2de(wdir.name);
		if(nds > 0) {
			# long file name, find "new" short name
			i := 1;
			for(;;) {
				sname = long2short(wdir.name, i);
				(r1, tmpdp) := searchdir(f, sname, 0, 0);
				if(r1 < 0)
					break;
				putsect(tmpdp.p);
				i++;
			}
			islong = 1;
		}else{
			(b, e) := dosname(wdir.name);
			sname = b+e;
		}
		# (r, ndp) := searchdir(pf, wdir.name, 1, 1);
		# if(r < 0){
		#	putsect(parp);
		#	g.errno = Eperm;
		#	return;
		# }
		if(getfile(f) < 0){
			putsect(parp);
			return e(Eio);
		}
		doremove(f.xf, dp);
		putfile(f);

		#
		# search for dir entry again, since we may be able to use the old slot,
		# and we need to set up the naddr field if a long name spans the block.
		# create new entry.
		#
		r := 0;
		(r, dp) = searchdir(pf, sname, 1, islong);
		if(r < 0){
			putsect(parp);
			return e(Ephase);
		}
		if((r = mkdentry(pf.xf, dp, wdir.name, sname, islong, attr, start, length)) != 0){
			putsect(parp);
			return e(r);
		}
		putsect(parp);

		#
		# relocate up other fids to the same file, if it moved
		#
		f.ptr = dp;
		f.qid.path = QIDPATH(dp);
		if(oaddr != dp.addr || ooffset != dp.offset)
			dosptrreloc(f, dp, oaddr, ooffset);
		changes = 1;
		# f = nil;
	}

	if(changes){
		d := Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
		putdir(d, wdir);
		dp.p.iobuf[dp.offset: ] = Dosdir.Dd2arr(d);
		dp.p.flags |= BMOD;
	}
	if(f != nil)
		putfile(f);
	sync();
	return ref Rmsg.Wstat(t.tag);
}

#
# FAT file system format
#

Dospart: adt {
	active: byte;
	hstart: byte;
	cylstart: array of byte;
	typ: byte;
	hend: byte;
	cylend: array of byte;
	start: array of byte;
	length: array of byte;
};

Dosboot: adt {
	arr2Db:	fn(arr: array of byte): ref Dosboot;
	magic:	array of byte;
	version:	array of byte;
	sectsize:	array of byte;
	clustsize:	byte;
	nresrv:	array of byte;
	nfats:	byte;
	rootsize:	array of byte;
	volsize:	array of byte;
	mediadesc:	byte;
	fatsize:	array of byte;
	trksize:	array of byte;
	nheads:	array of byte;
	nhidden:	array of byte;
	bigvolsize:	array of byte;
	driveno:	byte;
	bootsig:	byte;
	volid:	array of byte;
	label:	array of byte;
};

Dosbpb: adt {
	sectsize: int;	# in bytes 
	clustsize: int;	# in sectors 
	nresrv: int;	# sectors 
	nfats: int;	# usually 2 
	rootsize: int;	# number of entries 
	volsize: int;	# in sectors 
	mediadesc: int;
	fatsize: int;	# in sectors 
	fatclusters: int;
	fatbits: int;	# 12 or 16 
	fataddr: int; #big;	# sector number 
	rootaddr: int; #big;
	dataaddr: int; #big;
	freeptr: int; #big;	# next free cluster candidate 
};

Dosdir: adt {
	Dd2arr:	fn(d: ref Dosdir): array of byte;
	arr2Dd:	fn(arr: array of byte): ref Dosdir;
	name:	string;
	ext:		string;
	attr:		byte;
	reserved:	array of byte;
	time:		array of byte;
	date:		array of byte;
	start:		array of byte;
	length:	array of byte;
};

Dosptr: adt {
	addr:	int;	# of file's directory entry 
	offset:	int;
	paddr:	int;	# of parent's directory entry 
	poffset:	int;
	iclust:	int;	# ordinal within file 
	clust:	int;
	prevaddr:	int;
	naddr:	int;
	p:	ref Iosect;
	d:	ref Dosdir;
};

Asis, Clean, Clunk: con iota;

FAT12: con byte 16r01;
FAT16: con byte 16r04;
FATHUGE: con byte 16r06;
DMDDO: con 16r54;
DRONLY: con 16r01;
DHIDDEN: con 16r02;
DSYSTEM: con 16r04;
DVLABEL: con 16r08;
DDIR: con 16r10;
DARCH: con 16r20;
DLONG: con DRONLY | DHIDDEN | DSYSTEM | DVLABEL;
DMLONG: con DLONG | DDIR | DARCH;

DOSDIRSIZE: con 32;
DOSEMPTY: con 16rE5;
DOSRUNES: con 13;

FATRESRV: con 2;

Oread: con  1;
Owrite: con  2;
Orclose: con  4;
Omodes: con  3;

VERBOSE, STYX_MESS, FAT_INFO, CLUSTER_INFO: con (1 << iota);

nowt, nowt1: int;
tzoff: int;

#
# because we map all incoming short names from all upper to all lower case,
# and FAT cannot store mixed case names in short name form,
# we'll declare upper case as unacceptable to decide whether a long name
# is needed on output.  thus, long names are always written in the case
# in the system call, and are always read back as written; short names
# are produced by the common case of writing all lower case letters
#
isdos := array[256] of {
	'a' to 'z' => 1, 'A' to 'Z' => 0, '0' to '9' => 1,
	' ' => 1, '$' => 1, '%' => 1, '"' => 1, '-' => 1, '_' => 1, '@' => 1,
	'~' => 1, '`' => 1, '!' => 1, '(' => 1, ')' => 1, '{' => 1, '}' => 1, '^' => 1,
	'#' => 1, '&' => 1,
	* => 0
};

dossetup()
{
	nowt = daytime->now();
	nowt1 = sys->millisec();
	tzoff = daytime->local(0).tzoff;
}

# make xf into a Dos file system... or die trying to.
dosfs(xf: ref Xfs): int
{
	mbroffset := 0;
	i: int;
	p: ref Iosect;

Dmddo:
	for(;;) {
		for(i=2; i>0; i--) {
			p = getsect(xf, 0);
			if(p == nil)
				return -1;

			if((mbroffset == 0) && (p.iobuf[0] == byte 16re9))
				break;
			
			# Check if the jump displacement (magic[1]) is too 
			# short for a FAT. DOS 4.0 MBR has a displacement of 8.
			if(p.iobuf[0] == byte 16reb &&
			   p.iobuf[2] == byte 16r90 &&
			   p.iobuf[1] != byte 16r08)
				break;

			if(i < 2 ||
			   p.iobuf[16r1fe] != byte 16r55 ||
			   p.iobuf[16r1ff] != byte 16raa) {
				i = 0;
				break;
			}

			dp := 16r1be;
			for(j:=4; j>0; j--) {
				if(debug) {
					chat(sys->sprint("16r%2.2ux (%d,%d) 16r%2.2ux (%d,%d) %d %d...",
					int p.iobuf[dp], int p.iobuf[dp+1], 
					bytes2short(p.iobuf[dp+2: dp+4]),
					int p.iobuf[dp+4], int p.iobuf[dp+5], 
					bytes2short(p.iobuf[dp+6: dp+8]),
					bytes2int(p.iobuf[dp+8: dp+12]), 
					bytes2int(p.iobuf[dp+12:dp+16])));
				}

				# Check for a disc-manager partition in the MBR.
				# Real MBR is at lba 63. Unfortunately it starts
				# with 16rE9, hence the check above against magic.
				if(int p.iobuf[dp+4] == DMDDO) {
					mbroffset = 63*Sectorsize;
					putsect(p);
					purgebuf(xf);
					xf.offset += mbroffset;
					break Dmddo;
				}
				
				# Make sure it really is the right type, other
				# filesystems can look like a FAT
				# (e.g. OS/2 BOOT MANAGER).
				if(p.iobuf[dp+4] == FAT12 ||
				   p.iobuf[dp+4] == FAT16 ||
				   p.iobuf[dp+4] == FATHUGE)
					break;
				dp+=16;
			}

			if(j <= 0) {
				if(debug)
					chat("no active partition...");
				putsect(p);
				return -1;
			}

			offset := bytes2int(p.iobuf[dp+8:dp+12])* Sectorsize;
			putsect(p);
			purgebuf(xf);
			xf.offset = mbroffset+offset;
		}
		break;
	}
	if(i <= 0) {
		if(debug)
			chat("bad magic...");
		putsect(p);
		return -1;
	}

	b := Dosboot.arr2Db(p.iobuf);
	if(debug & FAT_INFO)
		bootdump(b);

	bp := ref Dosbpb;
	xf.ptr = bp;
	xf.fmt = 1;

	bp.sectsize = bytes2short(b.sectsize);
	bp.clustsize = int b.clustsize;
	bp.nresrv = bytes2short(b.nresrv);
	bp.nfats = int b.nfats;
	bp.rootsize = bytes2short(b.rootsize);
	bp.volsize = bytes2short(b.volsize);
	if(bp.volsize == 0)
		bp.volsize = bytes2int(b.bigvolsize);
	bp.mediadesc = int b.mediadesc;
	bp.fatsize = bytes2short(b.fatsize);

	bp.fataddr = int bp.nresrv;
	bp.rootaddr = bp.fataddr + bp.nfats*bp.fatsize;
	i = bp.rootsize*DOSDIRSIZE + bp.sectsize-1;
	i /= bp.sectsize;
	bp.dataaddr = bp.rootaddr + i;
	bp.fatclusters = FATRESRV+(bp.volsize - bp.dataaddr)/bp.clustsize;
	if(bp.fatclusters < 4087)
		bp.fatbits = 12;
	else
		bp.fatbits = 16;
	bp.freeptr = 2;
	if(debug & FAT_INFO){
		chat(sys->sprint("fatbits=%d (%d clusters)...",
			bp.fatbits, bp.fatclusters));
		for(i=0; i< int b.nfats; i++)
			chat(sys->sprint("fat %d: %d...",
				i, bp.fataddr+i*bp.fatsize));
		chat(sys->sprint("root: %d...", bp.rootaddr));
		chat(sys->sprint("data: %d...", bp.dataaddr));
	}
	putsect(p);
	return 0;
}

QIDPATH(dp: ref Dosptr): big
{
	return big (dp.addr*(Sectorsize/DOSDIRSIZE) + dp.offset/DOSDIRSIZE);
}

isroot(addr: int): int
{
	return addr == 0;
}

getfile(f: ref Xfile): int
{
	dp := f.ptr;
	if(dp.p!=nil)
		panic("getfile");
	if(dp.addr < 0)
		panic("getfile address");
	p := getsect(f.xf, dp.addr);
	if(p == nil)
		return -1;

	dp.d = nil;
	if(!isroot(dp.addr)) {
		if(f.qid.path != QIDPATH(dp)){
			if(debug) {
				chat(sys->sprint("qid mismatch f=0x%x d=0x%x...",
					int f.qid.path, int QIDPATH(dp)));
			}
			putsect(p);
			return -1;
		}
	#	dp.d = Dosdir.arr2Dd(p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
	}
	dp.p = p;
	return 0;
}

putfile(f: ref Xfile)
{
	dp := f.ptr;
	if(dp.p==nil)
		panic("putfile");
	putsect(dp.p);
	dp.p = nil;
	dp.d = nil;
}

getstart(nil: ref Xfs, d: ref Dosdir): int
{
	start := bytes2short(d.start);
#	if(xf.isfat32)
#		start |= bytes2short(d.hstart)<<16;
	return start;
}

putstart(nil: ref Xfs, d: ref Dosdir, start: int)
{
	d.start[0] = byte start;
	d.start[1] = byte (start>>8);
#	if(xf.isfat32){
#		d.hstart[0] = start>>16;
#		d.hstart[1] = start>>24;
#	}
}

#
# return the disk cluster for the iclust cluster in f
#
fileclust(f: ref Xfile, iclust: int, cflag: int): int
{

#	bp := f.xf.ptr;
	dp := f.ptr;
	if(isroot(dp.addr))
		return -1;		# root directory for old FAT format does not start on a cluster boundary
	d := dp.d;
	if(d == nil){
		if(dp.p == nil)
			panic("fileclust");
		d = Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
	}
	next := 0;
	start := getstart(f.xf, d);
	if(start == 0) {
		if(!cflag)
			return -1;
		start = falloc(f.xf);
		if(start <= 0)
			return -1;
		puttime(d);
		putstart(f.xf, d, start);
		dp.p.iobuf[dp.offset:] = Dosdir.Dd2arr(d);
		dp.p.flags |= BMOD;
		dp.clust = 0;
	}

	clust, nskip: int;
	if(dp.clust == 0 || iclust < dp.iclust) {
		clust = start;
		nskip = iclust;
	} else {
		clust = dp.clust;
		nskip = iclust - dp.iclust;
	}

	if(debug & CLUSTER_INFO  && nskip > 0)
		chat(sys->sprint("clust %d, skip %d...", clust, nskip));

	if(clust <= 0)
		return -1;

	if(nskip > 0) {
		while(--nskip >= 0) {
			next = getfat(f.xf, clust);
			if(debug & CLUSTER_INFO)
				chat(sys->sprint(".%d", next));
			if(next <= 0){
				if(!cflag)
					break;
				next = falloc(f.xf);
				if(next <= 0)
					return -1;
				putfat(f.xf, clust, next);
			}
			clust = next;
		}
		if(next <= 0)
			return -1;
		dp.clust = clust;
		dp.iclust = iclust;
	}
	if(debug & CLUSTER_INFO)
		chat(sys->sprint(" clust(%d)=0x%x...", iclust, clust));
	return clust;
}

#
# return the disk sector for the isect disk sector in f,
# allocating space if necessary and cflag is set
#
fileaddr(f: ref Xfile, isect: int, cflag: int): int
{
	bp := f.xf.ptr;
	dp := f.ptr;
	if(isroot(dp.addr)) {
		if(isect*bp.sectsize >= bp.rootsize*DOSDIRSIZE)
			return -1;
		return bp.rootaddr + isect;
	}
	clust := fileclust(f, isect/bp.clustsize, cflag);
	if(clust < 0)
		return -1;
	return clust2sect(bp, clust) + isect%bp.clustsize;
}

#
# look for a directory entry matching name
# always searches for long names which match a short name
#
# if creating (cflag is set), set address of available slot and allocate next cluster if necessary
#
searchdir(f: ref Xfile, name: string, cflag: int, lflag: int): (int, ref Dosptr)
{
	xf := f.xf;
	bp := xf.ptr;
	addr1 := -1;
	addr2 := -1;
	prevaddr1 := -1;
	o1 := 0;
	dp :=  ref Dosptr(0,0,0,0,0,0,-1,-1,nil,nil);	# prevaddr and naddr are -1
	dp.paddr = f.ptr.addr;
	dp.poffset = f.ptr.offset;
	islong :=0;
	buf := "";

	need := 1;
	if(lflag && cflag)
		need += name2de(name);
	if(!lflag) {
		name = name[0:8]+"."+name[8:11];
		i := len name -1;
		while(i >= 0 && (name[i]==' ' || name[i] == '.'))
			i--;
		name = name[0:i+1];
	}

	addr := -1;
	prevaddr: int;
	have := 0;
	for(isect:=0;; isect++) {
		prevaddr = addr;
		addr = fileaddr(f, isect, cflag);
		if(addr < 0)
			break;
		p := getsect(xf, addr);
		if(p == nil)
			break;
		for(o:=0; o<bp.sectsize; o+=DOSDIRSIZE) {
			dattr := int p.iobuf[o+11];
			dname0 := p.iobuf[o];
			if(dname0 == byte 16r00) {
				if(debug)
					chat("end dir(0)...");
				putsect(p);
				if(!cflag)
					return (-1, nil);

				#
				# addr1 and o1 are the start of the dirs
				# addr2 is the optional second cluster used if the long name
				# entry does not fit within the addr1 cluster
				# have tells us the number of contiguous free dirs
				# starting at addr1.o1; need is the number needed to hold the long name
				#
				if(addr1 < 0){
					addr1 = addr;
					prevaddr1 = prevaddr;
					o1 = o;
				}
				nleft := (bp.sectsize-o)/DOSDIRSIZE;
				if(addr2 < 0 && nleft+have < need){
					addr2 = fileaddr(f, isect+1, cflag);
					if(addr2 < 0){
						if(debug)
							chat("end dir(2)...");
						return (-2, nil);
					}
				}else if(addr2 < 0)
					addr2 = addr;
				if(addr2 == addr1)
					addr2 = -1;
				if(debug)
					chat(sys->sprint("allocate addr1=%d,%d addr2=%d for %s nleft=%d have=%d need=%d", addr1, o1, addr2, name, nleft, have, need));
				dp.addr = addr1;
				dp.offset = o1;
				dp.prevaddr = prevaddr1;
				dp.naddr = addr2;
				return (0, dp);
			}

			if(dname0 == byte DOSEMPTY) {
				if(debug)
					chat("empty...");
				have++;
				if(addr1 == -1){
					addr1 = addr;
					o1 = o;
					prevaddr1 = prevaddr;
				}
				if(addr2 == -1 && have >= need)
					addr2 = addr;
				continue;
			}
			have = 0;
			if(addr2 == -1)
				addr1 = -1;

			if(0 && lflag && debug)
				dirdump(p.iobuf[o:o+DOSDIRSIZE],addr,o);

			if((dattr & DMLONG) == DLONG) {
				if(!islong)
					buf = "";
				islong = 1;
				buf = getnamesect(p.iobuf[o:o+DOSDIRSIZE]) + buf;	# getnamesect should return sum
				continue;
			}
			if(dattr & DVLABEL) {
				islong = 0;
				continue;
			}

			if(!islong || !lflag) 
				buf = getname(p.iobuf[o:o+DOSDIRSIZE]);
			islong = 0;

			if(debug)
				chat(sys->sprint("cmp: [%s] [%s]", buf, name));
			if(mystrcmp(buf, name) != 0) {
				buf="";
				continue;
			}
			if(debug)
				chat("found\n");

			if(cflag) {
				putsect(p);
				return (-1,nil);
			}

			dp.addr = addr;
			dp.prevaddr = prevaddr;
			dp.offset = o;
			dp.p = p;
			#dp.d = Dosdir.arr2Dd(p.iobuf[o:o+DOSDIRSIZE]);
			return (0, dp);
		}
		putsect(p);
	}
	if(debug)
		chat("end dir(1)...");
	if(!cflag)
		return (-1, nil);
	#
	# end of root directory or end of non-root directory on cluster boundary
	#
	if(addr1 < 0){
		addr1 = fileaddr(f, isect, 1);
		if(addr1 < 0)
			return (-2, nil);
		prevaddr1 = prevaddr;
		o1 = 0;
	}else{
		if(addr2 < 0 && have < need){
			addr2 = fileaddr(f, isect, 1);
			if(addr2 < 0)
				return (-2, nil);
		}
	}
	if(addr2 == addr1)
		addr2 = -1;
	dp.addr = addr1;
	dp.offset = o1;
	dp.prevaddr = prevaddr1;
	dp.naddr = addr2;
	return (0, dp);
}

emptydir(f: ref Xfile): int
{
	for(isect:=0;; isect++) {
		addr := fileaddr(f, isect, 0);
		if(addr < 0)
			break;

		p := getsect(f.xf, addr);
		if(p == nil)
			return -1;

		for(o:=0; o<f.xf.ptr.sectsize; o+=DOSDIRSIZE) {
			dname0 := p.iobuf[o];
			dattr := int p.iobuf[o+11];

			if(dname0 == byte 16r00) {
				putsect(p);
				return 0;
			}

			if(dname0 == byte DOSEMPTY || dname0 == byte '.')
				continue;

			if(dattr & DVLABEL)
				continue;		# ignore any long name entries: it's empty if there are no short ones

			putsect(p);
			return -1;
		}
		putsect(p);
	}
	return 0;
}

readdir(f:ref Xfile, offset: int, count: int): (int, array of byte)
{
	xf := f.xf;
	bp := xf.ptr;
	rcnt := 0;
	buf := array[Styx->MAXFDATA] of byte;
	islong :=0;
	longnamebuf:="";

	if(count <= 0)
		return (0, nil);

Read:
	for(isect:=0;; isect++) {
		addr := fileaddr(f, isect, 0);
		if(addr < 0)
			break;
		p := getsect(xf, addr);
		if(p == nil)
			return (-1,nil);

		for(o:=0; o<bp.sectsize; o+=DOSDIRSIZE) {
			dname0 := int p.iobuf[o];
			dattr := int p.iobuf[o+11];

			if(dname0 == 16r00) {
				putsect(p);
				break Read;
			}

			if(dname0 == DOSEMPTY)
				continue;

			if(dname0 == '.') {
				dname1 := int p.iobuf[o+1];
				if(dname1 == ' ' || dname1 == 0)
					continue;
				dname2 := int p.iobuf[o+2];
				if(dname1 == '.' &&
				  (dname2 == ' ' || dname2 == 0))
					continue;
			}

			if((dattr & DMLONG) == DLONG) {
				if(!islong)
					longnamebuf = "";
				longnamebuf = getnamesect(p.iobuf[o:o+DOSDIRSIZE]) + longnamebuf;
				islong = 1;
				continue;
			}
			if(dattr & DVLABEL) {
				islong = 0;
				continue;
			}

			dir := getdir(p.iobuf[o:o+DOSDIRSIZE], addr, o);
			if(islong) {
				dir.name = longnamebuf;
				longnamebuf = "";
				islong = 0;
			}
			d := styx->packdir(*dir);
			if(offset > 0) {
				offset -= len d;
				islong = 0;
				continue;
			}
			if(rcnt+len d > count){
				putsect(p);
				break Read;
			}
			buf[rcnt:] = d;
			rcnt += len d;
			if(rcnt >= count) {
				putsect(p);
				break Read;
			}
		}
		putsect(p);
	}

	return (rcnt, buf[0:rcnt]);
}

walkup(f: ref Xfile): (int, ref Dosptr)
{
	bp := f.xf.ptr;
	dp := f.ptr;
	o: int;
	ndp:= ref Dosptr(0,0,0,0,0,0,-1,-1,nil,nil);
	ndp.addr = dp.paddr;
	ndp.offset = dp.poffset;

	if(debug)
		chat(sys->sprint("walkup: paddr=0x%x...", dp.paddr));

	if(dp.paddr == 0)
		return (0,ndp);

	p := getsect(f.xf, dp.paddr);
	if(p == nil)  
		return (-1,nil);

	if(debug)
		dirdump(p.iobuf[dp.poffset:dp.poffset+DOSDIRSIZE],dp.paddr,dp.poffset);

	xd := Dosdir.arr2Dd(p.iobuf[dp.poffset:dp.poffset+DOSDIRSIZE]);
	start := getstart(f.xf, xd);
	if(debug & CLUSTER_INFO)
		if(debug)
			chat(sys->sprint("start=0x%x...", start));
	putsect(p);
	if(start == 0)
		return (-1,nil);

	#
	# check that parent's . points to itself
	#
	p = getsect(f.xf, bp.dataaddr + (start-2)*bp.clustsize);
	if(p == nil)
		return (-1,nil);

	if(debug)
		dirdump(p.iobuf,0,0);

	xd = Dosdir.arr2Dd(p.iobuf);
	if(p.iobuf[0]!= byte '.' ||
	   p.iobuf[1]!= byte ' ' ||
	   start != getstart(f.xf, xd)) { 
 		if(p!=nil) 
			putsect(p);
		return (-1,nil);
	}

	if(debug)
		dirdump(p.iobuf[DOSDIRSIZE:],0,0);

	#
	# parent's .. is the next entry, and has start of parent's parent
	#
	xd = Dosdir.arr2Dd(p.iobuf[DOSDIRSIZE:]);
	if(p.iobuf[32] != byte '.' || p.iobuf[33] != byte '.') { 
 		if(p != nil) 
			putsect(p);
		return (-1,nil);
	}

	#
	# we're done if parent is root
	#
	pstart := getstart(f.xf, xd);
	putsect(p);
	if(pstart == 0)
		return (0, ndp);

	#
	# check that parent's . points to itself
	#
	p = getsect(f.xf, clust2sect(bp, pstart));
	if(p == nil) {
		if(debug)
			chat(sys->sprint("getsect %d failed\n", pstart));
		return (-1,nil);
	}
	if(debug)
		dirdump(p.iobuf,0,0);
	xd = Dosdir.arr2Dd(p.iobuf);
	if(p.iobuf[0]!= byte '.' ||
	   p.iobuf[1]!=byte ' ' || 
	   pstart!=getstart(f.xf, xd)) { 
 		if(p != nil) 
			putsect(p);
		return (-1,nil);
	}

	#
	# parent's parent's .. is the next entry, and has start of parent's parent's parent
	#
	if(debug)
		dirdump(p.iobuf[DOSDIRSIZE:],0,0);

	xd = Dosdir.arr2Dd(p.iobuf[DOSDIRSIZE:]);
	if(xd.name[0] != '.' || xd.name[1] !=  '.') { 
 		if(p != nil) 
			putsect(p);
		return (-1,nil);
	}
	ppstart :=getstart(f.xf, xd);
	putsect(p);

	#
	# open parent's parent's parent, and walk through it until parent's paretn is found
	# need this to find parent's parent's addr and offset
	#
	ppclust := ppstart;
	# TO DO: FAT32
	if(ppclust != 0)
		k := clust2sect(bp, ppclust);
	else
		k = bp.rootaddr;
	p = getsect(f.xf, k);
	if(p == nil) {
		if(debug)
			chat(sys->sprint("getsect %d failed\n", k));
		return (-1,nil);
	}

	if(debug)
		dirdump(p.iobuf,0,0);

	if(ppstart) {
		xd = Dosdir.arr2Dd(p.iobuf);
		if(p.iobuf[0]!= byte '.' ||
		   p.iobuf[1]!= byte ' ' || 
		   ppstart!=getstart(f.xf, xd)) { 
 			if(p!=nil) 
				putsect(p);
			return (-1,nil);
		}
	}

	for(so:=1; ;so++) {
		for(o=0; o<bp.sectsize; o+=DOSDIRSIZE) {
			xdname0 := p.iobuf[o];
			if(xdname0 == byte 16r00) {
				if(debug)
					chat("end dir\n");
 				if(p != nil) 
					putsect(p);
				return (-1,nil);
			}

			if(xdname0 == byte DOSEMPTY)
				continue;

			#xd = Dosdir.arr2Dd(p.iobuf[o:o+DOSDIRSIZE]);
			xdstart:= p.iobuf[o+26:o+28];	# TO DO: getstart
			if(bytes2short(xdstart) == pstart) {
				putsect(p);
				ndp.paddr = k;
				ndp.poffset = o;
				return (0,ndp);
			}
		}
		if(ppclust) {
			if(so%bp.clustsize == 0) {
				ppstart = getfat(f.xf, ppstart);
				if(ppstart < 0){
					if(debug)
						chat(sys->sprint("getfat %d fail\n", 
							ppstart));
 					if(p != nil) 
						putsect(p);
					return (-1,nil);
				}
			}
			k = clust2sect(bp, ppclust) + 
				so%bp.clustsize;
		}
		else {
			if(so*bp.sectsize >= bp.rootsize*DOSDIRSIZE) { 
 				if(p != nil) 
					putsect(p);
				return (-1,nil);
			}
			k = bp.rootaddr + so;
		}
		putsect(p);
		p = getsect(f.xf, k);
		if(p == nil) {
			if(debug)
				chat(sys->sprint("getsect %d failed\n", k));
			return (-1,nil);
		}
	}
	putsect(p);
	ndp.paddr = k;
	ndp.poffset = o;
	return (0,ndp);
}

readfile(f: ref Xfile, offset: int, count: int): (int, array of byte)
{
	xf := f.xf;
	bp := xf.ptr;
	dp := f.ptr;

	length := bytes2int(dp.p.iobuf[dp.offset+28:dp.offset+32]);
	rcnt := 0;
	if(offset >= length)
		return (0,nil);
 	buf := array[Styx->MAXFDATA] of byte;
	if(offset+count >= length)
		count = length - offset;
	isect := offset/bp.sectsize;
	o := offset%bp.sectsize;
	while(count > 0) {
		addr := fileaddr(f, isect++, 0);
		if(addr < 0)
			break;
		c := bp.sectsize - o;
		if(c > count)
			c = count;
		p := getsect(xf, addr);
		if(p == nil)
			return (-1, nil);
		buf[rcnt:] = p.iobuf[o:o+c];
		putsect(p);
		count -= c;
		rcnt += c;
		o = 0;
	}
	return (rcnt, buf[0:rcnt]);
}

writefile(f: ref Xfile, buf: array of byte, offset,count: int): int
{
	xf := f.xf;
	bp := xf.ptr;
	dp := f.ptr;
	addr := 0;
	c: int;
	rcnt := 0;
	p: ref Iosect;

	d := dp.d;
	if(d == nil)
		d = Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);
	isect := offset/bp.sectsize;

	o := offset%bp.sectsize;
	while(count > 0) {
		addr = fileaddr(f, isect++, 1);
		if(addr < 0)
			break;
		c = bp.sectsize - o;
		if(c > count)
			c = count;
		if(c == bp.sectsize){
			p = getosect(xf, addr);
			if(p == nil)
				return -1;
			p.flags = 0;
		}else{
			p = getsect(xf, addr);
			if(p == nil)
				return -1;
		}
		p.iobuf[o:] = buf[rcnt:rcnt+c];
		p.flags |= BMOD;
		putsect(p);
		count -= c;
		rcnt += c;
		o = 0;
	}
	if(rcnt <= 0 && addr < 0)
		return -2;
	length := 0;
	dlen := bytes2int(d.length);
	if(rcnt > 0)
		length = offset+rcnt;
	else if(dp.addr && dp.clust) {
		c = bp.clustsize*bp.sectsize;
		if(dp.iclust > (dlen+c-1)/c)
			length = c*dp.iclust;
	}
	if(length > dlen) {
		d.length[0] = byte length;
		d.length[1] = byte (length>>8);
		d.length[2] = byte (length>>16);
		d.length[3] = byte (length>>24);
	}
	puttime(d);
	dp.p.flags |= BMOD;
	dp.p.iobuf[dp.offset:] = Dosdir.Dd2arr(d);
	return rcnt;
}

truncfile(f: ref Xfile): int
{
	xf := f.xf;
#	bp := xf.ptr;
	dp := f.ptr;
	d := Dosdir.arr2Dd(dp.p.iobuf[dp.offset:dp.offset+DOSDIRSIZE]);

	clust := getstart(f.xf, d);
	putstart(f.xf, d, 0);
	while(clust > 0) {
		next := getfat(xf, clust);
		putfat(xf, clust, 0);
		clust = next;
	}

	d.length[0] = byte 0;
	d.length[1] = byte 0;
	d.length[2] = byte 0;
	d.length[3] = byte 0;

	dp.p.iobuf[dp.offset:] = Dosdir.Dd2arr(d);
	dp.iclust = 0;
	dp.clust = 0;
	dp.p.flags |= BMOD;

	return 0;
}

getdir(arr: array of byte, addr,offset: int) :ref Sys->Dir 
{
	dp := ref Sys->Dir;

	if(arr == nil || addr == 0) {
		dp.name = "";
		dp.qid.path = big 0;
		dp.qid.qtype = Sys->QTDIR;
		dp.length = big 0;
		dp.mode = Sys->DMDIR|8r777;
	}
	else {
		dp.name = getname(arr);
		for(i:=0; i < len dp.name; i++)
			if(dp.name[i]>='A' && dp.name[i]<='Z')
				dp.name[i] = dp.name[i]-'A'+'a';

		# dp.qid.path = bytes2short(d.start); 
		dp.qid.path = big (addr*(Sectorsize/DOSDIRSIZE) + offset/DOSDIRSIZE);
		dattr := int arr[11];

		if(dattr & DRONLY)
			dp.mode = 8r444;
		else
			dp.mode = 8r666;

		dp.atime = gtime(arr);
		dp.mtime = dp.atime;
		if(dattr & DDIR) {
			dp.length = big 0;
			dp.qid.qtype |= Styx->QTDIR;
			dp.mode |= Sys->DMDIR|8r111;
		}
		else 
			dp.length = big bytes2int(arr[28:32]);

		if(dattr & DSYSTEM){
			dp.mode |= Styx->DMEXCL;
			dp.qid.qtype |= Styx->QTEXCL;
		}
	}

	dp.qid.vers = 0;
	dp.dtype = 0;
	dp.dev = 0;
	dp.uid = "dos";
	dp.gid = "srv";

	return dp;
}

putdir(d: ref Dosdir, dp: ref Sys->Dir)
{
	if(dp.mode & 2)
		d.attr &= byte ~DRONLY;
	else
		d.attr |= byte DRONLY;

	if(dp.mode & Styx->DMEXCL)
		d.attr |= byte DSYSTEM;
	else
		d.attr &= byte ~DSYSTEM;
	xputtime(d, dp.mtime);
}

getname(arr: array of byte): string
{
	p: string;
	for(i:=0; i<8; i++) {
		c := int arr[i];
		if(c == 0 || c == ' ')
			break;
		if(i == 0 && c == 16r05)
			c = 16re5;
		p[len p] = c;
	}
	for(i=8; i<11; i++) {
		c := int arr[i];
		if(c == 0 || c == ' ')
			break;
		if(i == 8)
			p[len p] = '.';
		p[len p] = c;
	}

	return p;
}

dosname(p: string): (string, string)
{
	name := "        ";
	for(i := 0; i < len p && i < 8; i++) {
		c := p[i];
		if(c >= 'a' && c <= 'z')
			c += 'A'-'a';
		else if(c == '.')
			break;
		name[i] = c;
	}
	ext := "   ";
	for(j := len p - 1; j >= i; j--) {
		if(p[j] == '.') {
			q := 0;
			for(j++; j < len p && q < 3; j++) {
				c := p[j];
				if(c >= 'a' && c <= 'z')
					c += 'A'-'a';
				ext[q++] = c;
			}
			break;
		}
	}
	return (name, ext);
}

putname(p: string, d: ref Dosdir)
{
	if ((int d.attr & DLONG) == DLONG)
		panic("putname of long name");
	(d.name, d.ext) = dosname(p);
}

mystrcmp(s1, s2: string): int
{
	n := len s1;
	if(n != len s2)
		return 1;

	for(i := 0; i < n; i++) {
		c := s1[i];
		if(c >= 'A' && c <= 'Z')
			c -= 'A'-'a';
		d := s2[i];
		if(d >= 'A' && d <= 'Z')
			d -= 'A'-'a';
		if(c != d)
			return 1;
	}
	return 0;
}

#
# return the length of a long name in directory
# entries or zero if it's normal dos
#
name2de(p: string): int
{
	ext := 0;
	name := 0;

	for(end := len p; --end >= 0 && p[end] != '.';)
		ext++;

	if(end > 0) {
		name = end;
		for(i := 0; i < end; i++) {
			if(p[i] == '.')
				return (len p+DOSRUNES-1)/DOSRUNES;
		}
	}
	else {
		name = ext;
		ext = 0;
	}

	if(name <= 8 && ext <= 3 && isvalidname(p))
		return 0;

	return (len p+DOSRUNES-1)/DOSRUNES;
}

isvalidname(s: string): int
{
	dot := 0;
	for(i := 0; i < len s; i++)
		if(s[i] == '.') {
			if(++dot > 1 || i == len s-1)
				return 0;
		} else if(s[i] > len isdos || isdos[s[i]] == 0)
			return 0;
	return 1;
}

getnamesect(arr: array of byte): string
{
	s: string;
	c: int;

	for(i := 1; i < 11; i += 2) {
		c = int arr[i] | (int arr[i+1] << 8);
		if(c == 0)
			return s;
		s[len s] = c;
	}
	for(i = 14; i < 26; i += 2) {
		c = int arr[i] | (int arr[i+1] << 8);
		if(c == 0)
			return s;
		s[len s] = c;
	}
	for(i = 28; i < 32; i += 2) {
		c = int arr[i] | (int arr[i+1] << 8);
		if(c == 0)
			return s;
		s[len s] = c;
	}
	return s;
}

# takes a long filename and converts to a short dos name, with a tag number.
long2short(src: string,val: int): string
{
	dst :="           ";
	skip:=0;
	xskip:=0;
	ext:=len src-1;
	while(ext>=0 && src[ext]!='.')
		ext--;

	if (ext < 0)
		ext=len src -1;

	# convert name eliding periods 
	j:=0;
	for(name := 0; name < ext && j<8; name++){
		c := src[name];
		if(c!='.' && c!=' ' && c!='\t') {
			if(c>='a' && c<='z')
				dst[j++] = c-'a'+'A';
			else
				dst[j++] = c;
		}	
		else
			skip++;
	}

	# convert extension 
	j=8;
	for(xname := ext+1; xname < len src && j<11; xname++) {
		c := src[xname];
		if(c!=' ' && c!='\t'){
			if (c>='a' && c<='z')
				dst[j++] = c-'a'+'A';
			else
				dst[j++] = c;
		}else
			xskip++;
	}
	
	# add tag number
	j =1; 
	for(i:=val; i > 0; i/=10)
		j++;

	if (8-j<name) 
		name = 8-j;
	else
		name -= skip;

	dst[name]='~';
	for(; val > 0; val /= 10)
		dst[name+ --j] = (val%10)+'0';

	if(debug)
		chat(sys->sprint("returning dst [%s] src [%s]\n",dst,src));

	return dst;			
}

getfat(xf: ref Xfs, n: int): int
{
	bp := xf.ptr;
	k := 0; 

	if(n < 2 || n >= bp.fatclusters)
		return -1;
	fb := bp.fatbits;
	k = (fb*n) >> 3;
	if(k < 0 || k >= bp.fatsize*bp.sectsize)
		panic("getfat");

	sect := k/bp.sectsize + bp.fataddr;
	o := k%bp.sectsize;
	p := getsect(xf, sect);
	if(p == nil)
		return -1;
	k = int p.iobuf[o++];
	if(o >= bp.sectsize) {
		putsect(p);
		p = getsect(xf, sect+1);
		if(p == nil)
			return -1;
		o = 0;
	}
	k |= int p.iobuf[o++]<<8;
	if(fb == 32){
		# fat32 is really fat28
		k |= int p.iobuf[o++] << 16;
		k |= (int p.iobuf[o] & 16r0F) << 24;
		fb = 28;
	}
	putsect(p);
	if(fb == 12) {
		if(n&1)
			k >>= 4;
		else
			k &= 16rfff;
	}

	if(debug & FAT_INFO)
		chat(sys->sprint("fat(0x%x)=0x%x...", n, k));

	#
	# check for out of range
	#
	if(k >= (1<<fb) - 8)
		return -1;
	return k;
}

putfat(xf: ref Xfs, n, val: int)
{
	bp := xf.ptr;
	if(n < 2 || n >= bp.fatclusters)
		panic(sys->sprint("putfat n=%d", n));
	k := (bp.fatbits*n) >> 3;
	if(k >= bp.fatsize*bp.sectsize)
		panic("putfat");
	sect := k/bp.sectsize + bp.fataddr;
	for(; sect<bp.rootaddr; sect+=bp.fatsize) {
		o := k%bp.sectsize;
		p := getsect(xf, sect);
		if(p == nil)
			continue;
		case bp.fatbits {
		12 =>
			if(n&1) {
				p.iobuf[o] &= byte 16r0f;
				p.iobuf[o++] |= byte (val<<4);
				if(o >= bp.sectsize) {
					p.flags |= BMOD;
					putsect(p);
					p = getsect(xf, sect+1);
					if(p == nil)
						continue;
					o = 0;
				}
				p.iobuf[o] = byte (val>>4);
			}
			else {
				p.iobuf[o++] = byte val;
				if(o >= bp.sectsize) {
					p.flags |= BMOD;
					putsect(p);
					p = getsect(xf, sect+1);
					if(p == nil)
						continue;
					o = 0;
				}
				p.iobuf[o] &= byte 16rf0;
				p.iobuf[o] |= byte ((val>>8)&16r0f);
			}
		16 =>
			p.iobuf[o++] = byte val;
			p.iobuf[o] = byte (val>>8);
		32 =>	# fat32 is really fat28
			p.iobuf[o++] = byte val;
			p.iobuf[o++] = byte (val>>8);
			p.iobuf[o++] = byte (val>>16);
			p.iobuf[o] = byte ((int p.iobuf[o] & 16rF0) | ((val>>24) & 16r0F));
		* =>
			panic("putfat fatbits");
		}

		p.flags |= BMOD;
		putsect(p);
	}
}

falloc(xf: ref Xfs): int
{
	bp := xf.ptr;
	n := bp.freeptr;
	for(;;) {
		if(getfat(xf, n) == 0)
			break;
		if(++n >= bp.fatclusters)
			n = FATRESRV;
		if(n == bp.freeptr)
			return 0;
	}
	bp.freeptr = n+1;
	if(bp.freeptr >= bp.fatclusters)
		bp.freeptr = FATRESRV;
	putfat(xf, n, int 16rffffffff);
	k := clust2sect(bp, n);
	for(i:=0; i<bp.clustsize; i++) {
		p := getosect(xf, k+i);
		if(p == nil)
			return -1;
		for(j:=0; j<len p.iobuf; j++)
			p.iobuf[j] = byte 0;
		p.flags = BMOD;
		putsect(p);
	}
	return n;
}

clust2sect(bp: ref Dosbpb, clust: int): int
{
	return bp.dataaddr + (clust - FATRESRV)*bp.clustsize;
}

sect2clust(bp: ref Dosbpb, sect: int): int
{
	c := (sect - bp.dataaddr) / bp.clustsize + FATRESRV;
	# assert(sect == clust2sect(bp, c));
	return c;
}

bootdump(b: ref Dosboot)
{
	chat(sys->sprint("magic: 0x%2.2x 0x%2.2x 0x%2.2x\n",
		int b.magic[0], int b.magic[1], int b.magic[2]));
	chat(sys->sprint("version: \"%8.8s\"\n", string b.version));
	chat(sys->sprint("sectsize: %d\n", bytes2short(b.sectsize)));
	chat(sys->sprint("allocsize: %d\n", int b.clustsize));
	chat(sys->sprint("nresrv: %d\n", bytes2short(b.nresrv)));
	chat(sys->sprint("nfats: %d\n", int b.nfats));
	chat(sys->sprint("rootsize: %d\n", bytes2short(b.rootsize)));
	chat(sys->sprint("volsize: %d\n", bytes2short(b.volsize)));
	chat(sys->sprint("mediadesc: 0x%2.2x\n", int b.mediadesc));
	chat(sys->sprint("fatsize: %d\n", bytes2short(b.fatsize)));
	chat(sys->sprint("trksize: %d\n", bytes2short(b.trksize)));
	chat(sys->sprint("nheads: %d\n", bytes2short(b.nheads)));
	chat(sys->sprint("nhidden: %d\n", bytes2int(b.nhidden)));
	chat(sys->sprint("bigvolsize: %d\n", bytes2int(b.bigvolsize)));
	chat(sys->sprint("driveno: %d\n", int b.driveno));
	chat(sys->sprint("bootsig: 0x%2.2x\n", int b.bootsig));
	chat(sys->sprint("volid: 0x%8.8x\n", bytes2int(b.volid)));
	chat(sys->sprint("label: \"%11.11s\"\n", string b.label));
}

xputtime(d: ref Dosdir, s: int)
{
	if(s == 0)
		t := daytime->local((sys->millisec() - nowt1)/1000 + nowt);
	else
		t = daytime->local(s);
	x := (t.hour<<11) | (t.min<<5) | (t.sec>>1);
	d.time[0] = byte x;
	d.time[1] = byte (x>>8);
	x = ((t.year-80)<<9) | ((t.mon+1)<<5) | t.mday;
	d.date[0] = byte x;
	d.date[1] = byte (x>>8);
}

puttime(d: ref Dosdir)
{
	xputtime(d, 0);
}

gtime(a: array of byte): int
{
	tm := ref Daytime->Tm;
	i := bytes2short(a[22:24]);	# dos time
	tm.hour = i >> 11;
	tm.min = (i>>5) & 63;
	tm.sec = (i & 31) << 1;
	i = bytes2short(a[24:26]);	# dos date
	tm.year = 80 + (i>>9);
	tm.mon = ((i>>5) & 15) - 1;
	tm.mday = i & 31;
	tm.tzoff = tzoff;	# DOS time is local time
	return daytime->tm2epoch(tm);
}

dirdump(arr: array of byte, addr, offset: int)
{
	if(!debug)
		return;
	attrchar:= "rhsvda67";
	d := Dosdir.arr2Dd(arr);
	buf := sys->sprint("\"%.8s.%.3s\" ", d.name, d.ext);
	p_i:=7;

	for(i := 16r80; i != 0; i >>= 1) {
		if((d.attr & byte i) ==  byte i)
			ch := attrchar[p_i];
		else 
			ch = '-'; 
		buf += sys->sprint("%c", ch);
		p_i--;
	}

	i = bytes2short(d.time);
	buf += sys->sprint(" %2.2d:%2.2d:%2.2d", i>>11, (i>>5)&63, (i&31)<<1);
	i = bytes2short(d.date);
	buf += sys->sprint(" %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
	buf += sys->sprint(" %d %d", bytes2short(d.start), bytes2short(d.length));
	buf += sys->sprint(" %d %d\n",addr,offset);
	chat(buf);
}

putnamesect(longname: string, curslot: int, first: int, sum: int, a: array of byte)
{
	for(i := 0; i < DOSDIRSIZE; i++)
		a[i] = byte 16rFF;
	if(first)
		a[0] = byte (16r40 | curslot);
	else 
		a[0] = byte curslot;
	a[11] = byte DLONG;
	a[12] = byte 0;
	a[13] = byte sum;
	a[26] = byte 0;
	a[27] = byte 0;
	# a[1:1+10] = characters 1 to 5
	n := len longname;
	j := (curslot-1)*DOSRUNES;
	for(i = 1; i < 1+10; i += 2){
		c := 0;
		if(j < n)
			c = longname[j++];
		a[i] = byte c;
		a[i+1] = byte (c >> 8);
		if(c == 0)
			return;
	}
	# a[14:14+12] = characters 6 to 11
	for(i = 14; i < 14+12; i += 2){
		c := 0;
		if(j < n)
			c = longname[j++];
		a[i] = byte c;
		a[i+1] = byte (c >> 8);
		if(c == 0)
			return;
	}
	# a[28:28+4] characters 12 to 13
	for(i = 28; i < 28+4; i += 2){
		c := 0;
		if(j < n)
			c = longname[j++];
		a[i] = byte c;
		a[i+1] = byte (c>>8);
		if(c == 0)
			return;
	}
}

putlongname(xf: ref Xfs, ndp: ref Dosptr, name: string, sname: string): int
{
	bp := xf.ptr;
	first := 1;
	sum := aliassum(sname);
	for(nds := (len name+DOSRUNES-1)/DOSRUNES; nds > 0; nds--) {
		putnamesect(name, nds, first, sum, ndp.p.iobuf[ndp.offset:]);
		first = 0;
		ndp.offset += DOSDIRSIZE;
		if(ndp.offset == bp.sectsize) {
			if(debug)
				chat(sys->sprint("long name %s entry %d/%d crossing sector, addr=%d, naddr=%d", name, nds, (len name+DOSRUNES-1)/DOSRUNES, ndp.addr, ndp.naddr));
			ndp.p.flags |= BMOD;
			putsect(ndp.p);
			ndp.p = nil;
			ndp.d = nil;

			# switch to the next cluster for the next long entry or the subsequent normal dir. entry
			# naddr must be set up correctly by searchdir because we'll need one or the other

			ndp.prevaddr = ndp.addr;
			ndp.addr = ndp.naddr;
			ndp.naddr = -1;
			if(ndp.addr < 0)
				return -1;
			ndp.p = getsect(xf, ndp.addr);
			if(ndp.p == nil)
				return -1;
			ndp.offset = 0;
		}
	}
	return 0;
}

bytes2int(a: array of byte): int 
{
	return (((((int a[3] << 8) | int a[2]) << 8) | int a[1]) << 8) | int a[0];
}

bytes2short(a: array of byte): int 
{
	return (int a[1] << 8) | int a[0];
}

chat(s: string)
{
	if(debug)
		sys->fprint(sys->fildes(2), "%s", s);
}

panic(s: string)
{
	sys->fprint(sys->fildes(2), "dosfs: panic: %s\n", s);
	if(pflag)
		<-chan of int;	# hang here
	raise "fail:panic";
}

Dosboot.arr2Db(arr: array of byte): ref Dosboot
{
	db := ref Dosboot;
	db.magic = arr[0:3];
	db.version = arr[3:11];
	db.sectsize = arr[11:13];
	db.clustsize = arr[13];
	db.nresrv = arr[14:16];
	db.nfats = arr[16];
	db.rootsize = arr[17:19];
	db.volsize = arr[19:21];
	db.mediadesc = arr[21];
	db.fatsize = arr[22:24];
	db.trksize = arr[24:26];
	db.nheads = arr[26:28];
	db.nhidden = arr[28:32];
	db.bigvolsize = arr[32:36];
	db.driveno = arr[36];
	db.bootsig = arr[38];
	db.volid = arr[39:43];
	db.label = arr[43:54];
	return db;
}

Dosdir.arr2Dd(arr: array of byte): ref Dosdir
{
	dir := ref Dosdir;
	for(i := 0; i < 8; i++)
		dir.name[len dir.name] = int arr[i];
	for(; i < 11; i++)
		dir.ext[len dir.ext] = int arr[i];
	dir.attr = arr[11];
	dir.reserved = arr[12:22];
	dir.time = arr[22:24];
	dir.date = arr[24:26];
	dir.start = arr[26:28];
	dir.length = arr[28:32];
	return dir;
}

Dosdir.Dd2arr(d: ref Dosdir): array of byte
{
	a := array[32] of byte;
	i:=0;
	for(j := 0; j < len d.name; j++)
		a[i++] = byte d.name[j];
	for(; j<8; j++)
		a[i++]= byte 0;
	for(j=0; j<len d.ext; j++)
		a[i++] = byte d.ext[j];
	for(; j<3; j++)
		a[i++]= byte 0;
	a[i++] = d.attr;
	for(j=0; j<10; j++)
		a[i++] = d.reserved[j];
	for(j=0; j<2; j++)
		a[i++] = d.time[j];
	for(j=0; j<2; j++)
		a[i++] = d.date[j];
	for(j=0; j<2; j++)
		a[i++] = d.start[j];
	for(j=0; j<4; j++)
		a[i++] = d.length[j];
	return a;
}

#
# checksum of short name for use in long name directory entries
# assumes sname is already padded correctly to 8+3
#
aliassum(sname: string): int
{
	i := 0;
	for(sum:=0; i<11; i++)
		sum = (((sum&1)<<7)|((sum&16rfe)>>1))+sname[i];
	return sum;
}

#
# track i/o
#

# An Xfs represents the root of an external file system, anchored
# to the server and the client
Xfs: adt {
	next:cyclic ref Xfs;
	name: string;	# of file containing external f.s. 
	qid: Sys->Qid;	# of file containing external f.s. 
	refn: int;		# attach count 
	rootqid: Sys->Qid;	# of inferno constructed root directory 
	dev: ref Sys->FD;  # FD of the file containing external f.s.
	fmt: int;		# successfully read format
	offset: int;		# offset in sectors to file system
	ptr: ref Dosbpb;
};

# An Xfile represents the mapping of fid's & qid's to the server.
Xfile: adt {
	next: cyclic ref Xfile;		# in hash bucket 
	client: int;
	fid: int;
	flags: int;
	qid: Sys->Qid;
	xf: ref Xfs;
	ptr: ref Dosptr;
};

Iosect: adt
{
	next: cyclic ref Iosect;
	flags: int;
	t: cyclic ref Iotrack;
	iobuf: array of byte;
};

Iotrack: adt 
{
	flags: int;
	xf: ref Xfs;
	addr: int;
	next: cyclic ref Iotrack;		# in lru list 
	prev: cyclic ref Iotrack;
	hnext: cyclic ref Iotrack;		# in hash list 
	hprev: cyclic ref Iotrack;
	refn: int;
	tp: cyclic ref Track;
};

Track: adt
{
	create: fn(): ref Track;
	p: cyclic array of ref Iosect;
	buf: array of byte;
};

BMOD: con	1<<0;
BIMM: con	1<<1;
BSTALE: con	1<<2;

HIOB: con 31;	# a prime 
NIOBUF: con 20;

Sectorsize: con 512;
Sect2trk: con 9;	# default

hiob := array[HIOB+1] of ref Iotrack;		# hash buckets + lru list
iobuf := array[NIOBUF] of ref Iotrack;		# the real ones
freelist: ref Iosect;
sect2trk := Sect2trk;
trksize := Sect2trk*Sectorsize;

FIDMOD: con 127;	# prime
xhead:		ref Xfs;
client:		int;

xfiles := array[FIDMOD] of ref Xfile;
iodebug := 0;

iotrackinit(sectors: int)
{
	if(sectors <= 0)
		sectors = 9;
	sect2trk = sectors;
	trksize = sect2trk*Sectorsize;

	freelist = nil;

	for(i := 0;i < FIDMOD; i++)
		xfiles[i] = ref Xfile(nil,0,0,0,Sys->Qid(big 0,0,0),nil,nil);

	for(i = 0; i <= HIOB; i++)
		hiob[i] = ref Iotrack;

	for(i = 0; i < HIOB; i++) {
		hiob[i].hprev = hiob[i];
		hiob[i].hnext = hiob[i];
		hiob[i].refn = 0;
		hiob[i].addr = 0;
	}
	hiob[i].prev = hiob[i];
	hiob[i].next = hiob[i];
	hiob[i].refn = 0;
	hiob[i].addr = 0;

	for(i=0;i<NIOBUF;i++)
		iobuf[i] = ref Iotrack;

	for(i=0; i<NIOBUF; i++) {
		iobuf[i].hprev = iobuf[i].hnext = iobuf[i];
		iobuf[i].prev = iobuf[i].next = iobuf[i];
		iobuf[i].refn=iobuf[i].addr=0;
		iobuf[i].flags = 0;
		if(hiob[HIOB].next != iobuf[i]) {
			iobuf[i].prev.next = iobuf[i].next;
			iobuf[i].next.prev = iobuf[i].prev;
			iobuf[i].next = hiob[HIOB].next;
			iobuf[i].prev = hiob[HIOB];
			hiob[HIOB].next.prev = iobuf[i];
			hiob[HIOB].next = iobuf[i];
		}
		iobuf[i].tp =  Track.create();
	}
}

Track.create(): ref Track
{
	t := ref Track;
	t.p = array[sect2trk] of ref Iosect;
	t.buf = array[trksize] of byte;
	return t;
}

getsect(xf: ref Xfs, addr: int): ref Iosect
{
	return getiosect(xf, addr, 1);
}

getosect(xf: ref Xfs, addr: int): ref Iosect
{
	return getiosect(xf, addr, 0);
}

# get the sector corresponding to the address addr.
getiosect(xf: ref Xfs, addr , rflag: int): ref Iosect
{
	# offset from beginning of track.
	toff := addr %  sect2trk;

	# address of beginning of track.
	taddr := addr -  toff;
	t := getiotrack(xf, taddr);

	if(rflag && t.flags&BSTALE) {
		if(tread(t) < 0)
			return nil;

		t.flags &= ~BSTALE;
	}

	t.refn++;
	if(t.tp.p[toff] == nil) {
		p := newsect();
		t.tp.p[toff] = p;
		p.flags = t.flags&BSTALE;
		p.t = t;
		p.iobuf = t.tp.buf[toff*Sectorsize:(toff+1)*Sectorsize];
	}
	return t.tp.p[toff];
}

putsect(p: ref Iosect)
{
	t: ref Iotrack;

	t = p.t;
	t.flags |= p.flags;
	p.flags = 0;
	t.refn--;
	if(t.refn < 0)
		panic("putsect: refcount");

	if(t.flags & BIMM) {
		if(t.flags & BMOD)
			twrite(t);
		t.flags &= ~(BMOD|BIMM);
	}
}

# get the track corresponding to addr
# (which is the address of the beginning of a track
getiotrack(xf: ref Xfs, addr: int): ref Iotrack
{
	p: ref Iotrack;
	mp := hiob[HIOB];
	
	if(iodebug)
		chat(sys->sprint("iotrack %d,%d...", xf.dev.fd, addr));

	# find bucket in hash table.
	h := (xf.dev.fd<<24) ^ addr;
	if(h < 0)
		h = ~h;
	h %= HIOB;
	hp := hiob[h];

	out: for(;;){
		loop: for(;;) {
		 	# look for it in the active list
			for(p = hp.hnext; p != hp; p=p.hnext) {
				if(p.addr != addr || p.xf != xf)
					continue;
				if(p.addr == addr && p.xf == xf) {
					break out;
				}
				continue loop;
			}
		
		 	# not found
		 	# take oldest unref'd entry
			for(p = mp.prev; p != mp; p=p.prev)
				if(p.refn == 0 )
					break;
			if(p == mp) {
				if(iodebug)
					chat("iotrack all ref'd\n");
				continue loop;
			}

			if((p.flags & BMOD)!= 0) {
				twrite(p);
				p.flags &= ~(BMOD|BIMM);
				continue loop;
			}
			purgetrack(p);
			p.addr = addr;
			p.xf = xf;
			p.flags = BSTALE;
			break out;
		}
	}

	if(hp.hnext != p) {
		p.hprev.hnext = p.hnext;
		p.hnext.hprev = p.hprev;			
		p.hnext = hp.hnext;
		p.hprev = hp;
		hp.hnext.hprev = p;
		hp.hnext = p;
	}
	if(mp.next != p) {
		p.prev.next = p.next;
		p.next.prev = p.prev;
		p.next = mp.next;
		p.prev = mp;
		mp.next.prev = p;
		mp.next = p;			
	}
	return p;
}

purgetrack(t: ref Iotrack)
{
	refn := sect2trk;
	for(i := 0; i < sect2trk; i++) {
		if(t.tp.p[i] == nil) {
			--refn;
			continue;
		}
		freesect(t.tp.p[i]);
		--refn;
		t.tp.p[i]=nil;
	}
	if(t.refn != refn)
		panic("purgetrack");
	if(refn!=0)
		panic("refn not 0");
}

twrite(t: ref Iotrack): int
{
	if(iodebug)
		chat(sys->sprint("[twrite %d...", t.addr));

	if((t.flags & BSTALE)!= 0) {
		refn:=0;
		for(i:=0; i<sect2trk; i++)
			if(t.tp.p[i]!=nil)
				++refn;

		if(refn < sect2trk) {
			if(tread(t) < 0) {
				if (iodebug)
					chat("error]");
				return -1;
			}
		}
		else
			t.flags &= ~BSTALE;
	}

	if(devwrite(t.xf, t.addr, t.tp.buf) < 0) {
		if(iodebug)
			chat("error]");
		return -1;
	}

	if(iodebug)
		chat(" done]");

	return 0;
}

tread(t: ref Iotrack): int
{
	refn := 0;
	rval: int;

	for(i := 0; i < sect2trk; i++)
		if(t.tp.p[i] != nil)
			++refn;

	if(iodebug)
		chat(sys->sprint("[tread %d...", t.addr));

	tbuf := t.tp.buf;
	if(refn != 0)
		tbuf = array[trksize] of byte;

	rval = devread(t.xf, t.addr, tbuf);
	if(rval < 0) {
		if(iodebug)
			chat("error]");
		return -1;
	}

	if(refn != 0) {
		for(i=0; i < sect2trk; i++) {
			if(t.tp.p[i] == nil) {
				t.tp.buf[i*Sectorsize:]=tbuf[i*Sectorsize:(i+1)*Sectorsize];
				if(iodebug)
					chat(sys->sprint("%d ", i));
			}
		}
	}

	if(iodebug)
		chat("done]");

	t.flags &= ~BSTALE;
	return 0;
}

purgebuf(xf: ref Xfs)
{
	for(p := 0; p < NIOBUF; p++) {
		if(iobuf[p].xf != xf)
			continue;
		if(iobuf[p].xf == xf) {
			if((iobuf[p].flags & BMOD) != 0)
				twrite(iobuf[p]);

			iobuf[p].flags = BSTALE;
			purgetrack(iobuf[p]);
		}
	}
}

sync()
{
	for(p := 0; p < NIOBUF; p++) {
		if(!(iobuf[p].flags & BMOD))
			continue;

		if(iobuf[p].flags & BMOD){
			twrite(iobuf[p]);
			iobuf[p].flags &= ~(BMOD|BIMM);
		}
	}
}


newsect(): ref Iosect
{
	if((p := freelist)!=nil)	{
		freelist = p.next;
		p.next = nil;
	} else
		p = ref Iosect(nil, 0, nil,nil);

	return p;
}

freesect(p: ref Iosect)
{
	p.next = freelist;
	freelist = p;
}


# devio from here
deverror(name: string, xf: ref Xfs, addr,n,nret: int): int
{
	if(nret < 0) {
		if(iodebug)
			chat(sys->sprint("%s errstr=\"%r\"...", name));
		xf.dev = nil;
		return -1;
	}
	if(iodebug)
		chat(sys->sprint("dev %d sector %d, %s: %d, should be %d\n",
			xf.dev.fd, addr, name, nret, n));

	panic(name);
	return -1;
}

devread(xf: ref Xfs, addr: int, buf: array of byte): int
{
	if(xf.dev==nil)
		return -1;

	sys->seek(xf.dev, big (xf.offset+addr*Sectorsize), sys->SEEKSTART);
	nread := sys->read(xf.dev, buf, trksize);
	if(nread != trksize)
		return deverror("read", xf, addr, trksize, nread);

	return 0;
}

devwrite(xf: ref Xfs, addr: int, buf: array of byte): int
{
	if(xf.dev == nil)
		return -1;

	sys->seek(xf.dev, big (xf.offset+addr*Sectorsize), 0);
	nwrite := sys->write(xf.dev, buf, trksize);
	if(nwrite != trksize)
		return deverror("write", xf, addr, trksize , nwrite);

	return 0;
}

devcheck(xf: ref Xfs): int
{
	buf := array[Sectorsize] of byte;

	if(xf.dev == nil)
		return -1;

	sys->seek(xf.dev, big 0, sys->SEEKSTART);
	if(sys->read(xf.dev, buf, Sectorsize) != Sectorsize){
		xf.dev = nil;
		return -1;
	}

	return 0;
}

# setup and return the Xfs associated with "name"

getxfs(name: string): (ref Xfs, string)
{
	if(name == nil)
		return (nil, "no file system device specified");

	
	 # If the name passed is of the form 'name:offset' then
	 # offset is used to prime xf->offset. This allows accessing
	 # a FAT-based filesystem anywhere within a partition.
	 # Typical use would be to mount a filesystem in the presence
	 # of a boot manager programm at the beginning of the disc.
	
	offset := 0;
	for(i := 0;i < len name; i++)
		if(name[i]==':')
			break;

	if(i < len name) {
		offset = int name[i+1:];
		if(offset < 0)
			return (nil, "invalid device offset to file system");
		offset *= Sectorsize;
		name = name[0:i];
	}

	fd := sys->open(name, Sys->ORDWR);
	if(fd == nil) {
		if(iodebug)
			chat(sys->sprint("getxfs: open(%s) failed: %r\n", name));
		return (nil, sys->sprint("can't open %s: %r", name));
	}

	(rval,dir) := sys->fstat(fd);
	if(rval < 0)
		return (nil, sys->sprint("can't stat %s: %r", name));
	
	# lock down the list of xf's.
	fxf: ref Xfs;
	for(xf := xhead; xf != nil; xf = xf.next) {
		if(xf.refn == 0) {
			if(fxf == nil)
				fxf = xf;
			continue;
		}
		if(xf.qid.path != dir.qid.path || xf.qid.vers != dir.qid.vers)
			continue;

		if(xf.name!= name || xf.dev == nil)
			continue;

		if(devcheck(xf) < 0) # look for media change
			continue;

		if(offset && xf.offset != offset)
			continue;

		if(iodebug)
			chat(sys->sprint("incref \"%s\", dev=%d...",
				xf.name, xf.dev.fd));

		++xf.refn;
		return (xf, nil);
	}
	
	# this xf doesn't exist, make a new one and stick it on the list.
	if(fxf == nil){
		fxf = ref Xfs;
		fxf.next = xhead;
		xhead = fxf;
	}

	if(iodebug)
		chat(sys->sprint("alloc \"%s\", dev=%d...", name, fd.fd));

	fxf.name = name;
	fxf.refn = 1;
	fxf.qid = dir.qid;
	fxf.dev = fd;
	fxf.fmt = 0;
	fxf.offset = offset;
	return (fxf, nil);
}

refxfs(xf: ref Xfs, delta: int)
{
	xf.refn += delta;
	if(xf.refn == 0) {
		if (iodebug)
			chat(sys->sprint("free \"%s\", dev=%d...",
				xf.name, xf.dev.fd));

		purgebuf(xf);
		if(xf.dev !=nil)
			xf.dev = nil;
	}
}

xfile(fid, flag: int): ref Xfile
{
	pf: ref Xfile;

	# find hashed file list in LRU? table.
	k := (fid^client)%FIDMOD;

	# find if this fid is in the hashed file list.
	f:=xfiles[k];
	for(pf = nil; f != nil; f = f.next) {
		if(f.fid == fid && f.client == client)
			break;
		pf=f;
	}
	
	# move this fid to the front of the list if it was further down.
	if(f != nil && pf != nil){
		pf.next = f.next;
		f.next = xfiles[k];
		xfiles[k] = f;
	}

	case flag {
	* =>
		panic("xfile");
	Asis =>
		if(f != nil && f.xf != nil && f.xf.dev == nil)
			return nil;
		return f;
	Clean =>
		break;
	Clunk =>
		if(f != nil) {
			xfiles[k] = f.next;
			clean(f);
		}
		return nil;
	}

	# clean it up ..
	if(f != nil)
		return clean(f);

	# f wasn't found in the hashtable, make a new one and add it
	f = ref Xfile;
	f.next = xfiles[k];
	xfiles[k] = f;
	# sort out the fid, etc.
	f.fid = fid;
	f.client = client;
	f.flags = 0;
	f.qid = Sys->Qid(big 0, 0, Styx->QTFILE);
	f.xf = nil;
	f.ptr = ref Dosptr(0,0,0,0,0,0,-1,-1,nil,nil);
	return f;
}

clean(f: ref Xfile): ref Xfile
{
	f.ptr = nil;
	if(f.xf != nil) {
		refxfs(f.xf, -1);
		f.xf = nil;
	}
	f.flags = 0;
	f.qid = Sys->Qid(big 0, 0, 0);
	return f;
}

#
# the file at <addr, offset> has moved
# relocate the dos entries of all fids in the same file
#
dosptrreloc(f: ref Xfile, dp: ref Dosptr, addr: int, offset: int)
{
	i: int;
	p: ref Xfile;
	xdp: ref Dosptr;

	for(i=0; i < FIDMOD; i++){
		for(p = xfiles[i]; p != nil; p = p.next){
			xdp = p.ptr;
			if(p != f && p.xf == f.xf
			&& xdp != nil && xdp.addr == addr && xdp.offset == offset){
				*xdp = *dp;
				xdp.p = nil;
				# xdp.d = nil;
				p.qid.path = big QIDPATH(xdp);
			}
		}
	}
}