File: | render/render.c |
Location: | line 1617, column 26 |
Description: | The left operand of '>>' is a garbage value |
1 | /* | |||||
2 | * | |||||
3 | * Copyright © 2000 SuSE, Inc. | |||||
4 | * | |||||
5 | * Permission to use, copy, modify, distribute, and sell this software and its | |||||
6 | * documentation for any purpose is hereby granted without fee, provided that | |||||
7 | * the above copyright notice appear in all copies and that both that | |||||
8 | * copyright notice and this permission notice appear in supporting | |||||
9 | * documentation, and that the name of SuSE not be used in advertising or | |||||
10 | * publicity pertaining to distribution of the software without specific, | |||||
11 | * written prior permission. SuSE makes no representations about the | |||||
12 | * suitability of this software for any purpose. It is provided "as is" | |||||
13 | * without express or implied warranty. | |||||
14 | * | |||||
15 | * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL | |||||
16 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE | |||||
17 | * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |||||
18 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION | |||||
19 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN | |||||
20 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||||
21 | * | |||||
22 | * Author: Keith Packard, SuSE, Inc. | |||||
23 | */ | |||||
24 | ||||||
25 | #ifdef HAVE_DIX_CONFIG_H1 | |||||
26 | #include <dix-config.h> | |||||
27 | #endif | |||||
28 | ||||||
29 | #include <X11/X.h> | |||||
30 | #include <X11/Xproto.h> | |||||
31 | #include "misc.h" | |||||
32 | #include "os.h" | |||||
33 | #include "dixstruct.h" | |||||
34 | #include "resource.h" | |||||
35 | #include "scrnintstr.h" | |||||
36 | #include "windowstr.h" | |||||
37 | #include "pixmapstr.h" | |||||
38 | #include "colormapst.h" | |||||
39 | #include "extnsionst.h" | |||||
40 | #include "extinit.h" | |||||
41 | #include "servermd.h" | |||||
42 | #include <X11/extensions/render.h> | |||||
43 | #include <X11/extensions/renderproto.h> | |||||
44 | #include "picturestr.h" | |||||
45 | #include "glyphstr.h" | |||||
46 | #include <X11/Xfuncproto.h> | |||||
47 | #include "cursorstr.h" | |||||
48 | #include "xace.h" | |||||
49 | #include "protocol-versions.h" | |||||
50 | ||||||
51 | #ifdef PANORAMIX1 | |||||
52 | #include "panoramiX.h" | |||||
53 | #include "panoramiXsrv.h" | |||||
54 | #endif | |||||
55 | ||||||
56 | #include <stdint.h> | |||||
57 | ||||||
58 | static int ProcRenderQueryVersion(ClientPtr pClient); | |||||
59 | static int ProcRenderQueryPictFormats(ClientPtr pClient); | |||||
60 | static int ProcRenderQueryPictIndexValues(ClientPtr pClient); | |||||
61 | static int ProcRenderQueryDithers(ClientPtr pClient); | |||||
62 | static int ProcRenderCreatePicture(ClientPtr pClient); | |||||
63 | static int ProcRenderChangePicture(ClientPtr pClient); | |||||
64 | static int ProcRenderSetPictureClipRectangles(ClientPtr pClient); | |||||
65 | static int ProcRenderFreePicture(ClientPtr pClient); | |||||
66 | static int ProcRenderComposite(ClientPtr pClient); | |||||
67 | static int ProcRenderScale(ClientPtr pClient); | |||||
68 | static int ProcRenderTrapezoids(ClientPtr pClient); | |||||
69 | static int ProcRenderTriangles(ClientPtr pClient); | |||||
70 | static int ProcRenderTriStrip(ClientPtr pClient); | |||||
71 | static int ProcRenderTriFan(ClientPtr pClient); | |||||
72 | static int ProcRenderColorTrapezoids(ClientPtr pClient); | |||||
73 | static int ProcRenderColorTriangles(ClientPtr pClient); | |||||
74 | static int ProcRenderTransform(ClientPtr pClient); | |||||
75 | static int ProcRenderCreateGlyphSet(ClientPtr pClient); | |||||
76 | static int ProcRenderReferenceGlyphSet(ClientPtr pClient); | |||||
77 | static int ProcRenderFreeGlyphSet(ClientPtr pClient); | |||||
78 | static int ProcRenderAddGlyphs(ClientPtr pClient); | |||||
79 | static int ProcRenderAddGlyphsFromPicture(ClientPtr pClient); | |||||
80 | static int ProcRenderFreeGlyphs(ClientPtr pClient); | |||||
81 | static int ProcRenderCompositeGlyphs(ClientPtr pClient); | |||||
82 | static int ProcRenderFillRectangles(ClientPtr pClient); | |||||
83 | static int ProcRenderCreateCursor(ClientPtr pClient); | |||||
84 | static int ProcRenderSetPictureTransform(ClientPtr pClient); | |||||
85 | static int ProcRenderQueryFilters(ClientPtr pClient); | |||||
86 | static int ProcRenderSetPictureFilter(ClientPtr pClient); | |||||
87 | static int ProcRenderCreateAnimCursor(ClientPtr pClient); | |||||
88 | static int ProcRenderAddTraps(ClientPtr pClient); | |||||
89 | static int ProcRenderCreateSolidFill(ClientPtr pClient); | |||||
90 | static int ProcRenderCreateLinearGradient(ClientPtr pClient); | |||||
91 | static int ProcRenderCreateRadialGradient(ClientPtr pClient); | |||||
92 | static int ProcRenderCreateConicalGradient(ClientPtr pClient); | |||||
93 | ||||||
94 | static int ProcRenderDispatch(ClientPtr pClient); | |||||
95 | ||||||
96 | static int SProcRenderQueryVersion(ClientPtr pClient); | |||||
97 | static int SProcRenderQueryPictFormats(ClientPtr pClient); | |||||
98 | static int SProcRenderQueryPictIndexValues(ClientPtr pClient); | |||||
99 | static int SProcRenderQueryDithers(ClientPtr pClient); | |||||
100 | static int SProcRenderCreatePicture(ClientPtr pClient); | |||||
101 | static int SProcRenderChangePicture(ClientPtr pClient); | |||||
102 | static int SProcRenderSetPictureClipRectangles(ClientPtr pClient); | |||||
103 | static int SProcRenderFreePicture(ClientPtr pClient); | |||||
104 | static int SProcRenderComposite(ClientPtr pClient); | |||||
105 | static int SProcRenderScale(ClientPtr pClient); | |||||
106 | static int SProcRenderTrapezoids(ClientPtr pClient); | |||||
107 | static int SProcRenderTriangles(ClientPtr pClient); | |||||
108 | static int SProcRenderTriStrip(ClientPtr pClient); | |||||
109 | static int SProcRenderTriFan(ClientPtr pClient); | |||||
110 | static int SProcRenderColorTrapezoids(ClientPtr pClient); | |||||
111 | static int SProcRenderColorTriangles(ClientPtr pClient); | |||||
112 | static int SProcRenderTransform(ClientPtr pClient); | |||||
113 | static int SProcRenderCreateGlyphSet(ClientPtr pClient); | |||||
114 | static int SProcRenderReferenceGlyphSet(ClientPtr pClient); | |||||
115 | static int SProcRenderFreeGlyphSet(ClientPtr pClient); | |||||
116 | static int SProcRenderAddGlyphs(ClientPtr pClient); | |||||
117 | static int SProcRenderAddGlyphsFromPicture(ClientPtr pClient); | |||||
118 | static int SProcRenderFreeGlyphs(ClientPtr pClient); | |||||
119 | static int SProcRenderCompositeGlyphs(ClientPtr pClient); | |||||
120 | static int SProcRenderFillRectangles(ClientPtr pClient); | |||||
121 | static int SProcRenderCreateCursor(ClientPtr pClient); | |||||
122 | static int SProcRenderSetPictureTransform(ClientPtr pClient); | |||||
123 | static int SProcRenderQueryFilters(ClientPtr pClient); | |||||
124 | static int SProcRenderSetPictureFilter(ClientPtr pClient); | |||||
125 | static int SProcRenderCreateAnimCursor(ClientPtr pClient); | |||||
126 | static int SProcRenderAddTraps(ClientPtr pClient); | |||||
127 | static int SProcRenderCreateSolidFill(ClientPtr pClient); | |||||
128 | static int SProcRenderCreateLinearGradient(ClientPtr pClient); | |||||
129 | static int SProcRenderCreateRadialGradient(ClientPtr pClient); | |||||
130 | static int SProcRenderCreateConicalGradient(ClientPtr pClient); | |||||
131 | ||||||
132 | static int SProcRenderDispatch(ClientPtr pClient); | |||||
133 | ||||||
134 | int (*ProcRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr) = { | |||||
135 | ProcRenderQueryVersion, | |||||
136 | ProcRenderQueryPictFormats, | |||||
137 | ProcRenderQueryPictIndexValues, | |||||
138 | ProcRenderQueryDithers, | |||||
139 | ProcRenderCreatePicture, | |||||
140 | ProcRenderChangePicture, | |||||
141 | ProcRenderSetPictureClipRectangles, | |||||
142 | ProcRenderFreePicture, | |||||
143 | ProcRenderComposite, | |||||
144 | ProcRenderScale, | |||||
145 | ProcRenderTrapezoids, | |||||
146 | ProcRenderTriangles, | |||||
147 | ProcRenderTriStrip, | |||||
148 | ProcRenderTriFan, | |||||
149 | ProcRenderColorTrapezoids, | |||||
150 | ProcRenderColorTriangles, | |||||
151 | ProcRenderTransform, | |||||
152 | ProcRenderCreateGlyphSet, | |||||
153 | ProcRenderReferenceGlyphSet, | |||||
154 | ProcRenderFreeGlyphSet, | |||||
155 | ProcRenderAddGlyphs, | |||||
156 | ProcRenderAddGlyphsFromPicture, | |||||
157 | ProcRenderFreeGlyphs, | |||||
158 | ProcRenderCompositeGlyphs, | |||||
159 | ProcRenderCompositeGlyphs, | |||||
160 | ProcRenderCompositeGlyphs, | |||||
161 | ProcRenderFillRectangles, | |||||
162 | ProcRenderCreateCursor, | |||||
163 | ProcRenderSetPictureTransform, | |||||
164 | ProcRenderQueryFilters, | |||||
165 | ProcRenderSetPictureFilter, | |||||
166 | ProcRenderCreateAnimCursor, | |||||
167 | ProcRenderAddTraps, | |||||
168 | ProcRenderCreateSolidFill, | |||||
169 | ProcRenderCreateLinearGradient, | |||||
170 | ProcRenderCreateRadialGradient, ProcRenderCreateConicalGradient}; | |||||
171 | ||||||
172 | int (*SProcRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr) = { | |||||
173 | SProcRenderQueryVersion, | |||||
174 | SProcRenderQueryPictFormats, | |||||
175 | SProcRenderQueryPictIndexValues, | |||||
176 | SProcRenderQueryDithers, | |||||
177 | SProcRenderCreatePicture, | |||||
178 | SProcRenderChangePicture, | |||||
179 | SProcRenderSetPictureClipRectangles, | |||||
180 | SProcRenderFreePicture, | |||||
181 | SProcRenderComposite, | |||||
182 | SProcRenderScale, | |||||
183 | SProcRenderTrapezoids, | |||||
184 | SProcRenderTriangles, | |||||
185 | SProcRenderTriStrip, | |||||
186 | SProcRenderTriFan, | |||||
187 | SProcRenderColorTrapezoids, | |||||
188 | SProcRenderColorTriangles, | |||||
189 | SProcRenderTransform, | |||||
190 | SProcRenderCreateGlyphSet, | |||||
191 | SProcRenderReferenceGlyphSet, | |||||
192 | SProcRenderFreeGlyphSet, | |||||
193 | SProcRenderAddGlyphs, | |||||
194 | SProcRenderAddGlyphsFromPicture, | |||||
195 | SProcRenderFreeGlyphs, | |||||
196 | SProcRenderCompositeGlyphs, | |||||
197 | SProcRenderCompositeGlyphs, | |||||
198 | SProcRenderCompositeGlyphs, | |||||
199 | SProcRenderFillRectangles, | |||||
200 | SProcRenderCreateCursor, | |||||
201 | SProcRenderSetPictureTransform, | |||||
202 | SProcRenderQueryFilters, | |||||
203 | SProcRenderSetPictureFilter, | |||||
204 | SProcRenderCreateAnimCursor, | |||||
205 | SProcRenderAddTraps, | |||||
206 | SProcRenderCreateSolidFill, | |||||
207 | SProcRenderCreateLinearGradient, | |||||
208 | SProcRenderCreateRadialGradient, SProcRenderCreateConicalGradient}; | |||||
209 | ||||||
210 | int RenderErrBase; | |||||
211 | static DevPrivateKeyRec RenderClientPrivateKeyRec; | |||||
212 | ||||||
213 | #define RenderClientPrivateKey(&RenderClientPrivateKeyRec ) (&RenderClientPrivateKeyRec ) | |||||
214 | ||||||
215 | typedef struct _RenderClient { | |||||
216 | int major_version; | |||||
217 | int minor_version; | |||||
218 | } RenderClientRec, *RenderClientPtr; | |||||
219 | ||||||
220 | #define GetRenderClient(pClient)((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates , (&RenderClientPrivateKeyRec ))) ((RenderClientPtr)dixLookupPrivate(&(pClient)->devPrivates, RenderClientPrivateKey(&RenderClientPrivateKeyRec ))) | |||||
221 | ||||||
222 | #ifdef PANORAMIX1 | |||||
223 | RESTYPE XRT_PICTURE; | |||||
224 | #endif | |||||
225 | ||||||
226 | void | |||||
227 | RenderExtensionInit(void) | |||||
228 | { | |||||
229 | ExtensionEntry *extEntry; | |||||
230 | ||||||
231 | if (!PictureType) | |||||
232 | return; | |||||
233 | if (!PictureFinishInit()) | |||||
234 | return; | |||||
235 | if (!dixRegisterPrivateKey | |||||
236 | (&RenderClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(RenderClientRec))) | |||||
237 | return; | |||||
238 | ||||||
239 | extEntry = AddExtension(RENDER_NAME"RENDER", 0, RenderNumberErrors(4 +1), | |||||
240 | ProcRenderDispatch, SProcRenderDispatch, | |||||
241 | NULL((void*)0), StandardMinorOpcode); | |||||
242 | if (!extEntry) | |||||
243 | return; | |||||
244 | RenderErrBase = extEntry->errorBase; | |||||
245 | #ifdef PANORAMIX1 | |||||
246 | if (XRT_PICTURE) | |||||
247 | SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture1); | |||||
248 | #endif | |||||
249 | SetResourceTypeErrorValue(PictureType, RenderErrBase + BadPicture1); | |||||
250 | SetResourceTypeErrorValue(PictFormatType, RenderErrBase + BadPictFormat0); | |||||
251 | SetResourceTypeErrorValue(GlyphSetType, RenderErrBase + BadGlyphSet3); | |||||
252 | } | |||||
253 | ||||||
254 | static int | |||||
255 | ProcRenderQueryVersion(ClientPtr client) | |||||
256 | { | |||||
257 | RenderClientPtr pRenderClient = GetRenderClient(client)((RenderClientPtr)dixLookupPrivate(&(client)->devPrivates , (&RenderClientPrivateKeyRec ))); | |||||
258 | xRenderQueryVersionReply rep = { | |||||
259 | .type = X_Reply1, | |||||
260 | .sequenceNumber = client->sequence, | |||||
261 | .length = 0 | |||||
262 | }; | |||||
263 | ||||||
264 | REQUEST(xRenderQueryVersionReq)xRenderQueryVersionReq *stuff = (xRenderQueryVersionReq *)client ->requestBuffer; | |||||
265 | ||||||
266 | REQUEST_SIZE_MATCH(xRenderQueryVersionReq)if ((sizeof(xRenderQueryVersionReq) >> 2) != client-> req_len) return(16); | |||||
267 | ||||||
268 | pRenderClient->major_version = stuff->majorVersion; | |||||
269 | pRenderClient->minor_version = stuff->minorVersion; | |||||
270 | ||||||
271 | if ((stuff->majorVersion * 1000 + stuff->minorVersion) < | |||||
272 | (SERVER_RENDER_MAJOR_VERSION0 * 1000 + SERVER_RENDER_MINOR_VERSION11)) { | |||||
273 | rep.majorVersion = stuff->majorVersion; | |||||
274 | rep.minorVersion = stuff->minorVersion; | |||||
275 | } | |||||
276 | else { | |||||
277 | rep.majorVersion = SERVER_RENDER_MAJOR_VERSION0; | |||||
278 | rep.minorVersion = SERVER_RENDER_MINOR_VERSION11; | |||||
279 | } | |||||
280 | ||||||
281 | if (client->swapped) { | |||||
282 | 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); | |||||
283 | 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); | |||||
284 | swapl(&rep.majorVersion)do { if (sizeof(*(&rep.majorVersion)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&rep.majorVersion) & 3) && ((uintptr_t)(&rep.majorVersion) & 3) == 0) *(&rep.majorVersion) = lswapl(*(&rep.majorVersion )); else swap_uint32((uint32_t *)(&rep.majorVersion)); } while (0); | |||||
285 | swapl(&rep.minorVersion)do { if (sizeof(*(&rep.minorVersion)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&rep.minorVersion) & 3) && ((uintptr_t)(&rep.minorVersion) & 3) == 0) *(&rep.minorVersion) = lswapl(*(&rep.minorVersion )); else swap_uint32((uint32_t *)(&rep.minorVersion)); } while (0); | |||||
286 | } | |||||
287 | WriteToClient(client, sizeof(xRenderQueryVersionReply), &rep); | |||||
288 | return Success0; | |||||
289 | } | |||||
290 | ||||||
291 | static VisualPtr | |||||
292 | findVisual(ScreenPtr pScreen, VisualID vid) | |||||
293 | { | |||||
294 | VisualPtr pVisual; | |||||
295 | int v; | |||||
296 | ||||||
297 | for (v = 0; v < pScreen->numVisuals; v++) { | |||||
298 | pVisual = pScreen->visuals + v; | |||||
299 | if (pVisual->vid == vid) | |||||
300 | return pVisual; | |||||
301 | } | |||||
302 | return 0; | |||||
303 | } | |||||
304 | ||||||
305 | static int | |||||
306 | ProcRenderQueryPictFormats(ClientPtr client) | |||||
307 | { | |||||
308 | RenderClientPtr pRenderClient = GetRenderClient(client)((RenderClientPtr)dixLookupPrivate(&(client)->devPrivates , (&RenderClientPrivateKeyRec ))); | |||||
309 | xRenderQueryPictFormatsReply *reply; | |||||
310 | xPictScreen *pictScreen; | |||||
311 | xPictDepth *pictDepth; | |||||
312 | xPictVisual *pictVisual; | |||||
313 | xPictFormInfo *pictForm; | |||||
314 | CARD32 *pictSubpixel; | |||||
315 | ScreenPtr pScreen; | |||||
316 | VisualPtr pVisual; | |||||
317 | DepthPtr pDepth; | |||||
318 | int v, d; | |||||
319 | PictureScreenPtr ps; | |||||
320 | PictFormatPtr pFormat; | |||||
321 | int nformat; | |||||
322 | int ndepth; | |||||
323 | int nvisual; | |||||
324 | int rlength; | |||||
325 | int s; | |||||
326 | int numScreens; | |||||
327 | int numSubpixel; | |||||
328 | ||||||
329 | /* REQUEST(xRenderQueryPictFormatsReq); */ | |||||
330 | ||||||
331 | REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq)if ((sizeof(xRenderQueryPictFormatsReq) >> 2) != client ->req_len) return(16); | |||||
332 | ||||||
333 | #ifdef PANORAMIX1 | |||||
334 | if (noPanoramiXExtension) | |||||
335 | numScreens = screenInfo.numScreens; | |||||
336 | else | |||||
337 | numScreens = ((xConnSetup *) ConnectionInfo)->numRoots; | |||||
338 | #else | |||||
339 | numScreens = screenInfo.numScreens; | |||||
340 | #endif | |||||
341 | ndepth = nformat = nvisual = 0; | |||||
342 | for (s = 0; s < numScreens; s++) { | |||||
343 | pScreen = screenInfo.screens[s]; | |||||
344 | for (d = 0; d < pScreen->numDepths; d++) { | |||||
345 | pDepth = pScreen->allowedDepths + d; | |||||
346 | ++ndepth; | |||||
347 | ||||||
348 | for (v = 0; v < pDepth->numVids; v++) { | |||||
349 | pVisual = findVisual(pScreen, pDepth->vids[v]); | |||||
350 | if (pVisual && | |||||
351 | PictureMatchVisual(pScreen, pDepth->depth, pVisual)) | |||||
352 | ++nvisual; | |||||
353 | } | |||||
354 | } | |||||
355 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); | |||||
356 | if (ps) | |||||
357 | nformat += ps->nformats; | |||||
358 | } | |||||
359 | if (pRenderClient->major_version == 0 && pRenderClient->minor_version < 6) | |||||
360 | numSubpixel = 0; | |||||
361 | else | |||||
362 | numSubpixel = numScreens; | |||||
363 | ||||||
364 | rlength = (sizeof(xRenderQueryPictFormatsReply) + | |||||
365 | nformat * sizeof(xPictFormInfo) + | |||||
366 | numScreens * sizeof(xPictScreen) + | |||||
367 | ndepth * sizeof(xPictDepth) + | |||||
368 | nvisual * sizeof(xPictVisual) + numSubpixel * sizeof(CARD32)); | |||||
369 | reply = (xRenderQueryPictFormatsReply *) calloc(1, rlength); | |||||
370 | if (!reply) | |||||
371 | return BadAlloc11; | |||||
372 | reply->type = X_Reply1; | |||||
373 | reply->sequenceNumber = client->sequence; | |||||
374 | reply->length = bytes_to_int32(rlength - sizeof(xGenericReply)); | |||||
375 | reply->numFormats = nformat; | |||||
376 | reply->numScreens = numScreens; | |||||
377 | reply->numDepths = ndepth; | |||||
378 | reply->numVisuals = nvisual; | |||||
379 | reply->numSubpixel = numSubpixel; | |||||
380 | ||||||
381 | pictForm = (xPictFormInfo *) (reply + 1); | |||||
382 | ||||||
383 | for (s = 0; s < numScreens; s++) { | |||||
384 | pScreen = screenInfo.screens[s]; | |||||
385 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); | |||||
386 | if (ps) { | |||||
387 | for (nformat = 0, pFormat = ps->formats; | |||||
388 | nformat < ps->nformats; nformat++, pFormat++) { | |||||
389 | pictForm->id = pFormat->id; | |||||
390 | pictForm->type = pFormat->type; | |||||
391 | pictForm->depth = pFormat->depth; | |||||
392 | pictForm->direct.red = pFormat->direct.red; | |||||
393 | pictForm->direct.redMask = pFormat->direct.redMask; | |||||
394 | pictForm->direct.green = pFormat->direct.green; | |||||
395 | pictForm->direct.greenMask = pFormat->direct.greenMask; | |||||
396 | pictForm->direct.blue = pFormat->direct.blue; | |||||
397 | pictForm->direct.blueMask = pFormat->direct.blueMask; | |||||
398 | pictForm->direct.alpha = pFormat->direct.alpha; | |||||
399 | pictForm->direct.alphaMask = pFormat->direct.alphaMask; | |||||
400 | if (pFormat->type == PictTypeIndexed0 && | |||||
401 | pFormat->index.pColormap) | |||||
402 | pictForm->colormap = pFormat->index.pColormap->mid; | |||||
403 | else | |||||
404 | pictForm->colormap = None0L; | |||||
405 | if (client->swapped) { | |||||
406 | swapl(&pictForm->id)do { if (sizeof(*(&pictForm->id)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&pictForm->id) & 3) && ((uintptr_t)(&pictForm->id) & 3) == 0) *(&pictForm->id) = lswapl(*(&pictForm->id)) ; else swap_uint32((uint32_t *)(&pictForm->id)); } while (0); | |||||
407 | swaps(&pictForm->direct.red)do { if (sizeof(*(&pictForm->direct.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .red) & 1) && ((uintptr_t)(&pictForm->direct .red) & 1) == 0) *(&pictForm->direct.red) = lswaps (*(&pictForm->direct.red)); else swap_uint16((uint16_t *)(&pictForm->direct.red)); } while (0); | |||||
408 | swaps(&pictForm->direct.redMask)do { if (sizeof(*(&pictForm->direct.redMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .redMask) & 1) && ((uintptr_t)(&pictForm-> direct.redMask) & 1) == 0) *(&pictForm->direct.redMask ) = lswaps(*(&pictForm->direct.redMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.redMask)); } while (0); | |||||
409 | swaps(&pictForm->direct.green)do { if (sizeof(*(&pictForm->direct.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .green) & 1) && ((uintptr_t)(&pictForm->direct .green) & 1) == 0) *(&pictForm->direct.green) = lswaps (*(&pictForm->direct.green)); else swap_uint16((uint16_t *)(&pictForm->direct.green)); } while (0); | |||||
410 | swaps(&pictForm->direct.greenMask)do { if (sizeof(*(&pictForm->direct.greenMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .greenMask) & 1) && ((uintptr_t)(&pictForm-> direct.greenMask) & 1) == 0) *(&pictForm->direct.greenMask ) = lswaps(*(&pictForm->direct.greenMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.greenMask)); } while ( 0); | |||||
411 | swaps(&pictForm->direct.blue)do { if (sizeof(*(&pictForm->direct.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .blue) & 1) && ((uintptr_t)(&pictForm->direct .blue) & 1) == 0) *(&pictForm->direct.blue) = lswaps (*(&pictForm->direct.blue)); else swap_uint16((uint16_t *)(&pictForm->direct.blue)); } while (0); | |||||
412 | swaps(&pictForm->direct.blueMask)do { if (sizeof(*(&pictForm->direct.blueMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .blueMask) & 1) && ((uintptr_t)(&pictForm-> direct.blueMask) & 1) == 0) *(&pictForm->direct.blueMask ) = lswaps(*(&pictForm->direct.blueMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.blueMask)); } while (0 ); | |||||
413 | swaps(&pictForm->direct.alpha)do { if (sizeof(*(&pictForm->direct.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .alpha) & 1) && ((uintptr_t)(&pictForm->direct .alpha) & 1) == 0) *(&pictForm->direct.alpha) = lswaps (*(&pictForm->direct.alpha)); else swap_uint16((uint16_t *)(&pictForm->direct.alpha)); } while (0); | |||||
414 | swaps(&pictForm->direct.alphaMask)do { if (sizeof(*(&pictForm->direct.alphaMask)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->direct .alphaMask) & 1) && ((uintptr_t)(&pictForm-> direct.alphaMask) & 1) == 0) *(&pictForm->direct.alphaMask ) = lswaps(*(&pictForm->direct.alphaMask)); else swap_uint16 ((uint16_t *)(&pictForm->direct.alphaMask)); } while ( 0); | |||||
415 | swapl(&pictForm->colormap)do { if (sizeof(*(&pictForm->colormap)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictForm->colormap ) & 3) && ((uintptr_t)(&pictForm->colormap ) & 3) == 0) *(&pictForm->colormap) = lswapl(*(& pictForm->colormap)); else swap_uint32((uint32_t *)(&pictForm ->colormap)); } while (0); | |||||
416 | } | |||||
417 | pictForm++; | |||||
418 | } | |||||
419 | } | |||||
420 | } | |||||
421 | ||||||
422 | pictScreen = (xPictScreen *) pictForm; | |||||
423 | for (s = 0; s < numScreens; s++) { | |||||
424 | pScreen = screenInfo.screens[s]; | |||||
425 | pictDepth = (xPictDepth *) (pictScreen + 1); | |||||
426 | ndepth = 0; | |||||
427 | for (d = 0; d < pScreen->numDepths; d++) { | |||||
428 | pictVisual = (xPictVisual *) (pictDepth + 1); | |||||
429 | pDepth = pScreen->allowedDepths + d; | |||||
430 | ||||||
431 | nvisual = 0; | |||||
432 | for (v = 0; v < pDepth->numVids; v++) { | |||||
433 | pVisual = findVisual(pScreen, pDepth->vids[v]); | |||||
434 | if (pVisual && (pFormat = PictureMatchVisual(pScreen, | |||||
435 | pDepth->depth, | |||||
436 | pVisual))) { | |||||
437 | pictVisual->visual = pVisual->vid; | |||||
438 | pictVisual->format = pFormat->id; | |||||
439 | if (client->swapped) { | |||||
440 | swapl(&pictVisual->visual)do { if (sizeof(*(&pictVisual->visual)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictVisual-> visual) & 3) && ((uintptr_t)(&pictVisual-> visual) & 3) == 0) *(&pictVisual->visual) = lswapl (*(&pictVisual->visual)); else swap_uint32((uint32_t * )(&pictVisual->visual)); } while (0); | |||||
441 | swapl(&pictVisual->format)do { if (sizeof(*(&pictVisual->format)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictVisual-> format) & 3) && ((uintptr_t)(&pictVisual-> format) & 3) == 0) *(&pictVisual->format) = lswapl (*(&pictVisual->format)); else swap_uint32((uint32_t * )(&pictVisual->format)); } while (0); | |||||
442 | } | |||||
443 | pictVisual++; | |||||
444 | nvisual++; | |||||
445 | } | |||||
446 | } | |||||
447 | pictDepth->depth = pDepth->depth; | |||||
448 | pictDepth->nPictVisuals = nvisual; | |||||
449 | if (client->swapped) { | |||||
450 | swaps(&pictDepth->nPictVisuals)do { if (sizeof(*(&pictDepth->nPictVisuals)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictDepth->nPictVisuals ) & 1) && ((uintptr_t)(&pictDepth->nPictVisuals ) & 1) == 0) *(&pictDepth->nPictVisuals) = lswaps( *(&pictDepth->nPictVisuals)); else swap_uint16((uint16_t *)(&pictDepth->nPictVisuals)); } while (0); | |||||
451 | } | |||||
452 | ndepth++; | |||||
453 | pictDepth = (xPictDepth *) pictVisual; | |||||
454 | } | |||||
455 | pictScreen->nDepth = ndepth; | |||||
456 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); | |||||
457 | if (ps) | |||||
458 | pictScreen->fallback = ps->fallback->id; | |||||
459 | else | |||||
460 | pictScreen->fallback = 0; | |||||
461 | if (client->swapped) { | |||||
462 | swapl(&pictScreen->nDepth)do { if (sizeof(*(&pictScreen->nDepth)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictScreen-> nDepth) & 3) && ((uintptr_t)(&pictScreen-> nDepth) & 3) == 0) *(&pictScreen->nDepth) = lswapl (*(&pictScreen->nDepth)); else swap_uint32((uint32_t * )(&pictScreen->nDepth)); } while (0); | |||||
463 | swapl(&pictScreen->fallback)do { if (sizeof(*(&pictScreen->fallback)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&pictScreen-> fallback) & 3) && ((uintptr_t)(&pictScreen-> fallback) & 3) == 0) *(&pictScreen->fallback) = lswapl (*(&pictScreen->fallback)); else swap_uint32((uint32_t *)(&pictScreen->fallback)); } while (0); | |||||
464 | } | |||||
465 | pictScreen = (xPictScreen *) pictDepth; | |||||
466 | } | |||||
467 | pictSubpixel = (CARD32 *) pictScreen; | |||||
468 | ||||||
469 | for (s = 0; s < numSubpixel; s++) { | |||||
470 | pScreen = screenInfo.screens[s]; | |||||
471 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); | |||||
472 | if (ps) | |||||
473 | *pictSubpixel = ps->subpixel; | |||||
474 | else | |||||
475 | *pictSubpixel = SubPixelUnknown0; | |||||
476 | if (client->swapped) { | |||||
477 | swapl(pictSubpixel)do { if (sizeof(*(pictSubpixel)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(pictSubpixel) & 3) && ((uintptr_t)(pictSubpixel ) & 3) == 0) *(pictSubpixel) = lswapl(*(pictSubpixel)); else swap_uint32((uint32_t *)(pictSubpixel)); } while (0); | |||||
478 | } | |||||
479 | ++pictSubpixel; | |||||
480 | } | |||||
481 | ||||||
482 | if (client->swapped) { | |||||
483 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); | |||||
484 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); | |||||
485 | swapl(&reply->numFormats)do { if (sizeof(*(&reply->numFormats)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numFormats ) & 3) && ((uintptr_t)(&reply->numFormats) & 3) == 0) *(&reply->numFormats) = lswapl(*(& reply->numFormats)); else swap_uint32((uint32_t *)(&reply ->numFormats)); } while (0); | |||||
486 | swapl(&reply->numScreens)do { if (sizeof(*(&reply->numScreens)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numScreens ) & 3) && ((uintptr_t)(&reply->numScreens) & 3) == 0) *(&reply->numScreens) = lswapl(*(& reply->numScreens)); else swap_uint32((uint32_t *)(&reply ->numScreens)); } while (0); | |||||
487 | swapl(&reply->numDepths)do { if (sizeof(*(&reply->numDepths)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numDepths ) & 3) && ((uintptr_t)(&reply->numDepths) & 3) == 0) *(&reply->numDepths) = lswapl(*(&reply-> numDepths)); else swap_uint32((uint32_t *)(&reply->numDepths )); } while (0); | |||||
488 | swapl(&reply->numVisuals)do { if (sizeof(*(&reply->numVisuals)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numVisuals ) & 3) && ((uintptr_t)(&reply->numVisuals) & 3) == 0) *(&reply->numVisuals) = lswapl(*(& reply->numVisuals)); else swap_uint32((uint32_t *)(&reply ->numVisuals)); } while (0); | |||||
489 | swapl(&reply->numSubpixel)do { if (sizeof(*(&reply->numSubpixel)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numSubpixel ) & 3) && ((uintptr_t)(&reply->numSubpixel ) & 3) == 0) *(&reply->numSubpixel) = lswapl(*(& reply->numSubpixel)); else swap_uint32((uint32_t *)(&reply ->numSubpixel)); } while (0); | |||||
490 | } | |||||
491 | WriteToClient(client, rlength, reply); | |||||
492 | free(reply); | |||||
493 | return Success0; | |||||
494 | } | |||||
495 | ||||||
496 | static int | |||||
497 | ProcRenderQueryPictIndexValues(ClientPtr client) | |||||
498 | { | |||||
499 | PictFormatPtr pFormat; | |||||
500 | int rc, num; | |||||
501 | int rlength; | |||||
502 | int i; | |||||
503 | ||||||
504 | REQUEST(xRenderQueryPictIndexValuesReq)xRenderQueryPictIndexValuesReq *stuff = (xRenderQueryPictIndexValuesReq *)client->requestBuffer; | |||||
505 | xRenderQueryPictIndexValuesReply *reply; | |||||
506 | xIndexValue *values; | |||||
507 | ||||||
508 | REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq)if ((sizeof(xRenderQueryPictIndexValuesReq) >> 2) > client ->req_len ) return(16); | |||||
509 | ||||||
510 | rc = dixLookupResourceByType((void **) &pFormat, stuff->format, | |||||
511 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
512 | if (rc != Success0) | |||||
513 | return rc; | |||||
514 | ||||||
515 | if (pFormat->type != PictTypeIndexed0) { | |||||
516 | client->errorValue = stuff->format; | |||||
517 | return BadMatch8; | |||||
518 | } | |||||
519 | num = pFormat->index.nvalues; | |||||
520 | rlength = (sizeof(xRenderQueryPictIndexValuesReply) + | |||||
521 | num * sizeof(xIndexValue)); | |||||
522 | reply = (xRenderQueryPictIndexValuesReply *) calloc(1, rlength); | |||||
523 | if (!reply) | |||||
524 | return BadAlloc11; | |||||
525 | ||||||
526 | reply->type = X_Reply1; | |||||
527 | reply->sequenceNumber = client->sequence; | |||||
528 | reply->length = bytes_to_int32(rlength - sizeof(xGenericReply)); | |||||
529 | reply->numIndexValues = num; | |||||
530 | ||||||
531 | values = (xIndexValue *) (reply + 1); | |||||
532 | ||||||
533 | memcpy(reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue))__builtin___memcpy_chk (reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue), __builtin_object_size (reply + 1, 0)); | |||||
534 | ||||||
535 | if (client->swapped) { | |||||
536 | for (i = 0; i < num; i++) { | |||||
537 | swapl(&values[i].pixel)do { if (sizeof(*(&values[i].pixel)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].pixel) & 3) && ((uintptr_t)(&values[i].pixel) & 3) == 0) *(&values[i].pixel) = lswapl(*(&values[i].pixel)) ; else swap_uint32((uint32_t *)(&values[i].pixel)); } while (0); | |||||
538 | swaps(&values[i].red)do { if (sizeof(*(&values[i].red)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].red) & 1 ) && ((uintptr_t)(&values[i].red) & 1) == 0) * (&values[i].red) = lswaps(*(&values[i].red)); else swap_uint16 ((uint16_t *)(&values[i].red)); } while (0); | |||||
539 | swaps(&values[i].green)do { if (sizeof(*(&values[i].green)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].green) & 1) && ((uintptr_t)(&values[i].green) & 1) == 0) *(&values[i].green) = lswaps(*(&values[i].green)) ; else swap_uint16((uint16_t *)(&values[i].green)); } while (0); | |||||
540 | swaps(&values[i].blue)do { if (sizeof(*(&values[i].blue)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].blue) & 1) && ((uintptr_t)(&values[i].blue) & 1) == 0 ) *(&values[i].blue) = lswaps(*(&values[i].blue)); else swap_uint16((uint16_t *)(&values[i].blue)); } while (0); | |||||
541 | swaps(&values[i].alpha)do { if (sizeof(*(&values[i].alpha)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&values[i].alpha) & 1) && ((uintptr_t)(&values[i].alpha) & 1) == 0) *(&values[i].alpha) = lswaps(*(&values[i].alpha)) ; else swap_uint16((uint16_t *)(&values[i].alpha)); } while (0); | |||||
542 | } | |||||
543 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); | |||||
544 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); | |||||
545 | swapl(&reply->numIndexValues)do { if (sizeof(*(&reply->numIndexValues)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numIndexValues ) & 3) && ((uintptr_t)(&reply->numIndexValues ) & 3) == 0) *(&reply->numIndexValues) = lswapl(*( &reply->numIndexValues)); else swap_uint32((uint32_t * )(&reply->numIndexValues)); } while (0); | |||||
546 | } | |||||
547 | ||||||
548 | WriteToClient(client, rlength, reply); | |||||
549 | free(reply); | |||||
550 | return Success0; | |||||
551 | } | |||||
552 | ||||||
553 | static int | |||||
554 | ProcRenderQueryDithers(ClientPtr client) | |||||
555 | { | |||||
556 | return BadImplementation17; | |||||
557 | } | |||||
558 | ||||||
559 | static int | |||||
560 | ProcRenderCreatePicture(ClientPtr client) | |||||
561 | { | |||||
562 | PicturePtr pPicture; | |||||
563 | DrawablePtr pDrawable; | |||||
564 | PictFormatPtr pFormat; | |||||
565 | int len, error, rc; | |||||
566 | ||||||
567 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; | |||||
568 | ||||||
569 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); | |||||
570 | ||||||
571 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; | |||||
572 | rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0, | |||||
573 | DixReadAccess(1<<0) | DixAddAccess(1<<12)); | |||||
574 | if (rc != Success0) | |||||
575 | return rc; | |||||
576 | ||||||
577 | rc = dixLookupResourceByType((void **) &pFormat, stuff->format, | |||||
578 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
579 | if (rc != Success0) | |||||
580 | return rc; | |||||
581 | ||||||
582 | if (pFormat->depth != pDrawable->depth) | |||||
583 | return BadMatch8; | |||||
584 | len = client->req_len - bytes_to_int32(sizeof(xRenderCreatePictureReq)); | |||||
585 | if (Ones(stuff->mask) != len) | |||||
586 | return BadLength16; | |||||
587 | ||||||
588 | pPicture = CreatePicture(stuff->pid, | |||||
589 | pDrawable, | |||||
590 | pFormat, | |||||
591 | stuff->mask, (XID *) (stuff + 1), client, &error); | |||||
592 | if (!pPicture) | |||||
593 | return error; | |||||
594 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) | |||||
595 | return BadAlloc11; | |||||
596 | return Success0; | |||||
597 | } | |||||
598 | ||||||
599 | static int | |||||
600 | ProcRenderChangePicture(ClientPtr client) | |||||
601 | { | |||||
602 | PicturePtr pPicture; | |||||
603 | ||||||
604 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; | |||||
605 | int len; | |||||
606 | ||||||
607 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); | |||||
608 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; | |||||
609 | ||||||
610 | len = client->req_len - bytes_to_int32(sizeof(xRenderChangePictureReq)); | |||||
611 | if (Ones(stuff->mask) != len) | |||||
612 | return BadLength16; | |||||
613 | ||||||
614 | return ChangePicture(pPicture, stuff->mask, (XID *) (stuff + 1), | |||||
615 | (DevUnion *) 0, client); | |||||
616 | } | |||||
617 | ||||||
618 | static int | |||||
619 | ProcRenderSetPictureClipRectangles(ClientPtr client) | |||||
620 | { | |||||
621 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; | |||||
622 | PicturePtr pPicture; | |||||
623 | int nr; | |||||
624 | ||||||
625 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); | |||||
626 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; | |||||
627 | if (!pPicture->pDrawable) | |||||
628 | return RenderErrBase + BadPicture1; | |||||
629 | ||||||
630 | nr = (client->req_len << 2) - sizeof(xRenderSetPictureClipRectanglesReq); | |||||
631 | if (nr & 4) | |||||
632 | return BadLength16; | |||||
633 | nr >>= 3; | |||||
634 | return SetPictureClipRects(pPicture, | |||||
635 | stuff->xOrigin, stuff->yOrigin, | |||||
636 | nr, (xRectangle *) &stuff[1]); | |||||
637 | } | |||||
638 | ||||||
639 | static int | |||||
640 | ProcRenderFreePicture(ClientPtr client) | |||||
641 | { | |||||
642 | PicturePtr pPicture; | |||||
643 | ||||||
644 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; | |||||
645 | ||||||
646 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); | |||||
647 | ||||||
648 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixDestroyAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<2)); if ( tmprc != 0) return tmprc;}; | |||||
649 | FreeResource(stuff->picture, RT_NONE((RESTYPE)0)); | |||||
650 | return Success0; | |||||
651 | } | |||||
652 | ||||||
653 | static Bool | |||||
654 | PictOpValid(CARD8 op) | |||||
655 | { | |||||
656 | if ( /*PictOpMinimum <= op && */ op <= PictOpMaximum13) | |||||
657 | return TRUE1; | |||||
658 | if (PictOpDisjointMinimum0x10 <= op && op <= PictOpDisjointMaximum0x1b) | |||||
659 | return TRUE1; | |||||
660 | if (PictOpConjointMinimum0x20 <= op && op <= PictOpConjointMaximum0x2b) | |||||
661 | return TRUE1; | |||||
662 | if (PictOpBlendMinimum0x30 <= op && op <= PictOpBlendMaximum0x3e) | |||||
663 | return TRUE1; | |||||
664 | return FALSE0; | |||||
665 | } | |||||
666 | ||||||
667 | static int | |||||
668 | ProcRenderComposite(ClientPtr client) | |||||
669 | { | |||||
670 | PicturePtr pSrc, pMask, pDst; | |||||
671 | ||||||
672 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; | |||||
673 | ||||||
674 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); | |||||
675 | if (!PictOpValid(stuff->op)) { | |||||
676 | client->errorValue = stuff->op; | |||||
677 | return BadValue2; | |||||
678 | } | |||||
679 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
680 | if (!pDst->pDrawable) | |||||
681 | return BadDrawable9; | |||||
682 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
683 | VERIFY_ALPHA(pMask, stuff->mask, client, DixReadAccess){ if (stuff->mask == 0L) pMask = 0; else { { int tmprc = dixLookupResourceByType ((void *)&(pMask), stuff->mask, PictureType, client, ( 1<<0)); if (tmprc != 0) return tmprc;}; } }; | |||||
684 | if ((pSrc->pDrawable && | |||||
685 | pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) || (pMask && | |||||
686 | pMask-> | |||||
687 | pDrawable && | |||||
688 | pDst-> | |||||
689 | pDrawable-> | |||||
690 | pScreen != | |||||
691 | pMask-> | |||||
692 | pDrawable-> | |||||
693 | pScreen)) | |||||
694 | return BadMatch8; | |||||
695 | CompositePicture(stuff->op, | |||||
696 | pSrc, | |||||
697 | pMask, | |||||
698 | pDst, | |||||
699 | stuff->xSrc, | |||||
700 | stuff->ySrc, | |||||
701 | stuff->xMask, | |||||
702 | stuff->yMask, | |||||
703 | stuff->xDst, stuff->yDst, stuff->width, stuff->height); | |||||
704 | return Success0; | |||||
705 | } | |||||
706 | ||||||
707 | static int | |||||
708 | ProcRenderScale(ClientPtr client) | |||||
709 | { | |||||
710 | return BadImplementation17; | |||||
711 | } | |||||
712 | ||||||
713 | static int | |||||
714 | ProcRenderTrapezoids(ClientPtr client) | |||||
715 | { | |||||
716 | int rc, ntraps; | |||||
717 | PicturePtr pSrc, pDst; | |||||
718 | PictFormatPtr pFormat; | |||||
719 | ||||||
720 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; | |||||
721 | ||||||
722 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); | |||||
723 | if (!PictOpValid(stuff->op)) { | |||||
724 | client->errorValue = stuff->op; | |||||
725 | return BadValue2; | |||||
726 | } | |||||
727 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
728 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
729 | if (!pDst->pDrawable) | |||||
730 | return BadDrawable9; | |||||
731 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) | |||||
732 | return BadMatch8; | |||||
733 | if (stuff->maskFormat) { | |||||
734 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, | |||||
735 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
736 | if (rc != Success0) | |||||
737 | return rc; | |||||
738 | } | |||||
739 | else | |||||
740 | pFormat = 0; | |||||
741 | ntraps = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq); | |||||
742 | if (ntraps % sizeof(xTrapezoid)) | |||||
743 | return BadLength16; | |||||
744 | ntraps /= sizeof(xTrapezoid); | |||||
745 | if (ntraps) | |||||
746 | CompositeTrapezoids(stuff->op, pSrc, pDst, pFormat, | |||||
747 | stuff->xSrc, stuff->ySrc, | |||||
748 | ntraps, (xTrapezoid *) &stuff[1]); | |||||
749 | return Success0; | |||||
750 | } | |||||
751 | ||||||
752 | static int | |||||
753 | ProcRenderTriangles(ClientPtr client) | |||||
754 | { | |||||
755 | int rc, ntris; | |||||
756 | PicturePtr pSrc, pDst; | |||||
757 | PictFormatPtr pFormat; | |||||
758 | ||||||
759 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; | |||||
760 | ||||||
761 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); | |||||
762 | if (!PictOpValid(stuff->op)) { | |||||
763 | client->errorValue = stuff->op; | |||||
764 | return BadValue2; | |||||
765 | } | |||||
766 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
767 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
768 | if (!pDst->pDrawable) | |||||
769 | return BadDrawable9; | |||||
770 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) | |||||
771 | return BadMatch8; | |||||
772 | if (stuff->maskFormat) { | |||||
773 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, | |||||
774 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
775 | if (rc != Success0) | |||||
776 | return rc; | |||||
777 | } | |||||
778 | else | |||||
779 | pFormat = 0; | |||||
780 | ntris = (client->req_len << 2) - sizeof(xRenderTrianglesReq); | |||||
781 | if (ntris % sizeof(xTriangle)) | |||||
782 | return BadLength16; | |||||
783 | ntris /= sizeof(xTriangle); | |||||
784 | if (ntris) | |||||
785 | CompositeTriangles(stuff->op, pSrc, pDst, pFormat, | |||||
786 | stuff->xSrc, stuff->ySrc, | |||||
787 | ntris, (xTriangle *) &stuff[1]); | |||||
788 | return Success0; | |||||
789 | } | |||||
790 | ||||||
791 | static int | |||||
792 | ProcRenderTriStrip(ClientPtr client) | |||||
793 | { | |||||
794 | int rc, npoints; | |||||
795 | PicturePtr pSrc, pDst; | |||||
796 | PictFormatPtr pFormat; | |||||
797 | ||||||
798 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; | |||||
799 | ||||||
800 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); | |||||
801 | if (!PictOpValid(stuff->op)) { | |||||
802 | client->errorValue = stuff->op; | |||||
803 | return BadValue2; | |||||
804 | } | |||||
805 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
806 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
807 | if (!pDst->pDrawable) | |||||
808 | return BadDrawable9; | |||||
809 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) | |||||
810 | return BadMatch8; | |||||
811 | if (stuff->maskFormat) { | |||||
812 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, | |||||
813 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
814 | if (rc != Success0) | |||||
815 | return rc; | |||||
816 | } | |||||
817 | else | |||||
818 | pFormat = 0; | |||||
819 | npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq)); | |||||
820 | if (npoints & 4) | |||||
821 | return BadLength16; | |||||
822 | npoints >>= 3; | |||||
823 | if (npoints >= 3) | |||||
824 | CompositeTriStrip(stuff->op, pSrc, pDst, pFormat, | |||||
825 | stuff->xSrc, stuff->ySrc, | |||||
826 | npoints, (xPointFixed *) &stuff[1]); | |||||
827 | return Success0; | |||||
828 | } | |||||
829 | ||||||
830 | static int | |||||
831 | ProcRenderTriFan(ClientPtr client) | |||||
832 | { | |||||
833 | int rc, npoints; | |||||
834 | PicturePtr pSrc, pDst; | |||||
835 | PictFormatPtr pFormat; | |||||
836 | ||||||
837 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; | |||||
838 | ||||||
839 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); | |||||
840 | if (!PictOpValid(stuff->op)) { | |||||
841 | client->errorValue = stuff->op; | |||||
842 | return BadValue2; | |||||
843 | } | |||||
844 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
845 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
846 | if (!pDst->pDrawable) | |||||
847 | return BadDrawable9; | |||||
848 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) | |||||
849 | return BadMatch8; | |||||
850 | if (stuff->maskFormat) { | |||||
851 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, | |||||
852 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
853 | if (rc != Success0) | |||||
854 | return rc; | |||||
855 | } | |||||
856 | else | |||||
857 | pFormat = 0; | |||||
858 | npoints = ((client->req_len << 2) - sizeof(xRenderTriStripReq)); | |||||
859 | if (npoints & 4) | |||||
860 | return BadLength16; | |||||
861 | npoints >>= 3; | |||||
862 | if (npoints >= 3) | |||||
863 | CompositeTriFan(stuff->op, pSrc, pDst, pFormat, | |||||
864 | stuff->xSrc, stuff->ySrc, | |||||
865 | npoints, (xPointFixed *) &stuff[1]); | |||||
866 | return Success0; | |||||
867 | } | |||||
868 | ||||||
869 | static int | |||||
870 | ProcRenderColorTrapezoids(ClientPtr client) | |||||
871 | { | |||||
872 | return BadImplementation17; | |||||
873 | } | |||||
874 | ||||||
875 | static int | |||||
876 | ProcRenderColorTriangles(ClientPtr client) | |||||
877 | { | |||||
878 | return BadImplementation17; | |||||
879 | } | |||||
880 | ||||||
881 | static int | |||||
882 | ProcRenderTransform(ClientPtr client) | |||||
883 | { | |||||
884 | return BadImplementation17; | |||||
885 | } | |||||
886 | ||||||
887 | static int | |||||
888 | ProcRenderCreateGlyphSet(ClientPtr client) | |||||
889 | { | |||||
890 | GlyphSetPtr glyphSet; | |||||
891 | PictFormatPtr format; | |||||
892 | int rc, f; | |||||
893 | ||||||
894 | REQUEST(xRenderCreateGlyphSetReq)xRenderCreateGlyphSetReq *stuff = (xRenderCreateGlyphSetReq * )client->requestBuffer; | |||||
895 | ||||||
896 | REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq)if ((sizeof(xRenderCreateGlyphSetReq) >> 2) != client-> req_len) return(16); | |||||
897 | ||||||
898 | LEGAL_NEW_RESOURCE(stuff->gsid, client)if (!LegalNewID(stuff->gsid,client)) { client->errorValue = stuff->gsid; return 14; }; | |||||
899 | rc = dixLookupResourceByType((void **) &format, stuff->format, | |||||
900 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
901 | if (rc != Success0) | |||||
902 | return rc; | |||||
903 | ||||||
904 | switch (format->depth) { | |||||
905 | case 1: | |||||
906 | f = GlyphFormat10; | |||||
907 | break; | |||||
908 | case 4: | |||||
909 | f = GlyphFormat41; | |||||
910 | break; | |||||
911 | case 8: | |||||
912 | f = GlyphFormat82; | |||||
913 | break; | |||||
914 | case 16: | |||||
915 | f = GlyphFormat163; | |||||
916 | break; | |||||
917 | case 32: | |||||
918 | f = GlyphFormat324; | |||||
919 | break; | |||||
920 | default: | |||||
921 | return BadMatch8; | |||||
922 | } | |||||
923 | if (format->type != PictTypeDirect1) | |||||
924 | return BadMatch8; | |||||
925 | glyphSet = AllocateGlyphSet(f, format); | |||||
926 | if (!glyphSet) | |||||
927 | return BadAlloc11; | |||||
928 | /* security creation/labeling check */ | |||||
929 | rc = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->gsid, GlyphSetType, | |||||
930 | glyphSet, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); | |||||
931 | if (rc != Success0) | |||||
932 | return rc; | |||||
933 | if (!AddResourceDarwin_X_AddResource(stuff->gsid, GlyphSetType, (void *) glyphSet)) | |||||
934 | return BadAlloc11; | |||||
935 | return Success0; | |||||
936 | } | |||||
937 | ||||||
938 | static int | |||||
939 | ProcRenderReferenceGlyphSet(ClientPtr client) | |||||
940 | { | |||||
941 | GlyphSetPtr glyphSet; | |||||
942 | int rc; | |||||
943 | ||||||
944 | REQUEST(xRenderReferenceGlyphSetReq)xRenderReferenceGlyphSetReq *stuff = (xRenderReferenceGlyphSetReq *)client->requestBuffer; | |||||
945 | ||||||
946 | REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq)if ((sizeof(xRenderReferenceGlyphSetReq) >> 2) != client ->req_len) return(16); | |||||
947 | ||||||
948 | LEGAL_NEW_RESOURCE(stuff->gsid, client)if (!LegalNewID(stuff->gsid,client)) { client->errorValue = stuff->gsid; return 14; }; | |||||
949 | ||||||
950 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->existing, | |||||
951 | GlyphSetType, client, DixGetAttrAccess(1<<4)); | |||||
952 | if (rc != Success0) { | |||||
953 | client->errorValue = stuff->existing; | |||||
954 | return rc; | |||||
955 | } | |||||
956 | glyphSet->refcnt++; | |||||
957 | if (!AddResourceDarwin_X_AddResource(stuff->gsid, GlyphSetType, (void *) glyphSet)) | |||||
958 | return BadAlloc11; | |||||
959 | return Success0; | |||||
960 | } | |||||
961 | ||||||
962 | #define NLOCALDELTA64 64 | |||||
963 | #define NLOCALGLYPH256 256 | |||||
964 | ||||||
965 | static int | |||||
966 | ProcRenderFreeGlyphSet(ClientPtr client) | |||||
967 | { | |||||
968 | GlyphSetPtr glyphSet; | |||||
969 | int rc; | |||||
970 | ||||||
971 | REQUEST(xRenderFreeGlyphSetReq)xRenderFreeGlyphSetReq *stuff = (xRenderFreeGlyphSetReq *)client ->requestBuffer; | |||||
972 | ||||||
973 | REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq)if ((sizeof(xRenderFreeGlyphSetReq) >> 2) != client-> req_len) return(16); | |||||
974 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, | |||||
975 | GlyphSetType, client, DixDestroyAccess(1<<2)); | |||||
976 | if (rc != Success0) { | |||||
977 | client->errorValue = stuff->glyphset; | |||||
978 | return rc; | |||||
979 | } | |||||
980 | FreeResource(stuff->glyphset, RT_NONE((RESTYPE)0)); | |||||
981 | return Success0; | |||||
982 | } | |||||
983 | ||||||
984 | typedef struct _GlyphNew { | |||||
985 | Glyph id; | |||||
986 | GlyphPtr glyph; | |||||
987 | Bool found; | |||||
988 | unsigned char sha1[20]; | |||||
989 | } GlyphNewRec, *GlyphNewPtr; | |||||
990 | ||||||
991 | #define NeedsComponent(f)((((f) >> 12) & 0x0f) != 0 && (((f) ) & 0xfff) != 0) (PICT_FORMAT_A(f)(((f) >> 12) & 0x0f) != 0 && PICT_FORMAT_RGB(f)(((f) ) & 0xfff) != 0) | |||||
992 | ||||||
993 | static int | |||||
994 | ProcRenderAddGlyphs(ClientPtr client) | |||||
995 | { | |||||
996 | GlyphSetPtr glyphSet; | |||||
997 | ||||||
998 | REQUEST(xRenderAddGlyphsReq)xRenderAddGlyphsReq *stuff = (xRenderAddGlyphsReq *)client-> requestBuffer; | |||||
999 | GlyphNewRec glyphsLocal[NLOCALGLYPH256]; | |||||
1000 | GlyphNewPtr glyphsBase, glyphs, glyph_new; | |||||
1001 | int remain, nglyphs; | |||||
1002 | CARD32 *gids; | |||||
1003 | xGlyphInfo *gi; | |||||
1004 | CARD8 *bits; | |||||
1005 | unsigned int size; | |||||
1006 | int err; | |||||
1007 | int i, screen; | |||||
1008 | PicturePtr pSrc = NULL((void*)0), pDst = NULL((void*)0); | |||||
1009 | PixmapPtr pSrcPix = NULL((void*)0), pDstPix = NULL((void*)0); | |||||
1010 | CARD32 component_alpha; | |||||
1011 | ||||||
1012 | REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq)if ((sizeof(xRenderAddGlyphsReq) >> 2) > client-> req_len ) return(16); | |||||
1013 | err = | |||||
1014 | dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, | |||||
1015 | GlyphSetType, client, DixAddAccess(1<<12)); | |||||
1016 | if (err != Success0) { | |||||
1017 | client->errorValue = stuff->glyphset; | |||||
1018 | return err; | |||||
1019 | } | |||||
1020 | ||||||
1021 | err = BadAlloc11; | |||||
1022 | nglyphs = stuff->nglyphs; | |||||
1023 | if (nglyphs > UINT32_MAX4294967295U / sizeof(GlyphNewRec)) | |||||
1024 | return BadAlloc11; | |||||
1025 | ||||||
1026 | component_alpha = NeedsComponent(glyphSet->format->format)((((glyphSet->format->format) >> 12) & 0x0f) != 0 && (((glyphSet->format->format) ) & 0xfff ) != 0); | |||||
1027 | ||||||
1028 | if (nglyphs <= NLOCALGLYPH256) { | |||||
1029 | memset(glyphsLocal, 0, sizeof(glyphsLocal))__builtin___memset_chk (glyphsLocal, 0, sizeof(glyphsLocal), __builtin_object_size (glyphsLocal, 0)); | |||||
1030 | glyphsBase = glyphsLocal; | |||||
1031 | } | |||||
1032 | else { | |||||
1033 | glyphsBase = (GlyphNewPtr) calloc(nglyphs, sizeof(GlyphNewRec)); | |||||
1034 | if (!glyphsBase) | |||||
1035 | return BadAlloc11; | |||||
1036 | } | |||||
1037 | ||||||
1038 | remain = (client->req_len << 2) - sizeof(xRenderAddGlyphsReq); | |||||
1039 | ||||||
1040 | glyphs = glyphsBase; | |||||
1041 | ||||||
1042 | gids = (CARD32 *) (stuff + 1); | |||||
1043 | gi = (xGlyphInfo *) (gids + nglyphs); | |||||
1044 | bits = (CARD8 *) (gi + nglyphs); | |||||
1045 | remain -= (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs; | |||||
1046 | ||||||
1047 | /* protect against bad nglyphs */ | |||||
1048 | if (gi < ((xGlyphInfo *) stuff) || | |||||
1049 | gi > ((xGlyphInfo *) ((CARD32 *) stuff + client->req_len)) || | |||||
1050 | bits < ((CARD8 *) stuff) || | |||||
1051 | bits > ((CARD8 *) ((CARD32 *) stuff + client->req_len))) { | |||||
1052 | err = BadLength16; | |||||
1053 | goto bail; | |||||
1054 | } | |||||
1055 | ||||||
1056 | for (i = 0; i < nglyphs; i++) { | |||||
1057 | size_t padded_width; | |||||
1058 | ||||||
1059 | glyph_new = &glyphs[i]; | |||||
1060 | ||||||
1061 | padded_width = PixmapBytePad(gi[i].width, glyphSet->format->depth)((PixmapWidthPaddingInfo[glyphSet->format->depth].notPower2 ? (((int)(gi[i].width) * PixmapWidthPaddingInfo[glyphSet-> format->depth].bytesPerPixel + PixmapWidthPaddingInfo[glyphSet ->format->depth].bytesPerPixel) >> PixmapWidthPaddingInfo [glyphSet->format->depth].padBytesLog2) : ((int)((gi[i] .width) + PixmapWidthPaddingInfo[glyphSet->format->depth ].padRoundUp) >> PixmapWidthPaddingInfo[glyphSet->format ->depth].padPixelsLog2)) << PixmapWidthPaddingInfo[glyphSet ->format->depth].padBytesLog2); | |||||
1062 | ||||||
1063 | if (gi[i].height && | |||||
1064 | padded_width > (UINT32_MAX4294967295U - sizeof(GlyphRec)) / gi[i].height) | |||||
1065 | break; | |||||
1066 | ||||||
1067 | size = gi[i].height * padded_width; | |||||
1068 | if (remain < size) | |||||
1069 | break; | |||||
1070 | ||||||
1071 | err = HashGlyph(&gi[i], bits, size, glyph_new->sha1); | |||||
1072 | if (err) | |||||
1073 | goto bail; | |||||
1074 | ||||||
1075 | glyph_new->glyph = FindGlyphByHash(glyph_new->sha1, glyphSet->fdepth); | |||||
1076 | ||||||
1077 | if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph((GlyphPtr) 1)) { | |||||
1078 | glyph_new->found = TRUE1; | |||||
1079 | } | |||||
1080 | else { | |||||
1081 | GlyphPtr glyph; | |||||
1082 | ||||||
1083 | glyph_new->found = FALSE0; | |||||
1084 | glyph_new->glyph = glyph = AllocateGlyph(&gi[i], glyphSet->fdepth); | |||||
1085 | if (!glyph) { | |||||
1086 | err = BadAlloc11; | |||||
1087 | goto bail; | |||||
1088 | } | |||||
1089 | ||||||
1090 | for (screen = 0; screen < screenInfo.numScreens; screen++) { | |||||
1091 | int width = gi[i].width; | |||||
1092 | int height = gi[i].height; | |||||
1093 | int depth = glyphSet->format->depth; | |||||
1094 | ScreenPtr pScreen; | |||||
1095 | int error; | |||||
1096 | ||||||
1097 | /* Skip work if it's invisibly small anyway */ | |||||
1098 | if (!width || !height) | |||||
1099 | break; | |||||
1100 | ||||||
1101 | pScreen = screenInfo.screens[screen]; | |||||
1102 | pSrcPix = GetScratchPixmapHeader(pScreen, | |||||
1103 | width, height, | |||||
1104 | depth, depth, -1, bits); | |||||
1105 | if (!pSrcPix) { | |||||
1106 | err = BadAlloc11; | |||||
1107 | goto bail; | |||||
1108 | } | |||||
1109 | ||||||
1110 | pSrc = CreatePicture(0, &pSrcPix->drawable, | |||||
1111 | glyphSet->format, 0, NULL((void*)0), | |||||
1112 | serverClient, &error); | |||||
1113 | if (!pSrc) { | |||||
1114 | err = BadAlloc11; | |||||
1115 | goto bail; | |||||
1116 | } | |||||
1117 | ||||||
1118 | pDstPix = (pScreen->CreatePixmap) (pScreen, | |||||
1119 | width, height, depth, | |||||
1120 | CREATE_PIXMAP_USAGE_GLYPH_PICTURE3); | |||||
1121 | ||||||
1122 | if (!pDstPix) { | |||||
1123 | err = BadAlloc11; | |||||
1124 | goto bail; | |||||
1125 | } | |||||
1126 | ||||||
1127 | pDst = CreatePicture(0, &pDstPix->drawable, | |||||
1128 | glyphSet->format, | |||||
1129 | CPComponentAlpha(1 << 12), &component_alpha, | |||||
1130 | serverClient, &error); | |||||
1131 | SetGlyphPicture(glyph, pScreen, pDst); | |||||
1132 | ||||||
1133 | /* The picture takes a reference to the pixmap, so we | |||||
1134 | drop ours. */ | |||||
1135 | (pScreen->DestroyPixmap) (pDstPix); | |||||
1136 | pDstPix = NULL((void*)0); | |||||
1137 | ||||||
1138 | if (!pDst) { | |||||
1139 | err = BadAlloc11; | |||||
1140 | goto bail; | |||||
1141 | } | |||||
1142 | ||||||
1143 | CompositePicture(PictOpSrc1, | |||||
1144 | pSrc, | |||||
1145 | None0L, pDst, 0, 0, 0, 0, 0, 0, width, height); | |||||
1146 | ||||||
1147 | FreePicture((void *) pSrc, 0); | |||||
1148 | pSrc = NULL((void*)0); | |||||
1149 | FreeScratchPixmapHeader(pSrcPix); | |||||
1150 | pSrcPix = NULL((void*)0); | |||||
1151 | } | |||||
1152 | ||||||
1153 | memcpy(glyph_new->glyph->sha1, glyph_new->sha1, 20)__builtin___memcpy_chk (glyph_new->glyph->sha1, glyph_new ->sha1, 20, __builtin_object_size (glyph_new->glyph-> sha1, 0)); | |||||
1154 | } | |||||
1155 | ||||||
1156 | glyph_new->id = gids[i]; | |||||
1157 | ||||||
1158 | if (size & 3) | |||||
1159 | size += 4 - (size & 3); | |||||
1160 | bits += size; | |||||
1161 | remain -= size; | |||||
1162 | } | |||||
1163 | if (remain || i < nglyphs) { | |||||
1164 | err = BadLength16; | |||||
1165 | goto bail; | |||||
1166 | } | |||||
1167 | if (!ResizeGlyphSet(glyphSet, nglyphs)) { | |||||
1168 | err = BadAlloc11; | |||||
1169 | goto bail; | |||||
1170 | } | |||||
1171 | for (i = 0; i < nglyphs; i++) | |||||
1172 | AddGlyph(glyphSet, glyphs[i].glyph, glyphs[i].id); | |||||
1173 | ||||||
1174 | if (glyphsBase != glyphsLocal) | |||||
1175 | free(glyphsBase); | |||||
1176 | return Success0; | |||||
1177 | bail: | |||||
1178 | if (pSrc) | |||||
1179 | FreePicture((void *) pSrc, 0); | |||||
1180 | if (pSrcPix) | |||||
1181 | FreeScratchPixmapHeader(pSrcPix); | |||||
1182 | for (i = 0; i < nglyphs; i++) | |||||
1183 | if (glyphs[i].glyph && !glyphs[i].found) | |||||
1184 | free(glyphs[i].glyph); | |||||
1185 | if (glyphsBase != glyphsLocal) | |||||
1186 | free(glyphsBase); | |||||
1187 | return err; | |||||
1188 | } | |||||
1189 | ||||||
1190 | static int | |||||
1191 | ProcRenderAddGlyphsFromPicture(ClientPtr client) | |||||
1192 | { | |||||
1193 | return BadImplementation17; | |||||
1194 | } | |||||
1195 | ||||||
1196 | static int | |||||
1197 | ProcRenderFreeGlyphs(ClientPtr client) | |||||
1198 | { | |||||
1199 | REQUEST(xRenderFreeGlyphsReq)xRenderFreeGlyphsReq *stuff = (xRenderFreeGlyphsReq *)client-> requestBuffer; | |||||
1200 | GlyphSetPtr glyphSet; | |||||
1201 | int rc, nglyph; | |||||
1202 | CARD32 *gids; | |||||
1203 | CARD32 glyph; | |||||
1204 | ||||||
1205 | REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq)if ((sizeof(xRenderFreeGlyphsReq) >> 2) > client-> req_len ) return(16); | |||||
1206 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, | |||||
1207 | GlyphSetType, client, DixRemoveAccess(1<<13)); | |||||
1208 | if (rc != Success0) { | |||||
1209 | client->errorValue = stuff->glyphset; | |||||
1210 | return rc; | |||||
1211 | } | |||||
1212 | nglyph = | |||||
1213 | bytes_to_int32((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)); | |||||
1214 | gids = (CARD32 *) (stuff + 1); | |||||
1215 | while (nglyph-- > 0) { | |||||
1216 | glyph = *gids++; | |||||
1217 | if (!DeleteGlyph(glyphSet, glyph)) { | |||||
1218 | client->errorValue = glyph; | |||||
1219 | return RenderErrBase + BadGlyph4; | |||||
1220 | } | |||||
1221 | } | |||||
1222 | return Success0; | |||||
1223 | } | |||||
1224 | ||||||
1225 | static int | |||||
1226 | ProcRenderCompositeGlyphs(ClientPtr client) | |||||
1227 | { | |||||
1228 | GlyphSetPtr glyphSet; | |||||
1229 | GlyphSet gs; | |||||
1230 | PicturePtr pSrc, pDst; | |||||
1231 | PictFormatPtr pFormat; | |||||
1232 | GlyphListRec listsLocal[NLOCALDELTA64]; | |||||
1233 | GlyphListPtr lists, listsBase; | |||||
1234 | GlyphPtr glyphsLocal[NLOCALGLYPH256]; | |||||
1235 | Glyph glyph; | |||||
1236 | GlyphPtr *glyphs, *glyphsBase; | |||||
1237 | xGlyphElt *elt; | |||||
1238 | CARD8 *buffer, *end; | |||||
1239 | int nglyph; | |||||
1240 | int nlist; | |||||
1241 | int space; | |||||
1242 | int size; | |||||
1243 | int rc, n; | |||||
1244 | ||||||
1245 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; | |||||
1246 | ||||||
1247 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); | |||||
1248 | ||||||
1249 | switch (stuff->renderReqType) { | |||||
1250 | default: | |||||
1251 | size = 1; | |||||
1252 | break; | |||||
1253 | case X_RenderCompositeGlyphs1624: | |||||
1254 | size = 2; | |||||
1255 | break; | |||||
1256 | case X_RenderCompositeGlyphs3225: | |||||
1257 | size = 4; | |||||
1258 | break; | |||||
1259 | } | |||||
1260 | ||||||
1261 | if (!PictOpValid(stuff->op)) { | |||||
1262 | client->errorValue = stuff->op; | |||||
1263 | return BadValue2; | |||||
1264 | } | |||||
1265 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
1266 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
1267 | if (!pDst->pDrawable) | |||||
1268 | return BadDrawable9; | |||||
1269 | if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen) | |||||
1270 | return BadMatch8; | |||||
1271 | if (stuff->maskFormat) { | |||||
1272 | rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat, | |||||
1273 | PictFormatType, client, DixReadAccess(1<<0)); | |||||
1274 | if (rc != Success0) | |||||
1275 | return rc; | |||||
1276 | } | |||||
1277 | else | |||||
1278 | pFormat = 0; | |||||
1279 | ||||||
1280 | rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset, | |||||
1281 | GlyphSetType, client, DixUseAccess(1<<24)); | |||||
1282 | if (rc != Success0) | |||||
1283 | return rc; | |||||
1284 | ||||||
1285 | buffer = (CARD8 *) (stuff + 1); | |||||
1286 | end = (CARD8 *) stuff + (client->req_len << 2); | |||||
1287 | nglyph = 0; | |||||
1288 | nlist = 0; | |||||
1289 | while (buffer + sizeof(xGlyphElt) < end) { | |||||
1290 | elt = (xGlyphElt *) buffer; | |||||
1291 | buffer += sizeof(xGlyphElt); | |||||
1292 | ||||||
1293 | if (elt->len == 0xff) { | |||||
1294 | buffer += 4; | |||||
1295 | } | |||||
1296 | else { | |||||
1297 | nlist++; | |||||
1298 | nglyph += elt->len; | |||||
1299 | space = size * elt->len; | |||||
1300 | if (space & 3) | |||||
1301 | space += 4 - (space & 3); | |||||
1302 | buffer += space; | |||||
1303 | } | |||||
1304 | } | |||||
1305 | if (nglyph <= NLOCALGLYPH256) | |||||
1306 | glyphsBase = glyphsLocal; | |||||
1307 | else { | |||||
1308 | glyphsBase = xallocarray(nglyph, sizeof(GlyphPtr))xreallocarray(((void*)0), (nglyph), (sizeof(GlyphPtr))); | |||||
1309 | if (!glyphsBase) | |||||
1310 | return BadAlloc11; | |||||
1311 | } | |||||
1312 | if (nlist <= NLOCALDELTA64) | |||||
1313 | listsBase = listsLocal; | |||||
1314 | else { | |||||
1315 | listsBase = xallocarray(nlist, sizeof(GlyphListRec))xreallocarray(((void*)0), (nlist), (sizeof(GlyphListRec))); | |||||
1316 | if (!listsBase) { | |||||
1317 | rc = BadAlloc11; | |||||
1318 | goto bail; | |||||
1319 | } | |||||
1320 | } | |||||
1321 | buffer = (CARD8 *) (stuff + 1); | |||||
1322 | glyphs = glyphsBase; | |||||
1323 | lists = listsBase; | |||||
1324 | while (buffer + sizeof(xGlyphElt) < end) { | |||||
1325 | elt = (xGlyphElt *) buffer; | |||||
1326 | buffer += sizeof(xGlyphElt); | |||||
1327 | ||||||
1328 | if (elt->len == 0xff) { | |||||
1329 | if (buffer + sizeof(GlyphSet) < end) { | |||||
1330 | memcpy(&gs, buffer, sizeof(GlyphSet))__builtin___memcpy_chk (&gs, buffer, sizeof(GlyphSet), __builtin_object_size (&gs, 0)); | |||||
1331 | rc = dixLookupResourceByType((void **) &glyphSet, gs, | |||||
1332 | GlyphSetType, client, | |||||
1333 | DixUseAccess(1<<24)); | |||||
1334 | if (rc != Success0) | |||||
1335 | goto bail; | |||||
1336 | } | |||||
1337 | buffer += 4; | |||||
1338 | } | |||||
1339 | else { | |||||
1340 | lists->xOff = elt->deltax; | |||||
1341 | lists->yOff = elt->deltay; | |||||
1342 | lists->format = glyphSet->format; | |||||
1343 | lists->len = 0; | |||||
1344 | n = elt->len; | |||||
1345 | while (n--) { | |||||
1346 | if (buffer + size <= end) { | |||||
1347 | switch (size) { | |||||
1348 | case 1: | |||||
1349 | glyph = *((CARD8 *) buffer); | |||||
1350 | break; | |||||
1351 | case 2: | |||||
1352 | glyph = *((CARD16 *) buffer); | |||||
1353 | break; | |||||
1354 | case 4: | |||||
1355 | default: | |||||
1356 | glyph = *((CARD32 *) buffer); | |||||
1357 | break; | |||||
1358 | } | |||||
1359 | if ((*glyphs = FindGlyph(glyphSet, glyph))) { | |||||
1360 | lists->len++; | |||||
1361 | glyphs++; | |||||
1362 | } | |||||
1363 | } | |||||
1364 | buffer += size; | |||||
1365 | } | |||||
1366 | space = size * elt->len; | |||||
1367 | if (space & 3) | |||||
1368 | buffer += 4 - (space & 3); | |||||
1369 | lists++; | |||||
1370 | } | |||||
1371 | } | |||||
1372 | if (buffer > end) { | |||||
1373 | rc = BadLength16; | |||||
1374 | goto bail; | |||||
1375 | } | |||||
1376 | ||||||
1377 | CompositeGlyphs(stuff->op, | |||||
1378 | pSrc, | |||||
1379 | pDst, | |||||
1380 | pFormat, | |||||
1381 | stuff->xSrc, stuff->ySrc, nlist, listsBase, glyphsBase); | |||||
1382 | rc = Success0; | |||||
1383 | ||||||
1384 | bail: | |||||
1385 | if (glyphsBase != glyphsLocal) | |||||
1386 | free(glyphsBase); | |||||
1387 | if (listsBase != listsLocal) | |||||
1388 | free(listsBase); | |||||
1389 | return rc; | |||||
1390 | } | |||||
1391 | ||||||
1392 | static int | |||||
1393 | ProcRenderFillRectangles(ClientPtr client) | |||||
1394 | { | |||||
1395 | PicturePtr pDst; | |||||
1396 | int things; | |||||
1397 | ||||||
1398 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; | |||||
1399 | ||||||
1400 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); | |||||
1401 | if (!PictOpValid(stuff->op)) { | |||||
1402 | client->errorValue = stuff->op; | |||||
1403 | return BadValue2; | |||||
1404 | } | |||||
1405 | VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pDst), stuff ->dst, PictureType, client, (1<<1)); if (tmprc != 0) return tmprc;}; | |||||
1406 | if (!pDst->pDrawable) | |||||
1407 | return BadDrawable9; | |||||
1408 | ||||||
1409 | things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq); | |||||
1410 | if (things & 4) | |||||
1411 | return BadLength16; | |||||
1412 | things >>= 3; | |||||
1413 | ||||||
1414 | CompositeRects(stuff->op, | |||||
1415 | pDst, &stuff->color, things, (xRectangle *) &stuff[1]); | |||||
1416 | ||||||
1417 | return Success0; | |||||
1418 | } | |||||
1419 | ||||||
1420 | static void | |||||
1421 | RenderSetBit(unsigned char *line, int x, int bit) | |||||
1422 | { | |||||
1423 | unsigned char mask; | |||||
1424 | ||||||
1425 | if (screenInfo.bitmapBitOrder == LSBFirst0) | |||||
1426 | mask = (1 << (x & 7)); | |||||
1427 | else | |||||
1428 | mask = (0x80 >> (x & 7)); | |||||
1429 | /* XXX assumes byte order is host byte order */ | |||||
1430 | line += (x >> 3); | |||||
1431 | if (bit) | |||||
1432 | *line |= mask; | |||||
1433 | else | |||||
1434 | *line &= ~mask; | |||||
1435 | } | |||||
1436 | ||||||
1437 | #define DITHER_DIM2 2 | |||||
1438 | ||||||
1439 | static CARD32 orderedDither[DITHER_DIM2][DITHER_DIM2] = { | |||||
1440 | {1, 3,}, | |||||
1441 | {4, 2,}, | |||||
1442 | }; | |||||
1443 | ||||||
1444 | #define DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) ((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) | |||||
1445 | ||||||
1446 | static int | |||||
1447 | ProcRenderCreateCursor(ClientPtr client) | |||||
1448 | { | |||||
1449 | REQUEST(xRenderCreateCursorReq)xRenderCreateCursorReq *stuff = (xRenderCreateCursorReq *)client ->requestBuffer; | |||||
1450 | PicturePtr pSrc; | |||||
1451 | ScreenPtr pScreen; | |||||
1452 | unsigned short width, height; | |||||
1453 | CARD32 *argbbits, *argb; | |||||
1454 | unsigned char *srcbits, *srcline; | |||||
1455 | unsigned char *mskbits, *mskline; | |||||
1456 | int stride; | |||||
1457 | int x, y; | |||||
1458 | int nbytes_mono; | |||||
1459 | CursorMetricRec cm; | |||||
1460 | CursorPtr pCursor; | |||||
1461 | CARD32 twocolor[3]; | |||||
1462 | int rc, ncolor; | |||||
1463 | ||||||
1464 | REQUEST_SIZE_MATCH(xRenderCreateCursorReq)if ((sizeof(xRenderCreateCursorReq) >> 2) != client-> req_len) return(16); | |||||
1465 | LEGAL_NEW_RESOURCE(stuff->cid, client)if (!LegalNewID(stuff->cid,client)) { client->errorValue = stuff->cid; return 14; }; | |||||
1466 | ||||||
1467 | VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess){ int tmprc = dixLookupResourceByType((void *)&(pSrc), stuff ->src, PictureType, client, (1<<0)); if (tmprc != 0) return tmprc;}; | |||||
1468 | if (!pSrc->pDrawable) | |||||
| ||||||
1469 | return BadDrawable9; | |||||
1470 | pScreen = pSrc->pDrawable->pScreen; | |||||
1471 | width = pSrc->pDrawable->width; | |||||
1472 | height = pSrc->pDrawable->height; | |||||
1473 | if (height && width > UINT32_MAX4294967295U / (height * sizeof(CARD32))) | |||||
1474 | return BadAlloc11; | |||||
1475 | if (stuff->x > width || stuff->y > height) | |||||
1476 | return BadMatch8; | |||||
1477 | argbbits = malloc(width * height * sizeof(CARD32)); | |||||
1478 | if (!argbbits) | |||||
1479 | return BadAlloc11; | |||||
1480 | ||||||
1481 | stride = BitmapBytePad(width)(((int)((width) + 32 - 1) >> 5) << 2); | |||||
1482 | nbytes_mono = stride * height; | |||||
1483 | srcbits = calloc(1, nbytes_mono); | |||||
1484 | if (!srcbits) { | |||||
1485 | free(argbbits); | |||||
1486 | return BadAlloc11; | |||||
1487 | } | |||||
1488 | mskbits = calloc(1, nbytes_mono); | |||||
1489 | if (!mskbits) { | |||||
1490 | free(argbbits); | |||||
1491 | free(srcbits); | |||||
1492 | return BadAlloc11; | |||||
1493 | } | |||||
1494 | ||||||
1495 | if (pSrc->format == PICT_a8r8g8b8) { | |||||
1496 | (*pScreen->GetImage) (pSrc->pDrawable, | |||||
1497 | 0, 0, width, height, ZPixmap2, | |||||
1498 | 0xffffffff, (void *) argbbits); | |||||
1499 | } | |||||
1500 | else { | |||||
1501 | PixmapPtr pPixmap; | |||||
1502 | PicturePtr pPicture; | |||||
1503 | PictFormatPtr pFormat; | |||||
1504 | int error; | |||||
1505 | ||||||
1506 | pFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8); | |||||
1507 | if (!pFormat) { | |||||
1508 | free(argbbits); | |||||
1509 | free(srcbits); | |||||
1510 | free(mskbits); | |||||
1511 | return BadImplementation17; | |||||
1512 | } | |||||
1513 | pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32, | |||||
1514 | CREATE_PIXMAP_USAGE_SCRATCH1); | |||||
1515 | if (!pPixmap) { | |||||
1516 | free(argbbits); | |||||
1517 | free(srcbits); | |||||
1518 | free(mskbits); | |||||
1519 | return BadAlloc11; | |||||
1520 | } | |||||
1521 | pPicture = CreatePicture(0, &pPixmap->drawable, pFormat, 0, 0, | |||||
1522 | client, &error); | |||||
1523 | if (!pPicture) { | |||||
1524 | free(argbbits); | |||||
1525 | free(srcbits); | |||||
1526 | free(mskbits); | |||||
1527 | return error; | |||||
1528 | } | |||||
1529 | (*pScreen->DestroyPixmap) (pPixmap); | |||||
1530 | CompositePicture(PictOpSrc1, | |||||
1531 | pSrc, 0, pPicture, 0, 0, 0, 0, 0, 0, width, height); | |||||
1532 | (*pScreen->GetImage) (pPicture->pDrawable, | |||||
1533 | 0, 0, width, height, ZPixmap2, | |||||
1534 | 0xffffffff, (void *) argbbits); | |||||
1535 | FreePicture(pPicture, 0); | |||||
1536 | } | |||||
1537 | /* | |||||
1538 | * Check whether the cursor can be directly supported by | |||||
1539 | * the core cursor code | |||||
1540 | */ | |||||
1541 | ncolor = 0; | |||||
1542 | argb = argbbits; | |||||
1543 | for (y = 0; ncolor <= 2 && y < height; y++) { | |||||
1544 | for (x = 0; ncolor <= 2 && x < width; x++) { | |||||
1545 | CARD32 p = *argb++; | |||||
1546 | CARD32 a = (p >> 24); | |||||
1547 | ||||||
1548 | if (a == 0) /* transparent */ | |||||
1549 | continue; | |||||
1550 | if (a == 0xff) { /* opaque */ | |||||
1551 | int n; | |||||
1552 | ||||||
1553 | for (n = 0; n < ncolor; n++) | |||||
1554 | if (p == twocolor[n]) | |||||
1555 | break; | |||||
1556 | if (n == ncolor) | |||||
1557 | twocolor[ncolor++] = p; | |||||
1558 | } | |||||
1559 | else | |||||
1560 | ncolor = 3; | |||||
1561 | } | |||||
1562 | } | |||||
1563 | ||||||
1564 | /* | |||||
1565 | * Convert argb image to two plane cursor | |||||
1566 | */ | |||||
1567 | srcline = srcbits; | |||||
1568 | mskline = mskbits; | |||||
1569 | argb = argbbits; | |||||
1570 | for (y = 0; y < height; y++) { | |||||
1571 | for (x = 0; x < width; x++) { | |||||
1572 | CARD32 p = *argb++; | |||||
1573 | ||||||
1574 | if (ncolor <= 2) { | |||||
1575 | CARD32 a = ((p >> 24)); | |||||
1576 | ||||||
1577 | RenderSetBit(mskline, x, a != 0); | |||||
1578 | RenderSetBit(srcline, x, a != 0 && p == twocolor[0]); | |||||
1579 | } | |||||
1580 | else { | |||||
1581 | CARD32 a = ((p >> 24) * DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) + 127) / 255; | |||||
1582 | CARD32 i = ((CvtR8G8B8toY15(p)(((((p) >> 16) & 0xff) * 153 + (((p) >> 8) & 0xff) * 301 + (((p) ) & 0xff) * 58) >> 2) >> 7) * DITHER_SIZE((sizeof orderedDither / sizeof orderedDither[0][0]) + 1) + 127) / 255; | |||||
1583 | CARD32 d = | |||||
1584 | orderedDither[y & (DITHER_DIM2 - 1)][x & (DITHER_DIM2 - 1)]; | |||||
1585 | /* Set mask from dithered alpha value */ | |||||
1586 | RenderSetBit(mskline, x, a > d); | |||||
1587 | /* Set src from dithered intensity value */ | |||||
1588 | RenderSetBit(srcline, x, a > d && i <= d); | |||||
1589 | } | |||||
1590 | } | |||||
1591 | srcline += stride; | |||||
1592 | mskline += stride; | |||||
1593 | } | |||||
1594 | /* | |||||
1595 | * Dither to white and black if the cursor has more than two colors | |||||
1596 | */ | |||||
1597 | if (ncolor > 2) { | |||||
1598 | twocolor[0] = 0xff000000; | |||||
1599 | twocolor[1] = 0xffffffff; | |||||
1600 | } | |||||
1601 | else { | |||||
1602 | free(argbbits); | |||||
1603 | argbbits = 0; | |||||
1604 | } | |||||
1605 | ||||||
1606 | #define GetByte(p,s)(((p) >> (s)) & 0xff) (((p) >> (s)) & 0xff) | |||||
1607 | #define GetColor(p,s)((((p) >> (s)) & 0xff) | ((((p) >> (s)) & 0xff) << 8)) (GetByte(p,s)(((p) >> (s)) & 0xff) | (GetByte(p,s)(((p) >> (s)) & 0xff) << 8)) | |||||
1608 | ||||||
1609 | cm.width = width; | |||||
1610 | cm.height = height; | |||||
1611 | cm.xhot = stuff->x; | |||||
1612 | cm.yhot = stuff->y; | |||||
1613 | rc = AllocARGBCursor(srcbits, mskbits, argbbits, &cm, | |||||
1614 | GetColor(twocolor[0], 16)((((twocolor[0]) >> (16)) & 0xff) | ((((twocolor[0] ) >> (16)) & 0xff) << 8)), | |||||
1615 | GetColor(twocolor[0], 8)((((twocolor[0]) >> (8)) & 0xff) | ((((twocolor[0]) >> (8)) & 0xff) << 8)), | |||||
1616 | GetColor(twocolor[0], 0)((((twocolor[0]) >> (0)) & 0xff) | ((((twocolor[0]) >> (0)) & 0xff) << 8)), | |||||
1617 | GetColor(twocolor[1], 16)((((twocolor[1]) >> (16)) & 0xff) | ((((twocolor[1] ) >> (16)) & 0xff) << 8)), | |||||
| ||||||
1618 | GetColor(twocolor[1], 8)((((twocolor[1]) >> (8)) & 0xff) | ((((twocolor[1]) >> (8)) & 0xff) << 8)), | |||||
1619 | GetColor(twocolor[1], 0)((((twocolor[1]) >> (0)) & 0xff) | ((((twocolor[1]) >> (0)) & 0xff) << 8)), | |||||
1620 | &pCursor, client, stuff->cid); | |||||
1621 | if (rc != Success0) | |||||
1622 | goto bail; | |||||
1623 | if (!AddResourceDarwin_X_AddResource(stuff->cid, RT_CURSOR((RESTYPE)5), (void *) pCursor)) { | |||||
1624 | rc = BadAlloc11; | |||||
1625 | goto bail; | |||||
1626 | } | |||||
1627 | ||||||
1628 | return Success0; | |||||
1629 | bail: | |||||
1630 | free(srcbits); | |||||
1631 | free(mskbits); | |||||
1632 | return rc; | |||||
1633 | } | |||||
1634 | ||||||
1635 | static int | |||||
1636 | ProcRenderSetPictureTransform(ClientPtr client) | |||||
1637 | { | |||||
1638 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; | |||||
1639 | PicturePtr pPicture; | |||||
1640 | ||||||
1641 | REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) != client ->req_len) return(16); | |||||
1642 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; | |||||
1643 | return SetPictureTransform(pPicture, (PictTransform *) &stuff->transform); | |||||
1644 | } | |||||
1645 | ||||||
1646 | static int | |||||
1647 | ProcRenderQueryFilters(ClientPtr client) | |||||
1648 | { | |||||
1649 | REQUEST(xRenderQueryFiltersReq)xRenderQueryFiltersReq *stuff = (xRenderQueryFiltersReq *)client ->requestBuffer; | |||||
1650 | DrawablePtr pDrawable; | |||||
1651 | xRenderQueryFiltersReply *reply; | |||||
1652 | int nbytesName; | |||||
1653 | int nnames; | |||||
1654 | ScreenPtr pScreen; | |||||
1655 | PictureScreenPtr ps; | |||||
1656 | int i, j, len, total_bytes, rc; | |||||
1657 | INT16 *aliases; | |||||
1658 | char *names; | |||||
1659 | ||||||
1660 | REQUEST_SIZE_MATCH(xRenderQueryFiltersReq)if ((sizeof(xRenderQueryFiltersReq) >> 2) != client-> req_len) return(16); | |||||
1661 | rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0, | |||||
1662 | DixGetAttrAccess(1<<4)); | |||||
1663 | if (rc != Success0) | |||||
1664 | return rc; | |||||
1665 | ||||||
1666 | pScreen = pDrawable->pScreen; | |||||
1667 | nbytesName = 0; | |||||
1668 | nnames = 0; | |||||
1669 | ps = GetPictureScreenIfSet(pScreen)(dixPrivateKeyRegistered((&PictureScreenPrivateKeyRec)) ? ((PictureScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates , (&PictureScreenPrivateKeyRec))) : ((void*)0)); | |||||
1670 | if (ps) { | |||||
1671 | for (i = 0; i < ps->nfilters; i++) | |||||
1672 | nbytesName += 1 + strlen(ps->filters[i].name); | |||||
1673 | for (i = 0; i < ps->nfilterAliases; i++) | |||||
1674 | nbytesName += 1 + strlen(ps->filterAliases[i].alias); | |||||
1675 | nnames = ps->nfilters + ps->nfilterAliases; | |||||
1676 | } | |||||
1677 | len = ((nnames + 1) >> 1) + bytes_to_int32(nbytesName); | |||||
1678 | total_bytes = sizeof(xRenderQueryFiltersReply) + (len << 2); | |||||
1679 | reply = (xRenderQueryFiltersReply *) calloc(1, total_bytes); | |||||
1680 | if (!reply) | |||||
1681 | return BadAlloc11; | |||||
1682 | aliases = (INT16 *) (reply + 1); | |||||
1683 | names = (char *) (aliases + ((nnames + 1) & ~1)); | |||||
1684 | ||||||
1685 | reply->type = X_Reply1; | |||||
1686 | reply->sequenceNumber = client->sequence; | |||||
1687 | reply->length = len; | |||||
1688 | reply->numAliases = nnames; | |||||
1689 | reply->numFilters = nnames; | |||||
1690 | if (ps) { | |||||
1691 | ||||||
1692 | /* fill in alias values */ | |||||
1693 | for (i = 0; i < ps->nfilters; i++) | |||||
1694 | aliases[i] = FilterAliasNone-1; | |||||
1695 | for (i = 0; i < ps->nfilterAliases; i++) { | |||||
1696 | for (j = 0; j < ps->nfilters; j++) | |||||
1697 | if (ps->filterAliases[i].filter_id == ps->filters[j].id) | |||||
1698 | break; | |||||
1699 | if (j == ps->nfilters) { | |||||
1700 | for (j = 0; j < ps->nfilterAliases; j++) | |||||
1701 | if (ps->filterAliases[i].filter_id == | |||||
1702 | ps->filterAliases[j].alias_id) { | |||||
1703 | break; | |||||
1704 | } | |||||
1705 | if (j == ps->nfilterAliases) | |||||
1706 | j = FilterAliasNone-1; | |||||
1707 | else | |||||
1708 | j = j + ps->nfilters; | |||||
1709 | } | |||||
1710 | aliases[i + ps->nfilters] = j; | |||||
1711 | } | |||||
1712 | ||||||
1713 | /* fill in filter names */ | |||||
1714 | for (i = 0; i < ps->nfilters; i++) { | |||||
1715 | j = strlen(ps->filters[i].name); | |||||
1716 | *names++ = j; | |||||
1717 | memcpy(names, ps->filters[i].name, j)__builtin___memcpy_chk (names, ps->filters[i].name, j, __builtin_object_size (names, 0)); | |||||
1718 | names += j; | |||||
1719 | } | |||||
1720 | ||||||
1721 | /* fill in filter alias names */ | |||||
1722 | for (i = 0; i < ps->nfilterAliases; i++) { | |||||
1723 | j = strlen(ps->filterAliases[i].alias); | |||||
1724 | *names++ = j; | |||||
1725 | memcpy(names, ps->filterAliases[i].alias, j)__builtin___memcpy_chk (names, ps->filterAliases[i].alias, j, __builtin_object_size (names, 0)); | |||||
1726 | names += j; | |||||
1727 | } | |||||
1728 | } | |||||
1729 | ||||||
1730 | if (client->swapped) { | |||||
1731 | for (i = 0; i < reply->numAliases; i++) { | |||||
1732 | swaps(&aliases[i])do { if (sizeof(*(&aliases[i])) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&aliases[i]) & 1) && ((uintptr_t )(&aliases[i]) & 1) == 0) *(&aliases[i]) = lswaps (*(&aliases[i])); else swap_uint16((uint16_t *)(&aliases [i])); } while (0); | |||||
1733 | } | |||||
1734 | swaps(&reply->sequenceNumber)do { if (sizeof(*(&reply->sequenceNumber)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->sequenceNumber ) & 1) && ((uintptr_t)(&reply->sequenceNumber ) & 1) == 0) *(&reply->sequenceNumber) = lswaps(*( &reply->sequenceNumber)); else swap_uint16((uint16_t * )(&reply->sequenceNumber)); } while (0); | |||||
1735 | swapl(&reply->length)do { if (sizeof(*(&reply->length)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&reply->length) & 3) && ((uintptr_t)(&reply->length) & 3) == 0) *(&reply->length) = lswapl(*(&reply->length )); else swap_uint32((uint32_t *)(&reply->length)); } while (0); | |||||
1736 | swapl(&reply->numAliases)do { if (sizeof(*(&reply->numAliases)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numAliases ) & 3) && ((uintptr_t)(&reply->numAliases) & 3) == 0) *(&reply->numAliases) = lswapl(*(& reply->numAliases)); else swap_uint32((uint32_t *)(&reply ->numAliases)); } while (0); | |||||
1737 | swapl(&reply->numFilters)do { if (sizeof(*(&reply->numFilters)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&reply->numFilters ) & 3) && ((uintptr_t)(&reply->numFilters) & 3) == 0) *(&reply->numFilters) = lswapl(*(& reply->numFilters)); else swap_uint32((uint32_t *)(&reply ->numFilters)); } while (0); | |||||
1738 | } | |||||
1739 | WriteToClient(client, total_bytes, reply); | |||||
1740 | free(reply); | |||||
1741 | ||||||
1742 | return Success0; | |||||
1743 | } | |||||
1744 | ||||||
1745 | static int | |||||
1746 | ProcRenderSetPictureFilter(ClientPtr client) | |||||
1747 | { | |||||
1748 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; | |||||
1749 | PicturePtr pPicture; | |||||
1750 | int result; | |||||
1751 | xFixed *params; | |||||
1752 | int nparams; | |||||
1753 | char *name; | |||||
1754 | ||||||
1755 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); | |||||
1756 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<5)); if ( tmprc != 0) return tmprc;}; | |||||
1757 | name = (char *) (stuff + 1); | |||||
1758 | params = (xFixed *) (name + pad_to_int32(stuff->nbytes)); | |||||
1759 | nparams = ((xFixed *) stuff + client->req_len) - params; | |||||
1760 | result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams); | |||||
1761 | return result; | |||||
1762 | } | |||||
1763 | ||||||
1764 | static int | |||||
1765 | ProcRenderCreateAnimCursor(ClientPtr client) | |||||
1766 | { | |||||
1767 | REQUEST(xRenderCreateAnimCursorReq)xRenderCreateAnimCursorReq *stuff = (xRenderCreateAnimCursorReq *)client->requestBuffer; | |||||
1768 | CursorPtr *cursors; | |||||
1769 | CARD32 *deltas; | |||||
1770 | CursorPtr pCursor; | |||||
1771 | int ncursor; | |||||
1772 | xAnimCursorElt *elt; | |||||
1773 | int i; | |||||
1774 | int ret; | |||||
1775 | ||||||
1776 | REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq)if ((sizeof(xRenderCreateAnimCursorReq) >> 2) > client ->req_len ) return(16); | |||||
1777 | LEGAL_NEW_RESOURCE(stuff->cid, client)if (!LegalNewID(stuff->cid,client)) { client->errorValue = stuff->cid; return 14; }; | |||||
1778 | if (client->req_len & 1) | |||||
1779 | return BadLength16; | |||||
1780 | ncursor = | |||||
1781 | (client->req_len - | |||||
1782 | (bytes_to_int32(sizeof(xRenderCreateAnimCursorReq)))) >> 1; | |||||
1783 | cursors = xallocarray(ncursor, sizeof(CursorPtr) + sizeof(CARD32))xreallocarray(((void*)0), (ncursor), (sizeof(CursorPtr) + sizeof (CARD32))); | |||||
1784 | if (!cursors) | |||||
1785 | return BadAlloc11; | |||||
1786 | deltas = (CARD32 *) (cursors + ncursor); | |||||
1787 | elt = (xAnimCursorElt *) (stuff + 1); | |||||
1788 | for (i = 0; i < ncursor; i++) { | |||||
1789 | ret = dixLookupResourceByType((void **) (cursors + i), elt->cursor, | |||||
1790 | RT_CURSOR((RESTYPE)5), client, DixReadAccess(1<<0)); | |||||
1791 | if (ret != Success0) { | |||||
1792 | free(cursors); | |||||
1793 | return ret; | |||||
1794 | } | |||||
1795 | deltas[i] = elt->delay; | |||||
1796 | elt++; | |||||
1797 | } | |||||
1798 | ret = AnimCursorCreate(cursors, deltas, ncursor, &pCursor, client, | |||||
1799 | stuff->cid); | |||||
1800 | free(cursors); | |||||
1801 | if (ret != Success0) | |||||
1802 | return ret; | |||||
1803 | ||||||
1804 | if (AddResourceDarwin_X_AddResource(stuff->cid, RT_CURSOR((RESTYPE)5), (void *) pCursor)) | |||||
1805 | return Success0; | |||||
1806 | return BadAlloc11; | |||||
1807 | } | |||||
1808 | ||||||
1809 | static int | |||||
1810 | ProcRenderAddTraps(ClientPtr client) | |||||
1811 | { | |||||
1812 | int ntraps; | |||||
1813 | PicturePtr pPicture; | |||||
1814 | ||||||
1815 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; | |||||
1816 | ||||||
1817 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); | |||||
1818 | VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess){ int tmprc = dixLookupResourceByType((void *)&(pPicture) , stuff->picture, PictureType, client, (1<<1)); if ( tmprc != 0) return tmprc;}; | |||||
1819 | if (!pPicture->pDrawable) | |||||
1820 | return BadDrawable9; | |||||
1821 | ntraps = (client->req_len << 2) - sizeof(xRenderAddTrapsReq); | |||||
1822 | if (ntraps % sizeof(xTrap)) | |||||
1823 | return BadLength16; | |||||
1824 | ntraps /= sizeof(xTrap); | |||||
1825 | if (ntraps) | |||||
1826 | AddTraps(pPicture, | |||||
1827 | stuff->xOff, stuff->yOff, ntraps, (xTrap *) &stuff[1]); | |||||
1828 | return Success0; | |||||
1829 | } | |||||
1830 | ||||||
1831 | static int | |||||
1832 | ProcRenderCreateSolidFill(ClientPtr client) | |||||
1833 | { | |||||
1834 | PicturePtr pPicture; | |||||
1835 | int error = 0; | |||||
1836 | ||||||
1837 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; | |||||
1838 | ||||||
1839 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); | |||||
1840 | ||||||
1841 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; | |||||
1842 | ||||||
1843 | pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error); | |||||
1844 | if (!pPicture) | |||||
1845 | return error; | |||||
1846 | /* security creation/labeling check */ | |||||
1847 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, | |||||
1848 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); | |||||
1849 | if (error != Success0) | |||||
1850 | return error; | |||||
1851 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) | |||||
1852 | return BadAlloc11; | |||||
1853 | return Success0; | |||||
1854 | } | |||||
1855 | ||||||
1856 | static int | |||||
1857 | ProcRenderCreateLinearGradient(ClientPtr client) | |||||
1858 | { | |||||
1859 | PicturePtr pPicture; | |||||
1860 | int len; | |||||
1861 | int error = 0; | |||||
1862 | xFixed *stops; | |||||
1863 | xRenderColor *colors; | |||||
1864 | ||||||
1865 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; | |||||
1866 | ||||||
1867 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); | |||||
1868 | ||||||
1869 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; | |||||
1870 | ||||||
1871 | len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq); | |||||
1872 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
1873 | return BadLength16; | |||||
1874 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
1875 | return BadLength16; | |||||
1876 | ||||||
1877 | stops = (xFixed *) (stuff + 1); | |||||
1878 | colors = (xRenderColor *) (stops + stuff->nStops); | |||||
1879 | ||||||
1880 | pPicture = CreateLinearGradientPicture(stuff->pid, &stuff->p1, &stuff->p2, | |||||
1881 | stuff->nStops, stops, colors, | |||||
1882 | &error); | |||||
1883 | if (!pPicture) | |||||
1884 | return error; | |||||
1885 | /* security creation/labeling check */ | |||||
1886 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, | |||||
1887 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); | |||||
1888 | if (error != Success0) | |||||
1889 | return error; | |||||
1890 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) | |||||
1891 | return BadAlloc11; | |||||
1892 | return Success0; | |||||
1893 | } | |||||
1894 | ||||||
1895 | static int | |||||
1896 | ProcRenderCreateRadialGradient(ClientPtr client) | |||||
1897 | { | |||||
1898 | PicturePtr pPicture; | |||||
1899 | int len; | |||||
1900 | int error = 0; | |||||
1901 | xFixed *stops; | |||||
1902 | xRenderColor *colors; | |||||
1903 | ||||||
1904 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; | |||||
1905 | ||||||
1906 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); | |||||
1907 | ||||||
1908 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; | |||||
1909 | ||||||
1910 | len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq); | |||||
1911 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
1912 | return BadLength16; | |||||
1913 | ||||||
1914 | stops = (xFixed *) (stuff + 1); | |||||
1915 | colors = (xRenderColor *) (stops + stuff->nStops); | |||||
1916 | ||||||
1917 | pPicture = | |||||
1918 | CreateRadialGradientPicture(stuff->pid, &stuff->inner, &stuff->outer, | |||||
1919 | stuff->inner_radius, stuff->outer_radius, | |||||
1920 | stuff->nStops, stops, colors, &error); | |||||
1921 | if (!pPicture) | |||||
1922 | return error; | |||||
1923 | /* security creation/labeling check */ | |||||
1924 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, | |||||
1925 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); | |||||
1926 | if (error != Success0) | |||||
1927 | return error; | |||||
1928 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) | |||||
1929 | return BadAlloc11; | |||||
1930 | return Success0; | |||||
1931 | } | |||||
1932 | ||||||
1933 | static int | |||||
1934 | ProcRenderCreateConicalGradient(ClientPtr client) | |||||
1935 | { | |||||
1936 | PicturePtr pPicture; | |||||
1937 | int len; | |||||
1938 | int error = 0; | |||||
1939 | xFixed *stops; | |||||
1940 | xRenderColor *colors; | |||||
1941 | ||||||
1942 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; | |||||
1943 | ||||||
1944 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); | |||||
1945 | ||||||
1946 | LEGAL_NEW_RESOURCE(stuff->pid, client)if (!LegalNewID(stuff->pid,client)) { client->errorValue = stuff->pid; return 14; }; | |||||
1947 | ||||||
1948 | len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq); | |||||
1949 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
1950 | return BadLength16; | |||||
1951 | ||||||
1952 | stops = (xFixed *) (stuff + 1); | |||||
1953 | colors = (xRenderColor *) (stops + stuff->nStops); | |||||
1954 | ||||||
1955 | pPicture = | |||||
1956 | CreateConicalGradientPicture(stuff->pid, &stuff->center, stuff->angle, | |||||
1957 | stuff->nStops, stops, colors, &error); | |||||
1958 | if (!pPicture) | |||||
1959 | return error; | |||||
1960 | /* security creation/labeling check */ | |||||
1961 | error = XaceHook(XACE_RESOURCE_ACCESS2, client, stuff->pid, PictureType, | |||||
1962 | pPicture, RT_NONE((RESTYPE)0), NULL((void*)0), DixCreateAccess(1<<3)); | |||||
1963 | if (error != Success0) | |||||
1964 | return error; | |||||
1965 | if (!AddResourceDarwin_X_AddResource(stuff->pid, PictureType, (void *) pPicture)) | |||||
1966 | return BadAlloc11; | |||||
1967 | return Success0; | |||||
1968 | } | |||||
1969 | ||||||
1970 | static int | |||||
1971 | ProcRenderDispatch(ClientPtr client) | |||||
1972 | { | |||||
1973 | REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer; | |||||
1974 | ||||||
1975 | if (stuff->data < RenderNumberRequests(36 +1)) | |||||
1976 | return (*ProcRenderVector[stuff->data]) (client); | |||||
1977 | else | |||||
1978 | return BadRequest1; | |||||
1979 | } | |||||
1980 | ||||||
1981 | static int | |||||
1982 | SProcRenderQueryVersion(ClientPtr client) | |||||
1983 | { | |||||
1984 | REQUEST(xRenderQueryVersionReq)xRenderQueryVersionReq *stuff = (xRenderQueryVersionReq *)client ->requestBuffer; | |||||
1985 | REQUEST_SIZE_MATCH(xRenderQueryVersionReq)if ((sizeof(xRenderQueryVersionReq) >> 2) != client-> req_len) return(16); | |||||
1986 | 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); | |||||
1987 | swapl(&stuff->majorVersion)do { if (sizeof(*(&stuff->majorVersion)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->majorVersion ) & 3) && ((uintptr_t)(&stuff->majorVersion ) & 3) == 0) *(&stuff->majorVersion) = lswapl(*(& stuff->majorVersion)); else swap_uint32((uint32_t *)(& stuff->majorVersion)); } while (0); | |||||
1988 | swapl(&stuff->minorVersion)do { if (sizeof(*(&stuff->minorVersion)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->minorVersion ) & 3) && ((uintptr_t)(&stuff->minorVersion ) & 3) == 0) *(&stuff->minorVersion) = lswapl(*(& stuff->minorVersion)); else swap_uint32((uint32_t *)(& stuff->minorVersion)); } while (0); | |||||
1989 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
1990 | } | |||||
1991 | ||||||
1992 | static int | |||||
1993 | SProcRenderQueryPictFormats(ClientPtr client) | |||||
1994 | { | |||||
1995 | REQUEST(xRenderQueryPictFormatsReq)xRenderQueryPictFormatsReq *stuff = (xRenderQueryPictFormatsReq *)client->requestBuffer; | |||||
1996 | REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq)if ((sizeof(xRenderQueryPictFormatsReq) >> 2) != client ->req_len) return(16); | |||||
1997 | 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); | |||||
1998 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
1999 | } | |||||
2000 | ||||||
2001 | static int | |||||
2002 | SProcRenderQueryPictIndexValues(ClientPtr client) | |||||
2003 | { | |||||
2004 | REQUEST(xRenderQueryPictIndexValuesReq)xRenderQueryPictIndexValuesReq *stuff = (xRenderQueryPictIndexValuesReq *)client->requestBuffer; | |||||
2005 | REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq)if ((sizeof(xRenderQueryPictIndexValuesReq) >> 2) > client ->req_len ) return(16); | |||||
2006 | 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); | |||||
2007 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); | |||||
2008 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2009 | } | |||||
2010 | ||||||
2011 | static int | |||||
2012 | SProcRenderQueryDithers(ClientPtr client) | |||||
2013 | { | |||||
2014 | return BadImplementation17; | |||||
2015 | } | |||||
2016 | ||||||
2017 | static int | |||||
2018 | SProcRenderCreatePicture(ClientPtr client) | |||||
2019 | { | |||||
2020 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; | |||||
2021 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); | |||||
2022 | 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); | |||||
2023 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); | |||||
2024 | swapl(&stuff->drawable)do { if (sizeof(*(&stuff->drawable)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->drawable ) & 3) && ((uintptr_t)(&stuff->drawable) & 3) == 0) *(&stuff->drawable) = lswapl(*(&stuff-> drawable)); else swap_uint32((uint32_t *)(&stuff->drawable )); } while (0); | |||||
2025 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); | |||||
2026 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); | |||||
2027 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2028 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2029 | } | |||||
2030 | ||||||
2031 | static int | |||||
2032 | SProcRenderChangePicture(ClientPtr client) | |||||
2033 | { | |||||
2034 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; | |||||
2035 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); | |||||
2036 | 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); | |||||
2037 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2038 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); | |||||
2039 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2040 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2041 | } | |||||
2042 | ||||||
2043 | static int | |||||
2044 | SProcRenderSetPictureClipRectangles(ClientPtr client) | |||||
2045 | { | |||||
2046 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; | |||||
2047 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); | |||||
2048 | 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); | |||||
2049 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2050 | swaps(&stuff->xOrigin)do { if (sizeof(*(&stuff->xOrigin)) != 2) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->xOrigin ) & 1) && ((uintptr_t)(&stuff->xOrigin) & 1) == 0) *(&stuff->xOrigin) = lswaps(*(&stuff-> xOrigin)); else swap_uint16((uint16_t *)(&stuff->xOrigin )); } while (0); | |||||
2051 | swaps(&stuff->yOrigin)do { if (sizeof(*(&stuff->yOrigin)) != 2) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->yOrigin ) & 1) && ((uintptr_t)(&stuff->yOrigin) & 1) == 0) *(&stuff->yOrigin) = lswaps(*(&stuff-> yOrigin)); else swap_uint16((uint16_t *)(&stuff->yOrigin )); } while (0); | |||||
2052 | SwapRestS(stuff)SwapShorts((short *)(stuff + 1), ((client->req_len << 1) - (sizeof(*stuff) >> 1))); | |||||
2053 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2054 | } | |||||
2055 | ||||||
2056 | static int | |||||
2057 | SProcRenderFreePicture(ClientPtr client) | |||||
2058 | { | |||||
2059 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; | |||||
2060 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); | |||||
2061 | 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); | |||||
2062 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2063 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2064 | } | |||||
2065 | ||||||
2066 | static int | |||||
2067 | SProcRenderComposite(ClientPtr client) | |||||
2068 | { | |||||
2069 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; | |||||
2070 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); | |||||
2071 | 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); | |||||
2072 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2073 | swapl(&stuff->mask)do { if (sizeof(*(&stuff->mask)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->mask) & 3) && ((uintptr_t)(&stuff->mask) & 3) == 0 ) *(&stuff->mask) = lswapl(*(&stuff->mask)); else swap_uint32((uint32_t *)(&stuff->mask)); } while (0); | |||||
2074 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2075 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2076 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2077 | swaps(&stuff->xMask)do { if (sizeof(*(&stuff->xMask)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xMask) & 1) && ((uintptr_t)(&stuff->xMask) & 1) == 0) *(&stuff->xMask) = lswaps(*(&stuff->xMask)) ; else swap_uint16((uint16_t *)(&stuff->xMask)); } while (0); | |||||
2078 | swaps(&stuff->yMask)do { if (sizeof(*(&stuff->yMask)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yMask) & 1) && ((uintptr_t)(&stuff->yMask) & 1) == 0) *(&stuff->yMask) = lswaps(*(&stuff->yMask)) ; else swap_uint16((uint16_t *)(&stuff->yMask)); } while (0); | |||||
2079 | swaps(&stuff->xDst)do { if (sizeof(*(&stuff->xDst)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xDst) & 1) && ((uintptr_t)(&stuff->xDst) & 1) == 0 ) *(&stuff->xDst) = lswaps(*(&stuff->xDst)); else swap_uint16((uint16_t *)(&stuff->xDst)); } while (0); | |||||
2080 | swaps(&stuff->yDst)do { if (sizeof(*(&stuff->yDst)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yDst) & 1) && ((uintptr_t)(&stuff->yDst) & 1) == 0 ) *(&stuff->yDst) = lswaps(*(&stuff->yDst)); else swap_uint16((uint16_t *)(&stuff->yDst)); } while (0); | |||||
2081 | swaps(&stuff->width)do { if (sizeof(*(&stuff->width)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->width) & 1) && ((uintptr_t)(&stuff->width) & 1) == 0) *(&stuff->width) = lswaps(*(&stuff->width)) ; else swap_uint16((uint16_t *)(&stuff->width)); } while (0); | |||||
2082 | swaps(&stuff->height)do { if (sizeof(*(&stuff->height)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->height) & 1) && ((uintptr_t)(&stuff->height) & 1) == 0) *(&stuff->height) = lswaps(*(&stuff->height )); else swap_uint16((uint16_t *)(&stuff->height)); } while (0); | |||||
2083 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2084 | } | |||||
2085 | ||||||
2086 | static int | |||||
2087 | SProcRenderScale(ClientPtr client) | |||||
2088 | { | |||||
2089 | return BadImplementation17; | |||||
2090 | } | |||||
2091 | ||||||
2092 | static int | |||||
2093 | SProcRenderTrapezoids(ClientPtr client) | |||||
2094 | { | |||||
2095 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; | |||||
2096 | ||||||
2097 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); | |||||
2098 | 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); | |||||
2099 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2100 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2101 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); | |||||
2102 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2103 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2104 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2105 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2106 | } | |||||
2107 | ||||||
2108 | static int | |||||
2109 | SProcRenderTriangles(ClientPtr client) | |||||
2110 | { | |||||
2111 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; | |||||
2112 | ||||||
2113 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); | |||||
2114 | 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); | |||||
2115 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2116 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2117 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); | |||||
2118 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2119 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2120 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2121 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2122 | } | |||||
2123 | ||||||
2124 | static int | |||||
2125 | SProcRenderTriStrip(ClientPtr client) | |||||
2126 | { | |||||
2127 | REQUEST(xRenderTriStripReq)xRenderTriStripReq *stuff = (xRenderTriStripReq *)client-> requestBuffer; | |||||
2128 | ||||||
2129 | REQUEST_AT_LEAST_SIZE(xRenderTriStripReq)if ((sizeof(xRenderTriStripReq) >> 2) > client->req_len ) return(16); | |||||
2130 | 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); | |||||
2131 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2132 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2133 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); | |||||
2134 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2135 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2136 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2137 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2138 | } | |||||
2139 | ||||||
2140 | static int | |||||
2141 | SProcRenderTriFan(ClientPtr client) | |||||
2142 | { | |||||
2143 | REQUEST(xRenderTriFanReq)xRenderTriFanReq *stuff = (xRenderTriFanReq *)client->requestBuffer; | |||||
2144 | ||||||
2145 | REQUEST_AT_LEAST_SIZE(xRenderTriFanReq)if ((sizeof(xRenderTriFanReq) >> 2) > client->req_len ) return(16); | |||||
2146 | 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); | |||||
2147 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2148 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2149 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); | |||||
2150 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2151 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2152 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2153 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2154 | } | |||||
2155 | ||||||
2156 | static int | |||||
2157 | SProcRenderColorTrapezoids(ClientPtr client) | |||||
2158 | { | |||||
2159 | return BadImplementation17; | |||||
2160 | } | |||||
2161 | ||||||
2162 | static int | |||||
2163 | SProcRenderColorTriangles(ClientPtr client) | |||||
2164 | { | |||||
2165 | return BadImplementation17; | |||||
2166 | } | |||||
2167 | ||||||
2168 | static int | |||||
2169 | SProcRenderTransform(ClientPtr client) | |||||
2170 | { | |||||
2171 | return BadImplementation17; | |||||
2172 | } | |||||
2173 | ||||||
2174 | static int | |||||
2175 | SProcRenderCreateGlyphSet(ClientPtr client) | |||||
2176 | { | |||||
2177 | REQUEST(xRenderCreateGlyphSetReq)xRenderCreateGlyphSetReq *stuff = (xRenderCreateGlyphSetReq * )client->requestBuffer; | |||||
2178 | REQUEST_SIZE_MATCH(xRenderCreateGlyphSetReq)if ((sizeof(xRenderCreateGlyphSetReq) >> 2) != client-> req_len) return(16); | |||||
2179 | 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); | |||||
2180 | swapl(&stuff->gsid)do { if (sizeof(*(&stuff->gsid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->gsid) & 3) && ((uintptr_t)(&stuff->gsid) & 3) == 0 ) *(&stuff->gsid) = lswapl(*(&stuff->gsid)); else swap_uint32((uint32_t *)(&stuff->gsid)); } while (0); | |||||
2181 | swapl(&stuff->format)do { if (sizeof(*(&stuff->format)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->format) & 3) && ((uintptr_t)(&stuff->format) & 3) == 0) *(&stuff->format) = lswapl(*(&stuff->format )); else swap_uint32((uint32_t *)(&stuff->format)); } while (0); | |||||
2182 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2183 | } | |||||
2184 | ||||||
2185 | static int | |||||
2186 | SProcRenderReferenceGlyphSet(ClientPtr client) | |||||
2187 | { | |||||
2188 | REQUEST(xRenderReferenceGlyphSetReq)xRenderReferenceGlyphSetReq *stuff = (xRenderReferenceGlyphSetReq *)client->requestBuffer; | |||||
2189 | REQUEST_SIZE_MATCH(xRenderReferenceGlyphSetReq)if ((sizeof(xRenderReferenceGlyphSetReq) >> 2) != client ->req_len) return(16); | |||||
2190 | 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); | |||||
2191 | swapl(&stuff->gsid)do { if (sizeof(*(&stuff->gsid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->gsid) & 3) && ((uintptr_t)(&stuff->gsid) & 3) == 0 ) *(&stuff->gsid) = lswapl(*(&stuff->gsid)); else swap_uint32((uint32_t *)(&stuff->gsid)); } while (0); | |||||
2192 | swapl(&stuff->existing)do { if (sizeof(*(&stuff->existing)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->existing ) & 3) && ((uintptr_t)(&stuff->existing) & 3) == 0) *(&stuff->existing) = lswapl(*(&stuff-> existing)); else swap_uint32((uint32_t *)(&stuff->existing )); } while (0); | |||||
2193 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2194 | } | |||||
2195 | ||||||
2196 | static int | |||||
2197 | SProcRenderFreeGlyphSet(ClientPtr client) | |||||
2198 | { | |||||
2199 | REQUEST(xRenderFreeGlyphSetReq)xRenderFreeGlyphSetReq *stuff = (xRenderFreeGlyphSetReq *)client ->requestBuffer; | |||||
2200 | REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq)if ((sizeof(xRenderFreeGlyphSetReq) >> 2) != client-> req_len) return(16); | |||||
2201 | 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); | |||||
2202 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); | |||||
2203 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2204 | } | |||||
2205 | ||||||
2206 | static int | |||||
2207 | SProcRenderAddGlyphs(ClientPtr client) | |||||
2208 | { | |||||
2209 | register int i; | |||||
2210 | CARD32 *gids; | |||||
2211 | void *end; | |||||
2212 | xGlyphInfo *gi; | |||||
2213 | ||||||
2214 | REQUEST(xRenderAddGlyphsReq)xRenderAddGlyphsReq *stuff = (xRenderAddGlyphsReq *)client-> requestBuffer; | |||||
2215 | REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq)if ((sizeof(xRenderAddGlyphsReq) >> 2) > client-> req_len ) return(16); | |||||
2216 | 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); | |||||
2217 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); | |||||
2218 | swapl(&stuff->nglyphs)do { if (sizeof(*(&stuff->nglyphs)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->nglyphs ) & 3) && ((uintptr_t)(&stuff->nglyphs) & 3) == 0) *(&stuff->nglyphs) = lswapl(*(&stuff-> nglyphs)); else swap_uint32((uint32_t *)(&stuff->nglyphs )); } while (0); | |||||
2219 | if (stuff->nglyphs & 0xe0000000) | |||||
2220 | return BadLength16; | |||||
2221 | end = (CARD8 *) stuff + (client->req_len << 2); | |||||
2222 | gids = (CARD32 *) (stuff + 1); | |||||
2223 | gi = (xGlyphInfo *) (gids + stuff->nglyphs); | |||||
2224 | if ((char *) end - (char *) (gids + stuff->nglyphs) < 0) | |||||
2225 | return BadLength16; | |||||
2226 | if ((char *) end - (char *) (gi + stuff->nglyphs) < 0) | |||||
2227 | return BadLength16; | |||||
2228 | for (i = 0; i < stuff->nglyphs; i++) { | |||||
2229 | swapl(&gids[i])do { if (sizeof(*(&gids[i])) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gids[i]) & 3) && ((uintptr_t)(& gids[i]) & 3) == 0) *(&gids[i]) = lswapl(*(&gids[ i])); else swap_uint32((uint32_t *)(&gids[i])); } while ( 0); | |||||
2230 | swaps(&gi[i].width)do { if (sizeof(*(&gi[i].width)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&gi[i].width) & 1) && ((uintptr_t)(&gi[i].width) & 1) == 0) *(&gi[i].width ) = lswaps(*(&gi[i].width)); else swap_uint16((uint16_t * )(&gi[i].width)); } while (0); | |||||
2231 | swaps(&gi[i].height)do { if (sizeof(*(&gi[i].height)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&gi[i].height) & 1) && ((uintptr_t)(&gi[i].height) & 1) == 0) *(&gi[i]. height) = lswaps(*(&gi[i].height)); else swap_uint16((uint16_t *)(&gi[i].height)); } while (0); | |||||
2232 | swaps(&gi[i].x)do { if (sizeof(*(&gi[i].x)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].x) & 1) && ((uintptr_t)(& gi[i].x) & 1) == 0) *(&gi[i].x) = lswaps(*(&gi[i] .x)); else swap_uint16((uint16_t *)(&gi[i].x)); } while ( 0); | |||||
2233 | swaps(&gi[i].y)do { if (sizeof(*(&gi[i].y)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].y) & 1) && ((uintptr_t)(& gi[i].y) & 1) == 0) *(&gi[i].y) = lswaps(*(&gi[i] .y)); else swap_uint16((uint16_t *)(&gi[i].y)); } while ( 0); | |||||
2234 | swaps(&gi[i].xOff)do { if (sizeof(*(&gi[i].xOff)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].xOff) & 1) && ((uintptr_t )(&gi[i].xOff) & 1) == 0) *(&gi[i].xOff) = lswaps (*(&gi[i].xOff)); else swap_uint16((uint16_t *)(&gi[i ].xOff)); } while (0); | |||||
2235 | swaps(&gi[i].yOff)do { if (sizeof(*(&gi[i].yOff)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(&gi[i].yOff) & 1) && ((uintptr_t )(&gi[i].yOff) & 1) == 0) *(&gi[i].yOff) = lswaps (*(&gi[i].yOff)); else swap_uint16((uint16_t *)(&gi[i ].yOff)); } while (0); | |||||
2236 | } | |||||
2237 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2238 | } | |||||
2239 | ||||||
2240 | static int | |||||
2241 | SProcRenderAddGlyphsFromPicture(ClientPtr client) | |||||
2242 | { | |||||
2243 | return BadImplementation17; | |||||
2244 | } | |||||
2245 | ||||||
2246 | static int | |||||
2247 | SProcRenderFreeGlyphs(ClientPtr client) | |||||
2248 | { | |||||
2249 | REQUEST(xRenderFreeGlyphsReq)xRenderFreeGlyphsReq *stuff = (xRenderFreeGlyphsReq *)client-> requestBuffer; | |||||
2250 | REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq)if ((sizeof(xRenderFreeGlyphsReq) >> 2) > client-> req_len ) return(16); | |||||
2251 | 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); | |||||
2252 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); | |||||
2253 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2254 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2255 | } | |||||
2256 | ||||||
2257 | static int | |||||
2258 | SProcRenderCompositeGlyphs(ClientPtr client) | |||||
2259 | { | |||||
2260 | xGlyphElt *elt; | |||||
2261 | CARD8 *buffer; | |||||
2262 | CARD8 *end; | |||||
2263 | int space; | |||||
2264 | int i; | |||||
2265 | int size; | |||||
2266 | ||||||
2267 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; | |||||
2268 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); | |||||
2269 | ||||||
2270 | switch (stuff->renderReqType) { | |||||
2271 | default: | |||||
2272 | size = 1; | |||||
2273 | break; | |||||
2274 | case X_RenderCompositeGlyphs1624: | |||||
2275 | size = 2; | |||||
2276 | break; | |||||
2277 | case X_RenderCompositeGlyphs3225: | |||||
2278 | size = 4; | |||||
2279 | break; | |||||
2280 | } | |||||
2281 | ||||||
2282 | 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); | |||||
2283 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2284 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2285 | swapl(&stuff->maskFormat)do { if (sizeof(*(&stuff->maskFormat)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->maskFormat ) & 3) && ((uintptr_t)(&stuff->maskFormat) & 3) == 0) *(&stuff->maskFormat) = lswapl(*(& stuff->maskFormat)); else swap_uint32((uint32_t *)(&stuff ->maskFormat)); } while (0); | |||||
2286 | swapl(&stuff->glyphset)do { if (sizeof(*(&stuff->glyphset)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->glyphset ) & 3) && ((uintptr_t)(&stuff->glyphset) & 3) == 0) *(&stuff->glyphset) = lswapl(*(&stuff-> glyphset)); else swap_uint32((uint32_t *)(&stuff->glyphset )); } while (0); | |||||
2287 | swaps(&stuff->xSrc)do { if (sizeof(*(&stuff->xSrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xSrc) & 1) && ((uintptr_t)(&stuff->xSrc) & 1) == 0 ) *(&stuff->xSrc) = lswaps(*(&stuff->xSrc)); else swap_uint16((uint16_t *)(&stuff->xSrc)); } while (0); | |||||
2288 | swaps(&stuff->ySrc)do { if (sizeof(*(&stuff->ySrc)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->ySrc) & 1) && ((uintptr_t)(&stuff->ySrc) & 1) == 0 ) *(&stuff->ySrc) = lswaps(*(&stuff->ySrc)); else swap_uint16((uint16_t *)(&stuff->ySrc)); } while (0); | |||||
2289 | buffer = (CARD8 *) (stuff + 1); | |||||
2290 | end = (CARD8 *) stuff + (client->req_len << 2); | |||||
2291 | while (buffer + sizeof(xGlyphElt) < end) { | |||||
2292 | elt = (xGlyphElt *) buffer; | |||||
2293 | buffer += sizeof(xGlyphElt); | |||||
2294 | ||||||
2295 | swaps(&elt->deltax)do { if (sizeof(*(&elt->deltax)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&elt->deltax) & 1) && ((uintptr_t)(&elt->deltax) & 1) == 0 ) *(&elt->deltax) = lswaps(*(&elt->deltax)); else swap_uint16((uint16_t *)(&elt->deltax)); } while (0); | |||||
2296 | swaps(&elt->deltay)do { if (sizeof(*(&elt->deltay)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&elt->deltay) & 1) && ((uintptr_t)(&elt->deltay) & 1) == 0 ) *(&elt->deltay) = lswaps(*(&elt->deltay)); else swap_uint16((uint16_t *)(&elt->deltay)); } while (0); | |||||
2297 | ||||||
2298 | i = elt->len; | |||||
2299 | if (i == 0xff) { | |||||
2300 | swapl((int *) buffer)do { if (sizeof(*((int *) buffer)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)((int *) buffer) & 3) && ((uintptr_t) ((int *) buffer) & 3) == 0) *((int *) buffer) = lswapl(*( (int *) buffer)); else swap_uint32((uint32_t *)((int *) buffer )); } while (0); | |||||
2301 | buffer += 4; | |||||
2302 | } | |||||
2303 | else { | |||||
2304 | space = size * i; | |||||
2305 | switch (size) { | |||||
2306 | case 1: | |||||
2307 | buffer += i; | |||||
2308 | break; | |||||
2309 | case 2: | |||||
2310 | while (i--) { | |||||
2311 | swaps((short *) buffer)do { if (sizeof(*((short *) buffer)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)((short *) buffer) & 1) && ((uintptr_t)((short *) buffer) & 1) == 0) *((short *) buffer ) = lswaps(*((short *) buffer)); else swap_uint16((uint16_t * )((short *) buffer)); } while (0); | |||||
2312 | buffer += 2; | |||||
2313 | } | |||||
2314 | break; | |||||
2315 | case 4: | |||||
2316 | while (i--) { | |||||
2317 | swapl((int *) buffer)do { if (sizeof(*((int *) buffer)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)((int *) buffer) & 3) && ((uintptr_t) ((int *) buffer) & 3) == 0) *((int *) buffer) = lswapl(*( (int *) buffer)); else swap_uint32((uint32_t *)((int *) buffer )); } while (0); | |||||
2318 | buffer += 4; | |||||
2319 | } | |||||
2320 | break; | |||||
2321 | } | |||||
2322 | if (space & 3) | |||||
2323 | buffer += 4 - (space & 3); | |||||
2324 | } | |||||
2325 | } | |||||
2326 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2327 | } | |||||
2328 | ||||||
2329 | static int | |||||
2330 | SProcRenderFillRectangles(ClientPtr client) | |||||
2331 | { | |||||
2332 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; | |||||
2333 | ||||||
2334 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); | |||||
2335 | 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); | |||||
2336 | swapl(&stuff->dst)do { if (sizeof(*(&stuff->dst)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->dst) & 3 ) && ((uintptr_t)(&stuff->dst) & 3) == 0) * (&stuff->dst) = lswapl(*(&stuff->dst)); else swap_uint32 ((uint32_t *)(&stuff->dst)); } while (0); | |||||
2337 | swaps(&stuff->color.red)do { if (sizeof(*(&stuff->color.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .red) & 1) && ((uintptr_t)(&stuff->color.red ) & 1) == 0) *(&stuff->color.red) = lswaps(*(& stuff->color.red)); else swap_uint16((uint16_t *)(&stuff ->color.red)); } while (0); | |||||
2338 | swaps(&stuff->color.green)do { if (sizeof(*(&stuff->color.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .green) & 1) && ((uintptr_t)(&stuff->color .green) & 1) == 0) *(&stuff->color.green) = lswaps (*(&stuff->color.green)); else swap_uint16((uint16_t * )(&stuff->color.green)); } while (0); | |||||
2339 | swaps(&stuff->color.blue)do { if (sizeof(*(&stuff->color.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .blue) & 1) && ((uintptr_t)(&stuff->color. blue) & 1) == 0) *(&stuff->color.blue) = lswaps(*( &stuff->color.blue)); else swap_uint16((uint16_t *)(& stuff->color.blue)); } while (0); | |||||
2340 | swaps(&stuff->color.alpha)do { if (sizeof(*(&stuff->color.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .alpha) & 1) && ((uintptr_t)(&stuff->color .alpha) & 1) == 0) *(&stuff->color.alpha) = lswaps (*(&stuff->color.alpha)); else swap_uint16((uint16_t * )(&stuff->color.alpha)); } while (0); | |||||
2341 | SwapRestS(stuff)SwapShorts((short *)(stuff + 1), ((client->req_len << 1) - (sizeof(*stuff) >> 1))); | |||||
2342 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2343 | } | |||||
2344 | ||||||
2345 | static int | |||||
2346 | SProcRenderCreateCursor(ClientPtr client) | |||||
2347 | { | |||||
2348 | REQUEST(xRenderCreateCursorReq)xRenderCreateCursorReq *stuff = (xRenderCreateCursorReq *)client ->requestBuffer; | |||||
2349 | REQUEST_SIZE_MATCH(xRenderCreateCursorReq)if ((sizeof(xRenderCreateCursorReq) >> 2) != client-> req_len) return(16); | |||||
2350 | ||||||
2351 | 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); | |||||
2352 | swapl(&stuff->cid)do { if (sizeof(*(&stuff->cid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->cid) & 3 ) && ((uintptr_t)(&stuff->cid) & 3) == 0) * (&stuff->cid) = lswapl(*(&stuff->cid)); else swap_uint32 ((uint32_t *)(&stuff->cid)); } while (0); | |||||
2353 | swapl(&stuff->src)do { if (sizeof(*(&stuff->src)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->src) & 3 ) && ((uintptr_t)(&stuff->src) & 3) == 0) * (&stuff->src) = lswapl(*(&stuff->src)); else swap_uint32 ((uint32_t *)(&stuff->src)); } while (0); | |||||
2354 | swaps(&stuff->x)do { if (sizeof(*(&stuff->x)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&stuff->x) & 1) && ((uintptr_t)(&stuff->x) & 1) == 0) *(&stuff-> x) = lswaps(*(&stuff->x)); else swap_uint16((uint16_t * )(&stuff->x)); } while (0); | |||||
2355 | swaps(&stuff->y)do { if (sizeof(*(&stuff->y)) != 2) wrong_size(); if ( __builtin_constant_p((uintptr_t)(&stuff->y) & 1) && ((uintptr_t)(&stuff->y) & 1) == 0) *(&stuff-> y) = lswaps(*(&stuff->y)); else swap_uint16((uint16_t * )(&stuff->y)); } while (0); | |||||
2356 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2357 | } | |||||
2358 | ||||||
2359 | static int | |||||
2360 | SProcRenderSetPictureTransform(ClientPtr client) | |||||
2361 | { | |||||
2362 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; | |||||
2363 | REQUEST_SIZE_MATCH(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) != client ->req_len) return(16); | |||||
2364 | ||||||
2365 | 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); | |||||
2366 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2367 | swapl(&stuff->transform.matrix11)do { if (sizeof(*(&stuff->transform.matrix11)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix11) & 3) && ((uintptr_t)(&stuff->transform .matrix11) & 3) == 0) *(&stuff->transform.matrix11 ) = lswapl(*(&stuff->transform.matrix11)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix11)); } while (0 ); | |||||
2368 | swapl(&stuff->transform.matrix12)do { if (sizeof(*(&stuff->transform.matrix12)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix12) & 3) && ((uintptr_t)(&stuff->transform .matrix12) & 3) == 0) *(&stuff->transform.matrix12 ) = lswapl(*(&stuff->transform.matrix12)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix12)); } while (0 ); | |||||
2369 | swapl(&stuff->transform.matrix13)do { if (sizeof(*(&stuff->transform.matrix13)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix13) & 3) && ((uintptr_t)(&stuff->transform .matrix13) & 3) == 0) *(&stuff->transform.matrix13 ) = lswapl(*(&stuff->transform.matrix13)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix13)); } while (0 ); | |||||
2370 | swapl(&stuff->transform.matrix21)do { if (sizeof(*(&stuff->transform.matrix21)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix21) & 3) && ((uintptr_t)(&stuff->transform .matrix21) & 3) == 0) *(&stuff->transform.matrix21 ) = lswapl(*(&stuff->transform.matrix21)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix21)); } while (0 ); | |||||
2371 | swapl(&stuff->transform.matrix22)do { if (sizeof(*(&stuff->transform.matrix22)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix22) & 3) && ((uintptr_t)(&stuff->transform .matrix22) & 3) == 0) *(&stuff->transform.matrix22 ) = lswapl(*(&stuff->transform.matrix22)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix22)); } while (0 ); | |||||
2372 | swapl(&stuff->transform.matrix23)do { if (sizeof(*(&stuff->transform.matrix23)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix23) & 3) && ((uintptr_t)(&stuff->transform .matrix23) & 3) == 0) *(&stuff->transform.matrix23 ) = lswapl(*(&stuff->transform.matrix23)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix23)); } while (0 ); | |||||
2373 | swapl(&stuff->transform.matrix31)do { if (sizeof(*(&stuff->transform.matrix31)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix31) & 3) && ((uintptr_t)(&stuff->transform .matrix31) & 3) == 0) *(&stuff->transform.matrix31 ) = lswapl(*(&stuff->transform.matrix31)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix31)); } while (0 ); | |||||
2374 | swapl(&stuff->transform.matrix32)do { if (sizeof(*(&stuff->transform.matrix32)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix32) & 3) && ((uintptr_t)(&stuff->transform .matrix32) & 3) == 0) *(&stuff->transform.matrix32 ) = lswapl(*(&stuff->transform.matrix32)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix32)); } while (0 ); | |||||
2375 | swapl(&stuff->transform.matrix33)do { if (sizeof(*(&stuff->transform.matrix33)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->transform .matrix33) & 3) && ((uintptr_t)(&stuff->transform .matrix33) & 3) == 0) *(&stuff->transform.matrix33 ) = lswapl(*(&stuff->transform.matrix33)); else swap_uint32 ((uint32_t *)(&stuff->transform.matrix33)); } while (0 ); | |||||
2376 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2377 | } | |||||
2378 | ||||||
2379 | static int | |||||
2380 | SProcRenderQueryFilters(ClientPtr client) | |||||
2381 | { | |||||
2382 | REQUEST(xRenderQueryFiltersReq)xRenderQueryFiltersReq *stuff = (xRenderQueryFiltersReq *)client ->requestBuffer; | |||||
2383 | REQUEST_SIZE_MATCH(xRenderQueryFiltersReq)if ((sizeof(xRenderQueryFiltersReq) >> 2) != client-> req_len) return(16); | |||||
2384 | ||||||
2385 | 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); | |||||
2386 | swapl(&stuff->drawable)do { if (sizeof(*(&stuff->drawable)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->drawable ) & 3) && ((uintptr_t)(&stuff->drawable) & 3) == 0) *(&stuff->drawable) = lswapl(*(&stuff-> drawable)); else swap_uint32((uint32_t *)(&stuff->drawable )); } while (0); | |||||
2387 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2388 | } | |||||
2389 | ||||||
2390 | static int | |||||
2391 | SProcRenderSetPictureFilter(ClientPtr client) | |||||
2392 | { | |||||
2393 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; | |||||
2394 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); | |||||
2395 | ||||||
2396 | 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); | |||||
2397 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2398 | swaps(&stuff->nbytes)do { if (sizeof(*(&stuff->nbytes)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nbytes) & 1) && ((uintptr_t)(&stuff->nbytes) & 1) == 0) *(&stuff->nbytes) = lswaps(*(&stuff->nbytes )); else swap_uint16((uint16_t *)(&stuff->nbytes)); } while (0); | |||||
2399 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2400 | } | |||||
2401 | ||||||
2402 | static int | |||||
2403 | SProcRenderCreateAnimCursor(ClientPtr client) | |||||
2404 | { | |||||
2405 | REQUEST(xRenderCreateAnimCursorReq)xRenderCreateAnimCursorReq *stuff = (xRenderCreateAnimCursorReq *)client->requestBuffer; | |||||
2406 | REQUEST_AT_LEAST_SIZE(xRenderCreateAnimCursorReq)if ((sizeof(xRenderCreateAnimCursorReq) >> 2) > client ->req_len ) return(16); | |||||
2407 | ||||||
2408 | 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); | |||||
2409 | swapl(&stuff->cid)do { if (sizeof(*(&stuff->cid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->cid) & 3 ) && ((uintptr_t)(&stuff->cid) & 3) == 0) * (&stuff->cid) = lswapl(*(&stuff->cid)); else swap_uint32 ((uint32_t *)(&stuff->cid)); } while (0); | |||||
2410 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2411 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2412 | } | |||||
2413 | ||||||
2414 | static int | |||||
2415 | SProcRenderAddTraps(ClientPtr client) | |||||
2416 | { | |||||
2417 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; | |||||
2418 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); | |||||
2419 | ||||||
2420 | 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); | |||||
2421 | swapl(&stuff->picture)do { if (sizeof(*(&stuff->picture)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->picture ) & 3) && ((uintptr_t)(&stuff->picture) & 3) == 0) *(&stuff->picture) = lswapl(*(&stuff-> picture)); else swap_uint32((uint32_t *)(&stuff->picture )); } while (0); | |||||
2422 | swaps(&stuff->xOff)do { if (sizeof(*(&stuff->xOff)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->xOff) & 1) && ((uintptr_t)(&stuff->xOff) & 1) == 0 ) *(&stuff->xOff) = lswaps(*(&stuff->xOff)); else swap_uint16((uint16_t *)(&stuff->xOff)); } while (0); | |||||
2423 | swaps(&stuff->yOff)do { if (sizeof(*(&stuff->yOff)) != 2) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->yOff) & 1) && ((uintptr_t)(&stuff->yOff) & 1) == 0 ) *(&stuff->yOff) = lswaps(*(&stuff->yOff)); else swap_uint16((uint16_t *)(&stuff->yOff)); } while (0); | |||||
2424 | SwapRestL(stuff)SwapLongs((CARD32 *)(stuff + 1), (client->req_len - (sizeof (*stuff) >> 2))); | |||||
2425 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2426 | } | |||||
2427 | ||||||
2428 | static int | |||||
2429 | SProcRenderCreateSolidFill(ClientPtr client) | |||||
2430 | { | |||||
2431 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; | |||||
2432 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); | |||||
2433 | ||||||
2434 | 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); | |||||
2435 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); | |||||
2436 | swaps(&stuff->color.alpha)do { if (sizeof(*(&stuff->color.alpha)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .alpha) & 1) && ((uintptr_t)(&stuff->color .alpha) & 1) == 0) *(&stuff->color.alpha) = lswaps (*(&stuff->color.alpha)); else swap_uint16((uint16_t * )(&stuff->color.alpha)); } while (0); | |||||
2437 | swaps(&stuff->color.red)do { if (sizeof(*(&stuff->color.red)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .red) & 1) && ((uintptr_t)(&stuff->color.red ) & 1) == 0) *(&stuff->color.red) = lswaps(*(& stuff->color.red)); else swap_uint16((uint16_t *)(&stuff ->color.red)); } while (0); | |||||
2438 | swaps(&stuff->color.green)do { if (sizeof(*(&stuff->color.green)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .green) & 1) && ((uintptr_t)(&stuff->color .green) & 1) == 0) *(&stuff->color.green) = lswaps (*(&stuff->color.green)); else swap_uint16((uint16_t * )(&stuff->color.green)); } while (0); | |||||
2439 | swaps(&stuff->color.blue)do { if (sizeof(*(&stuff->color.blue)) != 2) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->color .blue) & 1) && ((uintptr_t)(&stuff->color. blue) & 1) == 0) *(&stuff->color.blue) = lswaps(*( &stuff->color.blue)); else swap_uint16((uint16_t *)(& stuff->color.blue)); } while (0); | |||||
2440 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2441 | } | |||||
2442 | ||||||
2443 | static void | |||||
2444 | swapStops(void *stuff, int num) | |||||
2445 | { | |||||
2446 | int i; | |||||
2447 | CARD32 *stops; | |||||
2448 | CARD16 *colors; | |||||
2449 | ||||||
2450 | stops = (CARD32 *) (stuff); | |||||
2451 | for (i = 0; i < num; ++i) { | |||||
2452 | swapl(stops)do { if (sizeof(*(stops)) != 4) wrong_size(); if (__builtin_constant_p ((uintptr_t)(stops) & 3) && ((uintptr_t)(stops) & 3) == 0) *(stops) = lswapl(*(stops)); else swap_uint32((uint32_t *)(stops)); } while (0); | |||||
2453 | ++stops; | |||||
2454 | } | |||||
2455 | colors = (CARD16 *) (stops); | |||||
2456 | for (i = 0; i < 4 * num; ++i) { | |||||
2457 | swaps(colors)do { if (sizeof(*(colors)) != 2) wrong_size(); if (__builtin_constant_p ((uintptr_t)(colors) & 1) && ((uintptr_t)(colors) & 1) == 0) *(colors) = lswaps(*(colors)); else swap_uint16 ((uint16_t *)(colors)); } while (0); | |||||
2458 | ++colors; | |||||
2459 | } | |||||
2460 | } | |||||
2461 | ||||||
2462 | static int | |||||
2463 | SProcRenderCreateLinearGradient(ClientPtr client) | |||||
2464 | { | |||||
2465 | int len; | |||||
2466 | ||||||
2467 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; | |||||
2468 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); | |||||
2469 | ||||||
2470 | 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); | |||||
2471 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); | |||||
2472 | swapl(&stuff->p1.x)do { if (sizeof(*(&stuff->p1.x)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p1.x) & 3) && ((uintptr_t)(&stuff->p1.x) & 3) == 0 ) *(&stuff->p1.x) = lswapl(*(&stuff->p1.x)); else swap_uint32((uint32_t *)(&stuff->p1.x)); } while (0); | |||||
2473 | swapl(&stuff->p1.y)do { if (sizeof(*(&stuff->p1.y)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p1.y) & 3) && ((uintptr_t)(&stuff->p1.y) & 3) == 0 ) *(&stuff->p1.y) = lswapl(*(&stuff->p1.y)); else swap_uint32((uint32_t *)(&stuff->p1.y)); } while (0); | |||||
2474 | swapl(&stuff->p2.x)do { if (sizeof(*(&stuff->p2.x)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p2.x) & 3) && ((uintptr_t)(&stuff->p2.x) & 3) == 0 ) *(&stuff->p2.x) = lswapl(*(&stuff->p2.x)); else swap_uint32((uint32_t *)(&stuff->p2.x)); } while (0); | |||||
2475 | swapl(&stuff->p2.y)do { if (sizeof(*(&stuff->p2.y)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->p2.y) & 3) && ((uintptr_t)(&stuff->p2.y) & 3) == 0 ) *(&stuff->p2.y) = lswapl(*(&stuff->p2.y)); else swap_uint32((uint32_t *)(&stuff->p2.y)); } while (0); | |||||
2476 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); | |||||
2477 | ||||||
2478 | len = (client->req_len << 2) - sizeof(xRenderCreateLinearGradientReq); | |||||
2479 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2480 | return BadLength16; | |||||
2481 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2482 | return BadLength16; | |||||
2483 | ||||||
2484 | swapStops(stuff + 1, stuff->nStops); | |||||
2485 | ||||||
2486 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2487 | } | |||||
2488 | ||||||
2489 | static int | |||||
2490 | SProcRenderCreateRadialGradient(ClientPtr client) | |||||
2491 | { | |||||
2492 | int len; | |||||
2493 | ||||||
2494 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; | |||||
2495 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); | |||||
2496 | ||||||
2497 | 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); | |||||
2498 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); | |||||
2499 | swapl(&stuff->inner.x)do { if (sizeof(*(&stuff->inner.x)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->inner.x ) & 3) && ((uintptr_t)(&stuff->inner.x) & 3) == 0) *(&stuff->inner.x) = lswapl(*(&stuff-> inner.x)); else swap_uint32((uint32_t *)(&stuff->inner .x)); } while (0); | |||||
2500 | swapl(&stuff->inner.y)do { if (sizeof(*(&stuff->inner.y)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->inner.y ) & 3) && ((uintptr_t)(&stuff->inner.y) & 3) == 0) *(&stuff->inner.y) = lswapl(*(&stuff-> inner.y)); else swap_uint32((uint32_t *)(&stuff->inner .y)); } while (0); | |||||
2501 | swapl(&stuff->outer.x)do { if (sizeof(*(&stuff->outer.x)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->outer.x ) & 3) && ((uintptr_t)(&stuff->outer.x) & 3) == 0) *(&stuff->outer.x) = lswapl(*(&stuff-> outer.x)); else swap_uint32((uint32_t *)(&stuff->outer .x)); } while (0); | |||||
2502 | swapl(&stuff->outer.y)do { if (sizeof(*(&stuff->outer.y)) != 4) wrong_size() ; if (__builtin_constant_p((uintptr_t)(&stuff->outer.y ) & 3) && ((uintptr_t)(&stuff->outer.y) & 3) == 0) *(&stuff->outer.y) = lswapl(*(&stuff-> outer.y)); else swap_uint32((uint32_t *)(&stuff->outer .y)); } while (0); | |||||
2503 | swapl(&stuff->inner_radius)do { if (sizeof(*(&stuff->inner_radius)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->inner_radius ) & 3) && ((uintptr_t)(&stuff->inner_radius ) & 3) == 0) *(&stuff->inner_radius) = lswapl(*(& stuff->inner_radius)); else swap_uint32((uint32_t *)(& stuff->inner_radius)); } while (0); | |||||
2504 | swapl(&stuff->outer_radius)do { if (sizeof(*(&stuff->outer_radius)) != 4) wrong_size (); if (__builtin_constant_p((uintptr_t)(&stuff->outer_radius ) & 3) && ((uintptr_t)(&stuff->outer_radius ) & 3) == 0) *(&stuff->outer_radius) = lswapl(*(& stuff->outer_radius)); else swap_uint32((uint32_t *)(& stuff->outer_radius)); } while (0); | |||||
2505 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); | |||||
2506 | ||||||
2507 | len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq); | |||||
2508 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2509 | return BadLength16; | |||||
2510 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2511 | return BadLength16; | |||||
2512 | ||||||
2513 | swapStops(stuff + 1, stuff->nStops); | |||||
2514 | ||||||
2515 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2516 | } | |||||
2517 | ||||||
2518 | static int | |||||
2519 | SProcRenderCreateConicalGradient(ClientPtr client) | |||||
2520 | { | |||||
2521 | int len; | |||||
2522 | ||||||
2523 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; | |||||
2524 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); | |||||
2525 | ||||||
2526 | 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); | |||||
2527 | swapl(&stuff->pid)do { if (sizeof(*(&stuff->pid)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->pid) & 3 ) && ((uintptr_t)(&stuff->pid) & 3) == 0) * (&stuff->pid) = lswapl(*(&stuff->pid)); else swap_uint32 ((uint32_t *)(&stuff->pid)); } while (0); | |||||
2528 | swapl(&stuff->center.x)do { if (sizeof(*(&stuff->center.x)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->center .x) & 3) && ((uintptr_t)(&stuff->center.x) & 3) == 0) *(&stuff->center.x) = lswapl(*(&stuff ->center.x)); else swap_uint32((uint32_t *)(&stuff-> center.x)); } while (0); | |||||
2529 | swapl(&stuff->center.y)do { if (sizeof(*(&stuff->center.y)) != 4) wrong_size( ); if (__builtin_constant_p((uintptr_t)(&stuff->center .y) & 3) && ((uintptr_t)(&stuff->center.y) & 3) == 0) *(&stuff->center.y) = lswapl(*(&stuff ->center.y)); else swap_uint32((uint32_t *)(&stuff-> center.y)); } while (0); | |||||
2530 | swapl(&stuff->angle)do { if (sizeof(*(&stuff->angle)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->angle) & 3) && ((uintptr_t)(&stuff->angle) & 3) == 0) *(&stuff->angle) = lswapl(*(&stuff->angle)) ; else swap_uint32((uint32_t *)(&stuff->angle)); } while (0); | |||||
2531 | swapl(&stuff->nStops)do { if (sizeof(*(&stuff->nStops)) != 4) wrong_size(); if (__builtin_constant_p((uintptr_t)(&stuff->nStops) & 3) && ((uintptr_t)(&stuff->nStops) & 3) == 0) *(&stuff->nStops) = lswapl(*(&stuff->nStops )); else swap_uint32((uint32_t *)(&stuff->nStops)); } while (0); | |||||
2532 | ||||||
2533 | len = (client->req_len << 2) - sizeof(xRenderCreateConicalGradientReq); | |||||
2534 | if (stuff->nStops > UINT32_MAX4294967295U / (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2535 | return BadLength16; | |||||
2536 | if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor))) | |||||
2537 | return BadLength16; | |||||
2538 | ||||||
2539 | swapStops(stuff + 1, stuff->nStops); | |||||
2540 | ||||||
2541 | return (*ProcRenderVector[stuff->renderReqType]) (client); | |||||
2542 | } | |||||
2543 | ||||||
2544 | static int | |||||
2545 | SProcRenderDispatch(ClientPtr client) | |||||
2546 | { | |||||
2547 | REQUEST(xReq)xReq *stuff = (xReq *)client->requestBuffer; | |||||
2548 | ||||||
2549 | if (stuff->data < RenderNumberRequests(36 +1)) | |||||
2550 | return (*SProcRenderVector[stuff->data]) (client); | |||||
2551 | else | |||||
2552 | return BadRequest1; | |||||
2553 | } | |||||
2554 | ||||||
2555 | #ifdef PANORAMIX1 | |||||
2556 | #define VERIFY_XIN_PICTURE(pPicture, pid, client, mode){ int rc = dixLookupResourceByType((void **)&(pPicture), pid , XRT_PICTURE, client, mode); if (rc != 0) return rc;} {\ | |||||
2557 | int rc = dixLookupResourceByType((void **)&(pPicture), pid,\ | |||||
2558 | XRT_PICTURE, client, mode);\ | |||||
2559 | if (rc != Success0)\ | |||||
2560 | return rc;\ | |||||
2561 | } | |||||
2562 | ||||||
2563 | #define VERIFY_XIN_ALPHA(pPicture, pid, client, mode){ if (pid == 0L) pPicture = 0; else { { int rc = dixLookupResourceByType ((void **)&(pPicture), pid, XRT_PICTURE, client, mode); if (rc != 0) return rc;}; } } {\ | |||||
2564 | if (pid == None0L) \ | |||||
2565 | pPicture = 0; \ | |||||
2566 | else { \ | |||||
2567 | VERIFY_XIN_PICTURE(pPicture, pid, client, mode){ int rc = dixLookupResourceByType((void **)&(pPicture), pid , XRT_PICTURE, client, mode); if (rc != 0) return rc;}; \ | |||||
2568 | } \ | |||||
2569 | } \ | |||||
2570 | ||||||
2571 | int (*PanoramiXSaveRenderVector[RenderNumberRequests(36 +1)]) (ClientPtr); | |||||
2572 | ||||||
2573 | static int | |||||
2574 | PanoramiXRenderCreatePicture(ClientPtr client) | |||||
2575 | { | |||||
2576 | REQUEST(xRenderCreatePictureReq)xRenderCreatePictureReq *stuff = (xRenderCreatePictureReq *)client ->requestBuffer; | |||||
2577 | PanoramiXRes *refDraw, *newPict; | |||||
2578 | int result, j; | |||||
2579 | ||||||
2580 | REQUEST_AT_LEAST_SIZE(xRenderCreatePictureReq)if ((sizeof(xRenderCreatePictureReq) >> 2) > client-> req_len ) return(16); | |||||
2581 | result = dixLookupResourceByClass((void **) &refDraw, stuff->drawable, | |||||
2582 | XRC_DRAWABLE, client, DixWriteAccess(1<<1)); | |||||
2583 | if (result != Success0) | |||||
2584 | return (result == BadValue2) ? BadDrawable9 : result; | |||||
2585 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) | |||||
2586 | return BadAlloc11; | |||||
2587 | newPict->type = XRT_PICTURE; | |||||
2588 | panoramix_setup_ids(newPict, client, stuff->pid); | |||||
2589 | ||||||
2590 | if (refDraw->type == XRT_WINDOW && | |||||
2591 | stuff->drawable == screenInfo.screens[0]->root->drawable.id) { | |||||
2592 | newPict->u.pict.root = TRUE1; | |||||
2593 | } | |||||
2594 | else | |||||
2595 | newPict->u.pict.root = FALSE0; | |||||
2596 | ||||||
2597 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2598 | stuff->pid = newPict->info[j].id; | |||||
2599 | stuff->drawable = refDraw->info[j].id; | |||||
2600 | result = (*PanoramiXSaveRenderVector[X_RenderCreatePicture4]) (client); | |||||
2601 | if (result != Success0) | |||||
2602 | break; | |||||
2603 | } | |||||
2604 | ||||||
2605 | if (result == Success0) | |||||
2606 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); | |||||
2607 | else | |||||
2608 | free(newPict); | |||||
2609 | ||||||
2610 | return result; | |||||
2611 | } | |||||
2612 | ||||||
2613 | static int | |||||
2614 | PanoramiXRenderChangePicture(ClientPtr client) | |||||
2615 | { | |||||
2616 | PanoramiXRes *pict; | |||||
2617 | int result = Success0, j; | |||||
2618 | ||||||
2619 | REQUEST(xRenderChangePictureReq)xRenderChangePictureReq *stuff = (xRenderChangePictureReq *)client ->requestBuffer; | |||||
2620 | ||||||
2621 | REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq)if ((sizeof(xRenderChangePictureReq) >> 2) > client-> req_len ) return(16); | |||||
2622 | ||||||
2623 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; | |||||
2624 | ||||||
2625 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2626 | stuff->picture = pict->info[j].id; | |||||
2627 | result = (*PanoramiXSaveRenderVector[X_RenderChangePicture5]) (client); | |||||
2628 | if (result != Success0) | |||||
2629 | break; | |||||
2630 | } | |||||
2631 | ||||||
2632 | return result; | |||||
2633 | } | |||||
2634 | ||||||
2635 | static int | |||||
2636 | PanoramiXRenderSetPictureClipRectangles(ClientPtr client) | |||||
2637 | { | |||||
2638 | REQUEST(xRenderSetPictureClipRectanglesReq)xRenderSetPictureClipRectanglesReq *stuff = (xRenderSetPictureClipRectanglesReq *)client->requestBuffer; | |||||
2639 | int result = Success0, j; | |||||
2640 | PanoramiXRes *pict; | |||||
2641 | ||||||
2642 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq)if ((sizeof(xRenderSetPictureClipRectanglesReq) >> 2) > client->req_len ) return(16); | |||||
2643 | ||||||
2644 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; | |||||
2645 | ||||||
2646 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2647 | stuff->picture = pict->info[j].id; | |||||
2648 | result = | |||||
2649 | (*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles6]) | |||||
2650 | (client); | |||||
2651 | if (result != Success0) | |||||
2652 | break; | |||||
2653 | } | |||||
2654 | ||||||
2655 | return result; | |||||
2656 | } | |||||
2657 | ||||||
2658 | static int | |||||
2659 | PanoramiXRenderSetPictureTransform(ClientPtr client) | |||||
2660 | { | |||||
2661 | REQUEST(xRenderSetPictureTransformReq)xRenderSetPictureTransformReq *stuff = (xRenderSetPictureTransformReq *)client->requestBuffer; | |||||
2662 | int result = Success0, j; | |||||
2663 | PanoramiXRes *pict; | |||||
2664 | ||||||
2665 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq)if ((sizeof(xRenderSetPictureTransformReq) >> 2) > client ->req_len ) return(16); | |||||
2666 | ||||||
2667 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; | |||||
2668 | ||||||
2669 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2670 | stuff->picture = pict->info[j].id; | |||||
2671 | result = | |||||
2672 | (*PanoramiXSaveRenderVector[X_RenderSetPictureTransform28]) (client); | |||||
2673 | if (result != Success0) | |||||
2674 | break; | |||||
2675 | } | |||||
2676 | ||||||
2677 | return result; | |||||
2678 | } | |||||
2679 | ||||||
2680 | static int | |||||
2681 | PanoramiXRenderSetPictureFilter(ClientPtr client) | |||||
2682 | { | |||||
2683 | REQUEST(xRenderSetPictureFilterReq)xRenderSetPictureFilterReq *stuff = (xRenderSetPictureFilterReq *)client->requestBuffer; | |||||
2684 | int result = Success0, j; | |||||
2685 | PanoramiXRes *pict; | |||||
2686 | ||||||
2687 | REQUEST_AT_LEAST_SIZE(xRenderSetPictureFilterReq)if ((sizeof(xRenderSetPictureFilterReq) >> 2) > client ->req_len ) return(16); | |||||
2688 | ||||||
2689 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; | |||||
2690 | ||||||
2691 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2692 | stuff->picture = pict->info[j].id; | |||||
2693 | result = | |||||
2694 | (*PanoramiXSaveRenderVector[X_RenderSetPictureFilter30]) (client); | |||||
2695 | if (result != Success0) | |||||
2696 | break; | |||||
2697 | } | |||||
2698 | ||||||
2699 | return result; | |||||
2700 | } | |||||
2701 | ||||||
2702 | static int | |||||
2703 | PanoramiXRenderFreePicture(ClientPtr client) | |||||
2704 | { | |||||
2705 | PanoramiXRes *pict; | |||||
2706 | int result = Success0, j; | |||||
2707 | ||||||
2708 | REQUEST(xRenderFreePictureReq)xRenderFreePictureReq *stuff = (xRenderFreePictureReq *)client ->requestBuffer; | |||||
2709 | ||||||
2710 | REQUEST_SIZE_MATCH(xRenderFreePictureReq)if ((sizeof(xRenderFreePictureReq) >> 2) != client-> req_len) return(16); | |||||
2711 | ||||||
2712 | client->errorValue = stuff->picture; | |||||
2713 | ||||||
2714 | VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess){ int rc = dixLookupResourceByType((void **)&(pict), stuff ->picture, XRT_PICTURE, client, (1<<2)); if (rc != 0 ) return rc;}; | |||||
2715 | ||||||
2716 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
2717 | stuff->picture = pict->info[j].id; | |||||
2718 | result = (*PanoramiXSaveRenderVector[X_RenderFreePicture7]) (client); | |||||
2719 | if (result != Success0) | |||||
2720 | break; | |||||
2721 | } | |||||
2722 | ||||||
2723 | /* Since ProcRenderFreePicture is using FreeResource, it will free | |||||
2724 | our resource for us on the last pass through the loop above */ | |||||
2725 | ||||||
2726 | return result; | |||||
2727 | } | |||||
2728 | ||||||
2729 | static int | |||||
2730 | PanoramiXRenderComposite(ClientPtr client) | |||||
2731 | { | |||||
2732 | PanoramiXRes *src, *msk, *dst; | |||||
2733 | int result = Success0, j; | |||||
2734 | xRenderCompositeReq orig; | |||||
2735 | ||||||
2736 | REQUEST(xRenderCompositeReq)xRenderCompositeReq *stuff = (xRenderCompositeReq *)client-> requestBuffer; | |||||
2737 | ||||||
2738 | REQUEST_SIZE_MATCH(xRenderCompositeReq)if ((sizeof(xRenderCompositeReq) >> 2) != client->req_len ) return(16); | |||||
2739 | ||||||
2740 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
2741 | VERIFY_XIN_ALPHA(msk, stuff->mask, client, DixReadAccess){ if (stuff->mask == 0L) msk = 0; else { { int rc = dixLookupResourceByType ((void **)&(msk), stuff->mask, XRT_PICTURE, client, (1 <<0)); if (rc != 0) return rc;}; } }; | |||||
2742 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2743 | ||||||
2744 | orig = *stuff; | |||||
2745 | ||||||
2746 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2747 | stuff->src = src->info[j].id; | |||||
2748 | if (src->u.pict.root) { | |||||
2749 | stuff->xSrc = orig.xSrc - screenInfo.screens[j]->x; | |||||
2750 | stuff->ySrc = orig.ySrc - screenInfo.screens[j]->y; | |||||
2751 | } | |||||
2752 | stuff->dst = dst->info[j].id; | |||||
2753 | if (dst->u.pict.root) { | |||||
2754 | stuff->xDst = orig.xDst - screenInfo.screens[j]->x; | |||||
2755 | stuff->yDst = orig.yDst - screenInfo.screens[j]->y; | |||||
2756 | } | |||||
2757 | if (msk) { | |||||
2758 | stuff->mask = msk->info[j].id; | |||||
2759 | if (msk->u.pict.root) { | |||||
2760 | stuff->xMask = orig.xMask - screenInfo.screens[j]->x; | |||||
2761 | stuff->yMask = orig.yMask - screenInfo.screens[j]->y; | |||||
2762 | } | |||||
2763 | } | |||||
2764 | result = (*PanoramiXSaveRenderVector[X_RenderComposite8]) (client); | |||||
2765 | if (result != Success0) | |||||
2766 | break; | |||||
2767 | } | |||||
2768 | ||||||
2769 | return result; | |||||
2770 | } | |||||
2771 | ||||||
2772 | static int | |||||
2773 | PanoramiXRenderCompositeGlyphs(ClientPtr client) | |||||
2774 | { | |||||
2775 | PanoramiXRes *src, *dst; | |||||
2776 | int result = Success0, j; | |||||
2777 | ||||||
2778 | REQUEST(xRenderCompositeGlyphsReq)xRenderCompositeGlyphsReq *stuff = (xRenderCompositeGlyphsReq *)client->requestBuffer; | |||||
2779 | xGlyphElt origElt, *elt; | |||||
2780 | INT16 xSrc, ySrc; | |||||
2781 | ||||||
2782 | REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq)if ((sizeof(xRenderCompositeGlyphsReq) >> 2) > client ->req_len ) return(16); | |||||
2783 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
2784 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2785 | ||||||
2786 | if (client->req_len << 2 >= (sizeof(xRenderCompositeGlyphsReq) + | |||||
2787 | sizeof(xGlyphElt))) { | |||||
2788 | elt = (xGlyphElt *) (stuff + 1); | |||||
2789 | origElt = *elt; | |||||
2790 | xSrc = stuff->xSrc; | |||||
2791 | ySrc = stuff->ySrc; | |||||
2792 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2793 | stuff->src = src->info[j].id; | |||||
2794 | if (src->u.pict.root) { | |||||
2795 | stuff->xSrc = xSrc - screenInfo.screens[j]->x; | |||||
2796 | stuff->ySrc = ySrc - screenInfo.screens[j]->y; | |||||
2797 | } | |||||
2798 | stuff->dst = dst->info[j].id; | |||||
2799 | if (dst->u.pict.root) { | |||||
2800 | elt->deltax = origElt.deltax - screenInfo.screens[j]->x; | |||||
2801 | elt->deltay = origElt.deltay - screenInfo.screens[j]->y; | |||||
2802 | } | |||||
2803 | result = | |||||
2804 | (*PanoramiXSaveRenderVector[stuff->renderReqType]) (client); | |||||
2805 | if (result != Success0) | |||||
2806 | break; | |||||
2807 | } | |||||
2808 | } | |||||
2809 | ||||||
2810 | return result; | |||||
2811 | } | |||||
2812 | ||||||
2813 | static int | |||||
2814 | PanoramiXRenderFillRectangles(ClientPtr client) | |||||
2815 | { | |||||
2816 | PanoramiXRes *dst; | |||||
2817 | int result = Success0, j; | |||||
2818 | ||||||
2819 | REQUEST(xRenderFillRectanglesReq)xRenderFillRectanglesReq *stuff = (xRenderFillRectanglesReq * )client->requestBuffer; | |||||
2820 | char *extra; | |||||
2821 | int extra_len; | |||||
2822 | ||||||
2823 | REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq)if ((sizeof(xRenderFillRectanglesReq) >> 2) > client ->req_len ) return(16); | |||||
2824 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2825 | extra_len = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq); | |||||
2826 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
2827 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
2828 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2829 | if (j) | |||||
2830 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
2831 | if (dst->u.pict.root) { | |||||
2832 | int x_off = screenInfo.screens[j]->x; | |||||
2833 | int y_off = screenInfo.screens[j]->y; | |||||
2834 | ||||||
2835 | if (x_off || y_off) { | |||||
2836 | xRectangle *rects = (xRectangle *) (stuff + 1); | |||||
2837 | int i = extra_len / sizeof(xRectangle); | |||||
2838 | ||||||
2839 | while (i--) { | |||||
2840 | rects->x -= x_off; | |||||
2841 | rects->y -= y_off; | |||||
2842 | rects++; | |||||
2843 | } | |||||
2844 | } | |||||
2845 | } | |||||
2846 | stuff->dst = dst->info[j].id; | |||||
2847 | result = | |||||
2848 | (*PanoramiXSaveRenderVector[X_RenderFillRectangles26]) (client); | |||||
2849 | if (result != Success0) | |||||
2850 | break; | |||||
2851 | } | |||||
2852 | free(extra); | |||||
2853 | } | |||||
2854 | ||||||
2855 | return result; | |||||
2856 | } | |||||
2857 | ||||||
2858 | static int | |||||
2859 | PanoramiXRenderTrapezoids(ClientPtr client) | |||||
2860 | { | |||||
2861 | PanoramiXRes *src, *dst; | |||||
2862 | int result = Success0, j; | |||||
2863 | ||||||
2864 | REQUEST(xRenderTrapezoidsReq)xRenderTrapezoidsReq *stuff = (xRenderTrapezoidsReq *)client-> requestBuffer; | |||||
2865 | char *extra; | |||||
2866 | int extra_len; | |||||
2867 | ||||||
2868 | REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq)if ((sizeof(xRenderTrapezoidsReq) >> 2) > client-> req_len ) return(16); | |||||
2869 | ||||||
2870 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
2871 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2872 | ||||||
2873 | extra_len = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq); | |||||
2874 | ||||||
2875 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
2876 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
2877 | ||||||
2878 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2879 | if (j) | |||||
2880 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
2881 | if (dst->u.pict.root) { | |||||
2882 | int x_off = screenInfo.screens[j]->x; | |||||
2883 | int y_off = screenInfo.screens[j]->y; | |||||
2884 | ||||||
2885 | if (x_off || y_off) { | |||||
2886 | xTrapezoid *trap = (xTrapezoid *) (stuff + 1); | |||||
2887 | int i = extra_len / sizeof(xTrapezoid); | |||||
2888 | ||||||
2889 | while (i--) { | |||||
2890 | trap->top -= y_off; | |||||
2891 | trap->bottom -= y_off; | |||||
2892 | trap->left.p1.x -= x_off; | |||||
2893 | trap->left.p1.y -= y_off; | |||||
2894 | trap->left.p2.x -= x_off; | |||||
2895 | trap->left.p2.y -= y_off; | |||||
2896 | trap->right.p1.x -= x_off; | |||||
2897 | trap->right.p1.y -= y_off; | |||||
2898 | trap->right.p2.x -= x_off; | |||||
2899 | trap->right.p2.y -= y_off; | |||||
2900 | trap++; | |||||
2901 | } | |||||
2902 | } | |||||
2903 | } | |||||
2904 | ||||||
2905 | stuff->src = src->info[j].id; | |||||
2906 | stuff->dst = dst->info[j].id; | |||||
2907 | result = (*PanoramiXSaveRenderVector[X_RenderTrapezoids10]) (client); | |||||
2908 | ||||||
2909 | if (result != Success0) | |||||
2910 | break; | |||||
2911 | } | |||||
2912 | ||||||
2913 | free(extra); | |||||
2914 | } | |||||
2915 | ||||||
2916 | return result; | |||||
2917 | } | |||||
2918 | ||||||
2919 | static int | |||||
2920 | PanoramiXRenderTriangles(ClientPtr client) | |||||
2921 | { | |||||
2922 | PanoramiXRes *src, *dst; | |||||
2923 | int result = Success0, j; | |||||
2924 | ||||||
2925 | REQUEST(xRenderTrianglesReq)xRenderTrianglesReq *stuff = (xRenderTrianglesReq *)client-> requestBuffer; | |||||
2926 | char *extra; | |||||
2927 | int extra_len; | |||||
2928 | ||||||
2929 | REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq)if ((sizeof(xRenderTrianglesReq) >> 2) > client-> req_len ) return(16); | |||||
2930 | ||||||
2931 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
2932 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2933 | ||||||
2934 | extra_len = (client->req_len << 2) - sizeof(xRenderTrianglesReq); | |||||
2935 | ||||||
2936 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
2937 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
2938 | ||||||
2939 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2940 | if (j) | |||||
2941 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
2942 | if (dst->u.pict.root) { | |||||
2943 | int x_off = screenInfo.screens[j]->x; | |||||
2944 | int y_off = screenInfo.screens[j]->y; | |||||
2945 | ||||||
2946 | if (x_off || y_off) { | |||||
2947 | xTriangle *tri = (xTriangle *) (stuff + 1); | |||||
2948 | int i = extra_len / sizeof(xTriangle); | |||||
2949 | ||||||
2950 | while (i--) { | |||||
2951 | tri->p1.x -= x_off; | |||||
2952 | tri->p1.y -= y_off; | |||||
2953 | tri->p2.x -= x_off; | |||||
2954 | tri->p2.y -= y_off; | |||||
2955 | tri->p3.x -= x_off; | |||||
2956 | tri->p3.y -= y_off; | |||||
2957 | tri++; | |||||
2958 | } | |||||
2959 | } | |||||
2960 | } | |||||
2961 | ||||||
2962 | stuff->src = src->info[j].id; | |||||
2963 | stuff->dst = dst->info[j].id; | |||||
2964 | result = (*PanoramiXSaveRenderVector[X_RenderTriangles11]) (client); | |||||
2965 | ||||||
2966 | if (result != Success0) | |||||
2967 | break; | |||||
2968 | } | |||||
2969 | ||||||
2970 | free(extra); | |||||
2971 | } | |||||
2972 | ||||||
2973 | return result; | |||||
2974 | } | |||||
2975 | ||||||
2976 | static int | |||||
2977 | PanoramiXRenderTriStrip(ClientPtr client) | |||||
2978 | { | |||||
2979 | PanoramiXRes *src, *dst; | |||||
2980 | int result = Success0, j; | |||||
2981 | ||||||
2982 | REQUEST(xRenderTriStripReq)xRenderTriStripReq *stuff = (xRenderTriStripReq *)client-> requestBuffer; | |||||
2983 | char *extra; | |||||
2984 | int extra_len; | |||||
2985 | ||||||
2986 | REQUEST_AT_LEAST_SIZE(xRenderTriStripReq)if ((sizeof(xRenderTriStripReq) >> 2) > client->req_len ) return(16); | |||||
2987 | ||||||
2988 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
2989 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
2990 | ||||||
2991 | extra_len = (client->req_len << 2) - sizeof(xRenderTriStripReq); | |||||
2992 | ||||||
2993 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
2994 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
2995 | ||||||
2996 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
2997 | if (j) | |||||
2998 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
2999 | if (dst->u.pict.root) { | |||||
3000 | int x_off = screenInfo.screens[j]->x; | |||||
3001 | int y_off = screenInfo.screens[j]->y; | |||||
3002 | ||||||
3003 | if (x_off || y_off) { | |||||
3004 | xPointFixed *fixed = (xPointFixed *) (stuff + 1); | |||||
3005 | int i = extra_len / sizeof(xPointFixed); | |||||
3006 | ||||||
3007 | while (i--) { | |||||
3008 | fixed->x -= x_off; | |||||
3009 | fixed->y -= y_off; | |||||
3010 | fixed++; | |||||
3011 | } | |||||
3012 | } | |||||
3013 | } | |||||
3014 | ||||||
3015 | stuff->src = src->info[j].id; | |||||
3016 | stuff->dst = dst->info[j].id; | |||||
3017 | result = (*PanoramiXSaveRenderVector[X_RenderTriStrip12]) (client); | |||||
3018 | ||||||
3019 | if (result != Success0) | |||||
3020 | break; | |||||
3021 | } | |||||
3022 | ||||||
3023 | free(extra); | |||||
3024 | } | |||||
3025 | ||||||
3026 | return result; | |||||
3027 | } | |||||
3028 | ||||||
3029 | static int | |||||
3030 | PanoramiXRenderTriFan(ClientPtr client) | |||||
3031 | { | |||||
3032 | PanoramiXRes *src, *dst; | |||||
3033 | int result = Success0, j; | |||||
3034 | ||||||
3035 | REQUEST(xRenderTriFanReq)xRenderTriFanReq *stuff = (xRenderTriFanReq *)client->requestBuffer; | |||||
3036 | char *extra; | |||||
3037 | int extra_len; | |||||
3038 | ||||||
3039 | REQUEST_AT_LEAST_SIZE(xRenderTriFanReq)if ((sizeof(xRenderTriFanReq) >> 2) > client->req_len ) return(16); | |||||
3040 | ||||||
3041 | VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess){ int rc = dixLookupResourceByType((void **)&(src), stuff ->src, XRT_PICTURE, client, (1<<0)); if (rc != 0) return rc;}; | |||||
3042 | VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(dst), stuff ->dst, XRT_PICTURE, client, (1<<1)); if (rc != 0) return rc;}; | |||||
3043 | ||||||
3044 | extra_len = (client->req_len << 2) - sizeof(xRenderTriFanReq); | |||||
3045 | ||||||
3046 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
3047 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
3048 | ||||||
3049 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
3050 | if (j) | |||||
3051 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
3052 | if (dst->u.pict.root) { | |||||
3053 | int x_off = screenInfo.screens[j]->x; | |||||
3054 | int y_off = screenInfo.screens[j]->y; | |||||
3055 | ||||||
3056 | if (x_off || y_off) { | |||||
3057 | xPointFixed *fixed = (xPointFixed *) (stuff + 1); | |||||
3058 | int i = extra_len / sizeof(xPointFixed); | |||||
3059 | ||||||
3060 | while (i--) { | |||||
3061 | fixed->x -= x_off; | |||||
3062 | fixed->y -= y_off; | |||||
3063 | fixed++; | |||||
3064 | } | |||||
3065 | } | |||||
3066 | } | |||||
3067 | ||||||
3068 | stuff->src = src->info[j].id; | |||||
3069 | stuff->dst = dst->info[j].id; | |||||
3070 | result = (*PanoramiXSaveRenderVector[X_RenderTriFan13]) (client); | |||||
3071 | ||||||
3072 | if (result != Success0) | |||||
3073 | break; | |||||
3074 | } | |||||
3075 | ||||||
3076 | free(extra); | |||||
3077 | } | |||||
3078 | ||||||
3079 | return result; | |||||
3080 | } | |||||
3081 | ||||||
3082 | static int | |||||
3083 | PanoramiXRenderAddTraps(ClientPtr client) | |||||
3084 | { | |||||
3085 | PanoramiXRes *picture; | |||||
3086 | int result = Success0, j; | |||||
3087 | ||||||
3088 | REQUEST(xRenderAddTrapsReq)xRenderAddTrapsReq *stuff = (xRenderAddTrapsReq *)client-> requestBuffer; | |||||
3089 | char *extra; | |||||
3090 | int extra_len; | |||||
3091 | INT16 x_off, y_off; | |||||
3092 | ||||||
3093 | REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq)if ((sizeof(xRenderAddTrapsReq) >> 2) > client->req_len ) return(16); | |||||
3094 | VERIFY_XIN_PICTURE(picture, stuff->picture, client, DixWriteAccess){ int rc = dixLookupResourceByType((void **)&(picture), stuff ->picture, XRT_PICTURE, client, (1<<1)); if (rc != 0 ) return rc;}; | |||||
3095 | extra_len = (client->req_len << 2) - sizeof(xRenderAddTrapsReq); | |||||
3096 | if (extra_len && (extra = (char *) malloc(extra_len))) { | |||||
3097 | memcpy(extra, stuff + 1, extra_len)__builtin___memcpy_chk (extra, stuff + 1, extra_len, __builtin_object_size (extra, 0)); | |||||
3098 | x_off = stuff->xOff; | |||||
3099 | y_off = stuff->yOff; | |||||
3100 | FOR_NSCREENS_FORWARD(j)for(j = 0; j < PanoramiXNumScreens; j++) { | |||||
3101 | if (j) | |||||
3102 | memcpy(stuff + 1, extra, extra_len)__builtin___memcpy_chk (stuff + 1, extra, extra_len, __builtin_object_size (stuff + 1, 0)); | |||||
3103 | stuff->picture = picture->info[j].id; | |||||
3104 | ||||||
3105 | if (picture->u.pict.root) { | |||||
3106 | stuff->xOff = x_off + screenInfo.screens[j]->x; | |||||
3107 | stuff->yOff = y_off + screenInfo.screens[j]->y; | |||||
3108 | } | |||||
3109 | result = (*PanoramiXSaveRenderVector[X_RenderAddTraps32]) (client); | |||||
3110 | if (result != Success0) | |||||
3111 | break; | |||||
3112 | } | |||||
3113 | free(extra); | |||||
3114 | } | |||||
3115 | ||||||
3116 | return result; | |||||
3117 | } | |||||
3118 | ||||||
3119 | static int | |||||
3120 | PanoramiXRenderCreateSolidFill(ClientPtr client) | |||||
3121 | { | |||||
3122 | REQUEST(xRenderCreateSolidFillReq)xRenderCreateSolidFillReq *stuff = (xRenderCreateSolidFillReq *)client->requestBuffer; | |||||
3123 | PanoramiXRes *newPict; | |||||
3124 | int result = Success0, j; | |||||
3125 | ||||||
3126 | REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq)if ((sizeof(xRenderCreateSolidFillReq) >> 2) > client ->req_len ) return(16); | |||||
3127 | ||||||
3128 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) | |||||
3129 | return BadAlloc11; | |||||
3130 | ||||||
3131 | newPict->type = XRT_PICTURE; | |||||
3132 | panoramix_setup_ids(newPict, client, stuff->pid); | |||||
3133 | newPict->u.pict.root = FALSE0; | |||||
3134 | ||||||
3135 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
3136 | stuff->pid = newPict->info[j].id; | |||||
3137 | result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill33]) (client); | |||||
3138 | if (result != Success0) | |||||
3139 | break; | |||||
3140 | } | |||||
3141 | ||||||
3142 | if (result == Success0) | |||||
3143 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); | |||||
3144 | else | |||||
3145 | free(newPict); | |||||
3146 | ||||||
3147 | return result; | |||||
3148 | } | |||||
3149 | ||||||
3150 | static int | |||||
3151 | PanoramiXRenderCreateLinearGradient(ClientPtr client) | |||||
3152 | { | |||||
3153 | REQUEST(xRenderCreateLinearGradientReq)xRenderCreateLinearGradientReq *stuff = (xRenderCreateLinearGradientReq *)client->requestBuffer; | |||||
3154 | PanoramiXRes *newPict; | |||||
3155 | int result = Success0, j; | |||||
3156 | ||||||
3157 | REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq)if ((sizeof(xRenderCreateLinearGradientReq) >> 2) > client ->req_len ) return(16); | |||||
3158 | ||||||
3159 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) | |||||
3160 | return BadAlloc11; | |||||
3161 | ||||||
3162 | newPict->type = XRT_PICTURE; | |||||
3163 | panoramix_setup_ids(newPict, client, stuff->pid); | |||||
3164 | newPict->u.pict.root = FALSE0; | |||||
3165 | ||||||
3166 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
3167 | stuff->pid = newPict->info[j].id; | |||||
3168 | result = | |||||
3169 | (*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient34]) (client); | |||||
3170 | if (result != Success0) | |||||
3171 | break; | |||||
3172 | } | |||||
3173 | ||||||
3174 | if (result == Success0) | |||||
3175 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); | |||||
3176 | else | |||||
3177 | free(newPict); | |||||
3178 | ||||||
3179 | return result; | |||||
3180 | } | |||||
3181 | ||||||
3182 | static int | |||||
3183 | PanoramiXRenderCreateRadialGradient(ClientPtr client) | |||||
3184 | { | |||||
3185 | REQUEST(xRenderCreateRadialGradientReq)xRenderCreateRadialGradientReq *stuff = (xRenderCreateRadialGradientReq *)client->requestBuffer; | |||||
3186 | PanoramiXRes *newPict; | |||||
3187 | int result = Success0, j; | |||||
3188 | ||||||
3189 | REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq)if ((sizeof(xRenderCreateRadialGradientReq) >> 2) > client ->req_len ) return(16); | |||||
3190 | ||||||
3191 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) | |||||
3192 | return BadAlloc11; | |||||
3193 | ||||||
3194 | newPict->type = XRT_PICTURE; | |||||
3195 | panoramix_setup_ids(newPict, client, stuff->pid); | |||||
3196 | newPict->u.pict.root = FALSE0; | |||||
3197 | ||||||
3198 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
3199 | stuff->pid = newPict->info[j].id; | |||||
3200 | result = | |||||
3201 | (*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient35]) (client); | |||||
3202 | if (result != Success0) | |||||
3203 | break; | |||||
3204 | } | |||||
3205 | ||||||
3206 | if (result == Success0) | |||||
3207 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); | |||||
3208 | else | |||||
3209 | free(newPict); | |||||
3210 | ||||||
3211 | return result; | |||||
3212 | } | |||||
3213 | ||||||
3214 | static int | |||||
3215 | PanoramiXRenderCreateConicalGradient(ClientPtr client) | |||||
3216 | { | |||||
3217 | REQUEST(xRenderCreateConicalGradientReq)xRenderCreateConicalGradientReq *stuff = (xRenderCreateConicalGradientReq *)client->requestBuffer; | |||||
3218 | PanoramiXRes *newPict; | |||||
3219 | int result = Success0, j; | |||||
3220 | ||||||
3221 | REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq)if ((sizeof(xRenderCreateConicalGradientReq) >> 2) > client->req_len ) return(16); | |||||
3222 | ||||||
3223 | if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes)))) | |||||
3224 | return BadAlloc11; | |||||
3225 | ||||||
3226 | newPict->type = XRT_PICTURE; | |||||
3227 | panoramix_setup_ids(newPict, client, stuff->pid); | |||||
3228 | newPict->u.pict.root = FALSE0; | |||||
3229 | ||||||
3230 | FOR_NSCREENS_BACKWARD(j)for(j = PanoramiXNumScreens - 1; j >= 0; j--) { | |||||
3231 | stuff->pid = newPict->info[j].id; | |||||
3232 | result = | |||||
3233 | (*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient36]) | |||||
3234 | (client); | |||||
3235 | if (result != Success0) | |||||
3236 | break; | |||||
3237 | } | |||||
3238 | ||||||
3239 | if (result == Success0) | |||||
3240 | AddResourceDarwin_X_AddResource(newPict->info[0].id, XRT_PICTURE, newPict); | |||||
3241 | else | |||||
3242 | free(newPict); | |||||
3243 | ||||||
3244 | return result; | |||||
3245 | } | |||||
3246 | ||||||
3247 | void | |||||
3248 | PanoramiXRenderInit(void) | |||||
3249 | { | |||||
3250 | int i; | |||||
3251 | ||||||
3252 | XRT_PICTURE = CreateNewResourceType(XineramaDeleteResource, | |||||
3253 | "XineramaPicture"); | |||||
3254 | if (RenderErrBase) | |||||
3255 | SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture1); | |||||
3256 | for (i = 0; i < RenderNumberRequests(36 +1); i++) | |||||
3257 | PanoramiXSaveRenderVector[i] = ProcRenderVector[i]; | |||||
3258 | /* | |||||
3259 | * Stuff in Xinerama aware request processing hooks | |||||
3260 | */ | |||||
3261 | ProcRenderVector[X_RenderCreatePicture4] = PanoramiXRenderCreatePicture; | |||||
3262 | ProcRenderVector[X_RenderChangePicture5] = PanoramiXRenderChangePicture; | |||||
3263 | ProcRenderVector[X_RenderSetPictureTransform28] = | |||||
3264 | PanoramiXRenderSetPictureTransform; | |||||
3265 | ProcRenderVector[X_RenderSetPictureFilter30] = | |||||
3266 | PanoramiXRenderSetPictureFilter; | |||||
3267 | ProcRenderVector[X_RenderSetPictureClipRectangles6] = | |||||
3268 | PanoramiXRenderSetPictureClipRectangles; | |||||
3269 | ProcRenderVector[X_RenderFreePicture7] = PanoramiXRenderFreePicture; | |||||
3270 | ProcRenderVector[X_RenderComposite8] = PanoramiXRenderComposite; | |||||
3271 | ProcRenderVector[X_RenderCompositeGlyphs823] = PanoramiXRenderCompositeGlyphs; | |||||
3272 | ProcRenderVector[X_RenderCompositeGlyphs1624] = | |||||
3273 | PanoramiXRenderCompositeGlyphs; | |||||
3274 | ProcRenderVector[X_RenderCompositeGlyphs3225] = | |||||
3275 | PanoramiXRenderCompositeGlyphs; | |||||
3276 | ProcRenderVector[X_RenderFillRectangles26] = PanoramiXRenderFillRectangles; | |||||
3277 | ||||||
3278 | ProcRenderVector[X_RenderTrapezoids10] = PanoramiXRenderTrapezoids; | |||||
3279 | ProcRenderVector[X_RenderTriangles11] = PanoramiXRenderTriangles; | |||||
3280 | ProcRenderVector[X_RenderTriStrip12] = PanoramiXRenderTriStrip; | |||||
3281 | ProcRenderVector[X_RenderTriFan13] = PanoramiXRenderTriFan; | |||||
3282 | ProcRenderVector[X_RenderAddTraps32] = PanoramiXRenderAddTraps; | |||||
3283 | ||||||
3284 | ProcRenderVector[X_RenderCreateSolidFill33] = PanoramiXRenderCreateSolidFill; | |||||
3285 | ProcRenderVector[X_RenderCreateLinearGradient34] = | |||||
3286 | PanoramiXRenderCreateLinearGradient; | |||||
3287 | ProcRenderVector[X_RenderCreateRadialGradient35] = | |||||
3288 | PanoramiXRenderCreateRadialGradient; | |||||
3289 | ProcRenderVector[X_RenderCreateConicalGradient36] = | |||||
3290 | PanoramiXRenderCreateConicalGradient; | |||||
3291 | } | |||||
3292 | ||||||
3293 | void | |||||
3294 | PanoramiXRenderReset(void) | |||||
3295 | { | |||||
3296 | int i; | |||||
3297 | ||||||
3298 | for (i = 0; i < RenderNumberRequests(36 +1); i++) | |||||
3299 | ProcRenderVector[i] = PanoramiXSaveRenderVector[i]; | |||||
3300 | RenderErrBase = 0; | |||||
3301 | } | |||||
3302 | ||||||
3303 | #endif /* PANORAMIX */ |