1 #include <u.h>
2 #include <libc.h>
3 #include <thread.h>
4 #include <9pclient.h>
5 #include <acme.h>
6 
7 static CFsys *acmefs;
8 static Win *windows;
9 static Win *last;
10 
11 static void
12 mountacme(void)
13 {
14 	if(acmefs == nil){
15 		acmefs = nsmount("acme", nil);
16 		if(acmefs == nil)
17 			sysfatal("cannot mount acme: %r");
18 	}
19 }
20 
21 Win*
22 newwin(void)
23 {
24 	CFid *fid;
25 	char buf[100];
26 	int id, n;
27 
28 	mountacme();
29 	fid = fsopen(acmefs, "new/ctl", ORDWR);
30 	if(fid == nil)
31 		sysfatal("open new/ctl: %r");
32 	n = fsread(fid, buf, sizeof buf-1);
33 	if(n <= 0)
34 		sysfatal("read new/ctl: %r");
35 	buf[n] = 0;
36 	id = atoi(buf);
37 	if(id == 0)
38 		sysfatal("read new/ctl: malformed message: %s", buf);
39 
40 	return openwin(id, fid);
41 }
42 
43 Win*
44 openwin(int id, CFid *ctl)
45 {
46 	char buf[100];
47 	Win *w;
48 
49 	mountacme();
50 	if(ctl == nil){
51 		snprint(buf, sizeof buf, "%d/ctl", id);
52 		if((ctl = fsopen(acmefs, buf, ORDWR)) == nil)
53 			sysfatal("open %s: %r", buf);
54 	}
55 	w = emalloc(sizeof *w);
56 	w->id = id;
57 	w->ctl = ctl;
58 	w->next = nil;
59 	w->prev = last;
60 	if(last)
61 		last->next = w;
62 	else
63 		windows = w;
64 	last = w;
65 	return w;
66 }
67 
68 void
69 winclosefiles(Win *w)
70 {
71 	if(w->ctl){
72 		fsclose(w->ctl);
73 		w->ctl = nil;
74 	}
75 	if(w->body){
76 		fsclose(w->body);
77 		w->body = nil;
78 	}
79 	if(w->addr){
80 		fsclose(w->addr);
81 		w->addr = nil;
82 	}
83 	if(w->tag){
84 		fsclose(w->tag);
85 		w->tag = nil;
86 	}
87 	if(w->event){
88 		fsclose(w->event);
89 		w->event = nil;
90 	}
91 	if(w->data){
92 		fsclose(w->data);
93 		w->data = nil;
94 	}
95 	if(w->xdata){
96 		fsclose(w->xdata);
97 		w->xdata = nil;
98 	}
99 }
100 
101 void
102 winfree(Win *w)
103 {
104 	winclosefiles(w);
105 	if(w->c){
106 		chanfree(w->c);
107 		w->c = nil;
108 	}
109 	if(w->next)
110 		w->next->prev = w->prev;
111 	else
112 		last = w->prev;
113 	if(w->prev)
114 		w->prev->next = w->next;
115 	else
116 		windows = w->next;
117 	free(w);
118 }
119 
120 void
121 windeleteall(void)
122 {
123 	Win *w, *next;
124 
125 	for(w=windows; w; w=next){
126 		next = w->next;
127 		winctl(w, "delete");
128 	}
129 }
130 
131 static CFid*
132 wfid(Win *w, char *name)
133 {
134 	char buf[100];
135 	CFid **fid;
136 
137 	if(strcmp(name, "ctl") == 0)
138 		fid = &w->ctl;
139 	else if(strcmp(name, "body") == 0)
140 		fid = &w->body;
141 	else if(strcmp(name, "addr") == 0)
142 		fid = &w->addr;
143 	else if(strcmp(name, "tag") == 0)
144 		fid = &w->tag;
145 	else if(strcmp(name, "event") == 0)
146 		fid = &w->event;
147 	else if(strcmp(name, "data") == 0)
148 		fid = &w->data;
149 	else if(strcmp(name, "xdata") == 0)
150 		fid = &w->xdata;
151 	else{
152 		fid = 0;
153 		sysfatal("bad window file name %s", name);
154 	}
155 
156 	if(*fid == nil){
157 		snprint(buf, sizeof buf, "acme/%d/%s", w->id, name);
158 		*fid = fsopen(acmefs, buf, ORDWR);
159 		if(*fid == nil)
160 			sysfatal("open %s: %r", buf);
161 	}
162 	return *fid;
163 }
164 
165 int
166 winopenfd(Win *w, char *name, int mode)
167 {
168 	char buf[100];
169 
170 	snprint(buf, sizeof buf, "%d/%s", w->id, name);
171 	return fsopenfd(acmefs, buf, mode);
172 }
173 
174 int
175 winctl(Win *w, char *fmt, ...)
176 {
177 	char *s;
178 	va_list arg;
179 	CFid *fid;
180 	int n;
181 
182 	va_start(arg, fmt);
183 	s = evsmprint(fmt, arg);
184 	va_end(arg);
185 
186 	fid = wfid(w, "ctl");
187 	n = fspwrite(fid, s, strlen(s), 0);
188 	free(s);
189 	return n;
190 }
191 
192 int
193 winname(Win *w, char *fmt, ...)
194 {
195 	char *s;
196 	va_list arg;
197 	int n;
198 
199 	va_start(arg, fmt);
200 	s = evsmprint(fmt, arg);
201 	va_end(arg);
202 
203 	n = winctl(w, "name %s\n", s);
204 	free(s);
205 	return n;
206 }
207 
208 int
209 winprint(Win *w, char *name, char *fmt, ...)
210 {
211 	char *s;
212 	va_list arg;
213 	int n;
214 
215 	va_start(arg, fmt);
216 	s = evsmprint(fmt, arg);
217 	va_end(arg);
218 
219 	n = fswrite(wfid(w, name), s, strlen(s));
220 	free(s);
221 	return n;
222 }
223 
224 int
225 winaddr(Win *w, char *fmt, ...)
226 {
227 	char *s;
228 	va_list arg;
229 	int n;
230 
231 	va_start(arg, fmt);
232 	s = evsmprint(fmt, arg);
233 	va_end(arg);
234 
235 	n = fswrite(wfid(w, "addr"), s, strlen(s));
236 	free(s);
237 	return n;
238 }
239 
240 int
241 winreadaddr(Win *w, uint *q1)
242 {
243 	char buf[40], *p;
244 	uint q0;
245 	int n;
246 
247 	n = fspread(wfid(w, "addr"), buf, sizeof buf-1, 0);
248 	if(n <= 0)
249 		return -1;
250 	buf[n] = 0;
251 	q0 = strtoul(buf, &p, 10);
252 	if(q1)
253 		*q1 = strtoul(p, nil, 10);
254 	return q0;
255 }
256 
257 int
258 winread(Win *w, char *file, void *a, int n)
259 {
260 	return fsread(wfid(w, file), a, n);
261 }
262 
263 int
264 winwrite(Win *w, char *file, void *a, int n)
265 {
266 	return fswrite(wfid(w, file), a, n);
267 }
268 
269 char*
270 winmread(Win *w, char *file)
271 {
272 	char *buf;
273 	int n, tot, m;
274 
275 	m = 128;
276 	buf = emalloc(m+1);
277 	tot = 0;
278 	while((n = fsread(wfid(w, file), buf+tot, m-tot)) > 0){
279 		tot += n;
280 		if(tot >= m){
281 			m += 128;
282 			buf = erealloc(buf, m+1);
283 		}
284 	}
285 	if(n < 0){
286 		free(buf);
287 		return nil;
288 	}
289 	buf[tot] = 0;
290 	return buf;
291 }
292 
293 int
294 winseek(Win *w, char *file, int n, int off)
295 {
296 	return fsseek(wfid(w, file), n, off);
297 }
298 
299 int
300 winwriteevent(Win *w, Event *e)
301 {
302 	char buf[100];
303 
304 	snprint(buf, sizeof buf, "%c%c%d %d \n", e->c1, e->c2, e->q0, e->q1);
305 	return fswrite(wfid(w, "event"), buf, strlen(buf));
306 }
307 
308 int
309 windel(Win *w, int sure)
310 {
311 	return winctl(w, sure ? "delete" : "del");
312 }
313 
314 int
315 winfd(Win *w, char *name, int mode)
316 {
317 	char buf[100];
318 
319 	snprint(buf, sizeof buf, "acme/%d/%s", w->id, name);
320 	return fsopenfd(acmefs, buf, mode);
321 }
322 
323 static void
324 error(Win *w, char *msg)
325 {
326 	if(msg == nil)
327 		longjmp(w->jmp, 1);
328 	fprint(2, "%s: win%d: %s\n", argv0, w->id, msg);
329 	longjmp(w->jmp, 2);
330 }
331 
332 static int
333 getec(Win *w, CFid *efd)
334 {
335 	if(w->nbuf <= 0){
336 		w->nbuf = fsread(efd, w->buf, sizeof w->buf);
337 		if(w->nbuf <= 0)
338 			error(w, nil);
339 		w->bufp = w->buf;
340 	}
341 	--w->nbuf;
342 	return *w->bufp++;
343 }
344 
345 static int
346 geten(Win *w, CFid *efd)
347 {
348 	int n, c;
349 
350 	n = 0;
351 	while('0'<=(c=getec(w,efd)) && c<='9')
352 		n = n*10+(c-'0');
353 	if(c != ' ')
354 		error(w, "event number syntax");
355 	return n;
356 }
357 
358 static int
359 geter(Win *w, CFid *efd, char *buf, int *nb)
360 {
361 	Rune r;
362 	int n;
363 
364 	r = getec(w, efd);
365 	buf[0] = r;
366 	n = 1;
367 	if(r < Runeself)
368 		goto Return;
369 	while(!fullrune(buf, n))
370 		buf[n++] = getec(w, efd);
371 	chartorune(&r, buf);
372     Return:
373 	*nb = n;
374 	return r;
375 }
376 
377 static void
378 gete(Win *w, CFid *efd, Event *e)
379 {
380 	int i, nb;
381 
382 	e->c1 = getec(w, efd);
383 	e->c2 = getec(w, efd);
384 	e->q0 = geten(w, efd);
385 	e->q1 = geten(w, efd);
386 	e->flag = geten(w, efd);
387 	e->nr = geten(w, efd);
388 	if(e->nr > EVENTSIZE)
389 		error(w, "event string too long");
390 	e->nb = 0;
391 	for(i=0; i<e->nr; i++){
392 		/* e->r[i] = */ geter(w, efd, e->text+e->nb, &nb);
393 		e->nb += nb;
394 	}
395 /* 	e->r[e->nr] = 0; */
396 	e->text[e->nb] = 0;
397 	if(getec(w, efd) != '\n')
398 		error(w, "event syntax 2");
399 }
400 
401 int
402 winreadevent(Win *w, Event *e)
403 {
404 	CFid *efd;
405 	int r;
406 
407 	if((r = setjmp(w->jmp)) != 0){
408 		if(r == 1)
409 			return 0;
410 		return -1;
411 	}
412 	efd = wfid(w, "event");
413 	gete(w, efd, e);
414 	e->oq0 = e->q0;
415 	e->oq1 = e->q1;
416 
417 	/* expansion */
418 	if(e->flag&2){
419 		gete(w, efd, &w->e2);
420 		if(e->q0==e->q1){
421 			w->e2.oq0 = e->q0;
422 			w->e2.oq1 = e->q1;
423 			w->e2.flag = e->flag;
424 			*e = w->e2;
425 		}
426 	}
427 
428 	/* chorded argument */
429 	if(e->flag&8){
430 		gete(w, efd, &w->e3);	/* arg */
431 		gete(w, efd, &w->e4);	/* location */
432 		strcpy(e->arg, w->e3.text);
433 		strcpy(e->loc, w->e4.text);
434 	}
435 
436 	return 1;
437 }
438 
439 int
440 eventfmt(Fmt *fmt)
441 {
442 	Event *e;
443 
444 	e = va_arg(fmt->args, Event*);
445 	return fmtprint(fmt, "%c%c %d %d %d %d %q", e->c1, e->c2, e->q0, e->q1, e->flag, e->nr, e->text);
446 }
447 
448 void*
449 emalloc(uint n)
450 {
451 	void *v;
452 
453 	v = mallocz(n, 1);
454 	if(v == nil)
455 		sysfatal("out of memory");
456 	return v;
457 }
458 
459 void*
460 erealloc(void *v, uint n)
461 {
462 	v = realloc(v, n);
463 	if(v == nil)
464 		sysfatal("out of memory");
465 	return v;
466 }
467 
468 char*
469 estrdup(char *s)
470 {
471 	s = strdup(s);
472 	if(s == nil)
473 		sysfatal("out of memory");
474 	return s;
475 }
476 
477 char*
478 evsmprint(char *s, va_list v)
479 {
480 	s = vsmprint(s, v);
481 	if(s == nil)
482 		sysfatal("out of memory");
483 	return s;
484 }
485 
486 int
487 pipewinto(Win *w, char *name, int errto, char *cmd, ...)
488 {
489 	va_list arg;
490 	char *p;
491 	int fd[3], pid;
492 
493 	va_start(arg, cmd);
494 	p = evsmprint(cmd, arg);
495 	va_end(arg);
496 	fd[0] = winfd(w, name, OREAD);
497 	fd[1] = dup(errto, -1);
498 	fd[2] = dup(errto, -1);
499 	pid = threadspawnl(fd, "rc", "rc", "-c", p, 0);
500 	free(p);
501 	return pid;
502 }
503 
504 int
505 pipetowin(Win *w, char *name, int errto, char *cmd, ...)
506 {
507 	va_list arg;
508 	char *p;
509 	int fd[3], pid;
510 
511 	va_start(arg, cmd);
512 	p = evsmprint(cmd, arg);
513 	va_end(arg);
514 	fd[0] = open("/dev/null", OREAD);
515 	fd[1] = winfd(w, name, OWRITE);
516 	if(errto == 0)
517 		fd[2] = dup(fd[1], -1);
518 	else
519 		fd[2] = dup(errto, -1);
520 	pid = threadspawnl(fd, "rc", "rc", "-c", p, 0);
521 	free(p);
522 	return pid;
523 }
524 
525 char*
526 sysrun(char *fmt, ...)
527 {
528 	static char buf[1025];
529 	char *cmd;
530 	va_list arg;
531 	int n, fd[3], p[2], tot;
532 
533 #undef pipe
534 	if(pipe(p) < 0)
535 		sysfatal("pipe: %r");
536 	fd[0] = open("/dev/null", OREAD);
537 	fd[1] = p[1];
538 	fd[2] = dup(p[1], -1);
539 
540 	va_start(arg, fmt);
541 	cmd = evsmprint(fmt, arg);
542 	va_end(arg);
543 	threadspawnl(fd, "rc", "rc", "-Ic", cmd, 0);
544 
545 	tot = 0;
546 	while((n = read(p[0], buf+tot, sizeof buf-tot)) > 0)
547 		tot += n;
548 	close(p[0]);
549 	if(n < 0)
550 		return nil;
551 	free(cmd);
552 	if(tot == sizeof buf)
553 		tot--;
554 	buf[tot] = 0;
555 	while(tot > 0 && isspace(buf[tot-1]))
556 		tot--;
557 	buf[tot] = 0;
558 	if(tot == 0){
559 		werrstr("no output");
560 		return nil;
561 	}
562 	return buf;
563 }
564 
565 static void
566 eventreader(void *v)
567 {
568 	Event e[2];
569 	Win *w;
570 	int i;
571 
572 	w = v;
573 	i = 0;
574 	for(;;){
575 		if(winreadevent(w, &e[i]) <= 0)
576 			break;
577 		sendp(w->c, &e[i]);
578 		i = 1-i;	/* toggle */
579 	}
580 	sendp(w->c, nil);
581 	threadexits(nil);
582 }
583 
584 Channel*
585 wineventchan(Win *w)
586 {
587 	if(w->c == nil){
588 		w->c = chancreate(sizeof(Event*), 0);
589 		threadcreate(eventreader, w, 32*1024);
590 	}
591 	return w->c;
592 }