#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <bio.h>
#include <ndb.h>
#include <thread.h>

/*
*  This fs presents a 1 level file system.  It contains
*  up to three files per console (xxx and xxxctl and xxxstat)
*/

typedef struct Console Console;
typedef struct Fid Fid;
typedef struct Request Request;
typedef struct Reqlist Reqlist;
typedef struct Fs Fs;

enum
{
       /* last 5 bits of qid.path */
       Textern=        0,              /* fake parent of top level */
       Ttopdir,                        /* top level directory */
       Qctl,
       Qstat,
       Qdata,

       Bufsize=        32*1024,        /* chars buffered per reader */
       Maxcons=        64,             /* maximum consoles */
       Nhash=          64,             /* Fid hash buckets */
};

#define TYPE(x)         (((ulong)x.path) & 0xf)
#define CONS(x)         ((((ulong)x.path) >> 4)&0xfff)
#define QID(c, x)       (((c)<<4) | (x))

struct Request
{
       Request *next;
       Fid     *fid;
       Fs      *fs;
       Fcall   f;
       uchar   buf[1];
};

struct Reqlist
{
       Lock;
       Request *first;
       Request *last;
};

struct Fid
{
       Lock;
       Fid     *next;                  /* hash list */
       Fid     *cnext;                 /* list of Fid's on a console */
       int     fid;
       int     ref;

       int     attached;
       int     open;
       char    *user;
       char    mbuf[Bufsize];          /* message */
       int     bufn;
       int     used;
       Qid     qid;

       Console *c;

       char    buf[Bufsize];
       char    *rp;
       char    *wp;

       Reqlist r;                      /* active read requests */
};

struct Console
{
       Lock;

       char    *name;
       char    *dev;
       int     speed;
       int     cronly;
       int     ondemand;               /* open only on demand */
       int     chat;                   /* chat consoles are special */

       int     pid;                    /* pid of reader */

       int     fd;
       int     cfd;
       int     sfd;

       Fid     *flist;                 /* open fids to broadcast to */
};

struct Fs
{
       Lock;

       int     fd;                     /* to kernel mount point */
       int     messagesize;
       Fid     *hash[Nhash];
       Console *cons[Maxcons];
       int     ncons;
};

extern  void    console(Fs*, char*, char*, int, int, int);
extern  Fs*     fsmount(char*);

extern  void    fsreader(void*);
extern  void    fsrun(void*);
extern  Fid*    fsgetfid(Fs*, int);
extern  void    fsputfid(Fs*, Fid*);
extern  int     fsdirgen(Fs*, Qid, int, Dir*, uchar*, int);
extern  void    fsreply(Fs*, Request*, char*);
extern  void    fskick(Fs*, Fid*);
extern  int     fsreopen(Fs*, Console*);

extern  void    fsversion(Fs*, Request*, Fid*);
extern  void    fsflush(Fs*, Request*, Fid*);
extern  void    fsauth(Fs*, Request*, Fid*);
extern  void    fsattach(Fs*, Request*, Fid*);
extern  void    fswalk(Fs*, Request*, Fid*);
extern  void    fsclwalk(Fs*, Request*, Fid*);
extern  void    fsopen(Fs*, Request*, Fid*);
extern  void    fscreate(Fs*, Request*, Fid*);
extern  void    fsread(Fs*, Request*, Fid*);
extern  void    fswrite(Fs*, Request*, Fid*);
extern  void    fsclunk(Fs*, Request*, Fid*);
extern  void    fsremove(Fs*, Request*, Fid*);
extern  void    fsstat(Fs*, Request*, Fid*);
extern  void    fswstat(Fs*, Request*, Fid*);


void    (*fcall[])(Fs*, Request*, Fid*) =
{
       [Tflush]        fsflush,
       [Tversion]      fsversion,
       [Tauth] fsauth,
       [Tattach]       fsattach,
       [Twalk]         fswalk,
       [Topen]         fsopen,
       [Tcreate]       fscreate,
       [Tread]         fsread,
       [Twrite]        fswrite,
       [Tclunk]        fsclunk,
       [Tremove]       fsremove,
       [Tstat]         fsstat,
       [Twstat]        fswstat
};

