Subversion Repositories planix.SVN

/* contributed by 20h@r-36.net, September 2005 */

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ndb.h>
#include <thread.h>
#include <fcall.h>
#include <9p.h>
#include <mp.h>
#include <libsec.h>

enum
{
        Blocksize = 64*1024,
        Stacksize = 8192,
};

char *host;
char *file;
char *port;
char *url;
char *get;
char *user;
char *net = "net";

vlong size;
int usetls;
int debug;
int ncache;
int mcache;

void
usage(void)
{
        fprint(2, "usage: httpfile [-Dd] [-c count] [-f file] [-m mtpt] [-s srvname] [-x net] url\n");
        exits("usage");
}

enum
{
        Qroot,
        Qfile,
};

#define PATH(type, n)           ((type)|((n)<<8))
#define TYPE(path)                      ((int)(path) & 0xFF)
#define NUM(path)                       ((uint)(path)>>8)

Channel *reqchan;
Channel *httpchan;
Channel *finishchan;
ulong time0;

typedef struct Block Block;
struct Block
{
        uchar *p;
        vlong off;
        vlong len;
        Block *link;
        long lastuse;
        Req *rq;
        Req **erq;
};

typedef struct Blocklist Blocklist;
struct Blocklist
{
        Block *first;
        Block **end;
};

Blocklist cache;
Blocklist inprogress;

void
queuereq(Block *b, Req *r)
{
        if(b->rq==nil)
                b->erq = &b->rq;
        *b->erq = r;
        r->aux = nil;
        b->erq = (Req**)&r->aux;
}

void
addblock(Blocklist *l, Block *b)
{
        if(debug)
                print("adding: %p %lld\n", b, b->off);

        if(l->first == nil)
                l->end = &l->first;
        *l->end = b;
        b->link = nil;
        l->end = &b->link;
        b->lastuse = time(0);
}

void
delreq(Block *b, Req *r)
{
        Req **l;

        for(l = &b->rq; *l; l = (Req**)&(*l)->aux){
                if(*l == r){
                        *l = r->aux;
                        if(*l == nil)
                                b->erq = l;
                        free(r);
                        return;
                }
        }
}

void
evictblock(Blocklist *cache)
{
        Block **l, **oldest, *b;

        if(cache->first == nil)
                return;

        oldest = nil;
        for(l=&cache->first; *l; l=&(*l)->link)
                if(oldest == nil || (*oldest)->lastuse > (*l)->lastuse)
                        oldest = l;

        b = *oldest;
        *oldest = (*oldest)->link;
        if(*oldest == nil)
                cache->end = oldest;
        free(b->p);
        free(b);
        ncache--;
}

Block *
findblock(Blocklist *s, vlong off)
{
        Block *b;

        for(b = s->first; b != nil; b = b->link){
                if(b->off <= off && off < b->off + Blocksize){
                        if(debug)
                                print("found: %lld -> %lld\n", off, b->off);
                        b->lastuse = time(0);
                        return b;
                }
        }

        return nil;
}

void
readfrom(Req *r, Block *b)
{
        int d, n;

        b->lastuse = time(0);

        n = r->ifcall.count;
        d = r->ifcall.offset - b->off;
        if(b->off + d + n > b->off + b->len)
                n = b->len - d;
        if(debug)
                print("Reading from: %p %d %d\n", b->p, d, n);
        memmove(r->ofcall.data, b->p + d, n);
        r->ofcall.count = n;

        respond(r, nil);
}

void
hangupclient(Srv*)
{
        if(debug)
                print("Hangup.\n");

        threadexitsall("done");
}

int
dotls(int fd)
{
        TLSconn conn;

        if((fd=tlsClient(fd, &conn)) < 0)
                sysfatal("tlsclient: %r");

        if(conn.cert != nil)
                free(conn.cert);

        return fd;
}

char*
nocr(char *s)
{
        char *r, *w;

        for(r=w=s; *r; r++)
                if(*r != '\r')
                        *w++ = *r;
        *w = 0;
        return s;
}

char*
readhttphdr(Biobuf *netbio, vlong *size)
{
        char *s, *stat;

        stat = nil;
        while((s = Brdstr(netbio, '\n', 1)) != nil && s[0] != '\r'
                        && s[0] != '\0'){
                if(stat == nil)
                        stat = estrdup9p(s);
                if(strncmp(s, "Content-Length: ", 16) == 0 && size != nil)
                        *size = atoll(s + 16);
                free(s);
        }
        if(stat)
                nocr(stat);

        return stat;
}

