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