ref: dfb4b522830edab8f3856289d326d6cf5e930644
dir: /sys/src/cmd/webfs/fs.c/
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include "dat.h"
#include "fns.h"
typedef struct Webfid Webfid;
typedef struct Client Client;
struct Client
{
Ref;
char request[16];
Url *baseurl;
Url *url;
Key *hdr;
int obody; /* body opend */
int cbody; /* body closed */
Buq *qbody;
};
struct Webfid
{
int level;
Client *client;
Key *key; /* copy for Qheader */
Buq *buq; /* reference for Qbody, Qpost */
};
enum {
Qroot,
Qrctl,
Qclone,
Qclient,
Qctl,
Qbody,
Qpost,
Qparsed,
Qurl,
Qurlschm,
Qurluser,
Qurlpass,
Qurlhost,
Qurlport,
Qurlpath,
Qurlqwry,
Qurlfrag,
Qheader,
};
static char *nametab[] = {
"/",
"ctl",
"clone",
nil,
"ctl",
"body",
"postbody",
"parsed",
"url",
"scheme",
"user",
"passwd",
"host",
"port",
"path",
"query",
"fragment",
nil,
};
static char *mtpt;
static char *service;
static long time0;
static char *user;
static char *agent;
static Client client[256];
static int nclient;
#define CLIENTID(c) ((int)(((Client*)(c)) - client))
Client*
newclient(void)
{
Client *cl;
int i;
for(i = 0; i < nclient; i++)
if(client[i].ref == 0)
break;
if(i >= nelem(client))
return nil;
if(i == nclient)
nclient++;
cl = &client[i];
incref(cl);
cl->request[0] = 0;
cl->baseurl = nil;
cl->url = nil;
cl->hdr = nil;
cl->qbody = nil;
return cl;
}
void
freeclient(Client *cl)
{
Key *k;
if(cl == nil || decref(cl))
return;
buclose(cl->qbody, 0);
bufree(cl->qbody);
while(k = cl->hdr){
cl->hdr = k->next;
free(k);
}
freeurl(cl->url);
freeurl(cl->baseurl);
memset(cl, 0, sizeof(*cl));
}
static Url*
clienturl(Client *cl)
{
static Url nullurl;
if(cl->qbody && cl->qbody->url)
return cl->qbody->url;
if(cl->url)
return cl->url;
return &nullurl;
}
static void*
wfaux(Webfid *f)
{
if(f->level < Qclient)
return nil;
else if(f->level < Qurl)
return f->client;
else if(f->level < Qheader)
return clienturl(f->client);
else
return f->key;
}
static void
fsmkqid(Qid *q, int level, void *aux)
{
q->type = 0;
q->vers = 0;
switch(level){
case Qroot:
case Qparsed:
case Qclient:
q->type = QTDIR;
default:
q->path = (level<<24) | (((uintptr)aux ^ time0) & 0x00ffffff);
}
}
static char*
fshdrname(char *s)
{
char *k, *w;
for(k=w=s; *k; k++)
if(isalnum(*k))
*w++ = tolower(*k);
*w = 0;
return s;
}
static int
urlstr(char *buf, int nbuf, Url *u, int level)
{
char *s;
if(level == Qurl)
return snprint(buf, nbuf, "%U", u);
if(level == Qurlpath)
return snprint(buf, nbuf, "%s", Upath(u));
if((s = (&u->scheme)[level - Qurlschm]) == nil){
buf[0] = 0;
return 0;
}
return snprint(buf, nbuf, "%s", s);
}
static void
fsmkdir(Dir *d, int level, void *aux)
{
char buf[1024];
memset(d, 0, sizeof(*d));
fsmkqid(&d->qid, level, aux);
d->mode = 0444;
d->atime = d->mtime = time0;
d->uid = estrdup(user);
d->gid = estrdup(user);
d->muid = estrdup(user);
if(d->qid.type & QTDIR)
d->mode |= DMDIR | 0111;
switch(level){
case Qheader:
d->name = fshdrname(estrdup(((Key*)aux)->key));
d->length = strlen(((Key*)aux)->val);
break;
case Qclient:
snprint(buf, sizeof(buf), "%d", CLIENTID(aux));
d->name = estrdup(buf);
break;
case Qctl:
case Qrctl:
case Qclone:
d->mode = 0666;
if(0){
case Qpost:
d->mode = 0222;
}
default:
d->name = estrdup(nametab[level]);
if(level >= Qurl && level <= Qurlfrag)
d->length = urlstr(buf, sizeof(buf), (Url*)aux, level);
}
}
static void
fsattach(Req *r)
{
Webfid *f;
if(r->ifcall.aname && r->ifcall.aname[0]){
respond(r, "invalid attach specifier");
return;
}
f = emalloc(sizeof(*f));
f->level = Qroot;
fsmkqid(&r->fid->qid, f->level, wfaux(f));
r->ofcall.qid = r->fid->qid;
r->fid->aux = f;
respond(r, nil);
}
static void
fsstat(Req *r)
{
Webfid *f;
f = r->fid->aux;
fsmkdir(&r->d, f->level, wfaux(f));
respond(r, nil);
}
static char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
Webfid *f;
int i, j;
if(!(fid->qid.type&QTDIR))
return "walk in non-directory";
f = fid->aux;
if(strcmp(name, "..") == 0){
switch(f->level){
case Qroot:
break;
case Qclient:
freeclient(f->client);
f->client = nil;
break;
default:
if(f->level > Qparsed)
f->level = Qparsed;
else
f->level = Qclient;
}
} else {
for(i=f->level+1; i < nelem(nametab); i++){
if(nametab[i]){
if(strcmp(name, nametab[i]) == 0)
break;
if(i == Qbody && strncmp(name, "body.", 5) == 0)
break;
}
if(i == Qclient){
j = atoi(name);
if(j >= 0 && j < nclient){
f->client = &client[j];
incref(f->client);
break;
}
}
if(i == Qheader && f->client && f->client->qbody){
char buf[128];
Key *k;
for(k = f->client->qbody->hdr; k; k = k->next){
nstrcpy(buf, k->key, sizeof(buf));
if(!strcmp(name, fshdrname(buf)))
break;
}
if(k != nil){
/* need to copy as key is owned by qbody wich might go away */
f->key = addkey(0, k->key, k->val);
break;
}
}
}
if(i >= nelem(nametab))
return "directory entry not found";
f->level = i;
}
fsmkqid(qid, f->level, wfaux(f));
fid->qid = *qid;
return nil;
}
static char*
fsclone(Fid *oldfid, Fid *newfid)
{
Webfid *f, *o;
o = oldfid->aux;
if(o == nil || o->key || o->buq)
return "bad fid";
f = emalloc(sizeof(*f));
memmove(f, o, sizeof(*f));
if(f->client)
incref(f->client);
newfid->aux = f;
return nil;
}
static void
fsopen(Req *r)
{
Webfid *f;
Client *cl;
f = r->fid->aux;
cl = f->client;
switch(f->level){
case Qclone:
if((cl = newclient()) == nil){
respond(r, "no more clients");
return;
}
f->level = Qctl;
f->client = cl;
fsmkqid(&r->fid->qid, f->level, wfaux(f));
r->ofcall.qid = r->fid->qid;
break;
case Qpost:
if(cl->qbody && !cl->cbody){
Inuse:
respond(r, "client in use");
return;
}
case Qbody:
if(cl->obody)
goto Inuse;
if(cl->cbody){
bufree(cl->qbody);
cl->qbody = nil;
cl->cbody = 0;
}
if(cl->qbody == nil){
char *m;
if(cl->url == nil){
respond(r, "no url set");
return;
}
cl->qbody = bualloc(16*1024);
if(f->level != Qbody){
f->buq = bualloc(64*1024);
if(!lookkey(cl->hdr, "Content-Type"))
cl->hdr = addkey(cl->hdr, "Content-Type",
"application/x-www-form-urlencoded");
m = "POST";
} else
m = "GET";
if(cl->request[0])
m = cl->request;
/*
* some sites give a 403 Forbidden if we dont include
* a meaningless Accept header in the request.
*/
if(!lookkey(cl->hdr, "Accept"))
cl->hdr = addkey(cl->hdr, "Accept", "*/*");
if(!lookkey(cl->hdr, "Connection"))
cl->hdr = addkey(cl->hdr, "Connection", "keep-alive");
if(agent && !lookkey(cl->hdr, "User-Agent"))
cl->hdr = addkey(cl->hdr, "User-Agent", agent);
http(m, cl->url, cl->hdr, cl->qbody, f->buq);
cl->request[0] = 0;
cl->url = nil;
cl->hdr = nil;
}
if(f->buq)
break;
cl->obody = 1;
incref(cl->qbody);
bureq(f->buq = cl->qbody, r);
return;
}
respond(r, nil);
}
static int
rootgen(int i, Dir *d, void *)
{
i += Qroot+1;
if(i < Qclient){
fsmkdir(d, i, 0);
return 0;
}
i -= Qclient;
if(i < nclient){
fsmkdir(d, Qclient, &client[i]);
return 0;
}
return -1;
}
static int
clientgen(int i, Dir *d, void *aux)
{
i += Qclient+1;
if(i > Qparsed){
Client *cl = aux;
Key *k;
i -= Qparsed+1;
if(cl == nil || cl->qbody == nil)
return -1;
for(k = cl->qbody->hdr; i > 0 && k; i--, k = k->next)
;
if(k == nil || i > 0)
return -1;
i = Qheader;
aux = k;
}
fsmkdir(d, i, aux);
return 0;
}
static int
parsedgen(int i, Dir *d, void *aux)
{
i += Qparsed+1;
if(i > Qurlfrag)
return -1;
fsmkdir(d, i, aux);
return 0;
}
static void
fsread(Req *r)
{
char buf[1024];
Webfid *f;
f = r->fid->aux;
switch(f->level){
case Qroot:
dirread9p(r, rootgen, nil);
respond(r, nil);
return;
case Qclient:
dirread9p(r, clientgen, f->client);
respond(r, nil);
return;
case Qparsed:
dirread9p(r, parsedgen, clienturl(f->client));
respond(r, nil);
return;
case Qrctl:
snprint(buf, sizeof(buf), "useragent %s\ntimeout %d\n", agent, timeout);
String:
readstr(r, buf);
respond(r, nil);
return;
case Qctl:
snprint(buf, sizeof(buf), "%d\n", CLIENTID(f->client));
goto String;
case Qheader:
snprint(buf, sizeof(buf), "%s", f->key->val);
goto String;
case Qurl:
case Qurlschm:
case Qurluser:
case Qurlpass:
case Qurlhost:
case Qurlport:
case Qurlpath:
case Qurlqwry:
case Qurlfrag:
urlstr(buf, sizeof(buf), clienturl(f->client), f->level);
goto String;
case Qbody:
bureq(f->buq, r);
return;
}
respond(r, "not implemented");
}
static char*
rootctl(Srv *fs, char *ctl, char *arg)
{
Url *u;
if(debug)
fprint(2, "rootctl: %q %q\n", ctl, arg);
if(!strcmp(ctl, "useragent")){
free(agent);
if(arg && *arg)
agent = estrdup(arg);
else
agent = nil;
return nil;
}
if(!strcmp(ctl, "flushauth")){
u = nil;
if(arg && *arg)
u = saneurl(url(arg, 0));
flushauth(u, 0);
freeurl(u);
return nil;
}
if(!strcmp(ctl, "timeout")){
if(arg && *arg)
timeout = atoi(arg);
else
timeout = 0;
if(timeout < 0)
timeout = 0;
return nil;
}
/* ppreemptive authentication only basic
* auth supported, ctl message of the form:
* preauth url realm
*/
if(!strcmp(ctl, "preauth")){
char *a[3], buf[256];
int rc;
if(tokenize(arg, a, nelem(a)) != 2)
return "preauth - bad field count";
if((u = saneurl(url(a[0], 0))) == nil)
return "preauth - malformed url";
snprint(buf, sizeof(buf), "BASIC realm=\"%s\"", a[1]);
srvrelease(fs);
rc = authenticate(u, u, "GET", buf);
srvacquire(fs);
freeurl(u);
if(rc == -1)
return "preauth failed";
return nil;
}
return "bad ctl message";
}
static char*
clientctl(Client *cl, char *ctl, char *arg)
{
char *p;
Url *u;
Key *k;
if(debug)
fprint(2, "clientctl: %q %q\n", ctl, arg);
if(!strcmp(ctl, "url")){
if((u = saneurl(url(arg, cl->baseurl))) == nil)
return "bad url";
freeurl(cl->url);
cl->url = u;
}
else if(!strcmp(ctl, "baseurl")){
if((u = url(arg, 0)) == nil)
return "bad baseurl";
freeurl(cl->baseurl);
cl->baseurl = u;
}
else if(!strcmp(ctl, "request")){
p = cl->request;
nstrcpy(p, arg, sizeof(cl->request));
for(; *p && isalpha(*p); p++)
*p = toupper(*p);
*p = 0;
}
else if(!strcmp(ctl, "headers")){
while(arg && *arg){
ctl = arg;
while(*ctl && strchr(whitespace, *ctl))
ctl++;
if(arg = strchr(ctl, '\n'))
*arg++ = 0;
if(k = parsehdr(ctl)){
k->next = cl->hdr;
cl->hdr = k;
}
}
}
else {
char buf[128], **t;
static char *tab[] = {
"User-Agent",
"Content-Type",
nil,
};
for(t = tab; *t; t++){
nstrcpy(buf, *t, sizeof(buf));
if(!strcmp(ctl, fshdrname(buf))){
cl->hdr = delkey(cl->hdr, *t);
if(arg && *arg)
cl->hdr = addkey(cl->hdr, *t, arg);
break;
}
}
if(*t == nil)
return "bad ctl message";
}
return nil;
}
static void
fswrite(Req *r)
{
int n;
Webfid *f;
char *s, *t;
f = r->fid->aux;
switch(f->level){
case Qrctl:
case Qctl:
n = r->ofcall.count = r->ifcall.count;
s = emalloc(n+1);
memmove(s, r->ifcall.data, n);
while(n > 0 && strchr("\r\n", s[n-1]))
n--;
s[n] = 0;
t = s;
while(*t && strchr(whitespace, *t)==0)
t++;
while(*t && strchr(whitespace, *t))
*t++ = 0;
if(f->level == Qctl)
t = clientctl(f->client, s, t);
else
t = rootctl(r->srv, s, t);
free(s);
respond(r, t);
return;
case Qpost:
bureq(f->buq, r);
return;
}
respond(r, "not implemented");
}
static void
fsflush(Req *r)
{
Webfid *f;
Req *o;
if(o = r->oldreq)
if(f = o->fid->aux)
buflushreq(f->buq, o);
respond(r, nil);
}
static void
fsdestroyfid(Fid *fid)
{
Webfid *f;
if(f = fid->aux){
fid->aux = nil;
if(f->buq){
buclose(f->buq, 0);
if(f->client->qbody == f->buq){
f->client->obody = 0;
f->client->cbody = 1;
}
bufree(f->buq);
}
if(f->key)
free(f->key);
freeclient(f->client);
free(f);
}
}
static void
fsstart(Srv*)
{
/* drop reference to old webfs mount */
if(mtpt != nil)
unmount(nil, mtpt);
}
static void
fsend(Srv*)
{
postnote(PNGROUP, getpid(), "shutdown");
exits(nil);
}
Srv fs =
{
.start=fsstart,
.attach=fsattach,
.stat=fsstat,
.walk1=fswalk1,
.clone=fsclone,
.open=fsopen,
.read=fsread,
.write=fswrite,
.flush=fsflush,
.destroyfid=fsdestroyfid,
.end=fsend,
};
void
usage(void)
{
fprint(2, "usage: %s [-Dd] [-A useragent] [-T timeout] [-m mtpt] [-s service]\n", argv0);
exits("usage");
}
void
main(int argc, char *argv[])
{
char *s;
quotefmtinstall();
fmtinstall('U', Ufmt);
fmtinstall('N', Nfmt);
fmtinstall(']', Mfmt);
fmtinstall('E', Efmt);
fmtinstall('[', encodefmt);
fmtinstall('H', encodefmt);
mtpt = "/mnt/web";
user = getuser();
time0 = time(0);
timeout = 10000;
ARGBEGIN {
case 'D':
chatty9p++;
break;
case 'A':
agent = EARGF(usage());
break;
case 'T':
timeout = atoi(EARGF(usage()));
if(timeout < 0)
timeout = 0;
break;
case 'm':
mtpt = EARGF(usage());
break;
case 's':
service = EARGF(usage());
break;
case 'd':
debug++;
break;
default:
usage();
} ARGEND;
rfork(RFNOTEG);
if(agent == nil)
agent = "Mozilla/5.0 (compatible; hjdicks)";
agent = estrdup(agent);
if(s = getenv("httpproxy")){
proxy = saneurl(url(s, 0));
if(proxy == nil || strcmp(proxy->scheme, "http") && strcmp(proxy->scheme, "https"))
sysfatal("invalid httpproxy url: %s", s);
free(s);
}
postmountsrv(&fs, service, mtpt, MREPL);
exits(nil);
}