/*
* Factotum RPC
*
* Must be paired write/read cycles on /mnt/factotum/rpc.
* The format of a request is verb, single space, data.
* Data format is verb-dependent; in particular, it can be binary.
* The format of a response is the same.  The write only sets up
* the RPC.  The read tries to execute it.  If the /mnt/factotum/key
* file is open, we ask for new keys using that instead of returning
* an error in the RPC.  This means the read blocks.
* Textual arguments are parsed with tokenize, so rc-style quoting
* rules apply.
*
* Only authentication protocol messages go here.  Configuration
* is still via ctl (below).
*
* Return values are:
*      error message - an error happened.
*      ok [data] - success, possible data is request dependent.
*      needkey proto domain user - request aborted, get me this key and try again
*      badkey proto domain user - request aborted, this key might be bad
*      done [haveai] - authentication is done [haveai: you can get an ai with authinfo]
* Request RPCs are:
*      start attrs - initializes protocol for authentication, can fail.
*              returns "ok read" or "ok write" on success.
*      read - execute protocol read
*      write - execute protocol write
*      authinfo - if the protocol is finished, return the AI if any
*      attr - return protocol information
*/

#include "dat.h"

Req *rpcwait;

typedef struct Verb Verb;
struct Verb {
       char *verb;
       int iverb;
};

enum {
       Vunknown = -1,
       Vauthinfo = 0,
       Vread,
       Vstart,
       Vwrite,
       Vattr,
};

Verb rpctab[] = {
       "authinfo",     Vauthinfo,
       "read",         Vread,
       "start",                Vstart,
       "write",                Vwrite,
       "attr",         Vattr,
};

static int
classify(char *s, Verb *verbtab, int nverbtab)
{
       int i;

       for(i=0; i<nverbtab; i++)
               if(strcmp(s, verbtab[i].verb) == 0)
                       return verbtab[i].iverb;
       return Vunknown;
}

void
rpcwrite(Req *r)
{
       Fsstate *fss;

       if(r->ifcall.count >= Maxrpc){
               respond(r, Etoolarge);
               return;
       }
       fss = r->fid->aux;
       if(fss->pending){
               respond(r, "rpc already pending; read to clear");
               return;
       }
       memmove(fss->rpc.buf, r->ifcall.data, r->ifcall.count);
       fss->rpc.buf[r->ifcall.count] = '\0';
       fss->rpc.verb = fss->rpc.buf;
       if(fss->rpc.arg = strchr(fss->rpc.buf, ' ')){
               *fss->rpc.arg++ = '\0';
               fss->rpc.narg = r->ifcall.count - (fss->rpc.arg - fss->rpc.buf);
       }else{
               fss->rpc.arg = "";
               fss->rpc.narg = 0;
       }
       fss->rpc.iverb = classify(fss->rpc.verb, rpctab, nelem(rpctab));
       r->ofcall.count = r->ifcall.count;
       fss->pending = 1;
       respond(r, nil);
}

static void
retstring(Req *r, Fsstate *fss, char *s)
{
       int n;

       n = strlen(s);
       if(n > r->ifcall.count)
               n = r->ifcall.count;
       memmove(r->ofcall.data, s, n);
       r->ofcall.count = n;
       fss->pending = 0;
       respond(r, nil);
       return;
}

void
retrpc(Req *r, int ret, Fsstate *fss)
{
       switch(ret){
       default:
               snprint(fss->rpc.buf, Maxrpc, "internal error %d", ret);
               retstring(r, fss, fss->rpc.buf);
               return;
       case RpcErrstr:
               snprint(fss->rpc.buf, Maxrpc, "error %r");
               retstring(r, fss, fss->rpc.buf);
               return;
       case RpcFailure:
               snprint(fss->rpc.buf, Maxrpc, "error %s", fss->err);
               retstring(r, fss, fss->rpc.buf);
               return;
       case RpcNeedkey:
               if(needkeyqueue(r, fss) < 0){
                       snprint(fss->rpc.buf, Maxrpc, "needkey %s", fss->keyinfo);
                       retstring(r, fss, fss->rpc.buf);
               }
               return;
       case RpcOk:
               retstring(r, fss, "ok");
               return;
       case RpcToosmall:
               snprint(fss->rpc.buf, Maxrpc, "toosmall %d", fss->rpc.nwant);
               retstring(r, fss, fss->rpc.buf);
               return;
       case RpcPhase:
               snprint(fss->rpc.buf, Maxrpc, "phase %r");
               retstring(r, fss, fss->rpc.buf);
               return;
       case RpcConfirm:
               confirmqueue(r, fss);
               return;
       }
}

int
rdwrcheck(Req *r, Fsstate *fss)
{
       if(fss->ps == nil){
               retstring(r, fss, "error no current protocol");
               return -1;
       }
       if(fss->phase == Notstarted){
               retstring(r, fss, "protocol not started");
               return -1;
       }
       if(fss->phase == Broken){
               snprint(fss->rpc.buf, Maxrpc, "error %s", fss->err);
               retstring(r, fss, fss->rpc.buf);
               return -1;
       }
       if(fss->phase == Established){
               if(fss->haveai)
                       retstring(r, fss, "done haveai");
               else
                       retstring(r, fss, "done");
               return -1;
       }
       return 0;
}

