idx int64 | func_before string | Vulnerability Classification string | vul int64 | func_after string | patch string | CWE ID string | lines_before string | lines_after string |
|---|---|---|---|---|---|---|---|---|
14,000 | ProcXvQueryImageAttributes(ClientPtr client)
{
xvQueryImageAttributesReply rep;
int size, num_planes, i;
CARD16 width, height;
XvImagePtr pImage = NULL;
XvPortPtr pPort;
int *offsets;
int *pitches;
int planeLength;
REQUEST(xvQueryImageAttributesReq);
REQUEST_SIZE_MATCH(xvQueryImageAttributesReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
for (i = 0; i < pPort->pAdaptor->nImages; i++) {
if (pPort->pAdaptor->pImages[i].id == stuff->id) {
pImage = &(pPort->pAdaptor->pImages[i]);
break;
}
}
#ifdef XvMCExtension
if (!pImage)
pImage = XvMCFindXvImage(pPort, stuff->id);
#endif
if (!pImage)
return BadMatch;
num_planes = pImage->num_planes;
if (!(offsets = malloc(num_planes << 3)))
return BadAlloc;
pitches = offsets + num_planes;
width = stuff->width;
height = stuff->height;
size = (*pPort->pAdaptor->ddQueryImageAttributes) (pPort, pImage,
&width, &height, offsets,
pitches);
rep = (xvQueryImageAttributesReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = planeLength = num_planes << 1,
.num_planes = num_planes,
.width = width,
.height = height,
.data_size = size
};
_WriteQueryImageAttributesReply(client, &rep);
if (client->swapped)
SwapLongs((CARD32 *) offsets, planeLength);
WriteToClient(client, planeLength << 2, offsets);
free(offsets);
return Success;
}
| Exec Code | 0 | ProcXvQueryImageAttributes(ClientPtr client)
{
xvQueryImageAttributesReply rep;
int size, num_planes, i;
CARD16 width, height;
XvImagePtr pImage = NULL;
XvPortPtr pPort;
int *offsets;
int *pitches;
int planeLength;
REQUEST(xvQueryImageAttributesReq);
REQUEST_SIZE_MATCH(xvQueryImageAttributesReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
for (i = 0; i < pPort->pAdaptor->nImages; i++) {
if (pPort->pAdaptor->pImages[i].id == stuff->id) {
pImage = &(pPort->pAdaptor->pImages[i]);
break;
}
}
#ifdef XvMCExtension
if (!pImage)
pImage = XvMCFindXvImage(pPort, stuff->id);
#endif
if (!pImage)
return BadMatch;
num_planes = pImage->num_planes;
if (!(offsets = malloc(num_planes << 3)))
return BadAlloc;
pitches = offsets + num_planes;
width = stuff->width;
height = stuff->height;
size = (*pPort->pAdaptor->ddQueryImageAttributes) (pPort, pImage,
&width, &height, offsets,
pitches);
rep = (xvQueryImageAttributesReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = planeLength = num_planes << 1,
.num_planes = num_planes,
.width = width,
.height = height,
.data_size = size
};
_WriteQueryImageAttributesReply(client, &rep);
if (client->swapped)
SwapLongs((CARD32 *) offsets, planeLength);
WriteToClient(client, planeLength << 2, offsets);
free(offsets);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,001 | ProcXvQueryPortAttributes(ClientPtr client)
{
int size, i;
XvPortPtr pPort;
XvAttributePtr pAtt;
xvQueryPortAttributesReply rep;
xvAttributeInfo Info;
REQUEST(xvQueryPortAttributesReq);
REQUEST_SIZE_MATCH(xvQueryPortAttributesReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixGetAttrAccess);
rep = (xvQueryPortAttributesReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.num_attributes = pPort->pAdaptor->nAttributes,
.text_size = 0
};
for (i = 0, pAtt = pPort->pAdaptor->pAttributes;
i < pPort->pAdaptor->nAttributes; i++, pAtt++) {
rep.text_size += pad_to_int32(strlen(pAtt->name) + 1);
}
rep.length = (pPort->pAdaptor->nAttributes * sz_xvAttributeInfo)
+ rep.text_size;
rep.length >>= 2;
_WriteQueryPortAttributesReply(client, &rep);
for (i = 0, pAtt = pPort->pAdaptor->pAttributes;
i < pPort->pAdaptor->nAttributes; i++, pAtt++) {
size = strlen(pAtt->name) + 1; /* pass the NULL */
Info.flags = pAtt->flags;
Info.min = pAtt->min_value;
Info.max = pAtt->max_value;
Info.size = pad_to_int32(size);
_WriteAttributeInfo(client, &Info);
WriteToClient(client, size, pAtt->name);
}
return Success;
}
| Exec Code | 0 | ProcXvQueryPortAttributes(ClientPtr client)
{
int size, i;
XvPortPtr pPort;
XvAttributePtr pAtt;
xvQueryPortAttributesReply rep;
xvAttributeInfo Info;
REQUEST(xvQueryPortAttributesReq);
REQUEST_SIZE_MATCH(xvQueryPortAttributesReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixGetAttrAccess);
rep = (xvQueryPortAttributesReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.num_attributes = pPort->pAdaptor->nAttributes,
.text_size = 0
};
for (i = 0, pAtt = pPort->pAdaptor->pAttributes;
i < pPort->pAdaptor->nAttributes; i++, pAtt++) {
rep.text_size += pad_to_int32(strlen(pAtt->name) + 1);
}
rep.length = (pPort->pAdaptor->nAttributes * sz_xvAttributeInfo)
+ rep.text_size;
rep.length >>= 2;
_WriteQueryPortAttributesReply(client, &rep);
for (i = 0, pAtt = pPort->pAdaptor->pAttributes;
i < pPort->pAdaptor->nAttributes; i++, pAtt++) {
size = strlen(pAtt->name) + 1; /* pass the NULL */
Info.flags = pAtt->flags;
Info.min = pAtt->min_value;
Info.max = pAtt->max_value;
Info.size = pad_to_int32(size);
_WriteAttributeInfo(client, &Info);
WriteToClient(client, size, pAtt->name);
}
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,002 | ProcXvSelectPortNotify(ClientPtr client)
{
XvPortPtr pPort;
REQUEST(xvSelectPortNotifyReq);
REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
return XvdiSelectPortNotify(client, pPort, stuff->onoff);
}
| Exec Code | 0 | ProcXvSelectPortNotify(ClientPtr client)
{
XvPortPtr pPort;
REQUEST(xvSelectPortNotifyReq);
REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
return XvdiSelectPortNotify(client, pPort, stuff->onoff);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,003 | ProcXvSetPortAttribute(ClientPtr client)
{
int status;
XvPortPtr pPort;
REQUEST(xvSetPortAttributeReq);
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixSetAttrAccess);
if (!ValidAtom(stuff->attribute)) {
client->errorValue = stuff->attribute;
return BadAtom;
}
status =
XvdiSetPortAttribute(client, pPort, stuff->attribute, stuff->value);
if (status == BadMatch)
client->errorValue = stuff->attribute;
else
client->errorValue = stuff->value;
return status;
}
| Exec Code | 0 | ProcXvSetPortAttribute(ClientPtr client)
{
int status;
XvPortPtr pPort;
REQUEST(xvSetPortAttributeReq);
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixSetAttrAccess);
if (!ValidAtom(stuff->attribute)) {
client->errorValue = stuff->attribute;
return BadAtom;
}
status =
XvdiSetPortAttribute(client, pPort, stuff->attribute, stuff->value);
if (status == BadMatch)
client->errorValue = stuff->attribute;
else
client->errorValue = stuff->value;
return status;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,004 | ProcXvShmPutImage(ClientPtr client)
{
return BadImplementation;
}
| Exec Code | 0 | ProcXvShmPutImage(ClientPtr client)
{
return BadImplementation;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,005 | ProcXvStopVideo(ClientPtr client)
{
int ret;
DrawablePtr pDraw;
XvPortPtr pPort;
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
ret = dixLookupDrawable(&pDraw, stuff->drawable, client, 0, DixWriteAccess);
if (ret != Success)
return ret;
return XvdiStopVideo(client, pPort, pDraw);
}
| Exec Code | 0 | ProcXvStopVideo(ClientPtr client)
{
int ret;
DrawablePtr pDraw;
XvPortPtr pPort;
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
ret = dixLookupDrawable(&pDraw, stuff->drawable, client, 0, DixWriteAccess);
if (ret != Success)
return ret;
return XvdiStopVideo(client, pPort, pDraw);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,006 | SProcXvDispatch(ClientPtr client)
{
REQUEST(xReq);
UpdateCurrentTime();
if (stuff->data >= xvNumRequests) {
return BadRequest;
}
return SXvProcVector[stuff->data] (client);
}
| Exec Code | 0 | SProcXvDispatch(ClientPtr client)
{
REQUEST(xReq);
UpdateCurrentTime();
if (stuff->data >= xvNumRequests) {
return BadRequest;
}
return SXvProcVector[stuff->data] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,007 | SProcXvGetPortAttribute(ClientPtr client)
{
REQUEST(xvGetPortAttributeReq);
REQUEST_SIZE_MATCH(xvGetPortAttributeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->attribute);
return XvProcVector[xv_GetPortAttribute] (client);
}
| Exec Code | 0 | SProcXvGetPortAttribute(ClientPtr client)
{
REQUEST(xvGetPortAttributeReq);
REQUEST_SIZE_MATCH(xvGetPortAttributeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->attribute);
return XvProcVector[xv_GetPortAttribute] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,008 | SProcXvGetVideo(ClientPtr client)
{
REQUEST(xvGetVideoReq);
REQUEST_SIZE_MATCH(xvGetVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_GetVideo] (client);
}
| Exec Code | 0 | SProcXvGetVideo(ClientPtr client)
{
REQUEST(xvGetVideoReq);
REQUEST_SIZE_MATCH(xvGetVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_GetVideo] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,009 | SProcXvListImageFormats(ClientPtr client)
{
REQUEST(xvListImageFormatsReq);
REQUEST_SIZE_MATCH(xvListImageFormatsReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_ListImageFormats] (client);
}
| Exec Code | 0 | SProcXvListImageFormats(ClientPtr client)
{
REQUEST(xvListImageFormatsReq);
REQUEST_SIZE_MATCH(xvListImageFormatsReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_ListImageFormats] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,010 | SProcXvPutImage(ClientPtr client)
{
REQUEST(xvPutImageReq);
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swapl(&stuff->id);
swaps(&stuff->src_x);
swaps(&stuff->src_y);
swaps(&stuff->src_w);
swaps(&stuff->src_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_PutImage] (client);
}
| Exec Code | 0 | SProcXvPutImage(ClientPtr client)
{
REQUEST(xvPutImageReq);
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swapl(&stuff->id);
swaps(&stuff->src_x);
swaps(&stuff->src_y);
swaps(&stuff->src_w);
swaps(&stuff->src_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_PutImage] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,011 | SProcXvPutStill(ClientPtr client)
{
REQUEST(xvPutStillReq);
REQUEST_SIZE_MATCH(xvPutStillReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_PutStill] (client);
}
| Exec Code | 0 | SProcXvPutStill(ClientPtr client)
{
REQUEST(xvPutStillReq);
REQUEST_SIZE_MATCH(xvPutStillReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_PutStill] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,012 | SProcXvPutVideo(ClientPtr client)
{
REQUEST(xvPutVideoReq);
REQUEST_SIZE_MATCH(xvPutVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_PutVideo] (client);
}
| Exec Code | 0 | SProcXvPutVideo(ClientPtr client)
{
REQUEST(xvPutVideoReq);
REQUEST_SIZE_MATCH(xvPutVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swaps(&stuff->vid_x);
swaps(&stuff->vid_y);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_PutVideo] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,013 | SProcXvQueryAdaptors(ClientPtr client)
{
REQUEST(xvQueryAdaptorsReq);
REQUEST_SIZE_MATCH(xvQueryAdaptorsReq);
swaps(&stuff->length);
swapl(&stuff->window);
return XvProcVector[xv_QueryAdaptors] (client);
}
| Exec Code | 0 | SProcXvQueryAdaptors(ClientPtr client)
{
REQUEST(xvQueryAdaptorsReq);
REQUEST_SIZE_MATCH(xvQueryAdaptorsReq);
swaps(&stuff->length);
swapl(&stuff->window);
return XvProcVector[xv_QueryAdaptors] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,014 | SProcXvQueryBestSize(ClientPtr client)
{
REQUEST(xvQueryBestSizeReq);
REQUEST_SIZE_MATCH(xvQueryBestSizeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_QueryBestSize] (client);
}
| Exec Code | 0 | SProcXvQueryBestSize(ClientPtr client)
{
REQUEST(xvQueryBestSizeReq);
REQUEST_SIZE_MATCH(xvQueryBestSizeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swaps(&stuff->vid_w);
swaps(&stuff->vid_h);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
return XvProcVector[xv_QueryBestSize] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,015 | SProcXvQueryEncodings(ClientPtr client)
{
REQUEST(xvQueryEncodingsReq);
REQUEST_SIZE_MATCH(xvQueryEncodingsReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_QueryEncodings] (client);
}
| Exec Code | 0 | SProcXvQueryEncodings(ClientPtr client)
{
REQUEST(xvQueryEncodingsReq);
REQUEST_SIZE_MATCH(xvQueryEncodingsReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_QueryEncodings] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,016 | SProcXvQueryExtension(ClientPtr client)
{
REQUEST(xvQueryExtensionReq);
REQUEST_SIZE_MATCH(xvQueryExtensionReq);
swaps(&stuff->length);
return XvProcVector[xv_QueryExtension] (client);
}
| Exec Code | 0 | SProcXvQueryExtension(ClientPtr client)
{
REQUEST(xvQueryExtensionReq);
REQUEST_SIZE_MATCH(xvQueryExtensionReq);
swaps(&stuff->length);
return XvProcVector[xv_QueryExtension] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,017 | SProcXvQueryImageAttributes(ClientPtr client)
{
REQUEST(xvQueryImageAttributesReq);
REQUEST_SIZE_MATCH(xvQueryImageAttributesReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->id);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_QueryImageAttributes] (client);
}
| Exec Code | 0 | SProcXvQueryImageAttributes(ClientPtr client)
{
REQUEST(xvQueryImageAttributesReq);
REQUEST_SIZE_MATCH(xvQueryImageAttributesReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->id);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_QueryImageAttributes] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,018 | SProcXvQueryPortAttributes(ClientPtr client)
{
REQUEST(xvQueryPortAttributesReq);
REQUEST_SIZE_MATCH(xvQueryPortAttributesReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_QueryPortAttributes] (client);
}
| Exec Code | 0 | SProcXvQueryPortAttributes(ClientPtr client)
{
REQUEST(xvQueryPortAttributesReq);
REQUEST_SIZE_MATCH(xvQueryPortAttributesReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_QueryPortAttributes] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,019 | SProcXvSelectPortNotify(ClientPtr client)
{
REQUEST(xvSelectPortNotifyReq);
REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_SelectPortNotify] (client);
}
| Exec Code | 0 | SProcXvSelectPortNotify(ClientPtr client)
{
REQUEST(xvSelectPortNotifyReq);
REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
swaps(&stuff->length);
swapl(&stuff->port);
return XvProcVector[xv_SelectPortNotify] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,020 | SProcXvSelectVideoNotify(ClientPtr client)
{
REQUEST(xvSelectVideoNotifyReq);
REQUEST_SIZE_MATCH(xvSelectVideoNotifyReq);
swaps(&stuff->length);
swapl(&stuff->drawable);
return XvProcVector[xv_SelectVideoNotify] (client);
}
| Exec Code | 0 | SProcXvSelectVideoNotify(ClientPtr client)
{
REQUEST(xvSelectVideoNotifyReq);
REQUEST_SIZE_MATCH(xvSelectVideoNotifyReq);
swaps(&stuff->length);
swapl(&stuff->drawable);
return XvProcVector[xv_SelectVideoNotify] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,021 | SProcXvSetPortAttribute(ClientPtr client)
{
REQUEST(xvSetPortAttributeReq);
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->attribute);
swapl(&stuff->value);
return XvProcVector[xv_SetPortAttribute] (client);
}
| Exec Code | 0 | SProcXvSetPortAttribute(ClientPtr client)
{
REQUEST(xvSetPortAttributeReq);
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->attribute);
swapl(&stuff->value);
return XvProcVector[xv_SetPortAttribute] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,022 | SProcXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
REQUEST_SIZE_MATCH(xvShmPutImageReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swapl(&stuff->shmseg);
swapl(&stuff->id);
swapl(&stuff->offset);
swaps(&stuff->src_x);
swaps(&stuff->src_y);
swaps(&stuff->src_w);
swaps(&stuff->src_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_ShmPutImage] (client);
}
| Exec Code | 0 | SProcXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
REQUEST_SIZE_MATCH(xvShmPutImageReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
swapl(&stuff->gc);
swapl(&stuff->shmseg);
swapl(&stuff->id);
swapl(&stuff->offset);
swaps(&stuff->src_x);
swaps(&stuff->src_y);
swaps(&stuff->src_w);
swaps(&stuff->src_h);
swaps(&stuff->drw_x);
swaps(&stuff->drw_y);
swaps(&stuff->drw_w);
swaps(&stuff->drw_h);
swaps(&stuff->width);
swaps(&stuff->height);
return XvProcVector[xv_ShmPutImage] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,023 | SProcXvStopVideo(ClientPtr client)
{
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
return XvProcVector[xv_StopVideo] (client);
}
| Exec Code | 0 | SProcXvStopVideo(ClientPtr client)
{
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->drawable);
return XvProcVector[xv_StopVideo] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,024 | SProcXvUngrabPort(ClientPtr client)
{
REQUEST(xvUngrabPortReq);
REQUEST_SIZE_MATCH(xvUngrabPortReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->time);
return XvProcVector[xv_UngrabPort] (client);
}
| Exec Code | 0 | SProcXvUngrabPort(ClientPtr client)
{
REQUEST(xvUngrabPortReq);
REQUEST_SIZE_MATCH(xvUngrabPortReq);
swaps(&stuff->length);
swapl(&stuff->port);
swapl(&stuff->time);
return XvProcVector[xv_UngrabPort] (client);
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,025 | SWriteAdaptorInfo(ClientPtr client, xvAdaptorInfo * pAdaptor)
{
swapl(&pAdaptor->base_id);
swaps(&pAdaptor->name_size);
swaps(&pAdaptor->num_ports);
swaps(&pAdaptor->num_formats);
WriteToClient(client, sz_xvAdaptorInfo, pAdaptor);
return Success;
}
| Exec Code | 0 | SWriteAdaptorInfo(ClientPtr client, xvAdaptorInfo * pAdaptor)
{
swapl(&pAdaptor->base_id);
swaps(&pAdaptor->name_size);
swaps(&pAdaptor->num_ports);
swaps(&pAdaptor->num_formats);
WriteToClient(client, sz_xvAdaptorInfo, pAdaptor);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,026 | SWriteAttributeInfo(ClientPtr client, xvAttributeInfo * pAtt)
{
swapl(&pAtt->flags);
swapl(&pAtt->size);
swapl(&pAtt->min);
swapl(&pAtt->max);
WriteToClient(client, sz_xvAttributeInfo, pAtt);
return Success;
}
| Exec Code | 0 | SWriteAttributeInfo(ClientPtr client, xvAttributeInfo * pAtt)
{
swapl(&pAtt->flags);
swapl(&pAtt->size);
swapl(&pAtt->min);
swapl(&pAtt->max);
WriteToClient(client, sz_xvAttributeInfo, pAtt);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,027 | SWriteEncodingInfo(ClientPtr client, xvEncodingInfo * pEncoding)
{
swapl(&pEncoding->encoding);
swaps(&pEncoding->name_size);
swaps(&pEncoding->width);
swaps(&pEncoding->height);
swapl(&pEncoding->rate.numerator);
swapl(&pEncoding->rate.denominator);
WriteToClient(client, sz_xvEncodingInfo, pEncoding);
return Success;
}
| Exec Code | 0 | SWriteEncodingInfo(ClientPtr client, xvEncodingInfo * pEncoding)
{
swapl(&pEncoding->encoding);
swaps(&pEncoding->name_size);
swaps(&pEncoding->width);
swaps(&pEncoding->height);
swapl(&pEncoding->rate.numerator);
swapl(&pEncoding->rate.denominator);
WriteToClient(client, sz_xvEncodingInfo, pEncoding);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,028 | SWriteFormat(ClientPtr client, xvFormat * pFormat)
{
swapl(&pFormat->visual);
WriteToClient(client, sz_xvFormat, pFormat);
return Success;
}
| Exec Code | 0 | SWriteFormat(ClientPtr client, xvFormat * pFormat)
{
swapl(&pFormat->visual);
WriteToClient(client, sz_xvFormat, pFormat);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,029 | SWriteGetPortAttributeReply(ClientPtr client, xvGetPortAttributeReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->value);
WriteToClient(client, sz_xvGetPortAttributeReply, rep);
return Success;
}
| Exec Code | 0 | SWriteGetPortAttributeReply(ClientPtr client, xvGetPortAttributeReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->value);
WriteToClient(client, sz_xvGetPortAttributeReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,030 | SWriteGrabPortReply(ClientPtr client, xvGrabPortReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, sz_xvGrabPortReply, rep);
return Success;
}
| Exec Code | 0 | SWriteGrabPortReply(ClientPtr client, xvGrabPortReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
WriteToClient(client, sz_xvGrabPortReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,031 | SWriteImageFormatInfo(ClientPtr client, xvImageFormatInfo * pImage)
{
swapl(&pImage->id);
swapl(&pImage->red_mask);
swapl(&pImage->green_mask);
swapl(&pImage->blue_mask);
swapl(&pImage->y_sample_bits);
swapl(&pImage->u_sample_bits);
swapl(&pImage->v_sample_bits);
swapl(&pImage->horz_y_period);
swapl(&pImage->horz_u_period);
swapl(&pImage->horz_v_period);
swapl(&pImage->vert_y_period);
swapl(&pImage->vert_u_period);
swapl(&pImage->vert_v_period);
WriteToClient(client, sz_xvImageFormatInfo, pImage);
return Success;
}
| Exec Code | 0 | SWriteImageFormatInfo(ClientPtr client, xvImageFormatInfo * pImage)
{
swapl(&pImage->id);
swapl(&pImage->red_mask);
swapl(&pImage->green_mask);
swapl(&pImage->blue_mask);
swapl(&pImage->y_sample_bits);
swapl(&pImage->u_sample_bits);
swapl(&pImage->v_sample_bits);
swapl(&pImage->horz_y_period);
swapl(&pImage->horz_u_period);
swapl(&pImage->horz_v_period);
swapl(&pImage->vert_y_period);
swapl(&pImage->vert_u_period);
swapl(&pImage->vert_v_period);
WriteToClient(client, sz_xvImageFormatInfo, pImage);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,032 | SWriteQueryBestSizeReply(ClientPtr client, xvQueryBestSizeReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->actual_width);
swaps(&rep->actual_height);
WriteToClient(client, sz_xvQueryBestSizeReply, rep);
return Success;
}
| Exec Code | 0 | SWriteQueryBestSizeReply(ClientPtr client, xvQueryBestSizeReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->actual_width);
swaps(&rep->actual_height);
WriteToClient(client, sz_xvQueryBestSizeReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,033 | SWriteQueryExtensionReply(ClientPtr client, xvQueryExtensionReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->version);
swaps(&rep->revision);
WriteToClient(client, sz_xvQueryExtensionReply, rep);
return Success;
}
| Exec Code | 0 | SWriteQueryExtensionReply(ClientPtr client, xvQueryExtensionReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swaps(&rep->version);
swaps(&rep->revision);
WriteToClient(client, sz_xvQueryExtensionReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,034 | SWriteQueryImageAttributesReply(ClientPtr client,
xvQueryImageAttributesReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->num_planes);
swapl(&rep->data_size);
swaps(&rep->width);
swaps(&rep->height);
WriteToClient(client, sz_xvQueryImageAttributesReply, rep);
return Success;
}
| Exec Code | 0 | SWriteQueryImageAttributesReply(ClientPtr client,
xvQueryImageAttributesReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->num_planes);
swapl(&rep->data_size);
swaps(&rep->width);
swaps(&rep->height);
WriteToClient(client, sz_xvQueryImageAttributesReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,035 | SWriteQueryPortAttributesReply(ClientPtr client,
xvQueryPortAttributesReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->num_attributes);
swapl(&rep->text_size);
WriteToClient(client, sz_xvQueryPortAttributesReply, rep);
return Success;
}
| Exec Code | 0 | SWriteQueryPortAttributesReply(ClientPtr client,
xvQueryPortAttributesReply * rep)
{
swaps(&rep->sequenceNumber);
swapl(&rep->length);
swapl(&rep->num_attributes);
swapl(&rep->text_size);
WriteToClient(client, sz_xvQueryPortAttributesReply, rep);
return Success;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,036 | XineramaXvPutImage(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutImage(client);
}
}
return result;
}
| Exec Code | 0 | XineramaXvPutImage(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutImage(client);
}
}
return result;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,037 | XineramaXvPutStill(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutStill(client);
}
}
return result;
}
| Exec Code | 0 | XineramaXvPutStill(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutImageReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutStill(client);
}
}
return result;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,038 | XineramaXvPutVideo(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutVideoReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutVideo(client);
}
}
return result;
}
| Exec Code | 0 | XineramaXvPutVideo(ClientPtr client)
{
REQUEST(xvPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool isRoot;
int result, i, x, y;
REQUEST_AT_LEAST_SIZE(xvPutVideoReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &gc, stuff->gc,
XRT_GC, client, DixReadAccess);
if (result != Success)
return result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
x = stuff->drw_x;
y = stuff->drw_y;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
stuff->gc = gc->info[i].id;
stuff->drw_x = x;
stuff->drw_y = y;
if (isRoot) {
stuff->drw_x -= screenInfo.screens[i]->x;
stuff->drw_y -= screenInfo.screens[i]->y;
}
result = ProcXvPutVideo(client);
}
}
return result;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,039 | XineramaXvSetPortAttribute(ClientPtr client)
{
REQUEST(xvSetPortAttributeReq);
PanoramiXRes *port;
int result, i;
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->port = port->info[i].id;
result = ProcXvSetPortAttribute(client);
}
}
return result;
}
| Exec Code | 0 | XineramaXvSetPortAttribute(ClientPtr client)
{
REQUEST(xvSetPortAttributeReq);
PanoramiXRes *port;
int result, i;
REQUEST_SIZE_MATCH(xvSetPortAttributeReq);
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->port = port->info[i].id;
result = ProcXvSetPortAttribute(client);
}
}
return result;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,040 | XineramaXvStopVideo(ClientPtr client)
{
int result, i;
PanoramiXRes *draw, *port;
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
result = ProcXvStopVideo(client);
}
}
return result;
}
| Exec Code | 0 | XineramaXvStopVideo(ClientPtr client)
{
int result, i;
PanoramiXRes *draw, *port;
REQUEST(xvStopVideoReq);
REQUEST_SIZE_MATCH(xvStopVideoReq);
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success)
return (result == BadValue) ? BadDrawable : result;
result = dixLookupResourceByType((void **) &port, stuff->port,
XvXRTPort, client, DixReadAccess);
if (result != Success)
return result;
FOR_NSCREENS_BACKWARD(i) {
if (port->info[i].id) {
stuff->drawable = draw->info[i].id;
stuff->port = port->info[i].id;
result = ProcXvStopVideo(client);
}
}
return result;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,041 | XineramifyXv(void)
{
XvScreenPtr xvsp0 =
dixLookupPrivate(&screenInfo.screens[0]->devPrivates, XvGetScreenKey());
XvAdaptorPtr MatchingAdaptors[MAXSCREENS];
int i, j, k;
XvXRTPort = CreateNewResourceType(XineramaDeleteResource, "XvXRTPort");
if (!xvsp0 || !XvXRTPort)
return;
SetResourceTypeErrorValue(XvXRTPort, _XvBadPort);
for (i = 0; i < xvsp0->nAdaptors; i++) {
Bool isOverlay;
XvAdaptorPtr refAdapt = xvsp0->pAdaptors + i;
if (!(refAdapt->type & XvInputMask))
continue;
MatchingAdaptors[0] = refAdapt;
isOverlay = hasOverlay(refAdapt);
FOR_NSCREENS_FORWARD_SKIP(j)
MatchingAdaptors[j] =
matchAdaptor(screenInfo.screens[j], refAdapt, isOverlay);
/* now create a resource for each port */
for (j = 0; j < refAdapt->nPorts; j++) {
PanoramiXRes *port = malloc(sizeof(PanoramiXRes));
if (!port)
break;
FOR_NSCREENS(k) {
if (MatchingAdaptors[k] && (MatchingAdaptors[k]->nPorts > j))
port->info[k].id = MatchingAdaptors[k]->base_id + j;
else
port->info[k].id = 0;
}
AddResource(port->info[0].id, XvXRTPort, port);
}
}
/* munge the dispatch vector */
XvProcVector[xv_PutVideo] = XineramaXvPutVideo;
XvProcVector[xv_PutStill] = XineramaXvPutStill;
XvProcVector[xv_StopVideo] = XineramaXvStopVideo;
XvProcVector[xv_SetPortAttribute] = XineramaXvSetPortAttribute;
XvProcVector[xv_PutImage] = XineramaXvPutImage;
XvProcVector[xv_ShmPutImage] = XineramaXvShmPutImage;
}
| Exec Code | 0 | XineramifyXv(void)
{
XvScreenPtr xvsp0 =
dixLookupPrivate(&screenInfo.screens[0]->devPrivates, XvGetScreenKey());
XvAdaptorPtr MatchingAdaptors[MAXSCREENS];
int i, j, k;
XvXRTPort = CreateNewResourceType(XineramaDeleteResource, "XvXRTPort");
if (!xvsp0 || !XvXRTPort)
return;
SetResourceTypeErrorValue(XvXRTPort, _XvBadPort);
for (i = 0; i < xvsp0->nAdaptors; i++) {
Bool isOverlay;
XvAdaptorPtr refAdapt = xvsp0->pAdaptors + i;
if (!(refAdapt->type & XvInputMask))
continue;
MatchingAdaptors[0] = refAdapt;
isOverlay = hasOverlay(refAdapt);
FOR_NSCREENS_FORWARD_SKIP(j)
MatchingAdaptors[j] =
matchAdaptor(screenInfo.screens[j], refAdapt, isOverlay);
/* now create a resource for each port */
for (j = 0; j < refAdapt->nPorts; j++) {
PanoramiXRes *port = malloc(sizeof(PanoramiXRes));
if (!port)
break;
FOR_NSCREENS(k) {
if (MatchingAdaptors[k] && (MatchingAdaptors[k]->nPorts > j))
port->info[k].id = MatchingAdaptors[k]->base_id + j;
else
port->info[k].id = 0;
}
AddResource(port->info[0].id, XvXRTPort, port);
}
}
/* munge the dispatch vector */
XvProcVector[xv_PutVideo] = XineramaXvPutVideo;
XvProcVector[xv_PutStill] = XineramaXvPutStill;
XvProcVector[xv_StopVideo] = XineramaXvStopVideo;
XvProcVector[xv_SetPortAttribute] = XineramaXvSetPortAttribute;
XvProcVector[xv_PutImage] = XineramaXvPutImage;
XvProcVector[xv_ShmPutImage] = XineramaXvShmPutImage;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,042 | XvResetProcVector(void)
{
#ifdef PANORAMIX
XvProcVector[xv_PutVideo] = ProcXvPutVideo;
XvProcVector[xv_PutStill] = ProcXvPutStill;
XvProcVector[xv_StopVideo] = ProcXvStopVideo;
XvProcVector[xv_SetPortAttribute] = ProcXvSetPortAttribute;
XvProcVector[xv_PutImage] = ProcXvPutImage;
XvProcVector[xv_ShmPutImage] = ProcXvShmPutImage;
#endif
}
| Exec Code | 0 | XvResetProcVector(void)
{
#ifdef PANORAMIX
XvProcVector[xv_PutVideo] = ProcXvPutVideo;
XvProcVector[xv_PutStill] = ProcXvPutStill;
XvProcVector[xv_StopVideo] = ProcXvStopVideo;
XvProcVector[xv_SetPortAttribute] = ProcXvSetPortAttribute;
XvProcVector[xv_PutImage] = ProcXvPutImage;
XvProcVector[xv_ShmPutImage] = ProcXvShmPutImage;
#endif
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,043 | hasOverlay(XvAdaptorPtr pAdapt)
{
int i;
for (i = 0; i < pAdapt->nAttributes; i++)
if (!strcmp(pAdapt->pAttributes[i].name, "XV_COLORKEY"))
return TRUE;
return FALSE;
}
| Exec Code | 0 | hasOverlay(XvAdaptorPtr pAdapt)
{
int i;
for (i = 0; i < pAdapt->nAttributes; i++)
if (!strcmp(pAdapt->pAttributes[i].name, "XV_COLORKEY"))
return TRUE;
return FALSE;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,044 | matchAdaptor(ScreenPtr pScreen, XvAdaptorPtr refAdapt, Bool isOverlay)
{
int i;
XvScreenPtr xvsp =
dixLookupPrivate(&pScreen->devPrivates, XvGetScreenKey());
/* Do not try to go on if xv is not supported on this screen */
if (xvsp == NULL)
return NULL;
/* if the adaptor has the same name it's a perfect match */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (!strcmp(refAdapt->name, pAdapt->name))
return pAdapt;
}
/* otherwise we only look for XvImage adaptors */
if (!isImageAdaptor(refAdapt))
return NULL;
/* prefer overlay/overlay non-overlay/non-overlay pairing */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (isImageAdaptor(pAdapt) && isOverlay == hasOverlay(pAdapt))
return pAdapt;
}
/* but we'll take any XvImage pairing if we can get it */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (isImageAdaptor(pAdapt))
return pAdapt;
}
return NULL;
}
| Exec Code | 0 | matchAdaptor(ScreenPtr pScreen, XvAdaptorPtr refAdapt, Bool isOverlay)
{
int i;
XvScreenPtr xvsp =
dixLookupPrivate(&pScreen->devPrivates, XvGetScreenKey());
/* Do not try to go on if xv is not supported on this screen */
if (xvsp == NULL)
return NULL;
/* if the adaptor has the same name it's a perfect match */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (!strcmp(refAdapt->name, pAdapt->name))
return pAdapt;
}
/* otherwise we only look for XvImage adaptors */
if (!isImageAdaptor(refAdapt))
return NULL;
/* prefer overlay/overlay non-overlay/non-overlay pairing */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (isImageAdaptor(pAdapt) && isOverlay == hasOverlay(pAdapt))
return pAdapt;
}
/* but we'll take any XvImage pairing if we can get it */
for (i = 0; i < xvsp->nAdaptors; i++) {
XvAdaptorPtr pAdapt = xvsp->pAdaptors + i;
if (isImageAdaptor(pAdapt))
return pAdapt;
}
return NULL;
}
| @@ -1493,12 +1493,14 @@ XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
- Bool send_event = stuff->send_event;
+ Bool send_event;
Bool isRoot;
int result, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
+ send_event = stuff->send_event;
+
result = dixLookupResourceByClass((void **) &draw, stuff->drawable,
XRC_DRAWABLE, client, DixWriteAccess);
if (result != Success) | CWE-20 | null | null |
14,045 | dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet)
{
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int idx = pScreen->myNum;
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
if (glyphPriv->glyphSets[idx]) {
XRenderFreeGlyphSet(dmxScreen->beDisplay, glyphPriv->glyphSets[idx]);
glyphPriv->glyphSets[idx] = (GlyphSet) 0;
return TRUE;
}
return FALSE;
}
| Exec Code | 0 | dmxBEFreeGlyphSet(ScreenPtr pScreen, GlyphSetPtr glyphSet)
{
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int idx = pScreen->myNum;
DMXScreenInfo *dmxScreen = &dmxScreens[idx];
if (glyphPriv->glyphSets[idx]) {
XRenderFreeGlyphSet(dmxScreen->beDisplay, glyphPriv->glyphSets[idx]);
glyphPriv->glyphSets[idx] = (GlyphSet) 0;
return TRUE;
}
return FALSE;
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,046 | dmxFindFormat(DMXScreenInfo * dmxScreen, PictFormatPtr pFmt)
{
XRenderPictFormat *pFormat = NULL;
int i = 0;
if (!pFmt || !dmxScreen->beDisplay)
return pFormat;
while (1) {
pFormat = XRenderFindFormat(dmxScreen->beDisplay, 0, 0, i++);
if (!pFormat)
break;
if (pFormat->type != pFmt->type)
continue;
if (pFormat->depth != pFmt->depth)
continue;
if (pFormat->direct.red != pFmt->direct.red)
continue;
if (pFormat->direct.redMask != pFmt->direct.redMask)
continue;
if (pFormat->direct.green != pFmt->direct.green)
continue;
if (pFormat->direct.greenMask != pFmt->direct.greenMask)
continue;
if (pFormat->direct.blue != pFmt->direct.blue)
continue;
if (pFormat->direct.blueMask != pFmt->direct.blueMask)
continue;
if (pFormat->direct.alpha != pFmt->direct.alpha)
continue;
if (pFormat->direct.alphaMask != pFmt->direct.alphaMask)
continue;
/* We have a match! */
break;
}
return pFormat;
}
| Exec Code | 0 | dmxFindFormat(DMXScreenInfo * dmxScreen, PictFormatPtr pFmt)
{
XRenderPictFormat *pFormat = NULL;
int i = 0;
if (!pFmt || !dmxScreen->beDisplay)
return pFormat;
while (1) {
pFormat = XRenderFindFormat(dmxScreen->beDisplay, 0, 0, i++);
if (!pFormat)
break;
if (pFormat->type != pFmt->type)
continue;
if (pFormat->depth != pFmt->depth)
continue;
if (pFormat->direct.red != pFmt->direct.red)
continue;
if (pFormat->direct.redMask != pFmt->direct.redMask)
continue;
if (pFormat->direct.green != pFmt->direct.green)
continue;
if (pFormat->direct.greenMask != pFmt->direct.greenMask)
continue;
if (pFormat->direct.blue != pFmt->direct.blue)
continue;
if (pFormat->direct.blueMask != pFmt->direct.blueMask)
continue;
if (pFormat->direct.alpha != pFmt->direct.alpha)
continue;
if (pFormat->direct.alphaMask != pFmt->direct.alphaMask)
continue;
/* We have a match! */
break;
}
return pFormat;
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,047 | dmxInitRender(void)
{
int i;
for (i = 0; i < RenderNumberRequests; i++)
dmxSaveRenderVector[i] = ProcRenderVector[i];
ProcRenderVector[X_RenderCreateGlyphSet]
= dmxProcRenderCreateGlyphSet;
ProcRenderVector[X_RenderFreeGlyphSet]
= dmxProcRenderFreeGlyphSet;
ProcRenderVector[X_RenderAddGlyphs]
= dmxProcRenderAddGlyphs;
ProcRenderVector[X_RenderFreeGlyphs]
= dmxProcRenderFreeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs8]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs16]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs32]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderSetPictureTransform]
= dmxProcRenderSetPictureTransform;
ProcRenderVector[X_RenderSetPictureFilter]
= dmxProcRenderSetPictureFilter;
}
| Exec Code | 0 | dmxInitRender(void)
{
int i;
for (i = 0; i < RenderNumberRequests; i++)
dmxSaveRenderVector[i] = ProcRenderVector[i];
ProcRenderVector[X_RenderCreateGlyphSet]
= dmxProcRenderCreateGlyphSet;
ProcRenderVector[X_RenderFreeGlyphSet]
= dmxProcRenderFreeGlyphSet;
ProcRenderVector[X_RenderAddGlyphs]
= dmxProcRenderAddGlyphs;
ProcRenderVector[X_RenderFreeGlyphs]
= dmxProcRenderFreeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs8]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs16]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs32]
= dmxProcRenderCompositeGlyphs;
ProcRenderVector[X_RenderSetPictureTransform]
= dmxProcRenderSetPictureTransform;
ProcRenderVector[X_RenderSetPictureFilter]
= dmxProcRenderSetPictureFilter;
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,048 | dmxProcRenderAddGlyphs(ClientPtr client)
{
int ret;
REQUEST(xRenderAddGlyphsReq);
ret = dmxSaveRenderVector[stuff->renderReqType] (client);
if (ret == Success) {
GlyphSetPtr glyphSet;
dmxGlyphPrivPtr glyphPriv;
int i;
int nglyphs;
CARD32 *gids;
Glyph *gidsCopy;
xGlyphInfo *gi;
CARD8 *bits;
int nbytes;
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixReadAccess);
glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
nglyphs = stuff->nglyphs;
gids = (CARD32 *) (stuff + 1);
gi = (xGlyphInfo *) (gids + nglyphs);
bits = (CARD8 *) (gi + nglyphs);
nbytes = ((stuff->length << 2) -
sizeof(xRenderAddGlyphsReq) -
(sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs);
gidsCopy = xallocarray(nglyphs, sizeof(*gidsCopy));
for (i = 0; i < nglyphs; i++)
gidsCopy[i] = gids[i];
/* FIXME: Will this ever fail? */
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
XRenderAddGlyphs(dmxScreen->beDisplay,
glyphPriv->glyphSets[i],
gidsCopy,
(XGlyphInfo *) gi,
nglyphs, (char *) bits, nbytes);
dmxSync(dmxScreen, FALSE);
}
}
free(gidsCopy);
}
return ret;
}
| Exec Code | 0 | dmxProcRenderAddGlyphs(ClientPtr client)
{
int ret;
REQUEST(xRenderAddGlyphsReq);
ret = dmxSaveRenderVector[stuff->renderReqType] (client);
if (ret == Success) {
GlyphSetPtr glyphSet;
dmxGlyphPrivPtr glyphPriv;
int i;
int nglyphs;
CARD32 *gids;
Glyph *gidsCopy;
xGlyphInfo *gi;
CARD8 *bits;
int nbytes;
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixReadAccess);
glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
nglyphs = stuff->nglyphs;
gids = (CARD32 *) (stuff + 1);
gi = (xGlyphInfo *) (gids + nglyphs);
bits = (CARD8 *) (gi + nglyphs);
nbytes = ((stuff->length << 2) -
sizeof(xRenderAddGlyphsReq) -
(sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs);
gidsCopy = xallocarray(nglyphs, sizeof(*gidsCopy));
for (i = 0; i < nglyphs; i++)
gidsCopy[i] = gids[i];
/* FIXME: Will this ever fail? */
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
XRenderAddGlyphs(dmxScreen->beDisplay,
glyphPriv->glyphSets[i],
gidsCopy,
(XGlyphInfo *) gi,
nglyphs, (char *) bits, nbytes);
dmxSync(dmxScreen, FALSE);
}
}
free(gidsCopy);
}
return ret;
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,049 | dmxProcRenderFreeGlyphSet(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderFreeGlyphSetReq);
REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixDestroyAccess);
if (glyphSet && glyphSet->refcnt == 1) {
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int i;
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
if (dmxBEFreeGlyphSet(screenInfo.screens[i], glyphSet))
dmxSync(dmxScreen, FALSE);
}
}
MAXSCREENSFREE(glyphPriv->glyphSets);
free(glyphPriv);
DMX_SET_GLYPH_PRIV(glyphSet, NULL);
}
return dmxSaveRenderVector[stuff->renderReqType] (client);
}
| Exec Code | 0 | dmxProcRenderFreeGlyphSet(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderFreeGlyphSetReq);
REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixDestroyAccess);
if (glyphSet && glyphSet->refcnt == 1) {
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int i;
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
if (dmxBEFreeGlyphSet(screenInfo.screens[i], glyphSet))
dmxSync(dmxScreen, FALSE);
}
}
MAXSCREENSFREE(glyphPriv->glyphSets);
free(glyphPriv);
DMX_SET_GLYPH_PRIV(glyphSet, NULL);
}
return dmxSaveRenderVector[stuff->renderReqType] (client);
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,050 | dmxProcRenderFreeGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderFreeGlyphsReq);
REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixWriteAccess);
if (glyphSet) {
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int i;
int nglyphs;
Glyph *gids;
nglyphs = ((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)) >> 2;
if (nglyphs) {
gids = xallocarray(nglyphs, sizeof(*gids));
for (i = 0; i < nglyphs; i++)
gids[i] = ((CARD32 *) (stuff + 1))[i];
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
XRenderFreeGlyphs(dmxScreen->beDisplay,
glyphPriv->glyphSets[i], gids, nglyphs);
dmxSync(dmxScreen, FALSE);
}
}
free(gids);
}
}
return dmxSaveRenderVector[stuff->renderReqType] (client);
}
| Exec Code | 0 | dmxProcRenderFreeGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderFreeGlyphsReq);
REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
dixLookupResourceByType((void **) &glyphSet,
stuff->glyphset, GlyphSetType,
client, DixWriteAccess);
if (glyphSet) {
dmxGlyphPrivPtr glyphPriv = DMX_GET_GLYPH_PRIV(glyphSet);
int i;
int nglyphs;
Glyph *gids;
nglyphs = ((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq)) >> 2;
if (nglyphs) {
gids = xallocarray(nglyphs, sizeof(*gids));
for (i = 0; i < nglyphs; i++)
gids[i] = ((CARD32 *) (stuff + 1))[i];
for (i = 0; i < dmxNumScreens; i++) {
DMXScreenInfo *dmxScreen = &dmxScreens[i];
if (dmxScreen->beDisplay) {
XRenderFreeGlyphs(dmxScreen->beDisplay,
glyphPriv->glyphSets[i], gids, nglyphs);
dmxSync(dmxScreen, FALSE);
}
}
free(gids);
}
}
return dmxSaveRenderVector[stuff->renderReqType] (client);
}
| @@ -716,6 +716,8 @@ dmxProcRenderSetPictureFilter(ClientPtr client)
filter = (char *) (stuff + 1);
params = (XFixed *) (filter + ((stuff->nbytes + 3) & ~3));
nparams = ((XFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
XRenderSetPictureFilter(dmxScreen->beDisplay,
pPictPriv->pict, filter, params, nparams); | CWE-20 | null | null |
14,051 | ProcPseudoramiXDispatch(ClientPtr client)
{
REQUEST(xReq);
TRACE;
switch (stuff->data) {
case X_PanoramiXQueryVersion:
return ProcPseudoramiXQueryVersion(client);
case X_PanoramiXGetState:
return ProcPseudoramiXGetState(client);
case X_PanoramiXGetScreenCount:
return ProcPseudoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return ProcPseudoramiXGetScreenSize(client);
case X_XineramaIsActive:
return ProcPseudoramiXIsActive(client);
case X_XineramaQueryScreens:
return ProcPseudoramiXQueryScreens(client);
}
return BadRequest;
}
| Exec Code | 0 | ProcPseudoramiXDispatch(ClientPtr client)
{
REQUEST(xReq);
TRACE;
switch (stuff->data) {
case X_PanoramiXQueryVersion:
return ProcPseudoramiXQueryVersion(client);
case X_PanoramiXGetState:
return ProcPseudoramiXGetState(client);
case X_PanoramiXGetScreenCount:
return ProcPseudoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return ProcPseudoramiXGetScreenSize(client);
case X_XineramaIsActive:
return ProcPseudoramiXIsActive(client);
case X_XineramaQueryScreens:
return ProcPseudoramiXQueryScreens(client);
}
return BadRequest;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,052 | ProcPseudoramiXGetState(ClientPtr client)
{
REQUEST(xPanoramiXGetStateReq);
WindowPtr pWin;
xPanoramiXGetStateReply rep;
register int rc;
TRACE;
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = !noPseudoramiXExtension;
rep.window = stuff->window;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply),&rep);
return Success;
}
| Exec Code | 0 | ProcPseudoramiXGetState(ClientPtr client)
{
REQUEST(xPanoramiXGetStateReq);
WindowPtr pWin;
xPanoramiXGetStateReply rep;
register int rc;
TRACE;
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = !noPseudoramiXExtension;
rep.window = stuff->window;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.window);
}
WriteToClient(client, sizeof(xPanoramiXGetStateReply),&rep);
return Success;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,053 | ProcPseudoramiXIsActive(ClientPtr client)
{
/* REQUEST(xXineramaIsActiveReq); */
xXineramaIsActiveReply rep;
TRACE;
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = !noPseudoramiXExtension;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply),&rep);
return Success;
}
| Exec Code | 0 | ProcPseudoramiXIsActive(ClientPtr client)
{
/* REQUEST(xXineramaIsActiveReq); */
xXineramaIsActiveReply rep;
TRACE;
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.state = !noPseudoramiXExtension;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.state);
}
WriteToClient(client, sizeof(xXineramaIsActiveReply),&rep);
return Success;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,054 | ProcPseudoramiXQueryScreens(ClientPtr client)
{
/* REQUEST(xXineramaQueryScreensReq); */
xXineramaQueryScreensReply rep;
DEBUG_LOG("noPseudoramiXExtension=%d, pseudoramiXNumScreens=%d\n",
noPseudoramiXExtension,
pseudoramiXNumScreens);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.number = noPseudoramiXExtension ? 0 : pseudoramiXNumScreens;
rep.length = bytes_to_int32(rep.number * sz_XineramaScreenInfo);
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply),&rep);
if (!noPseudoramiXExtension) {
xXineramaScreenInfo scratch;
int i;
for (i = 0; i < pseudoramiXNumScreens; i++) {
scratch.x_org = pseudoramiXScreens[i].x;
scratch.y_org = pseudoramiXScreens[i].y;
scratch.width = pseudoramiXScreens[i].w;
scratch.height = pseudoramiXScreens[i].h;
if (client->swapped) {
swaps(&scratch.x_org);
swaps(&scratch.y_org);
swaps(&scratch.width);
swaps(&scratch.height);
}
WriteToClient(client, sz_XineramaScreenInfo,&scratch);
}
}
return Success;
}
| Exec Code | 0 | ProcPseudoramiXQueryScreens(ClientPtr client)
{
/* REQUEST(xXineramaQueryScreensReq); */
xXineramaQueryScreensReply rep;
DEBUG_LOG("noPseudoramiXExtension=%d, pseudoramiXNumScreens=%d\n",
noPseudoramiXExtension,
pseudoramiXNumScreens);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.number = noPseudoramiXExtension ? 0 : pseudoramiXNumScreens;
rep.length = bytes_to_int32(rep.number * sz_XineramaScreenInfo);
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.number);
}
WriteToClient(client, sizeof(xXineramaQueryScreensReply),&rep);
if (!noPseudoramiXExtension) {
xXineramaScreenInfo scratch;
int i;
for (i = 0; i < pseudoramiXNumScreens; i++) {
scratch.x_org = pseudoramiXScreens[i].x;
scratch.y_org = pseudoramiXScreens[i].y;
scratch.width = pseudoramiXScreens[i].w;
scratch.height = pseudoramiXScreens[i].h;
if (client->swapped) {
swaps(&scratch.x_org);
swaps(&scratch.y_org);
swaps(&scratch.width);
swaps(&scratch.height);
}
WriteToClient(client, sz_XineramaScreenInfo,&scratch);
}
}
return Success;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,055 | ProcPseudoramiXQueryVersion(ClientPtr client)
{
TRACE;
return ProcPanoramiXQueryVersion(client);
}
| Exec Code | 0 | ProcPseudoramiXQueryVersion(ClientPtr client)
{
TRACE;
return ProcPanoramiXQueryVersion(client);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,056 | PseudoramiXAddScreen(int x, int y, int w, int h)
{
PseudoramiXScreenRec *s;
if (noPseudoramiXExtension) return;
if (pseudoramiXNumScreens == pseudoramiXScreensAllocated) {
pseudoramiXScreensAllocated += pseudoramiXScreensAllocated + 1;
pseudoramiXScreens = reallocarray(pseudoramiXScreens,
pseudoramiXScreensAllocated,
sizeof(PseudoramiXScreenRec));
}
DEBUG_LOG("x: %d, y: %d, w: %d, h: %d\n", x, y, w, h);
s = &pseudoramiXScreens[pseudoramiXNumScreens++];
s->x = x;
s->y = y;
s->w = w;
s->h = h;
}
| Exec Code | 0 | PseudoramiXAddScreen(int x, int y, int w, int h)
{
PseudoramiXScreenRec *s;
if (noPseudoramiXExtension) return;
if (pseudoramiXNumScreens == pseudoramiXScreensAllocated) {
pseudoramiXScreensAllocated += pseudoramiXScreensAllocated + 1;
pseudoramiXScreens = reallocarray(pseudoramiXScreens,
pseudoramiXScreensAllocated,
sizeof(PseudoramiXScreenRec));
}
DEBUG_LOG("x: %d, y: %d, w: %d, h: %d\n", x, y, w, h);
s = &pseudoramiXScreens[pseudoramiXNumScreens++];
s->x = x;
s->y = y;
s->w = w;
s->h = h;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,057 | PseudoramiXDebug(const char *format, ...)
{
va_list ap;
va_start(ap, format);
LogVMessageVerb(X_NONE, 3, format, ap);
va_end(ap);
}
| Exec Code | 0 | PseudoramiXDebug(const char *format, ...)
{
va_list ap;
va_start(ap, format);
LogVMessageVerb(X_NONE, 3, format, ap);
va_end(ap);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,058 | PseudoramiXResetProc(ExtensionEntry *extEntry)
{
TRACE;
PseudoramiXResetScreens();
}
| Exec Code | 0 | PseudoramiXResetProc(ExtensionEntry *extEntry)
{
TRACE;
PseudoramiXResetScreens();
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,059 | PseudoramiXResetScreens(void)
{
TRACE;
pseudoramiXNumScreens = 0;
}
| Exec Code | 0 | PseudoramiXResetScreens(void)
{
TRACE;
pseudoramiXNumScreens = 0;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,060 | SProcPseudoramiXDispatch(ClientPtr client)
{
REQUEST(xReq);
TRACE;
switch (stuff->data) {
case X_PanoramiXQueryVersion:
return SProcPseudoramiXQueryVersion(client);
case X_PanoramiXGetState:
return SProcPseudoramiXGetState(client);
case X_PanoramiXGetScreenCount:
return SProcPseudoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return SProcPseudoramiXGetScreenSize(client);
case X_XineramaIsActive:
return SProcPseudoramiXIsActive(client);
case X_XineramaQueryScreens:
return SProcPseudoramiXQueryScreens(client);
}
return BadRequest;
}
| Exec Code | 0 | SProcPseudoramiXDispatch(ClientPtr client)
{
REQUEST(xReq);
TRACE;
switch (stuff->data) {
case X_PanoramiXQueryVersion:
return SProcPseudoramiXQueryVersion(client);
case X_PanoramiXGetState:
return SProcPseudoramiXGetState(client);
case X_PanoramiXGetScreenCount:
return SProcPseudoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize:
return SProcPseudoramiXGetScreenSize(client);
case X_XineramaIsActive:
return SProcPseudoramiXIsActive(client);
case X_XineramaQueryScreens:
return SProcPseudoramiXQueryScreens(client);
}
return BadRequest;
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,061 | SProcPseudoramiXGetState(ClientPtr client)
{
REQUEST(xPanoramiXGetStateReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
return ProcPseudoramiXGetState(client);
}
| Exec Code | 0 | SProcPseudoramiXGetState(ClientPtr client)
{
REQUEST(xPanoramiXGetStateReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
return ProcPseudoramiXGetState(client);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,062 | SProcPseudoramiXIsActive(ClientPtr client)
{
REQUEST(xXineramaIsActiveReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
return ProcPseudoramiXIsActive(client);
}
| Exec Code | 0 | SProcPseudoramiXIsActive(ClientPtr client)
{
REQUEST(xXineramaIsActiveReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
return ProcPseudoramiXIsActive(client);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,063 | SProcPseudoramiXQueryScreens(ClientPtr client)
{
REQUEST(xXineramaQueryScreensReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
return ProcPseudoramiXQueryScreens(client);
}
| Exec Code | 0 | SProcPseudoramiXQueryScreens(ClientPtr client)
{
REQUEST(xXineramaQueryScreensReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
return ProcPseudoramiXQueryScreens(client);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,064 | SProcPseudoramiXQueryVersion(ClientPtr client)
{
REQUEST(xPanoramiXQueryVersionReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
return ProcPseudoramiXQueryVersion(client);
}
| Exec Code | 0 | SProcPseudoramiXQueryVersion(ClientPtr client)
{
REQUEST(xPanoramiXQueryVersionReq);
TRACE;
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
return ProcPseudoramiXQueryVersion(client);
}
| @@ -297,10 +297,11 @@ ProcPseudoramiXGetScreenSize(ClientPtr client)
TRACE;
+ REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
+
if (stuff->screen >= pseudoramiXNumScreens)
return BadMatch;
- REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc; | CWE-20 | null | null |
14,065 | PanoramiXRenderAddTraps(ClientPtr client)
{
PanoramiXRes *picture;
int result = Success, j;
REQUEST(xRenderAddTrapsReq);
char *extra;
int extra_len;
INT16 x_off, y_off;
REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
VERIFY_XIN_PICTURE(picture, stuff->picture, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
x_off = stuff->xOff;
y_off = stuff->yOff;
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
stuff->picture = picture->info[j].id;
if (picture->u.pict.root) {
stuff->xOff = x_off + screenInfo.screens[j]->x;
stuff->yOff = y_off + screenInfo.screens[j]->y;
}
result = (*PanoramiXSaveRenderVector[X_RenderAddTraps]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| Exec Code | 0 | PanoramiXRenderAddTraps(ClientPtr client)
{
PanoramiXRes *picture;
int result = Success, j;
REQUEST(xRenderAddTrapsReq);
char *extra;
int extra_len;
INT16 x_off, y_off;
REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
VERIFY_XIN_PICTURE(picture, stuff->picture, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
x_off = stuff->xOff;
y_off = stuff->yOff;
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
stuff->picture = picture->info[j].id;
if (picture->u.pict.root) {
stuff->xOff = x_off + screenInfo.screens[j]->x;
stuff->yOff = y_off + screenInfo.screens[j]->y;
}
result = (*PanoramiXSaveRenderVector[X_RenderAddTraps]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,066 | PanoramiXRenderChangePicture(ClientPtr client)
{
PanoramiXRes *pict;
int result = Success, j;
REQUEST(xRenderChangePictureReq);
REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderChangePicture]) (client);
if (result != Success)
break;
}
return result;
}
| Exec Code | 0 | PanoramiXRenderChangePicture(ClientPtr client)
{
PanoramiXRes *pict;
int result = Success, j;
REQUEST(xRenderChangePictureReq);
REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderChangePicture]) (client);
if (result != Success)
break;
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,067 | PanoramiXRenderCompositeGlyphs(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderCompositeGlyphsReq);
xGlyphElt origElt, *elt;
INT16 xSrc, ySrc;
REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
if (client->req_len << 2 >= (sizeof(xRenderCompositeGlyphsReq) +
sizeof(xGlyphElt))) {
elt = (xGlyphElt *) (stuff + 1);
origElt = *elt;
xSrc = stuff->xSrc;
ySrc = stuff->ySrc;
FOR_NSCREENS_FORWARD(j) {
stuff->src = src->info[j].id;
if (src->u.pict.root) {
stuff->xSrc = xSrc - screenInfo.screens[j]->x;
stuff->ySrc = ySrc - screenInfo.screens[j]->y;
}
stuff->dst = dst->info[j].id;
if (dst->u.pict.root) {
elt->deltax = origElt.deltax - screenInfo.screens[j]->x;
elt->deltay = origElt.deltay - screenInfo.screens[j]->y;
}
result =
(*PanoramiXSaveRenderVector[stuff->renderReqType]) (client);
if (result != Success)
break;
}
}
return result;
}
| Exec Code | 0 | PanoramiXRenderCompositeGlyphs(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderCompositeGlyphsReq);
xGlyphElt origElt, *elt;
INT16 xSrc, ySrc;
REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
if (client->req_len << 2 >= (sizeof(xRenderCompositeGlyphsReq) +
sizeof(xGlyphElt))) {
elt = (xGlyphElt *) (stuff + 1);
origElt = *elt;
xSrc = stuff->xSrc;
ySrc = stuff->ySrc;
FOR_NSCREENS_FORWARD(j) {
stuff->src = src->info[j].id;
if (src->u.pict.root) {
stuff->xSrc = xSrc - screenInfo.screens[j]->x;
stuff->ySrc = ySrc - screenInfo.screens[j]->y;
}
stuff->dst = dst->info[j].id;
if (dst->u.pict.root) {
elt->deltax = origElt.deltax - screenInfo.screens[j]->x;
elt->deltay = origElt.deltay - screenInfo.screens[j]->y;
}
result =
(*PanoramiXSaveRenderVector[stuff->renderReqType]) (client);
if (result != Success)
break;
}
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,068 | PanoramiXRenderCreateConicalGradient(ClientPtr client)
{
REQUEST(xRenderCreateConicalGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient])
(client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| Exec Code | 0 | PanoramiXRenderCreateConicalGradient(ClientPtr client)
{
REQUEST(xRenderCreateConicalGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateConicalGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateConicalGradient])
(client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,069 | PanoramiXRenderCreateLinearGradient(ClientPtr client)
{
REQUEST(xRenderCreateLinearGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| Exec Code | 0 | PanoramiXRenderCreateLinearGradient(ClientPtr client)
{
REQUEST(xRenderCreateLinearGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateLinearGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateLinearGradient]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,070 | PanoramiXRenderCreateRadialGradient(ClientPtr client)
{
REQUEST(xRenderCreateRadialGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| Exec Code | 0 | PanoramiXRenderCreateRadialGradient(ClientPtr client)
{
REQUEST(xRenderCreateRadialGradientReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderCreateRadialGradient]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,071 | PanoramiXRenderCreateSolidFill(ClientPtr client)
{
REQUEST(xRenderCreateSolidFillReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| Exec Code | 0 | PanoramiXRenderCreateSolidFill(ClientPtr client)
{
REQUEST(xRenderCreateSolidFillReq);
PanoramiXRes *newPict;
int result = Success, j;
REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
if (!(newPict = (PanoramiXRes *) malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPict->type = XRT_PICTURE;
panoramix_setup_ids(newPict, client, stuff->pid);
newPict->u.pict.root = FALSE;
FOR_NSCREENS_BACKWARD(j) {
stuff->pid = newPict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderCreateSolidFill]) (client);
if (result != Success)
break;
}
if (result == Success)
AddResource(newPict->info[0].id, XRT_PICTURE, newPict);
else
free(newPict);
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,072 | PanoramiXRenderFreePicture(ClientPtr client)
{
PanoramiXRes *pict;
int result = Success, j;
REQUEST(xRenderFreePictureReq);
REQUEST_SIZE_MATCH(xRenderFreePictureReq);
client->errorValue = stuff->picture;
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderFreePicture]) (client);
if (result != Success)
break;
}
/* Since ProcRenderFreePicture is using FreeResource, it will free
our resource for us on the last pass through the loop above */
return result;
}
| Exec Code | 0 | PanoramiXRenderFreePicture(ClientPtr client)
{
PanoramiXRes *pict;
int result = Success, j;
REQUEST(xRenderFreePictureReq);
REQUEST_SIZE_MATCH(xRenderFreePictureReq);
client->errorValue = stuff->picture;
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixDestroyAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderFreePicture]) (client);
if (result != Success)
break;
}
/* Since ProcRenderFreePicture is using FreeResource, it will free
our resource for us on the last pass through the loop above */
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,073 | PanoramiXRenderInit(void)
{
int i;
XRT_PICTURE = CreateNewResourceType(XineramaDeleteResource,
"XineramaPicture");
if (RenderErrBase)
SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
for (i = 0; i < RenderNumberRequests; i++)
PanoramiXSaveRenderVector[i] = ProcRenderVector[i];
/*
* Stuff in Xinerama aware request processing hooks
*/
ProcRenderVector[X_RenderCreatePicture] = PanoramiXRenderCreatePicture;
ProcRenderVector[X_RenderChangePicture] = PanoramiXRenderChangePicture;
ProcRenderVector[X_RenderSetPictureTransform] =
PanoramiXRenderSetPictureTransform;
ProcRenderVector[X_RenderSetPictureFilter] =
PanoramiXRenderSetPictureFilter;
ProcRenderVector[X_RenderSetPictureClipRectangles] =
PanoramiXRenderSetPictureClipRectangles;
ProcRenderVector[X_RenderFreePicture] = PanoramiXRenderFreePicture;
ProcRenderVector[X_RenderComposite] = PanoramiXRenderComposite;
ProcRenderVector[X_RenderCompositeGlyphs8] = PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs16] =
PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs32] =
PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderFillRectangles] = PanoramiXRenderFillRectangles;
ProcRenderVector[X_RenderTrapezoids] = PanoramiXRenderTrapezoids;
ProcRenderVector[X_RenderTriangles] = PanoramiXRenderTriangles;
ProcRenderVector[X_RenderTriStrip] = PanoramiXRenderTriStrip;
ProcRenderVector[X_RenderTriFan] = PanoramiXRenderTriFan;
ProcRenderVector[X_RenderAddTraps] = PanoramiXRenderAddTraps;
ProcRenderVector[X_RenderCreateSolidFill] = PanoramiXRenderCreateSolidFill;
ProcRenderVector[X_RenderCreateLinearGradient] =
PanoramiXRenderCreateLinearGradient;
ProcRenderVector[X_RenderCreateRadialGradient] =
PanoramiXRenderCreateRadialGradient;
ProcRenderVector[X_RenderCreateConicalGradient] =
PanoramiXRenderCreateConicalGradient;
}
| Exec Code | 0 | PanoramiXRenderInit(void)
{
int i;
XRT_PICTURE = CreateNewResourceType(XineramaDeleteResource,
"XineramaPicture");
if (RenderErrBase)
SetResourceTypeErrorValue(XRT_PICTURE, RenderErrBase + BadPicture);
for (i = 0; i < RenderNumberRequests; i++)
PanoramiXSaveRenderVector[i] = ProcRenderVector[i];
/*
* Stuff in Xinerama aware request processing hooks
*/
ProcRenderVector[X_RenderCreatePicture] = PanoramiXRenderCreatePicture;
ProcRenderVector[X_RenderChangePicture] = PanoramiXRenderChangePicture;
ProcRenderVector[X_RenderSetPictureTransform] =
PanoramiXRenderSetPictureTransform;
ProcRenderVector[X_RenderSetPictureFilter] =
PanoramiXRenderSetPictureFilter;
ProcRenderVector[X_RenderSetPictureClipRectangles] =
PanoramiXRenderSetPictureClipRectangles;
ProcRenderVector[X_RenderFreePicture] = PanoramiXRenderFreePicture;
ProcRenderVector[X_RenderComposite] = PanoramiXRenderComposite;
ProcRenderVector[X_RenderCompositeGlyphs8] = PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs16] =
PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderCompositeGlyphs32] =
PanoramiXRenderCompositeGlyphs;
ProcRenderVector[X_RenderFillRectangles] = PanoramiXRenderFillRectangles;
ProcRenderVector[X_RenderTrapezoids] = PanoramiXRenderTrapezoids;
ProcRenderVector[X_RenderTriangles] = PanoramiXRenderTriangles;
ProcRenderVector[X_RenderTriStrip] = PanoramiXRenderTriStrip;
ProcRenderVector[X_RenderTriFan] = PanoramiXRenderTriFan;
ProcRenderVector[X_RenderAddTraps] = PanoramiXRenderAddTraps;
ProcRenderVector[X_RenderCreateSolidFill] = PanoramiXRenderCreateSolidFill;
ProcRenderVector[X_RenderCreateLinearGradient] =
PanoramiXRenderCreateLinearGradient;
ProcRenderVector[X_RenderCreateRadialGradient] =
PanoramiXRenderCreateRadialGradient;
ProcRenderVector[X_RenderCreateConicalGradient] =
PanoramiXRenderCreateConicalGradient;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,074 | PanoramiXRenderReset(void)
{
int i;
for (i = 0; i < RenderNumberRequests; i++)
ProcRenderVector[i] = PanoramiXSaveRenderVector[i];
RenderErrBase = 0;
}
| Exec Code | 0 | PanoramiXRenderReset(void)
{
int i;
for (i = 0; i < RenderNumberRequests; i++)
ProcRenderVector[i] = PanoramiXSaveRenderVector[i];
RenderErrBase = 0;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,075 | PanoramiXRenderSetPictureClipRectangles(ClientPtr client)
{
REQUEST(xRenderSetPictureClipRectanglesReq);
int result = Success, j;
PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles])
(client);
if (result != Success)
break;
}
return result;
}
| Exec Code | 0 | PanoramiXRenderSetPictureClipRectangles(ClientPtr client)
{
REQUEST(xRenderSetPictureClipRectanglesReq);
int result = Success, j;
PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureClipRectanglesReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderSetPictureClipRectangles])
(client);
if (result != Success)
break;
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,076 | PanoramiXRenderSetPictureTransform(ClientPtr client)
{
REQUEST(xRenderSetPictureTransformReq);
int result = Success, j;
PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderSetPictureTransform]) (client);
if (result != Success)
break;
}
return result;
}
| Exec Code | 0 | PanoramiXRenderSetPictureTransform(ClientPtr client)
{
REQUEST(xRenderSetPictureTransformReq);
int result = Success, j;
PanoramiXRes *pict;
REQUEST_AT_LEAST_SIZE(xRenderSetPictureTransformReq);
VERIFY_XIN_PICTURE(pict, stuff->picture, client, DixWriteAccess);
FOR_NSCREENS_BACKWARD(j) {
stuff->picture = pict->info[j].id;
result =
(*PanoramiXSaveRenderVector[X_RenderSetPictureTransform]) (client);
if (result != Success)
break;
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,077 | PanoramiXRenderTrapezoids(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTrapezoidsReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xTrapezoid *trap = (xTrapezoid *) (stuff + 1);
int i = extra_len / sizeof(xTrapezoid);
while (i--) {
trap->top -= y_off;
trap->bottom -= y_off;
trap->left.p1.x -= x_off;
trap->left.p1.y -= y_off;
trap->left.p2.x -= x_off;
trap->left.p2.y -= y_off;
trap->right.p1.x -= x_off;
trap->right.p1.y -= y_off;
trap->right.p2.x -= x_off;
trap->right.p2.y -= y_off;
trap++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTrapezoids]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| Exec Code | 0 | PanoramiXRenderTrapezoids(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTrapezoidsReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTrapezoidsReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTrapezoidsReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xTrapezoid *trap = (xTrapezoid *) (stuff + 1);
int i = extra_len / sizeof(xTrapezoid);
while (i--) {
trap->top -= y_off;
trap->bottom -= y_off;
trap->left.p1.x -= x_off;
trap->left.p1.y -= y_off;
trap->left.p2.x -= x_off;
trap->left.p2.y -= y_off;
trap->right.p1.x -= x_off;
trap->right.p1.y -= y_off;
trap->right.p2.x -= x_off;
trap->right.p2.y -= y_off;
trap++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTrapezoids]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,078 | PanoramiXRenderTriFan(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTriFanReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTriFanReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTriFanReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
int i = extra_len / sizeof(xPointFixed);
while (i--) {
fixed->x -= x_off;
fixed->y -= y_off;
fixed++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriFan]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| Exec Code | 0 | PanoramiXRenderTriFan(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTriFanReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTriFanReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTriFanReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
int i = extra_len / sizeof(xPointFixed);
while (i--) {
fixed->x -= x_off;
fixed->y -= y_off;
fixed++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriFan]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,079 | PanoramiXRenderTriStrip(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTriStripReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTriStripReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTriStripReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
int i = extra_len / sizeof(xPointFixed);
while (i--) {
fixed->x -= x_off;
fixed->y -= y_off;
fixed++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriStrip]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| Exec Code | 0 | PanoramiXRenderTriStrip(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTriStripReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTriStripReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTriStripReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xPointFixed *fixed = (xPointFixed *) (stuff + 1);
int i = extra_len / sizeof(xPointFixed);
while (i--) {
fixed->x -= x_off;
fixed->y -= y_off;
fixed++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriStrip]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,080 | PanoramiXRenderTriangles(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTrianglesReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTrianglesReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xTriangle *tri = (xTriangle *) (stuff + 1);
int i = extra_len / sizeof(xTriangle);
while (i--) {
tri->p1.x -= x_off;
tri->p1.y -= y_off;
tri->p2.x -= x_off;
tri->p2.y -= y_off;
tri->p3.x -= x_off;
tri->p3.y -= y_off;
tri++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriangles]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| Exec Code | 0 | PanoramiXRenderTriangles(ClientPtr client)
{
PanoramiXRes *src, *dst;
int result = Success, j;
REQUEST(xRenderTrianglesReq);
char *extra;
int extra_len;
REQUEST_AT_LEAST_SIZE(xRenderTrianglesReq);
VERIFY_XIN_PICTURE(src, stuff->src, client, DixReadAccess);
VERIFY_XIN_PICTURE(dst, stuff->dst, client, DixWriteAccess);
extra_len = (client->req_len << 2) - sizeof(xRenderTrianglesReq);
if (extra_len && (extra = (char *) malloc(extra_len))) {
memcpy(extra, stuff + 1, extra_len);
FOR_NSCREENS_FORWARD(j) {
if (j)
memcpy(stuff + 1, extra, extra_len);
if (dst->u.pict.root) {
int x_off = screenInfo.screens[j]->x;
int y_off = screenInfo.screens[j]->y;
if (x_off || y_off) {
xTriangle *tri = (xTriangle *) (stuff + 1);
int i = extra_len / sizeof(xTriangle);
while (i--) {
tri->p1.x -= x_off;
tri->p1.y -= y_off;
tri->p2.x -= x_off;
tri->p2.y -= y_off;
tri->p3.x -= x_off;
tri->p3.y -= y_off;
tri++;
}
}
}
stuff->src = src->info[j].id;
stuff->dst = dst->info[j].id;
result = (*PanoramiXSaveRenderVector[X_RenderTriangles]) (client);
if (result != Success)
break;
}
free(extra);
}
return result;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,081 | ProcRenderAddGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderAddGlyphsReq);
GlyphNewRec glyphsLocal[NLOCALGLYPH];
GlyphNewPtr glyphsBase, glyphs, glyph_new;
int remain, nglyphs;
CARD32 *gids;
xGlyphInfo *gi;
CARD8 *bits;
unsigned int size;
int err;
int i, screen;
PicturePtr pSrc = NULL, pDst = NULL;
PixmapPtr pSrcPix = NULL, pDstPix = NULL;
CARD32 component_alpha;
REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq);
err =
dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixAddAccess);
if (err != Success) {
client->errorValue = stuff->glyphset;
return err;
}
err = BadAlloc;
nglyphs = stuff->nglyphs;
if (nglyphs > UINT32_MAX / sizeof(GlyphNewRec))
return BadAlloc;
component_alpha = NeedsComponent(glyphSet->format->format);
if (nglyphs <= NLOCALGLYPH) {
memset(glyphsLocal, 0, sizeof(glyphsLocal));
glyphsBase = glyphsLocal;
}
else {
glyphsBase = (GlyphNewPtr) calloc(nglyphs, sizeof(GlyphNewRec));
if (!glyphsBase)
return BadAlloc;
}
remain = (client->req_len << 2) - sizeof(xRenderAddGlyphsReq);
glyphs = glyphsBase;
gids = (CARD32 *) (stuff + 1);
gi = (xGlyphInfo *) (gids + nglyphs);
bits = (CARD8 *) (gi + nglyphs);
remain -= (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs;
/* protect against bad nglyphs */
if (gi < ((xGlyphInfo *) stuff) ||
gi > ((xGlyphInfo *) ((CARD32 *) stuff + client->req_len)) ||
bits < ((CARD8 *) stuff) ||
bits > ((CARD8 *) ((CARD32 *) stuff + client->req_len))) {
err = BadLength;
goto bail;
}
for (i = 0; i < nglyphs; i++) {
size_t padded_width;
glyph_new = &glyphs[i];
padded_width = PixmapBytePad(gi[i].width, glyphSet->format->depth);
if (gi[i].height &&
padded_width > (UINT32_MAX - sizeof(GlyphRec)) / gi[i].height)
break;
size = gi[i].height * padded_width;
if (remain < size)
break;
err = HashGlyph(&gi[i], bits, size, glyph_new->sha1);
if (err)
goto bail;
glyph_new->glyph = FindGlyphByHash(glyph_new->sha1, glyphSet->fdepth);
if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph) {
glyph_new->found = TRUE;
}
else {
GlyphPtr glyph;
glyph_new->found = FALSE;
glyph_new->glyph = glyph = AllocateGlyph(&gi[i], glyphSet->fdepth);
if (!glyph) {
err = BadAlloc;
goto bail;
}
for (screen = 0; screen < screenInfo.numScreens; screen++) {
int width = gi[i].width;
int height = gi[i].height;
int depth = glyphSet->format->depth;
ScreenPtr pScreen;
int error;
/* Skip work if it's invisibly small anyway */
if (!width || !height)
break;
pScreen = screenInfo.screens[screen];
pSrcPix = GetScratchPixmapHeader(pScreen,
width, height,
depth, depth, -1, bits);
if (!pSrcPix) {
err = BadAlloc;
goto bail;
}
pSrc = CreatePicture(0, &pSrcPix->drawable,
glyphSet->format, 0, NULL,
serverClient, &error);
if (!pSrc) {
err = BadAlloc;
goto bail;
}
pDstPix = (pScreen->CreatePixmap) (pScreen,
width, height, depth,
CREATE_PIXMAP_USAGE_GLYPH_PICTURE);
if (!pDstPix) {
err = BadAlloc;
goto bail;
}
pDst = CreatePicture(0, &pDstPix->drawable,
glyphSet->format,
CPComponentAlpha, &component_alpha,
serverClient, &error);
SetGlyphPicture(glyph, pScreen, pDst);
/* The picture takes a reference to the pixmap, so we
drop ours. */
(pScreen->DestroyPixmap) (pDstPix);
pDstPix = NULL;
if (!pDst) {
err = BadAlloc;
goto bail;
}
CompositePicture(PictOpSrc,
pSrc,
None, pDst, 0, 0, 0, 0, 0, 0, width, height);
FreePicture((void *) pSrc, 0);
pSrc = NULL;
FreeScratchPixmapHeader(pSrcPix);
pSrcPix = NULL;
}
memcpy(glyph_new->glyph->sha1, glyph_new->sha1, 20);
}
glyph_new->id = gids[i];
if (size & 3)
size += 4 - (size & 3);
bits += size;
remain -= size;
}
if (remain || i < nglyphs) {
err = BadLength;
goto bail;
}
if (!ResizeGlyphSet(glyphSet, nglyphs)) {
err = BadAlloc;
goto bail;
}
for (i = 0; i < nglyphs; i++)
AddGlyph(glyphSet, glyphs[i].glyph, glyphs[i].id);
if (glyphsBase != glyphsLocal)
free(glyphsBase);
return Success;
bail:
if (pSrc)
FreePicture((void *) pSrc, 0);
if (pSrcPix)
FreeScratchPixmapHeader(pSrcPix);
for (i = 0; i < nglyphs; i++)
if (glyphs[i].glyph && !glyphs[i].found)
free(glyphs[i].glyph);
if (glyphsBase != glyphsLocal)
free(glyphsBase);
return err;
}
| Exec Code | 0 | ProcRenderAddGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
REQUEST(xRenderAddGlyphsReq);
GlyphNewRec glyphsLocal[NLOCALGLYPH];
GlyphNewPtr glyphsBase, glyphs, glyph_new;
int remain, nglyphs;
CARD32 *gids;
xGlyphInfo *gi;
CARD8 *bits;
unsigned int size;
int err;
int i, screen;
PicturePtr pSrc = NULL, pDst = NULL;
PixmapPtr pSrcPix = NULL, pDstPix = NULL;
CARD32 component_alpha;
REQUEST_AT_LEAST_SIZE(xRenderAddGlyphsReq);
err =
dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixAddAccess);
if (err != Success) {
client->errorValue = stuff->glyphset;
return err;
}
err = BadAlloc;
nglyphs = stuff->nglyphs;
if (nglyphs > UINT32_MAX / sizeof(GlyphNewRec))
return BadAlloc;
component_alpha = NeedsComponent(glyphSet->format->format);
if (nglyphs <= NLOCALGLYPH) {
memset(glyphsLocal, 0, sizeof(glyphsLocal));
glyphsBase = glyphsLocal;
}
else {
glyphsBase = (GlyphNewPtr) calloc(nglyphs, sizeof(GlyphNewRec));
if (!glyphsBase)
return BadAlloc;
}
remain = (client->req_len << 2) - sizeof(xRenderAddGlyphsReq);
glyphs = glyphsBase;
gids = (CARD32 *) (stuff + 1);
gi = (xGlyphInfo *) (gids + nglyphs);
bits = (CARD8 *) (gi + nglyphs);
remain -= (sizeof(CARD32) + sizeof(xGlyphInfo)) * nglyphs;
/* protect against bad nglyphs */
if (gi < ((xGlyphInfo *) stuff) ||
gi > ((xGlyphInfo *) ((CARD32 *) stuff + client->req_len)) ||
bits < ((CARD8 *) stuff) ||
bits > ((CARD8 *) ((CARD32 *) stuff + client->req_len))) {
err = BadLength;
goto bail;
}
for (i = 0; i < nglyphs; i++) {
size_t padded_width;
glyph_new = &glyphs[i];
padded_width = PixmapBytePad(gi[i].width, glyphSet->format->depth);
if (gi[i].height &&
padded_width > (UINT32_MAX - sizeof(GlyphRec)) / gi[i].height)
break;
size = gi[i].height * padded_width;
if (remain < size)
break;
err = HashGlyph(&gi[i], bits, size, glyph_new->sha1);
if (err)
goto bail;
glyph_new->glyph = FindGlyphByHash(glyph_new->sha1, glyphSet->fdepth);
if (glyph_new->glyph && glyph_new->glyph != DeletedGlyph) {
glyph_new->found = TRUE;
}
else {
GlyphPtr glyph;
glyph_new->found = FALSE;
glyph_new->glyph = glyph = AllocateGlyph(&gi[i], glyphSet->fdepth);
if (!glyph) {
err = BadAlloc;
goto bail;
}
for (screen = 0; screen < screenInfo.numScreens; screen++) {
int width = gi[i].width;
int height = gi[i].height;
int depth = glyphSet->format->depth;
ScreenPtr pScreen;
int error;
/* Skip work if it's invisibly small anyway */
if (!width || !height)
break;
pScreen = screenInfo.screens[screen];
pSrcPix = GetScratchPixmapHeader(pScreen,
width, height,
depth, depth, -1, bits);
if (!pSrcPix) {
err = BadAlloc;
goto bail;
}
pSrc = CreatePicture(0, &pSrcPix->drawable,
glyphSet->format, 0, NULL,
serverClient, &error);
if (!pSrc) {
err = BadAlloc;
goto bail;
}
pDstPix = (pScreen->CreatePixmap) (pScreen,
width, height, depth,
CREATE_PIXMAP_USAGE_GLYPH_PICTURE);
if (!pDstPix) {
err = BadAlloc;
goto bail;
}
pDst = CreatePicture(0, &pDstPix->drawable,
glyphSet->format,
CPComponentAlpha, &component_alpha,
serverClient, &error);
SetGlyphPicture(glyph, pScreen, pDst);
/* The picture takes a reference to the pixmap, so we
drop ours. */
(pScreen->DestroyPixmap) (pDstPix);
pDstPix = NULL;
if (!pDst) {
err = BadAlloc;
goto bail;
}
CompositePicture(PictOpSrc,
pSrc,
None, pDst, 0, 0, 0, 0, 0, 0, width, height);
FreePicture((void *) pSrc, 0);
pSrc = NULL;
FreeScratchPixmapHeader(pSrcPix);
pSrcPix = NULL;
}
memcpy(glyph_new->glyph->sha1, glyph_new->sha1, 20);
}
glyph_new->id = gids[i];
if (size & 3)
size += 4 - (size & 3);
bits += size;
remain -= size;
}
if (remain || i < nglyphs) {
err = BadLength;
goto bail;
}
if (!ResizeGlyphSet(glyphSet, nglyphs)) {
err = BadAlloc;
goto bail;
}
for (i = 0; i < nglyphs; i++)
AddGlyph(glyphSet, glyphs[i].glyph, glyphs[i].id);
if (glyphsBase != glyphsLocal)
free(glyphsBase);
return Success;
bail:
if (pSrc)
FreePicture((void *) pSrc, 0);
if (pSrcPix)
FreeScratchPixmapHeader(pSrcPix);
for (i = 0; i < nglyphs; i++)
if (glyphs[i].glyph && !glyphs[i].found)
free(glyphs[i].glyph);
if (glyphsBase != glyphsLocal)
free(glyphsBase);
return err;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,082 | ProcRenderAddGlyphsFromPicture(ClientPtr client)
{
return BadImplementation;
}
| Exec Code | 0 | ProcRenderAddGlyphsFromPicture(ClientPtr client)
{
return BadImplementation;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,083 | ProcRenderAddTraps(ClientPtr client)
{
int ntraps;
PicturePtr pPicture;
REQUEST(xRenderAddTrapsReq);
REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess);
if (!pPicture->pDrawable)
return BadDrawable;
ntraps = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
if (ntraps % sizeof(xTrap))
return BadLength;
ntraps /= sizeof(xTrap);
if (ntraps)
AddTraps(pPicture,
stuff->xOff, stuff->yOff, ntraps, (xTrap *) &stuff[1]);
return Success;
}
| Exec Code | 0 | ProcRenderAddTraps(ClientPtr client)
{
int ntraps;
PicturePtr pPicture;
REQUEST(xRenderAddTrapsReq);
REQUEST_AT_LEAST_SIZE(xRenderAddTrapsReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixWriteAccess);
if (!pPicture->pDrawable)
return BadDrawable;
ntraps = (client->req_len << 2) - sizeof(xRenderAddTrapsReq);
if (ntraps % sizeof(xTrap))
return BadLength;
ntraps /= sizeof(xTrap);
if (ntraps)
AddTraps(pPicture,
stuff->xOff, stuff->yOff, ntraps, (xTrap *) &stuff[1]);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,084 | ProcRenderChangePicture(ClientPtr client)
{
PicturePtr pPicture;
REQUEST(xRenderChangePictureReq);
int len;
REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
len = client->req_len - bytes_to_int32(sizeof(xRenderChangePictureReq));
if (Ones(stuff->mask) != len)
return BadLength;
return ChangePicture(pPicture, stuff->mask, (XID *) (stuff + 1),
(DevUnion *) 0, client);
}
| Exec Code | 0 | ProcRenderChangePicture(ClientPtr client)
{
PicturePtr pPicture;
REQUEST(xRenderChangePictureReq);
int len;
REQUEST_AT_LEAST_SIZE(xRenderChangePictureReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
len = client->req_len - bytes_to_int32(sizeof(xRenderChangePictureReq));
if (Ones(stuff->mask) != len)
return BadLength;
return ChangePicture(pPicture, stuff->mask, (XID *) (stuff + 1),
(DevUnion *) 0, client);
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,085 | ProcRenderColorTrapezoids(ClientPtr client)
{
return BadImplementation;
}
| Exec Code | 0 | ProcRenderColorTrapezoids(ClientPtr client)
{
return BadImplementation;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,086 | ProcRenderColorTriangles(ClientPtr client)
{
return BadImplementation;
}
| Exec Code | 0 | ProcRenderColorTriangles(ClientPtr client)
{
return BadImplementation;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,087 | ProcRenderCompositeGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
GlyphSet gs;
PicturePtr pSrc, pDst;
PictFormatPtr pFormat;
GlyphListRec listsLocal[NLOCALDELTA];
GlyphListPtr lists, listsBase;
GlyphPtr glyphsLocal[NLOCALGLYPH];
Glyph glyph;
GlyphPtr *glyphs, *glyphsBase;
xGlyphElt *elt;
CARD8 *buffer, *end;
int nglyph;
int nlist;
int space;
int size;
int rc, n;
REQUEST(xRenderCompositeGlyphsReq);
REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
switch (stuff->renderReqType) {
default:
size = 1;
break;
case X_RenderCompositeGlyphs16:
size = 2;
break;
case X_RenderCompositeGlyphs32:
size = 4;
break;
}
if (!PictOpValid(stuff->op)) {
client->errorValue = stuff->op;
return BadValue;
}
VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
if (!pDst->pDrawable)
return BadDrawable;
if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
return BadMatch;
if (stuff->maskFormat) {
rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat,
PictFormatType, client, DixReadAccess);
if (rc != Success)
return rc;
}
else
pFormat = 0;
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixUseAccess);
if (rc != Success)
return rc;
buffer = (CARD8 *) (stuff + 1);
end = (CARD8 *) stuff + (client->req_len << 2);
nglyph = 0;
nlist = 0;
while (buffer + sizeof(xGlyphElt) < end) {
elt = (xGlyphElt *) buffer;
buffer += sizeof(xGlyphElt);
if (elt->len == 0xff) {
buffer += 4;
}
else {
nlist++;
nglyph += elt->len;
space = size * elt->len;
if (space & 3)
space += 4 - (space & 3);
buffer += space;
}
}
if (nglyph <= NLOCALGLYPH)
glyphsBase = glyphsLocal;
else {
glyphsBase = xallocarray(nglyph, sizeof(GlyphPtr));
if (!glyphsBase)
return BadAlloc;
}
if (nlist <= NLOCALDELTA)
listsBase = listsLocal;
else {
listsBase = xallocarray(nlist, sizeof(GlyphListRec));
if (!listsBase) {
rc = BadAlloc;
goto bail;
}
}
buffer = (CARD8 *) (stuff + 1);
glyphs = glyphsBase;
lists = listsBase;
while (buffer + sizeof(xGlyphElt) < end) {
elt = (xGlyphElt *) buffer;
buffer += sizeof(xGlyphElt);
if (elt->len == 0xff) {
if (buffer + sizeof(GlyphSet) < end) {
memcpy(&gs, buffer, sizeof(GlyphSet));
rc = dixLookupResourceByType((void **) &glyphSet, gs,
GlyphSetType, client,
DixUseAccess);
if (rc != Success)
goto bail;
}
buffer += 4;
}
else {
lists->xOff = elt->deltax;
lists->yOff = elt->deltay;
lists->format = glyphSet->format;
lists->len = 0;
n = elt->len;
while (n--) {
if (buffer + size <= end) {
switch (size) {
case 1:
glyph = *((CARD8 *) buffer);
break;
case 2:
glyph = *((CARD16 *) buffer);
break;
case 4:
default:
glyph = *((CARD32 *) buffer);
break;
}
if ((*glyphs = FindGlyph(glyphSet, glyph))) {
lists->len++;
glyphs++;
}
}
buffer += size;
}
space = size * elt->len;
if (space & 3)
buffer += 4 - (space & 3);
lists++;
}
}
if (buffer > end) {
rc = BadLength;
goto bail;
}
CompositeGlyphs(stuff->op,
pSrc,
pDst,
pFormat,
stuff->xSrc, stuff->ySrc, nlist, listsBase, glyphsBase);
rc = Success;
bail:
if (glyphsBase != glyphsLocal)
free(glyphsBase);
if (listsBase != listsLocal)
free(listsBase);
return rc;
}
| Exec Code | 0 | ProcRenderCompositeGlyphs(ClientPtr client)
{
GlyphSetPtr glyphSet;
GlyphSet gs;
PicturePtr pSrc, pDst;
PictFormatPtr pFormat;
GlyphListRec listsLocal[NLOCALDELTA];
GlyphListPtr lists, listsBase;
GlyphPtr glyphsLocal[NLOCALGLYPH];
Glyph glyph;
GlyphPtr *glyphs, *glyphsBase;
xGlyphElt *elt;
CARD8 *buffer, *end;
int nglyph;
int nlist;
int space;
int size;
int rc, n;
REQUEST(xRenderCompositeGlyphsReq);
REQUEST_AT_LEAST_SIZE(xRenderCompositeGlyphsReq);
switch (stuff->renderReqType) {
default:
size = 1;
break;
case X_RenderCompositeGlyphs16:
size = 2;
break;
case X_RenderCompositeGlyphs32:
size = 4;
break;
}
if (!PictOpValid(stuff->op)) {
client->errorValue = stuff->op;
return BadValue;
}
VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
if (!pDst->pDrawable)
return BadDrawable;
if (pSrc->pDrawable && pSrc->pDrawable->pScreen != pDst->pDrawable->pScreen)
return BadMatch;
if (stuff->maskFormat) {
rc = dixLookupResourceByType((void **) &pFormat, stuff->maskFormat,
PictFormatType, client, DixReadAccess);
if (rc != Success)
return rc;
}
else
pFormat = 0;
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixUseAccess);
if (rc != Success)
return rc;
buffer = (CARD8 *) (stuff + 1);
end = (CARD8 *) stuff + (client->req_len << 2);
nglyph = 0;
nlist = 0;
while (buffer + sizeof(xGlyphElt) < end) {
elt = (xGlyphElt *) buffer;
buffer += sizeof(xGlyphElt);
if (elt->len == 0xff) {
buffer += 4;
}
else {
nlist++;
nglyph += elt->len;
space = size * elt->len;
if (space & 3)
space += 4 - (space & 3);
buffer += space;
}
}
if (nglyph <= NLOCALGLYPH)
glyphsBase = glyphsLocal;
else {
glyphsBase = xallocarray(nglyph, sizeof(GlyphPtr));
if (!glyphsBase)
return BadAlloc;
}
if (nlist <= NLOCALDELTA)
listsBase = listsLocal;
else {
listsBase = xallocarray(nlist, sizeof(GlyphListRec));
if (!listsBase) {
rc = BadAlloc;
goto bail;
}
}
buffer = (CARD8 *) (stuff + 1);
glyphs = glyphsBase;
lists = listsBase;
while (buffer + sizeof(xGlyphElt) < end) {
elt = (xGlyphElt *) buffer;
buffer += sizeof(xGlyphElt);
if (elt->len == 0xff) {
if (buffer + sizeof(GlyphSet) < end) {
memcpy(&gs, buffer, sizeof(GlyphSet));
rc = dixLookupResourceByType((void **) &glyphSet, gs,
GlyphSetType, client,
DixUseAccess);
if (rc != Success)
goto bail;
}
buffer += 4;
}
else {
lists->xOff = elt->deltax;
lists->yOff = elt->deltay;
lists->format = glyphSet->format;
lists->len = 0;
n = elt->len;
while (n--) {
if (buffer + size <= end) {
switch (size) {
case 1:
glyph = *((CARD8 *) buffer);
break;
case 2:
glyph = *((CARD16 *) buffer);
break;
case 4:
default:
glyph = *((CARD32 *) buffer);
break;
}
if ((*glyphs = FindGlyph(glyphSet, glyph))) {
lists->len++;
glyphs++;
}
}
buffer += size;
}
space = size * elt->len;
if (space & 3)
buffer += 4 - (space & 3);
lists++;
}
}
if (buffer > end) {
rc = BadLength;
goto bail;
}
CompositeGlyphs(stuff->op,
pSrc,
pDst,
pFormat,
stuff->xSrc, stuff->ySrc, nlist, listsBase, glyphsBase);
rc = Success;
bail:
if (glyphsBase != glyphsLocal)
free(glyphsBase);
if (listsBase != listsLocal)
free(listsBase);
return rc;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,088 | ProcRenderCreateCursor(ClientPtr client)
{
REQUEST(xRenderCreateCursorReq);
PicturePtr pSrc;
ScreenPtr pScreen;
unsigned short width, height;
CARD32 *argbbits, *argb;
unsigned char *srcbits, *srcline;
unsigned char *mskbits, *mskline;
int stride;
int x, y;
int nbytes_mono;
CursorMetricRec cm;
CursorPtr pCursor;
CARD32 twocolor[3];
int rc, ncolor;
REQUEST_SIZE_MATCH(xRenderCreateCursorReq);
LEGAL_NEW_RESOURCE(stuff->cid, client);
VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
if (!pSrc->pDrawable)
return BadDrawable;
pScreen = pSrc->pDrawable->pScreen;
width = pSrc->pDrawable->width;
height = pSrc->pDrawable->height;
if (height && width > UINT32_MAX / (height * sizeof(CARD32)))
return BadAlloc;
if (stuff->x > width || stuff->y > height)
return BadMatch;
argbbits = malloc(width * height * sizeof(CARD32));
if (!argbbits)
return BadAlloc;
stride = BitmapBytePad(width);
nbytes_mono = stride * height;
srcbits = calloc(1, nbytes_mono);
if (!srcbits) {
free(argbbits);
return BadAlloc;
}
mskbits = calloc(1, nbytes_mono);
if (!mskbits) {
free(argbbits);
free(srcbits);
return BadAlloc;
}
if (pSrc->format == PICT_a8r8g8b8) {
(*pScreen->GetImage) (pSrc->pDrawable,
0, 0, width, height, ZPixmap,
0xffffffff, (void *) argbbits);
}
else {
PixmapPtr pPixmap;
PicturePtr pPicture;
PictFormatPtr pFormat;
int error;
pFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
if (!pFormat) {
free(argbbits);
free(srcbits);
free(mskbits);
return BadImplementation;
}
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap) {
free(argbbits);
free(srcbits);
free(mskbits);
return BadAlloc;
}
pPicture = CreatePicture(0, &pPixmap->drawable, pFormat, 0, 0,
client, &error);
if (!pPicture) {
free(argbbits);
free(srcbits);
free(mskbits);
return error;
}
(*pScreen->DestroyPixmap) (pPixmap);
CompositePicture(PictOpSrc,
pSrc, 0, pPicture, 0, 0, 0, 0, 0, 0, width, height);
(*pScreen->GetImage) (pPicture->pDrawable,
0, 0, width, height, ZPixmap,
0xffffffff, (void *) argbbits);
FreePicture(pPicture, 0);
}
/*
* Check whether the cursor can be directly supported by
* the core cursor code
*/
ncolor = 0;
argb = argbbits;
for (y = 0; ncolor <= 2 && y < height; y++) {
for (x = 0; ncolor <= 2 && x < width; x++) {
CARD32 p = *argb++;
CARD32 a = (p >> 24);
if (a == 0) /* transparent */
continue;
if (a == 0xff) { /* opaque */
int n;
for (n = 0; n < ncolor; n++)
if (p == twocolor[n])
break;
if (n == ncolor)
twocolor[ncolor++] = p;
}
else
ncolor = 3;
}
}
/*
* Convert argb image to two plane cursor
*/
srcline = srcbits;
mskline = mskbits;
argb = argbbits;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
CARD32 p = *argb++;
if (ncolor <= 2) {
CARD32 a = ((p >> 24));
RenderSetBit(mskline, x, a != 0);
RenderSetBit(srcline, x, a != 0 && p == twocolor[0]);
}
else {
CARD32 a = ((p >> 24) * DITHER_SIZE + 127) / 255;
CARD32 i = ((CvtR8G8B8toY15(p) >> 7) * DITHER_SIZE + 127) / 255;
CARD32 d =
orderedDither[y & (DITHER_DIM - 1)][x & (DITHER_DIM - 1)];
/* Set mask from dithered alpha value */
RenderSetBit(mskline, x, a > d);
/* Set src from dithered intensity value */
RenderSetBit(srcline, x, a > d && i <= d);
}
}
srcline += stride;
mskline += stride;
}
/*
* Dither to white and black if the cursor has more than two colors
*/
if (ncolor > 2) {
twocolor[0] = 0xff000000;
twocolor[1] = 0xffffffff;
}
else {
free(argbbits);
argbbits = 0;
}
#define GetByte(p,s) (((p) >> (s)) & 0xff)
#define GetColor(p,s) (GetByte(p,s) | (GetByte(p,s) << 8))
cm.width = width;
cm.height = height;
cm.xhot = stuff->x;
cm.yhot = stuff->y;
rc = AllocARGBCursor(srcbits, mskbits, argbbits, &cm,
GetColor(twocolor[0], 16),
GetColor(twocolor[0], 8),
GetColor(twocolor[0], 0),
GetColor(twocolor[1], 16),
GetColor(twocolor[1], 8),
GetColor(twocolor[1], 0),
&pCursor, client, stuff->cid);
if (rc != Success)
goto bail;
if (!AddResource(stuff->cid, RT_CURSOR, (void *) pCursor)) {
rc = BadAlloc;
goto bail;
}
return Success;
bail:
free(srcbits);
free(mskbits);
return rc;
}
| Exec Code | 0 | ProcRenderCreateCursor(ClientPtr client)
{
REQUEST(xRenderCreateCursorReq);
PicturePtr pSrc;
ScreenPtr pScreen;
unsigned short width, height;
CARD32 *argbbits, *argb;
unsigned char *srcbits, *srcline;
unsigned char *mskbits, *mskline;
int stride;
int x, y;
int nbytes_mono;
CursorMetricRec cm;
CursorPtr pCursor;
CARD32 twocolor[3];
int rc, ncolor;
REQUEST_SIZE_MATCH(xRenderCreateCursorReq);
LEGAL_NEW_RESOURCE(stuff->cid, client);
VERIFY_PICTURE(pSrc, stuff->src, client, DixReadAccess);
if (!pSrc->pDrawable)
return BadDrawable;
pScreen = pSrc->pDrawable->pScreen;
width = pSrc->pDrawable->width;
height = pSrc->pDrawable->height;
if (height && width > UINT32_MAX / (height * sizeof(CARD32)))
return BadAlloc;
if (stuff->x > width || stuff->y > height)
return BadMatch;
argbbits = malloc(width * height * sizeof(CARD32));
if (!argbbits)
return BadAlloc;
stride = BitmapBytePad(width);
nbytes_mono = stride * height;
srcbits = calloc(1, nbytes_mono);
if (!srcbits) {
free(argbbits);
return BadAlloc;
}
mskbits = calloc(1, nbytes_mono);
if (!mskbits) {
free(argbbits);
free(srcbits);
return BadAlloc;
}
if (pSrc->format == PICT_a8r8g8b8) {
(*pScreen->GetImage) (pSrc->pDrawable,
0, 0, width, height, ZPixmap,
0xffffffff, (void *) argbbits);
}
else {
PixmapPtr pPixmap;
PicturePtr pPicture;
PictFormatPtr pFormat;
int error;
pFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
if (!pFormat) {
free(argbbits);
free(srcbits);
free(mskbits);
return BadImplementation;
}
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, 32,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap) {
free(argbbits);
free(srcbits);
free(mskbits);
return BadAlloc;
}
pPicture = CreatePicture(0, &pPixmap->drawable, pFormat, 0, 0,
client, &error);
if (!pPicture) {
free(argbbits);
free(srcbits);
free(mskbits);
return error;
}
(*pScreen->DestroyPixmap) (pPixmap);
CompositePicture(PictOpSrc,
pSrc, 0, pPicture, 0, 0, 0, 0, 0, 0, width, height);
(*pScreen->GetImage) (pPicture->pDrawable,
0, 0, width, height, ZPixmap,
0xffffffff, (void *) argbbits);
FreePicture(pPicture, 0);
}
/*
* Check whether the cursor can be directly supported by
* the core cursor code
*/
ncolor = 0;
argb = argbbits;
for (y = 0; ncolor <= 2 && y < height; y++) {
for (x = 0; ncolor <= 2 && x < width; x++) {
CARD32 p = *argb++;
CARD32 a = (p >> 24);
if (a == 0) /* transparent */
continue;
if (a == 0xff) { /* opaque */
int n;
for (n = 0; n < ncolor; n++)
if (p == twocolor[n])
break;
if (n == ncolor)
twocolor[ncolor++] = p;
}
else
ncolor = 3;
}
}
/*
* Convert argb image to two plane cursor
*/
srcline = srcbits;
mskline = mskbits;
argb = argbbits;
for (y = 0; y < height; y++) {
for (x = 0; x < width; x++) {
CARD32 p = *argb++;
if (ncolor <= 2) {
CARD32 a = ((p >> 24));
RenderSetBit(mskline, x, a != 0);
RenderSetBit(srcline, x, a != 0 && p == twocolor[0]);
}
else {
CARD32 a = ((p >> 24) * DITHER_SIZE + 127) / 255;
CARD32 i = ((CvtR8G8B8toY15(p) >> 7) * DITHER_SIZE + 127) / 255;
CARD32 d =
orderedDither[y & (DITHER_DIM - 1)][x & (DITHER_DIM - 1)];
/* Set mask from dithered alpha value */
RenderSetBit(mskline, x, a > d);
/* Set src from dithered intensity value */
RenderSetBit(srcline, x, a > d && i <= d);
}
}
srcline += stride;
mskline += stride;
}
/*
* Dither to white and black if the cursor has more than two colors
*/
if (ncolor > 2) {
twocolor[0] = 0xff000000;
twocolor[1] = 0xffffffff;
}
else {
free(argbbits);
argbbits = 0;
}
#define GetByte(p,s) (((p) >> (s)) & 0xff)
#define GetColor(p,s) (GetByte(p,s) | (GetByte(p,s) << 8))
cm.width = width;
cm.height = height;
cm.xhot = stuff->x;
cm.yhot = stuff->y;
rc = AllocARGBCursor(srcbits, mskbits, argbbits, &cm,
GetColor(twocolor[0], 16),
GetColor(twocolor[0], 8),
GetColor(twocolor[0], 0),
GetColor(twocolor[1], 16),
GetColor(twocolor[1], 8),
GetColor(twocolor[1], 0),
&pCursor, client, stuff->cid);
if (rc != Success)
goto bail;
if (!AddResource(stuff->cid, RT_CURSOR, (void *) pCursor)) {
rc = BadAlloc;
goto bail;
}
return Success;
bail:
free(srcbits);
free(mskbits);
return rc;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,089 | ProcRenderCreateRadialGradient(ClientPtr client)
{
PicturePtr pPicture;
int len;
int error = 0;
xFixed *stops;
xRenderColor *colors;
REQUEST(xRenderCreateRadialGradientReq);
REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
LEGAL_NEW_RESOURCE(stuff->pid, client);
len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq);
if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
return BadLength;
if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
return BadLength;
stops = (xFixed *) (stuff + 1);
colors = (xRenderColor *) (stops + stuff->nStops);
pPicture =
CreateRadialGradientPicture(stuff->pid, &stuff->inner, &stuff->outer,
stuff->inner_radius, stuff->outer_radius,
stuff->nStops, stops, colors, &error);
if (!pPicture)
return error;
/* security creation/labeling check */
error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
pPicture, RT_NONE, NULL, DixCreateAccess);
if (error != Success)
return error;
if (!AddResource(stuff->pid, PictureType, (void *) pPicture))
return BadAlloc;
return Success;
}
| Exec Code | 0 | ProcRenderCreateRadialGradient(ClientPtr client)
{
PicturePtr pPicture;
int len;
int error = 0;
xFixed *stops;
xRenderColor *colors;
REQUEST(xRenderCreateRadialGradientReq);
REQUEST_AT_LEAST_SIZE(xRenderCreateRadialGradientReq);
LEGAL_NEW_RESOURCE(stuff->pid, client);
len = (client->req_len << 2) - sizeof(xRenderCreateRadialGradientReq);
if (stuff->nStops > UINT32_MAX / (sizeof(xFixed) + sizeof(xRenderColor)))
return BadLength;
if (len != stuff->nStops * (sizeof(xFixed) + sizeof(xRenderColor)))
return BadLength;
stops = (xFixed *) (stuff + 1);
colors = (xRenderColor *) (stops + stuff->nStops);
pPicture =
CreateRadialGradientPicture(stuff->pid, &stuff->inner, &stuff->outer,
stuff->inner_radius, stuff->outer_radius,
stuff->nStops, stops, colors, &error);
if (!pPicture)
return error;
/* security creation/labeling check */
error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
pPicture, RT_NONE, NULL, DixCreateAccess);
if (error != Success)
return error;
if (!AddResource(stuff->pid, PictureType, (void *) pPicture))
return BadAlloc;
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,090 | ProcRenderCreateSolidFill(ClientPtr client)
{
PicturePtr pPicture;
int error = 0;
REQUEST(xRenderCreateSolidFillReq);
REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
LEGAL_NEW_RESOURCE(stuff->pid, client);
pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error);
if (!pPicture)
return error;
/* security creation/labeling check */
error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
pPicture, RT_NONE, NULL, DixCreateAccess);
if (error != Success)
return error;
if (!AddResource(stuff->pid, PictureType, (void *) pPicture))
return BadAlloc;
return Success;
}
| Exec Code | 0 | ProcRenderCreateSolidFill(ClientPtr client)
{
PicturePtr pPicture;
int error = 0;
REQUEST(xRenderCreateSolidFillReq);
REQUEST_AT_LEAST_SIZE(xRenderCreateSolidFillReq);
LEGAL_NEW_RESOURCE(stuff->pid, client);
pPicture = CreateSolidPicture(stuff->pid, &stuff->color, &error);
if (!pPicture)
return error;
/* security creation/labeling check */
error = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, PictureType,
pPicture, RT_NONE, NULL, DixCreateAccess);
if (error != Success)
return error;
if (!AddResource(stuff->pid, PictureType, (void *) pPicture))
return BadAlloc;
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,091 | ProcRenderFillRectangles(ClientPtr client)
{
PicturePtr pDst;
int things;
REQUEST(xRenderFillRectanglesReq);
REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq);
if (!PictOpValid(stuff->op)) {
client->errorValue = stuff->op;
return BadValue;
}
VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
if (!pDst->pDrawable)
return BadDrawable;
things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq);
if (things & 4)
return BadLength;
things >>= 3;
CompositeRects(stuff->op,
pDst, &stuff->color, things, (xRectangle *) &stuff[1]);
return Success;
}
| Exec Code | 0 | ProcRenderFillRectangles(ClientPtr client)
{
PicturePtr pDst;
int things;
REQUEST(xRenderFillRectanglesReq);
REQUEST_AT_LEAST_SIZE(xRenderFillRectanglesReq);
if (!PictOpValid(stuff->op)) {
client->errorValue = stuff->op;
return BadValue;
}
VERIFY_PICTURE(pDst, stuff->dst, client, DixWriteAccess);
if (!pDst->pDrawable)
return BadDrawable;
things = (client->req_len << 2) - sizeof(xRenderFillRectanglesReq);
if (things & 4)
return BadLength;
things >>= 3;
CompositeRects(stuff->op,
pDst, &stuff->color, things, (xRectangle *) &stuff[1]);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,092 | ProcRenderFreeGlyphSet(ClientPtr client)
{
GlyphSetPtr glyphSet;
int rc;
REQUEST(xRenderFreeGlyphSetReq);
REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixDestroyAccess);
if (rc != Success) {
client->errorValue = stuff->glyphset;
return rc;
}
FreeResource(stuff->glyphset, RT_NONE);
return Success;
}
| Exec Code | 0 | ProcRenderFreeGlyphSet(ClientPtr client)
{
GlyphSetPtr glyphSet;
int rc;
REQUEST(xRenderFreeGlyphSetReq);
REQUEST_SIZE_MATCH(xRenderFreeGlyphSetReq);
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixDestroyAccess);
if (rc != Success) {
client->errorValue = stuff->glyphset;
return rc;
}
FreeResource(stuff->glyphset, RT_NONE);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,093 | ProcRenderFreeGlyphs(ClientPtr client)
{
REQUEST(xRenderFreeGlyphsReq);
GlyphSetPtr glyphSet;
int rc, nglyph;
CARD32 *gids;
CARD32 glyph;
REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixRemoveAccess);
if (rc != Success) {
client->errorValue = stuff->glyphset;
return rc;
}
nglyph =
bytes_to_int32((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq));
gids = (CARD32 *) (stuff + 1);
while (nglyph-- > 0) {
glyph = *gids++;
if (!DeleteGlyph(glyphSet, glyph)) {
client->errorValue = glyph;
return RenderErrBase + BadGlyph;
}
}
return Success;
}
| Exec Code | 0 | ProcRenderFreeGlyphs(ClientPtr client)
{
REQUEST(xRenderFreeGlyphsReq);
GlyphSetPtr glyphSet;
int rc, nglyph;
CARD32 *gids;
CARD32 glyph;
REQUEST_AT_LEAST_SIZE(xRenderFreeGlyphsReq);
rc = dixLookupResourceByType((void **) &glyphSet, stuff->glyphset,
GlyphSetType, client, DixRemoveAccess);
if (rc != Success) {
client->errorValue = stuff->glyphset;
return rc;
}
nglyph =
bytes_to_int32((client->req_len << 2) - sizeof(xRenderFreeGlyphsReq));
gids = (CARD32 *) (stuff + 1);
while (nglyph-- > 0) {
glyph = *gids++;
if (!DeleteGlyph(glyphSet, glyph)) {
client->errorValue = glyph;
return RenderErrBase + BadGlyph;
}
}
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,094 | ProcRenderFreePicture(ClientPtr client)
{
PicturePtr pPicture;
REQUEST(xRenderFreePictureReq);
REQUEST_SIZE_MATCH(xRenderFreePictureReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixDestroyAccess);
FreeResource(stuff->picture, RT_NONE);
return Success;
}
| Exec Code | 0 | ProcRenderFreePicture(ClientPtr client)
{
PicturePtr pPicture;
REQUEST(xRenderFreePictureReq);
REQUEST_SIZE_MATCH(xRenderFreePictureReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixDestroyAccess);
FreeResource(stuff->picture, RT_NONE);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,095 | ProcRenderQueryDithers(ClientPtr client)
{
return BadImplementation;
}
| Exec Code | 0 | ProcRenderQueryDithers(ClientPtr client)
{
return BadImplementation;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,096 | ProcRenderQueryFilters(ClientPtr client)
{
REQUEST(xRenderQueryFiltersReq);
DrawablePtr pDrawable;
xRenderQueryFiltersReply *reply;
int nbytesName;
int nnames;
ScreenPtr pScreen;
PictureScreenPtr ps;
int i, j, len, total_bytes, rc;
INT16 *aliases;
char *names;
REQUEST_SIZE_MATCH(xRenderQueryFiltersReq);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixGetAttrAccess);
if (rc != Success)
return rc;
pScreen = pDrawable->pScreen;
nbytesName = 0;
nnames = 0;
ps = GetPictureScreenIfSet(pScreen);
if (ps) {
for (i = 0; i < ps->nfilters; i++)
nbytesName += 1 + strlen(ps->filters[i].name);
for (i = 0; i < ps->nfilterAliases; i++)
nbytesName += 1 + strlen(ps->filterAliases[i].alias);
nnames = ps->nfilters + ps->nfilterAliases;
}
len = ((nnames + 1) >> 1) + bytes_to_int32(nbytesName);
total_bytes = sizeof(xRenderQueryFiltersReply) + (len << 2);
reply = (xRenderQueryFiltersReply *) calloc(1, total_bytes);
if (!reply)
return BadAlloc;
aliases = (INT16 *) (reply + 1);
names = (char *) (aliases + ((nnames + 1) & ~1));
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = len;
reply->numAliases = nnames;
reply->numFilters = nnames;
if (ps) {
/* fill in alias values */
for (i = 0; i < ps->nfilters; i++)
aliases[i] = FilterAliasNone;
for (i = 0; i < ps->nfilterAliases; i++) {
for (j = 0; j < ps->nfilters; j++)
if (ps->filterAliases[i].filter_id == ps->filters[j].id)
break;
if (j == ps->nfilters) {
for (j = 0; j < ps->nfilterAliases; j++)
if (ps->filterAliases[i].filter_id ==
ps->filterAliases[j].alias_id) {
break;
}
if (j == ps->nfilterAliases)
j = FilterAliasNone;
else
j = j + ps->nfilters;
}
aliases[i + ps->nfilters] = j;
}
/* fill in filter names */
for (i = 0; i < ps->nfilters; i++) {
j = strlen(ps->filters[i].name);
*names++ = j;
memcpy(names, ps->filters[i].name, j);
names += j;
}
/* fill in filter alias names */
for (i = 0; i < ps->nfilterAliases; i++) {
j = strlen(ps->filterAliases[i].alias);
*names++ = j;
memcpy(names, ps->filterAliases[i].alias, j);
names += j;
}
}
if (client->swapped) {
for (i = 0; i < reply->numAliases; i++) {
swaps(&aliases[i]);
}
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numAliases);
swapl(&reply->numFilters);
}
WriteToClient(client, total_bytes, reply);
free(reply);
return Success;
}
| Exec Code | 0 | ProcRenderQueryFilters(ClientPtr client)
{
REQUEST(xRenderQueryFiltersReq);
DrawablePtr pDrawable;
xRenderQueryFiltersReply *reply;
int nbytesName;
int nnames;
ScreenPtr pScreen;
PictureScreenPtr ps;
int i, j, len, total_bytes, rc;
INT16 *aliases;
char *names;
REQUEST_SIZE_MATCH(xRenderQueryFiltersReq);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixGetAttrAccess);
if (rc != Success)
return rc;
pScreen = pDrawable->pScreen;
nbytesName = 0;
nnames = 0;
ps = GetPictureScreenIfSet(pScreen);
if (ps) {
for (i = 0; i < ps->nfilters; i++)
nbytesName += 1 + strlen(ps->filters[i].name);
for (i = 0; i < ps->nfilterAliases; i++)
nbytesName += 1 + strlen(ps->filterAliases[i].alias);
nnames = ps->nfilters + ps->nfilterAliases;
}
len = ((nnames + 1) >> 1) + bytes_to_int32(nbytesName);
total_bytes = sizeof(xRenderQueryFiltersReply) + (len << 2);
reply = (xRenderQueryFiltersReply *) calloc(1, total_bytes);
if (!reply)
return BadAlloc;
aliases = (INT16 *) (reply + 1);
names = (char *) (aliases + ((nnames + 1) & ~1));
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = len;
reply->numAliases = nnames;
reply->numFilters = nnames;
if (ps) {
/* fill in alias values */
for (i = 0; i < ps->nfilters; i++)
aliases[i] = FilterAliasNone;
for (i = 0; i < ps->nfilterAliases; i++) {
for (j = 0; j < ps->nfilters; j++)
if (ps->filterAliases[i].filter_id == ps->filters[j].id)
break;
if (j == ps->nfilters) {
for (j = 0; j < ps->nfilterAliases; j++)
if (ps->filterAliases[i].filter_id ==
ps->filterAliases[j].alias_id) {
break;
}
if (j == ps->nfilterAliases)
j = FilterAliasNone;
else
j = j + ps->nfilters;
}
aliases[i + ps->nfilters] = j;
}
/* fill in filter names */
for (i = 0; i < ps->nfilters; i++) {
j = strlen(ps->filters[i].name);
*names++ = j;
memcpy(names, ps->filters[i].name, j);
names += j;
}
/* fill in filter alias names */
for (i = 0; i < ps->nfilterAliases; i++) {
j = strlen(ps->filterAliases[i].alias);
*names++ = j;
memcpy(names, ps->filterAliases[i].alias, j);
names += j;
}
}
if (client->swapped) {
for (i = 0; i < reply->numAliases; i++) {
swaps(&aliases[i]);
}
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numAliases);
swapl(&reply->numFilters);
}
WriteToClient(client, total_bytes, reply);
free(reply);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,097 | ProcRenderQueryPictFormats(ClientPtr client)
{
RenderClientPtr pRenderClient = GetRenderClient(client);
xRenderQueryPictFormatsReply *reply;
xPictScreen *pictScreen;
xPictDepth *pictDepth;
xPictVisual *pictVisual;
xPictFormInfo *pictForm;
CARD32 *pictSubpixel;
ScreenPtr pScreen;
VisualPtr pVisual;
DepthPtr pDepth;
int v, d;
PictureScreenPtr ps;
PictFormatPtr pFormat;
int nformat;
int ndepth;
int nvisual;
int rlength;
int s;
int numScreens;
int numSubpixel;
/* REQUEST(xRenderQueryPictFormatsReq); */
REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq);
#ifdef PANORAMIX
if (noPanoramiXExtension)
numScreens = screenInfo.numScreens;
else
numScreens = ((xConnSetup *) ConnectionInfo)->numRoots;
#else
numScreens = screenInfo.numScreens;
#endif
ndepth = nformat = nvisual = 0;
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
for (d = 0; d < pScreen->numDepths; d++) {
pDepth = pScreen->allowedDepths + d;
++ndepth;
for (v = 0; v < pDepth->numVids; v++) {
pVisual = findVisual(pScreen, pDepth->vids[v]);
if (pVisual &&
PictureMatchVisual(pScreen, pDepth->depth, pVisual))
++nvisual;
}
}
ps = GetPictureScreenIfSet(pScreen);
if (ps)
nformat += ps->nformats;
}
if (pRenderClient->major_version == 0 && pRenderClient->minor_version < 6)
numSubpixel = 0;
else
numSubpixel = numScreens;
rlength = (sizeof(xRenderQueryPictFormatsReply) +
nformat * sizeof(xPictFormInfo) +
numScreens * sizeof(xPictScreen) +
ndepth * sizeof(xPictDepth) +
nvisual * sizeof(xPictVisual) + numSubpixel * sizeof(CARD32));
reply = (xRenderQueryPictFormatsReply *) calloc(1, rlength);
if (!reply)
return BadAlloc;
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
reply->numFormats = nformat;
reply->numScreens = numScreens;
reply->numDepths = ndepth;
reply->numVisuals = nvisual;
reply->numSubpixel = numSubpixel;
pictForm = (xPictFormInfo *) (reply + 1);
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
ps = GetPictureScreenIfSet(pScreen);
if (ps) {
for (nformat = 0, pFormat = ps->formats;
nformat < ps->nformats; nformat++, pFormat++) {
pictForm->id = pFormat->id;
pictForm->type = pFormat->type;
pictForm->depth = pFormat->depth;
pictForm->direct.red = pFormat->direct.red;
pictForm->direct.redMask = pFormat->direct.redMask;
pictForm->direct.green = pFormat->direct.green;
pictForm->direct.greenMask = pFormat->direct.greenMask;
pictForm->direct.blue = pFormat->direct.blue;
pictForm->direct.blueMask = pFormat->direct.blueMask;
pictForm->direct.alpha = pFormat->direct.alpha;
pictForm->direct.alphaMask = pFormat->direct.alphaMask;
if (pFormat->type == PictTypeIndexed &&
pFormat->index.pColormap)
pictForm->colormap = pFormat->index.pColormap->mid;
else
pictForm->colormap = None;
if (client->swapped) {
swapl(&pictForm->id);
swaps(&pictForm->direct.red);
swaps(&pictForm->direct.redMask);
swaps(&pictForm->direct.green);
swaps(&pictForm->direct.greenMask);
swaps(&pictForm->direct.blue);
swaps(&pictForm->direct.blueMask);
swaps(&pictForm->direct.alpha);
swaps(&pictForm->direct.alphaMask);
swapl(&pictForm->colormap);
}
pictForm++;
}
}
}
pictScreen = (xPictScreen *) pictForm;
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
pictDepth = (xPictDepth *) (pictScreen + 1);
ndepth = 0;
for (d = 0; d < pScreen->numDepths; d++) {
pictVisual = (xPictVisual *) (pictDepth + 1);
pDepth = pScreen->allowedDepths + d;
nvisual = 0;
for (v = 0; v < pDepth->numVids; v++) {
pVisual = findVisual(pScreen, pDepth->vids[v]);
if (pVisual && (pFormat = PictureMatchVisual(pScreen,
pDepth->depth,
pVisual))) {
pictVisual->visual = pVisual->vid;
pictVisual->format = pFormat->id;
if (client->swapped) {
swapl(&pictVisual->visual);
swapl(&pictVisual->format);
}
pictVisual++;
nvisual++;
}
}
pictDepth->depth = pDepth->depth;
pictDepth->nPictVisuals = nvisual;
if (client->swapped) {
swaps(&pictDepth->nPictVisuals);
}
ndepth++;
pictDepth = (xPictDepth *) pictVisual;
}
pictScreen->nDepth = ndepth;
ps = GetPictureScreenIfSet(pScreen);
if (ps)
pictScreen->fallback = ps->fallback->id;
else
pictScreen->fallback = 0;
if (client->swapped) {
swapl(&pictScreen->nDepth);
swapl(&pictScreen->fallback);
}
pictScreen = (xPictScreen *) pictDepth;
}
pictSubpixel = (CARD32 *) pictScreen;
for (s = 0; s < numSubpixel; s++) {
pScreen = screenInfo.screens[s];
ps = GetPictureScreenIfSet(pScreen);
if (ps)
*pictSubpixel = ps->subpixel;
else
*pictSubpixel = SubPixelUnknown;
if (client->swapped) {
swapl(pictSubpixel);
}
++pictSubpixel;
}
if (client->swapped) {
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numFormats);
swapl(&reply->numScreens);
swapl(&reply->numDepths);
swapl(&reply->numVisuals);
swapl(&reply->numSubpixel);
}
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
| Exec Code | 0 | ProcRenderQueryPictFormats(ClientPtr client)
{
RenderClientPtr pRenderClient = GetRenderClient(client);
xRenderQueryPictFormatsReply *reply;
xPictScreen *pictScreen;
xPictDepth *pictDepth;
xPictVisual *pictVisual;
xPictFormInfo *pictForm;
CARD32 *pictSubpixel;
ScreenPtr pScreen;
VisualPtr pVisual;
DepthPtr pDepth;
int v, d;
PictureScreenPtr ps;
PictFormatPtr pFormat;
int nformat;
int ndepth;
int nvisual;
int rlength;
int s;
int numScreens;
int numSubpixel;
/* REQUEST(xRenderQueryPictFormatsReq); */
REQUEST_SIZE_MATCH(xRenderQueryPictFormatsReq);
#ifdef PANORAMIX
if (noPanoramiXExtension)
numScreens = screenInfo.numScreens;
else
numScreens = ((xConnSetup *) ConnectionInfo)->numRoots;
#else
numScreens = screenInfo.numScreens;
#endif
ndepth = nformat = nvisual = 0;
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
for (d = 0; d < pScreen->numDepths; d++) {
pDepth = pScreen->allowedDepths + d;
++ndepth;
for (v = 0; v < pDepth->numVids; v++) {
pVisual = findVisual(pScreen, pDepth->vids[v]);
if (pVisual &&
PictureMatchVisual(pScreen, pDepth->depth, pVisual))
++nvisual;
}
}
ps = GetPictureScreenIfSet(pScreen);
if (ps)
nformat += ps->nformats;
}
if (pRenderClient->major_version == 0 && pRenderClient->minor_version < 6)
numSubpixel = 0;
else
numSubpixel = numScreens;
rlength = (sizeof(xRenderQueryPictFormatsReply) +
nformat * sizeof(xPictFormInfo) +
numScreens * sizeof(xPictScreen) +
ndepth * sizeof(xPictDepth) +
nvisual * sizeof(xPictVisual) + numSubpixel * sizeof(CARD32));
reply = (xRenderQueryPictFormatsReply *) calloc(1, rlength);
if (!reply)
return BadAlloc;
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
reply->numFormats = nformat;
reply->numScreens = numScreens;
reply->numDepths = ndepth;
reply->numVisuals = nvisual;
reply->numSubpixel = numSubpixel;
pictForm = (xPictFormInfo *) (reply + 1);
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
ps = GetPictureScreenIfSet(pScreen);
if (ps) {
for (nformat = 0, pFormat = ps->formats;
nformat < ps->nformats; nformat++, pFormat++) {
pictForm->id = pFormat->id;
pictForm->type = pFormat->type;
pictForm->depth = pFormat->depth;
pictForm->direct.red = pFormat->direct.red;
pictForm->direct.redMask = pFormat->direct.redMask;
pictForm->direct.green = pFormat->direct.green;
pictForm->direct.greenMask = pFormat->direct.greenMask;
pictForm->direct.blue = pFormat->direct.blue;
pictForm->direct.blueMask = pFormat->direct.blueMask;
pictForm->direct.alpha = pFormat->direct.alpha;
pictForm->direct.alphaMask = pFormat->direct.alphaMask;
if (pFormat->type == PictTypeIndexed &&
pFormat->index.pColormap)
pictForm->colormap = pFormat->index.pColormap->mid;
else
pictForm->colormap = None;
if (client->swapped) {
swapl(&pictForm->id);
swaps(&pictForm->direct.red);
swaps(&pictForm->direct.redMask);
swaps(&pictForm->direct.green);
swaps(&pictForm->direct.greenMask);
swaps(&pictForm->direct.blue);
swaps(&pictForm->direct.blueMask);
swaps(&pictForm->direct.alpha);
swaps(&pictForm->direct.alphaMask);
swapl(&pictForm->colormap);
}
pictForm++;
}
}
}
pictScreen = (xPictScreen *) pictForm;
for (s = 0; s < numScreens; s++) {
pScreen = screenInfo.screens[s];
pictDepth = (xPictDepth *) (pictScreen + 1);
ndepth = 0;
for (d = 0; d < pScreen->numDepths; d++) {
pictVisual = (xPictVisual *) (pictDepth + 1);
pDepth = pScreen->allowedDepths + d;
nvisual = 0;
for (v = 0; v < pDepth->numVids; v++) {
pVisual = findVisual(pScreen, pDepth->vids[v]);
if (pVisual && (pFormat = PictureMatchVisual(pScreen,
pDepth->depth,
pVisual))) {
pictVisual->visual = pVisual->vid;
pictVisual->format = pFormat->id;
if (client->swapped) {
swapl(&pictVisual->visual);
swapl(&pictVisual->format);
}
pictVisual++;
nvisual++;
}
}
pictDepth->depth = pDepth->depth;
pictDepth->nPictVisuals = nvisual;
if (client->swapped) {
swaps(&pictDepth->nPictVisuals);
}
ndepth++;
pictDepth = (xPictDepth *) pictVisual;
}
pictScreen->nDepth = ndepth;
ps = GetPictureScreenIfSet(pScreen);
if (ps)
pictScreen->fallback = ps->fallback->id;
else
pictScreen->fallback = 0;
if (client->swapped) {
swapl(&pictScreen->nDepth);
swapl(&pictScreen->fallback);
}
pictScreen = (xPictScreen *) pictDepth;
}
pictSubpixel = (CARD32 *) pictScreen;
for (s = 0; s < numSubpixel; s++) {
pScreen = screenInfo.screens[s];
ps = GetPictureScreenIfSet(pScreen);
if (ps)
*pictSubpixel = ps->subpixel;
else
*pictSubpixel = SubPixelUnknown;
if (client->swapped) {
swapl(pictSubpixel);
}
++pictSubpixel;
}
if (client->swapped) {
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numFormats);
swapl(&reply->numScreens);
swapl(&reply->numDepths);
swapl(&reply->numVisuals);
swapl(&reply->numSubpixel);
}
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,098 | ProcRenderQueryPictIndexValues(ClientPtr client)
{
PictFormatPtr pFormat;
int rc, num;
int rlength;
int i;
REQUEST(xRenderQueryPictIndexValuesReq);
xRenderQueryPictIndexValuesReply *reply;
xIndexValue *values;
REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq);
rc = dixLookupResourceByType((void **) &pFormat, stuff->format,
PictFormatType, client, DixReadAccess);
if (rc != Success)
return rc;
if (pFormat->type != PictTypeIndexed) {
client->errorValue = stuff->format;
return BadMatch;
}
num = pFormat->index.nvalues;
rlength = (sizeof(xRenderQueryPictIndexValuesReply) +
num * sizeof(xIndexValue));
reply = (xRenderQueryPictIndexValuesReply *) calloc(1, rlength);
if (!reply)
return BadAlloc;
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
reply->numIndexValues = num;
values = (xIndexValue *) (reply + 1);
memcpy(reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue));
if (client->swapped) {
for (i = 0; i < num; i++) {
swapl(&values[i].pixel);
swaps(&values[i].red);
swaps(&values[i].green);
swaps(&values[i].blue);
swaps(&values[i].alpha);
}
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numIndexValues);
}
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
| Exec Code | 0 | ProcRenderQueryPictIndexValues(ClientPtr client)
{
PictFormatPtr pFormat;
int rc, num;
int rlength;
int i;
REQUEST(xRenderQueryPictIndexValuesReq);
xRenderQueryPictIndexValuesReply *reply;
xIndexValue *values;
REQUEST_AT_LEAST_SIZE(xRenderQueryPictIndexValuesReq);
rc = dixLookupResourceByType((void **) &pFormat, stuff->format,
PictFormatType, client, DixReadAccess);
if (rc != Success)
return rc;
if (pFormat->type != PictTypeIndexed) {
client->errorValue = stuff->format;
return BadMatch;
}
num = pFormat->index.nvalues;
rlength = (sizeof(xRenderQueryPictIndexValuesReply) +
num * sizeof(xIndexValue));
reply = (xRenderQueryPictIndexValuesReply *) calloc(1, rlength);
if (!reply)
return BadAlloc;
reply->type = X_Reply;
reply->sequenceNumber = client->sequence;
reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
reply->numIndexValues = num;
values = (xIndexValue *) (reply + 1);
memcpy(reply + 1, pFormat->index.pValues, num * sizeof(xIndexValue));
if (client->swapped) {
for (i = 0; i < num; i++) {
swapl(&values[i].pixel);
swaps(&values[i].red);
swaps(&values[i].green);
swaps(&values[i].blue);
swaps(&values[i].alpha);
}
swaps(&reply->sequenceNumber);
swapl(&reply->length);
swapl(&reply->numIndexValues);
}
WriteToClient(client, rlength, reply);
free(reply);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
14,099 | ProcRenderQueryVersion(ClientPtr client)
{
RenderClientPtr pRenderClient = GetRenderClient(client);
xRenderQueryVersionReply rep = {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0
};
REQUEST(xRenderQueryVersionReq);
REQUEST_SIZE_MATCH(xRenderQueryVersionReq);
pRenderClient->major_version = stuff->majorVersion;
pRenderClient->minor_version = stuff->minorVersion;
if ((stuff->majorVersion * 1000 + stuff->minorVersion) <
(SERVER_RENDER_MAJOR_VERSION * 1000 + SERVER_RENDER_MINOR_VERSION)) {
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
}
else {
rep.majorVersion = SERVER_RENDER_MAJOR_VERSION;
rep.minorVersion = SERVER_RENDER_MINOR_VERSION;
}
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRenderQueryVersionReply), &rep);
return Success;
}
| Exec Code | 0 | ProcRenderQueryVersion(ClientPtr client)
{
RenderClientPtr pRenderClient = GetRenderClient(client);
xRenderQueryVersionReply rep = {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0
};
REQUEST(xRenderQueryVersionReq);
REQUEST_SIZE_MATCH(xRenderQueryVersionReq);
pRenderClient->major_version = stuff->majorVersion;
pRenderClient->minor_version = stuff->minorVersion;
if ((stuff->majorVersion * 1000 + stuff->minorVersion) <
(SERVER_RENDER_MAJOR_VERSION * 1000 + SERVER_RENDER_MINOR_VERSION)) {
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
}
else {
rep.majorVersion = SERVER_RENDER_MAJOR_VERSION;
rep.minorVersion = SERVER_RENDER_MINOR_VERSION;
}
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xRenderQueryVersionReply), &rep);
return Success;
}
| @@ -1757,6 +1757,9 @@ ProcRenderSetPictureFilter(ClientPtr client)
name = (char *) (stuff + 1);
params = (xFixed *) (name + pad_to_int32(stuff->nbytes));
nparams = ((xFixed *) stuff + client->req_len) - params;
+ if (nparams < 0)
+ return BadLength;
+
result = SetPictureFilter(pPicture, name, stuff->nbytes, params, nparams);
return result;
} | CWE-20 | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.