int
dialhttp(Biobuf *netbio)
{
        int netfd;

        netfd = dial(netmkaddr(host, net, port), 0, 0, 0);
        if(netfd < 0)
                sysfatal("dial: %r");
        if(usetls)
                netfd = dotls(netfd);
        Binit(netbio, netfd, OREAD);

        return netfd;
}

uchar*
getrange(Block *b)
{
        uchar *data;
        char *status;
        int netfd;
        static Biobuf netbio;

        b->len = Blocksize;
        if(b->off + b->len > size)
                b->len = size - b->off;

        if(debug)
                print("getrange: %lld %lld\n", b->off, b->len);

        netfd = dialhttp(&netbio);

        fprint(netfd, 
                "GET %s HTTP/1.1\r\n"
                "Host: %s\r\n"
                "Accept-Encoding:\r\n"
                "Range: bytes=%lld-%lld\r\n"
                "\r\n",
                get, host, b->off, b->off+b->len);
        Bflush(&netbio);

        status = readhttphdr(&netbio, nil);
        if(status == nil)
                return nil;

        /*
         * Some servers (e.g., www.google.com) return 200 OK
         * when you ask for the entire page in one range.
         */
        if(strstr(status, "206 Partial Content")==nil
        && (b->off!=0 || b->len!=size || strstr(status, "200 OK")==nil)){
                free(status);
                close(netfd);
                werrstr("did not get requested range");
                return nil;
        }
        free(status);

        data = emalloc9p(b->len);
        if(Bread(&netbio, data, b->len) != b->len){
                free(data);
                close(netfd);
                werrstr("not enough bytes read");
                return nil;
        }

        b->p = data;

        close(netfd);
        return data;
}

void
httpfilereadproc(void*)
{
        Block *b;

        threadsetname("httpfilereadproc");

        for(;;){
                b = recvp(httpchan);
                if(b == nil)
                        continue;
                if(getrange(b) == nil)
                        sysfatal("getrange: %r");
                sendp(finishchan, b);
        }
}

typedef struct Tab Tab;
struct Tab
{
        char *name;
        ulong mode;
};

Tab tab[] =
{
        "/",            DMDIR|0555,
        nil,            0444,
};

static void
fillstat(Dir *d, uvlong path)
{
        Tab *t;

        memset(d, 0, sizeof(*d));
        d->uid = estrdup9p(user);
        d->gid = estrdup9p(user);
        d->qid.path = path;
        d->atime = d->mtime = time0;
        t = &tab[TYPE(path)];
        d->name = estrdup9p(t->name);
        d->length = size;
        d->qid.type = t->mode>>24;
        d->mode = t->mode;
}

static void
fsattach(Req *r)
{
        if(r->ifcall.aname && r->ifcall.aname[0]){
                respond(r, "invalid attach specifier");
                return;
        }
        r->fid->qid.path = PATH(Qroot, 0);
        r->fid->qid.type = QTDIR;
        r->fid->qid.vers = 0;
        r->ofcall.qid = r->fid->qid;
        respond(r, nil);
}

static void
fsstat(Req *r)
{
        fillstat(&r->d, r->fid->qid.path);
        respond(r, nil);
}

static int
rootgen(int i, Dir *d, void*)
{
        i += Qroot + 1;
        if(i <= Qfile){
                fillstat(d, i);
                return 0;
        }
        return -1;
}

static char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
        int i;
        ulong path;

        path = fid->qid.path;
        if(!(fid->qid.type & QTDIR))
                return "walk in non-directory";

        if(strcmp(name, "..") == 0){
                switch(TYPE(path)){
                case Qroot:
                        return nil;
                default:
                        return "bug in fswalk1";
                }
        }

        i = TYPE(path) + 1;
        while(i < nelem(tab)){
                if(strcmp(name, tab[i].name) == 0){
                        qid->path = PATH(i, NUM(path));
                        qid->type = tab[i].mode>>24;
                        return nil;
                }
                if(tab[i].mode & DMDIR)
                        break;
                i++;
        }
        return "directory entry not found";
}

vlong
getfilesize(void)
{
        char *status;
        vlong size;
        int netfd;
        static Biobuf netbio;

        netfd = dialhttp(&netbio);

        fprint(netfd, 
                "HEAD %s HTTP/1.1\r\n"
                "Host: %s\r\n"
                "Accept-Encoding:\r\n"
                "\r\n",
                get, host);

        status = readhttphdr(&netbio, &size);
        if(strstr(status, "200 OK") == nil){
                werrstr("%s", status);
                size = -1;
        }
        free(status);

        close(netfd);
        return size;
}

