op public repos

Blob

Date:: Sat Apr 1 19:24:03 2006 UTC
Message:: Use gcc -ansi -pedantic in 9c. Fix many non-C89-isms.
Actions:: History | Blame | Raw File
1 #include <u.h>
2 #include <libc.h>
3 #include <thread.h>
4 #include <fcall.h>
5 #include <9pclient.h>
6 #include "term.h"
7 
8 int noecho = 1;
9 
10 #define	EVENTSIZE	256
11 #define	STACK	32768
12 
13 typedef struct Event Event;
14 typedef struct Q Q;
15 
16 struct Event
17 {
18 	int	c1;
19 	int	c2;
20 	int	q0;
21 	int	q1;
22 	int	flag;
23 	int	nb;
24 	int	nr;
25 	char	b[EVENTSIZE*UTFmax+1];
26 	Rune	r[EVENTSIZE+1];
27 };
28 
29 Event blank = {
30 	'M',
31 	'X',
32 	0, 0, 0, 1, 1,
33 	{ ' ', 0 },
34 	{ ' ', 0 }
35 };
36 
37 struct Q
38 {
39 	QLock	lk;
40 	int		p;
41 	int		k;
42 };
43 
44 Q	q;
45 
46 CFid *eventfd;
47 CFid *addrfd;
48 CFid *datafd;
49 CFid *ctlfd;
50 /* int bodyfd; */
51 
52 char	*typing;
53 int	ntypeb;
54 int	ntyper;
55 int	ntypebreak;
56 int	debug;
57 int	rcfd;
58 
59 char *name;
60 
61 char **prog;
62 Channel *cwait;
63 int pid = -1;
64 
65 int	label(char*, int);
66 void	error(char*, ...);
67 void	stdinproc(void*);
68 void	stdoutproc(void*);
69 void	type(Event*, int, CFid*, CFid*);
70 void	sende(Event*, int, CFid*, CFid*, CFid*, int);
71 char	*onestring(int, char**);
72 int	delete(Event*);
73 void	deltype(uint, uint);
74 void	runproc(void*);
75 
76 int
77 fsfidprint(CFid *fid, char *fmt, ...)
78 {
79 	char buf[256];
80 	va_list arg;
81 	int n;
82 
83 	va_start(arg, fmt);
84 	n = vsnprint(buf, sizeof buf, fmt, arg);
85 	va_end(arg);
86 	return fswrite(fid, buf, n);
87 }
88 
89 void
90 usage(void)
91 {
92 	fprint(2, "usage: win cmd args...\n");
93 	threadexitsall("usage");
94 }
95 
96 int
97 nopipes(void *v, char *msg)
98 {
99 	USED(v);
100 	if(strcmp(msg, "sys: write on closed pipe") == 0)
101 		return 1;
102 	return 0;
103 }
104 
105 void
106 waitthread(void *v)
107 {
108 	recvp(cwait);
109 	threadexitsall(nil);
110 }
111 
112 void
113 hangupnote(void *a, char *msg)
114 {
115 	if(strcmp(msg, "hangup") == 0 && pid != 0){
116 		postnote(PNGROUP, pid, "hangup");
117 		noted(NDFLT);
118 	}
119 	if(strstr(msg, "child")){
120 		/* bug: do better */
121 		threadexitsall(0);
122 	}
123 	noted(NDFLT);
124 }
125 
126 void
127 threadmain(int argc, char **argv)
128 {
129 	int fd, id;
130 	char buf[256];
131 	char buf1[128];
132 	CFsys *fs;
133 
134 	ARGBEGIN{
135 	case 'd':
136 		debug = 1;
137 		break;
138 	case 'n':
139 		name = EARGF(usage());
140 		break;
141 	default:
142 		usage();
143 	}ARGEND
144 
145 	prog = argv;
146 
147 	if(name == nil){
148 		if(argc > 0)
149 			name = argv[0];
150 		else{
151 			name = sysname();
152 			if(name == nil)
153 				name = "gnot";
154 		}
155 	}
156 
157 	notedisable("sys: write on closed pipe");
158 	noteenable("sys: child");
159 	notify(hangupnote);
160 
161 	if((fs = nsmount("acme", "")) == 0)
162 		sysfatal("nsmount acme: %r");
163 	ctlfd = fsopen(fs, "new/ctl", ORDWR|OCEXEC);
164 	if(ctlfd == 0 || fsread(ctlfd, buf, 12) != 12)
165 		sysfatal("ctl: %r");
166 	id = atoi(buf);
167 	snprint(buf, sizeof buf, "%d", id);
168 	putenv("winid", buf);
169 	sprint(buf, "%d/tag", id);
170 	fd = fsopenfd(fs, buf, OWRITE|OCEXEC);
171 	write(fd, " Send Delete", 12);
172 	close(fd);
173 	sprint(buf, "%d/event", id);
174 	eventfd = fsopen(fs, buf, ORDWR|OCEXEC);
175 	sprint(buf, "%d/addr", id);
176 	addrfd = fsopen(fs, buf, ORDWR|OCEXEC);
177 	sprint(buf, "%d/data", id);
178 	datafd = fsopen(fs, buf, ORDWR|OCEXEC);
179 	sprint(buf, "%d/body", id);
180 /*	bodyfd = fsopenfd(fs, buf, ORDWR|OCEXEC); */
181 	if(eventfd==nil || addrfd==nil || datafd==nil)
182 		sysfatal("data files: %r");
183 /*
184 	if(eventfd<0 || addrfd<0 || datafd<0 || bodyfd<0)
185 		sysfatal("data files: %r");
186 */
187 	fsunmount(fs);
188 
189 	cwait = threadwaitchan();
190 	threadcreate(waitthread, nil, STACK);
191 	pid = rcstart(argc, argv, &rcfd, nil);
192 	if(pid == -1)
193 		sysfatal("exec failed");
194 
195 	getwd(buf1, sizeof buf1);
196 	sprint(buf, "name %s/-%s\n0\n", buf1, name);
197 	fswrite(ctlfd, buf, strlen(buf));
198 	sprint(buf, "dumpdir %s/\n", buf1);
199 	fswrite(ctlfd, buf, strlen(buf));
200 	sprint(buf, "dump %s\n", onestring(argc, argv));
201 	fswrite(ctlfd, buf, strlen(buf));
202 	
203 	updatewinsize(25, 80, 0, 0);
204 	proccreate(stdoutproc, nil, STACK);
205 	stdinproc(nil);
206 }
207 
208 void
209 error(char *s, ...)
210 {
211 	va_list arg;
212 	
213 	if(s){
214 		va_start(arg, s);
215 		s = vsmprint(s, arg);
216 		va_end(arg);
217 		fprint(2, "win: %s: %r\n", s);
218 	}
219 	if(pid != -1)
220 		postnote(PNGROUP, pid, "hangup");
221 	threadexitsall(s);
222 }
223 
224 char*
225 onestring(int argc, char **argv)
226 {
227 	char *p;
228 	int i, n;
229 	static char buf[1024];
230 
231 	if(argc == 0)
232 		return "";
233 	p = buf;
234 	for(i=0; i<argc; i++){
235 		n = strlen(argv[i]);
236 		if(p+n+1 >= buf+sizeof buf)
237 			break;
238 		memmove(p, argv[i], n);
239 		p += n;
240 		*p++ = ' ';
241 	}
242 	p[-1] = 0;
243 	return buf;
244 }
245 
246 int
247 getec(CFid *efd)
248 {
249 	static char buf[8192];
250 	static char *bufp;
251 	static int nbuf;
252 
253 	if(nbuf == 0){
254 		nbuf = fsread(efd, buf, sizeof buf);
255 		if(nbuf <= 0)
256 			error(nil);
257 		bufp = buf;
258 	}
259 	--nbuf;
260 	return *bufp++;
261 }
262 
263 int
264 geten(CFid *efd)
265 {
266 	int n, c;
267 
268 	n = 0;
269 	while('0'<=(c=getec(efd)) && c<='9')
270 		n = n*10+(c-'0');
271 	if(c != ' ')
272 		error("event number syntax");
273 	return n;
274 }
275 
276 int
277 geter(CFid *efd, char *buf, int *nb)
278 {
279 	Rune r;
280 	int n;
281 
282 	r = getec(efd);
283 	buf[0] = r;
284 	n = 1;
285 	if(r < Runeself)
286 		goto Return;
287 	while(!fullrune(buf, n))
288 		buf[n++] = getec(efd);
289 	chartorune(&r, buf);
290     Return:
291 	*nb = n;
292 	return r;
293 }
294 
295 void
296 gete(CFid *efd, Event *e)
297 {
298 	int i, nb;
299 
300 	e->c1 = getec(efd);
301 	e->c2 = getec(efd);
302 	e->q0 = geten(efd);
303 	e->q1 = geten(efd);
304 	e->flag = geten(efd);
305 	e->nr = geten(efd);
306 	if(e->nr > EVENTSIZE)
307 		error("event string too long");
308 	e->nb = 0;
309 	for(i=0; i<e->nr; i++){
310 		e->r[i] = geter(efd, e->b+e->nb, &nb);
311 		e->nb += nb;
312 	}
313 	e->r[e->nr] = 0;
314 	e->b[e->nb] = 0;
315 	if(getec(efd) != '\n')
316 		error("event syntax 2");
317 }
318 
319 int
320 nrunes(char *s, int nb)
321 {
322 	int i, n;
323 	Rune r;
324 
325 	n = 0;
326 	for(i=0; i<nb; n++)
327 		i += chartorune(&r, s+i);
328 	return n;
329 }
330 
331 void
332 stdinproc(void *v)
333 {
334 	CFid *cfd = ctlfd;
335 	CFid *efd = eventfd;
336 	CFid *dfd = datafd;
337 	CFid *afd = addrfd;
338 	int fd0 = rcfd;
339 	Event e, e2, e3, e4;
340 
341 	USED(v);
342 
343 	for(;;){
344 		if(debug)
345 			fprint(2, "typing[%d,%d)\n", q.p, q.p+ntyper);
346 		gete(efd, &e);
347 		if(debug)
348 			fprint(2, "msg %c%c q[%d,%d)... ", e.c1, e.c2, e.q0, e.q1);
349 		qlock(&q.lk);
350 		switch(e.c1){
351 		default:
352 		Unknown:
353 			print("unknown message %c%c\n", e.c1, e.c2);
354 			break;
355 
356 		case 'E':	/* write to body; can't affect us */
357 			if(debug)
358 				fprint(2, "shift typing %d... ", e.q1-e.q0);
359 			q.p += e.q1-e.q0;
360 			break;
361 
362 		case 'F':	/* generated by our actions; ignore */
363 			break;
364 
365 		case 'K':
366 		case 'M':
367 			switch(e.c2){
368 			case 'I':
369 				if(e.q0 < q.p){
370 					if(debug)
371 						fprint(2, "shift typing %d... ", e.q1-e.q0);
372 					q.p += e.q1-e.q0;
373 				}
374 				else if(e.q0 <= q.p+ntyper){
375 					if(debug)
376 						fprint(2, "type... ");
377 					type(&e, fd0, afd, dfd);
378 				}
379 				break;
380 
381 			case 'D':
382 				q.p -= delete(&e);
383 				break;
384 
385 			case 'x':
386 			case 'X':
387 				if(e.flag & 2)
388 					gete(efd, &e2);
389 				if(e.flag & 8){
390 					gete(efd, &e3);
391 					gete(efd, &e4);
392 				}
393 				if(e.flag&1 || (e.c2=='x' && e.nr==0 && e2.nr==0)){
394 					/* send it straight back */
395 					fsfidprint(efd, "%c%c%d %d\n", e.c1, e.c2, e.q0, e.q1);
396 					break;
397 				}
398 				if(e.q0==e.q1 && (e.flag&2)){
399 					e2.flag = e.flag;
400 					e = e2;
401 				}
402 				if(e.flag & 8){
403 					if(e.q1 != e.q0){
404 						sende(&e, fd0, cfd, afd, dfd, 0);
405 						sende(&blank, fd0, cfd, afd, dfd, 0);
406 					}
407 					sende(&e3, fd0, cfd, afd, dfd, 1);
408 				}else	 if(e.q1 != e.q0)
409 					sende(&e, fd0, cfd, afd, dfd, 1);
410 				break;
411 
412 			case 'l':
413 			case 'L':
414 				/* just send it back */
415 				if(e.flag & 2)
416 					gete(efd, &e2);
417 				fsfidprint(efd, "%c%c%d %d\n", e.c1, e.c2, e.q0, e.q1);
418 				break;
419 
420 			case 'd':
421 			case 'i':
422 				break;
423 
424 			default:
425 				goto Unknown;
426 			}
427 		}
428 		qunlock(&q.lk);
429 	}
430 }
431 
432 void
433 stdoutproc(void *v)
434 {
435 	int fd1 = rcfd;
436 	CFid *afd = addrfd;
437 	CFid *dfd = datafd;
438 	int n, m, w, npart;
439 	char *buf, *s, *t;
440 	Rune r;
441 	char x[16], hold[UTFmax];
442 
443 	USED(v);
444 	buf = malloc(8192+UTFmax+1);
445 	npart = 0;
446 	for(;;){
447 		/* Let typing have a go -- maybe there's a rubout waiting. */
448 		yield();
449 		n = read(fd1, buf+npart, 8192);
450 		if(n <= 0)
451 			error(nil);
452 
453 		/* squash NULs */
454 		s = memchr(buf+npart, 0, n);
455 		if(s){
456 			for(t=s; s<buf+npart+n; s++)
457 				if(*t = *s)	/* assign = */
458 					t++;
459 			n = t-(buf+npart);
460 		}
461 
462 		n += npart;
463 
464 		/* hold on to final partial rune */
465 		npart = 0;
466 		while(n>0 && (buf[n-1]&0xC0)){
467 			--n;
468 			npart++;
469 			if((buf[n]&0xC0)!=0x80){
470 				if(fullrune(buf+n, npart)){
471 					w = chartorune(&r, buf+n);
472 					n += w;
473 					npart -= w;
474 				}
475 				break;
476 			}
477 		}
478 		if(n > 0){
479 			memmove(hold, buf+n, npart);
480 			buf[n] = 0;
481 			n = label(buf, n);
482 			buf[n] = 0;
483 			qlock(&q.lk);
484 			m = sprint(x, "#%d", q.p);
485 			if(fswrite(afd, x, m) != m){
486 				fprint(2, "stdout writing address: %r; resetting\n");
487 				fswrite(afd, "$", 1);
488 				m = fsread(afd, x, sizeof x-1);
489 				if(m >= 0){
490 					x[m] = 0;
491 					q.p = atoi(x);
492 				}
493 			}
494 			if(fswrite(dfd, buf, n) != n)
495 				error("stdout writing body");
496 			q.p += nrunes(buf, n);
497 			qunlock(&q.lk);
498 			memmove(buf, hold, npart);
499 		}
500 	}
501 }
502 
503 char wdir[512];
504 int
505 label(char *sr, int n)
506 {
507 	char *sl, *el, *er, *r, *p;
508 
509 	er = sr+n;
510 	for(r=er-1; r>=sr; r--)
511 		if(*r == '\007')
512 			break;
513 	if(r < sr)
514 		return n;
515 
516 	el = r+1;
517 	if(el-sr > sizeof wdir - strlen(name) - 20)
518 		sr = el - sizeof wdir - strlen(name) - 20;
519 	for(sl=el-3; sl>=sr; sl--)
520 		if(sl[0]=='\033' && sl[1]==']' && sl[2]==';')
521 			break;
522 	if(sl < sr)
523 		return n;
524 
525 	*r = 0;
526 	/*
527 	 * add /-sysname if not present
528 	 */
529 	snprint(wdir, sizeof wdir, "name %s", sl+3);
530 	p = strrchr(wdir, '/');
531 	if(p==nil || *(p+1) != '-'){
532 		p = wdir+strlen(wdir);
533 		if(*(p-1) != '/')
534 			*p++ = '/';
535 		*p++ = '-';
536 		strcpy(p, name);
537 	}
538 	strcat(wdir, "\n0\n");
539 	fswrite(ctlfd, wdir, strlen(wdir));
540 
541 	memmove(sl, el, er-el);
542 	n -= (el-sl);
543 	return n;
544 }
545 
546 int
547 delete(Event *e)
548 {
549 	uint q0, q1;
550 	int deltap;
551 
552 	q0 = e->q0;
553 	q1 = e->q1;
554 	if(q1 <= q.p)
555 		return e->q1-e->q0;
556 	if(q0 >= q.p+ntyper)
557 		return 0;
558 	deltap = 0;
559 	if(q0 < q.p){
560 		deltap = q.p-q0;
561 		q0 = 0;
562 	}else
563 		q0 -= q.p;
564 	if(q1 > q.p+ntyper)
565 		q1 = ntyper;
566 	else
567 		q1 -= q.p;
568 	deltype(q0, q1);
569 	return deltap;
570 }
571 
572 void
573 addtype(int c, uint p0, char *b, int nb, int nr)
574 {
575 	int i, w;
576 	Rune r;
577 	uint p;
578 	char *b0;
579 
580 	for(i=0; i<nb; i+=w){
581 		w = chartorune(&r, b+i);
582 		if((r==0x7F||r==3) && c=='K'){
583 			write(rcfd, "\x7F", 1);
584 			/* toss all typing */
585 			q.p += ntyper+nr;
586 			ntypebreak = 0;
587 			ntypeb = 0;
588 			ntyper = 0;
589 			/* buglet:  more than one delete ignored */
590 			return;
591 		}
592 		if(r=='\n' || r==0x04)
593 			ntypebreak++;
594 	}
595 	typing = realloc(typing, ntypeb+nb);
596 	if(typing == nil)
597 		error("realloc");
598 	if(p0 == ntyper)
599 		memmove(typing+ntypeb, b, nb);
600 	else{
601 		b0 = typing;
602 		for(p=0; p<p0 && b0<typing+ntypeb; p++){
603 			w = chartorune(&r, b0+i);
604 			b0 += w;
605 		}
606 		if(p != p0)
607 			error("typing: findrune");
608 		memmove(b0+nb, b0, (typing+ntypeb)-b0);
609 		memmove(b0, b, nb);
610 	}
611 	ntypeb += nb;
612 	ntyper += nr;
613 }
614 
615 void
616 sendtype(int fd0)
617 {
618 	int i, n, nr;
619 
620 	while(ntypebreak){
621 		for(i=0; i<ntypeb; i++)
622 			if(typing[i]=='\n' || typing[i]==0x04){
623 				n = i+1;
624 				i++;
625 				if(write(fd0, typing, n) != n)
626 					error("sending to program");
627 				nr = nrunes(typing, i);
628 				q.p += nr;
629 				ntyper -= nr;
630 				ntypeb -= i;
631 				memmove(typing, typing+i, ntypeb);
632 				ntypebreak--;
633 				goto cont2;
634 			}
635 		print("no breakchar\n");
636 		ntypebreak = 0;
637 cont2:;
638 	}
639 }
640 
641 void
642 deltype(uint p0, uint p1)
643 {
644 	int w;
645 	uint p, b0, b1;
646 	Rune r;
647 
648 	/* advance to p0 */
649 	b0 = 0;
650 	for(p=0; p<p0 && b0<ntypeb; p++){
651 		w = chartorune(&r, typing+b0);
652 		b0 += w;
653 	}
654 	if(p != p0)
655 		error("deltype 1");
656 	/* advance to p1 */
657 	b1 = b0;
658 	for(; p<p1 && b1<ntypeb; p++){
659 		w = chartorune(&r, typing+b1);
660 		b1 += w;
661 		if(r=='\n' || r==0x04)
662 			ntypebreak--;
663 	}
664 	if(p != p1)
665 		error("deltype 2");
666 	memmove(typing+b0, typing+b1, ntypeb-b1);
667 	ntypeb -= b1-b0;
668 	ntyper -= p1-p0;
669 }
670 
671 void
672 type(Event *e, int fd0, CFid *afd, CFid *dfd)
673 {
674 	int m, n, nr;
675 	char buf[128];
676 
677 	if(e->nr > 0)
678 		addtype(e->c1, e->q0-q.p, e->b, e->nb, e->nr);
679 	else{
680 		m = e->q0;
681 		while(m < e->q1){
682 			n = sprint(buf, "#%d", m);
683 			fswrite(afd, buf, n);
684 			n = fsread(dfd, buf, sizeof buf);
685 			nr = nrunes(buf, n);
686 			while(m+nr > e->q1){
687 				do; while(n>0 && (buf[--n]&0xC0)==0x80);
688 				--nr;
689 			}
690 			if(n == 0)
691 				break;
692 			addtype(e->c1, m-q.p, buf, n, nr);
693 			m += nr;
694 		}
695 	}
696 	sendtype(fd0);
697 }
698 
699 void
700 sende(Event *e, int fd0, CFid *cfd, CFid *afd, CFid *dfd, int donl)
701 {
702 	int l, m, n, nr, lastc, end;
703 	char abuf[16], buf[128];
704 
705 	end = q.p+ntyper;
706 	l = sprint(abuf, "#%d", end);
707 	fswrite(afd, abuf, l);
708 	if(e->nr > 0){
709 		fswrite(dfd, e->b, e->nb);
710 		addtype(e->c1, ntyper, e->b, e->nb, e->nr);
711 		lastc = e->r[e->nr-1];
712 	}else{
713 		m = e->q0;
714 		lastc = 0;
715 		while(m < e->q1){
716 			n = sprint(buf, "#%d", m);
717 			fswrite(afd, buf, n);
718 			n = fsread(dfd, buf, sizeof buf);
719 			nr = nrunes(buf, n);
720 			while(m+nr > e->q1){
721 				do; while(n>0 && (buf[--n]&0xC0)==0x80);
722 				--nr;
723 			}
724 			if(n == 0)
725 				break;
726 			l = sprint(abuf, "#%d", end);
727 			fswrite(afd, abuf, l);
728 			fswrite(dfd, buf, n);
729 			addtype(e->c1, ntyper, buf, n, nr);
730 			lastc = buf[n-1];
731 			m += nr;
732 			end += nr;
733 		}
734 	}
735 	if(donl && lastc!='\n'){
736 		fswrite(dfd, "\n", 1);
737 		addtype(e->c1, ntyper, "\n", 1, 1);
738 	}
739 	fswrite(cfd, "dot=addr", 8);
740 	sendtype(fd0);
741 }