![[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] / 43BSD / contrib / jove|
Return to iproc-ptys.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 root 1: /*************************************************************************
2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
3: * provided to you without charge for use only on a licensed Unix *
4: * system. You may copy JOVE provided that this notice is included with *
5: * the copy. You may not sell copies of this program or versions *
6: * modified for use on microcomputer systems, unless the copies are *
7: * included with a Unix system distribution and the source is provided. *
8: *************************************************************************/
9:
10: #ifdef BSD4_2
11: # include <sys/wait.h>
12: #else
13: # include <wait.h>
14: #endif
15: #include <signal.h>
16: #include <sgtty.h>
17:
18: typedef struct process Process;
19:
20: #define DEAD 1 /* Dead but haven't informed user yet */
21: #define STOPPED 2 /* Job stopped */
22: #define RUNNING 3 /* Just running */
23: #define NEW 4 /* This process is brand new */
24:
25: /* If process is dead, flags says how. */
26: #define EXITED 1
27: #define KILLED 2
28:
29: #define isdead(p) (p == 0 || proc_state(p) == DEAD || p->p_fd == -1)
30:
31: #define proc_buf(p) (p->p_buffer->b_name)
32: #define proc_cmd(p) (p->p_name)
33: #define proc_state(p) (p->p_state)
34:
35: struct process {
36: Process *p_next;
37: int p_fd, /* File descriptor of ptyp? opened r/w */
38: p_pid; /* pid of child (the shell) */
39: Buffer *p_buffer; /* Add output to end of this buffer */
40: char *p_name; /* ... */
41: char p_state, /* State */
42: p_howdied, /* Killed? or Exited? */
43: p_reason, /* If signaled, p_reason is the signal; else
44: it is the the exit code */
45: p_eof; /* Received EOF, so can be free'd up */
46: Mark *p_mark; /* Where output left us. */
47: data_obj
48: *p_cmd; /* Command to call when process dies */
49: } *procs = 0,
50: *cur_proc = 0;
51:
52: char proc_prompt[80] = "% ";
53:
54: int global_fd = 1,
55: NumProcs = 0;
56:
57: #ifdef BRLUNIX
58: extern struct sg_brl sg1;
59: #else
60: extern struct sgttyb sg1;
61: #endif
62:
63: extern struct tchars tc1;
64:
65: #ifdef TIOCSLTC
66: extern struct ltchars ls1;
67: #endif
68:
69: static char *
70: pstate(p)
71: Process *p;
72: {
73: switch (proc_state(p)) {
74: case STOPPED:
75: return "Stopped";
76:
77: case RUNNING:
78: return "Running";
79:
80: case DEAD:
81: if (p->p_howdied == EXITED) {
82: if (p->p_reason == 0)
83: return "Done";
84: return sprint("exit(%d)", p->p_reason);
85: }
86: return sprint("Killed(%d)", p->p_reason);
87:
88: default:
89: return "Unknown state.";
90: }
91: }
92:
93: static Process *
94: proc_pid(pid)
95: {
96: register Process *p;
97:
98: for (p = procs; p != 0; p = p->p_next)
99: if (p->p_pid == pid)
100: break;
101:
102: return p;
103: }
104:
105: read_proc(fd)
106: register int fd;
107: {
108: register Process *p;
109: unsigned int n;
110: char ibuf[1024];
111:
112: for (p = procs; p != 0; p = p->p_next)
113: if (p->p_fd == fd)
114: break;
115:
116: if (p == 0) {
117: printf("\riproc: unknown fd %d", fd);
118: return;
119: }
120:
121: n = read(fd, ibuf, sizeof(ibuf) - 1);
122:
123: if (n == 0) {
124: proc_close(p);
125: NumProcs--;
126: return;
127: }
128:
129: ibuf[n] = '\0';
130: proc_rec(p, ibuf);
131: redisplay();
132: }
133:
134: ProcKill()
135: {
136: register Buffer *b;
137: register Process *p;
138: Process *buf_to_proc();
139: char *bname;
140:
141: bname = ask_buf(cur_proc ? cur_proc->p_buffer : (Buffer *) 0);
142:
143: if ((b = buf_exists(bname)) == 0)
144: complain("[No such buffer]");
145: if ((p = buf_to_proc(b)) == 0)
146: complain("%s not tied to a process.", bname);
147: proc_kill(p, SIGKILL);
148: }
149:
150: Process *
151: buf_to_proc(b)
152: register Buffer *b;
153: {
154: register Process *p;
155:
156: for (p = procs; p != 0; p = p->p_next)
157: if (p->p_buffer == b)
158: return p;
159: return 0;
160: }
161:
162: ProcCont()
163: {
164: if (cur_proc == 0)
165: complain("[No processes]");
166: if (cur_proc->p_state != DEAD) {
167: proc_kill(cur_proc, SIGCONT);
168: cur_proc->p_state = RUNNING;
169: }
170: }
171:
172: ProcEof()
173: {
174: send_p(tc1.t_eofc);
175: }
176:
177: ProcInt()
178: {
179: send_p(tc1.t_intrc);
180: }
181:
182: ProcQuit()
183: {
184: send_p(tc1.t_quitc);
185: }
186:
187: #ifdef TIOCSLTC
188:
189: ProcStop()
190: {
191: send_p(ls1.t_suspc);
192: }
193:
194: ProcDStop()
195: {
196: send_p(ls1.t_dsuspc);
197: }
198:
199: #endif
200:
201: send_p(c)
202: char c;
203: {
204: if (cur_proc == 0)
205: complain("[No processes]");
206: if (cur_proc->p_buffer == curbuf)
207: ToLast();
208: (void) write(cur_proc->p_fd, &c, 1);
209: }
210:
211: static
212: proc_close(p)
213: Process *p;
214: {
215: (void) close(p->p_fd);
216: global_fd &= ~(1 << p->p_fd);
217: p->p_eof++;
218: }
219:
220: do_rtp(mp)
221: register Mark *mp;
222: {
223: register Process *p = cur_proc;
224: Line *line1 = curline,
225: *line2 = mp->m_line;
226: int char1 = curchar,
227: char2 = mp->m_char;
228: char *gp;
229:
230: if (isdead(p) || p->p_buffer != curbuf)
231: return;
232:
233: (void) fixorder(&line1, &char1, &line2, &char2);
234: while (line1 != line2->l_next) {
235: gp = ltobuf(line1, genbuf) + char1;
236: if (line1 == line2)
237: gp[char2] = '\0';
238: else
239: strcat(gp, "\n");
240: (void) write(p->p_fd, gp, strlen(gp));
241: line1 = line1->l_next;
242: char1 = 0;
243: }
244: }
245:
246: /* VARARGS2 */
247:
248: static
249: proc_strt(bufname, procname, cmd)
250: char *bufname,
251: *procname,
252: *cmd;
253: {
254: Window *owind = curwind;
255: int pid;
256: Process *newp;
257: Buffer *bp;
258: char **cp;
259: int i,
260: f,
261: ttyfd;
262: long ldisc,
263: lmode;
264: register char *s,
265: *t;
266: extern int errno;
267: extern char **environ;
268: static char ttybuf[11],
269: ptybuf[11];
270: char cmdbuf[128];
271: #ifdef BRLUNIX
272: struct sg_brl sg;
273: #else
274: struct sgttyb sg;
275: #endif
276:
277: #ifdef TIOCGWINSZ
278: struct winsize win;
279: #else
280: # ifdef BTL_BLIT
281: # include <sys/jioctl.h>
282: struct jwinsize jwin;
283: # endif
284: #endif
285:
286: bp = buf_exists(bufname);
287: if (bp != 0 && IsModified(bp) && bp->b_type != B_IPROCESS && bp->b_type != B_PROCESS)
288: complain("Command would over-write buffer %s.", procname, bufname);
289: pop_wind(bufname, 1, B_IPROCESS);
290:
291: for (s = "pqrs"; *s; s++) {
292: for (t = "0123456789abcdef"; *t; t++) {
293: sprintf(ptybuf, "/dev/pty%c%c", *s, *t);
294: if ((ttyfd = open(ptybuf, 2)) >= 0)
295: goto out;
296: }
297: }
298:
299: out: if (s == 0 && t == 0)
300: complain("[Out of ptys!]");
301:
302: strcpy(ttybuf, ptybuf);
303: ttybuf[5] = 't';
304:
305: #ifdef TIOCGETD
306: (void) ioctl(0, TIOCGETD, (struct sgttyb *) &ldisc);
307: #endif
308: #ifdef TIOCLGET
309: (void) ioctl(0, TIOCLGET, (struct sgttyb *) &lmode);
310: #endif
311: #ifdef TIOCGWINSZ
312: (void) ioctl(0, TIOCGWINSZ, (struct sgttyb *) &win);
313: #else
314: # ifdef BTL_BLIT
315: (void) ioctl(0, JWINSIZE, (struct sgttyb *) &jwin);
316: # endif BTL_BLIT
317: #endif
318:
319: switch (pid = fork()) {
320: case -1:
321: (void) close(ttyfd);
322: complain("[Fork failed!]");
323:
324: case 0:
325: cp = &cmd;
326:
327: for (i = 0; i < 32; i++)
328: (void) close(i);
329:
330: #ifdef TIOCNOTTY
331: if ((i = open("/dev/tty", 2)) >= 0) {
332: (void) ioctl(i, TIOCNOTTY, (struct sgttyb *) 0);
333: (void) close(i);
334: }
335: #endif
336: i = open(ttybuf, 2);
337: for (f = 0; f <= 2; f++)
338: (void) dup2(i, f);
339:
340: #ifdef TIOCSETD
341: (void) ioctl(0, TIOCSETD, (struct sgttyb *) &ldisc);
342: #endif
343: #ifdef TIOCLSET
344: (void) ioctl(0, TIOCLSET, (struct sgttyb *) &lmode);
345: #endif
346: #ifdef TIOCSETC
347: (void) ioctl(0, TIOCSETC, (struct sgttyb *) &tc1);
348: #endif
349: #ifdef TIOCSLTC
350: (void) ioctl(0, TIOCSLTC, (struct sgttyb *) &ls1);
351: #endif
352:
353: #ifdef TIOCGWINSZ
354: # ifdef SIGWINCH
355: (void) signal(SIGWINCH, SIG_IGN);
356: # endif
357: win.ws_row = curwind->w_height;
358: (void) ioctl(0, TIOCSWINSZ, (struct sgttyb *) &win);
359: #else
360: # ifdef BTL_BLIT
361: jwin.bytesy = curwind->w_height;
362: (void) ioctl(0, JSWINSIZE, (struct sgttyb *) &jwin);
363: # endif
364: #endif
365:
366: sg = sg1;
367: sg.sg_flags &= ~(ECHO | CRMOD);
368: (void) stty(0, &sg);
369:
370: i = getpid();
371: (void) ioctl(0, TIOCSPGRP, (struct sgttyb *) &i);
372: (void) setpgrp(0, i);
373: execve(cp[0], &cp[1], environ);
374: (void) write(1, "execve failed!\n", 15);
375: _exit(errno + 1);
376: }
377:
378: sighold(SIGCHLD);
379: #ifdef SIGWINCH
380: sighold(SIGWINCH);
381: #endif
382: cur_proc = newp = (Process *) emalloc(sizeof *newp);
383:
384: newp->p_fd = ttyfd;
385: newp->p_pid = pid;
386: newp->p_eof = 0;
387: newp->p_buffer = curbuf;
388:
389: cp = &cmd + 1;
390: cmdbuf[0] = '\0';
391: while (*cp != 0)
392: (void) sprintf(&cmdbuf[strlen(cmdbuf)], "%s ", *cp++);
393:
394: newp->p_name = copystr(cmdbuf);
395: newp->p_state = RUNNING;
396: newp->p_reason = 0;
397: newp->p_mark = MakeMark(curline, curchar, FLOATER);
398:
399: newp->p_next = procs;
400: procs = newp;
401: NumProcs++;
402: global_fd |= 1 << newp->p_fd;
403: sigrelse(SIGCHLD);
404: SetWind(owind);
405: }
406:
407: pinit()
408: {
409: (void) signal(SIGCHLD, proc_child);
410: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.