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