![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XOpenDis.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X|
Return to XOpenDis.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X |
1.1 root 1: #include "copyright.h"
2: #ifndef lint
3: static char *rcsid_xopendisplay_c = "$Header: XOpenDis.c,v 11.50 87/09/01 15:00:36 toddb Exp $";
4: #endif
5: /* Copyright Massachusetts Institute of Technology 1985, 1986 */
6:
7: /* Converted to V11 by jg */
8:
9: #include <stdio.h>
10: #include "Xlibint.h"
11: #include <strings.h>
12: #include "Xatom.h"
13:
14: #ifndef lint
15: static int lock; /* get rid of ifdefs when locking implemented */
16: #endif
17:
18: int _Xdebug = 0;
19: static xReq _dummy_request = {
20: 0, 0, 0
21: };
22:
23: /* head of the linked list of open displays */
24: Display *_XHeadOfDisplayList = NULL;
25:
26: extern _XWireToEvent();
27: extern _XUnknownNativeEvent();
28: extern _XUnknownWireEvent();
29: /*
30: * Connects to a server, creates a Display object and returns a pointer to
31: * the newly created Display back to the caller.
32: */
33: Display *XOpenDisplay (display)
34: register char *display;
35: {
36: register Display *dpy; /* New Display object being created. */
37: register int i;
38: int j, k; /* random iterator indexes */
39: char *display_name; /* pointer to display name */
40: int indian; /* to determine which indian. */
41: xConnClientPrefix client; /* client information */
42: xConnSetupPrefix prefix; /* prefix information */
43: int vendorlen; /* length of vendor string */
44: char *setup; /* memory allocated at startup */
45: char displaybuf[256]; /* buffer to receive expanded name */
46: int screen_num; /* screen number */
47: union {
48: xConnSetup *setup;
49: char *failure;
50: char *vendor;
51: xPixmapFormat *sf;
52: xWindowRoot *rp;
53: xDepth *dp;
54: xVisualType *vp;
55: } u;
56: long setuplength; /* number of bytes in setup message */
57:
58: extern int _XSendClientPrefix();
59: extern int _XConnectDisplay();
60: extern char *getenv();
61: extern XID _XAllocID();
62:
63: /*
64: * If the display specifier string supplied as an argument to this
65: * routine is NULL or a pointer to NULL, read the DISPLAY variable.
66: */
67: if (display == NULL || *display == '\0') {
68: if ((display_name = getenv("DISPLAY")) == NULL) {
69: /* Oops! No DISPLAY environment variable - error. */
70: return(NULL);
71: }
72: }
73: else {
74: /* Display is non-NULL, copy the pointer */
75: display_name = display;
76: }
77:
78: /*
79: * Attempt to allocate a display structure. Return NULL if allocation fails.
80: */
81: LockMutex(&lock);
82: if ((dpy = (Display *)Xcalloc(1, sizeof(Display))) == NULL) {
83: errno = ENOMEM;
84: UnlockMutex(&lock);
85: return(NULL);
86: }
87:
88: /*
89: * Call the Connect routine to get the network socket. If 0 is returned, the
90: * connection failed. The connect routine will return the expanded display
91: * name in displaybuf.
92: */
93:
94: if ((dpy->fd = _XConnectDisplay(display_name, displaybuf, &screen_num))
95: < 0) {
96: Xfree ((char *) dpy);
97: UnlockMutex(&lock);
98: return(NULL); /* errno set by XConnectDisplay */
99: }
100:
101: /*
102: * First byte is the byte order byte.
103: * Authentication key is normally sent right after the connection.
104: * This (in MIT's case) will be kerberos.
105: */
106: indian = 1;
107: if (*(char *) &indian)
108: client.byteOrder = 'l';
109: else
110: client.byteOrder = 'B';
111: client.majorVersion = X_PROTOCOL;
112: client.minorVersion = X_PROTOCOL_REVISION;
113: _XSendClientPrefix (dpy, &client);
114: /*
115: * Now see if connection was accepted...
116: */
117: _XRead (dpy, (char *)&prefix,(long)sizeof(xConnSetupPrefix));
118:
119: if (prefix.majorVersion < X_PROTOCOL) {
120: (void) fputs ("Warning: Client built for newer server!\n", stderr);
121: }
122: if (prefix.minorVersion != X_PROTOCOL_REVISION) {
123: (void) fputs (
124: "Warning: Protocol rev. of client does not match server!\n",
125: stderr);
126: }
127:
128: setuplength = prefix.length << 2;
129: if ( (u.setup = (xConnSetup *)(setup = Xmalloc ((unsigned)setuplength)))
130: == NULL) {
131: errno = ENOMEM;
132: Xfree ((char *)dpy);
133: UnlockMutex(&lock);
134: return(NULL);
135: }
136: _XRead (dpy, (char *)u.setup, setuplength);
137: /*
138: * If the connection was not accepted by the server due to problems,
139: * give error message to the user....
140: */
141: if (prefix.success != xTrue) {
142: /*
143: (void) fwrite (u.failure, (int)*u.failure, sizeof(char), stderr);
144: */
145: (void) fwrite (u.failure, sizeof(char),
146: (int)prefix.lengthReason, stderr);
147: (void) fwrite ("\n", sizeof(char), 1, stderr);
148: Xfree ((char *)dpy);
149: Xfree (setup);
150: UnlockMutex(&lock);
151: return (NULL);
152: }
153:
154: /*
155: * We succeeded at authorization, so let us move the data into
156: * the display structure.
157: */
158: dpy->next = (Display *) NULL;
159: dpy->proto_major_version= prefix.majorVersion;
160: dpy->proto_minor_version= prefix.minorVersion;
161: dpy->release = u.setup->release;
162: dpy->resource_base = u.setup->ridBase;
163: dpy->resource_mask = u.setup->ridMask;
164: dpy->min_keycode = u.setup->minKeyCode;
165: dpy->max_keycode = u.setup->maxKeyCode;
166: dpy->keysyms = (KeySym *) NULL;
167: dpy->modifiermap = XNewModifiermap(0);
168: dpy->keysyms_per_keycode = 0;
169: dpy->current = None;
170: dpy->xdefaults = (char *)NULL;
171: dpy->scratch_length = 0L;
172: dpy->scratch_buffer = NULL;
173: dpy->motion_buffer = u.setup->motionBufferSize;
174: dpy->nformats = u.setup->numFormats;
175: dpy->nscreens = u.setup->numRoots;
176: dpy->byte_order = u.setup->imageByteOrder;
177: dpy->bitmap_unit = u.setup->bitmapScanlineUnit;
178: dpy->bitmap_pad = u.setup->bitmapScanlinePad;
179: dpy->bitmap_bit_order = u.setup->bitmapBitOrder;
180: dpy->max_request_size = u.setup->maxRequestSize;
181: dpy->ext_procs = (_XExtension *)NULL;
182: dpy->ext_data = (XExtData *)NULL;
183: dpy->ext_number = 0;
184: dpy->event_vec[X_Error] = _XUnknownWireEvent;
185: dpy->event_vec[X_Reply] = _XUnknownWireEvent;
186: dpy->wire_vec[X_Error] = _XUnknownNativeEvent;
187: dpy->wire_vec[X_Reply] = _XUnknownNativeEvent;
188: for (i = KeyPress; i < LASTEvent; i++) {
189: dpy->event_vec[i] = _XWireToEvent;
190: dpy->wire_vec[i] = NULL;
191: }
192: for (i = LASTEvent; i < 128; i++) {
193: dpy->event_vec[i] = _XUnknownWireEvent;
194: dpy->wire_vec[i] = _XUnknownNativeEvent;
195: }
196: dpy->resource_id = 0;
197: dpy->resource_shift = ffs(dpy->resource_mask) - 1;
198: dpy->db = (struct _XrmResourceDataBase *)NULL;
199: /*
200: * Initialize pointers to NULL so that XFreeDisplayStructure will
201: * work if we run out of memory
202: */
203:
204: dpy->screens = NULL;
205: dpy->display_name = NULL;
206: dpy->buffer = NULL;
207:
208: /*
209: * now extract the vendor string... String must be null terminated,
210: * padded to multiple of 4 bytes.
211: */
212: dpy->vendor = (char *) Xmalloc (u.setup->nbytesVendor + 1);
213: vendorlen = u.setup->nbytesVendor;
214: u.setup += 1; /* can't touch information in XConnSetup anymore..*/
215: (void) strncpy(dpy->vendor, u.vendor, vendorlen);
216: u.vendor += (vendorlen + 3) & ~3;
217: /*
218: * Now iterate down setup information.....
219: */
220: dpy->pixmap_format =
221: (ScreenFormat *)Xmalloc(
222: (unsigned) (dpy->nformats *sizeof(ScreenFormat)));
223: if (dpy->pixmap_format == NULL) {
224: OutOfMemory (dpy, setup);
225: UnlockMutex(&lock);
226: return(NULL);
227: }
228: /*
229: * First decode the Z axis Screen format information.
230: */
231: for (i = 0; i < dpy->nformats; i++) {
232: register ScreenFormat *fmt = &dpy->pixmap_format[i];
233: fmt->depth = u.sf->depth;
234: fmt->bits_per_pixel = u.sf->bitsPerPixel;
235: fmt->scanline_pad = u.sf->scanLinePad;
236: fmt->ext_data = NULL;
237: u.sf += 1;
238: }
239:
240: /*
241: * next the Screen structures.
242: */
243: dpy->screens =
244: (Screen *)Xmalloc((unsigned) dpy->nscreens*sizeof(Screen));
245: if (dpy->screens == NULL) {
246: OutOfMemory (dpy, setup);
247: UnlockMutex(&lock);
248: return(NULL);
249: }
250: /*
251: * Now go deal with each screen structure.
252: */
253: for (i = 0; i < dpy->nscreens; i++) {
254: register Screen *sp = &dpy->screens[i];
255: VisualID root_visualID = u.rp->rootVisualID;
256: sp->display = dpy;
257: sp->root = u.rp->windowId;
258: sp->cmap = u.rp->defaultColormap;
259: sp->white_pixel = u.rp->whitePixel;
260: sp->black_pixel = u.rp->blackPixel;
261: sp->root_input_mask = u.rp->currentInputMask;
262: sp->width = u.rp->pixWidth;
263: sp->height = u.rp->pixHeight;
264: sp->mwidth = u.rp->mmWidth;
265: sp->mheight = u.rp->mmHeight;
266: sp->min_maps = u.rp->minInstalledMaps;
267: sp->max_maps = u.rp->maxInstalledMaps;
268: sp->root_visual = NULL; /* filled in later, when we alloc Visuals */
269: sp->backing_store= u.rp->backingStore;
270: sp->save_unders = u.rp->saveUnders;
271: sp->root_depth = u.rp->rootDepth;
272: sp->ndepths = u.rp->nDepths;
273: sp->ext_data = NULL;
274: u.rp += 1;
275: /*
276: * lets set up the depth structures.
277: */
278: sp->depths = (Depth *)Xmalloc(
279: (unsigned)sp->ndepths*sizeof(Depth));
280: if (sp->depths == NULL) {
281: OutOfMemory (dpy, setup);
282: UnlockMutex(&lock);
283: return(NULL);
284: }
285: /*
286: * for all depths on this screen.
287: */
288: for (j = 0; j < sp->ndepths; j++) {
289: Depth *dp = &sp->depths[j];
290: dp->depth = u.dp->depth;
291: dp->nvisuals = u.dp->nVisuals;
292: u.dp += 1;
293: dp->visuals =
294: (Visual *)Xmalloc((unsigned)dp->nvisuals*sizeof(Visual));
295: if (dp->visuals == NULL) {
296: OutOfMemory (dpy, setup);
297: UnlockMutex(&lock);
298: return(NULL);
299: }
300: for (k = 0; k < dp->nvisuals; k++) {
301: register Visual *vp = &dp->visuals[k];
302: if ((vp->visualid = u.vp->visualID) == root_visualID)
303: sp->root_visual = vp;
304: vp->class = u.vp->class;
305: vp->bits_per_rgb= u.vp->bitsPerRGB;
306: vp->map_entries = u.vp->colormapEntries;
307: vp->red_mask = u.vp->redMask;
308: vp->green_mask = u.vp->greenMask;
309: vp->blue_mask = u.vp->blueMask;
310: vp->ext_data = NULL;
311: u.vp += 1;
312: }
313: }
314: }
315:
316:
317: /*
318: * Setup other information in this display structure.
319: */
320: dpy->vnumber = X_PROTOCOL;
321: dpy->resource_alloc = _XAllocID;
322: dpy->synchandler = NULL;
323: dpy->request = 0;
324: dpy->last_request_read = 0;
325: dpy->default_screen = screen_num; /* Value returned by ConnectDisplay */
326: dpy->last_req = (char *)&_dummy_request;
327:
328: /* Salt away the host:display string for later use */
329: if ((dpy->display_name = Xmalloc(
330: (unsigned) (strlen(displaybuf) + 1))) == NULL) {
331: OutOfMemory (dpy, setup);
332: UnlockMutex(&lock);
333: return(NULL);
334: }
335: (void) strcpy (dpy->display_name, displaybuf);
336:
337: /* Set up the output buffers. */
338: if ((dpy->bufptr = dpy->buffer = Xmalloc(BUFSIZE)) == NULL) {
339: OutOfMemory (dpy, setup);
340: UnlockMutex(&lock);
341: return(NULL);
342: }
343: dpy->bufmax = dpy->buffer + BUFSIZE;
344:
345: /* Set up the input event queue and input event queue parameters. */
346: dpy->head = dpy->tail = NULL;
347: dpy->qlen = 0;
348:
349: /*
350: * Now start talking to the server to setup all other information...
351: */
352:
353: Xfree (setup); /* all finished with setup information */
354: /*
355: * Set up other stuff clients are always going to use.
356: */
357: for (i = 0; i < dpy->nscreens; i++) {
358: register Screen *sp = &dpy->screens[i];
359: XGCValues values;
360: values.foreground = sp->white_pixel;
361: values.background = sp->black_pixel;
362: sp->default_gc = XCreateGC (dpy, sp->root,
363: GCForeground|GCBackground, &values);
364: }
365: /*
366: * call into synchronization routine so that all programs can be
367: * forced synchronize
368: */
369: (void) XSynchronize(dpy, _Xdebug);
370: /*
371: * chain this stucture onto global list.
372: */
373: dpy->next = _XHeadOfDisplayList;
374: _XHeadOfDisplayList = dpy;
375: UnlockDisplay(dpy);
376: UnlockMutex(&lock);
377: /*
378: * get the resource manager database off the root window.
379: */
380: {
381: Atom actual_type;
382: int actual_format;
383: unsigned long nitems;
384: long leftover;
385: if (XGetWindowProperty(dpy, RootWindow(dpy, 0),
386: XA_RESOURCE_MANAGER, 0L, 100000000L, False, XA_STRING,
387: &actual_type, &actual_format, &nitems, &leftover,
388: &dpy->xdefaults) != Success) {
389: dpy->xdefaults = (char *) NULL;
390: }
391: else {
392: if ( (actual_type != XA_STRING) || (actual_format != 8) ) {
393: if (dpy->xdefaults != NULL) Xfree ( dpy->xdefaults );
394: }
395: }
396: }
397: return(dpy);
398: }
399:
400:
401: /* OutOfMemory is called if malloc fails. XOpenDisplay returns NULL
402: after this returns. */
403:
404: static OutOfMemory (dpy, setup)
405: Display *dpy;
406: char *setup;
407: {
408: _XDisconnectDisplay (dpy->fd);
409: _XFreeDisplayStructure (dpy);
410: Xfree (setup);
411: errno = ENOMEM;
412: }
413:
414:
415: /* XFreeDisplayStructure frees all the storage associated with a
416: * Display. It is used by XOpenDisplay if it runs out of memory,
417: * and also by XCloseDisplay. It needs to check whether all pointers
418: * are non-NULL before dereferencing them, since it may be called
419: * by XOpenDisplay before the Display structure is fully formed.
420: * XOpenDisplay must be sure to initialize all the pointers to NULL
421: * before the first possible call on this.
422: */
423:
424: _XFreeDisplayStructure(dpy)
425: register Display *dpy;
426: {
427: if (dpy->screens) {
428: register int i;
429:
430: for (i = 0; i < dpy->nscreens; i++) {
431: Screen *sp = &dpy->screens[i];
432:
433: if (sp->depths) {
434: register int j;
435:
436: for (j = 0; j < sp->ndepths; j++) {
437: Depth *dp = &sp->depths[j];
438:
439: if (dp->visuals) {
440: register int k;
441:
442: for (k = 0; k < dp->nvisuals; k++)
443: _XFreeExtData (dp->visuals[k].ext_data);
444: Xfree ((char *) dp->visuals);
445: }
446: }
447:
448: Xfree ((char *) sp->depths);
449: }
450:
451: _XFreeExtData (sp->ext_data);
452: }
453:
454: Xfree ((char *)dpy->screens);
455: }
456:
457: if (dpy->pixmap_format) {
458: register int i;
459:
460: for (i = 0; i < dpy->nformats; i++)
461: _XFreeExtData (dpy->pixmap_format[i].ext_data);
462: Xfree ((char *)dpy->pixmap_format);
463: }
464:
465: if (dpy->display_name)
466: Xfree (dpy->display_name);
467:
468: if (dpy->buffer)
469: Xfree (dpy->buffer);
470: if (dpy->keysyms)
471: Xfree ((char *) dpy->keysyms);
472: if (dpy->xdefaults)
473: Xfree (dpy->xdefaults);
474:
475: _XFreeExtData (dpy->ext_data);
476:
477: Xfree ((char *)dpy);
478: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.