char Eperm[] = "permission denied";
char Eexist[] = "file does not exist";
char Enotdir[] = "not a directory";
char Eisopen[] = "file already open";
char Ebadcount[] = "bad read/write count";
char Enofid[] = "no such fid";

char *consoledb = "/lib/ndb/consoledb";
char *mntpt = "/mnt/consoles";

int messagesize = 8192+IOHDRSZ;

void
fatal(char *fmt, ...)
{
       va_list arg;
       char buf[1024];

       write(2, "consolefs: ", 10);
       va_start(arg, fmt);
       vseprint(buf, buf+1024, fmt, arg);
       va_end(arg);
       write(2, buf, strlen(buf));
       write(2, "\n", 1);
       threadexitsall(fmt);
}


void*
emalloc(uint n)
{
       void *p;

       p = malloc(n);
       if(p == nil)
               fatal("malloc failed: %r");
       memset(p, 0, n);
       return p;
}

int debug;
Ndb *db;

/*
*  any request that can get queued for a delayed reply
*/
Request*
allocreq(Fs *fs, int bufsize)
{
       Request *r;

       r = emalloc(sizeof(Request)+bufsize);
       r->fs = fs;
       r->next = nil;
       return r;
}

/*
*  for maintaining lists of requests
*/
void
addreq(Reqlist *l, Request *r)
{
       lock(l);
       if(l->first == nil)
               l->first = r;
       else
               l->last->next = r;
       l->last = r;
       r->next = nil;
       unlock(l);
}

/*
*  remove the first request from a list of requests
*/
Request*
remreq(Reqlist *l)
{
       Request *r;

       lock(l);
       r = l->first;
       if(r != nil)
               l->first = r->next;
       unlock(l);
       return r;
}

/*
*  remove a request with the given tag from a list of requests
*/
Request*
remtag(Reqlist *l, int tag)
{
       Request *or, **ll;

       lock(l);
       ll = &l->first;
       for(or = *ll; or; or = or->next){
               if(or->f.tag == tag){
                       *ll = or->next;
                       unlock(l);
                       return or;
               }
               ll = &or->next;
       }
       unlock(l);
       return nil;
}

Qid
parentqid(Qid q)
{
       if(q.type & QTDIR)
               return (Qid){QID(0, Textern), 0, QTDIR};
       else
               return (Qid){QID(0, Ttopdir), 0, QTDIR};
}

int
fsdirgen(Fs *fs, Qid parent, int i, Dir *d, uchar *buf, int nbuf)
{
       static char name[64];
       char *p;
       int xcons;

       d->uid = d->gid = d->muid = "network";
       d->length = 0;
       d->atime = time(nil);
       d->mtime = d->atime;
       d->type = 'C';
       d->dev = '0';

       switch(TYPE(parent)){
       case Textern:
               if(i != 0)
                       return -1;
               p = "consoles";
               d->mode = DMDIR|0555;
               d->qid.type = QTDIR;
               d->qid.path = QID(0, Ttopdir);
               d->qid.vers = 0;
               break;
       case Ttopdir:
               xcons = i/3;
               if(xcons >= fs->ncons)
                       return -1;
               p = fs->cons[xcons]->name;
               switch(i%3){
               case 0:
                       if(fs->cons[xcons]->cfd < 0)
                               return 0;
                       snprint(name, sizeof name, "%sctl", p);
                       p = name;
                       d->qid.type = QTFILE;
                       d->qid.path = QID(xcons, Qctl);
                       d->qid.vers = 0;
                       break;
               case 1:
                       if(fs->cons[xcons]->sfd < 0)
                               return 0;
                       snprint(name, sizeof name, "%sstat", p);
                       p = name;
                       d->qid.type = QTFILE;
                       d->qid.path = QID(xcons, Qstat);
                       d->qid.vers = 0;
                       break;
               case 2:
                       d->qid.type = QTFILE;
                       d->qid.path = QID(xcons, Qdata);
                       d->qid.vers = 0;
                       break;
               }
               d->mode = 0666;
               break;
       default:
               return -1;
       }
       d->name = p;
       if(buf != nil)
               return convD2M(d, buf, nbuf);
       return 1;
}

