| File: | src/OpenDis.c |
| Location: | line 704, column 8 |
| Description: | Access to field 'connection' results in a dereference of a null pointer (loaded from field 'xcb') |
| 1 | /* | |||
| 2 | ||||
| 3 | Copyright 1985, 1986, 1998 The Open Group | |||
| 4 | ||||
| 5 | Permission to use, copy, modify, distribute, and sell this software and its | |||
| 6 | documentation for any purpose is hereby granted without fee, provided that | |||
| 7 | the above copyright notice appear in all copies and that both that | |||
| 8 | copyright notice and this permission notice appear in supporting | |||
| 9 | documentation. | |||
| 10 | ||||
| 11 | The above copyright notice and this permission notice shall be included in | |||
| 12 | all copies or substantial portions of the Software. | |||
| 13 | ||||
| 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||
| 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||
| 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |||
| 17 | OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN | |||
| 18 | AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |||
| 19 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |||
| 20 | ||||
| 21 | Except as contained in this notice, the name of The Open Group shall not be | |||
| 22 | used in advertising or otherwise to promote the sale, use or other dealings | |||
| 23 | in this Software without prior written authorization from The Open Group. | |||
| 24 | ||||
| 25 | */ | |||
| 26 | ||||
| 27 | #ifdef HAVE_CONFIG_H1 | |||
| 28 | #include <config.h> | |||
| 29 | #endif | |||
| 30 | #include "Xlibint.h" | |||
| 31 | #include "Xxcbint.h" | |||
| 32 | #include <X11/Xatom.h> | |||
| 33 | #include <X11/Xresource.h> | |||
| 34 | #include <stdio.h> | |||
| 35 | #include "Xintconn.h" | |||
| 36 | ||||
| 37 | #ifdef XKB1 | |||
| 38 | #include "XKBlib.h" | |||
| 39 | #endif /* XKB */ | |||
| 40 | ||||
| 41 | #ifdef XTHREADS1 | |||
| 42 | #include "locking.h" | |||
| 43 | int (*_XInitDisplayLock_fn)(Display *dpy) = NULL((void*)0); | |||
| 44 | void (*_XFreeDisplayLock_fn)(Display *dpy) = NULL((void*)0); | |||
| 45 | ||||
| 46 | #define InitDisplayLock(d)(_XInitDisplayLock_fn ? (*_XInitDisplayLock_fn)(d) : 0) (_XInitDisplayLock_fn ? (*_XInitDisplayLock_fn)(d) : Success0) | |||
| 47 | #define FreeDisplayLock(d)if (_XFreeDisplayLock_fn) (*_XFreeDisplayLock_fn)(d) if (_XFreeDisplayLock_fn) (*_XFreeDisplayLock_fn)(d) | |||
| 48 | #else | |||
| 49 | #define InitDisplayLock(dis)(_XInitDisplayLock_fn ? (*_XInitDisplayLock_fn)(dis) : 0) Success0 | |||
| 50 | #define FreeDisplayLock(dis)if (_XFreeDisplayLock_fn) (*_XFreeDisplayLock_fn)(dis) | |||
| 51 | #endif /* XTHREADS */ | |||
| 52 | ||||
| 53 | static xReq _dummy_request = { | |||
| 54 | 0, 0, 0 | |||
| 55 | }; | |||
| 56 | ||||
| 57 | static void OutOfMemory(Display *dpy); | |||
| 58 | ||||
| 59 | /* | |||
| 60 | * Connects to a server, creates a Display object and returns a pointer to | |||
| 61 | * the newly created Display back to the caller. | |||
| 62 | */ | |||
| 63 | Display * | |||
| 64 | XOpenDisplay ( | |||
| 65 | register _Xconstconst char *display) | |||
| 66 | { | |||
| 67 | register Display *dpy; /* New Display object being created. */ | |||
| 68 | register int i; | |||
| 69 | int j, k; /* random iterator indexes */ | |||
| 70 | char *display_name; /* pointer to display name */ | |||
| 71 | char *setup = NULL((void*)0); /* memory allocated at startup */ | |||
| 72 | int iscreen; /* screen number */ | |||
| 73 | xConnSetupPrefix prefix; /* prefix information */ | |||
| 74 | int vendorlen; /* length of vendor string */ | |||
| 75 | union { | |||
| 76 | xConnSetup *setup; | |||
| 77 | char *failure; | |||
| 78 | char *vendor; | |||
| 79 | xPixmapFormat *sf; | |||
| 80 | xWindowRoot *rp; | |||
| 81 | xDepth *dp; | |||
| 82 | xVisualType *vp; | |||
| 83 | } u; /* proto data returned from server */ | |||
| 84 | long setuplength; /* number of bytes in setup message */ | |||
| 85 | long usedbytes = 0; /* number of bytes we have processed */ | |||
| 86 | unsigned long mask; | |||
| 87 | long int conn_buf_size; | |||
| 88 | char *xlib_buffer_size; | |||
| 89 | ||||
| 90 | /* | |||
| 91 | * If the display specifier string supplied as an argument to this | |||
| 92 | * routine is NULL or a pointer to NULL, read the DISPLAY variable. | |||
| 93 | */ | |||
| 94 | if (display == NULL((void*)0) || *display == '\0') { | |||
| ||||
| 95 | if ((display_name = getenv("DISPLAY")) == NULL((void*)0)) { | |||
| 96 | /* Oops! No DISPLAY environment variable - error. */ | |||
| 97 | return(NULL((void*)0)); | |||
| 98 | } | |||
| 99 | } | |||
| 100 | else { | |||
| 101 | /* Display is non-NULL, copy the pointer */ | |||
| 102 | display_name = (char *)display; | |||
| 103 | } | |||
| 104 | ||||
| 105 | /* | |||
| 106 | * Set the default error handlers. This allows the global variables to | |||
| 107 | * default to NULL for use with shared libraries. | |||
| 108 | */ | |||
| 109 | if (_XErrorFunction == NULL((void*)0)) (void) XSetErrorHandler (NULL((void*)0)); | |||
| 110 | if (_XIOErrorFunction == NULL((void*)0)) (void) XSetIOErrorHandler (NULL((void*)0)); | |||
| 111 | ||||
| 112 | /* | |||
| 113 | * Attempt to allocate a display structure. Return NULL if allocation fails. | |||
| 114 | */ | |||
| 115 | if ((dpy = Xcalloc(1, sizeof(Display))calloc(((1) == 0 ? 1 : (1)), (sizeof(Display)))) == NULL((void*)0)) { | |||
| 116 | return(NULL((void*)0)); | |||
| 117 | } | |||
| 118 | ||||
| 119 | if ((dpy->display_name = strdup(display_name)) == NULL((void*)0)) { | |||
| 120 | OutOfMemory(dpy); | |||
| 121 | return(NULL((void*)0)); | |||
| 122 | } | |||
| 123 | ||||
| 124 | /* | |||
| 125 | * Call the Connect routine to get the transport connection object. | |||
| 126 | * If NULL is returned, the connection failed. | |||
| 127 | */ | |||
| 128 | ||||
| 129 | if(!_XConnectXCB(dpy, display, &iscreen)) { | |||
| 130 | OutOfMemory(dpy); | |||
| 131 | return NULL((void*)0); | |||
| 132 | } | |||
| 133 | ||||
| 134 | /* Initialize as much of the display structure as we can. | |||
| 135 | * Initialize pointers to NULL so that XFreeDisplayStructure will | |||
| 136 | * work if we run out of memory before we finish initializing. | |||
| 137 | */ | |||
| 138 | dpy->keysyms = (KeySym *) NULL((void*)0); | |||
| 139 | dpy->modifiermap = NULL((void*)0); | |||
| 140 | dpy->lock_meaning = NoSymbol0L; | |||
| 141 | dpy->keysyms_per_keycode = 0; | |||
| 142 | dpy->xdefaults = (char *)NULL((void*)0); | |||
| 143 | dpy->scratch_length = 0L; | |||
| 144 | dpy->scratch_buffer = NULL((void*)0); | |||
| 145 | dpy->key_bindings = NULL((void*)0); | |||
| 146 | dpy->ext_procs = (_XExtension *)NULL((void*)0); | |||
| 147 | dpy->ext_data = (XExtData *)NULL((void*)0); | |||
| 148 | dpy->ext_number = 0; | |||
| 149 | dpy->event_vec[X_Error0] = _XUnknownWireEvent; | |||
| 150 | dpy->event_vec[X_Reply1] = _XUnknownWireEvent; | |||
| 151 | dpy->wire_vec[X_Error0] = _XUnknownNativeEvent; | |||
| 152 | dpy->wire_vec[X_Reply1] = _XUnknownNativeEvent; | |||
| 153 | for (i = KeyPress2; i < LASTEvent36; i++) { | |||
| 154 | dpy->event_vec[i] = _XWireToEvent; | |||
| 155 | dpy->wire_vec[i] = NULL((void*)0); | |||
| 156 | } | |||
| 157 | for (i = LASTEvent36; i < 128; i++) { | |||
| 158 | dpy->event_vec[i] = _XUnknownWireEvent; | |||
| 159 | dpy->wire_vec[i] = _XUnknownNativeEvent; | |||
| 160 | } | |||
| 161 | dpy->resource_id = 0; | |||
| 162 | dpy->db = (struct _XrmHashBucketRec *)NULL((void*)0); | |||
| 163 | dpy->cursor_font = None0L; | |||
| 164 | dpy->flags = 0; | |||
| 165 | dpy->async_handlers = NULL((void*)0); | |||
| 166 | dpy->screens = NULL((void*)0); | |||
| 167 | dpy->vendor = NULL((void*)0); | |||
| 168 | dpy->buffer = NULL((void*)0); | |||
| 169 | dpy->atoms = NULL((void*)0); | |||
| 170 | dpy->error_vec = NULL((void*)0); | |||
| 171 | dpy->context_db = NULL((void*)0); | |||
| 172 | dpy->free_funcs = NULL((void*)0); | |||
| 173 | dpy->pixmap_format = NULL((void*)0); | |||
| 174 | dpy->cms.clientCmaps = NULL((void*)0); | |||
| 175 | dpy->cms.defaultCCCs = NULL((void*)0); | |||
| 176 | dpy->cms.perVisualIntensityMaps = NULL((void*)0); | |||
| 177 | dpy->im_filters = NULL((void*)0); | |||
| 178 | dpy->bigreq_size = 0; | |||
| 179 | dpy->lock = NULL((void*)0); | |||
| 180 | dpy->lock_fns = NULL((void*)0); | |||
| 181 | dpy->qfree = NULL((void*)0); | |||
| 182 | dpy->next_event_serial_num = 1; | |||
| 183 | dpy->im_fd_info = NULL((void*)0); | |||
| 184 | dpy->im_fd_length = 0; | |||
| 185 | dpy->conn_watchers = NULL((void*)0); | |||
| 186 | dpy->watcher_count = 0; | |||
| 187 | dpy->filedes = NULL((void*)0); | |||
| 188 | dpy->flushes = NULL((void*)0); | |||
| 189 | dpy->xcmisc_opcode = 0; | |||
| 190 | dpy->xkb_info = NULL((void*)0); | |||
| 191 | ||||
| 192 | /* | |||
| 193 | * Setup other information in this display structure. | |||
| 194 | */ | |||
| 195 | dpy->vnumber = X_PROTOCOL11; | |||
| 196 | dpy->resource_alloc = _XAllocID; | |||
| 197 | dpy->idlist_alloc = _XAllocIDs; | |||
| 198 | dpy->synchandler = NULL((void*)0); | |||
| 199 | dpy->savedsynchandler = NULL((void*)0); | |||
| 200 | X_DPY_SET_REQUEST(dpy, 0)((struct _XDisplay*)dpy)->request = (0); | |||
| 201 | X_DPY_SET_LAST_REQUEST_READ(dpy, 0)((struct _XDisplay*)dpy)->last_request_read = (0); | |||
| 202 | dpy->default_screen = iscreen; /* Value returned by ConnectDisplay */ | |||
| 203 | dpy->last_req = (char *)&_dummy_request; | |||
| 204 | ||||
| 205 | /* Initialize the display lock */ | |||
| 206 | if (InitDisplayLock(dpy)(_XInitDisplayLock_fn ? (*_XInitDisplayLock_fn)(dpy) : 0) != 0) { | |||
| 207 | OutOfMemory (dpy); | |||
| 208 | return(NULL((void*)0)); | |||
| 209 | } | |||
| 210 | ||||
| 211 | if (!_XPollfdCacheInit(dpy)) { | |||
| 212 | OutOfMemory (dpy); | |||
| 213 | return(NULL((void*)0)); | |||
| 214 | } | |||
| 215 | ||||
| 216 | /* Set up the output buffers. */ | |||
| 217 | #ifndef XLIBDEFAULTBUFSIZE16384 | |||
| 218 | #define XLIBDEFAULTBUFSIZE16384 16384 /* 16k */ | |||
| 219 | #endif | |||
| 220 | #ifndef XLIBMINBUFSIZE2048 | |||
| 221 | #define XLIBMINBUFSIZE2048 BUFSIZE2048 /* old default buffer size */ | |||
| 222 | #endif | |||
| 223 | xlib_buffer_size = getenv("XLIBBUFFERSIZE"); | |||
| 224 | ||||
| 225 | #ifdef __sun /* Backwards compatibility for old Solaris libX11 name */ | |||
| 226 | if (xlib_buffer_size == NULL((void*)0)) | |||
| 227 | xlib_buffer_size = getenv("XSUNBUFFERSIZE"); | |||
| 228 | #endif | |||
| 229 | ||||
| 230 | if (xlib_buffer_size == NULL((void*)0)) | |||
| 231 | conn_buf_size = XLIBDEFAULTBUFSIZE16384; | |||
| 232 | else | |||
| 233 | conn_buf_size = 1024 * strtol(xlib_buffer_size, NULL((void*)0), 10); | |||
| 234 | if (conn_buf_size < XLIBMINBUFSIZE2048) | |||
| 235 | conn_buf_size = XLIBMINBUFSIZE2048; | |||
| 236 | ||||
| 237 | if ((dpy->bufptr = dpy->buffer = Xcalloc(1, conn_buf_size)calloc(((1) == 0 ? 1 : (1)), (conn_buf_size))) == NULL((void*)0)) { | |||
| 238 | OutOfMemory (dpy); | |||
| 239 | return(NULL((void*)0)); | |||
| 240 | } | |||
| 241 | dpy->xcb->real_bufmax = dpy->buffer + conn_buf_size; | |||
| 242 | dpy->bufmax = dpy->buffer; | |||
| 243 | ||||
| 244 | /* Set up the input event queue and input event queue parameters. */ | |||
| 245 | dpy->head = dpy->tail = NULL((void*)0); | |||
| 246 | dpy->qlen = 0; | |||
| 247 | ||||
| 248 | /* Set up free-function record */ | |||
| 249 | if ((dpy->free_funcs = Xcalloc(1, sizeof(_XFreeFuncRec))calloc(((1) == 0 ? 1 : (1)), (sizeof(_XFreeFuncRec)))) == NULL((void*)0)) { | |||
| 250 | OutOfMemory (dpy); | |||
| 251 | return(NULL((void*)0)); | |||
| 252 | } | |||
| 253 | ||||
| 254 | { | |||
| 255 | const struct xcb_setup_t *xcbsetup = xcb_get_setup(dpy->xcb->connection); | |||
| 256 | memcpy(&prefix, xcbsetup, sizeof(prefix))__builtin___memcpy_chk (&prefix, xcbsetup, sizeof(prefix) , __builtin_object_size (&prefix, 0)); | |||
| 257 | setuplength = prefix.length << 2; | |||
| 258 | setup = (char *) xcbsetup; | |||
| 259 | setup += SIZEOF(xConnSetupPrefix)8; | |||
| 260 | u.setup = (xConnSetup *) setup; | |||
| 261 | } | |||
| 262 | ||||
| 263 | /* | |||
| 264 | * Check if the reply was long enough to get any information out of it. | |||
| 265 | */ | |||
| 266 | usedbytes = sz_xConnSetup32; | |||
| 267 | if (setuplength < usedbytes ) { | |||
| 268 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 269 | OutOfMemory(dpy); | |||
| 270 | return (NULL((void*)0)); | |||
| 271 | } | |||
| 272 | ||||
| 273 | /* | |||
| 274 | * We succeeded at authorization, so let us move the data into | |||
| 275 | * the display structure. | |||
| 276 | */ | |||
| 277 | dpy->proto_major_version= prefix.majorVersion; | |||
| 278 | dpy->proto_minor_version= prefix.minorVersion; | |||
| 279 | dpy->release = u.setup->release; | |||
| 280 | dpy->resource_base = u.setup->ridBase; | |||
| 281 | dpy->resource_mask = u.setup->ridMask; | |||
| 282 | dpy->min_keycode = u.setup->minKeyCode; | |||
| 283 | dpy->max_keycode = u.setup->maxKeyCode; | |||
| 284 | dpy->motion_buffer = u.setup->motionBufferSize; | |||
| 285 | dpy->nformats = u.setup->numFormats; | |||
| 286 | dpy->nscreens = u.setup->numRoots; | |||
| 287 | dpy->byte_order = u.setup->imageByteOrder; | |||
| 288 | dpy->bitmap_unit = u.setup->bitmapScanlineUnit; | |||
| 289 | dpy->bitmap_pad = u.setup->bitmapScanlinePad; | |||
| 290 | dpy->bitmap_bit_order = u.setup->bitmapBitOrder; | |||
| 291 | dpy->max_request_size = u.setup->maxRequestSize; | |||
| 292 | mask = dpy->resource_mask; | |||
| 293 | dpy->resource_shift = 0; | |||
| 294 | if (!mask) | |||
| 295 | { | |||
| 296 | fprintf (stderr__stderrp, "Xlib: connection to \"%s\" invalid setup\n", | |||
| 297 | dpy->display_name); | |||
| 298 | OutOfMemory(dpy); | |||
| 299 | return (NULL((void*)0)); | |||
| 300 | } | |||
| 301 | ||||
| 302 | while (!(mask & 1)) { | |||
| 303 | dpy->resource_shift++; | |||
| 304 | mask = mask >> 1; | |||
| 305 | } | |||
| 306 | dpy->resource_max = (dpy->resource_mask >> dpy->resource_shift) - 5; | |||
| 307 | /* | |||
| 308 | * now extract the vendor string... String must be null terminated, | |||
| 309 | * padded to multiple of 4 bytes. | |||
| 310 | */ | |||
| 311 | /* Check for a sane vendor string length */ | |||
| 312 | if (u.setup->nbytesVendor > 256) { | |||
| 313 | OutOfMemory(dpy); | |||
| 314 | return (NULL((void*)0)); | |||
| 315 | } | |||
| 316 | ||||
| 317 | dpy->vendor = Xmalloc(u.setup->nbytesVendor + 1)malloc(((u.setup->nbytesVendor + 1) == 0 ? 1 : (u.setup-> nbytesVendor + 1))); | |||
| 318 | if (dpy->vendor == NULL((void*)0)) { | |||
| 319 | OutOfMemory(dpy); | |||
| 320 | return (NULL((void*)0)); | |||
| 321 | } | |||
| 322 | vendorlen = u.setup->nbytesVendor; | |||
| 323 | ||||
| 324 | /* | |||
| 325 | * validate setup length | |||
| 326 | */ | |||
| 327 | usedbytes += (vendorlen + 3) & ~3; | |||
| 328 | if (setuplength < usedbytes) { | |||
| 329 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 330 | OutOfMemory(dpy); | |||
| 331 | return (NULL((void*)0)); | |||
| 332 | } | |||
| 333 | ||||
| 334 | u.setup = (xConnSetup *) (((char *) u.setup) + sz_xConnSetup32); | |||
| 335 | (void) strncpy(dpy->vendor, u.vendor, vendorlen)__builtin___strncpy_chk (dpy->vendor, u.vendor, vendorlen, __builtin_object_size (dpy->vendor, 2 > 1 ? 1 : 0)); | |||
| 336 | dpy->vendor[vendorlen] = '\0'; | |||
| 337 | vendorlen = (vendorlen + 3) & ~3; /* round up */ | |||
| 338 | u.vendor += vendorlen; | |||
| 339 | ||||
| 340 | /* | |||
| 341 | * Now iterate down setup information..... | |||
| 342 | */ | |||
| 343 | dpy->pixmap_format = Xcalloc(dpy->nformats, sizeof(ScreenFormat))calloc(((dpy->nformats) == 0 ? 1 : (dpy->nformats)), (sizeof (ScreenFormat))); | |||
| 344 | if (dpy->pixmap_format == NULL((void*)0)) { | |||
| 345 | OutOfMemory (dpy); | |||
| 346 | return(NULL((void*)0)); | |||
| 347 | } | |||
| 348 | /* | |||
| 349 | * First decode the Z axis Screen format information. | |||
| 350 | */ | |||
| 351 | usedbytes += dpy->nformats * sz_xPixmapFormat8; | |||
| 352 | ||||
| 353 | if (setuplength < usedbytes) { | |||
| 354 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 355 | OutOfMemory (dpy); | |||
| 356 | return(NULL((void*)0)); | |||
| 357 | } | |||
| 358 | ||||
| 359 | for (i = 0; i < dpy->nformats; i++) { | |||
| 360 | register ScreenFormat *fmt = &dpy->pixmap_format[i]; | |||
| 361 | fmt->depth = u.sf->depth; | |||
| 362 | fmt->bits_per_pixel = u.sf->bitsPerPixel; | |||
| 363 | fmt->scanline_pad = u.sf->scanLinePad; | |||
| 364 | fmt->ext_data = NULL((void*)0); | |||
| 365 | u.sf = (xPixmapFormat *) (((char *) u.sf) + sz_xPixmapFormat8); | |||
| 366 | } | |||
| 367 | ||||
| 368 | /* | |||
| 369 | * next the Screen structures. | |||
| 370 | */ | |||
| 371 | dpy->screens = Xcalloc(dpy->nscreens, sizeof(Screen))calloc(((dpy->nscreens) == 0 ? 1 : (dpy->nscreens)), (sizeof (Screen))); | |||
| 372 | if (dpy->screens == NULL((void*)0)) { | |||
| 373 | OutOfMemory (dpy); | |||
| 374 | return(NULL((void*)0)); | |||
| 375 | } | |||
| 376 | ||||
| 377 | /* | |||
| 378 | * Now go deal with each screen structure. | |||
| 379 | */ | |||
| 380 | for (i = 0; i < dpy->nscreens; i++) { | |||
| 381 | register Screen *sp = &dpy->screens[i]; | |||
| 382 | VisualID root_visualID; | |||
| 383 | ||||
| 384 | usedbytes += sz_xWindowRoot40; | |||
| 385 | if (setuplength < usedbytes) { | |||
| 386 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 387 | OutOfMemory (dpy); | |||
| 388 | return(NULL((void*)0)); | |||
| 389 | } | |||
| 390 | ||||
| 391 | root_visualID = u.rp->rootVisualID; | |||
| 392 | sp->display = dpy; | |||
| 393 | sp->root = u.rp->windowId; | |||
| 394 | sp->cmap = u.rp->defaultColormap; | |||
| 395 | sp->white_pixel = u.rp->whitePixel; | |||
| 396 | sp->black_pixel = u.rp->blackPixel; | |||
| 397 | sp->root_input_mask = u.rp->currentInputMask; | |||
| 398 | sp->width = u.rp->pixWidth; | |||
| 399 | sp->height = u.rp->pixHeight; | |||
| 400 | sp->mwidth = u.rp->mmWidth; | |||
| 401 | sp->mheight = u.rp->mmHeight; | |||
| 402 | sp->min_maps = u.rp->minInstalledMaps; | |||
| 403 | sp->max_maps = u.rp->maxInstalledMaps; | |||
| 404 | sp->backing_store= u.rp->backingStore; | |||
| 405 | sp->save_unders = u.rp->saveUnders; | |||
| 406 | sp->root_depth = u.rp->rootDepth; | |||
| 407 | sp->ndepths = u.rp->nDepths; | |||
| 408 | sp->ext_data = NULL((void*)0); | |||
| 409 | u.rp = (xWindowRoot *) (((char *) u.rp) + sz_xWindowRoot40); | |||
| 410 | /* | |||
| 411 | * lets set up the depth structures. | |||
| 412 | */ | |||
| 413 | sp->depths = Xcalloc(sp->ndepths, sizeof(Depth))calloc(((sp->ndepths) == 0 ? 1 : (sp->ndepths)), (sizeof (Depth))); | |||
| 414 | if (sp->depths == NULL((void*)0)) { | |||
| 415 | OutOfMemory (dpy); | |||
| 416 | return(NULL((void*)0)); | |||
| 417 | } | |||
| 418 | /* | |||
| 419 | * for all depths on this screen. | |||
| 420 | */ | |||
| 421 | for (j = 0; j < sp->ndepths; j++) { | |||
| 422 | Depth *dp = &sp->depths[j]; | |||
| 423 | ||||
| 424 | usedbytes += sz_xDepth8; | |||
| 425 | if (setuplength < usedbytes) { | |||
| 426 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 427 | OutOfMemory (dpy); | |||
| 428 | return(NULL((void*)0)); | |||
| 429 | } | |||
| 430 | ||||
| 431 | dp->depth = u.dp->depth; | |||
| 432 | dp->nvisuals = u.dp->nVisuals; | |||
| 433 | u.dp = (xDepth *) (((char *) u.dp) + sz_xDepth8); | |||
| 434 | if (dp->nvisuals > 0) { | |||
| 435 | dp->visuals = Xcalloc(dp->nvisuals, sizeof(Visual))calloc(((dp->nvisuals) == 0 ? 1 : (dp->nvisuals)), (sizeof (Visual))); | |||
| 436 | if (dp->visuals == NULL((void*)0)) { | |||
| 437 | OutOfMemory (dpy); | |||
| 438 | return(NULL((void*)0)); | |||
| 439 | } | |||
| 440 | for (k = 0; k < dp->nvisuals; k++) { | |||
| 441 | register Visual *vp = &dp->visuals[k]; | |||
| 442 | ||||
| 443 | usedbytes += sz_xVisualType24; | |||
| 444 | if (setuplength < usedbytes) { | |||
| 445 | fprintf (stderr__stderrp, "Xlib: Broken initial reply: Too short (%ld)\n", setuplength); | |||
| 446 | OutOfMemory (dpy); | |||
| 447 | return(NULL((void*)0)); | |||
| 448 | } | |||
| 449 | ||||
| 450 | vp->visualid = u.vp->visualID; | |||
| 451 | vp->class = u.vp->class; | |||
| 452 | vp->bits_per_rgb= u.vp->bitsPerRGB; | |||
| 453 | vp->map_entries = u.vp->colormapEntries; | |||
| 454 | vp->red_mask = u.vp->redMask; | |||
| 455 | vp->green_mask = u.vp->greenMask; | |||
| 456 | vp->blue_mask = u.vp->blueMask; | |||
| 457 | vp->ext_data = NULL((void*)0); | |||
| 458 | u.vp = (xVisualType *) (((char *) u.vp) + | |||
| 459 | sz_xVisualType24); | |||
| 460 | } | |||
| 461 | if (dp->depth == 32 && getenv ("XLIB_SKIP_ARGB_VISUALS")) | |||
| 462 | { | |||
| 463 | Xfree (dp->visuals)free((dp->visuals)); | |||
| 464 | dp->visuals = NULL((void*)0); | |||
| 465 | dp->nvisuals = 0; | |||
| 466 | } | |||
| 467 | } else { | |||
| 468 | dp->visuals = (Visual *) NULL((void*)0); | |||
| 469 | } | |||
| 470 | } | |||
| 471 | sp->root_visual = _XVIDtoVisual(dpy, root_visualID); | |||
| 472 | } | |||
| 473 | ||||
| 474 | if(usedbytes != setuplength){ | |||
| 475 | /* Sanity check, shouldn't happen. */ | |||
| 476 | fprintf(stderr__stderrp, "Xlib: Did not parse entire setup message: " | |||
| 477 | "parsed: %ld, message: %ld\n", | |||
| 478 | usedbytes, setuplength); | |||
| 479 | OutOfMemory(dpy); | |||
| 480 | return(NULL((void*)0)); | |||
| 481 | } | |||
| 482 | ||||
| 483 | /* | |||
| 484 | * Now start talking to the server to setup all other information... | |||
| 485 | */ | |||
| 486 | ||||
| 487 | /* | |||
| 488 | * Make sure default screen is legal. | |||
| 489 | */ | |||
| 490 | if (iscreen >= dpy->nscreens) { | |||
| 491 | OutOfMemory(dpy); | |||
| 492 | return(NULL((void*)0)); | |||
| 493 | } | |||
| 494 | ||||
| 495 | /* | |||
| 496 | * get availability of large requests | |||
| 497 | */ | |||
| 498 | dpy->bigreq_size = xcb_get_maximum_request_length(dpy->xcb->connection); | |||
| 499 | if(dpy->bigreq_size <= dpy->max_request_size) | |||
| 500 | dpy->bigreq_size = 0; | |||
| 501 | ||||
| 502 | /* | |||
| 503 | * Set up other stuff clients are always going to use. | |||
| 504 | */ | |||
| 505 | for (i = 0; i < dpy->nscreens; i++) { | |||
| 506 | register Screen *sp = &dpy->screens[i]; | |||
| 507 | XGCValues values; | |||
| 508 | values.foreground = sp->black_pixel; | |||
| 509 | values.background = sp->white_pixel; | |||
| 510 | if ((sp->default_gc = XCreateGC (dpy, sp->root, | |||
| 511 | GCForeground(1L<<2)|GCBackground(1L<<3), | |||
| 512 | &values)) == NULL((void*)0)) { | |||
| 513 | OutOfMemory(dpy); | |||
| 514 | return (NULL((void*)0)); | |||
| 515 | } | |||
| 516 | } | |||
| 517 | /* | |||
| 518 | * call into synchronization routine so that all programs can be | |||
| 519 | * forced synchronous | |||
| 520 | */ | |||
| 521 | (void) XSynchronize(dpy, _Xdebug); | |||
| 522 | ||||
| 523 | /* | |||
| 524 | * get the resource manager database off the root window. | |||
| 525 | */ | |||
| 526 | LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display )(dpy); | |||
| 527 | { | |||
| 528 | xGetPropertyReply reply; | |||
| 529 | xGetPropertyReq *req; | |||
| 530 | ||||
| 531 | GetReq (GetProperty, req)req = (xGetPropertyReq *) _XGetRequest(dpy, 20, 24); | |||
| 532 | req->window = RootWindow(dpy, 0)((&((_XPrivDisplay)(dpy))->screens[0])->root); | |||
| 533 | req->property = XA_RESOURCE_MANAGER((Atom) 23); | |||
| 534 | req->type = XA_STRING((Atom) 31); | |||
| 535 | req->delete = False0; | |||
| 536 | req->longOffset = 0; | |||
| 537 | req->longLength = 100000000L; | |||
| 538 | ||||
| 539 | if (_XReply (dpy, (xReply *) &reply, 0, xFalse0)) { | |||
| 540 | if (reply.format == 8 && reply.propertyType == XA_STRING((Atom) 31) && | |||
| 541 | (reply.nItems + 1 > 0) && | |||
| 542 | (reply.nItems <= req->longLength * 4) && | |||
| 543 | (dpy->xdefaults = Xmalloc (reply.nItems + 1)malloc(((reply.nItems + 1) == 0 ? 1 : (reply.nItems + 1))))) { | |||
| 544 | _XReadPad (dpy, dpy->xdefaults, reply.nItems); | |||
| 545 | dpy->xdefaults[reply.nItems] = '\0'; | |||
| 546 | } | |||
| 547 | else if (reply.propertyType != None0L) | |||
| 548 | _XEatDataWords(dpy, reply.length); | |||
| 549 | } | |||
| 550 | } | |||
| 551 | UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display )(dpy); | |||
| 552 | ||||
| 553 | #ifdef MOTIFBC | |||
| 554 | { | |||
| 555 | extern Display *_XHeadOfDisplayList; | |||
| 556 | _XHeadOfDisplayList = dpy; | |||
| 557 | } | |||
| 558 | #endif | |||
| 559 | #ifdef XKB1 | |||
| 560 | XkbUseExtension(dpy,NULL((void*)0),NULL((void*)0)); | |||
| 561 | #endif | |||
| 562 | /* | |||
| 563 | * and return successfully | |||
| 564 | */ | |||
| 565 | return(dpy); | |||
| 566 | } | |||
| 567 | ||||
| 568 | /* XFreeDisplayStructure frees all the storage associated with a | |||
| 569 | * Display. It is used by XOpenDisplay if it runs out of memory, | |||
| 570 | * and also by XCloseDisplay. It needs to check whether all pointers | |||
| 571 | * are non-NULL before dereferencing them, since it may be called | |||
| 572 | * by XOpenDisplay before the Display structure is fully formed. | |||
| 573 | * XOpenDisplay must be sure to initialize all the pointers to NULL | |||
| 574 | * before the first possible call on this. | |||
| 575 | */ | |||
| 576 | ||||
| 577 | void _XFreeDisplayStructure(Display *dpy) | |||
| 578 | { | |||
| 579 | /* move all cookies in the EQ to the jar, then free them. */ | |||
| 580 | if (dpy->qfree) { | |||
| 581 | _XQEvent *qelt = dpy->qfree; | |||
| 582 | while (qelt) { | |||
| 583 | if (_XIsEventCookie(dpy, &qelt->event)) | |||
| 584 | _XStoreEventCookie(dpy, &qelt->event); | |||
| 585 | qelt = qelt->next; | |||
| 586 | } | |||
| 587 | } | |||
| 588 | if (dpy->cookiejar) | |||
| 589 | _XFreeEventCookies(dpy); | |||
| 590 | while (dpy->ext_procs) { | |||
| 591 | _XExtension *ext = dpy->ext_procs; | |||
| 592 | dpy->ext_procs = ext->next; | |||
| 593 | Xfree (ext->name)free((ext->name)); | |||
| 594 | Xfree (ext)free((ext)); | |||
| 595 | } | |||
| 596 | if (dpy->im_filters) | |||
| 597 | (*dpy->free_funcs->im_filters)(dpy); | |||
| 598 | if (dpy->cms.clientCmaps) | |||
| 599 | (*dpy->free_funcs->clientCmaps)(dpy); | |||
| 600 | if (dpy->cms.defaultCCCs) | |||
| 601 | (*dpy->free_funcs->defaultCCCs)(dpy); | |||
| 602 | if (dpy->cms.perVisualIntensityMaps) | |||
| 603 | (*dpy->free_funcs->intensityMaps)(dpy); | |||
| 604 | if (dpy->atoms) | |||
| 605 | (*dpy->free_funcs->atoms)(dpy); | |||
| 606 | if (dpy->modifiermap) | |||
| 607 | (*dpy->free_funcs->modifiermap)(dpy->modifiermap); | |||
| 608 | if (dpy->key_bindings) | |||
| 609 | (*dpy->free_funcs->key_bindings)(dpy); | |||
| 610 | if (dpy->context_db) | |||
| 611 | (*dpy->free_funcs->context_db)(dpy); | |||
| 612 | if (dpy->xkb_info) | |||
| 613 | (*dpy->free_funcs->xkb)(dpy); | |||
| 614 | ||||
| 615 | /* if RM database was allocated by XGetDefault() free it */ | |||
| 616 | if (dpy->db && (dpy->flags & XlibDisplayDfltRMDB(1L << 7))) | |||
| 617 | XrmDestroyDatabase(dpy->db); | |||
| 618 | ||||
| 619 | if (dpy->screens) { | |||
| 620 | register int i; | |||
| 621 | ||||
| 622 | for (i = 0; i < dpy->nscreens; i++) { | |||
| 623 | Screen *sp = &dpy->screens[i]; | |||
| 624 | ||||
| 625 | if (sp->depths) { | |||
| 626 | register int j; | |||
| 627 | ||||
| 628 | for (j = 0; j < sp->ndepths; j++) { | |||
| 629 | Depth *dp = &sp->depths[j]; | |||
| 630 | ||||
| 631 | if (dp->visuals) { | |||
| 632 | register int k; | |||
| 633 | ||||
| 634 | for (k = 0; k < dp->nvisuals; k++) | |||
| 635 | _XFreeExtData (dp->visuals[k].ext_data); | |||
| 636 | Xfree (dp->visuals)free((dp->visuals)); | |||
| 637 | } | |||
| 638 | } | |||
| 639 | ||||
| 640 | Xfree (sp->depths)free((sp->depths)); | |||
| 641 | } | |||
| 642 | ||||
| 643 | _XFreeExtData (sp->ext_data); | |||
| 644 | } | |||
| 645 | ||||
| 646 | Xfree (dpy->screens)free((dpy->screens)); | |||
| 647 | } | |||
| 648 | ||||
| 649 | if (dpy->pixmap_format) { | |||
| 650 | register int i; | |||
| 651 | ||||
| 652 | for (i = 0; i < dpy->nformats; i++) | |||
| 653 | _XFreeExtData (dpy->pixmap_format[i].ext_data); | |||
| 654 | Xfree (dpy->pixmap_format)free((dpy->pixmap_format)); | |||
| 655 | } | |||
| 656 | ||||
| 657 | free(dpy->display_name); | |||
| 658 | ||||
| 659 | Xfree (dpy->vendor)free((dpy->vendor)); | |||
| 660 | Xfree (dpy->buffer)free((dpy->buffer)); | |||
| 661 | Xfree (dpy->keysyms)free((dpy->keysyms)); | |||
| 662 | Xfree (dpy->xdefaults)free((dpy->xdefaults)); | |||
| 663 | Xfree (dpy->error_vec)free((dpy->error_vec)); | |||
| 664 | ||||
| 665 | _XFreeExtData (dpy->ext_data); | |||
| 666 | ||||
| 667 | Xfree (dpy->free_funcs)free((dpy->free_funcs)); | |||
| 668 | Xfree (dpy->scratch_buffer)free((dpy->scratch_buffer)); | |||
| 669 | FreeDisplayLock(dpy)if (_XFreeDisplayLock_fn) (*_XFreeDisplayLock_fn)(dpy); | |||
| 670 | ||||
| 671 | if (dpy->qfree) { | |||
| 672 | register _XQEvent *qelt = dpy->qfree; | |||
| 673 | ||||
| 674 | while (qelt) { | |||
| 675 | register _XQEvent *qnxt = qelt->next; | |||
| 676 | Xfree (qelt)free((qelt)); | |||
| 677 | qelt = qnxt; | |||
| 678 | } | |||
| 679 | } | |||
| 680 | while (dpy->im_fd_info) { | |||
| 681 | struct _XConnectionInfo *conni = dpy->im_fd_info; | |||
| 682 | dpy->im_fd_info = conni->next; | |||
| 683 | Xfree (conni->watch_data)free((conni->watch_data)); | |||
| 684 | Xfree (conni)free((conni)); | |||
| 685 | } | |||
| 686 | if (dpy->conn_watchers) { | |||
| 687 | struct _XConnWatchInfo *watcher = dpy->conn_watchers; | |||
| 688 | dpy->conn_watchers = watcher->next; | |||
| 689 | Xfree (watcher)free((watcher)); | |||
| 690 | } | |||
| 691 | ||||
| 692 | Xfree (dpy->filedes)free((dpy->filedes)); | |||
| 693 | ||||
| 694 | _XFreeX11XCBStructure(dpy); | |||
| 695 | ||||
| 696 | Xfree (dpy)free((dpy)); | |||
| 697 | } | |||
| 698 | ||||
| 699 | /* OutOfMemory is called if malloc fails. XOpenDisplay returns NULL | |||
| 700 | after this returns. */ | |||
| 701 | ||||
| 702 | static void OutOfMemory(Display *dpy) | |||
| 703 | { | |||
| 704 | if(dpy->xcb->connection) | |||
| ||||
| 705 | xcb_disconnect(dpy->xcb->connection); | |||
| 706 | _XFreeDisplayStructure (dpy); | |||
| 707 | } |