Plan 9 version, nothing tweaked yet.
This commit is contained in:
rsc
parent
7763a61a35
commit
b8c14089d8
7 changed files with 2596 additions and 0 deletions
975
src/cmd/plumb/fsys.c
Normal file
975
src/cmd/plumb/fsys.c
Normal file
|
|
@ -0,0 +1,975 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <regexp.h>
|
||||
#include <thread.h>
|
||||
#include <auth.h>
|
||||
#include <fcall.h>
|
||||
#include <plumb.h>
|
||||
#include "plumber.h"
|
||||
|
||||
enum
|
||||
{
|
||||
Stack = 8*1024
|
||||
};
|
||||
|
||||
typedef struct Dirtab Dirtab;
|
||||
typedef struct Fid Fid;
|
||||
typedef struct Holdq Holdq;
|
||||
typedef struct Readreq Readreq;
|
||||
typedef struct Sendreq Sendreq;
|
||||
|
||||
struct Dirtab
|
||||
{
|
||||
char *name;
|
||||
uchar type;
|
||||
uint qid;
|
||||
uint perm;
|
||||
int nopen; /* #fids open on this port */
|
||||
Fid *fopen;
|
||||
Holdq *holdq;
|
||||
Readreq *readq;
|
||||
Sendreq *sendq;
|
||||
};
|
||||
|
||||
struct Fid
|
||||
{
|
||||
int fid;
|
||||
int busy;
|
||||
int open;
|
||||
int mode;
|
||||
Qid qid;
|
||||
Dirtab *dir;
|
||||
long offset; /* zeroed at beginning of each message, read or write */
|
||||
char *writebuf; /* partial message written so far; offset tells how much */
|
||||
Fid *next;
|
||||
Fid *nextopen;
|
||||
};
|
||||
|
||||
struct Readreq
|
||||
{
|
||||
Fid *fid;
|
||||
Fcall *fcall;
|
||||
uchar *buf;
|
||||
Readreq *next;
|
||||
};
|
||||
|
||||
struct Sendreq
|
||||
{
|
||||
int nfid; /* number of fids that should receive this message */
|
||||
int nleft; /* number left that haven't received it */
|
||||
Fid **fid; /* fid[nfid] */
|
||||
Plumbmsg *msg;
|
||||
char *pack; /* plumbpack()ed message */
|
||||
int npack; /* length of pack */
|
||||
Sendreq *next;
|
||||
};
|
||||
|
||||
struct Holdq
|
||||
{
|
||||
Plumbmsg *msg;
|
||||
Holdq *next;
|
||||
};
|
||||
|
||||
struct /* needed because incref() doesn't return value */
|
||||
{
|
||||
Lock;
|
||||
int ref;
|
||||
} rulesref;
|
||||
|
||||
enum
|
||||
{
|
||||
DEBUG = 0,
|
||||
NDIR = 50,
|
||||
Nhash = 16,
|
||||
|
||||
Qdir = 0,
|
||||
Qrules = 1,
|
||||
Qsend = 2,
|
||||
Qport = 3,
|
||||
NQID = Qport
|
||||
};
|
||||
|
||||
static Dirtab dir[NDIR] =
|
||||
{
|
||||
{ ".", QTDIR, Qdir, 0500|DMDIR },
|
||||
{ "rules", QTFILE, Qrules, 0600 },
|
||||
{ "send", QTFILE, Qsend, 0200 },
|
||||
};
|
||||
static int ndir = NQID;
|
||||
|
||||
static int srvfd;
|
||||
static int srvclosefd; /* rock for end of pipe to close */
|
||||
static int clockfd;
|
||||
static int clock;
|
||||
static Fid *fids[Nhash];
|
||||
static QLock readlock;
|
||||
static QLock queue;
|
||||
static char srvfile[128];
|
||||
static int messagesize = 8192+IOHDRSZ; /* good start */
|
||||
|
||||
static void fsysproc(void*);
|
||||
static void fsysrespond(Fcall*, uchar*, char*);
|
||||
static Fid* newfid(int);
|
||||
|
||||
static Fcall* fsysflush(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysversion(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysauth(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysattach(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsyswalk(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysopen(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsyscreate(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysread(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsyswrite(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysclunk(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysremove(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsysstat(Fcall*, uchar*, Fid*);
|
||||
static Fcall* fsyswstat(Fcall*, uchar*, Fid*);
|
||||
|
||||
Fcall* (*fcall[Tmax])(Fcall*, uchar*, Fid*) =
|
||||
{
|
||||
[Tflush] = fsysflush,
|
||||
[Tversion] = fsysversion,
|
||||
[Tauth] = fsysauth,
|
||||
[Tattach] = fsysattach,
|
||||
[Twalk] = fsyswalk,
|
||||
[Topen] = fsysopen,
|
||||
[Tcreate] = fsyscreate,
|
||||
[Tread] = fsysread,
|
||||
[Twrite] = fsyswrite,
|
||||
[Tclunk] = fsysclunk,
|
||||
[Tremove]= fsysremove,
|
||||
[Tstat] = fsysstat,
|
||||
[Twstat] = fsyswstat,
|
||||
};
|
||||
|
||||
char Ebadfcall[] = "bad fcall type";
|
||||
char Eperm[] = "permission denied";
|
||||
char Enomem[] = "malloc failed for buffer";
|
||||
char Enotdir[] = "not a directory";
|
||||
char Enoexist[] = "plumb file does not exist";
|
||||
char Eisdir[] = "file is a directory";
|
||||
char Ebadmsg[] = "bad plumb message format";
|
||||
char Enosuchport[] ="no such plumb port";
|
||||
char Enoport[] = "couldn't find destination for message";
|
||||
char Einuse[] = "file already open";
|
||||
|
||||
/*
|
||||
* Add new port. A no-op if port already exists or is the null string
|
||||
*/
|
||||
void
|
||||
addport(char *port)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(port == nil)
|
||||
return;
|
||||
for(i=NQID; i<ndir; i++)
|
||||
if(strcmp(port, dir[i].name) == 0)
|
||||
return;
|
||||
if(i == NDIR){
|
||||
fprint(2, "plumb: too many ports; max %d\n", NDIR);
|
||||
return;
|
||||
}
|
||||
ndir++;
|
||||
dir[i].name = estrdup(port);
|
||||
dir[i].qid = i;
|
||||
dir[i].perm = 0400;
|
||||
nports++;
|
||||
ports = erealloc(ports, nports*sizeof(char*));
|
||||
ports[nports-1] = dir[i].name;
|
||||
}
|
||||
|
||||
static ulong
|
||||
getclock(void)
|
||||
{
|
||||
char buf[32];
|
||||
|
||||
seek(clockfd, 0, 0);
|
||||
read(clockfd, buf, sizeof buf);
|
||||
return atoi(buf);
|
||||
}
|
||||
|
||||
void
|
||||
startfsys(void)
|
||||
{
|
||||
int p[2], fd;
|
||||
|
||||
fmtinstall('F', fcallfmt);
|
||||
clockfd = open("/dev/time", OREAD|OCEXEC);
|
||||
clock = getclock();
|
||||
if(pipe(p) < 0)
|
||||
error("can't create pipe: %r");
|
||||
/* 0 will be server end, 1 will be client end */
|
||||
srvfd = p[0];
|
||||
srvclosefd = p[1];
|
||||
sprint(srvfile, "/srv/plumb.%s.%d", user, getpid());
|
||||
if(putenv("plumbsrv", srvfile) < 0)
|
||||
error("can't write $plumbsrv: %r");
|
||||
fd = create(srvfile, OWRITE|OCEXEC|ORCLOSE, 0600);
|
||||
if(fd < 0)
|
||||
error("can't create /srv file: %r");
|
||||
if(fprint(fd, "%d", p[1]) <= 0)
|
||||
error("can't write /srv/file: %r");
|
||||
/* leave fd open; ORCLOSE will take care of it */
|
||||
|
||||
procrfork(fsysproc, nil, Stack, RFFDG);
|
||||
|
||||
close(p[0]);
|
||||
if(mount(p[1], -1, "/mnt/plumb", MREPL, "") < 0)
|
||||
error("can't mount /mnt/plumb: %r");
|
||||
close(p[1]);
|
||||
}
|
||||
|
||||
static void
|
||||
fsysproc(void*)
|
||||
{
|
||||
int n;
|
||||
Fcall *t;
|
||||
Fid *f;
|
||||
uchar *buf;
|
||||
|
||||
close(srvclosefd);
|
||||
srvclosefd = -1;
|
||||
t = nil;
|
||||
for(;;){
|
||||
buf = malloc(messagesize); /* avoid memset of emalloc */
|
||||
if(buf == nil)
|
||||
error("malloc failed: %r");
|
||||
qlock(&readlock);
|
||||
n = read9pmsg(srvfd, buf, messagesize);
|
||||
if(n <= 0){
|
||||
if(n < 0)
|
||||
error("i/o error on server channel");
|
||||
threadexitsall("unmounted");
|
||||
}
|
||||
if(readlock.head == nil) /* no other processes waiting to read; start one */
|
||||
proccreate(fsysproc, nil, Stack);
|
||||
qunlock(&readlock);
|
||||
if(t == nil)
|
||||
t = emalloc(sizeof(Fcall));
|
||||
if(convM2S(buf, n, t) != n)
|
||||
error("convert error in convM2S");
|
||||
if(DEBUG)
|
||||
fprint(2, "<= %F\n", t);
|
||||
if(fcall[t->type] == nil)
|
||||
fsysrespond(t, buf, Ebadfcall);
|
||||
else{
|
||||
if(t->type==Tversion || t->type==Tauth)
|
||||
f = nil;
|
||||
else
|
||||
f = newfid(t->fid);
|
||||
t = (*fcall[t->type])(t, buf, f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
fsysrespond(Fcall *t, uchar *buf, char *err)
|
||||
{
|
||||
int n;
|
||||
|
||||
if(err){
|
||||
t->type = Rerror;
|
||||
t->ename = err;
|
||||
}else
|
||||
t->type++;
|
||||
if(buf == nil)
|
||||
buf = emalloc(messagesize);
|
||||
n = convS2M(t, buf, messagesize);
|
||||
if(n < 0)
|
||||
error("convert error in convS2M");
|
||||
if(write(srvfd, buf, n) != n)
|
||||
error("write error in respond");
|
||||
if(DEBUG)
|
||||
fprint(2, "=> %F\n", t);
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static
|
||||
Fid*
|
||||
newfid(int fid)
|
||||
{
|
||||
Fid *f, *ff, **fh;
|
||||
|
||||
qlock(&queue);
|
||||
ff = nil;
|
||||
fh = &fids[fid&(Nhash-1)];
|
||||
for(f=*fh; f; f=f->next)
|
||||
if(f->fid == fid)
|
||||
goto Return;
|
||||
else if(ff==nil && !f->busy)
|
||||
ff = f;
|
||||
if(ff){
|
||||
ff->fid = fid;
|
||||
f = ff;
|
||||
goto Return;
|
||||
}
|
||||
f = emalloc(sizeof *f);
|
||||
f->fid = fid;
|
||||
f->next = *fh;
|
||||
*fh = f;
|
||||
Return:
|
||||
qunlock(&queue);
|
||||
return f;
|
||||
}
|
||||
|
||||
static uint
|
||||
dostat(Dirtab *dir, uchar *buf, uint nbuf, uint clock)
|
||||
{
|
||||
Dir d;
|
||||
|
||||
d.qid.type = dir->type;
|
||||
d.qid.path = dir->qid;
|
||||
d.qid.vers = 0;
|
||||
d.mode = dir->perm;
|
||||
d.length = 0; /* would be nice to do better */
|
||||
d.name = dir->name;
|
||||
d.uid = user;
|
||||
d.gid = user;
|
||||
d.muid = user;
|
||||
d.atime = clock;
|
||||
d.mtime = clock;
|
||||
return convD2M(&d, buf, nbuf);
|
||||
}
|
||||
|
||||
static void
|
||||
queuesend(Dirtab *d, Plumbmsg *m)
|
||||
{
|
||||
Sendreq *s, *t;
|
||||
Fid *f;
|
||||
int i;
|
||||
|
||||
s = emalloc(sizeof(Sendreq));
|
||||
s->nfid = d->nopen;
|
||||
s->nleft = s->nfid;
|
||||
s->fid = emalloc(s->nfid*sizeof(Fid*));
|
||||
i = 0;
|
||||
/* build array of fids open on this channel */
|
||||
for(f=d->fopen; f!=nil; f=f->nextopen)
|
||||
s->fid[i++] = f;
|
||||
s->msg = m;
|
||||
s->next = nil;
|
||||
/* link to end of queue; drainqueue() searches in sender order so this implements a FIFO */
|
||||
for(t=d->sendq; t!=nil; t=t->next)
|
||||
if(t->next == nil)
|
||||
break;
|
||||
if(t == nil)
|
||||
d->sendq = s;
|
||||
else
|
||||
t->next = s;
|
||||
}
|
||||
|
||||
static void
|
||||
queueread(Dirtab *d, Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
Readreq *r;
|
||||
|
||||
r = emalloc(sizeof(Readreq));
|
||||
r->fcall = t;
|
||||
r->buf = buf;
|
||||
r->fid = f;
|
||||
r->next = d->readq;
|
||||
d->readq = r;
|
||||
}
|
||||
|
||||
static void
|
||||
drainqueue(Dirtab *d)
|
||||
{
|
||||
Readreq *r, *nextr, *prevr;
|
||||
Sendreq *s, *nexts, *prevs;
|
||||
int i, n;
|
||||
|
||||
prevs = nil;
|
||||
for(s=d->sendq; s!=nil; s=nexts){
|
||||
nexts = s->next;
|
||||
for(i=0; i<s->nfid; i++){
|
||||
prevr = nil;
|
||||
for(r=d->readq; r!=nil; r=nextr){
|
||||
nextr = r->next;
|
||||
if(r->fid == s->fid[i]){
|
||||
/* pack the message if necessary */
|
||||
if(s->pack == nil)
|
||||
s->pack = plumbpack(s->msg, &s->npack);
|
||||
/* exchange the stuff... */
|
||||
r->fcall->data = s->pack+r->fid->offset;
|
||||
n = s->npack - r->fid->offset;
|
||||
if(n > messagesize-IOHDRSZ)
|
||||
n = messagesize-IOHDRSZ;
|
||||
if(n > r->fcall->count)
|
||||
n = r->fcall->count;
|
||||
r->fcall->count = n;
|
||||
fsysrespond(r->fcall, r->buf, nil);
|
||||
r->fid->offset += n;
|
||||
if(r->fid->offset >= s->npack){
|
||||
/* message transferred; delete this fid from send queue */
|
||||
r->fid->offset = 0;
|
||||
s->fid[i] = nil;
|
||||
s->nleft--;
|
||||
}
|
||||
/* delete read request from queue */
|
||||
if(prevr)
|
||||
prevr->next = r->next;
|
||||
else
|
||||
d->readq = r->next;
|
||||
free(r->fcall);
|
||||
free(r);
|
||||
break;
|
||||
}else
|
||||
prevr = r;
|
||||
}
|
||||
}
|
||||
/* if no fids left, delete this send from queue */
|
||||
if(s->nleft == 0){
|
||||
free(s->fid);
|
||||
plumbfree(s->msg);
|
||||
free(s->pack);
|
||||
if(prevs)
|
||||
prevs->next = s->next;
|
||||
else
|
||||
d->sendq = s->next;
|
||||
free(s);
|
||||
}else
|
||||
prevs = s;
|
||||
}
|
||||
}
|
||||
|
||||
/* can't flush a send because they are always answered synchronously */
|
||||
static void
|
||||
flushqueue(Dirtab *d, int oldtag)
|
||||
{
|
||||
Readreq *r, *prevr;
|
||||
|
||||
prevr = nil;
|
||||
for(r=d->readq; r!=nil; r=r->next){
|
||||
if(oldtag == r->fcall->tag){
|
||||
/* delete read request from queue */
|
||||
if(prevr)
|
||||
prevr->next = r->next;
|
||||
else
|
||||
d->readq = r->next;
|
||||
free(r->fcall);
|
||||
free(r->buf);
|
||||
free(r);
|
||||
return;
|
||||
}
|
||||
prevr = r;
|
||||
}
|
||||
}
|
||||
|
||||
/* remove messages awaiting delivery to now-closing fid */
|
||||
static void
|
||||
removesenders(Dirtab *d, Fid *fid)
|
||||
{
|
||||
Sendreq *s, *nexts, *prevs;
|
||||
int i;
|
||||
|
||||
prevs = nil;
|
||||
for(s=d->sendq; s!=nil; s=nexts){
|
||||
nexts = s->next;
|
||||
for(i=0; i<s->nfid; i++)
|
||||
if(fid == s->fid[i]){
|
||||
/* delete this fid from send queue */
|
||||
s->fid[i] = nil;
|
||||
s->nleft--;
|
||||
break;
|
||||
}
|
||||
/* if no fids left, delete this send from queue */
|
||||
if(s->nleft == 0){
|
||||
free(s->fid);
|
||||
plumbfree(s->msg);
|
||||
free(s->pack);
|
||||
if(prevs)
|
||||
prevs->next = s->next;
|
||||
else
|
||||
d->sendq = s->next;
|
||||
free(s);
|
||||
}else
|
||||
prevs = s;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
hold(Plumbmsg *m, Dirtab *d)
|
||||
{
|
||||
Holdq *h, *q;
|
||||
|
||||
h = emalloc(sizeof(Holdq));
|
||||
h->msg = m;
|
||||
/* add to end of queue */
|
||||
if(d->holdq == nil)
|
||||
d->holdq = h;
|
||||
else{
|
||||
for(q=d->holdq; q->next!=nil; q=q->next)
|
||||
;
|
||||
q->next = h;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
queueheld(Dirtab *d)
|
||||
{
|
||||
Holdq *h;
|
||||
|
||||
while(d->holdq != nil){
|
||||
h = d->holdq;
|
||||
d->holdq = h->next;
|
||||
queuesend(d, h->msg);
|
||||
/* no need to drain queue because we know no-one is reading yet */
|
||||
free(h);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
dispose(Fcall *t, uchar *buf, Plumbmsg *m, Ruleset *rs, Exec *e)
|
||||
{
|
||||
int i;
|
||||
char *err;
|
||||
|
||||
qlock(&queue);
|
||||
err = nil;
|
||||
if(m->dst==nil || m->dst[0]=='\0'){
|
||||
err = Enoport;
|
||||
if(rs != nil)
|
||||
err = startup(rs, e);
|
||||
plumbfree(m);
|
||||
}else
|
||||
for(i=NQID; i<ndir; i++)
|
||||
if(strcmp(m->dst, dir[i].name) == 0){
|
||||
if(dir[i].nopen == 0){
|
||||
err = startup(rs, e);
|
||||
if(e!=nil && e->holdforclient)
|
||||
hold(m, &dir[i]);
|
||||
else
|
||||
plumbfree(m);
|
||||
}else{
|
||||
queuesend(&dir[i], m);
|
||||
drainqueue(&dir[i]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
freeexec(e);
|
||||
qunlock(&queue);
|
||||
fsysrespond(t, buf, err);
|
||||
free(t);
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysversion(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
if(t->msize < 256){
|
||||
fsysrespond(t, buf, "version: message size too small");
|
||||
return t;
|
||||
}
|
||||
if(t->msize < messagesize)
|
||||
messagesize = t->msize;
|
||||
t->msize = messagesize;
|
||||
if(strncmp(t->version, "9P2000", 6) != 0){
|
||||
fsysrespond(t, buf, "unrecognized 9P version");
|
||||
return t;
|
||||
}
|
||||
t->version = "9P2000";
|
||||
fsysrespond(t, buf, nil);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysauth(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
fsysrespond(t, buf, "plumber: authentication not required");
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysattach(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
Fcall out;
|
||||
|
||||
if(strcmp(t->uname, user) != 0){
|
||||
fsysrespond(&out, buf, Eperm);
|
||||
return t;
|
||||
}
|
||||
f->busy = 1;
|
||||
f->open = 0;
|
||||
f->qid.type = QTDIR;
|
||||
f->qid.path = Qdir;
|
||||
f->qid.vers = 0;
|
||||
f->dir = dir;
|
||||
memset(&out, 0, sizeof(Fcall));
|
||||
out.type = t->type;
|
||||
out.tag = t->tag;
|
||||
out.fid = f->fid;
|
||||
out.qid = f->qid;
|
||||
fsysrespond(&out, buf, nil);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysflush(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
int i;
|
||||
|
||||
qlock(&queue);
|
||||
for(i=NQID; i<ndir; i++)
|
||||
flushqueue(&dir[i], t->oldtag);
|
||||
qunlock(&queue);
|
||||
fsysrespond(t, buf, nil);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsyswalk(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
Fcall out;
|
||||
Fid *nf;
|
||||
ulong path;
|
||||
Dirtab *d, *dir;
|
||||
Qid q;
|
||||
int i;
|
||||
uchar type;
|
||||
char *err;
|
||||
|
||||
if(f->open){
|
||||
fsysrespond(t, buf, "clone of an open fid");
|
||||
return t;
|
||||
}
|
||||
|
||||
nf = nil;
|
||||
if(t->fid != t->newfid){
|
||||
nf = newfid(t->newfid);
|
||||
if(nf->busy){
|
||||
fsysrespond(t, buf, "clone to a busy fid");
|
||||
return t;
|
||||
}
|
||||
nf->busy = 1;
|
||||
nf->open = 0;
|
||||
nf->dir = f->dir;
|
||||
nf->qid = f->qid;
|
||||
f = nf; /* walk f */
|
||||
}
|
||||
|
||||
out.nwqid = 0;
|
||||
err = nil;
|
||||
dir = f->dir;
|
||||
q = f->qid;
|
||||
|
||||
if(t->nwname > 0){
|
||||
for(i=0; i<t->nwname; i++){
|
||||
if((q.type & QTDIR) == 0){
|
||||
err = Enotdir;
|
||||
break;
|
||||
}
|
||||
if(strcmp(t->wname[i], "..") == 0){
|
||||
type = QTDIR;
|
||||
path = Qdir;
|
||||
Accept:
|
||||
q.type = type;
|
||||
q.vers = 0;
|
||||
q.path = path;
|
||||
out.wqid[out.nwqid++] = q;
|
||||
continue;
|
||||
}
|
||||
d = dir;
|
||||
d++; /* skip '.' */
|
||||
for(; d->name; d++)
|
||||
if(strcmp(t->wname[i], d->name) == 0){
|
||||
type = d->type;
|
||||
path = d->qid;
|
||||
dir = d;
|
||||
goto Accept;
|
||||
}
|
||||
err = Enoexist;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
out.type = t->type;
|
||||
out.tag = t->tag;
|
||||
if(err!=nil || out.nwqid<t->nwname){
|
||||
if(nf)
|
||||
nf->busy = 0;
|
||||
}else if(out.nwqid == t->nwname){
|
||||
f->qid = q;
|
||||
f->dir = dir;
|
||||
}
|
||||
|
||||
fsysrespond(&out, buf, err);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysopen(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
int m, clearrules, mode;
|
||||
|
||||
clearrules = 0;
|
||||
if(t->mode & OTRUNC){
|
||||
if(f->qid.path != Qrules)
|
||||
goto Deny;
|
||||
clearrules = 1;
|
||||
}
|
||||
/* can't truncate anything, so just disregard */
|
||||
mode = t->mode & ~(OTRUNC|OCEXEC);
|
||||
/* can't execute or remove anything */
|
||||
if(mode==OEXEC || (mode&ORCLOSE))
|
||||
goto Deny;
|
||||
switch(mode){
|
||||
default:
|
||||
goto Deny;
|
||||
case OREAD:
|
||||
m = 0400;
|
||||
break;
|
||||
case OWRITE:
|
||||
m = 0200;
|
||||
break;
|
||||
case ORDWR:
|
||||
m = 0600;
|
||||
break;
|
||||
}
|
||||
if(((f->dir->perm&~(DMDIR|DMAPPEND))&m) != m)
|
||||
goto Deny;
|
||||
if(f->qid.path==Qrules && (mode==OWRITE || mode==ORDWR)){
|
||||
lock(&rulesref);
|
||||
if(rulesref.ref++ != 0){
|
||||
rulesref.ref--;
|
||||
unlock(&rulesref);
|
||||
fsysrespond(t, buf, Einuse);
|
||||
return t;
|
||||
}
|
||||
unlock(&rulesref);
|
||||
}
|
||||
if(clearrules){
|
||||
writerules(nil, 0);
|
||||
rules[0] = nil;
|
||||
}
|
||||
t->qid = f->qid;
|
||||
t->iounit = 0;
|
||||
qlock(&queue);
|
||||
f->mode = mode;
|
||||
f->open = 1;
|
||||
f->dir->nopen++;
|
||||
f->nextopen = f->dir->fopen;
|
||||
f->dir->fopen = f;
|
||||
queueheld(f->dir);
|
||||
qunlock(&queue);
|
||||
fsysrespond(t, buf, nil);
|
||||
return t;
|
||||
|
||||
Deny:
|
||||
fsysrespond(t, buf, Eperm);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsyscreate(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
fsysrespond(t, buf, Eperm);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysreadrules(Fcall *t, uchar *buf)
|
||||
{
|
||||
char *p;
|
||||
int n;
|
||||
|
||||
p = printrules();
|
||||
n = strlen(p);
|
||||
t->data = p;
|
||||
if(t->offset >= n)
|
||||
t->count = 0;
|
||||
else{
|
||||
t->data = p+t->offset;
|
||||
if(t->offset+t->count > n)
|
||||
t->count = n-t->offset;
|
||||
}
|
||||
fsysrespond(t, buf, nil);
|
||||
free(p);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysread(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
uchar *b;
|
||||
int i, n, o, e;
|
||||
uint len;
|
||||
Dirtab *d;
|
||||
uint clock;
|
||||
|
||||
if(f->qid.path != Qdir){
|
||||
if(f->qid.path == Qrules)
|
||||
return fsysreadrules(t, buf);
|
||||
/* read from port */
|
||||
if(f->qid.path < NQID){
|
||||
fsysrespond(t, buf, "internal error: unknown read port");
|
||||
return t;
|
||||
}
|
||||
qlock(&queue);
|
||||
queueread(f->dir, t, buf, f);
|
||||
drainqueue(f->dir);
|
||||
qunlock(&queue);
|
||||
return nil;
|
||||
}
|
||||
o = t->offset;
|
||||
e = t->offset+t->count;
|
||||
clock = getclock();
|
||||
b = malloc(messagesize-IOHDRSZ);
|
||||
if(b == nil){
|
||||
fsysrespond(t, buf, Enomem);
|
||||
return t;
|
||||
}
|
||||
n = 0;
|
||||
d = dir;
|
||||
d++; /* first entry is '.' */
|
||||
for(i=0; d->name!=nil && i<e; i+=len){
|
||||
len = dostat(d, b+n, messagesize-IOHDRSZ-n, clock);
|
||||
if(len <= BIT16SZ)
|
||||
break;
|
||||
if(i >= o)
|
||||
n += len;
|
||||
d++;
|
||||
}
|
||||
t->data = (char*)b;
|
||||
t->count = n;
|
||||
fsysrespond(t, buf, nil);
|
||||
free(b);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsyswrite(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
Plumbmsg *m;
|
||||
int i, n;
|
||||
long count;
|
||||
char *data;
|
||||
Exec *e;
|
||||
|
||||
switch((int)f->qid.path){
|
||||
case Qdir:
|
||||
fsysrespond(t, buf, Eisdir);
|
||||
return t;
|
||||
case Qrules:
|
||||
clock = getclock();
|
||||
fsysrespond(t, buf, writerules(t->data, t->count));
|
||||
return t;
|
||||
case Qsend:
|
||||
if(f->offset == 0){
|
||||
data = t->data;
|
||||
count = t->count;
|
||||
}else{
|
||||
/* partial message already assembled */
|
||||
f->writebuf = erealloc(f->writebuf, f->offset + t->count);
|
||||
memmove(f->writebuf+f->offset, t->data, t->count);
|
||||
data = f->writebuf;
|
||||
count = f->offset+t->count;
|
||||
}
|
||||
m = plumbunpackpartial(data, count, &n);
|
||||
if(m == nil){
|
||||
if(n == 0){
|
||||
f->offset = 0;
|
||||
free(f->writebuf);
|
||||
f->writebuf = nil;
|
||||
fsysrespond(t, buf, Ebadmsg);
|
||||
return t;
|
||||
}
|
||||
/* can read more... */
|
||||
if(f->offset == 0){
|
||||
f->writebuf = emalloc(t->count);
|
||||
memmove(f->writebuf, t->data, t->count);
|
||||
}
|
||||
/* else buffer has already been grown */
|
||||
f->offset += t->count;
|
||||
fsysrespond(t, buf, nil);
|
||||
return t;
|
||||
}
|
||||
/* release partial buffer */
|
||||
f->offset = 0;
|
||||
free(f->writebuf);
|
||||
f->writebuf = nil;
|
||||
for(i=0; rules[i]; i++)
|
||||
if((e=matchruleset(m, rules[i])) != nil){
|
||||
dispose(t, buf, m, rules[i], e);
|
||||
return nil;
|
||||
}
|
||||
if(m->dst != nil){
|
||||
dispose(t, buf, m, nil, nil);
|
||||
return nil;
|
||||
}
|
||||
fsysrespond(t, buf, "no matching plumb rule");
|
||||
return t;
|
||||
}
|
||||
fsysrespond(t, buf, "internal error: write to unknown file");
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysstat(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
t->stat = emalloc(messagesize-IOHDRSZ);
|
||||
t->nstat = dostat(f->dir, t->stat, messagesize-IOHDRSZ, clock);
|
||||
fsysrespond(t, buf, nil);
|
||||
free(t->stat);
|
||||
t->stat = nil;
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsyswstat(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
fsysrespond(t, buf, Eperm);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysremove(Fcall *t, uchar *buf, Fid*)
|
||||
{
|
||||
fsysrespond(t, buf, Eperm);
|
||||
return t;
|
||||
}
|
||||
|
||||
static Fcall*
|
||||
fsysclunk(Fcall *t, uchar *buf, Fid *f)
|
||||
{
|
||||
Fid *prev, *p;
|
||||
Dirtab *d;
|
||||
|
||||
qlock(&queue);
|
||||
if(f->open){
|
||||
d = f->dir;
|
||||
d->nopen--;
|
||||
if(d->qid==Qrules && (f->mode==OWRITE || f->mode==ORDWR)){
|
||||
/*
|
||||
* just to be sure last rule is parsed; error messages will be lost, though,
|
||||
* unless last write ended with a blank line
|
||||
*/
|
||||
writerules(nil, 0);
|
||||
lock(&rulesref);
|
||||
rulesref.ref--;
|
||||
unlock(&rulesref);
|
||||
}
|
||||
prev = nil;
|
||||
for(p=d->fopen; p; p=p->nextopen){
|
||||
if(p == f){
|
||||
if(prev)
|
||||
prev->nextopen = f->nextopen;
|
||||
else
|
||||
d->fopen = f->nextopen;
|
||||
removesenders(d, f);
|
||||
break;
|
||||
}
|
||||
prev = p;
|
||||
}
|
||||
}
|
||||
f->busy = 0;
|
||||
f->open = 0;
|
||||
f->offset = 0;
|
||||
if(f->writebuf != nil){
|
||||
free(f->writebuf);
|
||||
f->writebuf = nil;
|
||||
}
|
||||
qunlock(&queue);
|
||||
fsysrespond(t, buf, nil);
|
||||
return t;
|
||||
}
|
||||
463
src/cmd/plumb/match.c
Normal file
463
src/cmd/plumb/match.c
Normal file
|
|
@ -0,0 +1,463 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <regexp.h>
|
||||
#include <thread.h>
|
||||
#include <plumb.h>
|
||||
#include "plumber.h"
|
||||
|
||||
static char*
|
||||
nonnil(char *s)
|
||||
{
|
||||
if(s == nil)
|
||||
return "";
|
||||
return s;
|
||||
}
|
||||
|
||||
int
|
||||
verbis(int obj, Plumbmsg *m, Rule *r)
|
||||
{
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'is' object %d\n", obj);
|
||||
break;
|
||||
case OData:
|
||||
return strcmp(m->data, r->qarg) == 0;
|
||||
case ODst:
|
||||
return strcmp(m->dst, r->qarg) == 0;
|
||||
case OType:
|
||||
return strcmp(m->type, r->qarg) == 0;
|
||||
case OWdir:
|
||||
return strcmp(m->wdir, r->qarg) == 0;
|
||||
case OSrc:
|
||||
return strcmp(m->src, r->qarg) == 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
setvar(Resub rs[10], char *match[10])
|
||||
{
|
||||
int i, n;
|
||||
|
||||
for(i=0; i<10; i++){
|
||||
free(match[i]);
|
||||
match[i] = nil;
|
||||
}
|
||||
for(i=0; i<10 && rs[i].sp!=nil; i++){
|
||||
n = rs[i].ep-rs[i].sp;
|
||||
match[i] = emalloc(n+1);
|
||||
memmove(match[i], rs[i].sp, n);
|
||||
match[i][n] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
clickmatch(Reprog *re, char *text, Resub rs[10], int click)
|
||||
{
|
||||
char *clickp;
|
||||
int i, w;
|
||||
Rune r;
|
||||
|
||||
/* click is in characters, not bytes */
|
||||
for(i=0; i<click && text[i]!='\0'; i+=w)
|
||||
w = chartorune(&r, text+i);
|
||||
clickp = text+i;
|
||||
for(i=0; i<=click; i++){
|
||||
memset(rs, 0, 10*sizeof(Resub));
|
||||
if(regexec(re, text+i, rs, 10))
|
||||
if(rs[0].sp<=clickp && clickp<=rs[0].ep)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
verbmatches(int obj, Plumbmsg *m, Rule *r, Exec *e)
|
||||
{
|
||||
Resub rs[10];
|
||||
char *clickval, *alltext;
|
||||
int p0, p1, ntext;
|
||||
|
||||
memset(rs, 0, sizeof rs);
|
||||
ntext = -1;
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'matches' object %d\n", obj);
|
||||
break;
|
||||
case OData:
|
||||
clickval = plumblookup(m->attr, "click");
|
||||
if(clickval == nil){
|
||||
alltext = m->data;
|
||||
ntext = m->ndata;
|
||||
goto caseAlltext;
|
||||
}
|
||||
if(!clickmatch(r->regex, m->data, rs, atoi(clickval)))
|
||||
break;
|
||||
p0 = rs[0].sp - m->data;
|
||||
p1 = rs[0].ep - m->data;
|
||||
if(e->p0 >=0 && !(p0==e->p0 && p1==e->p1))
|
||||
break;
|
||||
e->clearclick = 1;
|
||||
e->setdata = 1;
|
||||
e->p0 = p0;
|
||||
e->p1 = p1;
|
||||
setvar(rs, e->match);
|
||||
return 1;
|
||||
case ODst:
|
||||
alltext = m->dst;
|
||||
goto caseAlltext;
|
||||
case OType:
|
||||
alltext = m->type;
|
||||
goto caseAlltext;
|
||||
case OWdir:
|
||||
alltext = m->wdir;
|
||||
goto caseAlltext;
|
||||
case OSrc:
|
||||
alltext = m->src;
|
||||
/* fall through */
|
||||
caseAlltext:
|
||||
/* must match full text */
|
||||
if(ntext < 0)
|
||||
ntext = strlen(alltext);
|
||||
if(!regexec(r->regex, alltext, rs, 10) || rs[0].sp!=alltext || rs[0].ep!=alltext+ntext)
|
||||
break;
|
||||
setvar(rs, e->match);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
isfile(char *file, ulong maskon, ulong maskoff)
|
||||
{
|
||||
Dir *d;
|
||||
int mode;
|
||||
|
||||
d = dirstat(file);
|
||||
if(d == nil)
|
||||
return 0;
|
||||
mode = d->mode;
|
||||
free(d);
|
||||
if((mode & maskon) == 0)
|
||||
return 0;
|
||||
if(mode & maskoff)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
char*
|
||||
absolute(char *dir, char *file)
|
||||
{
|
||||
char *p;
|
||||
|
||||
if(file[0] == '/')
|
||||
return estrdup(file);
|
||||
p = emalloc(strlen(dir)+1+strlen(file)+1);
|
||||
sprint(p, "%s/%s", dir, file);
|
||||
return cleanname(p);
|
||||
}
|
||||
|
||||
int
|
||||
verbisfile(int obj, Plumbmsg *m, Rule *r, Exec *e, ulong maskon, ulong maskoff, char **var)
|
||||
{
|
||||
char *file;
|
||||
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'isfile' object %d\n", obj);
|
||||
break;
|
||||
case OArg:
|
||||
file = absolute(m->wdir, expand(e, r->arg, nil));
|
||||
if(isfile(file, maskon, maskoff)){
|
||||
*var = file;
|
||||
return 1;
|
||||
}
|
||||
free(file);
|
||||
break;
|
||||
case OData:
|
||||
case OWdir:
|
||||
file = absolute(m->wdir, obj==OData? m->data : m->wdir);
|
||||
if(isfile(file, maskon, maskoff)){
|
||||
*var = file;
|
||||
return 1;
|
||||
}
|
||||
free(file);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
verbset(int obj, Plumbmsg *m, Rule *r, Exec *e)
|
||||
{
|
||||
char *new;
|
||||
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'is' object %d\n", obj);
|
||||
break;
|
||||
case OData:
|
||||
new = estrdup(expand(e, r->arg, nil));
|
||||
m->ndata = strlen(new);
|
||||
free(m->data);
|
||||
m->data = new;
|
||||
e->p0 = -1;
|
||||
e->p1 = -1;
|
||||
e->setdata = 0;
|
||||
return 1;
|
||||
case ODst:
|
||||
new = estrdup(expand(e, r->arg, nil));
|
||||
free(m->dst);
|
||||
m->dst = new;
|
||||
return 1;
|
||||
case OType:
|
||||
new = estrdup(expand(e, r->arg, nil));
|
||||
free(m->type);
|
||||
m->type = new;
|
||||
return 1;
|
||||
case OWdir:
|
||||
new = estrdup(expand(e, r->arg, nil));
|
||||
free(m->wdir);
|
||||
m->wdir = new;
|
||||
return 1;
|
||||
case OSrc:
|
||||
new = estrdup(expand(e, r->arg, nil));
|
||||
free(m->src);
|
||||
m->src = new;
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
verbadd(int obj, Plumbmsg *m, Rule *r, Exec *e)
|
||||
{
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'add' object %d\n", obj);
|
||||
break;
|
||||
case OAttr:
|
||||
m->attr = plumbaddattr(m->attr, plumbunpackattr(expand(e, r->arg, nil)));
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
verbdelete(int obj, Plumbmsg *m, Rule *r, Exec *e)
|
||||
{
|
||||
char *a;
|
||||
|
||||
switch(obj){
|
||||
default:
|
||||
fprint(2, "unimplemented 'delete' object %d\n", obj);
|
||||
break;
|
||||
case OAttr:
|
||||
a = expand(e, r->arg, nil);
|
||||
if(plumblookup(m->attr, a) == nil)
|
||||
break;
|
||||
m->attr = plumbdelattr(m->attr, a);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
matchpat(Plumbmsg *m, Exec *e, Rule *r)
|
||||
{
|
||||
switch(r->verb){
|
||||
default:
|
||||
fprint(2, "unimplemented verb %d\n", r->verb);
|
||||
break;
|
||||
case VAdd:
|
||||
return verbadd(r->obj, m, r, e);
|
||||
case VDelete:
|
||||
return verbdelete(r->obj, m, r, e);
|
||||
case VIs:
|
||||
return verbis(r->obj, m, r);
|
||||
case VIsdir:
|
||||
return verbisfile(r->obj, m, r, e, DMDIR, 0, &e->dir);
|
||||
case VIsfile:
|
||||
return verbisfile(r->obj, m, r, e, ~DMDIR, DMDIR, &e->file);
|
||||
case VMatches:
|
||||
return verbmatches(r->obj, m, r, e);
|
||||
case VSet:
|
||||
verbset(r->obj, m, r, e);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
freeexec(Exec *exec)
|
||||
{
|
||||
int i;
|
||||
|
||||
if(exec == nil)
|
||||
return;
|
||||
free(exec->dir);
|
||||
free(exec->file);
|
||||
for(i=0; i<10; i++)
|
||||
free(exec->match[i]);
|
||||
free(exec);
|
||||
}
|
||||
|
||||
Exec*
|
||||
newexec(Plumbmsg *m)
|
||||
{
|
||||
Exec *exec;
|
||||
|
||||
exec = emalloc(sizeof(Exec));
|
||||
exec->msg = m;
|
||||
exec->p0 = -1;
|
||||
exec->p1 = -1;
|
||||
return exec;
|
||||
}
|
||||
|
||||
void
|
||||
rewrite(Plumbmsg *m, Exec *e)
|
||||
{
|
||||
Plumbattr *a, *prev;
|
||||
|
||||
if(e->clearclick){
|
||||
prev = nil;
|
||||
for(a=m->attr; a!=nil; a=a->next){
|
||||
if(strcmp(a->name, "click") == 0){
|
||||
if(prev == nil)
|
||||
m->attr = a->next;
|
||||
else
|
||||
prev->next = a->next;
|
||||
free(a->name);
|
||||
free(a->value);
|
||||
free(a);
|
||||
break;
|
||||
}
|
||||
prev = a;
|
||||
}
|
||||
if(e->setdata){
|
||||
free(m->data);
|
||||
m->data = estrdup(expand(e, "$0", nil));
|
||||
m->ndata = strlen(m->data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
char**
|
||||
buildargv(char *s, Exec *e)
|
||||
{
|
||||
char **av;
|
||||
int ac;
|
||||
|
||||
ac = 0;
|
||||
av = nil;
|
||||
for(;;){
|
||||
av = erealloc(av, (ac+1) * sizeof(char*));
|
||||
av[ac] = nil;
|
||||
while(*s==' ' || *s=='\t')
|
||||
s++;
|
||||
if(*s == '\0')
|
||||
break;
|
||||
av[ac++] = estrdup(expand(e, s, &s));
|
||||
}
|
||||
return av;
|
||||
}
|
||||
|
||||
Exec*
|
||||
matchruleset(Plumbmsg *m, Ruleset *rs)
|
||||
{
|
||||
int i;
|
||||
Exec *exec;
|
||||
|
||||
if(m->dst!=nil && m->dst[0]!='\0' && rs->port!=nil && strcmp(m->dst, rs->port)!=0)
|
||||
return nil;
|
||||
exec = newexec(m);
|
||||
for(i=0; i<rs->npat; i++)
|
||||
if(!matchpat(m, exec, rs->pat[i])){
|
||||
freeexec(exec);
|
||||
return nil;
|
||||
}
|
||||
if(rs->port!=nil && (m->dst==nil || m->dst[0]=='\0')){
|
||||
free(m->dst);
|
||||
m->dst = estrdup(rs->port);
|
||||
}
|
||||
rewrite(m, exec);
|
||||
return exec;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
NARGS = 100,
|
||||
NARGCHAR = 8*1024,
|
||||
EXECSTACK = 4096+(NARGS+1)*sizeof(char*)+NARGCHAR
|
||||
};
|
||||
|
||||
/* copy argv to stack and free the incoming strings, so we don't leak argument vectors */
|
||||
void
|
||||
stackargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
|
||||
{
|
||||
int i, n;
|
||||
char *s, *a;
|
||||
|
||||
s = args;
|
||||
for(i=0; i<NARGS; i++){
|
||||
a = inargv[i];
|
||||
if(a == nil)
|
||||
break;
|
||||
n = strlen(a)+1;
|
||||
if((s-args)+n >= NARGCHAR) /* too many characters */
|
||||
break;
|
||||
argv[i] = s;
|
||||
memmove(s, a, n);
|
||||
s += n;
|
||||
free(a);
|
||||
}
|
||||
argv[i] = nil;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
execproc(void *v)
|
||||
{
|
||||
char **av;
|
||||
char buf[1024], *args[NARGS+1], argc[NARGCHAR];
|
||||
|
||||
rfork(RFFDG);
|
||||
close(0);
|
||||
open("/dev/null", OREAD);
|
||||
av = v;
|
||||
stackargv(av, args, argc);
|
||||
free(av);
|
||||
procexec(nil, args[0], args);
|
||||
if(args[0][0]!='/' && strncmp(args[0], "./", 2)!=0 && strncmp(args[0], "../", 3)!=0)
|
||||
snprint(buf, sizeof buf, "/bin/%s", args[0]);
|
||||
procexec(nil, buf, args);
|
||||
threadexits("can't exec");
|
||||
}
|
||||
|
||||
char*
|
||||
startup(Ruleset *rs, Exec *e)
|
||||
{
|
||||
char **argv;
|
||||
int i;
|
||||
|
||||
if(rs != nil)
|
||||
for(i=0; i<rs->nact; i++){
|
||||
if(rs->act[i]->verb == VStart)
|
||||
goto Found;
|
||||
if(rs->act[i]->verb == VClient){
|
||||
if(e->msg->dst==nil || e->msg->dst[0]=='\0')
|
||||
return "no port for \"client\" rule";
|
||||
e->holdforclient = 1;
|
||||
goto Found;
|
||||
}
|
||||
}
|
||||
return "no start action for plumb message";
|
||||
|
||||
Found:
|
||||
argv = buildargv(rs->act[i]->arg, e);
|
||||
if(argv[0] == nil)
|
||||
return "empty argument list";
|
||||
proccreate(execproc, argv, EXECSTACK);
|
||||
return nil;
|
||||
}
|
||||
20
src/cmd/plumb/mkfile
Normal file
20
src/cmd/plumb/mkfile
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
</$objtype/mkfile
|
||||
|
||||
TARG=plumber plumb
|
||||
|
||||
|
||||
BIN=/$objtype/bin
|
||||
</sys/src/cmd/mkmany
|
||||
|
||||
PLUMBER=plumber.$O fsys.$O match.$O rules.$O
|
||||
PLUMB=plumb.$O
|
||||
|
||||
$PLUMBER: $HFILES plumber.h
|
||||
$PLUMB: $HFILES
|
||||
|
||||
$O.plumb: $PLUMB
|
||||
$O.plumber: $PLUMBER
|
||||
|
||||
syms:V:
|
||||
8c -a plumber.c >syms
|
||||
8c -aa fsys.c match.c rules.c >>syms
|
||||
119
src/cmd/plumb/plumb.c
Normal file
119
src/cmd/plumb/plumb.c
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <plumb.h>
|
||||
|
||||
char *plumbfile = nil;
|
||||
Plumbmsg m;
|
||||
|
||||
void
|
||||
usage(void)
|
||||
{
|
||||
fprint(2, "usage: plumb [-p plumbfile] [-a 'attr=value ...'] [-s src] [-d dst] [-t type] [-w wdir] -i | data1\n");
|
||||
exits("usage");
|
||||
}
|
||||
|
||||
void
|
||||
gather(void)
|
||||
{
|
||||
char buf[8192];
|
||||
int n;
|
||||
|
||||
m.ndata = 0;
|
||||
m.data = nil;
|
||||
while((n = read(0, buf, sizeof buf)) > 0){
|
||||
m.data = realloc(m.data, m.ndata+n);
|
||||
if(m.data == nil){
|
||||
fprint(2, "plumb: alloc failed: %r\n");
|
||||
exits("alloc");
|
||||
}
|
||||
memmove(m.data+m.ndata, buf, n);
|
||||
m.ndata += n;
|
||||
}
|
||||
if(n < 0){
|
||||
fprint(2, "plumb: i/o error on input: %r\n");
|
||||
exits("read");
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
char buf[1024], *p;
|
||||
int fd, i, input;
|
||||
|
||||
input = 0;
|
||||
m.src = "plumb";
|
||||
m.dst = nil;
|
||||
m.wdir = getwd(buf, sizeof buf);
|
||||
m.type = "text";
|
||||
m.attr = nil;
|
||||
ARGBEGIN{
|
||||
case 'a':
|
||||
p = ARGF();
|
||||
if(p == nil)
|
||||
usage();
|
||||
m.attr = plumbaddattr(m.attr, plumbunpackattr(p));
|
||||
break;
|
||||
case 'd':
|
||||
m.dst = ARGF();
|
||||
if(m.dst == nil)
|
||||
usage();
|
||||
break;
|
||||
case 'i':
|
||||
input++;
|
||||
break;
|
||||
case 't':
|
||||
case 'k': /* for backwards compatibility */
|
||||
m.type = ARGF();
|
||||
if(m.type == nil)
|
||||
usage();
|
||||
break;
|
||||
case 'p':
|
||||
plumbfile = ARGF();
|
||||
if(plumbfile == nil)
|
||||
usage();
|
||||
break;
|
||||
case 's':
|
||||
m.src = ARGF();
|
||||
if(m.src == nil)
|
||||
usage();
|
||||
break;
|
||||
case 'w':
|
||||
m.wdir = ARGF();
|
||||
if(m.wdir == nil)
|
||||
usage();
|
||||
break;
|
||||
}ARGEND
|
||||
|
||||
if((input && argc>0) || (!input && argc<1))
|
||||
usage();
|
||||
if(plumbfile != nil)
|
||||
fd = open(plumbfile, OWRITE);
|
||||
else
|
||||
fd = plumbopen("send", OWRITE);
|
||||
if(fd < 0){
|
||||
fprint(2, "plumb: can't open plumb file: %r\n");
|
||||
exits("open");
|
||||
}
|
||||
if(input){
|
||||
gather();
|
||||
if(plumblookup(m.attr, "action") == nil)
|
||||
m.attr = plumbaddattr(m.attr, plumbunpackattr("action=showdata"));
|
||||
if(plumbsend(fd, &m) < 0){
|
||||
fprint(2, "plumb: can't send message: %r\n");
|
||||
exits("error");
|
||||
}
|
||||
exits(nil);
|
||||
}
|
||||
for(i=0; i<argc; i++){
|
||||
if(input == 0){
|
||||
m.data = argv[i];
|
||||
m.ndata = -1;
|
||||
}
|
||||
if(plumbsend(fd, &m) < 0){
|
||||
fprint(2, "plumb: can't send message: %r\n");
|
||||
exits("error");
|
||||
}
|
||||
}
|
||||
exits(nil);
|
||||
}
|
||||
147
src/cmd/plumb/plumber.c
Normal file
147
src/cmd/plumb/plumber.c
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <regexp.h>
|
||||
#include <thread.h>
|
||||
#include <plumb.h>
|
||||
#include <auth.h>
|
||||
#include <fcall.h>
|
||||
#include "plumber.h"
|
||||
|
||||
char *plumbfile;
|
||||
char *user;
|
||||
char *home;
|
||||
char *progname;
|
||||
Ruleset **rules;
|
||||
int printerrors=1;
|
||||
jmp_buf parsejmp;
|
||||
char *lasterror;
|
||||
|
||||
void
|
||||
makeports(Ruleset *rules[])
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i=0; rules[i]; i++)
|
||||
addport(rules[i]->port);
|
||||
}
|
||||
|
||||
void
|
||||
mainproc(void *v)
|
||||
{
|
||||
Channel *c;
|
||||
|
||||
c = v;
|
||||
printerrors = 0;
|
||||
makeports(rules);
|
||||
startfsys();
|
||||
sendp(c, nil);
|
||||
}
|
||||
|
||||
void
|
||||
threadmain(int argc, char *argv[])
|
||||
{
|
||||
char buf[512];
|
||||
int fd;
|
||||
Channel *c;
|
||||
|
||||
progname = "plumber";
|
||||
|
||||
ARGBEGIN{
|
||||
case 'p':
|
||||
plumbfile = ARGF();
|
||||
break;
|
||||
}ARGEND
|
||||
|
||||
user = getenv("user");
|
||||
home = getenv("home");
|
||||
if(user==nil || home==nil)
|
||||
error("can't initialize $user or $home: %r");
|
||||
if(plumbfile == nil){
|
||||
sprint(buf, "%s/lib/plumbing", home);
|
||||
plumbfile = estrdup(buf);
|
||||
}
|
||||
|
||||
fd = open(plumbfile, OREAD);
|
||||
if(fd < 0)
|
||||
error("can't open rules file %s: %r", plumbfile);
|
||||
if(setjmp(parsejmp))
|
||||
error("parse error");
|
||||
|
||||
rules = readrules(plumbfile, fd);
|
||||
close(fd);
|
||||
|
||||
/*
|
||||
* Start all processes and threads from other proc
|
||||
* so we (main pid) can return to user.
|
||||
*/
|
||||
c = chancreate(sizeof(void*), 0);
|
||||
proccreate(mainproc, c, 8192);
|
||||
recvp(c);
|
||||
chanfree(c);
|
||||
threadexits(nil);
|
||||
}
|
||||
|
||||
void
|
||||
error(char *fmt, ...)
|
||||
{
|
||||
char buf[512];
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
vseprint(buf, buf+sizeof buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
fprint(2, "%s: %s\n", progname, buf);
|
||||
threadexitsall("error");
|
||||
}
|
||||
|
||||
void
|
||||
parseerror(char *fmt, ...)
|
||||
{
|
||||
char buf[512];
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
vseprint(buf, buf+sizeof buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
if(printerrors){
|
||||
printinputstack();
|
||||
fprint(2, "%s\n", buf);
|
||||
}
|
||||
do; while(popinput());
|
||||
lasterror = estrdup(buf);
|
||||
longjmp(parsejmp, 1);
|
||||
}
|
||||
|
||||
void*
|
||||
emalloc(long n)
|
||||
{
|
||||
void *p;
|
||||
|
||||
p = malloc(n);
|
||||
if(p == nil)
|
||||
error("malloc failed: %r");
|
||||
memset(p, 0, n);
|
||||
return p;
|
||||
}
|
||||
|
||||
void*
|
||||
erealloc(void *p, long n)
|
||||
{
|
||||
p = realloc(p, n);
|
||||
if(p == nil)
|
||||
error("realloc failed: %r");
|
||||
return p;
|
||||
}
|
||||
|
||||
char*
|
||||
estrdup(char *s)
|
||||
{
|
||||
char *t;
|
||||
|
||||
t = strdup(s);
|
||||
if(t == nil)
|
||||
error("estrdup failed: %r");
|
||||
return t;
|
||||
}
|
||||
93
src/cmd/plumb/plumber.h
Normal file
93
src/cmd/plumb/plumber.h
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
typedef struct Exec Exec;
|
||||
typedef struct Rule Rule;
|
||||
typedef struct Ruleset Ruleset;
|
||||
|
||||
/*
|
||||
* Object
|
||||
*/
|
||||
enum
|
||||
{
|
||||
OArg,
|
||||
OAttr,
|
||||
OData,
|
||||
ODst,
|
||||
OPlumb,
|
||||
OSrc,
|
||||
OType,
|
||||
OWdir,
|
||||
};
|
||||
|
||||
/*
|
||||
* Verbs
|
||||
*/
|
||||
enum
|
||||
{
|
||||
VAdd, /* apply to OAttr only */
|
||||
VClient,
|
||||
VDelete, /* apply to OAttr only */
|
||||
VIs,
|
||||
VIsdir,
|
||||
VIsfile,
|
||||
VMatches,
|
||||
VSet,
|
||||
VStart,
|
||||
VTo,
|
||||
};
|
||||
|
||||
struct Rule
|
||||
{
|
||||
int obj;
|
||||
int verb;
|
||||
char *arg; /* unparsed string of all arguments */
|
||||
char *qarg; /* quote-processed arg string */
|
||||
Reprog *regex;
|
||||
};
|
||||
|
||||
struct Ruleset
|
||||
{
|
||||
int npat;
|
||||
int nact;
|
||||
Rule **pat;
|
||||
Rule **act;
|
||||
char *port;
|
||||
};
|
||||
|
||||
struct Exec
|
||||
{
|
||||
Plumbmsg *msg;
|
||||
char *match[10];
|
||||
int p0; /* begin and end of match */
|
||||
int p1;
|
||||
int clearclick; /* click was expanded; remove attribute */
|
||||
int setdata; /* data should be set to $0 */
|
||||
int holdforclient; /* exec'ing client; keep message until port is opened */
|
||||
/* values of $variables */
|
||||
char *file;
|
||||
char *dir;
|
||||
};
|
||||
|
||||
void parseerror(char*, ...);
|
||||
void error(char*, ...);
|
||||
void* emalloc(long);
|
||||
void* erealloc(void*, long);
|
||||
char* estrdup(char*);
|
||||
Ruleset** readrules(char*, int);
|
||||
void startfsys(void);
|
||||
Exec* matchruleset(Plumbmsg*, Ruleset*);
|
||||
void freeexec(Exec*);
|
||||
char* startup(Ruleset*, Exec*);
|
||||
char* printrules(void);
|
||||
void addport(char*);
|
||||
char* writerules(char*, int);
|
||||
char* expand(Exec*, char*, char**);
|
||||
void makeports(Ruleset*[]);
|
||||
void printinputstack(void);
|
||||
int popinput(void);
|
||||
|
||||
Ruleset **rules;
|
||||
char *user;
|
||||
char *home;
|
||||
jmp_buf parsejmp;
|
||||
char *lasterror;
|
||||
char **ports;
|
||||
int nports;
|
||||
779
src/cmd/plumb/rules.c
Normal file
779
src/cmd/plumb/rules.c
Normal file
|
|
@ -0,0 +1,779 @@
|
|||
#include <u.h>
|
||||
#include <libc.h>
|
||||
#include <bio.h>
|
||||
#include <regexp.h>
|
||||
#include <thread.h>
|
||||
#include <ctype.h>
|
||||
#include <plumb.h>
|
||||
#include "plumber.h"
|
||||
|
||||
typedef struct Input Input;
|
||||
typedef struct Var Var;
|
||||
|
||||
struct Input
|
||||
{
|
||||
char *file; /* name of file */
|
||||
Biobuf *fd; /* input buffer, if from real file */
|
||||
uchar *s; /* input string, if from /mnt/plumb/rules */
|
||||
uchar *end; /* end of input string */
|
||||
int lineno;
|
||||
Input *next; /* file to read after EOF on this one */
|
||||
};
|
||||
|
||||
struct Var
|
||||
{
|
||||
char *name;
|
||||
char *value;
|
||||
char *qvalue;
|
||||
};
|
||||
|
||||
static int parsing;
|
||||
static int nvars;
|
||||
static Var *vars;
|
||||
static Input *input;
|
||||
|
||||
static char ebuf[4096];
|
||||
|
||||
char *badports[] =
|
||||
{
|
||||
".",
|
||||
"..",
|
||||
"send",
|
||||
nil
|
||||
};
|
||||
|
||||
char *objects[] =
|
||||
{
|
||||
"arg",
|
||||
"attr",
|
||||
"data",
|
||||
"dst",
|
||||
"plumb",
|
||||
"src",
|
||||
"type",
|
||||
"wdir",
|
||||
nil
|
||||
};
|
||||
|
||||
char *verbs[] =
|
||||
{
|
||||
"add",
|
||||
"client",
|
||||
"delete",
|
||||
"is",
|
||||
"isdir",
|
||||
"isfile",
|
||||
"matches",
|
||||
"set",
|
||||
"start",
|
||||
"to",
|
||||
nil
|
||||
};
|
||||
|
||||
static void
|
||||
printinputstackrev(Input *in)
|
||||
{
|
||||
if(in == nil)
|
||||
return;
|
||||
printinputstackrev(in->next);
|
||||
fprint(2, "%s:%d: ", in->file, in->lineno);
|
||||
}
|
||||
|
||||
void
|
||||
printinputstack(void)
|
||||
{
|
||||
printinputstackrev(input);
|
||||
}
|
||||
|
||||
static void
|
||||
pushinput(char *name, int fd, uchar *str)
|
||||
{
|
||||
Input *in;
|
||||
int depth;
|
||||
|
||||
depth = 0;
|
||||
for(in=input; in; in=in->next)
|
||||
if(depth++ >= 10) /* prevent deep C stack in plumber and bad include structure */
|
||||
parseerror("include stack too deep; max 10");
|
||||
|
||||
in = emalloc(sizeof(Input));
|
||||
in->file = estrdup(name);
|
||||
in->next = input;
|
||||
input = in;
|
||||
if(str)
|
||||
in->s = str;
|
||||
else{
|
||||
in->fd = emalloc(sizeof(Biobuf));
|
||||
if(Binit(in->fd, fd, OREAD) < 0)
|
||||
parseerror("can't initialize Bio for rules file: %r");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
popinput(void)
|
||||
{
|
||||
Input *in;
|
||||
|
||||
in = input;
|
||||
if(in == nil)
|
||||
return 0;
|
||||
input = in->next;
|
||||
if(in->fd){
|
||||
Bterm(in->fd);
|
||||
free(in->fd);
|
||||
}
|
||||
free(in);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
getc(void)
|
||||
{
|
||||
if(input == nil)
|
||||
return Beof;
|
||||
if(input->fd)
|
||||
return Bgetc(input->fd);
|
||||
if(input->s < input->end)
|
||||
return *(input->s)++;
|
||||
return -1;
|
||||
}
|
||||
|
||||
char*
|
||||
getline(void)
|
||||
{
|
||||
static int n = 0;
|
||||
static char *s, *incl;
|
||||
int c, i;
|
||||
|
||||
i = 0;
|
||||
for(;;){
|
||||
c = getc();
|
||||
if(c < 0)
|
||||
return nil;
|
||||
if(i == n){
|
||||
n += 100;
|
||||
s = erealloc(s, n);
|
||||
}
|
||||
if(c<0 || c=='\0' || c=='\n')
|
||||
break;
|
||||
s[i++] = c;
|
||||
}
|
||||
s[i] = '\0';
|
||||
return s;
|
||||
}
|
||||
|
||||
int
|
||||
lookup(char *s, char *tab[])
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i=0; tab[i]!=nil; i++)
|
||||
if(strcmp(s, tab[i])==0)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
Var*
|
||||
lookupvariable(char *s, int n)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i=0; i<nvars; i++)
|
||||
if(n==strlen(vars[i].name) && memcmp(s, vars[i].name, n)==0)
|
||||
return vars+i;
|
||||
return nil;
|
||||
}
|
||||
|
||||
char*
|
||||
variable(char *s, int n)
|
||||
{
|
||||
Var *var;
|
||||
|
||||
var = lookupvariable(s, n);
|
||||
if(var)
|
||||
return var->qvalue;
|
||||
return nil;
|
||||
}
|
||||
|
||||
void
|
||||
setvariable(char *s, int n, char *val, char *qval)
|
||||
{
|
||||
Var *var;
|
||||
|
||||
var = lookupvariable(s, n);
|
||||
if(var){
|
||||
free(var->value);
|
||||
free(var->qvalue);
|
||||
}else{
|
||||
vars = erealloc(vars, (nvars+1)*sizeof(Var));
|
||||
var = vars+nvars++;
|
||||
var->name = emalloc(n+1);
|
||||
memmove(var->name, s, n);
|
||||
}
|
||||
var->value = estrdup(val);
|
||||
var->qvalue = estrdup(qval);
|
||||
}
|
||||
|
||||
static char*
|
||||
nonnil(char *s)
|
||||
{
|
||||
if(s == nil)
|
||||
return "";
|
||||
return s;
|
||||
}
|
||||
|
||||
static char*
|
||||
filename(Exec *e, char *name)
|
||||
{
|
||||
static char *buf; /* rock to hold value so we don't leak the strings */
|
||||
|
||||
free(buf);
|
||||
/* if name is defined, used it */
|
||||
if(name!=nil && name[0]!='\0'){
|
||||
buf = estrdup(name);
|
||||
return cleanname(buf);
|
||||
}
|
||||
/* if data is an absolute file name, or wdir is empty, use it */
|
||||
if(e->msg->data[0]=='/' || e->msg->wdir==nil || e->msg->wdir[0]=='\0'){
|
||||
buf = estrdup(e->msg->data);
|
||||
return cleanname(buf);
|
||||
}
|
||||
buf = emalloc(strlen(e->msg->wdir)+1+strlen(e->msg->data)+1);
|
||||
sprint(buf, "%s/%s", e->msg->wdir, e->msg->data);
|
||||
return cleanname(buf);
|
||||
}
|
||||
|
||||
char*
|
||||
dollar(Exec *e, char *s, int *namelen)
|
||||
{
|
||||
int n;
|
||||
static char *abuf;
|
||||
char *t;
|
||||
|
||||
*namelen = 1;
|
||||
if(e!=nil && '0'<=s[0] && s[0]<='9')
|
||||
return nonnil(e->match[s[0]-'0']);
|
||||
|
||||
for(t=s; isalnum(*t); t++)
|
||||
;
|
||||
n = t-s;
|
||||
*namelen = n;
|
||||
|
||||
if(e != nil){
|
||||
if(n == 3){
|
||||
if(memcmp(s, "src", 3) == 0)
|
||||
return nonnil(e->msg->src);
|
||||
if(memcmp(s, "dst", 3) == 0)
|
||||
return nonnil(e->msg->dst);
|
||||
if(memcmp(s, "dir", 3) == 0)
|
||||
return filename(e, e->dir);
|
||||
}
|
||||
if(n == 4){
|
||||
if(memcmp(s, "attr", 4) == 0){
|
||||
free(abuf);
|
||||
abuf = plumbpackattr(e->msg->attr);
|
||||
return nonnil(abuf);
|
||||
}
|
||||
if(memcmp(s, "data", 4) == 0)
|
||||
return nonnil(e->msg->data);
|
||||
if(memcmp(s, "file", 4) == 0)
|
||||
return filename(e, e->file);
|
||||
if(memcmp(s, "type", 4) == 0)
|
||||
return nonnil(e->msg->type);
|
||||
if(memcmp(s, "wdir", 3) == 0)
|
||||
return nonnil(e->msg->wdir);
|
||||
}
|
||||
}
|
||||
|
||||
return variable(s, n);
|
||||
}
|
||||
|
||||
/* expand one blank-terminated string, processing quotes and $ signs */
|
||||
char*
|
||||
expand(Exec *e, char *s, char **ends)
|
||||
{
|
||||
char *p, *ep, *val;
|
||||
int namelen, quoting;
|
||||
|
||||
p = ebuf;
|
||||
ep = ebuf+sizeof ebuf-1;
|
||||
quoting = 0;
|
||||
while(p<ep && *s!='\0' && (quoting || (*s!=' ' && *s!='\t'))){
|
||||
if(*s == '\''){
|
||||
s++;
|
||||
if(!quoting)
|
||||
quoting = 1;
|
||||
else if(*s == '\''){
|
||||
*p++ = '\'';
|
||||
s++;
|
||||
}else
|
||||
quoting = 0;
|
||||
continue;
|
||||
}
|
||||
if(quoting || *s!='$'){
|
||||
*p++ = *s++;
|
||||
continue;
|
||||
}
|
||||
s++;
|
||||
val = dollar(e, s, &namelen);
|
||||
if(val == nil){
|
||||
*p++ = '$';
|
||||
continue;
|
||||
}
|
||||
if(ep-p < strlen(val))
|
||||
return "string-too-long";
|
||||
strcpy(p, val);
|
||||
p += strlen(val);
|
||||
s += namelen;
|
||||
}
|
||||
if(ends)
|
||||
*ends = s;
|
||||
*p = '\0';
|
||||
return ebuf;
|
||||
}
|
||||
|
||||
void
|
||||
regerror(char *msg)
|
||||
{
|
||||
if(parsing){
|
||||
parsing = 0;
|
||||
parseerror("%s", msg);
|
||||
}
|
||||
error("%s", msg);
|
||||
}
|
||||
|
||||
void
|
||||
parserule(Rule *r)
|
||||
{
|
||||
r->qarg = estrdup(expand(nil, r->arg, nil));
|
||||
switch(r->obj){
|
||||
case OArg:
|
||||
case OAttr:
|
||||
case OData:
|
||||
case ODst:
|
||||
case OType:
|
||||
case OWdir:
|
||||
case OSrc:
|
||||
if(r->verb==VClient || r->verb==VStart || r->verb==VTo)
|
||||
parseerror("%s not valid verb for object %s", verbs[r->verb], objects[r->obj]);
|
||||
if(r->obj!=OAttr && (r->verb==VAdd || r->verb==VDelete))
|
||||
parseerror("%s not valid verb for object %s", verbs[r->verb], objects[r->obj]);
|
||||
if(r->verb == VMatches){
|
||||
r->regex = regcomp(r->qarg);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case OPlumb:
|
||||
if(r->verb!=VClient && r->verb!=VStart && r->verb!=VTo)
|
||||
parseerror("%s not valid verb for object %s", verbs[r->verb], objects[r->obj]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
assignment(char *p)
|
||||
{
|
||||
char *var, *qval;
|
||||
int n;
|
||||
|
||||
if(!isalpha(p[0]))
|
||||
return 0;
|
||||
for(var=p; isalnum(*p); p++)
|
||||
;
|
||||
n = p-var;
|
||||
while(*p==' ' || *p=='\t')
|
||||
p++;
|
||||
if(*p++ != '=')
|
||||
return 0;
|
||||
while(*p==' ' || *p=='\t')
|
||||
p++;
|
||||
qval = expand(nil, p, nil);
|
||||
setvariable(var, n, p, qval);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
include(char *s)
|
||||
{
|
||||
char *t, *args[3], buf[128];
|
||||
int n, fd;
|
||||
|
||||
if(strncmp(s, "include", 7) != 0)
|
||||
return 0;
|
||||
/* either an include or an error */
|
||||
n = tokenize(s, args, nelem(args));
|
||||
if(n < 2)
|
||||
goto Err;
|
||||
if(strcmp(args[0], "include") != 0)
|
||||
goto Err;
|
||||
if(args[1][0] == '#')
|
||||
goto Err;
|
||||
if(n>2 && args[2][0] != '#')
|
||||
goto Err;
|
||||
t = args[1];
|
||||
fd = open(t, OREAD);
|
||||
if(fd<0 && t[0]!='/' && strncmp(t, "./", 2)!=0 && strncmp(t, "../", 3)!=0){
|
||||
snprint(buf, sizeof buf, "/sys/lib/plumb/%s", t);
|
||||
t = buf;
|
||||
fd = open(t, OREAD);
|
||||
}
|
||||
if(fd < 0)
|
||||
parseerror("can't open %s for inclusion", t);
|
||||
pushinput(t, fd, nil);
|
||||
return 1;
|
||||
|
||||
Err:
|
||||
parseerror("malformed include statement");
|
||||
return 0;
|
||||
}
|
||||
|
||||
Rule*
|
||||
readrule(int *eof)
|
||||
{
|
||||
Rule *rp;
|
||||
char *line, *p;
|
||||
char *word;
|
||||
|
||||
Top:
|
||||
line = getline();
|
||||
if(line == nil){
|
||||
/*
|
||||
* if input is from string, and bytes remain (input->end is within string),
|
||||
* morerules() will pop input and save remaining data. otherwise pop
|
||||
* the stack here, and if there's more input, keep reading.
|
||||
*/
|
||||
if((input!=nil && input->end==nil) && popinput())
|
||||
goto Top;
|
||||
*eof = 1;
|
||||
return nil;
|
||||
}
|
||||
input->lineno++;
|
||||
|
||||
for(p=line; *p==' ' || *p=='\t'; p++)
|
||||
;
|
||||
if(*p=='\0' || *p=='#') /* empty or comment line */
|
||||
return nil;
|
||||
|
||||
if(include(p))
|
||||
goto Top;
|
||||
|
||||
if(assignment(p))
|
||||
return nil;
|
||||
|
||||
rp = emalloc(sizeof(Rule));
|
||||
|
||||
/* object */
|
||||
for(word=p; *p!=' ' && *p!='\t'; p++)
|
||||
if(*p == '\0')
|
||||
parseerror("malformed rule");
|
||||
*p++ = '\0';
|
||||
rp->obj = lookup(word, objects);
|
||||
if(rp->obj < 0){
|
||||
if(strcmp(word, "kind") == 0) /* backwards compatibility */
|
||||
rp->obj = OType;
|
||||
else
|
||||
parseerror("unknown object %s", word);
|
||||
}
|
||||
|
||||
/* verb */
|
||||
while(*p==' ' || *p=='\t')
|
||||
p++;
|
||||
for(word=p; *p!=' ' && *p!='\t'; p++)
|
||||
if(*p == '\0')
|
||||
parseerror("malformed rule");
|
||||
*p++ = '\0';
|
||||
rp->verb = lookup(word, verbs);
|
||||
if(rp->verb < 0)
|
||||
parseerror("unknown verb %s", word);
|
||||
|
||||
/* argument */
|
||||
while(*p==' ' || *p=='\t')
|
||||
p++;
|
||||
if(*p == '\0')
|
||||
parseerror("malformed rule");
|
||||
rp->arg = estrdup(p);
|
||||
|
||||
parserule(rp);
|
||||
|
||||
return rp;
|
||||
}
|
||||
|
||||
void
|
||||
freerule(Rule *r)
|
||||
{
|
||||
free(r->arg);
|
||||
free(r->qarg);
|
||||
free(r->regex);
|
||||
}
|
||||
|
||||
void
|
||||
freerules(Rule **r)
|
||||
{
|
||||
while(*r)
|
||||
freerule(*r++);
|
||||
}
|
||||
|
||||
void
|
||||
freeruleset(Ruleset *rs)
|
||||
{
|
||||
freerules(rs->pat);
|
||||
free(rs->pat);
|
||||
freerules(rs->act);
|
||||
free(rs->act);
|
||||
free(rs->port);
|
||||
free(rs);
|
||||
}
|
||||
|
||||
Ruleset*
|
||||
readruleset(void)
|
||||
{
|
||||
Ruleset *rs;
|
||||
Rule *r;
|
||||
int eof, inrule, i, ncmd;
|
||||
|
||||
Again:
|
||||
eof = 0;
|
||||
rs = emalloc(sizeof(Ruleset));
|
||||
rs->pat = emalloc(sizeof(Rule*));
|
||||
rs->act = emalloc(sizeof(Rule*));
|
||||
inrule = 0;
|
||||
ncmd = 0;
|
||||
for(;;){
|
||||
r = readrule(&eof);
|
||||
if(eof)
|
||||
break;
|
||||
if(r==nil){
|
||||
if(inrule)
|
||||
break;
|
||||
continue;
|
||||
}
|
||||
inrule = 1;
|
||||
switch(r->obj){
|
||||
case OArg:
|
||||
case OAttr:
|
||||
case OData:
|
||||
case ODst:
|
||||
case OType:
|
||||
case OWdir:
|
||||
case OSrc:
|
||||
rs->npat++;
|
||||
rs->pat = erealloc(rs->pat, (rs->npat+1)*sizeof(Rule*));
|
||||
rs->pat[rs->npat-1] = r;
|
||||
rs->pat[rs->npat] = nil;
|
||||
break;
|
||||
case OPlumb:
|
||||
rs->nact++;
|
||||
rs->act = erealloc(rs->act, (rs->nact+1)*sizeof(Rule*));
|
||||
rs->act[rs->nact-1] = r;
|
||||
rs->act[rs->nact] = nil;
|
||||
if(r->verb == VTo){
|
||||
if(rs->npat>0 && rs->port != nil) /* npat==0 implies port declaration */
|
||||
parseerror("too many ports");
|
||||
if(lookup(r->qarg, badports) >= 0)
|
||||
parseerror("illegal port name %s", r->qarg);
|
||||
rs->port = estrdup(r->qarg);
|
||||
}else
|
||||
ncmd++; /* start or client rule */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(ncmd > 1){
|
||||
freeruleset(rs);
|
||||
parseerror("ruleset has more than one client or start action");
|
||||
}
|
||||
if(rs->npat>0 && rs->nact>0)
|
||||
return rs;
|
||||
if(rs->npat==0 && rs->nact==0){
|
||||
freeruleset(rs);
|
||||
return nil;
|
||||
}
|
||||
if(rs->nact==0 || rs->port==nil){
|
||||
freeruleset(rs);
|
||||
parseerror("ruleset must have patterns and actions");
|
||||
return nil;
|
||||
}
|
||||
|
||||
/* declare ports */
|
||||
for(i=0; i<rs->nact; i++)
|
||||
if(rs->act[i]->verb != VTo){
|
||||
freeruleset(rs);
|
||||
parseerror("ruleset must have actions");
|
||||
return nil;
|
||||
}
|
||||
for(i=0; i<rs->nact; i++)
|
||||
addport(rs->act[i]->qarg);
|
||||
freeruleset(rs);
|
||||
goto Again;
|
||||
}
|
||||
|
||||
Ruleset**
|
||||
readrules(char *name, int fd)
|
||||
{
|
||||
Ruleset *rs, **rules;
|
||||
int n;
|
||||
|
||||
parsing = 1;
|
||||
pushinput(name, fd, nil);
|
||||
rules = emalloc(sizeof(Ruleset*));
|
||||
for(n=0; (rs=readruleset())!=nil; n++){
|
||||
rules = erealloc(rules, (n+2)*sizeof(Ruleset*));
|
||||
rules[n] = rs;
|
||||
rules[n+1] = nil;
|
||||
}
|
||||
popinput();
|
||||
parsing = 0;
|
||||
return rules;
|
||||
}
|
||||
|
||||
char*
|
||||
concat(char *s, char *t)
|
||||
{
|
||||
if(t == nil)
|
||||
return s;
|
||||
if(s == nil)
|
||||
s = estrdup(t);
|
||||
else{
|
||||
s = erealloc(s, strlen(s)+strlen(t)+1);
|
||||
strcat(s, t);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
printpat(Rule *r)
|
||||
{
|
||||
char *s;
|
||||
|
||||
s = emalloc(strlen(objects[r->obj])+1+strlen(verbs[r->verb])+1+strlen(r->arg)+1+1);
|
||||
sprint(s, "%s\t%s\t%s\n", objects[r->obj], verbs[r->verb], r->arg);
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
printvar(Var *v)
|
||||
{
|
||||
char *s;
|
||||
|
||||
s = emalloc(strlen(v->name)+1+strlen(v->value)+2+1);
|
||||
sprint(s, "%s=%s\n\n", v->name, v->value);
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
printrule(Ruleset *r)
|
||||
{
|
||||
int i;
|
||||
char *s;
|
||||
|
||||
s = nil;
|
||||
for(i=0; i<r->npat; i++)
|
||||
s = concat(s, printpat(r->pat[i]));
|
||||
for(i=0; i<r->nact; i++)
|
||||
s = concat(s, printpat(r->act[i]));
|
||||
s = concat(s, "\n");
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
printport(char *port)
|
||||
{
|
||||
char *s;
|
||||
|
||||
s = nil;
|
||||
s = concat(s, "plumb to ");
|
||||
s = concat(s, port);
|
||||
s = concat(s, "\n");
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
printrules(void)
|
||||
{
|
||||
int i;
|
||||
char *s;
|
||||
|
||||
s = nil;
|
||||
for(i=0; i<nvars; i++)
|
||||
s = concat(s, printvar(&vars[i]));
|
||||
for(i=0; i<nports; i++)
|
||||
s = concat(s, printport(ports[i]));
|
||||
s = concat(s, "\n");
|
||||
for(i=0; rules[i]; i++)
|
||||
s = concat(s, printrule(rules[i]));
|
||||
return s;
|
||||
}
|
||||
|
||||
char*
|
||||
stringof(char *s, int n)
|
||||
{
|
||||
char *t;
|
||||
|
||||
t = emalloc(n+1);
|
||||
memmove(t, s, n);
|
||||
return t;
|
||||
}
|
||||
|
||||
uchar*
|
||||
morerules(uchar *text, int done)
|
||||
{
|
||||
int n;
|
||||
Ruleset *rs;
|
||||
uchar *otext, *s, *endofrule;
|
||||
|
||||
pushinput("<rules input>", -1, text);
|
||||
if(done)
|
||||
input->end = text+strlen((char*)text);
|
||||
else{
|
||||
/*
|
||||
* Help user by sending any full rules to parser so any parse errors will
|
||||
* occur on write rather than close. A heuristic will do: blank line ends rule.
|
||||
*/
|
||||
endofrule = nil;
|
||||
for(s=text; *s!='\0'; s++)
|
||||
if(*s=='\n' && *++s=='\n')
|
||||
endofrule = s+1;
|
||||
if(endofrule == nil)
|
||||
return text;
|
||||
input->end = endofrule;
|
||||
}
|
||||
for(n=0; rules[n]; n++)
|
||||
;
|
||||
while((rs=readruleset()) != nil){
|
||||
rules = erealloc(rules, (n+2)*sizeof(Ruleset*));
|
||||
rules[n++] = rs;
|
||||
rules[n] = nil;
|
||||
}
|
||||
otext =text;
|
||||
if(input == nil)
|
||||
text = (uchar*)estrdup("");
|
||||
else
|
||||
text = (uchar*)estrdup((char*)input->end);
|
||||
popinput();
|
||||
free(otext);
|
||||
return text;
|
||||
}
|
||||
|
||||
char*
|
||||
writerules(char *s, int n)
|
||||
{
|
||||
static uchar *text;
|
||||
char *tmp;
|
||||
|
||||
free(lasterror);
|
||||
lasterror = nil;
|
||||
parsing = 1;
|
||||
if(setjmp(parsejmp) == 0){
|
||||
tmp = stringof(s, n);
|
||||
text = (uchar*)concat((char*)text, tmp);
|
||||
free(tmp);
|
||||
text = morerules(text, s==nil);
|
||||
}
|
||||
if(s == nil){
|
||||
free(text);
|
||||
text = nil;
|
||||
}
|
||||
parsing = 0;
|
||||
makeports(rules);
|
||||
return lasterror;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue