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