static int
XineramaXvShmPutImage(ClientPtr client)
{
REQUEST(xvShmPutImageReq);
PanoramiXRes *draw, *gc, *port;
Bool send_event = stuff->send_event;
Bool isRoot;
int result = Success, i, x, y;
REQUEST_SIZE_MATCH(xvShmPutImageReq);
if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
return BadDrawable;
if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->gc, XRT_GC, DixReadAccess)))
return BadGC;
if(!(port = (PanoramiXRes *)SecurityLookupIDByType(
client, stuff->port, XvXRTPort, DixReadAccess)))
return _XvBadPort;
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 -= panoramiXdataPtr[i].x;
stuff->drw_y -= panoramiXdataPtr[i].y;
}
stuff->send_event = (send_event && !i) ? 1 : 0;
result = ProcXvShmPutImage(client);
}
}
return result;
}
static int
ProcXvQueryExtension(ClientPtr client)
{
xvQueryExtensionReply rep;
/* REQUEST(xvQueryExtensionReq); */
REQUEST_SIZE_MATCH(xvQueryExtensionReq);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.version = XvVersion;
rep.revision = XvRevision;
_WriteQueryExtensionReply(client, &rep);
return Success;
}
static int
ProcAppleDRICreateSurface(ClientPtr client)
{
xAppleDRICreateSurfaceReply rep;
DrawablePtr pDrawable;
xp_surface_id sid;
unsigned int key[2];
int rc;
REQUEST(xAppleDRICreateSurfaceReq);
REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixReadAccess);
if (rc != Success)
return rc;
rep.key_0 = rep.key_1 = rep.uid = 0;
if (!DRICreateSurface(screenInfo.screens[stuff->screen],
(Drawable)stuff->drawable, pDrawable,
stuff->client_id, &sid, key,
surface_notify,
x_cvt_uint_to_vptr(client->index))) {
return BadValue;
}
rep.key_0 = key[0];
rep.key_1 = key[1];
rep.uid = sid;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.key_0);
swapl(&rep.key_1);
swapl(&rep.uid);
}
WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), (char *)&rep);
return Success;
}
// was Xinerama
static int
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;
}
static int
ProcDRI2CopyRegion(ClientPtr client)
{
REQUEST(xDRI2CopyRegionReq);
xDRI2CopyRegionReply rep;
DrawablePtr pDrawable;
int status;
RegionPtr pRegion;
REQUEST_SIZE_MATCH(xDRI2CopyRegionReq);
if (!validDrawable(client, stuff->drawable, DixWriteAccess,
&pDrawable, &status))
return status;
VERIFY_REGION(pRegion, stuff->region, client, DixReadAccess);
status = DRI2CopyRegion(pDrawable, pRegion, stuff->dest, stuff->src);
if (status != Success)
return status;
/* CopyRegion needs to be a round trip to make sure the X server
* queues the swap buffer rendering commands before the DRI client
* continues rendering. The reply has a bitmask to signal the
* presense of optional return values as well, but we're not using
* that yet.
*/
rep = (xDRI2CopyRegionReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.length = 0
};
WriteToClient(client, sizeof(xDRI2CopyRegionReply), &rep);
return Success;
}
static void
load_swap_reply(xDRI2SwapBuffersReply * rep, CARD64 sbc)
{
rep->swap_hi = sbc >> 32;
rep->swap_lo = sbc & 0xffffffff;
}
int
ProcXIAllowEvents(ClientPtr client)
{
TimeStamp time;
DeviceIntPtr dev;
int ret = Success;
REQUEST(xXIAllowEventsReq);
REQUEST_SIZE_MATCH(xXIAllowEventsReq);
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (ret != Success)
return ret;
time = ClientTimeToServerTime(stuff->time);
switch (stuff->mode) {
case XIReplayDevice:
AllowSome(client, time, dev, NOT_GRABBED);
break;
case XISyncDevice:
AllowSome(client, time, dev, FREEZE_NEXT_EVENT);
break;
case XIAsyncDevice:
AllowSome(client, time, dev, THAWED);
break;
case XIAsyncPairedDevice:
if (IsMaster(dev))
AllowSome(client, time, dev, THAW_OTHERS);
break;
case XISyncPair:
if (IsMaster(dev))
AllowSome(client, time, dev, FREEZE_BOTH_NEXT_EVENT);
break;
case XIAsyncPair:
if (IsMaster(dev))
AllowSome(client, time, dev, THAWED_BOTH);
break;
default:
client->errorValue = stuff->mode;
ret = BadValue;
}
return ret;
}
static int
ProcXTestGetVersion(ClientPtr client)
{
xXTestGetVersionReply rep;
REQUEST_SIZE_MATCH(xXTestGetVersionReq);
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.majorVersion = XTestMajorVersion;
rep.minorVersion = XTestMinorVersion;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swaps(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXTestGetVersionReply), &rep);
return Success;
}
static int
SProcXkbBell(ClientPtr client)
{
register int n;
REQUEST(xkbBellReq);
swaps(&stuff->length,n);
REQUEST_SIZE_MATCH(xkbBellReq);
swaps(&stuff->deviceSpec,n);
swaps(&stuff->bellClass,n);
swaps(&stuff->bellID,n);
swapl(&stuff->name,n);
swapl(&stuff->window,n);
swaps(&stuff->pitch,n);
swaps(&stuff->duration,n);
return ProcXkbBell(client);
}
int
SProcCopyArea(ClientPtr client)
{
char n;
REQUEST(xCopyAreaReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyAreaReq);
swapl(&stuff->srcDrawable, n);
swapl(&stuff->dstDrawable, n);
swapl(&stuff->gc, n);
swaps(&stuff->srcX, n);
swaps(&stuff->srcY, n);
swaps(&stuff->dstX, n);
swaps(&stuff->dstY, n);
swaps(&stuff->width, n);
swaps(&stuff->height, n);
return((* ProcVector[X_CopyArea])(client));
}
int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
__GLXcontext *cx;
int error;
__GLX_DECLARE_SWAP_VARIABLES;
REQUEST_SIZE_MATCH(xGLXSingleReq);
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
glFlush();
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
static int
ProcXvUngrabPort(ClientPtr client)
{
int status;
XvPortPtr pPort;
REQUEST(xvGrabPortReq);
REQUEST_SIZE_MATCH(xvGrabPortReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
if ((status = _AllocatePort(stuff->port, pPort)) != Success)
{
client->errorValue = stuff->port;
return status;
}
return XvdiUngrabPort(client, pPort, stuff->time);
}
static int
ProcAppleWMSendPSN(register ClientPtr client)
{
REQUEST(xAppleWMSendPSNReq);
int err;
REQUEST_SIZE_MATCH(xAppleWMSendPSNReq);
if(!appleWMProcs->SendPSN)
return BadRequest;
err = appleWMProcs->SendPSN(stuff->psn_hi, stuff->psn_lo);
if (err != Success) {
return err;
}
return (client->noClientException);
}
static int
ProcXvSelectPortNotify(ClientPtr client)
{
int status;
XvPortPtr pPort;
REQUEST(xvSelectPortNotifyReq);
REQUEST_SIZE_MATCH(xvSelectPortNotifyReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
if ((status = _AllocatePort(stuff->port, pPort)) != Success)
{
client->errorValue = stuff->port;
return status;
}
return XvdiSelectPortNotify(client, pPort, stuff->onoff);
}
int
ProcXFixesSetPictureClipRegion(ClientPtr client)
{
PicturePtr pPicture;
RegionPtr pRegion;
REQUEST(xXFixesSetPictureClipRegionReq);
REQUEST_SIZE_MATCH(xXFixesSetPictureClipRegionReq);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixSetAttrAccess);
VERIFY_REGION_OR_NONE(pRegion, stuff->region, client, DixReadAccess);
if (!pPicture->pDrawable)
return RenderErrBase + BadPicture;
return SetPictureClipRegion(pPicture, stuff->xOrigin, stuff->yOrigin,
pRegion);
}
static int
ProcAppleDRIDestroyPixmap(ClientPtr client)
{
DrawablePtr pDrawable;
int rc;
REQUEST(xAppleDRIDestroyPixmapReq);
REQUEST_SIZE_MATCH(xAppleDRIDestroyPixmapReq);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixReadAccess);
if (rc != Success)
return rc;
DRIDestroyPixmap(pDrawable);
return Success;
}
int
ProcXFixesSelectSelectionInput(ClientPtr client)
{
REQUEST(xXFixesSelectSelectionInputReq);
WindowPtr pWin;
int rc;
REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (stuff->eventMask & ~SelectionAllEvents) {
client->errorValue = stuff->eventMask;
return BadValue;
}
return XFixesSelectSelectionInput(client, stuff->selection,
pWin, stuff->eventMask);
}
static int
ProcXDGASelectInput(ClientPtr client)
{
REQUEST(xXDGASelectInputReq);
if (stuff->screen > screenInfo.numScreens)
return BadValue;
if(DGAClients[stuff->screen] != client)
return DGAErrorBase + XF86DGADirectNotActivated;
REQUEST_SIZE_MATCH(xXDGASelectInputReq);
if(DGAClients[stuff->screen] == client)
DGASelectInput(stuff->screen, client, stuff->mask);
return (client->noClientException);
}
static int
ProcXvGetStill(ClientPtr client)
{
DrawablePtr pDraw;
XvPortPtr pPort;
GCPtr pGC;
int status;
REQUEST(xvGetStillReq);
REQUEST_SIZE_MATCH(xvGetStillReq);
VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixReadAccess);
if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
{
client->errorValue = stuff->port;
return (_XvBadPort);
}
if ((status = _AllocatePort(stuff->port, pPort)) != Success)
{
client->errorValue = stuff->port;
return (status);
}
if (!(pPort->pAdaptor->type & XvOutputMask) ||
!(pPort->pAdaptor->type & XvStillMask))
{
client->errorValue = stuff->port;
return (BadMatch);
}
status = XVCALL(diMatchPort)(pPort, pDraw);
if (status != Success)
{
return status;
}
return XVCALL(diGetStill)(client, pDraw, pPort, pGC,
stuff->vid_x, stuff->vid_y,
stuff->vid_w, stuff->vid_h,
stuff->drw_x, stuff->drw_y,
stuff->drw_w, stuff->drw_h);
}
static int
ProcXvGetPortAttribute(ClientPtr client)
{
INT32 value;
int status;
XvPortPtr pPort;
xvGetPortAttributeReply rep;
REQUEST(xvGetPortAttributeReq);
REQUEST_SIZE_MATCH(xvGetPortAttributeReq);
if(!(pPort = LOOKUP_PORT(stuff->port, client) ))
{
client->errorValue = stuff->port;
return (_XvBadPort);
}
if ((status = _AllocatePort(stuff->port, pPort)) != Success)
{
client->errorValue = stuff->port;
return (status);
}
if (!ValidAtom(stuff->attribute))
{
client->errorValue = stuff->attribute;
return(BadAtom);
}
status = XVCALL(diGetPortAttribute)(client, pPort, stuff->attribute, &value);
if (status != Success)
{
client->errorValue = stuff->attribute;
return status;
}
rep.type = X_Reply;
rep.sequenceNumber = client->sequence;
rep.length = 0;
rep.value = value;
_WriteGetPortAttributeReply(client, &rep);
return Success;
}
int
ProcRRGetCrtcGamma (ClientPtr client)
{
REQUEST(xRRGetCrtcGammaReq);
xRRGetCrtcGammaReply reply;
RRCrtcPtr crtc;
int n;
unsigned long len;
char *extra = NULL;
REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq);
VERIFY_RR_CRTC(stuff->crtc, crtc, DixReadAccess);
/* Gamma retrieval failed, any better error? */
if (!RRCrtcGammaGet(crtc))
return RRErrorBase + BadRRCrtc;
len = crtc->gammaSize * 3 * 2;
if (crtc->gammaSize) {
extra = malloc(len);
if (!extra)
return BadAlloc;
}
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
reply.length = bytes_to_int32(len);
reply.size = crtc->gammaSize;
if (client->swapped) {
swaps (&reply.sequenceNumber, n);
swapl (&reply.length, n);
swaps (&reply.size, n);
}
WriteToClient (client, sizeof (xRRGetCrtcGammaReply), (char *) &reply);
if (crtc->gammaSize)
{
memcpy(extra, crtc->gammaRed, len);
client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write;
WriteSwappedDataToClient (client, len, extra);
free(extra);
}
return Success;
}
int
ProcXFixesSelectSelectionInput (ClientPtr client)
{
REQUEST (xXFixesSelectSelectionInputReq);
WindowPtr pWin;
REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
pWin = (WindowPtr)SecurityLookupWindow(stuff->window, client,
SecurityReadAccess);
if (!pWin)
return(BadWindow);
if (stuff->eventMask & ~SelectionAllEvents)
{
client->errorValue = stuff->eventMask;
return( BadValue );
}
return XFixesSelectSelectionInput (client, stuff->selection,
pWin, stuff->eventMask);
}
static int
ProcSecurityRevokeAuthorization(
ClientPtr client)
{
REQUEST(xSecurityRevokeAuthorizationReq);
SecurityAuthorizationPtr pAuth;
int rc;
REQUEST_SIZE_MATCH(xSecurityRevokeAuthorizationReq);
rc = dixLookupResourceByType((pointer *)&pAuth, stuff->authId,
SecurityAuthorizationResType, client,
DixDestroyAccess);
if (rc != Success)
return rc;
FreeResource(stuff->authId, RT_NONE);
return Success;
} /* ProcSecurityRevokeAuthorization */
int
SProcCopyPlane(register ClientPtr client)
{
register char n;
REQUEST(xCopyPlaneReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyPlaneReq);
swapl(&stuff->srcDrawable, n);
swapl(&stuff->dstDrawable, n);
swapl(&stuff->gc, n);
swaps(&stuff->srcX, n);
swaps(&stuff->srcY, n);
swaps(&stuff->dstX, n);
swaps(&stuff->dstY, n);
swaps(&stuff->width, n);
swaps(&stuff->height, n);
swapl(&stuff->bitPlane, n);
return((* ProcVector[X_CopyPlane])(client));
}
static int
ProcXDGAFillRectangle(ClientPtr client)
{
REQUEST(xXDGAFillRectangleReq);
if (stuff->screen > screenInfo.numScreens)
return BadValue;
if(DGAClients[stuff->screen] != client)
return DGAErrorBase + XF86DGADirectNotActivated;
REQUEST_SIZE_MATCH(xXDGAFillRectangleReq);
if(Success != DGAFillRect(stuff->screen, stuff->x, stuff->y,
stuff->width, stuff->height, stuff->color))
return BadMatch;
return (client->noClientException);
}
int ProcXIChangeCursor(ClientPtr client)
{
int rc;
WindowPtr pWin = NULL;
DeviceIntPtr pDev = NULL;
CursorPtr pCursor = NULL;
REQUEST(xXIChangeCursorReq);
REQUEST_SIZE_MATCH(xXIChangeCursorReq);
rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixSetAttrAccess);
if (rc != Success)
return rc;
if (!IsMaster(pDev) || !IsPointerDevice(pDev))
return BadDevice;
if (stuff->win != None)
{
rc = dixLookupWindow(&pWin, stuff->win, client, DixSetAttrAccess);
if (rc != Success)
return rc;
}
if (stuff->cursor == None)
{
if (pWin == pWin->drawable.pScreen->root)
pCursor = rootCursor;
else
pCursor = (CursorPtr)None;
}
else
{
rc = dixLookupResourceByType((pointer *)&pCursor, stuff->cursor,
RT_CURSOR, client, DixUseAccess);
if (rc != Success)
return rc;
}
ChangeWindowDeviceCursor(pWin, pDev, pCursor);
return Success;
}
static int
ProcWindowsWMQueryVersion(ClientPtr client)
{
xWindowsWMQueryVersionReply rep;
REQUEST_SIZE_MATCH(xWindowsWMQueryVersionReq);
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.majorVersion = SERVER_WINDOWSWM_MAJOR_VERSION;
rep.minorVersion = SERVER_WINDOWSWM_MINOR_VERSION;
rep.patchVersion = SERVER_WINDOWSWM_PATCH_VERSION;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client, sizeof(xWindowsWMQueryVersionReply), &rep);
return Success;
}
static int
ProcXF86DRIGetDeviceInfo(
register ClientPtr client
)
{
xXF86DRIGetDeviceInfoReply rep;
drm_handle_t hFrameBuffer;
void *pDevPrivate;
REQUEST(xXF86DRIGetDeviceInfoReq);
REQUEST_SIZE_MATCH(xXF86DRIGetDeviceInfoReq);
if (stuff->screen >= screenInfo.numScreens) {
client->errorValue = stuff->screen;
return BadValue;
}
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
if (!DRIGetDeviceInfo( screenInfo.screens[stuff->screen],
&hFrameBuffer,
(int*)&rep.framebufferOrigin,
(int*)&rep.framebufferSize,
(int*)&rep.framebufferStride,
(int*)&rep.devPrivateSize,
&pDevPrivate)) {
return BadValue;
}
rep.hFrameBufferLow = (CARD32)(hFrameBuffer & 0xffffffff);
#if defined(LONG64) && !defined(__linux__)
rep.hFrameBufferHigh = (CARD32)(hFrameBuffer >> 32);
#else
rep.hFrameBufferHigh = 0;
#endif
rep.length = 0;
if (rep.devPrivateSize) {
rep.length = (SIZEOF(xXF86DRIGetDeviceInfoReply) -
SIZEOF(xGenericReply) +
((rep.devPrivateSize + 3) & ~3)) >> 2;
}
static int
ProcXF86DRIDestroyContext(
register ClientPtr client
)
{
REQUEST(xXF86DRIDestroyContextReq);
REQUEST_SIZE_MATCH(xXF86DRIDestroyContextReq);
if (stuff->screen >= screenInfo.numScreens) {
client->errorValue = stuff->screen;
return BadValue;
}
if (!DRIDestroyContext( screenInfo.screens[stuff->screen],
stuff->context)) {
return BadValue;
}
return (client->noClientException);
}
static int
ProcXF86DRICreateContext(
register ClientPtr client
)
{
xXF86DRICreateContextReply rep;
ScreenPtr pScreen;
VisualPtr visual;
int i;
REQUEST(xXF86DRICreateContextReq);
REQUEST_SIZE_MATCH(xXF86DRICreateContextReq);
if (stuff->screen >= screenInfo.numScreens) {
client->errorValue = stuff->screen;
return BadValue;
}
rep.type = X_Reply;
rep.length = 0;
rep.sequenceNumber = client->sequence;
pScreen = screenInfo.screens[stuff->screen];
visual = pScreen->visuals;
/* Find the requested X visual */
for (i = 0; i < pScreen->numVisuals; i++, visual++)
if (visual->vid == stuff->visual)
break;
if (i == pScreen->numVisuals) {
/* No visual found */
return BadValue;
}
if (!DRICreateContext( pScreen,
visual,
stuff->context,
(drm_context_t *)&rep.hHWContext)) {
return BadValue;
}
WriteToClient(client, sizeof(xXF86DRICreateContextReply), (char *)&rep);
return (client->noClientException);
}
static int
ProcXDGACopyTransparentArea(ClientPtr client)
{
REQUEST(xXDGACopyTransparentAreaReq);
if (stuff->screen > screenInfo.numScreens)
return BadValue;
if(DGAClients[stuff->screen] != client)
return DGAErrorBase + XF86DGADirectNotActivated;
REQUEST_SIZE_MATCH(xXDGACopyTransparentAreaReq);
if(Success != DGABlitTransRect(stuff->screen, stuff->srcx, stuff->srcy,
stuff->width, stuff->height, stuff->dstx, stuff->dsty, stuff->key))
return BadMatch;
return (client->noClientException);
}