199 lines
3.3 KiB
C
199 lines
3.3 KiB
C
#include <u.h>
|
|
#include <lib9.h>
|
|
#include <auth.h>
|
|
#include <9P2000.h>
|
|
#include <thread.h>
|
|
#include <9p.h>
|
|
|
|
typedef struct Afid Afid;
|
|
|
|
struct Afid
|
|
{
|
|
AuthRpc *rpc;
|
|
char *uname;
|
|
char *aname;
|
|
int authok;
|
|
int afd;
|
|
};
|
|
|
|
static uint64_t authgen = 1ULL<<63;
|
|
|
|
void
|
|
auth9p(Req *r)
|
|
{
|
|
char *spec;
|
|
Afid *afid;
|
|
|
|
afid = emalloc9p(sizeof(Afid));
|
|
afid->afd = sys_open("/mnt/factotum/rpc", ORDWR);
|
|
if(afid->afd < 0)
|
|
goto error;
|
|
|
|
if((afid->rpc = auth_allocrpc(afid->afd)) == nil)
|
|
goto error;
|
|
|
|
if(r->ifcall.uname[0] == 0)
|
|
goto error;
|
|
afid->uname = estrdup9p(r->ifcall.uname);
|
|
afid->aname = estrdup9p(r->ifcall.aname);
|
|
|
|
spec = r->srv->keyspec;
|
|
if(spec == nil)
|
|
spec = "proto=p9any role=server";
|
|
|
|
if(auth_rpc(afid->rpc, "start", spec, strlen(spec)) != ARok)
|
|
goto error;
|
|
|
|
r->afid->qid.type = QTAUTH;
|
|
r->afid->qid.path = ++authgen;
|
|
r->afid->qid.vers = 0;
|
|
r->afid->omode = ORDWR;
|
|
r->ofcall.qid = r->afid->qid;
|
|
r->afid->aux = afid;
|
|
respond(r, nil);
|
|
return;
|
|
|
|
error:
|
|
if(afid->rpc)
|
|
auth_freerpc(afid->rpc);
|
|
if(afid->uname)
|
|
free(afid->uname);
|
|
if(afid->aname)
|
|
free(afid->aname);
|
|
if(afid->afd >= 0)
|
|
sys_close(afid->afd);
|
|
free(afid);
|
|
responderror(r);
|
|
}
|
|
|
|
static int
|
|
_authread(Afid *afid, void *data, int count)
|
|
{
|
|
AuthInfo *ai;
|
|
|
|
switch(auth_rpc(afid->rpc, "read", nil, 0)){
|
|
case ARdone:
|
|
ai = auth_getinfo(afid->rpc);
|
|
if(ai == nil)
|
|
return -1;
|
|
auth_freeAI(ai);
|
|
if(chatty9p)
|
|
fprint(2, "authenticate %s/%s: ok\n", afid->uname, afid->aname);
|
|
afid->authok = 1;
|
|
return 0;
|
|
|
|
case ARok:
|
|
if(count < afid->rpc->narg){
|
|
werrstr("authread count too small");
|
|
return -1;
|
|
}
|
|
count = afid->rpc->narg;
|
|
memmove(data, afid->rpc->arg, count);
|
|
return count;
|
|
|
|
case ARphase:
|
|
default:
|
|
werrstr("authrpc botch");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void
|
|
authread(Req *r)
|
|
{
|
|
int n;
|
|
Afid *afid;
|
|
Fid *fid;
|
|
|
|
fid = r->fid;
|
|
afid = fid->aux;
|
|
if(afid == nil || r->fid->qid.type != QTAUTH){
|
|
respond(r, "not an auth fid");
|
|
return;
|
|
}
|
|
n = _authread(afid, r->ofcall.data, r->ifcall.count);
|
|
if(n < 0){
|
|
responderror(r);
|
|
return;
|
|
}
|
|
r->ofcall.count = n;
|
|
respond(r, nil);
|
|
}
|
|
|
|
void
|
|
authwrite(Req *r)
|
|
{
|
|
Afid *afid;
|
|
Fid *fid;
|
|
|
|
fid = r->fid;
|
|
afid = fid->aux;
|
|
if(afid == nil || r->fid->qid.type != QTAUTH){
|
|
respond(r, "not an auth fid");
|
|
return;
|
|
}
|
|
if(auth_rpc(afid->rpc, "write", r->ifcall.data, r->ifcall.count) != ARok){
|
|
responderror(r);
|
|
return;
|
|
}
|
|
r->ofcall.count = r->ifcall.count;
|
|
respond(r, nil);
|
|
}
|
|
|
|
void
|
|
authdestroy(Fid *fid)
|
|
{
|
|
Afid *afid;
|
|
|
|
if((fid->qid.type & QTAUTH) && (afid = fid->aux) != nil){
|
|
if(afid->rpc)
|
|
auth_freerpc(afid->rpc);
|
|
sys_close(afid->afd);
|
|
free(afid->uname);
|
|
free(afid->aname);
|
|
free(afid);
|
|
fid->aux = nil;
|
|
}
|
|
}
|
|
|
|
int
|
|
authattach(Req *r)
|
|
{
|
|
Afid *afid;
|
|
char buf[ERRMAX];
|
|
|
|
if(r->afid == nil){
|
|
respond(r, "not authenticated");
|
|
return -1;
|
|
}
|
|
|
|
afid = r->afid->aux;
|
|
if((r->afid->qid.type&QTAUTH) == 0 || afid == nil){
|
|
respond(r, "not an auth fid");
|
|
return -1;
|
|
}
|
|
|
|
if(!afid->authok){
|
|
if(_authread(afid, buf, 0) < 0){
|
|
responderror(r);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if(strcmp(afid->uname, r->ifcall.uname) != 0){
|
|
snprint(buf, sizeof buf, "auth uname mismatch: %s vs %s",
|
|
afid->uname, r->ifcall.uname);
|
|
respond(r, buf);
|
|
return -1;
|
|
}
|
|
|
|
if(strcmp(afid->aname, r->ifcall.aname) != 0){
|
|
snprint(buf, sizeof buf, "auth aname mismatch: %s vs %s",
|
|
afid->aname, r->ifcall.aname);
|
|
respond(r, buf);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|