/*
*  mount the user interface and start a request processor
*/
Fs*
fsmount(char *mntpt)
{
       Fs *fs;
       int pfd[2], srv;
       char buf[32];
       int n;
       static void *v[2];

       fs = emalloc(sizeof(Fs));

       if(pipe(pfd) < 0)
               fatal("opening pipe: %r");

       /* start up the file system process */
       v[0] = fs;
       v[1] = pfd;
       proccreate(fsrun, v, 16*1024);

       /* Typically mounted before /srv exists */
       if(access("#s/consoles", AEXIST) < 0){
               srv = create("#s/consoles", OWRITE, 0666);
               if(srv < 0)
                       fatal("post: %r");

               n = sprint(buf, "%d", pfd[1]);
               if(write(srv, buf, n) < 0)
                       fatal("write srv: %r");

               close(srv);
       }

       mount(pfd[1], -1, mntpt, MBEFORE, "");
       close(pfd[1]);
       return fs;
}

/*
*  reopen a console
*/
int
fsreopen(Fs* fs, Console *c)
{
       char buf[128];
       static void *v[2];

       if(c->pid){
               if(postnote(PNPROC, c->pid, "reopen") != 0)
                       fprint(2, "postnote failed: %r\n");
               c->pid = 0;
       }

       if(c->fd >= 0){
               close(c->fd);
               close(c->cfd);
               close(c->sfd);
               c->cfd = -1;
               c->fd = -1;
               c->sfd = -1;
       }

       if(c->flist == nil && c->ondemand)
               return 0;

       c->fd = open(c->dev, ORDWR);
       if(c->fd < 0)
               return -1;

       snprint(buf, sizeof(buf), "%sctl", c->dev);
       c->cfd = open(buf, ORDWR);
       fprint(c->cfd, "b%d", c->speed);

       snprint(buf, sizeof(buf), "%sstat", c->dev);
       c->sfd = open(buf, OREAD);

       v[0] = fs;
       v[1] = c;
       proccreate(fsreader, v, 16*1024);

       return 0;
}

void
change(Fs *fs, Console *c, int doreopen, int speed, int cronly, int ondemand)
{
       lock(c);

       if(speed != c->speed){
               c->speed = speed;
               doreopen = 1;
       }
       if(ondemand != c->ondemand){
               c->ondemand = ondemand;
               doreopen = 1;
       }
       c->cronly = cronly;
       if(doreopen)
               fsreopen(fs, c);

       unlock(c);
}

/*
*  create a console interface
*/
void
console(Fs* fs, char *name, char *dev, int speed, int cronly, int ondemand)
{
       Console *c;
       char *x;
       int i, doreopen;

       if(fs->ncons >= Maxcons)
               fatal("too many consoles, too little time");

       doreopen = 0;
       for(i = 0; i < fs->ncons; i++){
               c = fs->cons[i];
               if(strcmp(name, c->name) == 0){
                       if(strcmp(dev, c->dev) != 0){
                               /* new device */
                               x = c->dev;
                               c->dev = strdup(dev);
                               free(x);
                               doreopen = 1;
                       }
                       change(fs, c, doreopen, speed, cronly, ondemand);
                       return;
               }
       }
#ifdef sapedoesntlikethis
       /*
        * The code below prevents this from working.  I can't
        * think of scenarios where the code below actually helps
        *      Sape
        *
        * console=borneo dev=/dev/eia1
        *      speed=9600
        *      openondemand=1
        * console=tottie dev=/dev/eia1
        *      speed=115200
        *      openondemand=1
        */
       for(i = 0; i < fs->ncons; i++){
               c = fs->cons[i];
               if(strcmp(dev, c->dev) == 0){
                       /* at least a rename */
                       x = c->name;
                       c->name = strdup(name);
                       free(x);
                       change(fs, c, doreopen, speed, cronly, ondemand);
                       return;
               }
       }
#endif
       c = emalloc(sizeof(Console));
       fs->cons[fs->ncons] = c;
       fs->ncons++;
       c->name = strdup(name);
       c->dev = strdup(dev);
       if(strcmp(c->dev, "/dev/null") == 0)
               c->chat = 1;
       else
               c->chat = 0;
       c->fd = -1;
       c->cfd = -1;
       c->sfd = -1;
       change(fs, c, 1, speed, cronly, ondemand);
}

/*
*  buffer data from console to a client.
*  circular q with writer able to catch up to reader.
*  the reader may miss data but always sees an in order sequence.
*/
void
fromconsole(Fid *f, char *p, int n)
{
       char *rp, *wp, *ep;
       int pass;

       lock(f);
       rp = f->rp;
       wp = f->wp;
       ep = f->buf + sizeof(f->buf);
       pass = 0;
       while(n--){
               *wp++ = *p++;
               if(wp >= ep)
                       wp = f->buf;
               if(rp == wp)
                       pass = 1;
       }
       f->wp = wp;

       /*  we overtook the read pointer, push it up so readers always
        *  see the tail of what was written
        */
       if(pass){
               wp++;
               if(wp >= ep)
                       f->rp = f->buf;
               else
                       f->rp = wp;
       }
       unlock(f);
}

/*
*  broadcast a list of members to all listeners
*/
void
bcastmembers(Fs *fs, Console *c, char *msg, Fid *f)
{
       int n;
       Fid *fl;
       char buf[512];

       sprint(buf, "[%s%s", msg, f->user);
       for(fl = c->flist; fl != nil && strlen(buf) + 64 < sizeof(buf); fl = fl->cnext){
               if(f == fl)
                       continue;
               strcat(buf, ", ");
               strcat(buf, fl->user);
       }
       strcat(buf, "]\n");

       n = strlen(buf);
       for(fl = c->flist; fl; fl = fl->cnext){
               fromconsole(fl, buf, n);
               fskick(fs, fl);
       }
}

void
handler(void*, char *msg)
{
       if(strstr(msg, "reopen") != nil ||
          strstr(msg, "write on closed pipe") != nil)
               noted(NCONT);
       noted(NDFLT);
}

/*
*  a process to read console output and broadcast it (one per console)
*/
void
fsreader(void *v)
{
       int n;
       Fid *fl;
       char buf[1024];
       Fs *fs;
       Console *c;
       void **a;

       a = v;
       fs = a[0];
       c = a[1];
       c->pid = getpid();
       notify(handler);
       if(c->chat)
               threadexits(nil);
       for(;;){
               n = read(c->fd, buf, sizeof(buf));
               if(n < 0)
                       break;
               lock(c);
               for(fl = c->flist; fl; fl = fl->cnext){
                       fromconsole(fl, buf, n);
                       fskick(fs, fl);
               }
               unlock(c);
       }
}

void
readdb(Fs *fs)
{
       Ndbtuple *t, *nt;
       char *dev, *cons;
       int cronly, speed, ondemand;

       ndbreopen(db);

       /* start a listener for each console */
       for(;;){
               t = ndbparse(db);
               if(t == nil)
                       break;
               dev = nil;
               cons = nil;
               speed = 9600;
               cronly = 0;
               ondemand = 0;
               for(nt = t; nt; nt = nt->entry){
                       if(strcmp(nt->attr, "console") == 0)
                               cons = nt->val;
                       else if(strcmp(nt->attr, "dev") == 0)
                               dev = nt->val;
                       else if(strcmp(nt->attr, "speed") == 0)
                               speed = atoi(nt->val);
                       else if(strcmp(nt->attr, "cronly") == 0)
                               cronly = 1;
                       else if(strcmp(nt->attr, "openondemand") == 0)
                               ondemand = 1;
               }
               if(dev != nil && cons != nil)
                       console(fs, cons, dev, speed, cronly, ondemand);
               ndbfree(t);
       }
}

