Subversion Repositories planix.SVN

#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       = 8192+(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;
}