[unix-history] / usr / src / new / jove / iproc-ptys.c

/***************************************************************************
 * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
 * is provided to you without charge, and with no warranty.  You may give  *
 * away copies of JOVE, including sources, provided that this notice is    *
 * included in all the files.                                              *
 ***************************************************************************/

#ifdef BSD4_2
#   include <sys/wait.h>
#else
#   include <wait.h>
#endif
#include <signal.h>
#include <sgtty.h>
#include <errno.h>

#define DEAD	1	/* dead but haven't informed user yet */
#define STOPPED	2	/* job stopped */
#define RUNNING	3	/* just running */
#define NEW	4	/* brand new, never been ... received no input */

/* If process is dead, flags says how. */
#define EXITED	1
#define KILLED	2

#define isdead(p)	(p == 0 || proc_state(p) == DEAD || p->p_fd == -1)
#define makedead(p)	(proc_state(p) = DEAD)

#define proc_buf(p)	(p->p_buffer->b_name)
#define proc_cmd(p)	(p->p_name)
#define proc_state(p)	(p->p_state)

private Process	*procs = 0;

long	global_fd = 1;
int	NumProcs = 0;

#ifdef BRLUNIX
	extern struct sg_brl sg1;
#else
	extern struct sgttyb sg1;
#endif

extern struct tchars tc1;

#ifdef TIOCSLTC
	extern struct ltchars ls1;
#endif

char *
pstate(p)
Process	*p;
{
	switch (proc_state(p)) {
	case STOPPED:
		return "Stopped";

	case RUNNING:
		return "Running";

	case DEAD:
		if (p->p_howdied == EXITED) {
			if (p->p_reason == 0)
				return "Done";
			return sprint("Exit %d", p->p_reason);
		}
		return sprint("Killed %d", p->p_reason);

	case NEW:
		return "New";

	default:
		return "Unknown state";
	}
}

static Process *
proc_pid(pid)
{
	register Process	*p;

	for (p = procs; p != 0; p = p->p_next)
		if (p->p_pid == pid)
			break;

	return p;
}

read_proc(fd)
register int	fd;
{
	register Process	*p;
	unsigned int	n;
	char	ibuf[1024];

	for (p = procs; p != 0; p = p->p_next)
		if (p->p_fd == fd)
			break;

	if (p == 0) {
		printf("\riproc: unknown fd %d", fd);
		return;
	}

	n = read(fd, ibuf, sizeof(ibuf) - 1);
	if (n == -1 && errno == EIO) {
		if (proc_state(p) == NEW)
			return;
		proc_close(p);
		makedead(p);
		return;
	} else {
		if (proc_state(p) != RUNNING) {
			proc_state(p) = RUNNING;
			UpdModLine = YES;
		}
	}
	if (n <= 0) {
		if (n == 0)
			strcpy(ibuf, "[Process EOF]");
		else
			sprintf(ibuf, "\n[pty read error: %d]\n", errno);
	} else
		ibuf[n] = '\0';
	proc_rec(p, ibuf);
}

ProcKill()
{
	register Buffer	*b;
	Process	*buf_to_proc();
	char	*bname;

	bname = ask_buf(curbuf);

	if ((b = buf_exists(bname)) == 0)
		complain("[No such buffer]");
	if (b->b_process == 0)
		complain("%s not tied to a process.", bname);
	proc_kill(b->b_process, SIGKILL);
}

ProcCont()
{
	Process	*p;

	if ((p = curbuf->b_process) == 0)
		complain("[No process]");
	if (p->p_state != DEAD) {
		proc_kill(p, SIGCONT);
		p->p_state = RUNNING;
	}		
}

ProcEof()
{
	send_p(tc1.t_eofc);
}

ProcInt()
{
	send_p(tc1.t_intrc);
}

ProcQuit()
{
	send_p(tc1.t_quitc);
}

ProcStop()
{
	send_p(ls1.t_suspc);
}

ProcDStop()
{
	send_p(ls1.t_dsuspc);
}

