sys/src/cmd/exportfs/exportfs.c

   1 /*
   2  * exportfs - Export a plan 9 name space across a network
   3  */
   4 #include <u.h>
   5 #include <libc.h>
   6 #include <auth.h>
   7 #include <fcall.h>
   8 #include <libsec.h>
   9 #define Extern
  10 #include "exportfs.h"
  11
  12 #define QIDPATH ((1LL<<48)-1)
  13 vlong newqid = 0;
  14
  15 enum {
  16         Encnone,
  17         Encssl,
  18         Enctls,
  19 };
  20
  21 void (*fcalls[])(Fsrpc*) =
  22 {
  23         [Tversion]      Xversion,
  24         [Tauth] Xauth,
  25         [Tflush]        Xflush,
  26         [Tattach]       Xattach,
  27         [Twalk]         Xwalk,
  28         [Topen]         slave,
  29         [Tcreate]       Xcreate,
  30         [Tclunk]        Xclunk,
  31         [Tread]         slave,
  32         [Twrite]        slave,
  33         [Tremove]       Xremove,
  34         [Tstat]         Xstat,
  35         [Twstat]        Xwstat,
  36 };
  37
  38 /* accounting and debugging counters */
  39 int     filecnt;
  40 int     freecnt;
  41 int     qidcnt;
  42 int     qfreecnt;
  43 int     ncollision;
  44
  45 int     netfd;                          /* initially stdin */
  46 int     srvfd = -1;
  47 int     nonone = 1;
  48 char    *filterp;
  49 char    *ealgs = "rc4_256 sha1";
  50 char    *aanfilter = "/bin/aan";
  51 int     encproto = Encnone;
  52 int     readonly;
  53
  54 static void mksecret(char *, uchar *);
  55 static int localread9pmsg(int, void *, uint, void *);
  56 static char *anstring  = "tcp!*!0";
  57
  58 char *netdir = "", *local = "", *remote = "";
  59
  60 int     filter(int, char *);
  61
  62 void
  63 usage(void)
  64 {
  65         fprint(2, "usage: %s [-adnsR] [-f dbgfile] [-m msize] [-r root] "
  66                 "[-S srvfile] [-e 'crypt hash'] [-P exclusion-file] "
  67                 "[-A announce-string] [-B address]\n", argv0);
  68         fatal("usage");
  69 }
  70
  71 static void
  72 noteconn(int fd)
  73 {
  74         NetConnInfo *nci;
  75
  76         nci = getnetconninfo(nil, fd);
  77         if (nci == nil)
  78                 return;
  79         netdir = strdup(nci->dir);
  80         local = strdup(nci->lsys);
  81         remote = strdup(nci->rsys);
  82         freenetconninfo(nci);
  83 }
  84
  85 void
  86 main(int argc, char **argv)
  87 {
  88         char buf[ERRMAX], ebuf[ERRMAX], initial[4], *ini, *srvfdfile;
  89         char *dbfile, *srv, *na, *nsfile, *keyspec;
  90         int doauth, n, fd;
  91         AuthInfo *ai;
  92         Fsrpc *r;
  93
  94         dbfile = "/tmp/exportdb";
  95         srv = nil;
  96         srvfd = -1;
  97         srvfdfile = nil;
  98         na = nil;
  99         nsfile = nil;
 100         keyspec = "";
 101         doauth = 0;
 102
 103         ai = nil;
 104         ARGBEGIN{
 105         case 'a':
 106                 doauth = 1;
 107                 break;
 108
 109         case 'd':
 110                 dbg++;
 111                 break;
 112
 113         case 'e':
 114                 ealgs = EARGF(usage());
 115                 if(*ealgs == 0 || strcmp(ealgs, "clear") == 0)
 116                         ealgs = nil;
 117                 break;
 118
 119         case 'f':
 120                 dbfile = EARGF(usage());
 121                 break;
 122
 123         case 'k':
 124                 keyspec = EARGF(usage());
 125                 break;
 126
 127         case 'm':
 128                 messagesize = strtoul(EARGF(usage()), nil, 0);
 129                 break;
 130
 131         case 'n':
 132                 nonone = 0;
 133                 break;
 134
 135         case 'r':
 136                 srv = EARGF(usage());
 137                 break;
 138
 139         case 's':
 140                 srv = "/";
 141                 break;
 142
 143         case 'A':
 144                 anstring = EARGF(usage());
 145                 break;
 146
 147         case 'B':
 148                 na = EARGF(usage());
 149                 break;
 150
 151         case 'F':
 152                 /* accepted but ignored, for backwards compatibility */
 153                 break;
 154
 155         case 'N':
 156                 nsfile = EARGF(usage());
 157                 break;
 158
 159         case 'P':
 160                 patternfile = EARGF(usage());
 161                 break;
 162
 163         case 'R':
 164                 readonly = 1;
 165                 break;
 166
 167         case 'S':
 168                 if(srvfdfile)
 169                         usage();
 170                 srvfdfile = EARGF(usage());
 171                 break;
 172
 173         default:
 174                 usage();
 175         }ARGEND
 176         USED(argc, argv);
 177
 178         if(doauth){
 179                 /*
 180                  * We use p9any so we don't have to visit this code again, with the
 181                  * cost that this code is incompatible with the old world, which
 182                  * requires p9sk2. (The two differ in who talks first, so compatibility
 183                  * is awkward.)
 184                  */
 185                 ai = auth_proxy(0, auth_getkey, "proto=p9any role=server %s", keyspec);
 186                 if(ai == nil)
 187                         fatal("auth_proxy: %r");
 188                 if(nonone && strcmp(ai->cuid, "none") == 0)
 189                         fatal("exportfs by none disallowed");
 190                 if(auth_chuid(ai, nsfile) < 0)
 191                         fatal("auth_chuid: %r");
 192                 putenv("service", "exportfs");
 193         }
 194
 195         if(srvfdfile){
 196                 if((srvfd = open(srvfdfile, ORDWR)) < 0)
 197                         fatal("open %s: %r", srvfdfile);
 198         }
 199
 200         if(na){
 201                 if(srv == nil)
 202                         fatal("-B requires -s");
 203
 204                 local = "me";
 205                 remote = na;
 206                 if((fd = dial(netmkaddr(na, 0, "importfs"), 0, 0, 0)) < 0)
 207                         fatal("can't dial %s: %r", na);
 208
 209                 ai = auth_proxy(fd, auth_getkey, "proto=p9any role=client %s", keyspec);
 210                 if(ai == nil)
 211                         fatal("%r: %s", na);
 212
 213                 dup(fd, 0);
 214                 dup(fd, 1);
 215                 close(fd);
 216         }
 217
 218         exclusions();
 219
 220         if(dbg) {
 221                 n = create(dbfile, OWRITE|OTRUNC, 0666);
 222                 dup(n, DFD);
 223                 close(n);
 224         }
 225
 226         if(srvfd >= 0 && srv){
 227                 fprint(2, "exportfs: -S cannot be used with -r or -s\n");
 228                 usage();
 229         }
 230
 231         DEBUG(DFD, "exportfs: started\n");
 232
 233         rfork(RFNOTEG);
 234
 235         if(messagesize == 0){
 236                 messagesize = iounit(netfd);
 237                 if(messagesize == 0)
 238                         messagesize = 8192+IOHDRSZ;
 239         }
 240
 241         Workq = emallocz(sizeof(Fsrpc)*Nr_workbufs);
 242         fhash = emallocz(sizeof(Fid*)*FHASHSIZE);
 243
 244         fmtinstall('F', fcallfmt);
 245
 246         /*
 247          * Get tree to serve from network connection,
 248          * check we can get there and ack the connection
 249          */
 250         if(srvfd != -1) {
 251                 /* do nothing */
 252         }
 253         else if(srv) {
 254                 if(chdir(srv) < 0) {
 255                         errstr(ebuf, sizeof ebuf);
 256                         fprint(0, "chdir(\"%s\"): %s\n", srv, ebuf);
 257                         DEBUG(DFD, "chdir(\"%s\"): %s\n", srv, ebuf);
 258                         exits(ebuf);
 259                 }
 260                 DEBUG(DFD, "invoked as server for %s", srv);
 261                 strncpy(buf, srv, sizeof buf);
 262         }
 263         else {
 264                 noteconn(netfd);
 265                 buf[0] = 0;
 266                 n = read(0, buf, sizeof(buf)-1);
 267                 if(n < 0) {
 268                         errstr(buf, sizeof buf);
 269                         fprint(0, "read(0): %s\n", buf);
 270                         DEBUG(DFD, "read(0): %s\n", buf);
 271                         exits(buf);
 272                 }
 273                 buf[n] = 0;
 274                 if(chdir(buf) < 0) {
 275                         errstr(ebuf, sizeof ebuf);
 276                         fprint(0, "chdir(%d:\"%s\"): %s\n", n, buf, ebuf);
 277                         DEBUG(DFD, "chdir(%d:\"%s\"): %s\n", n, buf, ebuf);
 278                         exits(ebuf);
 279                 }
 280         }
 281
 282         DEBUG(DFD, "\niniting root\n");
 283         initroot();
 284
 285         DEBUG(DFD, "exportfs: %s\n", buf);
 286
 287         if(srv == nil && srvfd == -1 && write(0, "OK", 2) != 2)
 288                 fatal("open ack write");
 289
 290         ini = initial;
 291         n = readn(netfd, initial, sizeof(initial));
 292         if (n == 0)
 293                 fatal(nil);     /* port scan or spurious open/close on exported /srv file (unmount) */
 294         if (n < sizeof(initial))
 295                 fatal("can't read initial string: %r");
 296
 297         if (memcmp(ini, "impo", 4) == 0) {
 298                 char buf[128], *p, *args[3];
 299
 300                 ini = nil;
 301                 p = buf;
 302                 for(;;){
 303                         if ((n = read(netfd, p, 1)) < 0)
 304                                 fatal("can't read impo arguments: %r");
 305                         if (n == 0)
 306                                 fatal("connection closed while reading arguments");
 307                         if (*p == '\n')
 308                                 *p = '\0';
 309                         if (*p++ == '\0')
 310                                 break;
 311                         if(p >= buf + sizeof(buf))
 312                                 fatal("import parameters too long");
 313                 }
 314
 315                 if (tokenize(buf, args, nelem(args)) != 2)
 316                         fatal("impo arguments invalid: impo%s...", buf);
 317
 318                 if (strcmp(args[0], "aan") == 0)
 319                         filterp = aanfilter;
 320                 else if (strcmp(args[0], "nofilter") != 0)
 321                         fatal("import filter argument unsupported: %s", args[0]);
 322
 323                 if (strcmp(args[1], "ssl") == 0)
 324                         encproto = Encssl;
 325                 else if (strcmp(args[1], "tls") == 0)
 326                         encproto = Enctls;
 327                 else if (strcmp(args[1], "clear") != 0)
 328                         fatal("import encryption proto unsupported: %s", args[1]);
 329
 330                 if (encproto == Enctls)
 331                         fatal("%s: tls has not yet been implemented", argv[0]);
 332         }
 333
 334         if (encproto != Encnone && ealgs && ai) {
 335                 uchar key[16], digest[SHA1dlen];
 336                 char fromclientsecret[21];
 337                 char fromserversecret[21];
 338                 int i;
 339
 340                 assert(ai->nsecret <= sizeof(key)-4);
 341                 memmove(key+4, ai->secret, ai->nsecret);
 342
 343                 /* exchange random numbers */
 344                 srand(truerand());
 345                 for(i = 0; i < 4; i++)
 346                         key[i+12] = rand();
 347
 348                 if (ini)
 349                         fatal("Protocol botch: old import");
 350                 if(readn(netfd, key, 4) != 4)
 351                         fatal("can't read key part; %r");
 352
 353                 if(write(netfd, key+12, 4) != 4)
 354                         fatal("can't write key part; %r");
 355
 356                 /* scramble into two secrets */
 357                 sha1(key, sizeof(key), digest, nil);
 358                 mksecret(fromclientsecret, digest);
 359                 mksecret(fromserversecret, digest+10);
 360
 361                 if (filterp)
 362                         netfd = filter(netfd, filterp);
 363
 364                 switch (encproto) {
 365                 case Encssl:
 366                         netfd = pushssl(netfd, ealgs, fromserversecret,
 367                                                 fromclientsecret, nil);
 368                         break;
 369                 case Enctls:
 370                 default:
 371                         fatal("Unsupported encryption protocol");
 372                 }
 373
 374                 if(netfd < 0)
 375                         fatal("can't establish ssl connection: %r");
 376         }
 377         else if (filterp) {
 378                 if (ini)
 379                         fatal("Protocol botch: don't know how to deal with this");
 380                 netfd = filter(netfd, filterp);
 381         }
 382
 383         if(ai)
 384                 auth_freeAI(ai);
 385
 386         /*
 387          * Start serving file requests from the network
 388          */
 389         for(;;) {
 390                 r = getsbuf();
 391                 if(r == 0)
 392                         fatal("Out of service buffers");
 393
 394                 while((n = localread9pmsg(netfd, r->buf, messagesize, ini)) == 0)
 395                         ;
 396                 if(n < 0)
 397                         fatal(nil);
 398                 if(convM2S(r->buf, n, &r->work) == 0)
 399                         fatal("convM2S format error");
 400
 401                 DEBUG(DFD, "%F\n", &r->work);
 402                 (fcalls[r->work.type])(r);
 403                 ini = nil;
 404         }
 405 }
 406
 407 /*
 408  * WARNING: Replace this with the original version as soon as all
 409  * _old_ imports have been replaced with negotiating imports.  Also
 410  * cpu relies on this (which needs to be fixed!) -- pb.
 411  */
 412 static int
 413 localread9pmsg(int fd, void *abuf, uint n, void *ini)
 414 {
 415         int m, len;
 416         uchar *buf;
 417
 418         buf = abuf;
 419
 420         /* read count */
 421         if (ini)
 422                 memcpy(buf, ini, BIT32SZ);
 423         else {
 424                 m = readn(fd, buf, BIT32SZ);
 425                 if(m != BIT32SZ){
 426                         if(m < 0)
 427                                 return -1;
 428                         return 0;
 429                 }
 430         }
 431
 432         len = GBIT32(buf);
 433         if(len <= BIT32SZ || len > n){
 434                 werrstr("bad length in 9P2000 message header");
 435                 return -1;
 436         }
 437         len -= BIT32SZ;
 438         m = readn(fd, buf+BIT32SZ, len);
 439         if(m < len)
 440                 return 0;
 441         return BIT32SZ+m;
 442 }
 443 void
 444 reply(Fcall *r, Fcall *t, char *err)
 445 {
 446         uchar *data;
 447         int n;
 448
 449         t->tag = r->tag;
 450         t->fid = r->fid;
 451         if(err) {
 452                 t->type = Rerror;
 453                 t->ename = err;
 454         }
 455         else
 456                 t->type = r->type + 1;
 457
 458         DEBUG(DFD, "\t%F\n", t);
 459
 460         data = malloc(messagesize);     /* not mallocz; no need to clear */
 461         if(data == nil)
 462                 fatal(Enomem);
 463         n = convS2M(t, data, messagesize);
 464         if(write(netfd, data, n)!=n){
 465                 syslog(0, "exportfs", "short write: %r");
 466                 fatal("mount write");
 467         }
 468         free(data);
 469 }
 470
 471 Fid *
 472 getfid(int nr)
 473 {
 474         Fid *f;
 475
 476         for(f = fidhash(nr); f; f = f->next)
 477                 if(f->nr == nr)
 478                         return f;
 479
 480         return 0;
 481 }
 482
 483 int
 484 freefid(int nr)
 485 {
 486         Fid *f, **l;
 487         char buf[128];
 488
 489         l = &fidhash(nr);
 490         for(f = *l; f; f = f->next) {
 491                 if(f->nr == nr) {
 492                         if(f->mid) {
 493                                 snprint(buf, sizeof(buf), "/mnt/exportfs/%d", f->mid);
 494                                 unmount(0, buf);
 495                                 psmap[f->mid] = 0;
 496                         }
 497                         if(f->f) {
 498                                 freefile(f->f);
 499                                 f->f = nil;
 500                         }
 501                         if(f->dir){
 502                                 free(f->dir);
 503                                 f->dir = nil;
 504                         }
 505                         *l = f->next;
 506                         f->next = fidfree;
 507                         fidfree = f;
 508                         return 1;
 509                 }
 510                 l = &f->next;
 511         }
 512
 513         return 0;
 514 }
 515
 516 Fid *
 517 newfid(int nr)
 518 {
 519         Fid *new, **l;
 520         int i;
 521
 522         l = &fidhash(nr);
 523         for(new = *l; new; new = new->next)
 524                 if(new->nr == nr)
 525                         return 0;
 526
 527         if(fidfree == 0) {
 528                 fidfree = emallocz(sizeof(Fid) * Fidchunk);
 529
 530                 for(i = 0; i < Fidchunk-1; i++)
 531                         fidfree[i].next = &fidfree[i+1];
 532
 533                 fidfree[Fidchunk-1].next = 0;
 534         }
 535
 536         new = fidfree;
 537         fidfree = new->next;
 538
 539         memset(new, 0, sizeof(Fid));
 540         new->next = *l;
 541         *l = new;
 542         new->nr = nr;
 543         new->fid = -1;
 544         new->mid = 0;
 545
 546         return new;
 547 }
 548
 549 Fsrpc *
 550 getsbuf(void)
 551 {
 552         static int ap;
 553         int look, rounds;
 554         Fsrpc *wb;
 555         int small_instead_of_fast = 1;
 556
 557         if(small_instead_of_fast)
 558                 ap = 0; /* so we always start looking at the beginning and reuse buffers */
 559
 560         for(rounds = 0; rounds < 10; rounds++) {
 561                 for(look = 0; look < Nr_workbufs; look++) {
 562                         if(++ap == Nr_workbufs)
 563                                 ap = 0;
 564                         if(Workq[ap].busy == 0)
 565                                 break;
 566                 }
 567
 568                 if(look == Nr_workbufs){
 569                         sleep(10 * rounds);
 570                         continue;
 571                 }
 572
 573                 wb = &Workq[ap];
 574                 wb->pid = 0;
 575                 wb->canint = 0;
 576                 wb->flushtag = NOTAG;
 577                 wb->busy = 1;
 578                 if(wb->buf == nil)      /* allocate buffers dynamically to keep size down */
 579                         wb->buf = emallocz(messagesize);
 580                 return wb;
 581         }
 582         fatal("No more work buffers");
 583         return nil;
 584 }
 585
 586 void
 587 freefile(File *f)
 588 {
 589         File *parent, *child;
 590
 591 Loop:
 592         f->ref--;
 593         if(f->ref > 0)
 594                 return;
 595         freecnt++;
 596         if(f->ref < 0) abort();
 597         DEBUG(DFD, "free %s\n", f->name);
 598         /* delete from parent */
 599         parent = f->parent;
 600         if(parent->child == f)
 601                 parent->child = f->childlist;
 602         else{
 603                 for(child=parent->child; child->childlist!=f; child=child->childlist)
 604                         if(child->childlist == nil)
 605                                 fatal("bad child list");
 606                 child->childlist = f->childlist;
 607         }
 608         freeqid(f->qidt);
 609         free(f->name);
 610         f->name = nil;
 611         free(f);
 612         f = parent;
 613         if(f != nil)
 614                 goto Loop;
 615 }
 616
 617 File *
 618 file(File *parent, char *name)
 619 {
 620         Dir *dir;
 621         char *path;
 622         File *f;
 623
 624         DEBUG(DFD, "\tfile: 0x%p %s name %s\n", parent, parent->name, name);
 625
 626         path = makepath(parent, name);
 627         if(patternfile != nil && excludefile(path)){
 628                 free(path);
 629                 return nil;
 630         }
 631         dir = dirstat(path);
 632         free(path);
 633         if(dir == nil)
 634                 return nil;
 635
 636         for(f = parent->child; f; f = f->childlist)
 637                 if(strcmp(name, f->name) == 0)
 638                         break;
 639
 640         if(f == nil){
 641                 f = emallocz(sizeof(File));
 642                 f->name = estrdup(name);
 643
 644                 f->parent = parent;
 645                 f->childlist = parent->child;
 646                 parent->child = f;
 647                 parent->ref++;
 648                 f->ref = 0;
 649                 filecnt++;
 650         }
 651         f->ref++;
 652         f->qid.type = dir->qid.type;
 653         f->qid.vers = dir->qid.vers;
 654         f->qidt = uniqueqid(dir);
 655         f->qid.path = f->qidt->uniqpath;
 656
 657         f->inval = 0;
 658
 659         free(dir);
 660
 661         return f;
 662 }
 663
 664 void
 665 initroot(void)
 666 {
 667         Dir *dir;
 668
 669         root = emallocz(sizeof(File));
 670         root->name = estrdup(".");
 671
 672         dir = dirstat(root->name);
 673         if(dir == nil)
 674                 fatal("root stat");
 675
 676         root->ref = 1;
 677         root->qid.vers = dir->qid.vers;
 678         root->qidt = uniqueqid(dir);
 679         root->qid.path = root->qidt->uniqpath;
 680         root->qid.type = QTDIR;
 681         free(dir);
 682
 683         psmpt = emallocz(sizeof(File));
 684         psmpt->name = estrdup("/");
 685
 686         dir = dirstat(psmpt->name);
 687         if(dir == nil)
 688                 return;
 689
 690         psmpt->ref = 1;
 691         psmpt->qid.vers = dir->qid.vers;
 692         psmpt->qidt = uniqueqid(dir);
 693         psmpt->qid.path = psmpt->qidt->uniqpath;
 694         free(dir);
 695
 696         psmpt = file(psmpt, "mnt");
 697         if(psmpt == 0)
 698                 return;
 699         psmpt = file(psmpt, "exportfs");
 700 }
 701
 702 char*
 703 makepath(File *p, char *name)
 704 {
 705         int i, n;
 706         char *c, *s, *path, *seg[256];
 707
 708         seg[0] = name;
 709         n = strlen(name)+2;
 710         for(i = 1; i < 256 && p; i++, p = p->parent){
 711                 seg[i] = p->name;
 712                 n += strlen(p->name)+1;
 713         }
 714         path = malloc(n);
 715         if(path == nil)
 716                 fatal("out of memory");
 717         s = path;
 718
 719         while(i--) {
 720                 for(c = seg[i]; *c; c++)
 721                         *s++ = *c;
 722                 *s++ = '/';
 723         }
 724         while(s[-1] == '/')
 725                 s--;
 726         *s = '\0';
 727
 728         return path;
 729 }
 730
 731 int
 732 qidhash(vlong path)
 733 {
 734         int h, n;
 735
 736         h = 0;
 737         for(n=0; n<64; n+=Nqidbits){
 738                 h ^= path;
 739                 path >>= Nqidbits;
 740         }
 741         return h & (Nqidtab-1);
 742 }
 743
 744 void
 745 freeqid(Qidtab *q)
 746 {
 747         ulong h;
 748         Qidtab *l;
 749
 750         q->ref--;
 751         if(q->ref > 0)
 752                 return;
 753         qfreecnt++;
 754         h = qidhash(q->path);
 755         if(qidtab[h] == q)
 756                 qidtab[h] = q->next;
 757         else{
 758                 for(l=qidtab[h]; l->next!=q; l=l->next)
 759                         if(l->next == nil)
 760                                 fatal("bad qid list");
 761                 l->next = q->next;
 762         }
 763         free(q);
 764 }
 765
 766 Qidtab*
 767 qidlookup(Dir *d)
 768 {
 769         ulong h;
 770         Qidtab *q;
 771
 772         h = qidhash(d->qid.path);
 773         for(q=qidtab[h]; q!=nil; q=q->next)
 774                 if(q->type==d->type && q->dev==d->dev && q->path==d->qid.path)
 775                         return q;
 776         return nil;
 777 }
 778
 779 int
 780 qidexists(vlong path)
 781 {
 782         int h;
 783         Qidtab *q;
 784
 785         for(h=0; h<Nqidtab; h++)
 786                 for(q=qidtab[h]; q!=nil; q=q->next)
 787                         if(q->uniqpath == path)
 788                                 return 1;
 789         return 0;
 790 }
 791
 792 Qidtab*
 793 uniqueqid(Dir *d)
 794 {
 795         ulong h;
 796         vlong path;
 797         Qidtab *q;
 798
 799         q = qidlookup(d);
 800         if(q != nil){
 801                 q->ref++;
 802                 return q;
 803         }
 804         path = d->qid.path;
 805         while(qidexists(path)){
 806                 DEBUG(DFD, "collision on %s\n", d->name);
 807                 /* collision: find a new one */
 808                 ncollision++;
 809                 path &= QIDPATH;
 810                 ++newqid;
 811                 if(newqid >= (1<<16)){
 812                         DEBUG(DFD, "collision wraparound\n");
 813                         newqid = 1;
 814                 }
 815                 path |= newqid<<48;
 816                 DEBUG(DFD, "assign qid %.16llux\n", path);
 817         }
 818         q = mallocz(sizeof(Qidtab), 1);
 819         if(q == nil)
 820                 fatal("no memory for qid table");
 821         qidcnt++;
 822         q->ref = 1;
 823         q->type = d->type;
 824         q->dev = d->dev;
 825         q->path = d->qid.path;
 826         q->uniqpath = path;
 827         h = qidhash(d->qid.path);
 828         q->next = qidtab[h];
 829         qidtab[h] = q;
 830         return q;
 831 }
 832
 833 void
 834 fatal(char *s, ...)
 835 {
 836         char buf[ERRMAX];
 837         va_list arg;
 838         Proc *m;
 839
 840         if (s) {
 841                 va_start(arg, s);
 842                 vsnprint(buf, ERRMAX, s, arg);
 843                 va_end(arg);
 844         }
 845
 846         /* Clear away the slave children */
 847         for(m = Proclist; m; m = m->next)
 848                 postnote(PNPROC, m->pid, "kill");
 849
 850         if (s) {
 851                 DEBUG(DFD, "%s\n", buf);
 852                 sysfatal("%s", buf);    /* caution: buf could contain '%' */
 853         } else
 854                 exits(nil);
 855 }
 856
 857 void*
 858 emallocz(uint n)
 859 {
 860         void *p;
 861
 862         p = mallocz(n, 1);
 863         if(p == nil)
 864                 fatal(Enomem);
 865         setmalloctag(p, getcallerpc(&n));
 866         return p;
 867 }
 868
 869 char*
 870 estrdup(char *s)
 871 {
 872         char *t;
 873
 874         t = strdup(s);
 875         if(t == nil)
 876                 fatal(Enomem);
 877         setmalloctag(t, getcallerpc(&s));
 878         return t;
 879 }
 880
 881 /* Network on fd1, mount driver on fd0 */
 882 int
 883 filter(int fd, char *cmd)
 884 {
 885         char buf[128], devdir[40], *s, *file, *argv[16];
 886         int p[2], lfd, len, argc;
 887
 888         /* Get a free port and post it to the client. */
 889         if (announce(anstring, devdir) < 0)
 890                 fatal("filter: Cannot announce %s: %r", anstring);
 891
 892         snprint(buf, sizeof(buf), "%s/local", devdir);
 893         if ((lfd = open(buf, OREAD)) < 0)
 894                 fatal("filter: Cannot open %s: %r", buf);
 895         if ((len = read(lfd, buf, sizeof buf - 1)) < 0)
 896                 fatal("filter: Cannot read %s: %r", buf);
 897         close(lfd);
 898         buf[len] = '\0';
 899         if ((s = strchr(buf, '\n')) != nil)
 900                 len = s - buf;
 901         if (write(fd, buf, len) != len)
 902                 fatal("filter: cannot write port; %r");
 903
 904         snprint(buf, sizeof(buf), "%s", cmd);
 905         argc = tokenize(buf, argv, nelem(argv)-2);
 906         if (argc == 0)
 907                 fatal("filter: empty command");
 908         argv[argc++] = devdir;
 909         argv[argc] = nil;
 910         file = argv[0];
 911         if (s = strrchr(argv[0], '/'))
 912                 argv[0] = s+1;
 913
 914         if(pipe(p) < 0)
 915                 fatal("filter: pipe; %r");
 916
 917         switch(rfork(RFNOWAIT|RFPROC|RFMEM|RFFDG|RFREND)) {
 918         case -1:
 919                 fatal("filter: rfork; %r\n");
 920         case 0:
 921                 if (dup(p[0], 1) < 0)
 922                         fatal("filter: Cannot dup to 1; %r");
 923                 if (dup(p[0], 0) < 0)
 924                         fatal("filter: Cannot dup to 0; %r");
 925                 close(p[0]);
 926                 close(p[1]);
 927                 exec(file, argv);
 928                 fatal("filter: exec; %r");
 929         default:
 930                 close(fd);
 931                 close(p[0]);
 932         }
 933         return p[1];
 934 }
 935
 936 static void
 937 mksecret(char *t, uchar *f)
 938 {
 939         sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux",
 940                 f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]);
 941 }