/* static */
int ProcXagCreate (
register ClientPtr client)
{
REQUEST (xXagCreateReq);
AppGroupPtr pAppGrp;
int ret;
REQUEST_AT_LEAST_SIZE (xXagCreateReq);
LEGAL_NEW_RESOURCE (stuff->app_group, client);
pAppGrp = CreateAppGroup (client, stuff->app_group,
stuff->attrib_mask, (CARD32*) &stuff[1]);
if (!pAppGrp)
return BadAlloc;
ret = AttrValidate (client, stuff->attrib_mask, pAppGrp);
if (ret != Success) {
XagAppGroupFree ((pointer)pAppGrp, (XID)0);
return ret;
}
if (pAppGrp->single_screen) {
CreateConnectionInfo (pAppGrp);
if (!pAppGrp->ConnectionInfo)
return BadAlloc;
}
if (!AddResource (stuff->app_group, RT_APPGROUP, (pointer)pAppGrp))
return BadAlloc;
if (XagCallbackRefCount++ == 0)
(void) AddCallback (&ClientStateCallback, XagClientStateChange, NULL);
return client->noClientException;
}
static int dispatch_CreateContext(ClientPtr client)
{
REQUEST(xGLXCreateContextReq);
CARD32 screen, context;
GlxServerVendor *vendor = NULL;
REQUEST_SIZE_MATCH(*stuff);
screen = GlxCheckSwap(client, stuff->screen);
context = GlxCheckSwap(client, stuff->context);
LEGAL_NEW_RESOURCE(context, client);
if (screen < screenInfo.numScreens) {
vendor = glxServer.getVendorForScreen(client, screenInfo.screens[screen]);
}
if (vendor != NULL) {
int ret;
if (!glxServer.addXIDMap(context, vendor)) {
return BadAlloc;
}
ret = glxServer.forwardRequest(vendor, client);
if (ret != Success) {
glxServer.removeXIDMap(context);
}
return ret;
} else {
client->errorValue = screen;
return BadMatch;
}
}
int
ProcXFixesCreateRegionFromBitmap (ClientPtr client)
{
RegionPtr pRegion;
PixmapPtr pPixmap;
REQUEST (xXFixesCreateRegionFromBitmapReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromBitmapReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
pPixmap = (PixmapPtr) SecurityLookupIDByType (client, stuff->bitmap,
RT_PIXMAP,
DixReadAccess);
if (!pPixmap)
{
client->errorValue = stuff->bitmap;
return BadPixmap;
}
if (pPixmap->drawable.depth != 1)
return BadMatch;
pRegion = BITMAP_TO_REGION(pPixmap->drawable.pScreen, pPixmap);
if (!pRegion)
return BadAlloc;
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
}
int
ProcXFixesCreateRegionFromPicture (ClientPtr client)
{
RegionPtr pRegion;
PicturePtr pPicture;
REQUEST (xXFixesCreateRegionFromPictureReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixGetAttrAccess);
switch (pPicture->clientClipType) {
case CT_PIXMAP:
pRegion = BitmapToRegion(pPicture->pDrawable->pScreen,
(PixmapPtr) pPicture->clientClip);
if (!pRegion)
return BadAlloc;
break;
case CT_REGION:
pRegion = XFixesRegionCopy ((RegionPtr) pPicture->clientClip);
if (!pRegion)
return BadAlloc;
break;
default:
return BadImplementation; /* assume sane server bits */
}
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return Success;
}
int
ProcXFixesCreateRegionFromPicture(ClientPtr client)
{
RegionPtr pRegion;
PicturePtr pPicture;
REQUEST(xXFixesCreateRegionFromPictureReq);
REQUEST_SIZE_MATCH(xXFixesCreateRegionFromPictureReq);
LEGAL_NEW_RESOURCE(stuff->region, client);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixGetAttrAccess);
if (!pPicture->pDrawable)
return RenderErrBase + BadPicture;
if (pPicture->clientClip) {
pRegion = XFixesRegionCopy((RegionPtr) pPicture->clientClip);
if (!pRegion)
return BadAlloc;
} else {
return BadMatch;
}
if (!AddResource(stuff->region, RegionResType, (void *) pRegion))
return BadAlloc;
return Success;
}
int
ProcXFixesCreateRegionFromBitmap(ClientPtr client)
{
RegionPtr pRegion;
PixmapPtr pPixmap;
int rc;
REQUEST(xXFixesCreateRegionFromBitmapReq);
REQUEST_SIZE_MATCH(xXFixesCreateRegionFromBitmapReq);
LEGAL_NEW_RESOURCE(stuff->region, client);
rc = dixLookupResourceByType((void **) &pPixmap, stuff->bitmap, RT_PIXMAP,
client, DixReadAccess);
if (rc != Success) {
client->errorValue = stuff->bitmap;
return rc;
}
if (pPixmap->drawable.depth != 1)
return BadMatch;
pRegion = BitmapToRegion(pPixmap->drawable.pScreen, pPixmap);
if (!pRegion)
return BadAlloc;
if (!AddResource(stuff->region, RegionResType, (void *) pRegion))
return BadAlloc;
return Success;
}
int
ProcXFixesCreateRegionFromGC(ClientPtr client)
{
RegionPtr pRegion, pClip;
GCPtr pGC;
int rc;
REQUEST(xXFixesCreateRegionFromGCReq);
REQUEST_SIZE_MATCH(xXFixesCreateRegionFromGCReq);
LEGAL_NEW_RESOURCE(stuff->region, client);
rc = dixLookupGC(&pGC, stuff->gc, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (pGC->clientClip) {
pClip = (RegionPtr) pGC->clientClip;
pRegion = XFixesRegionCopy(pClip);
if (!pRegion)
return BadAlloc;
} else {
return BadMatch;
}
if (!AddResource(stuff->region, RegionResType, (void *) pRegion))
return BadAlloc;
return Success;
}
static int
ProcCompositeNameWindowPixmap (ClientPtr client)
{
WindowPtr pWin;
CompWindowPtr cw;
PixmapPtr pPixmap;
REQUEST(xCompositeNameWindowPixmapReq);
REQUEST_SIZE_MATCH(xCompositeNameWindowPixmapReq);
pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW);
if (!pWin)
{
client->errorValue = stuff->window;
return BadWindow;
}
LEGAL_NEW_RESOURCE (stuff->pixmap, client);
cw = GetCompWindow (pWin);
if (!cw)
return BadMatch;
pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin);
if (!pPixmap)
return BadMatch;
++pPixmap->refcnt;
if (!AddResource (stuff->pixmap, RT_PIXMAP, (pointer) pPixmap))
return BadAlloc;
return(client->noClientException);
}
static int
ProcCompositeCreateRegionFromBorderClip (ClientPtr client)
{
WindowPtr pWin;
CompWindowPtr cw;
RegionPtr pBorderClip, pRegion;
REQUEST(xCompositeCreateRegionFromBorderClipReq);
REQUEST_SIZE_MATCH(xCompositeCreateRegionFromBorderClipReq);
pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW);
if (!pWin)
{
client->errorValue = stuff->window;
return BadWindow;
}
LEGAL_NEW_RESOURCE (stuff->region, client);
cw = GetCompWindow (pWin);
if (cw)
pBorderClip = &cw->borderClip;
else
pBorderClip = &pWin->borderClip;
pRegion = XFixesRegionCopy (pBorderClip);
if (!pRegion)
return BadAlloc;
REGION_TRANSLATE (pScreen, pRegion, -pWin->drawable.x, -pWin->drawable.y);
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
}
static int
ProcShmAttach(ClientPtr client)
{
SHMSTAT_TYPE buf;
ShmDescPtr shmdesc;
REQUEST(xShmAttachReq);
REQUEST_SIZE_MATCH(xShmAttachReq);
LEGAL_NEW_RESOURCE(stuff->shmseg, client);
if ((stuff->readOnly != xTrue) && (stuff->readOnly != xFalse))
{
client->errorValue = stuff->readOnly;
return BadValue;
}
for (shmdesc = Shmsegs;
shmdesc && (shmdesc->shmid != stuff->shmid);
shmdesc = shmdesc->next)
;
if (shmdesc)
{
if (!stuff->readOnly && !shmdesc->writable)
return BadAccess;
shmdesc->refcnt++;
}
else
{
shmdesc = malloc(sizeof(ShmDescRec));
if (!shmdesc)
return BadAlloc;
shmdesc->addr = shmat(stuff->shmid, 0,
stuff->readOnly ? SHM_RDONLY : 0);
if ((shmdesc->addr == ((char *)-1)) ||
SHMSTAT(stuff->shmid, &buf))
{
free(shmdesc);
return BadAccess;
}
/* The attach was performed with root privs. We must
* do manual checking of access rights for the credentials
* of the client */
if (shm_access(client, &(SHM_PERM(buf)), stuff->readOnly) == -1) {
shmdt(shmdesc->addr);
free(shmdesc);
return BadAccess;
}
shmdesc->shmid = stuff->shmid;
shmdesc->refcnt = 1;
shmdesc->writable = !stuff->readOnly;
shmdesc->size = SHM_SEGSZ(buf);
shmdesc->next = Shmsegs;
Shmsegs = shmdesc;
}
if (!AddResource(stuff->shmseg, ShmSegType, (pointer)shmdesc))
return BadAlloc;
return Success;
}
static int
ProcDamageCreate(ClientPtr client)
{
DrawablePtr pDrawable;
DamageExtPtr pDamageExt;
DamageReportLevel level;
RegionPtr pRegion;
REQUEST(xDamageCreateReq);
REQUEST_SIZE_MATCH(xDamageCreateReq);
LEGAL_NEW_RESOURCE(stuff->damage, client);
SECURITY_VERIFY_DRAWABLE(pDrawable, stuff->drawable, client,
SecurityReadAccess);
switch (stuff->level) {
case XDamageReportRawRectangles:
level = DamageReportRawRegion;
break;
case XDamageReportDeltaRectangles:
level = DamageReportDeltaRegion;
break;
case XDamageReportBoundingBox:
level = DamageReportBoundingBox;
break;
case XDamageReportNonEmpty:
level = DamageReportNonEmpty;
break;
default:
client->errorValue = stuff->level;
return BadValue;
}
pDamageExt = malloc(sizeof(DamageExtRec));
if (!pDamageExt)
return BadAlloc;
pDamageExt->id = stuff->damage;
pDamageExt->pDrawable = pDrawable;
pDamageExt->level = level;
pDamageExt->pClient = client;
pDamageExt->pDamage = DamageCreate(DamageExtReport,
DamageExtDestroy,
level,
FALSE, pDrawable->pScreen, pDamageExt);
if (!pDamageExt->pDamage) {
free(pDamageExt);
return BadAlloc;
}
if (!AddResource(stuff->damage, DamageExtType, (pointer) pDamageExt))
return BadAlloc;
DamageRegister(pDamageExt->pDrawable, pDamageExt->pDamage);
if (pDrawable->type == DRAWABLE_WINDOW) {
pRegion = &((WindowPtr) pDrawable)->borderClip;
DamageDamageRegion(pDrawable, pRegion);
}
return (client->noClientException);
}
int
present_select_input(ClientPtr client, XID eid, WindowPtr window, CARD32 mask)
{
present_window_priv_ptr window_priv;
present_event_ptr event;
int ret;
/* Check to see if we're modifying an existing event selection */
ret = dixLookupResourceByType((void **) &event, eid, present_event_type,
client, DixWriteAccess);
if (ret == Success) {
/* Match error for the wrong window; also don't modify some other
* client's event selection
*/
if (event->window != window || event->client != client)
return BadMatch;
if (mask)
event->mask = mask;
else
FreeResource(eid, RT_NONE);
return Success;
}
if (ret != BadValue)
return ret;
if (mask == 0)
return Success;
LEGAL_NEW_RESOURCE(eid, client);
window_priv = present_get_window_priv(window, TRUE);
if (!window_priv)
return BadAlloc;
event = calloc (1, sizeof (present_event_rec));
if (!event)
return BadAlloc;
event->client = client;
event->window = window;
event->id = eid;
event->mask = mask;
event->next = window_priv->events;
window_priv->events = event;
if (!AddResource(event->id, present_event_type, (void *) event))
return BadAlloc;
return Success;
}
int
ProcXFixesCreateRegionFromWindow (ClientPtr client)
{
RegionPtr pRegion;
Bool copy = TRUE;
WindowPtr pWin;
REQUEST (xXFixesCreateRegionFromWindowReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
pWin = (WindowPtr) LookupIDByType (stuff->window, RT_WINDOW);
if (!pWin)
{
client->errorValue = stuff->window;
return BadWindow;
}
switch (stuff->kind) {
case WindowRegionBounding:
#ifdef SHAPE
pRegion = wBoundingShape(pWin);
if (!pRegion)
#endif
{
pRegion = CreateBoundingShape (pWin);
copy = FALSE;
}
break;
case WindowRegionClip:
#ifdef SHAPE
pRegion = wClipShape(pWin);
if (!pRegion)
#endif
{
pRegion = CreateClipShape (pWin);
copy = FALSE;
}
break;
default:
client->errorValue = stuff->kind;
return BadValue;
}
if (copy && pRegion)
pRegion = XFixesRegionCopy (pRegion);
if (!pRegion)
return BadAlloc;
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
}
int
ProcXFixesCreateRegionFromWindow (ClientPtr client)
{
RegionPtr pRegion;
Bool copy = TRUE;
WindowPtr pWin;
int rc;
REQUEST (xXFixesCreateRegionFromWindowReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromWindowReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
rc = dixLookupResourceByType((pointer *)&pWin, stuff->window, RT_WINDOW,
client, DixGetAttrAccess);
if (rc != Success)
{
client->errorValue = stuff->window;
return rc;
}
switch (stuff->kind) {
case WindowRegionBounding:
pRegion = wBoundingShape(pWin);
if (!pRegion)
{
pRegion = CreateBoundingShape (pWin);
copy = FALSE;
}
break;
case WindowRegionClip:
pRegion = wClipShape(pWin);
if (!pRegion)
{
pRegion = CreateClipShape (pWin);
copy = FALSE;
}
break;
default:
client->errorValue = stuff->kind;
return BadValue;
}
if (copy && pRegion)
pRegion = XFixesRegionCopy (pRegion);
if (!pRegion)
return BadAlloc;
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return Success;
}
static int
proc_present_select_input (ClientPtr client)
{
REQUEST(xPresentSelectInputReq);
WindowPtr window;
int rc;
REQUEST_SIZE_MATCH(xPresentSelectInputReq);
LEGAL_NEW_RESOURCE(stuff->eid, client);
rc = dixLookupWindow(&window, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (stuff->eventMask & ~PresentAllEvents) {
client->errorValue = stuff->eventMask;
return BadValue;
}
return present_select_input(client, stuff->eid, window, stuff->eventMask);
}
int
ProcXFixesCreateRegionFromPicture (ClientPtr client)
{
#ifdef RENDER
RegionPtr pRegion;
PicturePtr pPicture;
REQUEST (xXFixesCreateRegionFromPictureReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromPictureReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
VERIFY_PICTURE(pPicture, stuff->picture, client, DixReadAccess,
RenderErrBase + BadPicture);
switch (pPicture->clientClipType) {
case CT_PIXMAP:
pRegion = BITMAP_TO_REGION(pPicture->pDrawable->pScreen,
(PixmapPtr) pPicture->clientClip);
if (!pRegion)
return BadAlloc;
break;
case CT_REGION:
pRegion = XFixesRegionCopy ((RegionPtr) pPicture->clientClip);
if (!pRegion)
return BadAlloc;
break;
default:
return BadImplementation; /* assume sane server bits */
}
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
#else
return BadRequest;
#endif
}
int
ProcXFixesCreateRegion (ClientPtr client)
{
int things;
RegionPtr pRegion;
REQUEST (xXFixesCreateRegionReq);
REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
things = (client->req_len << 2) - sizeof (xXFixesCreateRegionReq);
if (things & 4)
return BadLength;
things >>= 3;
pRegion = RECTS_TO_REGION(0, things, (xRectangle *) (stuff + 1), CT_UNSORTED);
if (!pRegion)
return BadAlloc;
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
}
int
ProcXFixesCreateRegionFromGC (ClientPtr client)
{
RegionPtr pRegion, pClip;
GCPtr pGC;
int rc;
REQUEST (xXFixesCreateRegionFromGCReq);
REQUEST_SIZE_MATCH (xXFixesCreateRegionFromGCReq);
LEGAL_NEW_RESOURCE (stuff->region, client);
rc = dixLookupGC(&pGC, stuff->gc, client, DixReadAccess);
if (rc != Success)
return rc;
switch (pGC->clientClipType) {
case CT_PIXMAP:
pRegion = BITMAP_TO_REGION(pGC->pScreen, (PixmapPtr) pGC->clientClip);
if (!pRegion)
return BadAlloc;
break;
case CT_REGION:
pClip = (RegionPtr) pGC->clientClip;
pRegion = XFixesRegionCopy (pClip);
if (!pRegion)
return BadAlloc;
break;
default:
return BadImplementation; /* assume sane server bits */
}
if (!AddResource (stuff->region, RegionResType, (pointer) pRegion))
return BadAlloc;
return(client->noClientException);
}
int
ProcXFixesCreateRegion(ClientPtr client)
{
int things;
RegionPtr pRegion;
REQUEST(xXFixesCreateRegionReq);
REQUEST_AT_LEAST_SIZE(xXFixesCreateRegionReq);
LEGAL_NEW_RESOURCE(stuff->region, client);
things = (client->req_len << 2) - sizeof(xXFixesCreateRegionReq);
if (things & 4)
return BadLength;
things >>= 3;
pRegion = RegionFromRects(things, (xRectangle *) (stuff + 1), CT_UNSORTED);
if (!pRegion)
return BadAlloc;
if (!AddResource(stuff->region, RegionResType, (void *) pRegion))
return BadAlloc;
return Success;
}
static int
proc_dri3_pixmap_from_buffer(ClientPtr client)
{
REQUEST(xDRI3PixmapFromBufferReq);
int fd;
DrawablePtr drawable;
PixmapPtr pixmap;
int rc;
SetReqFds(client, 1);
REQUEST_SIZE_MATCH(xDRI3PixmapFromBufferReq);
LEGAL_NEW_RESOURCE(stuff->pixmap, client);
rc = dixLookupDrawable(&drawable, stuff->drawable, client, M_ANY, DixGetAttrAccess);
if (rc != Success) {
client->errorValue = stuff->drawable;
return rc;
}
if (!stuff->width || !stuff->height) {
client->errorValue = 0;
return BadValue;
}
if (stuff->width > 32767 || stuff->height > 32767)
return BadAlloc;
if (stuff->depth != 1) {
DepthPtr depth = drawable->pScreen->allowedDepths;
int i;
for (i = 0; i < drawable->pScreen->numDepths; i++, depth++)
if (depth->depth == stuff->depth)
break;
if (i == drawable->pScreen->numDepths) {
client->errorValue = stuff->depth;
return BadValue;
}
}
fd = ReadFdFromClient(client);
if (fd < 0)
return BadValue;
rc = dri3_pixmap_from_fd(&pixmap,
drawable->pScreen, fd,
stuff->width, stuff->height,
stuff->stride, stuff->depth,
stuff->bpp);
close (fd);
if (rc != Success)
return rc;
pixmap->drawable.id = stuff->pixmap;
/* security creation/labeling check */
rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pixmap, RT_PIXMAP,
pixmap, RT_NONE, NULL, DixCreateAccess);
if (rc != Success) {
(*drawable->pScreen->DestroyPixmap) (pixmap);
return rc;
}
if (AddResource(stuff->pixmap, RT_PIXMAP, (void *) pixmap))
return Success;
return Success;
}
static int
ProcPanoramiXShmCreatePixmap(ClientPtr client)
{
ScreenPtr pScreen = NULL;
PixmapPtr pMap = NULL;
DrawablePtr pDraw;
DepthPtr pDepth;
int i, j, result, rc;
ShmDescPtr shmdesc;
REQUEST(xShmCreatePixmapReq);
unsigned int width, height, depth;
unsigned long size;
PanoramiXRes *newPix;
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
client->errorValue = stuff->pid;
if (!sharedPixmaps)
return BadImplementation;
LEGAL_NEW_RESOURCE(stuff->pid, client);
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
DixGetAttrAccess);
if (rc != Success)
return rc;
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
width = stuff->width;
height = stuff->height;
depth = stuff->depth;
if (!width || !height || !depth)
{
client->errorValue = 0;
return BadValue;
}
if (width > 32767 || height > 32767)
return BadAlloc;
if (stuff->depth != 1)
{
pDepth = pDraw->pScreen->allowedDepths;
for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)
if (pDepth->depth == stuff->depth)
goto CreatePmap;
client->errorValue = stuff->depth;
return BadValue;
}
CreatePmap:
size = PixmapBytePad(width, depth) * height;
if (sizeof(size) == 4 && BitsPerPixel(depth) > 8) {
if (size < width * height)
return BadAlloc;
}
/* thankfully, offset is unsigned */
if (stuff->offset + size < size)
return BadAlloc;
VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
if(!(newPix = malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPix->type = XRT_PIXMAP;
newPix->u.pix.shared = TRUE;
newPix->info[0].id = stuff->pid;
for(j = 1; j < PanoramiXNumScreens; j++)
newPix->info[j].id = FakeClientID(client->index);
result = Success;
FOR_NSCREENS(j) {
ShmScrPrivateRec *screen_priv;
pScreen = screenInfo.screens[j];
screen_priv = ShmGetScreenPriv(pScreen);
pMap = (*screen_priv->shmFuncs->CreatePixmap)(pScreen,
stuff->width, stuff->height, stuff->depth,
shmdesc->addr + stuff->offset);
if (pMap) {
dixSetPrivate(&pMap->devPrivates, shmPixmapPrivateKey, shmdesc);
shmdesc->refcnt++;
pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
pMap->drawable.id = newPix->info[j].id;
if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
(*pScreen->DestroyPixmap)(pMap);
result = BadAlloc;
break;
}
} else {
result = BadAlloc;
break;
}
}
if(result == BadAlloc) {
while(j--) {
(*pScreen->DestroyPixmap)(pMap);
FreeResource(newPix->info[j].id, RT_NONE);
}
free(newPix);
} else
AddResource(stuff->pid, XRT_PIXMAP, newPix);
return result;
}
static int
ProcDamageCreate (ClientPtr client)
{
DrawablePtr pDrawable;
DamageExtPtr pDamageExt;
DamageReportLevel level;
RegionPtr pRegion;
int rc;
REQUEST(xDamageCreateReq);
REQUEST_SIZE_MATCH(xDamageCreateReq);
LEGAL_NEW_RESOURCE(stuff->damage, client);
rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
DixGetAttrAccess|DixReadAccess);
if (rc != Success)
return rc;
switch (stuff->level) {
case XDamageReportRawRectangles:
level = DamageReportRawRegion;
break;
case XDamageReportDeltaRectangles:
level = DamageReportDeltaRegion;
break;
case XDamageReportBoundingBox:
level = DamageReportBoundingBox;
break;
case XDamageReportNonEmpty:
level = DamageReportNonEmpty;
break;
default:
client->errorValue = stuff->level;
return BadValue;
}
pDamageExt = malloc(sizeof (DamageExtRec));
if (!pDamageExt)
return BadAlloc;
pDamageExt->id = stuff->damage;
pDamageExt->drawable = stuff->drawable;
pDamageExt->pDrawable = pDrawable;
pDamageExt->level = level;
pDamageExt->pClient = client;
pDamageExt->pDamage = DamageCreate (DamageExtReport,
DamageExtDestroy,
level,
FALSE,
pDrawable->pScreen,
pDamageExt);
if (!pDamageExt->pDamage)
{
free(pDamageExt);
return BadAlloc;
}
if (!AddResource (stuff->damage, DamageExtType, (pointer) pDamageExt))
return BadAlloc;
DamageSetReportAfterOp (pDamageExt->pDamage, TRUE);
DamageRegister (pDamageExt->pDrawable, pDamageExt->pDamage);
if (pDrawable->type == DRAWABLE_WINDOW)
{
pRegion = &((WindowPtr) pDrawable)->borderClip;
DamageDamageRegion(pDrawable, pRegion);
}
return Success;
}
static int
ProcShmCreatePixmap(ClientPtr client)
{
PixmapPtr pMap;
DrawablePtr pDraw;
DepthPtr pDepth;
int i, rc;
ShmDescPtr shmdesc;
ShmScrPrivateRec *screen_priv;
REQUEST(xShmCreatePixmapReq);
unsigned int width, height, depth;
unsigned long size;
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
client->errorValue = stuff->pid;
if (!sharedPixmaps)
return BadImplementation;
LEGAL_NEW_RESOURCE(stuff->pid, client);
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
DixGetAttrAccess);
if (rc != Success)
return rc;
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
width = stuff->width;
height = stuff->height;
depth = stuff->depth;
if (!width || !height || !depth)
{
client->errorValue = 0;
return BadValue;
}
if (width > 32767 || height > 32767)
return BadAlloc;
if (stuff->depth != 1)
{
pDepth = pDraw->pScreen->allowedDepths;
for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)
if (pDepth->depth == stuff->depth)
goto CreatePmap;
client->errorValue = stuff->depth;
return BadValue;
}
CreatePmap:
size = PixmapBytePad(width, depth) * height;
if (sizeof(size) == 4 && BitsPerPixel(depth) > 8) {
if (size < width * height)
return BadAlloc;
}
/* thankfully, offset is unsigned */
if (stuff->offset + size < size)
return BadAlloc;
VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
screen_priv = ShmGetScreenPriv(pDraw->pScreen);
pMap = (*screen_priv->shmFuncs->CreatePixmap)(
pDraw->pScreen, stuff->width,
stuff->height, stuff->depth,
shmdesc->addr + stuff->offset);
if (pMap)
{
rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, RT_PIXMAP,
pMap, RT_NONE, NULL, DixCreateAccess);
if (rc != Success) {
pDraw->pScreen->DestroyPixmap(pMap);
return rc;
}
dixSetPrivate(&pMap->devPrivates, shmPixmapPrivateKey, shmdesc);
shmdesc->refcnt++;
pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
pMap->drawable.id = stuff->pid;
if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
{
return Success;
}
pDraw->pScreen->DestroyPixmap(pMap);
}
return BadAlloc;
}
int
__glXDisp_CreateContextAttribsARB(__GLXclientState * cl, GLbyte * pc)
{
ClientPtr client = cl->client;
xGLXCreateContextAttribsARBReq *req = (xGLXCreateContextAttribsARBReq *) pc;
int32_t *attribs = (req->numAttribs != 0) ? (int32_t *) (req + 1) : NULL;
unsigned i;
int major_version = 1;
int minor_version = 0;
uint32_t flags = 0;
uint32_t render_type = GLX_RGBA_TYPE;
__GLXcontext *ctx = NULL;
__GLXcontext *shareCtx = NULL;
__GLXscreen *glxScreen;
__GLXconfig *config;
int err;
/* The GLX_ARB_create_context_robustness spec says:
*
* "The default value for GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB
* is GLX_NO_RESET_NOTIFICATION_ARB."
*/
int reset = GLX_NO_RESET_NOTIFICATION_ARB;
/* The GLX_ARB_create_context_profile spec says:
*
* "The default value for GLX_CONTEXT_PROFILE_MASK_ARB is
* GLX_CONTEXT_CORE_PROFILE_BIT_ARB."
*
* The core profile only makes sense for OpenGL versions 3.2 and later.
* If the version ultimately specified is less than 3.2, the core profile
* bit is cleared (see below).
*/
int profile = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
/* Verify that the size of the packet matches the size inferred from the
* sizes specified for the various fields.
*/
const unsigned expected_size = (sz_xGLXCreateContextAttribsARBReq
+ (req->numAttribs * 8)) / 4;
if (req->length != expected_size)
return BadLength;
LEGAL_NEW_RESOURCE(req->context, client);
/* The GLX_ARB_create_context spec says:
*
* "* If <config> is not a valid GLXFBConfig, GLXBadFBConfig is
* generated."
*
* On the client, the screen comes from the FBConfig, so GLXBadFBConfig
* should be issued if the screen is nonsense.
*/
if (!validGlxScreen(client, req->screen, &glxScreen, &err))
return __glXError(GLXBadFBConfig);
if (!validGlxFBConfig(client, glxScreen, req->fbconfig, &config, &err))
return __glXError(GLXBadFBConfig);
/* Validate the context with which the new context should share resources.
*/
if (req->shareList != None) {
if (!validGlxContext(client, req->shareList, DixReadAccess,
&shareCtx, &err))
return err;
/* The crazy condition is because C doesn't have a logical XOR
* operator. Comparing directly for equality may fail if one is 1 and
* the other is 2 even though both are logically true.
*/
if (!!req->isDirect != !!shareCtx->isDirect) {
client->errorValue = req->shareList;
return BadMatch;
}
/* The GLX_ARB_create_context spec says:
*
* "* If the server context state for <share_context>...was
* created on a different screen than the one referenced by
* <config>...BadMatch is generated."
*/
if (glxScreen != shareCtx->pGlxScreen) {
client->errorValue = shareCtx->pGlxScreen->pScreen->myNum;
return BadMatch;
}
}
for (i = 0; i < req->numAttribs; i++) {
switch (attribs[i * 2]) {
case GLX_CONTEXT_MAJOR_VERSION_ARB:
major_version = attribs[2 * i + 1];
break;
case GLX_CONTEXT_MINOR_VERSION_ARB:
minor_version = attribs[2 * i + 1];
break;
case GLX_CONTEXT_FLAGS_ARB:
flags = attribs[2 * i + 1];
break;
case GLX_RENDER_TYPE:
render_type = attribs[2 * i + 1];
break;
case GLX_CONTEXT_PROFILE_MASK_ARB:
profile = attribs[2 * i + 1];
break;
case GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB:
reset = attribs[2 * i + 1];
if (reset != GLX_NO_RESET_NOTIFICATION_ARB
&& reset != GLX_LOSE_CONTEXT_ON_RESET_ARB)
return BadValue;
break;
default:
return BadValue;
}
}
/* The GLX_ARB_create_context spec says:
*
* "If attributes GLX_CONTEXT_MAJOR_VERSION_ARB and
* GLX_CONTEXT_MINOR_VERSION_ARB, when considered together
* with attributes GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB and
* GLX_RENDER_TYPE, specify an OpenGL version and feature set
* that are not defined, BadMatch is generated.
*
* ...Feature deprecation was introduced with OpenGL 3.0, so
* forward-compatible contexts may only be requested for
* OpenGL 3.0 and above. Thus, examples of invalid
* combinations of attributes include:
*
* - Major version < 1 or > 3
* - Major version == 1 and minor version < 0 or > 5
* - Major version == 2 and minor version < 0 or > 1
* - Major version == 3 and minor version > 2
* - Forward-compatible flag set and major version < 3
* - Color index rendering and major version >= 3"
*/
if (!validate_GL_version(major_version, minor_version))
return BadMatch;
if (major_version < 3
&& ((flags & GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) != 0))
return BadMatch;
if (major_version >= 3 && render_type == GLX_COLOR_INDEX_TYPE)
return BadMatch;
if (!validate_render_type(render_type))
return BadValue;
if ((flags & ~ALL_VALID_FLAGS) != 0)
return BadValue;
/* The GLX_ARB_create_context_profile spec says:
*
* "* If attribute GLX_CONTEXT_PROFILE_MASK_ARB has no bits set; has
* any bits set other than GLX_CONTEXT_CORE_PROFILE_BIT_ARB and
* GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; has more than one of
* these bits set; or if the implementation does not support the
* requested profile, then GLXBadProfileARB is generated."
*/
switch (profile) {
case GLX_CONTEXT_CORE_PROFILE_BIT_ARB:
case GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB:
break;
case GLX_CONTEXT_ES2_PROFILE_BIT_EXT:
/* The GLX_EXT_create_context_es2_profile spec says:
*
* "... If the version requested is 2.0, and the
* GLX_CONTEXT_ES2_PROFILE_BIT_EXT bit is set in the
* GLX_CONTEXT_PROFILE_MASK_ARB attribute (see below), then the
* context returned will implement OpenGL ES 2.0."
*
* It also says:
*
* "* If attribute GLX_CONTEXT_PROFILE_MASK_ARB has no bits set;
* has any bits set other than
* GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
* GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, or
* GLX_CONTEXT_ES2_PROFILE_BIT_EXT; has more than one of these
* bits set; or if the implementation does not supported the
* requested profile, then GLXBadProfileARB is generated."
*
* It does not specifically say what is supposed to happen if
* GLX_CONTEXT_ES2_PROFILE_BIT_EXT is set but the version requested is
* not 2.0. We choose to generate GLXBadProfileARB as this matches
* NVIDIA's behavior.
*/
if (major_version != 2 || minor_version != 0)
return __glXError(GLXBadProfileARB);
break;
default:
return __glXError(GLXBadProfileARB);
}
/* The GLX_ARB_create_context_robustness spec says:
*
* "* If the reset notification behavior of <share_context> and the
* newly created context are different, BadMatch is generated."
*/
if (shareCtx != NULL && shareCtx->resetNotificationStrategy != reset)
return BadMatch;
/* There is no GLX protocol for desktop OpenGL versions after 1.4. There
* is no GLX protocol for any version of OpenGL ES. If the application is
* requested an indirect rendering context for a version that cannot be
* satisfied, reject it.
*
* The GLX_ARB_create_context spec says:
*
* "* If <config> does not support compatible OpenGL contexts
* providing the requested API major and minor version,
* forward-compatible flag, and debug context flag, GLXBadFBConfig
* is generated."
*/
if (!req->isDirect && (major_version > 1 || minor_version > 4
|| profile == GLX_CONTEXT_ES2_PROFILE_BIT_EXT)) {
return __glXError(GLXBadFBConfig);
}
/* Allocate memory for the new context
*/
if (req->isDirect) {
ctx = __glXdirectContextCreate(glxScreen, config, shareCtx);
err = BadAlloc;
}
else {
ctx = glxScreen->createContext(glxScreen, config, shareCtx,
req->numAttribs, (uint32_t *) attribs,
&err);
}
if (ctx == NULL)
return err;
ctx->pGlxScreen = glxScreen;
ctx->config = config;
ctx->id = req->context;
ctx->share_id = req->shareList;
ctx->idExists = True;
ctx->isCurrent = False;
ctx->isDirect = req->isDirect;
ctx->hasUnflushedCommands = False;
ctx->renderMode = GL_RENDER;
ctx->feedbackBuf = NULL;
ctx->feedbackBufSize = 0;
ctx->selectBuf = NULL;
ctx->selectBufSize = 0;
ctx->drawPriv = NULL;
ctx->readPriv = NULL;
ctx->resetNotificationStrategy = reset;
/* Add the new context to the various global tables of GLX contexts.
*/
if (!__glXAddContext(ctx)) {
(*ctx->destroy) (ctx);
client->errorValue = req->context;
return BadAlloc;
}
return Success;
}
static int
proc_dri3_buffer_from_pixmap(ClientPtr client)
{
REQUEST(xDRI3BufferFromPixmapReq);
xDRI3BufferFromPixmapReply rep = {
.type = X_Reply,
.nfd = 1,
.sequenceNumber = client->sequence,
.length = 0,
};
int rc;
int fd;
PixmapPtr pixmap;
REQUEST_SIZE_MATCH(xDRI3BufferFromPixmapReq);
rc = dixLookupResourceByType((void **) &pixmap, stuff->pixmap, RT_PIXMAP,
client, DixWriteAccess);
if (rc != Success) {
client->errorValue = stuff->pixmap;
return rc;
}
rep.width = pixmap->drawable.width;
rep.height = pixmap->drawable.height;
rep.depth = pixmap->drawable.depth;
rep.bpp = pixmap->drawable.bitsPerPixel;
rc = dri3_fd_from_pixmap(&fd, pixmap, &rep.stride, &rep.size);
if (rc != Success)
return rc;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.size);
swaps(&rep.width);
swaps(&rep.height);
swaps(&rep.stride);
}
if (WriteFdToClient(client, fd, TRUE) < 0) {
close(fd);
return BadAlloc;
}
WriteToClient(client, sizeof(rep), &rep);
return client->noClientException;
}
static int
proc_dri3_fence_from_fd(ClientPtr client)
{
REQUEST(xDRI3FenceFromFDReq);
DrawablePtr drawable;
int fd;
int status;
SetReqFds(client, 1);
REQUEST_SIZE_MATCH(xDRI3FenceFromFDReq);
LEGAL_NEW_RESOURCE(stuff->fence, client);
status = dixLookupDrawable(&drawable, stuff->drawable, client, M_ANY, DixGetAttrAccess);
if (status != Success)
return status;
fd = ReadFdFromClient(client);
if (fd < 0)
return BadValue;
status = SyncCreateFenceFromFD(client, drawable, stuff->fence,
fd, stuff->initially_triggered);
return status;
}