send_p(c)
char	c;
{
	Process	*p;
	char	buf[2];

	if ((p = curbuf->b_process) == 0)
		complain("[No process]");
	ToLast();
	buf[0] = c;
	buf[1] = '\0';
	proc_rec(p, buf);
	(void) write(p->p_fd, &c, 1);
}

private
proc_close(p)
Process *p;
{
	sighold(SIGCHLD);	/* be mutually exclusive */

	if (p->p_fd >= 0) {
		(void) close(p->p_fd);
		global_fd &= ~(1L << p->p_fd);
		NumProcs -= 1;
		p->p_fd = -1;
	}

	sigrelse(SIGCHLD);
}

do_rtp(mp)
register Mark	*mp;
{
	register Process	*p = curbuf->b_process;
	Line	*line1 = curline,
		*line2 = mp->m_line;
	int	char1 = curchar,
		char2 = mp->m_char;
	char	*gp;
	int	nbytes;

	if (isdead(p) || p->p_buffer != curbuf)
		return;

	(void) fixorder(&line1, &char1, &line2, &char2);
	while (line1 != line2->l_next) {
		gp = ltobuf(line1, genbuf) + char1;
		if (line1 == line2)
			gp[char2] = '\0';
		else
			strcat(gp, "\n");
		if (nbytes = strlen(gp))
			(void) write(p->p_fd, gp, nbytes);
		line1 = line1->l_next;
		char1 = 0;
	}
}

/* VARARGS2 */

