src/ogl/gdio.c

/* Copyright (c) 1997 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 * I/O routines for GL display process.
 */

#include "standard.h"
#include <sys/uio.h>
#include "gldisp.h"
#include "gderrs.h"


gdSendRequest(d, r)     /* send a request across a connection */
GDconnect       *d;
GDrequest       *r;
{
        unsigned char   rbuf[10];
        struct iovec    iov[2];
                                        /* encode header */
        gdPutInt(rbuf, (int4)r->type, 2);
        gdPutInt(rbuf+2, r->id, 4);
        gdPutInt(rbuf+6, r->alen, 4);
        if (r->alen == 0)               /* write header, null body */
                write(d->fdout, rbuf, 10);
        else {                          /* write header and body */
                iov[0].iov_base = (MEM_PTR)rbuf;
                iov[0].iov_len = 10;
                iov[1].iov_base = (MEM_PTR)r->args;
                iov[1].iov_len = r->alen;
                writev(d->fdout, iov, 2);
        }
}


GDrequest *
gdRecvRequest(d)        /* receive a request across a connection */
register GDconnect      *d;
{
        register GDrequest      *r;
        int     type;
        int4    id, alen;
        unsigned char   rbuf[10];
                                        /* read header */
        fread(rbuf, 1, 10, d->fpin);
        if (feof(d->fpin))
                return(NULL);
        type = gdGetInt(rbuf, 2);
        id = gdGetInt(rbuf+2, 4);
        if (type < 0 | type > GD_NREQ) {
                gdSendError(d, GD_E_UNRECOG, id);
                return(NULL);
        }
        alen = gdGetInt(rbuf+6, 4);
        r = (GDrequest *)malloc(sizeof(GDrequest)-GD_ARG0+alen);
        if (r == NULL) {
                gdSendError(d, GD_E_NOMEMOR, id);
                return(NULL);
        }
        r->type = type;
        r->id = id;
        if ((r->alen = alen) > 0) {     /* read arguments */
                fread(r->args, 1, alen, d->fpin);
                if (feof(d->fpin)) {
                        gdSendError(d, GD_E_ARGMISS, id);
                        gdFree(r);
                        return(NULL);
                }
        }
        if (type == GD_R_Error) {       /* our error */
                gdReportError(d, (int)gdGetInt(r->args, 2), id);
                gdFree(r);
                return(NULL);
        }
        return(r);                      /* success! */
}


gdSendError(d, ec, id)  /* send fatal error associated with a request */
GDconnect       *d;
int     ec;
int4    id;
{
        GDrequest       rq;
                                /* build error request */
        rq.type = GD_R_Error;
        rq.id = id;
        gdPutInt(rq.args, (int4)ec, rq.alen=2);
        gdSendRequest(d, &rq);  /* send it */
        gdClose(d);             /* all errors are fatal */
}


gdReportError(d, ec, id)        /* report fatal error to stderr */
GDconnect       *d;
int     ec;
int4    id;
{
        fprintf(stderr, "RequestId %d: %s\nConnection %d closed.\n",
                        id, gdErrMsg[ec], d->cno);
        gdClose(d);             /* all errors are fatal */
}


GDconnect *
gdOpen(inp, outp, x, y) /* establish a client/server connection */
char    *inp, *outp;            /* named pipes, currently */
int     x, y;                   /* (0,0) for client */
{
        static int      nconnections = 0;
        register GDrequest      *rp;
        GDrequest       rq;
        register GDconnect      *dp;

        dp = (GDconnect *)malloc(sizeof(GDconnect));
        if (dp == NULL) {
                gdReportError(dp, GD_E_NOMEMOR, 0);
                return(NULL);
        }
        dp->cno = ++nconnections;
        if (!x)                         /* client opens to write first */
                dp->fdout = open(outp, O_WRONLY);
        dp->fpin = fopen(inp, "r");
        if (dp->fpin == NULL)
                goto connecterr;
        if (x)                          /* server opens to write second */
                dp->fdout = open(outp, O_WRONLY);
        if (dp->fdout < 0)
                goto connecterr;
        if (x) {                        /* server sends resolution */
                dp->xres = x; dp->yres = y;
                rq.type = GD_R_Init;
                rq.id = dp->cno;
                rq.alen = 4;
                gdPutInt(rq.args, (int4)x, 2);
                gdPutInt(rq.args+2, (int4)y, 2);
                gdSendRequest(dp, &rq);
        } else {                        /* client receives resolution */
                rp = gdRecvRequest(dp);
                if (rp == NULL)
                        return(NULL);
                if (rp->type != GD_R_Init)
                        goto connecterr;
                dp->cno = rp->id;
                dp->xres = gdGetInt(rp->args, 2);
                dp->yres = gdGetInt(rp->args+2, 2);
                gdFree(rp);
        }
        return(dp);                     /* success! */
connecterr:
        gdReportError(dp, GD_E_CONNECT, 0);
        return(NULL);
}