int dbmtime;

/*
*  a request processor (one per Fs)
*/
void
fsrun(void *v)
{
       int n, t;
       Request *r;
       Fid *f;
       Dir *d;
       void **a = v;
       Fs* fs;
       int *pfd;

       fs = a[0];
       pfd = a[1];
       fs->fd = pfd[0];
       notify(handler);
       for(;;){
               d = dirstat(consoledb);
               if(d != nil && d->mtime != dbmtime){
                       dbmtime = d->mtime;
                       readdb(fs);
               }
               free(d);
               r = allocreq(fs, messagesize);
               n = read9pmsg(fs->fd, r->buf, messagesize);
               if(n == 0)
                       threadexitsall("unmounted");
               if(n < 0)
                       fatal("mount read: %r");
               if(convM2S(r->buf, n, &r->f) != n)
                       fatal("convM2S format error: %r");

               f = fsgetfid(fs, r->f.fid);
               r->fid = f;
               if(debug)
                       fprint(2, "%F path %llux\n", &r->f, f->qid.path);

               t = r->f.type;
               r->f.type++;
               (*fcall[t])(fs, r, f);
       }
}

Fid*
fsgetfid(Fs *fs, int fid)
{
       Fid *f, *nf;

       lock(fs);
       for(f = fs->hash[fid%Nhash]; f; f = f->next){
               if(f->fid == fid){
                       f->ref++;
                       unlock(fs);
                       return f;
               }
       }

       nf = emalloc(sizeof(Fid));
       nf->next = fs->hash[fid%Nhash];
       fs->hash[fid%Nhash] = nf;
       nf->fid = fid;
       nf->ref = 1;
       nf->wp = nf->buf;
       nf->rp = nf->wp;
       unlock(fs);
       return nf;
}

void
fsputfid(Fs *fs, Fid *f)
{
       Fid **l, *nf;

       lock(fs);
       if(--f->ref > 0){
               unlock(fs);
               return;
       }
       for(l = &fs->hash[f->fid%Nhash]; nf = *l; l = &nf->next)
               if(nf == f){
                       *l = f->next;
                       break;
               }
       unlock(fs);
       free(f->user);
       free(f);
}

void
fsauth(Fs *fs, Request *r, Fid*)
{
       fsreply(fs, r, "consolefs: authentication not required");
}

void
fsversion(Fs *fs, Request *r, Fid*)
{

       if(r->f.msize < 256){
               fsreply(fs, r, "message size too small");
               return;
       }
       messagesize = r->f.msize;
       if(messagesize > 8192+IOHDRSZ)
               messagesize = 8192+IOHDRSZ;
       r->f.msize = messagesize;
       if(strncmp(r->f.version, "9P2000", 6) != 0){
               fsreply(fs, r, "unrecognized 9P version");
               return;
       }
       r->f.version = "9P2000";

       fsreply(fs, r, nil);
}

void
fsflush(Fs *fs, Request *r, Fid *f)
{
       Request *or;

       or = remtag(&f->r, r->f.oldtag);
       if(or != nil){
               fsputfid(fs, or->fid);
               free(or);
       }
       fsreply(fs, r, nil);
}

void
fsattach(Fs *fs, Request *r, Fid *f)
{
       f->qid.type = QTDIR;
       f->qid.path = QID(0, Ttopdir);
       f->qid.vers = 0;

       if(r->f.uname[0])
               f->user = strdup(r->f.uname);
       else
               f->user = strdup("none");

       /* hold down the fid till the clunk */
       f->attached = 1;
       lock(fs);
       f->ref++;
       unlock(fs);

       r->f.qid = f->qid;
       fsreply(fs, r, nil);
}

