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