![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XOpenDisplay.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / Xlib|
Return to XOpenDisplay.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / Xlib |
1.1 root 1: #include <X/mit-copyright.h>
2: /* $Header: XOpenDisplay.c,v 10.8 86/02/01 15:37:30 tony Rel $ */
3: /* Copyright Massachusetts Institute of Technology 1985 */
4:
5: #include "XlibInternal.h"
6: #include <sys/socket.h>
7: #include <strings.h>
8: #include <sys/un.h>
9:
10: /*
11: * Connects to a server, creates a Display object and returns a pointer to
12: * the newly created Display back to the caller.
13: */
14: Display *XOpenDisplay (display)
15: register char *display;
16: {
17: register Display *dpy; /* New Display object being created. */
18: char displaybuf[256]; /* Display string buffer. */
19: register char *displayptr; /* Display string buffer pointer. */
20: char buf[3]; /* place to form display string */
21: struct sockaddr_in inaddr; /* INET socket address. */
22: struct sockaddr_un unaddr; /* UNIX socket address. */
23: struct sockaddr *addr; /* address to connect to */
24: int addrlen; /* length of address */
25: int dispnum; /* display number. */
26: int indian; /* to determine which indian. */
27: struct hostent *host_ptr;
28: #ifdef DNETCONN
29: char objname[20]; /* Object name buffer */
30: int dnet = 0; /* flag to indicate DECnet connect */
31: #endif
32:
33: register XReq *req; /* XReq request packet pointer. */
34: XRep rep; /* XRep reply packet. */
35:
36: /* External declarations. */
37: extern char *getenv();
38: extern char *malloc();
39: extern struct hostent *gethostbyname();
40:
41: /*
42: * Extract the host name and display number from the display
43: * specifier string. The display specifier string is supplied
44: * as an argument to this routine. If it is NULL or a pointer
45: * to NULL
46: */
47: if (display == NULL || *display == '\0') {
48: char *disp;
49: /* No display given check the DISPLAY environment variable. */
50: if ((disp = getenv("DISPLAY")) == NULL) {
51: /* Oops! No DISPLAY environment variable - error. */
52: return(NULL);
53: }
54: strncpy(displaybuf, disp, sizeof(displaybuf));
55: }
56: else {
57: /* Display is non-NULL, copy it into the display buffer. */
58: strncpy(displaybuf, display, sizeof(displaybuf));
59: }
60: /*
61: * Find the ':' seperator and cut out the hostname and the
62: * display number.
63: * NOTE - if DECnet is to be used, the display name is formated
64: * as "host::number"
65: */
66: if ((displayptr = index(displaybuf,':')) == NULL) return (NULL);
67: #ifdef DNETCONN
68: if (*(displayptr + 1) == ':') {
69: dnet++;
70: *(displayptr++) = '\0';
71: }
72: #endif
73: *(displayptr++) = '\0';
74:
75: /* displaybuf now contains only a null-terminated host name;
76: * displayptr points to the display number */
77:
78: /* If the display number is missing there is an error.
79: * Otherwise, convert string to an integer we can use */
80: if (*displayptr == '\0') return(NULL);
81: dispnum = atoi(displayptr);
82:
83: if (strcmp("unix", displaybuf) == 0) {
84: /* Connect locally using Unix domain. */
85: unaddr.sun_family = AF_UNIX;
86: strcpy(unaddr.sun_path, X_UNIX_PATH);
87: strcat(unaddr.sun_path, displayptr);
88: addr = (struct sockaddr *) &unaddr;
89: addrlen = strlen(unaddr.sun_path) + 2;
90: } else {
91: #ifdef DNETCONN
92: if (!dnet) {
93: #endif
94: /* If the hostname is missing default to the local host. */
95: if (displaybuf[0] == '\0')
96: gethostname (displaybuf, sizeof (displaybuf));
97: /* Get the statistics on the specified host. */
98: if ((host_ptr = gethostbyname(displaybuf)) == NULL) {
99: /* No such host! */
100: errno = EINVAL;
101: return(NULL);
102: }
103: /* Check the address type to see if it is an internet host. */
104: if (host_ptr->h_addrtype != AF_INET) {
105: /* Not an Internet host! */
106: errno = EPROTOTYPE;
107: return(NULL);
108: }
109:
110: /* Set up the socket data. */
111: inaddr.sin_family = AF_INET;
112: inaddr.sin_port = dispnum;
113: indian = 1;
114: if (*(char *) &indian)
115: inaddr.sin_port += X_TCP_LI_PORT;
116: else
117: inaddr.sin_port += X_TCP_BI_PORT;
118: inaddr.sin_port = htons(inaddr.sin_port);
119: bcopy((char *)host_ptr->h_addr, &inaddr.sin_addr, sizeof(inaddr.sin_addr));
120: addr = (struct sockaddr *) &inaddr;
121: addrlen = sizeof (struct sockaddr_in);
122: #ifdef DNETCONN
123: } else {
124: /* If the nodename is missing default to the local node. */
125: if (displaybuf[0] == '\0')
126: strcpy (displaybuf, "0");
127: /* build the target object name. */
128: sprintf (objname, "X%d", dispnum);
129: }
130: #endif
131: }
132:
133: /* Malloc the new Display. */
134: if ((dpy = (Display *)malloc(sizeof(Display))) == NULL) {
135: /* Malloc call failed! */
136: errno = ENOMEM;
137: return(NULL);
138: }
139:
140: dpy->height = dpy->width = 0;
141: /* If DisplayWidth or DisplayWidth is subsequently called,
142: these will be replaced by "real" values. */
143:
144: /* Open the network socket. */
145: #ifdef DNETCONN
146: if (!dnet) {
147: #endif
148: if ((dpy->fd = socket(addr->sa_family, SOCK_STREAM, 0)) < 0) {
149: /* Socket call failed! */
150: /* errno set by system call. */
151: free (dpy);
152: return(NULL);
153: }
154:
155: /* Open the connection to the specified X server. */
156: if (connect(dpy->fd, addr, addrlen) == -1) {
157: /* Connection call failed! */
158: /* errno set by system call. */
159: close (dpy->fd);
160: free (dpy);
161: return(NULL);
162: }
163: #ifdef DNETCONN
164: } else {
165: if ((dpy->fd = dnet_conn(displaybuf, objname, SOCK_STREAM, 0, 0, 0, 0)) < 0) {
166: /* connect failed! */
167: /* errno set by dnet_conn. */
168: free (dpy);
169: return(NULL);
170: }
171: }
172: #endif
173:
174: /* Salt away the host:display string for later use */
175: buf[0] = ':';
176: buf[2] = '\0';
177: buf[1] = '0' + dispnum;
178: strcat(displaybuf, buf);
179: if ((dpy->displayname = malloc(strlen(displaybuf) + 1)) == NULL) {
180: close (dpy->fd);
181: free (dpy);
182: errno = ENOMEM;
183: return(NULL);
184: }
185: strcpy (dpy->displayname, displaybuf);
186:
187: /* Set up the output buffers. */
188: if ((dpy->bufptr = dpy->buffer = malloc(BUFSIZE)) == NULL) {
189: /* Malloc call failed! */
190: close (dpy->fd);
191: free (dpy);
192: errno = ENOMEM;
193: return(NULL);
194: }
195: dpy->bufmax = dpy->buffer + BUFSIZE;
196:
197: /* Set up the input event queue and input event queue parameters. */
198: dpy->head = dpy->tail = NULL;
199: dpy->qlen = 0;
200: /* Initialize MouseMoved event squishing. */
201: dpy->squish = 1;
202:
203: _XlibCurrentDisplay = dpy;
204:
205: /* Send an X_SetUp request to the server. */
206: GetReq(X_SetUp, 0);
207:
208: /* Send X_MakePixmap requests to get black and white
209: * constant tile Pixmaps */
210: GetReq(X_MakePixmap, 0);
211: req->param.l[0] = 0; /* no bitmap */
212: req->param.u[2] = BlackPixel;
213: GetReq(X_MakePixmap, 0);
214: req->param.l[0] = 0;
215: req->param.u[2] = WhitePixel;
216:
217: /* The following is needed to synchronize properly with errors,
218: * since three requests are outstanding and no replies have
219: * yet been read
220: */
221: dpy->request = 1;
222:
223: /* Get reply to X_SetUp */
224: if (!_XReply(dpy, &rep)) {
225: /* There was an error in retrieving the reply. */
226: close (dpy->fd);
227: free (dpy->buffer);
228: free (dpy);
229: return(NULL);
230: }
231:
232: /* Set the Display data returned by the X_SetUp call. */
233: dpy->root = rep.param.l[0]; /* Root window id. */
234: dpy->vnumber = rep.param.s[2]; /* X protocol version number. */
235: dpy->dtype = rep.param.s[3]; /* Server's display type. */
236: dpy->dplanes = rep.param.s[4]; /* Number of display bit planes. */
237: dpy->dcells = rep.param.u[5]; /* Number of display color map cell. */
238:
239: /* Get reply to MakePixmap (black) */
240: dpy->request++;
241: if (!_XReply (dpy, &rep)) {
242: close (dpy->fd);
243: free (dpy->buffer);
244: free (dpy);
245: return (NULL);
246: }
247: dpy->black = rep.param.l[0];
248:
249: /* Get reply to MakePixmap (white) */
250: dpy->request++;
251: if (!_XReply (dpy, &rep)) {
252: close (dpy->fd);
253: free (dpy->buffer);
254: free (dpy);
255: return (NULL);
256: }
257: dpy->white = rep.param.l[0];
258:
259: return(dpy);
260: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.