sys/src/cmd/cpu.c

   1 /*
   2  * cpu.c - Make a connection to a cpu server
   3  *
   4  *         Invoked by listen as 'cpu -R | -N service net netdir'
   5  *                 by users  as 'cpu [-h system] [-c cmd args ...]'
   6  */
   7
   8 #include <u.h>
   9 #include <libc.h>
  10 #include <auth.h>
  11 #include <fcall.h>
  12 #include <libsec.h>
  13
  14 #define Maxfdata 8192
  15 #define MaxStr 128
  16
  17 void    remoteside(int);
  18 void    fatal(char*, ...);
  19 void    lclnoteproc(int);
  20 void    rmtnoteproc(void);
  21 void    catcher(void*, char*);
  22 void    usage(void);
  23 void    writestr(int, char*, char*, int);
  24 int     readstr(int, char*, int);
  25 char    *rexcall(int*, char*, char*);
  26 int     setamalg(char*);
  27 char *keyspec = "";
  28
  29 int     notechan;
  30 int     exportpid;
  31 char    *system;
  32 int     cflag;
  33 int     nflag;
  34 int     dbg;
  35 char    *user;
  36 char    *patternfile;
  37 char    *origargs;
  38
  39 char    *srvname = "ncpu";
  40 char    *exportfs = "/bin/exportfs";
  41 char    *ealgs = "rc4_256 sha1";
  42
  43 /* message size for exportfs; may be larger so we can do big graphics in CPU window */
  44 int     msgsize = Maxfdata+IOHDRSZ;
  45
  46 /* authentication mechanisms */
  47 static int      netkeyauth(int);
  48 static int      netkeysrvauth(int, char*);
  49 static int      p9auth(int);
  50 static int      srvp9auth(int, char*);
  51 static int      noauth(int);
  52 static int      srvnoauth(int, char*);
  53
  54 typedef struct AuthMethod AuthMethod;
  55 struct AuthMethod {
  56         char    *name;                  /* name of method */
  57         int     (*cf)(int);             /* client side authentication */
  58         int     (*sf)(int, char*);      /* server side authentication */
  59 } authmethod[] =
  60 {
  61         { "p9",         p9auth,         srvp9auth,},
  62         { "netkey",     netkeyauth,     netkeysrvauth,},
  63         { "none",       noauth,         srvnoauth,},
  64         { nil,  nil}
  65 };
  66 AuthMethod *am = authmethod;    /* default is p9 */
  67
  68 char *p9authproto = "p9any";
  69
  70 int setam(char*);
  71
  72 char    *aan = "/bin/aan";
  73 char    *anstring = "tcp!*!0";
  74 char    *filterp = nil;
  75
  76 int     filter(int fd, char *host);
  77
  78 void
  79 usage(void)
  80 {
  81         fprint(2, "usage: cpu [-p] [-h system] [-u user] [-a authmethod] "
  82                 "[-e 'crypt hash'] [-k keypattern] [-P patternfile] "
  83                 "[-c cmd arg ...]\n");
  84         exits("usage");
  85 }
  86
  87 /*
  88  * reading /proc/pid/args yields either "name args" or "name [display args]",
  89  * so return only args or display args.
  90  */
  91 static char *
  92 procgetname(void)
  93 {
  94         int fd, n;
  95         char *lp, *rp;
  96         char buf[256];
  97
  98         snprint(buf, sizeof buf, "#p/%d/args", getpid());
  99         if((fd = open(buf, OREAD)) < 0)
 100                 return strdup("");
 101         *buf = '\0';
 102         n = read(fd, buf, sizeof buf-1);
 103         close(fd);
 104         if (n >= 0)
 105                 buf[n] = '\0';
 106         if ((lp = strchr(buf, '[')) == nil || (rp = strrchr(buf, ']')) == nil) {
 107                 lp = strchr(buf, ' ');
 108                 if (lp == nil)
 109                         return strdup("");
 110                 else
 111                         return strdup(lp+1);
 112         }
 113         *rp = '\0';
 114         return strdup(lp+1);
 115 }
 116
 117 /*
 118  * based on libthread's threadsetname, but drags in less library code.
 119  * actually just sets the arguments displayed.
 120  */
 121 void
 122 procsetname(char *fmt, ...)
 123 {
 124         int fd;
 125         char *cmdname;
 126         char buf[128];
 127         va_list arg;
 128
 129         va_start(arg, fmt);
 130         cmdname = vsmprint(fmt, arg);
 131         va_end(arg);
 132         if (cmdname == nil)
 133                 return;
 134         snprint(buf, sizeof buf, "#p/%d/args", getpid());
 135         if((fd = open(buf, OWRITE)) >= 0){
 136                 write(fd, cmdname, strlen(cmdname)+1);
 137                 close(fd);
 138         }
 139         free(cmdname);
 140 }
 141
 142 void
 143 main(int argc, char **argv)
 144 {
 145         char dat[MaxStr], buf[MaxStr], cmd[MaxStr], *p, *s, *err;
 146         int ac, fd, ms, data;
 147         char *av[10];
 148
 149         quotefmtinstall();
 150         origargs = procgetname();
 151         /* see if we should use a larger message size */
 152         fd = open("/dev/draw", OREAD);
 153         if(fd > 0){
 154                 ms = iounit(fd);
 155                 if(msgsize < ms+IOHDRSZ)
 156                         msgsize = ms+IOHDRSZ;
 157                 close(fd);
 158         }
 159
 160         user = getuser();
 161         if(user == nil)
 162                 fatal("can't read user name: %r");
 163         ARGBEGIN{
 164         case 'a':
 165                 p = EARGF(usage());
 166                 if(setam(p) < 0)
 167                         fatal("unknown auth method %s", p);
 168                 break;
 169         case 'e':
 170                 ealgs = EARGF(usage());
 171                 if(*ealgs == 0 || strcmp(ealgs, "clear") == 0)
 172                         ealgs = nil;
 173                 break;
 174         case 'd':
 175                 dbg++;
 176                 break;
 177         case 'f':
 178                 /* ignored but accepted for compatibility */
 179                 break;
 180         case 'n':
 181                 /* must be specified before -R/-O */
 182                 nflag++;
 183                 break;
 184         case 'A':
 185                 anstring = EARGF(usage());
 186                 break;
 187         case 'O':
 188                 p9authproto = "p9sk2";
 189                 remoteside(1);                          /* From listen */
 190                 break;
 191         case 'R':                               /* From listen */
 192                 remoteside(0);
 193                 break;
 194         case 'h':
 195                 system = EARGF(usage());
 196                 break;
 197         case 'c':
 198                 cflag++;
 199                 s = cmd;
 200                 *s++ = '!';
 201                 *s = 0;
 202                 while(p = ARGF())
 203                         s = seprint(s, cmd+sizeof(cmd), " %s", p);
 204                 break;
 205         case 'k':
 206                 keyspec = smprint("%s %s", keyspec, EARGF(usage()));
 207                 break;
 208         case 'P':
 209                 patternfile = EARGF(usage());
 210                 break;
 211         case 'u':
 212                 user = EARGF(usage());
 213                 keyspec = smprint("%s user=%s", keyspec, user);
 214                 break;
 215         case 'p':
 216                 filterp = aan;
 217                 break;
 218         default:
 219                 usage();
 220         }ARGEND;
 221
 222
 223         if(argc != 0)
 224                 usage();
 225
 226         if(system == nil) {
 227                 p = getenv("cpu");
 228                 if(p == 0)
 229                         fatal("set $cpu");
 230                 system = p;
 231         }
 232
 233         if(err = rexcall(&data, system, srvname))
 234                 fatal("%s: %s: %r", err, system);
 235
 236         procsetname("%s", origargs);
 237         /* Tell the remote side the command to execute and where our working directory is */
 238         if(cflag)
 239                 writestr(data, cmd, "command", 0);
 240         if(getwd(dat, sizeof(dat)) == 0)
 241                 writestr(data, "NO", "dir", 0);
 242         else
 243                 writestr(data, dat, "dir", 0);
 244
 245         /* start up a process to pass along notes */
 246         lclnoteproc(data);
 247
 248         /*
 249          *  Wait for the other end to execute and start our file service
 250          *  of /mnt/term
 251          */
 252         if(readstr(data, buf, sizeof(buf)) < 0)
 253                 fatal("waiting for FS: %r");
 254         if(strncmp("FS", buf, 2) != 0) {
 255                 print("remote cpu: %s", buf);
 256                 exits(buf);
 257         }
 258
 259         /* Begin serving the gnot namespace */
 260         close(0);
 261         dup(data, 0);
 262         close(data);
 263
 264         sprint(buf, "%d", msgsize);
 265         ac = 0;
 266         av[ac++] = exportfs;
 267         av[ac++] = "-m";
 268         av[ac++] = buf;
 269         if(dbg)
 270                 av[ac++] = "-d";
 271         if(patternfile != nil){
 272                 av[ac++] = "-P";
 273                 av[ac++] = patternfile;
 274         }
 275         av[ac] = nil;
 276         exec(exportfs, av);
 277         fatal("starting exportfs: %r");
 278 }
 279
 280 void
 281 fatal(char *fmt, ...)
 282 {
 283         char buf[1024];
 284         va_list arg;
 285
 286         va_start(arg, fmt);
 287         vsnprint(buf, sizeof(buf), fmt, arg);
 288         va_end(arg);
 289         fprint(2, "cpu: %s\n", buf);
 290         syslog(0, "cpu", "%s", buf);
 291         exits(buf);
 292 }
 293
 294 char *negstr = "negotiating authentication method";
 295
 296 int
 297 old9p(int fd)
 298 {
 299         int p[2];
 300
 301         if(pipe(p) < 0)
 302                 fatal("pipe: %r");
 303
 304         switch(rfork(RFPROC|RFMEM|RFFDG|RFNAMEG|RFREND)) {
 305         case -1:
 306                 fatal("rfork srvold9p: %r");
 307         case 0:
 308                 if(fd != 1){
 309                         dup(fd, 1);
 310                         close(fd);
 311                 }
 312                 if(p[0] != 0){
 313                         dup(p[0], 0);
 314                         close(p[0]);
 315                 }
 316                 close(p[1]);
 317                 if(0){
 318                         fd = open("/sys/log/cpu", OWRITE);
 319                         if(fd != 2){
 320                                 dup(fd, 2);
 321                                 close(fd);
 322                         }
 323                         execl("/bin/srvold9p", "srvold9p", "-ds", nil);
 324                 } else
 325                         execl("/bin/srvold9p", "srvold9p", "-s", nil);
 326                 fatal("exec srvold9p: %r");
 327         default:
 328                 close(fd);
 329                 close(p[0]);
 330         }
 331         return p[1];
 332 }
 333
 334 /* Invoked with stdin and stdout connected to the network connection */
 335 void
 336 remoteside(int old)
 337 {
 338         char user[MaxStr], home[MaxStr], buf[MaxStr], xdir[MaxStr], cmd[MaxStr];
 339         int i, n, fd, badchdir, gotcmd;
 340
 341         rfork(RFENVG);
 342         putenv("service", "cpu");
 343         fd = 0;
 344
 345         /* negotiate authentication mechanism */
 346         n = readstr(fd, cmd, sizeof(cmd));
 347         if(n < 0)
 348                 fatal("authenticating: %r");
 349         filterp = nil;
 350         if(!old && strcmp(cmd, "aan") == 0){
 351                 filterp = aan;
 352                 writestr(fd, "", nil, 1);
 353                 n = readstr(fd, cmd, sizeof(cmd));
 354                 if(n < 0)
 355                         fatal("authenticating: %r");
 356         }
 357         if(setamalg(cmd) < 0 || (nflag == 0 && am->sf == srvnoauth)) {
 358                 writestr(fd, "unsupported auth method", nil, 0);
 359                 fatal("bad auth method %s", cmd);
 360         } else
 361                 writestr(fd, "", "", 1);
 362
 363         fd = (*am->sf)(fd, user);
 364         if(fd < 0)
 365                 fatal("srvauth: %r");
 366
 367         /* Set environment values for the user */
 368         putenv("user", user);
 369         snprint(home, sizeof(home), "/usr/%s", user);
 370         putenv("home", home);
 371
 372         /* Now collect invoking cpu's current directory or possibly a command */
 373         gotcmd = 0;
 374         if(readstr(fd, xdir, sizeof(xdir)) < 0)
 375                 fatal("dir/cmd: %r");
 376         if(xdir[0] == '!') {
 377                 strcpy(cmd, &xdir[1]);
 378                 gotcmd = 1;
 379                 if(readstr(fd, xdir, sizeof(xdir)) < 0)
 380                         fatal("dir: %r");
 381         }
 382
 383         /* Establish the new process at the current working directory of the
 384          * gnot */
 385         badchdir = 0;
 386         if(strcmp(xdir, "NO") == 0)
 387                 chdir(home);
 388         else if(chdir(xdir) < 0) {
 389                 badchdir = 1;
 390                 chdir(home);
 391         }
 392
 393         /* Start the gnot serving its namespace */
 394         writestr(fd, "FS", "FS", 0);
 395         writestr(fd, "/", "exportfs dir", 0);
 396
 397         n = read(fd, buf, sizeof(buf));
 398         if(n != 2 || buf[0] != 'O' || buf[1] != 'K')
 399                 exits("remote tree");
 400
 401         if(old)
 402                 fd = old9p(fd);
 403
 404         /* make sure buffers are big by doing fversion explicitly; pick a huge number; other side will trim */
 405         strcpy(buf, VERSION9P);
 406         if(fversion(fd, 64*1024, buf, sizeof buf) < 0)
 407                 exits("fversion failed");
 408         if(mount(fd, -1, "/mnt/term", MCREATE|MREPL, "") < 0)
 409                 exits("mount failed");
 410
 411         close(fd);
 412
 413         /* the remote noteproc uses the mount so it must follow it */
 414         rmtnoteproc();
 415
 416         for(i = 0; i < 3; i++)
 417                 close(i);
 418
 419         if(open("/mnt/term/dev/cons", OREAD) != 0)
 420                 exits("open stdin");
 421         if(open("/mnt/term/dev/cons", OWRITE) != 1)
 422                 exits("open stdout");
 423         dup(1, 2);
 424
 425         if(badchdir)
 426                 print("cpu: failed to chdir to '%s'\n", xdir);
 427
 428         if(gotcmd)
 429                 execl("/bin/rc", "rc", "-lc", cmd, nil);
 430         else
 431                 execl("/bin/rc", "rc", "-li", nil);
 432         fatal("exec shell: %r");
 433 }
 434
 435 char*
 436 rexcall(int *fd, char *host, char *service)
 437 {
 438         char *na;
 439         char dir[MaxStr];
 440         char err[ERRMAX];
 441         char msg[MaxStr];
 442         int n;
 443
 444         na = netmkaddr(host, 0, service);
 445         procsetname("dialing %s", na);
 446         if((*fd = dial(na, 0, dir, 0)) < 0)
 447                 return "can't dial";
 448
 449         /* negotiate aan filter extension */
 450         if(filterp == aan){
 451                 writestr(*fd, "aan", "negotiating aan", 0);
 452                 n = readstr(*fd, err, sizeof err);
 453                 if(n < 0)
 454                         return "negotiating aan";
 455                 if(*err){
 456                         werrstr(err);
 457                         return negstr;
 458                 }
 459         }
 460
 461         /* negotiate authentication mechanism */
 462         if(ealgs != nil)
 463                 snprint(msg, sizeof(msg), "%s %s", am->name, ealgs);
 464         else
 465                 snprint(msg, sizeof(msg), "%s", am->name);
 466         procsetname("writing %s", msg);
 467         writestr(*fd, msg, negstr, 0);
 468         procsetname("awaiting auth method");
 469         n = readstr(*fd, err, sizeof err);
 470         if(n < 0)
 471                 return negstr;
 472         if(*err){
 473                 werrstr(err);
 474                 return negstr;
 475         }
 476
 477         /* authenticate */
 478         procsetname("%s: auth via %s", origargs, am->name);
 479         *fd = (*am->cf)(*fd);
 480         if(*fd < 0)
 481                 return "can't authenticate";
 482         return 0;
 483 }
 484
 485 void
 486 writestr(int fd, char *str, char *thing, int ignore)
 487 {
 488         int l, n;
 489
 490         l = strlen(str);
 491         n = write(fd, str, l+1);
 492         if(!ignore && n < 0)
 493                 fatal("writing network: %s: %r", thing);
 494 }
 495
 496 int
 497 readstr(int fd, char *str, int len)
 498 {
 499         int n;
 500
 501         while(len) {
 502                 n = read(fd, str, 1);
 503                 if(n < 0)
 504                         return -1;
 505                 if(*str == '\0')
 506                         return 0;
 507                 str++;
 508                 len--;
 509         }
 510         return -1;
 511 }
 512
 513 static int
 514 readln(char *buf, int n)
 515 {
 516         int i;
 517         char *p;
 518
 519         n--;    /* room for \0 */
 520         p = buf;
 521         for(i=0; i<n; i++){
 522                 if(read(0, p, 1) != 1)
 523                         break;
 524                 if(*p == '\n' || *p == '\r')
 525                         break;
 526                 p++;
 527         }
 528         *p = '\0';
 529         return p-buf;
 530 }
 531
 532 /*
 533  *  user level challenge/response
 534  */
 535 static int
 536 netkeyauth(int fd)
 537 {
 538         char chall[32];
 539         char resp[32];
 540
 541         strecpy(chall, chall+sizeof chall, getuser());
 542         print("user[%s]: ", chall);
 543         if(readln(resp, sizeof(resp)) < 0)
 544                 return -1;
 545         if(*resp != 0)
 546                 strcpy(chall, resp);
 547         writestr(fd, chall, "challenge/response", 1);
 548
 549         for(;;){
 550                 if(readstr(fd, chall, sizeof chall) < 0)
 551                         break;
 552                 if(*chall == 0)
 553                         return filter(fd, system);
 554                 print("challenge: %s\nresponse: ", chall);
 555                 if(readln(resp, sizeof(resp)) < 0)
 556                         break;
 557                 writestr(fd, resp, "challenge/response", 1);
 558         }
 559         return -1;
 560 }
 561
 562 static int
 563 netkeysrvauth(int fd, char *user)
 564 {
 565         char response[32];
 566         Chalstate *ch;
 567         int tries;
 568         AuthInfo *ai;
 569
 570         if(readstr(fd, user, MaxStr) < 0)
 571                 return -1;
 572
 573         ai = nil;
 574         ch = nil;
 575         for(tries = 0; tries < 10; tries++){
 576                 if((ch = auth_challenge("proto=p9cr role=server user=%q", user)) == nil)
 577                         return -1;
 578                 writestr(fd, ch->chal, "challenge", 1);
 579                 if(readstr(fd, response, sizeof response) < 0)
 580                         return -1;
 581                 ch->resp = response;
 582                 ch->nresp = strlen(response);
 583                 if((ai = auth_response(ch)) != nil)
 584                         break;
 585         }
 586         auth_freechal(ch);
 587         if(ai == nil)
 588                 return -1;
 589         writestr(fd, "", "challenge", 1);
 590         if(auth_chuid(ai, 0) < 0)
 591                 fatal("newns: %r");
 592         auth_freeAI(ai);
 593         return filter(fd, nil);
 594 }
 595
 596 static void
 597 mksecret(char *t, uchar *f)
 598 {
 599         sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux",
 600                 f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]);
 601 }
 602
 603 /*
 604  *  plan9 authentication followed by rc4 encryption
 605  */
 606 static int
 607 p9auth(int fd)
 608 {
 609         uchar key[16], digest[SHA1dlen];
 610         char fromclientsecret[21];
 611         char fromserversecret[21];
 612         AuthInfo *ai;
 613         int i;
 614
 615         procsetname("%s: auth_proxy proto=%q role=client %s",
 616                 origargs, p9authproto, keyspec);
 617         ai = auth_proxy(fd, auth_getkey, "proto=%q role=client %s", p9authproto, keyspec);
 618         if(ai == nil)
 619                 return -1;
 620         if(ealgs == nil){
 621                 auth_freeAI(ai);
 622                 return fd;
 623         }
 624         assert(ai->nsecret <= sizeof(key)-4);
 625         memmove(key+4, ai->secret, ai->nsecret);
 626         auth_freeAI(ai);
 627
 628         /* exchange random numbers */
 629         srand(truerand());
 630         for(i = 0; i < 4; i++)
 631                 key[i] = rand();
 632         procsetname("writing p9 key");
 633         if(write(fd, key, 4) != 4)
 634                 return -1;
 635         procsetname("reading p9 key");
 636         if(readn(fd, key+12, 4) != 4)
 637                 return -1;
 638
 639         /* scramble into two secrets */
 640         sha1(key, sizeof(key), digest, nil);
 641         mksecret(fromclientsecret, digest);
 642         mksecret(fromserversecret, digest+10);
 643
 644         if((fd = filter(fd, system)) < 0)
 645                 return -1;
 646
 647         /* set up encryption */
 648         procsetname("pushssl");
 649         fd = pushssl(fd, ealgs, fromclientsecret, fromserversecret, nil);
 650         if(fd < 0)
 651                 werrstr("can't establish ssl connection: %r");
 652         return fd;
 653 }
 654
 655 static int
 656 noauth(int fd)
 657 {
 658         ealgs = nil;
 659         return fd;
 660 }
 661
 662 static int
 663 srvnoauth(int fd, char *user)
 664 {
 665         strecpy(user, user+MaxStr, getuser());
 666         ealgs = nil;
 667         newns(user, nil);
 668         return fd;
 669 }
 670
 671 void
 672 loghex(uchar *p, int n)
 673 {
 674         char buf[100];
 675         int i;
 676
 677         for(i = 0; i < n; i++)
 678                 sprint(buf+2*i, "%2.2ux", p[i]);
 679         syslog(0, "cpu", "%s", buf);
 680 }
 681
 682 static int
 683 srvp9auth(int fd, char *user)
 684 {
 685         uchar key[16], digest[SHA1dlen];
 686         char fromclientsecret[21];
 687         char fromserversecret[21];
 688         AuthInfo *ai;
 689         int i;
 690
 691         ai = auth_proxy(fd, nil, "proto=%q role=server %s", p9authproto, keyspec);
 692         if(ai == nil)
 693                 return -1;
 694         if(auth_chuid(ai, nil) < 0)
 695                 fatal("newns: %r");
 696         snprint(user, MaxStr, "%s", ai->cuid);
 697         if(ealgs == nil){
 698                 auth_freeAI(ai);
 699                 return fd;
 700         }
 701         assert(ai->nsecret <= sizeof(key)-4);
 702         memmove(key+4, ai->secret, ai->nsecret);
 703         auth_freeAI(ai);
 704
 705         /* exchange random numbers */
 706         srand(truerand());
 707         for(i = 0; i < 4; i++)
 708                 key[i+12] = rand();
 709         if(readn(fd, key, 4) != 4)
 710                 return -1;
 711         if(write(fd, key+12, 4) != 4)
 712                 return -1;
 713
 714         /* scramble into two secrets */
 715         sha1(key, sizeof(key), digest, nil);
 716         mksecret(fromclientsecret, digest);
 717         mksecret(fromserversecret, digest+10);
 718
 719         if((fd = filter(fd, nil)) < 0)
 720                 return -1;
 721
 722         /* set up encryption */
 723         fd = pushssl(fd, ealgs, fromserversecret, fromclientsecret, nil);
 724         if(fd < 0)
 725                 werrstr("can't establish ssl connection: %r");
 726         return fd;
 727 }
 728
 729 /*
 730  *  set authentication mechanism
 731  */
 732 int
 733 setam(char *name)
 734 {
 735         for(am = authmethod; am->name != nil; am++)
 736                 if(strcmp(am->name, name) == 0)
 737                         return 0;
 738         am = authmethod;
 739         return -1;
 740 }
 741
 742 /*
 743  *  set authentication mechanism and encryption/hash algs
 744  */
 745 int
 746 setamalg(char *s)
 747 {
 748         ealgs = strchr(s, ' ');
 749         if(ealgs != nil)
 750                 *ealgs++ = 0;
 751         return setam(s);
 752 }
 753
 754 int
 755 filter(int fd, char *host)
 756 {
 757         char addr[128], buf[256], *s, *file, *argv[16];
 758         int p[2], lfd, flags, len, argc;
 759
 760         if(filterp == nil)
 761                 return fd;
 762         procsetname("filter %s", filterp);
 763         flags = RFNOWAIT|RFPROC|RFMEM|RFFDG|RFREND;
 764         if(host == nil){
 765                 /* remote side */
 766                 if(announce(anstring, addr) < 0)
 767                         fatal("filter: Cannot announce %s: %r", anstring);
 768                 snprint(buf, sizeof(buf), "%s/local", addr);
 769                 if((lfd = open(buf, OREAD)) < 0)
 770                         fatal("filter: Cannot open %s: %r", buf);
 771                 if((len = read(lfd, buf, sizeof buf - 1)) < 0)
 772                         fatal("filter: Cannot read %s: %r", buf);
 773                 close(lfd);
 774                 buf[len] = 0;
 775                 if(s = strchr(buf, '\n'))
 776                         len = s - buf;
 777                 if(write(fd, buf, len) != len)
 778                         fatal("filter: cannot write port; %r");
 779         } else {
 780                 /* client side */
 781                 flags |= RFNOTEG;
 782                 if((len = read(fd, buf, sizeof buf - 1)) < 0)
 783                         fatal("filter: cannot read port; %r");
 784                 buf[len] = '\0';
 785                 if((s = strrchr(buf, '!')) == nil)
 786                         fatal("filter: malformed remote port: %s", buf);
 787                 snprint(addr, sizeof(addr), "%s", netmkaddr(host, "tcp", s+1));
 788         }
 789
 790         snprint(buf, sizeof(buf), "%s", filterp);
 791         if((argc = tokenize(buf, argv, nelem(argv)-3)) <= 0)
 792                 fatal("filter: empty command");
 793         if(host)
 794                 argv[argc++] = "-c";
 795         argv[argc++] = addr;
 796         argv[argc] = nil;
 797         file = argv[0];
 798         if(s = strrchr(argv[0], '/'))
 799                 argv[0] = s+1;
 800
 801         if(pipe(p) < 0)
 802                 fatal("filter: pipe; %r");
 803
 804         switch(rfork(flags)) {
 805         case -1:
 806                 fatal("filter: rfork; %r\n");
 807         case 0:
 808                 if (dup(p[0], 1) < 0)
 809                         fatal("filter: Cannot dup to 1; %r");
 810                 if (dup(p[0], 0) < 0)
 811                         fatal("filter: Cannot dup to 0; %r");
 812                 close(p[0]);
 813                 close(p[1]);
 814                 exec(file, argv);
 815                 fatal("filter: exec; %r");
 816         default:
 817                 close(fd);
 818                 close(p[0]);
 819         }
 820         return p[1];
 821 }
 822
 823 char *rmtnotefile = "/mnt/term/dev/cpunote";
 824
 825 /*
 826  *  loop reading /mnt/term/dev/note looking for notes.
 827  *  The child returns to start the shell.
 828  */
 829 void
 830 rmtnoteproc(void)
 831 {
 832         int n, fd, pid, notepid;
 833         char buf[256];
 834
 835         /* new proc returns to start shell */
 836         pid = rfork(RFPROC|RFFDG|RFNOTEG|RFNAMEG|RFMEM);
 837         switch(pid){
 838         case -1:
 839                 syslog(0, "cpu", "cpu -R: can't start noteproc: %r");
 840                 return;
 841         case 0:
 842                 return;
 843         }
 844
 845         /* new proc reads notes from other side and posts them to shell */
 846         switch(notepid = rfork(RFPROC|RFFDG|RFMEM)){
 847         case -1:
 848                 syslog(0, "cpu", "cpu -R: can't start wait proc: %r");
 849                 _exits(0);
 850         case 0:
 851                 fd = open(rmtnotefile, OREAD);
 852                 if(fd < 0){
 853                         syslog(0, "cpu", "cpu -R: can't open %s", rmtnotefile);
 854                         _exits(0);
 855                 }
 856
 857                 for(;;){
 858                         n = read(fd, buf, sizeof(buf)-1);
 859                         if(n <= 0){
 860                                 postnote(PNGROUP, pid, "hangup");
 861                                 _exits(0);
 862                         }
 863                         buf[n] = 0;
 864                         postnote(PNGROUP, pid, buf);
 865                 }
 866         }
 867
 868         /* original proc waits for shell proc to die and kills note proc */
 869         for(;;){
 870                 n = waitpid();
 871                 if(n < 0 || n == pid)
 872                         break;
 873         }
 874         postnote(PNPROC, notepid, "kill");
 875         _exits(0);
 876 }
 877
 878 enum
 879 {
 880         Qdir,
 881         Qcpunote,
 882
 883         Nfid = 32,
 884 };
 885
 886 struct {
 887         char    *name;
 888         Qid     qid;
 889         ulong   perm;
 890 } fstab[] =
 891 {
 892         [Qdir]          { ".",          {Qdir, 0, QTDIR},       DMDIR|0555      },
 893         [Qcpunote]      { "cpunote",    {Qcpunote, 0},          0444            },
 894 };
 895
 896 typedef struct Note Note;
 897 struct Note
 898 {
 899         Note *next;
 900         char msg[ERRMAX];
 901 };
 902
 903 typedef struct Request Request;
 904 struct Request
 905 {
 906         Request *next;
 907         Fcall f;
 908 };
 909
 910 typedef struct Fid Fid;
 911 struct Fid
 912 {
 913         int     fid;
 914         int     file;
 915         int     omode;
 916 };
 917 Fid fids[Nfid];
 918
 919 struct {
 920         Lock;
 921         Note *nfirst, *nlast;
 922         Request *rfirst, *rlast;
 923 } nfs;
 924
 925 int
 926 fsreply(int fd, Fcall *f)
 927 {
 928         uchar buf[IOHDRSZ+Maxfdata];
 929         int n;
 930
 931         if(dbg)
 932                 fprint(2, "notefs: <-%F\n", f);
 933         n = convS2M(f, buf, sizeof buf);
 934         if(n > 0){
 935                 if(write(fd, buf, n) != n){
 936                         close(fd);
 937                         return -1;
 938                 }
 939         }
 940         return 0;
 941 }
 942
 943 /* match a note read request with a note, reply to the request */
 944 int
 945 kick(int fd)
 946 {
 947         Request *rp;
 948         Note *np;
 949         int rv;
 950
 951         for(;;){
 952                 lock(&nfs);
 953                 rp = nfs.rfirst;
 954                 np = nfs.nfirst;
 955                 if(rp == nil || np == nil){
 956                         unlock(&nfs);
 957                         break;
 958                 }
 959                 nfs.rfirst = rp->next;
 960                 nfs.nfirst = np->next;
 961                 unlock(&nfs);
 962
 963                 rp->f.type = Rread;
 964                 rp->f.count = strlen(np->msg);
 965                 rp->f.data = np->msg;
 966                 rv = fsreply(fd, &rp->f);
 967                 free(rp);
 968                 free(np);
 969                 if(rv < 0)
 970                         return -1;
 971         }
 972         return 0;
 973 }
 974
 975 void
 976 flushreq(int tag)
 977 {
 978         Request **l, *rp;
 979
 980         lock(&nfs);
 981         for(l = &nfs.rfirst; *l != nil; l = &(*l)->next){
 982                 rp = *l;
 983                 if(rp->f.tag == tag){
 984                         *l = rp->next;
 985                         unlock(&nfs);
 986                         free(rp);
 987                         return;
 988                 }
 989         }
 990         unlock(&nfs);
 991 }
 992
 993 Fid*
 994 getfid(int fid)
 995 {
 996         int i, freefid;
 997
 998         freefid = -1;
 999         for(i = 0; i < Nfid; i++){
1000                 if(freefid < 0 && fids[i].file < 0)
1001                         freefid = i;
1002                 if(fids[i].fid == fid)
1003                         return &fids[i];
1004         }
1005         if(freefid >= 0){
1006                 fids[freefid].fid = fid;
1007                 return &fids[freefid];
1008         }
1009         return nil;
1010 }
1011
1012 int
1013 fsstat(int fd, Fid *fid, Fcall *f)
1014 {
1015         Dir d;
1016         uchar statbuf[256];
1017
1018         memset(&d, 0, sizeof(d));
1019         d.name = fstab[fid->file].name;
1020         d.uid = user;
1021         d.gid = user;
1022         d.muid = user;
1023         d.qid = fstab[fid->file].qid;
1024         d.mode = fstab[fid->file].perm;
1025         d.atime = d.mtime = time(0);
1026         f->stat = statbuf;
1027         f->nstat = convD2M(&d, statbuf, sizeof statbuf);
1028         return fsreply(fd, f);
1029 }
1030
1031 int
1032 fsread(int fd, Fid *fid, Fcall *f)
1033 {
1034         Dir d;
1035         uchar buf[256];
1036         Request *rp;
1037
1038         switch(fid->file){
1039         default:
1040                 return -1;
1041         case Qdir:
1042                 if(f->offset == 0 && f->count >0){
1043                         memset(&d, 0, sizeof(d));
1044                         d.name = fstab[Qcpunote].name;
1045                         d.uid = user;
1046                         d.gid = user;
1047                         d.muid = user;
1048                         d.qid = fstab[Qcpunote].qid;
1049                         d.mode = fstab[Qcpunote].perm;
1050                         d.atime = d.mtime = time(0);
1051                         f->count = convD2M(&d, buf, sizeof buf);
1052                         f->data = (char*)buf;
1053                 } else
1054                         f->count = 0;
1055                 return fsreply(fd, f);
1056         case Qcpunote:
1057                 rp = mallocz(sizeof(*rp), 1);
1058                 if(rp == nil)
1059                         return -1;
1060                 rp->f = *f;
1061                 lock(&nfs);
1062                 if(nfs.rfirst == nil)
1063                         nfs.rfirst = rp;
1064                 else
1065                         nfs.rlast->next = rp;
1066                 nfs.rlast = rp;
1067                 unlock(&nfs);
1068                 return kick(fd);;
1069         }
1070 }
1071
1072 char Eperm[] = "permission denied";
1073 char Enofile[] = "out of files";
1074 char Enotdir[] = "not a directory";
1075
1076 void
1077 notefs(int fd)
1078 {
1079         uchar buf[IOHDRSZ+Maxfdata];
1080         int i, n, ncpunote;
1081         Fcall f;
1082         Qid wqid[MAXWELEM];
1083         Fid *fid, *nfid;
1084         int doreply;
1085
1086         rfork(RFNOTEG);
1087         fmtinstall('F', fcallfmt);
1088
1089         for(n = 0; n < Nfid; n++){
1090                 fids[n].file = -1;
1091                 fids[n].omode = -1;
1092         }
1093
1094         ncpunote = 0;
1095         for(;;){
1096                 n = read9pmsg(fd, buf, sizeof(buf));
1097                 if(n < 0){
1098                         if(dbg)
1099                                 fprint(2, "read9pmsg(%d) returns %d: %r\n", fd, n);
1100                         break;
1101                 }
1102                 if(n == 0)
1103                         continue;
1104                 if(convM2S(buf, n, &f) <= BIT16SZ)
1105                         break;
1106                 if(dbg)
1107                         fprint(2, "notefs: ->%F\n", &f);
1108                 doreply = 1;
1109                 fid = getfid(f.fid);
1110                 if(fid == nil){
1111 nofids:
1112                         f.type = Rerror;
1113                         f.ename = Enofile;
1114                         fsreply(fd, &f);
1115                         continue;
1116                 }
1117                 switch(f.type++){
1118                 default:
1119                         f.type = Rerror;
1120                         f.ename = "unknown type";
1121                         break;
1122                 case Tflush:
1123                         flushreq(f.oldtag);
1124                         break;
1125                 case Tversion:
1126                         if(f.msize > IOHDRSZ+Maxfdata)
1127                                 f.msize = IOHDRSZ+Maxfdata;
1128                         break;
1129                 case Tauth:
1130                         f.type = Rerror;
1131                         f.ename = "authentication not required";
1132                         break;
1133                 case Tattach:
1134                         f.qid = fstab[Qdir].qid;
1135                         fid->file = Qdir;
1136                         break;
1137                 case Twalk:
1138                         nfid = nil;
1139                         if(f.newfid != f.fid){
1140                                 nfid = getfid(f.newfid);
1141                                 if(nfid == nil)
1142                                         goto nofids;
1143                                 nfid->file = fid->file;
1144                                 fid = nfid;
1145                         }
1146                         for(i=0; i<f.nwname && i<MAXWELEM; i++){
1147                                 if(fid->file != Qdir){
1148                                         f.type = Rerror;
1149                                         f.ename = Enotdir;
1150                                         break;
1151                                 }
1152                                 if(strcmp(f.wname[i], "..") == 0){
1153                                         wqid[i] = fstab[Qdir].qid;
1154                                         continue;
1155                                 }
1156                                 if(strcmp(f.wname[i], "cpunote") != 0){
1157                                         if(i == 0){
1158                                                 f.type = Rerror;
1159                                                 f.ename = "file does not exist";
1160                                         }
1161                                         break;
1162                                 }
1163                                 fid->file = Qcpunote;
1164                                 wqid[i] = fstab[Qcpunote].qid;
1165                         }
1166                         if(nfid != nil && (f.type == Rerror || i < f.nwname))
1167                                 nfid ->file = -1;
1168                         if(f.type != Rerror){
1169                                 f.nwqid = i;
1170                                 for(i=0; i<f.nwqid; i++)
1171                                         f.wqid[i] = wqid[i];
1172                         }
1173                         break;
1174                 case Topen:
1175                         if(f.mode != OREAD){
1176                                 f.type = Rerror;
1177                                 f.ename = Eperm;
1178                                 break;
1179                         }
1180                         fid->omode = f.mode;
1181                         if(fid->file == Qcpunote)
1182                                 ncpunote++;
1183                         f.qid = fstab[fid->file].qid;
1184                         f.iounit = 0;
1185                         break;
1186                 case Tread:
1187                         if(fsread(fd, fid, &f) < 0)
1188                                 goto err;
1189                         doreply = 0;
1190                         break;
1191                 case Tclunk:
1192                         if(fid->omode != -1 && fid->file == Qcpunote){
1193                                 ncpunote--;
1194                                 if(ncpunote == 0)       /* remote side is done */
1195                                         goto err;
1196                         }
1197                         fid->file = -1;
1198                         fid->omode = -1;
1199                         break;
1200                 case Tstat:
1201                         if(fsstat(fd, fid, &f) < 0)
1202                                 goto err;
1203                         doreply = 0;
1204                         break;
1205                 case Tcreate:
1206                 case Twrite:
1207                 case Tremove:
1208                 case Twstat:
1209                         f.type = Rerror;
1210                         f.ename = Eperm;
1211                         break;
1212                 }
1213                 if(doreply)
1214                         if(fsreply(fd, &f) < 0)
1215                                 break;
1216         }
1217 err:
1218         if(dbg)
1219                 fprint(2, "notefs exiting: %r\n");
1220         werrstr("success");
1221         postnote(PNGROUP, exportpid, "kill");
1222         if(dbg)
1223                 fprint(2, "postnote PNGROUP %d: %r\n", exportpid);
1224         close(fd);
1225 }
1226
1227 char    notebuf[ERRMAX];
1228
1229 void
1230 catcher(void*, char *text)
1231 {
1232         int n;
1233
1234         n = strlen(text);
1235         if(n >= sizeof(notebuf))
1236                 n = sizeof(notebuf)-1;
1237         memmove(notebuf, text, n);
1238         notebuf[n] = '\0';
1239         noted(NCONT);
1240 }
1241
1242 /*
1243  *  mount in /dev a note file for the remote side to read.
1244  */
1245 void
1246 lclnoteproc(int netfd)
1247 {
1248         Waitmsg *w;
1249         Note *np;
1250         int pfd[2];
1251         int pid;
1252
1253         if(pipe(pfd) < 0){
1254                 fprint(2, "cpu: can't start note proc: pipe: %r\n");
1255                 return;
1256         }
1257
1258         /* new proc mounts and returns to start exportfs */
1259         switch(pid = rfork(RFPROC|RFNAMEG|RFFDG|RFMEM)){
1260         default:
1261                 exportpid = pid;
1262                 break;
1263         case -1:
1264                 fprint(2, "cpu: can't start note proc: rfork: %r\n");
1265                 return;
1266         case 0:
1267                 close(pfd[0]);
1268                 if(mount(pfd[1], -1, "/dev", MBEFORE, "") < 0)
1269                         fprint(2, "cpu: can't mount note proc: %r\n");
1270                 close(pfd[1]);
1271                 return;
1272         }
1273
1274         close(netfd);
1275         close(pfd[1]);
1276
1277         /* new proc listens for note file system rpc's */
1278         switch(rfork(RFPROC|RFNAMEG|RFMEM)){
1279         case -1:
1280                 fprint(2, "cpu: can't start note proc: rfork1: %r\n");
1281                 _exits(0);
1282         case 0:
1283                 notefs(pfd[0]);
1284                 _exits(0);
1285         }
1286
1287         /* original proc waits for notes */
1288         notify(catcher);
1289         w = nil;
1290         for(;;) {
1291                 *notebuf = 0;
1292                 free(w);
1293                 w = wait();
1294                 if(w == nil) {
1295                         if(*notebuf == 0)
1296                                 break;
1297                         np = mallocz(sizeof(Note), 1);
1298                         if(np != nil){
1299                                 strcpy(np->msg, notebuf);
1300                                 lock(&nfs);
1301                                 if(nfs.nfirst == nil)
1302                                         nfs.nfirst = np;
1303                                 else
1304                                         nfs.nlast->next = np;
1305                                 nfs.nlast = np;
1306                                 unlock(&nfs);
1307                                 kick(pfd[0]);
1308                         }
1309                         unlock(&nfs);
1310                 } else if(w->pid == exportpid)
1311                         break;
1312         }
1313
1314         if(w == nil)
1315                 exits(nil);
1316         exits(0);
1317 /*      exits(w->msg); */
1318 }