void
fswalk(Fs *fs, Request *r, Fid *f)
{
       char *name;
       Dir d;
       int i, n, nqid, nwname;
       Qid qid, wqid[MAXWELEM];
       Fid *nf;
       char *err;

       if(f->attached == 0){
               fsreply(fs, r, Enofid);
               return;
       }

       nf = nil;
       if(r->f.fid != r->f.newfid){
               nf = fsgetfid(fs, r->f.newfid);
               nf->attached = f->attached;
               nf->open = f->open;
               nf->qid = f->qid;
               nf->user = strdup(f->user);
               nf->c = f->c;
               nf->wp = nf->buf;
               nf->rp = nf->wp;
               f = nf;
       }

       qid = f->qid;
       err = nil;
       nwname = r->f.nwname;
       nqid = 0;
       if(nwname > 0){
               for(; err == nil && nqid < nwname; nqid++){
                       if(nqid >= MAXWELEM){
                               err = "too many name elements";
                               break;
                       }
                       name = r->f.wname[nqid];
                       if(strcmp(name, "..") == 0)
                               qid = parentqid(qid);
                       else if(strcmp(name, ".") != 0){
                               for(i = 0; ; i++){
                                       n = fsdirgen(fs, qid, i, &d, nil, 0);
                                       if(n < 0){
                                               err = Eexist;
                                               break;
                                       }
                                       if(n > 0 && strcmp(name, d.name) == 0){
                                               qid = d.qid;
                                               break;
                                       }
                               }
                       }
                       wqid[nqid] = qid;
               }
               if(nf != nil && nqid < nwname)
                       fsputfid(fs, nf);
               if(nqid == nwname)
                       f->qid = qid;
       }

       memmove(r->f.wqid, wqid, nqid*sizeof(Qid));
       r->f.nwqid = nqid;
       fsreply(fs, r, err);
}

int
ingroup(char *user, char *group)
{
       Ndbtuple *t, *nt;
       Ndbs s;

       t = ndbsearch(db, &s, "group", group);
       if(t == nil)
               return 0;
       for(nt = t; nt; nt = nt->entry){
               if(strcmp(nt->attr, "uid") == 0)
               if(strcmp(nt->val, user) == 0)
                       break;
       }
       ndbfree(t);
       return nt != nil;
}

int
userok(char *u, char *cname)
{
       Ndbtuple *t, *nt;
       Ndbs s;

       t = ndbsearch(db, &s, "console", cname);
       if(t == nil)
               return 0;

       for(nt = t; nt; nt = nt->entry){
               if(strcmp(nt->attr, "uid") == 0)
               if(strcmp(nt->val, u) == 0)
                       break;
               if(strcmp(nt->attr, "gid") == 0)
               if(ingroup(u, nt->val))
                       break;
       }
       ndbfree(t);

       return nt != nil;
}

int m2p[] ={
       [OREAD]         4,
       [OWRITE]        2,
       [ORDWR]         6
};

/*
*  broadcast a message to all listeners
*/
void
bcastmsg(Fs *fs, Console *c, char *msg, int n)
{
       Fid *fl;

       for(fl = c->flist; fl; fl = fl->cnext){
               fromconsole(fl, msg, n);
               fskick(fs, fl);
       }
}

void
fsopen(Fs *fs, Request *r, Fid *f)
{
       int mode;
       Console *c;

       if(f->attached == 0){
               fsreply(fs, r, Enofid);
               return;
       }

       if(f->open){
               fsreply(fs, r, Eisopen);
               return;
       }

       mode = r->f.mode & 3;

       if((QTDIR & f->qid.type) && mode != OREAD){
               fsreply(fs, r, Eperm);
               return;
       }

       switch(TYPE(f->qid)){
       case Qdata:
               c = fs->cons[CONS(f->qid)];
               if(!userok(f->user, c->name)){
                       fsreply(fs, r, Eperm);
                       return;
               }
               f->rp = f->buf;
               f->wp = f->buf;
               f->c = c;
               lock(c);
               sprint(f->mbuf, "[%s] ", f->user);
               f->bufn = strlen(f->mbuf);
               f->used = 0;
               f->cnext = c->flist;
               c->flist = f;
               bcastmembers(fs, c, "+", f);
               if(c->pid == 0)
                       fsreopen(fs, c);
               unlock(c);
               break;
       case Qctl:
               c = fs->cons[CONS(f->qid)];
               if(!userok(f->user, c->name)){
                       fsreply(fs, r, Eperm);
                       return;
               }
               f->c = c;
               break;
       case Qstat:
               c = fs->cons[CONS(f->qid)];
               if(!userok(f->user, c->name)){
                       fsreply(fs, r, Eperm);
                       return;
               }
               f->c = c;
               break;
       }

       f->open = 1;
       r->f.iounit = messagesize-IOHDRSZ;
       r->f.qid = f->qid;
       fsreply(fs, r, nil);
}

