ref: 7a29422cfefaf76315eafa82ca606f9ded9517b3
dir: /appl/cmd/install/create.b/
implement Create;
include "sys.m";
sys: Sys;
Dir, sprint, fprint: import sys;
include "draw.m";
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "string.m";
str: String;
include "arg.m";
arg: Arg;
include "daytime.m";
include "keyring.m";
keyring : Keyring;
include "sh.m";
include "wrap.m";
wrap : Wrap;
include "arch.m";
arch : Arch;
include "proto.m";
proto : Proto;
include "protocaller.m";
protocaller : Protocaller;
WARN, ERROR, FATAL : import Protocaller;
Create: module{
init: fn(nil: ref Draw->Context, nil: list of string);
protofile: fn(new : string, old : string, d : ref Sys->Dir);
protoerr: fn(lev : int, line : int, err : string);
};
bout: ref Iobuf; # stdout when writing archive
protof: string;
notesf: string;
oldroot: string;
buf: array of byte;
buflen := 1024-8;
verb: int;
xflag: int;
stderr: ref Sys->FD;
uid, gid : string;
desc : string;
pass : int;
update : int;
md5s : ref Keyring->DigestState;
w : ref Wrap->Wrapped;
root := "/";
prefix, notprefix: list of string;
onlist: list of (string, string); # NEW
remfile: string;
n2o(n: string): string
{
for(onl := onlist; onl != nil; onl = tl onl)
if((hd onl).t1 == n)
return (hd onl).t0;
return n;
}
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
bufio = load Bufio Bufio->PATH;
str = load String String->PATH;
arg = load Arg Arg->PATH;
wrap = load Wrap Wrap->PATH;
wrap->init(bufio);
arch = load Arch Arch->PATH;
arch->init(bufio);
daytime := load Daytime Daytime->PATH;
now := daytime->now();
# {
# for(i := 0; i < 21; i++){
# n := now+(i-9)*100000000;
# sys->print("%d -> %s\n", n, wrap->now2string(n));
# if(wrap->string2now(wrap->now2string(n)) != n)
# sys->print("%d wrong\n", n);
# }
# }
daytime = nil;
proto = load Proto Proto->PATH;
protocaller = load Protocaller "$self";
sys->pctl(Sys->NEWPGRP|Sys->FORKNS|Sys->FORKFD, nil);
stderr = sys->fildes(2);
if(arg == nil)
error(sys->sprint("can't load %s: %r", Arg->PATH));
name := "";
desc = "inferno";
tostdout := 0;
not := 0;
arg->init(args);
while((c := arg->opt()) != 0)
case c {
'n' =>
not = 1;
'o' =>
tostdout = 1;
'p' =>
protof = reqarg("proto file (-p)");
'r' =>
root = reqarg("root directory (-r)");
's' =>
oldroot = reqarg("source directory (-d)");
'u' =>
update = 1;
'v' =>
verb = 1;
'x' =>
xflag = 1;
'N' =>
uid = reqarg("user name (-U)");
'G' =>
gid = reqarg("group name (-G)");
'd' or 'D' =>
desc = reqarg("product description (-D)");
't' =>
rt := reqarg("package time (-t)");
now = int rt;
'i' =>
notesf = reqarg("file (-i)");
'R' =>
remfile = reqarg("remove file (-R)");
'P' =>
arch->addperms(0);
* =>
usage();
}
args = arg->argv();
if(args == nil)
usage();
if (tostdout || xflag) {
bout = bufio->fopen(sys->fildes(1), Sys->OWRITE);
if(bout == nil)
error(sys->sprint("can't open standard output for archive: %r"));
}
else {
# ar := sys->sprint("%ud", now);
ar := wrap->now2string(now, 0);
bout = bufio->create(ar, Sys->OWRITE, 8r664);
if(bout == nil)
error(sys->sprint("can't create %s for archive: %r", ar));
sys->print("archiving package %s to %s\n", hd args, ar);
}
buf = array [buflen] of byte;
name = hd args;
if(update){
if(not)
notprefix = tl args;
else
prefix = tl args;
}
else if (tl args != nil)
fatal("only one name allowed");
if (!xflag)
digest := wrapinit(name, now);
fprint(stderr, "processing %s\n", protof);
proto->rdproto(protof, oldroot, protocaller);
if (!xflag)
wrapend(digest);
if (!xflag)
fprint(stderr, "file system made\n");
arch->putend(bout);
exits();
}
protofile(new : string, old : string, d : ref Sys->Dir)
{
if(xflag && bout != nil){
bout.puts(sys->sprint("%s\t%d\t%bd\n", new, d.mtime, d.length));
return;
}
d.uid = uid;
d.gid = gid;
if (!(d.mode & Sys->DMDIR)) {
# if(verb)
# fprint(stderr, "%s\n", new);
f := sys->open(old, Sys->OREAD);
if(f == nil){
warn(sys->sprint("can't open %s: %r", old));
return;
}
}
mkarch(new, old, d);
}
protoerr(lev : int, line : int, err : string)
{
s := "line " + string line + " : " + err;
case lev {
WARN => warn(s);
ERROR => error(s);
FATAL => fatal(s);
}
}
quit()
{
if(bout != nil)
bout.flush();
exits();
}
reqarg(what: string): string
{
if((o := arg->arg()) == nil){
sys->fprint(stderr, "missing %s\n", what);
exits();
}
return o;
}
puthdr(f : string, d: ref Dir)
{
if (d.mode & Sys->DMDIR)
d.length = big 0;
arch->puthdr(bout, f, d);
}
error(s: string)
{
fprint(stderr, "%s: %s\n", protof, s);
quit();
}
fatal(s: string)
{
fprint(stderr, "fatal: %s\n", s);
exits();
}
warn(s: string)
{
fprint(stderr, "%s: %s\n", protof, s);
}
usage()
{
fprint(stderr, "usage: install/create [-ovx] [-N uid] [-G gid] [-r root] [-d desc] [-s src-fs] [-p proto] name\n");
fprint(stderr, "or install/create -u [-ovx] [-N uid] [-G gid] [-r root] [-d desc] [-s src-fs] [-p proto] old-package [prefix ...]\n");
exits();
}
wrapinit(name : string, t : int) : array of byte
{
rmfile : string;
rmfd: ref Sys->FD;
if (uid == nil)
uid = "inferno";
if (gid == nil)
gid = "inferno";
if (update) {
w = wrap->openwraphdr(name, root, nil, 0);
if (w == nil)
fatal("no such package found");
# ignore any updates - NEW commented out
# while (w.nu > 0 && w.u[w.nu-1].typ == wrap->UPD)
# w.nu--;
# w.nu = 1; NEW commented out
if (protof == nil)
protof = w.u[0].dir + "/proto";
name = w.name;
}
else {
if (protof == nil)
fatal("proto file missing");
}
(md5file, md5fd) := opentemp("wrap.md5", t);
if (md5fd == nil)
fatal(sys->sprint("cannot create %s", md5file));
keyring = load Keyring Keyring->PATH;
md5s = keyring->md5(nil, 0, nil, nil);
md5b := bufio->fopen(md5fd, Bufio->OWRITE);
if (md5b == nil)
fatal(sys->sprint("cannot open %s", md5file));
fprint(stderr, "wrap pass %s\n", protof);
obout := bout;
bout = md5b;
pass = 0;
proto->rdproto(protof, oldroot, protocaller);
bout.flush();
bout = md5b = nil;
digest := array[keyring->MD5dlen] of { * => byte 0 };
keyring->md5(nil, 0, digest, md5s);
md5s = nil;
(md5sort, md5sfd) := opentemp("wrap.md5s", t);
if (md5sfd == nil)
fatal(sys->sprint("cannot create %s", md5sort));
endc := chan of int;
md5fd = nil; # close md5file
spawn fsort(md5sfd, md5file, endc);
md5sfd = nil;
res := <- endc;
if (res < 0)
fatal("sort failed");
if (update) {
(rmfile, rmfd) = opentemp("wrap.rm", t);
if (rmfd == nil)
fatal(sys->sprint("cannot create %s", rmfile));
rmed: list of string;
for(i := w.nu-1; i >= 0; i--){ # NEW does loop
w.u[i].bmd5.seek(big 0, Bufio->SEEKSTART);
while ((p := w.u[i].bmd5.gets('\n')) != nil) {
if(prefix != nil && !wrap->match(p, prefix))
continue;
if(notprefix != nil && !wrap->notmatch(p, notprefix))
continue;
(q, nil) := str->splitl(p, " ");
q = pathcat(root, q);
(ok, nil) := sys->stat(q);
if(ok < 0)
(ok, nil) = sys->stat(n2o(q));
if (len q >= 7 && q[len q - 7:] == "emu.new") # quick hack for now
continue;
if (ok < 0){
for(r := rmed; r != nil; r = tl r) # NEW to avoid duplication
if(hd r == q)
break;
if(r == nil){
# sys->fprint(rmfd, "%s\n", q);
rmed = q :: rmed;
}
}
}
}
for(r := rmed; r != nil; r = tl r)
sys->fprint(rmfd, "%s\n", hd r);
if(remfile != nil){
rfd := sys->open(remfile, Sys->OREAD);
rbuf := array[128] of byte;
for(;;){
n := sys->read(rfd, rbuf, 128);
if(n <= 0)
break;
sys->write(rmfd, rbuf, n);
}
}
rmfd = nil;
rmed = nil;
}
bout = obout;
if (update)
wrap->putwrap(bout, name, t, desc, w.tfull, prefix == nil && notprefix == nil, uid, gid);
else
wrap->putwrap(bout, name, t, desc, 0, 1, uid, gid);
wrap->putwrapfile(bout, name, t, "proto", protof, uid, gid);
wrap->putwrapfile(bout, name, t, "md5sum", md5sort, uid, gid);
if (update)
wrap->putwrapfile(bout, name, t, "remove", rmfile, uid, gid);
if(notesf != nil)
wrap->putwrapfile(bout, name, t, "notes", notesf, uid, gid);
md5s = keyring->md5(nil, 0, nil, nil);
pass = 1;
return digest;
}
wrapend(digest : array of byte)
{
digest0 := array[keyring->MD5dlen] of { * => byte 0 };
keyring->md5(nil, 0, digest0, md5s);
md5s = nil;
if (wrap->memcmp(digest, digest0, keyring->MD5dlen) != 0)
warn(sys->sprint("files changed underfoot %s %s", wrap->md5conv(digest), wrap->md5conv(digest0)));
}
mkarch(new : string, old : string, d : ref Dir)
{
if(pass == 0 && old != new)
onlist = (old, new) :: onlist;
if(prefix != nil && !wrap->match(new, prefix))
return;
if(notprefix != nil && !wrap->notmatch(new, notprefix))
return;
digest := array[keyring->MD5dlen] of { * => byte 0 };
wrap->md5file(old, digest);
(ok, nil) := wrap->getfileinfo(w, new, digest, nil, nil);
if (ok >= 0)
return;
n := array of byte new;
keyring->md5(n, len n, nil, md5s);
if (pass == 0) {
bout.puts(sys->sprint("%s %s\n", new, wrap->md5conv(digest)));
return;
}
if(verb)
fprint(stderr, "%s\n", new);
puthdr(new, d);
if(!(d.mode & Sys->DMDIR)) {
err := arch->putfile(bout, old, int d.length);
if (err != nil)
warn(err);
}
}
fsort(fd : ref Sys->FD, file : string, c : chan of int)
{
sys->pctl(Sys->FORKFD, nil);
sys->dup(fd.fd, 1);
cmd := "/dis/sort.dis";
m := load Command cmd;
if(m == nil) {
c <-= -1;
return;
}
m->init(nil, cmd :: file :: nil);
c <-= 0;
}
tmpfiles: list of string;
opentemp(prefix: string, t: int): (string, ref Sys->FD)
{
name := sys->sprint("/tmp/%s.%ud.%d", prefix, t, sys->pctl(0, nil));
fd := sys->create(name, Sys->ORDWR, 8r666);
# fd := sys->create(name, Sys->ORDWR | Sys->ORCLOSE, 8r666); not on Nt
tmpfiles = name :: tmpfiles;
return (name, fd);
}
exits()
{
wrap->end();
for( ; tmpfiles != nil; tmpfiles = tl tmpfiles)
sys->remove(hd tmpfiles);
exit;
}
pathcat(s : string, t : string) : string
{
if (s == nil) return t;
if (t == nil) return s;
slashs := s[len s - 1] == '/';
slasht := t[0] == '/';
if (slashs && slasht)
return s + t[1:];
if (!slashs && !slasht)
return s + "/" + t;
return s + t;
}