(submit/cleanup-xfixes) xfixes: use stack allocation and static init for reply structs

Canonicalize all reply structures onto stack allocation and static
initialization, like already done in most other extension. So make
the code easier to understand and allow further simplifications by
subsequent commits. Also gaining a little bit efficiency by skipping
some heap allocations.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>

xfixes/cursor.c

@@ -355,7 +355,6 @@ ProcXFixesGetCursorImage(ClientPtr client)
 {
 /*    REQUEST(xXFixesGetCursorImageReq); */
     CursorPtr pCursor;
-    CARD32 *image;
     int npixels, width, height, rc, x, y;
 
     REQUEST_SIZE_MATCH(xXFixesGetCursorImageReq);
@@ -371,39 +370,36 @@ ProcXFixesGetCursorImage(ClientPtr client)
     height = pCursor->bits->height;
     npixels = width * height;
 
-    xXFixesGetCursorImageReply *rep = calloc(1,
+    CARD32 image[npixels];
-                 sizeof(xXFixesGetCursorImageReply) + npixels * sizeof(CARD32));
-    if (!rep)
-        return BadAlloc;
-
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels;
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot;
-    rep->cursorSerial = pCursor->serialNumber;
-
-    image = (CARD32 *) (rep + 1);
     CopyCursorToImage(pCursor, image);
+
+    xXFixesGetCursorImageReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = npixels,
+        .width = width,
+        .height = height,
+        .x = x,
+        .y = y,
+        .xhot = pCursor->bits->xhot,
+        .yhot = pCursor->bits->yhot,
+        .cursorSerial = pCursor->serialNumber,
+    };
+
     if (client->swapped) {
-        swaps(&rep->sequenceNumber);
+        swaps(&rep.sequenceNumber);
-        swapl(&rep->length);
+        swapl(&rep.length);
-        swaps(&rep->x);
+        swaps(&rep.x);
-        swaps(&rep->y);
+        swaps(&rep.y);
-        swaps(&rep->width);
+        swaps(&rep.width);
-        swaps(&rep->height);
+        swaps(&rep.height);
-        swaps(&rep->xhot);
+        swaps(&rep.xhot);
-        swaps(&rep->yhot);
+        swaps(&rep.yhot);
-        swapl(&rep->cursorSerial);
+        swapl(&rep.cursorSerial);
         SwapLongs(image, npixels);
     }
-    WriteToClient(client,
+    WriteToClient(client, sizeof(xXFixesGetCursorImageReply), &rep);
-                  sizeof(xXFixesGetCursorImageReply) + (npixels << 2), rep);
+    WriteToClient(client, sizeof(image), image);
-    free(rep);
     return Success;
 }
 
@@ -447,9 +443,9 @@ SProcXFixesSetCursorName(ClientPtr client)
 int
 ProcXFixesGetCursorName(ClientPtr client)
 {
-    CursorPtr pCursor;
-
     REQUEST(xXFixesGetCursorNameReq);
+
+    CursorPtr pCursor;
     const char *str;
     int len;
 
@@ -494,10 +490,9 @@ ProcXFixesGetCursorImageAndName(ClientPtr client)
 {
 /*    REQUEST(xXFixesGetCursorImageAndNameReq); */
     CursorPtr pCursor;
-    CARD32 *image;
     int npixels;
     const char *name;
-    int nbytes, nbytesRound;
+    int nbytes;
     int width, height;
     int rc, x, y;
 
@@ -515,47 +510,45 @@ ProcXFixesGetCursorImageAndName(ClientPtr client)
     npixels = width * height;
     name = pCursor->name ? NameForAtom(pCursor->name) : "";
     nbytes = strlen(name);
-    nbytesRound = pad_to_int32(nbytes);
 
-    xXFixesGetCursorImageAndNameReply *rep = calloc(1,
+    // pixmap plus name (padded to 4 bytes)
-                 sizeof(xXFixesGetCursorImageAndNameReply) +
+    CARD32 image[npixels + bytes_to_int32(nbytes)];
-                 npixels * sizeof(CARD32) + nbytesRound);
+    memset(image, 0, sizeof(image));
-    if (!rep)
-        return BadAlloc;
 
-    rep->type = X_Reply;
-    rep->sequenceNumber = client->sequence;
-    rep->length = npixels + bytes_to_int32(nbytesRound);
-    rep->width = width;
-    rep->height = height;
-    rep->x = x;
-    rep->y = y;
-    rep->xhot = pCursor->bits->xhot;
-    rep->yhot = pCursor->bits->yhot;
-    rep->cursorSerial = pCursor->serialNumber;
-    rep->cursorName = pCursor->name;
-    rep->nbytes = nbytes;
-
-    image = (CARD32 *) (rep + 1);
     CopyCursorToImage(pCursor, image);
     memcpy((image + npixels), name, nbytes);
+
+    xXFixesGetCursorImageAndNameReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = bytes_to_int32(sizeof(image)),
+        .width = width,
+        .height = height,
+        .x = x,
+        .y = y,
+        .xhot = pCursor->bits->xhot,
+        .yhot = pCursor->bits->yhot,
+        .cursorSerial = pCursor->serialNumber,
+        .cursorName = pCursor->name,
+        .nbytes = nbytes,
+    };
+
     if (client->swapped) {
-        swaps(&rep->sequenceNumber);
+        swaps(&rep.sequenceNumber);
-        swapl(&rep->length);
+        swapl(&rep.length);
-        swaps(&rep->x);
+        swaps(&rep.x);
-        swaps(&rep->y);
+        swaps(&rep.y);
-        swaps(&rep->width);
+        swaps(&rep.width);
-        swaps(&rep->height);
+        swaps(&rep.height);
-        swaps(&rep->xhot);
+        swaps(&rep.xhot);
-        swaps(&rep->yhot);
+        swaps(&rep.yhot);
-        swapl(&rep->cursorSerial);
+        swapl(&rep.cursorSerial);
-        swapl(&rep->cursorName);
+        swapl(&rep.cursorName);
-        swaps(&rep->nbytes);
+        swaps(&rep.nbytes);
         SwapLongs(image, npixels);
     }
-    WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply) +
+    WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply), &rep);
-                  (npixels << 2) + nbytesRound, rep);
+    WriteToClient(client, sizeof(image), image);
-    free(rep);
     return Success;
 }
 