static void
logret(char *pre, Fsstate *fss, int ret)
{
       switch(ret){
       default:
               flog("%s: code %d", pre, ret);
               break;
       case RpcErrstr:
               flog("%s: error %r", pre);
               break;
       case RpcFailure:
               flog("%s: failure %s", pre, fss->err);
               break;
       case RpcNeedkey:
               flog("%s: needkey %s", pre, fss->keyinfo);
               break;
       case RpcOk:
               flog("%s: ok", pre);
               break;
       case RpcToosmall:
               flog("%s: toosmall %d", pre, fss->rpc.nwant);
               break;
       case RpcPhase:
               flog("%s: phase: %r", pre);
               break;
       case RpcConfirm:
               flog("%s: waiting for confirm", pre);
               break;
       }
}

void
rpcrdwrlog(Fsstate *fss, char *rdwr, uint n, int ophase, int ret)
{
       char buf0[40], buf1[40], pre[300];

       if(!debug)
               return;
       snprint(pre, sizeof pre, "%d: %s %ud in phase %s yields phase %s",
               fss->seqnum, rdwr, n, phasename(fss, ophase, buf0), phasename(fss, fss->phase, buf1));
       logret(pre, fss, ret);
}

void
rpcstartlog(Attr *attr, Fsstate *fss, int ret)
{
       char pre[300], tmp[40];

       if(!debug)
               return;
       snprint(pre, sizeof pre, "%d: start %A yields phase %s", fss->seqnum,
               attr, phasename(fss, fss->phase, tmp));
       logret(pre, fss, ret);
}

int seqnum;

void
rpcread(Req *r)
{
       Attr *attr;
       char *p;
       int ophase, ret;
       uchar *e;
       uint count;
       Fsstate *fss;
       Proto *proto;

       if(r->ifcall.count < 64){
               respond(r, "rpc read too small");
               return;
       }
       fss = r->fid->aux;
       if(!fss->pending){
               respond(r, "no rpc pending");
               return;
       }
       switch(fss->rpc.iverb){
       default:
       case Vunknown:
               retstring(r, fss, "error unknown verb");
               break;

       case Vstart:
               if(fss->phase != Notstarted){
                       flog("%d: implicit close due to second start; old attr '%A'", fss->seqnum, fss->attr);
                       if(fss->proto && fss->ps)
                               (*fss->proto->close)(fss);
                       fss->ps = nil;
                       fss->proto = nil;
                       _freeattr(fss->attr);
                       fss->attr = nil;
                       fss->phase = Notstarted;
               }
               attr = _parseattr(fss->rpc.arg);
               if((p = _strfindattr(attr, "proto")) == nil){
                       retstring(r, fss, "error did not specify proto");
                       _freeattr(attr);
                       break;
               }
               if((proto = findproto(p)) == nil){
                       snprint(fss->rpc.buf, Maxrpc, "error unknown protocol %q", p);
                       retstring(r, fss, fss->rpc.buf);
                       _freeattr(attr);
                       break;
               }
               fss->attr = attr;
               fss->proto = proto;
               fss->seqnum = ++seqnum;
               ret = (*proto->init)(proto, fss);
               rpcstartlog(attr, fss, ret);
               if(ret != RpcOk){
                       _freeattr(fss->attr);
                       fss->attr = nil;
                       fss->phase = Notstarted;
               }
               retrpc(r, ret, fss);
               break;

       case Vread:
               if(fss->rpc.arg && fss->rpc.arg[0]){
                       retstring(r, fss, "error read needs no parameters");
                       break;
               }
               if(rdwrcheck(r, fss) < 0)
                       break;
               count = r->ifcall.count - 3;
               ophase = fss->phase;
               ret = fss->proto->read(fss, (uchar*)r->ofcall.data+3, &count);
               rpcrdwrlog(fss, "read", count, ophase, ret);
               if(ret == RpcOk){
                       memmove(r->ofcall.data, "ok ", 3);
                       if(count == 0)
                               r->ofcall.count = 2;
                       else
                               r->ofcall.count = 3+count;
                       fss->pending = 0;
                       respond(r, nil);
               }else
                       retrpc(r, ret, fss);
               break;

       case Vwrite:
               if(rdwrcheck(r, fss) < 0)
                       break;
               ophase = fss->phase;
               ret = fss->proto->write(fss, fss->rpc.arg, fss->rpc.narg);
               rpcrdwrlog(fss, "write", fss->rpc.narg, ophase, ret);
               retrpc(r, ret, fss);
               break;

       case Vauthinfo:
               if(fss->phase != Established){
                       retstring(r, fss, "error authentication unfinished");
                       break;
               }
               if(!fss->haveai){
                       retstring(r, fss, "error no authinfo available");
                       break;
               }
               memmove(r->ofcall.data, "ok ", 3);
               fss->ai.cap = mkcap(r->fid->uid, fss->ai.suid);
               e = convAI2M(&fss->ai, (uchar*)r->ofcall.data+3, r->ifcall.count-3);
               free(fss->ai.cap);
               fss->ai.cap = nil;
               if(e == nil){
                       retstring(r, fss, "error read too small");
                       break;
               }
               r->ofcall.count = e - (uchar*)r->ofcall.data;
               fss->pending = 0;
               respond(r, nil);
               break;

       case Vattr:
               snprint(fss->rpc.buf, Maxrpc, "ok %A", fss->attr);
               retstring(r, fss, fss->rpc.buf);
               break;
       }
}

