2003-11-14 16:54:54 +01:00
|
|
|
/************************************************************
|
|
|
|
|
|
|
|
Copyright 1989, 1998 The Open Group
|
|
|
|
|
|
|
|
Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
the above copyright notice appear in all copies and that both that
|
|
|
|
copyright notice and this permission notice appear in supporting
|
|
|
|
documentation.
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
|
|
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
|
|
|
Except as contained in this notice, the name of The Open Group shall not be
|
|
|
|
used in advertising or otherwise to promote the sale, use or other dealings
|
|
|
|
in this Software without prior written authorization from The Open Group.
|
|
|
|
|
|
|
|
********************************************************/
|
|
|
|
|
|
|
|
/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */
|
|
|
|
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
#define SHM
|
|
|
|
|
2005-07-03 09:02:09 +02:00
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
|
|
#include <dix-config.h>
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
2003-11-14 17:49:22 +01:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/stat.h>
|
2005-04-20 14:25:48 +02:00
|
|
|
#include <X11/X.h>
|
|
|
|
#include <X11/Xproto.h>
|
2005-07-03 10:53:54 +02:00
|
|
|
#include "misc.h"
|
|
|
|
#include "os.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
#include "dixstruct.h"
|
|
|
|
#include "resource.h"
|
|
|
|
#include "scrnintstr.h"
|
|
|
|
#include "windowstr.h"
|
|
|
|
#include "pixmapstr.h"
|
|
|
|
#include "gcstruct.h"
|
|
|
|
#include "extnsionst.h"
|
|
|
|
#include "servermd.h"
|
2007-08-24 14:02:35 +02:00
|
|
|
#include "shmint.h"
|
2007-09-20 12:53:51 +02:00
|
|
|
#include "xace.h"
|
2003-11-14 16:54:54 +01:00
|
|
|
#define _XSHM_SERVER_
|
2005-04-20 14:25:48 +02:00
|
|
|
#include <X11/extensions/shmstr.h>
|
|
|
|
#include <X11/Xfuncproto.h>
|
2003-11-14 17:49:22 +01:00
|
|
|
|
2007-10-10 03:44:04 +02:00
|
|
|
/* Needed for Solaris cross-zone shared memory extension */
|
|
|
|
#ifdef HAVE_SHMCTL64
|
|
|
|
#include <sys/ipc_impl.h>
|
|
|
|
#define SHMSTAT(id, buf) shmctl64(id, IPC_STAT64, buf)
|
|
|
|
#define SHMSTAT_TYPE struct shmid_ds64
|
|
|
|
#define SHMPERM_TYPE struct ipc_perm64
|
|
|
|
#define SHM_PERM(buf) buf.shmx_perm
|
|
|
|
#define SHM_SEGSZ(buf) buf.shmx_segsz
|
|
|
|
#define SHMPERM_UID(p) p->ipcx_uid
|
|
|
|
#define SHMPERM_CUID(p) p->ipcx_cuid
|
|
|
|
#define SHMPERM_GID(p) p->ipcx_gid
|
|
|
|
#define SHMPERM_CGID(p) p->ipcx_cgid
|
|
|
|
#define SHMPERM_MODE(p) p->ipcx_mode
|
|
|
|
#define SHMPERM_ZONEID(p) p->ipcx_zoneid
|
|
|
|
#else
|
|
|
|
#define SHMSTAT(id, buf) shmctl(id, IPC_STAT, buf)
|
|
|
|
#define SHMSTAT_TYPE struct shmid_ds
|
|
|
|
#define SHMPERM_TYPE struct ipc_perm
|
|
|
|
#define SHM_PERM(buf) buf.shm_perm
|
|
|
|
#define SHM_SEGSZ(buf) buf.shm_segsz
|
|
|
|
#define SHMPERM_UID(p) p->uid
|
|
|
|
#define SHMPERM_CUID(p) p->cuid
|
|
|
|
#define SHMPERM_GID(p) p->gid
|
|
|
|
#define SHMPERM_CGID(p) p->cgid
|
|
|
|
#define SHMPERM_MODE(p) p->mode
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef PANORAMIX
|
|
|
|
#include "panoramiX.h"
|
|
|
|
#include "panoramiXsrv.h"
|
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
#include "modinit.h"
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
typedef struct _ShmDesc {
|
|
|
|
struct _ShmDesc *next;
|
|
|
|
int shmid;
|
|
|
|
int refcnt;
|
|
|
|
char *addr;
|
|
|
|
Bool writable;
|
|
|
|
unsigned long size;
|
|
|
|
} ShmDescRec, *ShmDescPtr;
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
static PixmapPtr fbShmCreatePixmap(XSHM_CREATE_PIXMAP_ARGS);
|
|
|
|
static int ShmDetachSegment(
|
|
|
|
pointer /* value */,
|
|
|
|
XID /* shmseg */
|
|
|
|
);
|
|
|
|
static void ShmResetProc(
|
|
|
|
ExtensionEntry * /* extEntry */
|
|
|
|
);
|
|
|
|
static void SShmCompletionEvent(
|
|
|
|
xShmCompletionEvent * /* from */,
|
|
|
|
xShmCompletionEvent * /* to */
|
|
|
|
);
|
|
|
|
|
|
|
|
static Bool ShmDestroyPixmap (PixmapPtr pPixmap);
|
|
|
|
|
|
|
|
static DISPATCH_PROC(ProcShmAttach);
|
|
|
|
static DISPATCH_PROC(ProcShmCreatePixmap);
|
|
|
|
static DISPATCH_PROC(ProcShmDetach);
|
|
|
|
static DISPATCH_PROC(ProcShmDispatch);
|
|
|
|
static DISPATCH_PROC(ProcShmGetImage);
|
|
|
|
static DISPATCH_PROC(ProcShmPutImage);
|
|
|
|
static DISPATCH_PROC(ProcShmQueryVersion);
|
|
|
|
static DISPATCH_PROC(SProcShmAttach);
|
|
|
|
static DISPATCH_PROC(SProcShmCreatePixmap);
|
|
|
|
static DISPATCH_PROC(SProcShmDetach);
|
|
|
|
static DISPATCH_PROC(SProcShmDispatch);
|
|
|
|
static DISPATCH_PROC(SProcShmGetImage);
|
|
|
|
static DISPATCH_PROC(SProcShmPutImage);
|
|
|
|
static DISPATCH_PROC(SProcShmQueryVersion);
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
static unsigned char ShmReqCode;
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
int ShmCompletionCode;
|
|
|
|
int BadShmSegCode;
|
|
|
|
RESTYPE ShmSegType;
|
2003-11-14 16:54:54 +01:00
|
|
|
static ShmDescPtr Shmsegs;
|
|
|
|
static Bool sharedPixmaps;
|
|
|
|
static ShmFuncsPtr shmFuncs[MAXSCREENS];
|
2003-11-14 17:49:22 +01:00
|
|
|
static DestroyPixmapProcPtr destroyPixmap[MAXSCREENS];
|
2008-08-29 00:05:40 +02:00
|
|
|
static int shmPixmapPrivateIndex;
|
|
|
|
static DevPrivateKey shmPixmapPrivate = &shmPixmapPrivateIndex;
|
2008-08-27 22:05:47 +02:00
|
|
|
static ShmFuncs miFuncs = {NULL, NULL};
|
|
|
|
static ShmFuncs fbFuncs = {fbShmCreatePixmap, NULL};
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
#define VERIFY_SHMSEG(shmseg,shmdesc,client) \
|
|
|
|
{ \
|
|
|
|
shmdesc = (ShmDescPtr)LookupIDByType(shmseg, ShmSegType); \
|
|
|
|
if (!shmdesc) \
|
|
|
|
{ \
|
|
|
|
client->errorValue = shmseg; \
|
|
|
|
return BadShmSegCode; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define VERIFY_SHMPTR(shmseg,offset,needwrite,shmdesc,client) \
|
|
|
|
{ \
|
|
|
|
VERIFY_SHMSEG(shmseg, shmdesc, client); \
|
|
|
|
if ((offset & 3) || (offset > shmdesc->size)) \
|
|
|
|
{ \
|
|
|
|
client->errorValue = offset; \
|
|
|
|
return BadValue; \
|
|
|
|
} \
|
|
|
|
if (needwrite && !shmdesc->writable) \
|
|
|
|
return BadAccess; \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define VERIFY_SHMSIZE(shmdesc,offset,len,client) \
|
|
|
|
{ \
|
|
|
|
if ((offset + len) > shmdesc->size) \
|
|
|
|
{ \
|
|
|
|
return BadAccess; \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
|
2007-08-16 18:20:12 +02:00
|
|
|
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__DragonFly__)
|
2003-11-14 17:49:22 +01:00
|
|
|
#include <sys/signal.h>
|
|
|
|
|
|
|
|
static Bool badSysCall = FALSE;
|
|
|
|
|
|
|
|
static void
|
2008-06-11 17:41:34 +02:00
|
|
|
SigSysHandler(int signo)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
badSysCall = TRUE;
|
|
|
|
}
|
|
|
|
|
2008-06-11 17:41:34 +02:00
|
|
|
static Bool CheckForShmSyscall(void)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
void (*oldHandler)();
|
|
|
|
int shmid = -1;
|
|
|
|
|
|
|
|
/* If no SHM support in the kernel, the bad syscall will generate SIGSYS */
|
|
|
|
oldHandler = signal(SIGSYS, SigSysHandler);
|
|
|
|
|
|
|
|
badSysCall = FALSE;
|
|
|
|
shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT);
|
2003-11-25 20:29:01 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
if (shmid != -1)
|
|
|
|
{
|
2003-11-25 20:29:01 +01:00
|
|
|
/* Successful allocation - clean up */
|
2009-01-22 08:11:16 +01:00
|
|
|
shmctl(shmid, IPC_RMID, NULL);
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Allocation failed */
|
|
|
|
badSysCall = TRUE;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
signal(SIGSYS, oldHandler);
|
|
|
|
return(!badSysCall);
|
|
|
|
}
|
2003-11-25 20:29:01 +01:00
|
|
|
|
|
|
|
#define MUST_CHECK_FOR_SHM_SYSCALL
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#endif
|
2003-11-25 20:29:01 +01:00
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
void
|
2003-11-25 20:29:01 +01:00
|
|
|
ShmExtensionInit(INITARGS)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
ExtensionEntry *extEntry;
|
|
|
|
int i;
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
#ifdef MUST_CHECK_FOR_SHM_SYSCALL
|
2003-11-14 17:49:22 +01:00
|
|
|
if (!CheckForShmSyscall())
|
|
|
|
{
|
|
|
|
ErrorF("MIT-SHM extension disabled due to lack of kernel support\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
sharedPixmaps = xFalse;
|
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
sharedPixmaps = xTrue;
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++)
|
|
|
|
{
|
2003-11-14 16:54:54 +01:00
|
|
|
if (!shmFuncs[i])
|
|
|
|
shmFuncs[i] = &miFuncs;
|
|
|
|
if (!shmFuncs[i]->CreatePixmap)
|
|
|
|
sharedPixmaps = xFalse;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
if (sharedPixmaps)
|
|
|
|
for (i = 0; i < screenInfo.numScreens; i++)
|
|
|
|
{
|
|
|
|
destroyPixmap[i] = screenInfo.screens[i]->DestroyPixmap;
|
|
|
|
screenInfo.screens[i]->DestroyPixmap = ShmDestroyPixmap;
|
|
|
|
}
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
ShmSegType = CreateNewResourceType(ShmDetachSegment);
|
2003-11-14 17:49:22 +01:00
|
|
|
if (ShmSegType &&
|
2003-11-14 16:54:54 +01:00
|
|
|
(extEntry = AddExtension(SHMNAME, ShmNumberEvents, ShmNumberErrors,
|
|
|
|
ProcShmDispatch, SProcShmDispatch,
|
|
|
|
ShmResetProc, StandardMinorOpcode)))
|
|
|
|
{
|
|
|
|
ShmReqCode = (unsigned char)extEntry->base;
|
|
|
|
ShmCompletionCode = extEntry->eventBase;
|
|
|
|
BadShmSegCode = extEntry->errorBase;
|
2003-11-14 17:49:22 +01:00
|
|
|
EventSwapVector[ShmCompletionCode] = (EventSwapPtr) SShmCompletionEvent;
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static void
|
2008-06-11 17:41:34 +02:00
|
|
|
ShmResetProc(ExtensionEntry *extEntry)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < MAXSCREENS; i++)
|
|
|
|
{
|
2009-01-22 08:11:16 +01:00
|
|
|
shmFuncs[i] = NULL;
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
void
|
2008-06-11 17:41:34 +02:00
|
|
|
ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
shmFuncs[pScreen->myNum] = funcs;
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
static Bool
|
|
|
|
ShmDestroyPixmap (PixmapPtr pPixmap)
|
|
|
|
{
|
|
|
|
ScreenPtr pScreen = pPixmap->drawable.pScreen;
|
|
|
|
Bool ret;
|
|
|
|
if (pPixmap->refcnt == 1)
|
|
|
|
{
|
|
|
|
ShmDescPtr shmdesc;
|
2007-08-28 15:28:25 +02:00
|
|
|
shmdesc = (ShmDescPtr)dixLookupPrivate(&pPixmap->devPrivates,
|
|
|
|
shmPixmapPrivate);
|
2003-11-14 17:49:22 +01:00
|
|
|
if (shmdesc)
|
|
|
|
ShmDetachSegment ((pointer) shmdesc, pPixmap->drawable.id);
|
|
|
|
}
|
|
|
|
|
|
|
|
pScreen->DestroyPixmap = destroyPixmap[pScreen->myNum];
|
|
|
|
ret = (*pScreen->DestroyPixmap) (pPixmap);
|
|
|
|
destroyPixmap[pScreen->myNum] = pScreen->DestroyPixmap;
|
|
|
|
pScreen->DestroyPixmap = ShmDestroyPixmap;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
void
|
2008-06-11 17:41:34 +02:00
|
|
|
ShmRegisterFbFuncs(ScreenPtr pScreen)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
shmFuncs[pScreen->myNum] = &fbFuncs;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmQueryVersion(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
xShmQueryVersionReply rep;
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmQueryVersionReq);
|
|
|
|
rep.type = X_Reply;
|
|
|
|
rep.length = 0;
|
|
|
|
rep.sequenceNumber = client->sequence;
|
|
|
|
rep.sharedPixmaps = sharedPixmaps;
|
2008-08-28 19:49:35 +02:00
|
|
|
rep.pixmapFormat = sharedPixmaps ? ZPixmap : 0;
|
2003-11-14 16:54:54 +01:00
|
|
|
rep.majorVersion = SHM_MAJOR_VERSION;
|
|
|
|
rep.minorVersion = SHM_MINOR_VERSION;
|
|
|
|
rep.uid = geteuid();
|
|
|
|
rep.gid = getegid();
|
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&rep.sequenceNumber, n);
|
|
|
|
swapl(&rep.length, n);
|
|
|
|
swaps(&rep.majorVersion, n);
|
|
|
|
swaps(&rep.minorVersion, n);
|
|
|
|
swaps(&rep.uid, n);
|
|
|
|
swaps(&rep.gid, n);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xShmQueryVersionReply), (char *)&rep);
|
|
|
|
return (client->noClientException);
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
/*
|
|
|
|
* Simulate the access() system call for a shared memory segement,
|
|
|
|
* using the credentials from the client if available
|
|
|
|
*/
|
|
|
|
static int
|
2007-10-10 03:44:04 +02:00
|
|
|
shm_access(ClientPtr client, SHMPERM_TYPE *perm, int readonly)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
int uid, gid;
|
|
|
|
mode_t mask;
|
2007-10-10 03:44:04 +02:00
|
|
|
int uidset = 0, gidset = 0;
|
|
|
|
LocalClientCredRec *lcc;
|
|
|
|
|
|
|
|
if (GetLocalClientCreds(client, &lcc) != -1) {
|
2003-11-14 17:49:22 +01:00
|
|
|
|
2007-10-10 03:44:04 +02:00
|
|
|
if (lcc->fieldsSet & LCC_UID_SET) {
|
|
|
|
uid = lcc->euid;
|
|
|
|
uidset = 1;
|
|
|
|
}
|
|
|
|
if (lcc->fieldsSet & LCC_GID_SET) {
|
|
|
|
gid = lcc->egid;
|
|
|
|
gidset = 1;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
2007-10-10 03:44:04 +02:00
|
|
|
|
|
|
|
#if defined(HAVE_GETZONEID) && defined(SHMPERM_ZONEID)
|
|
|
|
if ( ((lcc->fieldsSet & LCC_ZID_SET) == 0) || (lcc->zoneid == -1)
|
|
|
|
|| (lcc->zoneid != SHMPERM_ZONEID(perm))) {
|
|
|
|
uidset = 0;
|
|
|
|
gidset = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
FreeLocalClientCreds(lcc);
|
|
|
|
|
|
|
|
if (uidset) {
|
|
|
|
/* User id 0 always gets access */
|
|
|
|
if (uid == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Check the owner */
|
|
|
|
if (SHMPERM_UID(perm) == uid || SHMPERM_CUID(perm) == uid) {
|
|
|
|
mask = S_IRUSR;
|
|
|
|
if (!readonly) {
|
|
|
|
mask |= S_IWUSR;
|
|
|
|
}
|
|
|
|
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
}
|
2007-10-10 03:44:04 +02:00
|
|
|
|
|
|
|
if (gidset) {
|
|
|
|
/* Check the group */
|
|
|
|
if (SHMPERM_GID(perm) == gid || SHMPERM_CGID(perm) == gid) {
|
|
|
|
mask = S_IRGRP;
|
|
|
|
if (!readonly) {
|
|
|
|
mask |= S_IWGRP;
|
|
|
|
}
|
|
|
|
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Otherwise, check everyone else */
|
|
|
|
mask = S_IROTH;
|
|
|
|
if (!readonly) {
|
|
|
|
mask |= S_IWOTH;
|
|
|
|
}
|
2007-10-10 03:44:04 +02:00
|
|
|
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmAttach(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-10-10 03:44:04 +02:00
|
|
|
SHMSTAT_TYPE buf;
|
2003-11-14 16:54:54 +01:00
|
|
|
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
|
|
|
|
{
|
2009-01-22 08:11:16 +01:00
|
|
|
shmdesc = xalloc(sizeof(ShmDescRec));
|
2003-11-14 16:54:54 +01:00
|
|
|
if (!shmdesc)
|
|
|
|
return BadAlloc;
|
|
|
|
shmdesc->addr = shmat(stuff->shmid, 0,
|
|
|
|
stuff->readOnly ? SHM_RDONLY : 0);
|
|
|
|
if ((shmdesc->addr == ((char *)-1)) ||
|
2007-10-10 03:44:04 +02:00
|
|
|
SHMSTAT(stuff->shmid, &buf))
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
xfree(shmdesc);
|
|
|
|
return BadAccess;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
/* The attach was performed with root privs. We must
|
|
|
|
* do manual checking of access rights for the credentials
|
|
|
|
* of the client */
|
|
|
|
|
2007-10-10 03:44:04 +02:00
|
|
|
if (shm_access(client, &(SHM_PERM(buf)), stuff->readOnly) == -1) {
|
2003-11-14 17:49:22 +01:00
|
|
|
shmdt(shmdesc->addr);
|
|
|
|
xfree(shmdesc);
|
|
|
|
return BadAccess;
|
|
|
|
}
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
shmdesc->shmid = stuff->shmid;
|
|
|
|
shmdesc->refcnt = 1;
|
|
|
|
shmdesc->writable = !stuff->readOnly;
|
2007-10-10 03:44:04 +02:00
|
|
|
shmdesc->size = SHM_SEGSZ(buf);
|
2003-11-14 16:54:54 +01:00
|
|
|
shmdesc->next = Shmsegs;
|
|
|
|
Shmsegs = shmdesc;
|
|
|
|
}
|
|
|
|
if (!AddResource(stuff->shmseg, ShmSegType, (pointer)shmdesc))
|
|
|
|
return BadAlloc;
|
|
|
|
return(client->noClientException);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ShmDetachSegment(pointer value, /* must conform to DeleteType */
|
|
|
|
XID shmseg)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
ShmDescPtr shmdesc = (ShmDescPtr)value;
|
|
|
|
ShmDescPtr *prev;
|
|
|
|
|
|
|
|
if (--shmdesc->refcnt)
|
|
|
|
return TRUE;
|
|
|
|
shmdt(shmdesc->addr);
|
|
|
|
for (prev = &Shmsegs; *prev != shmdesc; prev = &(*prev)->next)
|
|
|
|
;
|
|
|
|
*prev = shmdesc->next;
|
|
|
|
xfree(shmdesc);
|
|
|
|
return Success;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmDetach(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
ShmDescPtr shmdesc;
|
|
|
|
REQUEST(xShmDetachReq);
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmDetachReq);
|
|
|
|
VERIFY_SHMSEG(stuff->shmseg, shmdesc, client);
|
|
|
|
FreeResource(stuff->shmseg, RT_NONE);
|
|
|
|
return(client->noClientException);
|
|
|
|
}
|
|
|
|
|
2008-08-27 22:05:47 +02:00
|
|
|
/*
|
|
|
|
* If the given request doesn't exactly match PutImage's constraints,
|
|
|
|
* wrap the image in a scratch pixmap header and let CopyArea sort it out.
|
|
|
|
*/
|
2008-08-28 20:49:35 +02:00
|
|
|
static void
|
2008-08-27 22:05:47 +02:00
|
|
|
doShmPutImage(DrawablePtr dst, GCPtr pGC,
|
2008-06-11 17:41:34 +02:00
|
|
|
int depth, unsigned int format,
|
|
|
|
int w, int h, int sx, int sy, int sw, int sh, int dx, int dy,
|
|
|
|
char *data)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2008-08-27 22:05:47 +02:00
|
|
|
PixmapPtr pPixmap;
|
|
|
|
|
|
|
|
pPixmap = GetScratchPixmapHeader(dst->pScreen, w, h, depth,
|
|
|
|
BitsPerPixel(depth),
|
|
|
|
PixmapBytePad(w, depth),
|
|
|
|
data);
|
|
|
|
if (!pPixmap)
|
2003-11-14 16:54:54 +01:00
|
|
|
return;
|
2008-08-27 22:05:47 +02:00
|
|
|
pGC->ops->CopyArea((DrawablePtr)pPixmap, dst, pGC, sx, sy, sw, sh, dx, dy);
|
|
|
|
FreeScratchPixmapHeader(pPixmap);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef PANORAMIX
|
|
|
|
static int
|
2007-11-21 06:29:31 +01:00
|
|
|
ProcPanoramiXShmPutImage(ClientPtr client)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
int j, result = 0, orig_x, orig_y;
|
|
|
|
PanoramiXRes *draw, *gc;
|
|
|
|
Bool sendEvent, isRoot;
|
|
|
|
|
|
|
|
REQUEST(xShmPutImageReq);
|
|
|
|
REQUEST_SIZE_MATCH(xShmPutImageReq);
|
|
|
|
|
|
|
|
if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
|
2006-12-14 20:45:42 +01:00
|
|
|
client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
|
2003-11-14 17:49:22 +01:00
|
|
|
return BadDrawable;
|
|
|
|
|
|
|
|
if(!(gc = (PanoramiXRes *)SecurityLookupIDByType(
|
2006-12-14 20:45:42 +01:00
|
|
|
client, stuff->gc, XRT_GC, DixReadAccess)))
|
2003-11-14 17:49:22 +01:00
|
|
|
return BadGC;
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
orig_x = stuff->dstX;
|
|
|
|
orig_y = stuff->dstY;
|
|
|
|
sendEvent = stuff->sendEvent;
|
|
|
|
stuff->sendEvent = 0;
|
|
|
|
FOR_NSCREENS(j) {
|
|
|
|
if(!j) stuff->sendEvent = sendEvent;
|
|
|
|
stuff->drawable = draw->info[j].id;
|
|
|
|
stuff->gc = gc->info[j].id;
|
|
|
|
if (isRoot) {
|
|
|
|
stuff->dstX = orig_x - panoramiXdataPtr[j].x;
|
|
|
|
stuff->dstY = orig_y - panoramiXdataPtr[j].y;
|
|
|
|
}
|
|
|
|
result = ProcShmPutImage(client);
|
|
|
|
if(result != client->noClientException) break;
|
|
|
|
}
|
|
|
|
return(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ProcPanoramiXShmGetImage(ClientPtr client)
|
|
|
|
{
|
|
|
|
PanoramiXRes *draw;
|
|
|
|
DrawablePtr drawables[MAXSCREENS];
|
|
|
|
DrawablePtr pDraw;
|
|
|
|
xShmGetImageReply xgi;
|
|
|
|
ShmDescPtr shmdesc;
|
2006-12-14 23:27:12 +01:00
|
|
|
int i, x, y, w, h, format, rc;
|
2003-11-14 17:49:22 +01:00
|
|
|
Mask plane = 0, planemask;
|
|
|
|
long lenPer = 0, length, widthBytesLine;
|
|
|
|
Bool isRoot;
|
|
|
|
|
|
|
|
REQUEST(xShmGetImageReq);
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmGetImageReq);
|
|
|
|
|
|
|
|
if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap)) {
|
|
|
|
client->errorValue = stuff->format;
|
|
|
|
return(BadValue);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!(draw = (PanoramiXRes *)SecurityLookupIDByClass(
|
2006-12-14 20:45:42 +01:00
|
|
|
client, stuff->drawable, XRC_DRAWABLE, DixWriteAccess)))
|
2003-11-14 17:49:22 +01:00
|
|
|
return BadDrawable;
|
|
|
|
|
|
|
|
if (draw->type == XRT_PIXMAP)
|
|
|
|
return ProcShmGetImage(client);
|
|
|
|
|
2006-12-14 23:27:12 +01:00
|
|
|
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
|
2008-02-28 22:43:43 +01:00
|
|
|
DixReadAccess);
|
2006-12-14 23:27:12 +01:00
|
|
|
if (rc != Success)
|
|
|
|
return rc;
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
|
|
|
|
|
|
|
|
x = stuff->x;
|
|
|
|
y = stuff->y;
|
|
|
|
w = stuff->width;
|
|
|
|
h = stuff->height;
|
|
|
|
format = stuff->format;
|
|
|
|
planemask = stuff->planeMask;
|
|
|
|
|
2003-11-25 20:29:01 +01:00
|
|
|
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
if(isRoot) {
|
|
|
|
if( /* check for being onscreen */
|
|
|
|
x < 0 || x + w > PanoramiXPixWidth ||
|
|
|
|
y < 0 || y + h > PanoramiXPixHeight )
|
|
|
|
return(BadMatch);
|
|
|
|
} else {
|
|
|
|
if( /* check for being onscreen */
|
|
|
|
panoramiXdataPtr[0].x + pDraw->x + x < 0 ||
|
|
|
|
panoramiXdataPtr[0].x + pDraw->x + x + w > PanoramiXPixWidth ||
|
|
|
|
panoramiXdataPtr[0].y + pDraw->y + y < 0 ||
|
|
|
|
panoramiXdataPtr[0].y + pDraw->y + y + h > PanoramiXPixHeight ||
|
|
|
|
/* check for being inside of border */
|
|
|
|
x < - wBorderWidth((WindowPtr)pDraw) ||
|
|
|
|
x + w > wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
|
|
|
|
y < -wBorderWidth((WindowPtr)pDraw) ||
|
|
|
|
y + h > wBorderWidth ((WindowPtr)pDraw) + (int)pDraw->height)
|
|
|
|
return(BadMatch);
|
|
|
|
}
|
|
|
|
|
|
|
|
drawables[0] = pDraw;
|
2006-12-14 23:27:12 +01:00
|
|
|
for(i = 1; i < PanoramiXNumScreens; i++) {
|
|
|
|
rc = dixLookupDrawable(drawables+i, draw->info[i].id, client, 0,
|
2008-02-28 22:43:43 +01:00
|
|
|
DixReadAccess);
|
2006-12-14 23:27:12 +01:00
|
|
|
if (rc != Success)
|
|
|
|
return rc;
|
|
|
|
}
|
2003-11-14 17:49:22 +01:00
|
|
|
|
|
|
|
xgi.visual = wVisual(((WindowPtr)pDraw));
|
|
|
|
xgi.type = X_Reply;
|
|
|
|
xgi.length = 0;
|
|
|
|
xgi.sequenceNumber = client->sequence;
|
|
|
|
xgi.depth = pDraw->depth;
|
|
|
|
|
|
|
|
if(format == ZPixmap) {
|
|
|
|
widthBytesLine = PixmapBytePad(w, pDraw->depth);
|
|
|
|
length = widthBytesLine * h;
|
|
|
|
} else {
|
|
|
|
widthBytesLine = PixmapBytePad(w, 1);
|
|
|
|
lenPer = widthBytesLine * h;
|
|
|
|
plane = ((Mask)1) << (pDraw->depth - 1);
|
|
|
|
length = lenPer * Ones(planemask & (plane | (plane - 1)));
|
|
|
|
}
|
|
|
|
|
|
|
|
VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
|
|
|
|
xgi.size = length;
|
|
|
|
|
|
|
|
if (length == 0) {/* nothing to do */ }
|
|
|
|
else if (format == ZPixmap) {
|
|
|
|
XineramaGetImageData(drawables, x, y, w, h, format, planemask,
|
|
|
|
shmdesc->addr + stuff->offset,
|
|
|
|
widthBytesLine, isRoot);
|
|
|
|
} else {
|
|
|
|
|
|
|
|
length = stuff->offset;
|
|
|
|
for (; plane; plane >>= 1) {
|
|
|
|
if (planemask & plane) {
|
|
|
|
XineramaGetImageData(drawables, x, y, w, h,
|
|
|
|
format, plane, shmdesc->addr + length,
|
|
|
|
widthBytesLine, isRoot);
|
|
|
|
length += lenPer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (client->swapped) {
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 17:49:22 +01:00
|
|
|
swaps(&xgi.sequenceNumber, n);
|
|
|
|
swapl(&xgi.length, n);
|
|
|
|
swapl(&xgi.visual, n);
|
|
|
|
swapl(&xgi.size, n);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
|
|
|
|
|
|
|
|
return(client->noClientException);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcPanoramiXShmCreatePixmap(ClientPtr client)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
ScreenPtr pScreen = NULL;
|
|
|
|
PixmapPtr pMap = NULL;
|
|
|
|
DrawablePtr pDraw;
|
|
|
|
DepthPtr pDepth;
|
2006-12-15 00:27:09 +01:00
|
|
|
int i, j, result, rc;
|
2003-11-14 17:49:22 +01:00
|
|
|
ShmDescPtr shmdesc;
|
|
|
|
REQUEST(xShmCreatePixmapReq);
|
2008-01-17 15:28:42 +01:00
|
|
|
unsigned int width, height, depth;
|
|
|
|
unsigned long size;
|
2003-11-14 17:49:22 +01:00
|
|
|
PanoramiXRes *newPix;
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
|
|
|
|
client->errorValue = stuff->pid;
|
|
|
|
if (!sharedPixmaps)
|
|
|
|
return BadImplementation;
|
|
|
|
LEGAL_NEW_RESOURCE(stuff->pid, client);
|
2006-12-15 00:27:09 +01:00
|
|
|
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
|
2008-02-28 22:43:43 +01:00
|
|
|
DixGetAttrAccess);
|
2006-12-15 00:27:09 +01:00
|
|
|
if (rc != Success)
|
|
|
|
return rc;
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
|
2008-01-17 15:28:42 +01:00
|
|
|
|
|
|
|
width = stuff->width;
|
|
|
|
height = stuff->height;
|
|
|
|
depth = stuff->depth;
|
|
|
|
if (!width || !height || !depth)
|
2003-11-14 17:49:22 +01:00
|
|
|
{
|
|
|
|
client->errorValue = 0;
|
|
|
|
return BadValue;
|
|
|
|
}
|
2008-01-17 15:28:42 +01:00
|
|
|
if (width > 32767 || height > 32767)
|
|
|
|
return BadAlloc;
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
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;
|
|
|
|
}
|
2008-01-18 20:41:20 +01:00
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
CreatePmap:
|
2008-01-18 20:41:20 +01:00
|
|
|
size = PixmapBytePad(width, depth) * height;
|
|
|
|
if (sizeof(size) == 4 && BitsPerPixel(depth) > 8) {
|
|
|
|
if (size < width * height)
|
|
|
|
return BadAlloc;
|
|
|
|
}
|
2008-01-21 16:13:21 +01:00
|
|
|
/* thankfully, offset is unsigned */
|
|
|
|
if (stuff->offset + size < size)
|
|
|
|
return BadAlloc;
|
2008-01-18 20:41:20 +01:00
|
|
|
|
2008-01-17 15:28:42 +01:00
|
|
|
VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
|
2003-11-14 17:49:22 +01:00
|
|
|
|
2009-01-22 08:11:16 +01:00
|
|
|
if(!(newPix = xalloc(sizeof(PanoramiXRes))))
|
2003-11-14 17:49:22 +01:00
|
|
|
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 = (client->noClientException);
|
|
|
|
|
|
|
|
FOR_NSCREENS(j) {
|
|
|
|
pScreen = screenInfo.screens[j];
|
|
|
|
|
|
|
|
pMap = (*shmFuncs[j]->CreatePixmap)(pScreen,
|
|
|
|
stuff->width, stuff->height, stuff->depth,
|
|
|
|
shmdesc->addr + stuff->offset);
|
|
|
|
|
|
|
|
if (pMap) {
|
2007-08-28 15:28:25 +02:00
|
|
|
dixSetPrivate(&pMap->devPrivates, shmPixmapPrivate, shmdesc);
|
2003-11-14 17:49:22 +01:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
xfree(newPix);
|
|
|
|
} else
|
|
|
|
AddResource(stuff->pid, XRT_PIXMAP, newPix);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmPutImage(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2006-12-15 01:15:21 +01:00
|
|
|
GCPtr pGC;
|
|
|
|
DrawablePtr pDraw;
|
2003-11-14 16:54:54 +01:00
|
|
|
long length;
|
|
|
|
ShmDescPtr shmdesc;
|
|
|
|
REQUEST(xShmPutImageReq);
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmPutImageReq);
|
2007-09-25 15:33:51 +02:00
|
|
|
VALIDATE_DRAWABLE_AND_GC(stuff->drawable, pDraw, DixWriteAccess);
|
2003-11-14 16:54:54 +01:00
|
|
|
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, FALSE, shmdesc, client);
|
|
|
|
if ((stuff->sendEvent != xTrue) && (stuff->sendEvent != xFalse))
|
|
|
|
return BadValue;
|
|
|
|
if (stuff->format == XYBitmap)
|
|
|
|
{
|
|
|
|
if (stuff->depth != 1)
|
|
|
|
return BadMatch;
|
|
|
|
length = PixmapBytePad(stuff->totalWidth, 1);
|
|
|
|
}
|
|
|
|
else if (stuff->format == XYPixmap)
|
|
|
|
{
|
|
|
|
if (pDraw->depth != stuff->depth)
|
|
|
|
return BadMatch;
|
|
|
|
length = PixmapBytePad(stuff->totalWidth, 1);
|
|
|
|
length *= stuff->depth;
|
|
|
|
}
|
|
|
|
else if (stuff->format == ZPixmap)
|
|
|
|
{
|
|
|
|
if (pDraw->depth != stuff->depth)
|
|
|
|
return BadMatch;
|
|
|
|
length = PixmapBytePad(stuff->totalWidth, stuff->depth);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->format;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
|
2008-06-10 20:20:43 +02:00
|
|
|
/*
|
|
|
|
* There's a potential integer overflow in this check:
|
|
|
|
* VERIFY_SHMSIZE(shmdesc, stuff->offset, length * stuff->totalHeight,
|
|
|
|
* client);
|
|
|
|
* the version below ought to avoid it
|
|
|
|
*/
|
|
|
|
if (stuff->totalHeight != 0 &&
|
|
|
|
length > (shmdesc->size - stuff->offset)/stuff->totalHeight) {
|
|
|
|
client->errorValue = stuff->totalWidth;
|
|
|
|
return BadValue;
|
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
if (stuff->srcX > stuff->totalWidth)
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->srcX;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
if (stuff->srcY > stuff->totalHeight)
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->srcY;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
if ((stuff->srcX + stuff->srcWidth) > stuff->totalWidth)
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->srcWidth;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
if ((stuff->srcY + stuff->srcHeight) > stuff->totalHeight)
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->srcHeight;
|
|
|
|
return BadValue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((((stuff->format == ZPixmap) && (stuff->srcX == 0)) ||
|
|
|
|
((stuff->format != ZPixmap) &&
|
|
|
|
(stuff->srcX < screenInfo.bitmapScanlinePad) &&
|
|
|
|
((stuff->format == XYBitmap) ||
|
|
|
|
((stuff->srcY == 0) &&
|
|
|
|
(stuff->srcHeight == stuff->totalHeight))))) &&
|
|
|
|
((stuff->srcX + stuff->srcWidth) == stuff->totalWidth))
|
|
|
|
(*pGC->ops->PutImage) (pDraw, pGC, stuff->depth,
|
|
|
|
stuff->dstX, stuff->dstY,
|
|
|
|
stuff->totalWidth, stuff->srcHeight,
|
|
|
|
stuff->srcX, stuff->format,
|
|
|
|
shmdesc->addr + stuff->offset +
|
|
|
|
(stuff->srcY * length));
|
|
|
|
else
|
2008-08-27 22:05:47 +02:00
|
|
|
doShmPutImage(pDraw, pGC, stuff->depth, stuff->format,
|
|
|
|
stuff->totalWidth, stuff->totalHeight,
|
|
|
|
stuff->srcX, stuff->srcY,
|
|
|
|
stuff->srcWidth, stuff->srcHeight,
|
|
|
|
stuff->dstX, stuff->dstY,
|
|
|
|
shmdesc->addr + stuff->offset);
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
if (stuff->sendEvent)
|
|
|
|
{
|
|
|
|
xShmCompletionEvent ev;
|
|
|
|
|
|
|
|
ev.type = ShmCompletionCode;
|
|
|
|
ev.drawable = stuff->drawable;
|
|
|
|
ev.sequenceNumber = client->sequence;
|
|
|
|
ev.minorEvent = X_ShmPutImage;
|
|
|
|
ev.majorEvent = ShmReqCode;
|
|
|
|
ev.shmseg = stuff->shmseg;
|
|
|
|
ev.offset = stuff->offset;
|
|
|
|
WriteEventsToClient(client, 1, (xEvent *) &ev);
|
|
|
|
}
|
|
|
|
|
2003-11-14 17:49:22 +01:00
|
|
|
return (client->noClientException);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmGetImage(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2006-12-14 23:27:12 +01:00
|
|
|
DrawablePtr pDraw;
|
2003-11-14 17:49:22 +01:00
|
|
|
long lenPer = 0, length;
|
|
|
|
Mask plane = 0;
|
2003-11-14 16:54:54 +01:00
|
|
|
xShmGetImageReply xgi;
|
|
|
|
ShmDescPtr shmdesc;
|
2006-12-14 23:27:12 +01:00
|
|
|
int n, rc;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
REQUEST(xShmGetImageReq);
|
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmGetImageReq);
|
|
|
|
if ((stuff->format != XYPixmap) && (stuff->format != ZPixmap))
|
|
|
|
{
|
|
|
|
client->errorValue = stuff->format;
|
|
|
|
return(BadValue);
|
|
|
|
}
|
2006-12-14 23:27:12 +01:00
|
|
|
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0,
|
2007-09-20 12:53:51 +02:00
|
|
|
DixReadAccess);
|
2006-12-14 23:27:12 +01:00
|
|
|
if (rc != Success)
|
|
|
|
return rc;
|
2003-11-14 16:54:54 +01:00
|
|
|
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
|
|
|
|
if (pDraw->type == DRAWABLE_WINDOW)
|
|
|
|
{
|
|
|
|
if( /* check for being viewable */
|
|
|
|
!((WindowPtr) pDraw)->realized ||
|
|
|
|
/* check for being on screen */
|
|
|
|
pDraw->x + stuff->x < 0 ||
|
|
|
|
pDraw->x + stuff->x + (int)stuff->width > pDraw->pScreen->width ||
|
|
|
|
pDraw->y + stuff->y < 0 ||
|
|
|
|
pDraw->y + stuff->y + (int)stuff->height > pDraw->pScreen->height ||
|
|
|
|
/* check for being inside of border */
|
|
|
|
stuff->x < - wBorderWidth((WindowPtr)pDraw) ||
|
|
|
|
stuff->x + (int)stuff->width >
|
|
|
|
wBorderWidth((WindowPtr)pDraw) + (int)pDraw->width ||
|
|
|
|
stuff->y < -wBorderWidth((WindowPtr)pDraw) ||
|
|
|
|
stuff->y + (int)stuff->height >
|
|
|
|
wBorderWidth((WindowPtr)pDraw) + (int)pDraw->height
|
|
|
|
)
|
|
|
|
return(BadMatch);
|
|
|
|
xgi.visual = wVisual(((WindowPtr)pDraw));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (stuff->x < 0 ||
|
|
|
|
stuff->x+(int)stuff->width > pDraw->width ||
|
|
|
|
stuff->y < 0 ||
|
|
|
|
stuff->y+(int)stuff->height > pDraw->height
|
|
|
|
)
|
|
|
|
return(BadMatch);
|
|
|
|
xgi.visual = None;
|
|
|
|
}
|
|
|
|
xgi.type = X_Reply;
|
|
|
|
xgi.length = 0;
|
|
|
|
xgi.sequenceNumber = client->sequence;
|
|
|
|
xgi.depth = pDraw->depth;
|
|
|
|
if(stuff->format == ZPixmap)
|
|
|
|
{
|
|
|
|
length = PixmapBytePad(stuff->width, pDraw->depth) * stuff->height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
lenPer = PixmapBytePad(stuff->width, 1) * stuff->height;
|
|
|
|
plane = ((Mask)1) << (pDraw->depth - 1);
|
|
|
|
/* only planes asked for */
|
|
|
|
length = lenPer * Ones(stuff->planeMask & (plane | (plane - 1)));
|
|
|
|
}
|
|
|
|
|
|
|
|
VERIFY_SHMSIZE(shmdesc, stuff->offset, length, client);
|
|
|
|
xgi.size = length;
|
|
|
|
|
|
|
|
if (length == 0)
|
|
|
|
{
|
|
|
|
/* nothing to do */
|
|
|
|
}
|
|
|
|
else if (stuff->format == ZPixmap)
|
|
|
|
{
|
|
|
|
(*pDraw->pScreen->GetImage)(pDraw, stuff->x, stuff->y,
|
|
|
|
stuff->width, stuff->height,
|
|
|
|
stuff->format, stuff->planeMask,
|
|
|
|
shmdesc->addr + stuff->offset);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
|
|
|
|
length = stuff->offset;
|
|
|
|
for (; plane; plane >>= 1)
|
|
|
|
{
|
|
|
|
if (stuff->planeMask & plane)
|
|
|
|
{
|
|
|
|
(*pDraw->pScreen->GetImage)(pDraw,
|
|
|
|
stuff->x, stuff->y,
|
|
|
|
stuff->width, stuff->height,
|
|
|
|
stuff->format, plane,
|
|
|
|
shmdesc->addr + length);
|
|
|
|
length += lenPer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (client->swapped) {
|
|
|
|
swaps(&xgi.sequenceNumber, n);
|
|
|
|
swapl(&xgi.length, n);
|
|
|
|
swapl(&xgi.visual, n);
|
|
|
|
swapl(&xgi.size, n);
|
|
|
|
}
|
|
|
|
WriteToClient(client, sizeof(xShmGetImageReply), (char *)&xgi);
|
|
|
|
|
|
|
|
return(client->noClientException);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PixmapPtr
|
2008-06-11 17:41:34 +02:00
|
|
|
fbShmCreatePixmap (ScreenPtr pScreen,
|
|
|
|
int width, int height, int depth, char *addr)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
PixmapPtr pPixmap;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
2007-10-31 22:15:35 +01:00
|
|
|
pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth, 0);
|
2003-11-14 16:54:54 +01:00
|
|
|
if (!pPixmap)
|
|
|
|
return NullPixmap;
|
|
|
|
|
|
|
|
if (!(*pScreen->ModifyPixmapHeader)(pPixmap, width, height, depth,
|
2003-11-14 17:49:22 +01:00
|
|
|
BitsPerPixel(depth), PixmapBytePad(width, depth), (pointer)addr)) {
|
|
|
|
(*pScreen->DestroyPixmap)(pPixmap);
|
2003-11-14 16:54:54 +01:00
|
|
|
return NullPixmap;
|
2003-11-14 17:49:22 +01:00
|
|
|
}
|
2003-11-14 16:54:54 +01:00
|
|
|
return pPixmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmCreatePixmap(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
PixmapPtr pMap;
|
2006-12-15 00:27:09 +01:00
|
|
|
DrawablePtr pDraw;
|
2003-11-14 16:54:54 +01:00
|
|
|
DepthPtr pDepth;
|
2007-11-21 06:29:31 +01:00
|
|
|
int i, rc;
|
2003-11-14 16:54:54 +01:00
|
|
|
ShmDescPtr shmdesc;
|
|
|
|
REQUEST(xShmCreatePixmapReq);
|
2008-01-17 15:28:42 +01:00
|
|
|
unsigned int width, height, depth;
|
|
|
|
unsigned long size;
|
2003-11-14 16:54:54 +01:00
|
|
|
|
|
|
|
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
|
|
|
|
client->errorValue = stuff->pid;
|
|
|
|
if (!sharedPixmaps)
|
|
|
|
return BadImplementation;
|
|
|
|
LEGAL_NEW_RESOURCE(stuff->pid, client);
|
2006-12-15 00:27:09 +01:00
|
|
|
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
|
2007-09-20 12:53:51 +02:00
|
|
|
DixGetAttrAccess);
|
2006-12-15 00:27:09 +01:00
|
|
|
if (rc != Success)
|
|
|
|
return rc;
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
|
2008-01-17 15:28:42 +01:00
|
|
|
|
|
|
|
width = stuff->width;
|
|
|
|
height = stuff->height;
|
|
|
|
depth = stuff->depth;
|
|
|
|
if (!width || !height || !depth)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
client->errorValue = 0;
|
|
|
|
return BadValue;
|
|
|
|
}
|
2008-01-17 15:28:42 +01:00
|
|
|
if (width > 32767 || height > 32767)
|
|
|
|
return BadAlloc;
|
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
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;
|
|
|
|
}
|
2008-01-18 20:41:20 +01:00
|
|
|
|
2003-11-14 16:54:54 +01:00
|
|
|
CreatePmap:
|
2008-01-18 20:41:20 +01:00
|
|
|
size = PixmapBytePad(width, depth) * height;
|
|
|
|
if (sizeof(size) == 4 && BitsPerPixel(depth) > 8) {
|
|
|
|
if (size < width * height)
|
|
|
|
return BadAlloc;
|
|
|
|
}
|
2008-01-21 16:13:21 +01:00
|
|
|
/* thankfully, offset is unsigned */
|
|
|
|
if (stuff->offset + size < size)
|
|
|
|
return BadAlloc;
|
2008-01-18 20:41:20 +01:00
|
|
|
|
2008-01-17 15:28:42 +01:00
|
|
|
VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
|
2003-11-14 16:54:54 +01:00
|
|
|
pMap = (*shmFuncs[pDraw->pScreen->myNum]->CreatePixmap)(
|
|
|
|
pDraw->pScreen, stuff->width,
|
|
|
|
stuff->height, stuff->depth,
|
|
|
|
shmdesc->addr + stuff->offset);
|
|
|
|
if (pMap)
|
|
|
|
{
|
2007-09-20 12:53:51 +02:00
|
|
|
rc = XaceHook(XACE_RESOURCE_ACCESS, client, stuff->pid, RT_PIXMAP,
|
|
|
|
pMap, RT_NONE, NULL, DixCreateAccess);
|
|
|
|
if (rc != Success) {
|
|
|
|
pDraw->pScreen->DestroyPixmap(pMap);
|
|
|
|
return rc;
|
|
|
|
}
|
2007-08-28 15:28:25 +02:00
|
|
|
dixSetPrivate(&pMap->devPrivates, shmPixmapPrivate, shmdesc);
|
2003-11-14 17:49:22 +01:00
|
|
|
shmdesc->refcnt++;
|
2003-11-14 16:54:54 +01:00
|
|
|
pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
|
|
|
|
pMap->drawable.id = stuff->pid;
|
|
|
|
if (AddResource(stuff->pid, RT_PIXMAP, (pointer)pMap))
|
|
|
|
{
|
2003-11-14 17:49:22 +01:00
|
|
|
return(client->noClientException);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
2007-09-20 12:53:51 +02:00
|
|
|
pDraw->pScreen->DestroyPixmap(pMap);
|
2003-11-14 16:54:54 +01:00
|
|
|
}
|
|
|
|
return (BadAlloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
ProcShmDispatch (ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
REQUEST(xReq);
|
|
|
|
switch (stuff->data)
|
|
|
|
{
|
|
|
|
case X_ShmQueryVersion:
|
|
|
|
return ProcShmQueryVersion(client);
|
|
|
|
case X_ShmAttach:
|
|
|
|
return ProcShmAttach(client);
|
|
|
|
case X_ShmDetach:
|
|
|
|
return ProcShmDetach(client);
|
|
|
|
case X_ShmPutImage:
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef PANORAMIX
|
|
|
|
if ( !noPanoramiXExtension )
|
|
|
|
return ProcPanoramiXShmPutImage(client);
|
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
return ProcShmPutImage(client);
|
|
|
|
case X_ShmGetImage:
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef PANORAMIX
|
|
|
|
if ( !noPanoramiXExtension )
|
|
|
|
return ProcPanoramiXShmGetImage(client);
|
|
|
|
#endif
|
2003-11-14 16:54:54 +01:00
|
|
|
return ProcShmGetImage(client);
|
|
|
|
case X_ShmCreatePixmap:
|
2003-11-14 17:49:22 +01:00
|
|
|
#ifdef PANORAMIX
|
|
|
|
if ( !noPanoramiXExtension )
|
|
|
|
return ProcPanoramiXShmCreatePixmap(client);
|
|
|
|
#endif
|
|
|
|
return ProcShmCreatePixmap(client);
|
2003-11-14 16:54:54 +01:00
|
|
|
default:
|
|
|
|
return BadRequest;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2008-06-11 17:41:34 +02:00
|
|
|
SShmCompletionEvent(xShmCompletionEvent *from, xShmCompletionEvent *to)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
to->type = from->type;
|
|
|
|
cpswaps(from->sequenceNumber, to->sequenceNumber);
|
|
|
|
cpswapl(from->drawable, to->drawable);
|
|
|
|
cpswaps(from->minorEvent, to->minorEvent);
|
|
|
|
to->majorEvent = from->majorEvent;
|
|
|
|
cpswapl(from->shmseg, to->shmseg);
|
|
|
|
cpswapl(from->offset, to->offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmQueryVersion(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmQueryVersionReq);
|
|
|
|
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
return ProcShmQueryVersion(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmAttach(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmAttachReq);
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
REQUEST_SIZE_MATCH(xShmAttachReq);
|
|
|
|
swapl(&stuff->shmseg, n);
|
|
|
|
swapl(&stuff->shmid, n);
|
|
|
|
return ProcShmAttach(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmDetach(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmDetachReq);
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
REQUEST_SIZE_MATCH(xShmDetachReq);
|
|
|
|
swapl(&stuff->shmseg, n);
|
|
|
|
return ProcShmDetach(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmPutImage(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmPutImageReq);
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
REQUEST_SIZE_MATCH(xShmPutImageReq);
|
|
|
|
swapl(&stuff->drawable, n);
|
|
|
|
swapl(&stuff->gc, n);
|
|
|
|
swaps(&stuff->totalWidth, n);
|
|
|
|
swaps(&stuff->totalHeight, n);
|
|
|
|
swaps(&stuff->srcX, n);
|
|
|
|
swaps(&stuff->srcY, n);
|
|
|
|
swaps(&stuff->srcWidth, n);
|
|
|
|
swaps(&stuff->srcHeight, n);
|
|
|
|
swaps(&stuff->dstX, n);
|
|
|
|
swaps(&stuff->dstY, n);
|
|
|
|
swapl(&stuff->shmseg, n);
|
|
|
|
swapl(&stuff->offset, n);
|
|
|
|
return ProcShmPutImage(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmGetImage(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmGetImageReq);
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
REQUEST_SIZE_MATCH(xShmGetImageReq);
|
|
|
|
swapl(&stuff->drawable, n);
|
|
|
|
swaps(&stuff->x, n);
|
|
|
|
swaps(&stuff->y, n);
|
|
|
|
swaps(&stuff->width, n);
|
|
|
|
swaps(&stuff->height, n);
|
|
|
|
swapl(&stuff->planeMask, n);
|
|
|
|
swapl(&stuff->shmseg, n);
|
|
|
|
swapl(&stuff->offset, n);
|
|
|
|
return ProcShmGetImage(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmCreatePixmap(ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
2007-11-21 06:29:31 +01:00
|
|
|
int n;
|
2003-11-14 16:54:54 +01:00
|
|
|
REQUEST(xShmCreatePixmapReq);
|
|
|
|
swaps(&stuff->length, n);
|
|
|
|
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
|
2005-10-21 20:50:09 +02:00
|
|
|
swapl(&stuff->pid, n);
|
2003-11-14 16:54:54 +01:00
|
|
|
swapl(&stuff->drawable, n);
|
|
|
|
swaps(&stuff->width, n);
|
|
|
|
swaps(&stuff->height, n);
|
|
|
|
swapl(&stuff->shmseg, n);
|
|
|
|
swapl(&stuff->offset, n);
|
|
|
|
return ProcShmCreatePixmap(client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2008-06-11 17:41:34 +02:00
|
|
|
SProcShmDispatch (ClientPtr client)
|
2003-11-14 16:54:54 +01:00
|
|
|
{
|
|
|
|
REQUEST(xReq);
|
|
|
|
switch (stuff->data)
|
|
|
|
{
|
|
|
|
case X_ShmQueryVersion:
|
|
|
|
return SProcShmQueryVersion(client);
|
|
|
|
case X_ShmAttach:
|
|
|
|
return SProcShmAttach(client);
|
|
|
|
case X_ShmDetach:
|
|
|
|
return SProcShmDetach(client);
|
|
|
|
case X_ShmPutImage:
|
|
|
|
return SProcShmPutImage(client);
|
|
|
|
case X_ShmGetImage:
|
|
|
|
return SProcShmGetImage(client);
|
|
|
|
case X_ShmCreatePixmap:
|
|
|
|
return SProcShmCreatePixmap(client);
|
|
|
|
default:
|
|
|
|
return BadRequest;
|
|
|
|
}
|
|
|
|
}
|