void
fileread(Req *r)
{
        Block *b;

        if(r->ifcall.offset > size){
                respond(r, nil);
                return;
        }

        if((b = findblock(&cache, r->ifcall.offset)) != nil){
                readfrom(r, b);
                return;
        }
        if((b = findblock(&inprogress, r->ifcall.offset)) == nil){
                b = emalloc9p(sizeof(Block));
                b->off = r->ifcall.offset - (r->ifcall.offset % Blocksize);
                addblock(&inprogress, b);
                if(inprogress.first == b)
                        sendp(httpchan, b);
        }
        queuereq(b, r);
}

static void
fsopen(Req *r)
{
        if(r->ifcall.mode != OREAD){
                respond(r, "permission denied");
                return;
        }
        respond(r, nil);
}

void
finishthread(void*)
{
        Block *b;
        Req *r, *nextr;

        threadsetname("finishthread");

        for(;;){
                b = recvp(finishchan);
                assert(b == inprogress.first);
                inprogress.first = b->link;
                ncache++;
                if(ncache >= mcache)
                        evictblock(&cache);
                addblock(&cache, b);
                for(r=b->rq; r; r=nextr){
                        nextr = r->aux;
                        readfrom(r, b);
                }
                b->rq = nil;
                if(inprogress.first)
                        sendp(httpchan, inprogress.first);
        }
}

void
fsnetproc(void*)
{
        Req *r;
        Block *b;

        threadcreate(finishthread, nil, 8192);

        threadsetname("fsnetproc");

        for(;;){
                r = recvp(reqchan);
                switch(r->ifcall.type){
                case Tflush:
                        b = findblock(&inprogress, r->ifcall.offset);
                        delreq(b, r->oldreq);
                        respond(r->oldreq, "interrupted");
                        respond(r, nil);
                        break;
                case Tread:
                        fileread(r);
                        break;
                default:
                        respond(r, "bug in fsthread");
                        break;
                }
        }
}

static void
fsflush(Req *r)
{
        sendp(reqchan, r);
}

static void
fsread(Req *r)
{
        char e[ERRMAX];
        ulong path;

        path = r->fid->qid.path;
        switch(TYPE(path)){
        case Qroot:
                dirread9p(r, rootgen, nil);
                respond(r, nil);
                break;
        case Qfile:
                sendp(reqchan, r);
                break;
        default:
                snprint(e, sizeof(e), "bug in fsread path=%lux", path);
                respond(r, e);
                break;
        }
}

Srv fs = 
{
.attach=                fsattach,
.walk1=         fswalk1,
.open=          fsopen,
.read=          fsread,
.stat=          fsstat,
.flush=         fsflush,
.end=           hangupclient,
};

void
threadmain(int argc, char **argv)
{
        char *defport, *mtpt, *srvname, *p;

        mtpt = nil;
        srvname = nil;
        ARGBEGIN{
        case 'D':
                chatty9p++;
                break;
        case 'd':
                debug++;
                break;
        case 's':
                srvname = EARGF(usage());
                break;
        case 'm':
                mtpt = EARGF(usage());
                break;
        case 'c':
                mcache = atoi(EARGF(usage()));
                break;
        case 'f':
                file = EARGF(usage());
                break;
        case 'x':
                net = smprint("%s/net", EARGF(usage()));
                break;
        default:
                usage();
        }ARGEND;

        if(srvname == nil && mtpt == nil)
                mtpt = ".";

        if(argc < 1)
                usage();
        if(mcache <= 0)
                mcache = 32;

        time0 = time(0);
        host = url = estrdup9p(argv[0]);

        defport = nil;
        if(!cistrncmp(url, "https://", 8)){
                host += 8;
                usetls = 1;
                defport = "https";
        }else if(!cistrncmp(url, "http://", 7)){
                host += 7;
                defport = "http";
        }else
                sysfatal("unsupported url: %s", url);

        if((p = strchr(host, '/')) != nil){
                get = estrdup9p(p);
                *p = '\0';
        }else
                get = "/";

        port = strchr(host, ':');
        if(port != nil)
                *port++ = '\0';
        else
                port = defport;

        if(file == nil){
                file = strrchr(get, '/')+1;
                if(*file == 0)
                        file = "index";
        }

        tab[Qfile].name = file;
        user = getuser();
        size = getfilesize();
        if(size < 0)
                sysfatal("getfilesize: %r");

        reqchan = chancreate(sizeof(Req*), 0);
        httpchan = chancreate(sizeof(Block*), 0);
        finishchan = chancreate(sizeof(Block*), 0);

        procrfork(fsnetproc, nil, Stacksize, RFNAMEG|RFNOTEG);
        procrfork(httpfilereadproc, nil, Stacksize, RFNAMEG|RFNOTEG);

        threadpostmountsrv(&fs, srvname, mtpt, MBEFORE);
        threadexits(0);
}