xfixes/disconnect.c

@@ -87,21 +87,20 @@ int
 ProcXFixesGetClientDisconnectMode(ClientPtr client)
 {
     ClientDisconnectPtr pDisconnect = GetClientDisconnect(client);
-    xXFixesGetClientDisconnectModeReply reply;
 
     REQUEST_SIZE_MATCH(xXFixesGetClientDisconnectModeReq);
 
-    reply = (xXFixesGetClientDisconnectModeReply) {
+    xXFixesGetClientDisconnectModeReply rep = {
         .type = X_Reply,
         .sequenceNumber = client->sequence,
         .length = 0,
         .disconnect_mode = pDisconnect->disconnect_mode,
     };
     if (client->swapped) {
-        swaps(&reply.sequenceNumber);
+        swaps(&rep.sequenceNumber);
-        swapl(&reply.disconnect_mode);
+        swapl(&rep.disconnect_mode);
     }
-    WriteToClient(client, sizeof(xXFixesGetClientDisconnectModeReply), &reply);
+    WriteToClient(client, sizeof(xXFixesGetClientDisconnectModeReply), &rep);
 
     return Success;
 }

xfixes/region.c

@@ -509,8 +509,6 @@ int
 ProcXFixesFetchRegion(ClientPtr client)
 {
     RegionPtr pRegion;
-    xXFixesFetchRegionReply *reply;
-    xRectangle *pRect;
     BoxPtr pExtent;
     BoxPtr pBox;
     int i, nBox;
@@ -524,37 +522,36 @@ ProcXFixesFetchRegion(ClientPtr client)
     pBox = RegionRects(pRegion);
     nBox = RegionNumRects(pRegion);
 
-    reply = calloc(sizeof(xXFixesFetchRegionReply) + nBox * sizeof(xRectangle),
+    xRectangle pRect[nBox];
-                   1);
-    if (!reply)
-        return BadAlloc;
-    reply->type = X_Reply;
-    reply->sequenceNumber = client->sequence;
-    reply->length = nBox << 1;
-    reply->x = pExtent->x1;
-    reply->y = pExtent->y1;
-    reply->width = pExtent->x2 - pExtent->x1;
-    reply->height = pExtent->y2 - pExtent->y1;
 
-    pRect = (xRectangle *) (reply + 1);
     for (i = 0; i < nBox; i++) {
         pRect[i].x = pBox[i].x1;
         pRect[i].y = pBox[i].y1;
         pRect[i].width = pBox[i].x2 - pBox[i].x1;
         pRect[i].height = pBox[i].y2 - pBox[i].y1;
     }
+
+    xXFixesFetchRegionReply rep = {
+        .type = X_Reply,
+        .sequenceNumber = client->sequence,
+        .length = nBox << 1,
+        .x = pExtent->x1,
+        .y = pExtent->y1,
+        .width = pExtent->x2 - pExtent->x1,
+        .height = pExtent->y2 - pExtent->y1,
+    };
+
     if (client->swapped) {
-        swaps(&reply->sequenceNumber);
+        swaps(&rep.sequenceNumber);
-        swapl(&reply->length);
+        swapl(&rep.length);
-        swaps(&reply->x);
+        swaps(&rep.x);
-        swaps(&reply->y);
+        swaps(&rep.y);
-        swaps(&reply->width);
+        swaps(&rep.width);
-        swaps(&reply->height);
+        swaps(&rep.height);
         SwapShorts((INT16 *) pRect, nBox * 4);
     }
-    WriteToClient(client, sizeof(xXFixesFetchRegionReply) +
+    WriteToClient(client, sizeof(xXFixesFetchRegionReply), &rep);
-                         nBox * sizeof(xRectangle), (char *) reply);
+    WriteToClient(client, sizeof(pRect), pRect);
-    free(reply);
     return Success;
 }