![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iproc-ptys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to iproc-ptys.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: /* NOTE WELL:
9: * This file is "included" into iproc.c -- it is not compiled separately!
10: */
11:
12: #include <sys/time.h>
13: #include <fcntl.h>
14: #include <signal.h>
15: #include <sgtty.h>
16: #include <errno.h>
17: #include "wait.h"
18:
19: #ifdef USE_OLD_TTY
20: # define gtty(fd, buf) ioctl(fd, TIOCGETP, buf)
21: # define stty(fd, buf) ioctl(fd, TIOCSETP, buf)
22: #endif
23:
24: #define DEAD 1 /* dead but haven't informed user yet */
25: #define STOPPED 2 /* job stopped */
26: #define RUNNING 3 /* just running */
27: #define NEW 4 /* brand new, never been ... received no input */
28:
29: /* If process is dead, flags says how. */
30: #define EXITED 1
31: #define KILLED 2
32:
33: #define isdead(p) ((p) == NULL || proc_state((p)) == DEAD || (p)->p_fd == -1)
34: #define makedead(p) { proc_state((p)) = DEAD; }
35:
36: #define proc_buf(p) ((p)->p_buffer->b_name)
37: #define proc_cmd(p) ((p)->p_name)
38: #define proc_state(p) ((p)->p_state)
39:
40: private Process *procs = 0;
41:
42: long global_fd = 1;
43: int NumProcs = 0;
44:
45: #include "ttystate.h"
46:
47: private Process *
48: proc_pid(pid)
49: int pid;
50: {
51: register Process *p;
52:
53: for (p = procs; p != 0; p = p->p_next)
54: if (p->p_pid == pid)
55: break;
56:
57: return p;
58: }
59:
60: void
61: read_proc(fd)
62: register int fd;
63: {
64: register Process *p;
65: int n;
66: char ibuf[1024];
67:
68: for (p = procs; p != 0; p = p->p_next)
69: if (p->p_fd == fd)
70: break;
71:
72: if (p == 0) {
73: writef("\riproc: unknown fd %d", fd);
74: return;
75: }
76:
77: n = read(fd, ibuf, sizeof(ibuf) - 1);
78: if (n == -1 && (errno == EIO || errno == EWOULDBLOCK)) {
79: if (proc_state(p) == NEW)
80: return;
81: proc_close(p);
82: makedead(p);
83: return;
84: } else {
85: if (proc_state(p) != RUNNING) {
86: proc_state(p) = RUNNING;
87: UpdModLine = YES;
88: }
89: }
90: if (n <= 0) {
91: if (n == 0)
92: strcpy(ibuf, "[Process EOF]");
93: else
94: swritef(ibuf, "\n[pty read error: %d]\n", errno);
95: } else
96: ibuf[n] = '\0';
97: proc_rec(p, ibuf);
98: }
99:
100: void
101: ProcKill()
102: {
103: register Buffer *b;
104: char *bname;
105:
106: bname = ask_buf(curbuf);
107:
108: if ((b = buf_exists(bname)) == 0)
109: complain("[No such buffer]");
110: if (b->b_process == 0)
111: complain("%s not tied to a process.", bname);
112: proc_kill(b->b_process, SIGKILL);
113: }
114:
115: void
116: ProcCont()
117: {
118: Process *p;
119:
120: if ((p = curbuf->b_process) == 0)
121: complain("[No process]");
122: if (p->p_state != DEAD) {
123: proc_kill(p, SIGCONT);
124: UpdModLine = YES;
125: p->p_state = RUNNING;
126: }
127: }
128:
129: private void
130: send_p(c)
131: char c;
132: {
133: Process *p;
134: char buf[2];
135:
136: if ((p = curbuf->b_process) == 0)
137: complain("[No process]");
138: ToLast();
139: buf[0] = c;
140: buf[1] = '\0';
141: proc_rec(p, buf);
142: (void) write(p->p_fd, &c, (size_t) 1);
143: }
144:
145: void
146: ProcEof()
147: {
148: send_p(tc[OFF].t_eofc);
149: }
150:
151: void
152: ProcInt()
153: {
154: send_p(tc[OFF].t_intrc);
155: }
156:
157: void
158: ProcQuit()
159: {
160: send_p(tc[OFF].t_quitc);
161: }
162:
163: void
164: ProcStop()
165: {
166: send_p(ls[OFF].t_suspc);
167: }
168:
169: void
170: ProcDStop()
171: {
172: send_p(ls[OFF].t_dsuspc);
173: }
174:
175: private void
176: proc_close(p)
177: Process *p;
178: {
179: SigHold(SIGCHLD); /* be mutually exclusive */
180:
181: if (p->p_fd >= 0) {
182: (void) close(p->p_fd);
183: global_fd &= ~(1L << p->p_fd);
184: NumProcs -= 1;
185: p->p_fd = -1;
186: }
187:
188: SigRelse(SIGCHLD);
189: }
190:
191: private void
192: proc_write(p, buf, nbytes)
193: Process *p;
194: char *buf;
195: size_t nbytes;
196: {
197: long mask = (1 << p->p_fd);
198:
199: while (write(p->p_fd, buf, nbytes) < 0)
200: select(p->p_fd + 1, (long *) 0, &mask, (long *) 0, (struct timeval *) 0);
201: }
202:
203: #ifdef STDARGS
204: private void
205: proc_strt(char *bufname, int clobber, ...)
206: #else
207: private /*VARARGS2*/ void
208: proc_strt(bufname, clobber, va_alist)
209: char *bufname;
210: int clobber;
211: va_dcl
212: #endif
213: {
214: va_list ap;
215: char *argv[32],
216: *cp;
217: Window *owind = curwind;
218: int pid;
219: Process *newp;
220: Buffer *newbuf;
221: int i,
222: ptyfd,
223: ttyfd,
224: ldisc,
225: lmode;
226: register char *s,
227: *t;
228: char ttybuf[11],
229: ptybuf[11];
230: char cmdbuf[128];
231: #ifdef BRLUNIX
232: struct sg_brl sgt;
233: #else
234: struct sgttyb sgt;
235: #endif
236:
237: #ifdef TIOCGWINSZ
238: struct winsize win;
239: #else
240: # ifdef BTL_BLIT
241: # include <sys/jioctl.h>
242: struct jwinsize jwin;
243: # endif
244: #endif
245:
246: isprocbuf(bufname); /* make sure BUFNAME is either nonexistant
247: or is of type B_PROCESS */
248: for (s = "pqrs"; *s; s++) {
249: for (t = "0123456789abcdef"; *t; t++) {
250: swritef(ptybuf, "/dev/pty%c%c", *s, *t);
251: if ((ptyfd = open(ptybuf, 2)) >= 0) {
252: strcpy(ttybuf, ptybuf);
253: ttybuf[5] = 't';
254: /* make sure both ends are available */
255: if ((i = open(ttybuf, 2)) < 0)
256: continue;
257: (void) close(i);
258: goto out;
259: }
260: }
261: }
262:
263: out: if (s == 0 && t == 0)
264: complain("[Out of ptys!]");
265:
266: #ifdef TIOCGETD
267: (void) ioctl(0, TIOCGETD, (UnivPtr) &ldisc);
268: #endif
269: #ifdef TIOCLGET
270: (void) ioctl(0, TIOCLGET, (UnivPtr) &lmode);
271: #endif
272: #ifdef TIOCGWINSZ
273: (void) ioctl(0, TIOCGWINSZ, (UnivPtr) &win);
274: #else
275: # ifdef BTL_BLIT
276: (void) ioctl(0, JWINSIZE, (UnivPtr) &jwin);
277: # endif /* BTL_BLIT */
278: #endif
279:
280: SigHold(SIGCHLD);
281: #ifdef SIGWINCH
282: SigHold(SIGWINCH);
283: #endif
284: switch (pid = fork()) {
285: case -1:
286: (void) close(ptyfd);
287: message("[Fork failed!]");
288: goto fail;
289:
290: case 0:
291: SigRelse(SIGCHLD);
292: #ifdef SIGWINCH
293: SigRelse(SIGWINCH);
294: #endif
295: for (i = 0; i < 32; i++)
296: (void) close(i);
297:
298: #ifdef TIOCNOTTY
299: if ((i = open("/dev/tty", 2)) >= 0) {
300: (void) ioctl(i, TIOCNOTTY, (UnivPtr) 0);
301: (void) close(i);
302: }
303: #endif
304: if ((ttyfd = open(ttybuf, 2)) < 0)
305: exit(-1);
306: (void) dup2(ttyfd, 1);
307: (void) dup2(ttyfd, 2);
308:
309: #ifdef TIOCSETD
310: (void) ioctl(0, TIOCSETD, (UnivPtr) &ldisc);
311: #endif
312: #ifdef TIOCLSET
313: (void) ioctl(0, TIOCLSET, (UnivPtr) &lmode);
314: #endif
315: #ifdef TIOCSETC
316: (void) ioctl(0, TIOCSETC, (UnivPtr) &tc[OFF]);
317: #endif
318: #ifdef TIOCSLTC
319: (void) ioctl(0, TIOCSLTC, (UnivPtr) &ls[OFF]);
320: #endif
321:
322: #ifdef TIOCGWINSZ
323: # ifdef SIGWINCH
324: (void) signal(SIGWINCH, SIG_IGN);
325: # endif
326: win.ws_row = curwind->w_height;
327: (void) ioctl(0, TIOCSWINSZ, (UnivPtr) &win);
328: #else
329: # ifdef BTL_BLIT
330: jwin.bytesy = curwind->w_height;
331: (void) ioctl(0, JSWINSIZE, (UnivPtr) &jwin);
332: # endif
333: #endif
334:
335: sgt = sg[OFF];
336: sgt.sg_flags &= ~(ECHO | CRMOD | ANYP | ALLDELAY | RAW | LCASE | CBREAK | TANDEM);
337: (void) stty(0, &sgt);
338:
339: {
340: int on = 1;
341:
342: (void) ioctl(0, TIOCREMOTE, (UnivPtr) &on);
343: }
344:
345: i = getpid();
346: (void) ioctl(0, TIOCSPGRP, (UnivPtr) &i);
347: (void) setpgrp(0, i);
348: va_init(ap, clobber);
349: make_argv(argv, ap);
350: va_end(ap);
351: execv(argv[0], (const char **) &argv[1]);
352: (void) write(1, "execve failed!\n", (size_t) 15);
353: _exit(errno + 1);
354: }
355:
356: newp = (Process *) emalloc(sizeof *newp);
357:
358: #ifdef O_NDELAY
359: fcntl (ptyfd, F_SETFL, O_NDELAY);
360: #endif
361: newp->p_fd = ptyfd;
362: newp->p_pid = pid;
363:
364: newbuf = do_select((Window *) 0, bufname);
365: newbuf->b_type = B_PROCESS;
366: newp->p_buffer = newbuf;
367: newbuf->b_process = newp; /* sorta circular, eh? */
368: pop_wind(bufname, clobber, B_PROCESS);
369: /* Pop_wind() after everything is set up; important!
370: Bindings won't work right unless newbuf->b_process is already
371: set up BEFORE NEWBUF is first SetBuf()'d. */
372: ToLast();
373: if (!bolp())
374: LineInsert(1);
375:
376: cmdbuf[0] = '\0';
377: va_init(ap, clobber);
378: while ((cp = va_arg(ap, char *)) != NIL)
379: swritef(&cmdbuf[strlen(cmdbuf)], "%s ", cp++);
380: va_end(ap);
381:
382: newp->p_name = copystr(cmdbuf);
383: newp->p_state = NEW;
384: newp->p_reason = 0;
385: newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
386: newp->p_dbx_mode = NO;
387:
388: newp->p_next = procs;
389: procs = newp;
390: NumProcs += 1;
391: global_fd |= 1L << newp->p_fd;
392: SetWind(owind);
393:
394: fail: SigRelse(SIGCHLD);
395: #ifdef SIGWINCH
396: SigRelse(SIGWINCH);
397: #endif
398: }
399:
400: void
401: pinit()
402: {
403: (void) signal(SIGCHLD, proc_child);
404: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.