sys/src/cmd/aux/consolefs.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4 #include <fcall.h>
   5 #include <bio.h>
   6 #include <ndb.h>
   7 #include <thread.h>
   8
   9 /*
  10  *  This fs presents a 1 level file system.  It contains
  11  *  up to three files per console (xxx and xxxctl and xxxstat)
  12  */
  13
  14 typedef struct Console Console;
  15 typedef struct Fid Fid;
  16 typedef struct Request Request;
  17 typedef struct Reqlist Reqlist;
  18 typedef struct Fs Fs;
  19
  20 enum
  21 {
  22         /* last 5 bits of qid.path */
  23         Textern=        0,              /* fake parent of top level */
  24         Ttopdir,                        /* top level directory */
  25         Qctl,
  26         Qstat,
  27         Qdata,
  28
  29         Bufsize=        32*1024,        /* chars buffered per reader */
  30         Maxcons=        64,             /* maximum consoles */
  31         Nhash=          64,             /* Fid hash buckets */
  32 };
  33
  34 #define TYPE(x)         (((ulong)x.path) & 0xf)
  35 #define CONS(x)         ((((ulong)x.path) >> 4)&0xfff)
  36 #define QID(c, x)       (((c)<<4) | (x))
  37
  38 struct Request
  39 {
  40         Request *next;
  41         Fid     *fid;
  42         Fs      *fs;
  43         Fcall   f;
  44         uchar   buf[1];
  45 };
  46
  47 struct Reqlist
  48 {
  49         Lock;
  50         Request *first;
  51         Request *last;
  52 };
  53
  54 struct Fid
  55 {
  56         Lock;
  57         Fid     *next;                  /* hash list */
  58         Fid     *cnext;                 /* list of Fid's on a console */
  59         int     fid;
  60         int     ref;
  61
  62         int     attached;
  63         int     open;
  64         char    *user;
  65         char    mbuf[Bufsize];          /* message */
  66         int     bufn;
  67         int     used;
  68         Qid     qid;
  69
  70         Console *c;
  71
  72         char    buf[Bufsize];
  73         char    *rp;
  74         char    *wp;
  75
  76         Reqlist r;                      /* active read requests */
  77 };
  78
  79 struct Console
  80 {
  81         Lock;
  82
  83         char    *name;
  84         char    *dev;
  85         int     speed;
  86         int     cronly;
  87         int     ondemand;               /* open only on demand */
  88         int     chat;                   /* chat consoles are special */
  89
  90         int     pid;                    /* pid of reader */
  91
  92         int     fd;
  93         int     cfd;
  94         int     sfd;
  95
  96         Fid     *flist;                 /* open fids to broadcast to */
  97 };
  98
  99 struct Fs
 100 {
 101         Lock;
 102
 103         int     fd;                     /* to kernel mount point */
 104         int     messagesize;
 105         Fid     *hash[Nhash];
 106         Console *cons[Maxcons];
 107         int     ncons;
 108 };
 109
 110 extern  void    console(Fs*, char*, char*, int, int, int);
 111 extern  Fs*     fsmount(char*);
 112
 113 extern  void    fsreader(void*);
 114 extern  void    fsrun(void*);
 115 extern  Fid*    fsgetfid(Fs*, int);
 116 extern  void    fsputfid(Fs*, Fid*);
 117 extern  int     fsdirgen(Fs*, Qid, int, Dir*, uchar*, int);
 118 extern  void    fsreply(Fs*, Request*, char*);
 119 extern  void    fskick(Fs*, Fid*);
 120 extern  int     fsreopen(Fs*, Console*);
 121
 122 extern  void    fsversion(Fs*, Request*, Fid*);
 123 extern  void    fsflush(Fs*, Request*, Fid*);
 124 extern  void    fsauth(Fs*, Request*, Fid*);
 125 extern  void    fsattach(Fs*, Request*, Fid*);
 126 extern  void    fswalk(Fs*, Request*, Fid*);
 127 extern  void    fsclwalk(Fs*, Request*, Fid*);
 128 extern  void    fsopen(Fs*, Request*, Fid*);
 129 extern  void    fscreate(Fs*, Request*, Fid*);
 130 extern  void    fsread(Fs*, Request*, Fid*);
 131 extern  void    fswrite(Fs*, Request*, Fid*);
 132 extern  void    fsclunk(Fs*, Request*, Fid*);
 133 extern  void    fsremove(Fs*, Request*, Fid*);
 134 extern  void    fsstat(Fs*, Request*, Fid*);
 135 extern  void    fswstat(Fs*, Request*, Fid*);
 136
 137
 138 void    (*fcall[])(Fs*, Request*, Fid*) =
 139 {
 140         [Tflush]        fsflush,
 141         [Tversion]      fsversion,
 142         [Tauth] fsauth,
 143         [Tattach]       fsattach,
 144         [Twalk]         fswalk,
 145         [Topen]         fsopen,
 146         [Tcreate]       fscreate,
 147         [Tread]         fsread,
 148         [Twrite]        fswrite,
 149         [Tclunk]        fsclunk,
 150         [Tremove]       fsremove,
 151         [Tstat]         fsstat,
 152         [Twstat]        fswstat
 153 };
 154
 155 char Eperm[] = "permission denied";
 156 char Eexist[] = "file does not exist";
 157 char Enotdir[] = "not a directory";
 158 char Eisopen[] = "file already open";
 159 char Ebadcount[] = "bad read/write count";
 160 char Enofid[] = "no such fid";
 161
 162 char *consoledb = "/lib/ndb/consoledb";
 163 char *mntpt = "/mnt/consoles";
 164
 165 int messagesize = 8192+IOHDRSZ;
 166
 167 void
 168 fatal(char *fmt, ...)
 169 {
 170         va_list arg;
 171         char buf[1024];
 172
 173         write(2, "consolefs: ", 10);
 174         va_start(arg, fmt);
 175         vseprint(buf, buf+1024, fmt, arg);
 176         va_end(arg);
 177         write(2, buf, strlen(buf));
 178         write(2, "\n", 1);
 179         threadexitsall(fmt);
 180 }
 181
 182
 183 void*
 184 emalloc(uint n)
 185 {
 186         void *p;
 187
 188         p = malloc(n);
 189         if(p == nil)
 190                 fatal("malloc failed: %r");
 191         memset(p, 0, n);
 192         return p;
 193 }
 194
 195 int debug;
 196 Ndb *db;
 197
 198 /*
 199  *  any request that can get queued for a delayed reply
 200  */
 201 Request*
 202 allocreq(Fs *fs, int bufsize)
 203 {
 204         Request *r;
 205
 206         r = emalloc(sizeof(Request)+bufsize);
 207         r->fs = fs;
 208         r->next = nil;
 209         return r;
 210 }
 211
 212 /*
 213  *  for maintaining lists of requests
 214  */
 215 void
 216 addreq(Reqlist *l, Request *r)
 217 {
 218         lock(l);
 219         if(l->first == nil)
 220                 l->first = r;
 221         else
 222                 l->last->next = r;
 223         l->last = r;
 224         r->next = nil;
 225         unlock(l);
 226 }
 227
 228 /*
 229  *  remove the first request from a list of requests
 230  */
 231 Request*
 232 remreq(Reqlist *l)
 233 {
 234         Request *r;
 235
 236         lock(l);
 237         r = l->first;
 238         if(r != nil)
 239                 l->first = r->next;
 240         unlock(l);
 241         return r;
 242 }
 243
 244 /*
 245  *  remove a request with the given tag from a list of requests
 246  */
 247 Request*
 248 remtag(Reqlist *l, int tag)
 249 {
 250         Request *or, **ll;
 251
 252         lock(l);
 253         ll = &l->first;
 254         for(or = *ll; or; or = or->next){
 255                 if(or->f.tag == tag){
 256                         *ll = or->next;
 257                         unlock(l);
 258                         return or;
 259                 }
 260                 ll = &or->next;
 261         }
 262         unlock(l);
 263         return nil;
 264 }
 265
 266 Qid
 267 parentqid(Qid q)
 268 {
 269         if(q.type & QTDIR)
 270                 return (Qid){QID(0, Textern), 0, QTDIR};
 271         else
 272                 return (Qid){QID(0, Ttopdir), 0, QTDIR};
 273 }
 274
 275 int
 276 fsdirgen(Fs *fs, Qid parent, int i, Dir *d, uchar *buf, int nbuf)
 277 {
 278         static char name[64];
 279         char *p;
 280         int xcons;
 281
 282         d->uid = d->gid = d->muid = "network";
 283         d->length = 0;
 284         d->atime = time(nil);
 285         d->mtime = d->atime;
 286         d->type = 'C';
 287         d->dev = '0';
 288
 289         switch(TYPE(parent)){
 290         case Textern:
 291                 if(i != 0)
 292                         return -1;
 293                 p = "consoles";
 294                 d->mode = DMDIR|0555;
 295                 d->qid.type = QTDIR;
 296                 d->qid.path = QID(0, Ttopdir);
 297                 d->qid.vers = 0;
 298                 break;
 299         case Ttopdir:
 300                 xcons = i/3;
 301                 if(xcons >= fs->ncons)
 302                         return -1;
 303                 p = fs->cons[xcons]->name;
 304                 switch(i%3){
 305                 case 0:
 306                         if(fs->cons[xcons]->cfd < 0)
 307                                 return 0;
 308                         snprint(name, sizeof name, "%sctl", p);
 309                         p = name;
 310                         d->qid.type = QTFILE;
 311                         d->qid.path = QID(xcons, Qctl);
 312                         d->qid.vers = 0;
 313                         break;
 314                 case 1:
 315                         if(fs->cons[xcons]->sfd < 0)
 316                                 return 0;
 317                         snprint(name, sizeof name, "%sstat", p);
 318                         p = name;
 319                         d->qid.type = QTFILE;
 320                         d->qid.path = QID(xcons, Qstat);
 321                         d->qid.vers = 0;
 322                         break;
 323                 case 2:
 324                         d->qid.type = QTFILE;
 325                         d->qid.path = QID(xcons, Qdata);
 326                         d->qid.vers = 0;
 327                         break;
 328                 }
 329                 d->mode = 0666;
 330                 break;
 331         default:
 332                 return -1;
 333         }
 334         d->name = p;
 335         if(buf != nil)
 336                 return convD2M(d, buf, nbuf);
 337         return 1;
 338 }
 339
 340 /*
 341  *  mount the user interface and start a request processor
 342  */
 343 Fs*
 344 fsmount(char *mntpt)
 345 {
 346         Fs *fs;
 347         int pfd[2], srv;
 348         char buf[32];
 349         int n;
 350         static void *v[2];
 351
 352         fs = emalloc(sizeof(Fs));
 353
 354         if(pipe(pfd) < 0)
 355                 fatal("opening pipe: %r");
 356
 357         /* start up the file system process */
 358         v[0] = fs;
 359         v[1] = pfd;
 360         proccreate(fsrun, v, 16*1024);
 361
 362         /* Typically mounted before /srv exists */
 363         if(access("#s/consoles", AEXIST) < 0){
 364                 srv = create("#s/consoles", OWRITE, 0666);
 365                 if(srv < 0)
 366                         fatal("post: %r");
 367
 368                 n = sprint(buf, "%d", pfd[1]);
 369                 if(write(srv, buf, n) < 0)
 370                         fatal("write srv: %r");
 371
 372                 close(srv);
 373         }
 374
 375         mount(pfd[1], -1, mntpt, MBEFORE, "");
 376         close(pfd[1]);
 377         return fs;
 378 }
 379
 380 /*
 381  *  reopen a console
 382  */
 383 int
 384 fsreopen(Fs* fs, Console *c)
 385 {
 386         char buf[128];
 387         static void *v[2];
 388
 389         if(c->pid){
 390                 if(postnote(PNPROC, c->pid, "reopen") != 0)
 391                         fprint(2, "postnote failed: %r\n");
 392                 c->pid = 0;
 393         }
 394
 395         if(c->fd >= 0){
 396                 close(c->fd);
 397                 close(c->cfd);
 398                 close(c->sfd);
 399                 c->cfd = -1;
 400                 c->fd = -1;
 401                 c->sfd = -1;
 402         }
 403
 404         if(c->flist == nil && c->ondemand)
 405                 return 0;
 406
 407         c->fd = open(c->dev, ORDWR);
 408         if(c->fd < 0)
 409                 return -1;
 410
 411         snprint(buf, sizeof(buf), "%sctl", c->dev);
 412         c->cfd = open(buf, ORDWR);
 413         fprint(c->cfd, "b%d", c->speed);
 414
 415         snprint(buf, sizeof(buf), "%sstat", c->dev);
 416         c->sfd = open(buf, OREAD);
 417
 418         v[0] = fs;
 419         v[1] = c;
 420         proccreate(fsreader, v, 16*1024);
 421
 422         return 0;
 423 }
 424
 425 void
 426 change(Fs *fs, Console *c, int doreopen, int speed, int cronly, int ondemand)
 427 {
 428         lock(c);
 429
 430         if(speed != c->speed){
 431                 c->speed = speed;
 432                 doreopen = 1;
 433         }
 434         if(ondemand != c->ondemand){
 435                 c->ondemand = ondemand;
 436                 doreopen = 1;
 437         }
 438         c->cronly = cronly;
 439         if(doreopen)
 440                 fsreopen(fs, c);
 441
 442         unlock(c);
 443 }
 444
 445 /*
 446  *  create a console interface
 447  */
 448 void
 449 console(Fs* fs, char *name, char *dev, int speed, int cronly, int ondemand)
 450 {
 451         Console *c;
 452         char *x;
 453         int i, doreopen;
 454
 455         if(fs->ncons >= Maxcons)
 456                 fatal("too many consoles, too little time");
 457
 458         doreopen = 0;
 459         for(i = 0; i < fs->ncons; i++){
 460                 c = fs->cons[i];
 461                 if(strcmp(name, c->name) == 0){
 462                         if(strcmp(dev, c->dev) != 0){
 463                                 /* new device */
 464                                 x = c->dev;
 465                                 c->dev = strdup(dev);
 466                                 free(x);
 467                                 doreopen = 1;
 468                         }
 469                         change(fs, c, doreopen, speed, cronly, ondemand);
 470                         return;
 471                 }
 472         }
 473 #ifdef sapedoesntlikethis
 474         /*
 475          * The code below prevents this from working.  I can't
 476          * think of scenarios where the code below actually helps
 477          *      Sape
 478          *
 479          * console=borneo dev=/dev/eia1
 480          *      speed=9600
 481          *      openondemand=1
 482          * console=tottie dev=/dev/eia1
 483          *      speed=115200
 484          *      openondemand=1
 485          */
 486         for(i = 0; i < fs->ncons; i++){
 487                 c = fs->cons[i];
 488                 if(strcmp(dev, c->dev) == 0){
 489                         /* at least a rename */
 490                         x = c->name;
 491                         c->name = strdup(name);
 492                         free(x);
 493                         change(fs, c, doreopen, speed, cronly, ondemand);
 494                         return;
 495                 }
 496         }
 497 #endif
 498         c = emalloc(sizeof(Console));
 499         fs->cons[fs->ncons] = c;
 500         fs->ncons++;
 501         c->name = strdup(name);
 502         c->dev = strdup(dev);
 503         if(strcmp(c->dev, "/dev/null") == 0)
 504                 c->chat = 1;
 505         else
 506                 c->chat = 0;
 507         c->fd = -1;
 508         c->cfd = -1;
 509         c->sfd = -1;
 510         change(fs, c, 1, speed, cronly, ondemand);
 511 }
 512
 513 /*
 514  *  buffer data from console to a client.
 515  *  circular q with writer able to catch up to reader.
 516  *  the reader may miss data but always sees an in order sequence.
 517  */
 518 void
 519 fromconsole(Fid *f, char *p, int n)
 520 {
 521         char *rp, *wp, *ep;
 522         int pass;
 523
 524         lock(f);
 525         rp = f->rp;
 526         wp = f->wp;
 527         ep = f->buf + sizeof(f->buf);
 528         pass = 0;
 529         while(n--){
 530                 *wp++ = *p++;
 531                 if(wp >= ep)
 532                         wp = f->buf;
 533                 if(rp == wp)
 534                         pass = 1;
 535         }
 536         f->wp = wp;
 537
 538         /*  we overtook the read pointer, push it up so readers always
 539          *  see the tail of what was written
 540          */
 541         if(pass){
 542                 wp++;
 543                 if(wp >= ep)
 544                         f->rp = f->buf;
 545                 else
 546                         f->rp = wp;
 547         }
 548         unlock(f);
 549 }
 550
 551 /*
 552  *  broadcast a list of members to all listeners
 553  */
 554 void
 555 bcastmembers(Fs *fs, Console *c, char *msg, Fid *f)
 556 {
 557         int n;
 558         Fid *fl;
 559         char buf[512];
 560
 561         sprint(buf, "[%s%s", msg, f->user);
 562         for(fl = c->flist; fl != nil && strlen(buf) + 64 < sizeof(buf); fl = fl->cnext){
 563                 if(f == fl)
 564                         continue;
 565                 strcat(buf, ", ");
 566                 strcat(buf, fl->user);
 567         }
 568         strcat(buf, "]\n");
 569
 570         n = strlen(buf);
 571         for(fl = c->flist; fl; fl = fl->cnext){
 572                 fromconsole(fl, buf, n);
 573                 fskick(fs, fl);
 574         }
 575 }
 576
 577 void
 578 handler(void*, char *msg)
 579 {
 580         if(strstr(msg, "reopen") != nil ||
 581            strstr(msg, "write on closed pipe") != nil)
 582                 noted(NCONT);
 583         noted(NDFLT);
 584 }
 585
 586 /*
 587  *  a process to read console output and broadcast it (one per console)
 588  */
 589 void
 590 fsreader(void *v)
 591 {
 592         int n;
 593         Fid *fl;
 594         char buf[1024];
 595         Fs *fs;
 596         Console *c;
 597         void **a;
 598
 599         a = v;
 600         fs = a[0];
 601         c = a[1];
 602         c->pid = getpid();
 603         notify(handler);
 604         if(c->chat)
 605                 threadexits(nil);
 606         for(;;){
 607                 n = read(c->fd, buf, sizeof(buf));
 608                 if(n < 0)
 609                         break;
 610                 lock(c);
 611                 for(fl = c->flist; fl; fl = fl->cnext){
 612                         fromconsole(fl, buf, n);
 613                         fskick(fs, fl);
 614                 }
 615                 unlock(c);
 616         }
 617 }
 618
 619 void
 620 readdb(Fs *fs)
 621 {
 622         Ndbtuple *t, *nt;
 623         char *dev, *cons;
 624         int cronly, speed, ondemand;
 625
 626         ndbreopen(db);
 627
 628         /* start a listener for each console */
 629         for(;;){
 630                 t = ndbparse(db);
 631                 if(t == nil)
 632                         break;
 633                 dev = nil;
 634                 cons = nil;
 635                 speed = 9600;
 636                 cronly = 0;
 637                 ondemand = 0;
 638                 for(nt = t; nt; nt = nt->entry){
 639                         if(strcmp(nt->attr, "console") == 0)
 640                                 cons = nt->val;
 641                         else if(strcmp(nt->attr, "dev") == 0)
 642                                 dev = nt->val;
 643                         else if(strcmp(nt->attr, "speed") == 0)
 644                                 speed = atoi(nt->val);
 645                         else if(strcmp(nt->attr, "cronly") == 0)
 646                                 cronly = 1;
 647                         else if(strcmp(nt->attr, "openondemand") == 0)
 648                                 ondemand = 1;
 649                 }
 650                 if(dev != nil && cons != nil)
 651                         console(fs, cons, dev, speed, cronly, ondemand);
 652                 ndbfree(t);
 653         }
 654 }
 655
 656 int dbmtime;
 657
 658 /*
 659  *  a request processor (one per Fs)
 660  */
 661 void
 662 fsrun(void *v)
 663 {
 664         int n, t;
 665         Request *r;
 666         Fid *f;
 667         Dir *d;
 668         void **a = v;
 669         Fs* fs;
 670         int *pfd;
 671
 672         fs = a[0];
 673         pfd = a[1];
 674         fs->fd = pfd[0];
 675         notify(handler);
 676         for(;;){
 677                 d = dirstat(consoledb);
 678                 if(d != nil && d->mtime != dbmtime){
 679                         dbmtime = d->mtime;
 680                         readdb(fs);
 681                 }
 682                 free(d);
 683                 r = allocreq(fs, messagesize);
 684                 n = read9pmsg(fs->fd, r->buf, messagesize);
 685                 if(n == 0)
 686                         threadexitsall("unmounted");
 687                 if(n < 0)
 688                         fatal("mount read: %r");
 689                 if(convM2S(r->buf, n, &r->f) != n)
 690                         fatal("convM2S format error: %r");
 691
 692                 f = fsgetfid(fs, r->f.fid);
 693                 r->fid = f;
 694                 if(debug)
 695                         fprint(2, "%F path %llux\n", &r->f, f->qid.path);
 696
 697                 t = r->f.type;
 698                 r->f.type++;
 699                 (*fcall[t])(fs, r, f);
 700         }
 701 }
 702
 703 Fid*
 704 fsgetfid(Fs *fs, int fid)
 705 {
 706         Fid *f, *nf;
 707
 708         lock(fs);
 709         for(f = fs->hash[fid%Nhash]; f; f = f->next){
 710                 if(f->fid == fid){
 711                         f->ref++;
 712                         unlock(fs);
 713                         return f;
 714                 }
 715         }
 716
 717         nf = emalloc(sizeof(Fid));
 718         nf->next = fs->hash[fid%Nhash];
 719         fs->hash[fid%Nhash] = nf;
 720         nf->fid = fid;
 721         nf->ref = 1;
 722         nf->wp = nf->buf;
 723         nf->rp = nf->wp;
 724         unlock(fs);
 725         return nf;
 726 }
 727
 728 void
 729 fsputfid(Fs *fs, Fid *f)
 730 {
 731         Fid **l, *nf;
 732
 733         lock(fs);
 734         if(--f->ref > 0){
 735                 unlock(fs);
 736                 return;
 737         }
 738         for(l = &fs->hash[f->fid%Nhash]; nf = *l; l = &nf->next)
 739                 if(nf == f){
 740                         *l = f->next;
 741                         break;
 742                 }
 743         unlock(fs);
 744         free(f->user);
 745         free(f);
 746 }
 747
 748 void
 749 fsauth(Fs *fs, Request *r, Fid*)
 750 {
 751         fsreply(fs, r, "consolefs: authentication not required");
 752 }
 753
 754 void
 755 fsversion(Fs *fs, Request *r, Fid*)
 756 {
 757
 758         if(r->f.msize < 256){
 759                 fsreply(fs, r, "message size too small");
 760                 return;
 761         }
 762         messagesize = r->f.msize;
 763         if(messagesize > 8192+IOHDRSZ)
 764                 messagesize = 8192+IOHDRSZ;
 765         r->f.msize = messagesize;
 766         if(strncmp(r->f.version, "9P2000", 6) != 0){
 767                 fsreply(fs, r, "unrecognized 9P version");
 768                 return;
 769         }
 770         r->f.version = "9P2000";
 771
 772         fsreply(fs, r, nil);
 773 }
 774
 775 void
 776 fsflush(Fs *fs, Request *r, Fid *f)
 777 {
 778         Request *or;
 779
 780         or = remtag(&f->r, r->f.oldtag);
 781         if(or != nil){
 782                 fsputfid(fs, or->fid);
 783                 free(or);
 784         }
 785         fsreply(fs, r, nil);
 786 }
 787
 788 void
 789 fsattach(Fs *fs, Request *r, Fid *f)
 790 {
 791         f->qid.type = QTDIR;
 792         f->qid.path = QID(0, Ttopdir);
 793         f->qid.vers = 0;
 794
 795         if(r->f.uname[0])
 796                 f->user = strdup(r->f.uname);
 797         else
 798                 f->user = strdup("none");
 799
 800         /* hold down the fid till the clunk */
 801         f->attached = 1;
 802         lock(fs);
 803         f->ref++;
 804         unlock(fs);
 805
 806         r->f.qid = f->qid;
 807         fsreply(fs, r, nil);
 808 }
 809
 810 void
 811 fswalk(Fs *fs, Request *r, Fid *f)
 812 {
 813         char *name;
 814         Dir d;
 815         int i, n, nqid, nwname;
 816         Qid qid, wqid[MAXWELEM];
 817         Fid *nf;
 818         char *err;
 819
 820         if(f->attached == 0){
 821                 fsreply(fs, r, Enofid);
 822                 return;
 823         }
 824
 825         nf = nil;
 826         if(r->f.fid != r->f.newfid){
 827                 nf = fsgetfid(fs, r->f.newfid);
 828                 nf->attached = f->attached;
 829                 nf->open = f->open;
 830                 nf->qid = f->qid;
 831                 nf->user = strdup(f->user);
 832                 nf->c = f->c;
 833                 nf->wp = nf->buf;
 834                 nf->rp = nf->wp;
 835                 f = nf;
 836         }
 837
 838         qid = f->qid;
 839         err = nil;
 840         nwname = r->f.nwname;
 841         nqid = 0;
 842         if(nwname > 0){
 843                 for(; err == nil && nqid < nwname; nqid++){
 844                         if(nqid >= MAXWELEM){
 845                                 err = "too many name elements";
 846                                 break;
 847                         }
 848                         name = r->f.wname[nqid];
 849                         if(strcmp(name, "..") == 0)
 850                                 qid = parentqid(qid);
 851                         else if(strcmp(name, ".") != 0){
 852                                 for(i = 0; ; i++){
 853                                         n = fsdirgen(fs, qid, i, &d, nil, 0);
 854                                         if(n < 0){
 855                                                 err = Eexist;
 856                                                 break;
 857                                         }
 858                                         if(n > 0 && strcmp(name, d.name) == 0){
 859                                                 qid = d.qid;
 860                                                 break;
 861                                         }
 862                                 }
 863                         }
 864                         wqid[nqid] = qid;
 865                 }
 866                 if(nf != nil && nqid < nwname)
 867                         fsputfid(fs, nf);
 868                 if(nqid == nwname)
 869                         f->qid = qid;
 870         }
 871
 872         memmove(r->f.wqid, wqid, nqid*sizeof(Qid));
 873         r->f.nwqid = nqid;
 874         fsreply(fs, r, err);
 875 }
 876
 877 int
 878 ingroup(char *user, char *group)
 879 {
 880         Ndbtuple *t, *nt;
 881         Ndbs s;
 882
 883         t = ndbsearch(db, &s, "group", group);
 884         if(t == nil)
 885                 return 0;
 886         for(nt = t; nt; nt = nt->entry){
 887                 if(strcmp(nt->attr, "uid") == 0)
 888                 if(strcmp(nt->val, user) == 0)
 889                         break;
 890         }
 891         ndbfree(t);
 892         return nt != nil;
 893 }
 894
 895 int
 896 userok(char *u, char *cname)
 897 {
 898         Ndbtuple *t, *nt;
 899         Ndbs s;
 900
 901         t = ndbsearch(db, &s, "console", cname);
 902         if(t == nil)
 903                 return 0;
 904
 905         for(nt = t; nt; nt = nt->entry){
 906                 if(strcmp(nt->attr, "uid") == 0)
 907                 if(strcmp(nt->val, u) == 0)
 908                         break;
 909                 if(strcmp(nt->attr, "gid") == 0)
 910                 if(ingroup(u, nt->val))
 911                         break;
 912         }
 913         ndbfree(t);
 914
 915         return nt != nil;
 916 }
 917
 918 int m2p[] ={
 919         [OREAD]         4,
 920         [OWRITE]        2,
 921         [ORDWR]         6
 922 };
 923
 924 /*
 925  *  broadcast a message to all listeners
 926  */
 927 void
 928 bcastmsg(Fs *fs, Console *c, char *msg, int n)
 929 {
 930         Fid *fl;
 931
 932         for(fl = c->flist; fl; fl = fl->cnext){
 933                 fromconsole(fl, msg, n);
 934                 fskick(fs, fl);
 935         }
 936 }
 937
 938 void
 939 fsopen(Fs *fs, Request *r, Fid *f)
 940 {
 941         int mode;
 942         Console *c;
 943
 944         if(f->attached == 0){
 945                 fsreply(fs, r, Enofid);
 946                 return;
 947         }
 948
 949         if(f->open){
 950                 fsreply(fs, r, Eisopen);
 951                 return;
 952         }
 953
 954         mode = r->f.mode & 3;
 955
 956         if((QTDIR & f->qid.type) && mode != OREAD){
 957                 fsreply(fs, r, Eperm);
 958                 return;
 959         }
 960
 961         switch(TYPE(f->qid)){
 962         case Qdata:
 963                 c = fs->cons[CONS(f->qid)];
 964                 if(!userok(f->user, c->name)){
 965                         fsreply(fs, r, Eperm);
 966                         return;
 967                 }
 968                 f->rp = f->buf;
 969                 f->wp = f->buf;
 970                 f->c = c;
 971                 lock(c);
 972                 sprint(f->mbuf, "[%s] ", f->user);
 973                 f->bufn = strlen(f->mbuf);
 974                 f->used = 0;
 975                 f->cnext = c->flist;
 976                 c->flist = f;
 977                 bcastmembers(fs, c, "+", f);
 978                 if(c->pid == 0)
 979                         fsreopen(fs, c);
 980                 unlock(c);
 981                 break;
 982         case Qctl:
 983                 c = fs->cons[CONS(f->qid)];
 984                 if(!userok(f->user, c->name)){
 985                         fsreply(fs, r, Eperm);
 986                         return;
 987                 }
 988                 f->c = c;
 989                 break;
 990         case Qstat:
 991                 c = fs->cons[CONS(f->qid)];
 992                 if(!userok(f->user, c->name)){
 993                         fsreply(fs, r, Eperm);
 994                         return;
 995                 }
 996                 f->c = c;
 997                 break;
 998         }
 999
1000         f->open = 1;
1001         r->f.iounit = messagesize-IOHDRSZ;
1002         r->f.qid = f->qid;
1003         fsreply(fs, r, nil);
1004 }
1005
1006 void
1007 fscreate(Fs *fs, Request *r, Fid*)
1008 {
1009         fsreply(fs, r, Eperm);
1010 }
1011
1012 void
1013 fsread(Fs *fs, Request *r, Fid *f)
1014 {
1015         uchar *p, *e;
1016         int i, m, off;
1017         vlong offset;
1018         Dir d;
1019         char sbuf[ERRMAX];
1020
1021         if(f->attached == 0){
1022                 fsreply(fs, r, Enofid);
1023                 return;
1024         }
1025
1026         if((int)r->f.count < 0){
1027                 fsreply(fs, r, Ebadcount);
1028                 return;
1029         }
1030
1031         if(QTDIR & f->qid.type){
1032                 p = r->buf + IOHDRSZ;
1033                 e = p + r->f.count;
1034                 offset = r->f.offset;
1035                 off = 0;
1036                 for(i=0; p<e; i++, off+=m){
1037                         m = fsdirgen(fs, f->qid, i, &d, p, e-p);
1038                         if(m < 0)
1039                                 break;
1040                         if(m > BIT16SZ && off >= offset)
1041                                 p += m;
1042                 }
1043                 r->f.data = (char*)r->buf + IOHDRSZ;
1044                 r->f.count = (char*)p - r->f.data;
1045         } else {
1046                 switch(TYPE(f->qid)){
1047                 case Qdata:
1048                         addreq(&f->r, r);
1049                         fskick(fs, f);
1050                         return;
1051                 case Qctl:
1052                         r->f.data = (char*)r->buf+IOHDRSZ;
1053                         r->f.count = 0;
1054                         break;
1055                 case Qstat:
1056                         if(r->f.count > sizeof(sbuf))
1057                                 r->f.count = sizeof(sbuf);
1058                         i = pread(f->c->sfd, sbuf, r->f.count, r->f.offset);
1059                         if(i < 0){
1060                                 errstr(sbuf, sizeof sbuf);
1061                                 fsreply(fs, r, sbuf);
1062                                 return;
1063                         }
1064                         r->f.data = sbuf;
1065                         r->f.count = i;
1066                         break;
1067                 default:
1068                         fsreply(fs, r, Eexist);
1069                         return;
1070                 }
1071         }
1072         fsreply(fs, r, nil);
1073 }
1074
1075 void
1076 fswrite(Fs *fs, Request *r, Fid *f)
1077 {
1078         int i, eol = 0;
1079
1080         if(f->attached == 0){
1081                 fsreply(fs, r, Enofid);
1082                 return;
1083         }
1084
1085         if((int)r->f.count < 0){
1086                 fsreply(fs, r, Ebadcount);
1087                 return;
1088         }
1089
1090         if(QTDIR & f->qid.type){
1091                 fsreply(fs, r, Eperm);
1092                 return;
1093         }
1094
1095         switch(TYPE(f->qid)){
1096         default:
1097                 fsreply(fs, r, Eperm);
1098                 return;
1099         case Qctl:
1100                 write(f->c->cfd, r->f.data, r->f.count);
1101                 break;
1102         case Qdata:
1103                 for(i = 0; i < r->f.count; i++){
1104                         if(r->f.data[i] == '\n'){
1105                                 if(f->c->chat && f->used)
1106                                         eol = 1;
1107                                 if(f->c->cronly)
1108                                         r->f.data[i] = '\r';
1109                         }
1110                         else
1111                                 f->used = 1;
1112                 }
1113                 if(f->c->chat){
1114                         fskick(fs, f);
1115                         if(!f->used)
1116                                 break;
1117
1118                         if(f->bufn + r->f.count > Bufsize){
1119                                 r->f.count -= (f->bufn + r->f.count) % Bufsize;
1120                                 eol = 1;
1121                         }
1122                         strncat(f->mbuf, r->f.data, r->f.count);
1123                         f->bufn += r->f.count;
1124                         if(eol){
1125                                 bcastmsg(fs, f->c, f->mbuf, f->bufn);
1126                                 sprint(f->mbuf, "[%s] ", f->user);
1127                                 f->bufn = strlen(f->mbuf);
1128                                 f->used = 0;
1129                         }
1130                 }
1131                 else
1132                         write(f->c->fd, r->f.data, r->f.count);
1133                 break;
1134         }
1135         fsreply(fs, r, nil);
1136 }
1137
1138 void
1139 fsclunk(Fs *fs, Request *r, Fid *f)
1140 {
1141         Fid **l, *fl;
1142         Request *nr;
1143
1144         if(f->open && TYPE(f->qid) == Qdata){
1145                 while((nr = remreq(&f->r)) != nil){
1146                         fsputfid(fs, f);
1147                         free(nr);
1148                 }
1149
1150                 lock(f->c);
1151                 for(l = &f->c->flist; *l; l = &fl->cnext){
1152                         fl = *l;
1153                         if(fl == f){
1154                                 *l = fl->cnext;
1155                                 break;
1156                         }
1157                 }
1158                 bcastmembers(fs, f->c, "-", f);
1159                 if(f->c->ondemand && f->c->flist == nil)
1160                         fsreopen(fs, f->c);
1161                 unlock(f->c);
1162         }
1163         fsreply(fs, r, nil);
1164         fsputfid(fs, f);
1165 }
1166
1167 void
1168 fsremove(Fs *fs, Request *r, Fid*)
1169 {
1170         fsreply(fs, r, Eperm);
1171 }
1172
1173 void
1174 fsstat(Fs *fs, Request *r, Fid *f)
1175 {
1176         int i, n;
1177         Qid q;
1178         Dir d;
1179
1180         q = parentqid(f->qid);
1181         for(i = 0; ; i++){
1182                 r->f.stat = r->buf+IOHDRSZ;
1183                 n = fsdirgen(fs, q, i, &d, r->f.stat, messagesize-IOHDRSZ);
1184                 if(n < 0){
1185                         fsreply(fs, r, Eexist);
1186                         return;
1187                 }
1188                 r->f.nstat = n;
1189                 if(r->f.nstat > BIT16SZ && d.qid.path == f->qid.path)
1190                         break;
1191         }
1192         fsreply(fs, r, nil);
1193 }
1194
1195 void
1196 fswstat(Fs *fs, Request *r, Fid*)
1197 {
1198         fsreply(fs, r, Eperm);
1199 }
1200
1201 void
1202 fsreply(Fs *fs, Request *r, char *err)
1203 {
1204         int n;
1205         uchar buf[8192+IOHDRSZ];
1206
1207         if(err){
1208                 r->f.type = Rerror;
1209                 r->f.ename = err;
1210         }
1211         n = convS2M(&r->f, buf, messagesize);
1212         if(debug)
1213                 fprint(2, "%F path %llux n=%d\n", &r->f, r->fid->qid.path, n);
1214         fsputfid(fs, r->fid);
1215         if(write(fs->fd, buf, n) != n)
1216                 fatal("unmounted");
1217         free(r);
1218 }
1219
1220 /*
1221  *  called whenever input or a read request has been received
1222  */
1223 void
1224 fskick(Fs *fs, Fid *f)
1225 {
1226         Request *r;
1227         char *p, *rp, *wp, *ep;
1228         int i;
1229
1230         lock(f);
1231         while(f->rp != f->wp){
1232                 r = remreq(&f->r);
1233                 if(r == nil)
1234                         break;
1235                 p = (char*)r->buf;
1236                 rp = f->rp;
1237                 wp = f->wp;
1238                 ep = &f->buf[Bufsize];
1239                 for(i = 0; i < r->f.count && rp != wp; i++){
1240                         *p++ = *rp++;
1241                         if(rp >= ep)
1242                                 rp = f->buf;
1243                 }
1244                 f->rp = rp;
1245                 r->f.data = (char*)r->buf;
1246                 r->f.count = p - (char*)r->buf;
1247                 fsreply(fs, r, nil);
1248         }
1249         unlock(f);
1250 }
1251
1252 void
1253 usage(void)
1254 {
1255         fprint(2, "usage: consolefs [-d] [-m mount-point] [-c console-db]\n");
1256         threadexitsall("usage");
1257 }
1258
1259 void
1260 threadmain(int argc, char **argv)
1261 {
1262         fmtinstall('F', fcallfmt);
1263
1264         ARGBEGIN{
1265         case 'd':
1266                 debug++;
1267                 break;
1268         case 'c':
1269                 consoledb = ARGF();
1270                 if(consoledb == nil)
1271                         usage();
1272                 break;
1273         case 'm':
1274                 mntpt = ARGF();
1275                 if(mntpt == nil)
1276                         usage();
1277                 break;
1278         }ARGEND;
1279
1280         db = ndbopen(consoledb);
1281         if(db == nil)
1282                 fatal("can't open %s: %r", consoledb);
1283
1284         fsmount(mntpt);
1285 }