void
fscreate(Fs *fs, Request *r, Fid*)
{
       fsreply(fs, r, Eperm);
}

void
fsread(Fs *fs, Request *r, Fid *f)
{
       uchar *p, *e;
       int i, m, off;
       vlong offset;
       Dir d;
       char sbuf[ERRMAX];

       if(f->attached == 0){
               fsreply(fs, r, Enofid);
               return;
       }

       if((int)r->f.count < 0){
               fsreply(fs, r, Ebadcount);
               return;
       }

       if(QTDIR & f->qid.type){
               p = r->buf + IOHDRSZ;
               e = p + r->f.count;
               offset = r->f.offset;
               off = 0;
               for(i=0; p<e; i++, off+=m){
                       m = fsdirgen(fs, f->qid, i, &d, p, e-p);
                       if(m < 0)
                               break;
                       if(m > BIT16SZ && off >= offset)
                               p += m;
               }
               r->f.data = (char*)r->buf + IOHDRSZ;
               r->f.count = (char*)p - r->f.data;
       } else {
               switch(TYPE(f->qid)){
               case Qdata:
                       addreq(&f->r, r);
                       fskick(fs, f);
                       return;
               case Qctl:
                       r->f.data = (char*)r->buf+IOHDRSZ;
                       r->f.count = 0;
                       break;
               case Qstat:
                       if(r->f.count > sizeof(sbuf))
                               r->f.count = sizeof(sbuf);
                       i = pread(f->c->sfd, sbuf, r->f.count, r->f.offset);
                       if(i < 0){
                               errstr(sbuf, sizeof sbuf);
                               fsreply(fs, r, sbuf);
                               return;
                       }
                       r->f.data = sbuf;
                       r->f.count = i;
                       break;
               default:
                       fsreply(fs, r, Eexist);
                       return;
               }
       }
       fsreply(fs, r, nil);
}

void
fswrite(Fs *fs, Request *r, Fid *f)
{
       int i, eol = 0;

       if(f->attached == 0){
               fsreply(fs, r, Enofid);
               return;
       }

       if((int)r->f.count < 0){
               fsreply(fs, r, Ebadcount);
               return;
       }

       if(QTDIR & f->qid.type){
               fsreply(fs, r, Eperm);
               return;
       }

       switch(TYPE(f->qid)){
       default:
               fsreply(fs, r, Eperm);
               return;
       case Qctl:
               write(f->c->cfd, r->f.data, r->f.count);
               break;
       case Qdata:
               for(i = 0; i < r->f.count; i++){
                       if(r->f.data[i] == '\n'){
                               if(f->c->chat && f->used)
                                       eol = 1;
                               if(f->c->cronly)
                                       r->f.data[i] = '\r';
                       }
                       else
                               f->used = 1;
               }
               if(f->c->chat){
                       fskick(fs, f);
                       if(!f->used)
                               break;

                       if(f->bufn + r->f.count > Bufsize){
                               r->f.count -= (f->bufn + r->f.count) % Bufsize;
                               eol = 1;
                       }
                       strncat(f->mbuf, r->f.data, r->f.count);
                       f->bufn += r->f.count;
                       if(eol){
                               bcastmsg(fs, f->c, f->mbuf, f->bufn);
                               sprint(f->mbuf, "[%s] ", f->user);
                               f->bufn = strlen(f->mbuf);
                               f->used = 0;
                       }
               }
               else
                       write(f->c->fd, r->f.data, r->f.count);
               break;
       }
       fsreply(fs, r, nil);
}

