#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->file);
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);
if(rs->port)
free(rs->port);
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;
}
|
