src/rt/devcomm.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  devcomm.c - communication routines for separate drivers.
 *
 *  External symbols declared in driver.h
 */

/* ====================================================================
 * The Radiance Software License, Version 1.0
 *
 * Copyright (c) 1990 - 2002 The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory.   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *         notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *           if any, must include the following acknowledgment:
 *             "This product includes Radiance software
 *                 (http://radsite.lbl.gov/)
 *                 developed by the Lawrence Berkeley National Laboratory
 *               (http://www.lbl.gov/)."
 *       Alternately, this acknowledgment may appear in the software itself,
 *       if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
 *       and "The Regents of the University of California" must
 *       not be used to endorse or promote products derived from this
 *       software without prior written permission. For written
 *       permission, please contact [email protected].
 *
 * 5. Products derived from this software may not be called "Radiance",
 *       nor may "Radiance" appear in their name, without prior written
 *       permission of Lawrence Berkeley National Laboratory.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
 * information on Lawrence Berkeley National Laboratory, please see
 * <http://www.lbl.gov/>.
 */

#include "standard.h"

#include "color.h"

#include "driver.h"

#include "vfork.h"

#ifndef DEVPATH
#define DEVPATH         getenv("PATH")  /* device search path */
#endif

static int      comm_getcur();
static void     comm_close(), comm_clear(), comm_paintr(),
                comm_comin(), comm_comout(), comm_flush();

struct driver   comm_driver = {
        comm_close, comm_clear, comm_paintr, comm_getcur,
        comm_comout, comm_comin, comm_flush
};

static void     mygets(), myputs(), reply_error(), getstate();

FILE    *devin, *devout;

int     devchild;


static struct driver *
final_connect()                         /* verify and initialize connection */
{
        putw(COM_SENDM, devout);
        fflush(devout);
        if (getw(devin) != COM_RECVM)
                return(NULL);
                                                /* get driver parameters */
        getstate();
                                                /* set error vectors */
        erract[COMMAND].pf = comm_comout;
        if (erract[WARNING].pf != NULL)
                erract[WARNING].pf = comm_comout;
        return(&comm_driver);
}


struct driver *
slave_init(dname, id)                   /* run rview in slave mode */
char    *dname, *id;
{
        devchild = -1;                          /* we're the slave here */
        devout = stdout;                        /* use standard input */
        devin = stdin;                          /* and standard output */
        return(final_connect());                /* verify initialization */
}


struct driver *
comm_init(dname, id)                    /* set up and execute driver */
char    *dname, *id;
{
        char    *dvcname;
        int     p1[2], p2[2];
        char    pin[16], pout[16];
                                                /* find driver program */
        if ((dvcname = getpath(dname, DEVPATH, X_OK)) == NULL) {
                eputs(dname);
                eputs(": not found\n");
                return(NULL);
        }
                                                /* open communication pipes */
        if (pipe(p1) == -1 || pipe(p2) == -1)
                goto syserr;
        if ((devchild = vfork()) == 0) {        /* fork driver process */
                close(p1[1]);
                close(p2[0]);
                sprintf(pin, "%d", p1[0]);
                sprintf(pout, "%d", p2[1]);
                execl(dvcname, dname, pin, pout, id, 0);
                perror(dvcname);
                _exit(127);
        }
        if (devchild == -1)
                goto syserr;
        close(p1[0]);
        close(p2[1]);
        if ((devout = fdopen(p1[1], "w")) == NULL)
                goto syserr;
        if ((devin = fdopen(p2[0], "r")) == NULL)
                goto syserr;
        return(final_connect());                /* verify initialization */
syserr:
        perror(dname);
        return(NULL);
}


static void
comm_close()                    /* done with driver */
{
        int     pid;

        erract[COMMAND].pf = NULL;              /* reset error vectors */
        if (erract[WARNING].pf != NULL)
                erract[WARNING].pf = wputs;
        fclose(devout);
        fclose(devin);
        if (devchild < 0)
                return;
        while ((pid = wait(0)) != -1 && pid != devchild)
                ;
}


static void
comm_clear(xres, yres)                          /* clear screen */
int     xres, yres;
{
        putc(COM_CLEAR, devout);
        putw(xres, devout);
        putw(yres, devout);
        fflush(devout);
}


