#define NEED_REPLIES
#define NEED_EVENTS
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "Xlibint.h"
#if USE_XCB
#include "Xxcbint.h"
#else
#include <X11/Xtrans/Xtrans.h>
#include <X11/extensions/bigreqstr.h>
#endif
#include <X11/Xatom.h>
#include <X11/Xresource.h>
#include <stdio.h>
#include "Xintconn.h"
#ifdef XKB
#include "XKBlib.h"
#endif
#if !USE_XCB
#ifdef X_NOT_POSIX
#define Size_t unsigned int
#else
#define Size_t size_t
#endif
#define bignamelen (sizeof(XBigReqExtensionName) - 1)
typedef struct {
unsigned long seq;
int opcode;
} _XBigReqState;
#endif
#ifdef XTHREADS
#include "locking.h"
int (*_XInitDisplayLock_fn)(Display *dpy) = NULL;
void (*_XFreeDisplayLock_fn)(Display *dpy) = NULL;
#define InitDisplayLock(d) (_XInitDisplayLock_fn ? (*_XInitDisplayLock_fn)(d) : Success)
#define FreeDisplayLock(d) if (_XFreeDisplayLock_fn) (*_XFreeDisplayLock_fn)(d)
#else
#define InitDisplayLock(dis) Success
#define FreeDisplayLock(dis)
#endif
static xReq _dummy_request = {
0, 0, 0
};
static void OutOfMemory(Display *dpy, char *setup);
#if !USE_XCB
static Bool _XBigReqHandler(Display *dpy, xReply *rep, char *buf, int len,
XPointer data);
#endif
Display *
XOpenDisplay (
register _Xconst char *display)
{
register Display *dpy;
register int i;
int j, k;
#if !USE_XCB
char *display_name;
int endian;
xConnClientPrefix client;
int idisplay;
int prefixread = 0;
char *conn_auth_name, *conn_auth_data;
int conn_auth_namelen, conn_auth_datalen;
#endif
char *setup = NULL;
char *fullname = NULL;
int iscreen;
xConnSetupPrefix prefix;
int vendorlen;
union {
xConnSetup *setup;
char *failure;
char *vendor;
xPixmapFormat *sf;
xWindowRoot *rp;
xDepth *dp;
xVisualType *vp;
} u;
long setuplength;
long usedbytes = 0;
unsigned long mask;
long int conn_buf_size;
char *xlib_buffer_size;
#if !USE_XCB
bzero((char *) &client, sizeof(client));
bzero((char *) &prefix, sizeof(prefix));
if (display == NULL || *display == '\0') {
if ((display_name = getenv("DISPLAY")) == NULL) {
return(NULL);
}
}
else {
display_name = (char *)display;
}
#endif
if (_XErrorFunction == NULL) (void) XSetErrorHandler (NULL);
if (_XIOErrorFunction == NULL) (void) XSetIOErrorHandler (NULL);
if ((dpy = (Display *)Xcalloc(1, sizeof(Display))) == NULL) {
return(NULL);
}
#if USE_XCB
if(!_XConnectXCB(dpy, display, &fullname, &iscreen)) {
OutOfMemory(dpy, 0);
return 0;
}
#else
if ((dpy->trans_conn = _X11TransConnectDisplay (
display_name, &fullname, &idisplay,
&iscreen, &conn_auth_name,
&conn_auth_namelen, &conn_auth_data,
&conn_auth_datalen)) == NULL) {
Xfree ((char *) dpy);
return(NULL);
}
dpy->fd = _X11TransGetConnectionNumber (dpy->trans_conn);
#endif
dpy->display_name = fullname;
dpy->keysyms = (KeySym *) NULL;
dpy->modifiermap = NULL;
dpy->lock_meaning = NoSymbol;
dpy->keysyms_per_keycode = 0;
dpy->xdefaults = (char *)NULL;
dpy->scratch_length = 0L;
dpy->scratch_buffer = NULL;
dpy->key_bindings = NULL;
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->db = (struct _XrmHashBucketRec *)NULL;
dpy->cursor_font = None;
dpy->flags = 0;
dpy->async_handlers = NULL;
dpy->screens = NULL;
dpy->vendor = NULL;
dpy->buffer = NULL;
dpy->atoms = NULL;
dpy->error_vec = NULL;
dpy->context_db = NULL;
dpy->free_funcs = NULL;
dpy->pixmap_format = NULL;
dpy->cms.clientCmaps = NULL;
dpy->cms.defaultCCCs = NULL;
dpy->cms.perVisualIntensityMaps = NULL;
dpy->im_filters = NULL;
dpy->bigreq_size = 0;
dpy->lock = NULL;
dpy->lock_fns = NULL;
dpy->qfree = NULL;
dpy->next_event_serial_num = 1;
dpy->im_fd_info = NULL;
dpy->im_fd_length = 0;
dpy->conn_watchers = NULL;
dpy->watcher_count = 0;
dpy->filedes = NULL;
dpy->flushes = NULL;
dpy->xcmisc_opcode = 0;
dpy->xkb_info = NULL;
dpy->vnumber = X_PROTOCOL;
dpy->resource_alloc = _XAllocID;
dpy->idlist_alloc = _XAllocIDs;
dpy->synchandler = NULL;
dpy->savedsynchandler = NULL;
dpy->request = 0;
dpy->last_request_read = 0;
dpy->default_screen = iscreen;
dpy->last_req = (char *)&_dummy_request;
if (InitDisplayLock(dpy) != 0) {
OutOfMemory (dpy, setup);
return(NULL);
}
#if USE_XCB
if (!_XCBInitDisplayLock(dpy)) {
OutOfMemory (dpy, setup);
return(NULL);
}
#endif
if (!_XPollfdCacheInit(dpy)) {
OutOfMemory (dpy, setup);
return(NULL);
}
#ifndef XLIBDEFAULTBUFSIZE
#define XLIBDEFAULTBUFSIZE 16384
#endif
#ifndef XLIBMINBUFSIZE
#define XLIBMINBUFSIZE BUFSIZE
#endif
if ((xlib_buffer_size = getenv("XLIBBUFFERSIZE")) == NULL)
conn_buf_size = XLIBDEFAULTBUFSIZE;
else
conn_buf_size = 1024 * strtol(xlib_buffer_size, NULL, 10);
if (conn_buf_size < XLIBMINBUFSIZE)
conn_buf_size = XLIBMINBUFSIZE;
if ((dpy->bufptr = dpy->buffer = Xcalloc(1, conn_buf_size)) == NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
dpy->bufmax = dpy->buffer + conn_buf_size;
dpy->head = dpy->tail = NULL;
dpy->qlen = 0;
if ((dpy->free_funcs = (_XFreeFuncRec *)Xcalloc(1,
sizeof(_XFreeFuncRec)))
== NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
#if !USE_XCB
endian = 1;
if (*(char *) &endian)
client.byteOrder = '\154';
else
client.byteOrder = '\102';
client.majorVersion = X_PROTOCOL;
client.minorVersion = X_PROTOCOL_REVISION;
client.nbytesAuthProto = conn_auth_namelen;
client.nbytesAuthString = conn_auth_datalen;
prefixread = _XSendClientPrefix(dpy, &client,
conn_auth_name, conn_auth_data,
&prefix);
if (prefixread < 0)
{
_XDisconnectDisplay (dpy->trans_conn);
Xfree ((char *)dpy);
return(NULL);
}
if (conn_auth_name) Xfree(conn_auth_name);
if (conn_auth_data) Xfree(conn_auth_data);
LockDisplay(dpy);
if (prefixread == 0)
_XRead (dpy, (char *)&prefix,(long)SIZEOF(xConnSetupPrefix));
if (prefix.success != xTrue && prefix.success != xFalse) {
fprintf (stderr,
"Xlib: unexpected connection setup reply from server, type %d.\r\n",
prefix.success);
_XDisconnectDisplay (dpy->trans_conn);
Xfree ((char *)dpy);
return(NULL);
}
if (prefix.majorVersion != X_PROTOCOL) {
fprintf (stderr,
"Xlib: client uses different protocol version (%d) than server (%d)!\r\n",
X_PROTOCOL, prefix.majorVersion);
_XDisconnectDisplay (dpy->trans_conn);
Xfree ((char *)dpy);
return(NULL);
}
#endif
#if USE_XCB
{
const struct xcb_setup_t *xcbsetup = xcb_get_setup(dpy->xcb->connection);
memcpy(&prefix, xcbsetup, sizeof(prefix));
setuplength = prefix.length << 2;
setup = (char *) xcbsetup;
setup += SIZEOF(xConnSetupPrefix);
u.setup = (xConnSetup *) setup;
}
#else
setuplength = prefix.length << 2;
if ( (u.setup = (xConnSetup *)
(setup = Xmalloc ((unsigned) setuplength))) == NULL) {
_XDisconnectDisplay (dpy->trans_conn);
Xfree ((char *)dpy);
return(NULL);
}
_XRead (dpy, (char *)u.setup, setuplength);
if (prefix.success != xTrue) {
fprintf (stderr,
"Xlib: connection to \"%s\" refused by server\r\nXlib: ",
fullname);
if (prefix.lengthReason > setuplength) {
fprintf (stderr, "Xlib: Broken initial reply: length of reason > length of packet\r\n");
}else{
(void) fwrite (u.failure, (Size_t)sizeof(char),
(Size_t)prefix.lengthReason, stderr);
(void) fwrite ("\r\n", sizeof(char), 2, stderr);
}
OutOfMemory(dpy, setup);
return (NULL);
}
#endif
usedbytes = sz_xConnSetup;
if (setuplength < usedbytes ) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory(dpy, setup);
return (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->motion_buffer = 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;
mask = dpy->resource_mask;
dpy->resource_shift = 0;
if (!mask)
{
fprintf (stderr, "Xlib: connection to \"%s\" invalid setup\n",
fullname);
OutOfMemory(dpy, setup);
return (NULL);
}
while (!(mask & 1)) {
dpy->resource_shift++;
mask = mask >> 1;
}
dpy->resource_max = (dpy->resource_mask >> dpy->resource_shift) - 5;
if (u.setup->nbytesVendor > 256) {
OutOfMemory(dpy, setup);
return (NULL);
}
dpy->vendor = (char *) Xmalloc((unsigned) (u.setup->nbytesVendor + 1));
if (dpy->vendor == NULL) {
OutOfMemory(dpy, setup);
return (NULL);
}
vendorlen = u.setup->nbytesVendor;
usedbytes += (vendorlen + 3) & ~3;
if (setuplength < usedbytes) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory(dpy, setup);
return (NULL);
}
u.setup = (xConnSetup *) (((char *) u.setup) + sz_xConnSetup);
(void) strncpy(dpy->vendor, u.vendor, vendorlen);
dpy->vendor[vendorlen] = '\0';
vendorlen = (vendorlen + 3) & ~3;
u.vendor += vendorlen;
dpy->pixmap_format =
(ScreenFormat *)Xmalloc(
(unsigned) (dpy->nformats *sizeof(ScreenFormat)));
if (dpy->pixmap_format == NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
usedbytes += dpy->nformats * sz_xPixmapFormat;
if (setuplength < usedbytes) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory (dpy, setup);
return(NULL);
}
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 = (xPixmapFormat *) (((char *) u.sf) + sz_xPixmapFormat);
}
dpy->screens =
(Screen *)Xmalloc((unsigned) dpy->nscreens*sizeof(Screen));
if (dpy->screens == NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
for (i = 0; i < dpy->nscreens; i++) {
register Screen *sp = &dpy->screens[i];
VisualID root_visualID;
usedbytes += sz_xWindowRoot;
if (setuplength < usedbytes) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory (dpy, setup);
return(NULL);
}
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->backing_store= u.rp->backingStore;
sp->save_unders = u.rp->saveUnders;
sp->root_depth = u.rp->rootDepth;
sp->ndepths = u.rp->nDepths;
sp->ext_data = NULL;
u.rp = (xWindowRoot *) (((char *) u.rp) + sz_xWindowRoot);
sp->depths = (Depth *)Xmalloc(
(unsigned)sp->ndepths*sizeof(Depth));
if (sp->depths == NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
for (j = 0; j < sp->ndepths; j++) {
Depth *dp = &sp->depths[j];
usedbytes += sz_xDepth;
if (setuplength < usedbytes) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory (dpy, setup);
return(NULL);
}
dp->depth = u.dp->depth;
dp->nvisuals = u.dp->nVisuals;
u.dp = (xDepth *) (((char *) u.dp) + sz_xDepth);
if (dp->nvisuals > 0) {
dp->visuals =
(Visual *)Xmalloc((unsigned)dp->nvisuals*sizeof(Visual));
if (dp->visuals == NULL) {
OutOfMemory (dpy, setup);
return(NULL);
}
for (k = 0; k < dp->nvisuals; k++) {
register Visual *vp = &dp->visuals[k];
usedbytes += sz_xVisualType;
if (setuplength < usedbytes) {
fprintf (stderr, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength);
OutOfMemory (dpy, setup);
return(NULL);
}
vp->visualid = u.vp->visualID;
vp->class = u.vp->class;
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;
u.vp = (xVisualType *) (((char *) u.vp) +
sz_xVisualType);
}
if (dp->depth == 32 && getenv ("XLIB_SKIP_ARGB_VISUALS"))
{
Xfree (dp->visuals);
dp->visuals = NULL;
dp->nvisuals = 0;
}
} else {
dp->visuals = (Visual *) NULL;
}
}
sp->root_visual = _XVIDtoVisual(dpy, root_visualID);
}
if(usedbytes != setuplength){
fprintf(stderr, "Xlib: Did not parse entire setup message: "
"parsed: %ld, message: %ld\n",
usedbytes, setuplength);
OutOfMemory(dpy, setup);
return(NULL);
}
#if !USE_XCB
Xfree (setup);
#endif
if (iscreen >= dpy->nscreens) {
OutOfMemory(dpy, (char *) NULL);
return(NULL);
}
#if !USE_XCB
UnlockDisplay(dpy);
#endif
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;
if ((sp->default_gc = XCreateGC (dpy, sp->root,
GCForeground|GCBackground,
&values)) == NULL) {
OutOfMemory(dpy, (char *) NULL);
return (NULL);
}
}
(void) XSynchronize(dpy, _Xdebug);
#if USE_XCB
dpy->bigreq_size = xcb_get_maximum_request_length(dpy->xcb->connection);
if(dpy->bigreq_size <= dpy->max_request_size)
dpy->bigreq_size = 0;
#endif
LockDisplay(dpy);
{
xGetPropertyReply reply;
xGetPropertyReq *req;
#if !USE_XCB
_XAsyncHandler async;
_XBigReqState async_state;
xQueryExtensionReq *qreq;
xBigReqEnableReq *breq;
xBigReqEnableReply brep;
GetReq(QueryExtension, qreq);
async_state.seq = dpy->request;
async_state.opcode = 0;
async.next = dpy->async_handlers;
async.handler = _XBigReqHandler;
async.data = (XPointer)&async_state;
dpy->async_handlers = &async;
qreq->nbytes = bignamelen;
qreq->length += (bignamelen+3)>>2;
Data(dpy, XBigReqExtensionName, bignamelen);
#endif
GetReq (GetProperty, req);
req->window = RootWindow(dpy, 0);
req->property = XA_RESOURCE_MANAGER;
req->type = XA_STRING;
req->delete = False;
req->longOffset = 0;
req->longLength = 100000000L;
if (_XReply (dpy, (xReply *) &reply, 0, xFalse)) {
if (reply.format == 8 && reply.propertyType == XA_STRING &&
(reply.nItems + 1 > 0) &&
(reply.nItems <= req->longLength * 4) &&
(dpy->xdefaults = Xmalloc (reply.nItems + 1))) {
_XReadPad (dpy, dpy->xdefaults, reply.nItems);
dpy->xdefaults[reply.nItems] = '\0';
}
else if (reply.propertyType != None)
_XEatData(dpy, reply.nItems * (reply.format >> 3));
}
#if !USE_XCB
DeqAsyncHandler(dpy, &async);
if (async_state.opcode) {
GetReq(BigReqEnable, breq);
breq->reqType = async_state.opcode;
breq->brReqType = X_BigReqEnable;
if (_XReply(dpy, (xReply *)&brep, 0, xFalse))
dpy->bigreq_size = brep.max_request_size;
}
#endif
}
UnlockDisplay(dpy);
#ifdef MOTIFBC
{
extern Display *_XHeadOfDisplayList;
_XHeadOfDisplayList = dpy;
}
#endif
#ifdef XKB
XkbUseExtension(dpy,NULL,NULL);
#endif
return(dpy);
}
#if !USE_XCB
static Bool
_XBigReqHandler(
register Display *dpy,
register xReply *rep,
char *buf,
int len,
XPointer data)
{
_XBigReqState *state;
xQueryExtensionReply replbuf;
xQueryExtensionReply *repl;
state = (_XBigReqState *)data;
if (dpy->last_request_read != state->seq)
return False;
if (rep->generic.type == X_Error)
return True;
repl = (xQueryExtensionReply *)
_XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len,
(SIZEOF(xQueryExtensionReply) - SIZEOF(xReply)) >> 2,
True);
if (repl->present)
state->opcode = repl->major_opcode;
return True;
}
#endif
void _XFreeDisplayStructure(dpy)
register Display *dpy;
{
while (dpy->ext_procs) {
_XExtension *ext = dpy->ext_procs;
dpy->ext_procs = ext->next;
if (ext->name)
Xfree (ext->name);
Xfree ((char *)ext);
}
if (dpy->im_filters)
(*dpy->free_funcs->im_filters)(dpy);
if (dpy->cms.clientCmaps)
(*dpy->free_funcs->clientCmaps)(dpy);
if (dpy->cms.defaultCCCs)
(*dpy->free_funcs->defaultCCCs)(dpy);
if (dpy->cms.perVisualIntensityMaps)
(*dpy->free_funcs->intensityMaps)(dpy);
if (dpy->atoms)
(*dpy->free_funcs->atoms)(dpy);
if (dpy->modifiermap)
(*dpy->free_funcs->modifiermap)(dpy->modifiermap);
if (dpy->key_bindings)
(*dpy->free_funcs->key_bindings)(dpy);
if (dpy->context_db)
(*dpy->free_funcs->context_db)(dpy);
if (dpy->xkb_info)
(*dpy->free_funcs->xkb)(dpy);
if (dpy->db && (dpy->flags & XlibDisplayDfltRMDB))
XrmDestroyDatabase(dpy->db);
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->xdefaults)
Xfree (dpy->xdefaults);
if (dpy->error_vec)
Xfree ((char *)dpy->error_vec);
_XFreeExtData (dpy->ext_data);
if (dpy->free_funcs)
Xfree ((char *)dpy->free_funcs);
if (dpy->scratch_buffer)
Xfree (dpy->scratch_buffer);
FreeDisplayLock(dpy);
#if USE_XCB
_XCBShutdownDisplayLock(dpy);
#endif
if (dpy->qfree) {
register _XQEvent *qelt = dpy->qfree;
while (qelt) {
register _XQEvent *qnxt = qelt->next;
Xfree ((char *) qelt);
qelt = qnxt;
}
}
while (dpy->im_fd_info) {
struct _XConnectionInfo *conni = dpy->im_fd_info;
dpy->im_fd_info = conni->next;
if (conni->watch_data)
Xfree (conni->watch_data);
Xfree (conni);
}
if (dpy->conn_watchers) {
struct _XConnWatchInfo *watcher = dpy->conn_watchers;
dpy->conn_watchers = watcher->next;
Xfree (watcher);
}
if (dpy->filedes)
Xfree (dpy->filedes);
#if USE_XCB
_XFreeX11XCBStructure(dpy);
#endif
Xfree ((char *)dpy);
}
static void OutOfMemory (dpy, setup)
Display *dpy;
char *setup;
{
#if USE_XCB
if(dpy->xcb->connection)
xcb_disconnect(dpy->xcb->connection);
#else
_XDisconnectDisplay (dpy->trans_conn);
#endif
_XFreeDisplayStructure (dpy);
#if !USE_XCB
if (setup) Xfree (setup);
#endif
}