int
ProcListExtensions(ClientPtr client)
{
xListExtensionsReply reply;
char *bufptr, *buffer;
int total_length = 0;
REQUEST_SIZE_MATCH(xReq);
memset(&reply, 0, sizeof(xListExtensionsReply));
reply.type = X_Reply;
reply.nExtensions = 0;
reply.length = 0;
reply.sequenceNumber = client->sequence;
buffer = NULL;
if ( NumExtensions )
{
int i, j;
for (i=0; i<NumExtensions; i++)
{
/* call callbacks to find out whether to show extension */
if (XaceHook(XACE_EXT_ACCESS, client, extensions[i]) != Success)
continue;
total_length += strlen(extensions[i]->name) + 1;
reply.nExtensions += 1 + extensions[i]->num_aliases;
for (j = extensions[i]->num_aliases; --j >= 0;)
total_length += strlen(extensions[i]->aliases[j]) + 1;
}
reply.length = bytes_to_int32(total_length);
buffer = bufptr = malloc(total_length);
if (!buffer)
return BadAlloc;
for (i=0; i<NumExtensions; i++)
{
int len;
if (XaceHook(XACE_EXT_ACCESS, client, extensions[i]) != Success)
continue;
*bufptr++ = len = strlen(extensions[i]->name);
memmove(bufptr, extensions[i]->name, len);
bufptr += len;
for (j = extensions[i]->num_aliases; --j >= 0;)
{
*bufptr++ = len = strlen(extensions[i]->aliases[j]);
memmove(bufptr, extensions[i]->aliases[j], len);
bufptr += len;
}
}
}
WriteReplyToClient(client, sizeof(xListExtensionsReply), &reply);
if (reply.length)
WriteToClient(client, total_length, buffer);
free(buffer);
return Success;
}
int
dixLookupClient(ClientPtr *pClient, XID rid, ClientPtr client, Mask access)
{
pointer pRes;
int rc = BadValue, clientIndex = CLIENT_ID(rid);
if (!clientIndex || !clients[clientIndex] || (rid & SERVER_BIT))
goto bad;
rc = dixLookupResourceByClass(&pRes, rid, RC_ANY, client, DixGetAttrAccess);
if (rc != Success)
goto bad;
rc = XaceHook(XACE_CLIENT_ACCESS, client, clients[clientIndex], access);
if (rc != Success)
goto bad;
*pClient = clients[clientIndex];
return Success;
bad:
if (client)
client->errorValue = rid;
*pClient = NULL;
return rc;
}
/* Check if a button map change is okay with the device.
* Returns -1 for BadValue, as it collides with MappingBusy. */
static int
check_butmap_change(DeviceIntPtr dev, CARD8 *map, int len, CARD32 *errval_out,
ClientPtr client)
{
int i, ret;
if (!dev || !dev->button)
{
client->errorValue = (dev) ? dev->id : 0;
return BadDevice;
}
ret = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixManageAccess);
if (ret != Success)
{
client->errorValue = dev->id;
return ret;
}
for (i = 0; i < len; i++) {
if (dev->button->map[i + 1] != map[i] && dev->button->down[i + 1])
return MappingBusy;
}
return Success;
}
int
ProcQueryExtension(ClientPtr client)
{
xQueryExtensionReply reply;
int i;
REQUEST(xQueryExtensionReq);
REQUEST_FIXED_SIZE(xQueryExtensionReq, stuff->nbytes);
memset(&reply, 0, sizeof(xQueryExtensionReply));
reply.type = X_Reply;
reply.length = 0;
reply.major_opcode = 0;
reply.sequenceNumber = client->sequence;
if ( ! NumExtensions )
reply.present = xFalse;
else
{
i = FindExtension((char *)&stuff[1], stuff->nbytes);
if (i < 0 || XaceHook(XACE_EXT_ACCESS, client, extensions[i]))
reply.present = xFalse;
else
{
reply.present = xTrue;
reply.major_opcode = extensions[i]->base;
reply.first_event = extensions[i]->eventBase;
reply.first_error = extensions[i]->errorBase;
}
}
WriteReplyToClient(client, sizeof(xQueryExtensionReply), &reply);
return Success;
}
/**
* @return Whether the device should be included in the returned list.
*/
static Bool
ShouldSkipDevice(ClientPtr client, int deviceid, DeviceIntPtr dev)
{
/* if all devices are not being queried, only master devices are */
if (deviceid == XIAllDevices || IsMaster(dev)) {
int rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixGetAttrAccess);
if (rc == Success)
return FALSE;
}
return TRUE;
}
int generate_modkeymap(ClientPtr client, DeviceIntPtr dev,
KeyCode **modkeymap_out, int *max_keys_per_mod_out)
{
CARD8 keys_per_mod[8];
int max_keys_per_mod;
KeyCode *modkeymap = NULL;
int i, j, ret;
ret = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixGetAttrAccess);
if (ret != Success)
return ret;
if (!dev->key)
return BadMatch;
/* Count the number of keys per modifier to determine how wide we
* should make the map. */
max_keys_per_mod = 0;
for (i = 0; i < 8; i++)
keys_per_mod[i] = 0;
for (i = 8; i < MAP_LENGTH; i++) {
for (j = 0; j < 8; j++) {
if (dev->key->xkbInfo->desc->map->modmap[i] & (1 << j)) {
if (++keys_per_mod[j] > max_keys_per_mod)
max_keys_per_mod = keys_per_mod[j];
}
}
}
if (max_keys_per_mod != 0) {
modkeymap = calloc(max_keys_per_mod * 8, sizeof(KeyCode));
if (!modkeymap)
return BadAlloc;
for (i = 0; i < 8; i++)
keys_per_mod[i] = 0;
for (i = 8; i < MAP_LENGTH; i++) {
for (j = 0; j < 8; j++) {
if (dev->key->xkbInfo->desc->map->modmap[i] & (1 << j)) {
modkeymap[(j * max_keys_per_mod) + keys_per_mod[j]] = i;
keys_per_mod[j]++;
}
}
}
}
*max_keys_per_mod_out = max_keys_per_mod;
*modkeymap_out = modkeymap;
return Success;
}
/* Check if a modifier map change is okay with the device.
* Returns -1 for BadValue, as it collides with MappingBusy; this particular
* caveat can be removed with LegalModifier, as we have no other reason to
* set MappingFailed. Sigh. */
static int
check_modmap_change(ClientPtr client, DeviceIntPtr dev, KeyCode *modmap)
{
int ret, i;
XkbDescPtr xkb;
ret = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixManageAccess);
if (ret != Success)
return ret;
if (!dev->key)
return BadMatch;
xkb = dev->key->xkbInfo->desc;
for (i = 0; i < MAP_LENGTH; i++) {
if (!modmap[i])
continue;
/* Check that all the new modifiers fall within the advertised
* keycode range. */
if (i < xkb->min_key_code || i > xkb->max_key_code) {
client->errorValue = i;
return -1;
}
/* Make sure the mapping is okay with the DDX. */
if (!LegalModifier(i, dev)) {
client->errorValue = i;
return MappingFailed;
}
/* None of the new modifiers may be down while we change the
* map. */
if (key_is_down(dev, i, KEY_POSTED | KEY_PROCESSED)) {
client->errorValue = i;
return MappingBusy;
}
}
/* None of the old modifiers may be down while we change the map,
* either. */
for (i = xkb->min_key_code; i < xkb->max_key_code; i++) {
if (!xkb->map->modmap[i])
continue;
if (key_is_down(dev, i, KEY_POSTED | KEY_PROCESSED)) {
client->errorValue = i;
return MappingBusy;
}
}
return Success;
}
/**
* Write the class info of the device into the memory pointed to by any, set
* nclasses to the number of classes in total and return the number of bytes
* written.
*/
int
ListDeviceClasses(ClientPtr client, DeviceIntPtr dev,
char *any, uint16_t * nclasses)
{
int total_len = 0;
int len;
int i;
int rc;
/* Check if the current device state should be suppressed */
rc = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixReadAccess);
if (dev->button) {
(*nclasses)++;
len = ListButtonInfo(dev, (xXIButtonInfo *) any, rc == Success);
any += len;
total_len += len;
}
if (dev->key) {
(*nclasses)++;
len = ListKeyInfo(dev, (xXIKeyInfo *) any);
any += len;
total_len += len;
}
for (i = 0; dev->valuator && i < dev->valuator->numAxes; i++) {
(*nclasses)++;
len = ListValuatorInfo(dev, (xXIValuatorInfo *) any, i, rc == Success);
any += len;
total_len += len;
}
for (i = 0; dev->valuator && i < dev->valuator->numAxes; i++) {
len = ListScrollInfo(dev, (xXIScrollInfo *) any, i);
if (len)
(*nclasses)++;
any += len;
total_len += len;
}
if (dev->touch) {
(*nclasses)++;
len = ListTouchInfo(dev, (xXITouchInfo *) any);
any += len;
total_len += len;
}
return total_len;
}
/* CreateGC(pDrawable, mask, pval, pStatus)
creates a default GC for the given drawable, using mask to fill
in any non-default values.
Returns a pointer to the new GC on success, NULL otherwise.
returns status of non-default fields in pStatus
BUG:
should check for failure to create default tile
*/
GCPtr
CreateGC(DrawablePtr pDrawable, BITS32 mask, XID *pval, int *pStatus,
XID gcid, ClientPtr client)
{
GCPtr pGC;
pGC = NewGCObject(pDrawable->pScreen, pDrawable->depth);
if (!pGC) {
*pStatus = BadAlloc;
return (GCPtr) NULL;
}
pGC->serialNumber = GC_CHANGE_SERIAL_BIT;
if (mask & GCForeground) {
/*
* magic special case -- ChangeGC checks for this condition
* and snags the Foreground value to create a pseudo default-tile
*/
pGC->tileIsPixel = FALSE;
}
else {
pGC->tileIsPixel = TRUE;
}
/* security creation/labeling check */
*pStatus = XaceHook(XACE_RESOURCE_ACCESS, client, gcid, RT_GC, pGC,
RT_NONE, NULL, DixCreateAccess | DixSetAttrAccess);
if (*pStatus != Success)
goto out;
pGC->stateChanges = GCAllBits;
if (!(*pGC->pScreen->CreateGC) (pGC))
*pStatus = BadAlloc;
else if (mask)
*pStatus = ChangeGCXIDs(client, pGC, mask, pval);
else
*pStatus = Success;
out:
if (*pStatus != Success) {
if (!pGC->tileIsPixel && !pGC->tile.pixmap)
pGC->tileIsPixel = TRUE; /* undo special case */
FreeGC(pGC, (XID) 0);
pGC = (GCPtr) NULL;
}
return pGC;
}
/**
* Prepend the new grab to the list of passive grabs on the window.
* Any previously existing grab that matches the new grab will be removed.
* Adding a new grab that would override another client's grab will result in
* a BadAccess.
*
* @return Success or X error code on failure.
*/
int
AddPassiveGrabToList(ClientPtr client, GrabPtr pGrab)
{
GrabPtr grab;
Mask access_mode = DixGrabAccess;
int rc;
for (grab = wPassiveGrabs(pGrab->window); grab; grab = grab->next)
{
if (GrabMatchesSecond(pGrab, grab, FALSE))
{
if (CLIENT_BITS(pGrab->resource) != CLIENT_BITS(grab->resource))
{
FreeGrab(pGrab);
return BadAccess;
}
}
}
if (pGrab->keyboardMode == GrabModeSync||pGrab->pointerMode == GrabModeSync)
access_mode |= DixFreezeAccess;
rc = XaceHook(XACE_DEVICE_ACCESS, client, pGrab->device, access_mode);
if (rc != Success)
return rc;
/* Remove all grabs that match the new one exactly */
for (grab = wPassiveGrabs(pGrab->window); grab; grab = grab->next)
{
if (GrabsAreIdentical(pGrab, grab))
{
DeletePassiveGrabFromList(grab);
break;
}
}
if (!pGrab->window->optional && !MakeWindowOptional (pGrab->window))
{
FreeGrab(pGrab);
return BadAlloc;
}
pGrab->next = pGrab->window->optional->passiveGrabs;
pGrab->window->optional->passiveGrabs = pGrab;
if (AddResource(pGrab->resource, RT_PASSIVEGRAB, (pointer)pGrab))
return Success;
return BadAlloc;
}
int
AnimCursorCreate (CursorPtr *cursors, CARD32 *deltas, int ncursor, CursorPtr *ppCursor, ClientPtr client, XID cid)
{
CursorPtr pCursor;
int rc, i;
AnimCurPtr ac;
for (i = 0; i < screenInfo.numScreens; i++)
if (!GetAnimCurScreenIfSet (screenInfo.screens[i]))
return BadImplementation;
for (i = 0; i < ncursor; i++)
if (IsAnimCur (cursors[i]))
return BadMatch;
pCursor = (CursorPtr) xalloc (sizeof (CursorRec) +
sizeof (AnimCurRec) +
ncursor * sizeof (AnimCurElt));
if (!pCursor)
return BadAlloc;
pCursor->bits = &animCursorBits;
pCursor->refcnt = 1;
pCursor->foreRed = cursors[0]->foreRed;
pCursor->foreGreen = cursors[0]->foreGreen;
pCursor->foreBlue = cursors[0]->foreBlue;
pCursor->backRed = cursors[0]->backRed;
pCursor->backGreen = cursors[0]->backGreen;
pCursor->backBlue = cursors[0]->backBlue;
pCursor->id = cid;
pCursor->devPrivates = NULL;
/* security creation/labeling check */
rc = XaceHook(XACE_RESOURCE_ACCESS, client, cid, RT_CURSOR, pCursor,
RT_NONE, NULL, DixCreateAccess);
if (rc != Success) {
dixFreePrivates(pCursor->devPrivates);
xfree(pCursor);
return rc;
}
/*
* Fill in the AnimCurRec
*/
animCursorBits.refcnt++;
ac = GetAnimCur (pCursor);
ac->nelt = ncursor;
ac->elts = (AnimCurElt *) (ac + 1);
for (i = 0; i < ncursor; i++)
{
cursors[i]->refcnt++;
ac->elts[i].pCursor = cursors[i];
ac->elts[i].delay = deltas[i];
}
*ppCursor = pCursor;
return Success;
}
static int
XFixesSelectSelectionInput(ClientPtr pClient,
Atom selection, WindowPtr pWindow, CARD32 eventMask)
{
pointer val;
int rc;
SelectionEventPtr *prev, e;
rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);
if (rc != Success)
return rc;
for (prev = &selectionEvents; (e = *prev); prev = &e->next) {
if (e->selection == selection &&
e->pClient == pClient && e->pWindow == pWindow) {
break;
}
}
if (!eventMask) {
if (e) {
FreeResource(e->clientResource, 0);
}
return Success;
}
if (!e) {
e = (SelectionEventPtr) malloc(sizeof(SelectionEventRec));
if (!e)
return BadAlloc;
e->next = 0;
e->selection = selection;
e->pClient = pClient;
e->pWindow = pWindow;
e->clientResource = FakeClientID(pClient->index);
/*
* Add a resource hanging from the window to
* catch window destroy
*/
rc = dixLookupResourceByType(&val, pWindow->drawable.id,
SelectionWindowType, serverClient,
DixGetAttrAccess);
if (rc != Success)
if (!AddResource(pWindow->drawable.id, SelectionWindowType,
(pointer) pWindow)) {
free(e);
return BadAlloc;
}
if (!AddResource(e->clientResource, SelectionClientType, (pointer) e))
return BadAlloc;
*prev = e;
if (!CheckSelectionCallback()) {
FreeResource(e->clientResource, 0);
return BadAlloc;
}
}
e->eventMask = eventMask;
return Success;
}
int
AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
unsigned foreRed, unsigned foreGreen, unsigned foreBlue,
unsigned backRed, unsigned backGreen, unsigned backBlue,
CursorPtr *ppCurs, ClientPtr client, XID cid)
{
FontPtr sourcefont, maskfont;
unsigned char *srcbits;
unsigned char *mskbits;
CursorMetricRec cm;
int rc;
CursorBitsPtr bits;
CursorPtr pCurs;
GlyphSharePtr pShare;
rc = dixLookupResourceByType((pointer *)&sourcefont, source, RT_FONT, client,
DixUseAccess);
if (rc != Success)
{
client->errorValue = source;
return rc;
}
rc = dixLookupResourceByType((pointer *)&maskfont, mask, RT_FONT, client,
DixUseAccess);
if (rc != Success && mask != None)
{
client->errorValue = mask;
return rc;
}
if (sourcefont != maskfont)
pShare = (GlyphSharePtr)NULL;
else
{
for (pShare = sharedGlyphs;
pShare &&
((pShare->font != sourcefont) ||
(pShare->sourceChar != sourceChar) ||
(pShare->maskChar != maskChar));
pShare = pShare->next)
;
}
if (pShare)
{
pCurs = (CursorPtr)calloc(CURSOR_REC_SIZE, 1);
if (!pCurs)
return BadAlloc;
dixInitPrivates(pCurs, pCurs + 1, PRIVATE_CURSOR);
bits = pShare->bits;
bits->refcnt++;
}
else
{
if (!CursorMetricsFromGlyph(sourcefont, sourceChar, &cm))
{
client->errorValue = sourceChar;
return BadValue;
}
if (!maskfont)
{
long n;
unsigned char *mskptr;
n = BitmapBytePad(cm.width)*(long)cm.height;
mskptr = mskbits = malloc(n);
if (!mskptr)
return BadAlloc;
while (--n >= 0)
*mskptr++ = ~0;
}
else
{
if (!CursorMetricsFromGlyph(maskfont, maskChar, &cm))
{
client->errorValue = maskChar;
return BadValue;
}
if ((rc = ServerBitsFromGlyph(maskfont, maskChar, &cm, &mskbits)))
return rc;
}
if ((rc = ServerBitsFromGlyph(sourcefont, sourceChar, &cm, &srcbits)))
{
free(mskbits);
return rc;
}
if (sourcefont != maskfont)
{
pCurs =
(CursorPtr)calloc(CURSOR_REC_SIZE + CURSOR_BITS_SIZE, 1);
if (pCurs)
bits = (CursorBitsPtr)((char *)pCurs + CURSOR_REC_SIZE);
else
bits = (CursorBitsPtr)NULL;
}
else
{
pCurs = (CursorPtr)calloc(CURSOR_REC_SIZE, 1);
if (pCurs)
bits = (CursorBitsPtr)calloc(CURSOR_BITS_SIZE, 1);
else
bits = (CursorBitsPtr)NULL;
}
if (!bits)
{
free(pCurs);
free(mskbits);
free(srcbits);
return BadAlloc;
}
dixInitPrivates(pCurs, pCurs + 1, PRIVATE_CURSOR);
dixInitPrivates(bits, bits + 1, PRIVATE_CURSOR_BITS);
bits->source = srcbits;
bits->mask = mskbits;
#ifdef ARGB_CURSOR
bits->argb = 0;
#endif
bits->width = cm.width;
bits->height = cm.height;
bits->xhot = cm.xhot;
bits->yhot = cm.yhot;
if (sourcefont != maskfont)
bits->refcnt = -1;
else
{
bits->refcnt = 1;
pShare = malloc(sizeof(GlyphShare));
if (!pShare)
{
FreeCursorBits(bits);
return BadAlloc;
}
pShare->font = sourcefont;
sourcefont->refcnt++;
pShare->sourceChar = sourceChar;
pShare->maskChar = maskChar;
pShare->bits = bits;
pShare->next = sharedGlyphs;
sharedGlyphs = pShare;
}
}
CheckForEmptyMask(bits);
pCurs->bits = bits;
pCurs->refcnt = 1;
#ifdef XFIXES
pCurs->serialNumber = ++cursorSerial;
pCurs->name = None;
#endif
pCurs->foreRed = foreRed;
pCurs->foreGreen = foreGreen;
pCurs->foreBlue = foreBlue;
pCurs->backRed = backRed;
pCurs->backGreen = backGreen;
pCurs->backBlue = backBlue;
pCurs->id = cid;
/* security creation/labeling check */
rc = XaceHook(XACE_RESOURCE_ACCESS, client, cid, RT_CURSOR,
pCurs, RT_NONE, NULL, DixCreateAccess);
if (rc != Success)
goto error;
rc = RealizeCursorAllScreens(pCurs);
if (rc != Success)
goto error;
*ppCurs = pCurs;
return Success;
error:
FreeCursorBits(bits);
dixFiniPrivates(pCurs, PRIVATE_CURSOR);
free(pCurs);
return rc;
}
/**
* does nothing about the resource table, just creates the data structure.
* does not copy the src and mask bits
*
* \param psrcbits server-defined padding
* \param pmaskbits server-defined padding
* \param argb no padding
*/
int
AllocARGBCursor(unsigned char *psrcbits, unsigned char *pmaskbits,
CARD32 *argb, CursorMetricPtr cm,
unsigned foreRed, unsigned foreGreen, unsigned foreBlue,
unsigned backRed, unsigned backGreen, unsigned backBlue,
CursorPtr *ppCurs, ClientPtr client, XID cid)
{
CursorBitsPtr bits;
CursorPtr pCurs;
int rc;
*ppCurs = NULL;
pCurs = (CursorPtr)calloc(CURSOR_REC_SIZE + CURSOR_BITS_SIZE, 1);
if (!pCurs)
return BadAlloc;
bits = (CursorBitsPtr)((char *)pCurs + CURSOR_REC_SIZE);
dixInitPrivates(pCurs, pCurs + 1, PRIVATE_CURSOR);
dixInitPrivates(bits, bits + 1, PRIVATE_CURSOR_BITS)
bits->source = psrcbits;
bits->mask = pmaskbits;
#ifdef ARGB_CURSOR
bits->argb = argb;
#endif
bits->width = cm->width;
bits->height = cm->height;
bits->xhot = cm->xhot;
bits->yhot = cm->yhot;
pCurs->refcnt = 1;
bits->refcnt = -1;
CheckForEmptyMask(bits);
pCurs->bits = bits;
#ifdef XFIXES
pCurs->serialNumber = ++cursorSerial;
pCurs->name = None;
#endif
pCurs->foreRed = foreRed;
pCurs->foreGreen = foreGreen;
pCurs->foreBlue = foreBlue;
pCurs->backRed = backRed;
pCurs->backGreen = backGreen;
pCurs->backBlue = backBlue;
pCurs->id = cid;
/* security creation/labeling check */
rc = XaceHook(XACE_RESOURCE_ACCESS, client, cid, RT_CURSOR,
pCurs, RT_NONE, NULL, DixCreateAccess);
if (rc != Success)
goto error;
rc = RealizeCursorAllScreens(pCurs);
if (rc != Success)
goto error;
*ppCurs = pCurs;
return Success;
error:
FreeCursorBits(bits);
dixFiniPrivates(pCurs, PRIVATE_CURSOR);
free(pCurs);
return rc;
}
void
OpenInputDevice(DeviceIntPtr dev, ClientPtr client, int *status)
{
*status = XaceHook(XACE_DEVICE_ACCESS, client, dev, DixUseAccess);
}
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;
}
char *
ClientAuthorized(ClientPtr client,
unsigned int proto_n, char *auth_proto,
unsigned int string_n, char *auth_string)
{
OsCommPtr priv;
Xtransaddr *from = NULL;
int family;
int fromlen;
XID auth_id;
char *reason = NULL;
XtransConnInfo trans_conn;
priv = (OsCommPtr)client->osPrivate;
trans_conn = priv->trans_conn;
/* Allow any client to connect without authorization on a launchd socket,
because it is securely created -- this prevents a race condition on launch */
if(trans_conn->flags & TRANS_NOXAUTH) {
auth_id = (XID) 0L;
} else {
auth_id = CheckAuthorization (proto_n, auth_proto, string_n, auth_string, client, &reason);
}
if (auth_id == (XID) ~0L)
{
if (_XSERVTransGetPeerAddr(trans_conn, &family, &fromlen, &from) != -1)
{
if (InvalidHost ((struct sockaddr *) from, fromlen, client))
AuthAudit(client, FALSE, (struct sockaddr *) from,
fromlen, proto_n, auth_proto, auth_id);
else
{
auth_id = (XID) 0;
#ifdef XSERVER_DTRACE
if ((auditTrailLevel > 1) || XSERVER_CLIENT_AUTH_ENABLED())
#else
if (auditTrailLevel > 1)
#endif
AuthAudit(client, TRUE,
(struct sockaddr *) from, fromlen,
proto_n, auth_proto, auth_id);
}
xfree (from);
}
if (auth_id == (XID) ~0L) {
if (reason)
return reason;
else
return "Client is not authorized to connect to Server";
}
}
#ifdef XSERVER_DTRACE
else if ((auditTrailLevel > 1) || XSERVER_CLIENT_AUTH_ENABLED())
#else
else if (auditTrailLevel > 1)
#endif
{
if (_XSERVTransGetPeerAddr (trans_conn,
&family, &fromlen, &from) != -1)
{
AuthAudit(client, TRUE, (struct sockaddr *) from, fromlen,
proto_n, auth_proto, auth_id);
xfree (from);
}
}
priv->auth_id = auth_id;
priv->conn_time = 0;
#ifdef XDMCP
/* indicate to Xdmcp protocol that we've opened new client */
XdmcpOpenDisplay(priv->fd);
#endif /* XDMCP */
XaceHook(XACE_AUTH_AVAIL, client, auth_id);
/* At this point, if the client is authorized to change the access control
* list, we should getpeername() information, and add the client to
* the selfhosts list. It's not really the host machine, but the
* true purpose of the selfhosts list is to see who may change the
* access control list.
*/
return((char *)NULL);
}
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;
}
static int
miDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction)
{
ScreenPtr pScreen;
DbeWindowPrivPtr pDbeWindowPriv;
DbeScreenPrivPtr pDbeScreenPriv;
GCPtr pGC;
xRectangle clearRect;
int rc;
pScreen = pWin->drawable.pScreen;
pDbeWindowPriv = DBE_WINDOW_PRIV(pWin);
if (pDbeWindowPriv->nBufferIDs == 0) {
/* There is no buffer associated with the window.
* We have to create the window priv priv. Remember, the window
* priv was created at the DIX level, so all we need to do is
* create the priv priv and attach it to the priv.
*/
pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
/* Get a front pixmap. */
if (!(pDbeWindowPriv->pFrontBuffer =
(*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
pDbeWindowPriv->height,
pWin->drawable.depth, 0))) {
return BadAlloc;
}
/* Get a back pixmap. */
if (!(pDbeWindowPriv->pBackBuffer =
(*pScreen->CreatePixmap) (pScreen, pDbeWindowPriv->width,
pDbeWindowPriv->height,
pWin->drawable.depth, 0))) {
(*pScreen->DestroyPixmap) (pDbeWindowPriv->pFrontBuffer);
return BadAlloc;
}
/* Security creation/labeling check. */
rc = XaceHook(XACE_RESOURCE_ACCESS, serverClient, bufId,
dbeDrawableResType, pDbeWindowPriv->pBackBuffer,
RT_WINDOW, pWin, DixCreateAccess);
/* Make the back pixmap a DBE drawable resource. */
if (rc != Success || !AddResource(bufId, dbeDrawableResType,
pDbeWindowPriv->pBackBuffer)) {
/* free the buffer and the drawable resource */
FreeResource(bufId, RT_NONE);
return (rc == Success) ? BadAlloc : rc;
}
/* Clear the back buffer. */
pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen);
if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
ValidateGC((DrawablePtr) pDbeWindowPriv->pBackBuffer, pGC);
clearRect.x = clearRect.y = 0;
clearRect.width = pDbeWindowPriv->pBackBuffer->drawable.width;
clearRect.height = pDbeWindowPriv->pBackBuffer->drawable.height;
(*pGC->ops->PolyFillRect) ((DrawablePtr) pDbeWindowPriv->
pBackBuffer, pGC, 1, &clearRect);
}
FreeScratchGC(pGC);
} /* if no buffer associated with the window */
else {
/* A buffer is already associated with the window.
* Place the new buffer ID information at the head of the ID list.
*/
/* Associate the new ID with an existing pixmap. */
if (!AddResource(bufId, dbeDrawableResType,
(void *) pDbeWindowPriv->pBackBuffer)) {
return BadAlloc;
}
}
return Success;
} /* miDbeAllocBackBufferName() */