static void
comm_paintr(col, xmin, ymin, xmax, ymax)        /* paint a rectangle */
COLOR   col;
int     xmin, ymin, xmax, ymax;
{
        putc(COM_PAINTR, devout);
        fwrite((char *)col, sizeof(COLOR), 1, devout);
        putw(xmin, devout);
        putw(ymin, devout);
        putw(xmax, devout);
        putw(ymax, devout);
}


static void
comm_flush()                            /* flush output to driver */
{
        putc(COM_FLUSH, devout);
        fflush(devout);
        if (getc(devin) != COM_FLUSH)
                reply_error("flush");
        getstate();
}


static int
comm_getcur(xp, yp)                     /* get and return cursor position */
int     *xp, *yp;
{
        int     c;

        putc(COM_GETCUR, devout);
        fflush(devout);
        if (getc(devin) != COM_GETCUR)
                reply_error("getcur");
        c = getc(devin);
        *xp = getw(devin);
        *yp = getw(devin);
        return(c);
}


static void
comm_comout(str)                        /* print string to command line */
char    *str;
{
        putc(COM_COMOUT, devout);
        myputs(str, devout);
        if (str[strlen(str)-1] == '\n')
                fflush(devout);
}


static void
comm_comin(buf, prompt)                 /* read string from command line */
char    *buf;
char    *prompt;
{
        putc(COM_COMIN, devout);
        if (prompt == NULL)
                putc(0, devout);
        else {
                putc(1, devout);
                myputs(prompt, devout);
        }
        fflush(devout);
        if (getc(devin) != COM_COMIN)
                reply_error("comin");
        mygets(buf, devin);
        getstate();
}


static void
mygets(s, fp)                           /* get string from file (with nul) */
register char   *s;
register FILE   *fp;
{
        register int    c;

        while ((c = getc(fp)) != EOF)
                if ((*s++ = c) == '\0')
                        return;
        *s = '\0';
}


static void
myputs(s, fp)                           /* put string to file (with nul) */
register char   *s;
register FILE   *fp;
{
        do
                putc(*s, fp);
        while (*s++);
}


static void
reply_error(routine)                    /* what should we do here? */
char    *routine;
{
        eputs(routine);
        eputs(": driver reply error\n");
        quit(1);
}


