Bug Summary

File:Xext/vidmode.c
Location:line 1377, column 5
Description:Argument to free() is offset by 4 bytes from the start of memory allocated by calloc()

Annotated Source Code

1/*
2
3Copyright 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/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
31
32#ifdef HAVE_DIX_CONFIG_H1
33#include <dix-config.h>
34#endif
35
36#ifdef XF86VIDMODE1
37
38#include <X11/X.h>
39#include <X11/Xproto.h>
40#include <X11/extensions/xf86vmproto.h>
41#include "misc.h"
42#include "dixstruct.h"
43#include "extnsionst.h"
44#include "scrnintstr.h"
45#include "servermd.h"
46#include "swaprep.h"
47#include "vidmodestr.h"
48#include "globals.h"
49#include "protocol-versions.h"
50
51static int VidModeErrorBase;
52static int VidModeAllowNonLocal;
53
54static DevPrivateKeyRec VidModeClientPrivateKeyRec;
55#define VidModeClientPrivateKey(&VidModeClientPrivateKeyRec) (&VidModeClientPrivateKeyRec)
56
57static DevPrivateKeyRec VidModePrivateKeyRec;
58#define VidModePrivateKey(&VidModePrivateKeyRec) (&VidModePrivateKeyRec)
59
60/* This holds the client's version information */
61typedef struct {
62 int major;
63 int minor;
64} VidModePrivRec, *VidModePrivPtr;
65
66#define VM_GETPRIV(c)((VidModePrivPtr) dixLookupPrivate(&(c)->devPrivates, (
&VidModeClientPrivateKeyRec)))
((VidModePrivPtr) \
67 dixLookupPrivate(&(c)->devPrivates, VidModeClientPrivateKey(&VidModeClientPrivateKeyRec)))
68#define VM_SETPRIV(c,p)dixSetPrivate(&(c)->devPrivates, (&VidModeClientPrivateKeyRec
), p)
\
69 dixSetPrivate(&(c)->devPrivates, VidModeClientPrivateKey(&VidModeClientPrivateKeyRec), p)
70
71#ifdef DEBUG
72#define DEBUG_P(x) DebugF(x"\n")
73#else
74#define DEBUG_P(x) /**/
75#endif
76
77static DisplayModePtr
78VidModeCreateMode(void)
79{
80 DisplayModePtr mode;
81
82 mode = malloc(sizeof(DisplayModeRec));
83 if (mode != NULL((void*)0)) {
84 mode->name = "";
85 mode->VScan = 1; /* divides refresh rate. default = 1 */
86 mode->Private = NULL((void*)0);
87 mode->next = mode;
88 mode->prev = mode;
89 }
90 return mode;
91}
92
93static void
94VidModeCopyMode(DisplayModePtr modefrom, DisplayModePtr modeto)
95{
96 memcpy(modeto, modefrom, sizeof(DisplayModeRec))__builtin___memcpy_chk (modeto, modefrom, sizeof(DisplayModeRec
), __builtin_object_size (modeto, 0))
;
97}
98
99static int
100VidModeGetModeValue(DisplayModePtr mode, int valtyp)
101{
102 int ret = 0;
103
104 switch (valtyp) {
105 case VIDMODE_H_DISPLAY:
106 ret = mode->HDisplay;
107 break;
108 case VIDMODE_H_SYNCSTART:
109 ret = mode->HSyncStart;
110 break;
111 case VIDMODE_H_SYNCEND:
112 ret = mode->HSyncEnd;
113 break;
114 case VIDMODE_H_TOTAL:
115 ret = mode->HTotal;
116 break;
117 case VIDMODE_H_SKEW:
118 ret = mode->HSkew;
119 break;
120 case VIDMODE_V_DISPLAY:
121 ret = mode->VDisplay;
122 break;
123 case VIDMODE_V_SYNCSTART:
124 ret = mode->VSyncStart;
125 break;
126 case VIDMODE_V_SYNCEND:
127 ret = mode->VSyncEnd;
128 break;
129 case VIDMODE_V_TOTAL:
130 ret = mode->VTotal;
131 break;
132 case VIDMODE_FLAGS:
133 ret = mode->Flags;
134 break;
135 case VIDMODE_CLOCK:
136 ret = mode->Clock;
137 break;
138 }
139 return ret;
140}
141
142static void
143VidModeSetModeValue(DisplayModePtr mode, int valtyp, int val)
144{
145 switch (valtyp) {
146 case VIDMODE_H_DISPLAY:
147 mode->HDisplay = val;
148 break;
149 case VIDMODE_H_SYNCSTART:
150 mode->HSyncStart = val;
151 break;
152 case VIDMODE_H_SYNCEND:
153 mode->HSyncEnd = val;
154 break;
155 case VIDMODE_H_TOTAL:
156 mode->HTotal = val;
157 break;
158 case VIDMODE_H_SKEW:
159 mode->HSkew = val;
160 break;
161 case VIDMODE_V_DISPLAY:
162 mode->VDisplay = val;
163 break;
164 case VIDMODE_V_SYNCSTART:
165 mode->VSyncStart = val;
166 break;
167 case VIDMODE_V_SYNCEND:
168 mode->VSyncEnd = val;
169 break;
170 case VIDMODE_V_TOTAL:
171 mode->VTotal = val;
172 break;
173 case VIDMODE_FLAGS:
174 mode->Flags = val;
175 break;
176 case VIDMODE_CLOCK:
177 mode->Clock = val;
178 break;
179 }
180 return;
181}
182
183static int
184ClientMajorVersion(ClientPtr client)
185{
186 VidModePrivPtr pPriv;
187
188 pPriv = VM_GETPRIV(client)((VidModePrivPtr) dixLookupPrivate(&(client)->devPrivates
, (&VidModeClientPrivateKeyRec)))
;
189 if (!pPriv)
190 return 0;
191 else
192 return pPriv->major;
193}
194
195static int
196ProcVidModeQueryVersion(ClientPtr client)
197{
198 xXF86VidModeQueryVersionReply rep = {
199 .type = X_Reply1,
200 .sequenceNumber = client->sequence,
201 .length = 0,
202 .majorVersion = SERVER_XF86VIDMODE_MAJOR_VERSION2,
203 .minorVersion = SERVER_XF86VIDMODE_MINOR_VERSION2
204 };
205
206 DEBUG_P("XF86VidModeQueryVersion");
207
208 REQUEST_SIZE_MATCH(xXF86VidModeQueryVersionReq)if ((sizeof(xXF86VidModeQueryVersionReq) >> 2) != client
->req_len) return(16)
;
209
210 if (client->swapped) {
211 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
212 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
213 swaps(&rep.majorVersion)do { if (sizeof(*(&rep.majorVersion)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.majorVersion) &
1) && ((uintptr_t)(&rep.majorVersion) & 1) ==
0) *(&rep.majorVersion) = lswaps(*(&rep.majorVersion
)); else swap_uint16((uint16_t *)(&rep.majorVersion)); } while
(0)
;
214 swaps(&rep.minorVersion)do { if (sizeof(*(&rep.minorVersion)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&rep.minorVersion) &
1) && ((uintptr_t)(&rep.minorVersion) & 1) ==
0) *(&rep.minorVersion) = lswaps(*(&rep.minorVersion
)); else swap_uint16((uint16_t *)(&rep.minorVersion)); } while
(0)
;
215 }
216 WriteToClient(client, sizeof(xXF86VidModeQueryVersionReply), &rep);
217 return Success0;
218}
219
220static int
221ProcVidModeGetModeLine(ClientPtr client)
222{
223 REQUEST(xXF86VidModeGetModeLineReq)xXF86VidModeGetModeLineReq *stuff = (xXF86VidModeGetModeLineReq
*)client->requestBuffer
;
224 xXF86VidModeGetModeLineReply rep = {
225 .type = X_Reply1,
226 .sequenceNumber = client->sequence
227 };
228 ScreenPtr pScreen;
229 VidModePtr pVidMode;
230 DisplayModePtr mode;
231 int dotClock;
232 int ver;
233
234 DEBUG_P("XF86VidModeGetModeline");
235
236 ver = ClientMajorVersion(client);
237 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq)if ((sizeof(xXF86VidModeGetModeLineReq) >> 2) != client
->req_len) return(16)
;
238
239 if (ver < 2) {
240 rep.length = bytes_to_int32(SIZEOF(xXF86OldVidModeGetModeLineReply)36 -
241 SIZEOF(xGenericReply)32);
242 }
243 else {
244 rep.length = bytes_to_int32(SIZEOF(xXF86VidModeGetModeLineReply)52 -
245 SIZEOF(xGenericReply)32);
246 }
247
248 if (stuff->screen >= screenInfo.numScreens)
249 return BadValue2;
250 pScreen = screenInfo.screens[stuff->screen];
251 pVidMode = VidModeGetPtr(pScreen);
252 if (pVidMode == NULL((void*)0))
253 return BadImplementation17;
254
255 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
256 return BadValue2;
257
258 rep.dotclock = dotClock;
259 rep.hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY);
260 rep.hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART);
261 rep.hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND);
262 rep.htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL);
263 rep.hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW);
264 rep.vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY);
265 rep.vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART);
266 rep.vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND);
267 rep.vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL);
268 rep.flags = VidModeGetModeValue(mode, VIDMODE_FLAGS);
269
270 DebugF("GetModeLine - scrn: %d clock: %ld\n",
271 stuff->screen, (unsigned long) rep.dotclock);
272 DebugF("GetModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
273 rep.hdisplay, rep.hsyncstart, rep.hsyncend, rep.htotal);
274 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
275 rep.vdisplay, rep.vsyncstart, rep.vsyncend,
276 rep.vtotal, (unsigned long) rep.flags);
277
278 /*
279 * Older servers sometimes had server privates that the VidMode
280 * extention made available. So to be compatiable pretend that
281 * there are no server privates to pass to the client
282 */
283 rep.privsize = 0;
284
285 if (client->swapped) {
286 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
287 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
288 swapl(&rep.dotclock)do { if (sizeof(*(&rep.dotclock)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.dotclock) & 3) &&
((uintptr_t)(&rep.dotclock) & 3) == 0) *(&rep.dotclock
) = lswapl(*(&rep.dotclock)); else swap_uint32((uint32_t *
)(&rep.dotclock)); } while (0)
;
289 swaps(&rep.hdisplay)do { if (sizeof(*(&rep.hdisplay)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.hdisplay) & 1) &&
((uintptr_t)(&rep.hdisplay) & 1) == 0) *(&rep.hdisplay
) = lswaps(*(&rep.hdisplay)); else swap_uint16((uint16_t *
)(&rep.hdisplay)); } while (0)
;
290 swaps(&rep.hsyncstart)do { if (sizeof(*(&rep.hsyncstart)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.hsyncstart) &
1) && ((uintptr_t)(&rep.hsyncstart) & 1) == 0
) *(&rep.hsyncstart) = lswaps(*(&rep.hsyncstart)); else
swap_uint16((uint16_t *)(&rep.hsyncstart)); } while (0)
;
291 swaps(&rep.hsyncend)do { if (sizeof(*(&rep.hsyncend)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.hsyncend) & 1) &&
((uintptr_t)(&rep.hsyncend) & 1) == 0) *(&rep.hsyncend
) = lswaps(*(&rep.hsyncend)); else swap_uint16((uint16_t *
)(&rep.hsyncend)); } while (0)
;
292 swaps(&rep.htotal)do { if (sizeof(*(&rep.htotal)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.htotal) & 1) && ((uintptr_t
)(&rep.htotal) & 1) == 0) *(&rep.htotal) = lswaps
(*(&rep.htotal)); else swap_uint16((uint16_t *)(&rep.
htotal)); } while (0)
;
293 swaps(&rep.hskew)do { if (sizeof(*(&rep.hskew)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.hskew) & 1) && ((uintptr_t)
(&rep.hskew) & 1) == 0) *(&rep.hskew) = lswaps(*(
&rep.hskew)); else swap_uint16((uint16_t *)(&rep.hskew
)); } while (0)
;
294 swaps(&rep.vdisplay)do { if (sizeof(*(&rep.vdisplay)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.vdisplay) & 1) &&
((uintptr_t)(&rep.vdisplay) & 1) == 0) *(&rep.vdisplay
) = lswaps(*(&rep.vdisplay)); else swap_uint16((uint16_t *
)(&rep.vdisplay)); } while (0)
;
295 swaps(&rep.vsyncstart)do { if (sizeof(*(&rep.vsyncstart)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.vsyncstart) &
1) && ((uintptr_t)(&rep.vsyncstart) & 1) == 0
) *(&rep.vsyncstart) = lswaps(*(&rep.vsyncstart)); else
swap_uint16((uint16_t *)(&rep.vsyncstart)); } while (0)
;
296 swaps(&rep.vsyncend)do { if (sizeof(*(&rep.vsyncend)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.vsyncend) & 1) &&
((uintptr_t)(&rep.vsyncend) & 1) == 0) *(&rep.vsyncend
) = lswaps(*(&rep.vsyncend)); else swap_uint16((uint16_t *
)(&rep.vsyncend)); } while (0)
;
297 swaps(&rep.vtotal)do { if (sizeof(*(&rep.vtotal)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.vtotal) & 1) && ((uintptr_t
)(&rep.vtotal) & 1) == 0) *(&rep.vtotal) = lswaps
(*(&rep.vtotal)); else swap_uint16((uint16_t *)(&rep.
vtotal)); } while (0)
;
298 swapl(&rep.flags)do { if (sizeof(*(&rep.flags)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.flags) & 3) && ((uintptr_t)
(&rep.flags) & 3) == 0) *(&rep.flags) = lswapl(*(
&rep.flags)); else swap_uint32((uint32_t *)(&rep.flags
)); } while (0)
;
299 swapl(&rep.privsize)do { if (sizeof(*(&rep.privsize)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&rep.privsize) & 3) &&
((uintptr_t)(&rep.privsize) & 3) == 0) *(&rep.privsize
) = lswapl(*(&rep.privsize)); else swap_uint32((uint32_t *
)(&rep.privsize)); } while (0)
;
300 }
301 if (ver < 2) {
302 xXF86OldVidModeGetModeLineReply oldrep = {
303 .type = rep.type,
304 .sequenceNumber = rep.sequenceNumber,
305 .length = rep.length,
306 .dotclock = rep.dotclock,
307 .hdisplay = rep.hdisplay,
308 .hsyncstart = rep.hsyncstart,
309 .hsyncend = rep.hsyncend,
310 .htotal = rep.htotal,
311 .vdisplay = rep.vdisplay,
312 .vsyncstart = rep.vsyncstart,
313 .vsyncend = rep.vsyncend,
314 .vtotal = rep.vtotal,
315 .flags = rep.flags,
316 .privsize = rep.privsize
317 };
318 WriteToClient(client, sizeof(xXF86OldVidModeGetModeLineReply), &oldrep);
319 }
320 else {
321 WriteToClient(client, sizeof(xXF86VidModeGetModeLineReply), &rep);
322 }
323 return Success0;
324}
325
326static int
327ProcVidModeGetAllModeLines(ClientPtr client)
328{
329 REQUEST(xXF86VidModeGetAllModeLinesReq)xXF86VidModeGetAllModeLinesReq *stuff = (xXF86VidModeGetAllModeLinesReq
*)client->requestBuffer
;
330 xXF86VidModeGetAllModeLinesReply rep;
331 ScreenPtr pScreen;
332 VidModePtr pVidMode;
333 DisplayModePtr mode;
334 int modecount, dotClock;
335 int ver;
336
337 DEBUG_P("XF86VidModeGetAllModelines");
338
339 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq)if ((sizeof(xXF86VidModeGetAllModeLinesReq) >> 2) != client
->req_len) return(16)
;
340
341 if (stuff->screen >= screenInfo.numScreens)
342 return BadValue2;
343 pScreen = screenInfo.screens[stuff->screen];
344 ver = ClientMajorVersion(client);
345 pVidMode = VidModeGetPtr(pScreen);
346 if (pVidMode == NULL((void*)0))
347 return BadImplementation17;
348
349 modecount = pVidMode->GetNumOfModes(pScreen);
350 if (modecount < 1)
351 return VidModeErrorBase + XF86VidModeExtensionDisabled4;
352
353 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
354 return BadValue2;
355
356 rep = (xXF86VidModeGetAllModeLinesReply) {
357 .type = X_Reply1,
358 .length = SIZEOF(xXF86VidModeGetAllModeLinesReply)32 -
359 SIZEOF(xGenericReply)32,
360 .sequenceNumber = client->sequence,
361 .modecount = modecount
362 };
363 if (ver < 2)
364 rep.length += modecount * sizeof(xXF86OldVidModeModeInfo);
365 else
366 rep.length += modecount * sizeof(xXF86VidModeModeInfo);
367 rep.length >>= 2;
368 if (client->swapped) {
369 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
370 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
371 swapl(&rep.modecount)do { if (sizeof(*(&rep.modecount)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.modecount) & 3
) && ((uintptr_t)(&rep.modecount) & 3) == 0) *
(&rep.modecount) = lswapl(*(&rep.modecount)); else swap_uint32
((uint32_t *)(&rep.modecount)); } while (0)
;
372 }
373 WriteToClient(client, sizeof(xXF86VidModeGetAllModeLinesReply), &rep);
374
375 do {
376 xXF86VidModeModeInfo mdinf = {
377 .dotclock = dotClock,
378 .hdisplay = VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
379 .hsyncstart = VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
380 .hsyncend = VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
381 .htotal = VidModeGetModeValue(mode, VIDMODE_H_TOTAL),
382 .hskew = VidModeGetModeValue(mode, VIDMODE_H_SKEW),
383 .vdisplay = VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
384 .vsyncstart = VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
385 .vsyncend = VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
386 .vtotal = VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
387 .flags = VidModeGetModeValue(mode, VIDMODE_FLAGS),
388 .privsize = 0
389 };
390 if (client->swapped) {
391 swapl(&mdinf.dotclock)do { if (sizeof(*(&mdinf.dotclock)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.dotclock) &
3) && ((uintptr_t)(&mdinf.dotclock) & 3) == 0
) *(&mdinf.dotclock) = lswapl(*(&mdinf.dotclock)); else
swap_uint32((uint32_t *)(&mdinf.dotclock)); } while (0)
;
392 swaps(&mdinf.hdisplay)do { if (sizeof(*(&mdinf.hdisplay)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.hdisplay) &
1) && ((uintptr_t)(&mdinf.hdisplay) & 1) == 0
) *(&mdinf.hdisplay) = lswaps(*(&mdinf.hdisplay)); else
swap_uint16((uint16_t *)(&mdinf.hdisplay)); } while (0)
;
393 swaps(&mdinf.hsyncstart)do { if (sizeof(*(&mdinf.hsyncstart)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&mdinf.hsyncstart) &
1) && ((uintptr_t)(&mdinf.hsyncstart) & 1) ==
0) *(&mdinf.hsyncstart) = lswaps(*(&mdinf.hsyncstart
)); else swap_uint16((uint16_t *)(&mdinf.hsyncstart)); } while
(0)
;
394 swaps(&mdinf.hsyncend)do { if (sizeof(*(&mdinf.hsyncend)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.hsyncend) &
1) && ((uintptr_t)(&mdinf.hsyncend) & 1) == 0
) *(&mdinf.hsyncend) = lswaps(*(&mdinf.hsyncend)); else
swap_uint16((uint16_t *)(&mdinf.hsyncend)); } while (0)
;
395 swaps(&mdinf.htotal)do { if (sizeof(*(&mdinf.htotal)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&mdinf.htotal) & 1) &&
((uintptr_t)(&mdinf.htotal) & 1) == 0) *(&mdinf.
htotal) = lswaps(*(&mdinf.htotal)); else swap_uint16((uint16_t
*)(&mdinf.htotal)); } while (0)
;
396 swapl(&mdinf.hskew)do { if (sizeof(*(&mdinf.hskew)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&mdinf.hskew) & 3) &&
((uintptr_t)(&mdinf.hskew) & 3) == 0) *(&mdinf.hskew
) = lswapl(*(&mdinf.hskew)); else swap_uint32((uint32_t *
)(&mdinf.hskew)); } while (0)
;
397 swaps(&mdinf.vdisplay)do { if (sizeof(*(&mdinf.vdisplay)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.vdisplay) &
1) && ((uintptr_t)(&mdinf.vdisplay) & 1) == 0
) *(&mdinf.vdisplay) = lswaps(*(&mdinf.vdisplay)); else
swap_uint16((uint16_t *)(&mdinf.vdisplay)); } while (0)
;
398 swaps(&mdinf.vsyncstart)do { if (sizeof(*(&mdinf.vsyncstart)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&mdinf.vsyncstart) &
1) && ((uintptr_t)(&mdinf.vsyncstart) & 1) ==
0) *(&mdinf.vsyncstart) = lswaps(*(&mdinf.vsyncstart
)); else swap_uint16((uint16_t *)(&mdinf.vsyncstart)); } while
(0)
;
399 swaps(&mdinf.vsyncend)do { if (sizeof(*(&mdinf.vsyncend)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.vsyncend) &
1) && ((uintptr_t)(&mdinf.vsyncend) & 1) == 0
) *(&mdinf.vsyncend) = lswaps(*(&mdinf.vsyncend)); else
swap_uint16((uint16_t *)(&mdinf.vsyncend)); } while (0)
;
400 swaps(&mdinf.vtotal)do { if (sizeof(*(&mdinf.vtotal)) != 2) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&mdinf.vtotal) & 1) &&
((uintptr_t)(&mdinf.vtotal) & 1) == 0) *(&mdinf.
vtotal) = lswaps(*(&mdinf.vtotal)); else swap_uint16((uint16_t
*)(&mdinf.vtotal)); } while (0)
;
401 swapl(&mdinf.flags)do { if (sizeof(*(&mdinf.flags)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&mdinf.flags) & 3) &&
((uintptr_t)(&mdinf.flags) & 3) == 0) *(&mdinf.flags
) = lswapl(*(&mdinf.flags)); else swap_uint32((uint32_t *
)(&mdinf.flags)); } while (0)
;
402 swapl(&mdinf.privsize)do { if (sizeof(*(&mdinf.privsize)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&mdinf.privsize) &
3) && ((uintptr_t)(&mdinf.privsize) & 3) == 0
) *(&mdinf.privsize) = lswapl(*(&mdinf.privsize)); else
swap_uint32((uint32_t *)(&mdinf.privsize)); } while (0)
;
403 }
404 if (ver < 2) {
405 xXF86OldVidModeModeInfo oldmdinf = {
406 .dotclock = mdinf.dotclock,
407 .hdisplay = mdinf.hdisplay,
408 .hsyncstart = mdinf.hsyncstart,
409 .hsyncend = mdinf.hsyncend,
410 .htotal = mdinf.htotal,
411 .vdisplay = mdinf.vdisplay,
412 .vsyncstart = mdinf.vsyncstart,
413 .vsyncend = mdinf.vsyncend,
414 .vtotal = mdinf.vtotal,
415 .flags = mdinf.flags,
416 .privsize = mdinf.privsize
417 };
418 WriteToClient(client, sizeof(xXF86OldVidModeModeInfo), &oldmdinf);
419 }
420 else {
421 WriteToClient(client, sizeof(xXF86VidModeModeInfo), &mdinf);
422 }
423
424 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
425
426 return Success0;
427}
428
429#define MODEMATCH(mode,stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
\
430 (VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay \
431 && VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) == stuff->hsyncstart \
432 && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND) == stuff->hsyncend \
433 && VidModeGetModeValue(mode, VIDMODE_H_TOTAL) == stuff->htotal \
434 && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY) == stuff->vdisplay \
435 && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART) == stuff->vsyncstart \
436 && VidModeGetModeValue(mode, VIDMODE_V_SYNCEND) == stuff->vsyncend \
437 && VidModeGetModeValue(mode, VIDMODE_V_TOTAL) == stuff->vtotal \
438 && VidModeGetModeValue(mode, VIDMODE_FLAGS) == stuff->flags )
439
440static int
441ProcVidModeAddModeLine(ClientPtr client)
442{
443 REQUEST(xXF86VidModeAddModeLineReq)xXF86VidModeAddModeLineReq *stuff = (xXF86VidModeAddModeLineReq
*)client->requestBuffer
;
444 xXF86OldVidModeAddModeLineReq *oldstuff =
445 (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
446 xXF86VidModeAddModeLineReq newstuff;
447 ScreenPtr pScreen;
448 VidModePtr pVidMode;
449 DisplayModePtr mode;
450 int len;
451 int dotClock;
452 int ver;
453
454 DEBUG_P("XF86VidModeAddModeline");
455
456 ver = ClientMajorVersion(client);
457 if (ver < 2) {
458 /* convert from old format */
459 stuff = &newstuff;
460 stuff->length = oldstuff->length;
461 stuff->screen = oldstuff->screen;
462 stuff->dotclock = oldstuff->dotclock;
463 stuff->hdisplay = oldstuff->hdisplay;
464 stuff->hsyncstart = oldstuff->hsyncstart;
465 stuff->hsyncend = oldstuff->hsyncend;
466 stuff->htotal = oldstuff->htotal;
467 stuff->hskew = 0;
468 stuff->vdisplay = oldstuff->vdisplay;
469 stuff->vsyncstart = oldstuff->vsyncstart;
470 stuff->vsyncend = oldstuff->vsyncend;
471 stuff->vtotal = oldstuff->vtotal;
472 stuff->flags = oldstuff->flags;
473 stuff->privsize = oldstuff->privsize;
474 stuff->after_dotclock = oldstuff->after_dotclock;
475 stuff->after_hdisplay = oldstuff->after_hdisplay;
476 stuff->after_hsyncstart = oldstuff->after_hsyncstart;
477 stuff->after_hsyncend = oldstuff->after_hsyncend;
478 stuff->after_htotal = oldstuff->after_htotal;
479 stuff->after_hskew = 0;
480 stuff->after_vdisplay = oldstuff->after_vdisplay;
481 stuff->after_vsyncstart = oldstuff->after_vsyncstart;
482 stuff->after_vsyncend = oldstuff->after_vsyncend;
483 stuff->after_vtotal = oldstuff->after_vtotal;
484 stuff->after_flags = oldstuff->after_flags;
485 }
486 DebugF("AddModeLine - scrn: %d clock: %ld\n",
487 (int) stuff->screen, (unsigned long) stuff->dotclock);
488 DebugF("AddModeLine - hdsp: %d hbeg: %d hend: %d httl: %d\n",
489 stuff->hdisplay, stuff->hsyncstart,
490 stuff->hsyncend, stuff->htotal);
491 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
492 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
493 stuff->vtotal, (unsigned long) stuff->flags);
494 DebugF(" after - scrn: %d clock: %ld\n",
495 (int) stuff->screen, (unsigned long) stuff->after_dotclock);
496 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
497 stuff->after_hdisplay, stuff->after_hsyncstart,
498 stuff->after_hsyncend, stuff->after_htotal);
499 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
500 stuff->after_vdisplay, stuff->after_vsyncstart,
501 stuff->after_vsyncend, stuff->after_vtotal,
502 (unsigned long) stuff->after_flags);
503
504 if (ver < 2) {
505 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq)if ((sizeof(xXF86OldVidModeAddModeLineReq) >> 2) > client
->req_len ) return(16)
;
506 len =
507 client->req_len -
508 bytes_to_int32(sizeof(xXF86OldVidModeAddModeLineReq));
509 }
510 else {
511 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq)if ((sizeof(xXF86VidModeAddModeLineReq) >> 2) > client
->req_len ) return(16)
;
512 len =
513 client->req_len -
514 bytes_to_int32(sizeof(xXF86VidModeAddModeLineReq));
515 }
516 if (len != stuff->privsize)
517 return BadLength16;
518
519 if (stuff->screen >= screenInfo.numScreens)
520 return BadValue2;
521 pScreen = screenInfo.screens[stuff->screen];
522
523 if (stuff->hsyncstart < stuff->hdisplay ||
524 stuff->hsyncend < stuff->hsyncstart ||
525 stuff->htotal < stuff->hsyncend ||
526 stuff->vsyncstart < stuff->vdisplay ||
527 stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
528 return BadValue2;
529
530 if (stuff->after_hsyncstart < stuff->after_hdisplay ||
531 stuff->after_hsyncend < stuff->after_hsyncstart ||
532 stuff->after_htotal < stuff->after_hsyncend ||
533 stuff->after_vsyncstart < stuff->after_vdisplay ||
534 stuff->after_vsyncend < stuff->after_vsyncstart ||
535 stuff->after_vtotal < stuff->after_vsyncend)
536 return BadValue2;
537
538 pVidMode = VidModeGetPtr(pScreen);
539 if (pVidMode == NULL((void*)0))
540 return BadImplementation17;
541
542 if (stuff->after_htotal != 0 || stuff->after_vtotal != 0) {
543 Bool found = FALSE0;
544
545 if (pVidMode->GetFirstModeline(pScreen, &mode, &dotClock)) {
546 do {
547 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock)
548 == dotClock) && MODEMATCH(mode, stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
) {
549 found = TRUE1;
550 break;
551 }
552 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
553 }
554 if (!found)
555 return BadValue2;
556 }
557
558 mode = VidModeCreateMode();
559 if (mode == NULL((void*)0))
560 return BadValue2;
561
562 VidModeSetModeValue(mode, VIDMODE_CLOCK, stuff->dotclock);
563 VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
564 VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
565 VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
566 VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
567 VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
568 VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
569 VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
570 VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
571 VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
572 VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
573
574 if (stuff->privsize)
575 DebugF("AddModeLine - Privates in request have been ignored\n");
576
577 /* Check that the mode is consistent with the monitor specs */
578 switch (pVidMode->CheckModeForMonitor(pScreen, mode)) {
579 case MODE_OK:
580 break;
581 case MODE_HSYNC:
582 case MODE_H_ILLEGAL:
583 free(mode);
584 return VidModeErrorBase + XF86VidModeBadHTimings1;
585 case MODE_VSYNC:
586 case MODE_V_ILLEGAL:
587 free(mode);
588 return VidModeErrorBase + XF86VidModeBadVTimings2;
589 default:
590 free(mode);
591 return VidModeErrorBase + XF86VidModeModeUnsuitable3;
592 }
593
594 /* Check that the driver is happy with the mode */
595 if (pVidMode->CheckModeForDriver(pScreen, mode) != MODE_OK) {
596 free(mode);
597 return VidModeErrorBase + XF86VidModeModeUnsuitable3;
598 }
599
600 pVidMode->SetCrtcForMode(pScreen, mode);
601
602 pVidMode->AddModeline(pScreen, mode);
603
604 DebugF("AddModeLine - Succeeded\n");
605
606 return Success0;
607}
608
609static int
610ProcVidModeDeleteModeLine(ClientPtr client)
611{
612 REQUEST(xXF86VidModeDeleteModeLineReq)xXF86VidModeDeleteModeLineReq *stuff = (xXF86VidModeDeleteModeLineReq
*)client->requestBuffer
;
613 xXF86OldVidModeDeleteModeLineReq *oldstuff =
614 (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
615 xXF86VidModeDeleteModeLineReq newstuff;
616 ScreenPtr pScreen;
617 VidModePtr pVidMode;
618 DisplayModePtr mode;
619 int len, dotClock;
620 int ver;
621
622 DEBUG_P("XF86VidModeDeleteModeline");
623
624 ver = ClientMajorVersion(client);
625 if (ver < 2) {
626 /* convert from old format */
627 stuff = &newstuff;
628 stuff->length = oldstuff->length;
629 stuff->screen = oldstuff->screen;
630 stuff->dotclock = oldstuff->dotclock;
631 stuff->hdisplay = oldstuff->hdisplay;
632 stuff->hsyncstart = oldstuff->hsyncstart;
633 stuff->hsyncend = oldstuff->hsyncend;
634 stuff->htotal = oldstuff->htotal;
635 stuff->hskew = 0;
636 stuff->vdisplay = oldstuff->vdisplay;
637 stuff->vsyncstart = oldstuff->vsyncstart;
638 stuff->vsyncend = oldstuff->vsyncend;
639 stuff->vtotal = oldstuff->vtotal;
640 stuff->flags = oldstuff->flags;
641 stuff->privsize = oldstuff->privsize;
642 }
643 DebugF("DeleteModeLine - scrn: %d clock: %ld\n",
644 (int) stuff->screen, (unsigned long) stuff->dotclock);
645 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
646 stuff->hdisplay, stuff->hsyncstart,
647 stuff->hsyncend, stuff->htotal);
648 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
649 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
650 (unsigned long) stuff->flags);
651
652 if (ver < 2) {
653 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq)if ((sizeof(xXF86OldVidModeDeleteModeLineReq) >> 2) >
client->req_len ) return(16)
;
654 len =
655 client->req_len -
656 bytes_to_int32(sizeof(xXF86OldVidModeDeleteModeLineReq));
657 }
658 else {
659 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq)if ((sizeof(xXF86VidModeDeleteModeLineReq) >> 2) > client
->req_len ) return(16)
;
660 len =
661 client->req_len -
662 bytes_to_int32(sizeof(xXF86VidModeDeleteModeLineReq));
663 }
664 if (len != stuff->privsize) {
665 DebugF("req_len = %ld, sizeof(Req) = %d, privsize = %ld, "
666 "len = %d, length = %d\n",
667 (unsigned long) client->req_len,
668 (int) sizeof(xXF86VidModeDeleteModeLineReq) >> 2,
669 (unsigned long) stuff->privsize, len, stuff->length);
670 return BadLength16;
671 }
672
673 if (stuff->screen >= screenInfo.numScreens)
674 return BadValue2;
675 pScreen = screenInfo.screens[stuff->screen];
676
677 pVidMode = VidModeGetPtr(pScreen);
678 if (pVidMode == NULL((void*)0))
679 return BadImplementation17;
680
681 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
682 return BadValue2;
683
684 DebugF("Checking against clock: %d (%d)\n",
685 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
686 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
687 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
688 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
689 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
690 VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
691 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
692 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
693 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
694 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
695 VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
696 VidModeGetModeValue(mode, VIDMODE_FLAGS));
697
698 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
699 MODEMATCH(mode, stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
)
700 return BadValue2;
701
702 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
703 return BadValue2;
704
705 do {
706 DebugF("Checking against clock: %d (%d)\n",
707 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
708 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
709 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
710 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
711 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
712 VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
713 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
714 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
715 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
716 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
717 VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
718 VidModeGetModeValue(mode, VIDMODE_FLAGS));
719
720 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
721 MODEMATCH(mode, stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
) {
722 pVidMode->DeleteModeline(pScreen, mode);
723 DebugF("DeleteModeLine - Succeeded\n");
724 return Success0;
725 }
726 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
727
728 return BadValue2;
729}
730
731static int
732ProcVidModeModModeLine(ClientPtr client)
733{
734 REQUEST(xXF86VidModeModModeLineReq)xXF86VidModeModModeLineReq *stuff = (xXF86VidModeModModeLineReq
*)client->requestBuffer
;
735 xXF86OldVidModeModModeLineReq *oldstuff =
736 (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
737 xXF86VidModeModModeLineReq newstuff;
738 ScreenPtr pScreen;
739 VidModePtr pVidMode;
740 DisplayModePtr mode, modetmp;
741 int len, dotClock;
742 int ver;
743
744 DEBUG_P("XF86VidModeModModeline");
745
746 ver = ClientMajorVersion(client);
747 if (ver < 2) {
748 /* convert from old format */
749 stuff = &newstuff;
750 stuff->length = oldstuff->length;
751 stuff->screen = oldstuff->screen;
752 stuff->hdisplay = oldstuff->hdisplay;
753 stuff->hsyncstart = oldstuff->hsyncstart;
754 stuff->hsyncend = oldstuff->hsyncend;
755 stuff->htotal = oldstuff->htotal;
756 stuff->hskew = 0;
757 stuff->vdisplay = oldstuff->vdisplay;
758 stuff->vsyncstart = oldstuff->vsyncstart;
759 stuff->vsyncend = oldstuff->vsyncend;
760 stuff->vtotal = oldstuff->vtotal;
761 stuff->flags = oldstuff->flags;
762 stuff->privsize = oldstuff->privsize;
763 }
764 DebugF("ModModeLine - scrn: %d hdsp: %d hbeg: %d hend: %d httl: %d\n",
765 (int) stuff->screen, stuff->hdisplay, stuff->hsyncstart,
766 stuff->hsyncend, stuff->htotal);
767 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
768 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend,
769 stuff->vtotal, (unsigned long) stuff->flags);
770
771 if (ver < 2) {
772 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq)if ((sizeof(xXF86OldVidModeModModeLineReq) >> 2) > client
->req_len ) return(16)
;
773 len =
774 client->req_len -
775 bytes_to_int32(sizeof(xXF86OldVidModeModModeLineReq));
776 }
777 else {
778 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq)if ((sizeof(xXF86VidModeModModeLineReq) >> 2) > client
->req_len ) return(16)
;
779 len =
780 client->req_len -
781 bytes_to_int32(sizeof(xXF86VidModeModModeLineReq));
782 }
783 if (len != stuff->privsize)
784 return BadLength16;
785
786 if (stuff->hsyncstart < stuff->hdisplay ||
787 stuff->hsyncend < stuff->hsyncstart ||
788 stuff->htotal < stuff->hsyncend ||
789 stuff->vsyncstart < stuff->vdisplay ||
790 stuff->vsyncend < stuff->vsyncstart || stuff->vtotal < stuff->vsyncend)
791 return BadValue2;
792
793 if (stuff->screen >= screenInfo.numScreens)
794 return BadValue2;
795 pScreen = screenInfo.screens[stuff->screen];
796
797 pVidMode = VidModeGetPtr(pScreen);
798 if (pVidMode == NULL((void*)0))
799 return BadImplementation17;
800
801 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
802 return BadValue2;
803
804 modetmp = VidModeCreateMode();
805 VidModeCopyMode(mode, modetmp);
806
807 VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
808 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
809 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
810 VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
811 VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
812 VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
813 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
814 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
815 VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
816 VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
817
818 if (stuff->privsize)
819 DebugF("ModModeLine - Privates in request have been ignored\n");
820
821 /* Check that the mode is consistent with the monitor specs */
822 switch (pVidMode->CheckModeForMonitor(pScreen, modetmp)) {
823 case MODE_OK:
824 break;
825 case MODE_HSYNC:
826 case MODE_H_ILLEGAL:
827 free(modetmp);
828 return VidModeErrorBase + XF86VidModeBadHTimings1;
829 case MODE_VSYNC:
830 case MODE_V_ILLEGAL:
831 free(modetmp);
832 return VidModeErrorBase + XF86VidModeBadVTimings2;
833 default:
834 free(modetmp);
835 return VidModeErrorBase + XF86VidModeModeUnsuitable3;
836 }
837
838 /* Check that the driver is happy with the mode */
839 if (pVidMode->CheckModeForDriver(pScreen, modetmp) != MODE_OK) {
840 free(modetmp);
841 return VidModeErrorBase + XF86VidModeModeUnsuitable3;
842 }
843 free(modetmp);
844
845 VidModeSetModeValue(mode, VIDMODE_H_DISPLAY, stuff->hdisplay);
846 VidModeSetModeValue(mode, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
847 VidModeSetModeValue(mode, VIDMODE_H_SYNCEND, stuff->hsyncend);
848 VidModeSetModeValue(mode, VIDMODE_H_TOTAL, stuff->htotal);
849 VidModeSetModeValue(mode, VIDMODE_H_SKEW, stuff->hskew);
850 VidModeSetModeValue(mode, VIDMODE_V_DISPLAY, stuff->vdisplay);
851 VidModeSetModeValue(mode, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
852 VidModeSetModeValue(mode, VIDMODE_V_SYNCEND, stuff->vsyncend);
853 VidModeSetModeValue(mode, VIDMODE_V_TOTAL, stuff->vtotal);
854 VidModeSetModeValue(mode, VIDMODE_FLAGS, stuff->flags);
855
856 pVidMode->SetCrtcForMode(pScreen, mode);
857 pVidMode->SwitchMode(pScreen, mode);
858
859 DebugF("ModModeLine - Succeeded\n");
860 return Success0;
861}
862
863static int
864ProcVidModeValidateModeLine(ClientPtr client)
865{
866 REQUEST(xXF86VidModeValidateModeLineReq)xXF86VidModeValidateModeLineReq *stuff = (xXF86VidModeValidateModeLineReq
*)client->requestBuffer
;
867 xXF86OldVidModeValidateModeLineReq *oldstuff =
868 (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
869 xXF86VidModeValidateModeLineReq newstuff;
870 xXF86VidModeValidateModeLineReply rep;
871 ScreenPtr pScreen;
872 VidModePtr pVidMode;
873 DisplayModePtr mode, modetmp = NULL((void*)0);
874 int len, status, dotClock;
875 int ver;
876
877 DEBUG_P("XF86VidModeValidateModeline");
878
879 ver = ClientMajorVersion(client);
880 if (ver < 2) {
881 /* convert from old format */
882 stuff = &newstuff;
883 stuff->length = oldstuff->length;
884 stuff->screen = oldstuff->screen;
885 stuff->dotclock = oldstuff->dotclock;
886 stuff->hdisplay = oldstuff->hdisplay;
887 stuff->hsyncstart = oldstuff->hsyncstart;
888 stuff->hsyncend = oldstuff->hsyncend;
889 stuff->htotal = oldstuff->htotal;
890 stuff->hskew = 0;
891 stuff->vdisplay = oldstuff->vdisplay;
892 stuff->vsyncstart = oldstuff->vsyncstart;
893 stuff->vsyncend = oldstuff->vsyncend;
894 stuff->vtotal = oldstuff->vtotal;
895 stuff->flags = oldstuff->flags;
896 stuff->privsize = oldstuff->privsize;
897 }
898
899 DebugF("ValidateModeLine - scrn: %d clock: %ld\n",
900 (int) stuff->screen, (unsigned long) stuff->dotclock);
901 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
902 stuff->hdisplay, stuff->hsyncstart,
903 stuff->hsyncend, stuff->htotal);
904 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
905 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
906 (unsigned long) stuff->flags);
907
908 if (ver < 2) {
909 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq)if ((sizeof(xXF86OldVidModeValidateModeLineReq) >> 2) >
client->req_len ) return(16)
;
910 len = client->req_len -
911 bytes_to_int32(sizeof(xXF86OldVidModeValidateModeLineReq));
912 }
913 else {
914 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq)if ((sizeof(xXF86VidModeValidateModeLineReq) >> 2) >
client->req_len ) return(16)
;
915 len =
916 client->req_len -
917 bytes_to_int32(sizeof(xXF86VidModeValidateModeLineReq));
918 }
919 if (len != stuff->privsize)
920 return BadLength16;
921
922 if (stuff->screen >= screenInfo.numScreens)
923 return BadValue2;
924 pScreen = screenInfo.screens[stuff->screen];
925
926 status = MODE_OK;
927
928 if (stuff->hsyncstart < stuff->hdisplay ||
929 stuff->hsyncend < stuff->hsyncstart ||
930 stuff->htotal < stuff->hsyncend ||
931 stuff->vsyncstart < stuff->vdisplay ||
932 stuff->vsyncend < stuff->vsyncstart ||
933 stuff->vtotal < stuff->vsyncend) {
934 status = MODE_BAD;
935 goto status_reply;
936 }
937
938 pVidMode = VidModeGetPtr(pScreen);
939 if (pVidMode == NULL((void*)0))
940 return BadImplementation17;
941
942 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
943 return BadValue2;
944
945 modetmp = VidModeCreateMode();
946 VidModeCopyMode(mode, modetmp);
947
948 VidModeSetModeValue(modetmp, VIDMODE_H_DISPLAY, stuff->hdisplay);
949 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCSTART, stuff->hsyncstart);
950 VidModeSetModeValue(modetmp, VIDMODE_H_SYNCEND, stuff->hsyncend);
951 VidModeSetModeValue(modetmp, VIDMODE_H_TOTAL, stuff->htotal);
952 VidModeSetModeValue(modetmp, VIDMODE_H_SKEW, stuff->hskew);
953 VidModeSetModeValue(modetmp, VIDMODE_V_DISPLAY, stuff->vdisplay);
954 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCSTART, stuff->vsyncstart);
955 VidModeSetModeValue(modetmp, VIDMODE_V_SYNCEND, stuff->vsyncend);
956 VidModeSetModeValue(modetmp, VIDMODE_V_TOTAL, stuff->vtotal);
957 VidModeSetModeValue(modetmp, VIDMODE_FLAGS, stuff->flags);
958 if (stuff->privsize)
959 DebugF("ValidateModeLine - Privates in request have been ignored\n");
960
961 /* Check that the mode is consistent with the monitor specs */
962 if ((status =
963 pVidMode->CheckModeForMonitor(pScreen, modetmp)) != MODE_OK)
964 goto status_reply;
965
966 /* Check that the driver is happy with the mode */
967 status = pVidMode->CheckModeForDriver(pScreen, modetmp);
968
969 status_reply:
970 free(modetmp);
971
972 rep = (xXF86VidModeValidateModeLineReply) {
973 .type = X_Reply1,
974 .sequenceNumber = client->sequence,
975 .length = bytes_to_int32(SIZEOF(xXF86VidModeValidateModeLineReply)32
976 - SIZEOF(xGenericReply)32),
977 .status = status
978 };
979 if (client->swapped) {
980 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
981 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
982 swapl(&rep.status)do { if (sizeof(*(&rep.status)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.status) & 3) && ((uintptr_t
)(&rep.status) & 3) == 0) *(&rep.status) = lswapl
(*(&rep.status)); else swap_uint32((uint32_t *)(&rep.
status)); } while (0)
;
983 }
984 WriteToClient(client, sizeof(xXF86VidModeValidateModeLineReply), &rep);
985 DebugF("ValidateModeLine - Succeeded (status = %d)\n", status);
986
987 return Success0;
988}
989
990static int
991ProcVidModeSwitchMode(ClientPtr client)
992{
993 REQUEST(xXF86VidModeSwitchModeReq)xXF86VidModeSwitchModeReq *stuff = (xXF86VidModeSwitchModeReq
*)client->requestBuffer
;
994 ScreenPtr pScreen;
995 VidModePtr pVidMode;
996
997 DEBUG_P("XF86VidModeSwitchMode");
998
999 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq)if ((sizeof(xXF86VidModeSwitchModeReq) >> 2) != client->
req_len) return(16)
;
1000
1001 if (stuff->screen >= screenInfo.numScreens)
1002 return BadValue2;
1003 pScreen = screenInfo.screens[stuff->screen];
1004
1005 pVidMode = VidModeGetPtr(pScreen);
1006 if (pVidMode == NULL((void*)0))
1007 return BadImplementation17;
1008
1009 pVidMode->ZoomViewport(pScreen, (short) stuff->zoom);
1010
1011 return Success0;
1012}
1013
1014static int
1015ProcVidModeSwitchToMode(ClientPtr client)
1016{
1017 REQUEST(xXF86VidModeSwitchToModeReq)xXF86VidModeSwitchToModeReq *stuff = (xXF86VidModeSwitchToModeReq
*)client->requestBuffer
;
1018 xXF86OldVidModeSwitchToModeReq *oldstuff =
1019 (xXF86OldVidModeSwitchToModeReq *) client->requestBuffer;
1020 xXF86VidModeSwitchToModeReq newstuff;
1021 ScreenPtr pScreen;
1022 VidModePtr pVidMode;
1023 DisplayModePtr mode;
1024 int len, dotClock;
1025 int ver;
1026
1027 DEBUG_P("XF86VidModeSwitchToMode");
1028
1029 ver = ClientMajorVersion(client);
1030 if (ver < 2) {
1031 /* convert from old format */
1032 stuff = &newstuff;
1033 stuff->length = oldstuff->length;
1034 stuff->screen = oldstuff->screen;
1035 stuff->dotclock = oldstuff->dotclock;
1036 stuff->hdisplay = oldstuff->hdisplay;
1037 stuff->hsyncstart = oldstuff->hsyncstart;
1038 stuff->hsyncend = oldstuff->hsyncend;
1039 stuff->htotal = oldstuff->htotal;
1040 stuff->hskew = 0;
1041 stuff->vdisplay = oldstuff->vdisplay;
1042 stuff->vsyncstart = oldstuff->vsyncstart;
1043 stuff->vsyncend = oldstuff->vsyncend;
1044 stuff->vtotal = oldstuff->vtotal;
1045 stuff->flags = oldstuff->flags;
1046 stuff->privsize = oldstuff->privsize;
1047 }
1048
1049 DebugF("SwitchToMode - scrn: %d clock: %ld\n",
1050 (int) stuff->screen, (unsigned long) stuff->dotclock);
1051 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
1052 stuff->hdisplay, stuff->hsyncstart,
1053 stuff->hsyncend, stuff->htotal);
1054 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %ld\n",
1055 stuff->vdisplay, stuff->vsyncstart, stuff->vsyncend, stuff->vtotal,
1056 (unsigned long) stuff->flags);
1057
1058 if (ver < 2) {
1059 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeSwitchToModeReq)if ((sizeof(xXF86OldVidModeSwitchToModeReq) >> 2) > client
->req_len ) return(16)
;
1060 len =
1061 client->req_len -
1062 bytes_to_int32(sizeof(xXF86OldVidModeSwitchToModeReq));
1063 }
1064 else {
1065 REQUEST_AT_LEAST_SIZE(xXF86VidModeSwitchToModeReq)if ((sizeof(xXF86VidModeSwitchToModeReq) >> 2) > client
->req_len ) return(16)
;
1066 len =
1067 client->req_len -
1068 bytes_to_int32(sizeof(xXF86VidModeSwitchToModeReq));
1069 }
1070 if (len != stuff->privsize)
1071 return BadLength16;
1072
1073 if (stuff->screen >= screenInfo.numScreens)
1074 return BadValue2;
1075 pScreen = screenInfo.screens[stuff->screen];
1076
1077 pVidMode = VidModeGetPtr(pScreen);
1078 if (pVidMode == NULL((void*)0))
1079 return BadImplementation17;
1080
1081 if (!pVidMode->GetCurrentModeline(pScreen, &mode, &dotClock))
1082 return BadValue2;
1083
1084 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock)
1085 && MODEMATCH(mode, stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
)
1086 return Success0;
1087
1088 if (!pVidMode->GetFirstModeline(pScreen, &mode, &dotClock))
1089 return BadValue2;
1090
1091 do {
1092 DebugF("Checking against clock: %d (%d)\n",
1093 VidModeGetModeValue(mode, VIDMODE_CLOCK), dotClock);
1094 DebugF(" hdsp: %d hbeg: %d hend: %d httl: %d\n",
1095 VidModeGetModeValue(mode, VIDMODE_H_DISPLAY),
1096 VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART),
1097 VidModeGetModeValue(mode, VIDMODE_H_SYNCEND),
1098 VidModeGetModeValue(mode, VIDMODE_H_TOTAL));
1099 DebugF(" vdsp: %d vbeg: %d vend: %d vttl: %d flags: %d\n",
1100 VidModeGetModeValue(mode, VIDMODE_V_DISPLAY),
1101 VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART),
1102 VidModeGetModeValue(mode, VIDMODE_V_SYNCEND),
1103 VidModeGetModeValue(mode, VIDMODE_V_TOTAL),
1104 VidModeGetModeValue(mode, VIDMODE_FLAGS));
1105
1106 if ((pVidMode->GetDotClock(pScreen, stuff->dotclock) == dotClock) &&
1107 MODEMATCH(mode, stuff)(VidModeGetModeValue(mode, VIDMODE_H_DISPLAY) == stuff->hdisplay
&& VidModeGetModeValue(mode, VIDMODE_H_SYNCSTART) ==
stuff->hsyncstart && VidModeGetModeValue(mode, VIDMODE_H_SYNCEND
) == stuff->hsyncend && VidModeGetModeValue(mode, VIDMODE_H_TOTAL
) == stuff->htotal && VidModeGetModeValue(mode, VIDMODE_V_DISPLAY
) == stuff->vdisplay && VidModeGetModeValue(mode, VIDMODE_V_SYNCSTART
) == stuff->vsyncstart && VidModeGetModeValue(mode
, VIDMODE_V_SYNCEND) == stuff->vsyncend && VidModeGetModeValue
(mode, VIDMODE_V_TOTAL) == stuff->vtotal && VidModeGetModeValue
(mode, VIDMODE_FLAGS) == stuff->flags )
) {
1108
1109 if (!pVidMode->SwitchMode(pScreen, mode))
1110 return BadValue2;
1111
1112 DebugF("SwitchToMode - Succeeded\n");
1113 return Success0;
1114 }
1115 } while (pVidMode->GetNextModeline(pScreen, &mode, &dotClock));
1116
1117 return BadValue2;
1118}
1119
1120static int
1121ProcVidModeLockModeSwitch(ClientPtr client)
1122{
1123 REQUEST(xXF86VidModeLockModeSwitchReq)xXF86VidModeLockModeSwitchReq *stuff = (xXF86VidModeLockModeSwitchReq
*)client->requestBuffer
;
1124 ScreenPtr pScreen;
1125 VidModePtr pVidMode;
1126
1127 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq)if ((sizeof(xXF86VidModeLockModeSwitchReq) >> 2) != client
->req_len) return(16)
;
1128
1129 DEBUG_P("XF86VidModeLockModeSwitch");
1130
1131 if (stuff->screen >= screenInfo.numScreens)
1132 return BadValue2;
1133 pScreen = screenInfo.screens[stuff->screen];
1134
1135 pVidMode = VidModeGetPtr(pScreen);
1136 if (pVidMode == NULL((void*)0))
1137 return BadImplementation17;
1138
1139 if (!pVidMode->LockZoom(pScreen, (short) stuff->lock))
1140 return VidModeErrorBase + XF86VidModeZoomLocked6;
1141
1142 return Success0;
1143}
1144
1145static int
1146ProcVidModeGetMonitor(ClientPtr client)
1147{
1148 REQUEST(xXF86VidModeGetMonitorReq)xXF86VidModeGetMonitorReq *stuff = (xXF86VidModeGetMonitorReq
*)client->requestBuffer
;
1149 xXF86VidModeGetMonitorReply rep = {
1150 .type = X_Reply1,
1151 .sequenceNumber = client->sequence
1152 };
1153 CARD32 *hsyncdata, *vsyncdata;
1154 ScreenPtr pScreen;
1155 VidModePtr pVidMode;
1156 int i, nHsync, nVrefresh;
1157
1158 DEBUG_P("XF86VidModeGetMonitor");
1159
1160 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq)if ((sizeof(xXF86VidModeGetMonitorReq) >> 2) != client->
req_len) return(16)
;
1161
1162 if (stuff->screen >= screenInfo.numScreens)
1163 return BadValue2;
1164 pScreen = screenInfo.screens[stuff->screen];
1165
1166 pVidMode = VidModeGetPtr(pScreen);
1167 if (pVidMode == NULL((void*)0))
1168 return BadImplementation17;
1169
1170 nHsync = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NHSYNC, 0).i;
1171 nVrefresh = pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_NVREFRESH, 0).i;
1172
1173 if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr)
1174 rep.vendorLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
1175 VIDMODE_MON_VENDOR,
1176 0)).ptr);
1177 else
1178 rep.vendorLength = 0;
1179 if ((char *) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr)
1180 rep.modelLength = strlen((char *) (pVidMode->GetMonitorValue(pScreen,
1181 VIDMODE_MON_MODEL,
1182 0)).ptr);
1183 else
1184 rep.modelLength = 0;
1185 rep.length =
1186 bytes_to_int32(SIZEOF(xXF86VidModeGetMonitorReply)32 -
1187 SIZEOF(xGenericReply)32 + (nHsync +
1188 nVrefresh) * sizeof(CARD32) +
1189 pad_to_int32(rep.vendorLength) +
1190 pad_to_int32(rep.modelLength));
1191 rep.nhsync = nHsync;
1192 rep.nvsync = nVrefresh;
1193 hsyncdata = xallocarray(nHsync, sizeof(CARD32))xreallocarray(((void*)0), (nHsync), (sizeof(CARD32)));
1194 if (!hsyncdata) {
1195 return BadAlloc11;
1196 }
1197 vsyncdata = xallocarray(nVrefresh, sizeof(CARD32))xreallocarray(((void*)0), (nVrefresh), (sizeof(CARD32)));
1198
1199 if (!vsyncdata) {
1200 free(hsyncdata);
1201 return BadAlloc11;
1202 }
1203
1204 for (i = 0; i < nHsync; i++) {
1205 hsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
1206 VIDMODE_MON_HSYNC_LO,
1207 i)).f |
1208 (unsigned
1209 short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_HSYNC_HI,
1210 i)).f << 16;
1211 }
1212 for (i = 0; i < nVrefresh; i++) {
1213 vsyncdata[i] = (unsigned short) (pVidMode->GetMonitorValue(pScreen,
1214 VIDMODE_MON_VREFRESH_LO,
1215 i)).f |
1216 (unsigned
1217 short) (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VREFRESH_HI,
1218 i)).f << 16;
1219 }
1220
1221 if (client->swapped) {
1222 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1223 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1224 }
1225 WriteToClient(client, SIZEOF(xXF86VidModeGetMonitorReply)32, &rep);
1226 client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
1227 WriteSwappedDataToClient(client, nHsync * sizeof(CARD32), hsyncdata)if ((client)->swapped) (*(client)->pSwapReplyFunc)(client
, (int)(nHsync * sizeof(CARD32)), hsyncdata); else WriteToClient
(client, (int)(nHsync * sizeof(CARD32)), (hsyncdata));
;
1228 WriteSwappedDataToClient(client, nVrefresh * sizeof(CARD32), vsyncdata)if ((client)->swapped) (*(client)->pSwapReplyFunc)(client
, (int)(nVrefresh * sizeof(CARD32)), vsyncdata); else WriteToClient
(client, (int)(nVrefresh * sizeof(CARD32)), (vsyncdata));
;
1229 if (rep.vendorLength)
1230 WriteToClient(client, rep.vendorLength,
1231 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_VENDOR, 0)).ptr);
1232 if (rep.modelLength)
1233 WriteToClient(client, rep.modelLength,
1234 (pVidMode->GetMonitorValue(pScreen, VIDMODE_MON_MODEL, 0)).ptr);
1235
1236 free(hsyncdata);
1237 free(vsyncdata);
1238
1239 return Success0;
1240}
1241
1242static int
1243ProcVidModeGetViewPort(ClientPtr client)
1244{
1245 REQUEST(xXF86VidModeGetViewPortReq)xXF86VidModeGetViewPortReq *stuff = (xXF86VidModeGetViewPortReq
*)client->requestBuffer
;
1246 xXF86VidModeGetViewPortReply rep;
1247 ScreenPtr pScreen;
1248 VidModePtr pVidMode;
1249 int x, y;
1250
1251 DEBUG_P("XF86VidModeGetViewPort");
1252
1253 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq)if ((sizeof(xXF86VidModeGetViewPortReq) >> 2) != client
->req_len) return(16)
;
1254
1255 if (stuff->screen >= screenInfo.numScreens)
1256 return BadValue2;
1257 pScreen = screenInfo.screens[stuff->screen];
1258
1259 pVidMode = VidModeGetPtr(pScreen);
1260 if (pVidMode == NULL((void*)0))
1261 return BadImplementation17;
1262
1263 pVidMode->GetViewPort(pScreen, &x, &y);
1264
1265 rep = (xXF86VidModeGetViewPortReply) {
1266 .type = X_Reply1,
1267 .sequenceNumber = client->sequence,
1268 .length = 0,
1269 .x = x,
1270 .y = y
1271 };
1272
1273 if (client->swapped) {
1274 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1275 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1276 swapl(&rep.x)do { if (sizeof(*(&rep.x)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.x) & 3) && ((uintptr_t)(&
rep.x) & 3) == 0) *(&rep.x) = lswapl(*(&rep.x)); else
swap_uint32((uint32_t *)(&rep.x)); } while (0)
;
1277 swapl(&rep.y)do { if (sizeof(*(&rep.y)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.y) & 3) && ((uintptr_t)(&
rep.y) & 3) == 0) *(&rep.y) = lswapl(*(&rep.y)); else
swap_uint32((uint32_t *)(&rep.y)); } while (0)
;
1278 }
1279 WriteToClient(client, SIZEOF(xXF86VidModeGetViewPortReply)32, &rep);
1280 return Success0;
1281}
1282
1283static int
1284ProcVidModeSetViewPort(ClientPtr client)
1285{
1286 REQUEST(xXF86VidModeSetViewPortReq)xXF86VidModeSetViewPortReq *stuff = (xXF86VidModeSetViewPortReq
*)client->requestBuffer
;
1287 ScreenPtr pScreen;
1288 VidModePtr pVidMode;
1289
1290 DEBUG_P("XF86VidModeSetViewPort");
1291
1292 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq)if ((sizeof(xXF86VidModeSetViewPortReq) >> 2) != client
->req_len) return(16)
;
1293
1294 if (stuff->screen >= screenInfo.numScreens)
1295 return BadValue2;
1296 pScreen = screenInfo.screens[stuff->screen];
1297
1298 pVidMode = VidModeGetPtr(pScreen);
1299 if (pVidMode == NULL((void*)0))
1300 return BadImplementation17;
1301
1302 if (!pVidMode->SetViewPort(pScreen, stuff->x, stuff->y))
1303 return BadValue2;
1304
1305 return Success0;
1306}
1307
1308static int
1309ProcVidModeGetDotClocks(ClientPtr client)
1310{
1311 REQUEST(xXF86VidModeGetDotClocksReq)xXF86VidModeGetDotClocksReq *stuff = (xXF86VidModeGetDotClocksReq
*)client->requestBuffer
;
1312 xXF86VidModeGetDotClocksReply rep;
1313 ScreenPtr pScreen;
1314 VidModePtr pVidMode;
1315 int n;
1316 int numClocks;
1317 CARD32 dotclock;
1318 int *Clocks = NULL((void*)0);
1319 Bool ClockProg;
1320
1321 DEBUG_P("XF86VidModeGetDotClocks");
1322
1323 REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq)if ((sizeof(xXF86VidModeGetDotClocksReq) >> 2) != client
->req_len) return(16)
;
1324
1325 if (stuff->screen >= screenInfo.numScreens)
1
Taking false branch
1326 return BadValue2;
1327 pScreen = screenInfo.screens[stuff->screen];
1328
1329 pVidMode = VidModeGetPtr(pScreen);
1330 if (pVidMode == NULL((void*)0))
2
Assuming 'pVidMode' is not equal to null
3
Taking false branch
1331 return BadImplementation17;
1332
1333 numClocks = pVidMode->GetNumOfClocks(pScreen, &ClockProg);
1334
1335 rep = (xXF86VidModeGetDotClocksReply) {
1336 .type = X_Reply1,
1337 .sequenceNumber = client->sequence,
1338 .length = bytes_to_int32(SIZEOF(xXF86VidModeGetDotClocksReply)32
1339 - SIZEOF(xGenericReply)32 + numClocks),
1340 .clocks = numClocks,
1341 .maxclocks = MAXCLOCKS128,
1342 .flags = 0
1343 };
1344
1345 if (!ClockProg) {
4
Assuming 'ClockProg' is 0
5
Taking true branch
1346 Clocks = calloc(numClocks, sizeof(int));
1347 if (!Clocks)
6
Assuming 'Clocks' is non-null
7
Taking false branch
1348 return BadValue2;
1349 if (!pVidMode->GetClocks(pScreen, Clocks)) {
8
Taking false branch
1350 free(Clocks);
1351 return BadValue2;
1352 }
1353 }
1354 if (ClockProg) {
9
Taking false branch
1355 rep.flags |= CLKFLAG_PROGRAMABLE1;
1356 }
1357 if (client->swapped) {
10
Taking false branch
1358 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1359 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1360 swapl(&rep.clocks)do { if (sizeof(*(&rep.clocks)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.clocks) & 3) && ((uintptr_t
)(&rep.clocks) & 3) == 0) *(&rep.clocks) = lswapl
(*(&rep.clocks)); else swap_uint32((uint32_t *)(&rep.
clocks)); } while (0)
;
1361 swapl(&rep.maxclocks)do { if (sizeof(*(&rep.maxclocks)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.maxclocks) & 3
) && ((uintptr_t)(&rep.maxclocks) & 3) == 0) *
(&rep.maxclocks) = lswapl(*(&rep.maxclocks)); else swap_uint32
((uint32_t *)(&rep.maxclocks)); } while (0)
;
1362 swapl(&rep.flags)do { if (sizeof(*(&rep.flags)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.flags) & 3) && ((uintptr_t)
(&rep.flags) & 3) == 0) *(&rep.flags) = lswapl(*(
&rep.flags)); else swap_uint32((uint32_t *)(&rep.flags
)); } while (0)
;
1363 }
1364 WriteToClient(client, sizeof(xXF86VidModeGetDotClocksReply), &rep);
1365 if (!ClockProg) {
11
Taking true branch
1366 for (n = 0; n < numClocks; n++) {
12
Assuming 'n' is < 'numClocks'
13
Loop condition is true. Entering loop body
15
Assuming 'n' is >= 'numClocks'
16
Loop condition is false. Execution continues on line 1377
1367 dotclock = *Clocks++;
1368 if (client->swapped) {
14
Taking false branch
1369 WriteSwappedDataToClient(client, 4, (char *) &dotclock)if ((client)->swapped) (*(client)->pSwapReplyFunc)(client
, (int)(4), (char *) &dotclock); else WriteToClient(client
, (int)(4), ((char *) &dotclock));
;
1370 }
1371 else {
1372 WriteToClient(client, 4, &dotclock);
1373 }
1374 }
1375 }
1376
1377 free(Clocks);
17
Argument to free() is offset by 4 bytes from the start of memory allocated by calloc()
1378 return Success0;
1379}
1380
1381static int
1382ProcVidModeSetGamma(ClientPtr client)
1383{
1384 REQUEST(xXF86VidModeSetGammaReq)xXF86VidModeSetGammaReq *stuff = (xXF86VidModeSetGammaReq *)client
->requestBuffer
;
1385 ScreenPtr pScreen;
1386 VidModePtr pVidMode;
1387
1388 DEBUG_P("XF86VidModeSetGamma");
1389
1390 REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq)if ((sizeof(xXF86VidModeSetGammaReq) >> 2) != client->
req_len) return(16)
;
1391
1392 if (stuff->screen >= screenInfo.numScreens)
1393 return BadValue2;
1394 pScreen = screenInfo.screens[stuff->screen];
1395
1396 pVidMode = VidModeGetPtr(pScreen);
1397 if (pVidMode == NULL((void*)0))
1398 return BadImplementation17;
1399
1400 if (!pVidMode->SetGamma(pScreen, ((float) stuff->red) / 10000.,
1401 ((float) stuff->green) / 10000.,
1402 ((float) stuff->blue) / 10000.))
1403 return BadValue2;
1404
1405 return Success0;
1406}
1407
1408static int
1409ProcVidModeGetGamma(ClientPtr client)
1410{
1411 REQUEST(xXF86VidModeGetGammaReq)xXF86VidModeGetGammaReq *stuff = (xXF86VidModeGetGammaReq *)client
->requestBuffer
;
1412 xXF86VidModeGetGammaReply rep;
1413 ScreenPtr pScreen;
1414 VidModePtr pVidMode;
1415 float red, green, blue;
1416
1417 DEBUG_P("XF86VidModeGetGamma");
1418
1419 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq)if ((sizeof(xXF86VidModeGetGammaReq) >> 2) != client->
req_len) return(16)
;
1420
1421 if (stuff->screen >= screenInfo.numScreens)
1422 return BadValue2;
1423 pScreen = screenInfo.screens[stuff->screen];
1424
1425 pVidMode = VidModeGetPtr(pScreen);
1426 if (pVidMode == NULL((void*)0))
1427 return BadImplementation17;
1428
1429 if (!pVidMode->GetGamma(pScreen, &red, &green, &blue))
1430 return BadValue2;
1431 rep = (xXF86VidModeGetGammaReply) {
1432 .type = X_Reply1,
1433 .sequenceNumber = client->sequence,
1434 .length = 0,
1435 .red = (CARD32) (red * 10000.),
1436 .green = (CARD32) (green * 10000.),
1437 .blue = (CARD32) (blue * 10000.)
1438 };
1439 if (client->swapped) {
1440 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1441 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1442 swapl(&rep.red)do { if (sizeof(*(&rep.red)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.red) & 3) && ((uintptr_t)(&
rep.red) & 3) == 0) *(&rep.red) = lswapl(*(&rep.red
)); else swap_uint32((uint32_t *)(&rep.red)); } while (0)
;
1443 swapl(&rep.green)do { if (sizeof(*(&rep.green)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.green) & 3) && ((uintptr_t)
(&rep.green) & 3) == 0) *(&rep.green) = lswapl(*(
&rep.green)); else swap_uint32((uint32_t *)(&rep.green
)); } while (0)
;
1444 swapl(&rep.blue)do { if (sizeof(*(&rep.blue)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.blue) & 3) && ((uintptr_t)(
&rep.blue) & 3) == 0) *(&rep.blue) = lswapl(*(&
rep.blue)); else swap_uint32((uint32_t *)(&rep.blue)); } while
(0)
;
1445 }
1446 WriteToClient(client, sizeof(xXF86VidModeGetGammaReply), &rep);
1447
1448 return Success0;
1449}
1450
1451static int
1452ProcVidModeSetGammaRamp(ClientPtr client)
1453{
1454 CARD16 *r, *g, *b;
1455 int length;
1456 ScreenPtr pScreen;
1457 VidModePtr pVidMode;
1458
1459 REQUEST(xXF86VidModeSetGammaRampReq)xXF86VidModeSetGammaRampReq *stuff = (xXF86VidModeSetGammaRampReq
*)client->requestBuffer
;
1460
1461 if (stuff->screen >= screenInfo.numScreens)
1462 return BadValue2;
1463 pScreen = screenInfo.screens[stuff->screen];
1464
1465 pVidMode = VidModeGetPtr(pScreen);
1466 if (pVidMode == NULL((void*)0))
1467 return BadImplementation17;
1468
1469 if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
1470 return BadValue2;
1471
1472 length = (stuff->size + 1) & ~1;
1473
1474 REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length * 6)if (((sizeof(xXF86VidModeSetGammaRampReq) >> 2) > client
->req_len) || (((length * 6) >> 2) >= client->
req_len) || ((((uint64_t) sizeof(xXF86VidModeSetGammaRampReq)
+ (length * 6) + 3) >> 2) != (uint64_t) client->req_len
)) return(16)
;
1475
1476 r = (CARD16 *) &stuff[1];
1477 g = r + length;
1478 b = g + length;
1479
1480 if (!pVidMode->SetGammaRamp(pScreen, stuff->size, r, g, b))
1481 return BadValue2;
1482
1483 return Success0;
1484}
1485
1486static int
1487ProcVidModeGetGammaRamp(ClientPtr client)
1488{
1489 CARD16 *ramp = NULL((void*)0);
1490 int length;
1491 size_t ramplen = 0;
1492 xXF86VidModeGetGammaRampReply rep;
1493 ScreenPtr pScreen;
1494 VidModePtr pVidMode;
1495
1496 REQUEST(xXF86VidModeGetGammaRampReq)xXF86VidModeGetGammaRampReq *stuff = (xXF86VidModeGetGammaRampReq
*)client->requestBuffer
;
1497
1498 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq)if ((sizeof(xXF86VidModeGetGammaRampReq) >> 2) != client
->req_len) return(16)
;
1499
1500 if (stuff->screen >= screenInfo.numScreens)
1501 return BadValue2;
1502 pScreen = screenInfo.screens[stuff->screen];
1503
1504 pVidMode = VidModeGetPtr(pScreen);
1505 if (pVidMode == NULL((void*)0))
1506 return BadImplementation17;
1507
1508 if (stuff->size != pVidMode->GetGammaRampSize(pScreen))
1509 return BadValue2;
1510
1511 length = (stuff->size + 1) & ~1;
1512
1513 if (stuff->size) {
1514 if (!(ramp = xallocarray(length, 3 * sizeof(CARD16))xreallocarray(((void*)0), (length), (3 * sizeof(CARD16)))))
1515 return BadAlloc11;
1516 ramplen = length * 3 * sizeof(CARD16);
1517
1518 if (!pVidMode->GetGammaRamp(pScreen, stuff->size,
1519 ramp, ramp + length, ramp + (length * 2))) {
1520 free(ramp);
1521 return BadValue2;
1522 }
1523 }
1524 rep = (xXF86VidModeGetGammaRampReply) {
1525 .type = X_Reply1,
1526 .sequenceNumber = client->sequence,
1527 .length = (length >> 1) * 3,
1528 .size = stuff->size
1529 };
1530 if (client->swapped) {
1531 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1532 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1533 swaps(&rep.size)do { if (sizeof(*(&rep.size)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.size) & 1) && ((uintptr_t)(
&rep.size) & 1) == 0) *(&rep.size) = lswaps(*(&
rep.size)); else swap_uint16((uint16_t *)(&rep.size)); } while
(0)
;
1534 SwapShorts((short *) ramp, length * 3);
1535 }
1536 WriteToClient(client, sizeof(xXF86VidModeGetGammaRampReply), &rep);
1537
1538 if (stuff->size) {
1539 WriteToClient(client, ramplen, ramp);
1540 free(ramp);
1541 }
1542
1543 return Success0;
1544}
1545
1546
1547static int
1548ProcVidModeGetGammaRampSize(ClientPtr client)
1549{
1550 xXF86VidModeGetGammaRampSizeReply rep;
1551 ScreenPtr pScreen;
1552 VidModePtr pVidMode;
1553
1554 REQUEST(xXF86VidModeGetGammaRampSizeReq)xXF86VidModeGetGammaRampSizeReq *stuff = (xXF86VidModeGetGammaRampSizeReq
*)client->requestBuffer
;
1555
1556 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq)if ((sizeof(xXF86VidModeGetGammaRampSizeReq) >> 2) != client
->req_len) return(16)
;
1557
1558 if (stuff->screen >= screenInfo.numScreens)
1559 return BadValue2;
1560 pScreen = screenInfo.screens[stuff->screen];
1561
1562 pVidMode = VidModeGetPtr(pScreen);
1563 if (pVidMode == NULL((void*)0))
1564 return BadImplementation17;
1565
1566 rep = (xXF86VidModeGetGammaRampSizeReply) {
1567 .type = X_Reply1,
1568 .sequenceNumber = client->sequence,
1569 .length = 0,
1570 .size = pVidMode->GetGammaRampSize(pScreen)
1571 };
1572 if (client->swapped) {
1573 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1574 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1575 swaps(&rep.size)do { if (sizeof(*(&rep.size)) != 2) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.size) & 1) && ((uintptr_t)(
&rep.size) & 1) == 0) *(&rep.size) = lswaps(*(&
rep.size)); else swap_uint16((uint16_t *)(&rep.size)); } while
(0)
;
1576 }
1577 WriteToClient(client, sizeof(xXF86VidModeGetGammaRampSizeReply), &rep);
1578
1579 return Success0;
1580}
1581
1582static int
1583ProcVidModeGetPermissions(ClientPtr client)
1584{
1585 xXF86VidModeGetPermissionsReply rep = {
1586 .type = X_Reply1,
1587 .sequenceNumber = client->sequence,
1588 .length = 0,
1589 .permissions = XF86VM_READ_PERMISSION1
1590 };
1591
1592 REQUEST(xXF86VidModeGetPermissionsReq)xXF86VidModeGetPermissionsReq *stuff = (xXF86VidModeGetPermissionsReq
*)client->requestBuffer
;
1593
1594 REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq)if ((sizeof(xXF86VidModeGetPermissionsReq) >> 2) != client
->req_len) return(16)
;
1595
1596 if (stuff->screen >= screenInfo.numScreens)
1597 return BadValue2;
1598
1599 if (VidModeAllowNonLocal || client->local) {
1600 rep.permissions |= XF86VM_WRITE_PERMISSION2;
1601 }
1602 if (client->swapped) {
1603 swaps(&rep.sequenceNumber)do { if (sizeof(*(&rep.sequenceNumber)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&rep.sequenceNumber
) & 1) && ((uintptr_t)(&rep.sequenceNumber) &
1) == 0) *(&rep.sequenceNumber) = lswaps(*(&rep.sequenceNumber
)); else swap_uint16((uint16_t *)(&rep.sequenceNumber)); }
while (0)
;
1604 swapl(&rep.length)do { if (sizeof(*(&rep.length)) != 4) wrong_size(); if (__builtin_constant_p
((uintptr_t)(&rep.length) & 3) && ((uintptr_t
)(&rep.length) & 3) == 0) *(&rep.length) = lswapl
(*(&rep.length)); else swap_uint32((uint32_t *)(&rep.
length)); } while (0)
;
1605 swapl(&rep.permissions)do { if (sizeof(*(&rep.permissions)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&rep.permissions) &
3) && ((uintptr_t)(&rep.permissions) & 3) ==
0) *(&rep.permissions) = lswapl(*(&rep.permissions))
; else swap_uint32((uint32_t *)(&rep.permissions)); } while
(0)
;
1606 }
1607 WriteToClient(client, sizeof(xXF86VidModeGetPermissionsReply), &rep);
1608
1609 return Success0;
1610}
1611
1612static int
1613ProcVidModeSetClientVersion(ClientPtr client)
1614{
1615 REQUEST(xXF86VidModeSetClientVersionReq)xXF86VidModeSetClientVersionReq *stuff = (xXF86VidModeSetClientVersionReq
*)client->requestBuffer
;
1616
1617 VidModePrivPtr pPriv;
1618
1619 DEBUG_P("XF86VidModeSetClientVersion");
1620
1621 REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq)if ((sizeof(xXF86VidModeSetClientVersionReq) >> 2) != client
->req_len) return(16)
;
1622
1623 if ((pPriv = VM_GETPRIV(client)((VidModePrivPtr) dixLookupPrivate(&(client)->devPrivates
, (&VidModeClientPrivateKeyRec)))
) == NULL((void*)0)) {
1624 pPriv = malloc(sizeof(VidModePrivRec));
1625 if (!pPriv)
1626 return BadAlloc11;
1627 VM_SETPRIV(client, pPriv)dixSetPrivate(&(client)->devPrivates, (&VidModeClientPrivateKeyRec
), pPriv)
;
1628 }
1629 pPriv->major = stuff->major;
1630
1631 pPriv->minor = stuff->minor;
1632
1633 return Success0;
1634}
1635
1636static int
1637ProcVidModeDispatch(ClientPtr client)
1638{
1639 REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer;
1640 switch (stuff->data) {
1641 case X_XF86VidModeQueryVersion0:
1642 return ProcVidModeQueryVersion(client);
1643 case X_XF86VidModeGetModeLine1:
1644 return ProcVidModeGetModeLine(client);
1645 case X_XF86VidModeGetMonitor4:
1646 return ProcVidModeGetMonitor(client);
1647 case X_XF86VidModeGetAllModeLines6:
1648 return ProcVidModeGetAllModeLines(client);
1649 case X_XF86VidModeValidateModeLine9:
1650 return ProcVidModeValidateModeLine(client);
1651 case X_XF86VidModeGetViewPort11:
1652 return ProcVidModeGetViewPort(client);
1653 case X_XF86VidModeGetDotClocks13:
1654 return ProcVidModeGetDotClocks(client);
1655 case X_XF86VidModeSetClientVersion14:
1656 return ProcVidModeSetClientVersion(client);
1657 case X_XF86VidModeGetGamma16:
1658 return ProcVidModeGetGamma(client);
1659 case X_XF86VidModeGetGammaRamp17:
1660 return ProcVidModeGetGammaRamp(client);
1661 case X_XF86VidModeGetGammaRampSize19:
1662 return ProcVidModeGetGammaRampSize(client);
1663 case X_XF86VidModeGetPermissions20:
1664 return ProcVidModeGetPermissions(client);
1665 default:
1666 if (VidModeAllowNonLocal || client->local) {
1667 switch (stuff->data) {
1668 case X_XF86VidModeAddModeLine7:
1669 return ProcVidModeAddModeLine(client);
1670 case X_XF86VidModeDeleteModeLine8:
1671 return ProcVidModeDeleteModeLine(client);
1672 case X_XF86VidModeModModeLine2:
1673 return ProcVidModeModModeLine(client);
1674 case X_XF86VidModeSwitchMode3:
1675 return ProcVidModeSwitchMode(client);
1676 case X_XF86VidModeSwitchToMode10:
1677 return ProcVidModeSwitchToMode(client);
1678 case X_XF86VidModeLockModeSwitch5:
1679 return ProcVidModeLockModeSwitch(client);
1680 case X_XF86VidModeSetViewPort12:
1681 return ProcVidModeSetViewPort(client);
1682 case X_XF86VidModeSetGamma15:
1683 return ProcVidModeSetGamma(client);
1684 case X_XF86VidModeSetGammaRamp18:
1685 return ProcVidModeSetGammaRamp(client);
1686 default:
1687 return BadRequest1;
1688 }
1689 }
1690 else
1691 return VidModeErrorBase + XF86VidModeClientNotLocal5;
1692 }
1693}
1694
1695static int
1696SProcVidModeQueryVersion(ClientPtr client)
1697{
1698 REQUEST(xXF86VidModeQueryVersionReq)xXF86VidModeQueryVersionReq *stuff = (xXF86VidModeQueryVersionReq
*)client->requestBuffer
;
1699 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1700 return ProcVidModeQueryVersion(client);
1701}
1702
1703static int
1704SProcVidModeGetModeLine(ClientPtr client)
1705{
1706 REQUEST(xXF86VidModeGetModeLineReq)xXF86VidModeGetModeLineReq *stuff = (xXF86VidModeGetModeLineReq
*)client->requestBuffer
;
1707 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1708 REQUEST_SIZE_MATCH(xXF86VidModeGetModeLineReq)if ((sizeof(xXF86VidModeGetModeLineReq) >> 2) != client
->req_len) return(16)
;
1709 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1710 return ProcVidModeGetModeLine(client);
1711}
1712
1713static int
1714SProcVidModeGetAllModeLines(ClientPtr client)
1715{
1716 REQUEST(xXF86VidModeGetAllModeLinesReq)xXF86VidModeGetAllModeLinesReq *stuff = (xXF86VidModeGetAllModeLinesReq
*)client->requestBuffer
;
1717 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1718 REQUEST_SIZE_MATCH(xXF86VidModeGetAllModeLinesReq)if ((sizeof(xXF86VidModeGetAllModeLinesReq) >> 2) != client
->req_len) return(16)
;
1719 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1720 return ProcVidModeGetAllModeLines(client);
1721}
1722
1723static int
1724SProcVidModeAddModeLine(ClientPtr client)
1725{
1726 xXF86OldVidModeAddModeLineReq *oldstuff =
1727 (xXF86OldVidModeAddModeLineReq *) client->requestBuffer;
1728 int ver;
1729
1730 REQUEST(xXF86VidModeAddModeLineReq)xXF86VidModeAddModeLineReq *stuff = (xXF86VidModeAddModeLineReq
*)client->requestBuffer
;
1731 ver = ClientMajorVersion(client);
1732 if (ver < 2) {
1733 swaps(&oldstuff->length)do { if (sizeof(*(&oldstuff->length)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->length
) & 1) && ((uintptr_t)(&oldstuff->length) &
1) == 0) *(&oldstuff->length) = lswaps(*(&oldstuff
->length)); else swap_uint16((uint16_t *)(&oldstuff->
length)); } while (0)
;
1734 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeAddModeLineReq)if ((sizeof(xXF86OldVidModeAddModeLineReq) >> 2) > client
->req_len ) return(16)
;
1735 swapl(&oldstuff->screen)do { if (sizeof(*(&oldstuff->screen)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->screen
) & 3) && ((uintptr_t)(&oldstuff->screen) &
3) == 0) *(&oldstuff->screen) = lswapl(*(&oldstuff
->screen)); else swap_uint32((uint32_t *)(&oldstuff->
screen)); } while (0)
;
1736 swaps(&oldstuff->hdisplay)do { if (sizeof(*(&oldstuff->hdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hdisplay
) & 1) && ((uintptr_t)(&oldstuff->hdisplay
) & 1) == 0) *(&oldstuff->hdisplay) = lswaps(*(&
oldstuff->hdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->hdisplay)); } while (0)
;
1737 swaps(&oldstuff->hsyncstart)do { if (sizeof(*(&oldstuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncstart
) & 1) && ((uintptr_t)(&oldstuff->hsyncstart
) & 1) == 0) *(&oldstuff->hsyncstart) = lswaps(*(&
oldstuff->hsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->hsyncstart)); } while (0)
;
1738 swaps(&oldstuff->hsyncend)do { if (sizeof(*(&oldstuff->hsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncend
) & 1) && ((uintptr_t)(&oldstuff->hsyncend
) & 1) == 0) *(&oldstuff->hsyncend) = lswaps(*(&
oldstuff->hsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->hsyncend)); } while (0)
;
1739 swaps(&oldstuff->htotal)do { if (sizeof(*(&oldstuff->htotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->htotal
) & 1) && ((uintptr_t)(&oldstuff->htotal) &
1) == 0) *(&oldstuff->htotal) = lswaps(*(&oldstuff
->htotal)); else swap_uint16((uint16_t *)(&oldstuff->
htotal)); } while (0)
;
1740 swaps(&oldstuff->vdisplay)do { if (sizeof(*(&oldstuff->vdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vdisplay
) & 1) && ((uintptr_t)(&oldstuff->vdisplay
) & 1) == 0) *(&oldstuff->vdisplay) = lswaps(*(&
oldstuff->vdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->vdisplay)); } while (0)
;
1741 swaps(&oldstuff->vsyncstart)do { if (sizeof(*(&oldstuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncstart
) & 1) && ((uintptr_t)(&oldstuff->vsyncstart
) & 1) == 0) *(&oldstuff->vsyncstart) = lswaps(*(&
oldstuff->vsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->vsyncstart)); } while (0)
;
1742 swaps(&oldstuff->vsyncend)do { if (sizeof(*(&oldstuff->vsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncend
) & 1) && ((uintptr_t)(&oldstuff->vsyncend
) & 1) == 0) *(&oldstuff->vsyncend) = lswaps(*(&
oldstuff->vsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->vsyncend)); } while (0)
;
1743 swaps(&oldstuff->vtotal)do { if (sizeof(*(&oldstuff->vtotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vtotal
) & 1) && ((uintptr_t)(&oldstuff->vtotal) &
1) == 0) *(&oldstuff->vtotal) = lswaps(*(&oldstuff
->vtotal)); else swap_uint16((uint16_t *)(&oldstuff->
vtotal)); } while (0)
;
1744 swapl(&oldstuff->flags)do { if (sizeof(*(&oldstuff->flags)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&oldstuff->flags
) & 3) && ((uintptr_t)(&oldstuff->flags) &
3) == 0) *(&oldstuff->flags) = lswapl(*(&oldstuff
->flags)); else swap_uint32((uint32_t *)(&oldstuff->
flags)); } while (0)
;
1745 swapl(&oldstuff->privsize)do { if (sizeof(*(&oldstuff->privsize)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->privsize
) & 3) && ((uintptr_t)(&oldstuff->privsize
) & 3) == 0) *(&oldstuff->privsize) = lswapl(*(&
oldstuff->privsize)); else swap_uint32((uint32_t *)(&oldstuff
->privsize)); } while (0)
;
1746 SwapRestL(oldstuff)SwapLongs((CARD32 *)(oldstuff + 1), (client->req_len - (sizeof
(*oldstuff) >> 2)))
;
1747 }
1748 else {
1749 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1750 REQUEST_AT_LEAST_SIZE(xXF86VidModeAddModeLineReq)if ((sizeof(xXF86VidModeAddModeLineReq) >> 2) > client
->req_len ) return(16)
;
1751 swapl(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
3) && ((uintptr_t)(&stuff->screen) & 3) ==
0) *(&stuff->screen) = lswapl(*(&stuff->screen
)); else swap_uint32((uint32_t *)(&stuff->screen)); } while
(0)
;
1752 swaps(&stuff->hdisplay)do { if (sizeof(*(&stuff->hdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hdisplay
) & 1) && ((uintptr_t)(&stuff->hdisplay) &
1) == 0) *(&stuff->hdisplay) = lswaps(*(&stuff->
hdisplay)); else swap_uint16((uint16_t *)(&stuff->hdisplay
)); } while (0)
;
1753 swaps(&stuff->hsyncstart)do { if (sizeof(*(&stuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncstart
) & 1) && ((uintptr_t)(&stuff->hsyncstart)
& 1) == 0) *(&stuff->hsyncstart) = lswaps(*(&
stuff->hsyncstart)); else swap_uint16((uint16_t *)(&stuff
->hsyncstart)); } while (0)
;
1754 swaps(&stuff->hsyncend)do { if (sizeof(*(&stuff->hsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncend
) & 1) && ((uintptr_t)(&stuff->hsyncend) &
1) == 0) *(&stuff->hsyncend) = lswaps(*(&stuff->
hsyncend)); else swap_uint16((uint16_t *)(&stuff->hsyncend
)); } while (0)
;
1755 swaps(&stuff->htotal)do { if (sizeof(*(&stuff->htotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->htotal) &
1) && ((uintptr_t)(&stuff->htotal) & 1) ==
0) *(&stuff->htotal) = lswaps(*(&stuff->htotal
)); else swap_uint16((uint16_t *)(&stuff->htotal)); } while
(0)
;
1756 swaps(&stuff->hskew)do { if (sizeof(*(&stuff->hskew)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->hskew) &
1) && ((uintptr_t)(&stuff->hskew) & 1) ==
0) *(&stuff->hskew) = lswaps(*(&stuff->hskew))
; else swap_uint16((uint16_t *)(&stuff->hskew)); } while
(0)
;
1757 swaps(&stuff->vdisplay)do { if (sizeof(*(&stuff->vdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vdisplay
) & 1) && ((uintptr_t)(&stuff->vdisplay) &
1) == 0) *(&stuff->vdisplay) = lswaps(*(&stuff->
vdisplay)); else swap_uint16((uint16_t *)(&stuff->vdisplay
)); } while (0)
;
1758 swaps(&stuff->vsyncstart)do { if (sizeof(*(&stuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncstart
) & 1) && ((uintptr_t)(&stuff->vsyncstart)
& 1) == 0) *(&stuff->vsyncstart) = lswaps(*(&
stuff->vsyncstart)); else swap_uint16((uint16_t *)(&stuff
->vsyncstart)); } while (0)
;
1759 swaps(&stuff->vsyncend)do { if (sizeof(*(&stuff->vsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncend
) & 1) && ((uintptr_t)(&stuff->vsyncend) &
1) == 0) *(&stuff->vsyncend) = lswaps(*(&stuff->
vsyncend)); else swap_uint16((uint16_t *)(&stuff->vsyncend
)); } while (0)
;
1760 swaps(&stuff->vtotal)do { if (sizeof(*(&stuff->vtotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->vtotal) &
1) && ((uintptr_t)(&stuff->vtotal) & 1) ==
0) *(&stuff->vtotal) = lswaps(*(&stuff->vtotal
)); else swap_uint16((uint16_t *)(&stuff->vtotal)); } while
(0)
;
1761 swapl(&stuff->flags)do { if (sizeof(*(&stuff->flags)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->flags) &
3) && ((uintptr_t)(&stuff->flags) & 3) ==
0) *(&stuff->flags) = lswapl(*(&stuff->flags))
; else swap_uint32((uint32_t *)(&stuff->flags)); } while
(0)
;
1762 swapl(&stuff->privsize)do { if (sizeof(*(&stuff->privsize)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->privsize
) & 3) && ((uintptr_t)(&stuff->privsize) &
3) == 0) *(&stuff->privsize) = lswapl(*(&stuff->
privsize)); else swap_uint32((uint32_t *)(&stuff->privsize
)); } while (0)
;
1763 SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof
(*stuff) >> 2)))
;
1764 }
1765 return ProcVidModeAddModeLine(client);
1766}
1767
1768static int
1769SProcVidModeDeleteModeLine(ClientPtr client)
1770{
1771 xXF86OldVidModeDeleteModeLineReq *oldstuff =
1772 (xXF86OldVidModeDeleteModeLineReq *) client->requestBuffer;
1773 int ver;
1774
1775 REQUEST(xXF86VidModeDeleteModeLineReq)xXF86VidModeDeleteModeLineReq *stuff = (xXF86VidModeDeleteModeLineReq
*)client->requestBuffer
;
1776 ver = ClientMajorVersion(client);
1777 if (ver < 2) {
1778 swaps(&oldstuff->length)do { if (sizeof(*(&oldstuff->length)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->length
) & 1) && ((uintptr_t)(&oldstuff->length) &
1) == 0) *(&oldstuff->length) = lswaps(*(&oldstuff
->length)); else swap_uint16((uint16_t *)(&oldstuff->
length)); } while (0)
;
1779 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeDeleteModeLineReq)if ((sizeof(xXF86OldVidModeDeleteModeLineReq) >> 2) >
client->req_len ) return(16)
;
1780 swapl(&oldstuff->screen)do { if (sizeof(*(&oldstuff->screen)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->screen
) & 3) && ((uintptr_t)(&oldstuff->screen) &
3) == 0) *(&oldstuff->screen) = lswapl(*(&oldstuff
->screen)); else swap_uint32((uint32_t *)(&oldstuff->
screen)); } while (0)
;
1781 swaps(&oldstuff->hdisplay)do { if (sizeof(*(&oldstuff->hdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hdisplay
) & 1) && ((uintptr_t)(&oldstuff->hdisplay
) & 1) == 0) *(&oldstuff->hdisplay) = lswaps(*(&
oldstuff->hdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->hdisplay)); } while (0)
;
1782 swaps(&oldstuff->hsyncstart)do { if (sizeof(*(&oldstuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncstart
) & 1) && ((uintptr_t)(&oldstuff->hsyncstart
) & 1) == 0) *(&oldstuff->hsyncstart) = lswaps(*(&
oldstuff->hsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->hsyncstart)); } while (0)
;
1783 swaps(&oldstuff->hsyncend)do { if (sizeof(*(&oldstuff->hsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncend
) & 1) && ((uintptr_t)(&oldstuff->hsyncend
) & 1) == 0) *(&oldstuff->hsyncend) = lswaps(*(&
oldstuff->hsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->hsyncend)); } while (0)
;
1784 swaps(&oldstuff->htotal)do { if (sizeof(*(&oldstuff->htotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->htotal
) & 1) && ((uintptr_t)(&oldstuff->htotal) &
1) == 0) *(&oldstuff->htotal) = lswaps(*(&oldstuff
->htotal)); else swap_uint16((uint16_t *)(&oldstuff->
htotal)); } while (0)
;
1785 swaps(&oldstuff->vdisplay)do { if (sizeof(*(&oldstuff->vdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vdisplay
) & 1) && ((uintptr_t)(&oldstuff->vdisplay
) & 1) == 0) *(&oldstuff->vdisplay) = lswaps(*(&
oldstuff->vdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->vdisplay)); } while (0)
;
1786 swaps(&oldstuff->vsyncstart)do { if (sizeof(*(&oldstuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncstart
) & 1) && ((uintptr_t)(&oldstuff->vsyncstart
) & 1) == 0) *(&oldstuff->vsyncstart) = lswaps(*(&
oldstuff->vsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->vsyncstart)); } while (0)
;
1787 swaps(&oldstuff->vsyncend)do { if (sizeof(*(&oldstuff->vsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncend
) & 1) && ((uintptr_t)(&oldstuff->vsyncend
) & 1) == 0) *(&oldstuff->vsyncend) = lswaps(*(&
oldstuff->vsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->vsyncend)); } while (0)
;
1788 swaps(&oldstuff->vtotal)do { if (sizeof(*(&oldstuff->vtotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vtotal
) & 1) && ((uintptr_t)(&oldstuff->vtotal) &
1) == 0) *(&oldstuff->vtotal) = lswaps(*(&oldstuff
->vtotal)); else swap_uint16((uint16_t *)(&oldstuff->
vtotal)); } while (0)
;
1789 swapl(&oldstuff->flags)do { if (sizeof(*(&oldstuff->flags)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&oldstuff->flags
) & 3) && ((uintptr_t)(&oldstuff->flags) &
3) == 0) *(&oldstuff->flags) = lswapl(*(&oldstuff
->flags)); else swap_uint32((uint32_t *)(&oldstuff->
flags)); } while (0)
;
1790 swapl(&oldstuff->privsize)do { if (sizeof(*(&oldstuff->privsize)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->privsize
) & 3) && ((uintptr_t)(&oldstuff->privsize
) & 3) == 0) *(&oldstuff->privsize) = lswapl(*(&
oldstuff->privsize)); else swap_uint32((uint32_t *)(&oldstuff
->privsize)); } while (0)
;
1791 SwapRestL(oldstuff)SwapLongs((CARD32 *)(oldstuff + 1), (client->req_len - (sizeof
(*oldstuff) >> 2)))
;
1792 }
1793 else {
1794 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1795 REQUEST_AT_LEAST_SIZE(xXF86VidModeDeleteModeLineReq)if ((sizeof(xXF86VidModeDeleteModeLineReq) >> 2) > client
->req_len ) return(16)
;
1796 swapl(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
3) && ((uintptr_t)(&stuff->screen) & 3) ==
0) *(&stuff->screen) = lswapl(*(&stuff->screen
)); else swap_uint32((uint32_t *)(&stuff->screen)); } while
(0)
;
1797 swaps(&stuff->hdisplay)do { if (sizeof(*(&stuff->hdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hdisplay
) & 1) && ((uintptr_t)(&stuff->hdisplay) &
1) == 0) *(&stuff->hdisplay) = lswaps(*(&stuff->
hdisplay)); else swap_uint16((uint16_t *)(&stuff->hdisplay
)); } while (0)
;
1798 swaps(&stuff->hsyncstart)do { if (sizeof(*(&stuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncstart
) & 1) && ((uintptr_t)(&stuff->hsyncstart)
& 1) == 0) *(&stuff->hsyncstart) = lswaps(*(&
stuff->hsyncstart)); else swap_uint16((uint16_t *)(&stuff
->hsyncstart)); } while (0)
;
1799 swaps(&stuff->hsyncend)do { if (sizeof(*(&stuff->hsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncend
) & 1) && ((uintptr_t)(&stuff->hsyncend) &
1) == 0) *(&stuff->hsyncend) = lswaps(*(&stuff->
hsyncend)); else swap_uint16((uint16_t *)(&stuff->hsyncend
)); } while (0)
;
1800 swaps(&stuff->htotal)do { if (sizeof(*(&stuff->htotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->htotal) &
1) && ((uintptr_t)(&stuff->htotal) & 1) ==
0) *(&stuff->htotal) = lswaps(*(&stuff->htotal
)); else swap_uint16((uint16_t *)(&stuff->htotal)); } while
(0)
;
1801 swaps(&stuff->hskew)do { if (sizeof(*(&stuff->hskew)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->hskew) &
1) && ((uintptr_t)(&stuff->hskew) & 1) ==
0) *(&stuff->hskew) = lswaps(*(&stuff->hskew))
; else swap_uint16((uint16_t *)(&stuff->hskew)); } while
(0)
;
1802 swaps(&stuff->vdisplay)do { if (sizeof(*(&stuff->vdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vdisplay
) & 1) && ((uintptr_t)(&stuff->vdisplay) &
1) == 0) *(&stuff->vdisplay) = lswaps(*(&stuff->
vdisplay)); else swap_uint16((uint16_t *)(&stuff->vdisplay
)); } while (0)
;
1803 swaps(&stuff->vsyncstart)do { if (sizeof(*(&stuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncstart
) & 1) && ((uintptr_t)(&stuff->vsyncstart)
& 1) == 0) *(&stuff->vsyncstart) = lswaps(*(&
stuff->vsyncstart)); else swap_uint16((uint16_t *)(&stuff
->vsyncstart)); } while (0)
;
1804 swaps(&stuff->vsyncend)do { if (sizeof(*(&stuff->vsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncend
) & 1) && ((uintptr_t)(&stuff->vsyncend) &
1) == 0) *(&stuff->vsyncend) = lswaps(*(&stuff->
vsyncend)); else swap_uint16((uint16_t *)(&stuff->vsyncend
)); } while (0)
;
1805 swaps(&stuff->vtotal)do { if (sizeof(*(&stuff->vtotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->vtotal) &
1) && ((uintptr_t)(&stuff->vtotal) & 1) ==
0) *(&stuff->vtotal) = lswaps(*(&stuff->vtotal
)); else swap_uint16((uint16_t *)(&stuff->vtotal)); } while
(0)
;
1806 swapl(&stuff->flags)do { if (sizeof(*(&stuff->flags)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->flags) &
3) && ((uintptr_t)(&stuff->flags) & 3) ==
0) *(&stuff->flags) = lswapl(*(&stuff->flags))
; else swap_uint32((uint32_t *)(&stuff->flags)); } while
(0)
;
1807 swapl(&stuff->privsize)do { if (sizeof(*(&stuff->privsize)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->privsize
) & 3) && ((uintptr_t)(&stuff->privsize) &
3) == 0) *(&stuff->privsize) = lswapl(*(&stuff->
privsize)); else swap_uint32((uint32_t *)(&stuff->privsize
)); } while (0)
;
1808 SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof
(*stuff) >> 2)))
;
1809 }
1810 return ProcVidModeDeleteModeLine(client);
1811}
1812
1813static int
1814SProcVidModeModModeLine(ClientPtr client)
1815{
1816 xXF86OldVidModeModModeLineReq *oldstuff =
1817 (xXF86OldVidModeModModeLineReq *) client->requestBuffer;
1818 int ver;
1819
1820 REQUEST(xXF86VidModeModModeLineReq)xXF86VidModeModModeLineReq *stuff = (xXF86VidModeModModeLineReq
*)client->requestBuffer
;
1821 ver = ClientMajorVersion(client);
1822 if (ver < 2) {
1823 swaps(&oldstuff->length)do { if (sizeof(*(&oldstuff->length)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->length
) & 1) && ((uintptr_t)(&oldstuff->length) &
1) == 0) *(&oldstuff->length) = lswaps(*(&oldstuff
->length)); else swap_uint16((uint16_t *)(&oldstuff->
length)); } while (0)
;
1824 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeModModeLineReq)if ((sizeof(xXF86OldVidModeModModeLineReq) >> 2) > client
->req_len ) return(16)
;
1825 swapl(&oldstuff->screen)do { if (sizeof(*(&oldstuff->screen)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->screen
) & 3) && ((uintptr_t)(&oldstuff->screen) &
3) == 0) *(&oldstuff->screen) = lswapl(*(&oldstuff
->screen)); else swap_uint32((uint32_t *)(&oldstuff->
screen)); } while (0)
;
1826 swaps(&oldstuff->hdisplay)do { if (sizeof(*(&oldstuff->hdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hdisplay
) & 1) && ((uintptr_t)(&oldstuff->hdisplay
) & 1) == 0) *(&oldstuff->hdisplay) = lswaps(*(&
oldstuff->hdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->hdisplay)); } while (0)
;
1827 swaps(&oldstuff->hsyncstart)do { if (sizeof(*(&oldstuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncstart
) & 1) && ((uintptr_t)(&oldstuff->hsyncstart
) & 1) == 0) *(&oldstuff->hsyncstart) = lswaps(*(&
oldstuff->hsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->hsyncstart)); } while (0)
;
1828 swaps(&oldstuff->hsyncend)do { if (sizeof(*(&oldstuff->hsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncend
) & 1) && ((uintptr_t)(&oldstuff->hsyncend
) & 1) == 0) *(&oldstuff->hsyncend) = lswaps(*(&
oldstuff->hsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->hsyncend)); } while (0)
;
1829 swaps(&oldstuff->htotal)do { if (sizeof(*(&oldstuff->htotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->htotal
) & 1) && ((uintptr_t)(&oldstuff->htotal) &
1) == 0) *(&oldstuff->htotal) = lswaps(*(&oldstuff
->htotal)); else swap_uint16((uint16_t *)(&oldstuff->
htotal)); } while (0)
;
1830 swaps(&oldstuff->vdisplay)do { if (sizeof(*(&oldstuff->vdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vdisplay
) & 1) && ((uintptr_t)(&oldstuff->vdisplay
) & 1) == 0) *(&oldstuff->vdisplay) = lswaps(*(&
oldstuff->vdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->vdisplay)); } while (0)
;
1831 swaps(&oldstuff->vsyncstart)do { if (sizeof(*(&oldstuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncstart
) & 1) && ((uintptr_t)(&oldstuff->vsyncstart
) & 1) == 0) *(&oldstuff->vsyncstart) = lswaps(*(&
oldstuff->vsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->vsyncstart)); } while (0)
;
1832 swaps(&oldstuff->vsyncend)do { if (sizeof(*(&oldstuff->vsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncend
) & 1) && ((uintptr_t)(&oldstuff->vsyncend
) & 1) == 0) *(&oldstuff->vsyncend) = lswaps(*(&
oldstuff->vsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->vsyncend)); } while (0)
;
1833 swaps(&oldstuff->vtotal)do { if (sizeof(*(&oldstuff->vtotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vtotal
) & 1) && ((uintptr_t)(&oldstuff->vtotal) &
1) == 0) *(&oldstuff->vtotal) = lswaps(*(&oldstuff
->vtotal)); else swap_uint16((uint16_t *)(&oldstuff->
vtotal)); } while (0)
;
1834 swapl(&oldstuff->flags)do { if (sizeof(*(&oldstuff->flags)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&oldstuff->flags
) & 3) && ((uintptr_t)(&oldstuff->flags) &
3) == 0) *(&oldstuff->flags) = lswapl(*(&oldstuff
->flags)); else swap_uint32((uint32_t *)(&oldstuff->
flags)); } while (0)
;
1835 swapl(&oldstuff->privsize)do { if (sizeof(*(&oldstuff->privsize)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->privsize
) & 3) && ((uintptr_t)(&oldstuff->privsize
) & 3) == 0) *(&oldstuff->privsize) = lswapl(*(&
oldstuff->privsize)); else swap_uint32((uint32_t *)(&oldstuff
->privsize)); } while (0)
;
1836 SwapRestL(oldstuff)SwapLongs((CARD32 *)(oldstuff + 1), (client->req_len - (sizeof
(*oldstuff) >> 2)))
;
1837 }
1838 else {
1839 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1840 REQUEST_AT_LEAST_SIZE(xXF86VidModeModModeLineReq)if ((sizeof(xXF86VidModeModModeLineReq) >> 2) > client
->req_len ) return(16)
;
1841 swapl(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
3) && ((uintptr_t)(&stuff->screen) & 3) ==
0) *(&stuff->screen) = lswapl(*(&stuff->screen
)); else swap_uint32((uint32_t *)(&stuff->screen)); } while
(0)
;
1842 swaps(&stuff->hdisplay)do { if (sizeof(*(&stuff->hdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hdisplay
) & 1) && ((uintptr_t)(&stuff->hdisplay) &
1) == 0) *(&stuff->hdisplay) = lswaps(*(&stuff->
hdisplay)); else swap_uint16((uint16_t *)(&stuff->hdisplay
)); } while (0)
;
1843 swaps(&stuff->hsyncstart)do { if (sizeof(*(&stuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncstart
) & 1) && ((uintptr_t)(&stuff->hsyncstart)
& 1) == 0) *(&stuff->hsyncstart) = lswaps(*(&
stuff->hsyncstart)); else swap_uint16((uint16_t *)(&stuff
->hsyncstart)); } while (0)
;
1844 swaps(&stuff->hsyncend)do { if (sizeof(*(&stuff->hsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncend
) & 1) && ((uintptr_t)(&stuff->hsyncend) &
1) == 0) *(&stuff->hsyncend) = lswaps(*(&stuff->
hsyncend)); else swap_uint16((uint16_t *)(&stuff->hsyncend
)); } while (0)
;
1845 swaps(&stuff->htotal)do { if (sizeof(*(&stuff->htotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->htotal) &
1) && ((uintptr_t)(&stuff->htotal) & 1) ==
0) *(&stuff->htotal) = lswaps(*(&stuff->htotal
)); else swap_uint16((uint16_t *)(&stuff->htotal)); } while
(0)
;
1846 swaps(&stuff->hskew)do { if (sizeof(*(&stuff->hskew)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->hskew) &
1) && ((uintptr_t)(&stuff->hskew) & 1) ==
0) *(&stuff->hskew) = lswaps(*(&stuff->hskew))
; else swap_uint16((uint16_t *)(&stuff->hskew)); } while
(0)
;
1847 swaps(&stuff->vdisplay)do { if (sizeof(*(&stuff->vdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vdisplay
) & 1) && ((uintptr_t)(&stuff->vdisplay) &
1) == 0) *(&stuff->vdisplay) = lswaps(*(&stuff->
vdisplay)); else swap_uint16((uint16_t *)(&stuff->vdisplay
)); } while (0)
;
1848 swaps(&stuff->vsyncstart)do { if (sizeof(*(&stuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncstart
) & 1) && ((uintptr_t)(&stuff->vsyncstart)
& 1) == 0) *(&stuff->vsyncstart) = lswaps(*(&
stuff->vsyncstart)); else swap_uint16((uint16_t *)(&stuff
->vsyncstart)); } while (0)
;
1849 swaps(&stuff->vsyncend)do { if (sizeof(*(&stuff->vsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncend
) & 1) && ((uintptr_t)(&stuff->vsyncend) &
1) == 0) *(&stuff->vsyncend) = lswaps(*(&stuff->
vsyncend)); else swap_uint16((uint16_t *)(&stuff->vsyncend
)); } while (0)
;
1850 swaps(&stuff->vtotal)do { if (sizeof(*(&stuff->vtotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->vtotal) &
1) && ((uintptr_t)(&stuff->vtotal) & 1) ==
0) *(&stuff->vtotal) = lswaps(*(&stuff->vtotal
)); else swap_uint16((uint16_t *)(&stuff->vtotal)); } while
(0)
;
1851 swapl(&stuff->flags)do { if (sizeof(*(&stuff->flags)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->flags) &
3) && ((uintptr_t)(&stuff->flags) & 3) ==
0) *(&stuff->flags) = lswapl(*(&stuff->flags))
; else swap_uint32((uint32_t *)(&stuff->flags)); } while
(0)
;
1852 swapl(&stuff->privsize)do { if (sizeof(*(&stuff->privsize)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->privsize
) & 3) && ((uintptr_t)(&stuff->privsize) &
3) == 0) *(&stuff->privsize) = lswapl(*(&stuff->
privsize)); else swap_uint32((uint32_t *)(&stuff->privsize
)); } while (0)
;
1853 SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof
(*stuff) >> 2)))
;
1854 }
1855 return ProcVidModeModModeLine(client);
1856}
1857
1858static int
1859SProcVidModeValidateModeLine(ClientPtr client)
1860{
1861 xXF86OldVidModeValidateModeLineReq *oldstuff =
1862 (xXF86OldVidModeValidateModeLineReq *) client->requestBuffer;
1863 int ver;
1864
1865 REQUEST(xXF86VidModeValidateModeLineReq)xXF86VidModeValidateModeLineReq *stuff = (xXF86VidModeValidateModeLineReq
*)client->requestBuffer
;
1866 ver = ClientMajorVersion(client);
1867 if (ver < 2) {
1868 swaps(&oldstuff->length)do { if (sizeof(*(&oldstuff->length)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->length
) & 1) && ((uintptr_t)(&oldstuff->length) &
1) == 0) *(&oldstuff->length) = lswaps(*(&oldstuff
->length)); else swap_uint16((uint16_t *)(&oldstuff->
length)); } while (0)
;
1869 REQUEST_AT_LEAST_SIZE(xXF86OldVidModeValidateModeLineReq)if ((sizeof(xXF86OldVidModeValidateModeLineReq) >> 2) >
client->req_len ) return(16)
;
1870 swapl(&oldstuff->screen)do { if (sizeof(*(&oldstuff->screen)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->screen
) & 3) && ((uintptr_t)(&oldstuff->screen) &
3) == 0) *(&oldstuff->screen) = lswapl(*(&oldstuff
->screen)); else swap_uint32((uint32_t *)(&oldstuff->
screen)); } while (0)
;
1871 swaps(&oldstuff->hdisplay)do { if (sizeof(*(&oldstuff->hdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hdisplay
) & 1) && ((uintptr_t)(&oldstuff->hdisplay
) & 1) == 0) *(&oldstuff->hdisplay) = lswaps(*(&
oldstuff->hdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->hdisplay)); } while (0)
;
1872 swaps(&oldstuff->hsyncstart)do { if (sizeof(*(&oldstuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncstart
) & 1) && ((uintptr_t)(&oldstuff->hsyncstart
) & 1) == 0) *(&oldstuff->hsyncstart) = lswaps(*(&
oldstuff->hsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->hsyncstart)); } while (0)
;
1873 swaps(&oldstuff->hsyncend)do { if (sizeof(*(&oldstuff->hsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->hsyncend
) & 1) && ((uintptr_t)(&oldstuff->hsyncend
) & 1) == 0) *(&oldstuff->hsyncend) = lswaps(*(&
oldstuff->hsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->hsyncend)); } while (0)
;
1874 swaps(&oldstuff->htotal)do { if (sizeof(*(&oldstuff->htotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->htotal
) & 1) && ((uintptr_t)(&oldstuff->htotal) &
1) == 0) *(&oldstuff->htotal) = lswaps(*(&oldstuff
->htotal)); else swap_uint16((uint16_t *)(&oldstuff->
htotal)); } while (0)
;
1875 swaps(&oldstuff->vdisplay)do { if (sizeof(*(&oldstuff->vdisplay)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vdisplay
) & 1) && ((uintptr_t)(&oldstuff->vdisplay
) & 1) == 0) *(&oldstuff->vdisplay) = lswaps(*(&
oldstuff->vdisplay)); else swap_uint16((uint16_t *)(&oldstuff
->vdisplay)); } while (0)
;
1876 swaps(&oldstuff->vsyncstart)do { if (sizeof(*(&oldstuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncstart
) & 1) && ((uintptr_t)(&oldstuff->vsyncstart
) & 1) == 0) *(&oldstuff->vsyncstart) = lswaps(*(&
oldstuff->vsyncstart)); else swap_uint16((uint16_t *)(&
oldstuff->vsyncstart)); } while (0)
;
1877 swaps(&oldstuff->vsyncend)do { if (sizeof(*(&oldstuff->vsyncend)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vsyncend
) & 1) && ((uintptr_t)(&oldstuff->vsyncend
) & 1) == 0) *(&oldstuff->vsyncend) = lswaps(*(&
oldstuff->vsyncend)); else swap_uint16((uint16_t *)(&oldstuff
->vsyncend)); } while (0)
;
1878 swaps(&oldstuff->vtotal)do { if (sizeof(*(&oldstuff->vtotal)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->vtotal
) & 1) && ((uintptr_t)(&oldstuff->vtotal) &
1) == 0) *(&oldstuff->vtotal) = lswaps(*(&oldstuff
->vtotal)); else swap_uint16((uint16_t *)(&oldstuff->
vtotal)); } while (0)
;
1879 swapl(&oldstuff->flags)do { if (sizeof(*(&oldstuff->flags)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&oldstuff->flags
) & 3) && ((uintptr_t)(&oldstuff->flags) &
3) == 0) *(&oldstuff->flags) = lswapl(*(&oldstuff
->flags)); else swap_uint32((uint32_t *)(&oldstuff->
flags)); } while (0)
;
1880 swapl(&oldstuff->privsize)do { if (sizeof(*(&oldstuff->privsize)) != 4) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&oldstuff->privsize
) & 3) && ((uintptr_t)(&oldstuff->privsize
) & 3) == 0) *(&oldstuff->privsize) = lswapl(*(&
oldstuff->privsize)); else swap_uint32((uint32_t *)(&oldstuff
->privsize)); } while (0)
;
1881 SwapRestL(oldstuff)SwapLongs((CARD32 *)(oldstuff + 1), (client->req_len - (sizeof
(*oldstuff) >> 2)))
;
1882 }
1883 else {
1884 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1885 REQUEST_AT_LEAST_SIZE(xXF86VidModeValidateModeLineReq)if ((sizeof(xXF86VidModeValidateModeLineReq) >> 2) >
client->req_len ) return(16)
;
1886 swapl(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
3) && ((uintptr_t)(&stuff->screen) & 3) ==
0) *(&stuff->screen) = lswapl(*(&stuff->screen
)); else swap_uint32((uint32_t *)(&stuff->screen)); } while
(0)
;
1887 swaps(&stuff->hdisplay)do { if (sizeof(*(&stuff->hdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hdisplay
) & 1) && ((uintptr_t)(&stuff->hdisplay) &
1) == 0) *(&stuff->hdisplay) = lswaps(*(&stuff->
hdisplay)); else swap_uint16((uint16_t *)(&stuff->hdisplay
)); } while (0)
;
1888 swaps(&stuff->hsyncstart)do { if (sizeof(*(&stuff->hsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncstart
) & 1) && ((uintptr_t)(&stuff->hsyncstart)
& 1) == 0) *(&stuff->hsyncstart) = lswaps(*(&
stuff->hsyncstart)); else swap_uint16((uint16_t *)(&stuff
->hsyncstart)); } while (0)
;
1889 swaps(&stuff->hsyncend)do { if (sizeof(*(&stuff->hsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->hsyncend
) & 1) && ((uintptr_t)(&stuff->hsyncend) &
1) == 0) *(&stuff->hsyncend) = lswaps(*(&stuff->
hsyncend)); else swap_uint16((uint16_t *)(&stuff->hsyncend
)); } while (0)
;
1890 swaps(&stuff->htotal)do { if (sizeof(*(&stuff->htotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->htotal) &
1) && ((uintptr_t)(&stuff->htotal) & 1) ==
0) *(&stuff->htotal) = lswaps(*(&stuff->htotal
)); else swap_uint16((uint16_t *)(&stuff->htotal)); } while
(0)
;
1891 swaps(&stuff->hskew)do { if (sizeof(*(&stuff->hskew)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->hskew) &
1) && ((uintptr_t)(&stuff->hskew) & 1) ==
0) *(&stuff->hskew) = lswaps(*(&stuff->hskew))
; else swap_uint16((uint16_t *)(&stuff->hskew)); } while
(0)
;
1892 swaps(&stuff->vdisplay)do { if (sizeof(*(&stuff->vdisplay)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vdisplay
) & 1) && ((uintptr_t)(&stuff->vdisplay) &
1) == 0) *(&stuff->vdisplay) = lswaps(*(&stuff->
vdisplay)); else swap_uint16((uint16_t *)(&stuff->vdisplay
)); } while (0)
;
1893 swaps(&stuff->vsyncstart)do { if (sizeof(*(&stuff->vsyncstart)) != 2) wrong_size
(); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncstart
) & 1) && ((uintptr_t)(&stuff->vsyncstart)
& 1) == 0) *(&stuff->vsyncstart) = lswaps(*(&
stuff->vsyncstart)); else swap_uint16((uint16_t *)(&stuff
->vsyncstart)); } while (0)
;
1894 swaps(&stuff->vsyncend)do { if (sizeof(*(&stuff->vsyncend)) != 2) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->vsyncend
) & 1) && ((uintptr_t)(&stuff->vsyncend) &
1) == 0) *(&stuff->vsyncend) = lswaps(*(&stuff->
vsyncend)); else swap_uint16((uint16_t *)(&stuff->vsyncend
)); } while (0)
;
1895 swaps(&stuff->vtotal)do { if (sizeof(*(&stuff->vtotal)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->vtotal) &
1) && ((uintptr_t)(&stuff->vtotal) & 1) ==
0) *(&stuff->vtotal) = lswaps(*(&stuff->vtotal
)); else swap_uint16((uint16_t *)(&stuff->vtotal)); } while
(0)
;
1896 swapl(&stuff->flags)do { if (sizeof(*(&stuff->flags)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->flags) &
3) && ((uintptr_t)(&stuff->flags) & 3) ==
0) *(&stuff->flags) = lswapl(*(&stuff->flags))
; else swap_uint32((uint32_t *)(&stuff->flags)); } while
(0)
;
1897 swapl(&stuff->privsize)do { if (sizeof(*(&stuff->privsize)) != 4) wrong_size(
); if (__builtin_constant_p((uintptr_t)(&stuff->privsize
) & 3) && ((uintptr_t)(&stuff->privsize) &
3) == 0) *(&stuff->privsize) = lswapl(*(&stuff->
privsize)); else swap_uint32((uint32_t *)(&stuff->privsize
)); } while (0)
;
1898 SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof
(*stuff) >> 2)))
;
1899 }
1900 return ProcVidModeValidateModeLine(client);
1901}
1902
1903static int
1904SProcVidModeSwitchMode(ClientPtr client)
1905{
1906 REQUEST(xXF86VidModeSwitchModeReq)xXF86VidModeSwitchModeReq *stuff = (xXF86VidModeSwitchModeReq
*)client->requestBuffer
;
1907 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1908 REQUEST_SIZE_MATCH(xXF86VidModeSwitchModeReq)if ((sizeof(xXF86VidModeSwitchModeReq) >> 2) != client->
req_len) return(16)
;
1909 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1910 swaps(&stuff->zoom)do { if (sizeof(*(&stuff->zoom)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->zoom) &
1) && ((uintptr_t)(&stuff->zoom) & 1) == 0
) *(&stuff->zoom) = lswaps(*(&stuff->zoom)); else
swap_uint16((uint16_t *)(&stuff->zoom)); } while (0)
;
1911 return ProcVidModeSwitchMode(client);
1912}
1913
1914static int
1915SProcVidModeSwitchToMode(ClientPtr client)
1916{
1917 REQUEST(xXF86VidModeSwitchToModeReq)xXF86VidModeSwitchToModeReq *stuff = (xXF86VidModeSwitchToModeReq
*)client->requestBuffer
;
1918 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1919 REQUEST_SIZE_MATCH(xXF86VidModeSwitchToModeReq)if ((sizeof(xXF86VidModeSwitchToModeReq) >> 2) != client
->req_len) return(16)
;
1920 swapl(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 4) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
3) && ((uintptr_t)(&stuff->screen) & 3) ==
0) *(&stuff->screen) = lswapl(*(&stuff->screen
)); else swap_uint32((uint32_t *)(&stuff->screen)); } while
(0)
;
1921 return ProcVidModeSwitchToMode(client);
1922}
1923
1924static int
1925SProcVidModeLockModeSwitch(ClientPtr client)
1926{
1927 REQUEST(xXF86VidModeLockModeSwitchReq)xXF86VidModeLockModeSwitchReq *stuff = (xXF86VidModeLockModeSwitchReq
*)client->requestBuffer
;
1928 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1929 REQUEST_SIZE_MATCH(xXF86VidModeLockModeSwitchReq)if ((sizeof(xXF86VidModeLockModeSwitchReq) >> 2) != client
->req_len) return(16)
;
1930 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1931 swaps(&stuff->lock)do { if (sizeof(*(&stuff->lock)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->lock) &
1) && ((uintptr_t)(&stuff->lock) & 1) == 0
) *(&stuff->lock) = lswaps(*(&stuff->lock)); else
swap_uint16((uint16_t *)(&stuff->lock)); } while (0)
;
1932 return ProcVidModeLockModeSwitch(client);
1933}
1934
1935static int
1936SProcVidModeGetMonitor(ClientPtr client)
1937{
1938 REQUEST(xXF86VidModeGetMonitorReq)xXF86VidModeGetMonitorReq *stuff = (xXF86VidModeGetMonitorReq
*)client->requestBuffer
;
1939 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1940 REQUEST_SIZE_MATCH(xXF86VidModeGetMonitorReq)if ((sizeof(xXF86VidModeGetMonitorReq) >> 2) != client->
req_len) return(16)
;
1941 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1942 return ProcVidModeGetMonitor(client);
1943}
1944
1945static int
1946SProcVidModeGetViewPort(ClientPtr client)
1947{
1948 REQUEST(xXF86VidModeGetViewPortReq)xXF86VidModeGetViewPortReq *stuff = (xXF86VidModeGetViewPortReq
*)client->requestBuffer
;
1949 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1950 REQUEST_SIZE_MATCH(xXF86VidModeGetViewPortReq)if ((sizeof(xXF86VidModeGetViewPortReq) >> 2) != client
->req_len) return(16)
;
1951 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1952 return ProcVidModeGetViewPort(client);
1953}
1954
1955static int
1956SProcVidModeSetViewPort(ClientPtr client)
1957{
1958 REQUEST(xXF86VidModeSetViewPortReq)xXF86VidModeSetViewPortReq *stuff = (xXF86VidModeSetViewPortReq
*)client->requestBuffer
;
1959 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1960 REQUEST_SIZE_MATCH(xXF86VidModeSetViewPortReq)if ((sizeof(xXF86VidModeSetViewPortReq) >> 2) != client
->req_len) return(16)
;
1961 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1962 swapl(&stuff->x)do { if (sizeof(*(&stuff->x)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&stuff->x) & 3) &&
((uintptr_t)(&stuff->x) & 3) == 0) *(&stuff->
x) = lswapl(*(&stuff->x)); else swap_uint32((uint32_t *
)(&stuff->x)); } while (0)
;
1963 swapl(&stuff->y)do { if (sizeof(*(&stuff->y)) != 4) wrong_size(); if (
__builtin_constant_p((uintptr_t)(&stuff->y) & 3) &&
((uintptr_t)(&stuff->y) & 3) == 0) *(&stuff->
y) = lswapl(*(&stuff->y)); else swap_uint32((uint32_t *
)(&stuff->y)); } while (0)
;
1964 return ProcVidModeSetViewPort(client);
1965}
1966
1967static int
1968SProcVidModeGetDotClocks(ClientPtr client)
1969{
1970 REQUEST(xXF86VidModeGetDotClocksReq)xXF86VidModeGetDotClocksReq *stuff = (xXF86VidModeGetDotClocksReq
*)client->requestBuffer
;
1971 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1972 REQUEST_SIZE_MATCH(xXF86VidModeGetDotClocksReq)if ((sizeof(xXF86VidModeGetDotClocksReq) >> 2) != client
->req_len) return(16)
;
1973 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1974 return ProcVidModeGetDotClocks(client);
1975}
1976
1977static int
1978SProcVidModeSetClientVersion(ClientPtr client)
1979{
1980 REQUEST(xXF86VidModeSetClientVersionReq)xXF86VidModeSetClientVersionReq *stuff = (xXF86VidModeSetClientVersionReq
*)client->requestBuffer
;
1981 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1982 REQUEST_SIZE_MATCH(xXF86VidModeSetClientVersionReq)if ((sizeof(xXF86VidModeSetClientVersionReq) >> 2) != client
->req_len) return(16)
;
1983 swaps(&stuff->major)do { if (sizeof(*(&stuff->major)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->major) &
1) && ((uintptr_t)(&stuff->major) & 1) ==
0) *(&stuff->major) = lswaps(*(&stuff->major))
; else swap_uint16((uint16_t *)(&stuff->major)); } while
(0)
;
1984 swaps(&stuff->minor)do { if (sizeof(*(&stuff->minor)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->minor) &
1) && ((uintptr_t)(&stuff->minor) & 1) ==
0) *(&stuff->minor) = lswaps(*(&stuff->minor))
; else swap_uint16((uint16_t *)(&stuff->minor)); } while
(0)
;
1985 return ProcVidModeSetClientVersion(client);
1986}
1987
1988static int
1989SProcVidModeSetGamma(ClientPtr client)
1990{
1991 REQUEST(xXF86VidModeSetGammaReq)xXF86VidModeSetGammaReq *stuff = (xXF86VidModeSetGammaReq *)client
->requestBuffer
;
1992 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
1993 REQUEST_SIZE_MATCH(xXF86VidModeSetGammaReq)if ((sizeof(xXF86VidModeSetGammaReq) >> 2) != client->
req_len) return(16)
;
1994 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
1995 swapl(&stuff->red)do { if (sizeof(*(&stuff->red)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->red) & 3
) && ((uintptr_t)(&stuff->red) & 3) == 0) *
(&stuff->red) = lswapl(*(&stuff->red)); else swap_uint32
((uint32_t *)(&stuff->red)); } while (0)
;
1996 swapl(&stuff->green)do { if (sizeof(*(&stuff->green)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->green) &
3) && ((uintptr_t)(&stuff->green) & 3) ==
0) *(&stuff->green) = lswapl(*(&stuff->green))
; else swap_uint32((uint32_t *)(&stuff->green)); } while
(0)
;
1997 swapl(&stuff->blue)do { if (sizeof(*(&stuff->blue)) != 4) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->blue) &
3) && ((uintptr_t)(&stuff->blue) & 3) == 0
) *(&stuff->blue) = lswapl(*(&stuff->blue)); else
swap_uint32((uint32_t *)(&stuff->blue)); } while (0)
;
1998 return ProcVidModeSetGamma(client);
1999}
2000
2001static int
2002SProcVidModeGetGamma(ClientPtr client)
2003{
2004 REQUEST(xXF86VidModeGetGammaReq)xXF86VidModeGetGammaReq *stuff = (xXF86VidModeGetGammaReq *)client
->requestBuffer
;
2005 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
2006 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaReq)if ((sizeof(xXF86VidModeGetGammaReq) >> 2) != client->
req_len) return(16)
;
2007 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
2008 return ProcVidModeGetGamma(client);
2009}
2010
2011static int
2012SProcVidModeSetGammaRamp(ClientPtr client)
2013{
2014 int length;
2015
2016 REQUEST(xXF86VidModeSetGammaRampReq)xXF86VidModeSetGammaRampReq *stuff = (xXF86VidModeSetGammaRampReq
*)client->requestBuffer
;
2017 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
2018 REQUEST_AT_LEAST_SIZE(xXF86VidModeSetGammaRampReq)if ((sizeof(xXF86VidModeSetGammaRampReq) >> 2) > client
->req_len ) return(16)
;
2019 swaps(&stuff->size)do { if (sizeof(*(&stuff->size)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->size) &
1) && ((uintptr_t)(&stuff->size) & 1) == 0
) *(&stuff->size) = lswaps(*(&stuff->size)); else
swap_uint16((uint16_t *)(&stuff->size)); } while (0)
;
2020 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
2021 length = ((stuff->size + 1) & ~1) * 6;
2022 REQUEST_FIXED_SIZE(xXF86VidModeSetGammaRampReq, length)if (((sizeof(xXF86VidModeSetGammaRampReq) >> 2) > client
->req_len) || (((length) >> 2) >= client->req_len
) || ((((uint64_t) sizeof(xXF86VidModeSetGammaRampReq) + (length
) + 3) >> 2) != (uint64_t) client->req_len)) return(
16)
;
2023 SwapRestS(stuff)SwapShorts((short *)(stuff + 1), ((client->req_len <<
1) - (sizeof(*stuff) >> 1)))
;
2024 return ProcVidModeSetGammaRamp(client);
2025}
2026
2027static int
2028SProcVidModeGetGammaRamp(ClientPtr client)
2029{
2030 REQUEST(xXF86VidModeGetGammaRampReq)xXF86VidModeGetGammaRampReq *stuff = (xXF86VidModeGetGammaRampReq
*)client->requestBuffer
;
2031 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
2032 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampReq)if ((sizeof(xXF86VidModeGetGammaRampReq) >> 2) != client
->req_len) return(16)
;
2033 swaps(&stuff->size)do { if (sizeof(*(&stuff->size)) != 2) wrong_size(); if
(__builtin_constant_p((uintptr_t)(&stuff->size) &
1) && ((uintptr_t)(&stuff->size) & 1) == 0
) *(&stuff->size) = lswaps(*(&stuff->size)); else
swap_uint16((uint16_t *)(&stuff->size)); } while (0)
;
2034 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
2035 return ProcVidModeGetGammaRamp(client);
2036}
2037
2038static int
2039SProcVidModeGetGammaRampSize(ClientPtr client)
2040{
2041 REQUEST(xXF86VidModeGetGammaRampSizeReq)xXF86VidModeGetGammaRampSizeReq *stuff = (xXF86VidModeGetGammaRampSizeReq
*)client->requestBuffer
;
2042 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
2043 REQUEST_SIZE_MATCH(xXF86VidModeGetGammaRampSizeReq)if ((sizeof(xXF86VidModeGetGammaRampSizeReq) >> 2) != client
->req_len) return(16)
;
2044 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
2045 return ProcVidModeGetGammaRampSize(client);
2046}
2047
2048static int
2049SProcVidModeGetPermissions(ClientPtr client)
2050{
2051 REQUEST(xXF86VidModeGetPermissionsReq)xXF86VidModeGetPermissionsReq *stuff = (xXF86VidModeGetPermissionsReq
*)client->requestBuffer
;
2052 swaps(&stuff->length)do { if (sizeof(*(&stuff->length)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->length) &
1) && ((uintptr_t)(&stuff->length) & 1) ==
0) *(&stuff->length) = lswaps(*(&stuff->length
)); else swap_uint16((uint16_t *)(&stuff->length)); } while
(0)
;
2053 REQUEST_SIZE_MATCH(xXF86VidModeGetPermissionsReq)if ((sizeof(xXF86VidModeGetPermissionsReq) >> 2) != client
->req_len) return(16)
;
2054 swaps(&stuff->screen)do { if (sizeof(*(&stuff->screen)) != 2) wrong_size();
if (__builtin_constant_p((uintptr_t)(&stuff->screen) &
1) && ((uintptr_t)(&stuff->screen) & 1) ==
0) *(&stuff->screen) = lswaps(*(&stuff->screen
)); else swap_uint16((uint16_t *)(&stuff->screen)); } while
(0)
;
2055 return ProcVidModeGetPermissions(client);
2056}
2057
2058static int
2059SProcVidModeDispatch(ClientPtr client)
2060{
2061 REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer;
2062 switch (stuff->data) {
2063 case X_XF86VidModeQueryVersion0:
2064 return SProcVidModeQueryVersion(client);
2065 case X_XF86VidModeGetModeLine1:
2066 return SProcVidModeGetModeLine(client);
2067 case X_XF86VidModeGetMonitor4:
2068 return SProcVidModeGetMonitor(client);
2069 case X_XF86VidModeGetAllModeLines6:
2070 return SProcVidModeGetAllModeLines(client);
2071 case X_XF86VidModeGetViewPort11:
2072 return SProcVidModeGetViewPort(client);
2073 case X_XF86VidModeValidateModeLine9:
2074 return SProcVidModeValidateModeLine(client);
2075 case X_XF86VidModeGetDotClocks13:
2076 return SProcVidModeGetDotClocks(client);
2077 case X_XF86VidModeSetClientVersion14:
2078 return SProcVidModeSetClientVersion(client);
2079 case X_XF86VidModeGetGamma16:
2080 return SProcVidModeGetGamma(client);
2081 case X_XF86VidModeGetGammaRamp17:
2082 return SProcVidModeGetGammaRamp(client);
2083 case X_XF86VidModeGetGammaRampSize19:
2084 return SProcVidModeGetGammaRampSize(client);
2085 case X_XF86VidModeGetPermissions20:
2086 return SProcVidModeGetPermissions(client);
2087 default:
2088 if (VidModeAllowNonLocal || client->local) {
2089 switch (stuff->data) {
2090 case X_XF86VidModeAddModeLine7:
2091 return SProcVidModeAddModeLine(client);
2092 case X_XF86VidModeDeleteModeLine8:
2093 return SProcVidModeDeleteModeLine(client);
2094 case X_XF86VidModeModModeLine2:
2095 return SProcVidModeModModeLine(client);
2096 case X_XF86VidModeSwitchMode3:
2097 return SProcVidModeSwitchMode(client);
2098 case X_XF86VidModeSwitchToMode10:
2099 return SProcVidModeSwitchToMode(client);
2100 case X_XF86VidModeLockModeSwitch5:
2101 return SProcVidModeLockModeSwitch(client);
2102 case X_XF86VidModeSetViewPort12:
2103 return SProcVidModeSetViewPort(client);
2104 case X_XF86VidModeSetGamma15:
2105 return SProcVidModeSetGamma(client);
2106 case X_XF86VidModeSetGammaRamp18:
2107 return SProcVidModeSetGammaRamp(client);
2108 default:
2109 return BadRequest1;
2110 }
2111 }
2112 else
2113 return VidModeErrorBase + XF86VidModeClientNotLocal5;
2114 }
2115}
2116
2117void
2118VidModeAddExtension(Bool allow_non_local)
2119{
2120 ExtensionEntry *extEntry;
2121
2122 DEBUG_P("VidModeAddExtension");
2123
2124 if (!dixRegisterPrivateKey(VidModeClientPrivateKey(&VidModeClientPrivateKeyRec), PRIVATE_CLIENT, 0))
2125 return;
2126
2127 if ((extEntry = AddExtension(XF86VIDMODENAME"XFree86-VidModeExtension",
2128 XF86VidModeNumberEvents0,
2129 XF86VidModeNumberErrors(6 + 1),
2130 ProcVidModeDispatch,
2131 SProcVidModeDispatch,
2132 NULL((void*)0), StandardMinorOpcode))) {
2133 VidModeErrorBase = extEntry->errorBase;
2134 VidModeAllowNonLocal = allow_non_local;
2135 }
2136}
2137
2138VidModePtr VidModeGetPtr(ScreenPtr pScreen)
2139{
2140 return (VidModePtr) (dixLookupPrivate(&pScreen->devPrivates, VidModePrivateKey(&VidModePrivateKeyRec)));
2141}
2142
2143VidModePtr VidModeInit(ScreenPtr pScreen)
2144{
2145 if (!dixRegisterPrivateKey(VidModePrivateKey(&VidModePrivateKeyRec), PRIVATE_SCREEN, sizeof(VidModeRec)))
2146 return NULL((void*)0);
2147
2148 return VidModeGetPtr(pScreen);
2149}
2150
2151#endif /* XF86VIDMODE */