enum {
       Vdelkey,
       Vaddkey,
       Vdebug,
};

Verb ctltab[] = {
       "delkey",               Vdelkey,
       "key",          Vaddkey,
       "debug",        Vdebug,
};

/*
*      key attr=val... - add a key
*              the attr=val pairs are protocol-specific.
*              for example, both of these are valid:
*                      key p9sk1 gre cs.bell-labs.com mysecret
*                      key p9sk1 gre cs.bell-labs.com 11223344556677 fmt=des7hex
*      delkey ... - delete a key
*              if given, the attr=val pairs are used to narrow the search
*              [maybe should require a password?]
*/

int
ctlwrite(char *a, int atzero)
{
       char *p;
       int i, nmatch, ret;
       Attr *attr, **l, **lpriv, **lprotos, *pa, *priv, *protos;
       Key *k;
       Proto *proto;

       if(a[0] == '#' || a[0] == '\0')
               return 0;

       /*
        * it would be nice to emit a warning of some sort here.
        * we ignore all but the first line of the write.  this helps
        * both with things like "echo delkey >/mnt/factotum/ctl"
        * and writes that (incorrectly) contain multiple key lines.
        */
       if(p = strchr(a, '\n')){
               if(p[1] != '\0'){
                       werrstr("multiline write not allowed");
                       return -1;
               }
               *p = '\0';
       }

       if((p = strchr(a, ' ')) == nil)
               p = "";
       else
               *p++ = '\0';
       switch(classify(a, ctltab, nelem(ctltab))){
       default:
       case Vunknown:
               werrstr("unknown verb");
               return -1;
       case Vdebug:
               debug ^= 1;
               return 0;
       case Vdelkey:
               nmatch = 0;
               attr = _parseattr(p);
               for(pa=attr; pa; pa=pa->next){
                       if(pa->type != AttrQuery && pa->name[0]=='!'){
                               werrstr("only !private? patterns are allowed for private fields");
                               _freeattr(attr);
                               return -1;
                       }
               }
       Again:
               qlock(ring);
               for(i=0; i<ring->nkey; i++){
                       k = ring->key[i];
                       if(matchattr(attr, k->attr, k->privattr)){
                               nmatch++;
                               ring->nkey--;
                               memmove(&ring->key[i], &ring->key[i+1], (ring->nkey-i)*sizeof(ring->key[0]));
                               qunlock(ring);
                               closekey(k);
                               goto Again;
                       }
               }
               qunlock(ring);
               _freeattr(attr);
               if(nmatch == 0){
                       werrstr("found no keys to delete");
                       return -1;
               }
               return 0;
       case Vaddkey:
               attr = _parseattr(p);
               /* separate out proto= attributes */
               lprotos = &protos;
               for(l=&attr; (*l); ){
                       if(strcmp((*l)->name, "proto") == 0){
                               *lprotos = *l;
                               lprotos = &(*l)->next;
                               *l = (*l)->next;
                       }else
                               l = &(*l)->next;
               }
               *lprotos = nil;
               if(protos == nil){
                       werrstr("key without protos");
                       _freeattr(attr);
                       return -1;
               }

               /* separate out private attributes */
               lpriv = &priv;
               for(l=&attr; (*l); ){
                       if((*l)->name[0] == '!'){
                               *lpriv = *l;
                               lpriv = &(*l)->next;
                               *l = (*l)->next;
                       }else
                               l = &(*l)->next;
               }
               *lpriv = nil;

               /* add keys */
               ret = 0;
               for(pa=protos; pa; pa=pa->next){
                       if((proto = findproto(pa->val)) == nil){
                               werrstr("unknown proto %s", pa->val);
                               ret = -1;
                               continue;
                       }
                       if(proto->addkey == nil){
                               werrstr("proto %s doesn't take keys", proto->name);
                               ret = -1;
                               continue;
                       }
                       k = emalloc(sizeof(Key));
                       k->attr = _mkattr(AttrNameval, "proto", proto->name, _copyattr(attr));
                       k->privattr = _copyattr(priv);
                       k->ref = 1;
                       k->proto = proto;
                       if(proto->addkey(k, atzero) < 0){
                               ret = -1;
                               closekey(k);
                               continue;
                       }
                       closekey(k);
               }
               _freeattr(attr);
               _freeattr(priv);
               _freeattr(protos);
               return ret;
       }
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.