static void
getstate()                              /* get driver state variables */
{
        fread((char *)&comm_driver.pixaspect,
                        sizeof(comm_driver.pixaspect), 1, devin);
        comm_driver.xsiz = getw(devin);
        comm_driver.ysiz = getw(devin);
        comm_driver.inpready = getw(devin);
}
Revision:	2.6
Committed:	Sat Feb 22 02:07:28 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.5:	+77 -22 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.6	static const char RCSid[] = "$Id$";
3	greg	1.1	#endif
4			/*
5			* devcomm.c - communication routines for separate drivers.
6			*
7	greg	2.6	* External symbols declared in driver.h
8			*/
9
10			/* ====================================================================
11			* The Radiance Software License, Version 1.0
12			*
13			* Copyright (c) 1990 - 2002 The Regents of the University of California,
14			* through Lawrence Berkeley National Laboratory. All rights reserved.
15			*
16			* Redistribution and use in source and binary forms, with or without
17			* modification, are permitted provided that the following conditions
18			* are met:
19			*
20			* 1. Redistributions of source code must retain the above copyright
21			* notice, this list of conditions and the following disclaimer.
22			*
23			* 2. Redistributions in binary form must reproduce the above copyright
24			* notice, this list of conditions and the following disclaimer in
25			* the documentation and/or other materials provided with the
26			* distribution.
27			*
28			* 3. The end-user documentation included with the redistribution,
29			* if any, must include the following acknowledgment:
30			* "This product includes Radiance software
31			* (http://radsite.lbl.gov/)
32			* developed by the Lawrence Berkeley National Laboratory
33			* (http://www.lbl.gov/)."
34			* Alternately, this acknowledgment may appear in the software itself,
35			* if and wherever such third-party acknowledgments normally appear.
36			*
37			* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38			* and "The Regents of the University of California" must
39			* not be used to endorse or promote products derived from this
40			* software without prior written permission. For written
41			* permission, please contact [email protected].
42			*
43			* 5. Products derived from this software may not be called "Radiance",
44			* nor may "Radiance" appear in their name, without prior written
45			* permission of Lawrence Berkeley National Laboratory.
46			*
47			* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48			* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50			* DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51			* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53			* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54			* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55			* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56			* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57			* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58			* SUCH DAMAGE.
59			* ====================================================================
60			*
61			* This software consists of voluntary contributions made by many
62			* individuals on behalf of Lawrence Berkeley National Laboratory. For more
63			* information on Lawrence Berkeley National Laboratory, please see
64			* <http://www.lbl.gov/>.
65	greg	1.1	*/
66
67	greg	1.10	#include "standard.h"
68	greg	1.1
69			#include "color.h"
70
71			#include "driver.h"
72
73	greg	2.2	#include "vfork.h"
74
75	greg	1.1	#ifndef DEVPATH
76			#define DEVPATH getenv("PATH") /* device search path */
77			#endif
78
79	greg	2.6	static int comm_getcur();
80			static void comm_close(), comm_clear(), comm_paintr(),
81			comm_comin(), comm_comout(), comm_flush();
82	greg	1.1
83	greg	1.12	struct driver comm_driver = {
84	greg	1.1	comm_close, comm_clear, comm_paintr, comm_getcur,
85	greg	1.12	comm_comout, comm_comin, comm_flush
86	greg	1.1	};
87
88	greg	2.6	static void mygets(), myputs(), reply_error(), getstate();
89	greg	2.4
90	greg	1.1	FILE devin, devout;
91
92			int devchild;
93
94
95	greg	2.3	static struct driver *
96			final_connect() /* verify and initialize connection */
97			{
98			putw(COM_SENDM, devout);
99			fflush(devout);
100			if (getw(devin) != COM_RECVM)
101			return(NULL);
102			/* get driver parameters */
103			getstate();
104			/* set error vectors */
105	gregl	2.5	erract[COMMAND].pf = comm_comout;
106			if (erract[WARNING].pf != NULL)
107			erract[WARNING].pf = comm_comout;
108	greg	2.3	return(&comm_driver);
109			}
110
111
112	greg	1.1	struct driver *
113	greg	2.3	slave_init(dname, id) /* run rview in slave mode */
114			char dname, id;
115			{
116			devchild = -1; /* we're the slave here */
117			devout = stdout; /* use standard input */
118			devin = stdin; /* and standard output */
119			return(final_connect()); /* verify initialization */
120			}
121
122
123			struct driver *
124	greg	1.7	comm_init(dname, id) /* set up and execute driver */
125			char dname, id;
126	greg	1.1	{
127	greg	2.6	char *dvcname;
128	greg	1.1	int p1[2], p2[2];
129	greg	1.7	char pin[16], pout[16];
130			/* find driver program */
131	greg	2.6	if ((dvcname = getpath(dname, DEVPATH, X_OK)) == NULL) {
132	gregl	2.5	eputs(dname);
133			eputs(": not found\n");
134	greg	1.1	return(NULL);
135			}
136	greg	1.7	/* open communication pipes */
137	greg	1.1	if (pipe(p1) == -1 \|\| pipe(p2) == -1)
138			goto syserr;
139	greg	1.7	if ((devchild = vfork()) == 0) { /* fork driver process */
140	greg	1.1	close(p1[1]);
141			close(p2[0]);
142	greg	1.7	sprintf(pin, "%d", p1[0]);
143			sprintf(pout, "%d", p2[1]);
144	greg	2.6	execl(dvcname, dname, pin, pout, id, 0);
145			perror(dvcname);
146	greg	1.1	_exit(127);
147			}
148			if (devchild == -1)
149			goto syserr;
150			close(p1[0]);
151			close(p2[1]);
152			if ((devout = fdopen(p1[1], "w")) == NULL)
153			goto syserr;
154			if ((devin = fdopen(p2[0], "r")) == NULL)
155			goto syserr;
156	greg	2.3	return(final_connect()); /* verify initialization */
157	greg	1.1	syserr:
158	greg	1.7	perror(dname);
159	greg	1.1	return(NULL);
160			}
161
162
163	greg	2.6	static void
164	greg	1.1	comm_close() /* done with driver */
165			{
166			int pid;
167
168	gregl	2.5	erract[COMMAND].pf = NULL; /* reset error vectors */
169			if (erract[WARNING].pf != NULL)
170			erract[WARNING].pf = wputs;
171	greg	1.1	fclose(devout);
172			fclose(devin);
173	greg	2.3	if (devchild < 0)
174			return;
175	greg	1.1	while ((pid = wait(0)) != -1 && pid != devchild)
176			;
177			}
178
179
180	greg	2.6	static void
181	greg	1.1	comm_clear(xres, yres) /* clear screen */
182			int xres, yres;
183			{
184			putc(COM_CLEAR, devout);
185	greg	1.8	putw(xres, devout);
186			putw(yres, devout);
187	greg	1.1	fflush(devout);
188			}
189
190
191	greg	2.6	static void
192	greg	1.1	comm_paintr(col, xmin, ymin, xmax, ymax) /* paint a rectangle */
193			COLOR col;
194			int xmin, ymin, xmax, ymax;
195			{
196			putc(COM_PAINTR, devout);
197	greg	1.10	fwrite((char *)col, sizeof(COLOR), 1, devout);
198	greg	1.8	putw(xmin, devout);
199			putw(ymin, devout);
200			putw(xmax, devout);
201			putw(ymax, devout);
202	greg	1.12	}
203
204
205	greg	2.6	static void
206	greg	1.12	comm_flush() /* flush output to driver */
207			{
208			putc(COM_FLUSH, devout);
209			fflush(devout);
210	greg	1.13	if (getc(devin) != COM_FLUSH)
211			reply_error("flush");
212	greg	1.17	getstate();
213	greg	1.1	}
214
215
216			static int
217			comm_getcur(xp, yp) /* get and return cursor position */
218			int xp, yp;
219			{
220			int c;
221
222			putc(COM_GETCUR, devout);
223			fflush(devout);
224			if (getc(devin) != COM_GETCUR)
225			reply_error("getcur");
226			c = getc(devin);
227	greg	1.8	*xp = getw(devin);
228			*yp = getw(devin);
229	greg	1.1	return(c);
230			}
231
232
233	greg	2.6	static void
234	greg	1.1	comm_comout(str) /* print string to command line */
235			char *str;
236			{
237			putc(COM_COMOUT, devout);
238			myputs(str, devout);
239	greg	1.18	if (str[strlen(str)-1] == '\n')
240			fflush(devout);
241	greg	1.1	}
242
243
244	greg	2.6	static void
245	greg	1.11	comm_comin(buf, prompt) /* read string from command line */
246	greg	1.1	char *buf;
247	greg	1.11	char *prompt;
248	greg	1.1	{
249			putc(COM_COMIN, devout);
250	greg	1.11	if (prompt == NULL)
251			putc(0, devout);
252			else {
253			putc(1, devout);
254			myputs(prompt, devout);
255			}
256	greg	1.1	fflush(devout);
257			if (getc(devin) != COM_COMIN)
258			reply_error("comin");
259			mygets(buf, devin);
260	greg	1.17	getstate();
261	greg	1.1	}
262
263
264	greg	2.6	static void
265	greg	1.1	mygets(s, fp) /* get string from file (with nul) */
266			register char *s;
267			register FILE *fp;
268			{
269			register int c;
270
271			while ((c = getc(fp)) != EOF)
272			if ((*s++ = c) == '\0')
273			return;
274			*s = '\0';
275			}
276
277
278	greg	2.6	static void
279	greg	1.1	myputs(s, fp) /* put string to file (with nul) */
280			register char *s;
281			register FILE *fp;
282			{
283			do
284			putc(*s, fp);
285			while (*s++);
286			}
287
288
289	greg	2.6	static void
290	greg	1.1	reply_error(routine) /* what should we do here? */
291			char *routine;
292			{
293	gregl	2.5	eputs(routine);
294			eputs(": driver reply error\n");
295	greg	1.1	quit(1);
296	greg	1.17	}
297
298
299	greg	2.6	static void
300	greg	1.17	getstate() /* get driver state variables */
301			{
302			fread((char *)&comm_driver.pixaspect,
303			sizeof(comm_driver.pixaspect), 1, devin);
304			comm_driver.xsiz = getw(devin);
305			comm_driver.ysiz = getw(devin);
306			comm_driver.inpready = getw(devin);
307	greg	1.1	}