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