ref: 5611a46d8fb04ec3fd60c05a1486743cea98a311
dir: /appl/cmd/9660srv.b/
implement ISO9660;
include "sys.m";
sys: Sys;
Dir, Qid, QTDIR, QTFILE, DMDIR: import sys;
include "draw.m";
include "daytime.m";
daytime: Daytime;
include "string.m";
str: String;
include "styx.m";
styx: Styx;
Rmsg, Tmsg: import styx;
include "arg.m";
ISO9660: module
{
init: fn(nil: ref Draw->Context, nil: list of string);
};
Sectorsize: con 2048;
Maxname: con 256;
Enonexist: con "file does not exist";
Eperm: con "permission denied";
Enofile: con "no file system specified";
Eauth: con "authentication failed";
Ebadfid: con "invalid fid";
Efidinuse: con "fid already in use";
Enotdir: con "not a directory";
Esyntax: con "file name syntax";
devname: string;
chatty := 0;
showstyx := 0;
progname := "9660srv";
stderr: ref Sys->FD;
noplan9 := 0;
nojoliet := 0;
norock := 0;
usage()
{
sys->fprint(sys->fildes(2), "usage: %s [-rabc] [-9JR] [-s] cd_device dir\n", progname);
raise "fail:usage";
}
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
sys->pctl(Sys->FORKFD|Sys->NEWPGRP, nil);
stderr = sys->fildes(2);
if(args != nil)
progname = hd args;
styx = load Styx Styx->PATH;
if(styx == nil)
noload(Styx->PATH);
styx->init();
if(args != nil)
progname = hd args;
mountopt := Sys->MREPL;
copt := 0;
stdio := 0;
arg := load Arg Arg->PATH;
if(arg == nil)
noload(Arg->PATH);
arg->init(args);
while((c := arg->opt()) != 0)
case c {
'v' or 'D' => chatty = 1; showstyx = 1;
'r' => mountopt = Sys->MREPL;
'a' => mountopt = Sys->MAFTER;
'b' => mountopt = Sys->MBEFORE;
'c' => copt = Sys->MCREATE;
's' => stdio = 1;
'9' => noplan9 = 1;
'J' => nojoliet = 1;
'R' => norock = 1;
* => usage();
}
args = arg->argv();
arg = nil;
if(args == nil || tl args == nil)
usage();
what := hd args;
mountpt := hd tl args;
daytime = load Daytime Daytime->PATH;
if(daytime == nil)
noload(Daytime->PATH);
iobufinit(Sectorsize);
pip := array[2] of ref Sys->FD;
if(stdio){
pip[0] = sys->fildes(0);
pip[1] = sys->fildes(1);
}else
if(sys->pipe(pip) < 0)
error(sys->sprint("can't create pipe: %r"));
devname = what;
sync := chan of int;
spawn fileserve(pip[1], sync);
<-sync;
if(sys->mount(pip[0], nil, mountpt, mountopt|copt, nil) < 0) {
sys->fprint(sys->fildes(2), "%s: mount %s %s failed: %r\n", progname, what, mountpt);
exit;
}
}
noload(s: string)
{
sys->fprint(sys->fildes(2), "%s: can't load %s: %r\n", progname, s);
raise "fail:load";
}
error(p: string)
{
sys->fprint(sys->fildes(2), "9660srv: %s\n", p);
raise "fail:error";
}
fileserve(rfd: ref Sys->FD, sync: chan of int)
{
sys->pctl(Sys->NEWFD|Sys->FORKNS, list of {2, rfd.fd});
rfd = sys->fildes(rfd.fd);
stderr = sys->fildes(2);
sync <-= 1;
while((m := Tmsg.read(rfd, 0)) != nil){
if(showstyx)
chat(sys->sprint("%s...", m.text()));
r: ref Rmsg;
pick t := m {
Readerror =>
error(sys->sprint("mount read error: %s", t.error));
Version =>
r = rversion(t);
Auth =>
r = rauth(t);
Flush =>
r = rflush(t);
Attach =>
r = rattach(t);
Walk =>
r = rwalk(t);
Open =>
r = ropen(t);
Create =>
r = rcreate(t);
Read =>
r = rread(t);
Write =>
r = rwrite(t);
Clunk =>
r = rclunk(t);
Remove =>
r = rremove(t);
Stat =>
r = rstat(t);
Wstat =>
r = rwstat(t);
* =>
error(sys->sprint("invalid T-message tag: %d", tagof m));
}
pick e := r {
Error =>
r.tag = m.tag;
}
rbuf := r.pack();
if(rbuf == nil)
error("bad R-message conversion");
if(showstyx)
chat(r.text()+"\n");
if(sys->write(rfd, rbuf, len rbuf) != len rbuf)
error(sys->sprint("connection write error: %r"));
}
if(chatty)
chat("server end of file\n");
}
E(s: string): ref Rmsg.Error
{
return ref Rmsg.Error(0, s);
}
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
{
dname := devname;
if(t.aname != "")
dname = t.aname;
(dev, err) := devattach(dname, Sys->OREAD, Sectorsize);
if(dev == nil)
return E(err);
xf := Xfs.new(dev);
root := cleanfid(t.fid);
root.qid = Sys->Qid(big 0, 0, Sys->QTDIR);
root.xf = xf;
err = root.attach();
if(err != nil){
clunkfid(t.fid);
return E(err);
}
xf.rootqid = root.qid;
return ref Rmsg.Attach(t.tag, root.qid);
}
walk1(f: ref Xfile, name: string): string
{
if(!(f.qid.qtype & Sys->QTDIR))
return Enotdir;
case name {
"." =>
return nil; # nop, but shouldn't happen
".." =>
if(f.qid.path==f.xf.rootqid.path)
return nil;
return f.walkup();
* =>
return f.walk(name);
}
}
rwalk(t: ref Tmsg.Walk): ref Rmsg
{
f:=findfid(t.fid);
if(f == nil)
return E(Ebadfid);
nf, sf: ref Xfile;
if(t.newfid != t.fid){
nf = cleanfid(t.newfid);
if(nf == nil)
return E(Efidinuse);
f.clone(nf);
f = nf;
}else
sf = f.save();
qids: array of Sys->Qid;
if(len t.names > 0){
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){
if(nf != nil){
nf.clunk();
clunkfid(t.newfid);
}else
f.restore(sf);
if(i == 0)
return E(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
{
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
if(f.flags&Omodes)
return E("open on open file");
e := f.open(t.mode);
if(e != nil)
return E(e);
f.flags = openflags(t.mode);
return ref Rmsg.Open(t.tag, f.qid, Styx->MAXFDATA);
}
rcreate(t: ref Tmsg.Create): ref Rmsg
{
name := t.name;
if(name == "." || name == "..")
return E(Esyntax);
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
if(f.flags&Omodes)
return E("create on open file");
if(!(f.qid.qtype&Sys->QTDIR))
return E("create in non-directory");
e := f.create(name, t.perm, t.mode);
if(e != nil)
return E(e);
f.flags = openflags(t.mode);
return ref Rmsg.Create(t.tag, f.qid, Styx->MAXFDATA);
}
rread(t: ref Tmsg.Read): ref Rmsg
{
err: string;
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
if (!(f.flags&Oread))
return E("file not opened for reading");
if(t.count < 0 || t.offset < big 0)
return E("negative offset or count");
b := array[Styx->MAXFDATA] of byte;
count: int;
if(f.qid.qtype & Sys->QTDIR)
(count, err) = f.readdir(b, int t.offset, t.count);
else
(count, err) = f.read(b, int t.offset, t.count);
if(err != nil)
return E(err);
if(count != len b)
b = b[0:count];
return ref Rmsg.Read(t.tag, b);
}
rwrite(nil: ref Tmsg.Write): ref Rmsg
{
return E(Eperm);
}
rclunk(t: ref Tmsg.Clunk): ref Rmsg
{
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
f.clunk();
clunkfid(t.fid);
return ref Rmsg.Clunk(t.tag);
}
rremove(t: ref Tmsg.Remove): ref Rmsg
{
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
f.clunk();
clunkfid(t.fid);
return E(Eperm);
}
rstat(t: ref Tmsg.Stat): ref Rmsg
{
f := findfid(t.fid);
if(f == nil)
return E(Ebadfid);
(dir, nil) := f.stat();
return ref Rmsg.Stat(t.tag, *dir);
}
rwstat(nil: ref Tmsg.Wstat): ref Rmsg
{
return E(Eperm);
}
openflags(mode: int): int
{
flags := 0;
case mode & ~(Sys->OTRUNC|Sys->ORCLOSE) {
Sys->OREAD =>
flags = Oread;
Sys->OWRITE =>
flags = Owrite;
Sys->ORDWR =>
flags = Oread|Owrite;
}
if(mode & Sys->ORCLOSE)
flags |= Orclose;
return flags;
}
chat(s: string)
{
if(chatty)
sys->fprint(stderr, "%s", s);
}
Fid: adt {
fid: int;
file: ref Xfile;
};
FIDMOD: con 127; # prime
fids := array[FIDMOD] of list of ref Fid;
hashfid(fid: int): (ref Fid, array of list of ref Fid)
{
nl: list of ref Fid;
hp := fids[fid%FIDMOD:];
nl = nil;
for(l := hp[0]; l != nil; l = tl l){
f := hd l;
if(f.fid == fid){
l = tl l; # excluding f
for(; nl != nil; nl = tl nl)
l = (hd nl) :: l; # put examined ones back, in order
hp[0] = l;
return (f, hp);
} else
nl = f :: nl;
}
return (nil, hp);
}
findfid(fid: int): ref Xfile
{
(f, hp) := hashfid(fid);
if(f == nil){
chat("unassigned fid");
return nil;
}
hp[0] = f :: hp[0];
return f.file;
}
cleanfid(fid: int): ref Xfile
{
(f, hp) := hashfid(fid);
if(f != nil){
chat("fid in use");
return nil;
}
f = ref Fid;
f.fid = fid;
f.file = Xfile.new();
hp[0] = f :: hp[0];
return f.file.clean();
}
clunkfid(fid: int)
{
(f, nil) := hashfid(fid);
if(f != nil)
f.file.clean();
}
#
#
#
Xfs: adt {
d: ref Device;
inuse: int;
issusp: int; # system use sharing protocol in use?
suspoff: int; # LEN_SKP, if so
isplan9: int; # has Plan 9-specific directory info
isrock: int; # is rock ridge
rootqid: Sys->Qid;
ptr: int; # tag for private data
new: fn(nil: ref Device): ref Xfs;
incref: fn(nil: self ref Xfs);
decref: fn(nil: self ref Xfs);
};
Xfile: adt {
xf: ref Xfs;
flags: int;
qid: Sys->Qid;
ptr: ref Isofile; # tag for private data
new: fn(): ref Xfile;
clean: fn(nil: self ref Xfile): ref Xfile;
save: fn(nil: self ref Xfile): ref Xfile;
restore: fn(nil: self ref Xfile, s: ref Xfile);
attach: fn(nil: self ref Xfile): string;
clone: fn(nil: self ref Xfile, nil: ref Xfile);
walkup: fn(nil: self ref Xfile): string;
walk: fn(nil: self ref Xfile, nil: string): string;
open: fn(nil: self ref Xfile, nil: int): string;
create: fn(nil: self ref Xfile, nil: string, nil: int, nil: int): string;
readdir: fn(nil: self ref Xfile, nil: array of byte, nil: int, nil: int): (int, string);
read: fn(nil: self ref Xfile, nil: array of byte, nil: int, nil: int): (int, string);
write: fn(nil: self ref Xfile, nil: array of byte, nil: int, nil: int): (int, string);
clunk: fn(nil: self ref Xfile);
remove: fn(nil: self ref Xfile): string;
stat: fn(nil: self ref Xfile): (ref Sys->Dir, string);
wstat: fn(nil: self ref Xfile, nil: ref Sys->Dir): string;
};
Oread, Owrite, Orclose: con 1<<iota;
Omodes: con 3; # mask
VOLDESC: con 16; # sector number
Drec: adt {
reclen: int;
attrlen: int;
addr: int; # should be big?
size: int; # should be big?
date: array of byte;
time: int;
tzone: int; # not in high sierra
flags: int;
unitsize: int;
gapsize: int;
vseqno: int;
name: array of byte;
data: array of byte; # system extensions
};
Isofile: adt {
fmt: int; # 'z' if iso, 'r' if high sierra
blksize: int;
offset: int; # true offset when reading directory
doffset: int; # styx offset when reading directory
d: ref Drec;
};
Xfile.new(): ref Xfile
{
f := ref Xfile;
return f.clean();
}
Xfile.clean(f: self ref Xfile): ref Xfile
{
if(f.xf != nil){
f.xf.decref();
f.xf = nil;
}
f.ptr = nil;
f.flags = 0;
f.qid = Qid(big 0, 0, 0);
return f;
}
Xfile.save(f: self ref Xfile): ref Xfile
{
s := ref Xfile;
*s = *f;
s.ptr = ref *f.ptr;
s.ptr.d = ref *f.ptr.d;
return s;
}
Xfile.restore(f: self ref Xfile, s: ref Xfile)
{
f.flags = s.flags;
f.qid = s.qid;
*f.ptr = *s.ptr;
}
Xfile.attach(root: self ref Xfile): string
{
fmt := 0;
blksize := 0;
haveplan9 := 0;
dirp: ref Block;
dp := ref Drec;
for(a:=VOLDESC;a<VOLDESC+100;a++){
p := Block.get(root.xf.d, a);
if(p == nil){
if(dirp != nil)
dirp.put();
return "can't read volume descriptor";
}
v := p.data; # Voldesc
if(eqs(v[0:7], "\u0001CD001\u0001")){ # ISO
if(dirp != nil)
dirp.put();
dirp = p;
fmt = 'z';
convM2Drec(v[156:], dp, 0); # v.z.desc.rootdir
blksize = l16(v[128:]); # v.z.desc.blksize
if(chatty)
chat(sys->sprint("iso, blksize=%d...", blksize));
haveplan9 = eqs(v[8:8+6], "PLAN 9"); # v.z.boot.sysid
if(haveplan9){
if(noplan9) {
chat("ignoring plan9");
haveplan9 = 0;
}else{
fmt = '9';
chat("plan9 iso...");
}
}
continue;
}
if(eqs(v[8:8+7], "\u0001CDROM\u0001")){ # high sierra
if(dirp != nil)
dirp.put();
dirp = p;
fmt = 'r';
convM2Drec(v[180:], dp, 1); # v.r.desc.rootdir
blksize = l16(v[136:]); # v.r.desc.blksize
if(chatty)
chat(sys->sprint("high sierra, blksize=%d...", blksize));
continue;
}
if(haveplan9==0 && !nojoliet && eqs(v[0:7], "\u0002CD001\u0001")){
q := v[88:]; # v.z.desc.escapes
if(q[0] == byte 16r25 && q[1] == byte 16r2F &&
(q[2] == byte 16r40 || q[2] == byte 16r43 || q[2] == byte 16r45)){ # joliet, it appears
if(dirp != nil)
dirp.put();
dirp = p;
fmt = 'J';
convM2Drec(v[156:], dp, 0); # v.z.desc.rootdir
if(blksize != l16(v[128:])) # v.z.desc.blksize
sys->fprint(stderr, "9660srv: warning: suspicious Joliet block size: %d\n", l16(v[128:]));
chat("joliet...");
continue;
}
}else{
p.put();
if(v[0] == byte 16rFF)
break;
}
}
if(fmt == 0){
if(dirp != nil)
dirp.put();
return "CD format not recognised";
}
if(chatty)
showdrec(stderr, fmt, dp);
if(blksize > Sectorsize){
dirp.put();
return "blocksize too big";
}
fp := iso(root);
root.xf.isplan9 = haveplan9;
fp.fmt = fmt;
fp.blksize = blksize;
fp.offset = 0;
fp.doffset = 0;
fp.d = dp;
root.qid.path = big dp.addr;
root.qid.qtype = QTDIR;
root.qid.vers = 0;
dirp.put();
dp = ref Drec;
if(getdrec(root, dp) >= 0){
s := dp.data;
n := len s;
if(n >= 7 && s[0] == byte 'S' && s[1] == byte 'P' && s[2] == byte 7 &&
s[3] == byte 1 && s[4] == byte 16rBE && s[5] == byte 16rEF){
root.xf.issusp = 1;
root.xf.suspoff = int s[6];
n -= root.xf.suspoff;
s = s[root.xf.suspoff:];
while(n >= 4){
l := int s[2];
if(s[0] == byte 'E' && s[1] == byte 'R'){
if(int s[4] == 10 && eqs(s[8:18], "RRIP_1991A"))
root.xf.isrock = 1;
break;
} else if(s[0] == byte 'C' && s[1] == byte 'E' && int s[2] >= 28){
(s, n) = getcontin(root.xf.d, s);
continue;
} else if(s[0] == byte 'R' && s[1] == byte 'R'){
if(!norock)
root.xf.isrock = 1;
break; # can skip search for ER
} else if(s[0] == byte 'S' && s[1] == byte 'T')
break;
s = s[l:];
n -= l;
}
}
}
if(root.xf.isrock)
chat("Rock Ridge...");
fp.offset = 0;
fp.doffset = 0;
return nil;
}
Xfile.clone(oldf: self ref Xfile, newf: ref Xfile)
{
*newf = *oldf;
newf.ptr = nil;
newf.xf.incref();
ip := iso(oldf);
np := iso(newf);
*np = *ip; # might not be right; shares ip.d
}
Xfile.walkup(f: self ref Xfile): string
{
pf := Xfile.new();
ppf := Xfile.new();
e := walkup(f, pf, ppf);
pf.clunk();
ppf.clunk();
return e;
}
walkup(f, pf, ppf: ref Xfile): string
{
e := opendotdot(f, pf);
if(e != nil)
return sys->sprint("can't open pf: %s", e);
paddr := iso(pf).d.addr;
if(iso(f).d.addr == paddr)
return nil;
e = opendotdot(pf, ppf);
if(e != nil)
return sys->sprint("can't open ppf: %s", e);
d := ref Drec;
while(getdrec(ppf, d) >= 0){
if(d.addr == paddr){
newdrec(f, d);
f.qid.path = big paddr;
f.qid.qtype = QTDIR;
f.qid.vers = 0;
return nil;
}
}
return "can't find addr of ..";
}
Xfile.walk(f: self ref Xfile, name: string): string
{
ip := iso(f);
if(!f.xf.isplan9){
for(i := 0; i < len name; i++)
if(name[i] == ';')
break;
if(i >= Maxname)
i = Maxname-1;
name = name[0:i];
}
if(chatty)
chat(sys->sprint("%d \"%s\"...", len name, name));
ip.offset = 0;
dir := ref Dir;
d := ref Drec;
while(getdrec(f, d) >= 0) {
dvers := rzdir(f.xf, dir, ip.fmt, d);
if(name != dir.name)
continue;
newdrec(f, d);
f.qid.path = dir.qid.path;
f.qid.qtype = dir.qid.qtype;
f.qid.vers = dir.qid.vers;
if(dvers){
# versions ignored
}
return nil;
}
return Enonexist;
}
Xfile.open(f: self ref Xfile, mode: int): string
{
if(mode != Sys->OREAD)
return Eperm;
ip := iso(f);
ip.offset = 0;
ip.doffset = 0;
return nil;
}
Xfile.create(nil: self ref Xfile, nil: string, nil: int, nil: int): string
{
return Eperm;
}
Xfile.readdir(f: self ref Xfile, buf: array of byte, offset: int, count: int): (int, string)
{
ip := iso(f);
d := ref Dir;
drec := ref Drec;
if(offset < ip.doffset){
ip.offset = 0;
ip.doffset = 0;
}
rcnt := 0;
while(rcnt < count && getdrec(f, drec) >= 0){
if(len drec.name == 1){
if(drec.name[0] == byte 0)
continue;
if(drec.name[0] == byte 1)
continue;
}
rzdir(f.xf, d, ip.fmt, drec);
d.qid.vers = f.qid.vers;
a := styx->packdir(*d);
if(ip.doffset < offset){
ip.doffset += len a;
continue;
}
if(rcnt+len a > count)
break;
buf[rcnt:] = a; # BOTCH: copy
rcnt += len a;
}
ip.doffset += rcnt;
return (rcnt, nil);
}
Xfile.read(f: self ref Xfile, buf: array of byte, offset: int, count: int): (int, string)
{
ip := iso(f);
if(offset >= ip.d.size)
return (0, nil);
if(offset+count > ip.d.size)
count = ip.d.size - offset;
addr := (ip.d.addr+ip.d.attrlen)*ip.blksize + offset;
o := addr % Sectorsize;
addr /= Sectorsize;
if(chatty)
chat(sys->sprint("d.addr=0x%x, addr=0x%x, o=0x%x...", ip.d.addr, addr, o));
n := Sectorsize - o;
rcnt := 0;
while(count > 0){
if(n > count)
n = count;
p := Block.get(f.xf.d, addr);
if(p == nil)
return (-1, "i/o error");
buf[rcnt:] = p.data[o:o+n];
p.put();
count -= n;
rcnt += n;
addr++;
o = 0;
n = Sectorsize;
}
return (rcnt, nil);
}
Xfile.write(nil: self ref Xfile, nil: array of byte, nil: int, nil: int): (int, string)
{
return (-1, Eperm);
}
Xfile.clunk(f: self ref Xfile)
{
f.ptr = nil;
}
Xfile.remove(nil: self ref Xfile): string
{
return Eperm;
}
Xfile.stat(f: self ref Xfile): (ref Dir, string)
{
ip := iso(f);
d := ref Dir;
rzdir(f.xf, d, ip.fmt, ip.d);
d.qid.vers = f.qid.vers;
if(d.qid.path==f.xf.rootqid.path){
d.qid.path = big 0;
d.qid.qtype = QTDIR;
}
return (d, nil);
}
Xfile.wstat(nil: self ref Xfile, nil: ref Dir): string
{
return Eperm;
}
Xfs.new(d: ref Device): ref Xfs
{
xf := ref Xfs;
xf.inuse = 1;
xf.d = d;
xf.isplan9 = 0;
xf.issusp = 0;
xf.isrock = 0;
xf.suspoff = 0;
xf.ptr = 0;
xf.rootqid = Qid(big 0, 0, QTDIR);
return xf;
}
Xfs.incref(xf: self ref Xfs)
{
xf.inuse++;
}
Xfs.decref(xf: self ref Xfs)
{
xf.inuse--;
if(xf.inuse == 0){
if(xf.d != nil)
xf.d.detach();
}
}
showdrec(fd: ref Sys->FD, fmt: int, d: ref Drec)
{
if(d.reclen == 0)
return;
sys->fprint(fd, "%d %d %d %d ",
d.reclen, d.attrlen, d.addr, d.size);
sys->fprint(fd, "%s 0x%2.2x %d %d %d ",
rdate(d.date, fmt), d.flags,
d.unitsize, d.gapsize, d.vseqno);
sys->fprint(fd, "%d %s", len d.name, nstr(d.name));
syslen := len d.data;
if(syslen != 0)
sys->fprint(fd, " %s", nstr(d.data));
sys->fprint(fd, "\n");
}
newdrec(f: ref Xfile, dp: ref Drec)
{
x := iso(f);
n := ref Isofile;
n.fmt = x.fmt;
n.blksize = x.blksize;
n.offset = 0;
n.doffset = 0;
n.d = dp;
f.ptr = n;
}
getdrec(f: ref Xfile, d: ref Drec): int
{
if(f.ptr == nil)
return -1;
boff := 0;
ip := iso(f);
size := ip.d.size;
while(ip.offset<size){
addr := (ip.d.addr+ip.d.attrlen)*ip.blksize + ip.offset;
boff = addr % Sectorsize;
if(boff > Sectorsize-34){
ip.offset += Sectorsize-boff;
continue;
}
p := Block.get(f.xf.d, addr/Sectorsize);
if(p == nil)
return -1;
nb := int p.data[boff];
if(nb >= 34) {
convM2Drec(p.data[boff:], d, ip.fmt=='r');
#chat(sys->sprint("off %d", ip.offset));
#showdrec(stderr, ip.fmt, d);
p.put();
ip.offset += nb + (nb&1);
return 0;
}
p.put();
p = nil;
ip.offset += Sectorsize-boff;
}
return -1;
}
# getcontin returns a slice of the Iobuf, valid until next i/o call
getcontin(d: ref Device, a: array of byte): (array of byte, int)
{
bn := l32(a[4:]);
off := l32(a[12:]);
n := l32(a[20:]);
p := Block.get(d, bn);
if(p == nil)
return (nil, 0);
return (p.data[off:off+n], n);
}
iso(f: ref Xfile): ref Isofile
{
if(f.ptr == nil){
f.ptr = ref Isofile;
f.ptr.d = ref Drec;
}
return f.ptr;
}
opendotdot(f: ref Xfile, pf: ref Xfile): string
{
d := ref Drec;
ip := iso(f);
ip.offset = 0;
if(getdrec(f, d) < 0)
return "opendotdot: getdrec(.) failed";
if(len d.name != 1 || d.name[0] != byte 0)
return "opendotdot: no . entry";
if(d.addr != ip.d.addr)
return "opendotdot: bad . address";
if(getdrec(f, d) < 0)
return "opendotdot: getdrec(..) failed";
if(len d.name != 1 || d.name[0] != byte 1)
return "opendotdot: no .. entry";
pf.xf = f.xf;
pip := iso(pf);
pip.fmt = ip.fmt;
pip.blksize = ip.blksize;
pip.offset = 0;
pip.doffset = 0;
pip.d = d;
return nil;
}
rzdir(fs: ref Xfs, d: ref Dir, fmt: int, dp: ref Drec): int
{
Hmode, Hname: con 1<<iota;
vers := -1;
have := 0;
d.qid.path = big dp.addr;
d.qid.vers = 0;
d.qid.qtype = QTFILE;
n := len dp.name;
if(n == 1) {
case int dp.name[0] {
0 => d.name = "."; have |= Hname;
1 => d.name = ".."; have |= Hname;
* => d.name = ""; d.name[0] = tolower(int dp.name[0]);
}
} else {
if(fmt == 'J'){ # Joliet, 16-bit Unicode
d.name = "";
for(i:=0; i<n; i+=2){
r := (int dp.name[i]<<8) | int dp.name[i+1];
d.name[len d.name] = r;
}
}else{
if(n >= Maxname)
n = Maxname-1;
d.name = "";
for(i:=0; i<n && int dp.name[i] != '\r'; i++)
d.name[i] = tolower(int dp.name[i]);
}
}
if(fs.isplan9 && dp.reclen>34+len dp.name) {
#
# get gid, uid, mode and possibly name
# from plan9 directory extension
#
s := dp.data;
n = int s[0];
if(n)
d.name = string s[1:1+n];
l := 1+n;
n = int s[l++];
d.uid = string s[l:l+n];
l += n;
n = int s[l++];
d.gid = string s[l:l+n];
l += n;
if(l & 1)
l++;
d.mode = l32(s[l:]);
if(d.mode & DMDIR)
d.qid.qtype = QTDIR;
} else {
d.mode = 8r444;
case fmt {
'z' =>
if(fs.isrock)
d.gid = "ridge";
else
d.gid = "iso";
'r' =>
d.gid = "sierra";
'J' =>
d.gid = "joliet";
* =>
d.gid = "???";
}
flags := dp.flags;
if(flags & 2){
d.qid.qtype = QTDIR;
d.mode |= DMDIR|8r111;
}
d.uid = "cdrom";
for(i := 0; i < len d.name; i++)
if(d.name[i] == ';') {
vers = int string d.name[i+1:]; # inefficient
d.name = d.name[0:i]; # inefficient
break;
}
n = len dp.data - fs.suspoff;
if(fs.isrock && n >= 4){
s := dp.data[fs.suspoff:];
nm := 0;
while(n >= 4 && have != (Hname|Hmode)){
l := int s[2];
if(s[0] == byte 'P' && s[1] == byte 'X' && s[3] == byte 1){
# posix file attributes
mode := l32(s[4:12]);
d.mode = mode & 8r777;
if((mode & 8r170000) == 8r0040000){
d.mode |= DMDIR;
d.qid.qtype = QTDIR;
}
have |= Hmode;
} else if(s[0] == byte 'N' && s[1] == byte 'M' && s[3] == byte 1){
# alternative name
flags = int s[4];
if((flags & ~1) == 0){
if(nm == 0){
d.name = string s[5:l];
nm = 1;
} else
d.name += string s[5:l];
if(flags == 0)
have |= Hname; # no more
}
} else if(s[0] == byte 'C' && s[1] == byte 'E' && int s[2] >= 28){
(s, n) = getcontin(fs.d, s);
continue;
} else if(s[0] == byte 'S' && s[1] == byte 'T')
break;
n -= l;
s = s[l:];
}
}
}
d.length = big 0;
if((d.mode & DMDIR) == 0)
d.length = big dp.size;
d.dtype = 0;
d.dev = 0;
d.atime = dp.time;
d.mtime = d.atime;
return vers;
}
convM2Drec(a: array of byte, d: ref Drec, highsierra: int)
{
d.reclen = int a[0];
d.attrlen = int a[1];
d.addr = int l32(a[2:10]);
d.size = int l32(a[10:18]);
d.time = gtime(a[18:24]);
d.date = array[7] of byte;
d.date[0:] = a[18:25];
if(highsierra){
d.tzone = 0;
d.flags = int a[24];
d.unitsize = 0;
d.gapsize = 0;
d.vseqno = 0;
} else {
d.tzone = int a[24];
d.flags = int a[25];
d.unitsize = int a[26];
d.gapsize = int a[27];
d.vseqno = l32(a[28:32]);
}
n := int a[32];
d.name = array[n] of byte;
d.name[0:] = a[33:33+n];
n += 33;
if(n & 1)
n++; # check this
syslen := d.reclen - n;
if(syslen > 0){
d.data = array[syslen] of byte;
d.data[0:] = a[n:n+syslen];
} else
d.data = nil;
}
nstr(p: array of byte): string
{
q := "";
n := len p;
for(i := 0; i < n; i++){
if(int p[i] == '\\')
q[len q] = '\\';
if(' ' <= int p[i] && int p[i] <= '~')
q[len q] = int p[i];
else
q += sys->sprint("\\%2.2ux", int p[i]);
}
return q;
}
rdate(p: array of byte, fmt: int): string
{
c: int;
s := sys->sprint("%2.2d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d",
int p[0], int p[1], int p[2], int p[3], int p[4], int p[5]);
if(fmt == 'z'){
htz := int p[6];
if(htz >= 128){
htz = 256-htz;
c = '-';
}else
c = '+';
s += sys->sprint(" (%c%.1f)", c, real htz/2.0);
}
return s;
}
dmsize := array[] of {
31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
};
dysize(y: int): int
{
if((y%4) == 0)
return 366;
return 365;
}
gtime(p: array of byte): int # yMdhms
{
y:=int p[0]; M:=int p[1]; d:=int p[2];
h:=int p[3]; m:=int p[4]; s:=int p[5];;
if(y < 70)
return 0;
if(M < 1 || M > 12)
return 0;
if(d < 1 || d > dmsize[M-1])
return 0;
if(h > 23)
return 0;
if(m > 59)
return 0;
if(s > 59)
return 0;
y += 1900;
t := 0;
for(i:=1970; i<y; i++)
t += dysize(i);
if(dysize(y)==366 && M >= 3)
t++;
M--;
while(M-- > 0)
t += dmsize[M];
t += d-1;
t = 24*t + h;
t = 60*t + m;
t = 60*t + s;
return t;
}
l16(p: array of byte): int
{
v := (int p[1]<<8)| int p[0];
if (v >= 16r8000)
v -= 16r10000;
return v;
}
l32(p: array of byte): int
{
return (((((int p[3]<<8)| int p[2])<<8)| int p[1])<<8)| int p[0];
}
eqs(a: array of byte, b: string): int
{
if(len a != len b)
return 0;
for(i := 0; i < len a; i++)
if(int a[i] != b[i])
return 0;
return 1;
}
tolower(c: int): int
{
if(c >= 'A' && c <= 'Z')
return c-'A' + 'a';
return c;
}
#
# I/O buffers
#
Device: adt {
inuse: int; # attach count
name: string; # of underlying file
fd: ref Sys->FD;
sectorsize: int;
qid: Sys->Qid; # (qid,dtype,dev) identify uniquely
dtype: int;
dev: int;
detach: fn(nil: self ref Device);
};
Block: adt {
dev: ref Device;
addr: int;
data: array of byte;
# internal
next: cyclic ref Block;
prev: cyclic ref Block;
busy: int;
get: fn(nil: ref Device, addr: int): ref Block;
put: fn(nil: self ref Block);
};
devices: list of ref Device;
NIOB: con 100; # for starters
HIOB: con 127; # prime
hiob := array[HIOB] of list of ref Block; # hash buckets
iohead: ref Block;
iotail: ref Block;
bufsize := 0;
iobufinit(bsize: int)
{
bufsize = bsize;
for(i:=0; i<NIOB; i++)
newblock();
}
newblock(): ref Block
{
p := ref Block;
p.busy = 0;
p.addr = -1;
p.dev = nil;
p.data = array[bufsize] of byte;
p.next = iohead;
if(iohead != nil)
iohead.prev = p;
iohead = p;
if(iotail == nil)
iotail = p;
return p;
}
Block.get(dev: ref Device, addr: int): ref Block
{
p: ref Block;
dh := hiob[addr%HIOB:];
for(l := dh[0]; l != nil; l = tl l) {
p = hd l;
if(p.addr == addr && p.dev == dev) {
p.busy++;
return p;
}
}
# Find a non-busy buffer from the tail
for(p = iotail; p != nil && p.busy; p = p.prev)
;
if(p == nil)
p = newblock();
# Delete from hash chain
if(p.addr >= 0) {
hp := hiob[p.addr%HIOB:];
l = nil;
for(f := hp[0]; f != nil; f = tl f)
if(hd f != p)
l = (hd f) :: l;
hp[0] = l;
}
# Hash and fill
p.addr = addr;
p.dev = dev;
p.busy++;
sys->seek(dev.fd, big addr*big dev.sectorsize, 0);
if(sys->read(dev.fd, p.data, dev.sectorsize) != dev.sectorsize){
p.addr = -1; # stop caching
p.put();
purge(dev);
return nil;
}
dh[0] = p :: dh[0];
return p;
}
Block.put(p: self ref Block)
{
p.busy--;
if(p.busy < 0)
panic("Block.put");
if(p == iohead)
return;
# Link onto head for lru
if(p.prev != nil)
p.prev.next = p.next;
else
iohead = p.next;
if(p.next != nil)
p.next.prev = p.prev;
else
iotail = p.prev;
p.prev = nil;
p.next = iohead;
iohead.prev = p;
iohead = p;
}
purge(dev: ref Device)
{
for(i := 0; i < HIOB; i++){
l := hiob[i];
hiob[i] = nil;
for(; l != nil; l = tl l){ # reverses bucket's list, but never mind
p := hd l;
if(p.dev == dev)
p.busy = 0;
else
hiob[i] = p :: hiob[i];
}
}
}
devattach(name: string, mode: int, sectorsize: int): (ref Device, string)
{
if(sectorsize > bufsize)
return (nil, "sector size too big");
fd := sys->open(name, mode);
if(fd == nil)
return(nil, sys->sprint("%s: can't open: %r", name));
(rc, dir) := sys->fstat(fd);
if(rc < 0)
return (nil, sys->sprint("%r"));
for(dl := devices; dl != nil; dl = tl dl){
d := hd dl;
if(d.qid.path != dir.qid.path || d.qid.vers != dir.qid.vers)
continue;
if(d.dtype != dir.dtype || d.dev != dir.dev)
continue;
d.inuse++;
if(chatty)
sys->print("inuse=%d, \"%s\", dev=%H...\n", d.inuse, d.name, d.fd);
return (d, nil);
}
if(chatty)
sys->print("alloc \"%s\", dev=%H...\n", name, fd);
d := ref Device;
d.inuse = 1;
d.name = name;
d.qid = dir.qid;
d.dtype = dir.dtype;
d.dev = dir.dev;
d.fd = fd;
d.sectorsize = sectorsize;
devices = d :: devices;
return (d, nil);
}
Device.detach(d: self ref Device)
{
d.inuse--;
if(d.inuse < 0)
panic("putxdata");
if(chatty)
sys->print("decref=%d, \"%s\", dev=%H...\n", d.inuse, d.name, d.fd);
if(d.inuse == 0){
if(chatty)
sys->print("purge...\n");
purge(d);
dl := devices;
devices = nil;
for(; dl != nil; dl = tl dl)
if((hd dl) != d)
devices = (hd dl) :: devices;
}
}
panic(s: string)
{
sys->print("panic: %s\n", s);
a: array of byte;
a[5] = byte 0; # trap
}