| File: | render/render.c |
| Location: | line 1614, 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 */ |