private
proc_strt(bufname, clobber, va_alist)
char	*bufname;
va_dcl
{
	va_list	ap;
	char	*argv[32],
		*cp;
	Window *owind = curwind;
	int	pid;
	Process	*newp;
	Buffer 	*newbuf;
	int	i,
		ptyfd,
		ttyfd,
	 	ldisc,
		lmode;
	register char	*s,
			*t;
	extern int	errno;
	static char	ttybuf[11],
			ptybuf[11];
	char	cmdbuf[128];
#ifdef BRLUNIX
	struct sg_brl sg;
#else
	struct sgttyb sg;
#endif

#ifdef TIOCGWINSZ
	struct winsize win;
#else
#  ifdef BTL_BLIT
#  include <sys/jioctl.h>
	struct jwinsize jwin;
#  endif
#endif

	isprocbuf(bufname);	/* make sure BUFNAME is either nonexistant
				   or is of type B_PROCESS */
	for (s = "pqrs"; *s; s++) {
		for (t = "0123456789abcdef"; *t; t++) {
			sprintf(ptybuf, "/dev/pty%c%c", *s, *t);
			if ((ptyfd = open(ptybuf, 2)) >= 0) {
				strcpy(ttybuf, ptybuf);
				ttybuf[5] = 't';
				/* make sure both ends are available */
				if ((i = open(ttybuf, 2)) < 0)
					continue;
				(void) close(i);
				goto out;
			}
		}
	}

out:	if (s == 0 && t == 0)
		complain("[Out of ptys!]");

#ifdef TIOCGETD
	(void) ioctl(0, TIOCGETD, (struct sgttyb *) &ldisc);
#endif
#ifdef TIOCLGET
	(void) ioctl(0, TIOCLGET, (struct sgttyb *) &lmode);
#endif
#ifdef TIOCGWINSZ
	(void) ioctl(0, TIOCGWINSZ, (struct sgttyb *) &win);
#else
#  ifdef BTL_BLIT
	(void) ioctl(0, JWINSIZE, (struct sgttyb *) &jwin);
#  endif /* BTL_BLIT */
#endif

	sighold(SIGCHLD);
#ifdef SIGWINCH
	sighold(SIGWINCH);
#endif
	switch (pid = fork()) {
	case -1:
		(void) close(ptyfd);
		message("[Fork failed!]");
		goto fail;

	case 0:
		sigrelse(SIGCHLD);
#ifdef SIGWINCH
		sigrelse(SIGWINCH);
#endif
		for (i = 0; i < 32; i++)
			(void) close(i);

#ifdef TIOCNOTTY
		if ((i = open("/dev/tty", 2)) >= 0) {
			(void) ioctl(i, TIOCNOTTY, (struct sgttyb *) 0);
			(void) close(i);
		}
#endif
		if ((ttyfd = open(ttybuf, 2)) < 0)
			exit(-1);
		(void) dup2(ttyfd, 1);
		(void) dup2(ttyfd, 2);

#ifdef TIOCSETD
		(void) ioctl(0, TIOCSETD, (struct sgttyb *) &ldisc);
#endif
#ifdef TIOCLSET
		(void) ioctl(0, TIOCLSET, (struct sgttyb *) &lmode);
#endif
#ifdef TIOCSETC
		(void) ioctl(0, TIOCSETC, (struct sgttyb *) &tc1);
#endif
#ifdef TIOCSLTC
		(void) ioctl(0, TIOCSLTC, (struct sgttyb *) &ls1);
#endif

#ifdef TIOCGWINSZ
#    ifdef SIGWINCH
		(void) signal(SIGWINCH, SIG_IGN);
#    endif
		win.ws_row = curwind->w_height;
		(void) ioctl(0, TIOCSWINSZ, (struct sgttyb *) &win);
#else
#  ifdef BTL_BLIT
		jwin.bytesy = curwind->w_height;
		(void) ioctl(0, JSWINSIZE, (struct sgttyb *) &jwin);
#  endif
#endif

		sg = sg1;
		sg.sg_flags &= ~(ECHO | CRMOD);
		(void) stty(0, &sg);

		i = getpid();
		(void) ioctl(0, TIOCSPGRP, (struct sgttyb *) &i);
		(void) setpgrp(0, i);
		va_start(ap);
		make_argv(argv, ap);
		va_end(ap);
		execv(argv[0], &argv[1]);
		(void) write(1, "execve failed!\n", 15);
		_exit(errno + 1);
	}

	newp = (Process *) emalloc(sizeof *newp);

	newp->p_fd = ptyfd;
	newp->p_pid = pid;

	newbuf = do_select((Window *) 0, bufname);
	newbuf->b_type = B_PROCESS;
	newp->p_buffer = newbuf;
	newbuf->b_process = newp;	/* sorta circular, eh? */
	pop_wind(bufname, clobber, B_PROCESS);
	/* Pop_wind() after everything is set up; important!
	   Bindings won't work right unless newbuf->b_process is already
	   set up BEFORE NEWBUF is first SetBuf()'d. */
	ToLast();
	if (!bolp())
		LineInsert(1);

	cmdbuf[0] = '\0';
	va_start(ap);
	while (cp = va_arg(ap, char *))
		sprintf(&cmdbuf[strlen(cmdbuf)], "%s ", cp++);
	va_end(ap);

	newp->p_name = copystr(cmdbuf);
	newp->p_state = NEW;
	newp->p_reason = 0;
	newp->p_mark = MakeMark(curline, curchar, M_FLOATER);

	newp->p_next = procs;
	procs = newp;
	NumProcs += 1;
	global_fd |= 1L << newp->p_fd;
	SetWind(owind);

fail:	sigrelse(SIGCHLD);
#ifdef SIGWINCH
	sigrelse(SIGWINCH);
#endif
}
	
