![[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] / 43BSDTahoe / new / X / Xlib|
Return to XOpenDisplay.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / Xlib |
1.1 root 1: #include <X/mit-copyright.h>
2: /* $Header: XOpenDisplay.c,v 10.12 86/12/24 09:07:53 swick Exp $ */
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[4]; /* 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: strncpy (displaybuf, XDisplayName(display), sizeof(displaybuf));
49: if (*displaybuf == '\0') return (NULL);
50: }
51: else {
52: /* Display is non-NULL, copy it into the display buffer. */
53: strncpy(displaybuf, display, sizeof(displaybuf));
54: }
55: /*
56: * Find the ':' seperator and cut out the hostname and the
57: * display number.
58: * NOTE - if DECnet is to be used, the display name is formated
59: * as "host::number"
60: */
61: if ((displayptr = index(displaybuf,':')) == NULL) return (NULL);
62: #ifdef DNETCONN
63: if (*(displayptr + 1) == ':') {
64: dnet++;
65: *(displayptr++) = '\0';
66: }
67: #endif
68: *(displayptr++) = '\0';
69:
70: /* displaybuf now contains only a null-terminated host name;
71: * displayptr points to the display number */
72:
73: /* If the display number is missing there is an error.
74: * Otherwise, convert string to an integer we can use */
75: if (*displayptr == '\0') return(NULL);
76: dispnum = atoi(displayptr);
77:
78: if (strcmp("unix", displaybuf) == 0) {
79: /* Connect locally using Unix domain. */
80: unaddr.sun_family = AF_UNIX;
81: strcpy(unaddr.sun_path, X_UNIX_PATH);
82: strcat(unaddr.sun_path, displayptr);
83: addr = (struct sockaddr *) &unaddr;
84: addrlen = strlen(unaddr.sun_path) + 2;
85: } else {
86: #ifdef DNETCONN
87: if (!dnet) {
88: #endif
89: /* If the hostname is missing default to the local host. */
90: if (displaybuf[0] == '\0')
91: gethostname (displaybuf, sizeof (displaybuf));
92: /* Get the statistics on the specified host. */
93: if ((inaddr.sin_addr.s_addr = inet_addr(displaybuf)) == -1) {
94: if ((host_ptr = gethostbyname(displaybuf)) == NULL) {
95: /* No such host! */
96: errno = EINVAL;
97: return(NULL);
98: }
99: /* Check the address type for an internet host. */
100: if (host_ptr->h_addrtype != AF_INET) {
101: /* Not an Internet host! */
102: errno = EPROTOTYPE;
103: return(NULL);
104: }
105:
106: /* Set up the socket data. */
107: inaddr.sin_family = host_ptr->h_addrtype;
108: bcopy((char *)host_ptr->h_addr,
109: (char *)&inaddr.sin_addr,
110: sizeof(inaddr.sin_addr));
111: } else {
112: inaddr.sin_family = AF_INET;
113: }
114: addr = (struct sockaddr *) &inaddr;
115: addrlen = sizeof (struct sockaddr_in);
116: inaddr.sin_port = dispnum;
117: indian = 1;
118: if (*(char *) &indian)
119: inaddr.sin_port += X_TCP_LI_PORT;
120: else
121: inaddr.sin_port += X_TCP_BI_PORT;
122: inaddr.sin_port = htons(inaddr.sin_port);
123: #ifdef DNETCONN
124: } else {
125: /* If the nodename is missing default to the local node. */
126: if (displaybuf[0] == '\0')
127: strcpy (displaybuf, "0");
128: /* build the target object name. */
129: sprintf (objname, "X%d", dispnum);
130: }
131: #endif
132: }
133:
134: /* Malloc the new Display. */
135: if ((dpy = (Display *)malloc(sizeof(Display))) == NULL) {
136: /* Malloc call failed! */
137: errno = ENOMEM;
138: return(NULL);
139: }
140:
141: dpy->height = dpy->width = 0;
142: /* If DisplayWidth or DisplayWidth is subsequently called,
143: these will be replaced by "real" values. */
144:
145: /* Open the network socket. */
146: #ifdef DNETCONN
147: if (!dnet) {
148: #endif
149: if ((dpy->fd = socket(addr->sa_family, SOCK_STREAM, 0)) < 0) {
150: /* Socket call failed! */
151: /* errno set by system call. */
152: free ((char *)dpy);
153: return(NULL);
154: }
155:
156: /* Open the connection to the specified X server. */
157: if (connect(dpy->fd, addr, addrlen) == -1) {
158: /* Connection call failed! */
159: /* errno set by system call. */
160: close (dpy->fd);
161: free ((char *)dpy);
162: return(NULL);
163: }
164: #ifdef DNETCONN
165: } else {
166: if ((dpy->fd = dnet_conn(displaybuf, objname, SOCK_STREAM, 0, 0, 0, 0)) < 0) {
167: /* connect failed! */
168: /* errno set by dnet_conn. */
169: free ((char *)dpy);
170: return(NULL);
171: }
172: }
173: #endif
174:
175: /* Salt away the host:display string for later use */
176: buf[0] = ':';
177: #ifdef DNETCONN
178: {
179: int b = 1;
180: if (dnet) buf[b++] = ':';
181: buf[b++] = '0' + dispnum;
182: buf[b] = '\0';
183: }
184: #else DNETCONN
185: buf[2] = '\0';
186: buf[1] = '0' + dispnum;
187: #endif DNETCONN
188: strcat(displaybuf, buf);
189: if ((dpy->displayname = malloc(strlen(displaybuf) + 1)) == NULL) {
190: close (dpy->fd);
191: free ((char *)dpy);
192: errno = ENOMEM;
193: return(NULL);
194: }
195: strcpy (dpy->displayname, displaybuf);
196:
197: /* Set up the output buffers. */
198: if ((dpy->bufptr = dpy->buffer = malloc(BUFSIZE)) == NULL) {
199: /* Malloc call failed! */
200: close (dpy->fd);
201: free ((char *)dpy);
202: errno = ENOMEM;
203: return(NULL);
204: }
205: dpy->bufmax = dpy->buffer + BUFSIZE;
206:
207: /* Set up the input event queue and input event queue parameters. */
208: dpy->head = dpy->tail = NULL;
209: dpy->qlen = 0;
210: /* Initialize MouseMoved event squishing. */
211: dpy->squish = 1;
212:
213: _XlibCurrentDisplay = dpy;
214:
215: /* Send an X_SetUp request to the server. */
216: GetReq(X_SetUp, 0);
217:
218: /* Send X_MakePixmap requests to get black and white
219: * constant tile Pixmaps */
220: GetReq(X_MakePixmap, 0);
221: req->param.l[0] = 0; /* no bitmap */
222: req->paramu2 = BlackPixel;
223: GetReq(X_MakePixmap, 0);
224: req->param.l[0] = 0;
225: req->paramu2 = WhitePixel;
226:
227: /* The following is needed to synchronize properly with errors,
228: * since three requests are outstanding and no replies have
229: * yet been read
230: */
231: dpy->request = 1;
232:
233: /* Get reply to X_SetUp */
234: if (!_XReply(dpy, &rep)) {
235: /* There was an error in retrieving the reply. */
236: close (dpy->fd);
237: free (dpy->buffer);
238: free ((char *)dpy);
239: return(NULL);
240: }
241:
242: /* Set the Display data returned by the X_SetUp call. */
243: dpy->root = rep.param.l[0]; /* Root window id. */
244: dpy->vnumber = rep.params2; /* X protocol version number. */
245: dpy->dtype = rep.params3; /* Server's display type. */
246: dpy->dplanes = rep.params4; /* Number of display bit planes. */
247: dpy->dcells = rep.paramu5; /* Number of display color map cell. */
248:
249: /* Get reply to MakePixmap (black) */
250: dpy->request++;
251: if (!_XReply (dpy, &rep)) {
252: close (dpy->fd);
253: free (dpy->buffer);
254: free ((char *)dpy);
255: return (NULL);
256: }
257: dpy->black = rep.param.l[0];
258:
259: /* Get reply to MakePixmap (white) */
260: dpy->request++;
261: if (!_XReply (dpy, &rep)) {
262: close (dpy->fd);
263: free (dpy->buffer);
264: free ((char *)dpy);
265: return (NULL);
266: }
267: dpy->white = rep.param.l[0];
268:
269: return(dpy);
270: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.