void
fsclunk(Fs *fs, Request *r, Fid *f)
{
       Fid **l, *fl;
       Request *nr;

       if(f->open && TYPE(f->qid) == Qdata){
               while((nr = remreq(&f->r)) != nil){
                       fsputfid(fs, f);
                       free(nr);
               }

               lock(f->c);
               for(l = &f->c->flist; *l; l = &fl->cnext){
                       fl = *l;
                       if(fl == f){
                               *l = fl->cnext;
                               break;
                       }
               }
               bcastmembers(fs, f->c, "-", f);
               if(f->c->ondemand && f->c->flist == nil)
                       fsreopen(fs, f->c);
               unlock(f->c);
       }
       fsreply(fs, r, nil);
       fsputfid(fs, f);
}

void
fsremove(Fs *fs, Request *r, Fid*)
{
       fsreply(fs, r, Eperm);
}

void
fsstat(Fs *fs, Request *r, Fid *f)
{
       int i, n;
       Qid q;
       Dir d;

       q = parentqid(f->qid);
       for(i = 0; ; i++){
               r->f.stat = r->buf+IOHDRSZ;
               n = fsdirgen(fs, q, i, &d, r->f.stat, messagesize-IOHDRSZ);
               if(n < 0){
                       fsreply(fs, r, Eexist);
                       return;
               }
               r->f.nstat = n;
               if(r->f.nstat > BIT16SZ && d.qid.path == f->qid.path)
                       break;
       }
       fsreply(fs, r, nil);
}

void
fswstat(Fs *fs, Request *r, Fid*)
{
       fsreply(fs, r, Eperm);
}

void
fsreply(Fs *fs, Request *r, char *err)
{
       int n;
       uchar buf[8192+IOHDRSZ];

       if(err){
               r->f.type = Rerror;
               r->f.ename = err;
       }
       n = convS2M(&r->f, buf, messagesize);
       if(debug)
               fprint(2, "%F path %llux n=%d\n", &r->f, r->fid->qid.path, n);
       fsputfid(fs, r->fid);
       if(write(fs->fd, buf, n) != n)
               fatal("unmounted");
       free(r);
}

/*
*  called whenever input or a read request has been received
*/
void
fskick(Fs *fs, Fid *f)
{
       Request *r;
       char *p, *rp, *wp, *ep;
       int i;

       lock(f);
       while(f->rp != f->wp){
               r = remreq(&f->r);
               if(r == nil)
                       break;
               p = (char*)r->buf;
               rp = f->rp;
               wp = f->wp;
               ep = &f->buf[Bufsize];
               for(i = 0; i < r->f.count && rp != wp; i++){
                       *p++ = *rp++;
                       if(rp >= ep)
                               rp = f->buf;
               }
               f->rp = rp;
               r->f.data = (char*)r->buf;
               r->f.count = p - (char*)r->buf;
               fsreply(fs, r, nil);
       }
       unlock(f);
}

void
usage(void)
{
       fprint(2, "usage: consolefs [-d] [-m mount-point] [-c console-db]\n");
       threadexitsall("usage");
}

void
threadmain(int argc, char **argv)
{
       fmtinstall('F', fcallfmt);

       ARGBEGIN{
       case 'd':
               debug++;
               break;
       case 'c':
               consoledb = ARGF();
               if(consoledb == nil)
                       usage();
               break;
       case 'm':
               mntpt = ARGF();
               if(mntpt == nil)
                       usage();
               break;
       }ARGEND;

       db = ndbopen(consoledb);
       if(db == nil)
               fatal("can't open %s: %r", consoledb);

       fsmount(mntpt);
}

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.