pinit()
{
	(void) signal(SIGCHLD, proc_child);
}
Commit	Line	Data
6ca833f5 C	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	#ifdef BSD4_2
	9	# include <sys/wait.h>
	10	#else
	11	# include <wait.h>
	12	#endif
	13	#include <signal.h>
	14	#include <sgtty.h>
	15	#include <errno.h>
	16
	17	#define DEAD 1 /* dead but haven't informed user yet */
	18	#define STOPPED 2 /* job stopped */
	19	#define RUNNING 3 /* just running */
	20	#define NEW 4 /* brand new, never been ... received no input */
	21
	22	/* If process is dead, flags says how. */
	23	#define EXITED 1
	24	#define KILLED 2
	25
	26	#define isdead(p) (p == 0 \|\| proc_state(p) == DEAD \|\| p->p_fd == -1)
	27	#define makedead(p) (proc_state(p) = DEAD)
	28
	29	#define proc_buf(p) (p->p_buffer->b_name)
	30	#define proc_cmd(p) (p->p_name)
	31	#define proc_state(p) (p->p_state)
	32
	33	private Process *procs = 0;
	34
	35	long global_fd = 1;
	36	int NumProcs = 0;
	37
	38	#ifdef BRLUNIX
	39	extern struct sg_brl sg1;
	40	#else
	41	extern struct sgttyb sg1;
	42	#endif
	43
	44	extern struct tchars tc1;
	45
	46	#ifdef TIOCSLTC
	47	extern struct ltchars ls1;
	48	#endif
	49
	50	char *
	51	pstate(p)
	52	Process *p;
	53	{
	54	switch (proc_state(p)) {
	55	case STOPPED:
	56	return "Stopped";
	57
	58	case RUNNING:
	59	return "Running";
	60
	61	case DEAD:
	62	if (p->p_howdied == EXITED) {
	63	if (p->p_reason == 0)
	64	return "Done";
65	return sprint("Exit %d", p->p_reason);
66	}
67	return sprint("Killed %d", p->p_reason);
68
69	case NEW:
70	return "New";
71
72	default:
73	return "Unknown state";
74	}
75	}
76
77	static Process *
78	proc_pid(pid)
79	{
80	register Process *p;
81
82	for (p = procs; p != 0; p = p->p_next)
83	if (p->p_pid == pid)
84	break;
85
86	return p;
87	}
88
89	read_proc(fd)
90	register int fd;
91	{
92	register Process *p;
93	unsigned int n;
94	char ibuf[1024];
95
96	for (p = procs; p != 0; p = p->p_next)
97	if (p->p_fd == fd)
98	break;
99
100	if (p == 0) {
101	printf("\riproc: unknown fd %d", fd);
102	return;
103	}
104
105	n = read(fd, ibuf, sizeof(ibuf) - 1);
106	if (n == -1 && errno == EIO) {
107	if (proc_state(p) == NEW)
108	return;
109	proc_close(p);
110	makedead(p);
111	return;
112	} else {
113	if (proc_state(p) != RUNNING) {
114	proc_state(p) = RUNNING;
115	UpdModLine = YES;
116	}
117	}
118	if (n <= 0) {
119	if (n == 0)
120	strcpy(ibuf, "[Process EOF]");
121	else
122	sprintf(ibuf, "\n[pty read error: %d]\n", errno);
123	} else
124	ibuf[n] = '\0';
125	proc_rec(p, ibuf);
126	}
127
128	ProcKill()
129	{
130	register Buffer *b;
131	Process *buf_to_proc();
132	char *bname;
133
134	bname = ask_buf(curbuf);
135
136	if ((b = buf_exists(bname)) == 0)
137	complain("[No such buffer]");
138	if (b->b_process == 0)
139	complain("%s not tied to a process.", bname);
140	proc_kill(b->b_process, SIGKILL);
141	}
142
143	ProcCont()
144	{
145	Process *p;
146
147	if ((p = curbuf->b_process) == 0)
148	complain("[No process]");
149	if (p->p_state != DEAD) {
150	proc_kill(p, SIGCONT);
151	p->p_state = RUNNING;
152	}
153	}
154
155	ProcEof()
156	{
157	send_p(tc1.t_eofc);
158	}
159
160	ProcInt()
161	{
162	send_p(tc1.t_intrc);
163	}
164
165	ProcQuit()
166	{
167	send_p(tc1.t_quitc);
168	}
169
170	ProcStop()
171	{
172	send_p(ls1.t_suspc);
173	}
174
175	ProcDStop()
176	{
177	send_p(ls1.t_dsuspc);
178	}
179
180	send_p(c)
181	char c;
182	{
183	Process *p;
184	char buf[2];
185
186	if ((p = curbuf->b_process) == 0)
187	complain("[No process]");
188	ToLast();
189	buf[0] = c;
190	buf[1] = '\0';
191	proc_rec(p, buf);
192	(void) write(p->p_fd, &c, 1);
193	}
194
195	private
196	proc_close(p)
197	Process *p;
198	{
199	sighold(SIGCHLD); /* be mutually exclusive */
200
201	if (p->p_fd >= 0) {
202	(void) close(p->p_fd);
203	global_fd &= ~(1L << p->p_fd);
204	NumProcs -= 1;
205	p->p_fd = -1;
206	}
207
208	sigrelse(SIGCHLD);
209	}
210
211	do_rtp(mp)
212	register Mark *mp;
213	{
214	register Process *p = curbuf->b_process;
215	Line *line1 = curline,
216	*line2 = mp->m_line;
217	int char1 = curchar,
218	char2 = mp->m_char;
219	char *gp;
220	int nbytes;
221
222	if (isdead(p) \|\| p->p_buffer != curbuf)
223	return;
224
225	(void) fixorder(&line1, &char1, &line2, &char2);
226	while (line1 != line2->l_next) {
227	gp = ltobuf(line1, genbuf) + char1;
228	if (line1 == line2)
229	gp[char2] = '\0';
230	else
231	strcat(gp, "\n");
232	if (nbytes = strlen(gp))
233	(void) write(p->p_fd, gp, nbytes);
234	line1 = line1->l_next;
235	char1 = 0;
236	}
237	}
238
239	/* VARARGS2 */
240
241	private
242	proc_strt(bufname, clobber, va_alist)
243	char *bufname;
244	va_dcl
245	{
246	va_list ap;
247	char *argv[32],
248	*cp;
249	Window *owind = curwind;
250	int pid;
251	Process *newp;
252	Buffer *newbuf;
253	int i,
254	ptyfd,
255	ttyfd,
256	ldisc,
257	lmode;
258	register char *s,
259	*t;
260	extern int errno;
261	static char ttybuf[11],
262	ptybuf[11];
263	char cmdbuf[128];
264	#ifdef BRLUNIX
265	struct sg_brl sg;
266	#else
267	struct sgttyb sg;
268	#endif
269
270	#ifdef TIOCGWINSZ
271	struct winsize win;
272	#else
273	# ifdef BTL_BLIT
274	# include <sys/jioctl.h>
275	struct jwinsize jwin;
276	# endif
277	#endif
278
279	isprocbuf(bufname); /* make sure BUFNAME is either nonexistant
280	or is of type B_PROCESS */
281	for (s = "pqrs"; *s; s++) {
282	for (t = "0123456789abcdef"; *t; t++) {
283	sprintf(ptybuf, "/dev/pty%c%c", s, t);
284	if ((ptyfd = open(ptybuf, 2)) >= 0) {
285	strcpy(ttybuf, ptybuf);
286	ttybuf[5] = 't';
287	/* make sure both ends are available */
288	if ((i = open(ttybuf, 2)) < 0)
289	continue;
290	(void) close(i);
291	goto out;
292	}
293	}
294	}
295
296	out: if (s == 0 && t == 0)
297	complain("[Out of ptys!]");
298
299	#ifdef TIOCGETD
300	(void) ioctl(0, TIOCGETD, (struct sgttyb *) &ldisc);
301	#endif
302	#ifdef TIOCLGET
303	(void) ioctl(0, TIOCLGET, (struct sgttyb *) &lmode);
304	#endif
305	#ifdef TIOCGWINSZ
306	(void) ioctl(0, TIOCGWINSZ, (struct sgttyb *) &win);
307	#else
308	# ifdef BTL_BLIT
309	(void) ioctl(0, JWINSIZE, (struct sgttyb *) &jwin);
310	# endif /* BTL_BLIT */
311	#endif
312
313	sighold(SIGCHLD);
314	#ifdef SIGWINCH
315	sighold(SIGWINCH);
316	#endif
317	switch (pid = fork()) {
318	case -1:
319	(void) close(ptyfd);
320	message("[Fork failed!]");
321	goto fail;
322
323	case 0:
324	sigrelse(SIGCHLD);
325	#ifdef SIGWINCH
326	sigrelse(SIGWINCH);
327	#endif
328	for (i = 0; i < 32; i++)
329	(void) close(i);
330
331	#ifdef TIOCNOTTY
332	if ((i = open("/dev/tty", 2)) >= 0) {
333	(void) ioctl(i, TIOCNOTTY, (struct sgttyb *) 0);
334	(void) close(i);
335	}
336	#endif
337	if ((ttyfd = open(ttybuf, 2)) < 0)
338	exit(-1);
339	(void) dup2(ttyfd, 1);
340	(void) dup2(ttyfd, 2);
341
342	#ifdef TIOCSETD
343	(void) ioctl(0, TIOCSETD, (struct sgttyb *) &ldisc);
344	#endif
345	#ifdef TIOCLSET
346	(void) ioctl(0, TIOCLSET, (struct sgttyb *) &lmode);
347	#endif
348	#ifdef TIOCSETC
349	(void) ioctl(0, TIOCSETC, (struct sgttyb *) &tc1);
350	#endif
351	#ifdef TIOCSLTC
352	(void) ioctl(0, TIOCSLTC, (struct sgttyb *) &ls1);
353	#endif
354
355	#ifdef TIOCGWINSZ
356	# ifdef SIGWINCH
357	(void) signal(SIGWINCH, SIG_IGN);
358	# endif
359	win.ws_row = curwind->w_height;
360	(void) ioctl(0, TIOCSWINSZ, (struct sgttyb *) &win);
361	#else
362	# ifdef BTL_BLIT
363	jwin.bytesy = curwind->w_height;
364	(void) ioctl(0, JSWINSIZE, (struct sgttyb *) &jwin);
365	# endif
366	#endif
367
368	sg = sg1;
369	sg.sg_flags &= ~(ECHO \| CRMOD);
370	(void) stty(0, &sg);
371
372	i = getpid();
373	(void) ioctl(0, TIOCSPGRP, (struct sgttyb *) &i);
374	(void) setpgrp(0, i);
375	va_start(ap);
376	make_argv(argv, ap);
377	va_end(ap);
378	execv(argv[0], &argv[1]);
379	(void) write(1, "execve failed!\n", 15);
380	_exit(errno + 1);
381	}
382
383	newp = (Process ) emalloc(sizeof newp);
384
385	newp->p_fd = ptyfd;
386	newp->p_pid = pid;
387
388	newbuf = do_select((Window *) 0, bufname);
389	newbuf->b_type = B_PROCESS;
390	newp->p_buffer = newbuf;
391	newbuf->b_process = newp; /* sorta circular, eh? */
392	pop_wind(bufname, clobber, B_PROCESS);
393	/* Pop_wind() after everything is set up; important!
394	Bindings won't work right unless newbuf->b_process is already
395	set up BEFORE NEWBUF is first SetBuf()'d. */
396	ToLast();
397	if (!bolp())
398	LineInsert(1);
399
400	cmdbuf[0] = '\0';
401	va_start(ap);
402	while (cp = va_arg(ap, char *))
403	sprintf(&cmdbuf[strlen(cmdbuf)], "%s ", cp++);
404	va_end(ap);
405
406	newp->p_name = copystr(cmdbuf);
407	newp->p_state = NEW;
408	newp->p_reason = 0;
409	newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
410
411	newp->p_next = procs;
412	procs = newp;
413	NumProcs += 1;
414	global_fd \|= 1L << newp->p_fd;
415	SetWind(owind);
416
417	fail: sigrelse(SIGCHLD);
418	#ifdef SIGWINCH
419	sigrelse(SIGWINCH);
420	#endif
421	}
422
423	pinit()
424	{
425	(void) signal(SIGCHLD, proc_child);
426	}
427