Add swapped dispatch for randr 1.2 requests

randr/rrcrtc.c

@@ -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;
 }

randr/rrproperty.c

@@ -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))

randr/rrsdispatch.c

@@ -84,191 +84,284 @@ SProcRRSelectInput (ClientPtr client)
 static int
 SProcRRGetScreenSizeRange (ClientPtr client)
 {
+    int n;
     REQUEST(xRRGetScreenSizeRangeReq);
 
     REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->window, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetScreenSize (ClientPtr client)
 {
+    int n;
     REQUEST(xRRSetScreenSizeReq);
 
     REQUEST_SIZE_MATCH(xRRSetScreenSizeReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->window, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetOutputInfo (ClientPtr client)
 {
+    int n;
     REQUEST(xRRGetOutputInfoReq);;
 
     REQUEST_SIZE_MATCH(xRRGetOutputInfoReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->output, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRQueryOutputProperty (ClientPtr client)
 {
+    int n;
     REQUEST(xRRQueryOutputPropertyReq);
 
     REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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);
+    swaps(&stuff->length, n);
-    (void) stuff;
+    swapl(&stuff->output, n);
-    return BadImplementation; 
+    swapl(&stuff->property, n);
+    SwapRestL(stuff);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRChangeOutputProperty (ClientPtr client)
 {
+    int n;
     REQUEST(xRRChangeOutputPropertyReq);
 
-    REQUEST_SIZE_MATCH(xRRChangeOutputPropertyReq);
+    REQUEST_AT_LEAST_SIZE (xRRChangeOutputPropertyReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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);
+    REQUEST_AT_LEAST_SIZE(xRRCreateModeReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->mode, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRAddOutputMode (ClientPtr client)
 {
+    int n;
     REQUEST(xRRAddOutputModeReq);
 
     REQUEST_SIZE_MATCH(xRRAddOutputModeReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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);
+    REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    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;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->crtc, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRGetCrtcGamma (ClientPtr client)
 {
+    int n;
     REQUEST(xRRGetCrtcGammaReq);
 
     REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->crtc, n);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 static int
 SProcRRSetCrtcGamma (ClientPtr client)
 {
+    int n;
     REQUEST(xRRSetCrtcGammaReq);
 
-    REQUEST_SIZE_MATCH(xRRSetCrtcGammaReq);
+    REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq);
-    (void) stuff;
+    swaps(&stuff->length, n);
-    return BadImplementation; 
+    swapl(&stuff->crtc, n);
+    swaps(&stuff->size, n);
+    SwapRestS(stuff);
+    return (*ProcRandrVector[stuff->randrReqType]) (client);
 }
 
 int (*SProcRandrVector[RRNumberRequests])(ClientPtr) = {