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

Add swapped dispatch for randr 1.2 requests

This commit is contained in:
Julien Cristau 2008-08-21 01:32:03 +02:00
parent e02f864fdf
commit 01264f1792
3 changed files with 215 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
randr/rrcrtc.c
View File

@ -894,6 +894,7 @@ ProcRRGetCrtcGamma (ClientPtr client)
RRCrtcPtr crtc;
int n;
unsigned long len;
char *extra;
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
crtc = LookupCrtc (client, stuff->crtc, DixReadAccess);
@ -902,6 +903,12 @@ ProcRRGetCrtcGamma (ClientPtr client)
len = crtc->gammaSize * 3 * 2;
if (crtc->gammaSize) {
extra = xalloc(len);
if (!extra)
return BadAlloc;
}
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.length = (len + 3) >> 2;
@ -914,8 +921,10 @@ ProcRRGetCrtcGamma (ClientPtr client)
WriteToClient (client, sizeof (xRRGetCrtcGammaReply), (char *) &reply);
if (crtc->gammaSize)
{
memcpy(extra, crtc->gammaRed, len);
client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write;
WriteSwappedDataToClient (client, len, (char *) crtc->gammaRed);
WriteSwappedDataToClient (client, len, extra);
xfree(extra);
}
return client->noClientException;
}

58
randr/rrproperty.c
View File

@ -406,12 +406,13 @@ ProcRRListOutputProperties (ClientPtr client)
int n;
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
swaps (&rep.nAtoms, n);
}
temppAtoms = pAtoms;
for (prop = output->properties; prop; prop = prop->next)
*temppAtoms++ = prop->propertyName;
WriteReplyToClient(client, sizeof(xRRListOutputPropertiesReply), &rep);
WriteToClient(client, sizeof(xRRListOutputPropertiesReply), (char*)&rep);
if (numProps)
{
client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
@ -428,6 +429,7 @@ ProcRRQueryOutputProperty (ClientPtr client)
xRRQueryOutputPropertyReply rep;
RROutputPtr output;
RRPropertyPtr prop;
char *extra;
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
@ -440,6 +442,11 @@ ProcRRQueryOutputProperty (ClientPtr client)
if (!prop)
return BadName;
if (prop->num_valid) {
extra = xalloc(prop->num_valid * sizeof(INT32));
if (!extra)
return BadAlloc;
}
rep.type = X_Reply;
rep.length = prop->num_valid;
rep.sequenceNumber = client->sequence;
@ -452,12 +459,14 @@ ProcRRQueryOutputProperty (ClientPtr client)
swaps (&rep.sequenceNumber, n);
swapl (&rep.length, n);
}
WriteReplyToClient (client, sizeof (xRRQueryOutputPropertyReply), &rep);
WriteToClient (client, sizeof (xRRQueryOutputPropertyReply), (char*)&rep);
if (prop->num_valid)
{
memcpy(extra, prop->valid_values, prop->num_valid * sizeof(INT32));
client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
prop->valid_values);
extra);
xfree(extra);
}
return(client->noClientException);
}
@ -572,6 +581,7 @@ ProcRRGetOutputProperty (ClientPtr client)
unsigned long n, len, ind;
RROutputPtr output;
xRRGetOutputPropertyReply reply;
char *extra;
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
if (stuff->delete)
@ -611,7 +621,16 @@ ProcRRGetOutputProperty (ClientPtr client)
reply.bytesAfter = 0;
reply.propertyType = None;
reply.format = 0;
WriteReplyToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
}
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
return(client->noClientException);
}
@ -634,7 +653,16 @@ ProcRRGetOutputProperty (ClientPtr client)
reply.length = 0;
reply.nItems = 0;
reply.propertyType = prop_value->type;
WriteReplyToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
}
WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
return(client->noClientException);
}
@ -655,6 +683,11 @@ ProcRRGetOutputProperty (ClientPtr client)
len = min(n - ind, 4 * stuff->longLength);
if (len) {
extra = xalloc(len);
if (!extra)
return BadAlloc;
}
reply.bytesAfter = n - (ind + len);
reply.format = prop_value->format;
reply.length = (len + 3) >> 2;
@ -677,16 +710,27 @@ ProcRRGetOutputProperty (ClientPtr client)
RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask);
}
WriteReplyToClient(client, sizeof(xGenericReply), &reply);
if (client->swapped) {
int n;
swaps(&reply.sequenceNumber, n);
swapl(&reply.length, n);
swapl(&reply.propertyType, n);
swapl(&reply.bytesAfter, n);
swapl(&reply.nItems, n);
}
WriteToClient(client, sizeof(xGenericReply), &reply);
if (len)
{
memcpy(extra, (char *)prop_value->data + ind, len);
switch (reply.format) {
case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;
case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;
default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;
}
WriteSwappedDataToClient(client, len,
(char *)prop_value->data + ind);
extra);
xfree(extra);
}
if (stuff->delete && (reply.bytesAfter == 0))

