Bug Summary

File:Xrandr.c
Location:line 329, column 18
Description:The left operand of '!=' is a garbage value

Annotated Source Code

1/*
2 * Copyright © 2000 Compaq Computer Corporation, Inc.
3 * Copyright © 2002 Hewlett Packard Company, Inc.
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, and that the name of Compaq or HP not be used in advertising
10 * or publicity pertaining to distribution of the software without specific,
11 * written prior permission. HP makes no representations about the
12 * suitability of this software for any purpose. It is provided "as is"
13 * without express or implied warranty.
14 *
15 * HP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL COMPAQ
17 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
19 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 *
22 * Author: Jim Gettys, HP Labs, HP.
23 */
24
25#ifdef HAVE_CONFIG_H1
26#include <config.h>
27#endif
28
29#include <stdio.h>
30#include <X11/Xlib.h>
31/* we need to be able to manipulate the Display structure on events */
32#include <X11/Xlibint.h>
33#include <X11/extensions/render.h>
34#include <X11/extensions/Xrender.h>
35#include "Xrandrint.h"
36
37static XExtensionInfo XRRExtensionInfo;
38_X_HIDDEN__attribute__((visibility("hidden"))) char XRRExtensionName[] = RANDR_NAME"RANDR";
39
40static Boolint XRRWireToEvent(Display *dpy, XEvent *event, xEvent *wire);
41static Statusint XRREventToWire(Display *dpy, XEvent *event, xEvent *wire);
42
43static int
44XRRCloseDisplay (Display *dpy, XExtCodes *codes);
45
46static /* const */ XExtensionHooks rr_extension_hooks = {
47 NULL((void*)0), /* create_gc */
48 NULL((void*)0), /* copy_gc */
49 NULL((void*)0), /* flush_gc */
50 NULL((void*)0), /* free_gc */
51 NULL((void*)0), /* create_font */
52 NULL((void*)0), /* free_font */
53 XRRCloseDisplay, /* close_display */
54 XRRWireToEvent, /* wire_to_event */
55 XRREventToWire, /* event_to_wire */
56 NULL((void*)0), /* error */
57 NULL((void*)0), /* error_string */
58};
59
60static Boolint XRRWireToEvent(Display *dpy, XEvent *event, xEvent *wire)
61{
62 XExtDisplayInfo *info = XRRFindDisplay(dpy);
63
64 RRCheckExtension(dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, XRRExtensionName); return 0; }
;
65
66 switch ((wire->u.u.type & 0x7F) - info->codes->first_event)
67 {
68 case RRScreenChangeNotify0: {
69 XRRScreenChangeNotifyEvent *aevent= (XRRScreenChangeNotifyEvent *) event;
70 xRRScreenChangeNotifyEvent *awire = (xRRScreenChangeNotifyEvent *) wire;
71 aevent->type = awire->type & 0x7F;
72 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
73 aevent->send_event = (awire->type & 0x80) != 0;
74 aevent->display = dpy;
75 aevent->window = awire->window;
76 aevent->root = awire->root;
77 aevent->timestamp = awire->timestamp;
78 aevent->config_timestamp = awire->configTimestamp;
79 aevent->size_index = awire->sizeID;
80 aevent->subpixel_order = awire->subpixelOrder;
81 aevent->rotation = awire->rotation;
82 aevent->width = awire->widthInPixels;
83 aevent->height = awire->heightInPixels;
84 aevent->mwidth = awire->widthInMillimeters;
85 aevent->mheight = awire->heightInMillimeters;
86 return True1;
87 }
88 case RRNotify1: {
89 switch (wire->u.u.detail) {
90 case RRNotify_OutputChange1: {
91 XRROutputChangeNotifyEvent *aevent = (XRROutputChangeNotifyEvent *) event;
92 xRROutputChangeNotifyEvent *awire = (xRROutputChangeNotifyEvent *) wire;
93 aevent->type = awire->type & 0x7F;
94 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
95 aevent->send_event = (awire->type & 0x80) != 0;
96 aevent->display = dpy;
97 aevent->window = awire->window;
98 aevent->subtype = awire->subCode;
99 aevent->output = awire->output;
100 aevent->crtc = awire->crtc;
101 aevent->mode = awire->mode;
102 aevent->rotation = awire->rotation;
103 aevent->connection = awire->connection;
104 aevent->subpixel_order = awire->subpixelOrder;
105 return True1;
106 }
107 case RRNotify_CrtcChange0: {
108 XRRCrtcChangeNotifyEvent *aevent = (XRRCrtcChangeNotifyEvent *) event;
109 xRRCrtcChangeNotifyEvent *awire = (xRRCrtcChangeNotifyEvent *) wire;
110 aevent->type = awire->type & 0x7F;
111 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
112 aevent->send_event = (awire->type & 0x80) != 0;
113 aevent->display = dpy;
114 aevent->window = awire->window;
115 aevent->subtype = awire->subCode;
116 aevent->crtc = awire->crtc;
117 aevent->mode = awire->mode;
118 aevent->rotation = awire->rotation;
119 aevent->x = awire->x;
120 aevent->y = awire->y;
121 aevent->width = awire->width;
122 aevent->height = awire->height;
123 return True1;
124 }
125 case RRNotify_OutputProperty2: {
126 XRROutputPropertyNotifyEvent *aevent = (XRROutputPropertyNotifyEvent *) event;
127 xRROutputPropertyNotifyEvent *awire = (xRROutputPropertyNotifyEvent *) wire;
128 aevent->type = awire->type & 0x7F;
129 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
130 aevent->send_event = (awire->type & 0x80) != 0;
131 aevent->display = dpy;
132 aevent->window = awire->window;
133 aevent->subtype = awire->subCode;
134 aevent->output = awire->output;
135 aevent->property = awire->atom;
136 aevent->timestamp = awire->timestamp;
137 aevent->state = awire->state;
138 return True1;
139 }
140 case RRNotify_ProviderChange3: {
141 XRRProviderChangeNotifyEvent *aevent = (XRRProviderChangeNotifyEvent *) event;
142 xRRProviderChangeNotifyEvent *awire = (xRRProviderChangeNotifyEvent *) wire;
143 aevent->type = awire->type & 0x7F;
144 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
145 aevent->send_event = (awire->type & 0x80) != 0;
146 aevent->display = dpy;
147 aevent->window = awire->window;
148 aevent->subtype = awire->subCode;
149 aevent->provider = awire->provider;
150 aevent->timestamp = awire->timestamp;
151 return True1;
152 }
153 case RRNotify_ProviderProperty4: {
154 XRRProviderPropertyNotifyEvent *aevent = (XRRProviderPropertyNotifyEvent *) event;
155 xRRProviderPropertyNotifyEvent *awire = (xRRProviderPropertyNotifyEvent *) wire;
156 aevent->type = awire->type & 0x7F;
157 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
158 aevent->send_event = (awire->type & 0x80) != 0;
159 aevent->display = dpy;
160 aevent->window = awire->window;
161 aevent->subtype = awire->subCode;
162 aevent->provider = awire->provider;
163 aevent->property = awire->atom;
164 aevent->timestamp = awire->timestamp;
165 aevent->state = awire->state;
166 return True1;
167 }
168 case RRNotify_ResourceChange5: {
169 XRRResourceChangeNotifyEvent *aevent = (XRRResourceChangeNotifyEvent *) event;
170 xRRResourceChangeNotifyEvent *awire = (xRRResourceChangeNotifyEvent *) wire;
171 aevent->type = awire->type & 0x7F;
172 aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
173 aevent->send_event = (awire->type & 0x80) != 0;
174 aevent->display = dpy;
175 aevent->window = awire->window;
176 aevent->subtype = awire->subCode;
177 aevent->timestamp = awire->timestamp;
178 return True1;
179 }
180 break;
181 }
182 }
183 }
184
185 return False0;
186}
187
188static Statusint XRREventToWire(Display *dpy, XEvent *event, xEvent *wire)
189{
190 XExtDisplayInfo *info = XRRFindDisplay(dpy);
191
192 RRCheckExtension(dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, XRRExtensionName); return 0; }
;
193
194 switch ((event->type & 0x7F) - info->codes->first_event)
195 {
196 case RRScreenChangeNotify0: {
197 xRRScreenChangeNotifyEvent *awire = (xRRScreenChangeNotifyEvent *) wire;
198 XRRScreenChangeNotifyEvent *aevent = (XRRScreenChangeNotifyEvent *) event;
199 awire->type = aevent->type | (aevent->send_event ? 0x80 : 0);
200 awire->rotation = (CARD8) aevent->rotation;
201 awire->sequenceNumber = aevent->serial & 0xFFFF;
202 awire->timestamp = aevent->timestamp;
203 awire->configTimestamp = aevent->config_timestamp;
204 awire->root = aevent->root;
205 awire->window = aevent->window;
206 awire->sizeID = aevent->size_index;
207 awire->subpixelOrder = aevent->subpixel_order;
208 awire->widthInPixels = aevent->width;
209 awire->heightInPixels = aevent->height;
210 awire->widthInMillimeters = aevent->mwidth;
211 awire->heightInMillimeters = aevent->mheight;
212 return True1;
213 }
214 case RRNotify1: {
215 xRRCrtcChangeNotifyEvent *awire = (xRRCrtcChangeNotifyEvent *) wire;
216 XRRNotifyEvent *aevent = (XRRNotifyEvent *) event;
217 awire->type = aevent->type | (aevent->send_event ? 0x80 : 0);
218 awire->sequenceNumber = aevent->serial & 0xFFFF;
219 awire->subCode = aevent->subtype;
220 switch (aevent->subtype) {
221 case RRNotify_OutputChange1: {
222 xRROutputChangeNotifyEvent *sawire = (xRROutputChangeNotifyEvent *) wire;
223 XRROutputChangeNotifyEvent *saevent = (XRROutputChangeNotifyEvent *) event;
224 sawire->window = saevent->window;
225 sawire->output = saevent->output;
226 sawire->crtc = saevent->crtc;
227 sawire->mode = saevent->mode;
228 sawire->rotation = saevent->rotation;
229 sawire->connection = saevent->connection;
230 sawire->subpixelOrder = saevent->subpixel_order;
231 return True1;
232 }
233 case RRNotify_CrtcChange0: {
234 xRRCrtcChangeNotifyEvent *sawire = (xRRCrtcChangeNotifyEvent *) wire;
235 XRRCrtcChangeNotifyEvent *saevent = (XRRCrtcChangeNotifyEvent *) event;
236 sawire->window = saevent->window;
237 sawire->crtc = saevent->crtc;
238 sawire->mode = saevent->mode;
239 sawire->rotation = saevent->rotation;
240 sawire->x = saevent->x;
241 sawire->y = saevent->y;
242 sawire->width = saevent->width;
243 sawire->height = saevent->height;
244 return True1;
245 }
246 case RRNotify_OutputProperty2: {
247 xRROutputPropertyNotifyEvent *sawire = (xRROutputPropertyNotifyEvent *) wire;
248 XRROutputPropertyNotifyEvent *saevent = (XRROutputPropertyNotifyEvent *) event;
249 sawire->window = saevent->window;
250 sawire->output = saevent->output;
251 sawire->atom = saevent->property;
252 sawire->timestamp = saevent->timestamp;
253 sawire->state = saevent->state;
254 return True1;
255 }
256 case RRNotify_ProviderChange3: {
257 xRRProviderChangeNotifyEvent *sawire = (xRRProviderChangeNotifyEvent *) wire;
258 XRRProviderChangeNotifyEvent *saevent = (XRRProviderChangeNotifyEvent *) event;
259 sawire->window = saevent->window;
260 sawire->provider = saevent->provider;
261 return True1;
262 }
263 case RRNotify_ProviderProperty4: {
264 xRRProviderPropertyNotifyEvent *sawire = (xRRProviderPropertyNotifyEvent *) wire;
265 XRRProviderPropertyNotifyEvent *saevent = (XRRProviderPropertyNotifyEvent *) event;
266 sawire->window = saevent->window;
267 sawire->provider = saevent->provider;
268 sawire->atom = saevent->property;
269 sawire->timestamp = saevent->timestamp;
270 sawire->state = saevent->state;
271 return True1;
272 }
273 case RRNotify_ResourceChange5: {
274 xRRResourceChangeNotifyEvent *sawire = (xRRResourceChangeNotifyEvent *) wire;
275 XRRResourceChangeNotifyEvent *saevent = (XRRResourceChangeNotifyEvent *) event;
276 sawire->window = saevent->window;
277 sawire->timestamp = saevent->timestamp;
278 return True1;
279 }
280 }
281 }
282 }
283 return False0;
284}
285
286_X_HIDDEN__attribute__((visibility("hidden"))) XExtDisplayInfo *
287XRRFindDisplay (Display *dpy)
288{
289 XExtDisplayInfo *dpyinfo;
290 XRandRInfo *xrri;
291 int i, numscreens;
292
293 dpyinfo = XextFindDisplay (&XRRExtensionInfo, dpy);
294 if (!dpyinfo) {
295 dpyinfo = XextAddDisplay (&XRRExtensionInfo, dpy,
296 XRRExtensionName,
297 &rr_extension_hooks,
298 RRNumberEvents2, NULL((void*)0));
299 numscreens = ScreenCount(dpy)(((_XPrivDisplay)(dpy))->nscreens);
300 xrri = Xmalloc (sizeof(XRandRInfo) +malloc(((sizeof(XRandRInfo) + sizeof(char *) * numscreens) ==
0 ? 1 : (sizeof(XRandRInfo) + sizeof(char *) * numscreens)))
301 sizeof(char *) * numscreens)malloc(((sizeof(XRandRInfo) + sizeof(char *) * numscreens) ==
0 ? 1 : (sizeof(XRandRInfo) + sizeof(char *) * numscreens)))
;
302 xrri->config = (XRRScreenConfiguration **)(xrri + 1);
303 for(i = 0; i < numscreens; i++)
304 xrri->config[i] = NULL((void*)0);
305 xrri->major_version = -1;
306 dpyinfo->data = (char *) xrri;
307 }
308 return dpyinfo;
309}
310
311static int
312XRRCloseDisplay (Display *dpy, XExtCodes *codes)
313{
314 int i;
315 XRRScreenConfiguration **configs;
316 XExtDisplayInfo *info = XRRFindDisplay (dpy);
317 XRandRInfo *xrri;
318
319 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
320 /*
321 * free cached data
322 */
323 if (XextHasExtension(info)((info) && ((info)->codes))) {
1
Taking true branch
324 xrri = (XRandRInfo *) info->data;
325 if (xrri) {
2
Taking true branch
326 configs = xrri->config;
327
328 for (i = 0; i < ScreenCount(dpy)(((_XPrivDisplay)(dpy))->nscreens); i++) {
3
Loop condition is true. Entering loop body
329 if (configs[i] != NULL((void*)0)) XFree (configs[i]);
4
The left operand of '!=' is a garbage value
330 }
331 XFree (xrri);
332 }
333 }
334 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
335 return XextRemoveDisplay (&XRRExtensionInfo, dpy);
336}
337
338int XRRRootToScreen(Display *dpy, Window root)
339{
340 int snum;
341 for (snum = 0; snum < ScreenCount(dpy)(((_XPrivDisplay)(dpy))->nscreens); snum++) {
342 if (RootWindow(dpy, snum)((&((_XPrivDisplay)(dpy))->screens[snum])->root) == root) return snum;
343 }
344 return -1;
345}
346
347
348Boolint XRRQueryExtension (Display *dpy,
349 int *event_base_return,
350 int *error_base_return)
351{
352 XExtDisplayInfo *info = XRRFindDisplay (dpy);
353
354 if (XextHasExtension(info)((info) && ((info)->codes))) {
355 *event_base_return = info->codes->first_event;
356 *error_base_return = info->codes->first_error;
357 return True1;
358 } else {
359 return False0;
360 }
361}
362
363_X_HIDDEN__attribute__((visibility("hidden"))) Boolint
364_XRRHasRates (int major, int minor)
365{
366 return major > 1 || (major == 1 && minor >= 1);
367}
368
369Statusint XRRQueryVersion (Display *dpy,
370 int *major_versionp,
371 int *minor_versionp)
372{
373 XExtDisplayInfo *info = XRRFindDisplay (dpy);
374 xRRQueryVersionReply rep;
375 xRRQueryVersionReq *req;
376 XRandRInfo *xrri;
377
378 RRCheckExtension (dpy, info, 0)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, XRRExtensionName); return 0; }
;
379
380 xrri = (XRandRInfo *) info->data;
381
382 /*
383 * only get the version information from the server if we don't have it already
384 */
385 if (xrri->major_version == -1) {
386 LockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
387 GetReq (RRQueryVersion, req)req = (xRRQueryVersionReq *) _XGetRequest(dpy, 0, 12);
388 req->reqType = info->codes->major_opcode;
389 req->randrReqType = X_RRQueryVersion0;
390 req->majorVersion = RANDR_MAJOR1;
391 req->minorVersion = RANDR_MINOR5;
392 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue1)) {
393 UnlockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
394 SyncHandle ()if (dpy->synchandler) (*dpy->synchandler)(dpy);
395 return 0;
396 }
397 xrri->major_version = rep.majorVersion;
398 xrri->minor_version = rep.minorVersion;
399 xrri->has_rates = _XRRHasRates (xrri->major_version, xrri->minor_version);
400 UnlockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
401 SyncHandle ()if (dpy->synchandler) (*dpy->synchandler)(dpy);
402 }
403 *major_versionp = xrri->major_version;
404 *minor_versionp = xrri->minor_version;
405 return 1;
406}
407
408_X_HIDDEN__attribute__((visibility("hidden"))) Boolint
409_XRRVersionHandler (Display *dpy,
410 xReply *rep,
411 char *buf,
412 int len,
413 XPointer data)
414{
415 xRRQueryVersionReply replbuf;
416 xRRQueryVersionReply *repl;
417 _XRRVersionState *state = (_XRRVersionState *) data;
418
419 if (dpy->last_request_read != state->version_seq)
420 return False0;
421 if (rep->generic.type == X_Error0)
422 {
423 state->error = True1;
424 return False0;
425 }
426 repl = (xRRQueryVersionReply *)
427 _XGetAsyncReply(dpy, (char *)&replbuf, rep, buf, len,
428 (SIZEOF(xRRQueryVersionReply)32 - SIZEOF(xReply)32) >> 2,
429 True1);
430 state->major_version = repl->majorVersion;
431 state->minor_version = repl->minorVersion;
432 return True1;
433}
434
435/*
436 * in protocol version 0.1, routine added to allow selecting for new events.
437 */
438
439void XRRSelectInput (Display *dpy, Window window, int mask)
440{
441 XExtDisplayInfo *info = XRRFindDisplay (dpy);
442 xRRSelectInputReq *req;
443
444 RRSimpleCheckExtension (dpy, info)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, XRRExtensionName); return; }
;
445
446 LockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
447 GetReq (RRSelectInput, req)req = (xRRSelectInputReq *) _XGetRequest(dpy, 4, 12);
448 req->reqType = info->codes->major_opcode;
449 req->randrReqType = X_RRSelectInput4;
450 req->window = window;
451 req->enable = 0;
452 if (mask) req->enable = mask;
453 UnlockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
454 SyncHandle ()if (dpy->synchandler) (*dpy->synchandler)(dpy);
455 return;
456}
457
458int XRRUpdateConfiguration(XEvent *event)
459{
460 XRRScreenChangeNotifyEvent *scevent;
461 XConfigureEvent *rcevent;
462 Display *dpy = event->xany.display;
463 XExtDisplayInfo *info;
464 XRandRInfo *xrri;
465 int snum;
466
467 /* first, see if it is a vanilla configure notify event */
468 if (event->type == ConfigureNotify22) {
469 rcevent = (XConfigureEvent *) event;
470 snum = XRRRootToScreen(dpy, rcevent->window);
471 if (snum != -1) {
472 dpy->screens[snum].width = rcevent->width;
473 dpy->screens[snum].height = rcevent->height;
474 return 1;
475 }
476 }
477
478 info = XRRFindDisplay(dpy);
479 RRCheckExtension (dpy, info, 0)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, XRRExtensionName); return 0; }
;
480
481 switch (event->type - info->codes->first_event) {
482 case RRScreenChangeNotify0:
483 scevent = (XRRScreenChangeNotifyEvent *) event;
484 snum = XRRRootToScreen(dpy,
485 ((XRRScreenChangeNotifyEvent *) event)->root);
486 if (snum < 0)
487 return 0;
488
489 if (scevent->rotation & (RR_Rotate_902 | RR_Rotate_2708)) {
490 dpy->screens[snum].width = scevent->height;
491 dpy->screens[snum].height = scevent->width;
492 dpy->screens[snum].mwidth = scevent->mheight;
493 dpy->screens[snum].mheight = scevent->mwidth;
494 } else {
495 dpy->screens[snum].width = scevent->width;
496 dpy->screens[snum].height = scevent->height;
497 dpy->screens[snum].mwidth = scevent->mwidth;
498 dpy->screens[snum].mheight = scevent->mheight;
499 }
500 XRenderSetSubpixelOrder (dpy, snum, scevent->subpixel_order);
501 break;
502 default:
503 return 0;
504 }
505 xrri = (XRandRInfo *) info->data;
506 /*
507 * so the next time someone wants some data, it will be fetched;
508 * it might be better to force the round trip immediately, but
509 * I dislike pounding the server simultaneously when not necessary
510 */
511 if (xrri->config[snum] != NULL((void*)0)) {
512 XFree (xrri->config[snum]);
513 xrri->config[snum] = NULL((void*)0);
514 }
515 return 1;
516}