Bug Summary

File:XF86VMode.c
Location:line 677, column 9
Description:The left operand of '<' is a garbage value

Annotated Source Code

1/*
2
3Copyright (c) 1995 Kaleb S. KEITHLEY
4
5Permission is hereby granted, free of charge, to any person obtaining
6a copy of this software and associated documentation files (the
7"Software"), to deal in the Software without restriction, including
8without limitation the rights to use, copy, modify, merge, publish,
9distribute, sublicense, and/or sell copies of the Software, and to
10permit persons to whom the Software is furnished to do so, subject to
11the following conditions:
12
13The above copyright notice and this permission notice shall be
14included in all copies or substantial portions of the Software.
15
16THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES
20OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22OTHER DEALINGS IN THE SOFTWARE.
23
24Except as contained in this notice, the name of Kaleb S. KEITHLEY
25shall not be used in advertising or otherwise to promote the sale, use
26or other dealings in this Software without prior written authorization
27from Kaleb S. KEITHLEY.
28
29*/
30
31/* THIS IS NOT AN X CONSORTIUM STANDARD */
32
33#ifdef HAVE_CONFIG_H1
34#include <config.h>
35#endif
36
37#include <X11/Xlibint.h>
38#include <X11/extensions/xf86vmproto.h>
39#include <X11/extensions/xf86vmode.h>
40#include <X11/extensions/Xext.h>
41#include <X11/extensions/extutil.h>
42#include <limits.h>
43
44#ifdef DEBUG
45#include <stdio.h>
46#endif
47
48#ifndef MODE_BAD255
49#define MODE_BAD255 255
50#endif
51
52static XExtensionInfo _xf86vidmode_info_data;
53static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
54static const char *xf86vidmode_extension_name = XF86VIDMODENAME"XFree86-VidModeExtension";
55
56#define XF86VidModeCheckExtension(dpy,i,val)if (!((i) && ((i)->codes))) { XMissingExtension (dpy
, xf86vidmode_extension_name); return val; }
\
57 XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)if (!((i) && ((i)->codes))) { XMissingExtension (dpy
, xf86vidmode_extension_name); return val; }
58
59/*****************************************************************************
60 * *
61 * private utility routines *
62 * *
63 *****************************************************************************/
64
65static XEXT_CLOSE_DISPLAY_PROTO(close_display)int close_display(Display *dpy, XExtCodes *codes);
66static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
67 NULL((void*)0), /* create_gc */
68 NULL((void*)0), /* copy_gc */
69 NULL((void*)0), /* flush_gc */
70 NULL((void*)0), /* free_gc */
71 NULL((void*)0), /* create_font */
72 NULL((void*)0), /* free_font */
73 close_display, /* close_display */
74 NULL((void*)0), /* wire_to_event */
75 NULL((void*)0), /* event_to_wire */
76 NULL((void*)0), /* error */
77 NULL((void*)0), /* error_string */
78};
79
80static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info,XExtDisplayInfo *find_display (Display *dpy) { XExtDisplayInfo
*dpyinfo; if (!xf86vidmode_info) { if (!(xf86vidmode_info = XextCreateExtension
())) return ((void*)0); } if (!(dpyinfo = XextFindDisplay (xf86vidmode_info
, dpy))) dpyinfo = XextAddDisplay (xf86vidmode_info,dpy,xf86vidmode_extension_name
,&xf86vidmode_extension_hooks,0,((void*)0)); return dpyinfo
; }
4
Within the expansion of the macro 'XEXT_GENERATE_FIND_DISPLAY':
a
Assuming 'dpyinfo' is not null
81 xf86vidmode_extension_name,XExtDisplayInfo *find_display (Display *dpy) { XExtDisplayInfo
*dpyinfo; if (!xf86vidmode_info) { if (!(xf86vidmode_info = XextCreateExtension
())) return ((void*)0); } if (!(dpyinfo = XextFindDisplay (xf86vidmode_info
, dpy))) dpyinfo = XextAddDisplay (xf86vidmode_info,dpy,xf86vidmode_extension_name
,&xf86vidmode_extension_hooks,0,((void*)0)); return dpyinfo
; }
82 &xf86vidmode_extension_hooks,XExtDisplayInfo *find_display (Display *dpy) { XExtDisplayInfo
*dpyinfo; if (!xf86vidmode_info) { if (!(xf86vidmode_info = XextCreateExtension
())) return ((void*)0); } if (!(dpyinfo = XextFindDisplay (xf86vidmode_info
, dpy))) dpyinfo = XextAddDisplay (xf86vidmode_info,dpy,xf86vidmode_extension_name
,&xf86vidmode_extension_hooks,0,((void*)0)); return dpyinfo
; }
83 0, NULL)XExtDisplayInfo *find_display (Display *dpy) { XExtDisplayInfo
*dpyinfo; if (!xf86vidmode_info) { if (!(xf86vidmode_info = XextCreateExtension
())) return ((void*)0); } if (!(dpyinfo = XextFindDisplay (xf86vidmode_info
, dpy))) dpyinfo = XextAddDisplay (xf86vidmode_info,dpy,xf86vidmode_extension_name
,&xf86vidmode_extension_hooks,0,((void*)0)); return dpyinfo
; }
84
85static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)int close_display (Display *dpy, XExtCodes *codes) { return XextRemoveDisplay
(xf86vidmode_info, dpy); }
86
87
88/*****************************************************************************
89 * *
90 * public XFree86-VidMode Extension routines *
91 * *
92 *****************************************************************************/
93
94Boolint
95XF86VidModeQueryExtension(Display *dpy, int *event_basep, int *error_basep)
96{
97 XExtDisplayInfo *info = find_display (dpy);
98
99 if (XextHasExtension(info)((info) && ((info)->codes))) {
100 *event_basep = info->codes->first_event;
101 *error_basep = info->codes->first_error;
102 return True1;
103 } else {
104 return False0;
105 }
106}
107
108Boolint
109XF86VidModeQueryVersion(Display* dpy, int* majorVersion, int* minorVersion)
110{
111 XExtDisplayInfo *info = find_display (dpy);
3
Calling 'find_display'
5
Returning from 'find_display'
112 xXF86VidModeQueryVersionReply rep;
113 xXF86VidModeQueryVersionReq *req;
114
115 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
6
Within the expansion of the macro 'XF86VidModeCheckExtension':
116
117 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
118 GetReq(XF86VidModeQueryVersion, req)req = (xXF86VidModeQueryVersionReq *) _XGetRequest(dpy, 0, 4);
119 req->reqType = info->codes->major_opcode;
120 req->xf86vidmodeReqType = X_XF86VidModeQueryVersion0;
121 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse0)) {
122 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
123 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
124 return False0;
125 }
126 *majorVersion = rep.majorVersion;
127 *minorVersion = rep.minorVersion;
128 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
129 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
130 if (*majorVersion >= 2)
131 XF86VidModeSetClientVersion(dpy);
132 return True1;
133}
134
135Boolint
136XF86VidModeSetClientVersion(Display *dpy)
137{
138 XExtDisplayInfo *info = find_display(dpy);
139 xXF86VidModeSetClientVersionReq *req;
140
141 XF86VidModeCheckExtension(dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
142
143 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
144 GetReq(XF86VidModeSetClientVersion, req)req = (xXF86VidModeSetClientVersionReq *) _XGetRequest(dpy, 14
, 8)
;
145 req->reqType = info->codes->major_opcode;
146 req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion14;
147 req->major = XF86VIDMODE_MAJOR_VERSION2;
148 req->minor = XF86VIDMODE_MINOR_VERSION2;
149 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
150 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
151 return True1;
152}
153
154Boolint
155XF86VidModeSetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
156{
157 XExtDisplayInfo *info = find_display(dpy);
158 xXF86VidModeSetGammaReq *req;
159
160 XF86VidModeCheckExtension(dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
161
162 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
163 GetReq(XF86VidModeSetGamma, req)req = (xXF86VidModeSetGammaReq *) _XGetRequest(dpy, 15, 32);
164 req->reqType = info->codes->major_opcode;
165 req->xf86vidmodeReqType = X_XF86VidModeSetGamma15;
166 req->screen = screen;
167 req->red = (CARD32)(Gamma->red * 10000.);
168 req->green = (CARD32)(Gamma->green * 10000.);
169 req->blue = (CARD32)(Gamma->blue * 10000.);
170 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
171 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
172 return True1;
173}
174
175Boolint
176XF86VidModeGetGamma(Display *dpy, int screen, XF86VidModeGamma *Gamma)
177{
178 XExtDisplayInfo *info = find_display (dpy);
179 xXF86VidModeGetGammaReply rep;
180 xXF86VidModeGetGammaReq *req;
181
182 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
183
184 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
185 GetReq(XF86VidModeGetGamma, req)req = (xXF86VidModeGetGammaReq *) _XGetRequest(dpy, 16, 32);
186 req->reqType = info->codes->major_opcode;
187 req->xf86vidmodeReqType = X_XF86VidModeGetGamma16;
188 req->screen = screen;
189 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse0)) {
190 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
191 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
192 return False0;
193 }
194 Gamma->red = ((float)rep.red) / 10000.;
195 Gamma->green = ((float)rep.green) / 10000.;
196 Gamma->blue = ((float)rep.blue) / 10000.;
197 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
198 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
199 return True1;
200}
201
202Boolint
203XF86VidModeGetModeLine(Display* dpy, int screen, int* dotclock,
204 XF86VidModeModeLine* modeline)
205{
206 XExtDisplayInfo *info = find_display (dpy);
207 xXF86VidModeGetModeLineReq *req;
208 int majorVersion, minorVersion;
209 CARD32 remaining_len;
210 Boolint result = True1;
211
212 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
213 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
214
215 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
216 GetReq(XF86VidModeGetModeLine, req)req = (xXF86VidModeGetModeLineReq *) _XGetRequest(dpy, 1, 8);
217 req->reqType = info->codes->major_opcode;
218 req->xf86vidmodeReqType = X_XF86VidModeGetModeLine1;
219 req->screen = screen;
220
221 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
222 xXF86OldVidModeGetModeLineReply oldrep;
223
224 if (!_XReply(dpy, (xReply *)&oldrep,
225 (SIZEOF(xXF86OldVidModeGetModeLineReply)36 - SIZEOF(xReply)32) >> 2, xFalse0)) {
226 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
227 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
228 return False0;
229 }
230 remaining_len = oldrep.length -
231 ((SIZEOF(xXF86OldVidModeGetModeLineReply)36 - SIZEOF(xReply)32) >> 2);
232 *dotclock = oldrep.dotclock;
233 modeline->hdisplay = oldrep.hdisplay;
234 modeline->hsyncstart = oldrep.hsyncstart;
235 modeline->hsyncend = oldrep.hsyncend;
236 modeline->htotal = oldrep.htotal;
237 modeline->hskew = 0;
238 modeline->vdisplay = oldrep.vdisplay;
239 modeline->vsyncstart = oldrep.vsyncstart;
240 modeline->vsyncend = oldrep.vsyncend;
241 modeline->vtotal = oldrep.vtotal;
242 modeline->flags = oldrep.flags;
243 modeline->privsize = oldrep.privsize;
244 } else {
245 xXF86VidModeGetModeLineReply rep;
246
247 if (!_XReply(dpy, (xReply *)&rep,
248 (SIZEOF(xXF86VidModeGetModeLineReply)52 - SIZEOF(xReply)32) >> 2, xFalse0)) {
249 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
250 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
251 return False0;
252 }
253 remaining_len = rep.length -
254 ((SIZEOF(xXF86VidModeGetModeLineReply)52 - SIZEOF(xReply)32) >> 2);
255 *dotclock = rep.dotclock;
256 modeline->hdisplay = rep.hdisplay;
257 modeline->hsyncstart = rep.hsyncstart;
258 modeline->hsyncend = rep.hsyncend;
259 modeline->htotal = rep.htotal;
260 modeline->hskew = rep.hskew;
261 modeline->vdisplay = rep.vdisplay;
262 modeline->vsyncstart = rep.vsyncstart;
263 modeline->vsyncend = rep.vsyncend;
264 modeline->vtotal = rep.vtotal;
265 modeline->flags = rep.flags;
266 modeline->privsize = rep.privsize;
267 }
268
269 if (modeline->privsize > 0) {
270 if (modeline->privsize < (INT_MAX2147483647 / sizeof(INT32)))
271 modeline->private = Xcalloc(modeline->privsize, sizeof(INT32))calloc(((modeline->privsize) == 0 ? 1 : (modeline->privsize
)), (sizeof(INT32)))
;
272 else
273 modeline->private = NULL((void*)0);
274 if (modeline->private == NULL((void*)0)) {
275 _XEatDataWords(dpy, remaining_len);
276 result = False0;
277 } else
278 _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
279 } else {
280 modeline->private = NULL((void*)0);
281 }
282 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
283 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
284 return result;
285}
286
287Boolint
288XF86VidModeGetAllModeLines(Display* dpy, int screen, int* modecount,
289 XF86VidModeModeInfo ***modelinesPtr)
290{
291 XExtDisplayInfo *info = find_display (dpy);
292 xXF86VidModeGetAllModeLinesReply rep;
293 xXF86VidModeGetAllModeLinesReq *req;
294 XF86VidModeModeInfo *mdinfptr, **modelines;
295 xXF86VidModeModeInfo xmdline;
296 xXF86OldVidModeModeInfo oldxmdline;
297 unsigned int i;
298 int majorVersion, minorVersion;
299 Boolint protocolBug = False0;
300
301 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
302
303 /*
304 * Note: There was a bug in the protocol implementation in versions
305 * 0.x with x < 8 (the .private field wasn't being passed over the wire).
306 * Check the server's version, and accept the old format if appropriate.
307 */
308
309 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
310 if (majorVersion == 0 && minorVersion < 8) {
311 protocolBug = True1;
312#ifdef DEBUG
313 fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
314 "running an old version (%d.%d)\n", majorVersion,
315 minorVersion);
316#endif
317 }
318
319 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
320 GetReq(XF86VidModeGetAllModeLines, req)req = (xXF86VidModeGetAllModeLinesReq *) _XGetRequest(dpy, 6,
8)
;
321 req->reqType = info->codes->major_opcode;
322 req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines6;
323 req->screen = screen;
324 if (!_XReply(dpy, (xReply *)&rep,
325 (SIZEOF(xXF86VidModeGetAllModeLinesReply)32 - SIZEOF(xReply)32) >> 2, xFalse0)) {
326 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
327 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
328 return False0;
329 }
330
331 *modecount = rep.modecount;
332
333 if (!(modelines = (XF86VidModeModeInfo **) Xcalloc(rep.modecount,calloc(((rep.modecount) == 0 ? 1 : (rep.modecount)), (sizeof(
XF86VidModeModeInfo *) +sizeof(XF86VidModeModeInfo)))
334 sizeof(XF86VidModeModeInfo *)calloc(((rep.modecount) == 0 ? 1 : (rep.modecount)), (sizeof(
XF86VidModeModeInfo *) +sizeof(XF86VidModeModeInfo)))
335 +sizeof(XF86VidModeModeInfo))calloc(((rep.modecount) == 0 ? 1 : (rep.modecount)), (sizeof(
XF86VidModeModeInfo *) +sizeof(XF86VidModeModeInfo)))
)) {
336 _XEatDataWords(dpy, rep.length -
337 ((SIZEOF(xXF86VidModeGetAllModeLinesReply)32 - SIZEOF(xReply)32) >> 2));
338 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
339 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
340 return False0;
341 }
342 mdinfptr = (XF86VidModeModeInfo *) (
343 (char *) modelines
344 + rep.modecount*sizeof(XF86VidModeModeInfo *)
345 );
346
347 for (i = 0; i < rep.modecount; i++) {
348 modelines[i] = mdinfptr++;
349 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
350 _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
351 modelines[i]->dotclock = oldxmdline.dotclock;
352 modelines[i]->hdisplay = oldxmdline.hdisplay;
353 modelines[i]->hsyncstart = oldxmdline.hsyncstart;
354 modelines[i]->hsyncend = oldxmdline.hsyncend;
355 modelines[i]->htotal = oldxmdline.htotal;
356 modelines[i]->hskew = 0;
357 modelines[i]->vdisplay = oldxmdline.vdisplay;
358 modelines[i]->vsyncstart = oldxmdline.vsyncstart;
359 modelines[i]->vsyncend = oldxmdline.vsyncend;
360 modelines[i]->vtotal = oldxmdline.vtotal;
361 modelines[i]->flags = oldxmdline.flags;
362 if (protocolBug) {
363 modelines[i]->privsize = 0;
364 modelines[i]->private = NULL((void*)0);
365 } else {
366 modelines[i]->privsize = oldxmdline.privsize;
367 if (oldxmdline.privsize > 0) {
368 if (!(modelines[i]->private =
369 Xcalloc(oldxmdline.privsize, sizeof(INT32))calloc(((oldxmdline.privsize) == 0 ? 1 : (oldxmdline.privsize
)), (sizeof(INT32)))
)) {
370 _XEatDataWords(dpy, oldxmdline.privsize);
371 } else {
372 _XRead(dpy, (char*)modelines[i]->private,
373 oldxmdline.privsize * sizeof(INT32));
374 }
375 } else {
376 modelines[i]->private = NULL((void*)0);
377 }
378 }
379 } else {
380 _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
381 modelines[i]->dotclock = xmdline.dotclock;
382 modelines[i]->hdisplay = xmdline.hdisplay;
383 modelines[i]->hsyncstart = xmdline.hsyncstart;
384 modelines[i]->hsyncend = xmdline.hsyncend;
385 modelines[i]->htotal = xmdline.htotal;
386 modelines[i]->hskew = xmdline.hskew;
387 modelines[i]->vdisplay = xmdline.vdisplay;
388 modelines[i]->vsyncstart = xmdline.vsyncstart;
389 modelines[i]->vsyncend = xmdline.vsyncend;
390 modelines[i]->vtotal = xmdline.vtotal;
391 modelines[i]->flags = xmdline.flags;
392 if (protocolBug) {
393 modelines[i]->privsize = 0;
394 modelines[i]->private = NULL((void*)0);
395 } else {
396 modelines[i]->privsize = xmdline.privsize;
397 if (xmdline.privsize > 0) {
398 if (!(modelines[i]->private =
399 Xcalloc(xmdline.privsize, sizeof(INT32))calloc(((xmdline.privsize) == 0 ? 1 : (xmdline.privsize)), (sizeof
(INT32)))
)) {
400 _XEatDataWords(dpy, xmdline.privsize);
401 } else {
402 _XRead(dpy, (char*)modelines[i]->private,
403 xmdline.privsize * sizeof(INT32));
404 }
405 } else {
406 modelines[i]->private = NULL((void*)0);
407 }
408 }
409 }
410 }
411 *modelinesPtr = modelines;
412 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
413 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
414 return True1;
415}
416
417/*
418 * GetReq replacement for use with VidMode protocols earlier than 2.0
419 */
420#define GetOldReq(name, oldname, req)if ((dpy->bufptr + sz_xoldnameReq) > dpy->bufmax) _XFlush
(dpy); req = (xoldnameReq *)(dpy->last_req = dpy->bufptr
); req->reqType = X_name; req->length = (sz_xoldnameReq
)>>2; dpy->bufptr += sz_xoldnameReq; dpy->request
++
\
421 WORD64ALIGN\
422 if ((dpy->bufptr + SIZEOF(x##oldname##Req)sz_x##oldname##Req) > dpy->bufmax)\
423 _XFlush(dpy);\
424 req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);\
425 req->reqType = X_##name;\
426 req->length = (SIZEOF(x##oldname##Req)sz_x##oldname##Req)>>2;\
427 dpy->bufptr += SIZEOF(x##oldname##Req)sz_x##oldname##Req;\
428 dpy->request++
429
430Boolint
431XF86VidModeAddModeLine(Display *dpy, int screen,
432 XF86VidModeModeInfo* newmodeline,
433 XF86VidModeModeInfo* aftermodeline)
434{
435 XExtDisplayInfo *info = find_display (dpy);
436 xXF86VidModeAddModeLineReq *req;
437 xXF86OldVidModeAddModeLineReq *oldreq;
438 int majorVersion, minorVersion;
439
440 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
441 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
442
443 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
444 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
445 GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq)if ((dpy->bufptr + 60) > dpy->bufmax) _XFlush(dpy); oldreq
= (xXF86OldVidModeAddModeLineReq *)(dpy->last_req = dpy->
bufptr); oldreq->reqType = 7; oldreq->length = (60)>>
2; dpy->bufptr += 60; dpy->request++
;
446 oldreq->reqType = info->codes->major_opcode;
447 oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine7;
448 oldreq->screen = screen;
449 oldreq->dotclock = newmodeline->dotclock;
450 oldreq->hdisplay = newmodeline->hdisplay;
451 oldreq->hsyncstart = newmodeline->hsyncstart;
452 oldreq->hsyncend = newmodeline->hsyncend;
453 oldreq->htotal = newmodeline->htotal;
454 oldreq->vdisplay = newmodeline->vdisplay;
455 oldreq->vsyncstart = newmodeline->vsyncstart;
456 oldreq->vsyncend = newmodeline->vsyncend;
457 oldreq->vtotal = newmodeline->vtotal;
458 oldreq->flags = newmodeline->flags;
459 oldreq->privsize = newmodeline->privsize;
460 if (aftermodeline != NULL((void*)0)) {
461 oldreq->after_dotclock = aftermodeline->dotclock;
462 oldreq->after_hdisplay = aftermodeline->hdisplay;
463 oldreq->after_hsyncstart = aftermodeline->hsyncstart;
464 oldreq->after_hsyncend = aftermodeline->hsyncend;
465 oldreq->after_htotal = aftermodeline->htotal;
466 oldreq->after_vdisplay = aftermodeline->vdisplay;
467 oldreq->after_vsyncstart = aftermodeline->vsyncstart;
468 oldreq->after_vsyncend = aftermodeline->vsyncend;
469 oldreq->after_vtotal = aftermodeline->vtotal;
470 oldreq->after_flags = aftermodeline->flags;
471 } else {
472 oldreq->after_dotclock = 0;
473 oldreq->after_hdisplay = 0;
474 oldreq->after_hsyncstart = 0;
475 oldreq->after_hsyncend = 0;
476 oldreq->after_htotal = 0;
477 oldreq->after_vdisplay = 0;
478 oldreq->after_vsyncstart = 0;
479 oldreq->after_vsyncend = 0;
480 oldreq->after_vtotal = 0;
481 oldreq->after_flags = 0;
482 }
483 if (newmodeline->privsize) {
484 oldreq->length += newmodeline->privsize;
485 Data32(dpy, (long *) newmodeline->private,_XData32(dpy, (const long *)(long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32))
486 newmodeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32))
;
487 }
488 } else {
489 GetReq(XF86VidModeAddModeLine, req)req = (xXF86VidModeAddModeLineReq *) _XGetRequest(dpy, 7, 92);
490 req->reqType = info->codes->major_opcode;
491 req->xf86vidmodeReqType = X_XF86VidModeAddModeLine7;
492 req->screen = screen;
493 req->dotclock = newmodeline->dotclock;
494 req->hdisplay = newmodeline->hdisplay;
495 req->hsyncstart = newmodeline->hsyncstart;
496 req->hsyncend = newmodeline->hsyncend;
497 req->htotal = newmodeline->htotal;
498 req->hskew = newmodeline->hskew;
499 req->vdisplay = newmodeline->vdisplay;
500 req->vsyncstart = newmodeline->vsyncstart;
501 req->vsyncend = newmodeline->vsyncend;
502 req->vtotal = newmodeline->vtotal;
503 req->flags = newmodeline->flags;
504 req->privsize = newmodeline->privsize;
505 if (aftermodeline != NULL((void*)0)) {
506 req->after_dotclock = aftermodeline->dotclock;
507 req->after_hdisplay = aftermodeline->hdisplay;
508 req->after_hsyncstart = aftermodeline->hsyncstart;
509 req->after_hsyncend = aftermodeline->hsyncend;
510 req->after_htotal = aftermodeline->htotal;
511 req->after_hskew = aftermodeline->hskew;
512 req->after_vdisplay = aftermodeline->vdisplay;
513 req->after_vsyncstart = aftermodeline->vsyncstart;
514 req->after_vsyncend = aftermodeline->vsyncend;
515 req->after_vtotal = aftermodeline->vtotal;
516 req->after_flags = aftermodeline->flags;
517 } else {
518 req->after_dotclock = 0;
519 req->after_hdisplay = 0;
520 req->after_hsyncstart = 0;
521 req->after_hsyncend = 0;
522 req->after_htotal = 0;
523 req->after_hskew = 0;
524 req->after_vdisplay = 0;
525 req->after_vsyncstart = 0;
526 req->after_vsyncend = 0;
527 req->after_vtotal = 0;
528 req->after_flags = 0;
529 }
530 if (newmodeline->privsize) {
531 req->length += newmodeline->privsize;
532 Data32(dpy, (long *) newmodeline->private,_XData32(dpy, (const long *)(long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32))
533 newmodeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) newmodeline->private,
newmodeline->privsize * sizeof(INT32))
;
534 }
535 }
536 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
537 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
538 return True1;
539}
540
541Boolint
542XF86VidModeDeleteModeLine(Display *dpy, int screen,
543 XF86VidModeModeInfo* modeline)
544{
545 XExtDisplayInfo *info = find_display (dpy);
546 xXF86VidModeDeleteModeLineReq *req;
547 xXF86OldVidModeDeleteModeLineReq *oldreq;
548 int majorVersion, minorVersion;
549
550 XF86VidModeCheckExtension (dpy, info, 0)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
551 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
552
553 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
554 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
555 GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq)if ((dpy->bufptr + 36) > dpy->bufmax) _XFlush(dpy); oldreq
= (xXF86OldVidModeDeleteModeLineReq *)(dpy->last_req = dpy
->bufptr); oldreq->reqType = 8; oldreq->length = (36
)>>2; dpy->bufptr += 36; dpy->request++
;
556 oldreq->reqType = info->codes->major_opcode;
557 oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine8;
558 oldreq->screen = screen;
559 oldreq->dotclock = modeline->dotclock;
560 oldreq->hdisplay = modeline->hdisplay;
561 oldreq->hsyncstart = modeline->hsyncstart;
562 oldreq->hsyncend = modeline->hsyncend;
563 oldreq->htotal = modeline->htotal;
564 oldreq->vdisplay = modeline->vdisplay;
565 oldreq->vsyncstart = modeline->vsyncstart;
566 oldreq->vsyncend = modeline->vsyncend;
567 oldreq->vtotal = modeline->vtotal;
568 oldreq->flags = modeline->flags;
569 oldreq->privsize = modeline->privsize;
570 if (modeline->privsize) {
571 oldreq->length += modeline->privsize;
572 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
573 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
574 }
575 } else {
576 GetReq(XF86VidModeDeleteModeLine, req)req = (xXF86VidModeDeleteModeLineReq *) _XGetRequest(dpy, 8, 52
)
;
577 req->reqType = info->codes->major_opcode;
578 req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine8;
579 req->screen = screen;
580 req->dotclock = modeline->dotclock;
581 req->hdisplay = modeline->hdisplay;
582 req->hsyncstart = modeline->hsyncstart;
583 req->hsyncend = modeline->hsyncend;
584 req->htotal = modeline->htotal;
585 req->hskew = modeline->hskew;
586 req->vdisplay = modeline->vdisplay;
587 req->vsyncstart = modeline->vsyncstart;
588 req->vsyncend = modeline->vsyncend;
589 req->vtotal = modeline->vtotal;
590 req->flags = modeline->flags;
591 req->privsize = modeline->privsize;
592 if (modeline->privsize) {
593 req->length += modeline->privsize;
594 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
595 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
596 }
597 }
598 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
599 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
600 return True1;
601}
602
603Boolint
604XF86VidModeModModeLine(Display *dpy, int screen, XF86VidModeModeLine* modeline)
605{
606 XExtDisplayInfo *info = find_display (dpy);
607 xXF86VidModeModModeLineReq *req;
608 xXF86OldVidModeModModeLineReq *oldreq;
609 int majorVersion, minorVersion;
610
611 XF86VidModeCheckExtension (dpy, info, 0)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
612 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
613
614 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
615 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
616 GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq)if ((dpy->bufptr + 32) > dpy->bufmax) _XFlush(dpy); oldreq
= (xXF86OldVidModeModModeLineReq *)(dpy->last_req = dpy->
bufptr); oldreq->reqType = 2; oldreq->length = (32)>>
2; dpy->bufptr += 32; dpy->request++
;
617 oldreq->reqType = info->codes->major_opcode;
618 oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine2;
619 oldreq->screen = screen;
620 oldreq->hdisplay = modeline->hdisplay;
621 oldreq->hsyncstart = modeline->hsyncstart;
622 oldreq->hsyncend = modeline->hsyncend;
623 oldreq->htotal = modeline->htotal;
624 oldreq->vdisplay = modeline->vdisplay;
625 oldreq->vsyncstart = modeline->vsyncstart;
626 oldreq->vsyncend = modeline->vsyncend;
627 oldreq->vtotal = modeline->vtotal;
628 oldreq->flags = modeline->flags;
629 oldreq->privsize = modeline->privsize;
630 if (modeline->privsize) {
631 oldreq->length += modeline->privsize;
632 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
633 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
634 }
635 } else {
636 GetReq(XF86VidModeModModeLine, req)req = (xXF86VidModeModModeLineReq *) _XGetRequest(dpy, 2, 48);
637 req->reqType = info->codes->major_opcode;
638 req->xf86vidmodeReqType = X_XF86VidModeModModeLine2;
639 req->screen = screen;
640 req->hdisplay = modeline->hdisplay;
641 req->hsyncstart = modeline->hsyncstart;
642 req->hsyncend = modeline->hsyncend;
643 req->htotal = modeline->htotal;
644 req->hskew = modeline->hskew;
645 req->vdisplay = modeline->vdisplay;
646 req->vsyncstart = modeline->vsyncstart;
647 req->vsyncend = modeline->vsyncend;
648 req->vtotal = modeline->vtotal;
649 req->flags = modeline->flags;
650 req->privsize = modeline->privsize;
651 if (modeline->privsize) {
652 req->length += modeline->privsize;
653 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
654 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
655 }
656 }
657 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
658 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
659 return True1;
660}
661
662Statusint
663XF86VidModeValidateModeLine(Display *dpy, int screen,
664 XF86VidModeModeInfo* modeline)
665{
666 XExtDisplayInfo *info = find_display (dpy);
667 xXF86VidModeValidateModeLineReq *req;
668 xXF86OldVidModeValidateModeLineReq *oldreq;
669 xXF86VidModeValidateModeLineReply rep;
670 int majorVersion, minorVersion;
1
'majorVersion' declared without an initial value
671
672 XF86VidModeCheckExtension (dpy, info, 0)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
673 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
2
Calling 'XF86VidModeQueryVersion'
7
Returning from 'XF86VidModeQueryVersion'
674
675 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
676
677 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
8
Within the expansion of the macro '_X_UNLIKELY':
a
The left operand of '<' is a garbage value
678 GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq)if ((dpy->bufptr + 36) > dpy->bufmax) _XFlush(dpy); oldreq
= (xXF86OldVidModeValidateModeLineReq *)(dpy->last_req = dpy
->bufptr); oldreq->reqType = 9; oldreq->length = (36
)>>2; dpy->bufptr += 36; dpy->request++
;
679 oldreq->reqType = info->codes->major_opcode;
680 oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine9;
681 oldreq->screen = screen;
682 oldreq->dotclock = modeline->dotclock;
683 oldreq->hdisplay = modeline->hdisplay;
684 oldreq->hsyncstart = modeline->hsyncstart;
685 oldreq->hsyncend = modeline->hsyncend;
686 oldreq->htotal = modeline->htotal;
687 oldreq->vdisplay = modeline->vdisplay;
688 oldreq->vsyncstart = modeline->vsyncstart;
689 oldreq->vsyncend = modeline->vsyncend;
690 oldreq->vtotal = modeline->vtotal;
691 oldreq->flags = modeline->flags;
692 oldreq->privsize = modeline->privsize;
693 if (modeline->privsize) {
694 oldreq->length += modeline->privsize;
695 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
696 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
697 }
698 } else {
699 GetReq(XF86VidModeValidateModeLine, req)req = (xXF86VidModeValidateModeLineReq *) _XGetRequest(dpy, 9
, 52)
;
700 req->reqType = info->codes->major_opcode;
701 req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine9;
702 req->screen = screen;
703 req->dotclock = modeline->dotclock;
704 req->hdisplay = modeline->hdisplay;
705 req->hsyncstart = modeline->hsyncstart;
706 req->hsyncend = modeline->hsyncend;
707 req->htotal = modeline->htotal;
708 req->hskew = modeline->hskew;
709 req->vdisplay = modeline->vdisplay;
710 req->vsyncstart = modeline->vsyncstart;
711 req->vsyncend = modeline->vsyncend;
712 req->vtotal = modeline->vtotal;
713 req->flags = modeline->flags;
714 req->privsize = modeline->privsize;
715 if (modeline->privsize) {
716 req->length += modeline->privsize;
717 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
718 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
719 }
720 }
721 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse0)) {
722 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
723 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
724 return MODE_BAD255;
725 }
726 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
727 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
728 return rep.status;
729}
730
731Boolint
732XF86VidModeSwitchMode(Display* dpy, int screen, int zoom)
733{
734 XExtDisplayInfo *info = find_display (dpy);
735 xXF86VidModeSwitchModeReq *req;
736
737 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
738
739 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
740 GetReq(XF86VidModeSwitchMode, req)req = (xXF86VidModeSwitchModeReq *) _XGetRequest(dpy, 3, 8);
741 req->reqType = info->codes->major_opcode;
742 req->xf86vidmodeReqType = X_XF86VidModeSwitchMode3;
743 req->screen = screen;
744 req->zoom = zoom;
745 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
746 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
747 return True1;
748}
749
750Boolint
751XF86VidModeSwitchToMode(Display* dpy, int screen, XF86VidModeModeInfo* modeline)
752{
753 XExtDisplayInfo *info = find_display (dpy);
754 xXF86VidModeSwitchToModeReq *req;
755 xXF86OldVidModeSwitchToModeReq *oldreq;
756 int majorVersion, minorVersion;
757 Boolint protocolBug = False0;
758
759 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
760
761 /*
762 * Note: There was a bug in the protocol implementation in versions
763 * 0.x with x < 8 (the .private field wasn't expected to be sent over
764 * the wire). Check the server's version, and accept the old format
765 * if appropriate.
766 */
767
768 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
769 if (_X_UNLIKELY(majorVersion == 0 && minorVersion < 8)__builtin_expect(!!(majorVersion == 0 && minorVersion
< 8), 0)
) {
770 protocolBug = True1;
771#ifdef DEBUG
772 fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
773 "running an old version (%d.%d)\n", majorVersion,
774 minorVersion);
775#endif
776 }
777
778 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
779 if (_X_UNLIKELY(majorVersion < 2)__builtin_expect(!!(majorVersion < 2), 0)) {
780 GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq)if ((dpy->bufptr + 36) > dpy->bufmax) _XFlush(dpy); oldreq
= (xXF86OldVidModeSwitchToModeReq *)(dpy->last_req = dpy->
bufptr); oldreq->reqType = 10; oldreq->length = (36)>>
2; dpy->bufptr += 36; dpy->request++
;
781 oldreq->reqType = info->codes->major_opcode;
782 oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode10;
783 oldreq->screen = screen;
784 oldreq->dotclock = modeline->dotclock;
785 oldreq->hdisplay = modeline->hdisplay;
786 oldreq->hsyncstart = modeline->hsyncstart;
787 oldreq->hsyncend = modeline->hsyncend;
788 oldreq->htotal = modeline->htotal;
789 oldreq->vdisplay = modeline->vdisplay;
790 oldreq->vsyncstart = modeline->vsyncstart;
791 oldreq->vsyncend = modeline->vsyncend;
792 oldreq->vtotal = modeline->vtotal;
793 oldreq->flags = modeline->flags;
794 if (protocolBug) {
795 oldreq->privsize = 0;
796 } else {
797 oldreq->privsize = modeline->privsize;
798 if (modeline->privsize) {
799 oldreq->length += modeline->privsize;
800 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
801 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
802 }
803 }
804 } else {
805 GetReq(XF86VidModeSwitchToMode, req)req = (xXF86VidModeSwitchToModeReq *) _XGetRequest(dpy, 10, 52
)
;
806 req->reqType = info->codes->major_opcode;
807 req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode10;
808 req->screen = screen;
809 req->dotclock = modeline->dotclock;
810 req->hdisplay = modeline->hdisplay;
811 req->hsyncstart = modeline->hsyncstart;
812 req->hsyncend = modeline->hsyncend;
813 req->htotal = modeline->htotal;
814 req->hskew = modeline->hskew;
815 req->vdisplay = modeline->vdisplay;
816 req->vsyncstart = modeline->vsyncstart;
817 req->vsyncend = modeline->vsyncend;
818 req->vtotal = modeline->vtotal;
819 req->flags = modeline->flags;
820 if (protocolBug) {
821 req->privsize = 0;
822 } else {
823 req->privsize = modeline->privsize;
824 if (modeline->privsize) {
825 req->length += modeline->privsize;
826 Data32(dpy, (long *) modeline->private,_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
827 modeline->privsize * sizeof(INT32))_XData32(dpy, (const long *)(long *) modeline->private, modeline
->privsize * sizeof(INT32))
;
828 }
829 }
830 }
831 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
832 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
833 return True1;
834}
835
836Boolint
837XF86VidModeLockModeSwitch(Display* dpy, int screen, int lock)
838{
839 XExtDisplayInfo *info = find_display (dpy);
840 xXF86VidModeLockModeSwitchReq *req;
841
842 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
843
844 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
845 GetReq(XF86VidModeLockModeSwitch, req)req = (xXF86VidModeLockModeSwitchReq *) _XGetRequest(dpy, 5, 8
)
;
846 req->reqType = info->codes->major_opcode;
847 req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch5;
848 req->screen = screen;
849 req->lock = lock;
850 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
851 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
852 return True1;
853}
854
855Boolint
856XF86VidModeGetMonitor(Display* dpy, int screen, XF86VidModeMonitor* monitor)
857{
858 XExtDisplayInfo *info = find_display (dpy);
859 xXF86VidModeGetMonitorReply rep;
860 xXF86VidModeGetMonitorReq *req;
861 CARD32 syncrange;
862 int i;
863 Boolint result = True1;
864
865 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
866
867 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
868 GetReq(XF86VidModeGetMonitor, req)req = (xXF86VidModeGetMonitorReq *) _XGetRequest(dpy, 4, 8);
869 req->reqType = info->codes->major_opcode;
870 req->xf86vidmodeReqType = X_XF86VidModeGetMonitor4;
871 req->screen = screen;
872 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse0)) {
873 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
874 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
875 return False0;
876 }
877 monitor->nhsync = rep.nhsync;
878 monitor->nvsync = rep.nvsync;
879#if 0
880 monitor->bandwidth = (float)rep.bandwidth / 1e6;
881#endif
882 if (rep.vendorLength) {
883 monitor->vendor = Xcalloc(rep.vendorLength + 1, 1)calloc(((rep.vendorLength + 1) == 0 ? 1 : (rep.vendorLength +
1)), (1))
;
884 if (monitor->vendor == NULL((void*)0))
885 result = False0;
886 } else {
887 monitor->vendor = NULL((void*)0);
888 }
889 if (result && rep.modelLength) {
890 monitor->model = Xcalloc(rep.modelLength + 1, 1)calloc(((rep.modelLength + 1) == 0 ? 1 : (rep.modelLength + 1
)), (1))
;
891 if (monitor->model == NULL((void*)0))
892 result = False0;
893 } else {
894 monitor->model = NULL((void*)0);
895 }
896 if (result) {
897 monitor->hsync = Xcalloc(rep.nhsync, sizeof(XF86VidModeSyncRange))calloc(((rep.nhsync) == 0 ? 1 : (rep.nhsync)), (sizeof(XF86VidModeSyncRange
)))
;
898 monitor->vsync = Xcalloc(rep.nvsync, sizeof(XF86VidModeSyncRange))calloc(((rep.nvsync) == 0 ? 1 : (rep.nvsync)), (sizeof(XF86VidModeSyncRange
)))
;
899 if ((monitor->hsync == NULL((void*)0)) || (monitor->vsync == NULL((void*)0)))
900 result = False0;
901 } else {
902 monitor->hsync = monitor->vsync = NULL((void*)0);
903 }
904 if (result == False0) {
905 _XEatDataWords(dpy, rep.length);
906 Xfree(monitor->vendor)free((monitor->vendor));
907 monitor->vendor = NULL((void*)0);
908 Xfree(monitor->model)free((monitor->model));
909 monitor->model = NULL((void*)0);
910 Xfree(monitor->hsync)free((monitor->hsync));
911 monitor->hsync = NULL((void*)0);
912 Xfree(monitor->vsync)free((monitor->vsync));
913 monitor->vsync = NULL((void*)0);
914 }
915 else {
916 for (i = 0; i < rep.nhsync; i++) {
917 _XRead(dpy, (char *)&syncrange, 4);
918 monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
919 monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0;
920 }
921 for (i = 0; i < rep.nvsync; i++) {
922 _XRead(dpy, (char *)&syncrange, 4);
923 monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
924 monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0;
925 }
926 if (rep.vendorLength)
927 _XReadPad(dpy, monitor->vendor, rep.vendorLength);
928 if (rep.modelLength)
929 _XReadPad(dpy, monitor->model, rep.modelLength);
930 }
931 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
932 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
933 return result;
934}
935
936Boolint
937XF86VidModeGetViewPort(Display* dpy, int screen, int *x, int *y)
938{
939 XExtDisplayInfo *info = find_display (dpy);
940 xXF86VidModeGetViewPortReply rep;
941 xXF86VidModeGetViewPortReq *req;
942 int majorVersion, minorVersion;
943 Boolint protocolBug = False0;
944
945 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
946
947 /*
948 * Note: There was a bug in the protocol implementation in versions
949 * 0.x with x < 8 (no reply was sent, so the client would hang)
950 * Check the server's version, and don't wait for a reply with older
951 * versions.
952 */
953
954 XF86VidModeQueryVersion(dpy, &majorVersion, &minorVersion);
955 if (majorVersion == 0 && minorVersion < 8) {
956 protocolBug = True1;
957#ifdef DEBUG
958 fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is"
959 "running an old version (%d.%d)\n", majorVersion,
960 minorVersion);
961#endif
962 }
963 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
964 GetReq(XF86VidModeGetViewPort, req)req = (xXF86VidModeGetViewPortReq *) _XGetRequest(dpy, 11, 8);
965 req->reqType = info->codes->major_opcode;
966 req->xf86vidmodeReqType = X_XF86VidModeGetViewPort11;
967 req->screen = screen;
968 if (protocolBug) {
969 *x = 0;
970 *y = 0;
971 } else {
972 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse0)) {
973 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
974 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
975 return False0;
976 }
977 *x = rep.x;
978 *y = rep.y;
979 }
980
981 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
982 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
983 return True1;
984}
985
986Boolint
987XF86VidModeSetViewPort(Display* dpy, int screen, int x, int y)
988{
989 XExtDisplayInfo *info = find_display (dpy);
990 xXF86VidModeSetViewPortReq *req;
991
992 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
993
994 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
995 GetReq(XF86VidModeSetViewPort, req)req = (xXF86VidModeSetViewPortReq *) _XGetRequest(dpy, 12, 16
)
;
996 req->reqType = info->codes->major_opcode;
997 req->xf86vidmodeReqType = X_XF86VidModeSetViewPort12;
998 req->screen = screen;
999 req->x = x;
1000 req->y = y;
1001
1002 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1003 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1004 return True1;
1005}
1006
1007Boolint
1008XF86VidModeGetDotClocks(Display* dpy, int screen, int *flagsPtr,
1009 int *numclocksPtr, int *maxclocksPtr, int *clocksPtr[])
1010{
1011 XExtDisplayInfo *info = find_display (dpy);
1012 xXF86VidModeGetDotClocksReply rep;
1013 xXF86VidModeGetDotClocksReq *req;
1014 int *dotclocks;
1015 CARD32 dotclk;
1016 Boolint result = True1;
1017
1018 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
1019
1020 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
1021 GetReq(XF86VidModeGetDotClocks, req)req = (xXF86VidModeGetDotClocksReq *) _XGetRequest(dpy, 13, 8
)
;
1022 req->reqType = info->codes->major_opcode;
1023 req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks13;
1024 req->screen = screen;
1025 if (!_XReply(dpy, (xReply *)&rep,
1026 (SIZEOF(xXF86VidModeGetDotClocksReply)32 - SIZEOF(xReply)32) >> 2, xFalse0))
1027 {
1028 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1029 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1030 return False0;
1031 }
1032 *numclocksPtr = rep.clocks;
1033 *maxclocksPtr = rep.maxclocks;
1034 *flagsPtr = rep.flags;
1035
1036 dotclocks = Xcalloc(rep.clocks, sizeof(int))calloc(((rep.clocks) == 0 ? 1 : (rep.clocks)), (sizeof(int)));
1037 if (dotclocks == NULL((void*)0)) {
1038 _XEatDataWords(dpy, rep.length -
1039 ((SIZEOF(xXF86VidModeGetDotClocksReply)32 - SIZEOF(xReply)32) >> 2));
1040 result = False0;
1041 }
1042 else {
1043 unsigned int i;
1044
1045 for (i = 0; i < rep.clocks; i++) {
1046 _XRead(dpy, (char*)&dotclk, 4);
1047 dotclocks[i] = dotclk;
1048 }
1049 }
1050 *clocksPtr = dotclocks;
1051 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1052 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1053 return result;
1054}
1055
1056Boolint
1057XF86VidModeSetGammaRamp (
1058 Display *dpy,
1059 int screen,
1060 int size,
1061 unsigned short *red,
1062 unsigned short *green,
1063 unsigned short *blue
1064)
1065{
1066 int length = (size + 1) & ~1;
1067 XExtDisplayInfo *info = find_display (dpy);
1068 xXF86VidModeSetGammaRampReq *req;
1069
1070 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
1071 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
1072 GetReq(XF86VidModeSetGammaRamp, req)req = (xXF86VidModeSetGammaRampReq *) _XGetRequest(dpy, 18, 8
)
;
1073 req->reqType = info->codes->major_opcode;
1074 req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp18;
1075 req->screen = screen;
1076 req->length += (length >> 1) * 3;
1077 req->size = size;
1078 _XSend(dpy, (char*)red, size * 2);
1079 _XSend(dpy, (char*)green, size * 2);
1080 _XSend(dpy, (char*)blue, size * 2);
1081 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1082 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1083 return True1;
1084}
1085
1086
1087Boolint
1088XF86VidModeGetGammaRamp (
1089 Display *dpy,
1090 int screen,
1091 int size,
1092 unsigned short *red,
1093 unsigned short *green,
1094 unsigned short *blue
1095)
1096{
1097 XExtDisplayInfo *info = find_display (dpy);
1098 xXF86VidModeGetGammaRampReq *req;
1099 xXF86VidModeGetGammaRampReply rep;
1100 Boolint result = True1;
1101
1102 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
1103
1104 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
1105 GetReq(XF86VidModeGetGammaRamp, req)req = (xXF86VidModeGetGammaRampReq *) _XGetRequest(dpy, 17, 8
)
;
1106 req->reqType = info->codes->major_opcode;
1107 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp17;
1108 req->screen = screen;
1109 req->size = size;
1110 if (!_XReply (dpy, (xReply *) &rep, 0, xFalse0)) {
1111 result = False0;
1112 }
1113 else if (rep.size) {
1114 if (rep.size <= size) {
1115 _XRead(dpy, (char*)red, rep.size << 1);
1116 _XRead(dpy, (char*)green, rep.size << 1);
1117 _XRead(dpy, (char*)blue, rep.size << 1);
1118 }
1119 else {
1120 _XEatDataWords(dpy, rep.length);
1121 result = False0;
1122 }
1123 }
1124
1125 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1126 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1127 return result;
1128}
1129
1130Boolint XF86VidModeGetGammaRampSize(
1131 Display *dpy,
1132 int screen,
1133 int *size
1134)
1135{
1136 XExtDisplayInfo *info = find_display (dpy);
1137 xXF86VidModeGetGammaRampSizeReq *req;
1138 xXF86VidModeGetGammaRampSizeReply rep;
1139
1140 *size = 0;
1141
1142 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
1143
1144 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
1145 GetReq(XF86VidModeGetGammaRampSize, req)req = (xXF86VidModeGetGammaRampSizeReq *) _XGetRequest(dpy, 19
, 8)
;
1146 req->reqType = info->codes->major_opcode;
1147 req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize19;
1148 req->screen = screen;
1149 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue1)) {
1150 UnlockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1151 SyncHandle ()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1152 return False0;
1153 }
1154 *size = rep.size;
1155 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1156 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1157 return True1;
1158}
1159
1160Boolint XF86VidModeGetPermissions(
1161 Display *dpy,
1162 int screen,
1163 int *permissions
1164)
1165{
1166 XExtDisplayInfo *info = find_display (dpy);
1167 xXF86VidModeGetPermissionsReq *req;
1168 xXF86VidModeGetPermissionsReply rep;
1169
1170 *permissions = 0;
1171
1172 XF86VidModeCheckExtension (dpy, info, False)if (!((info) && ((info)->codes))) { XMissingExtension
(dpy, xf86vidmode_extension_name); return 0; }
;
1173
1174 LockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->lock_display
)(dpy)
;
1175 GetReq(XF86VidModeGetPermissions, req)req = (xXF86VidModeGetPermissionsReq *) _XGetRequest(dpy, 20,
8)
;
1176 req->reqType = info->codes->major_opcode;
1177 req->xf86vidmodeReqType = X_XF86VidModeGetPermissions20;
1178 req->screen = screen;
1179 if (!_XReply (dpy, (xReply *) &rep, 0, xTrue1)) {
1180 UnlockDisplay (dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1181 SyncHandle ()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1182 return False0;
1183 }
1184 *permissions = rep.permissions;
1185 UnlockDisplay(dpy)if ((dpy)->lock_fns) (*(dpy)->lock_fns->unlock_display
)(dpy)
;
1186 SyncHandle()if (dpy->synchandler) (*dpy->synchandler)(dpy);
1187 return True1;
1188}
1189