179
randr/rrsdispatch.c
View File

@ -84,191 +84,284 @@ SProcRRSelectInput (ClientPtr client)
static int
SProcRRGetScreenSizeRange (ClientPtr client)
{
int n;
REQUEST(xRRGetScreenSizeRangeReq);
REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->window, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetScreenSize (ClientPtr client)
{
int n;
REQUEST(xRRSetScreenSizeReq);
REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->window, n);
swaps(&stuff->width, n);
swaps(&stuff->height, n);
swapl(&stuff->widthInMillimeters, n);
swapl(&stuff->heightInMillimeters, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetScreenResources (ClientPtr client)
{
int n;
REQUEST(xRRGetScreenResourcesReq);
REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->window, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetOutputInfo (ClientPtr client)
{
int n;
REQUEST(xRRGetOutputInfoReq);;
REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->configTimestamp, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRListOutputProperties (ClientPtr client)
{
int n;
REQUEST(xRRListOutputPropertiesReq);
REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRQueryOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRQueryOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRConfigureOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRConfigureOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRConfigureOutputPropertyReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
SwapRestL(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRChangeOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRChangeOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRChangeOutputPropertyReq);
(void) stuff;
return BadImplementation;
REQUEST_AT_LEAST_SIZE (xRRChangeOutputPropertyReq);
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swapl(&stuff->type, n);
swapl(&stuff->nUnits, n);
switch(stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
default:
client->errorValue = stuff->format;
return BadValue;
}
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRDeleteOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRDeleteOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetOutputProperty (ClientPtr client)
{
int n;
REQUEST(xRRGetOutputPropertyReq);
REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->property, n);
swapl(&stuff->type, n);
swapl(&stuff->longOffset, n);
swapl(&stuff->longLength, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRCreateMode (ClientPtr client)
{
int n;
xRRModeInfo *modeinfo;
REQUEST(xRRCreateModeReq);
REQUEST_SIZE_MATCH(xRRCreateModeReq);
(void) stuff;
return BadImplementation;
REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
swaps(&stuff->length, n);
swapl(&stuff->window, n);
modeinfo = &stuff->modeInfo;
swapl(&modeinfo->id, n);
swaps(&modeinfo->width, n);
swaps(&modeinfo->height, n);
swapl(&modeinfo->dotClock, n);
swaps(&modeinfo->hSyncStart, n);
swaps(&modeinfo->hSyncEnd, n);
swaps(&modeinfo->hTotal, n);
swaps(&modeinfo->vSyncStart, n);
swaps(&modeinfo->vSyncEnd, n);
swaps(&modeinfo->vTotal, n);
swaps(&modeinfo->nameLength, n);
swapl(&modeinfo->modeFlags, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRDestroyMode (ClientPtr client)
{
int n;
REQUEST(xRRDestroyModeReq);
REQUEST_SIZE_MATCH(xRRDestroyModeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->mode, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRAddOutputMode (ClientPtr client)
{
int n;
REQUEST(xRRAddOutputModeReq);
REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->mode, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRDeleteOutputMode (ClientPtr client)
{
int n;
REQUEST(xRRDeleteOutputModeReq);
REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->output, n);
swapl(&stuff->mode, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetCrtcInfo (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcInfoReq);
REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swapl(&stuff->configTimestamp, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetCrtcConfig (ClientPtr client)
{
int n;
REQUEST(xRRSetCrtcConfigReq);
REQUEST_SIZE_MATCH(xRRSetCrtcConfigReq);
(void) stuff;
return BadImplementation;
REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swapl(&stuff->timestamp, n);
swapl(&stuff->configTimestamp, n);
swaps(&stuff->x, n);
swaps(&stuff->y, n);
swapl(&stuff->mode, n);
swaps(&stuff->rotation, n);
SwapRestL(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetCrtcGammaSize (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcGammaSizeReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRGetCrtcGamma (ClientPtr client)
{
int n;
REQUEST(xRRGetCrtcGammaReq);
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
(void) stuff;
return BadImplementation;
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
static int
SProcRRSetCrtcGamma (ClientPtr client)
{
int n;
REQUEST(xRRSetCrtcGammaReq);
REQUEST_SIZE_MATCH(xRRSetCrtcGammaReq);
(void) stuff;
return BadImplementation;
REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
swaps(&stuff->length, n);
swapl(&stuff->crtc, n);
swaps(&stuff->size, n);
SwapRestS(stuff);
return (*ProcRandrVector[stuff->randrReqType]) (client);
}
int (*SProcRandrVector[RRNumberRequests])(ClientPtr) = {