![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iproc.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.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: #include "jove.h"
11:
12: #ifdef IPROCS
13:
14: int proc_child();
15:
16: #ifdef PIPEPROCS
17: # include "iproc-pipes.c"
18: #else
19: # include "iproc-ptys.c"
20: #endif
21:
22: KillProcs()
23: {
24: register Process *p;
25: int killem = -1; /* -1 means undetermined */
26: char *yorn;
27:
28: for (p = procs; p != 0; p = p->p_next)
29: if (!isdead(p)) {
30: if (killem == -1) {
31: yorn = ask("y", "Should I kill your i-processes? ");
32: killem = (Upper(*yorn) == 'Y');
33: }
34: if (killem)
35: proc_kill(p, SIGKILL);
36: }
37: }
38:
39: static Process *
40: proc_exists(name)
41: char *name;
42: {
43: register Process *p;
44:
45: for (p = procs; p != 0; p = p->p_next)
46: if (strcmp(proc_buf(p), name) == 0) {
47: (void) pstate(p);
48: if (p->p_eof) {
49: DealWDeath();
50: return 0;
51: }
52: break;
53: }
54:
55: return p;
56: }
57:
58: assign_p()
59: {
60: register Process *p;
61:
62: for (p = procs; p != 0; p = p->p_next)
63: if (p->p_buffer == curbuf) {
64: cur_proc = p;
65: break;
66: }
67: }
68:
69: pbuftiedp(b)
70: Buffer *b;
71: {
72: register Process *p;
73:
74: for (p = procs; p != 0; p = p->p_next)
75: if (p->p_buffer == b && !p->p_eof)
76: complain("[There is a process tied to %s]", proc_buf(p));
77: }
78:
79: /* Process receive: receives the characters in buf, and appends them to
80: the buffer associated with p. */
81:
82: static
83: proc_rec(p, buf)
84: register Process *p;
85: char *buf;
86: {
87: Buffer *saveb = curbuf;
88: Window *w;
89: Mark *savepoint;
90: int sameplace = 0,
91: do_disp = 0;
92:
93: if (curwind->w_bufp == p->p_buffer)
94: w = curwind;
95: else
96: w = windbp(p->p_buffer); /* Is this window visible? */
97: if (w != 0)
98: do_disp = (in_window(w, p->p_mark->m_line) != -1);
99: SetBuf(p->p_buffer);
100: savepoint = MakeMark(curline, curchar, FLOATER);
101: ToMark(p->p_mark); /* Where output last stopped. */
102: if (savepoint->m_line == curline && savepoint->m_char == curchar)
103: sameplace++;
104:
105: ins_str(buf, YES);
106: if (do_disp) {
107: w->w_line = curline;
108: w->w_char = curchar;
109: redisplay();
110: }
111: MarkSet(p->p_mark, curline, curchar);
112: if (!sameplace)
113: ToMark(savepoint); /* Back to where we were. */
114: DelMark(savepoint);
115: SetBuf(saveb);
116: }
117:
118: proc_kill(p, sig)
119: Process *p;
120: {
121: if (p == 0 || p->p_state == DEAD)
122: return;
123: if (killpg(p->p_pid, sig) == -1)
124: s_mess("Cannot kill %s!", proc_buf(p));
125: }
126:
127: /* Deal with a process' death. proc_rec turns on the FREEUP bit when it
128: it gets the "EOF" from portsrv. FREEUP'd processes get unlinked from
129: the list, and the proc stucture and proc_buf(p) get free'd up, here. */
130:
131: static
132: DealWDeath()
133: {
134: register Process *p,
135: *next,
136: *prev = 0;
137:
138: for (p = procs; p != 0; p = next) {
139: next = p->p_next;
140: if (!p->p_eof) {
141: prev = p;
142: continue;
143: }
144: if (cur_proc == p)
145: cur_proc = next ? next : prev;
146: proc_close(p);
147: free((char *) p->p_name);
148: free((char *) p);
149: if (prev)
150: prev->p_next = next;
151: else
152: procs = next;
153: }
154: }
155:
156: ProcList()
157: {
158: register Process *p;
159: char *fmt = "%-15s %-15s %-8s %s",
160: pidstr[10];
161:
162: if (procs == 0) {
163: message("[No subprocesses]");
164: return;
165: }
166: TOstart("Process list", TRUE);
167:
168: Typeout(fmt, "Buffer", "Status", "Pid ", "Command");
169: Typeout(fmt, "------", "------", "--- ", "-------");
170: for (p = procs; p != 0; p = p->p_next) {
171: sprintf(pidstr, "%d", p->p_pid);
172: Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
173: }
174: DealWDeath();
175: TOstop();
176: }
177:
178: ProcNewline()
179: {
180: if (isdead(cur_proc))
181: return;
182: if (lastp(curline)) {
183: Eol();
184: LineInsert();
185: do_rtp(cur_proc->p_mark);
186: MarkSet(cur_proc->p_mark, curline, curchar);
187: } else {
188: Bol();
189: while (LookingAt(proc_prompt, linebuf, curchar))
190: SetDot(dosearch(proc_prompt, 1, 1));
191: strcpy(genbuf, linebuf + curchar);
192: ToLast();
193: ins_str(genbuf, NO);
194: }
195: }
196:
197: IShell()
198: {
199: char shell[30];
200: int number = 1;
201:
202: do
203: sprintf(shell, "shell-%d", number++);
204: while (proc_exists(shell));
205:
206: proc_strt(shell, "i-shell", Shell, basename(Shell), "-i", 0);
207: SetWind(windlook(shell));
208: }
209:
210: Iprocess()
211: {
212: extern char ShcomBuf[100],
213: *MakeName();
214: char *command;
215:
216: command = ask(ShcomBuf, ProcFmt);
217: null_ncpy(ShcomBuf, command, (sizeof ShcomBuf) - 1);
218: proc_strt(MakeName(command), command, Shell, basename(Shell), ShFlags, command, 0);
219: }
220:
221: proc_child()
222: {
223: union wait w;
224: int pid;
225:
226: for (;;) {
227: #ifndef VMUNIX
228: pid = wait2(&w.w_status, (WNOHANG | WUNTRACED));
229: #else
230: pid = wait3(&w, (WNOHANG | WUNTRACED), (struct rusage *) 0);
231: #endif
232: if (pid <= 0)
233: break;
234: kill_off(pid, w);
235: }
236: }
237:
238: kill_off(pid, w)
239: int pid;
240: union wait w;
241: {
242: Process *child;
243:
244: if ((child = proc_pid(pid)) == 0)
245: return;
246:
247: if (WIFSTOPPED(w))
248: child->p_state = STOPPED;
249: else {
250: child->p_state = DEAD;
251: if (WIFEXITED(w))
252: child->p_howdied = EXITED;
253: else if (WIFSIGNALED(w)) {
254: child->p_reason = w.w_termsig;
255: child->p_howdied = KILLED;
256: }
257: proc_close(child);
258: }
259: s_mess("%s [%s] %s", pstate(child), proc_buf(child), proc_cmd(child));
260: }
261:
262: /* Push/pod process bindings. I openly acknowledge that this is a
263: kludge, but I can't be bothered making it right. */
264:
265: struct proc_bind {
266: int pb_key;
267: data_obj **pb_map;
268: data_obj *pb_push;
269: data_obj *pb_cmd;
270: struct proc_bind *pb_next;
271: };
272:
273: struct proc_bind *PBinds = 0;
274:
275: PopPBs()
276: {
277: register struct proc_bind *p;
278:
279: for (p = PBinds; p != 0; p = p->pb_next)
280: p->pb_map[p->pb_key] = p->pb_push;
281: }
282:
283: PushPBs()
284: {
285: register struct proc_bind *p;
286:
287: for (p = PBinds; p != 0; p = p->pb_next) {
288: p->pb_push = p->pb_map[p->pb_key];
289: p->pb_map[p->pb_key] = p->pb_cmd;
290: }
291: }
292: /* VARARGS0 */
293:
294: ProcBind()
295: {
296: data_obj *d;
297:
298: if ((d = findcom(ProcFmt, NOTHING)) == 0)
299: return;
300: s_mess(": %f %s ", d->Name);
301: ProcB2(mainmap, EOF, d);
302: }
303:
304: ProcB2(map, lastkey, cmd)
305: data_obj **map,
306: *cmd;
307: {
308: register struct proc_bind *p;
309: data_obj **nextmap;
310: int c;
311:
312: c = addgetc();
313: if (c == EOF) {
314: if (lastkey == EOF)
315: complain("[Empty key sequence]");
316: complain("[Unexpected end-of-line]");
317: } else {
318: if (nextmap = IsPrefix(map[c]))
319: ProcB2(nextmap, c, cmd);
320: else {
321: if (curbuf->b_type == B_IPROCESS)
322: PopPBs();
323:
324: for (p = PBinds; p != 0; p = p->pb_next)
325: if (p->pb_key == c && p->pb_map == map)
326: break;
327: if (p == 0) {
328: p = (struct proc_bind *) emalloc(sizeof *p);
329: p->pb_next = PBinds;
330: PBinds = p;
331: }
332: p->pb_map = map;
333: p->pb_key = c;
334: p->pb_cmd = cmd;
335:
336: if (curbuf->b_type == B_IPROCESS)
337: PushPBs();
338: }
339: }
340: }
341:
342: #endif IPROCS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.