gdClose(d)              /* close a display server/client connection */
register GDconnect      *d;
{
        if (d == NULL) return;
        close(d->fdout);
        fclose(d->fpin);
        gdFree(d);              /* free associated memory */
}


int4
gdGetInt(ab, n)         /* get an n-byte integer from buffer ab */
register unsigned char  *ab;
register int    n;                      /* maximum length 4 */
{
        register int4   res;

        res = *ab&0x80 ? -1 : 0;        /* sign extend */
        while (n--)
                res = res<<8 | *ab++;
        return(res);
}


gdPutInt(ab, i, n)      /* put an n-byte integer into buffer ab */
register unsigned char  *ab;
register int4   i;
register int    n;
{
        while (n--)
                *ab++ = i>>(n<<3) & 0xff;
}


double
gdGetReal(ab)           /* get a 5-byte real value from buffer ab */
char    *ab;
{
        register int4   i;
        register double d;

        i = gdGetInt(ab, 4);
        d = (i + (i>0 ? .5 : -.5)) * (1./0x7fffffff);
        return(ldexp(d, (int)gdGetInt(ab+4,1)));
}


gdPutReal(ab, d)        /* put a 5-byte real value to buffer ab */
unsigned char   *ab;
double  d;
{
        int     e;

        gdPutInt(ab, (int4)(frexp(d,&e)*0x7fffffff), 4);
        gdPutInt(ab+4, (int4)e, 1);
}
Revision:	3.3
Committed:	Fri Feb 28 20:25:32 2003 UTC (21 years, 3 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 3.2:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Removed unused ray/src/ogl directory
#	User	Rev	Content
1	greg	3.1	/* Copyright (c) 1997 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8	greg	3.2	* I/O routines for GL display process.
9	greg	3.1	*/
10
11			#include "standard.h"
12	greg	3.2	#include <sys/uio.h>
13	greg	3.1	#include "gldisp.h"
14	greg	3.2	#include "gderrs.h"
15	greg	3.1
16
17	greg	3.2	gdSendRequest(d, r) /* send a request across a connection */
18			GDconnect *d;
19			GDrequest *r;
20			{
21			unsigned char rbuf[10];
22			struct iovec iov[2];
23			/* encode header */
24			gdPutInt(rbuf, (int4)r->type, 2);
25			gdPutInt(rbuf+2, r->id, 4);
26			gdPutInt(rbuf+6, r->alen, 4);
27			if (r->alen == 0) /* write header, null body */
28			write(d->fdout, rbuf, 10);
29			else { /* write header and body */
30			iov[0].iov_base = (MEM_PTR)rbuf;
31			iov[0].iov_len = 10;
32			iov[1].iov_base = (MEM_PTR)r->args;
33			iov[1].iov_len = r->alen;
34			writev(d->fdout, iov, 2);
35			}
36			}
37	greg	3.1
38
39	greg	3.2	GDrequest *
40			gdRecvRequest(d) /* receive a request across a connection */
41			register GDconnect *d;
42			{
43			register GDrequest *r;
44			int type;
45			int4 id, alen;
46			unsigned char rbuf[10];
47			/* read header */
48			fread(rbuf, 1, 10, d->fpin);
49			if (feof(d->fpin))
50			return(NULL);
51			type = gdGetInt(rbuf, 2);
52			id = gdGetInt(rbuf+2, 4);
53			if (type < 0 \| type > GD_NREQ) {
54			gdSendError(d, GD_E_UNRECOG, id);
55			return(NULL);
56			}
57			alen = gdGetInt(rbuf+6, 4);
58			r = (GDrequest *)malloc(sizeof(GDrequest)-GD_ARG0+alen);
59			if (r == NULL) {
60			gdSendError(d, GD_E_NOMEMOR, id);
61			return(NULL);
62			}
63			r->type = type;
64			r->id = id;
65			if ((r->alen = alen) > 0) { /* read arguments */
66			fread(r->args, 1, alen, d->fpin);
67			if (feof(d->fpin)) {
68			gdSendError(d, GD_E_ARGMISS, id);
69			gdFree(r);
70			return(NULL);
71			}
72			}
73			if (type == GD_R_Error) { /* our error */
74			gdReportError(d, (int)gdGetInt(r->args, 2), id);
75			gdFree(r);
76			return(NULL);
77			}
78			return(r); /* success! */
79			}
80	greg	3.1
81
82	greg	3.2	gdSendError(d, ec, id) /* send fatal error associated with a request */
83			GDconnect *d;
84			int ec;
85			int4 id;
86			{
87			GDrequest rq;
88			/* build error request */
89			rq.type = GD_R_Error;
90			rq.id = id;
91			gdPutInt(rq.args, (int4)ec, rq.alen=2);
92			gdSendRequest(d, &rq); /* send it */
93			gdClose(d); /* all errors are fatal */
94			}
95	greg	3.1
96
97	greg	3.2	gdReportError(d, ec, id) /* report fatal error to stderr */
98			GDconnect *d;
99			int ec;
100			int4 id;
101			{
102			fprintf(stderr, "RequestId %d: %s\nConnection %d closed.\n",
103			id, gdErrMsg[ec], d->cno);
104			gdClose(d); /* all errors are fatal */
105			}
106	greg	3.1
107
108	greg	3.2	GDconnect *
109			gdOpen(inp, outp, x, y) /* establish a client/server connection */
110			char inp, outp; /* named pipes, currently */
111			int x, y; /* (0,0) for client */
112			{
113			static int nconnections = 0;
114			register GDrequest *rp;
115			GDrequest rq;
116			register GDconnect *dp;
117	greg	3.1
118	greg	3.2	dp = (GDconnect *)malloc(sizeof(GDconnect));
119			if (dp == NULL) {
120			gdReportError(dp, GD_E_NOMEMOR, 0);
121			return(NULL);
122			}
123			dp->cno = ++nconnections;
124			if (!x) /* client opens to write first */
125			dp->fdout = open(outp, O_WRONLY);
126			dp->fpin = fopen(inp, "r");
127			if (dp->fpin == NULL)
128			goto connecterr;
129			if (x) /* server opens to write second */
130			dp->fdout = open(outp, O_WRONLY);
131			if (dp->fdout < 0)
132			goto connecterr;
133			if (x) { /* server sends resolution */
134			dp->xres = x; dp->yres = y;
135			rq.type = GD_R_Init;
136			rq.id = dp->cno;
137			rq.alen = 4;
138			gdPutInt(rq.args, (int4)x, 2);
139			gdPutInt(rq.args+2, (int4)y, 2);
140			gdSendRequest(dp, &rq);
141			} else { /* client receives resolution */
142			rp = gdRecvRequest(dp);
143			if (rp == NULL)
144			return(NULL);
145			if (rp->type != GD_R_Init)
146			goto connecterr;
147			dp->cno = rp->id;
148			dp->xres = gdGetInt(rp->args, 2);
149			dp->yres = gdGetInt(rp->args+2, 2);
150			gdFree(rp);
151			}
152			return(dp); /* success! */
153			connecterr:
154			gdReportError(dp, GD_E_CONNECT, 0);
155			return(NULL);
156			}
157	greg	3.1
158
159	greg	3.2	gdClose(d) /* close a display server/client connection */
160			register GDconnect *d;
161	greg	3.1	{
162	greg	3.2	if (d == NULL) return;
163			close(d->fdout);
164			fclose(d->fpin);
165			gdFree(d); /* free associated memory */
166	greg	3.1	}
167
168
169	greg	3.2	int4
170			gdGetInt(ab, n) /* get an n-byte integer from buffer ab */
171			register unsigned char *ab;
172			register int n; /* maximum length 4 */
173	greg	3.1	{
174	greg	3.2	register int4 res;
175	greg	3.1
176	greg	3.2	res = ab&0x80 ? -1 : 0; / sign extend */
177			while (n--)
178			res = res<<8 \| *ab++;
179			return(res);
180	greg	3.1	}
181
182
183	greg	3.2	gdPutInt(ab, i, n) /* put an n-byte integer into buffer ab */
184			register unsigned char *ab;
185			register int4 i;
186			register int n;
187	greg	3.1	{
188	greg	3.2	while (n--)
189			*ab++ = i>>(n<<3) & 0xff;
190	greg	3.1	}
191
192
193	greg	3.2	double
194			gdGetReal(ab) /* get a 5-byte real value from buffer ab */
195			char *ab;
196	greg	3.1	{
197	greg	3.2	register int4 i;
198			register double d;
199	greg	3.1
200	greg	3.2	i = gdGetInt(ab, 4);
201			d = (i + (i>0 ? .5 : -.5)) * (1./0x7fffffff);
202			return(ldexp(d, (int)gdGetInt(ab+4,1)));
203	greg	3.1	}
204
205
206	greg	3.2	gdPutReal(ab, d) /* put a 5-byte real value to buffer ab */
207			unsigned char *ab;
208			double d;
209	greg	3.1	{
210	greg	3.2	int e;
211	greg	3.1
212	greg	3.2	gdPutInt(ab, (int4)(frexp(d,&e)*0x7fffffff), 4);
213			gdPutInt(ab+4, (int4)e, 1);
214	greg	3.1	}