frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

(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>
This commit is contained in:
Enrico Weigelt, metux IT consult 2024-07-12 14:52:51 +02:00
parent b8ce247d5d
commit c6408565b9
3 changed files with 85 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
xfixes/cursor.c
View File

@ -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,
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);
CARD32 image[npixels];
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);
swapl(&rep->length);
swaps(&rep->x);
swaps(&rep->y);
swaps(&rep->width);
swaps(&rep->height);
swaps(&rep->xhot);
swaps(&rep->yhot);
swapl(&rep->cursorSerial);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.x);
swaps(&rep.y);
swaps(&rep.width);
swaps(&rep.height);
swaps(&rep.xhot);
swaps(&rep.yhot);
swapl(&rep.cursorSerial);
SwapLongs(image, npixels);
}
WriteToClient(client,
sizeof(xXFixesGetCursorImageReply) + (npixels << 2), rep);
free(rep);
WriteToClient(client, sizeof(xXFixesGetCursorImageReply), &rep);
WriteToClient(client, sizeof(image), image);
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,
sizeof(xXFixesGetCursorImageAndNameReply) +
npixels * sizeof(CARD32) + nbytesRound);
if (!rep)
return BadAlloc;
// pixmap plus name (padded to 4 bytes)
CARD32 image[npixels + bytes_to_int32(nbytes)];
memset(image, 0, sizeof(image));
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);
swapl(&rep->length);
swaps(&rep->x);
swaps(&rep->y);
swaps(&rep->width);
swaps(&rep->height);
swaps(&rep->xhot);
swaps(&rep->yhot);
swapl(&rep->cursorSerial);
swapl(&rep->cursorName);
swaps(&rep->nbytes);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.x);
swaps(&rep.y);
swaps(&rep.width);
swaps(&rep.height);
swaps(&rep.xhot);
swaps(&rep.yhot);
swapl(&rep.cursorSerial);
swapl(&rep.cursorName);
swaps(&rep.nbytes);
SwapLongs(image, npixels);
}
WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply) +
(npixels << 2) + nbytesRound, rep);
free(rep);
WriteToClient(client, sizeof(xXFixesGetCursorImageAndNameReply), &rep);
WriteToClient(client, sizeof(image), image);
return Success;
}

9
xfixes/disconnect.c
View File

@ -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);
swapl(&reply.disconnect_mode);
swaps(&rep.sequenceNumber);
swapl(&rep.disconnect_mode);
}
WriteToClient(client, sizeof(xXFixesGetClientDisconnectModeReply), &reply);
WriteToClient(client, sizeof(xXFixesGetClientDisconnectModeReply), &rep);
return Success;
}

43
xfixes/region.c
View File

@ -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),
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;
xRectangle pRect[nBox];
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);
swapl(&reply->length);
swaps(&reply->x);
swaps(&reply->y);
swaps(&reply->width);
swaps(&reply->height);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.x);
swaps(&rep.y);
swaps(&rep.width);
swaps(&rep.height);
SwapShorts((INT16 *) pRect, nBox * 4);
}
WriteToClient(client, sizeof(xXFixesFetchRegionReply) +
nBox * sizeof(xRectangle), (char *) reply);
free(reply);
WriteToClient(client, sizeof(xXFixesFetchRegionReply), &rep);
WriteToClient(client, sizeof(pRect), pRect);
return Success;
}