/* * $XConsortium: XOpenDis.c,v 11.69 88/09/30 14:03:15 jim Exp $ */ /* * $Header: /cec/src/nestor/servers/R3/shXlib/XOpenDis.c,v 1.2 90/07/26 * 08:31:44 altenhof Exp $ */ #include "copyright.h" /* Copyright Massachusetts Institute of Technology 1985, 1986 */ /* Converted to V11 by jg */ /* Extended to allow multiplexing by ma */ #include #define NEED_EVENTS /* -- XmuXlibint.h refers to event structures * -- */ #include "Xlibint.h" /* -- additional includes -- */ #include "XmuXlibint.h" #include "resources.h" #include #include #ifndef lint static int lock; /* get rid of ifdefs when locking implemented */ #endif static int first_call = xTrue; static OutOfMemory (); /* to avoid gcc flag -traditional */ int _Xdebug = 0; static xReq _dummy_request = { 0, 0, 0 }; /* head of the linked list of open displays */ Display *_XHeadOfDisplayList = NULL; extern Bool _XWireToEvent (); extern Status _XUnknownNativeEvent (); extern Bool _XUnknownWireEvent (); /* * Connects to a server, creates a Display object and returns a pointer to * the newly created Display back to the caller. */ Display * XOpenDisplay (display) register char *display; { register Display *dpy; /* New Display object being created. */ register int i; int j, k; /* random iterator indexes */ char *display_name; /* pointer to display name */ int indian; /* to determine which indian. */ xConnClientPrefix client; /* client information */ xConnSetupPrefix prefix; /* prefix information */ int vendorlen; /* length of vendor string */ char *setup; /* memory allocated at startup */ char displaybuf[256]; /* buffer to receive expanded name */ char prop_name[256]; /* buffer to receive property name */ int screen_num; /* screen number */ union { xConnSetup *setup; char *failure; char *vendor; xPixmapFormat *sf; xWindowRoot *rp; xDepth *dp; xVisualType *vp; } u; long setuplength; /* number of bytes in setup message */ extern int _XSendClientPrefix (); extern int _XConnectDisplay (); extern char *getenv (); extern XID _XAllocID (); /* * -- Call XmuX initialisation routine on first call */ if (first_call) XmuXInitialize (); /* * If the display specifier string supplied as an argument to this routine * is NULL or a pointer to NULL, read the DISPLAY variable. */ if (display == NULL || *display == '\0') { if ((display_name = getenv ("DISPLAY")) == NULL) { /* Oops! No DISPLAY environment variable - error. */ return (NULL); } } else { /* Display is non-NULL, copy the pointer */ display_name = display; } /* * Attempt to allocate a display structure. Return NULL if allocation * fails. */ LockMutex (&lock); if ((dpy = (Display *) Xcalloc (1, sizeof (Display))) == NULL) { errno = ENOMEM; UnlockMutex (&lock); return (NULL); } /* * Call the Connect routine to get the network socket. If 0 is returned, * the connection failed. The connect routine will return the expanded * display name in displaybuf. */ displaybuf[0] = prop_name[0] = '\0'; if ((dpy->fd = _XConnectDisplay (display_name, displaybuf, prop_name, &screen_num)) < 0) { Xfree ((char *) dpy); UnlockMutex (&lock); return (NULL); /* errno set by XConnectDisplay */ } /* * -- Create default entry in Connection translation table -- On success , * return xTrue , otherwise xFalse -- XXX values will be overwritten for * multiplex connections outside of this */ if (!CreateDefaultEntry (dpy)) { /* -- we've failed -- */ _XDisconnectDisplay (dpy->fd); _XFreeDisplayStructure (dpy); errno = ENOMEM; return (NULL); } /* * First byte is the byte order byte. Authentication key is normally sent * right after the connection. This (in MIT's case) will be kerberos. */ indian = 1; if (*(char *) &indian) client.byteOrder = 'l'; else client.byteOrder = 'B'; client.majorVersion = X_PROTOCOL; client.minorVersion = X_PROTOCOL_REVISION; _XSendClientPrefix (dpy, &client); /* * Now see if connection was accepted... */ _XRead (dpy, (char *) &prefix, (long) SIZEOF (xConnSetupPrefix)); if (prefix.majorVersion < X_PROTOCOL) { (void) fputs ("Warning: Client built for newer server!\n", stderr); } if (prefix.minorVersion != X_PROTOCOL_REVISION) { (void) fputs ( "Warning: Protocol rev. of client does not match server!\n", stderr); } setuplength = prefix.length << 2; if ((u.setup = (xConnSetup *) (setup = Xmalloc ((unsigned) setuplength))) == NULL) { errno = ENOMEM; Xfree ((char *) dpy); UnlockMutex (&lock); return (NULL); } _XRead (dpy, (char *) u.setup, setuplength); /* * If the connection was not accepted by the server due to problems, give * error message to the user.... */ if (prefix.success != xTrue) { /* * (void) fwrite (u.failure, (int)*u.failure, sizeof(char), stderr); */ (void) fwrite (u.failure, sizeof (char), (int) prefix.lengthReason, stderr); (void) fwrite ("\n", sizeof (char), 1, stderr); Xfree ((char *) dpy); Xfree (setup); UnlockMutex (&lock); return (NULL); } /* * We succeeded at authorization, so let us move the data into the display * structure. */ dpy->next = (Display *) NULL; dpy->proto_major_version = prefix.majorVersion; dpy->proto_minor_version = prefix.minorVersion; dpy->release = u.setup->release; dpy->resource_base = u.setup->ridBase; dpy->resource_mask = u.setup->ridMask; dpy->min_keycode = u.setup->minKeyCode; dpy->max_keycode = u.setup->maxKeyCode; dpy->keysyms = (KeySym *) NULL; dpy->modifiermap = NULL; dpy->lock_meaning = NoSymbol; dpy->keysyms_per_keycode = 0; dpy->current = None; dpy->xdefaults = (char *) NULL; dpy->scratch_length = 0L; dpy->scratch_buffer = NULL; dpy->key_bindings = NULL; /* * -- we are not interested in handling motion buffers */ dpy->motion_buffer = 0; /* u.setup->motionBufferSize; */ dpy->nformats = u.setup->numFormats; dpy->nscreens = u.setup->numRoots; dpy->byte_order = u.setup->imageByteOrder; dpy->bitmap_unit = u.setup->bitmapScanlineUnit; dpy->bitmap_pad = u.setup->bitmapScanlinePad; dpy->bitmap_bit_order = u.setup->bitmapBitOrder; dpy->max_request_size = u.setup->maxRequestSize; dpy->ext_procs = (_XExtension *) NULL; dpy->ext_data = (XExtData *) NULL; dpy->ext_number = 0; dpy->event_vec[X_Error] = _XUnknownWireEvent; dpy->event_vec[X_Reply] = _XUnknownWireEvent; dpy->wire_vec[X_Error] = _XUnknownNativeEvent; dpy->wire_vec[X_Reply] = _XUnknownNativeEvent; for (i = KeyPress; i < LASTEvent; i++) { dpy->event_vec[i] = _XWireToEvent; dpy->wire_vec[i] = NULL; } for (i = LASTEvent; i < 128; i++) { dpy->event_vec[i] = _XUnknownWireEvent; dpy->wire_vec[i] = _XUnknownNativeEvent; } dpy->resource_id = 0; dpy->resource_shift = ffs (dpy->resource_mask) - 1; dpy->db = (struct _XrmHashBucketRec *) NULL; dpy->cursor_font = None; /* * Initialize pointers to NULL so that XFreeDisplayStructure will work if * we run out of memory */ dpy->screens = NULL; dpy->display_name = NULL; dpy->vendor = NULL; dpy->buffer = NULL; /* * now extract the vendor string... String must be null terminated, padded * to multiple of 4 bytes. */ dpy->vendor = (char *) Xmalloc (u.setup->nbytesVendor + 1); vendorlen = u.setup->nbytesVendor; u.setup += 1; /* can't touch information in XConnSetup * anymore.. */ (void) strncpy (dpy->vendor, u.vendor, vendorlen); u.vendor += (vendorlen + 3) & ~3; /* * Now iterate down setup information..... */ dpy->pixmap_format = (ScreenFormat *) Xmalloc ( (unsigned) (dpy->nformats * sizeof (ScreenFormat))); if (dpy->pixmap_format == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } /* * First decode the Z axis Screen format information. */ for (i = 0; i < dpy->nformats; i++) { register ScreenFormat *fmt = &dpy->pixmap_format[i]; fmt->depth = u.sf->depth; fmt->bits_per_pixel = u.sf->bitsPerPixel; fmt->scanline_pad = u.sf->scanLinePad; fmt->ext_data = NULL; u.sf += 1; } /* * next the Screen structures. */ dpy->screens = (Screen *) Xmalloc ((unsigned) dpy->nscreens * sizeof (Screen)); if (dpy->screens == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } /* * Now go deal with each screen structure. */ for (i = 0; i < dpy->nscreens; i++) { register Screen *sp = &dpy->screens[i]; VisualID root_visualID = u.rp->rootVisualID; sp->display = dpy; sp->root = u.rp->windowId; sp->cmap = u.rp->defaultColormap; sp->white_pixel = u.rp->whitePixel; sp->black_pixel = u.rp->blackPixel; sp->root_input_mask = u.rp->currentInputMask; sp->width = u.rp->pixWidth; sp->height = u.rp->pixHeight; sp->mwidth = u.rp->mmWidth; sp->mheight = u.rp->mmHeight; sp->min_maps = u.rp->minInstalledMaps; sp->max_maps = u.rp->maxInstalledMaps; sp->root_visual = NULL; /* filled in later, when we alloc Visuals */ /* * -- NO backing store */ sp->backing_store = NotUseful; /* u.rp->backingStore; */ /* * -- NO save unders */ sp->save_unders = False; /* u.rp->saveUnders; */ sp->root_depth = u.rp->rootDepth; sp->ndepths = u.rp->nDepths; sp->ext_data = NULL; u.rp += 1; /* * lets set up the depth structures. */ sp->depths = (Depth *) Xmalloc ( (unsigned) sp->ndepths * sizeof (Depth)); if (sp->depths == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } /* * for all depths on this screen. */ for (j = 0; j < sp->ndepths; j++) { Depth *dp = &sp->depths[j]; dp->depth = u.dp->depth; dp->nvisuals = u.dp->nVisuals; u.dp += 1; dp->visuals = (Visual *) Xmalloc ((unsigned) dp->nvisuals * sizeof (Visual)); if (dp->visuals == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } for (k = 0; k < dp->nvisuals; k++) { register Visual *vp = &dp->visuals[k]; /* * -- RESTRICTION : No read/write color cells */ vp->class = u.vp->class; /* * -- if( vp->class == GrayScale ) vp->class = StaticGray ; else if( * vp->class == PseudoColor ) vp->class = StaticColor ; else if( * vp->class == DirectColor ) vp->class = TrueColor ; -- */ vp->bits_per_rgb = u.vp->bitsPerRGB; vp->map_entries = u.vp->colormapEntries; vp->red_mask = u.vp->redMask; vp->green_mask = u.vp->greenMask; vp->blue_mask = u.vp->blueMask; vp->ext_data = NULL; vp->visualid = u.vp->visualID; u.vp += 1; } if (!XmuXSortVisuals (dpy, dp->visuals, dp->nvisuals, dp->depth)) { errno = ENOMEM; Xfree ((char *) dpy); UnlockMutex (&lock); return (NULL); } for (k = 0; k < dp->nvisuals; k++) { register Visual *vp = &dp->visuals[k]; if (vp->visualid == root_visualID) { unsigned long black = sp->black_pixel, white = sp->white_pixel; sp->root_visual = vp; /* * -- Create a colormap entry for screen's default -- Second last * argument says -- "no private colormap" -- and insert "black" and * "white" */ XmuXCreateColormapInfo (dpy, sp->cmap, vp, sp->root, False, AllocNone); XmuXUpdateColormapInfo (dpy, sp->cmap, &black, 1, NULL, 0, True, False); XmuXUpdateColormapInfo (dpy, sp->cmap, &white, 1, NULL, 0, True, False); } } } } /* * Setup other information in this display structure. */ dpy->vnumber = X_PROTOCOL; dpy->resource_alloc = _XAllocID; dpy->synchandler = NULL; dpy->request = 0; dpy->last_request_read = 0; dpy->default_screen = screen_num; /* Value returned by ConnectDisplay */ dpy->last_req = (char *) &_dummy_request; /* Salt away the host:display string for later use */ if ((dpy->display_name = Xmalloc ( (unsigned) (strlen (displaybuf) + 1))) == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } (void) strcpy (dpy->display_name, displaybuf); /* Set up the output buffers. */ if ((dpy->bufptr = dpy->buffer = Xmalloc (BUFSIZE)) == NULL) { OutOfMemory (dpy, setup); UnlockMutex (&lock); return (NULL); } dpy->bufmax = dpy->buffer + BUFSIZE; /* Set up the input event queue and input event queue parameters. */ dpy->head = dpy->tail = NULL; dpy->qlen = 0; /* * Now start talking to the server to setup all other information... */ Xfree (setup); /* all finished with setup information */ /* * Make sure default screen is legal. */ if (screen_num >= dpy->nscreens) { _XDisconnectDisplay (dpy->fd); _XFreeDisplayStructure (dpy); errno = EINVAL; UnlockMutex (&lock); return (NULL); } /* * Set up other stuff clients are always going to use. */ for (i = 0; i < dpy->nscreens; i++) { register Screen *sp = &dpy->screens[i]; XGCValues values; values.foreground = sp->black_pixel; values.background = sp->white_pixel; sp->default_gc = XCreateGC (dpy, sp->root, GCForeground | GCBackground, &values); } /* * call into synchronization routine so that all programs can be forced * synchronize */ (void) XSynchronize (dpy, _Xdebug); /* * chain this stucture onto global list. */ dpy->next = _XHeadOfDisplayList; _XHeadOfDisplayList = dpy; /* * W A R N I N G * * This is experimental code for implementing pseudo-root windows as specified * by the Inter-Client Communications Conventions Manual. The structures * that it provides should be considered private to the MIT implementation * of Xlib and are SUBJECT TO CHANGE WITHOUT NOTICE. They should not be * incorporated into any toolkits or applications. When they change, no * effort will be made to provide backwards compatibility. * */ if (prop_name[0] != '\0') { extern Status _XGetPseudoRoot (); /* * If a bad property name is specified we want to fail so that the * application doesn't get started up in the original root or, worse yet, * in a messed up one. Again, the interfaces to the pseudo root code are * to be considered private to this implementation of Xlib and should not * be used in any toolkits or applications. */ if (!_XGetPseudoRoot (dpy, prop_name)) { _XDisconnectDisplay (dpy); _XFreeDisplayStructure (dpy); errno = EINVAL; UnlockMutex (&lock); return (NULL); } } /* * and done mucking with the display */ UnlockDisplay (dpy); /* didn't exist, so didn't lock */ UnlockMutex (&lock); /* * get the resource manager database off the root window. */ { Atom actual_type; int actual_format; unsigned long nitems; unsigned long leftover; if (XGetWindowProperty (dpy, RootWindow (dpy, 0), XA_RESOURCE_MANAGER, 0L, 100000000L, False, XA_STRING, &actual_type, &actual_format, &nitems, &leftover, (unsigned char **) &dpy->xdefaults) != Success) { dpy->xdefaults = (char *) NULL; } else { if ((actual_type != XA_STRING) || (actual_format != 8)) { if (dpy->xdefaults != NULL) Xfree (dpy->xdefaults); } } } /* * -- we must define some atoms */ XmuXDefineAtoms (dpy); if (first_call) { first_call = xFalse; XmuXAddDisplays (dpy); } return (dpy); } /* * OutOfMemory is called if malloc fails. XOpenDisplay returns NULL after * this returns. */ static OutOfMemory (dpy, setup) Display *dpy; char *setup; { _XDisconnectDisplay (dpy->fd); _XFreeDisplayStructure (dpy); Xfree (setup); errno = ENOMEM; } /* * XFreeDisplayStructure frees all the storage associated with a Display. It * is used by XOpenDisplay if it runs out of memory, and also by * XCloseDisplay. It needs to check whether all pointers are non-NULL * before dereferencing them, since it may be called by XOpenDisplay before * the Display structure is fully formed. XOpenDisplay must be sure to * initialize all the pointers to NULL before the first possible call on * this. */ _XFreeDisplayStructure (dpy) register Display *dpy; { if (dpy->screens) { register int i; for (i = 0; i < dpy->nscreens; i++) { Screen *sp = &dpy->screens[i]; if (sp->depths) { register int j; for (j = 0; j < sp->ndepths; j++) { Depth *dp = &sp->depths[j]; if (dp->visuals) { register int k; for (k = 0; k < dp->nvisuals; k++) _XFreeExtData (dp->visuals[k].ext_data); Xfree ((char *) dp->visuals); } } Xfree ((char *) sp->depths); } _XFreeExtData (sp->ext_data); } Xfree ((char *) dpy->screens); } if (dpy->pixmap_format) { register int i; for (i = 0; i < dpy->nformats; i++) _XFreeExtData (dpy->pixmap_format[i].ext_data); Xfree ((char *) dpy->pixmap_format); } if (dpy->display_name) Xfree (dpy->display_name); if (dpy->vendor) Xfree (dpy->vendor); if (dpy->buffer) Xfree (dpy->buffer); if (dpy->keysyms) Xfree ((char *) dpy->keysyms); if (dpy->modifiermap) XFreeModifiermap (dpy->modifiermap); if (dpy->xdefaults) Xfree (dpy->xdefaults); if (dpy->key_bindings) _XFreeKeyBindings (dpy); _XFreeExtData (dpy->ext_data); Xfree ((char *) dpy); }