ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/devcomm.c

Comparing ray/src/rt/devcomm.c (file contents):
Revision 2.5 by gregl, Tue Nov 11 19:55:03 1997 UTC vs.
Revision 2.13 by greg, Mon Sep 20 16:26:58 2004 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1988 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		*  devcomm.c - communication routines for separate drivers.
6		*
7	<	*      10/5/88
7	>	*  External symbols declared in driver.h
8		*/
9
10	<	#include "standard.h"
10	>	#include "copyright.h"
11
12	<	#include "color.h"
12	>	#include <sys/types.h>
13	>	#include <sys/wait.h> /* XXX platform specific */
14
15	+	#include "platform.h"
16	+	#include "standard.h"
17		#include "driver.h"
18
19	–	#include "vfork.h"
20	–
19		#ifndef DEVPATH
20		#define DEVPATH         getenv("PATH")  /* device search path */
21		#endif
22
23	<	static int      comm_close(), comm_clear(), comm_paintr(),
24	<	comm_getcur(), comm_comout(), comm_comin(), comm_flush();
23	>	FILE    *devin, *devout;
24	>	int     devchild;
25
26	+	static struct driver * final_connect(void);
27	+	static void mygets(char *s, FILE        *fp);
28	+	static void myputs(char *s, FILE        *fp);
29	+	static void reply_error(char    *routine);
30	+	static void getstate(void);
31	+
32	+	static dr_closef_t comm_close;
33	+	static dr_clearf_t comm_clear;
34	+	static dr_paintrf_t comm_paintr;
35	+	static dr_getcurf_t comm_getcur;
36	+	static dr_comoutf_t comm_comout;
37	+	static dr_cominf_t comm_comin;
38	+	static dr_flushf_t comm_flush;
39	+
40		struct driver   comm_driver = {
41		comm_close, comm_clear, comm_paintr, comm_getcur,
42		comm_comout, comm_comin, comm_flush
43		};
44
33	–	static int      mygets(), myputs(), reply_error(), getstate();
45
35	–	FILE    *devin, *devout;
36	–
37	–	int     devchild;
38	–
39	–
46		static struct driver *
47	<	final_connect()                         /* verify and initialize connection */
47	>	final_connect(void)                             /* verify and initialize connection */
48		{
49		putw(COM_SENDM, devout);
50		fflush(devout);
#	Line 54 | Line 60 | final_connect()                                /* verify and initialize connection
60		}
61
62
63	<	struct driver *
64	<	slave_init(dname, id)                   /* run rview in slave mode */
65	<	char    *dname, *id;
63	>	extern struct driver *
64	>	slave_init(                     /* run rview in slave mode */
65	>	char    *dname,
66	>	char    *id
67	>	)
68		{
69		devchild = -1;                          /* we're the slave here */
70		devout = stdout;                        /* use standard input */
#	Line 65 | Line 73 | char   *dname, *id;
73		}
74
75
76	<	struct driver *
77	<	comm_init(dname, id)                    /* set up and execute driver */
78	<	char    *dname, *id;
76	>	extern struct driver *
77	>	comm_init(                      /* set up and execute driver */
78	>	char    *dname,
79	>	char    *id
80	>	)
81		{
82	<	char    *devname;
82	>	char    *dvcname;
83		int     p1[2], p2[2];
84		char    pin[16], pout[16];
85		/* find driver program */
86	<	if ((devname = getpath(dname, DEVPATH, X_OK)) == NULL) {
86	>	if ((dvcname = getpath(dname, DEVPATH, X_OK)) == NULL) {
87		eputs(dname);
88		eputs(": not found\n");
89		return(NULL);
90		}
91	+	#ifdef RHAS_FORK_EXEC
92		/* open communication pipes */
93		if (pipe(p1) == -1 || pipe(p2) == -1)
94		goto syserr;
95	<	if ((devchild = vfork()) == 0) {        /* fork driver process */
95	>	if ((devchild = fork()) == 0) { /* fork driver process */
96		close(p1[1]);
97		close(p2[0]);
98		sprintf(pin, "%d", p1[0]);
99		sprintf(pout, "%d", p2[1]);
100	<	execl(devname, dname, pin, pout, id, 0);
101	<	perror(devname);
100	>	execl(dvcname, dname, pin, pout, id, 0);
101	>	perror(dvcname);
102		_exit(127);
103		}
104		if (devchild == -1)
105		goto syserr;
106		close(p1[0]);
107		close(p2[1]);
108	+	/*
109	+	* Close write stream on exec to avoid multiprocessing deadlock.
110	+	* No use in read stream without it, so set flag there as well.
111	+	*/
112	+	fcntl(p1[1], F_SETFD, FD_CLOEXEC);
113	+	fcntl(p2[0], F_SETFD, FD_CLOEXEC);
114		if ((devout = fdopen(p1[1], "w")) == NULL)
115		goto syserr;
116		if ((devin = fdopen(p2[0], "r")) == NULL)
#	Line 102 | Line 119 | char   *dname, *id;
119		syserr:
120		perror(dname);
121		return(NULL);
122	+
123	+	#else   /* ! RHAS_FORK_EXEC */
124	+
125	+	eputs(dname);
126	+	eputs(": no fork/exec\n");
127	+	return(NULL);
128	+
129	+	#endif  /* ! RHAS_FORK_EXEC */
130		}
131
132
133	<	static
134	<	comm_close()                    /* done with driver */
133	>	static void
134	>	comm_close(void)                        /* done with driver */
135		{
136		int     pid;
137
#	Line 122 | Line 147 | comm_close()                   /* done with driver */
147		}
148
149
150	<	static
151	<	comm_clear(xres, yres)                          /* clear screen */
152	<	int     xres, yres;
150	>	static void
151	>	comm_clear(                             /* clear screen */
152	>	int     xres,
153	>	int     yres
154	>	)
155		{
156		putc(COM_CLEAR, devout);
157		putw(xres, devout);
#	Line 133 | Line 160 | int    xres, yres;
160		}
161
162
163	<	static
164	<	comm_paintr(col, xmin, ymin, xmax, ymax)        /* paint a rectangle */
165	<	COLOR   col;
166	<	int     xmin, ymin, xmax, ymax;
163	>	static void
164	>	comm_paintr(    /* paint a rectangle */
165	>	COLOR   col,
166	>	int     xmin,
167	>	int     ymin,
168	>	int     xmax,
169	>	int     ymax
170	>	)
171		{
172		putc(COM_PAINTR, devout);
173		fwrite((char *)col, sizeof(COLOR), 1, devout);
#	Line 147 | Line 178 | int    xmin, ymin, xmax, ymax;
178		}
179
180
181	<	static
182	<	comm_flush()                            /* flush output to driver */
181	>	static void
182	>	comm_flush(void)                                /* flush output to driver */
183		{
184		putc(COM_FLUSH, devout);
185		fflush(devout);
#	Line 159 | Line 190 | comm_flush()                           /* flush output to driver */
190
191
192		static int
193	<	comm_getcur(xp, yp)                     /* get and return cursor position */
194	<	int     *xp, *yp;
193	>	comm_getcur(                    /* get and return cursor position */
194	>	int     *xp,
195	>	int     *yp
196	>	)
197		{
198		int     c;
199
#	Line 175 | Line 208 | int    *xp, *yp;
208		}
209
210
211	<	static
212	<	comm_comout(str)                        /* print string to command line */
213	<	char    *str;
211	>	static void
212	>	comm_comout(                    /* print string to command line */
213	>	char    *str
214	>	)
215		{
216		putc(COM_COMOUT, devout);
217		myputs(str, devout);
#	Line 186 | Line 220 | char   *str;
220		}
221
222
223	<	static
224	<	comm_comin(buf, prompt)                 /* read string from command line */
225	<	char    *buf;
226	<	char    *prompt;
223	>	static void
224	>	comm_comin(                     /* read string from command line */
225	>	char    *buf,
226	>	char    *prompt
227	>	)
228		{
229		putc(COM_COMIN, devout);
230		if (prompt == NULL)
#	Line 206 | Line 241 | char   *prompt;
241		}
242
243
244	<	static
245	<	mygets(s, fp)                           /* get string from file (with nul) */
246	<	register char   *s;
247	<	register FILE   *fp;
244	>	static void
245	>	mygets(                         /* get string from file (with nul) */
246	>	register char   *s,
247	>	register FILE   *fp
248	>	)
249		{
250		register int    c;
251
#	Line 220 | Line 256 | register FILE  *fp;
256		}
257
258
259	<	static
260	<	myputs(s, fp)                           /* put string to file (with nul) */
261	<	register char   *s;
262	<	register FILE   *fp;
259	>	static void
260	>	myputs(                         /* put string to file (with nul) */
261	>	register char   *s,
262	>	register FILE   *fp
263	>	)
264		{
265		do
266		putc(*s, fp);
#	Line 231 | Line 268 | register FILE  *fp;
268		}
269
270
271	<	static
272	<	reply_error(routine)                    /* what should we do here? */
273	<	char    *routine;
271	>	static void
272	>	reply_error(                    /* what should we do here? */
273	>	char    *routine
274	>	)
275		{
276		eputs(routine);
277		eputs(": driver reply error\n");
#	Line 241 | Line 279 | char   *routine;
279		}
280
281
282	<	static
283	<	getstate()                              /* get driver state variables */
282	>	static void
283	>	getstate(void)                          /* get driver state variables */
284		{
285		fread((char *)&comm_driver.pixaspect,
286		sizeof(comm_driver.pixaspect), 1, devin);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)