frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce a consistent coding style 

This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
This commit is contained in:
Keith Packard 2012-03-21 12:55:09 -07:00
parent 75199129c6
commit 9838b7032e
1258 changed files with 257574 additions and 252857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Xext/bigreq.c
View File

@ -43,16 +43,16 @@ from The Open Group.
void BigReqExtensionInit(INITARGS); void BigReqExtensionInit(INITARGS);
static int static int
ProcBigReqDispatch (ClientPtr client) ProcBigReqDispatch(ClientPtr client)
{ {
REQUEST(xBigReqEnableReq); REQUEST(xBigReqEnableReq);
xBigReqEnableReply rep; xBigReqEnableReply rep;
if (client->swapped) { if (client->swapped) {
swaps(&stuff->length); swaps(&stuff->length);
} }
if (stuff->brReqType != X_BigReqEnable) if (stuff->brReqType != X_BigReqEnable)
return BadRequest; return BadRequest;
REQUEST_SIZE_MATCH(xBigReqEnableReq); REQUEST_SIZE_MATCH(xBigReqEnableReq);
client->big_requests = TRUE; client->big_requests = TRUE;
memset(&rep, 0, sizeof(xBigReqEnableReply)); memset(&rep, 0, sizeof(xBigReqEnableReply));
@ -61,10 +61,10 @@ ProcBigReqDispatch (ClientPtr client)
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.max_request_size = maxBigRequestSize; rep.max_request_size = maxBigRequestSize;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.max_request_size); swapl(&rep.max_request_size);
} }
WriteToClient(client, sizeof(xBigReqEnableReply), (char *)&rep); WriteToClient(client, sizeof(xBigReqEnableReply), (char *) &rep);
return Success; return Success;
} }
@ -72,6 +72,6 @@ void
BigReqExtensionInit(INITARGS) BigReqExtensionInit(INITARGS)
{ {
AddExtension(XBigReqExtensionName, 0, 0, AddExtension(XBigReqExtensionName, 0, 0,
ProcBigReqDispatch, ProcBigReqDispatch, ProcBigReqDispatch, ProcBigReqDispatch,
NULL, StandardMinorOpcode); NULL, StandardMinorOpcode);
} }

107
Xext/dpms.c
View File

@ -55,11 +55,11 @@ ProcDPMSGetVersion(ClientPtr client)
rep.majorVersion = DPMSMajorVersion; rep.majorVersion = DPMSMajorVersion;
rep.minorVersion = DPMSMinorVersion; rep.minorVersion = DPMSMinorVersion;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.majorVersion); swaps(&rep.majorVersion);
swaps(&rep.minorVersion); swaps(&rep.minorVersion);
} }
WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *)&rep); WriteToClient(client, sizeof(xDPMSGetVersionReply), (char *) &rep);
return Success; return Success;
} }
@ -77,9 +77,9 @@ ProcDPMSCapable(ClientPtr client)
rep.capable = DPMSCapableFlag; rep.capable = DPMSCapableFlag;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
} }
WriteToClient(client, sizeof(xDPMSCapableReply), (char *)&rep); WriteToClient(client, sizeof(xDPMSCapableReply), (char *) &rep);
return Success; return Success;
} }
@ -99,12 +99,12 @@ ProcDPMSGetTimeouts(ClientPtr client)
rep.off = DPMSOffTime / MILLI_PER_SECOND; rep.off = DPMSOffTime / MILLI_PER_SECOND;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.standby); swaps(&rep.standby);
swaps(&rep.suspend); swaps(&rep.suspend);
swaps(&rep.off); swaps(&rep.off);
} }
WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *)&rep); WriteToClient(client, sizeof(xDPMSGetTimeoutsReply), (char *) &rep);
return Success; return Success;
} }
@ -115,15 +115,13 @@ ProcDPMSSetTimeouts(ClientPtr client)
REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq); REQUEST_SIZE_MATCH(xDPMSSetTimeoutsReq);
if ((stuff->off != 0)&&(stuff->off < stuff->suspend)) if ((stuff->off != 0) && (stuff->off < stuff->suspend)) {
{ client->errorValue = stuff->off;
client->errorValue = stuff->off; return BadValue;
return BadValue;
} }
if ((stuff->suspend != 0)&&(stuff->suspend < stuff->standby)) if ((stuff->suspend != 0) && (stuff->suspend < stuff->standby)) {
{ client->errorValue = stuff->suspend;
client->errorValue = stuff->suspend; return BadValue;
return BadValue;
} }
DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND; DPMSStandbyTime = stuff->standby * MILLI_PER_SECOND;
@ -142,9 +140,9 @@ ProcDPMSEnable(ClientPtr client)
REQUEST_SIZE_MATCH(xDPMSEnableReq); REQUEST_SIZE_MATCH(xDPMSEnableReq);
if (DPMSCapableFlag) { if (DPMSCapableFlag) {
DPMSEnabled = TRUE; DPMSEnabled = TRUE;
if (!was_enabled) if (!was_enabled)
SetScreenSaverTimer(); SetScreenSaverTimer();
} }
return Success; return Success;
@ -172,14 +170,13 @@ ProcDPMSForceLevel(ClientPtr client)
REQUEST_SIZE_MATCH(xDPMSForceLevelReq); REQUEST_SIZE_MATCH(xDPMSForceLevelReq);
if (!DPMSEnabled) if (!DPMSEnabled)
return BadMatch; return BadMatch;
if (stuff->level != DPMSModeOn && if (stuff->level != DPMSModeOn &&
stuff->level != DPMSModeStandby && stuff->level != DPMSModeStandby &&
stuff->level != DPMSModeSuspend && stuff->level != DPMSModeSuspend && stuff->level != DPMSModeOff) {
stuff->level != DPMSModeOff) { client->errorValue = stuff->level;
client->errorValue = stuff->level; return BadValue;
return BadValue;
} }
DPMSSet(client, stuff->level); DPMSSet(client, stuff->level);
@ -202,38 +199,37 @@ ProcDPMSInfo(ClientPtr client)
rep.state = DPMSEnabled; rep.state = DPMSEnabled;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.power_level); swaps(&rep.power_level);
} }
WriteToClient(client, sizeof(xDPMSInfoReply), (char *)&rep); WriteToClient(client, sizeof(xDPMSInfoReply), (char *) &rep);
return Success; return Success;
} }
static int static int
ProcDPMSDispatch (ClientPtr client) ProcDPMSDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{
case X_DPMSGetVersion: case X_DPMSGetVersion:
return ProcDPMSGetVersion(client); return ProcDPMSGetVersion(client);
case X_DPMSCapable: case X_DPMSCapable:
return ProcDPMSCapable(client); return ProcDPMSCapable(client);
case X_DPMSGetTimeouts: case X_DPMSGetTimeouts:
return ProcDPMSGetTimeouts(client); return ProcDPMSGetTimeouts(client);
case X_DPMSSetTimeouts: case X_DPMSSetTimeouts:
return ProcDPMSSetTimeouts(client); return ProcDPMSSetTimeouts(client);
case X_DPMSEnable: case X_DPMSEnable:
return ProcDPMSEnable(client); return ProcDPMSEnable(client);
case X_DPMSDisable: case X_DPMSDisable:
return ProcDPMSDisable(client); return ProcDPMSDisable(client);
case X_DPMSForceLevel: case X_DPMSForceLevel:
return ProcDPMSForceLevel(client); return ProcDPMSForceLevel(client);
case X_DPMSInfo: case X_DPMSInfo:
return ProcDPMSInfo(client); return ProcDPMSInfo(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -332,29 +328,28 @@ SProcDPMSInfo(ClientPtr client)
} }
static int static int
SProcDPMSDispatch (ClientPtr client) SProcDPMSDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{
case X_DPMSGetVersion: case X_DPMSGetVersion:
return SProcDPMSGetVersion(client); return SProcDPMSGetVersion(client);
case X_DPMSCapable: case X_DPMSCapable:
return SProcDPMSCapable(client); return SProcDPMSCapable(client);
case X_DPMSGetTimeouts: case X_DPMSGetTimeouts:
return SProcDPMSGetTimeouts(client); return SProcDPMSGetTimeouts(client);
case X_DPMSSetTimeouts: case X_DPMSSetTimeouts:
return SProcDPMSSetTimeouts(client); return SProcDPMSSetTimeouts(client);
case X_DPMSEnable: case X_DPMSEnable:
return SProcDPMSEnable(client); return SProcDPMSEnable(client);
case X_DPMSDisable: case X_DPMSDisable:
return SProcDPMSDisable(client); return SProcDPMSDisable(client);
case X_DPMSForceLevel: case X_DPMSForceLevel:
return SProcDPMSForceLevel(client); return SProcDPMSForceLevel(client);
case X_DPMSInfo: case X_DPMSInfo:
return SProcDPMSInfo(client); return SProcDPMSInfo(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -362,6 +357,6 @@ void
DPMSExtensionInit(INITARGS) DPMSExtensionInit(INITARGS)
{ {
AddExtension(DPMSExtensionName, 0, 0, AddExtension(DPMSExtensionName, 0, 0,
ProcDPMSDispatch, SProcDPMSDispatch, ProcDPMSDispatch, SProcDPMSDispatch,
NULL, StandardMinorOpcode); NULL, StandardMinorOpcode);
} }

2
Xext/dpmsproc.h
View File

@ -9,7 +9,7 @@
#include "dixstruct.h" #include "dixstruct.h"
int DPMSSet(ClientPtr client, int level); int DPMSSet(ClientPtr client, int level);
Bool DPMSSupported(void); Bool DPMSSupported(void);
#endif #endif

6
Xext/dpmsstubs.c
View File

@ -34,12 +34,14 @@ Equipment Corporation.
#define FALSE 0 #define FALSE 0
Bool DPMSSupported(void) Bool
DPMSSupported(void)
{ {
return FALSE; return FALSE;
} }
int DPMSSet(ClientPtr client, int level) int
DPMSSet(ClientPtr client, int level)
{ {
return Success; return Success;
} }

87
Xext/geext.c
View File

@ -35,18 +35,18 @@
DevPrivateKeyRec GEClientPrivateKeyRec; DevPrivateKeyRec GEClientPrivateKeyRec;
int RT_GECLIENT = 0; int RT_GECLIENT = 0;
GEExtension GEExtensions[MAXEXTENSIONS]; GEExtension GEExtensions[MAXEXTENSIONS];
/* Major available requests */ /* Major available requests */
static const int version_requests[] = { static const int version_requests[] = {
X_GEQueryVersion, /* before client sends QueryVersion */ X_GEQueryVersion, /* before client sends QueryVersion */
X_GEQueryVersion, /* must be set to last request in version 1 */ X_GEQueryVersion, /* must be set to last request in version 1 */
}; };
/* Forward declarations */ /* Forward declarations */
static void SGEGenericEvent(xEvent* from, xEvent* to); static void SGEGenericEvent(xEvent *from, xEvent *to);
#define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0])) #define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0]))
#define EXT_MASK(ext) ((ext) & 0x7F) #define EXT_MASK(ext) ((ext) & 0x7F)
@ -60,6 +60,7 @@ ProcGEQueryVersion(ClientPtr client)
{ {
GEClientInfoPtr pGEClient = GEGetClient(client); GEClientInfoPtr pGEClient = GEGetClient(client);
xGEQueryVersionReply rep; xGEQueryVersionReply rep;
REQUEST(xGEQueryVersionReq); REQUEST(xGEQueryVersionReq);
REQUEST_SIZE_MATCH(xGEQueryVersionReq); REQUEST_SIZE_MATCH(xGEQueryVersionReq);
@ -77,22 +78,20 @@ ProcGEQueryVersion(ClientPtr client)
pGEClient->major_version = stuff->majorVersion; pGEClient->major_version = stuff->majorVersion;
pGEClient->minor_version = stuff->minorVersion; pGEClient->minor_version = stuff->minorVersion;
if (client->swapped) if (client->swapped) {
{ swaps(&rep.sequenceNumber);
swaps(&rep.sequenceNumber); swapl(&rep.length);
swapl(&rep.length); swaps(&rep.majorVersion);
swaps(&rep.majorVersion); swaps(&rep.minorVersion);
swaps(&rep.minorVersion);
} }
WriteToClient(client, sizeof(xGEQueryVersionReply), (char*)&rep); WriteToClient(client, sizeof(xGEQueryVersionReply), (char *) &rep);
return Success; return Success;
} }
int (*ProcGEVector[GENumberRequests])(ClientPtr) = { int (*ProcGEVector[GENumberRequests]) (ClientPtr) = {
/* Version 1.0 */ /* Version 1.0 */
ProcGEQueryVersion ProcGEQueryVersion};
};
/************************************************************/ /************************************************************/
/* swapped request handlers */ /* swapped request handlers */
@ -106,14 +105,12 @@ SProcGEQueryVersion(ClientPtr client)
REQUEST_SIZE_MATCH(xGEQueryVersionReq); REQUEST_SIZE_MATCH(xGEQueryVersionReq);
swaps(&stuff->majorVersion); swaps(&stuff->majorVersion);
swaps(&stuff->minorVersion); swaps(&stuff->minorVersion);
return(*ProcGEVector[stuff->ReqType])(client); return (*ProcGEVector[stuff->ReqType]) (client);
} }
int (*SProcGEVector[GENumberRequests])(ClientPtr) = { int (*SProcGEVector[GENumberRequests]) (ClientPtr) = {
/* Version 1.0 */ /* Version 1.0 */
SProcGEQueryVersion SProcGEQueryVersion};
};
/************************************************************/ /************************************************************/
/* callbacks */ /* callbacks */
@ -124,6 +121,7 @@ static int
ProcGEDispatch(ClientPtr client) ProcGEDispatch(ClientPtr client)
{ {
GEClientInfoPtr pGEClient = GEGetClient(client); GEClientInfoPtr pGEClient = GEGetClient(client);
REQUEST(xGEReq); REQUEST(xGEReq);
if (pGEClient->major_version >= NUM_VERSION_REQUESTS) if (pGEClient->major_version >= NUM_VERSION_REQUESTS)
@ -131,7 +129,7 @@ ProcGEDispatch(ClientPtr client)
if (stuff->ReqType > version_requests[pGEClient->major_version]) if (stuff->ReqType > version_requests[pGEClient->major_version])
return BadRequest; return BadRequest;
return (ProcGEVector[stuff->ReqType])(client); return (ProcGEVector[stuff->ReqType]) (client);
} }
/* dispatch swapped requests */ /* dispatch swapped requests */
@ -141,7 +139,7 @@ SProcGEDispatch(ClientPtr client)
REQUEST(xGEReq); REQUEST(xGEReq);
if (stuff->ReqType >= GENumberRequests) if (stuff->ReqType >= GENumberRequests)
return BadRequest; return BadRequest;
return (*SProcGEVector[stuff->ReqType])(client); return (*SProcGEVector[stuff->ReqType]) (client);
} }
/** /**
@ -151,13 +149,11 @@ SProcGEDispatch(ClientPtr client)
* used in the furture for versioning support. * used in the furture for versioning support.
*/ */
static void static void
GEClientCallback(CallbackListPtr *list, GEClientCallback(CallbackListPtr *list, pointer closure, pointer data)
pointer closure,
pointer data)
{ {
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client; ClientPtr pClient = clientinfo->client;
GEClientInfoPtr pGEClient = GEGetClient(pClient); GEClientInfoPtr pGEClient = GEGetClient(pClient);
pGEClient->major_version = 0; pGEClient->major_version = 0;
pGEClient->minor_version = 0; pGEClient->minor_version = 0;
@ -165,7 +161,7 @@ GEClientCallback(CallbackListPtr *list,
/* Reset extension. Called on server shutdown. */ /* Reset extension. Called on server shutdown. */
static void static void
GEResetProc(ExtensionEntry *extEntry) GEResetProc(ExtensionEntry * extEntry)
{ {
DeleteCallback(&ClientStateCallback, GEClientCallback, 0); DeleteCallback(&ClientStateCallback, GEClientCallback, 0);
EventSwapVector[GenericEvent] = NotImplemented; EventSwapVector[GenericEvent] = NotImplemented;
@ -179,13 +175,12 @@ GEResetProc(ExtensionEntry *extEntry)
* work. * work.
*/ */
static void static void
SGEGenericEvent(xEvent* from, xEvent* to) SGEGenericEvent(xEvent *from, xEvent *to)
{ {
xGenericEvent* gefrom = (xGenericEvent*)from; xGenericEvent *gefrom = (xGenericEvent *) from;
xGenericEvent* geto = (xGenericEvent*)to; xGenericEvent *geto = (xGenericEvent *) to;
if ((gefrom->extension & 0x7f) > MAXEXTENSIONS) if ((gefrom->extension & 0x7f) > MAXEXTENSIONS) {
{
ErrorF("GE: Invalid extension offset for event.\n"); ErrorF("GE: Invalid extension offset for event.\n");
return; return;
} }
@ -203,23 +198,23 @@ GEExtensionInit(void)
{ {
ExtensionEntry *extEntry; ExtensionEntry *extEntry;
if (!dixRegisterPrivateKey(&GEClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(GEClientInfoRec))) if (!dixRegisterPrivateKey
(&GEClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(GEClientInfoRec)))
FatalError("GEExtensionInit: GE private request failed.\n"); FatalError("GEExtensionInit: GE private request failed.\n");
if(!AddCallback(&ClientStateCallback, GEClientCallback, 0)) if (!AddCallback(&ClientStateCallback, GEClientCallback, 0)) {
{
FatalError("GEExtensionInit: register client callback failed.\n"); FatalError("GEExtensionInit: register client callback failed.\n");
} }
if((extEntry = AddExtension(GE_NAME, if ((extEntry = AddExtension(GE_NAME,
0, GENumberErrors, 0, GENumberErrors,
ProcGEDispatch, SProcGEDispatch, ProcGEDispatch, SProcGEDispatch,
GEResetProc, StandardMinorOpcode)) != 0) GEResetProc, StandardMinorOpcode)) != 0) {
{
memset(GEExtensions, 0, sizeof(GEExtensions)); memset(GEExtensions, 0, sizeof(GEExtensions));
EventSwapVector[GenericEvent] = (EventSwapPtr) SGEGenericEvent; EventSwapVector[GenericEvent] = (EventSwapPtr) SGEGenericEvent;
} else { }
else {
FatalError("GEInit: AddExtensions failed.\n"); FatalError("GEInit: AddExtensions failed.\n");
} }
@ -238,24 +233,22 @@ GEExtensionInit(void)
*/ */
void void
GERegisterExtension(int extension, GERegisterExtension(int extension,
void (*ev_swap)(xGenericEvent* from, xGenericEvent* to)) void (*ev_swap) (xGenericEvent *from, xGenericEvent *to))
{ {
if (EXT_MASK(extension) >= MAXEXTENSIONS) if (EXT_MASK(extension) >= MAXEXTENSIONS)
FatalError("GE: extension > MAXEXTENSIONS. This should not happen.\n"); FatalError("GE: extension > MAXEXTENSIONS. This should not happen.\n");
/* extension opcodes are > 128, might as well save some space here */ /* extension opcodes are > 128, might as well save some space here */
GEExtensions[EXT_MASK(extension)].evswap = ev_swap; GEExtensions[EXT_MASK(extension)].evswap = ev_swap;
} }
/* Sets type and extension field for a generic event. This is just an /* Sets type and extension field for a generic event. This is just an
* auxiliary function, extensions could do it manually too. * auxiliary function, extensions could do it manually too.
*/ */
void void
GEInitEvent(xGenericEvent* ev, int extension) GEInitEvent(xGenericEvent *ev, int extension)
{ {
ev->type = GenericEvent; ev->type = GenericEvent;
ev->extension = extension; ev->extension = extension;
ev->length = 0; ev->length = 0;
} }

16
Xext/geext.h
View File

@ -37,10 +37,9 @@ from the author.
/** Struct to keep information about registered extensions */ /** Struct to keep information about registered extensions */
typedef struct _GEExtension { typedef struct _GEExtension {
/** Event swapping routine */ /** Event swapping routine */
void (*evswap)(xGenericEvent* from, xGenericEvent* to); void (*evswap) (xGenericEvent *from, xGenericEvent *to);
} GEExtension, *GEExtensionPtr; } GEExtension, *GEExtensionPtr;
/* All registered extensions and their handling functions. */ /* All registered extensions and their handling functions. */
extern _X_EXPORT GEExtension GEExtensions[MAXEXTENSIONS]; extern _X_EXPORT GEExtension GEExtensions[MAXEXTENSIONS];
@ -70,14 +69,15 @@ extern _X_EXPORT GEExtension GEExtensions[MAXEXTENSIONS];
GEEXT(ev) == (ext) && \ GEEXT(ev) == (ext) && \
GEV(ev)->evtype == (ev_type)) GEV(ev)->evtype == (ev_type))
/* Interface for other extensions */ /* Interface for other extensions */
extern _X_EXPORT void GERegisterExtension( extern _X_EXPORT void GERegisterExtension(int extension,
int extension, void (*ev_dispatch) (xGenericEvent
void (*ev_dispatch)(xGenericEvent* from, xGenericEvent* to)); *from,
xGenericEvent
*to));
extern _X_EXPORT void GEInitEvent(xGenericEvent* ev, int extension); extern _X_EXPORT void GEInitEvent(xGenericEvent *ev, int extension);
extern _X_EXPORT void GEExtensionInit(void); extern _X_EXPORT void GEExtensionInit(void);
#endif /* _GEEXT_H_ */ #endif /* _GEEXT_H_ */

11
Xext/geint.h
View File

@ -38,16 +38,17 @@
#include <X11/extensions/geproto.h> #include <X11/extensions/geproto.h>
extern _X_EXPORT DevPrivateKeyRec GEClientPrivateKeyRec; extern _X_EXPORT DevPrivateKeyRec GEClientPrivateKeyRec;
#define GEClientPrivateKey (&GEClientPrivateKeyRec) #define GEClientPrivateKey (&GEClientPrivateKeyRec)
typedef struct _GEClientInfo { typedef struct _GEClientInfo {
CARD32 major_version; CARD32 major_version;
CARD32 minor_version; CARD32 minor_version;
} GEClientInfoRec, *GEClientInfoPtr; } GEClientInfoRec, *GEClientInfoPtr;
#define GEGetClient(pClient) ((GEClientInfoPtr)(dixLookupPrivate(&((pClient)->devPrivates), GEClientPrivateKey))) #define GEGetClient(pClient) ((GEClientInfoPtr)(dixLookupPrivate(&((pClient)->devPrivates), GEClientPrivateKey)))
extern _X_EXPORT int (*ProcGEVector[/*GENumRequests*/])(ClientPtr); extern _X_EXPORT int (*ProcGEVector[ /*GENumRequests */ ]) (ClientPtr);
extern _X_EXPORT int (*SProcGEVector[/*GENumRequests*/])(ClientPtr); extern _X_EXPORT int (*SProcGEVector[ /*GENumRequests */ ]) (ClientPtr);
#endif /* _GEINT_H_ */ #endif /* _GEINT_H_ */

1136
Xext/panoramiX.c
View File

File diff suppressed because it is too large Load Diff

29
Xext/panoramiX.h
View File

@ -26,7 +26,6 @@ Equipment Corporation.
******************************************************************/ ******************************************************************/
/* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */ /* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */
/* /*
@ -47,25 +46,25 @@ Equipment Corporation.
#include "dixstruct.h" #include "dixstruct.h"
typedef struct _PanoramiXInfo { typedef struct _PanoramiXInfo {
XID id ; XID id;
} PanoramiXInfo; } PanoramiXInfo;
typedef struct { typedef struct {
PanoramiXInfo info[MAXSCREENS]; PanoramiXInfo info[MAXSCREENS];
RESTYPE type; RESTYPE type;
union { union {
struct { struct {
char visibility; char visibility;
char class; char class;
char root; char root;
} win; } win;
struct { struct {
Bool shared; Bool shared;
} pix; } pix;
struct { struct {
Bool root; Bool root;
} pict; } pict;
char raw_data[4]; char raw_data[4];
} u; } u;
} PanoramiXRes; } PanoramiXRes;
@ -77,4 +76,4 @@ typedef struct {
#define IS_SHARED_PIXMAP(r) (((r)->type == XRT_PIXMAP) && (r)->u.pix.shared) #define IS_SHARED_PIXMAP(r) (((r)->type == XRT_PIXMAP) && (r)->u.pix.shared)
#define IS_ROOT_DRAWABLE(d) (((d)->type == XRT_WINDOW) && (d)->u.win.root) #define IS_ROOT_DRAWABLE(d) (((d)->type == XRT_WINDOW) && (d)->u.win.root)
#endif /* _PANORAMIX_H_ */ #endif /* _PANORAMIX_H_ */

93
Xext/panoramiXSwap.c
View File

@ -48,89 +48,86 @@ Equipment Corporation.
#include "panoramiXh.h" #include "panoramiXh.h"
static int static int
SProcPanoramiXQueryVersion (ClientPtr client) SProcPanoramiXQueryVersion(ClientPtr client)
{ {
REQUEST(xPanoramiXQueryVersionReq); REQUEST(xPanoramiXQueryVersionReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq); REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq);
return ProcPanoramiXQueryVersion(client); return ProcPanoramiXQueryVersion(client);
} }
static int static int
SProcPanoramiXGetState(ClientPtr client) SProcPanoramiXGetState(ClientPtr client)
{ {
REQUEST(xPanoramiXGetStateReq); REQUEST(xPanoramiXGetStateReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetStateReq); REQUEST_SIZE_MATCH(xPanoramiXGetStateReq);
swapl(&stuff->window); swapl(&stuff->window);
return ProcPanoramiXGetState(client); return ProcPanoramiXGetState(client);
} }
static int static int
SProcPanoramiXGetScreenCount(ClientPtr client) SProcPanoramiXGetScreenCount(ClientPtr client)
{ {
REQUEST(xPanoramiXGetScreenCountReq); REQUEST(xPanoramiXGetScreenCountReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq); REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq);
swapl(&stuff->window); swapl(&stuff->window);
return ProcPanoramiXGetScreenCount(client); return ProcPanoramiXGetScreenCount(client);
} }
static int static int
SProcPanoramiXGetScreenSize(ClientPtr client) SProcPanoramiXGetScreenSize(ClientPtr client)
{ {
REQUEST(xPanoramiXGetScreenSizeReq); REQUEST(xPanoramiXGetScreenSizeReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq); REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq);
swapl(&stuff->window); swapl(&stuff->window);
swapl(&stuff->screen); swapl(&stuff->screen);
return ProcPanoramiXGetScreenSize(client); return ProcPanoramiXGetScreenSize(client);
} }
static int static int
SProcXineramaIsActive(ClientPtr client) SProcXineramaIsActive(ClientPtr client)
{ {
REQUEST(xXineramaIsActiveReq); REQUEST(xXineramaIsActiveReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaIsActiveReq); REQUEST_SIZE_MATCH(xXineramaIsActiveReq);
return ProcXineramaIsActive(client); return ProcXineramaIsActive(client);
} }
static int static int
SProcXineramaQueryScreens(ClientPtr client) SProcXineramaQueryScreens(ClientPtr client)
{ {
REQUEST(xXineramaQueryScreensReq); REQUEST(xXineramaQueryScreensReq);
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_SIZE_MATCH(xXineramaQueryScreensReq); REQUEST_SIZE_MATCH(xXineramaQueryScreensReq);
return ProcXineramaQueryScreens(client); return ProcXineramaQueryScreens(client);
} }
int int
SProcPanoramiXDispatch (ClientPtr client) SProcPanoramiXDispatch(ClientPtr client)
{ REQUEST(xReq); {
switch (stuff->data) REQUEST(xReq);
{ switch (stuff->data) {
case X_PanoramiXQueryVersion: case X_PanoramiXQueryVersion:
return SProcPanoramiXQueryVersion(client); return SProcPanoramiXQueryVersion(client);
case X_PanoramiXGetState: case X_PanoramiXGetState:
return SProcPanoramiXGetState(client); return SProcPanoramiXGetState(client);
case X_PanoramiXGetScreenCount: case X_PanoramiXGetScreenCount:
return SProcPanoramiXGetScreenCount(client); return SProcPanoramiXGetScreenCount(client);
case X_PanoramiXGetScreenSize: case X_PanoramiXGetScreenSize:
return SProcPanoramiXGetScreenSize(client); return SProcPanoramiXGetScreenSize(client);
case X_XineramaIsActive: case X_XineramaIsActive:
return SProcXineramaIsActive(client); return SProcXineramaIsActive(client);
case X_XineramaQueryScreens: case X_XineramaQueryScreens:
return SProcXineramaQueryScreens(client); return SProcXineramaQueryScreens(client);
} }
return BadRequest; return BadRequest;
} }

2
Xext/panoramiXh.h
View File

@ -70,4 +70,4 @@ extern int SProcPanoramiXDispatch(ClientPtr client);
extern int connBlockScreenStart; extern int connBlockScreenStart;
extern xConnSetupPrefix connSetupPrefix; extern xConnSetupPrefix connSetupPrefix;
extern int (* SavedProcVector[256]) (ClientPtr client); extern int (*SavedProcVector[256]) (ClientPtr client);

2600
Xext/panoramiXprocs.c
View File

File diff suppressed because it is too large Load Diff

33
Xext/panoramiXsrv.h
View File

@ -15,8 +15,9 @@ extern _X_EXPORT int PanoramiXPixHeight;
extern _X_EXPORT VisualID PanoramiXTranslateVisualID(int screen, VisualID orig); extern _X_EXPORT VisualID PanoramiXTranslateVisualID(int screen, VisualID orig);
extern _X_EXPORT void PanoramiXConsolidate(void); extern _X_EXPORT void PanoramiXConsolidate(void);
extern _X_EXPORT Bool PanoramiXCreateConnectionBlock(void); extern _X_EXPORT Bool PanoramiXCreateConnectionBlock(void);
extern _X_EXPORT PanoramiXRes * PanoramiXFindIDByScrnum(RESTYPE, XID, int); extern _X_EXPORT PanoramiXRes *PanoramiXFindIDByScrnum(RESTYPE, XID, int);
extern _X_EXPORT Bool XineramaRegisterConnectionBlockCallback(void (*func)(void)); extern _X_EXPORT Bool
XineramaRegisterConnectionBlockCallback(void (*func) (void));
extern _X_EXPORT int XineramaDeleteResource(pointer, XID); extern _X_EXPORT int XineramaDeleteResource(pointer, XID);
extern _X_EXPORT void XineramaReinitData(void); extern _X_EXPORT void XineramaReinitData(void);
@ -35,24 +36,20 @@ extern _X_EXPORT RESTYPE XRT_PICTURE;
* layers agree that the visuals are equal. The first visual is always from * layers agree that the visuals are equal. The first visual is always from
* screen 0. * screen 0.
*/ */
typedef Bool (*XineramaVisualsEqualProcPtr)(VisualPtr, ScreenPtr, VisualPtr); typedef Bool (*XineramaVisualsEqualProcPtr) (VisualPtr, ScreenPtr, VisualPtr);
extern _X_EXPORT XineramaVisualsEqualProcPtr XineramaVisualsEqualPtr; extern _X_EXPORT XineramaVisualsEqualProcPtr XineramaVisualsEqualPtr;
extern _X_EXPORT void XineramaGetImageData( extern _X_EXPORT void XineramaGetImageData(DrawablePtr *pDrawables,
DrawablePtr *pDrawables, int left,
int left, int top,
int top, int width,
int width, int height,
int height, unsigned int format,
unsigned int format, unsigned long planemask,
unsigned long planemask, char *data, int pitch, Bool isRoot);
char *data,
int pitch,
Bool isRoot
);
static inline void panoramix_setup_ids(PanoramiXRes *resource, static inline void
ClientPtr client, XID base_id) panoramix_setup_ids(PanoramiXRes * resource, ClientPtr client, XID base_id)
{ {
int j; int j;
@ -62,4 +59,4 @@ static inline void panoramix_setup_ids(PanoramiXRes *resource,
} }
} }
#endif /* _PANORAMIXSRV_H_ */ #endif /* _PANORAMIXSRV_H_ */

1622
Xext/saver.c
View File

File diff suppressed because it is too large Load Diff

726
Xext/security.c
View File

File diff suppressed because it is too large Load Diff

45
Xext/securitysrv.h
View File

@ -32,52 +32,51 @@ from The Open Group.
/* Allow client side portions of <X11/extensions/security.h> to compile */ /* Allow client side portions of <X11/extensions/security.h> to compile */
#ifndef Status #ifndef Status
# define Status int #define Status int
# define NEED_UNDEF_Status #define NEED_UNDEF_Status
#endif #endif
#ifndef Display #ifndef Display
# define Display void #define Display void
# define NEED_UNDEF_Display #define NEED_UNDEF_Display
#endif #endif
#include <X11/extensions/secur.h> #include <X11/extensions/secur.h>
#ifdef NEED_UNDEF_Status #ifdef NEED_UNDEF_Status
# undef Status #undef Status
# undef NEED_UNDEF_Status #undef NEED_UNDEF_Status
#endif #endif
#ifdef NEED_UNDEF_Display #ifdef NEED_UNDEF_Display
# undef Display #undef Display
# undef NEED_UNDEF_Display #undef NEED_UNDEF_Display
#endif #endif
#include "input.h" /* for DeviceIntPtr */
#include "input.h" /* for DeviceIntPtr */ #include "property.h" /* for PropertyPtr */
#include "property.h" /* for PropertyPtr */ #include "pixmap.h" /* for DrawablePtr */
#include "pixmap.h" /* for DrawablePtr */ #include "resource.h" /* for RESTYPE */
#include "resource.h" /* for RESTYPE */
/* resource type to pass in LookupIDByType for authorizations */ /* resource type to pass in LookupIDByType for authorizations */
extern RESTYPE SecurityAuthorizationResType; extern RESTYPE SecurityAuthorizationResType;
/* this is what we store for an authorization */ /* this is what we store for an authorization */
typedef struct { typedef struct {
XID id; /* resource ID */ XID id; /* resource ID */
CARD32 timeout; /* how long to live in seconds after refcnt == 0 */ CARD32 timeout; /* how long to live in seconds after refcnt == 0 */
unsigned int trustLevel; /* trusted/untrusted */ unsigned int trustLevel; /* trusted/untrusted */
XID group; /* see embedding extension */ XID group; /* see embedding extension */
unsigned int refcnt; /* how many clients connected with this auth */ unsigned int refcnt; /* how many clients connected with this auth */
unsigned int secondsRemaining; /* overflow time amount for >49 days */ unsigned int secondsRemaining; /* overflow time amount for >49 days */
OsTimerPtr timer; /* timer for this auth */ OsTimerPtr timer; /* timer for this auth */
struct _OtherClients *eventClients; /* clients wanting events */ struct _OtherClients *eventClients; /* clients wanting events */
} SecurityAuthorizationRec, *SecurityAuthorizationPtr; } SecurityAuthorizationRec, *SecurityAuthorizationPtr;
typedef struct { typedef struct {
XID group; /* the group that was sent in GenerateAuthorization */ XID group; /* the group that was sent in GenerateAuthorization */
Bool valid; /* did anyone recognize it? if so, set to TRUE */ Bool valid; /* did anyone recognize it? if so, set to TRUE */
} SecurityValidateGroupInfoRec; } SecurityValidateGroupInfoRec;
/* Give this value or higher to the -audit option to get security messages */ /* Give this value or higher to the -audit option to get security messages */
#define SECURITY_AUDIT_LEVEL 4 #define SECURITY_AUDIT_LEVEL 4
#endif /* _SECURITY_SRV_H */ #endif /* _SECURITY_SRV_H */

1311
Xext/shape.c
View File

File diff suppressed because it is too large Load Diff

1045
Xext/shm.c
View File

File diff suppressed because it is too large Load Diff

14
Xext/shmint.h
View File

@ -42,28 +42,28 @@
int /* sh */, \ int /* sh */, \
int /* dx */, \ int /* dx */, \
int /* dy */, \ int /* dy */, \
char * /* data */ char * /* data */
#define XSHM_CREATE_PIXMAP_ARGS \ #define XSHM_CREATE_PIXMAP_ARGS \
ScreenPtr /* pScreen */, \ ScreenPtr /* pScreen */, \
int /* width */, \ int /* width */, \
int /* height */, \ int /* height */, \
int /* depth */, \ int /* depth */, \
char * /* addr */ char * /* addr */
typedef struct _ShmFuncs { typedef struct _ShmFuncs {
PixmapPtr (* CreatePixmap)(XSHM_CREATE_PIXMAP_ARGS); PixmapPtr (*CreatePixmap) (XSHM_CREATE_PIXMAP_ARGS);
void (* PutImage)(XSHM_PUT_IMAGE_ARGS); void (*PutImage) (XSHM_PUT_IMAGE_ARGS);
} ShmFuncs, *ShmFuncsPtr; } ShmFuncs, *ShmFuncsPtr;
extern _X_EXPORT void extern _X_EXPORT void
ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs); ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
extern _X_EXPORT void extern _X_EXPORT void
ShmRegisterFbFuncs(ScreenPtr pScreen); ShmRegisterFbFuncs(ScreenPtr pScreen);
extern _X_EXPORT RESTYPE ShmSegType; extern _X_EXPORT RESTYPE ShmSegType;
extern _X_EXPORT int ShmCompletionCode; extern _X_EXPORT int ShmCompletionCode;
extern _X_EXPORT int BadShmSegCode; extern _X_EXPORT int BadShmSegCode;
#endif /* _SHMINT_H_ */ #endif /* _SHMINT_H_ */

222
Xext/sleepuntil.c
View File

@ -41,185 +41,169 @@ in this Software without prior written authorization from The Open Group.
#include "scrnintstr.h" #include "scrnintstr.h"
typedef struct _Sertafied { typedef struct _Sertafied {
struct _Sertafied *next; struct _Sertafied *next;
TimeStamp revive; TimeStamp revive;
ClientPtr pClient; ClientPtr pClient;
XID id; XID id;
void (*notifyFunc)( void (*notifyFunc) (ClientPtr /* client */ ,
ClientPtr /* client */, pointer /* closure */
pointer /* closure */ );
);
pointer closure; pointer closure;
} SertafiedRec, *SertafiedPtr; } SertafiedRec, *SertafiedPtr;
static SertafiedPtr pPending; static SertafiedPtr pPending;
static RESTYPE SertafiedResType; static RESTYPE SertafiedResType;
static Bool BlockHandlerRegistered; static Bool BlockHandlerRegistered;
static int SertafiedGeneration; static int SertafiedGeneration;
static void ClientAwaken( static void ClientAwaken(ClientPtr /* client */ ,
ClientPtr /* client */, pointer /* closure */
pointer /* closure */ );
); static int SertafiedDelete(pointer /* value */ ,
static int SertafiedDelete( XID /* id */
pointer /* value */, );
XID /* id */ static void SertafiedBlockHandler(pointer /* data */ ,
); OSTimePtr /* wt */ ,
static void SertafiedBlockHandler( pointer /* LastSelectMask */
pointer /* data */, );
OSTimePtr /* wt */, static void SertafiedWakeupHandler(pointer /* data */ ,
pointer /* LastSelectMask */ int /* i */ ,
); pointer /* LastSelectMask */
static void SertafiedWakeupHandler( );
pointer /* data */,
int /* i */,
pointer /* LastSelectMask */
);
int int
ClientSleepUntil (ClientPtr client, ClientSleepUntil(ClientPtr client,
TimeStamp *revive, TimeStamp *revive,
void (*notifyFunc)(ClientPtr, pointer), void (*notifyFunc) (ClientPtr, pointer), pointer closure)
pointer closure)
{ {
SertafiedPtr pRequest, pReq, pPrev; SertafiedPtr pRequest, pReq, pPrev;
if (SertafiedGeneration != serverGeneration) if (SertafiedGeneration != serverGeneration) {
{ SertafiedResType = CreateNewResourceType(SertafiedDelete,
SertafiedResType = CreateNewResourceType (SertafiedDelete, "ClientSleep");
"ClientSleep"); if (!SertafiedResType)
if (!SertafiedResType) return FALSE;
return FALSE; SertafiedGeneration = serverGeneration;
SertafiedGeneration = serverGeneration; BlockHandlerRegistered = FALSE;
BlockHandlerRegistered = FALSE;
} }
pRequest = malloc(sizeof (SertafiedRec)); pRequest = malloc(sizeof(SertafiedRec));
if (!pRequest) if (!pRequest)
return FALSE; return FALSE;
pRequest->pClient = client; pRequest->pClient = client;
pRequest->revive = *revive; pRequest->revive = *revive;
pRequest->id = FakeClientID (client->index); pRequest->id = FakeClientID(client->index);
pRequest->closure = closure; pRequest->closure = closure;
if (!BlockHandlerRegistered) if (!BlockHandlerRegistered) {
{ if (!RegisterBlockAndWakeupHandlers(SertafiedBlockHandler,
if (!RegisterBlockAndWakeupHandlers (SertafiedBlockHandler, SertafiedWakeupHandler,
SertafiedWakeupHandler, (pointer) 0)) {
(pointer) 0)) free(pRequest);
{ return FALSE;
free(pRequest); }
return FALSE; BlockHandlerRegistered = TRUE;
}
BlockHandlerRegistered = TRUE;
} }
pRequest->notifyFunc = 0; pRequest->notifyFunc = 0;
if (!AddResource (pRequest->id, SertafiedResType, (pointer) pRequest)) if (!AddResource(pRequest->id, SertafiedResType, (pointer) pRequest))
return FALSE; return FALSE;
if (!notifyFunc) if (!notifyFunc)
notifyFunc = ClientAwaken; notifyFunc = ClientAwaken;
pRequest->notifyFunc = notifyFunc; pRequest->notifyFunc = notifyFunc;
/* Insert into time-ordered queue, with earliest activation time coming first. */ /* Insert into time-ordered queue, with earliest activation time coming first. */
pPrev = 0; pPrev = 0;
for (pReq = pPending; pReq; pReq = pReq->next) for (pReq = pPending; pReq; pReq = pReq->next) {
{ if (CompareTimeStamps(pReq->revive, *revive) == LATER)
if (CompareTimeStamps (pReq->revive, *revive) == LATER) break;
break; pPrev = pReq;
pPrev = pReq;
} }
if (pPrev) if (pPrev)
pPrev->next = pRequest; pPrev->next = pRequest;
else else
pPending = pRequest; pPending = pRequest;
pRequest->next = pReq; pRequest->next = pReq;
IgnoreClient (client); IgnoreClient(client);
return TRUE; return TRUE;
} }
static void static void
ClientAwaken (ClientPtr client, pointer closure) ClientAwaken(ClientPtr client, pointer closure)
{ {
if (!client->clientGone) if (!client->clientGone)
AttendClient (client); AttendClient(client);
} }
static int static int
SertafiedDelete (pointer value, XID id) SertafiedDelete(pointer value, XID id)
{ {
SertafiedPtr pRequest = (SertafiedPtr)value; SertafiedPtr pRequest = (SertafiedPtr) value;
SertafiedPtr pReq, pPrev; SertafiedPtr pReq, pPrev;
pPrev = 0; pPrev = 0;
for (pReq = pPending; pReq; pPrev = pReq, pReq = pReq->next) for (pReq = pPending; pReq; pPrev = pReq, pReq = pReq->next)
if (pReq == pRequest) if (pReq == pRequest) {
{ if (pPrev)
if (pPrev) pPrev->next = pReq->next;
pPrev->next = pReq->next; else
else pPending = pReq->next;
pPending = pReq->next; break;
break; }
}
if (pRequest->notifyFunc) if (pRequest->notifyFunc)
(*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure); (*pRequest->notifyFunc) (pRequest->pClient, pRequest->closure);
free(pRequest); free(pRequest);
return TRUE; return TRUE;
} }
static void static void
SertafiedBlockHandler (pointer data, OSTimePtr wt, pointer LastSelectMask) SertafiedBlockHandler(pointer data, OSTimePtr wt, pointer LastSelectMask)
{ {
SertafiedPtr pReq, pNext; SertafiedPtr pReq, pNext;
unsigned long delay; unsigned long delay;
TimeStamp now; TimeStamp now;
if (!pPending) if (!pPending)
return; return;
now.milliseconds = GetTimeInMillis (); now.milliseconds = GetTimeInMillis();
now.months = currentTime.months; now.months = currentTime.months;
if ((int) (now.milliseconds - currentTime.milliseconds) < 0) if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
now.months++; now.months++;
for (pReq = pPending; pReq; pReq = pNext) for (pReq = pPending; pReq; pReq = pNext) {
{ pNext = pReq->next;
pNext = pReq->next; if (CompareTimeStamps(pReq->revive, now) == LATER)
if (CompareTimeStamps (pReq->revive, now) == LATER) break;
break; FreeResource(pReq->id, RT_NONE);
FreeResource (pReq->id, RT_NONE);
/* AttendClient() may have been called via the resource delete /* AttendClient() may have been called via the resource delete
* function so a client may have input to be processed and so * function so a client may have input to be processed and so
* set delay to 0 to prevent blocking in WaitForSomething(). * set delay to 0 to prevent blocking in WaitForSomething().
*/ */
AdjustWaitForDelay (wt, 0); AdjustWaitForDelay(wt, 0);
} }
pReq = pPending; pReq = pPending;
if (!pReq) if (!pReq)
return; return;
delay = pReq->revive.milliseconds - now.milliseconds; delay = pReq->revive.milliseconds - now.milliseconds;
AdjustWaitForDelay (wt, delay); AdjustWaitForDelay(wt, delay);
} }
static void static void
SertafiedWakeupHandler (pointer data, int i, pointer LastSelectMask) SertafiedWakeupHandler(pointer data, int i, pointer LastSelectMask)
{ {
SertafiedPtr pReq, pNext; SertafiedPtr pReq, pNext;
TimeStamp now; TimeStamp now;
now.milliseconds = GetTimeInMillis (); now.milliseconds = GetTimeInMillis();
now.months = currentTime.months; now.months = currentTime.months;
if ((int) (now.milliseconds - currentTime.milliseconds) < 0) if ((int) (now.milliseconds - currentTime.milliseconds) < 0)
now.months++; now.months++;
for (pReq = pPending; pReq; pReq = pNext) for (pReq = pPending; pReq; pReq = pNext) {
{ pNext = pReq->next;
pNext = pReq->next; if (CompareTimeStamps(pReq->revive, now) == LATER)
if (CompareTimeStamps (pReq->revive, now) == LATER) break;
break; FreeResource(pReq->id, RT_NONE);
FreeResource (pReq->id, RT_NONE);
} }
if (!pPending) if (!pPending) {
{ RemoveBlockAndWakeupHandlers(SertafiedBlockHandler,
RemoveBlockAndWakeupHandlers (SertafiedBlockHandler, SertafiedWakeupHandler, (pointer) 0);
SertafiedWakeupHandler, BlockHandlerRegistered = FALSE;
(pointer) 0);
BlockHandlerRegistered = FALSE;
} }
} }

14
Xext/sleepuntil.h
View File

@ -33,14 +33,10 @@
#include "dix.h" #include "dix.h"
extern int ClientSleepUntil( extern int ClientSleepUntil(ClientPtr client,
ClientPtr client, TimeStamp *revive,
TimeStamp *revive, void (*notifyFunc) (ClientPtr /* client */ ,
void (*notifyFunc)( pointer /* closure */
ClientPtr /* client */, ), pointer Closure);
pointer /* closure */
),
pointer Closure
);
#endif #endif

2276
Xext/sync.c
View File

File diff suppressed because it is too large Load Diff

5
Xext/syncsdk.h
View File

@ -27,7 +27,7 @@
#include "misync.h" #include "misync.h"
extern _X_EXPORT int extern _X_EXPORT int
SyncVerifyFence(SyncFence **ppFence, XID fid, ClientPtr client, Mask mode); SyncVerifyFence(SyncFence ** ppFence, XID fid, ClientPtr client, Mask mode);
#define VERIFY_SYNC_FENCE(pFence, fid, client, mode) \ #define VERIFY_SYNC_FENCE(pFence, fid, client, mode) \
do { \ do { \
@ -43,5 +43,4 @@ SyncVerifyFence(SyncFence **ppFence, XID fid, ClientPtr client, Mask mode);
VERIFY_SYNC_FENCE((pFence), (fid), (client), (mode)); \ VERIFY_SYNC_FENCE((pFence), (fid), (client), (mode)); \
} while (0) } while (0)
#endif /* _SYNCSDK_H_ */ #endif /* _SYNCSDK_H_ */

99
Xext/syncsrv.h
View File

@ -66,81 +66,82 @@ typedef enum {
} SyncCounterType; } SyncCounterType;
typedef struct _SysCounterInfo { typedef struct _SysCounterInfo {
const char *name; const char *name;
CARD64 resolution; CARD64 resolution;
CARD64 bracket_greater; CARD64 bracket_greater;
CARD64 bracket_less; CARD64 bracket_less;
SyncCounterType counterType; /* how can this counter change */ SyncCounterType counterType; /* how can this counter change */
void (*QueryValue)( void (*QueryValue) (pointer /*pCounter */ ,
pointer /*pCounter*/, CARD64 * /*freshvalue */
CARD64 * /*freshvalue*/ );
); void (*BracketValues) (pointer /*pCounter */ ,
void (*BracketValues)( CARD64 * /*lessthan */ ,
pointer /*pCounter*/, CARD64 * /*greaterthan */
CARD64 * /*lessthan*/, );
CARD64 * /*greaterthan*/
);
} SysCounterInfo; } SysCounterInfo;
typedef struct _SyncAlarmClientList { typedef struct _SyncAlarmClientList {
ClientPtr client; ClientPtr client;
XID delete_id; XID delete_id;
struct _SyncAlarmClientList *next; struct _SyncAlarmClientList *next;
} SyncAlarmClientList; } SyncAlarmClientList;
typedef struct _SyncAlarm { typedef struct _SyncAlarm {
SyncTrigger trigger; SyncTrigger trigger;
ClientPtr client; ClientPtr client;
XSyncAlarm alarm_id; XSyncAlarm alarm_id;
CARD64 delta; CARD64 delta;
int events; int events;
int state; int state;
SyncAlarmClientList *pEventClients; SyncAlarmClientList *pEventClients;
} SyncAlarm; } SyncAlarm;
typedef struct { typedef struct {
ClientPtr client; ClientPtr client;
CARD32 delete_id; CARD32 delete_id;
int num_waitconditions; int num_waitconditions;
} SyncAwaitHeader; } SyncAwaitHeader;
typedef struct { typedef struct {
SyncTrigger trigger; SyncTrigger trigger;
CARD64 event_threshold; CARD64 event_threshold;
SyncAwaitHeader *pHeader; SyncAwaitHeader *pHeader;
} SyncAwait; } SyncAwait;
typedef union { typedef union {
SyncAwaitHeader header; SyncAwaitHeader header;
SyncAwait await; SyncAwait await;
} SyncAwaitUnion; } SyncAwaitUnion;
extern pointer SyncCreateSystemCounter( extern pointer SyncCreateSystemCounter(const char * /* name */ ,
const char */* name */, CARD64 /* inital_value */ ,
CARD64 /* inital_value */, CARD64 /* resolution */ ,
CARD64 /* resolution */, SyncCounterType
SyncCounterType /* change characterization */, /* change characterization */ ,
void (* /*QueryValue*/ ) ( void (* /*QueryValue */ )(
pointer /* pCounter */, pointer
CARD64 * /* pValue_return */), /* XXX prototype */ /* pCounter */
void (* /*BracketValues*/) ( ,
pointer /* pCounter */, CARD64 * /* pValue_return */ ), /* XXX prototype */
CARD64 * /* pbracket_less */, void (* /*BracketValues */ )(
CARD64 * /* pbracket_greater */) pointer
); /* pCounter */
,
CARD64 *
/* pbracket_less */
,
CARD64 *
/* pbracket_greater */
)
);
extern void SyncChangeCounter( extern void SyncChangeCounter(SyncCounter * /* pCounter */ ,
SyncCounter * /* pCounter*/, CARD64 /* new_value */
CARD64 /* new_value */ );
);
extern void SyncDestroySystemCounter( extern void SyncDestroySystemCounter(pointer pCounter);
pointer pCounter
);
extern void InitServertime(void); extern void InitServertime(void);
extern void SyncExtensionInit(void); extern void SyncExtensionInit(void);
#endif /* _SYNCSRV_H_ */ #endif /* _SYNCSRV_H_ */

380
Xext/xace.c
View File

@ -34,49 +34,53 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <X11/Xtrans/Xtrans.h> #include <X11/Xtrans/Xtrans.h>
#include "../os/osdep.h" #include "../os/osdep.h"
_X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS] = {0}; _X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS] = { 0 };
/* Special-cased hook functions. Called by Xserver. /* Special-cased hook functions. Called by Xserver.
*/ */
int XaceHookDispatch(ClientPtr client, int major) int
XaceHookDispatch(ClientPtr client, int major)
{ {
/* Call the audit begin callback, there is no return value. */ /* Call the audit begin callback, there is no return value. */
XaceAuditRec rec = { client, 0 }; XaceAuditRec rec = { client, 0 };
CallCallbacks(&XaceHooks[XACE_AUDIT_BEGIN], &rec); CallCallbacks(&XaceHooks[XACE_AUDIT_BEGIN], &rec);
if (major < 128) { if (major < 128) {
/* Call the core dispatch hook */ /* Call the core dispatch hook */
XaceCoreDispatchRec rec = { client, Success /* default allow */ }; XaceCoreDispatchRec rec = { client, Success /* default allow */ };
CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec); CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec);
return rec.status; return rec.status;
} else { }
/* Call the extension dispatch hook */ else {
ExtensionEntry *ext = GetExtensionEntry(major); /* Call the extension dispatch hook */
XaceExtAccessRec rec = { client, ext, DixUseAccess, Success }; ExtensionEntry *ext = GetExtensionEntry(major);
if (ext) XaceExtAccessRec rec = { client, ext, DixUseAccess, Success };
CallCallbacks(&XaceHooks[XACE_EXT_DISPATCH], &rec); if (ext)
/* On error, pretend extension doesn't exist */ CallCallbacks(&XaceHooks[XACE_EXT_DISPATCH], &rec);
return (rec.status == Success) ? Success : BadRequest; /* On error, pretend extension doesn't exist */
return (rec.status == Success) ? Success : BadRequest;
} }
} }
int XaceHookPropertyAccess(ClientPtr client, WindowPtr pWin, int
PropertyPtr *ppProp, Mask access_mode) XaceHookPropertyAccess(ClientPtr client, WindowPtr pWin,
PropertyPtr *ppProp, Mask access_mode)
{ {
XacePropertyAccessRec rec = { client, pWin, ppProp, access_mode, Success }; XacePropertyAccessRec rec = { client, pWin, ppProp, access_mode, Success };
CallCallbacks(&XaceHooks[XACE_PROPERTY_ACCESS], &rec); CallCallbacks(&XaceHooks[XACE_PROPERTY_ACCESS], &rec);
return rec.status; return rec.status;
} }
int XaceHookSelectionAccess(ClientPtr client, int
Selection **ppSel, Mask access_mode) XaceHookSelectionAccess(ClientPtr client, Selection ** ppSel, Mask access_mode)
{ {
XaceSelectionAccessRec rec = { client, ppSel, access_mode, Success }; XaceSelectionAccessRec rec = { client, ppSel, access_mode, Success };
CallCallbacks(&XaceHooks[XACE_SELECTION_ACCESS], &rec); CallCallbacks(&XaceHooks[XACE_SELECTION_ACCESS], &rec);
return rec.status; return rec.status;
} }
void XaceHookAuditEnd(ClientPtr ptr, int result) void
XaceHookAuditEnd(ClientPtr ptr, int result)
{ {
XaceAuditRec rec = { ptr, result }; XaceAuditRec rec = { ptr, result };
/* call callbacks, there is no return value. */ /* call callbacks, there is no return value. */
@ -85,25 +89,26 @@ void XaceHookAuditEnd(ClientPtr ptr, int result)
/* Entry point for hook functions. Called by Xserver. /* Entry point for hook functions. Called by Xserver.
*/ */
int XaceHook(int hook, ...) int
XaceHook(int hook, ...)
{ {
union { union {
XaceResourceAccessRec res; XaceResourceAccessRec res;
XaceDeviceAccessRec dev; XaceDeviceAccessRec dev;
XaceSendAccessRec send; XaceSendAccessRec send;
XaceReceiveAccessRec recv; XaceReceiveAccessRec recv;
XaceClientAccessRec client; XaceClientAccessRec client;
XaceExtAccessRec ext; XaceExtAccessRec ext;
XaceServerAccessRec server; XaceServerAccessRec server;
XaceScreenAccessRec screen; XaceScreenAccessRec screen;
XaceAuthAvailRec auth; XaceAuthAvailRec auth;
XaceKeyAvailRec key; XaceKeyAvailRec key;
} u; } u;
int *prv = NULL; /* points to return value from callback */ int *prv = NULL; /* points to return value from callback */
va_list ap; /* argument list */ va_list ap; /* argument list */
if (!XaceHooks[hook]) if (!XaceHooks[hook])
return Success; return Success;
va_start(ap, hook); va_start(ap, hook);
@ -112,83 +117,94 @@ int XaceHook(int hook, ...)
* the arguments and integer return parameter, or in some cases just * the arguments and integer return parameter, or in some cases just
* sets calldata directly to a single argument (with no return result) * sets calldata directly to a single argument (with no return result)
*/ */
switch (hook) switch (hook) {
{ case XACE_RESOURCE_ACCESS:
case XACE_RESOURCE_ACCESS: u.res.client = va_arg(ap, ClientPtr);
u.res.client = va_arg(ap, ClientPtr); u.res.id = va_arg(ap, XID);
u.res.id = va_arg(ap, XID); u.res.rtype = va_arg(ap, RESTYPE);
u.res.rtype = va_arg(ap, RESTYPE); u.res.res = va_arg(ap, pointer);
u.res.res = va_arg(ap, pointer); u.res.ptype = va_arg(ap, RESTYPE);
u.res.ptype = va_arg(ap, RESTYPE); u.res.parent = va_arg(ap, pointer);
u.res.parent = va_arg(ap, pointer); u.res.access_mode = va_arg(ap, Mask);
u.res.access_mode = va_arg(ap, Mask);
u.res.status = Success; /* default allow */ u.res.status = Success; /* default allow */
prv = &u.res.status; prv = &u.res.status;
break; break;
case XACE_DEVICE_ACCESS: case XACE_DEVICE_ACCESS:
u.dev.client = va_arg(ap, ClientPtr); u.dev.client = va_arg(ap, ClientPtr);
u.dev.dev = va_arg(ap, DeviceIntPtr); u.dev.dev = va_arg(ap, DeviceIntPtr);
u.dev.access_mode = va_arg(ap, Mask); u.dev.access_mode = va_arg(ap, Mask);
u.dev.status = Success; /* default allow */
prv = &u.dev.status; u.dev.status = Success; /* default allow */
break; prv = &u.dev.status;
case XACE_SEND_ACCESS: break;
u.send.client = va_arg(ap, ClientPtr); case XACE_SEND_ACCESS:
u.send.dev = va_arg(ap, DeviceIntPtr); u.send.client = va_arg(ap, ClientPtr);
u.send.pWin = va_arg(ap, WindowPtr); u.send.dev = va_arg(ap, DeviceIntPtr);
u.send.events = va_arg(ap, xEventPtr); u.send.pWin = va_arg(ap, WindowPtr);
u.send.count = va_arg(ap, int);
u.send.status = Success; /* default allow */ u.send.events = va_arg(ap, xEventPtr);
prv = &u.send.status; u.send.count = va_arg(ap, int);
break;
case XACE_RECEIVE_ACCESS: u.send.status = Success; /* default allow */
u.recv.client = va_arg(ap, ClientPtr); prv = &u.send.status;
u.recv.pWin = va_arg(ap, WindowPtr); break;
u.recv.events = va_arg(ap, xEventPtr); case XACE_RECEIVE_ACCESS:
u.recv.count = va_arg(ap, int); u.recv.client = va_arg(ap, ClientPtr);
u.recv.status = Success; /* default allow */ u.recv.pWin = va_arg(ap, WindowPtr);
prv = &u.recv.status;
break; u.recv.events = va_arg(ap, xEventPtr);
case XACE_CLIENT_ACCESS: u.recv.count = va_arg(ap, int);
u.client.client = va_arg(ap, ClientPtr);
u.client.target = va_arg(ap, ClientPtr); u.recv.status = Success; /* default allow */
u.client.access_mode = va_arg(ap, Mask); prv = &u.recv.status;
u.client.status = Success; /* default allow */ break;
prv = &u.client.status; case XACE_CLIENT_ACCESS:
break; u.client.client = va_arg(ap, ClientPtr);
case XACE_EXT_ACCESS: u.client.target = va_arg(ap, ClientPtr);
u.ext.client = va_arg(ap, ClientPtr); u.client.access_mode = va_arg(ap, Mask);
u.ext.ext = va_arg(ap, ExtensionEntry*);
u.ext.access_mode = DixGetAttrAccess; u.client.status = Success; /* default allow */
u.ext.status = Success; /* default allow */ prv = &u.client.status;
prv = &u.ext.status; break;
break; case XACE_EXT_ACCESS:
case XACE_SERVER_ACCESS: u.ext.client = va_arg(ap, ClientPtr);
u.server.client = va_arg(ap, ClientPtr);
u.server.access_mode = va_arg(ap, Mask); u.ext.ext = va_arg(ap, ExtensionEntry *);
u.server.status = Success; /* default allow */ u.ext.access_mode = DixGetAttrAccess;
prv = &u.server.status; u.ext.status = Success; /* default allow */
break; prv = &u.ext.status;
case XACE_SCREEN_ACCESS: break;
case XACE_SCREENSAVER_ACCESS: case XACE_SERVER_ACCESS:
u.screen.client = va_arg(ap, ClientPtr); u.server.client = va_arg(ap, ClientPtr);
u.screen.screen = va_arg(ap, ScreenPtr); u.server.access_mode = va_arg(ap, Mask);
u.screen.access_mode = va_arg(ap, Mask);
u.screen.status = Success; /* default allow */ u.server.status = Success; /* default allow */
prv = &u.screen.status; prv = &u.server.status;
break; break;
case XACE_AUTH_AVAIL: case XACE_SCREEN_ACCESS:
u.auth.client = va_arg(ap, ClientPtr); case XACE_SCREENSAVER_ACCESS:
u.auth.authId = va_arg(ap, XID); u.screen.client = va_arg(ap, ClientPtr);
break; u.screen.screen = va_arg(ap, ScreenPtr);
case XACE_KEY_AVAIL: u.screen.access_mode = va_arg(ap, Mask);
u.key.event = va_arg(ap, xEventPtr);
u.key.keybd = va_arg(ap, DeviceIntPtr); u.screen.status = Success; /* default allow */
u.key.count = va_arg(ap, int); prv = &u.screen.status;
break; break;
default: case XACE_AUTH_AVAIL:
va_end(ap); u.auth.client = va_arg(ap, ClientPtr);
return 0; /* unimplemented hook number */ u.auth.authId = va_arg(ap, XID);
break;
case XACE_KEY_AVAIL:
u.key.event = va_arg(ap, xEventPtr);
u.key.keybd = va_arg(ap, DeviceIntPtr);
u.key.count = va_arg(ap, int);
break;
default:
va_end(ap);
return 0; /* unimplemented hook number */
} }
va_end(ap); va_end(ap);
@ -218,17 +234,14 @@ int XaceHook(int hook, ...)
* region of the window will be destroyed (overwritten) in pBuf. * region of the window will be destroyed (overwritten) in pBuf.
*/ */
void void
XaceCensorImage( XaceCensorImage(ClientPtr client,
ClientPtr client, RegionPtr pVisibleRegion,
RegionPtr pVisibleRegion, long widthBytesLine,
long widthBytesLine, DrawablePtr pDraw,
DrawablePtr pDraw, int x, int y, int w, int h, unsigned int format, char *pBuf)
int x, int y, int w, int h,
unsigned int format,
char *pBuf)
{ {
RegionRec imageRegion; /* region representing x,y,w,h */ RegionRec imageRegion; /* region representing x,y,w,h */
RegionRec censorRegion; /* region to obliterate */ RegionRec censorRegion; /* region to obliterate */
BoxRec imageBox; BoxRec imageBox;
int nRects; int nRects;
@ -242,90 +255,87 @@ XaceCensorImage(
/* censorRegion = imageRegion - visibleRegion */ /* censorRegion = imageRegion - visibleRegion */
RegionSubtract(&censorRegion, &imageRegion, pVisibleRegion); RegionSubtract(&censorRegion, &imageRegion, pVisibleRegion);
nRects = RegionNumRects(&censorRegion); nRects = RegionNumRects(&censorRegion);
if (nRects > 0) if (nRects > 0) { /* we have something to censor */
{ /* we have something to censor */ GCPtr pScratchGC = NULL;
GCPtr pScratchGC = NULL; PixmapPtr pPix = NULL;
PixmapPtr pPix = NULL; xRectangle *pRects = NULL;
xRectangle *pRects = NULL; Bool failed = FALSE;
Bool failed = FALSE; int depth = 1;
int depth = 1; int bitsPerPixel = 1;
int bitsPerPixel = 1; int i;
int i; BoxPtr pBox;
BoxPtr pBox;
/* convert region to list-of-rectangles for PolyFillRect */ /* convert region to list-of-rectangles for PolyFillRect */
pRects = malloc(nRects * sizeof(xRectangle)); pRects = malloc(nRects * sizeof(xRectangle));
if (!pRects) if (!pRects) {
{ failed = TRUE;
failed = TRUE; goto failSafe;
goto failSafe; }
} for (pBox = RegionRects(&censorRegion), i = 0; i < nRects; i++, pBox++) {
for (pBox = RegionRects(&censorRegion), i = 0; pRects[i].x = pBox->x1;
i < nRects; pRects[i].y = pBox->y1 - imageBox.y1;
i++, pBox++) pRects[i].width = pBox->x2 - pBox->x1;
{ pRects[i].height = pBox->y2 - pBox->y1;
pRects[i].x = pBox->x1; }
pRects[i].y = pBox->y1 - imageBox.y1;
pRects[i].width = pBox->x2 - pBox->x1;
pRects[i].height = pBox->y2 - pBox->y1;
}
/* use pBuf as a fake pixmap */ /* use pBuf as a fake pixmap */
if (format == ZPixmap) if (format == ZPixmap) {
{ depth = pDraw->depth;
depth = pDraw->depth; bitsPerPixel = pDraw->bitsPerPixel;
bitsPerPixel = pDraw->bitsPerPixel; }
}
pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h, pPix = GetScratchPixmapHeader(pDraw->pScreen, w, h,
depth, bitsPerPixel, depth, bitsPerPixel,
widthBytesLine, (pointer)pBuf); widthBytesLine, (pointer) pBuf);
if (!pPix) if (!pPix) {
{ failed = TRUE;
failed = TRUE; goto failSafe;
goto failSafe; }
}
pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen); pScratchGC = GetScratchGC(depth, pPix->drawable.pScreen);
if (!pScratchGC) if (!pScratchGC) {
{ failed = TRUE;
failed = TRUE; goto failSafe;
goto failSafe; }
}
ValidateGC(&pPix->drawable, pScratchGC); ValidateGC(&pPix->drawable, pScratchGC);
(* pScratchGC->ops->PolyFillRect)(&pPix->drawable, (*pScratchGC->ops->PolyFillRect) (&pPix->drawable,
pScratchGC, nRects, pRects); pScratchGC, nRects, pRects);
failSafe: failSafe:
if (failed) if (failed) {
{ /* Censoring was not completed above. To be safe, wipe out
/* Censoring was not completed above. To be safe, wipe out * all the image data so that nothing trusted gets out.
* all the image data so that nothing trusted gets out. */
*/ memset(pBuf, 0, (int) (widthBytesLine * h));
memset(pBuf, 0, (int)(widthBytesLine * h)); }
} free(pRects);
free(pRects); if (pScratchGC)
if (pScratchGC) FreeScratchGC(pScratchGC); FreeScratchGC(pScratchGC);
if (pPix) FreeScratchPixmapHeader(pPix); if (pPix)
FreeScratchPixmapHeader(pPix);
} }
RegionUninit(&imageRegion); RegionUninit(&imageRegion);
RegionUninit(&censorRegion); RegionUninit(&censorRegion);
} /* XaceCensorImage */ } /* XaceCensorImage */
/* /*
* Xtrans wrappers for use by modules * Xtrans wrappers for use by modules
*/ */
int XaceGetConnectionNumber(ClientPtr client) int
XaceGetConnectionNumber(ClientPtr client)
{ {
XtransConnInfo ci = ((OsCommPtr)client->osPrivate)->trans_conn; XtransConnInfo ci = ((OsCommPtr) client->osPrivate)->trans_conn;
return _XSERVTransGetConnectionNumber(ci); return _XSERVTransGetConnectionNumber(ci);
} }
int XaceIsLocal(ClientPtr client) int
XaceIsLocal(ClientPtr client)
{ {
XtransConnInfo ci = ((OsCommPtr)client->osPrivate)->trans_conn; XtransConnInfo ci = ((OsCommPtr) client->osPrivate)->trans_conn;
return _XSERVTransIsLocal(ci); return _XSERVTransIsLocal(ci);
} }

33
Xext/xace.h
View File

@ -61,18 +61,18 @@ extern _X_EXPORT CallbackListPtr XaceHooks[XACE_NUM_HOOKS];
/* Entry point for hook functions. Called by Xserver. /* Entry point for hook functions. Called by Xserver.
* Required by libdbe and libextmod * Required by libdbe and libextmod
*/ */
extern _X_EXPORT int XaceHook( extern _X_EXPORT int XaceHook(int /*hook */ ,
int /*hook*/, ... /*appropriate args for hook */
... /*appropriate args for hook*/
); );
/* Special-cased hook functions /* Special-cased hook functions
*/ */
extern _X_EXPORT int XaceHookDispatch(ClientPtr ptr, int major); extern _X_EXPORT int XaceHookDispatch(ClientPtr ptr, int major);
extern _X_EXPORT int XaceHookPropertyAccess(ClientPtr ptr, WindowPtr pWin, extern _X_EXPORT int XaceHookPropertyAccess(ClientPtr ptr, WindowPtr pWin,
PropertyPtr *ppProp, Mask access_mode); PropertyPtr *ppProp,
extern _X_EXPORT int XaceHookSelectionAccess(ClientPtr ptr, Mask access_mode);
Selection **ppSel, Mask access_mode); extern _X_EXPORT int XaceHookSelectionAccess(ClientPtr ptr, Selection ** ppSel,
Mask access_mode);
extern _X_EXPORT void XaceHookAuditEnd(ClientPtr ptr, int result); extern _X_EXPORT void XaceHookAuditEnd(ClientPtr ptr, int result);
/* Register a callback for a given hook. /* Register a callback for a given hook.
@ -93,17 +93,14 @@ extern _X_EXPORT int XaceIsLocal(ClientPtr ptr);
/* From the original Security extension... /* From the original Security extension...
*/ */
extern _X_EXPORT void XaceCensorImage( extern _X_EXPORT void XaceCensorImage(ClientPtr client,
ClientPtr client, RegionPtr pVisibleRegion,
RegionPtr pVisibleRegion, long widthBytesLine,
long widthBytesLine, DrawablePtr pDraw,
DrawablePtr pDraw, int x, int y, int w, int h,
int x, int y, int w, int h, unsigned int format, char *pBuf);
unsigned int format,
char * pBuf
);
#else /* XACE */ #else /* XACE */
/* Default window background */ /* Default window background */
#define XaceBackgroundNoneState(w) None #define XaceBackgroundNoneState(w) None
@ -126,6 +123,6 @@ extern _X_EXPORT void XaceCensorImage(
#define XaceCensorImage(...) { ; } #define XaceCensorImage(...) { ; }
#endif #endif
#endif /* XACE */ #endif /* XACE */
#endif /* _XACE_H */ #endif /* _XACE_H */

2
Xext/xacestr.h
View File

@ -144,4 +144,4 @@ typedef struct {
int requestResult; int requestResult;
} XaceAuditRec; } XaceAuditRec;
#endif /* _XACESTR_H */ #endif /* _XACESTR_H */

70
Xext/xcmisc.c
View File

@ -54,11 +54,11 @@ ProcXCMiscGetVersion(ClientPtr client)
rep.majorVersion = XCMiscMajorVersion; rep.majorVersion = XCMiscMajorVersion;
rep.minorVersion = XCMiscMinorVersion; rep.minorVersion = XCMiscMinorVersion;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.majorVersion); swaps(&rep.majorVersion);
swaps(&rep.minorVersion); swaps(&rep.minorVersion);
} }
WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *)&rep); WriteToClient(client, sizeof(xXCMiscGetVersionReply), (char *) &rep);
return Success; return Success;
} }
@ -76,11 +76,11 @@ ProcXCMiscGetXIDRange(ClientPtr client)
rep.start_id = min_id; rep.start_id = min_id;
rep.count = max_id - min_id + 1; rep.count = max_id - min_id + 1;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.start_id); swapl(&rep.start_id);
swapl(&rep.count); swapl(&rep.count);
} }
WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *)&rep); WriteToClient(client, sizeof(xXCMiscGetXIDRangeReply), (char *) &rep);
return Success; return Success;
} }
@ -95,12 +95,11 @@ ProcXCMiscGetXIDList(ClientPtr client)
REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq); REQUEST_SIZE_MATCH(xXCMiscGetXIDListReq);
if (stuff->count > UINT32_MAX / sizeof(XID)) if (stuff->count > UINT32_MAX / sizeof(XID))
return BadAlloc; return BadAlloc;
pids = (XID *)malloc(stuff->count * sizeof(XID)); pids = (XID *) malloc(stuff->count * sizeof(XID));
if (!pids) if (!pids) {
{ return BadAlloc;
return BadAlloc;
} }
count = GetXIDList(client, stuff->count, pids); count = GetXIDList(client, stuff->count, pids);
rep.type = X_Reply; rep.type = X_Reply;
@ -108,34 +107,32 @@ ProcXCMiscGetXIDList(ClientPtr client)
rep.length = count; rep.length = count;
rep.count = count; rep.count = count;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.length); swapl(&rep.length);
swapl(&rep.count); swapl(&rep.count);
} }
WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *)&rep); WriteToClient(client, sizeof(xXCMiscGetXIDListReply), (char *) &rep);
if (count) if (count) {
{ client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; WriteSwappedDataToClient(client, count * sizeof(XID), pids);
WriteSwappedDataToClient(client, count * sizeof(XID), pids);
} }
free(pids); free(pids);
return Success; return Success;
} }
static int static int
ProcXCMiscDispatch (ClientPtr client) ProcXCMiscDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{
case X_XCMiscGetVersion: case X_XCMiscGetVersion:
return ProcXCMiscGetVersion(client); return ProcXCMiscGetVersion(client);
case X_XCMiscGetXIDRange: case X_XCMiscGetXIDRange:
return ProcXCMiscGetXIDRange(client); return ProcXCMiscGetXIDRange(client);
case X_XCMiscGetXIDList: case X_XCMiscGetXIDList:
return ProcXCMiscGetXIDList(client); return ProcXCMiscGetXIDList(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -171,19 +168,18 @@ SProcXCMiscGetXIDList(ClientPtr client)
} }
static int static int
SProcXCMiscDispatch (ClientPtr client) SProcXCMiscDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{
case X_XCMiscGetVersion: case X_XCMiscGetVersion:
return SProcXCMiscGetVersion(client); return SProcXCMiscGetVersion(client);
case X_XCMiscGetXIDRange: case X_XCMiscGetXIDRange:
return SProcXCMiscGetXIDRange(client); return SProcXCMiscGetXIDRange(client);
case X_XCMiscGetXIDList: case X_XCMiscGetXIDList:
return SProcXCMiscGetXIDList(client); return SProcXCMiscGetXIDList(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -191,6 +187,6 @@ void
XCMiscExtensionInit(INITARGS) XCMiscExtensionInit(INITARGS)
{ {
AddExtension(XCMiscExtensionName, 0, 0, AddExtension(XCMiscExtensionName, 0, 0,
ProcXCMiscDispatch, SProcXCMiscDispatch, ProcXCMiscDispatch, SProcXCMiscDispatch,
NULL, StandardMinorOpcode); NULL, StandardMinorOpcode);
} }

729
Xext/xf86bigfont.c
View File

@ -76,11 +76,9 @@
#include <X11/extensions/xf86bigfproto.h> #include <X11/extensions/xf86bigfproto.h>
#include "xf86bigfontsrv.h" #include "xf86bigfontsrv.h"
static void XF86BigfontResetProc( static void XF86BigfontResetProc(ExtensionEntry * /* extEntry */
ExtensionEntry * /* extEntry */
); );
#ifdef HAS_SHM #ifdef HAS_SHM
/* A random signature, transmitted to the clients so they can verify that the /* A random signature, transmitted to the clients so they can verify that the
@ -100,8 +98,7 @@ static Bool badSysCall = FALSE;
#include <sys/signal.h> #include <sys/signal.h>
static void static void
SigSysHandler( SigSysHandler(int signo)
int signo)
{ {
badSysCall = TRUE; badSysCall = TRUE;
} }
@ -109,7 +106,7 @@ SigSysHandler(
static Bool static Bool
CheckForShmSyscall(void) CheckForShmSyscall(void)
{ {
void (*oldHandler)(int); void (*oldHandler) (int);
int shmid = -1; int shmid = -1;
/* If no SHM support in the kernel, the bad syscall will generate SIGSYS */ /* If no SHM support in the kernel, the bad syscall will generate SIGSYS */
@ -117,13 +114,11 @@ CheckForShmSyscall(void)
badSysCall = FALSE; badSysCall = FALSE;
shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT); shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT);
if (shmid != -1) if (shmid != -1) {
{
/* Successful allocation - clean up */ /* Successful allocation - clean up */
shmctl(shmid, IPC_RMID, NULL); shmctl(shmid, IPC_RMID, NULL);
} }
else else {
{
/* Allocation failed */ /* Allocation failed */
badSysCall = TRUE; badSysCall = TRUE;
} }
@ -158,8 +153,7 @@ typedef struct _ShmDesc {
static ShmDescPtr ShmList = (ShmDescPtr) NULL; static ShmDescPtr ShmList = (ShmDescPtr) NULL;
static ShmDescPtr static ShmDescPtr
shmalloc( shmalloc(unsigned int size)
unsigned int size)
{ {
ShmDescPtr pDesc; ShmDescPtr pDesc;
int shmid; int shmid;
@ -167,7 +161,7 @@ shmalloc(
#ifdef MUST_CHECK_FOR_SHM_SYSCALL #ifdef MUST_CHECK_FOR_SHM_SYSCALL
if (pagesize == 0) if (pagesize == 0)
return (ShmDescPtr) NULL; return (ShmDescPtr) NULL;
#endif #endif
/* On some older Linux systems, the number of shared memory segments /* On some older Linux systems, the number of shared memory segments
@ -177,27 +171,27 @@ shmalloc(
the glyph metrics on the other hand. If the glyph metrics size is the glyph metrics on the other hand. If the glyph metrics size is
small, we prefer the traditional way. */ small, we prefer the traditional way. */
if (size < 3500) if (size < 3500)
return (ShmDescPtr) NULL; return (ShmDescPtr) NULL;
pDesc = malloc(sizeof(ShmDescRec)); pDesc = malloc(sizeof(ShmDescRec));
if (!pDesc) if (!pDesc)
return (ShmDescPtr) NULL; return (ShmDescPtr) NULL;
size = (size + pagesize-1) & -pagesize; size = (size + pagesize - 1) & -pagesize;
shmid = shmget(IPC_PRIVATE, size, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH); shmid = shmget(IPC_PRIVATE, size, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
if (shmid == -1) { if (shmid == -1) {
ErrorF(XF86BIGFONTNAME " extension: shmget() failed, size = %u, %s\n", ErrorF(XF86BIGFONTNAME " extension: shmget() failed, size = %u, %s\n",
size, strerror(errno)); size, strerror(errno));
free(pDesc); free(pDesc);
return (ShmDescPtr) NULL; return (ShmDescPtr) NULL;
} }
if ((addr = shmat(shmid, 0, 0)) == (char *)-1) { if ((addr = shmat(shmid, 0, 0)) == (char *) -1) {
ErrorF(XF86BIGFONTNAME " extension: shmat() failed, size = %u, %s\n", ErrorF(XF86BIGFONTNAME " extension: shmat() failed, size = %u, %s\n",
size, strerror(errno)); size, strerror(errno));
shmctl(shmid, IPC_RMID, (void *) 0); shmctl(shmid, IPC_RMID, (void *) 0);
free(pDesc); free(pDesc);
return (ShmDescPtr) NULL; return (ShmDescPtr) NULL;
} }
#ifdef EARLY_REMOVE #ifdef EARLY_REMOVE
@ -206,7 +200,8 @@ shmalloc(
pDesc->shmid = shmid; pDesc->shmid = shmid;
pDesc->attach_addr = addr; pDesc->attach_addr = addr;
if (ShmList) ShmList->prev = &pDesc->next; if (ShmList)
ShmList->prev = &pDesc->next;
pDesc->next = ShmList; pDesc->next = ShmList;
pDesc->prev = &ShmList; pDesc->prev = &ShmList;
ShmList = pDesc; ShmList = pDesc;
@ -215,15 +210,15 @@ shmalloc(
} }
static void static void
shmdealloc( shmdealloc(ShmDescPtr pDesc)
ShmDescPtr pDesc)
{ {
#ifndef EARLY_REMOVE #ifndef EARLY_REMOVE
shmctl(pDesc->shmid, IPC_RMID, (void *) 0); shmctl(pDesc->shmid, IPC_RMID, (void *) 0);
#endif #endif
shmdt(pDesc->attach_addr); shmdt(pDesc->attach_addr);
if (pDesc->next) pDesc->next->prev = pDesc->prev; if (pDesc->next)
pDesc->next->prev = pDesc->prev;
*pDesc->prev = pDesc->next; *pDesc->prev = pDesc->next;
free(pDesc); free(pDesc);
} }
@ -232,8 +227,7 @@ shmdealloc(
/* Called when a font is closed. */ /* Called when a font is closed. */
void void
XF86BigfontFreeFontShm( XF86BigfontFreeFontShm(FontPtr pFont)
FontPtr pFont)
{ {
#ifdef HAS_SHM #ifdef HAS_SHM
ShmDescPtr pDesc; ShmDescPtr pDesc;
@ -242,11 +236,11 @@ XF86BigfontFreeFontShm(
* called shmdealloc() for all segments, we don't need to do it here. * called shmdealloc() for all segments, we don't need to do it here.
*/ */
if (!ShmList) if (!ShmList)
return; return;
pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex); pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex);
if (pDesc) if (pDesc)
shmdealloc(pDesc); shmdealloc(pDesc);
#endif #endif
} }
@ -256,14 +250,13 @@ XF86BigfontCleanup(void)
{ {
#ifdef HAS_SHM #ifdef HAS_SHM
while (ShmList) while (ShmList)
shmdealloc(ShmList); shmdealloc(ShmList);
#endif #endif
} }
/* Called when a server generation dies. */ /* Called when a server generation dies. */
static void static void
XF86BigfontResetProc( XF86BigfontResetProc(ExtensionEntry * extEntry)
ExtensionEntry* extEntry)
{ {
/* This function is normally called from CloseDownExtensions(), called /* This function is normally called from CloseDownExtensions(), called
* from main(). It will be followed by a call to FreeAllResources(), * from main(). It will be followed by a call to FreeAllResources(),
@ -276,12 +269,10 @@ XF86BigfontResetProc(
XF86BigfontCleanup(); XF86BigfontCleanup();
} }
/* ========== Handling of extension specific requests ========== */ /* ========== Handling of extension specific requests ========== */
static int static int
ProcXF86BigfontQueryVersion( ProcXF86BigfontQueryVersion(ClientPtr client)
ClientPtr client)
{ {
xXF86BigfontQueryVersionReply reply; xXF86BigfontQueryVersionReply reply;
@ -296,33 +287,33 @@ ProcXF86BigfontQueryVersion(
#ifdef HAS_SHM #ifdef HAS_SHM
reply.signature = signature; reply.signature = signature;
#else #else
reply.signature = 0; /* This is redundant. Avoids uninitialized memory. */ reply.signature = 0; /* This is redundant. Avoids uninitialized memory. */
#endif #endif
reply.capabilities = reply.capabilities =
#ifdef HAS_SHM #ifdef HAS_SHM
(LocalClient(client) && !client->swapped ? XF86Bigfont_CAP_LocalShm : 0) (LocalClient(client) && !client->swapped ? XF86Bigfont_CAP_LocalShm : 0)
#else #else
0 0
#endif #endif
; /* may add more bits here in future versions */ ; /* may add more bits here in future versions */
if (client->swapped) { if (client->swapped) {
char tmp; char tmp;
swaps(&reply.sequenceNumber);
swapl(&reply.length); swaps(&reply.sequenceNumber);
swaps(&reply.majorVersion); swapl(&reply.length);
swaps(&reply.minorVersion); swaps(&reply.majorVersion);
swapl(&reply.uid); swaps(&reply.minorVersion);
swapl(&reply.gid); swapl(&reply.uid);
swapl(&reply.signature); swapl(&reply.gid);
swapl(&reply.signature);
} }
WriteToClient(client, WriteToClient(client,
sizeof(xXF86BigfontQueryVersionReply), (char *)&reply); sizeof(xXF86BigfontQueryVersionReply), (char *) &reply);
return Success; return Success;
} }
static void static void
swapCharInfo( swapCharInfo(xCharInfo * pCI)
xCharInfo *pCI)
{ {
char tmp; char tmp;
@ -342,52 +333,55 @@ swapCharInfo(
(p->ascent << 11) + (p->descent << 6)) ^ p->attributes) (p->ascent << 11) + (p->descent << 6)) ^ p->attributes)
static int static int
ProcXF86BigfontQueryFont( ProcXF86BigfontQueryFont(ClientPtr client)
ClientPtr client)
{ {
FontPtr pFont; FontPtr pFont;
REQUEST(xXF86BigfontQueryFontReq); REQUEST(xXF86BigfontQueryFontReq);
CARD32 stuff_flags; CARD32 stuff_flags;
xCharInfo* pmax; xCharInfo *pmax;
xCharInfo* pmin; xCharInfo *pmin;
int nCharInfos; int nCharInfos;
int shmid; int shmid;
#ifdef HAS_SHM #ifdef HAS_SHM
ShmDescPtr pDesc = NULL; ShmDescPtr pDesc = NULL;
#else #else
#define pDesc 0 #define pDesc 0
#endif #endif
xCharInfo* pCI; xCharInfo *pCI;
CARD16* pIndex2UniqIndex; CARD16 *pIndex2UniqIndex;
CARD16* pUniqIndex2Index; CARD16 *pUniqIndex2Index;
CARD32 nUniqCharInfos; CARD32 nUniqCharInfos;
#if 0 #if 0
REQUEST_SIZE_MATCH(xXF86BigfontQueryFontReq); REQUEST_SIZE_MATCH(xXF86BigfontQueryFontReq);
#else #else
switch (client->req_len) { switch (client->req_len) {
case 2: /* client with version 1.0 libX11 */ case 2: /* client with version 1.0 libX11 */
stuff_flags = (LocalClient(client) && !client->swapped ? XF86Bigfont_FLAGS_Shm : 0); stuff_flags = (LocalClient(client) &&
break; !client->swapped ? XF86Bigfont_FLAGS_Shm : 0);
case 3: /* client with version 1.1 libX11 */ break;
stuff_flags = stuff->flags; case 3: /* client with version 1.1 libX11 */
break; stuff_flags = stuff->flags;
default: break;
return BadLength; default:
return BadLength;
} }
#endif #endif
if (dixLookupFontable(&pFont, stuff->id, client, DixGetAttrAccess) != Success) if (dixLookupFontable(&pFont, stuff->id, client, DixGetAttrAccess) !=
return BadFont; /* procotol spec says only error is BadFont */ Success)
return BadFont; /* procotol spec says only error is BadFont */
pmax = FONTINKMAX(pFont); pmax = FONTINKMAX(pFont);
pmin = FONTINKMIN(pFont); pmin = FONTINKMIN(pFont);
nCharInfos = nCharInfos =
(pmax->rightSideBearing == pmin->rightSideBearing (pmax->rightSideBearing == pmin->rightSideBearing
&& pmax->leftSideBearing == pmin->leftSideBearing && pmax->leftSideBearing == pmin->leftSideBearing
&& pmax->descent == pmin->descent && pmax->descent == pmin->descent
&& pmax->ascent == pmin->ascent && pmax->ascent == pmin->ascent
&& pmax->characterWidth == pmin->characterWidth) && pmax->characterWidth == pmin->characterWidth)
? 0 : N2dChars(pFont); ? 0 : N2dChars(pFont);
shmid = -1; shmid = -1;
pCI = NULL; pCI = NULL;
pIndex2UniqIndex = NULL; pIndex2UniqIndex = NULL;
@ -396,278 +390,289 @@ ProcXF86BigfontQueryFont(
if (nCharInfos > 0) { if (nCharInfos > 0) {
#ifdef HAS_SHM #ifdef HAS_SHM
if (!badSysCall) if (!badSysCall)
pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex); pDesc = (ShmDescPtr) FontGetPrivate(pFont, FontShmdescIndex);
if (pDesc) { if (pDesc) {
pCI = (xCharInfo *) pDesc->attach_addr; pCI = (xCharInfo *) pDesc->attach_addr;
if (stuff_flags & XF86Bigfont_FLAGS_Shm) if (stuff_flags & XF86Bigfont_FLAGS_Shm)
shmid = pDesc->shmid; shmid = pDesc->shmid;
} else { }
if (stuff_flags & XF86Bigfont_FLAGS_Shm && !badSysCall) else {
pDesc = shmalloc(nCharInfos * sizeof(xCharInfo) if (stuff_flags & XF86Bigfont_FLAGS_Shm && !badSysCall)
+ sizeof(CARD32)); pDesc = shmalloc(nCharInfos * sizeof(xCharInfo)
if (pDesc) { + sizeof(CARD32));
pCI = (xCharInfo *) pDesc->attach_addr; if (pDesc) {
shmid = pDesc->shmid; pCI = (xCharInfo *) pDesc->attach_addr;
} else { shmid = pDesc->shmid;
}
else {
#endif #endif
pCI = malloc(nCharInfos * sizeof(xCharInfo)); pCI = malloc(nCharInfos * sizeof(xCharInfo));
if (!pCI) if (!pCI)
return BadAlloc; return BadAlloc;
#ifdef HAS_SHM #ifdef HAS_SHM
} }
#endif #endif
/* Fill nCharInfos starting at pCI. */ /* Fill nCharInfos starting at pCI. */
{ {
xCharInfo* prCI = pCI; xCharInfo *prCI = pCI;
int ninfos = 0; int ninfos = 0;
int ncols = pFont->info.lastCol - pFont->info.firstCol + 1; int ncols = pFont->info.lastCol - pFont->info.firstCol + 1;
int row; int row;
for (row = pFont->info.firstRow;
row <= pFont->info.lastRow && ninfos < nCharInfos; for (row = pFont->info.firstRow;
row++) { row <= pFont->info.lastRow && ninfos < nCharInfos; row++) {
unsigned char chars[512]; unsigned char chars[512];
xCharInfo* tmpCharInfos[256]; xCharInfo *tmpCharInfos[256];
unsigned long count; unsigned long count;
int col; int col;
unsigned long i; unsigned long i;
i = 0;
for (col = pFont->info.firstCol; i = 0;
col <= pFont->info.lastCol; for (col = pFont->info.firstCol;
col++) { col <= pFont->info.lastCol; col++) {
chars[i++] = row; chars[i++] = row;
chars[i++] = col; chars[i++] = col;
} }
(*pFont->get_metrics) (pFont, ncols, chars, TwoD16Bit, (*pFont->get_metrics) (pFont, ncols, chars, TwoD16Bit,
&count, tmpCharInfos); &count, tmpCharInfos);
for (i = 0; i < count && ninfos < nCharInfos; i++) { for (i = 0; i < count && ninfos < nCharInfos; i++) {
*prCI++ = *tmpCharInfos[i]; *prCI++ = *tmpCharInfos[i];
ninfos++; ninfos++;
} }
} }
} }
#ifdef HAS_SHM #ifdef HAS_SHM
if (pDesc && !badSysCall) { if (pDesc && !badSysCall) {
*(CARD32 *)(pCI + nCharInfos) = signature; *(CARD32 *) (pCI + nCharInfos) = signature;
if (!FontSetPrivate(pFont, FontShmdescIndex, pDesc)) { if (!FontSetPrivate(pFont, FontShmdescIndex, pDesc)) {
shmdealloc(pDesc); shmdealloc(pDesc);
return BadAlloc; return BadAlloc;
} }
} }
} }
#endif #endif
if (shmid == -1) { if (shmid == -1) {
/* Cannot use shared memory, so remove-duplicates the xCharInfos /* Cannot use shared memory, so remove-duplicates the xCharInfos
using a temporary hash table. */ using a temporary hash table. */
/* Note that CARD16 is suitable as index type, because /* Note that CARD16 is suitable as index type, because
nCharInfos <= 0x10000. */ nCharInfos <= 0x10000. */
CARD32 hashModulus; CARD32 hashModulus;
CARD16* pHash2UniqIndex; CARD16 *pHash2UniqIndex;
CARD16* pUniqIndex2NextUniqIndex; CARD16 *pUniqIndex2NextUniqIndex;
CARD32 NextIndex; CARD32 NextIndex;
CARD32 NextUniqIndex; CARD32 NextUniqIndex;
CARD16* tmp; CARD16 *tmp;
CARD32 i, j; CARD32 i, j;
hashModulus = 67; hashModulus = 67;
if (hashModulus > nCharInfos+1) if (hashModulus > nCharInfos + 1)
hashModulus = nCharInfos+1; hashModulus = nCharInfos + 1;
tmp = malloc((4*nCharInfos+1) * sizeof(CARD16)); tmp = malloc((4 * nCharInfos + 1) * sizeof(CARD16));
if (!tmp) { if (!tmp) {
if (!pDesc) free(pCI); if (!pDesc)
return BadAlloc; free(pCI);
} return BadAlloc;
pIndex2UniqIndex = tmp; }
/* nCharInfos elements */ pIndex2UniqIndex = tmp;
pUniqIndex2Index = tmp + nCharInfos; /* nCharInfos elements */
/* max. nCharInfos elements */ pUniqIndex2Index = tmp + nCharInfos;
pUniqIndex2NextUniqIndex = tmp + 2*nCharInfos; /* max. nCharInfos elements */
/* max. nCharInfos elements */ pUniqIndex2NextUniqIndex = tmp + 2 * nCharInfos;
pHash2UniqIndex = tmp + 3*nCharInfos; /* max. nCharInfos elements */
/* hashModulus (<= nCharInfos+1) elements */ pHash2UniqIndex = tmp + 3 * nCharInfos;
/* hashModulus (<= nCharInfos+1) elements */
/* Note that we can use 0xffff as end-of-list indicator, because /* Note that we can use 0xffff as end-of-list indicator, because
even if nCharInfos = 0x10000, 0xffff can not occur as valid even if nCharInfos = 0x10000, 0xffff can not occur as valid
entry before the last element has been inserted. And once the entry before the last element has been inserted. And once the
last element has been inserted, we don't need the hash table last element has been inserted, we don't need the hash table
any more. */ any more. */
for (j = 0; j < hashModulus; j++) for (j = 0; j < hashModulus; j++)
pHash2UniqIndex[j] = (CARD16)(-1); pHash2UniqIndex[j] = (CARD16) (-1);
NextUniqIndex = 0; NextUniqIndex = 0;
for (NextIndex = 0; NextIndex < nCharInfos; NextIndex++) { for (NextIndex = 0; NextIndex < nCharInfos; NextIndex++) {
xCharInfo* p = &pCI[NextIndex]; xCharInfo *p = &pCI[NextIndex];
CARD32 hashCode = hashCI(p) % hashModulus; CARD32 hashCode = hashCI(p) % hashModulus;
for (i = pHash2UniqIndex[hashCode];
i != (CARD16)(-1); for (i = pHash2UniqIndex[hashCode];
i = pUniqIndex2NextUniqIndex[i]) { i != (CARD16) (-1); i = pUniqIndex2NextUniqIndex[i]) {
j = pUniqIndex2Index[i]; j = pUniqIndex2Index[i];
if (pCI[j].leftSideBearing == p->leftSideBearing if (pCI[j].leftSideBearing == p->leftSideBearing
&& pCI[j].rightSideBearing == p->rightSideBearing && pCI[j].rightSideBearing == p->rightSideBearing
&& pCI[j].characterWidth == p->characterWidth && pCI[j].characterWidth == p->characterWidth
&& pCI[j].ascent == p->ascent && pCI[j].ascent == p->ascent
&& pCI[j].descent == p->descent && pCI[j].descent == p->descent
&& pCI[j].attributes == p->attributes) && pCI[j].attributes == p->attributes)
break; break;
} }
if (i != (CARD16)(-1)) { if (i != (CARD16) (-1)) {
/* Found *p at Index j, UniqIndex i */ /* Found *p at Index j, UniqIndex i */
pIndex2UniqIndex[NextIndex] = i; pIndex2UniqIndex[NextIndex] = i;
} else { }
/* Allocate a new entry in the Uniq table */ else {
if (hashModulus <= 2*NextUniqIndex /* Allocate a new entry in the Uniq table */
&& hashModulus < nCharInfos+1) { if (hashModulus <= 2 * NextUniqIndex
/* Time to increate hash table size */ && hashModulus < nCharInfos + 1) {
hashModulus = 2*hashModulus+1; /* Time to increate hash table size */
if (hashModulus > nCharInfos+1) hashModulus = 2 * hashModulus + 1;
hashModulus = nCharInfos+1; if (hashModulus > nCharInfos + 1)
for (j = 0; j < hashModulus; j++) hashModulus = nCharInfos + 1;
pHash2UniqIndex[j] = (CARD16)(-1); for (j = 0; j < hashModulus; j++)
for (i = 0; i < NextUniqIndex; i++) pHash2UniqIndex[j] = (CARD16) (-1);
pUniqIndex2NextUniqIndex[i] = (CARD16)(-1); for (i = 0; i < NextUniqIndex; i++)
for (i = 0; i < NextUniqIndex; i++) { pUniqIndex2NextUniqIndex[i] = (CARD16) (-1);
j = pUniqIndex2Index[i]; for (i = 0; i < NextUniqIndex; i++) {
p = &pCI[j]; j = pUniqIndex2Index[i];
hashCode = hashCI(p) % hashModulus; p = &pCI[j];
pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode]; hashCode = hashCI(p) % hashModulus;
pHash2UniqIndex[hashCode] = i; pUniqIndex2NextUniqIndex[i] =
} pHash2UniqIndex[hashCode];
p = &pCI[NextIndex]; pHash2UniqIndex[hashCode] = i;
hashCode = hashCI(p) % hashModulus; }
} p = &pCI[NextIndex];
i = NextUniqIndex++; hashCode = hashCI(p) % hashModulus;
pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode]; }
pHash2UniqIndex[hashCode] = i; i = NextUniqIndex++;
pUniqIndex2Index[i] = NextIndex; pUniqIndex2NextUniqIndex[i] = pHash2UniqIndex[hashCode];
pIndex2UniqIndex[NextIndex] = i; pHash2UniqIndex[hashCode] = i;
} pUniqIndex2Index[i] = NextIndex;
} pIndex2UniqIndex[NextIndex] = i;
nUniqCharInfos = NextUniqIndex; }
/* fprintf(stderr, "font metrics: nCharInfos = %d, nUniqCharInfos = %d, hashModulus = %d\n", nCharInfos, nUniqCharInfos, hashModulus); */ }
} nUniqCharInfos = NextUniqIndex;
/* fprintf(stderr, "font metrics: nCharInfos = %d, nUniqCharInfos = %d, hashModulus = %d\n", nCharInfos, nUniqCharInfos, hashModulus); */
}
} }
{ {
int nfontprops = pFont->info.nprops; int nfontprops = pFont->info.nprops;
int rlength = int rlength = sizeof(xXF86BigfontQueryFontReply)
sizeof(xXF86BigfontQueryFontReply) + nfontprops * sizeof(xFontProp)
+ nfontprops * sizeof(xFontProp) + (nCharInfos > 0 && shmid == -1
+ (nCharInfos > 0 && shmid == -1 ? nUniqCharInfos * sizeof(xCharInfo)
? nUniqCharInfos * sizeof(xCharInfo) + (nCharInfos + 1) / 2 * 2 * sizeof(CARD16)
+ (nCharInfos+1)/2 * 2 * sizeof(CARD16) : 0);
: 0); xXF86BigfontQueryFontReply *reply = malloc(rlength);
xXF86BigfontQueryFontReply* reply = malloc(rlength); char *p;
char* p;
if (!reply) { if (!reply) {
if (nCharInfos > 0) { if (nCharInfos > 0) {
if (shmid == -1) free(pIndex2UniqIndex); if (shmid == -1)
if (!pDesc) free(pCI); free(pIndex2UniqIndex);
} if (!pDesc)
return BadAlloc; free(pCI);
} }
reply->type = X_Reply; return BadAlloc;
reply->length = bytes_to_int32(rlength - sizeof(xGenericReply)); }
reply->sequenceNumber = client->sequence; reply->type = X_Reply;
reply->minBounds = pFont->info.ink_minbounds; reply->length = bytes_to_int32(rlength - sizeof(xGenericReply));
reply->maxBounds = pFont->info.ink_maxbounds; reply->sequenceNumber = client->sequence;
reply->minCharOrByte2 = pFont->info.firstCol; reply->minBounds = pFont->info.ink_minbounds;
reply->maxCharOrByte2 = pFont->info.lastCol; reply->maxBounds = pFont->info.ink_maxbounds;
reply->defaultChar = pFont->info.defaultCh; reply->minCharOrByte2 = pFont->info.firstCol;
reply->nFontProps = pFont->info.nprops; reply->maxCharOrByte2 = pFont->info.lastCol;
reply->drawDirection = pFont->info.drawDirection; reply->defaultChar = pFont->info.defaultCh;
reply->minByte1 = pFont->info.firstRow; reply->nFontProps = pFont->info.nprops;
reply->maxByte1 = pFont->info.lastRow; reply->drawDirection = pFont->info.drawDirection;
reply->allCharsExist = pFont->info.allExist; reply->minByte1 = pFont->info.firstRow;
reply->fontAscent = pFont->info.fontAscent; reply->maxByte1 = pFont->info.lastRow;
reply->fontDescent = pFont->info.fontDescent; reply->allCharsExist = pFont->info.allExist;
reply->nCharInfos = nCharInfos; reply->fontAscent = pFont->info.fontAscent;
reply->fontDescent = pFont->info.fontDescent;
reply->nCharInfos = nCharInfos;
reply->nUniqCharInfos = nUniqCharInfos; reply->nUniqCharInfos = nUniqCharInfos;
reply->shmid = shmid; reply->shmid = shmid;
reply->shmsegoffset = 0; reply->shmsegoffset = 0;
if (client->swapped) { if (client->swapped) {
char tmp; char tmp;
swaps(&reply->sequenceNumber);
swapl(&reply->length); swaps(&reply->sequenceNumber);
swapCharInfo(&reply->minBounds); swapl(&reply->length);
swapCharInfo(&reply->maxBounds); swapCharInfo(&reply->minBounds);
swaps(&reply->minCharOrByte2); swapCharInfo(&reply->maxBounds);
swaps(&reply->maxCharOrByte2); swaps(&reply->minCharOrByte2);
swaps(&reply->defaultChar); swaps(&reply->maxCharOrByte2);
swaps(&reply->nFontProps); swaps(&reply->defaultChar);
swaps(&reply->fontAscent); swaps(&reply->nFontProps);
swaps(&reply->fontDescent); swaps(&reply->fontAscent);
swapl(&reply->nCharInfos); swaps(&reply->fontDescent);
swapl(&reply->nUniqCharInfos); swapl(&reply->nCharInfos);
swapl(&reply->shmid); swapl(&reply->nUniqCharInfos);
swapl(&reply->shmsegoffset); swapl(&reply->shmid);
} swapl(&reply->shmsegoffset);
p = (char*) &reply[1]; }
{ p = (char *) &reply[1];
FontPropPtr pFP; {
xFontProp* prFP; FontPropPtr pFP;
int i; xFontProp *prFP;
for (i = 0, pFP = pFont->info.props, prFP = (xFontProp *) p; int i;
i < nfontprops;
i++, pFP++, prFP++) { for (i = 0, pFP = pFont->info.props, prFP = (xFontProp *) p;
prFP->name = pFP->name; i < nfontprops; i++, pFP++, prFP++) {
prFP->value = pFP->value; prFP->name = pFP->name;
if (client->swapped) { prFP->value = pFP->value;
char tmp; if (client->swapped) {
swapl(&prFP->name); char tmp;
swapl(&prFP->value);
} swapl(&prFP->name);
} swapl(&prFP->value);
p = (char*) prFP; }
} }
if (nCharInfos > 0 && shmid == -1) { p = (char *) prFP;
xCharInfo* pci; }
CARD16* ps; if (nCharInfos > 0 && shmid == -1) {
int i, j; xCharInfo *pci;
pci = (xCharInfo*) p; CARD16 *ps;
for (i = 0; i < nUniqCharInfos; i++, pci++) { int i, j;
*pci = pCI[pUniqIndex2Index[i]];
if (client->swapped) pci = (xCharInfo *) p;
swapCharInfo(pci); for (i = 0; i < nUniqCharInfos; i++, pci++) {
} *pci = pCI[pUniqIndex2Index[i]];
ps = (CARD16*) pci; if (client->swapped)
for (j = 0; j < nCharInfos; j++, ps++) { swapCharInfo(pci);
*ps = pIndex2UniqIndex[j]; }
if (client->swapped) { ps = (CARD16 *) pci;
char tmp; for (j = 0; j < nCharInfos; j++, ps++) {
swaps(ps); *ps = pIndex2UniqIndex[j];
} if (client->swapped) {
} char tmp;
}
WriteToClient(client, rlength, (char *)reply); swaps(ps);
free(reply); }
if (nCharInfos > 0) { }
if (shmid == -1) free(pIndex2UniqIndex); }
if (!pDesc) free(pCI); WriteToClient(client, rlength, (char *) reply);
} free(reply);
return Success; if (nCharInfos > 0) {
if (shmid == -1)
free(pIndex2UniqIndex);
if (!pDesc)
free(pCI);
}
return Success;
} }
} }
static int static int
ProcXF86BigfontDispatch( ProcXF86BigfontDispatch(ClientPtr client)
ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) { switch (stuff->data) {
case X_XF86BigfontQueryVersion: case X_XF86BigfontQueryVersion:
return ProcXF86BigfontQueryVersion(client); return ProcXF86BigfontQueryVersion(client);
case X_XF86BigfontQueryFont: case X_XF86BigfontQueryFont:
return ProcXF86BigfontQueryFont(client); return ProcXF86BigfontQueryFont(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
static int static int
SProcXF86BigfontQueryVersion( SProcXF86BigfontQueryVersion(ClientPtr client)
ClientPtr client)
{ {
REQUEST(xXF86BigfontQueryVersionReq); REQUEST(xXF86BigfontQueryVersionReq);
char tmp; char tmp;
@ -677,8 +682,7 @@ SProcXF86BigfontQueryVersion(
} }
static int static int
SProcXF86BigfontQueryFont( SProcXF86BigfontQueryFont(ClientPtr client)
ClientPtr client)
{ {
REQUEST(xXF86BigfontQueryFontReq); REQUEST(xXF86BigfontQueryFontReq);
char tmp; char tmp;
@ -690,18 +694,17 @@ SProcXF86BigfontQueryFont(
} }
static int static int
SProcXF86BigfontDispatch( SProcXF86BigfontDispatch(ClientPtr client)
ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) { switch (stuff->data) {
case X_XF86BigfontQueryVersion: case X_XF86BigfontQueryVersion:
return SProcXF86BigfontQueryVersion(client); return SProcXF86BigfontQueryVersion(client);
case X_XF86BigfontQueryFont: case X_XF86BigfontQueryFont:
return SProcXF86BigfontQueryFont(client); return SProcXF86BigfontQueryFont(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -709,41 +712,41 @@ void
XFree86BigfontExtensionInit(void) XFree86BigfontExtensionInit(void)
{ {
if (AddExtension(XF86BIGFONTNAME, if (AddExtension(XF86BIGFONTNAME,
XF86BigfontNumberEvents, XF86BigfontNumberEvents,
XF86BigfontNumberErrors, XF86BigfontNumberErrors,
ProcXF86BigfontDispatch, ProcXF86BigfontDispatch,
SProcXF86BigfontDispatch, SProcXF86BigfontDispatch,
XF86BigfontResetProc, XF86BigfontResetProc, StandardMinorOpcode)) {
StandardMinorOpcode)) {
#ifdef HAS_SHM #ifdef HAS_SHM
#ifdef MUST_CHECK_FOR_SHM_SYSCALL #ifdef MUST_CHECK_FOR_SHM_SYSCALL
/* /*
* Note: Local-clients will not be optimized without shared memory * Note: Local-clients will not be optimized without shared memory
* support. Remote-client optimization does not depend on shared * support. Remote-client optimization does not depend on shared
* memory support. Thus, the extension is still registered even * memory support. Thus, the extension is still registered even
* when shared memory support is not functional. * when shared memory support is not functional.
*/ */
if (!CheckForShmSyscall()) { if (!CheckForShmSyscall()) {
ErrorF(XF86BIGFONTNAME " extension local-client optimization disabled due to lack of shared memory support in the kernel\n"); ErrorF(XF86BIGFONTNAME
return; " extension local-client optimization disabled due to lack of shared memory support in the kernel\n");
} return;
}
#endif #endif
srand((unsigned int) time(NULL)); srand((unsigned int) time(NULL));
signature = ((unsigned int) (65536.0/(RAND_MAX+1.0) * rand()) << 16) signature = ((unsigned int) (65536.0 / (RAND_MAX + 1.0) * rand()) << 16)
+ (unsigned int) (65536.0/(RAND_MAX+1.0) * rand()); + (unsigned int) (65536.0 / (RAND_MAX + 1.0) * rand());
/* fprintf(stderr, "signature = 0x%08X\n", signature); */ /* fprintf(stderr, "signature = 0x%08X\n", signature); */
FontShmdescIndex = AllocateFontPrivateIndex(); FontShmdescIndex = AllocateFontPrivateIndex();
#if !defined(CSRG_BASED) && !defined(__CYGWIN__) #if !defined(CSRG_BASED) && !defined(__CYGWIN__)
pagesize = SHMLBA; pagesize = SHMLBA;
#else #else
# ifdef _SC_PAGESIZE #ifdef _SC_PAGESIZE
pagesize = sysconf(_SC_PAGESIZE); pagesize = sysconf(_SC_PAGESIZE);
# else #else
pagesize = getpagesize(); pagesize = getpagesize();
# endif #endif
#endif #endif
#endif #endif
} }

166
Xext/xres.c
View File

@ -24,12 +24,12 @@
#include "protocol-versions.h" #include "protocol-versions.h"
static int static int
ProcXResQueryVersion (ClientPtr client) ProcXResQueryVersion(ClientPtr client)
{ {
REQUEST(xXResQueryVersionReq); REQUEST(xXResQueryVersionReq);
xXResQueryVersionReply rep; xXResQueryVersionReply rep;
REQUEST_SIZE_MATCH (xXResQueryVersionReq); REQUEST_SIZE_MATCH(xXResQueryVersionReq);
rep.type = X_Reply; rep.type = X_Reply;
rep.length = 0; rep.length = 0;
@ -42,12 +42,12 @@ ProcXResQueryVersion (ClientPtr client)
swaps(&rep.server_major); swaps(&rep.server_major);
swaps(&rep.server_minor); swaps(&rep.server_minor);
} }
WriteToClient(client, sizeof (xXResQueryVersionReply), (char *)&rep); WriteToClient(client, sizeof(xXResQueryVersionReply), (char *) &rep);
return Success; return Success;
} }
static int static int
ProcXResQueryClients (ClientPtr client) ProcXResQueryClients(ClientPtr client)
{ {
/* REQUEST(xXResQueryClientsReq); */ /* REQUEST(xXResQueryClientsReq); */
xXResQueryClientsReply rep; xXResQueryClientsReply rep;
@ -59,11 +59,11 @@ ProcXResQueryClients (ClientPtr client)
current_clients = malloc(currentMaxClients * sizeof(int)); current_clients = malloc(currentMaxClients * sizeof(int));
num_clients = 0; num_clients = 0;
for(i = 0; i < currentMaxClients; i++) { for (i = 0; i < currentMaxClients; i++) {
if(clients[i]) { if (clients[i]) {
current_clients[num_clients] = i; current_clients[num_clients] = i;
num_clients++; num_clients++;
} }
} }
rep.type = X_Reply; rep.type = X_Reply;
@ -75,20 +75,20 @@ ProcXResQueryClients (ClientPtr client)
swapl(&rep.length); swapl(&rep.length);
swapl(&rep.num_clients); swapl(&rep.num_clients);
} }
WriteToClient (client, sizeof (xXResQueryClientsReply), (char *) &rep); WriteToClient(client, sizeof(xXResQueryClientsReply), (char *) &rep);
if(num_clients) { if (num_clients) {
xXResClient scratch; xXResClient scratch;
for(i = 0; i < num_clients; i++) { for (i = 0; i < num_clients; i++) {
scratch.resource_base = clients[current_clients[i]]->clientAsMask; scratch.resource_base = clients[current_clients[i]]->clientAsMask;
scratch.resource_mask = RESOURCE_ID_MASK; scratch.resource_mask = RESOURCE_ID_MASK;
if(client->swapped) { if (client->swapped) {
swapl(&scratch.resource_base); swapl(&scratch.resource_base);
swapl(&scratch.resource_mask); swapl(&scratch.resource_mask);
} }
WriteToClient (client, sz_xXResClient, (char *) &scratch); WriteToClient(client, sz_xXResClient, (char *) &scratch);
} }
} }
@ -97,17 +97,16 @@ ProcXResQueryClients (ClientPtr client)
return Success; return Success;
} }
static void static void
ResFindAllRes (pointer value, XID id, RESTYPE type, pointer cdata) ResFindAllRes(pointer value, XID id, RESTYPE type, pointer cdata)
{ {
int *counts = (int *)cdata; int *counts = (int *) cdata;
counts[(type & TypeMask) - 1]++; counts[(type & TypeMask) - 1]++;
} }
static int static int
ProcXResQueryClientResources (ClientPtr client) ProcXResQueryClientResources(ClientPtr client)
{ {
REQUEST(xXResQueryClientResourcesReq); REQUEST(xXResQueryClientResourcesReq);
xXResQueryClientResourcesReply rep; xXResQueryClientResourcesReply rep;
@ -118,7 +117,7 @@ ProcXResQueryClientResources (ClientPtr client)
clientID = CLIENT_ID(stuff->xid); clientID = CLIENT_ID(stuff->xid);
if((clientID >= currentMaxClients) || !clients[clientID]) { if ((clientID >= currentMaxClients) || !clients[clientID]) {
client->errorValue = stuff->xid; client->errorValue = stuff->xid;
return BadValue; return BadValue;
} }
@ -129,8 +128,9 @@ ProcXResQueryClientResources (ClientPtr client)
num_types = 0; num_types = 0;
for(i = 0; i <= lastResourceType; i++) { for (i = 0; i <= lastResourceType; i++) {
if(counts[i]) num_types++; if (counts[i])
num_types++;
} }
rep.type = X_Reply; rep.type = X_Reply;
@ -143,31 +143,34 @@ ProcXResQueryClientResources (ClientPtr client)
swapl(&rep.num_types); swapl(&rep.num_types);
} }
WriteToClient (client,sizeof(xXResQueryClientResourcesReply),(char*)&rep); WriteToClient(client, sizeof(xXResQueryClientResourcesReply),
(char *) &rep);
if(num_types) { if (num_types) {
xXResType scratch; xXResType scratch;
const char *name; const char *name;
for(i = 0; i < lastResourceType; i++) { for (i = 0; i < lastResourceType; i++) {
if(!counts[i]) continue; if (!counts[i])
continue;
name = LookupResourceName(i + 1); name = LookupResourceName(i + 1);
if (strcmp(name, XREGISTRY_UNKNOWN)) if (strcmp(name, XREGISTRY_UNKNOWN))
scratch.resource_type = MakeAtom(name, strlen(name), TRUE); scratch.resource_type = MakeAtom(name, strlen(name), TRUE);
else { else {
char buf[40]; char buf[40];
snprintf(buf, sizeof(buf), "Unregistered resource %i", i + 1); snprintf(buf, sizeof(buf), "Unregistered resource %i", i + 1);
scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE); scratch.resource_type = MakeAtom(buf, strlen(buf), TRUE);
} }
scratch.count = counts[i]; scratch.count = counts[i];
if(client->swapped) { if (client->swapped) {
swapl(&scratch.resource_type); swapl(&scratch.resource_type);
swapl(&scratch.count); swapl(&scratch.count);
} }
WriteToClient (client, sz_xXResType, (char *) &scratch); WriteToClient(client, sz_xXResType, (char *) &scratch);
} }
} }
@ -177,57 +180,57 @@ ProcXResQueryClientResources (ClientPtr client)
} }
static unsigned long static unsigned long
ResGetApproxPixmapBytes (PixmapPtr pix) ResGetApproxPixmapBytes(PixmapPtr pix)
{ {
unsigned long nPixels; unsigned long nPixels;
int bytesPerPixel; int bytesPerPixel;
bytesPerPixel = pix->drawable.bitsPerPixel>>3; bytesPerPixel = pix->drawable.bitsPerPixel >> 3;
nPixels = pix->drawable.width * pix->drawable.height; nPixels = pix->drawable.width * pix->drawable.height;
/* Divide by refcnt as pixmap could be shared between clients, /* Divide by refcnt as pixmap could be shared between clients,
* so total pixmap mem is shared between these. * so total pixmap mem is shared between these.
*/ */
return ( nPixels * bytesPerPixel ) / pix->refcnt; return (nPixels * bytesPerPixel) / pix->refcnt;
} }
static void static void
ResFindPixmaps (pointer value, XID id, pointer cdata) ResFindPixmaps(pointer value, XID id, pointer cdata)
{ {
unsigned long *bytes = (unsigned long *)cdata; unsigned long *bytes = (unsigned long *) cdata;
PixmapPtr pix = (PixmapPtr)value; PixmapPtr pix = (PixmapPtr) value;
*bytes += ResGetApproxPixmapBytes(pix); *bytes += ResGetApproxPixmapBytes(pix);
} }
static void static void
ResFindWindowPixmaps (pointer value, XID id, pointer cdata) ResFindWindowPixmaps(pointer value, XID id, pointer cdata)
{ {
unsigned long *bytes = (unsigned long *)cdata; unsigned long *bytes = (unsigned long *) cdata;
WindowPtr pWin = (WindowPtr)value; WindowPtr pWin = (WindowPtr) value;
if (pWin->backgroundState == BackgroundPixmap) if (pWin->backgroundState == BackgroundPixmap)
*bytes += ResGetApproxPixmapBytes(pWin->background.pixmap); *bytes += ResGetApproxPixmapBytes(pWin->background.pixmap);
if (pWin->border.pixmap != NULL && !pWin->borderIsPixel) if (pWin->border.pixmap != NULL && !pWin->borderIsPixel)
*bytes += ResGetApproxPixmapBytes(pWin->border.pixmap); *bytes += ResGetApproxPixmapBytes(pWin->border.pixmap);
} }
static void static void
ResFindGCPixmaps (pointer value, XID id, pointer cdata) ResFindGCPixmaps(pointer value, XID id, pointer cdata)
{ {
unsigned long *bytes = (unsigned long *)cdata; unsigned long *bytes = (unsigned long *) cdata;
GCPtr pGC = (GCPtr)value; GCPtr pGC = (GCPtr) value;
if (pGC->stipple != NULL) if (pGC->stipple != NULL)
*bytes += ResGetApproxPixmapBytes(pGC->stipple); *bytes += ResGetApproxPixmapBytes(pGC->stipple);
if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel) if (pGC->tile.pixmap != NULL && !pGC->tileIsPixel)
*bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap); *bytes += ResGetApproxPixmapBytes(pGC->tile.pixmap);
} }
static int static int
ProcXResQueryClientPixmapBytes (ClientPtr client) ProcXResQueryClientPixmapBytes(ClientPtr client)
{ {
REQUEST(xXResQueryClientPixmapBytesReq); REQUEST(xXResQueryClientPixmapBytesReq);
xXResQueryClientPixmapBytesReply rep; xXResQueryClientPixmapBytesReply rep;
@ -238,7 +241,7 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
clientID = CLIENT_ID(stuff->xid); clientID = CLIENT_ID(stuff->xid);
if((clientID >= currentMaxClients) || !clients[clientID]) { if ((clientID >= currentMaxClients) || !clients[clientID]) {
client->errorValue = stuff->xid; client->errorValue = stuff->xid;
return BadValue; return BadValue;
} }
@ -246,21 +249,19 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
bytes = 0; bytes = 0;
FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps, FindClientResourcesByType(clients[clientID], RT_PIXMAP, ResFindPixmaps,
(pointer)(&bytes)); (pointer) (&bytes));
/* /*
* Make sure win background pixmaps also held to account. * Make sure win background pixmaps also held to account.
*/ */
FindClientResourcesByType(clients[clientID], RT_WINDOW, FindClientResourcesByType(clients[clientID], RT_WINDOW,
ResFindWindowPixmaps, ResFindWindowPixmaps, (pointer) (&bytes));
(pointer)(&bytes));
/* /*
* GC Tile & Stipple pixmaps too. * GC Tile & Stipple pixmaps too.
*/ */
FindClientResourcesByType(clients[clientID], RT_GC, FindClientResourcesByType(clients[clientID], RT_GC,
ResFindGCPixmaps, ResFindGCPixmaps, (pointer) (&bytes));
(pointer)(&bytes));
#ifdef COMPOSITE #ifdef COMPOSITE
/* FIXME: include composite pixmaps too */ /* FIXME: include composite pixmaps too */
@ -281,13 +282,14 @@ ProcXResQueryClientPixmapBytes (ClientPtr client)
swapl(&rep.bytes); swapl(&rep.bytes);
swapl(&rep.bytes_overflow); swapl(&rep.bytes_overflow);
} }
WriteToClient (client,sizeof(xXResQueryClientPixmapBytesReply),(char*)&rep); WriteToClient(client, sizeof(xXResQueryClientPixmapBytesReply),
(char *) &rep);
return Success; return Success;
} }
static int static int
ProcResDispatch (ClientPtr client) ProcResDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) { switch (stuff->data) {
@ -299,40 +301,41 @@ ProcResDispatch (ClientPtr client)
return ProcXResQueryClientResources(client); return ProcXResQueryClientResources(client);
case X_XResQueryClientPixmapBytes: case X_XResQueryClientPixmapBytes:
return ProcXResQueryClientPixmapBytes(client); return ProcXResQueryClientPixmapBytes(client);
default: break; default:
break;
} }
return BadRequest; return BadRequest;
} }
static int static int
SProcXResQueryVersion (ClientPtr client) SProcXResQueryVersion(ClientPtr client)
{ {
REQUEST(xXResQueryVersionReq); REQUEST(xXResQueryVersionReq);
REQUEST_SIZE_MATCH (xXResQueryVersionReq); REQUEST_SIZE_MATCH(xXResQueryVersionReq);
return ProcXResQueryVersion(client); return ProcXResQueryVersion(client);
} }
static int static int
SProcXResQueryClientResources (ClientPtr client) SProcXResQueryClientResources(ClientPtr client)
{ {
REQUEST(xXResQueryClientResourcesReq); REQUEST(xXResQueryClientResourcesReq);
REQUEST_SIZE_MATCH (xXResQueryClientResourcesReq); REQUEST_SIZE_MATCH(xXResQueryClientResourcesReq);
swapl(&stuff->xid); swapl(&stuff->xid);
return ProcXResQueryClientResources(client); return ProcXResQueryClientResources(client);
} }
static int static int
SProcXResQueryClientPixmapBytes (ClientPtr client) SProcXResQueryClientPixmapBytes(ClientPtr client)
{ {
REQUEST(xXResQueryClientPixmapBytesReq); REQUEST(xXResQueryClientPixmapBytesReq);
REQUEST_SIZE_MATCH (xXResQueryClientPixmapBytesReq); REQUEST_SIZE_MATCH(xXResQueryClientPixmapBytesReq);
swapl(&stuff->xid); swapl(&stuff->xid);
return ProcXResQueryClientPixmapBytes(client); return ProcXResQueryClientPixmapBytes(client);
} }
static int static int
SProcResDispatch (ClientPtr client) SProcResDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
swaps(&stuff->length); swaps(&stuff->length);
@ -340,13 +343,14 @@ SProcResDispatch (ClientPtr client)
switch (stuff->data) { switch (stuff->data) {
case X_XResQueryVersion: case X_XResQueryVersion:
return SProcXResQueryVersion(client); return SProcXResQueryVersion(client);
case X_XResQueryClients: /* nothing to swap */ case X_XResQueryClients: /* nothing to swap */
return ProcXResQueryClients(client); return ProcXResQueryClients(client);
case X_XResQueryClientResources: case X_XResQueryClientResources:
return SProcXResQueryClientResources(client); return SProcXResQueryClientResources(client);
case X_XResQueryClientPixmapBytes: case X_XResQueryClientPixmapBytes:
return SProcXResQueryClientPixmapBytes(client); return SProcXResQueryClientPixmapBytes(client);
default: break; default:
break;
} }
return BadRequest; return BadRequest;
@ -356,6 +360,6 @@ void
ResExtensionInit(INITARGS) ResExtensionInit(INITARGS)
{ {
(void) AddExtension(XRES_NAME, 0, 0, (void) AddExtension(XRES_NAME, 0, 0,
ProcResDispatch, SProcResDispatch, ProcResDispatch, SProcResDispatch,
NULL, StandardMinorOpcode); NULL, StandardMinorOpcode);
} }

116
Xext/xselinux.h
View File

@ -53,87 +53,87 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define X_SELinuxGetClientContext 22 #define X_SELinuxGetClientContext 22
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
CARD8 client_major; CARD8 client_major;
CARD8 client_minor; CARD8 client_minor;
} SELinuxQueryVersionReq; } SELinuxQueryVersionReq;
typedef struct { typedef struct {
CARD8 type; CARD8 type;
CARD8 pad1; CARD8 pad1;
CARD16 sequenceNumber; CARD16 sequenceNumber;
CARD32 length; CARD32 length;
CARD16 server_major; CARD16 server_major;
CARD16 server_minor; CARD16 server_minor;
CARD32 pad2; CARD32 pad2;
CARD32 pad3; CARD32 pad3;
CARD32 pad4; CARD32 pad4;
CARD32 pad5; CARD32 pad5;
CARD32 pad6; CARD32 pad6;
} SELinuxQueryVersionReply; } SELinuxQueryVersionReply;
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
CARD32 context_len; CARD32 context_len;
} SELinuxSetCreateContextReq; } SELinuxSetCreateContextReq;
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
} SELinuxGetCreateContextReq; } SELinuxGetCreateContextReq;
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
CARD32 id; CARD32 id;
CARD32 context_len; CARD32 context_len;
} SELinuxSetContextReq; } SELinuxSetContextReq;
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
CARD32 id; CARD32 id;
} SELinuxGetContextReq; } SELinuxGetContextReq;
typedef struct { typedef struct {
CARD8 reqType; CARD8 reqType;
CARD8 SELinuxReqType; CARD8 SELinuxReqType;
CARD16 length; CARD16 length;
CARD32 window; CARD32 window;
CARD32 property; CARD32 property;
} SELinuxGetPropertyContextReq; } SELinuxGetPropertyContextReq;
typedef struct { typedef struct {
CARD8 type; CARD8 type;
CARD8 pad1; CARD8 pad1;
CARD16 sequenceNumber; CARD16 sequenceNumber;
CARD32 length; CARD32 length;
CARD32 context_len; CARD32 context_len;
CARD32 pad2; CARD32 pad2;
CARD32 pad3; CARD32 pad3;
CARD32 pad4; CARD32 pad4;
CARD32 pad5; CARD32 pad5;
CARD32 pad6; CARD32 pad6;
} SELinuxGetContextReply; } SELinuxGetContextReply;
typedef struct { typedef struct {
CARD8 type; CARD8 type;
CARD8 pad1; CARD8 pad1;
CARD16 sequenceNumber; CARD16 sequenceNumber;
CARD32 length; CARD32 length;
CARD32 count; CARD32 count;
CARD32 pad2; CARD32 pad2;
CARD32 pad3; CARD32 pad3;
CARD32 pad4; CARD32 pad4;
CARD32 pad5; CARD32 pad5;
CARD32 pad6; CARD32 pad6;
} SELinuxListItemsReply; } SELinuxListItemsReply;
#endif /* _XSELINUX_H */ #endif /* _XSELINUX_H */

302
Xext/xselinux_ext.c
View File

@ -44,7 +44,6 @@ typedef struct {
CARD32 id; CARD32 id;
} SELinuxListItemRec; } SELinuxListItemRec;
/* /*
* Extension Dispatch * Extension Dispatch
*/ */
@ -53,8 +52,9 @@ static security_context_t
SELinuxCopyContext(char *ptr, unsigned len) SELinuxCopyContext(char *ptr, unsigned len)
{ {
security_context_t copy = malloc(len + 1); security_context_t copy = malloc(len + 1);
if (!copy) if (!copy)
return NULL; return NULL;
strncpy(copy, ptr, len); strncpy(copy, ptr, len);
copy[len] = '\0'; copy[len] = '\0';
return copy; return copy;
@ -71,12 +71,12 @@ ProcSELinuxQueryVersion(ClientPtr client)
rep.server_major = SELINUX_MAJOR_VERSION; rep.server_major = SELINUX_MAJOR_VERSION;
rep.server_minor = SELINUX_MINOR_VERSION; rep.server_minor = SELINUX_MINOR_VERSION;
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.length); swapl(&rep.length);
swaps(&rep.server_major); swaps(&rep.server_major);
swaps(&rep.server_minor); swaps(&rep.server_minor);
} }
WriteToClient(client, sizeof(rep), (char *)&rep); WriteToClient(client, sizeof(rep), (char *) &rep);
return Success; return Success;
} }
@ -88,9 +88,9 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
int len = 0; int len = 0;
if (sid) { if (sid) {
if (avc_sid_to_context_raw(sid, &ctx) < 0) if (avc_sid_to_context_raw(sid, &ctx) < 0)
return BadValue; return BadValue;
len = strlen(ctx) + 1; len = strlen(ctx) + 1;
} }
rep.type = X_Reply; rep.type = X_Reply;
@ -99,12 +99,12 @@ SELinuxSendContextReply(ClientPtr client, security_id_t sid)
rep.context_len = len; rep.context_len = len;
if (client->swapped) { if (client->swapped) {
swapl(&rep.length); swapl(&rep.length);
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.context_len); swapl(&rep.context_len);
} }
WriteToClient(client, sizeof(SELinuxGetContextReply), (char *)&rep); WriteToClient(client, sizeof(SELinuxGetContextReply), (char *) &rep);
WriteToClient(client, len, ctx); WriteToClient(client, len, ctx);
freecon(ctx); freecon(ctx);
return Success; return Success;
@ -123,20 +123,20 @@ ProcSELinuxSetCreateContext(ClientPtr client, unsigned offset)
REQUEST_FIXED_SIZE(SELinuxSetCreateContextReq, stuff->context_len); REQUEST_FIXED_SIZE(SELinuxSetCreateContextReq, stuff->context_len);
if (stuff->context_len > 0) { if (stuff->context_len > 0) {
ctx = SELinuxCopyContext((char *)(stuff + 1), stuff->context_len); ctx = SELinuxCopyContext((char *) (stuff + 1), stuff->context_len);
if (!ctx) if (!ctx)
return BadAlloc; return BadAlloc;
} }
ptr = dixLookupPrivate(privPtr, subjectKey); ptr = dixLookupPrivate(privPtr, subjectKey);
pSid = (security_id_t *)(ptr + offset); pSid = (security_id_t *) (ptr + offset);
*pSid = NULL; *pSid = NULL;
rc = Success; rc = Success;
if (stuff->context_len > 0) { if (stuff->context_len > 0) {
if (security_check_context_raw(ctx) < 0 || if (security_check_context_raw(ctx) < 0 ||
avc_context_to_sid_raw(ctx, pSid) < 0) avc_context_to_sid_raw(ctx, pSid) < 0)
rc = BadValue; rc = BadValue;
} }
free(ctx); free(ctx);
@ -152,11 +152,11 @@ ProcSELinuxGetCreateContext(ClientPtr client, unsigned offset)
REQUEST_SIZE_MATCH(SELinuxGetCreateContextReq); REQUEST_SIZE_MATCH(SELinuxGetCreateContextReq);
if (offset == CTX_DEV) if (offset == CTX_DEV)
ptr = dixLookupPrivate(&serverClient->devPrivates, subjectKey); ptr = dixLookupPrivate(&serverClient->devPrivates, subjectKey);
else else
ptr = dixLookupPrivate(&client->devPrivates, subjectKey); ptr = dixLookupPrivate(&client->devPrivates, subjectKey);
pSid = (security_id_t *)(ptr + offset); pSid = (security_id_t *) (ptr + offset);
return SELinuxSendContextReply(client, *pSid); return SELinuxSendContextReply(client, *pSid);
} }
@ -174,19 +174,19 @@ ProcSELinuxSetDeviceContext(ClientPtr client)
REQUEST_FIXED_SIZE(SELinuxSetContextReq, stuff->context_len); REQUEST_FIXED_SIZE(SELinuxSetContextReq, stuff->context_len);
if (stuff->context_len < 1) if (stuff->context_len < 1)
return BadLength; return BadLength;
ctx = SELinuxCopyContext((char *)(stuff + 1), stuff->context_len); ctx = SELinuxCopyContext((char *) (stuff + 1), stuff->context_len);
if (!ctx) if (!ctx)
return BadAlloc; return BadAlloc;
rc = dixLookupDevice(&dev, stuff->id, client, DixManageAccess); rc = dixLookupDevice(&dev, stuff->id, client, DixManageAccess);
if (rc != Success) if (rc != Success)
goto out; goto out;
if (security_check_context_raw(ctx) < 0 || if (security_check_context_raw(ctx) < 0 ||
avc_context_to_sid_raw(ctx, &sid) < 0) { avc_context_to_sid_raw(ctx, &sid) < 0) {
rc = BadValue; rc = BadValue;
goto out; goto out;
} }
subj = dixLookupPrivate(&dev->devPrivates, subjectKey); subj = dixLookupPrivate(&dev->devPrivates, subjectKey);
@ -195,7 +195,7 @@ ProcSELinuxSetDeviceContext(ClientPtr client)
obj->sid = sid; obj->sid = sid;
rc = Success; rc = Success;
out: out:
free(ctx); free(ctx);
return rc; return rc;
} }
@ -212,7 +212,7 @@ ProcSELinuxGetDeviceContext(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->id, client, DixGetAttrAccess); rc = dixLookupDevice(&dev, stuff->id, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
subj = dixLookupPrivate(&dev->devPrivates, subjectKey); subj = dixLookupPrivate(&dev->devPrivates, subjectKey);
return SELinuxSendContextReply(client, subj->sid); return SELinuxSendContextReply(client, subj->sid);
@ -231,12 +231,12 @@ ProcSELinuxGetDrawableContext(ClientPtr client)
rc = dixLookupDrawable(&pDraw, stuff->id, client, 0, DixGetAttrAccess); rc = dixLookupDrawable(&pDraw, stuff->id, client, 0, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (pDraw->type == DRAWABLE_PIXMAP) if (pDraw->type == DRAWABLE_PIXMAP)
privatePtr = &((PixmapPtr)pDraw)->devPrivates; privatePtr = &((PixmapPtr) pDraw)->devPrivates;
else else
privatePtr = &((WindowPtr)pDraw)->devPrivates; privatePtr = &((WindowPtr) pDraw)->devPrivates;
obj = dixLookupPrivate(privatePtr, objectKey); obj = dixLookupPrivate(privatePtr, objectKey);
return SELinuxSendContextReply(client, obj->sid); return SELinuxSendContextReply(client, obj->sid);
@ -255,12 +255,12 @@ ProcSELinuxGetPropertyContext(ClientPtr client, pointer privKey)
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetPropAccess); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetPropAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
rc = dixLookupProperty(&pProp, pWin, stuff->property, client, rc = dixLookupProperty(&pProp, pWin, stuff->property, client,
DixGetAttrAccess); DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
obj = dixLookupPrivate(&pProp->devPrivates, privKey); obj = dixLookupPrivate(&pProp->devPrivates, privKey);
return SELinuxSendContextReply(client, obj->sid); return SELinuxSendContextReply(client, obj->sid);
@ -278,7 +278,7 @@ ProcSELinuxGetSelectionContext(ClientPtr client, pointer privKey)
rc = dixLookupSelection(&pSel, stuff->id, client, DixGetAttrAccess); rc = dixLookupSelection(&pSel, stuff->id, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
obj = dixLookupPrivate(&pSel->devPrivates, privKey); obj = dixLookupPrivate(&pSel->devPrivates, privKey);
return SELinuxSendContextReply(client, obj->sid); return SELinuxSendContextReply(client, obj->sid);
@ -296,23 +296,23 @@ ProcSELinuxGetClientContext(ClientPtr client)
rc = dixLookupClient(&target, stuff->id, client, DixGetAttrAccess); rc = dixLookupClient(&target, stuff->id, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
subj = dixLookupPrivate(&target->devPrivates, subjectKey); subj = dixLookupPrivate(&target->devPrivates, subjectKey);
return SELinuxSendContextReply(client, subj->sid); return SELinuxSendContextReply(client, subj->sid);
} }
static int static int
SELinuxPopulateItem(SELinuxListItemRec *i, PrivateRec **privPtr, CARD32 id, SELinuxPopulateItem(SELinuxListItemRec * i, PrivateRec ** privPtr, CARD32 id,
int *size) int *size)
{ {
SELinuxObjectRec *obj = dixLookupPrivate(privPtr, objectKey); SELinuxObjectRec *obj = dixLookupPrivate(privPtr, objectKey);
SELinuxObjectRec *data = dixLookupPrivate(privPtr, dataKey); SELinuxObjectRec *data = dixLookupPrivate(privPtr, dataKey);
if (avc_sid_to_context_raw(obj->sid, &i->octx) < 0) if (avc_sid_to_context_raw(obj->sid, &i->octx) < 0)
return BadValue; return BadValue;
if (avc_sid_to_context_raw(data->sid, &i->dctx) < 0) if (avc_sid_to_context_raw(data->sid, &i->dctx) < 0)
return BadValue; return BadValue;
i->id = id; i->id = id;
i->octx_len = bytes_to_int32(strlen(i->octx) + 1); i->octx_len = bytes_to_int32(strlen(i->octx) + 1);
@ -323,19 +323,20 @@ SELinuxPopulateItem(SELinuxListItemRec *i, PrivateRec **privPtr, CARD32 id,
} }
static void static void
SELinuxFreeItems(SELinuxListItemRec *items, int count) SELinuxFreeItems(SELinuxListItemRec * items, int count)
{ {
int k; int k;
for (k = 0; k < count; k++) { for (k = 0; k < count; k++) {
freecon(items[k].octx); freecon(items[k].octx);
freecon(items[k].dctx); freecon(items[k].dctx);
} }
free(items); free(items);
} }
static int static int
SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items, SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec * items,
int size, int count) int size, int count)
{ {
int rc, k, pos = 0; int rc, k, pos = 0;
SELinuxListItemsReply rep; SELinuxListItemsReply rep;
@ -343,31 +344,31 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
buf = calloc(size, sizeof(CARD32)); buf = calloc(size, sizeof(CARD32));
if (size && !buf) { if (size && !buf) {
rc = BadAlloc; rc = BadAlloc;
goto out; goto out;
} }
/* Fill in the buffer */ /* Fill in the buffer */
for (k = 0; k < count; k++) { for (k = 0; k < count; k++) {
buf[pos] = items[k].id; buf[pos] = items[k].id;
if (client->swapped) if (client->swapped)
swapl(buf + pos); swapl(buf + pos);
pos++; pos++;
buf[pos] = items[k].octx_len * 4; buf[pos] = items[k].octx_len * 4;
if (client->swapped) if (client->swapped)
swapl(buf + pos); swapl(buf + pos);
pos++; pos++;
buf[pos] = items[k].dctx_len * 4; buf[pos] = items[k].dctx_len * 4;
if (client->swapped) if (client->swapped)
swapl(buf + pos); swapl(buf + pos);
pos++; pos++;
memcpy((char *)(buf + pos), items[k].octx, strlen(items[k].octx) + 1); memcpy((char *) (buf + pos), items[k].octx, strlen(items[k].octx) + 1);
pos += items[k].octx_len; pos += items[k].octx_len;
memcpy((char *)(buf + pos), items[k].dctx, strlen(items[k].dctx) + 1); memcpy((char *) (buf + pos), items[k].dctx, strlen(items[k].dctx) + 1);
pos += items[k].dctx_len; pos += items[k].dctx_len;
} }
/* Send reply to client */ /* Send reply to client */
@ -377,18 +378,18 @@ SELinuxSendItemsToClient(ClientPtr client, SELinuxListItemRec *items,
rep.count = count; rep.count = count;
if (client->swapped) { if (client->swapped) {
swapl(&rep.length); swapl(&rep.length);
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swapl(&rep.count); swapl(&rep.count);
} }
WriteToClient(client, sizeof(SELinuxListItemsReply), (char *)&rep); WriteToClient(client, sizeof(SELinuxListItemsReply), (char *) &rep);
WriteToClient(client, size * 4, (char *)buf); WriteToClient(client, size * 4, (char *) buf);
/* Free stuff and return */ /* Free stuff and return */
rc = Success; rc = Success;
free(buf); free(buf);
out: out:
SELinuxFreeItems(items, count); SELinuxFreeItems(items, count);
return rc; return rc;
} }
@ -407,27 +408,27 @@ ProcSELinuxListProperties(ClientPtr client)
rc = dixLookupWindow(&pWin, stuff->id, client, DixListPropAccess); rc = dixLookupWindow(&pWin, stuff->id, client, DixListPropAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
/* Count the number of properties and allocate items */ /* Count the number of properties and allocate items */
count = 0; count = 0;
for (pProp = wUserProps(pWin); pProp; pProp = pProp->next) for (pProp = wUserProps(pWin); pProp; pProp = pProp->next)
count++; count++;
items = calloc(count, sizeof(SELinuxListItemRec)); items = calloc(count, sizeof(SELinuxListItemRec));
if (count && !items) if (count && !items)
return BadAlloc; return BadAlloc;
/* Fill in the items and calculate size */ /* Fill in the items and calculate size */
i = 0; i = 0;
size = 0; size = 0;
for (pProp = wUserProps(pWin); pProp; pProp = pProp->next) { for (pProp = wUserProps(pWin); pProp; pProp = pProp->next) {
id = pProp->propertyName; id = pProp->propertyName;
rc = SELinuxPopulateItem(items + i, &pProp->devPrivates, id, &size); rc = SELinuxPopulateItem(items + i, &pProp->devPrivates, id, &size);
if (rc != Success) { if (rc != Success) {
SELinuxFreeItems(items, count); SELinuxFreeItems(items, count);
return rc; return rc;
} }
i++; i++;
} }
return SELinuxSendItemsToClient(client, items, size, count); return SELinuxSendItemsToClient(client, items, size, count);
@ -446,22 +447,22 @@ ProcSELinuxListSelections(ClientPtr client)
/* Count the number of selections and allocate items */ /* Count the number of selections and allocate items */
count = 0; count = 0;
for (pSel = CurrentSelections; pSel; pSel = pSel->next) for (pSel = CurrentSelections; pSel; pSel = pSel->next)
count++; count++;
items = calloc(count, sizeof(SELinuxListItemRec)); items = calloc(count, sizeof(SELinuxListItemRec));
if (count && !items) if (count && !items)
return BadAlloc; return BadAlloc;
/* Fill in the items and calculate size */ /* Fill in the items and calculate size */
i = 0; i = 0;
size = 0; size = 0;
for (pSel = CurrentSelections; pSel; pSel = pSel->next) { for (pSel = CurrentSelections; pSel; pSel = pSel->next) {
id = pSel->selection; id = pSel->selection;
rc = SELinuxPopulateItem(items + i, &pSel->devPrivates, id, &size); rc = SELinuxPopulateItem(items + i, &pSel->devPrivates, id, &size);
if (rc != Success) { if (rc != Success) {
SELinuxFreeItems(items, count); SELinuxFreeItems(items, count);
return rc; return rc;
} }
i++; i++;
} }
return SELinuxSendItemsToClient(client, items, size, count); return SELinuxSendItemsToClient(client, items, size, count);
@ -473,53 +474,53 @@ ProcSELinuxDispatch(ClientPtr client)
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) { switch (stuff->data) {
case X_SELinuxQueryVersion: case X_SELinuxQueryVersion:
return ProcSELinuxQueryVersion(client); return ProcSELinuxQueryVersion(client);
case X_SELinuxSetDeviceCreateContext: case X_SELinuxSetDeviceCreateContext:
return ProcSELinuxSetCreateContext(client, CTX_DEV); return ProcSELinuxSetCreateContext(client, CTX_DEV);
case X_SELinuxGetDeviceCreateContext: case X_SELinuxGetDeviceCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_DEV); return ProcSELinuxGetCreateContext(client, CTX_DEV);
case X_SELinuxSetDeviceContext: case X_SELinuxSetDeviceContext:
return ProcSELinuxSetDeviceContext(client); return ProcSELinuxSetDeviceContext(client);
case X_SELinuxGetDeviceContext: case X_SELinuxGetDeviceContext:
return ProcSELinuxGetDeviceContext(client); return ProcSELinuxGetDeviceContext(client);
case X_SELinuxSetDrawableCreateContext: case X_SELinuxSetDrawableCreateContext:
return ProcSELinuxSetCreateContext(client, CTX_WIN); return ProcSELinuxSetCreateContext(client, CTX_WIN);
case X_SELinuxGetDrawableCreateContext: case X_SELinuxGetDrawableCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_WIN); return ProcSELinuxGetCreateContext(client, CTX_WIN);
case X_SELinuxGetDrawableContext: case X_SELinuxGetDrawableContext:
return ProcSELinuxGetDrawableContext(client); return ProcSELinuxGetDrawableContext(client);
case X_SELinuxSetPropertyCreateContext: case X_SELinuxSetPropertyCreateContext:
return ProcSELinuxSetCreateContext(client, CTX_PRP); return ProcSELinuxSetCreateContext(client, CTX_PRP);
case X_SELinuxGetPropertyCreateContext: case X_SELinuxGetPropertyCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_PRP); return ProcSELinuxGetCreateContext(client, CTX_PRP);
case X_SELinuxSetPropertyUseContext: case X_SELinuxSetPropertyUseContext:
return ProcSELinuxSetCreateContext(client, USE_PRP); return ProcSELinuxSetCreateContext(client, USE_PRP);
case X_SELinuxGetPropertyUseContext: case X_SELinuxGetPropertyUseContext:
return ProcSELinuxGetCreateContext(client, USE_PRP); return ProcSELinuxGetCreateContext(client, USE_PRP);
case X_SELinuxGetPropertyContext: case X_SELinuxGetPropertyContext:
return ProcSELinuxGetPropertyContext(client, objectKey); return ProcSELinuxGetPropertyContext(client, objectKey);
case X_SELinuxGetPropertyDataContext: case X_SELinuxGetPropertyDataContext:
return ProcSELinuxGetPropertyContext(client, dataKey); return ProcSELinuxGetPropertyContext(client, dataKey);
case X_SELinuxListProperties: case X_SELinuxListProperties:
return ProcSELinuxListProperties(client); return ProcSELinuxListProperties(client);
case X_SELinuxSetSelectionCreateContext: case X_SELinuxSetSelectionCreateContext:
return ProcSELinuxSetCreateContext(client, CTX_SEL); return ProcSELinuxSetCreateContext(client, CTX_SEL);
case X_SELinuxGetSelectionCreateContext: case X_SELinuxGetSelectionCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_SEL); return ProcSELinuxGetCreateContext(client, CTX_SEL);
case X_SELinuxSetSelectionUseContext: case X_SELinuxSetSelectionUseContext:
return ProcSELinuxSetCreateContext(client, USE_SEL); return ProcSELinuxSetCreateContext(client, USE_SEL);
case X_SELinuxGetSelectionUseContext: case X_SELinuxGetSelectionUseContext:
return ProcSELinuxGetCreateContext(client, USE_SEL); return ProcSELinuxGetCreateContext(client, USE_SEL);
case X_SELinuxGetSelectionContext: case X_SELinuxGetSelectionContext:
return ProcSELinuxGetSelectionContext(client, objectKey); return ProcSELinuxGetSelectionContext(client, objectKey);
case X_SELinuxGetSelectionDataContext: case X_SELinuxGetSelectionDataContext:
return ProcSELinuxGetSelectionContext(client, dataKey); return ProcSELinuxGetSelectionContext(client, dataKey);
case X_SELinuxListSelections: case X_SELinuxListSelections:
return ProcSELinuxListSelections(client); return ProcSELinuxListSelections(client);
case X_SELinuxGetClientContext: case X_SELinuxGetClientContext:
return ProcSELinuxGetClientContext(client); return ProcSELinuxGetClientContext(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
@ -620,63 +621,62 @@ SProcSELinuxDispatch(ClientPtr client)
switch (stuff->data) { switch (stuff->data) {
case X_SELinuxQueryVersion: case X_SELinuxQueryVersion:
return SProcSELinuxQueryVersion(client); return SProcSELinuxQueryVersion(client);
case X_SELinuxSetDeviceCreateContext: case X_SELinuxSetDeviceCreateContext:
return SProcSELinuxSetCreateContext(client, CTX_DEV); return SProcSELinuxSetCreateContext(client, CTX_DEV);
case X_SELinuxGetDeviceCreateContext: case X_SELinuxGetDeviceCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_DEV); return ProcSELinuxGetCreateContext(client, CTX_DEV);
case X_SELinuxSetDeviceContext: case X_SELinuxSetDeviceContext:
return SProcSELinuxSetDeviceContext(client); return SProcSELinuxSetDeviceContext(client);
case X_SELinuxGetDeviceContext: case X_SELinuxGetDeviceContext:
return SProcSELinuxGetDeviceContext(client); return SProcSELinuxGetDeviceContext(client);
case X_SELinuxSetDrawableCreateContext: case X_SELinuxSetDrawableCreateContext:
return SProcSELinuxSetCreateContext(client, CTX_WIN); return SProcSELinuxSetCreateContext(client, CTX_WIN);
case X_SELinuxGetDrawableCreateContext: case X_SELinuxGetDrawableCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_WIN); return ProcSELinuxGetCreateContext(client, CTX_WIN);
case X_SELinuxGetDrawableContext: case X_SELinuxGetDrawableContext:
return SProcSELinuxGetDrawableContext(client); return SProcSELinuxGetDrawableContext(client);
case X_SELinuxSetPropertyCreateContext: case X_SELinuxSetPropertyCreateContext:
return SProcSELinuxSetCreateContext(client, CTX_PRP); return SProcSELinuxSetCreateContext(client, CTX_PRP);
case X_SELinuxGetPropertyCreateContext: case X_SELinuxGetPropertyCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_PRP); return ProcSELinuxGetCreateContext(client, CTX_PRP);
case X_SELinuxSetPropertyUseContext: case X_SELinuxSetPropertyUseContext:
return SProcSELinuxSetCreateContext(client, USE_PRP); return SProcSELinuxSetCreateContext(client, USE_PRP);
case X_SELinuxGetPropertyUseContext: case X_SELinuxGetPropertyUseContext:
return ProcSELinuxGetCreateContext(client, USE_PRP); return ProcSELinuxGetCreateContext(client, USE_PRP);
case X_SELinuxGetPropertyContext: case X_SELinuxGetPropertyContext:
return SProcSELinuxGetPropertyContext(client, objectKey); return SProcSELinuxGetPropertyContext(client, objectKey);
case X_SELinuxGetPropertyDataContext: case X_SELinuxGetPropertyDataContext:
return SProcSELinuxGetPropertyContext(client, dataKey); return SProcSELinuxGetPropertyContext(client, dataKey);
case X_SELinuxListProperties: case X_SELinuxListProperties:
return SProcSELinuxListProperties(client); return SProcSELinuxListProperties(client);
case X_SELinuxSetSelectionCreateContext: case X_SELinuxSetSelectionCreateContext:
return SProcSELinuxSetCreateContext(client, CTX_SEL); return SProcSELinuxSetCreateContext(client, CTX_SEL);
case X_SELinuxGetSelectionCreateContext: case X_SELinuxGetSelectionCreateContext:
return ProcSELinuxGetCreateContext(client, CTX_SEL); return ProcSELinuxGetCreateContext(client, CTX_SEL);
case X_SELinuxSetSelectionUseContext: case X_SELinuxSetSelectionUseContext:
return SProcSELinuxSetCreateContext(client, USE_SEL); return SProcSELinuxSetCreateContext(client, USE_SEL);
case X_SELinuxGetSelectionUseContext: case X_SELinuxGetSelectionUseContext:
return ProcSELinuxGetCreateContext(client, USE_SEL); return ProcSELinuxGetCreateContext(client, USE_SEL);
case X_SELinuxGetSelectionContext: case X_SELinuxGetSelectionContext:
return SProcSELinuxGetSelectionContext(client, objectKey); return SProcSELinuxGetSelectionContext(client, objectKey);
case X_SELinuxGetSelectionDataContext: case X_SELinuxGetSelectionDataContext:
return SProcSELinuxGetSelectionContext(client, dataKey); return SProcSELinuxGetSelectionContext(client, dataKey);
case X_SELinuxListSelections: case X_SELinuxListSelections:
return ProcSELinuxListSelections(client); return ProcSELinuxListSelections(client);
case X_SELinuxGetClientContext: case X_SELinuxGetClientContext:
return SProcSELinuxGetClientContext(client); return SProcSELinuxGetClientContext(client);
default: default:
return BadRequest; return BadRequest;
} }
} }
/* /*
* Extension Setup / Teardown * Extension Setup / Teardown
*/ */
static void static void
SELinuxResetProc(ExtensionEntry *extEntry) SELinuxResetProc(ExtensionEntry * extEntry)
{ {
SELinuxFlaskReset(); SELinuxFlaskReset();
SELinuxLabelReset(); SELinuxLabelReset();
@ -689,15 +689,15 @@ SELinuxExtensionInit(INITARGS)
/* Check SELinux mode on system, configuration file, and boolean */ /* Check SELinux mode on system, configuration file, and boolean */
if (!is_selinux_enabled()) { if (!is_selinux_enabled()) {
LogMessage(X_INFO, "SELinux: Disabled on system\n"); LogMessage(X_INFO, "SELinux: Disabled on system\n");
return; return;
} }
if (selinuxEnforcingState == SELINUX_MODE_DISABLED) { if (selinuxEnforcingState == SELINUX_MODE_DISABLED) {
LogMessage(X_INFO, "SELinux: Disabled in configuration file\n"); LogMessage(X_INFO, "SELinux: Disabled in configuration file\n");
return; return;
} }
if (!security_get_boolean_active("xserver_object_manager")) { if (!security_get_boolean_active("xserver_object_manager")) {
LogMessage(X_INFO, "SELinux: Disabled by boolean\n"); LogMessage(X_INFO, "SELinux: Disabled by boolean\n");
return; return;
} }
@ -707,9 +707,9 @@ SELinuxExtensionInit(INITARGS)
/* Add extension to server */ /* Add extension to server */
extEntry = AddExtension(SELINUX_EXTENSION_NAME, extEntry = AddExtension(SELINUX_EXTENSION_NAME,
SELinuxNumberEvents, SELinuxNumberErrors, SELinuxNumberEvents, SELinuxNumberErrors,
ProcSELinuxDispatch, SProcSELinuxDispatch, ProcSELinuxDispatch, SProcSELinuxDispatch,
SELinuxResetProc, StandardMinorOpcode); SELinuxResetProc, StandardMinorOpcode);
AddExtensionAlias("Flask", extEntry); AddExtensionAlias("Flask", extEntry);
} }

638
Xext/xselinux_hooks.c
View File

File diff suppressed because it is too large Load Diff

235
Xext/xselinux_label.c
View File

@ -43,8 +43,10 @@ static struct selabel_handle *label_hnd;
/* Array of object classes indexed by resource type */ /* Array of object classes indexed by resource type */
SELinuxArrayRec arr_types; SELinuxArrayRec arr_types;
/* Array of event SIDs indexed by event type */ /* Array of event SIDs indexed by event type */
SELinuxArrayRec arr_events; SELinuxArrayRec arr_events;
/* Array of property and selection SID structures */ /* Array of property and selection SID structures */
SELinuxArrayRec arr_atoms; SELinuxArrayRec arr_atoms;
@ -52,21 +54,21 @@ SELinuxArrayRec arr_atoms;
* Dynamic array helpers * Dynamic array helpers
*/ */
static void * static void *
SELinuxArrayGet(SELinuxArrayRec *rec, unsigned key) SELinuxArrayGet(SELinuxArrayRec * rec, unsigned key)
{ {
return (rec->size > key) ? rec->array[key] : 0; return (rec->size > key) ? rec->array[key] : 0;
} }
static int static int
SELinuxArraySet(SELinuxArrayRec *rec, unsigned key, void *val) SELinuxArraySet(SELinuxArrayRec * rec, unsigned key, void *val)
{ {
if (key >= rec->size) { if (key >= rec->size) {
/* Need to increase size of array */ /* Need to increase size of array */
rec->array = realloc(rec->array, (key + 1) * sizeof(val)); rec->array = realloc(rec->array, (key + 1) * sizeof(val));
if (!rec->array) if (!rec->array)
return FALSE; return FALSE;
memset(rec->array + rec->size, 0, (key - rec->size + 1) * sizeof(val)); memset(rec->array + rec->size, 0, (key - rec->size + 1) * sizeof(val));
rec->size = key + 1; rec->size = key + 1;
} }
rec->array[key] = val; rec->array[key] = val;
@ -74,12 +76,13 @@ SELinuxArraySet(SELinuxArrayRec *rec, unsigned key, void *val)
} }
static void static void
SELinuxArrayFree(SELinuxArrayRec *rec, int free_elements) SELinuxArrayFree(SELinuxArrayRec * rec, int free_elements)
{ {
if (free_elements) { if (free_elements) {
unsigned i = rec->size; unsigned i = rec->size;
while (i)
free(rec->array[--i]); while (i)
free(rec->array[--i]);
} }
free(rec->array); free(rec->array);
@ -91,7 +94,7 @@ SELinuxArrayFree(SELinuxArrayRec *rec, int free_elements)
* Looks up a name in the selection or property mappings * Looks up a name in the selection or property mappings
*/ */
static int static int
SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap) SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec * obj, int map, int polymap)
{ {
const char *name = NameForAtom(atom); const char *name = NameForAtom(atom);
security_context_t ctx; security_context_t ctx;
@ -101,19 +104,21 @@ SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap)
/* Look in the mappings of names to contexts */ /* Look in the mappings of names to contexts */
if (selabel_lookup_raw(label_hnd, &ctx, name, map) == 0) { if (selabel_lookup_raw(label_hnd, &ctx, name, map) == 0) {
obj->poly = 0; obj->poly = 0;
} else if (errno != ENOENT) { }
ErrorF("SELinux: a property label lookup failed!\n"); else if (errno != ENOENT) {
return BadValue; ErrorF("SELinux: a property label lookup failed!\n");
} else if (selabel_lookup_raw(label_hnd, &ctx, name, polymap) < 0) { return BadValue;
ErrorF("SELinux: a property label lookup failed!\n"); }
return BadValue; else if (selabel_lookup_raw(label_hnd, &ctx, name, polymap) < 0) {
ErrorF("SELinux: a property label lookup failed!\n");
return BadValue;
} }
/* Get a SID for context */ /* Get a SID for context */
if (avc_context_to_sid_raw(ctx, &obj->sid) < 0) { if (avc_context_to_sid_raw(ctx, &obj->sid) < 0) {
ErrorF("SELinux: a context_to_SID_raw call failed!\n"); ErrorF("SELinux: a context_to_SID_raw call failed!\n");
rc = BadAlloc; rc = BadAlloc;
} }
freecon(ctx); freecon(ctx);
@ -124,7 +129,7 @@ SELinuxAtomToSIDLookup(Atom atom, SELinuxObjectRec *obj, int map, int polymap)
* Looks up the SID corresponding to the given property or selection atom * Looks up the SID corresponding to the given property or selection atom
*/ */
int int
SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn) SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec ** obj_rtn)
{ {
SELinuxAtomRec *rec; SELinuxAtomRec *rec;
SELinuxObjectRec *obj; SELinuxObjectRec *obj;
@ -132,30 +137,31 @@ SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn)
rec = SELinuxArrayGet(&arr_atoms, atom); rec = SELinuxArrayGet(&arr_atoms, atom);
if (!rec) { if (!rec) {
rec = calloc(1, sizeof(SELinuxAtomRec)); rec = calloc(1, sizeof(SELinuxAtomRec));
if (!rec || !SELinuxArraySet(&arr_atoms, atom, rec)) if (!rec || !SELinuxArraySet(&arr_atoms, atom, rec))
return BadAlloc; return BadAlloc;
} }
if (prop) { if (prop) {
obj = &rec->prp; obj = &rec->prp;
map = SELABEL_X_PROP; map = SELABEL_X_PROP;
polymap = SELABEL_X_POLYPROP; polymap = SELABEL_X_POLYPROP;
} else { }
obj = &rec->sel; else {
map = SELABEL_X_SELN; obj = &rec->sel;
polymap = SELABEL_X_POLYSELN; map = SELABEL_X_SELN;
polymap = SELABEL_X_POLYSELN;
} }
if (!obj->sid) { if (!obj->sid) {
rc = SELinuxAtomToSIDLookup(atom, obj, map, polymap); rc = SELinuxAtomToSIDLookup(atom, obj, map, polymap);
if (rc != Success) if (rc != Success)
goto out; goto out;
} }
*obj_rtn = obj; *obj_rtn = obj;
rc = Success; rc = Success;
out: out:
return rc; return rc;
} }
@ -163,8 +169,8 @@ out:
* Looks up a SID for a selection/subject pair * Looks up a SID for a selection/subject pair
*/ */
int int
SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj, SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec * subj,
security_id_t *sid_rtn, int *poly_rtn) security_id_t * sid_rtn, int *poly_rtn)
{ {
int rc; int rc;
SELinuxObjectRec *obj; SELinuxObjectRec *obj;
@ -173,26 +179,26 @@ SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj,
/* Get the default context and polyinstantiation bit */ /* Get the default context and polyinstantiation bit */
rc = SELinuxAtomToSID(selection, 0, &obj); rc = SELinuxAtomToSID(selection, 0, &obj);
if (rc != Success) if (rc != Success)
return rc; return rc;
/* Check for an override context next */ /* Check for an override context next */
if (subj->sel_use_sid) { if (subj->sel_use_sid) {
tsid = subj->sel_use_sid; tsid = subj->sel_use_sid;
goto out; goto out;
} }
tsid = obj->sid; tsid = obj->sid;
/* Polyinstantiate if necessary to obtain the final SID */ /* Polyinstantiate if necessary to obtain the final SID */
if (obj->poly && avc_compute_member(subj->sid, obj->sid, if (obj->poly && avc_compute_member(subj->sid, obj->sid,
SECCLASS_X_SELECTION, &tsid) < 0) { SECCLASS_X_SELECTION, &tsid) < 0) {
ErrorF("SELinux: a compute_member call failed!\n"); ErrorF("SELinux: a compute_member call failed!\n");
return BadValue; return BadValue;
} }
out: out:
*sid_rtn = tsid; *sid_rtn = tsid;
if (poly_rtn) if (poly_rtn)
*poly_rtn = obj->poly; *poly_rtn = obj->poly;
return Success; return Success;
} }
@ -200,8 +206,8 @@ out:
* Looks up a SID for a property/subject pair * Looks up a SID for a property/subject pair
*/ */
int int
SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj, SELinuxPropertyToSID(Atom property, SELinuxSubjectRec * subj,
security_id_t *sid_rtn, int *poly_rtn) security_id_t * sid_rtn, int *poly_rtn)
{ {
int rc; int rc;
SELinuxObjectRec *obj; SELinuxObjectRec *obj;
@ -210,34 +216,33 @@ SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj,
/* Get the default context and polyinstantiation bit */ /* Get the default context and polyinstantiation bit */
rc = SELinuxAtomToSID(property, 1, &obj); rc = SELinuxAtomToSID(property, 1, &obj);
if (rc != Success) if (rc != Success)
return rc; return rc;
/* Check for an override context next */ /* Check for an override context next */
if (subj->prp_use_sid) { if (subj->prp_use_sid) {
tsid = subj->prp_use_sid; tsid = subj->prp_use_sid;
goto out; goto out;
} }
/* Perform a transition */ /* Perform a transition */
if (avc_compute_create(subj->sid, obj->sid, if (avc_compute_create(subj->sid, obj->sid, SECCLASS_X_PROPERTY, &tsid) < 0) {
SECCLASS_X_PROPERTY, &tsid) < 0) { ErrorF("SELinux: a compute_create call failed!\n");
ErrorF("SELinux: a compute_create call failed!\n"); return BadValue;
return BadValue;
} }
/* Polyinstantiate if necessary to obtain the final SID */ /* Polyinstantiate if necessary to obtain the final SID */
if (obj->poly) { if (obj->poly) {
tsid2 = tsid; tsid2 = tsid;
if (avc_compute_member(subj->sid, tsid2, if (avc_compute_member(subj->sid, tsid2,
SECCLASS_X_PROPERTY, &tsid) < 0) { SECCLASS_X_PROPERTY, &tsid) < 0) {
ErrorF("SELinux: a compute_member call failed!\n"); ErrorF("SELinux: a compute_member call failed!\n");
return BadValue; return BadValue;
} }
} }
out: out:
*sid_rtn = tsid; *sid_rtn = tsid;
if (poly_rtn) if (poly_rtn)
*poly_rtn = obj->poly; *poly_rtn = obj->poly;
return Success; return Success;
} }
@ -246,57 +251,58 @@ out:
*/ */
int int
SELinuxEventToSID(unsigned type, security_id_t sid_of_window, SELinuxEventToSID(unsigned type, security_id_t sid_of_window,
SELinuxObjectRec *sid_return) SELinuxObjectRec * sid_return)
{ {
const char *name = LookupEventName(type); const char *name = LookupEventName(type);
security_id_t sid; security_id_t sid;
security_context_t ctx; security_context_t ctx;
type &= 127; type &= 127;
sid = SELinuxArrayGet(&arr_events, type); sid = SELinuxArrayGet(&arr_events, type);
if (!sid) { if (!sid) {
/* Look in the mappings of event names to contexts */ /* Look in the mappings of event names to contexts */
if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EVENT) < 0) { if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EVENT) < 0) {
ErrorF("SELinux: an event label lookup failed!\n"); ErrorF("SELinux: an event label lookup failed!\n");
return BadValue; return BadValue;
} }
/* Get a SID for context */ /* Get a SID for context */
if (avc_context_to_sid_raw(ctx, &sid) < 0) { if (avc_context_to_sid_raw(ctx, &sid) < 0) {
ErrorF("SELinux: a context_to_SID_raw call failed!\n"); ErrorF("SELinux: a context_to_SID_raw call failed!\n");
freecon(ctx); freecon(ctx);
return BadAlloc; return BadAlloc;
} }
freecon(ctx); freecon(ctx);
/* Cache the SID value */ /* Cache the SID value */
if (!SELinuxArraySet(&arr_events, type, sid)) if (!SELinuxArraySet(&arr_events, type, sid))
return BadAlloc; return BadAlloc;
} }
/* Perform a transition to obtain the final SID */ /* Perform a transition to obtain the final SID */
if (avc_compute_create(sid_of_window, sid, SECCLASS_X_EVENT, if (avc_compute_create(sid_of_window, sid, SECCLASS_X_EVENT,
&sid_return->sid) < 0) { &sid_return->sid) < 0) {
ErrorF("SELinux: a compute_create call failed!\n"); ErrorF("SELinux: a compute_create call failed!\n");
return BadValue; return BadValue;
} }
return Success; return Success;
} }
int int
SELinuxExtensionToSID(const char *name, security_id_t *sid_rtn) SELinuxExtensionToSID(const char *name, security_id_t * sid_rtn)
{ {
security_context_t ctx; security_context_t ctx;
/* Look in the mappings of extension names to contexts */ /* Look in the mappings of extension names to contexts */
if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EXT) < 0) { if (selabel_lookup_raw(label_hnd, &ctx, name, SELABEL_X_EXT) < 0) {
ErrorF("SELinux: a property label lookup failed!\n"); ErrorF("SELinux: a property label lookup failed!\n");
return BadValue; return BadValue;
} }
/* Get a SID for context */ /* Get a SID for context */
if (avc_context_to_sid_raw(ctx, sid_rtn) < 0) { if (avc_context_to_sid_raw(ctx, sid_rtn) < 0) {
ErrorF("SELinux: a context_to_SID_raw call failed!\n"); ErrorF("SELinux: a context_to_SID_raw call failed!\n");
freecon(ctx); freecon(ctx);
return BadAlloc; return BadAlloc;
} }
freecon(ctx); freecon(ctx);
return Success; return Success;
@ -312,32 +318,33 @@ SELinuxTypeToClass(RESTYPE type)
tmp = SELinuxArrayGet(&arr_types, type & TypeMask); tmp = SELinuxArrayGet(&arr_types, type & TypeMask);
if (!tmp) { if (!tmp) {
unsigned long class = SECCLASS_X_RESOURCE; unsigned long class = SECCLASS_X_RESOURCE;
if (type & RC_DRAWABLE) if (type & RC_DRAWABLE)
class = SECCLASS_X_DRAWABLE; class = SECCLASS_X_DRAWABLE;
else if (type == RT_GC) else if (type == RT_GC)
class = SECCLASS_X_GC; class = SECCLASS_X_GC;
else if (type == RT_FONT) else if (type == RT_FONT)
class = SECCLASS_X_FONT; class = SECCLASS_X_FONT;
else if (type == RT_CURSOR) else if (type == RT_CURSOR)
class = SECCLASS_X_CURSOR; class = SECCLASS_X_CURSOR;
else if (type == RT_COLORMAP) else if (type == RT_COLORMAP)
class = SECCLASS_X_COLORMAP; class = SECCLASS_X_COLORMAP;
else { else {
/* Need to do a string lookup */ /* Need to do a string lookup */
const char *str = LookupResourceName(type); const char *str = LookupResourceName(type);
if (!strcmp(str, "PICTURE"))
class = SECCLASS_X_DRAWABLE;
else if (!strcmp(str, "GLYPHSET"))
class = SECCLASS_X_FONT;
}
tmp = (void *)class; if (!strcmp(str, "PICTURE"))
SELinuxArraySet(&arr_types, type & TypeMask, tmp); class = SECCLASS_X_DRAWABLE;
else if (!strcmp(str, "GLYPHSET"))
class = SECCLASS_X_FONT;
}
tmp = (void *) class;
SELinuxArraySet(&arr_types, type & TypeMask, tmp);
} }
return (security_class_t)(unsigned long)tmp; return (security_class_t) (unsigned long) tmp;
} }
security_context_t security_context_t
@ -346,7 +353,7 @@ SELinuxDefaultClientLabel(void)
security_context_t ctx; security_context_t ctx;
if (selabel_lookup_raw(label_hnd, &ctx, "remote", SELABEL_X_CLIENT) < 0) if (selabel_lookup_raw(label_hnd, &ctx, "remote", SELABEL_X_CLIENT) < 0)
FatalError("SELinux: failed to look up remote-client context\n"); FatalError("SELinux: failed to look up remote-client context\n");
return ctx; return ctx;
} }
@ -354,11 +361,11 @@ SELinuxDefaultClientLabel(void)
void void
SELinuxLabelInit(void) SELinuxLabelInit(void)
{ {
struct selinux_opt selabel_option = { SELABEL_OPT_VALIDATE, (char *)1 }; struct selinux_opt selabel_option = { SELABEL_OPT_VALIDATE, (char *) 1 };
label_hnd = selabel_open(SELABEL_CTX_X, &selabel_option, 1); label_hnd = selabel_open(SELABEL_CTX_X, &selabel_option, 1);
if (!label_hnd) if (!label_hnd)
FatalError("SELinux: Failed to open x_contexts mapping in policy\n"); FatalError("SELinux: Failed to open x_contexts mapping in policy\n");
} }
void void

859
Xext/xselinuxint.h
View File

@ -63,10 +63,13 @@ typedef struct {
*/ */
extern DevPrivateKeyRec subjectKeyRec; extern DevPrivateKeyRec subjectKeyRec;
#define subjectKey (&subjectKeyRec) #define subjectKey (&subjectKeyRec)
extern DevPrivateKeyRec objectKeyRec; extern DevPrivateKeyRec objectKeyRec;
#define objectKey (&objectKeyRec) #define objectKey (&objectKeyRec)
extern DevPrivateKeyRec dataKeyRec; extern DevPrivateKeyRec dataKeyRec;
#define dataKey (&dataKeyRec) #define dataKey (&dataKeyRec)
/* /*
@ -74,45 +77,45 @@ extern DevPrivateKeyRec dataKeyRec;
*/ */
int int
SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec **obj_rtn); SELinuxAtomToSID(Atom atom, int prop, SELinuxObjectRec ** obj_rtn);
int int
SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec *subj,
security_id_t *sid_rtn, int *poly_rtn); SELinuxSelectionToSID(Atom selection, SELinuxSubjectRec * subj,
security_id_t * sid_rtn, int *poly_rtn);
int int
SELinuxPropertyToSID(Atom property, SELinuxSubjectRec *subj,
security_id_t *sid_rtn, int *poly_rtn); SELinuxPropertyToSID(Atom property, SELinuxSubjectRec * subj,
security_id_t * sid_rtn, int *poly_rtn);
int int
SELinuxEventToSID(unsigned type, security_id_t sid_of_window, SELinuxEventToSID(unsigned type, security_id_t sid_of_window,
SELinuxObjectRec *sid_return); SELinuxObjectRec * sid_return);
int int
SELinuxExtensionToSID(const char *name, security_id_t *sid_rtn); SELinuxExtensionToSID(const char *name, security_id_t * sid_rtn);
security_class_t security_class_t SELinuxTypeToClass(RESTYPE type);
SELinuxTypeToClass(RESTYPE type);
security_context_t security_context_t SELinuxDefaultClientLabel(void);
SELinuxDefaultClientLabel(void);
void void
SELinuxLabelInit(void); SELinuxLabelInit(void);
void void
SELinuxLabelReset(void); SELinuxLabelReset(void);
/* /*
* Security module functions * Security module functions
*/ */
void void
SELinuxFlaskInit(void); SELinuxFlaskInit(void);
void void
SELinuxFlaskReset(void); SELinuxFlaskReset(void);
/* /*
* Private Flask definitions * Private Flask definitions
@ -139,416 +142,416 @@ SELinuxFlaskReset(void);
#ifdef _XSELINUX_NEED_FLASK_MAP #ifdef _XSELINUX_NEED_FLASK_MAP
/* Mapping from DixAccess bits to Flask permissions */ /* Mapping from DixAccess bits to Flask permissions */
static struct security_class_mapping map[] = { static struct security_class_mapping map[] = {
{ "x_drawable", {"x_drawable",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"list_property", /* DixListPropAccess */ "list_property", /* DixListPropAccess */
"get_property", /* DixGetPropAccess */ "get_property", /* DixGetPropAccess */
"set_property", /* DixSetPropAccess */ "set_property", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"list_child", /* DixListAccess */ "list_child", /* DixListAccess */
"add_child", /* DixAddAccess */ "add_child", /* DixAddAccess */
"remove_child", /* DixRemoveAccess */ "remove_child", /* DixRemoveAccess */
"hide", /* DixHideAccess */ "hide", /* DixHideAccess */
"show", /* DixShowAccess */ "show", /* DixShowAccess */
"blend", /* DixBlendAccess */ "blend", /* DixBlendAccess */
"override", /* DixGrabAccess */ "override", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"send", /* DixSendAccess */ "send", /* DixSendAccess */
"receive", /* DixReceiveAccess */ "receive", /* DixReceiveAccess */
"", /* DixUseAccess */ "", /* DixUseAccess */
"manage", /* DixManageAccess */ "manage", /* DixManageAccess */
NULL }}, NULL}},
{ "x_screen", {"x_screen",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"saver_getattr", /* DixListPropAccess */ "saver_getattr", /* DixListPropAccess */
"saver_setattr", /* DixGetPropAccess */ "saver_setattr", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"hide_cursor", /* DixHideAccess */ "hide_cursor", /* DixHideAccess */
"show_cursor", /* DixShowAccess */ "show_cursor", /* DixShowAccess */
"saver_hide", /* DixBlendAccess */ "saver_hide", /* DixBlendAccess */
"saver_show", /* DixGrabAccess */ "saver_show", /* DixGrabAccess */
NULL }}, NULL}},
{ "x_gc", {"x_gc",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
NULL }}, NULL}},
{ "x_font", {"x_font",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"", /* DixSetAttrAccess */ "", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"add_glyph", /* DixAddAccess */ "add_glyph", /* DixAddAccess */
"remove_glyph", /* DixRemoveAccess */ "remove_glyph", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
NULL }}, NULL}},
{ "x_colormap", {"x_colormap",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"", /* DixSetAttrAccess */ "", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"add_color", /* DixAddAccess */ "add_color", /* DixAddAccess */
"remove_color", /* DixRemoveAccess */ "remove_color", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"install", /* DixInstallAccess */ "install", /* DixInstallAccess */
"uninstall", /* DixUninstallAccess */ "uninstall", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
NULL }}, NULL}},
{ "x_property", {"x_property",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"write", /* DixBlendAccess */ "write", /* DixBlendAccess */
NULL }}, NULL}},
{ "x_selection", {"x_selection",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"setattr", /* DixCreateAccess */ "setattr", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
NULL }}, NULL}},
{ "x_cursor", {"x_cursor",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
NULL }}, NULL}},
{ "x_client", {"x_client",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"", /* DixUseAccess */ "", /* DixUseAccess */
"manage", /* DixManageAccess */ "manage", /* DixManageAccess */
NULL }}, NULL}},
{ "x_pointer", {"x_pointer",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"list_property", /* DixListPropAccess */ "list_property", /* DixListPropAccess */
"get_property", /* DixGetPropAccess */ "get_property", /* DixGetPropAccess */
"set_property", /* DixSetPropAccess */ "set_property", /* DixSetPropAccess */
"getfocus", /* DixGetFocusAccess */ "getfocus", /* DixGetFocusAccess */
"setfocus", /* DixSetFocusAccess */ "setfocus", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"add", /* DixAddAccess */ "add", /* DixAddAccess */
"remove", /* DixRemoveAccess */ "remove", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"grab", /* DixGrabAccess */ "grab", /* DixGrabAccess */
"freeze", /* DixFreezeAccess */ "freeze", /* DixFreezeAccess */
"force_cursor", /* DixForceAccess */ "force_cursor", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
"manage", /* DixManageAccess */ "manage", /* DixManageAccess */
"", /* DixDebugAccess */ "", /* DixDebugAccess */
"bell", /* DixBellAccess */ "bell", /* DixBellAccess */
NULL }}, NULL}},
{ "x_keyboard", {"x_keyboard",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"destroy", /* DixDestroyAccess */ "destroy", /* DixDestroyAccess */
"create", /* DixCreateAccess */ "create", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"list_property", /* DixListPropAccess */ "list_property", /* DixListPropAccess */
"get_property", /* DixGetPropAccess */ "get_property", /* DixGetPropAccess */
"set_property", /* DixSetPropAccess */ "set_property", /* DixSetPropAccess */
"getfocus", /* DixGetFocusAccess */ "getfocus", /* DixGetFocusAccess */
"setfocus", /* DixSetFocusAccess */ "setfocus", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"add", /* DixAddAccess */ "add", /* DixAddAccess */
"remove", /* DixRemoveAccess */ "remove", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"grab", /* DixGrabAccess */ "grab", /* DixGrabAccess */
"freeze", /* DixFreezeAccess */ "freeze", /* DixFreezeAccess */
"force_cursor", /* DixForceAccess */ "force_cursor", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
"manage", /* DixManageAccess */ "manage", /* DixManageAccess */
"", /* DixDebugAccess */ "", /* DixDebugAccess */
"bell", /* DixBellAccess */ "bell", /* DixBellAccess */
NULL }}, NULL}},
{ "x_server", {"x_server",
{ "record", /* DixReadAccess */ {"record", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"getattr", /* DixGetAttrAccess */ "getattr", /* DixGetAttrAccess */
"setattr", /* DixSetAttrAccess */ "setattr", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"grab", /* DixGrabAccess */ "grab", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"", /* DixUseAccess */ "", /* DixUseAccess */
"manage", /* DixManageAccess */ "manage", /* DixManageAccess */
"debug", /* DixDebugAccess */ "debug", /* DixDebugAccess */
NULL }}, NULL}},
{ "x_extension", {"x_extension",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"query", /* DixGetAttrAccess */ "query", /* DixGetAttrAccess */
"", /* DixSetAttrAccess */ "", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"", /* DixSendAccess */ "", /* DixSendAccess */
"", /* DixReceiveAccess */ "", /* DixReceiveAccess */
"use", /* DixUseAccess */ "use", /* DixUseAccess */
NULL }}, NULL}},
{ "x_event", {"x_event",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"", /* DixGetAttrAccess */ "", /* DixGetAttrAccess */
"", /* DixSetAttrAccess */ "", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"send", /* DixSendAccess */ "send", /* DixSendAccess */
"receive", /* DixReceiveAccess */ "receive", /* DixReceiveAccess */
NULL }}, NULL}},
{ "x_synthetic_event", {"x_synthetic_event",
{ "", /* DixReadAccess */ {"", /* DixReadAccess */
"", /* DixWriteAccess */ "", /* DixWriteAccess */
"", /* DixDestroyAccess */ "", /* DixDestroyAccess */
"", /* DixCreateAccess */ "", /* DixCreateAccess */
"", /* DixGetAttrAccess */ "", /* DixGetAttrAccess */
"", /* DixSetAttrAccess */ "", /* DixSetAttrAccess */
"", /* DixListPropAccess */ "", /* DixListPropAccess */
"", /* DixGetPropAccess */ "", /* DixGetPropAccess */
"", /* DixSetPropAccess */ "", /* DixSetPropAccess */
"", /* DixGetFocusAccess */ "", /* DixGetFocusAccess */
"", /* DixSetFocusAccess */ "", /* DixSetFocusAccess */
"", /* DixListAccess */ "", /* DixListAccess */
"", /* DixAddAccess */ "", /* DixAddAccess */
"", /* DixRemoveAccess */ "", /* DixRemoveAccess */
"", /* DixHideAccess */ "", /* DixHideAccess */
"", /* DixShowAccess */ "", /* DixShowAccess */
"", /* DixBlendAccess */ "", /* DixBlendAccess */
"", /* DixGrabAccess */ "", /* DixGrabAccess */
"", /* DixFreezeAccess */ "", /* DixFreezeAccess */
"", /* DixForceAccess */ "", /* DixForceAccess */
"", /* DixInstallAccess */ "", /* DixInstallAccess */
"", /* DixUninstallAccess */ "", /* DixUninstallAccess */
"send", /* DixSendAccess */ "send", /* DixSendAccess */
"receive", /* DixReceiveAccess */ "receive", /* DixReceiveAccess */
NULL }}, NULL}},
{ "x_resource", {"x_resource",
{ "read", /* DixReadAccess */ {"read", /* DixReadAccess */
"write", /* DixWriteAccess */ "write", /* DixWriteAccess */
"write", /* DixDestroyAccess */ "write", /* DixDestroyAccess */
"write", /* DixCreateAccess */ "write", /* DixCreateAccess */
"read", /* DixGetAttrAccess */ "read", /* DixGetAttrAccess */
"write", /* DixSetAttrAccess */ "write", /* DixSetAttrAccess */
"read", /* DixListPropAccess */ "read", /* DixListPropAccess */
"read", /* DixGetPropAccess */ "read", /* DixGetPropAccess */
"write", /* DixSetPropAccess */ "write", /* DixSetPropAccess */
"read", /* DixGetFocusAccess */ "read", /* DixGetFocusAccess */
"write", /* DixSetFocusAccess */ "write", /* DixSetFocusAccess */
"read", /* DixListAccess */ "read", /* DixListAccess */
"write", /* DixAddAccess */ "write", /* DixAddAccess */
"write", /* DixRemoveAccess */ "write", /* DixRemoveAccess */
"write", /* DixHideAccess */ "write", /* DixHideAccess */
"read", /* DixShowAccess */ "read", /* DixShowAccess */
"read", /* DixBlendAccess */ "read", /* DixBlendAccess */
"write", /* DixGrabAccess */ "write", /* DixGrabAccess */
"write", /* DixFreezeAccess */ "write", /* DixFreezeAccess */
"write", /* DixForceAccess */ "write", /* DixForceAccess */
"write", /* DixInstallAccess */ "write", /* DixInstallAccess */
"write", /* DixUninstallAccess */ "write", /* DixUninstallAccess */
"write", /* DixSendAccess */ "write", /* DixSendAccess */
"read", /* DixReceiveAccess */ "read", /* DixReceiveAccess */
"read", /* DixUseAccess */ "read", /* DixUseAccess */
"write", /* DixManageAccess */ "write", /* DixManageAccess */
"read", /* DixDebugAccess */ "read", /* DixDebugAccess */
"write", /* DixBellAccess */ "write", /* DixBellAccess */
NULL }}, NULL}},
{ NULL } {NULL}
}; };
/* x_resource "read" bits from the list above */ /* x_resource "read" bits from the list above */
@ -557,5 +560,5 @@ static struct security_class_mapping map[] = {
DixShowAccess|DixBlendAccess|DixReceiveAccess| \ DixShowAccess|DixBlendAccess|DixReceiveAccess| \
DixUseAccess|DixDebugAccess) DixUseAccess|DixDebugAccess)
#endif /* _XSELINUX_NEED_FLASK_MAP */ #endif /* _XSELINUX_NEED_FLASK_MAP */
#endif /* _XSELINUXINT_H */ #endif /* _XSELINUXINT_H */

461
Xext/xtest.c
View File

@ -62,7 +62,7 @@ extern int DeviceValuator;
/* XTest events are sent during request processing and may be interruped by /* XTest events are sent during request processing and may be interruped by
* a SIGIO. We need a separate event list to avoid events overwriting each * a SIGIO. We need a separate event list to avoid events overwriting each
* other's memory */ * other's memory */
static InternalEvent* xtest_evlist; static InternalEvent *xtest_evlist;
/** /**
* xtestpointer * xtestpointer
@ -81,11 +81,9 @@ DeviceIntPtr xtestpointer, xtestkeyboard;
#include "panoramiXsrv.h" #include "panoramiXsrv.h"
#endif #endif
static int XTestSwapFakeInput( static int XTestSwapFakeInput(ClientPtr /* client */ ,
ClientPtr /* client */, xReq * /* req */
xReq * /* req */ );
);
static int static int
ProcXTestGetVersion(ClientPtr client) ProcXTestGetVersion(ClientPtr client)
@ -102,7 +100,7 @@ ProcXTestGetVersion(ClientPtr client)
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
swaps(&rep.minorVersion); swaps(&rep.minorVersion);
} }
WriteToClient(client, sizeof(xXTestGetVersionReply), (char *)&rep); WriteToClient(client, sizeof(xXTestGetVersionReply), (char *) &rep);
return Success; return Success;
} }
@ -125,10 +123,9 @@ ProcXTestCompareCursor(ClientPtr client)
else if (stuff->cursor == XTestCurrentCursor) else if (stuff->cursor == XTestCurrentCursor)
pCursor = GetSpriteCursor(ptr); pCursor = GetSpriteCursor(ptr);
else { else {
rc = dixLookupResourceByType((pointer *)&pCursor, stuff->cursor, RT_CURSOR, rc = dixLookupResourceByType((pointer *) &pCursor, stuff->cursor,
client, DixReadAccess); RT_CURSOR, client, DixReadAccess);
if (rc != Success) if (rc != Success) {
{
client->errorValue = stuff->cursor; client->errorValue = stuff->cursor;
return rc; return rc;
} }
@ -140,7 +137,7 @@ ProcXTestCompareCursor(ClientPtr client)
if (client->swapped) { if (client->swapped) {
swaps(&rep.sequenceNumber); swaps(&rep.sequenceNumber);
} }
WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *)&rep); WriteToClient(client, sizeof(xXTestCompareCursorReply), (char *) &rep);
return Success; return Success;
} }
@ -155,7 +152,7 @@ ProcXTestFakeInput(ClientPtr client)
Bool extension = FALSE; Bool extension = FALSE;
deviceValuator *dv = NULL; deviceValuator *dv = NULL;
ValuatorMask mask; ValuatorMask mask;
int valuators[MAX_VALUATORS] = {0}; int valuators[MAX_VALUATORS] = { 0 };
int numValuators = 0; int numValuators = 0;
int firstValuator = 0; int firstValuator = 0;
int nevents = 0; int nevents = 0;
@ -169,18 +166,16 @@ ProcXTestFakeInput(ClientPtr client)
return BadLength; return BadLength;
nev /= sizeof(xEvent); nev /= sizeof(xEvent);
UpdateCurrentTime(); UpdateCurrentTime();
ev = (xEvent *)&((xReq *)stuff)[1]; ev = (xEvent *) &((xReq *) stuff)[1];
type = ev->u.u.type & 0177; type = ev->u.u.type & 0177;
if (type >= EXTENSION_EVENT_BASE) if (type >= EXTENSION_EVENT_BASE) {
{
extension = TRUE; extension = TRUE;
/* check device */ /* check device */
rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client, rc = dixLookupDevice(&dev, stuff->deviceid & 0177, client,
DixWriteAccess); DixWriteAccess);
if (rc != Success) if (rc != Success) {
{
client->errorValue = stuff->deviceid & 0177; client->errorValue = stuff->deviceid & 0177;
return rc; return rc;
} }
@ -188,144 +183,135 @@ ProcXTestFakeInput(ClientPtr client)
/* check type */ /* check type */
type -= DeviceValuator; type -= DeviceValuator;
switch (type) { switch (type) {
case XI_DeviceKeyPress: case XI_DeviceKeyPress:
case XI_DeviceKeyRelease: case XI_DeviceKeyRelease:
if (!dev->key) if (!dev->key) {
{
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_DeviceButtonPress:
case XI_DeviceButtonRelease:
if (!dev->button)
{
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_DeviceMotionNotify:
if (!dev->valuator)
{
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_ProximityIn:
case XI_ProximityOut:
if (!dev->proximity)
{
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
default:
client->errorValue = ev->u.u.type; client->errorValue = ev->u.u.type;
return BadValue; return BadValue;
}
break;
case XI_DeviceButtonPress:
case XI_DeviceButtonRelease:
if (!dev->button) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_DeviceMotionNotify:
if (!dev->valuator) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
case XI_ProximityIn:
case XI_ProximityOut:
if (!dev->proximity) {
client->errorValue = ev->u.u.type;
return BadValue;
}
break;
default:
client->errorValue = ev->u.u.type;
return BadValue;
} }
/* check validity */ /* check validity */
if (nev == 1 && type == XI_DeviceMotionNotify) if (nev == 1 && type == XI_DeviceMotionNotify)
return BadLength; /* DevMotion must be followed by DevValuator */ return BadLength; /* DevMotion must be followed by DevValuator */
if (type == XI_DeviceMotionNotify) if (type == XI_DeviceMotionNotify) {
{ firstValuator = ((deviceValuator *) (ev + 1))->first_valuator;
firstValuator = ((deviceValuator *)(ev+1))->first_valuator; if (firstValuator > dev->valuator->numAxes) {
if (firstValuator > dev->valuator->numAxes)
{
client->errorValue = ev->u.u.type; client->errorValue = ev->u.u.type;
return BadValue; return BadValue;
} }
if (ev->u.u.detail == xFalse) if (ev->u.u.detail == xFalse)
flags |= POINTER_ABSOLUTE; flags |= POINTER_ABSOLUTE;
} else }
{ else {
firstValuator = 0; firstValuator = 0;
flags |= POINTER_ABSOLUTE; flags |= POINTER_ABSOLUTE;
} }
if (nev > 1 && !dev->valuator) if (nev > 1 && !dev->valuator) {
{
client->errorValue = dv->first_valuator; client->errorValue = dv->first_valuator;
return BadValue; return BadValue;
} }
/* check validity of valuator events */ /* check validity of valuator events */
base = firstValuator; base = firstValuator;
for (n = 1; n < nev; n++) for (n = 1; n < nev; n++) {
{ dv = (deviceValuator *) (ev + n);
dv = (deviceValuator *)(ev + n); if (dv->type != DeviceValuator) {
if (dv->type != DeviceValuator)
{
client->errorValue = dv->type; client->errorValue = dv->type;
return BadValue; return BadValue;
} }
if (dv->first_valuator != base) if (dv->first_valuator != base) {
{
client->errorValue = dv->first_valuator; client->errorValue = dv->first_valuator;
return BadValue; return BadValue;
} }
switch(dv->num_valuators) switch (dv->num_valuators) {
{ case 6:
case 6: valuators[base + 5] = dv->valuator5; valuators[base + 5] = dv->valuator5;
case 5: valuators[base + 4] = dv->valuator4; case 5:
case 4: valuators[base + 3] = dv->valuator3; valuators[base + 4] = dv->valuator4;
case 3: valuators[base + 2] = dv->valuator2; case 4:
case 2: valuators[base + 1] = dv->valuator1; valuators[base + 3] = dv->valuator3;
case 1: valuators[base] = dv->valuator0; case 3:
break; valuators[base + 2] = dv->valuator2;
default: case 2:
client->errorValue = dv->num_valuators; valuators[base + 1] = dv->valuator1;
return BadValue; case 1:
valuators[base] = dv->valuator0;
break;
default:
client->errorValue = dv->num_valuators;
return BadValue;
} }
base += dv->num_valuators; base += dv->num_valuators;
numValuators += dv->num_valuators; numValuators += dv->num_valuators;
if (firstValuator + numValuators > dev->valuator->numAxes) if (firstValuator + numValuators > dev->valuator->numAxes) {
{
client->errorValue = dv->num_valuators; client->errorValue = dv->num_valuators;
return BadValue; return BadValue;
} }
} }
type = type - XI_DeviceKeyPress + KeyPress; type = type - XI_DeviceKeyPress + KeyPress;
} else }
{ else {
if (nev != 1) if (nev != 1)
return BadLength; return BadLength;
switch (type) switch (type) {
{ case KeyPress:
case KeyPress: case KeyRelease:
case KeyRelease: dev = PickKeyboard(client);
dev = PickKeyboard(client); break;
break; case ButtonPress:
case ButtonPress: case ButtonRelease:
case ButtonRelease: dev = PickPointer(client);
dev = PickPointer(client); break;
break; case MotionNotify:
case MotionNotify: dev = PickPointer(client);
dev = PickPointer(client); valuators[0] = ev->u.keyButtonPointer.rootX;
valuators[0] = ev->u.keyButtonPointer.rootX; valuators[1] = ev->u.keyButtonPointer.rootY;
valuators[1] = ev->u.keyButtonPointer.rootY; numValuators = 2;
numValuators = 2; firstValuator = 0;
firstValuator = 0; if (ev->u.u.detail == xFalse)
if (ev->u.u.detail == xFalse) flags = POINTER_ABSOLUTE | POINTER_SCREEN;
flags = POINTER_ABSOLUTE | POINTER_SCREEN; break;
break; default:
default: client->errorValue = ev->u.u.type;
client->errorValue = ev->u.u.type; return BadValue;
return BadValue;
} }
dev = GetXTestDevice(dev); dev = GetXTestDevice(dev);
} }
/* If the event has a time set, wait for it to pass */ /* If the event has a time set, wait for it to pass */
if (ev->u.keyButtonPointer.time) if (ev->u.keyButtonPointer.time) {
{
TimeStamp activateTime; TimeStamp activateTime;
CARD32 ms; CARD32 ms;
@ -339,92 +325,85 @@ ProcXTestFakeInput(ClientPtr client)
/* see mbuf.c:QueueDisplayRequest (from the deprecated Multibuffer /* see mbuf.c:QueueDisplayRequest (from the deprecated Multibuffer
* extension) for code similar to this */ * extension) for code similar to this */
if (!ClientSleepUntil(client, &activateTime, NULL, NULL)) if (!ClientSleepUntil(client, &activateTime, NULL, NULL)) {
{
return BadAlloc; return BadAlloc;
} }
/* swap the request back so we can simply re-execute it */ /* swap the request back so we can simply re-execute it */
if (client->swapped) if (client->swapped) {
{ (void) XTestSwapFakeInput(client, (xReq *) stuff);
(void) XTestSwapFakeInput(client, (xReq *)stuff);
swaps(&stuff->length); swaps(&stuff->length);
} }
ResetCurrentRequest (client); ResetCurrentRequest(client);
client->sequence--; client->sequence--;
return Success; return Success;
} }
switch (type) switch (type) {
{ case KeyPress:
case KeyPress: case KeyRelease:
case KeyRelease: if (!dev->key)
if (!dev->key) return BadDevice;
return BadDevice;
if (ev->u.u.detail < dev->key->xkbInfo->desc->min_key_code || if (ev->u.u.detail < dev->key->xkbInfo->desc->min_key_code ||
ev->u.u.detail > dev->key->xkbInfo->desc->max_key_code) ev->u.u.detail > dev->key->xkbInfo->desc->max_key_code) {
{ client->errorValue = ev->u.u.detail;
client->errorValue = ev->u.u.detail; return BadValue;
}
need_ptr_update = 0;
break;
case MotionNotify:
if (!dev->valuator)
return BadDevice;
if (!(extension || ev->u.keyButtonPointer.root == None)) {
rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root,
client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (root->parent) {
client->errorValue = ev->u.keyButtonPointer.root;
return BadValue; return BadValue;
} }
}
if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse) {
client->errorValue = ev->u.u.detail;
return BadValue;
}
need_ptr_update = 0; /* FIXME: Xinerama! */
break;
case MotionNotify:
if (!dev->valuator)
return BadDevice;
if (!(extension || ev->u.keyButtonPointer.root == None)) break;
{ case ButtonPress:
rc = dixLookupWindow(&root, ev->u.keyButtonPointer.root, case ButtonRelease:
client, DixGetAttrAccess); if (!dev->button)
if (rc != Success) return BadDevice;
return rc;
if (root->parent)
{
client->errorValue = ev->u.keyButtonPointer.root;
return BadValue;
}
}
if (ev->u.u.detail != xTrue && ev->u.u.detail != xFalse)
{
client->errorValue = ev->u.u.detail;
return BadValue;
}
/* FIXME: Xinerama! */ if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons) {
client->errorValue = ev->u.u.detail;
break; return BadValue;
case ButtonPress: }
case ButtonRelease: break;
if (!dev->button)
return BadDevice;
if (!ev->u.u.detail || ev->u.u.detail > dev->button->numButtons)
{
client->errorValue = ev->u.u.detail;
return BadValue;
}
break;
} }
if (screenIsSaved == SCREEN_SAVER_ON) if (screenIsSaved == SCREEN_SAVER_ON)
dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset); dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
switch(type) { switch (type) {
case MotionNotify: case MotionNotify:
valuator_mask_set_range(&mask, firstValuator, numValuators, valuators); valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask); nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask);
break; break;
case ButtonPress: case ButtonPress:
case ButtonRelease: case ButtonRelease:
valuator_mask_set_range(&mask, firstValuator, numValuators, valuators); valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail, nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail,
flags, &mask); flags, &mask);
break; break;
case KeyPress: case KeyPress:
case KeyRelease: case KeyRelease:
nevents = GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail, NULL); nevents =
break; GetKeyboardEvents(xtest_evlist, dev, type, ev->u.u.detail, NULL);
break;
} }
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
@ -441,8 +420,7 @@ ProcXTestGrabControl(ClientPtr client)
REQUEST(xXTestGrabControlReq); REQUEST(xXTestGrabControlReq);
REQUEST_SIZE_MATCH(xXTestGrabControlReq); REQUEST_SIZE_MATCH(xXTestGrabControlReq);
if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse)) if ((stuff->impervious != xTrue) && (stuff->impervious != xFalse)) {
{
client->errorValue = stuff->impervious; client->errorValue = stuff->impervious;
return BadValue; return BadValue;
} }
@ -454,21 +432,20 @@ ProcXTestGrabControl(ClientPtr client)
} }
static int static int
ProcXTestDispatch (ClientPtr client) ProcXTestDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{ case X_XTestGetVersion:
case X_XTestGetVersion: return ProcXTestGetVersion(client);
return ProcXTestGetVersion(client); case X_XTestCompareCursor:
case X_XTestCompareCursor: return ProcXTestCompareCursor(client);
return ProcXTestCompareCursor(client); case X_XTestFakeInput:
case X_XTestFakeInput: return ProcXTestFakeInput(client);
return ProcXTestFakeInput(client); case X_XTestGrabControl:
case X_XTestGrabControl: return ProcXTestGrabControl(client);
return ProcXTestGrabControl(client); default:
default: return BadRequest;
return BadRequest;
} }
} }
@ -496,7 +473,7 @@ SProcXTestCompareCursor(ClientPtr client)
} }
static int static int
XTestSwapFakeInput(ClientPtr client, xReq *req) XTestSwapFakeInput(ClientPtr client, xReq * req)
{ {
int nev; int nev;
xEvent *ev; xEvent *ev;
@ -504,16 +481,15 @@ XTestSwapFakeInput(ClientPtr client, xReq *req)
EventSwapPtr proc; EventSwapPtr proc;
nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent); nev = ((req->length << 2) - sizeof(xReq)) / sizeof(xEvent);
for (ev = (xEvent *)&req[1]; --nev >= 0; ev++) for (ev = (xEvent *) &req[1]; --nev >= 0; ev++) {
{
/* Swap event */ /* Swap event */
proc = EventSwapVector[ev->u.u.type & 0177]; proc = EventSwapVector[ev->u.u.type & 0177];
/* no swapping proc; invalid event type? */ /* no swapping proc; invalid event type? */
if (!proc || proc == NotImplemented) { if (!proc || proc == NotImplemented) {
client->errorValue = ev->u.u.type; client->errorValue = ev->u.u.type;
return BadValue; return BadValue;
} }
(*proc)(ev, &sev); (*proc) (ev, &sev);
*ev = sev; *ev = sev;
} }
return Success; return Success;
@ -522,7 +498,8 @@ XTestSwapFakeInput(ClientPtr client, xReq *req)
static int static int
SProcXTestFakeInput(ClientPtr client) SProcXTestFakeInput(ClientPtr client)
{ {
int n; int n;
REQUEST(xReq); REQUEST(xReq);
swaps(&stuff->length); swaps(&stuff->length);
@ -543,21 +520,20 @@ SProcXTestGrabControl(ClientPtr client)
} }
static int static int
SProcXTestDispatch (ClientPtr client) SProcXTestDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
switch (stuff->data) switch (stuff->data) {
{ case X_XTestGetVersion:
case X_XTestGetVersion: return SProcXTestGetVersion(client);
return SProcXTestGetVersion(client); case X_XTestCompareCursor:
case X_XTestCompareCursor: return SProcXTestCompareCursor(client);
return SProcXTestCompareCursor(client); case X_XTestFakeInput:
case X_XTestFakeInput: return SProcXTestFakeInput(client);
return SProcXTestFakeInput(client); case X_XTestGrabControl:
case X_XTestGrabControl: return SProcXTestGrabControl(client);
return SProcXTestGrabControl(client); default:
default: return BadRequest;
return BadRequest;
} }
} }
@ -565,21 +541,22 @@ SProcXTestDispatch (ClientPtr client)
* Allocate an virtual slave device for xtest events, this * Allocate an virtual slave device for xtest events, this
* is a slave device to inputInfo master devices * is a slave device to inputInfo master devices
*/ */
void InitXTestDevices(void) void
InitXTestDevices(void)
{ {
if(AllocXTestDevice(serverClient, "Virtual core", if (AllocXTestDevice(serverClient, "Virtual core",
&xtestpointer, &xtestkeyboard, &xtestpointer, &xtestkeyboard,
inputInfo.pointer, inputInfo.keyboard) != Success) inputInfo.pointer, inputInfo.keyboard) != Success)
FatalError("Failed to allocate XTest devices"); FatalError("Failed to allocate XTest devices");
if (ActivateDevice(xtestpointer, TRUE) != Success || if (ActivateDevice(xtestpointer, TRUE) != Success ||
ActivateDevice(xtestkeyboard, TRUE) != Success) ActivateDevice(xtestkeyboard, TRUE) != Success)
FatalError("Failed to activate XTest core devices."); FatalError("Failed to activate XTest core devices.");
if (!EnableDevice(xtestpointer, TRUE) || if (!EnableDevice(xtestpointer, TRUE) || !EnableDevice(xtestkeyboard, TRUE))
!EnableDevice(xtestkeyboard, TRUE))
FatalError("Failed to enable XTest core devices."); FatalError("Failed to enable XTest core devices.");
AttachDevice(NULL, xtestpointer, inputInfo.pointer); AttachDevice(NULL, xtestpointer, inputInfo.pointer);
AttachDevice(NULL, xtestkeyboard, inputInfo.keyboard); AttachDevice(NULL, xtestkeyboard, inputInfo.keyboard);
} }
@ -588,7 +565,7 @@ void InitXTestDevices(void)
*/ */
static int static int
DeviceSetXTestProperty(DeviceIntPtr dev, Atom property, DeviceSetXTestProperty(DeviceIntPtr dev, Atom property,
XIPropertyValuePtr prop, BOOL checkonly) XIPropertyValuePtr prop, BOOL checkonly)
{ {
if (property == XIGetKnownProperty(XI_PROP_XTEST_DEVICE)) if (property == XIGetKnownProperty(XI_PROP_XTEST_DEVICE))
return BadAccess; return BadAccess;
@ -603,35 +580,42 @@ DeviceSetXTestProperty(DeviceIntPtr dev, Atom property,
* This only creates the pair, Activate/Enable Device * This only creates the pair, Activate/Enable Device
* still need to be called. * still need to be called.
*/ */
int AllocXTestDevice (ClientPtr client, const char* name, int
DeviceIntPtr* ptr, DeviceIntPtr* keybd, AllocXTestDevice(ClientPtr client, const char *name,
DeviceIntPtr master_ptr, DeviceIntPtr master_keybd) DeviceIntPtr *ptr, DeviceIntPtr *keybd,
DeviceIntPtr master_ptr, DeviceIntPtr master_keybd)
{ {
int retval; int retval;
char *xtestname; char *xtestname;
char dummy = 1; char dummy = 1;
if (asprintf(&xtestname, "%s XTEST", name) == -1) if (asprintf(&xtestname, "%s XTEST", name) == -1)
return BadAlloc; return BadAlloc;
retval = AllocDevicePair( client, xtestname, ptr, keybd, CorePointerProc, CoreKeyboardProc, FALSE); retval =
if ( retval == Success ){ AllocDevicePair(client, xtestname, ptr, keybd, CorePointerProc,
(*ptr)->xtest_master_id = master_ptr->id; CoreKeyboardProc, FALSE);
(*keybd)->xtest_master_id = master_keybd->id; if (retval == Success) {
(*ptr)->xtest_master_id = master_ptr->id;
(*keybd)->xtest_master_id = master_keybd->id;
XIChangeDeviceProperty(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), XIChangeDeviceProperty(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy, XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE); FALSE);
XISetDevicePropertyDeletable(*ptr, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE); XISetDevicePropertyDeletable(*ptr,
XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
FALSE);
XIRegisterPropertyHandler(*ptr, DeviceSetXTestProperty, NULL, NULL); XIRegisterPropertyHandler(*ptr, DeviceSetXTestProperty, NULL, NULL);
XIChangeDeviceProperty(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), XIChangeDeviceProperty(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
XA_INTEGER, 8, PropModeReplace, 1, &dummy, XA_INTEGER, 8, PropModeReplace, 1, &dummy,
FALSE); FALSE);
XISetDevicePropertyDeletable(*keybd, XIGetKnownProperty(XI_PROP_XTEST_DEVICE), FALSE); XISetDevicePropertyDeletable(*keybd,
XIGetKnownProperty(XI_PROP_XTEST_DEVICE),
FALSE);
XIRegisterPropertyHandler(*keybd, DeviceSetXTestProperty, NULL, NULL); XIRegisterPropertyHandler(*keybd, DeviceSetXTestProperty, NULL, NULL);
} }
free( xtestname ); free(xtestname);
return retval; return retval;
} }
@ -651,7 +635,7 @@ IsXTestDevice(DeviceIntPtr dev, DeviceIntPtr master)
/* deviceid 0 is reserved for XIAllDevices, non-zero mid means XTest /* deviceid 0 is reserved for XIAllDevices, non-zero mid means XTest
* device */ * device */
if (master) if (master)
return dev->xtest_master_id == master->id; return dev->xtest_master_id == master->id;
return dev->xtest_master_id != 0; return dev->xtest_master_id != 0;
} }
@ -664,8 +648,7 @@ GetXTestDevice(DeviceIntPtr master)
{ {
DeviceIntPtr it; DeviceIntPtr it;
for (it = inputInfo.devices; it; it = it->next) for (it = inputInfo.devices; it; it = it->next) {
{
if (IsXTestDevice(it, master)) if (IsXTestDevice(it, master))
return it; return it;
} }
@ -675,7 +658,7 @@ GetXTestDevice(DeviceIntPtr master)
} }
static void static void
XTestExtensionTearDown(ExtensionEntry *e) XTestExtensionTearDown(ExtensionEntry * e)
{ {
FreeEventList(xtest_evlist, GetMaximumEventsNum()); FreeEventList(xtest_evlist, GetMaximumEventsNum());
xtest_evlist = NULL; xtest_evlist = NULL;
@ -685,8 +668,8 @@ void
XTestExtensionInit(INITARGS) XTestExtensionInit(INITARGS)
{ {
AddExtension(XTestExtensionName, 0, 0, AddExtension(XTestExtensionName, 0, 0,
ProcXTestDispatch, SProcXTestDispatch, ProcXTestDispatch, SProcXTestDispatch,
XTestExtensionTearDown, StandardMinorOpcode); XTestExtensionTearDown, StandardMinorOpcode);
xtest_evlist = InitEventList(GetMaximumEventsNum()); xtest_evlist = InitEventList(GetMaximumEventsNum());
} }

2136
Xext/xvdisp.c
View File

File diff suppressed because it is too large Load Diff

244
Xext/xvdix.h
View File

@ -73,132 +73,131 @@ extern _X_EXPORT RESTYPE XvRTPortNotify;
#endif #endif
typedef struct { typedef struct {
int numerator; int numerator;
int denominator; int denominator;
} XvRationalRec, *XvRationalPtr; } XvRationalRec, *XvRationalPtr;
typedef struct { typedef struct {
char depth; char depth;
unsigned long visual; unsigned long visual;
} XvFormatRec, *XvFormatPtr; } XvFormatRec, *XvFormatPtr;
typedef struct { typedef struct {
unsigned long id; unsigned long id;
ClientPtr client; ClientPtr client;
} XvGrabRec, *XvGrabPtr; } XvGrabRec, *XvGrabPtr;
typedef struct _XvVideoNotifyRec { typedef struct _XvVideoNotifyRec {
struct _XvVideoNotifyRec *next; struct _XvVideoNotifyRec *next;
ClientPtr client; ClientPtr client;
unsigned long id; unsigned long id;
unsigned long mask; unsigned long mask;
} XvVideoNotifyRec, *XvVideoNotifyPtr; } XvVideoNotifyRec, *XvVideoNotifyPtr;
typedef struct _XvPortNotifyRec { typedef struct _XvPortNotifyRec {
struct _XvPortNotifyRec *next; struct _XvPortNotifyRec *next;
ClientPtr client; ClientPtr client;
unsigned long id; unsigned long id;
} XvPortNotifyRec, *XvPortNotifyPtr; } XvPortNotifyRec, *XvPortNotifyPtr;
typedef struct { typedef struct {
int id; int id;
ScreenPtr pScreen; ScreenPtr pScreen;
char *name; char *name;
unsigned short width, height; unsigned short width, height;
XvRationalRec rate; XvRationalRec rate;
} XvEncodingRec, *XvEncodingPtr; } XvEncodingRec, *XvEncodingPtr;
typedef struct _XvAttributeRec { typedef struct _XvAttributeRec {
int flags; int flags;
int min_value; int min_value;
int max_value; int max_value;
char *name; char *name;
} XvAttributeRec, *XvAttributePtr; } XvAttributeRec, *XvAttributePtr;
typedef struct { typedef struct {
int id; int id;
int type; int type;
int byte_order; int byte_order;
char guid[16]; char guid[16];
int bits_per_pixel; int bits_per_pixel;
int format; int format;
int num_planes; int num_planes;
/* for RGB formats only */ /* for RGB formats only */
int depth; int depth;
unsigned int red_mask; unsigned int red_mask;
unsigned int green_mask; unsigned int green_mask;
unsigned int blue_mask; unsigned int blue_mask;
/* for YUV formats only */ /* for YUV formats only */
unsigned int y_sample_bits; unsigned int y_sample_bits;
unsigned int u_sample_bits; unsigned int u_sample_bits;
unsigned int v_sample_bits; unsigned int v_sample_bits;
unsigned int horz_y_period; unsigned int horz_y_period;
unsigned int horz_u_period; unsigned int horz_u_period;
unsigned int horz_v_period; unsigned int horz_v_period;
unsigned int vert_y_period; unsigned int vert_y_period;
unsigned int vert_u_period; unsigned int vert_u_period;
unsigned int vert_v_period; unsigned int vert_v_period;
char component_order[32]; char component_order[32];
int scanline_order; int scanline_order;
} XvImageRec, *XvImagePtr; } XvImageRec, *XvImagePtr;
typedef struct { typedef struct {
unsigned long base_id; unsigned long base_id;
unsigned char type; unsigned char type;
char *name; char *name;
int nEncodings; int nEncodings;
XvEncodingPtr pEncodings; XvEncodingPtr pEncodings;
int nFormats; int nFormats;
XvFormatPtr pFormats; XvFormatPtr pFormats;
int nAttributes; int nAttributes;
XvAttributePtr pAttributes; XvAttributePtr pAttributes;
int nImages; int nImages;
XvImagePtr pImages; XvImagePtr pImages;
int nPorts; int nPorts;
struct _XvPortRec *pPorts; struct _XvPortRec *pPorts;
ScreenPtr pScreen; ScreenPtr pScreen;
int (* ddAllocatePort)(unsigned long, struct _XvPortRec*, int (*ddAllocatePort) (unsigned long, struct _XvPortRec *,
struct _XvPortRec**); struct _XvPortRec **);
int (* ddFreePort)(struct _XvPortRec*); int (*ddFreePort) (struct _XvPortRec *);
int (* ddPutVideo)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr, int (*ddPutVideo) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
int (* ddPutStill)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr, int (*ddPutStill) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
int (* ddGetVideo)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr, int (*ddGetVideo) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
int (* ddGetStill)(ClientPtr, DrawablePtr,struct _XvPortRec*, GCPtr, int (*ddGetStill) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
int (* ddStopVideo)(ClientPtr, struct _XvPortRec*, DrawablePtr); int (*ddStopVideo) (ClientPtr, struct _XvPortRec *, DrawablePtr);
int (* ddSetPortAttribute)(ClientPtr, struct _XvPortRec*, Atom, INT32); int (*ddSetPortAttribute) (ClientPtr, struct _XvPortRec *, Atom, INT32);
int (* ddGetPortAttribute)(ClientPtr, struct _XvPortRec*, Atom, INT32*); int (*ddGetPortAttribute) (ClientPtr, struct _XvPortRec *, Atom, INT32 *);
int (* ddQueryBestSize)(ClientPtr, struct _XvPortRec*, CARD8, int (*ddQueryBestSize) (ClientPtr, struct _XvPortRec *, CARD8,
CARD16, CARD16,CARD16, CARD16, CARD16, CARD16, CARD16, CARD16,
unsigned int*, unsigned int*); unsigned int *, unsigned int *);
int (* ddPutImage)(ClientPtr, DrawablePtr, struct _XvPortRec*, GCPtr, int (*ddPutImage) (ClientPtr, DrawablePtr, struct _XvPortRec *, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
XvImagePtr, unsigned char*, Bool, XvImagePtr, unsigned char *, Bool, CARD16, CARD16);
CARD16, CARD16); int (*ddQueryImageAttributes) (ClientPtr, struct _XvPortRec *, XvImagePtr,
int (* ddQueryImageAttributes)(ClientPtr, struct _XvPortRec*, XvImagePtr, CARD16 *, CARD16 *, int *, int *);
CARD16*, CARD16*, int*, int*); DevUnion devPriv;
DevUnion devPriv;
} XvAdaptorRec, *XvAdaptorPtr; } XvAdaptorRec, *XvAdaptorPtr;
typedef struct _XvPortRec { typedef struct _XvPortRec {
unsigned long id; unsigned long id;
XvAdaptorPtr pAdaptor; XvAdaptorPtr pAdaptor;
XvPortNotifyPtr pNotify; XvPortNotifyPtr pNotify;
DrawablePtr pDraw; DrawablePtr pDraw;
ClientPtr client; ClientPtr client;
XvGrabRec grab; XvGrabRec grab;
TimeStamp time; TimeStamp time;
DevUnion devPriv; DevUnion devPriv;
} XvPortRec, *XvPortPtr; } XvPortRec, *XvPortPtr;
#define VALIDATE_XV_PORT(portID, pPort, mode)\ #define VALIDATE_XV_PORT(portID, pPort, mode)\
@ -210,15 +209,15 @@ typedef struct _XvPortRec {
} }
typedef struct { typedef struct {
int version, revision; int version, revision;
int nAdaptors; int nAdaptors;
XvAdaptorPtr pAdaptors; XvAdaptorPtr pAdaptors;
DestroyWindowProcPtr DestroyWindow; DestroyWindowProcPtr DestroyWindow;
DestroyPixmapProcPtr DestroyPixmap; DestroyPixmapProcPtr DestroyPixmap;
CloseScreenProcPtr CloseScreen; CloseScreenProcPtr CloseScreen;
Bool (* ddCloseScreen)(int, ScreenPtr); Bool (*ddCloseScreen) (int, ScreenPtr);
int (* ddQueryAdaptors)(ScreenPtr, XvAdaptorPtr*, int*); int (*ddQueryAdaptors) (ScreenPtr, XvAdaptorPtr *, int *);
DevUnion devPriv; DevUnion devPriv;
} XvScreenRec, *XvScreenPtr; } XvScreenRec, *XvScreenPtr;
#define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = ((XvScreenPtr) \ #define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = ((XvScreenPtr) \
@ -244,32 +243,31 @@ extern _X_EXPORT int XvdiSendPortNotify(XvPortPtr, Atom, INT32);
extern _X_EXPORT int XvdiVideoStopped(XvPortPtr, int); extern _X_EXPORT int XvdiVideoStopped(XvPortPtr, int);
extern _X_EXPORT int XvdiPutVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr, extern _X_EXPORT int XvdiPutVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
extern _X_EXPORT int XvdiPutStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr, extern _X_EXPORT int XvdiPutStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
extern _X_EXPORT int XvdiGetVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr, extern _X_EXPORT int XvdiGetVideo(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
extern _X_EXPORT int XvdiGetStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr, extern _X_EXPORT int XvdiGetStill(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16); INT16, INT16, CARD16, CARD16);
extern _X_EXPORT int XvdiPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr, extern _X_EXPORT int XvdiPutImage(ClientPtr, DrawablePtr, XvPortPtr, GCPtr,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
INT16, INT16, CARD16, CARD16, INT16, INT16, CARD16, CARD16,
XvImagePtr, unsigned char*, Bool, XvImagePtr, unsigned char *, Bool,
CARD16, CARD16); CARD16, CARD16);
extern _X_EXPORT int XvdiSelectVideoNotify(ClientPtr, DrawablePtr, BOOL); extern _X_EXPORT int XvdiSelectVideoNotify(ClientPtr, DrawablePtr, BOOL);
extern _X_EXPORT int XvdiSelectPortNotify(ClientPtr, XvPortPtr, BOOL); extern _X_EXPORT int XvdiSelectPortNotify(ClientPtr, XvPortPtr, BOOL);
extern _X_EXPORT int XvdiSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32); extern _X_EXPORT int XvdiSetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32);
extern _X_EXPORT int XvdiGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32*); extern _X_EXPORT int XvdiGetPortAttribute(ClientPtr, XvPortPtr, Atom, INT32 *);
extern _X_EXPORT int XvdiStopVideo(ClientPtr, XvPortPtr, DrawablePtr); extern _X_EXPORT int XvdiStopVideo(ClientPtr, XvPortPtr, DrawablePtr);
extern _X_EXPORT int XvdiPreemptVideo(ClientPtr, XvPortPtr, DrawablePtr); extern _X_EXPORT int XvdiPreemptVideo(ClientPtr, XvPortPtr, DrawablePtr);
extern _X_EXPORT int XvdiMatchPort(XvPortPtr, DrawablePtr); extern _X_EXPORT int XvdiMatchPort(XvPortPtr, DrawablePtr);
extern _X_EXPORT int XvdiGrabPort(ClientPtr, XvPortPtr, Time, int *); extern _X_EXPORT int XvdiGrabPort(ClientPtr, XvPortPtr, Time, int *);
extern _X_EXPORT int XvdiUngrabPort( ClientPtr, XvPortPtr, Time); extern _X_EXPORT int XvdiUngrabPort(ClientPtr, XvPortPtr, Time);
#endif /* XorgLoader */ #endif /* XorgLoader */
#endif /* XVDIX_H */
#endif /* XVDIX_H */

1276
Xext/xvmain.c
View File

File diff suppressed because it is too large Load Diff

513
Xext/xvmc.c
View File

@ -26,14 +26,13 @@
#include <sys/ipc.h> #include <sys/ipc.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/shm.h> #include <sys/shm.h>
#endif /* HAS_XVMCSHM */ #endif /* HAS_XVMCSHM */
#define DR_CLIENT_DRIVER_NAME_SIZE 48 #define DR_CLIENT_DRIVER_NAME_SIZE 48
#define DR_BUSID_SIZE 48 #define DR_BUSID_SIZE 48
static DevPrivateKeyRec XvMCScreenKeyRec; static DevPrivateKeyRec XvMCScreenKeyRec;
#define XvMCScreenKey (&XvMCScreenKeyRec) #define XvMCScreenKey (&XvMCScreenKeyRec)
static Bool XvMCInUse; static Bool XvMCInUse;
@ -47,71 +46,71 @@ static RESTYPE XvMCRTSurface;
static RESTYPE XvMCRTSubpicture; static RESTYPE XvMCRTSubpicture;
typedef struct { typedef struct {
int num_adaptors; int num_adaptors;
XvMCAdaptorPtr adaptors; XvMCAdaptorPtr adaptors;
CloseScreenProcPtr CloseScreen; CloseScreenProcPtr CloseScreen;
char clientDriverName[DR_CLIENT_DRIVER_NAME_SIZE]; char clientDriverName[DR_CLIENT_DRIVER_NAME_SIZE];
char busID[DR_BUSID_SIZE]; char busID[DR_BUSID_SIZE];
int major; int major;
int minor; int minor;
int patchLevel; int patchLevel;
} XvMCScreenRec, *XvMCScreenPtr; } XvMCScreenRec, *XvMCScreenPtr;
#define XVMC_GET_PRIVATE(pScreen) \ #define XVMC_GET_PRIVATE(pScreen) \
(XvMCScreenPtr)(dixLookupPrivate(&(pScreen)->devPrivates, XvMCScreenKey)) (XvMCScreenPtr)(dixLookupPrivate(&(pScreen)->devPrivates, XvMCScreenKey))
static int static int
XvMCDestroyContextRes(pointer data, XID id) XvMCDestroyContextRes(pointer data, XID id)
{ {
XvMCContextPtr pContext = (XvMCContextPtr)data; XvMCContextPtr pContext = (XvMCContextPtr) data;
pContext->refcnt--; pContext->refcnt--;
if(!pContext->refcnt) { if (!pContext->refcnt) {
XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
(*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext)(pContext);
free(pContext);
}
return Success; (*pScreenPriv->adaptors[pContext->adapt_num].DestroyContext) (pContext);
free(pContext);
}
return Success;
} }
static int static int
XvMCDestroySurfaceRes(pointer data, XID id) XvMCDestroySurfaceRes(pointer data, XID id)
{ {
XvMCSurfacePtr pSurface = (XvMCSurfacePtr)data; XvMCSurfacePtr pSurface = (XvMCSurfacePtr) data;
XvMCContextPtr pContext = pSurface->context; XvMCContextPtr pContext = pSurface->context;
XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
(*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface)(pSurface); (*pScreenPriv->adaptors[pContext->adapt_num].DestroySurface) (pSurface);
free(pSurface); free(pSurface);
XvMCDestroyContextRes((pointer)pContext, pContext->context_id); XvMCDestroyContextRes((pointer) pContext, pContext->context_id);
return Success; return Success;
} }
static int static int
XvMCDestroySubpictureRes(pointer data, XID id) XvMCDestroySubpictureRes(pointer data, XID id)
{ {
XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr)data; XvMCSubpicturePtr pSubpict = (XvMCSubpicturePtr) data;
XvMCContextPtr pContext = pSubpict->context; XvMCContextPtr pContext = pSubpict->context;
XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
(*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture)(pSubpict); (*pScreenPriv->adaptors[pContext->adapt_num].DestroySubpicture) (pSubpict);
free(pSubpict); free(pSubpict);
XvMCDestroyContextRes((pointer)pContext, pContext->context_id); XvMCDestroyContextRes((pointer) pContext, pContext->context_id);
return Success; return Success;
} }
static int static int
ProcXvMCQueryVersion(ClientPtr client) ProcXvMCQueryVersion(ClientPtr client)
{ {
xvmcQueryVersionReply rep; xvmcQueryVersionReply rep;
/* REQUEST(xvmcQueryVersionReq); */ /* REQUEST(xvmcQueryVersionReq); */
REQUEST_SIZE_MATCH(xvmcQueryVersionReq); REQUEST_SIZE_MATCH(xvmcQueryVersionReq);
rep.type = X_Reply; rep.type = X_Reply;
@ -119,11 +118,10 @@ ProcXvMCQueryVersion(ClientPtr client)
rep.length = 0; rep.length = 0;
rep.major = SERVER_XVMC_MAJOR_VERSION; rep.major = SERVER_XVMC_MAJOR_VERSION;
rep.minor = SERVER_XVMC_MINOR_VERSION; rep.minor = SERVER_XVMC_MINOR_VERSION;
WriteToClient(client, sizeof(xvmcQueryVersionReply), (char*)&rep); WriteToClient(client, sizeof(xvmcQueryVersionReply), (char *) &rep);
return Success; return Success;
} }
static int static int
ProcXvMCListSurfaceTypes(ClientPtr client) ProcXvMCListSurfaceTypes(ClientPtr client)
{ {
@ -134,21 +132,23 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
xvmcSurfaceInfo info; xvmcSurfaceInfo info;
XvMCAdaptorPtr adaptor = NULL; XvMCAdaptorPtr adaptor = NULL;
XvMCSurfaceInfoPtr surface; XvMCSurfaceInfoPtr surface;
REQUEST(xvmcListSurfaceTypesReq); REQUEST(xvmcListSurfaceTypesReq);
REQUEST_SIZE_MATCH(xvmcListSurfaceTypesReq); REQUEST_SIZE_MATCH(xvmcListSurfaceTypesReq);
VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess); VALIDATE_XV_PORT(stuff->port, pPort, DixReadAccess);
if(XvMCInUse) { /* any adaptors at all */ if (XvMCInUse) { /* any adaptors at all */
ScreenPtr pScreen = pPort->pAdaptor->pScreen; ScreenPtr pScreen = pPort->pAdaptor->pScreen;
if((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) { /* any this screen */
for(i = 0; i < pScreenPriv->num_adaptors; i++) { if ((pScreenPriv = XVMC_GET_PRIVATE(pScreen))) { /* any this screen */
if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) { for (i = 0; i < pScreenPriv->num_adaptors; i++) {
adaptor = &(pScreenPriv->adaptors[i]); if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
break; adaptor = &(pScreenPriv->adaptors[i]);
} break;
} }
} }
}
} }
rep.type = X_Reply; rep.type = X_Reply;
@ -156,19 +156,19 @@ ProcXvMCListSurfaceTypes(ClientPtr client)
rep.num = (adaptor) ? adaptor->num_surfaces : 0; rep.num = (adaptor) ? adaptor->num_surfaces : 0;
rep.length = bytes_to_int32(rep.num * sizeof(xvmcSurfaceInfo)); rep.length = bytes_to_int32(rep.num * sizeof(xvmcSurfaceInfo));
WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char*)&rep); WriteToClient(client, sizeof(xvmcListSurfaceTypesReply), (char *) &rep);
for(i = 0; i < rep.num; i++) { for (i = 0; i < rep.num; i++) {
surface = adaptor->surfaces[i]; surface = adaptor->surfaces[i];
info.surface_type_id = surface->surface_type_id; info.surface_type_id = surface->surface_type_id;
info.chroma_format = surface->chroma_format; info.chroma_format = surface->chroma_format;
info.max_width = surface->max_width; info.max_width = surface->max_width;
info.max_height = surface->max_height; info.max_height = surface->max_height;
info.subpicture_max_width = surface->subpicture_max_width; info.subpicture_max_width = surface->subpicture_max_width;
info.subpicture_max_height = surface->subpicture_max_height; info.subpicture_max_height = surface->subpicture_max_height;
info.mc_type = surface->mc_type; info.mc_type = surface->mc_type;
info.flags = surface->flags; info.flags = surface->flags;
WriteToClient(client, sizeof(xvmcSurfaceInfo), (char*)&info); WriteToClient(client, sizeof(xvmcSurfaceInfo), (char *) &info);
} }
return Success; return Success;
@ -187,6 +187,7 @@ ProcXvMCCreateContext(ClientPtr client)
XvMCAdaptorPtr adaptor = NULL; XvMCAdaptorPtr adaptor = NULL;
XvMCSurfaceInfoPtr surface = NULL; XvMCSurfaceInfoPtr surface = NULL;
xvmcCreateContextReply rep; xvmcCreateContextReply rep;
REQUEST(xvmcCreateContextReq); REQUEST(xvmcCreateContextReq);
REQUEST_SIZE_MATCH(xvmcCreateContextReq); REQUEST_SIZE_MATCH(xvmcCreateContextReq);
@ -194,43 +195,42 @@ ProcXvMCCreateContext(ClientPtr client)
pScreen = pPort->pAdaptor->pScreen; pScreen = pPort->pAdaptor->pScreen;
if(!XvMCInUse) /* no XvMC adaptors */ if (!XvMCInUse) /* no XvMC adaptors */
return BadMatch; return BadMatch;
if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) /* none this screen */ if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) /* none this screen */
return BadMatch; return BadMatch;
for(i = 0; i < pScreenPriv->num_adaptors; i++) { for (i = 0; i < pScreenPriv->num_adaptors; i++) {
if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) { if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
adaptor = &(pScreenPriv->adaptors[i]); adaptor = &(pScreenPriv->adaptors[i]);
adapt_num = i; adapt_num = i;
break; break;
} }
} }
if(adapt_num < 0) /* none this port */ if (adapt_num < 0) /* none this port */
return BadMatch; return BadMatch;
for(i = 0; i < adaptor->num_surfaces; i++) { for (i = 0; i < adaptor->num_surfaces; i++) {
if(adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) { if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
surface = adaptor->surfaces[i]; surface = adaptor->surfaces[i];
break; break;
} }
} }
/* adaptor doesn't support this suface_type_id */ /* adaptor doesn't support this suface_type_id */
if(!surface) return BadMatch; if (!surface)
return BadMatch;
if ((stuff->width > surface->max_width) ||
if((stuff->width > surface->max_width) || (stuff->height > surface->max_height))
(stuff->height > surface->max_height))
return BadValue; return BadValue;
if(!(pContext = malloc(sizeof(XvMCContextRec)))) { if (!(pContext = malloc(sizeof(XvMCContextRec)))) {
return BadAlloc; return BadAlloc;
} }
pContext->pScreen = pScreen; pContext->pScreen = pScreen;
pContext->adapt_num = adapt_num; pContext->adapt_num = adapt_num;
pContext->context_id = stuff->context_id; pContext->context_id = stuff->context_id;
@ -240,11 +240,11 @@ ProcXvMCCreateContext(ClientPtr client)
pContext->flags = stuff->flags; pContext->flags = stuff->flags;
pContext->refcnt = 1; pContext->refcnt = 1;
result = (*adaptor->CreateContext)(pPort, pContext, &dwords, &data); result = (*adaptor->CreateContext) (pPort, pContext, &dwords, &data);
if(result != Success) { if (result != Success) {
free(pContext); free(pContext);
return result; return result;
} }
rep.type = X_Reply; rep.type = X_Reply;
@ -254,9 +254,9 @@ ProcXvMCCreateContext(ClientPtr client)
rep.flags_return = pContext->flags; rep.flags_return = pContext->flags;
rep.length = dwords; rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateContextReply), (char*)&rep); WriteToClient(client, sizeof(xvmcCreateContextReply), (char *) &rep);
if(dwords) if (dwords)
WriteToClient(client, dwords << 2, (char*)data); WriteToClient(client, dwords << 2, (char *) data);
AddResource(pContext->context_id, XvMCRTContext, pContext); AddResource(pContext->context_id, XvMCRTContext, pContext);
free(data); free(data);
@ -269,13 +269,14 @@ ProcXvMCDestroyContext(ClientPtr client)
{ {
pointer val; pointer val;
int rc; int rc;
REQUEST(xvmcDestroyContextReq); REQUEST(xvmcDestroyContextReq);
REQUEST_SIZE_MATCH(xvmcDestroyContextReq); REQUEST_SIZE_MATCH(xvmcDestroyContextReq);
rc = dixLookupResourceByType(&val, stuff->context_id, XvMCRTContext, rc = dixLookupResourceByType(&val, stuff->context_id, XvMCRTContext,
client, DixDestroyAccess); client, DixDestroyAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
FreeResource(stuff->context_id, RT_NONE); FreeResource(stuff->context_id, RT_NONE);
@ -292,27 +293,30 @@ ProcXvMCCreateSurface(ClientPtr client)
XvMCSurfacePtr pSurface; XvMCSurfacePtr pSurface;
XvMCScreenPtr pScreenPriv; XvMCScreenPtr pScreenPriv;
xvmcCreateSurfaceReply rep; xvmcCreateSurfaceReply rep;
REQUEST(xvmcCreateSurfaceReq); REQUEST(xvmcCreateSurfaceReq);
REQUEST_SIZE_MATCH(xvmcCreateSurfaceReq); REQUEST_SIZE_MATCH(xvmcCreateSurfaceReq);
result = dixLookupResourceByType((pointer *)&pContext, stuff->context_id, result = dixLookupResourceByType((pointer *) &pContext, stuff->context_id,
XvMCRTContext, client, DixUseAccess); XvMCRTContext, client, DixUseAccess);
if (result != Success) if (result != Success)
return result; return result;
pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen); pScreenPriv = XVMC_GET_PRIVATE(pContext->pScreen);
if(!(pSurface = malloc(sizeof(XvMCSurfaceRec)))) if (!(pSurface = malloc(sizeof(XvMCSurfaceRec))))
return BadAlloc; return BadAlloc;
pSurface->surface_id = stuff->surface_id; pSurface->surface_id = stuff->surface_id;
pSurface->surface_type_id = pContext->surface_type_id; pSurface->surface_type_id = pContext->surface_type_id;
pSurface->context = pContext; pSurface->context = pContext;
result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface)( result =
pSurface, &dwords, &data); (*pScreenPriv->adaptors[pContext->adapt_num].CreateSurface) (pSurface,
&dwords,
&data);
if(result != Success) { if (result != Success) {
free(pSurface); free(pSurface);
return result; return result;
} }
@ -321,9 +325,9 @@ ProcXvMCCreateSurface(ClientPtr client)
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.length = dwords; rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char*)&rep); WriteToClient(client, sizeof(xvmcCreateSurfaceReply), (char *) &rep);
if(dwords) if (dwords)
WriteToClient(client, dwords << 2, (char*)data); WriteToClient(client, dwords << 2, (char *) data);
AddResource(pSurface->surface_id, XvMCRTSurface, pSurface); AddResource(pSurface->surface_id, XvMCRTSurface, pSurface);
free(data); free(data);
@ -338,11 +342,12 @@ ProcXvMCDestroySurface(ClientPtr client)
{ {
pointer val; pointer val;
int rc; int rc;
REQUEST(xvmcDestroySurfaceReq); REQUEST(xvmcDestroySurfaceReq);
REQUEST_SIZE_MATCH(xvmcDestroySurfaceReq); REQUEST_SIZE_MATCH(xvmcDestroySurfaceReq);
rc = dixLookupResourceByType(&val, stuff->surface_id, XvMCRTSurface, rc = dixLookupResourceByType(&val, stuff->surface_id, XvMCRTSurface,
client, DixDestroyAccess); client, DixDestroyAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
@ -363,11 +368,12 @@ ProcXvMCCreateSubpicture(ClientPtr client)
xvmcCreateSubpictureReply rep; xvmcCreateSubpictureReply rep;
XvMCAdaptorPtr adaptor; XvMCAdaptorPtr adaptor;
XvMCSurfaceInfoPtr surface = NULL; XvMCSurfaceInfoPtr surface = NULL;
REQUEST(xvmcCreateSubpictureReq); REQUEST(xvmcCreateSubpictureReq);
REQUEST_SIZE_MATCH(xvmcCreateSubpictureReq); REQUEST_SIZE_MATCH(xvmcCreateSubpictureReq);
result = dixLookupResourceByType((pointer *)&pContext, stuff->context_id, result = dixLookupResourceByType((pointer *) &pContext, stuff->context_id,
XvMCRTContext, client, DixUseAccess); XvMCRTContext, client, DixUseAccess);
if (result != Success) if (result != Success)
return result; return result;
@ -376,51 +382,56 @@ ProcXvMCCreateSubpicture(ClientPtr client)
adaptor = &(pScreenPriv->adaptors[pContext->adapt_num]); adaptor = &(pScreenPriv->adaptors[pContext->adapt_num]);
/* find which surface this context supports */ /* find which surface this context supports */
for(i = 0; i < adaptor->num_surfaces; i++) { for (i = 0; i < adaptor->num_surfaces; i++) {
if(adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id){ if (adaptor->surfaces[i]->surface_type_id == pContext->surface_type_id) {
surface = adaptor->surfaces[i]; surface = adaptor->surfaces[i];
break; break;
} }
} }
if(!surface) return BadMatch; if (!surface)
return BadMatch;
/* make sure this surface supports that xvimage format */ /* make sure this surface supports that xvimage format */
if(!surface->compatible_subpictures) return BadMatch; if (!surface->compatible_subpictures)
return BadMatch;
for(i = 0; i < surface->compatible_subpictures->num_xvimages; i++) { for (i = 0; i < surface->compatible_subpictures->num_xvimages; i++) {
if(surface->compatible_subpictures->xvimage_ids[i] == stuff->xvimage_id) { if (surface->compatible_subpictures->xvimage_ids[i] ==
image_supported = TRUE; stuff->xvimage_id) {
break; image_supported = TRUE;
} break;
}
} }
if(!image_supported) return BadMatch; if (!image_supported)
return BadMatch;
/* make sure the size is OK */ /* make sure the size is OK */
if((stuff->width > surface->subpicture_max_width) || if ((stuff->width > surface->subpicture_max_width) ||
(stuff->height > surface->subpicture_max_height)) (stuff->height > surface->subpicture_max_height))
return BadValue; return BadValue;
if(!(pSubpicture = malloc(sizeof(XvMCSubpictureRec)))) if (!(pSubpicture = malloc(sizeof(XvMCSubpictureRec))))
return BadAlloc; return BadAlloc;
pSubpicture->subpicture_id = stuff->subpicture_id; pSubpicture->subpicture_id = stuff->subpicture_id;
pSubpicture->xvimage_id = stuff->xvimage_id; pSubpicture->xvimage_id = stuff->xvimage_id;
pSubpicture->width = stuff->width; pSubpicture->width = stuff->width;
pSubpicture->height = stuff->height; pSubpicture->height = stuff->height;
pSubpicture->num_palette_entries = 0; /* overwritten by DDX */ pSubpicture->num_palette_entries = 0; /* overwritten by DDX */
pSubpicture->entry_bytes = 0; /* overwritten by DDX */ pSubpicture->entry_bytes = 0; /* overwritten by DDX */
pSubpicture->component_order[0] = 0; /* overwritten by DDX */ pSubpicture->component_order[0] = 0; /* overwritten by DDX */
pSubpicture->component_order[1] = 0; pSubpicture->component_order[1] = 0;
pSubpicture->component_order[2] = 0; pSubpicture->component_order[2] = 0;
pSubpicture->component_order[3] = 0; pSubpicture->component_order[3] = 0;
pSubpicture->context = pContext; pSubpicture->context = pContext;
result = (*pScreenPriv->adaptors[pContext->adapt_num].CreateSubpicture)( result =
pSubpicture, &dwords, &data); (*pScreenPriv->adaptors[pContext->adapt_num].
CreateSubpicture) (pSubpicture, &dwords, &data);
if(result != Success) { if (result != Success) {
free(pSubpicture); free(pSubpicture);
return result; return result;
} }
@ -437,9 +448,9 @@ ProcXvMCCreateSubpicture(ClientPtr client)
rep.component_order[3] = pSubpicture->component_order[3]; rep.component_order[3] = pSubpicture->component_order[3];
rep.length = dwords; rep.length = dwords;
WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char*)&rep); WriteToClient(client, sizeof(xvmcCreateSubpictureReply), (char *) &rep);
if(dwords) if (dwords)
WriteToClient(client, dwords << 2, (char*)data); WriteToClient(client, dwords << 2, (char *) data);
AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture); AddResource(pSubpicture->subpicture_id, XvMCRTSubpicture, pSubpicture);
free(data); free(data);
@ -454,11 +465,12 @@ ProcXvMCDestroySubpicture(ClientPtr client)
{ {
pointer val; pointer val;
int rc; int rc;
REQUEST(xvmcDestroySubpictureReq); REQUEST(xvmcDestroySubpictureReq);
REQUEST_SIZE_MATCH(xvmcDestroySubpictureReq); REQUEST_SIZE_MATCH(xvmcDestroySubpictureReq);
rc = dixLookupResourceByType(&val, stuff->subpicture_id, XvMCRTSubpicture, rc = dixLookupResourceByType(&val, stuff->subpicture_id, XvMCRTSubpicture,
client, DixDestroyAccess); client, DixDestroyAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
@ -467,7 +479,6 @@ ProcXvMCDestroySubpicture(ClientPtr client)
return Success; return Success;
} }
static int static int
ProcXvMCListSubpictureTypes(ClientPtr client) ProcXvMCListSubpictureTypes(ClientPtr client)
{ {
@ -480,6 +491,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
xvImageFormatInfo info; xvImageFormatInfo info;
XvImagePtr pImage; XvImagePtr pImage;
int i, j; int i, j;
REQUEST(xvmcListSubpictureTypesReq); REQUEST(xvmcListSubpictureTypesReq);
REQUEST_SIZE_MATCH(xvmcListSubpictureTypesReq); REQUEST_SIZE_MATCH(xvmcListSubpictureTypesReq);
@ -488,53 +500,55 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
pScreen = pPort->pAdaptor->pScreen; pScreen = pPort->pAdaptor->pScreen;
if (!dixPrivateKeyRegistered(XvMCScreenKey)) if (!dixPrivateKeyRegistered(XvMCScreenKey))
return BadMatch; /* No XvMC adaptors */ return BadMatch; /* No XvMC adaptors */
if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
return BadMatch; /* None this screen */ return BadMatch; /* None this screen */
for(i = 0; i < pScreenPriv->num_adaptors; i++) { for (i = 0; i < pScreenPriv->num_adaptors; i++) {
if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) { if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
adaptor = &(pScreenPriv->adaptors[i]); adaptor = &(pScreenPriv->adaptors[i]);
break; break;
} }
} }
if(!adaptor) return BadMatch; if (!adaptor)
return BadMatch;
for(i = 0; i < adaptor->num_surfaces; i++) { for (i = 0; i < adaptor->num_surfaces; i++) {
if(adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) { if (adaptor->surfaces[i]->surface_type_id == stuff->surface_type_id) {
surface = adaptor->surfaces[i]; surface = adaptor->surfaces[i];
break; break;
} }
} }
if(!surface) return BadMatch; if (!surface)
return BadMatch;
rep.type = X_Reply; rep.type = X_Reply;
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.num = 0; rep.num = 0;
if(surface->compatible_subpictures) if (surface->compatible_subpictures)
rep.num = surface->compatible_subpictures->num_xvimages; rep.num = surface->compatible_subpictures->num_xvimages;
rep.length = bytes_to_int32(rep.num * sizeof(xvImageFormatInfo)); rep.length = bytes_to_int32(rep.num * sizeof(xvImageFormatInfo));
WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), (char*)&rep); WriteToClient(client, sizeof(xvmcListSubpictureTypesReply), (char *) &rep);
for(i = 0; i < rep.num; i++) { for (i = 0; i < rep.num; i++) {
pImage = NULL; pImage = NULL;
for(j = 0; j < adaptor->num_subpictures; j++) { for (j = 0; j < adaptor->num_subpictures; j++) {
if(surface->compatible_subpictures->xvimage_ids[i] == if (surface->compatible_subpictures->xvimage_ids[i] ==
adaptor->subpictures[j]->id) adaptor->subpictures[j]->id) {
{ pImage = adaptor->subpictures[j];
pImage = adaptor->subpictures[j]; break;
break; }
} }
} if (!pImage)
if(!pImage) return BadImplementation; return BadImplementation;
info.id = pImage->id; info.id = pImage->id;
info.type = pImage->type; info.type = pImage->type;
info.byte_order = pImage->byte_order; info.byte_order = pImage->byte_order;
memcpy(&info.guid, pImage->guid, 16); memcpy(&info.guid, pImage->guid, 16);
info.bpp = pImage->bits_per_pixel; info.bpp = pImage->bits_per_pixel;
@ -555,7 +569,7 @@ ProcXvMCListSubpictureTypes(ClientPtr client)
info.vert_v_period = pImage->vert_v_period; info.vert_v_period = pImage->vert_v_period;
memcpy(&info.comp_order, pImage->component_order, 32); memcpy(&info.comp_order, pImage->component_order, 32);
info.scanline_order = pImage->scanline_order; info.scanline_order = pImage->scanline_order;
WriteToClient(client, sizeof(xvImageFormatInfo), (char*)&info); WriteToClient(client, sizeof(xvImageFormatInfo), (char *) &info);
} }
return Success; return Success;
@ -590,8 +604,8 @@ ProcXvMCGetDRInfo(ClientPtr client)
rep.busIDLen = bytes_to_int32(strlen(pScreenPriv->busID) + 1); rep.busIDLen = bytes_to_int32(strlen(pScreenPriv->busID) + 1);
rep.length = rep.nameLen + rep.busIDLen; rep.length = rep.nameLen + rep.busIDLen;
rep.nameLen <<=2; rep.nameLen <<= 2;
rep.busIDLen <<=2; rep.busIDLen <<= 2;
/* /*
* Read back to the client what she has put in the shared memory * Read back to the client what she has put in the shared memory
@ -600,64 +614,58 @@ ProcXvMCGetDRInfo(ClientPtr client)
rep.isLocal = 1; rep.isLocal = 1;
#ifdef HAS_XVMCSHM #ifdef HAS_XVMCSHM
patternP = (CARD32 *)shmat( stuff->shmKey, NULL, SHM_RDONLY ); patternP = (CARD32 *) shmat(stuff->shmKey, NULL, SHM_RDONLY);
if ( -1 != (long) patternP) { if (-1 != (long) patternP) {
volatile CARD32 *patternC = patternP; volatile CARD32 *patternC = patternP;
int i; int i;
CARD32 magic = stuff->magic; CARD32 magic = stuff->magic;
rep.isLocal = 1; rep.isLocal = 1;
i = 1024 / sizeof(CARD32); i = 1024 / sizeof(CARD32);
while ( i-- ) { while (i--) {
if (*patternC++ != magic) { if (*patternC++ != magic) {
rep.isLocal = 0; rep.isLocal = 0;
break; break;
} }
magic = ~magic; magic = ~magic;
} }
shmdt( (char *)patternP ); shmdt((char *) patternP);
} }
#endif /* HAS_XVMCSHM */ #endif /* HAS_XVMCSHM */
WriteToClient(client, sizeof(xvmcGetDRInfoReply), WriteToClient(client, sizeof(xvmcGetDRInfoReply), (char *) &rep);
(char*)&rep);
if (rep.length) { if (rep.length) {
WriteToClient(client, rep.nameLen, WriteToClient(client, rep.nameLen, pScreenPriv->clientDriverName);
pScreenPriv->clientDriverName); WriteToClient(client, rep.busIDLen, pScreenPriv->busID);
WriteToClient(client, rep.busIDLen,
pScreenPriv->busID);
} }
return Success; return Success;
} }
int (*ProcXvMCVector[xvmcNumRequest]) (ClientPtr) = {
int (*ProcXvMCVector[xvmcNumRequest])(ClientPtr) = { ProcXvMCQueryVersion,
ProcXvMCQueryVersion, ProcXvMCListSurfaceTypes,
ProcXvMCListSurfaceTypes, ProcXvMCCreateContext,
ProcXvMCCreateContext, ProcXvMCDestroyContext,
ProcXvMCDestroyContext, ProcXvMCCreateSurface,
ProcXvMCCreateSurface, ProcXvMCDestroySurface,
ProcXvMCDestroySurface, ProcXvMCCreateSubpicture,
ProcXvMCCreateSubpicture, ProcXvMCDestroySubpicture,
ProcXvMCDestroySubpicture, ProcXvMCListSubpictureTypes, ProcXvMCGetDRInfo};
ProcXvMCListSubpictureTypes,
ProcXvMCGetDRInfo
};
static int static int
ProcXvMCDispatch (ClientPtr client) ProcXvMCDispatch(ClientPtr client)
{ {
REQUEST(xReq); REQUEST(xReq);
if(stuff->data < xvmcNumRequest) if (stuff->data < xvmcNumRequest)
return (*ProcXvMCVector[stuff->data])(client); return (*ProcXvMCVector[stuff->data]) (client);
else else
return BadRequest; return BadRequest;
} }
static int static int
SProcXvMCDispatch (ClientPtr client) SProcXvMCDispatch(ClientPtr client)
{ {
/* We only support local */ /* We only support local */
return BadImplementation; return BadImplementation;
@ -666,38 +674,42 @@ SProcXvMCDispatch (ClientPtr client)
void void
XvMCExtensionInit(void) XvMCExtensionInit(void)
{ {
ExtensionEntry *extEntry; ExtensionEntry *extEntry;
if (!dixPrivateKeyRegistered(XvMCScreenKey)) if (!dixPrivateKeyRegistered(XvMCScreenKey))
return; return;
if(!(XvMCRTContext = CreateNewResourceType(XvMCDestroyContextRes, if (!(XvMCRTContext = CreateNewResourceType(XvMCDestroyContextRes,
"XvMCRTContext"))) "XvMCRTContext")))
return; return;
if(!(XvMCRTSurface = CreateNewResourceType(XvMCDestroySurfaceRes, if (!(XvMCRTSurface = CreateNewResourceType(XvMCDestroySurfaceRes,
"XvMCRTSurface"))) "XvMCRTSurface")))
return; return;
if(!(XvMCRTSubpicture = CreateNewResourceType(XvMCDestroySubpictureRes, if (!(XvMCRTSubpicture = CreateNewResourceType(XvMCDestroySubpictureRes,
"XvMCRTSubpicture"))) "XvMCRTSubpicture")))
return; return;
extEntry = AddExtension(XvMCName, XvMCNumEvents, XvMCNumErrors, extEntry = AddExtension(XvMCName, XvMCNumEvents, XvMCNumErrors,
ProcXvMCDispatch, SProcXvMCDispatch, ProcXvMCDispatch, SProcXvMCDispatch,
NULL, StandardMinorOpcode); NULL, StandardMinorOpcode);
if(!extEntry) return; if (!extEntry)
return;
XvMCReqCode = extEntry->base; XvMCReqCode = extEntry->base;
XvMCEventBase = extEntry->eventBase; XvMCEventBase = extEntry->eventBase;
SetResourceTypeErrorValue(XvMCRTContext, extEntry->errorBase + XvMCBadContext); SetResourceTypeErrorValue(XvMCRTContext,
SetResourceTypeErrorValue(XvMCRTSurface, extEntry->errorBase + XvMCBadSurface); extEntry->errorBase + XvMCBadContext);
SetResourceTypeErrorValue(XvMCRTSubpicture, extEntry->errorBase + XvMCBadSubpicture); SetResourceTypeErrorValue(XvMCRTSurface,
extEntry->errorBase + XvMCBadSurface);
SetResourceTypeErrorValue(XvMCRTSubpicture,
extEntry->errorBase + XvMCBadSubpicture);
} }
static Bool static Bool
XvMCCloseScreen (int i, ScreenPtr pScreen) XvMCCloseScreen(int i, ScreenPtr pScreen)
{ {
XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen); XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
@ -705,40 +717,40 @@ XvMCCloseScreen (int i, ScreenPtr pScreen)
free(pScreenPriv); free(pScreenPriv);
return (*pScreen->CloseScreen)(i, pScreen); return (*pScreen->CloseScreen) (i, pScreen);
} }
int int
XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt) XvMCScreenInit(ScreenPtr pScreen, int num, XvMCAdaptorPtr pAdapt)
{ {
XvMCScreenPtr pScreenPriv; XvMCScreenPtr pScreenPriv;
if (!dixRegisterPrivateKey(&XvMCScreenKeyRec, PRIVATE_SCREEN, 0)) if (!dixRegisterPrivateKey(&XvMCScreenKeyRec, PRIVATE_SCREEN, 0))
return BadAlloc; return BadAlloc;
if(!(pScreenPriv = malloc(sizeof(XvMCScreenRec)))) if (!(pScreenPriv = malloc(sizeof(XvMCScreenRec))))
return BadAlloc; return BadAlloc;
dixSetPrivate(&pScreen->devPrivates, XvMCScreenKey, pScreenPriv); dixSetPrivate(&pScreen->devPrivates, XvMCScreenKey, pScreenPriv);
pScreenPriv->CloseScreen = pScreen->CloseScreen; pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = XvMCCloseScreen; pScreen->CloseScreen = XvMCCloseScreen;
pScreenPriv->num_adaptors = num; pScreenPriv->num_adaptors = num;
pScreenPriv->adaptors = pAdapt; pScreenPriv->adaptors = pAdapt;
pScreenPriv->clientDriverName[0] = 0; pScreenPriv->clientDriverName[0] = 0;
pScreenPriv->busID[0] = 0; pScreenPriv->busID[0] = 0;
pScreenPriv->major = 0; pScreenPriv->major = 0;
pScreenPriv->minor = 0; pScreenPriv->minor = 0;
pScreenPriv->patchLevel = 0; pScreenPriv->patchLevel = 0;
XvMCInUse = TRUE; XvMCInUse = TRUE;
return Success; return Success;
} }
XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id) XvImagePtr
XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
{ {
XvImagePtr pImage = NULL; XvImagePtr pImage = NULL;
ScreenPtr pScreen = pPort->pAdaptor->pScreen; ScreenPtr pScreen = pPort->pAdaptor->pScreen;
@ -749,20 +761,21 @@ XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
if (!dixPrivateKeyRegistered(XvMCScreenKey)) if (!dixPrivateKeyRegistered(XvMCScreenKey))
return NULL; return NULL;
if(!(pScreenPriv = XVMC_GET_PRIVATE(pScreen))) if (!(pScreenPriv = XVMC_GET_PRIVATE(pScreen)))
return NULL; return NULL;
for(i = 0; i < pScreenPriv->num_adaptors; i++) { for (i = 0; i < pScreenPriv->num_adaptors; i++) {
if(pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) { if (pPort->pAdaptor == pScreenPriv->adaptors[i].xv_adaptor) {
adaptor = &(pScreenPriv->adaptors[i]); adaptor = &(pScreenPriv->adaptors[i]);
break; break;
} }
} }
if(!adaptor) return NULL; if (!adaptor)
return NULL;
for(i = 0; i < adaptor->num_subpictures; i++) { for (i = 0; i < adaptor->num_subpictures; i++) {
if(adaptor->subpictures[i]->id == id) { if (adaptor->subpictures[i]->id == id) {
pImage = adaptor->subpictures[i]; pImage = adaptor->subpictures[i];
break; break;
} }
@ -773,16 +786,14 @@ XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id)
int int
xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name, xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name,
char *busID, int major, int minor, char *busID, int major, int minor, int patchLevel)
int patchLevel)
{ {
XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen); XvMCScreenPtr pScreenPriv = XVMC_GET_PRIVATE(pScreen);
strlcpy(pScreenPriv->clientDriverName, name,
DR_CLIENT_DRIVER_NAME_SIZE); strlcpy(pScreenPriv->clientDriverName, name, DR_CLIENT_DRIVER_NAME_SIZE);
strlcpy(pScreenPriv->busID, busID, DR_BUSID_SIZE); strlcpy(pScreenPriv->busID, busID, DR_BUSID_SIZE);
pScreenPriv->major = major; pScreenPriv->major = major;
pScreenPriv->minor = minor; pScreenPriv->minor = minor;
pScreenPriv->patchLevel = patchLevel; pScreenPriv->patchLevel = patchLevel;
return Success; return Success;
} }

138
Xext/xvmcext.h
View File

@ -5,114 +5,96 @@
#include "xvdix.h" #include "xvdix.h"
typedef struct { typedef struct {
int num_xvimages; int num_xvimages;
int *xvimage_ids; int *xvimage_ids;
} XvMCImageIDList; } XvMCImageIDList;
typedef struct { typedef struct {
int surface_type_id; int surface_type_id;
int chroma_format; int chroma_format;
int color_description; int color_description;
unsigned short max_width; unsigned short max_width;
unsigned short max_height; unsigned short max_height;
unsigned short subpicture_max_width; unsigned short subpicture_max_width;
unsigned short subpicture_max_height; unsigned short subpicture_max_height;
int mc_type; int mc_type;
int flags; int flags;
XvMCImageIDList *compatible_subpictures; XvMCImageIDList *compatible_subpictures;
} XvMCSurfaceInfoRec, *XvMCSurfaceInfoPtr; } XvMCSurfaceInfoRec, *XvMCSurfaceInfoPtr;
typedef struct { typedef struct {
XID context_id; XID context_id;
ScreenPtr pScreen; ScreenPtr pScreen;
int adapt_num; int adapt_num;
int surface_type_id; int surface_type_id;
unsigned short width; unsigned short width;
unsigned short height; unsigned short height;
CARD32 flags; CARD32 flags;
int refcnt; int refcnt;
pointer port_priv; pointer port_priv;
pointer driver_priv; pointer driver_priv;
} XvMCContextRec, *XvMCContextPtr; } XvMCContextRec, *XvMCContextPtr;
typedef struct { typedef struct {
XID surface_id; XID surface_id;
int surface_type_id; int surface_type_id;
XvMCContextPtr context; XvMCContextPtr context;
pointer driver_priv; pointer driver_priv;
} XvMCSurfaceRec, *XvMCSurfacePtr; } XvMCSurfaceRec, *XvMCSurfacePtr;
typedef struct { typedef struct {
XID subpicture_id; XID subpicture_id;
int xvimage_id; int xvimage_id;
unsigned short width; unsigned short width;
unsigned short height; unsigned short height;
int num_palette_entries; int num_palette_entries;
int entry_bytes; int entry_bytes;
char component_order[4]; char component_order[4];
XvMCContextPtr context; XvMCContextPtr context;
pointer driver_priv; pointer driver_priv;
} XvMCSubpictureRec, *XvMCSubpicturePtr; } XvMCSubpictureRec, *XvMCSubpicturePtr;
typedef int (*XvMCCreateContextProcPtr) ( typedef int (*XvMCCreateContextProcPtr) (XvPortPtr port,
XvPortPtr port, XvMCContextPtr context,
XvMCContextPtr context, int *num_priv, CARD32 **priv);
int *num_priv,
CARD32 **priv
);
typedef void (*XvMCDestroyContextProcPtr) ( typedef void (*XvMCDestroyContextProcPtr) (XvMCContextPtr context);
XvMCContextPtr context
);
typedef int (*XvMCCreateSurfaceProcPtr) ( typedef int (*XvMCCreateSurfaceProcPtr) (XvMCSurfacePtr surface,
XvMCSurfacePtr surface, int *num_priv, CARD32 **priv);
int *num_priv,
CARD32 **priv
);
typedef void (*XvMCDestroySurfaceProcPtr) ( typedef void (*XvMCDestroySurfaceProcPtr) (XvMCSurfacePtr surface);
XvMCSurfacePtr surface
);
typedef int (*XvMCCreateSubpictureProcPtr) ( typedef int (*XvMCCreateSubpictureProcPtr) (XvMCSubpicturePtr subpicture,
XvMCSubpicturePtr subpicture, int *num_priv, CARD32 **priv);
int *num_priv,
CARD32 **priv
);
typedef void (*XvMCDestroySubpictureProcPtr) (
XvMCSubpicturePtr subpicture
);
typedef void (*XvMCDestroySubpictureProcPtr) (XvMCSubpicturePtr subpicture);
typedef struct { typedef struct {
XvAdaptorPtr xv_adaptor; XvAdaptorPtr xv_adaptor;
int num_surfaces; int num_surfaces;
XvMCSurfaceInfoPtr *surfaces; XvMCSurfaceInfoPtr *surfaces;
int num_subpictures; int num_subpictures;
XvImagePtr *subpictures; XvImagePtr *subpictures;
XvMCCreateContextProcPtr CreateContext; XvMCCreateContextProcPtr CreateContext;
XvMCDestroyContextProcPtr DestroyContext; XvMCDestroyContextProcPtr DestroyContext;
XvMCCreateSurfaceProcPtr CreateSurface; XvMCCreateSurfaceProcPtr CreateSurface;
XvMCDestroySurfaceProcPtr DestroySurface; XvMCDestroySurfaceProcPtr DestroySurface;
XvMCCreateSubpictureProcPtr CreateSubpicture; XvMCCreateSubpictureProcPtr CreateSubpicture;
XvMCDestroySubpictureProcPtr DestroySubpicture; XvMCDestroySubpictureProcPtr DestroySubpicture;
} XvMCAdaptorRec, *XvMCAdaptorPtr; } XvMCAdaptorRec, *XvMCAdaptorPtr;
#ifndef XorgLoader #ifndef XorgLoader
extern _X_EXPORT void XvMCExtensionInit(void); extern _X_EXPORT void XvMCExtensionInit(void);
extern _X_EXPORT int XvMCScreenInit(ScreenPtr pScreen, extern _X_EXPORT int XvMCScreenInit(ScreenPtr pScreen,
int num, int num, XvMCAdaptorPtr adapt);
XvMCAdaptorPtr adapt);
extern _X_EXPORT XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id); extern _X_EXPORT XvImagePtr XvMCFindXvImage(XvPortPtr pPort, CARD32 id);
extern _X_EXPORT int xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name, extern _X_EXPORT int xf86XvMCRegisterDRInfo(ScreenPtr pScreen, char *name,
char *busID, int major, int minor, char *busID, int major, int minor,
int patchLevel); int patchLevel);
#endif #endif
#endif /* _XVMC_H */ #endif /* _XVMC_H */

32
Xi/allowev.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
@ -97,31 +97,31 @@ ProcXAllowDeviceEvents(ClientPtr client)
rc = dixLookupDevice(&thisdev, stuff->deviceid, client, DixGetAttrAccess); rc = dixLookupDevice(&thisdev, stuff->deviceid, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
time = ClientTimeToServerTime(stuff->time); time = ClientTimeToServerTime(stuff->time);
switch (stuff->mode) { switch (stuff->mode) {
case ReplayThisDevice: case ReplayThisDevice:
AllowSome(client, time, thisdev, NOT_GRABBED); AllowSome(client, time, thisdev, NOT_GRABBED);
break; break;
case SyncThisDevice: case SyncThisDevice:
AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT); AllowSome(client, time, thisdev, FREEZE_NEXT_EVENT);
break; break;
case AsyncThisDevice: case AsyncThisDevice:
AllowSome(client, time, thisdev, THAWED); AllowSome(client, time, thisdev, THAWED);
break; break;
case AsyncOtherDevices: case AsyncOtherDevices:
AllowSome(client, time, thisdev, THAW_OTHERS); AllowSome(client, time, thisdev, THAW_OTHERS);
break; break;
case SyncAll: case SyncAll:
AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT); AllowSome(client, time, thisdev, FREEZE_BOTH_NEXT_EVENT);
break; break;
case AsyncAll: case AsyncAll:
AllowSome(client, time, thisdev, THAWED_BOTH); AllowSome(client, time, thisdev, THAWED_BOTH);
break; break;
default: default:
client->errorValue = stuff->mode; client->errorValue = stuff->mode;
return BadValue; return BadValue;
} }
return Success; return Success;
} }

6
Xi/allowev.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef ALLOWEV_H #ifndef ALLOWEV_H
#define ALLOWEV_H 1 #define ALLOWEV_H 1
int SProcXAllowDeviceEvents(ClientPtr /* client */ int SProcXAllowDeviceEvents(ClientPtr /* client */
); );
int ProcXAllowDeviceEvents(ClientPtr /* client */ int ProcXAllowDeviceEvents(ClientPtr /* client */
); );
#endif /* ALLOWEV_H */ #endif /* ALLOWEV_H */

91
Xi/chgdctl.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> /* control constants */ #include <X11/extensions/XIproto.h> /* control constants */
#include "XIstubs.h" #include "XIstubs.h"
#include "exglobals.h" #include "exglobals.h"
@ -80,17 +80,17 @@ SProcXChangeDeviceControl(ClientPtr client)
swaps(&stuff->length); swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq); REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
swaps(&stuff->control); swaps(&stuff->control);
ctl = (xDeviceCtl*)&stuff[1]; ctl = (xDeviceCtl *) & stuff[1];
swaps(&ctl->control); swaps(&ctl->control);
swaps(&ctl->length); swaps(&ctl->length);
switch(stuff->control) { switch (stuff->control) {
case DEVICE_ABS_CALIB: case DEVICE_ABS_CALIB:
case DEVICE_ABS_AREA: case DEVICE_ABS_AREA:
case DEVICE_CORE: case DEVICE_CORE:
case DEVICE_ENABLE: case DEVICE_ENABLE:
case DEVICE_RESOLUTION: case DEVICE_RESOLUTION:
/* hmm. beer. *drool* */ /* hmm. beer. *drool* */
break; break;
} }
return (ProcXChangeDeviceControl(client)); return (ProcXChangeDeviceControl(client));
@ -130,44 +130,47 @@ ProcXChangeDeviceControl(ClientPtr client)
switch (stuff->control) { switch (stuff->control) {
case DEVICE_RESOLUTION: case DEVICE_RESOLUTION:
r = (xDeviceResolutionCtl *) & stuff[1]; r = (xDeviceResolutionCtl *) & stuff[1];
if ((len < bytes_to_int32(sizeof(xDeviceResolutionCtl))) || if ((len < bytes_to_int32(sizeof(xDeviceResolutionCtl))) ||
(len != bytes_to_int32(sizeof(xDeviceResolutionCtl)) + r->num_valuators)) { (len !=
bytes_to_int32(sizeof(xDeviceResolutionCtl)) + r->num_valuators)) {
ret = BadLength; ret = BadLength;
goto out; goto out;
} }
if (!dev->valuator) { if (!dev->valuator) {
ret = BadMatch; ret = BadMatch;
goto out; goto out;
} }
if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) { if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client)) {
rep.status = AlreadyGrabbed; rep.status = AlreadyGrabbed;
ret = Success; ret = Success;
goto out; goto out;
} }
resolution = (CARD32 *) (r + 1); resolution = (CARD32 *) (r + 1);
if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) { if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
ret = BadValue; ret = BadValue;
goto out; goto out;
} }
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r); status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
if (status == Success) { if (status == Success) {
a = &dev->valuator->axes[r->first_valuator]; a = &dev->valuator->axes[r->first_valuator];
for (i = 0; i < r->num_valuators; i++) for (i = 0; i < r->num_valuators; i++)
if (*(resolution + i) < (a + i)->min_resolution || if (*(resolution + i) < (a + i)->min_resolution ||
*(resolution + i) > (a + i)->max_resolution) *(resolution + i) > (a + i)->max_resolution)
return BadValue; return BadValue;
for (i = 0; i < r->num_valuators; i++) for (i = 0; i < r->num_valuators; i++)
(a++)->resolution = *resolution++; (a++)->resolution = *resolution++;
ret = Success; ret = Success;
} else if (status == DeviceBusy) { }
rep.status = DeviceBusy; else if (status == DeviceBusy) {
rep.status = DeviceBusy;
ret = Success; ret = Success;
} else { }
else {
ret = BadMatch; ret = BadMatch;
} }
break; break;
case DEVICE_ABS_CALIB: case DEVICE_ABS_CALIB:
case DEVICE_ABS_AREA: case DEVICE_ABS_AREA:
/* Calibration is now done through properties, and never had any effect /* Calibration is now done through properties, and never had any effect
@ -180,7 +183,7 @@ ProcXChangeDeviceControl(ClientPtr client)
ret = BadMatch; ret = BadMatch;
break; break;
case DEVICE_ENABLE: case DEVICE_ENABLE:
e = (xDeviceEnableCtl *)&stuff[1]; e = (xDeviceEnableCtl *) & stuff[1];
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e); status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
@ -190,10 +193,12 @@ ProcXChangeDeviceControl(ClientPtr client)
else else
DisableDevice(dev, TRUE); DisableDevice(dev, TRUE);
ret = Success; ret = Success;
} else if (status == DeviceBusy) { }
else if (status == DeviceBusy) {
rep.status = DeviceBusy; rep.status = DeviceBusy;
ret = Success; ret = Success;
} else { }
else {
ret = BadMatch; ret = BadMatch;
} }
@ -202,7 +207,7 @@ ProcXChangeDeviceControl(ClientPtr client)
ret = BadValue; ret = BadValue;
} }
out: out:
if (ret == Success) { if (ret == Success) {
dpn.type = DevicePresenceNotify; dpn.type = DevicePresenceNotify;
dpn.time = currentTime.milliseconds; dpn.time = currentTime.milliseconds;
@ -227,9 +232,9 @@ out:
void void
SRepXChangeDeviceControl(ClientPtr client, int size, SRepXChangeDeviceControl(ClientPtr client, int size,
xChangeDeviceControlReply * rep) xChangeDeviceControlReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/chgdctl.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGDCTL_H #ifndef CHGDCTL_H
#define CHGDCTL_H 1 #define CHGDCTL_H 1
int SProcXChangeDeviceControl(ClientPtr /* client */ int SProcXChangeDeviceControl(ClientPtr /* client */
); );
int ProcXChangeDeviceControl(ClientPtr /* client */ int ProcXChangeDeviceControl(ClientPtr /* client */
); );
void SRepXChangeDeviceControl(ClientPtr /* client */ , void SRepXChangeDeviceControl(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xChangeDeviceControlReply * /* rep */ xChangeDeviceControlReply * /* rep */
); );
#endif /* CHGDCTL_H */ #endif /* CHGDCTL_H */

433
Xi/chgfctl.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> /* control constants */ #include <X11/extensions/XIproto.h> /* control constants */
#include "exglobals.h" #include "exglobals.h"
@ -89,107 +89,110 @@ SProcXChangeFeedbackControl(ClientPtr client)
static int static int
ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask, ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
KbdFeedbackPtr k, xKbdFeedbackCtl * f) KbdFeedbackPtr k, xKbdFeedbackCtl * f)
{ {
KeybdCtrl kctrl; KeybdCtrl kctrl;
int t; int t;
int key = DO_ALL; int key = DO_ALL;
if (client->swapped) { if (client->swapped) {
swaps(&f->length); swaps(&f->length);
swaps(&f->pitch); swaps(&f->pitch);
swaps(&f->duration); swaps(&f->duration);
swapl(&f->led_mask); swapl(&f->led_mask);
swapl(&f->led_values); swapl(&f->led_values);
} }
kctrl = k->ctrl; kctrl = k->ctrl;
if (mask & DvKeyClickPercent) { if (mask & DvKeyClickPercent) {
t = f->click; t = f->click;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.click; t = defaultKeyboardControl.click;
else if (t < 0 || t > 100) { else if (t < 0 || t > 100) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
kctrl.click = t; kctrl.click = t;
} }
if (mask & DvPercent) { if (mask & DvPercent) {
t = f->percent; t = f->percent;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell; t = defaultKeyboardControl.bell;
else if (t < 0 || t > 100) { else if (t < 0 || t > 100) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
kctrl.bell = t; kctrl.bell = t;
} }
if (mask & DvPitch) { if (mask & DvPitch) {
t = f->pitch; t = f->pitch;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell_pitch; t = defaultKeyboardControl.bell_pitch;
else if (t < 0) { else if (t < 0) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
kctrl.bell_pitch = t; kctrl.bell_pitch = t;
} }
if (mask & DvDuration) { if (mask & DvDuration) {
t = f->duration; t = f->duration;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell_duration; t = defaultKeyboardControl.bell_duration;
else if (t < 0) { else if (t < 0) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
kctrl.bell_duration = t; kctrl.bell_duration = t;
} }
if (mask & DvLed) { if (mask & DvLed) {
kctrl.leds &= ~(f->led_mask); kctrl.leds &= ~(f->led_mask);
kctrl.leds |= (f->led_mask & f->led_values); kctrl.leds |= (f->led_mask & f->led_values);
} }
if (mask & DvKey) { if (mask & DvKey) {
key = (KeyCode) f->key; key = (KeyCode) f->key;
if (key < 8 || key > 255) { if (key < 8 || key > 255) {
client->errorValue = key; client->errorValue = key;
return BadValue; return BadValue;
} }
if (!(mask & DvAutoRepeatMode)) if (!(mask & DvAutoRepeatMode))
return BadMatch; return BadMatch;
} }
if (mask & DvAutoRepeatMode) { if (mask & DvAutoRepeatMode) {
int inx = (key >> 3); int inx = (key >> 3);
int kmask = (1 << (key & 7)); int kmask = (1 << (key & 7));
t = (CARD8) f->auto_repeat_mode; t = (CARD8) f->auto_repeat_mode;
if (t == AutoRepeatModeOff) { if (t == AutoRepeatModeOff) {
if (key == DO_ALL) if (key == DO_ALL)
kctrl.autoRepeat = FALSE; kctrl.autoRepeat = FALSE;
else else
kctrl.autoRepeats[inx] &= ~kmask; kctrl.autoRepeats[inx] &= ~kmask;
} else if (t == AutoRepeatModeOn) { }
if (key == DO_ALL) else if (t == AutoRepeatModeOn) {
kctrl.autoRepeat = TRUE; if (key == DO_ALL)
else kctrl.autoRepeat = TRUE;
kctrl.autoRepeats[inx] |= kmask; else
} else if (t == AutoRepeatModeDefault) { kctrl.autoRepeats[inx] |= kmask;
if (key == DO_ALL) }
kctrl.autoRepeat = defaultKeyboardControl.autoRepeat; else if (t == AutoRepeatModeDefault) {
else if (key == DO_ALL)
kctrl.autoRepeats[inx] &= ~kmask; kctrl.autoRepeat = defaultKeyboardControl.autoRepeat;
kctrl.autoRepeats[inx] = else
(kctrl.autoRepeats[inx] & ~kmask) | kctrl.autoRepeats[inx] &= ~kmask;
(defaultKeyboardControl.autoRepeats[inx] & kmask); kctrl.autoRepeats[inx] =
} else { (kctrl.autoRepeats[inx] & ~kmask) |
client->errorValue = t; (defaultKeyboardControl.autoRepeats[inx] & kmask);
return BadValue; }
} else {
client->errorValue = t;
return BadValue;
}
} }
k->ctrl = kctrl; k->ctrl = kctrl;
@ -205,55 +208,58 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
static int static int
ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask, ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
PtrFeedbackPtr p, xPtrFeedbackCtl * f) PtrFeedbackPtr p, xPtrFeedbackCtl * f)
{ {
PtrCtrl pctrl; /* might get BadValue part way through */ PtrCtrl pctrl; /* might get BadValue part way through */
if (client->swapped) { if (client->swapped) {
swaps(&f->length); swaps(&f->length);
swaps(&f->num); swaps(&f->num);
swaps(&f->denom); swaps(&f->denom);
swaps(&f->thresh); swaps(&f->thresh);
} }
pctrl = p->ctrl; pctrl = p->ctrl;
if (mask & DvAccelNum) { if (mask & DvAccelNum) {
int accelNum; int accelNum;
accelNum = f->num; accelNum = f->num;
if (accelNum == -1) if (accelNum == -1)
pctrl.num = defaultPointerControl.num; pctrl.num = defaultPointerControl.num;
else if (accelNum < 0) { else if (accelNum < 0) {
client->errorValue = accelNum; client->errorValue = accelNum;
return BadValue; return BadValue;
} else }
pctrl.num = accelNum; else
pctrl.num = accelNum;
} }
if (mask & DvAccelDenom) { if (mask & DvAccelDenom) {
int accelDenom; int accelDenom;
accelDenom = f->denom; accelDenom = f->denom;
if (accelDenom == -1) if (accelDenom == -1)
pctrl.den = defaultPointerControl.den; pctrl.den = defaultPointerControl.den;
else if (accelDenom <= 0) { else if (accelDenom <= 0) {
client->errorValue = accelDenom; client->errorValue = accelDenom;
return BadValue; return BadValue;
} else }
pctrl.den = accelDenom; else
pctrl.den = accelDenom;
} }
if (mask & DvThreshold) { if (mask & DvThreshold) {
int threshold; int threshold;
threshold = f->thresh; threshold = f->thresh;
if (threshold == -1) if (threshold == -1)
pctrl.threshold = defaultPointerControl.threshold; pctrl.threshold = defaultPointerControl.threshold;
else if (threshold < 0) { else if (threshold < 0) {
client->errorValue = threshold; client->errorValue = threshold;
return BadValue; return BadValue;
} else }
pctrl.threshold = threshold; else
pctrl.threshold = threshold;
} }
p->ctrl = pctrl; p->ctrl = pctrl;
@ -269,12 +275,12 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
static int static int
ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev, ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, IntegerFeedbackPtr i, long unsigned int mask, IntegerFeedbackPtr i,
xIntegerFeedbackCtl * f) xIntegerFeedbackCtl * f)
{ {
if (client->swapped) { if (client->swapped) {
swaps(&f->length); swaps(&f->length);
swapl(&f->int_to_display); swapl(&f->int_to_display);
} }
i->ctrl.integer_displayed = f->int_to_display; i->ctrl.integer_displayed = f->int_to_display;
@ -290,33 +296,33 @@ ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
static int static int
ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev, ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, StringFeedbackPtr s, long unsigned int mask, StringFeedbackPtr s,
xStringFeedbackCtl * f) xStringFeedbackCtl * f)
{ {
int i, j; int i, j;
KeySym *syms, *sup_syms; KeySym *syms, *sup_syms;
syms = (KeySym *) (f + 1); syms = (KeySym *) (f + 1);
if (client->swapped) { if (client->swapped) {
swaps(&f->length); /* swapped num_keysyms in calling proc */ swaps(&f->length); /* swapped num_keysyms in calling proc */
SwapLongs((CARD32 *) syms, f->num_keysyms); SwapLongs((CARD32 *) syms, f->num_keysyms);
} }
if (f->num_keysyms > s->ctrl.max_symbols) if (f->num_keysyms > s->ctrl.max_symbols)
return BadValue; return BadValue;
sup_syms = s->ctrl.symbols_supported; sup_syms = s->ctrl.symbols_supported;
for (i = 0; i < f->num_keysyms; i++) { for (i = 0; i < f->num_keysyms; i++) {
for (j = 0; j < s->ctrl.num_symbols_supported; j++) for (j = 0; j < s->ctrl.num_symbols_supported; j++)
if (*(syms + i) == *(sup_syms + j)) if (*(syms + i) == *(sup_syms + j))
break; break;
if (j == s->ctrl.num_symbols_supported) if (j == s->ctrl.num_symbols_supported)
return BadMatch; return BadMatch;
} }
s->ctrl.num_symbols_displayed = f->num_keysyms; s->ctrl.num_symbols_displayed = f->num_keysyms;
for (i = 0; i < f->num_keysyms; i++) for (i = 0; i < f->num_keysyms; i++)
*(s->ctrl.symbols_displayed + i) = *(syms + i); *(s->ctrl.symbols_displayed + i) = *(syms + i);
(*s->CtrlProc) (dev, &s->ctrl); (*s->CtrlProc) (dev, &s->ctrl);
return Success; return Success;
} }
@ -329,50 +335,50 @@ ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
static int static int
ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev, ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, BellFeedbackPtr b, long unsigned int mask, BellFeedbackPtr b,
xBellFeedbackCtl * f) xBellFeedbackCtl * f)
{ {
int t; int t;
BellCtrl bctrl; /* might get BadValue part way through */ BellCtrl bctrl; /* might get BadValue part way through */
if (client->swapped) { if (client->swapped) {
swaps(&f->length); swaps(&f->length);
swaps(&f->pitch); swaps(&f->pitch);
swaps(&f->duration); swaps(&f->duration);
} }
bctrl = b->ctrl; bctrl = b->ctrl;
if (mask & DvPercent) { if (mask & DvPercent) {
t = f->percent; t = f->percent;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell; t = defaultKeyboardControl.bell;
else if (t < 0 || t > 100) { else if (t < 0 || t > 100) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
bctrl.percent = t; bctrl.percent = t;
} }
if (mask & DvPitch) { if (mask & DvPitch) {
t = f->pitch; t = f->pitch;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell_pitch; t = defaultKeyboardControl.bell_pitch;
else if (t < 0) { else if (t < 0) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
bctrl.pitch = t; bctrl.pitch = t;
} }
if (mask & DvDuration) { if (mask & DvDuration) {
t = f->duration; t = f->duration;
if (t == -1) if (t == -1)
t = defaultKeyboardControl.bell_duration; t = defaultKeyboardControl.bell_duration;
else if (t < 0) { else if (t < 0) {
client->errorValue = t; client->errorValue = t;
return BadValue; return BadValue;
} }
bctrl.duration = t; bctrl.duration = t;
} }
b->ctrl = bctrl; b->ctrl = bctrl;
(*b->CtrlProc) (dev, &b->ctrl); (*b->CtrlProc) (dev, &b->ctrl);
@ -387,24 +393,24 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
static int static int
ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask, ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
LedFeedbackPtr l, xLedFeedbackCtl * f) LedFeedbackPtr l, xLedFeedbackCtl * f)
{ {
LedCtrl lctrl; /* might get BadValue part way through */ LedCtrl lctrl; /* might get BadValue part way through */
if (client->swapped) { if (client->swapped) {
swaps(&f->length); swaps(&f->length);
swapl(&f->led_values); swapl(&f->led_values);
swapl(&f->led_mask); swapl(&f->led_mask);
} }
f->led_mask &= l->ctrl.led_mask; /* set only supported leds */ f->led_mask &= l->ctrl.led_mask; /* set only supported leds */
f->led_values &= l->ctrl.led_mask; /* set only supported leds */ f->led_values &= l->ctrl.led_mask; /* set only supported leds */
if (mask & DvLed) { if (mask & DvLed) {
lctrl.led_mask = f->led_mask; lctrl.led_mask = f->led_mask;
lctrl.led_values = f->led_values; lctrl.led_values = f->led_values;
(*l->CtrlProc) (dev, &lctrl); (*l->CtrlProc) (dev, &lctrl);
l->ctrl.led_values &= ~(f->led_mask); /* zero changed leds */ l->ctrl.led_values &= ~(f->led_mask); /* zero changed leds */
l->ctrl.led_values |= (f->led_mask & f->led_values); /* OR in set leds */ l->ctrl.led_values |= (f->led_mask & f->led_values); /* OR in set leds */
} }
return Success; return Success;
@ -435,74 +441,75 @@ ProcXChangeFeedbackControl(ClientPtr client)
len = stuff->length - bytes_to_int32(sizeof(xChangeFeedbackControlReq)); len = stuff->length - bytes_to_int32(sizeof(xChangeFeedbackControlReq));
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
switch (stuff->feedbackid) { switch (stuff->feedbackid) {
case KbdFeedbackClass: case KbdFeedbackClass:
if (len != bytes_to_int32(sizeof(xKbdFeedbackCtl))) if (len != bytes_to_int32(sizeof(xKbdFeedbackCtl)))
return BadLength; return BadLength;
for (k = dev->kbdfeed; k; k = k->next) for (k = dev->kbdfeed; k; k = k->next)
if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id)
return ChangeKbdFeedback(client, dev, stuff->mask, k, return ChangeKbdFeedback(client, dev, stuff->mask, k,
(xKbdFeedbackCtl *) & stuff[1]); (xKbdFeedbackCtl *) & stuff[1]);
break; break;
case PtrFeedbackClass: case PtrFeedbackClass:
if (len != bytes_to_int32(sizeof(xPtrFeedbackCtl))) if (len != bytes_to_int32(sizeof(xPtrFeedbackCtl)))
return BadLength; return BadLength;
for (p = dev->ptrfeed; p; p = p->next) for (p = dev->ptrfeed; p; p = p->next)
if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id)
return ChangePtrFeedback(client, dev, stuff->mask, p, return ChangePtrFeedback(client, dev, stuff->mask, p,
(xPtrFeedbackCtl *) & stuff[1]); (xPtrFeedbackCtl *) & stuff[1]);
break; break;
case StringFeedbackClass: case StringFeedbackClass:
{ {
xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]); xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]);
if (client->swapped) { if (client->swapped) {
swaps(&f->num_keysyms); swaps(&f->num_keysyms);
} }
if (len != (bytes_to_int32(sizeof(xStringFeedbackCtl)) + f->num_keysyms)) if (len !=
return BadLength; (bytes_to_int32(sizeof(xStringFeedbackCtl)) + f->num_keysyms))
return BadLength;
for (s = dev->stringfeed; s; s = s->next) for (s = dev->stringfeed; s; s = s->next)
if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id)
return ChangeStringFeedback(client, dev, stuff->mask, s, return ChangeStringFeedback(client, dev, stuff->mask, s,
(xStringFeedbackCtl *) & stuff[1]); (xStringFeedbackCtl *) & stuff[1]);
break; break;
} }
case IntegerFeedbackClass: case IntegerFeedbackClass:
if (len != bytes_to_int32(sizeof(xIntegerFeedbackCtl))) if (len != bytes_to_int32(sizeof(xIntegerFeedbackCtl)))
return BadLength; return BadLength;
for (i = dev->intfeed; i; i = i->next) for (i = dev->intfeed; i; i = i->next)
if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id)
return ChangeIntegerFeedback(client, dev, stuff->mask, i, return ChangeIntegerFeedback(client, dev, stuff->mask, i,
(xIntegerFeedbackCtl *)&stuff[1]); (xIntegerFeedbackCtl *) &
break; stuff[1]);
break;
case LedFeedbackClass: case LedFeedbackClass:
if (len != bytes_to_int32(sizeof(xLedFeedbackCtl))) if (len != bytes_to_int32(sizeof(xLedFeedbackCtl)))
return BadLength; return BadLength;
for (l = dev->leds; l; l = l->next) for (l = dev->leds; l; l = l->next)
if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id)
return ChangeLedFeedback(client, dev, stuff->mask, l, return ChangeLedFeedback(client, dev, stuff->mask, l,
(xLedFeedbackCtl *) & stuff[1]); (xLedFeedbackCtl *) & stuff[1]);
break; break;
case BellFeedbackClass: case BellFeedbackClass:
if (len != bytes_to_int32(sizeof(xBellFeedbackCtl))) if (len != bytes_to_int32(sizeof(xBellFeedbackCtl)))
return BadLength; return BadLength;
for (b = dev->bell; b; b = b->next) for (b = dev->bell; b; b = b->next)
if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id)
return ChangeBellFeedback(client, dev, stuff->mask, b, return ChangeBellFeedback(client, dev, stuff->mask, b,
(xBellFeedbackCtl *) & stuff[1]); (xBellFeedbackCtl *) & stuff[1]);
break; break;
default: default:
break; break;
} }
return BadMatch; return BadMatch;
} }

6
Xi/chgfctl.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGFCTL_H #ifndef CHGFCTL_H
#define CHGFCTL_H 1 #define CHGFCTL_H 1
int SProcXChangeFeedbackControl(ClientPtr /* client */ int SProcXChangeFeedbackControl(ClientPtr /* client */
); );
int ProcXChangeFeedbackControl(ClientPtr /* client */ int ProcXChangeFeedbackControl(ClientPtr /* client */
); );
#endif /* CHGFCTL_H */ #endif /* CHGFCTL_H */

2
Xi/chgkbd.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "XIstubs.h" #include "XIstubs.h"

6
Xi/chgkbd.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGKBD_H #ifndef CHGKBD_H
#define CHGKBD_H 1 #define CHGKBD_H 1
int SProcXChangeKeyboardDevice(ClientPtr /* client */ int SProcXChangeKeyboardDevice(ClientPtr /* client */
); );
int ProcXChangeKeyboardDevice(ClientPtr /* client */ int ProcXChangeKeyboardDevice(ClientPtr /* client */
); );
#endif /* CHGKBD_H */ #endif /* CHGKBD_H */

8
Xi/chgkmap.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -105,12 +105,12 @@ ProcXChangeDeviceKeyMapping(ClientPtr client)
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess); ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
len = stuff->length - bytes_to_int32(sizeof(xChangeDeviceKeyMappingReq)); len = stuff->length - bytes_to_int32(sizeof(xChangeDeviceKeyMappingReq));
ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify, ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify,
stuff->firstKeyCode, stuff->keyCodes, stuff->firstKeyCode, stuff->keyCodes,
stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]); stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]);
return ret; return ret;
} }

6
Xi/chgkmap.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGKMAP_H #ifndef CHGKMAP_H
#define CHGKMAP_H 1 #define CHGKMAP_H 1
int SProcXChangeDeviceKeyMapping(ClientPtr /* client */ int SProcXChangeDeviceKeyMapping(ClientPtr /* client */
); );
int ProcXChangeDeviceKeyMapping(ClientPtr /* client */ int ProcXChangeDeviceKeyMapping(ClientPtr /* client */
); );
#endif /* CHGKMAP_H */ #endif /* CHGKMAP_H */

43
Xi/chgprop.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" #include "windowstr.h"
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
@ -80,7 +80,7 @@ SProcXChangeDeviceDontPropagateList(ClientPtr client)
swapl(&stuff->window); swapl(&stuff->window);
swaps(&stuff->count); swaps(&stuff->count);
REQUEST_FIXED_SIZE(xChangeDeviceDontPropagateListReq, REQUEST_FIXED_SIZE(xChangeDeviceDontPropagateListReq,
stuff->count * sizeof(CARD32)); stuff->count * sizeof(CARD32));
SwapLongs((CARD32 *) (&stuff[1]), stuff->count); SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
return (ProcXChangeDeviceDontPropagateList(client)); return (ProcXChangeDeviceDontPropagateList(client));
} }
@ -102,39 +102,40 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
REQUEST(xChangeDeviceDontPropagateListReq); REQUEST(xChangeDeviceDontPropagateListReq);
REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq); REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
if (stuff->length != bytes_to_int32(sizeof(xChangeDeviceDontPropagateListReq)) + if (stuff->length !=
stuff->count) bytes_to_int32(sizeof(xChangeDeviceDontPropagateListReq)) +
return BadLength; stuff->count)
return BadLength;
rc = dixLookupWindow(&pWin, stuff->window, client, DixSetAttrAccess); rc = dixLookupWindow(&pWin, stuff->window, client, DixSetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (stuff->mode != AddToList && stuff->mode != DeleteFromList) { if (stuff->mode != AddToList && stuff->mode != DeleteFromList) {
client->errorValue = stuff->window; client->errorValue = stuff->window;
return BadMode; return BadMode;
} }
if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1], if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
stuff->count, tmp, NULL, stuff->count, tmp, NULL,
X_ChangeDeviceDontPropagateList)) != Success) X_ChangeDeviceDontPropagateList)) != Success)
return rc; return rc;
others = wOtherInputMasks(pWin); others = wOtherInputMasks(pWin);
if (!others && stuff->mode == DeleteFromList) if (!others && stuff->mode == DeleteFromList)
return Success; return Success;
for (i = 0; i < EMASKSIZE; i++) { for (i = 0; i < EMASKSIZE; i++) {
if (tmp[i].mask == 0) if (tmp[i].mask == 0)
continue; continue;
if (stuff->mode == DeleteFromList) if (stuff->mode == DeleteFromList)
tmp[i].mask = (others->dontPropagateMask[i] & ~tmp[i].mask); tmp[i].mask = (others->dontPropagateMask[i] & ~tmp[i].mask);
else if (others) else if (others)
tmp[i].mask |= others->dontPropagateMask[i]; tmp[i].mask |= others->dontPropagateMask[i];
if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) != if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
Success) Success)
return BadClass; return BadClass;
} }
return Success; return Success;

6
Xi/chgprop.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGPROP_H #ifndef CHGPROP_H
#define CHGPROP_H 1 #define CHGPROP_H 1
int SProcXChangeDeviceDontPropagateList(ClientPtr /* client */ int SProcXChangeDeviceDontPropagateList(ClientPtr /* client */
); );
int ProcXChangeDeviceDontPropagateList(ClientPtr /* client */ int ProcXChangeDeviceDontPropagateList(ClientPtr /* client */
); );
#endif /* CHGPROP_H */ #endif /* CHGPROP_H */

6
Xi/chgptr.c
View File

@ -54,12 +54,12 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "XIstubs.h" #include "XIstubs.h"
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include "scrnintstr.h" /* screen structure */ #include "scrnintstr.h" /* screen structure */
#include "dixevents.h" #include "dixevents.h"
#include "exevents.h" #include "exevents.h"

14
Xi/chgptr.h
View File

@ -30,19 +30,19 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CHGPTR_H #ifndef CHGPTR_H
#define CHGPTR_H 1 #define CHGPTR_H 1
int SProcXChangePointerDevice(ClientPtr /* client */ int SProcXChangePointerDevice(ClientPtr /* client */
); );
int ProcXChangePointerDevice(ClientPtr /* client */ int ProcXChangePointerDevice(ClientPtr /* client */
); );
void DeleteFocusClassDeviceStruct(DeviceIntPtr /* dev */ void DeleteFocusClassDeviceStruct(DeviceIntPtr /* dev */
); );
void SendEventToAllWindows(DeviceIntPtr /* dev */ , void SendEventToAllWindows(DeviceIntPtr /* dev */ ,
Mask /* mask */ , Mask /* mask */ ,
xEvent * /* ev */ , xEvent * /* ev */ ,
int /* count */ int /* count */
); );
#endif /* CHGPTR_H */ #endif /* CHGPTR_H */

40
Xi/closedev.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include "scrnintstr.h" /* screen structure */ #include "scrnintstr.h" /* screen structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "XIstubs.h" #include "XIstubs.h"
@ -94,15 +94,15 @@ DeleteDeviceEvents(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
GrabPtr grab, next; GrabPtr grab, next;
if ((pOthers = wOtherInputMasks(pWin)) != 0) if ((pOthers = wOtherInputMasks(pWin)) != 0)
for (others = pOthers->inputClients; others; others = others->next) for (others = pOthers->inputClients; others; others = others->next)
if (SameClient(others, client)) if (SameClient(others, client))
others->mask[dev->id] = NoEventMask; others->mask[dev->id] = NoEventMask;
for (grab = wPassiveGrabs(pWin); grab; grab = next) { for (grab = wPassiveGrabs(pWin); grab; grab = next) {
next = grab->next; next = grab->next;
if ((grab->device == dev) && if ((grab->device == dev) &&
(client->clientAsMask == CLIENT_BITS(grab->resource))) (client->clientAsMask == CLIENT_BITS(grab->resource)))
FreeResource(grab->resource, RT_NONE); FreeResource(grab->resource, RT_NONE);
} }
} }
@ -119,10 +119,10 @@ DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
WindowPtr p2; WindowPtr p2;
while (p1) { while (p1) {
p2 = p1->firstChild; p2 = p1->firstChild;
DeleteDeviceEvents(dev, p1, client); DeleteDeviceEvents(dev, p1, client);
DeleteEventsFromChildren(dev, p2, client); DeleteEventsFromChildren(dev, p2, client);
p1 = p1->nextSib; p1 = p1->nextSib;
} }
} }
@ -144,20 +144,20 @@ ProcXCloseDevice(ClientPtr client)
rc = dixLookupDevice(&d, stuff->deviceid, client, DixUseAccess); rc = dixLookupDevice(&d, stuff->deviceid, client, DixUseAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (d->deviceGrab.grab && SameClient(d->deviceGrab.grab, client)) if (d->deviceGrab.grab && SameClient(d->deviceGrab.grab, client))
(*d->deviceGrab.DeactivateGrab) (d); /* release active grab */ (*d->deviceGrab.DeactivateGrab) (d); /* release active grab */
/* Remove event selections from all windows for events from this device /* Remove event selections from all windows for events from this device
* and selected by this client. * and selected by this client.
* Delete passive grabs from all windows for this device. */ * Delete passive grabs from all windows for this device. */
for (i = 0; i < screenInfo.numScreens; i++) { for (i = 0; i < screenInfo.numScreens; i++) {
pWin = screenInfo.screens[i]->root; pWin = screenInfo.screens[i]->root;
DeleteDeviceEvents(d, pWin, client); DeleteDeviceEvents(d, pWin, client);
p1 = pWin->firstChild; p1 = pWin->firstChild;
DeleteEventsFromChildren(d, p1, client); DeleteEventsFromChildren(d, p1, client);
} }
return Success; return Success;

6
Xi/closedev.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef CLOSEDEV_H #ifndef CLOSEDEV_H
#define CLOSEDEV_H 1 #define CLOSEDEV_H 1
int SProcXCloseDevice(ClientPtr /* client */ int SProcXCloseDevice(ClientPtr /* client */
); );
int ProcXCloseDevice(ClientPtr /* client */ int ProcXCloseDevice(ClientPtr /* client */
); );
#endif /* CLOSEDEV_H */ #endif /* CLOSEDEV_H */

68
Xi/devbell.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -99,47 +99,49 @@ ProcXDeviceBell(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixBellAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixBellAccess);
if (rc != Success) { if (rc != Success) {
client->errorValue = stuff->deviceid; client->errorValue = stuff->deviceid;
return rc; return rc;
} }
if (stuff->percent < -100 || stuff->percent > 100) { if (stuff->percent < -100 || stuff->percent > 100) {
client->errorValue = stuff->percent; client->errorValue = stuff->percent;
return BadValue; return BadValue;
} }
if (stuff->feedbackclass == KbdFeedbackClass) { if (stuff->feedbackclass == KbdFeedbackClass) {
for (k = dev->kbdfeed; k; k = k->next) for (k = dev->kbdfeed; k; k = k->next)
if (k->ctrl.id == stuff->feedbackid) if (k->ctrl.id == stuff->feedbackid)
break; break;
if (!k) { if (!k) {
client->errorValue = stuff->feedbackid; client->errorValue = stuff->feedbackid;
return BadValue; return BadValue;
} }
base = k->ctrl.bell; base = k->ctrl.bell;
proc = k->BellProc; proc = k->BellProc;
ctrl = (pointer) & (k->ctrl); ctrl = (pointer) &(k->ctrl);
class = KbdFeedbackClass; class = KbdFeedbackClass;
} else if (stuff->feedbackclass == BellFeedbackClass) { }
for (b = dev->bell; b; b = b->next) else if (stuff->feedbackclass == BellFeedbackClass) {
if (b->ctrl.id == stuff->feedbackid) for (b = dev->bell; b; b = b->next)
break; if (b->ctrl.id == stuff->feedbackid)
if (!b) { break;
client->errorValue = stuff->feedbackid; if (!b) {
return BadValue; client->errorValue = stuff->feedbackid;
} return BadValue;
base = b->ctrl.percent; }
proc = b->BellProc; base = b->ctrl.percent;
ctrl = (pointer) & (b->ctrl); proc = b->BellProc;
class = BellFeedbackClass; ctrl = (pointer) &(b->ctrl);
} else { class = BellFeedbackClass;
client->errorValue = stuff->feedbackclass; }
return BadValue; else {
client->errorValue = stuff->feedbackclass;
return BadValue;
} }
newpercent = (base * stuff->percent) / 100; newpercent = (base * stuff->percent) / 100;
if (stuff->percent < 0) if (stuff->percent < 0)
newpercent = base + newpercent; newpercent = base + newpercent;
else else
newpercent = base - newpercent + stuff->percent; newpercent = base - newpercent + stuff->percent;
(*proc) (newpercent, dev, ctrl, class); (*proc) (newpercent, dev, ctrl, class);
return Success; return Success;

6
Xi/devbell.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef DEVBELL_H #ifndef DEVBELL_H
#define DEVBELL_H 1 #define DEVBELL_H 1
int SProcXDeviceBell(ClientPtr /* client */ int SProcXDeviceBell(ClientPtr /* client */
); );
int ProcXDeviceBell(ClientPtr /* client */ int ProcXDeviceBell(ClientPtr /* client */
); );
#endif /* DEVBELL_H */ #endif /* DEVBELL_H */

1751
Xi/exevents.c
View File

File diff suppressed because it is too large Load Diff

3
Xi/exglobals.h
View File

@ -79,6 +79,7 @@ extern int DevicePropertyNotify;
extern RESTYPE RT_INPUTCLIENT; extern RESTYPE RT_INPUTCLIENT;
extern DevPrivateKeyRec XIClientPrivateKeyRec; extern DevPrivateKeyRec XIClientPrivateKeyRec;
#define XIClientPrivateKey (&XIClientPrivateKeyRec) #define XIClientPrivateKey (&XIClientPrivateKeyRec)
#endif /* EXGLOBALS_H */ #endif /* EXGLOBALS_H */

815
Xi/extinit.c
View File

File diff suppressed because it is too large Load Diff

12
Xi/getbmap.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -100,16 +100,16 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
b = dev->button; b = dev->button;
if (b == NULL) if (b == NULL)
return BadMatch; return BadMatch;
rep.nElts = b->numButtons; rep.nElts = b->numButtons;
rep.length = bytes_to_int32(rep.nElts); rep.length = bytes_to_int32(rep.nElts);
WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep); WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
(void)WriteToClient(client, rep.nElts, (char *)&b->map[1]); (void) WriteToClient(client, rep.nElts, (char *) &b->map[1]);
return Success; return Success;
} }
@ -122,9 +122,9 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
void void
SRepXGetDeviceButtonMapping(ClientPtr client, int size, SRepXGetDeviceButtonMapping(ClientPtr client, int size,
xGetDeviceButtonMappingReply * rep) xGetDeviceButtonMappingReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getbmap.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETBMAP_H #ifndef GETBMAP_H
#define GETBMAP_H 1 #define GETBMAP_H 1
int SProcXGetDeviceButtonMapping(ClientPtr /* client */ int SProcXGetDeviceButtonMapping(ClientPtr /* client */
); );
int ProcXGetDeviceButtonMapping(ClientPtr /* client */ int ProcXGetDeviceButtonMapping(ClientPtr /* client */
); );
void SRepXGetDeviceButtonMapping(ClientPtr /* client */ , void SRepXGetDeviceButtonMapping(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceButtonMappingReply * /* rep */ xGetDeviceButtonMappingReply * /* rep */
); );
#endif /* GETBMAP_H */ #endif /* GETBMAP_H */

58
Xi/getdctl.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -86,7 +86,7 @@ SProcXGetDeviceControl(ClientPtr client)
static void static void
CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf, CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
int length) int length)
{ {
AxisInfoPtr a; AxisInfoPtr a;
xDeviceResolutionState *r; xDeviceResolutionState *r;
@ -97,25 +97,26 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
r->length = length; r->length = length;
r->num_valuators = v->numAxes; r->num_valuators = v->numAxes;
buf += sizeof(xDeviceResolutionState); buf += sizeof(xDeviceResolutionState);
iptr = (int *)buf; iptr = (int *) buf;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++) for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->resolution; *iptr++ = a->resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++) for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->min_resolution; *iptr++ = a->min_resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++) for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->max_resolution; *iptr++ = a->max_resolution;
if (client->swapped) { if (client->swapped) {
swaps(&r->control); swaps(&r->control);
swaps(&r->length); swaps(&r->length);
swapl(&r->num_valuators); swapl(&r->num_valuators);
iptr = (int *)buf; iptr = (int *) buf;
for (i = 0; i < (3 * v->numAxes); i++, iptr++) { for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
swapl(iptr); swapl(iptr);
} }
} }
} }
static void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf) static void
CopySwapDeviceCore(ClientPtr client, DeviceIntPtr dev, char *buf)
{ {
xDeviceCoreState *c = (xDeviceCoreState *) buf; xDeviceCoreState *c = (xDeviceCoreState *) buf;
@ -130,7 +131,8 @@ static void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
} }
} }
static void CopySwapDeviceEnable (ClientPtr client, DeviceIntPtr dev, char *buf) static void
CopySwapDeviceEnable(ClientPtr client, DeviceIntPtr dev, char *buf)
{ {
xDeviceEnableState *e = (xDeviceEnableState *) buf; xDeviceEnableState *e = (xDeviceEnableState *) buf;
@ -156,7 +158,7 @@ SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }
/*********************************************************************** /***********************************************************************
@ -178,7 +180,7 @@ ProcXGetDeviceControl(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_GetDeviceControl; rep.RepType = X_GetDeviceControl;
@ -187,11 +189,11 @@ ProcXGetDeviceControl(ClientPtr client)
switch (stuff->control) { switch (stuff->control) {
case DEVICE_RESOLUTION: case DEVICE_RESOLUTION:
if (!dev->valuator) if (!dev->valuator)
return BadMatch; return BadMatch;
total_length = sizeof(xDeviceResolutionState) + total_length = sizeof(xDeviceResolutionState) +
(3 * sizeof(int) * dev->valuator->numAxes); (3 * sizeof(int) * dev->valuator->numAxes);
break; break;
case DEVICE_ABS_CALIB: case DEVICE_ABS_CALIB:
case DEVICE_ABS_AREA: case DEVICE_ABS_AREA:
return BadMatch; return BadMatch;
@ -202,18 +204,18 @@ ProcXGetDeviceControl(ClientPtr client)
total_length = sizeof(xDeviceEnableState); total_length = sizeof(xDeviceEnableState);
break; break;
default: default:
return BadValue; return BadValue;
} }
buf = (char *)malloc(total_length); buf = (char *) malloc(total_length);
if (!buf) if (!buf)
return BadAlloc; return BadAlloc;
savbuf = buf; savbuf = buf;
switch (stuff->control) { switch (stuff->control) {
case DEVICE_RESOLUTION: case DEVICE_RESOLUTION:
CopySwapDeviceResolution(client, dev->valuator, buf, total_length); CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
break; break;
case DEVICE_CORE: case DEVICE_CORE:
CopySwapDeviceCore(client, dev, buf); CopySwapDeviceCore(client, dev, buf);
break; break;
@ -221,7 +223,7 @@ ProcXGetDeviceControl(ClientPtr client)
CopySwapDeviceEnable(client, dev, buf); CopySwapDeviceEnable(client, dev, buf);
break; break;
default: default:
break; break;
} }
rep.length = bytes_to_int32(total_length); rep.length = bytes_to_int32(total_length);

10
Xi/getdctl.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETDCTL_H #ifndef GETDCTL_H
#define GETDCTL_H 1 #define GETDCTL_H 1
int SProcXGetDeviceControl(ClientPtr /* client */ int SProcXGetDeviceControl(ClientPtr /* client */
); );
int ProcXGetDeviceControl(ClientPtr /* client */ int ProcXGetDeviceControl(ClientPtr /* client */
); );
void SRepXGetDeviceControl(ClientPtr /* client */ , void SRepXGetDeviceControl(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceControlReply * /* rep */ xGetDeviceControlReply * /* rep */
); );
#endif /* GETDCTL_H */ #endif /* GETDCTL_H */

110
Xi/getfctl.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -99,13 +99,13 @@ CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
k2->led_mask = k->ctrl.leds; k2->led_mask = k->ctrl.leds;
k2->global_auto_repeat = k->ctrl.autoRepeat; k2->global_auto_repeat = k->ctrl.autoRepeat;
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
k2->auto_repeats[i] = k->ctrl.autoRepeats[i]; k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
if (client->swapped) { if (client->swapped) {
swaps(&k2->length); swaps(&k2->length);
swaps(&k2->pitch); swaps(&k2->pitch);
swaps(&k2->duration); swaps(&k2->duration);
swapl(&k2->led_mask); swapl(&k2->led_mask);
swapl(&k2->led_values); swapl(&k2->led_values);
} }
*buf += sizeof(xKbdFeedbackState); *buf += sizeof(xKbdFeedbackState);
} }
@ -129,10 +129,10 @@ CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
p2->accelDenom = p->ctrl.den; p2->accelDenom = p->ctrl.den;
p2->threshold = p->ctrl.threshold; p2->threshold = p->ctrl.threshold;
if (client->swapped) { if (client->swapped) {
swaps(&p2->length); swaps(&p2->length);
swaps(&p2->accelNum); swaps(&p2->accelNum);
swaps(&p2->accelDenom); swaps(&p2->accelDenom);
swaps(&p2->threshold); swaps(&p2->threshold);
} }
*buf += sizeof(xPtrFeedbackState); *buf += sizeof(xPtrFeedbackState);
} }
@ -156,10 +156,10 @@ CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
i2->min_value = i->ctrl.min_value; i2->min_value = i->ctrl.min_value;
i2->max_value = i->ctrl.max_value; i2->max_value = i->ctrl.max_value;
if (client->swapped) { if (client->swapped) {
swaps(&i2->length); swaps(&i2->length);
swapl(&i2->resolution); swapl(&i2->resolution);
swapl(&i2->min_value); swapl(&i2->min_value);
swapl(&i2->max_value); swapl(&i2->max_value);
} }
*buf += sizeof(xIntegerFeedbackState); *buf += sizeof(xIntegerFeedbackState);
} }
@ -180,22 +180,22 @@ CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
s2 = (xStringFeedbackState *) * buf; s2 = (xStringFeedbackState *) * buf;
s2->class = StringFeedbackClass; s2->class = StringFeedbackClass;
s2->length = sizeof(xStringFeedbackState) + s2->length = sizeof(xStringFeedbackState) +
s->ctrl.num_symbols_supported * sizeof(KeySym); s->ctrl.num_symbols_supported * sizeof(KeySym);
s2->id = s->ctrl.id; s2->id = s->ctrl.id;
s2->max_symbols = s->ctrl.max_symbols; s2->max_symbols = s->ctrl.max_symbols;
s2->num_syms_supported = s->ctrl.num_symbols_supported; s2->num_syms_supported = s->ctrl.num_symbols_supported;
*buf += sizeof(xStringFeedbackState); *buf += sizeof(xStringFeedbackState);
kptr = (KeySym *) (*buf); kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++) for (i = 0; i < s->ctrl.num_symbols_supported; i++)
*kptr++ = *(s->ctrl.symbols_supported + i); *kptr++ = *(s->ctrl.symbols_supported + i);
if (client->swapped) { if (client->swapped) {
swaps(&s2->length); swaps(&s2->length);
swaps(&s2->max_symbols); swaps(&s2->max_symbols);
swaps(&s2->num_syms_supported); swaps(&s2->num_syms_supported);
kptr = (KeySym *) (*buf); kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) { for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
swapl(kptr); swapl(kptr);
} }
} }
*buf += (s->ctrl.num_symbols_supported * sizeof(KeySym)); *buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
} }
@ -218,9 +218,9 @@ CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
l2->led_values = l->ctrl.led_values; l2->led_values = l->ctrl.led_values;
l2->led_mask = l->ctrl.led_mask; l2->led_mask = l->ctrl.led_mask;
if (client->swapped) { if (client->swapped) {
swaps(&l2->length); swaps(&l2->length);
swapl(&l2->led_values); swapl(&l2->led_values);
swapl(&l2->led_mask); swapl(&l2->led_mask);
} }
*buf += sizeof(xLedFeedbackState); *buf += sizeof(xLedFeedbackState);
} }
@ -244,9 +244,9 @@ CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
b2->pitch = b->ctrl.pitch; b2->pitch = b->ctrl.pitch;
b2->duration = b->ctrl.duration; b2->duration = b->ctrl.duration;
if (client->swapped) { if (client->swapped) {
swaps(&b2->length); swaps(&b2->length);
swaps(&b2->pitch); swaps(&b2->pitch);
swaps(&b2->duration); swaps(&b2->duration);
} }
*buf += sizeof(xBellFeedbackState); *buf += sizeof(xBellFeedbackState);
} }
@ -260,12 +260,12 @@ CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
void void
SRepXGetFeedbackControl(ClientPtr client, int size, SRepXGetFeedbackControl(ClientPtr client, int size,
xGetFeedbackControlReply * rep) xGetFeedbackControlReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
swaps(&rep->num_feedbacks); swaps(&rep->num_feedbacks);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }
/*********************************************************************** /***********************************************************************
@ -293,7 +293,7 @@ ProcXGetFeedbackControl(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_GetFeedbackControl; rep.RepType = X_GetFeedbackControl;
@ -302,51 +302,51 @@ ProcXGetFeedbackControl(ClientPtr client)
rep.num_feedbacks = 0; rep.num_feedbacks = 0;
for (k = dev->kbdfeed; k; k = k->next) { for (k = dev->kbdfeed; k; k = k->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xKbdFeedbackState); total_length += sizeof(xKbdFeedbackState);
} }
for (p = dev->ptrfeed; p; p = p->next) { for (p = dev->ptrfeed; p; p = p->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xPtrFeedbackState); total_length += sizeof(xPtrFeedbackState);
} }
for (s = dev->stringfeed; s; s = s->next) { for (s = dev->stringfeed; s; s = s->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xStringFeedbackState) + total_length += sizeof(xStringFeedbackState) +
(s->ctrl.num_symbols_supported * sizeof(KeySym)); (s->ctrl.num_symbols_supported * sizeof(KeySym));
} }
for (i = dev->intfeed; i; i = i->next) { for (i = dev->intfeed; i; i = i->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xIntegerFeedbackState); total_length += sizeof(xIntegerFeedbackState);
} }
for (l = dev->leds; l; l = l->next) { for (l = dev->leds; l; l = l->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xLedFeedbackState); total_length += sizeof(xLedFeedbackState);
} }
for (b = dev->bell; b; b = b->next) { for (b = dev->bell; b; b = b->next) {
rep.num_feedbacks++; rep.num_feedbacks++;
total_length += sizeof(xBellFeedbackState); total_length += sizeof(xBellFeedbackState);
} }
if (total_length == 0) if (total_length == 0)
return BadMatch; return BadMatch;
buf = (char *)malloc(total_length); buf = (char *) malloc(total_length);
if (!buf) if (!buf)
return BadAlloc; return BadAlloc;
savbuf = buf; savbuf = buf;
for (k = dev->kbdfeed; k; k = k->next) for (k = dev->kbdfeed; k; k = k->next)
CopySwapKbdFeedback(client, k, &buf); CopySwapKbdFeedback(client, k, &buf);
for (p = dev->ptrfeed; p; p = p->next) for (p = dev->ptrfeed; p; p = p->next)
CopySwapPtrFeedback(client, p, &buf); CopySwapPtrFeedback(client, p, &buf);
for (s = dev->stringfeed; s; s = s->next) for (s = dev->stringfeed; s; s = s->next)
CopySwapStringFeedback(client, s, &buf); CopySwapStringFeedback(client, s, &buf);
for (i = dev->intfeed; i; i = i->next) for (i = dev->intfeed; i; i = i->next)
CopySwapIntegerFeedback(client, i, &buf); CopySwapIntegerFeedback(client, i, &buf);
for (l = dev->leds; l; l = l->next) for (l = dev->leds; l; l = l->next)
CopySwapLedFeedback(client, l, &buf); CopySwapLedFeedback(client, l, &buf);
for (b = dev->bell; b; b = b->next) for (b = dev->bell; b; b = b->next)
CopySwapBellFeedback(client, b, &buf); CopySwapBellFeedback(client, b, &buf);
rep.length = bytes_to_int32(total_length); rep.length = bytes_to_int32(total_length);
WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep); WriteReplyToClient(client, sizeof(xGetFeedbackControlReply), &rep);

10
Xi/getfctl.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETFCTL_H #ifndef GETFCTL_H
#define GETFCTL_H 1 #define GETFCTL_H 1
int SProcXGetFeedbackControl(ClientPtr /* client */ int SProcXGetFeedbackControl(ClientPtr /* client */
); );
int ProcXGetFeedbackControl(ClientPtr /* client */ int ProcXGetFeedbackControl(ClientPtr /* client */
); );
void SRepXGetFeedbackControl(ClientPtr /* client */ , void SRepXGetFeedbackControl(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetFeedbackControlReply * /* rep */ xGetFeedbackControlReply * /* rep */
); );
#endif /* GETFCTL_H */ #endif /* GETFCTL_H */

18
Xi/getfocus.c
View File

@ -54,8 +54,8 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "windowstr.h" /* focus struct */ #include "windowstr.h" /* focus struct */
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -95,9 +95,9 @@ ProcXGetDeviceFocus(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetFocusAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetFocusAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (!dev->focus) if (!dev->focus)
return BadDevice; return BadDevice;
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_GetDeviceFocus; rep.RepType = X_GetDeviceFocus;
@ -107,13 +107,13 @@ ProcXGetDeviceFocus(ClientPtr client)
focus = dev->focus; focus = dev->focus;
if (focus->win == NoneWin) if (focus->win == NoneWin)
rep.focus = None; rep.focus = None;
else if (focus->win == PointerRootWin) else if (focus->win == PointerRootWin)
rep.focus = PointerRoot; rep.focus = PointerRoot;
else if (focus->win == FollowKeyboardWin) else if (focus->win == FollowKeyboardWin)
rep.focus = FollowKeyboard; rep.focus = FollowKeyboard;
else else
rep.focus = focus->win->drawable.id; rep.focus = focus->win->drawable.id;
rep.time = focus->time.milliseconds; rep.time = focus->time.milliseconds;
rep.revertTo = focus->revert; rep.revertTo = focus->revert;
@ -135,5 +135,5 @@ SRepXGetDeviceFocus(ClientPtr client, int size, xGetDeviceFocusReply * rep)
swapl(&rep->length); swapl(&rep->length);
swapl(&rep->focus); swapl(&rep->focus);
swapl(&rep->time); swapl(&rep->time);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getfocus.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETFOCUS_H #ifndef GETFOCUS_H
#define GETFOCUS_H 1 #define GETFOCUS_H 1
int SProcXGetDeviceFocus(ClientPtr /* client */ int SProcXGetDeviceFocus(ClientPtr /* client */
); );
int ProcXGetDeviceFocus(ClientPtr /* client */ int ProcXGetDeviceFocus(ClientPtr /* client */
); );
void SRepXGetDeviceFocus(ClientPtr /* client */ , void SRepXGetDeviceFocus(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceFocusReply * /* rep */ xGetDeviceFocusReply * /* rep */
); );
#endif /* GETFOCUS_H */ #endif /* GETFOCUS_H */

22
Xi/getkmap.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -99,20 +99,20 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if (dev->key == NULL) if (dev->key == NULL)
return BadMatch; return BadMatch;
xkb = dev->key->xkbInfo->desc; xkb = dev->key->xkbInfo->desc;
if (stuff->firstKeyCode < xkb->min_key_code || if (stuff->firstKeyCode < xkb->min_key_code ||
stuff->firstKeyCode > xkb->max_key_code) { stuff->firstKeyCode > xkb->max_key_code) {
client->errorValue = stuff->firstKeyCode; client->errorValue = stuff->firstKeyCode;
return BadValue; return BadValue;
} }
if (stuff->firstKeyCode + stuff->count > xkb->max_key_code + 1) { if (stuff->firstKeyCode + stuff->count > xkb->max_key_code + 1) {
client->errorValue = stuff->count; client->errorValue = stuff->count;
return BadValue; return BadValue;
} }
syms = XkbGetCoreMap(dev); syms = XkbGetCoreMap(dev);
@ -123,7 +123,7 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
rep.RepType = X_GetDeviceKeyMapping; rep.RepType = X_GetDeviceKeyMapping;
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.keySymsPerKeyCode = syms->mapWidth; rep.keySymsPerKeyCode = syms->mapWidth;
rep.length = (syms->mapWidth * stuff->count); /* KeySyms are 4 bytes */ rep.length = (syms->mapWidth * stuff->count); /* KeySyms are 4 bytes */
WriteReplyToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep); WriteReplyToClient(client, sizeof(xGetDeviceKeyMappingReply), &rep);
client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write; client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write;
@ -146,9 +146,9 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
void void
SRepXGetDeviceKeyMapping(ClientPtr client, int size, SRepXGetDeviceKeyMapping(ClientPtr client, int size,
xGetDeviceKeyMappingReply * rep) xGetDeviceKeyMappingReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getkmap.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETKMAP_H #ifndef GETKMAP_H
#define GETKMAP_H 1 #define GETKMAP_H 1
int SProcXGetDeviceKeyMapping(ClientPtr /* client */ int SProcXGetDeviceKeyMapping(ClientPtr /* client */
); );
int ProcXGetDeviceKeyMapping(ClientPtr /* client */ int ProcXGetDeviceKeyMapping(ClientPtr /* client */
); );
void SRepXGetDeviceKeyMapping(ClientPtr /* client */ , void SRepXGetDeviceKeyMapping(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceKeyMappingReply * /* rep */ xGetDeviceKeyMappingReply * /* rep */
); );
#endif /* GETKMAP_H */ #endif /* GETKMAP_H */

10
Xi/getmmap.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> /* Request macro */ #include <X11/extensions/XIproto.h> /* Request macro */
#include "exglobals.h" #include "exglobals.h"
#include "getmmap.h" #include "getmmap.h"
@ -95,7 +95,7 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess); ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetAttrAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
ret = generate_modkeymap(client, dev, &modkeymap, &max_keys_per_mod); ret = generate_modkeymap(client, dev, &modkeymap, &max_keys_per_mod);
if (ret != Success) if (ret != Success)
@ -125,9 +125,9 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
void void
SRepXGetDeviceModifierMapping(ClientPtr client, int size, SRepXGetDeviceModifierMapping(ClientPtr client, int size,
xGetDeviceModifierMappingReply * rep) xGetDeviceModifierMappingReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getmmap.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETMMAP_H #ifndef GETMMAP_H
#define GETMMAP_H 1 #define GETMMAP_H 1
int SProcXGetDeviceModifierMapping(ClientPtr /* client */ int SProcXGetDeviceModifierMapping(ClientPtr /* client */
); );
int ProcXGetDeviceModifierMapping(ClientPtr /* client */ int ProcXGetDeviceModifierMapping(ClientPtr /* client */
); );
void SRepXGetDeviceModifierMapping(ClientPtr /* client */ , void SRepXGetDeviceModifierMapping(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceModifierMappingReply * /* rep */ xGetDeviceModifierMappingReply * /* rep */
); );
#endif /* GETMMAP_H */ #endif /* GETMMAP_H */

61
Xi/getprop.c
View File

@ -54,8 +54,8 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structs */ #include "windowstr.h" /* window structs */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
@ -109,30 +109,29 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if ((others = wOtherInputMasks(pWin)) != 0) { if ((others = wOtherInputMasks(pWin)) != 0) {
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
ClassFromMask(NULL, others->dontPropagateMask[i], i, ClassFromMask(NULL, others->dontPropagateMask[i], i, &count, COUNT);
&count, COUNT); if (count) {
if (count) { rep.count = count;
rep.count = count; buf = (XEventClass *) malloc(rep.count * sizeof(XEventClass));
buf = (XEventClass *) malloc(rep.count * sizeof(XEventClass)); rep.length = bytes_to_int32(rep.count * sizeof(XEventClass));
rep.length = bytes_to_int32(rep.count * sizeof(XEventClass));
tbuf = buf; tbuf = buf;
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i, tbuf = ClassFromMask(tbuf, others->dontPropagateMask[i], i,
NULL, CREATE); NULL, CREATE);
} }
} }
WriteReplyToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep); WriteReplyToClient(client, sizeof(xGetDeviceDontPropagateListReply), &rep);
if (count) { if (count) {
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf); WriteSwappedDataToClient(client, count * sizeof(XEventClass), buf);
free(buf); free(buf);
} }
return Success; return Success;
} }
@ -145,23 +144,23 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
*/ */
XEventClass XEventClass
* ClassFromMask(XEventClass * buf, Mask mask, int maskndx, CARD16 * count, * ClassFromMask(XEventClass * buf, Mask mask, int maskndx, CARD16 *count,
int mode) int mode)
{ {
int i, j; int i, j;
int id = maskndx; int id = maskndx;
Mask tmask = 0x80000000; Mask tmask = 0x80000000;
for (i = 0; i < 32; i++, tmask >>= 1) for (i = 0; i < 32; i++, tmask >>= 1)
if (tmask & mask) { if (tmask & mask) {
for (j = 0; j < ExtEventIndex; j++) for (j = 0; j < ExtEventIndex; j++)
if (EventInfo[j].mask == tmask) { if (EventInfo[j].mask == tmask) {
if (mode == COUNT) if (mode == COUNT)
(*count)++; (*count)++;
else else
*buf++ = (id << 8) | EventInfo[j].type; *buf++ = (id << 8) | EventInfo[j].type;
} }
} }
return buf; return buf;
} }
@ -174,10 +173,10 @@ XEventClass
void void
SRepXGetDeviceDontPropagateList(ClientPtr client, int size, SRepXGetDeviceDontPropagateList(ClientPtr client, int size,
xGetDeviceDontPropagateListReply * rep) xGetDeviceDontPropagateListReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
swaps(&rep->count); swaps(&rep->count);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

18
Xi/getprop.h
View File

@ -30,22 +30,22 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETPROP_H #ifndef GETPROP_H
#define GETPROP_H 1 #define GETPROP_H 1
int SProcXGetDeviceDontPropagateList(ClientPtr /* client */ int SProcXGetDeviceDontPropagateList(ClientPtr /* client */
); );
int ProcXGetDeviceDontPropagateList(ClientPtr /* client */ int ProcXGetDeviceDontPropagateList(ClientPtr /* client */
); );
XEventClass *ClassFromMask(XEventClass * /* buf */ , XEventClass *ClassFromMask(XEventClass * /* buf */ ,
Mask /* mask */ , Mask /* mask */ ,
int /* maskndx */ , int /* maskndx */ ,
CARD16 * /* count */ , CARD16 * /* count */ ,
int /* mode */ int /* mode */
); );
void SRepXGetDeviceDontPropagateList(ClientPtr /* client */ , void SRepXGetDeviceDontPropagateList(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceDontPropagateListReply * /* rep */ xGetDeviceDontPropagateListReply * /* rep */
); );
#endif /* GETPROP_H */ #endif /* GETPROP_H */

64
Xi/getselev.c
View File

@ -56,8 +56,8 @@ SOFTWARE.
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window struct */ #include "windowstr.h" /* window struct */
#include "exglobals.h" #include "exglobals.h"
#include "swaprep.h" #include "swaprep.h"
@ -111,45 +111,45 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if ((pOthers = wOtherInputMasks(pWin)) != 0) { if ((pOthers = wOtherInputMasks(pWin)) != 0) {
for (others = pOthers->inputClients; others; others = others->next) for (others = pOthers->inputClients; others; others = others->next)
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
ClassFromMask(NULL, others->mask[i], i, ClassFromMask(NULL, others->mask[i], i,
&rep.all_clients_count, COUNT); &rep.all_clients_count, COUNT);
for (others = pOthers->inputClients; others; others = others->next) for (others = pOthers->inputClients; others; others = others->next)
if (SameClient(others, client)) { if (SameClient(others, client)) {
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
ClassFromMask(NULL, others->mask[i], i, ClassFromMask(NULL, others->mask[i], i,
&rep.this_client_count, COUNT); &rep.this_client_count, COUNT);
break; break;
} }
total_length = (rep.all_clients_count + rep.this_client_count) * total_length = (rep.all_clients_count + rep.this_client_count) *
sizeof(XEventClass); sizeof(XEventClass);
rep.length = bytes_to_int32(total_length); rep.length = bytes_to_int32(total_length);
buf = (XEventClass *) malloc(total_length); buf = (XEventClass *) malloc(total_length);
tclient = buf; tclient = buf;
aclient = buf + rep.this_client_count; aclient = buf + rep.this_client_count;
if (others) if (others)
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
tclient = tclient =
ClassFromMask(tclient, others->mask[i], i, NULL, CREATE); ClassFromMask(tclient, others->mask[i], i, NULL, CREATE);
for (others = pOthers->inputClients; others; others = others->next) for (others = pOthers->inputClients; others; others = others->next)
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
aclient = aclient =
ClassFromMask(aclient, others->mask[i], i, NULL, CREATE); ClassFromMask(aclient, others->mask[i], i, NULL, CREATE);
} }
WriteReplyToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep); WriteReplyToClient(client, sizeof(xGetSelectedExtensionEventsReply), &rep);
if (total_length) { if (total_length) {
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, total_length, buf); WriteSwappedDataToClient(client, total_length, buf);
} }
free(buf); free(buf);
return Success; return Success;
@ -164,11 +164,11 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
void void
SRepXGetSelectedExtensionEvents(ClientPtr client, int size, SRepXGetSelectedExtensionEvents(ClientPtr client, int size,
xGetSelectedExtensionEventsReply * rep) xGetSelectedExtensionEventsReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
swaps(&rep->this_client_count); swaps(&rep->this_client_count);
swaps(&rep->all_clients_count); swaps(&rep->all_clients_count);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getselev.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETSELEV_H #ifndef GETSELEV_H
#define GETSELEV_H 1 #define GETSELEV_H 1
int SProcXGetSelectedExtensionEvents(ClientPtr /* client */ int SProcXGetSelectedExtensionEvents(ClientPtr /* client */
); );
int ProcXGetSelectedExtensionEvents(ClientPtr /* client */ int ProcXGetSelectedExtensionEvents(ClientPtr /* client */
); );
void SRepXGetSelectedExtensionEvents(ClientPtr /* client */ , void SRepXGetSelectedExtensionEvents(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetSelectedExtensionEventsReply * /* rep */ xGetSelectedExtensionEventsReply * /* rep */
); );
#endif /* GETSELEV_H */ #endif /* GETSELEV_H */

10
Xi/getvers.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -95,8 +95,8 @@ ProcXGetExtensionVersion(ClientPtr client)
REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq); REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
if (stuff->length != bytes_to_int32(sizeof(xGetExtensionVersionReq) + if (stuff->length != bytes_to_int32(sizeof(xGetExtensionVersionReq) +
stuff->nbytes)) stuff->nbytes))
return BadLength; return BadLength;
memset(&rep, 0, sizeof(xGetExtensionVersionReply)); memset(&rep, 0, sizeof(xGetExtensionVersionReply));
rep.repType = X_Reply; rep.repType = X_Reply;
@ -121,11 +121,11 @@ ProcXGetExtensionVersion(ClientPtr client)
void void
SRepXGetExtensionVersion(ClientPtr client, int size, SRepXGetExtensionVersion(ClientPtr client, int size,
xGetExtensionVersionReply * rep) xGetExtensionVersionReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
swaps(&rep->major_version); swaps(&rep->major_version);
swaps(&rep->minor_version); swaps(&rep->minor_version);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/getvers.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GETVERS_H #ifndef GETVERS_H
#define GETVERS_H 1 #define GETVERS_H 1
int SProcXGetExtensionVersion(ClientPtr /* client */ int SProcXGetExtensionVersion(ClientPtr /* client */
); );
int ProcXGetExtensionVersion(ClientPtr /* client */ int ProcXGetExtensionVersion(ClientPtr /* client */
); );
void SRepXGetExtensionVersion(ClientPtr /* client */ , void SRepXGetExtensionVersion(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetExtensionVersionReply * /* rep */ xGetExtensionVersionReply * /* rep */
); );
#endif /* GETVERS_H */ #endif /* GETVERS_H */

67
Xi/grabdev.c
View File

@ -54,12 +54,12 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exglobals.h" #include "exglobals.h"
#include "dixevents.h" /* GrabDevice */ #include "dixevents.h" /* GrabDevice */
#include "grabdev.h" #include "grabdev.h"
@ -82,8 +82,9 @@ SProcXGrabDevice(ClientPtr client)
swapl(&stuff->time); swapl(&stuff->time);
swaps(&stuff->event_count); swaps(&stuff->event_count);
if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count) if (stuff->length !=
return BadLength; bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
return BadLength;
SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count); SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
@ -108,8 +109,9 @@ ProcXGrabDevice(ClientPtr client)
REQUEST(xGrabDeviceReq); REQUEST(xGrabDeviceReq);
REQUEST_AT_LEAST_SIZE(xGrabDeviceReq); REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count) if (stuff->length !=
return BadLength; bytes_to_int32(sizeof(xGrabDeviceReq)) + stuff->event_count)
return BadLength;
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_GrabDevice; rep.RepType = X_GrabDevice;
@ -118,23 +120,22 @@ ProcXGrabDevice(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixGrabAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1], if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
stuff->event_count, tmp, dev, stuff->event_count, tmp, dev,
X_GrabDevice)) != Success) X_GrabDevice)) != Success)
return rc; return rc;
mask.xi = tmp[stuff->deviceid].mask; mask.xi = tmp[stuff->deviceid].mask;
rc = GrabDevice(client, dev, stuff->other_devices_mode, rc = GrabDevice(client, dev, stuff->other_devices_mode,
stuff->this_device_mode, stuff->grabWindow, stuff->this_device_mode, stuff->grabWindow,
stuff->ownerEvents, stuff->time, stuff->ownerEvents, stuff->time,
&mask, XI, None, None, &mask, XI, None, None, &rep.status);
&rep.status);
if (rc != Success) if (rc != Success)
return rc; return rc;
WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep); WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
return Success; return Success;
@ -166,34 +167,34 @@ ProcXGrabDevice(ClientPtr client)
int int
CreateMaskFromList(ClientPtr client, XEventClass * list, int count, CreateMaskFromList(ClientPtr client, XEventClass * list, int count,
struct tmask *mask, DeviceIntPtr dev, int req) struct tmask *mask, DeviceIntPtr dev, int req)
{ {
int rc, i, j; int rc, i, j;
int device; int device;
DeviceIntPtr tdev; DeviceIntPtr tdev;
for (i = 0; i < EMASKSIZE; i++) { for (i = 0; i < EMASKSIZE; i++) {
mask[i].mask = 0; mask[i].mask = 0;
mask[i].dev = NULL; mask[i].dev = NULL;
} }
for (i = 0; i < count; i++, list++) { for (i = 0; i < count; i++, list++) {
device = *list >> 8; device = *list >> 8;
if (device > 255) if (device > 255)
return BadClass; return BadClass;
rc = dixLookupDevice(&tdev, device, client, DixUseAccess); rc = dixLookupDevice(&tdev, device, client, DixUseAccess);
if (rc != BadDevice && rc != Success) if (rc != BadDevice && rc != Success)
return rc; return rc;
if (rc == BadDevice || (dev != NULL && tdev != dev)) if (rc == BadDevice || (dev != NULL && tdev != dev))
return BadClass; return BadClass;
for (j = 0; j < ExtEventIndex; j++) for (j = 0; j < ExtEventIndex; j++)
if (EventInfo[j].type == (*list & 0xff)) { if (EventInfo[j].type == (*list & 0xff)) {
mask[device].mask |= EventInfo[j].mask; mask[device].mask |= EventInfo[j].mask;
mask[device].dev = (Pointer) tdev; mask[device].dev = (Pointer) tdev;
break; break;
} }
} }
return Success; return Success;
} }
@ -210,5 +211,5 @@ SRepXGrabDevice(ClientPtr client, int size, xGrabDeviceReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

20
Xi/grabdev.h
View File

@ -30,23 +30,23 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GRABDEV_H #ifndef GRABDEV_H
#define GRABDEV_H 1 #define GRABDEV_H 1
int SProcXGrabDevice(ClientPtr /* client */ int SProcXGrabDevice(ClientPtr /* client */
); );
int ProcXGrabDevice(ClientPtr /* client */ int ProcXGrabDevice(ClientPtr /* client */
); );
int CreateMaskFromList(ClientPtr /* client */ , int CreateMaskFromList(ClientPtr /* client */ ,
XEventClass * /* list */ , XEventClass * /* list */ ,
int /* count */ , int /* count */ ,
struct tmask /* mask */ [], struct tmask /* mask */ [],
DeviceIntPtr /* dev */ , DeviceIntPtr /* dev */ ,
int /* req */ int /* req */
); );
void SRepXGrabDevice(ClientPtr /* client */ , void SRepXGrabDevice(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGrabDeviceReply * /* rep */ xGrabDeviceReply * /* rep */
); );
#endif /* GRABDEV_H */ #endif /* GRABDEV_H */

46
Xi/grabdevb.c
View File

@ -54,8 +54,8 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -81,7 +81,7 @@ SProcXGrabDeviceButton(ClientPtr client)
swaps(&stuff->modifiers); swaps(&stuff->modifiers);
swaps(&stuff->event_count); swaps(&stuff->event_count);
REQUEST_FIXED_SIZE(xGrabDeviceButtonReq, REQUEST_FIXED_SIZE(xGrabDeviceButtonReq,
stuff->event_count * sizeof(CARD32)); stuff->event_count * sizeof(CARD32));
SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count); SwapLongs((CARD32 *) (&stuff[1]), stuff->event_count);
return (ProcXGrabDeviceButton(client)); return (ProcXGrabDeviceButton(client));
@ -108,33 +108,34 @@ ProcXGrabDeviceButton(ClientPtr client)
REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq); REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
if (stuff->length != if (stuff->length !=
bytes_to_int32(sizeof(xGrabDeviceButtonReq)) + stuff->event_count) bytes_to_int32(sizeof(xGrabDeviceButtonReq)) + stuff->event_count)
return BadLength; return BadLength;
ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess); ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
if (stuff->modifier_device != UseXKeyboard) { if (stuff->modifier_device != UseXKeyboard) {
ret = dixLookupDevice(&mdev, stuff->modifier_device, client, ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
DixUseAccess); DixUseAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
if (mdev->key == NULL) if (mdev->key == NULL)
return BadMatch; return BadMatch;
} else { }
mdev = PickKeyboard(client); else {
ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess); mdev = PickKeyboard(client);
if (ret != Success) ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
return ret; if (ret != Success)
return ret;
} }
class = (XEventClass *) (&stuff[1]); /* first word of values */ class = (XEventClass *) (&stuff[1]); /* first word of values */
if ((ret = CreateMaskFromList(client, class, if ((ret = CreateMaskFromList(client, class,
stuff->event_count, tmp, dev, stuff->event_count, tmp, dev,
X_GrabDeviceButton)) != Success) X_GrabDeviceButton)) != Success)
return ret; return ret;
memset(&param, 0, sizeof(param)); memset(&param, 0, sizeof(param));
param.grabtype = XI; param.grabtype = XI;
@ -145,8 +146,7 @@ ProcXGrabDeviceButton(ClientPtr client)
param.modifiers = stuff->modifiers; param.modifiers = stuff->modifiers;
mask.xi = tmp[stuff->grabbed_device].mask; mask.xi = tmp[stuff->grabbed_device].mask;
ret = GrabButton(client, dev, mdev, stuff->button, &param, ret = GrabButton(client, dev, mdev, stuff->button, &param, XI, &mask);
XI, &mask);
return ret; return ret;
} }

6
Xi/grabdevb.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GRABDEVB_H #ifndef GRABDEVB_H
#define GRABDEVB_H 1 #define GRABDEVB_H 1
int SProcXGrabDeviceButton(ClientPtr /* client */ int SProcXGrabDeviceButton(ClientPtr /* client */
); );
int ProcXGrabDeviceButton(ClientPtr /* client */ int ProcXGrabDeviceButton(ClientPtr /* client */
); );
#endif /* GRABDEVB_H */ #endif /* GRABDEVB_H */

43
Xi/grabdevk.c
View File

@ -54,8 +54,8 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -105,34 +105,35 @@ ProcXGrabDeviceKey(ClientPtr client)
REQUEST(xGrabDeviceKeyReq); REQUEST(xGrabDeviceKeyReq);
REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq); REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
if (stuff->length != bytes_to_int32(sizeof(xGrabDeviceKeyReq)) + stuff->event_count) if (stuff->length !=
return BadLength; bytes_to_int32(sizeof(xGrabDeviceKeyReq)) + stuff->event_count)
return BadLength;
ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess); ret = dixLookupDevice(&dev, stuff->grabbed_device, client, DixGrabAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
if (stuff->modifier_device != UseXKeyboard) { if (stuff->modifier_device != UseXKeyboard) {
ret = dixLookupDevice(&mdev, stuff->modifier_device, client, ret = dixLookupDevice(&mdev, stuff->modifier_device, client,
DixUseAccess); DixUseAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
if (mdev->key == NULL) if (mdev->key == NULL)
return BadMatch; return BadMatch;
} else { }
mdev = PickKeyboard(client); else {
ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess); mdev = PickKeyboard(client);
if (ret != Success) ret = XaceHook(XACE_DEVICE_ACCESS, client, mdev, DixUseAccess);
return ret; if (ret != Success)
return ret;
} }
class = (XEventClass *) (&stuff[1]); /* first word of values */ class = (XEventClass *) (&stuff[1]); /* first word of values */
if ((ret = CreateMaskFromList(client, class, if ((ret = CreateMaskFromList(client, class,
stuff->event_count, tmp, dev, stuff->event_count, tmp, dev,
X_GrabDeviceKey)) != Success) X_GrabDeviceKey)) != Success)
return ret; return ret;
memset(&param, 0, sizeof(param)); memset(&param, 0, sizeof(param));
param.grabtype = XI; param.grabtype = XI;

6
Xi/grabdevk.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GRABDEVK_H #ifndef GRABDEVK_H
#define GRABDEVK_H 1 #define GRABDEVK_H 1
int SProcXGrabDeviceKey(ClientPtr /* client */ int SProcXGrabDeviceKey(ClientPtr /* client */
); );
int ProcXGrabDeviceKey(ClientPtr /* client */ int ProcXGrabDeviceKey(ClientPtr /* client */
); );
#endif /* GRABDEVK_H */ #endif /* GRABDEVK_H */

48
Xi/gtmotion.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -103,51 +103,51 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq); REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess);
if (rc != Success) if (rc != Success)
return rc; return rc;
v = dev->valuator; v = dev->valuator;
if (v == NULL || v->numAxes == 0) if (v == NULL || v->numAxes == 0)
return BadMatch; return BadMatch;
if (dev->valuator->motionHintWindow) if (dev->valuator->motionHintWindow)
MaybeStopDeviceHint(dev, client); MaybeStopDeviceHint(dev, client);
axes = v->numAxes; axes = v->numAxes;
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_GetDeviceMotionEvents; rep.RepType = X_GetDeviceMotionEvents;
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.nEvents = 0; rep.nEvents = 0;
rep.axes = axes; rep.axes = axes;
rep.mode = Absolute; /* XXX we don't do relative at the moment */ rep.mode = Absolute; /* XXX we don't do relative at the moment */
rep.length = 0; rep.length = 0;
start = ClientTimeToServerTime(stuff->start); start = ClientTimeToServerTime(stuff->start);
stop = ClientTimeToServerTime(stuff->stop); stop = ClientTimeToServerTime(stuff->stop);
if (CompareTimeStamps(start, stop) == LATER || if (CompareTimeStamps(start, stop) == LATER ||
CompareTimeStamps(start, currentTime) == LATER) { CompareTimeStamps(start, currentTime) == LATER) {
WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep); WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
return Success; return Success;
} }
if (CompareTimeStamps(stop, currentTime) == LATER) if (CompareTimeStamps(stop, currentTime) == LATER)
stop = currentTime; stop = currentTime;
num_events = v->numMotionEvents; num_events = v->numMotionEvents;
if (num_events) { if (num_events) {
size = sizeof(Time) + (axes * sizeof(INT32)); size = sizeof(Time) + (axes * sizeof(INT32));
rep.nEvents = GetMotionHistory(dev, (xTimecoord **) &coords,/* XXX */ rep.nEvents = GetMotionHistory(dev, (xTimecoord **) & coords, /* XXX */
start.milliseconds, stop.milliseconds, start.milliseconds, stop.milliseconds,
(ScreenPtr) NULL, FALSE); (ScreenPtr) NULL, FALSE);
} }
if (rep.nEvents > 0) { if (rep.nEvents > 0) {
length = bytes_to_int32(rep.nEvents * size); length = bytes_to_int32(rep.nEvents * size);
rep.length = length; rep.length = length;
} }
nEvents = rep.nEvents; nEvents = rep.nEvents;
WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep); WriteReplyToClient(client, sizeof(xGetDeviceMotionEventsReply), &rep);
if (nEvents) { if (nEvents) {
if (client->swapped) { if (client->swapped) {
bufptr = coords; bufptr = coords;
for (i = 0; i < nEvents * (axes + 1); i++) { for (i = 0; i < nEvents * (axes + 1); i++) {
swapl(bufptr); swapl(bufptr);
bufptr++; bufptr++;
} }
} }
WriteToClient(client, length * 4, (char *)coords); WriteToClient(client, length * 4, (char *) coords);
} }
free(coords); free(coords);
return Success; return Success;
@ -162,10 +162,10 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
void void
SRepXGetDeviceMotionEvents(ClientPtr client, int size, SRepXGetDeviceMotionEvents(ClientPtr client, int size,
xGetDeviceMotionEventsReply * rep) xGetDeviceMotionEventsReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
swapl(&rep->nEvents); swapl(&rep->nEvents);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/gtmotion.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef GTMOTION_H #ifndef GTMOTION_H
#define GTMOTION_H 1 #define GTMOTION_H 1
int SProcXGetDeviceMotionEvents(ClientPtr /* client */ int SProcXGetDeviceMotionEvents(ClientPtr /* client */
); );
int ProcXGetDeviceMotionEvents(ClientPtr /* client */ int ProcXGetDeviceMotionEvents(ClientPtr /* client */
); );
void SRepXGetDeviceMotionEvents(ClientPtr /* client */ , void SRepXGetDeviceMotionEvents(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xGetDeviceMotionEventsReply * /* rep */ xGetDeviceMotionEventsReply * /* rep */
); );
#endif /* GTMOTION_H */ #endif /* GTMOTION_H */

133
Xi/listdev.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include <X11/X.h> /* for inputstr.h */ #include <X11/X.h> /* for inputstr.h */
#include <X11/Xproto.h> /* Request macro */ #include <X11/Xproto.h> /* Request macro */
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "XIstubs.h" #include "XIstubs.h"
@ -68,7 +68,6 @@ SOFTWARE.
#include "listdev.h" #include "listdev.h"
/*********************************************************************** /***********************************************************************
* *
* This procedure lists the input devices available to the server. * This procedure lists the input devices available to the server.
@ -97,15 +96,15 @@ SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
*namesize += 1; *namesize += 1;
if (d->name) if (d->name)
*namesize += strlen(d->name); *namesize += strlen(d->name);
if (d->key != NULL) if (d->key != NULL)
*size += sizeof(xKeyInfo); *size += sizeof(xKeyInfo);
if (d->button != NULL) if (d->button != NULL)
*size += sizeof(xButtonInfo); *size += sizeof(xButtonInfo);
if (d->valuator != NULL) { if (d->valuator != NULL) {
chunks = ((int)d->valuator->numAxes + 19) / VPC; chunks = ((int) d->valuator->numAxes + 19) / VPC;
*size += (chunks * sizeof(xValuatorInfo) + *size += (chunks * sizeof(xValuatorInfo) +
d->valuator->numAxes * sizeof(xAxisInfo)); d->valuator->numAxes * sizeof(xAxisInfo));
} }
} }
@ -122,15 +121,16 @@ SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
static void static void
CopyDeviceName(char **namebuf, char *name) CopyDeviceName(char **namebuf, char *name)
{ {
char *nameptr = (char *)*namebuf; char *nameptr = (char *) *namebuf;
if (name) { if (name) {
*nameptr++ = strlen(name); *nameptr++ = strlen(name);
strcpy(nameptr, name); strcpy(nameptr, name);
*namebuf += (strlen(name) + 1); *namebuf += (strlen(name) + 1);
} else { }
*nameptr++ = 0; else {
*namebuf += 1; *nameptr++ = 0;
*namebuf += 1;
} }
} }
@ -150,7 +150,7 @@ CopySwapButtonClass(ClientPtr client, ButtonClassPtr b, char **buf)
b2->length = sizeof(xButtonInfo); b2->length = sizeof(xButtonInfo);
b2->num_buttons = b->numButtons; b2->num_buttons = b->numButtons;
if (client && client->swapped) { if (client && client->swapped) {
swaps(&b2->num_buttons); swaps(&b2->num_buttons);
} }
*buf += sizeof(xButtonInfo); *buf += sizeof(xButtonInfo);
} }
@ -162,8 +162,7 @@ CopySwapButtonClass(ClientPtr client, ButtonClassPtr b, char **buf)
*/ */
static void static void
CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes, CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes, char **buf)
char **buf)
{ {
xDeviceInfoPtr dev; xDeviceInfoPtr dev;
@ -173,18 +172,18 @@ CopySwapDevice(ClientPtr client, DeviceIntPtr d, int num_classes,
dev->type = d->xinput_type; dev->type = d->xinput_type;
dev->num_classes = num_classes; dev->num_classes = num_classes;
if (IsMaster(d) && IsKeyboardDevice(d)) if (IsMaster(d) && IsKeyboardDevice(d))
dev->use = IsXKeyboard; dev->use = IsXKeyboard;
else if (IsMaster(d) && IsPointerDevice(d)) else if (IsMaster(d) && IsPointerDevice(d))
dev->use = IsXPointer; dev->use = IsXPointer;
else if (d->valuator && d->button) else if (d->valuator && d->button)
dev->use = IsXExtensionPointer; dev->use = IsXExtensionPointer;
else if (d->key && d->kbdfeed) else if (d->key && d->kbdfeed)
dev->use = IsXExtensionKeyboard; dev->use = IsXExtensionKeyboard;
else else
dev->use = IsXExtensionDevice; dev->use = IsXExtensionDevice;
if (client->swapped) { if (client->swapped) {
swapl(&dev->type); swapl(&dev->type);
} }
*buf += sizeof(xDeviceInfo); *buf += sizeof(xDeviceInfo);
} }
@ -207,7 +206,7 @@ CopySwapKeyClass(ClientPtr client, KeyClassPtr k, char **buf)
k2->max_keycode = k->xkbInfo->desc->max_key_code; k2->max_keycode = k->xkbInfo->desc->max_key_code;
k2->num_keys = k2->max_keycode - k2->min_keycode + 1; k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
if (client && client->swapped) { if (client && client->swapped) {
swaps(&k2->num_keys); swaps(&k2->num_keys);
} }
*buf += sizeof(xKeyInfo); *buf += sizeof(xKeyInfo);
} }
@ -234,54 +233,53 @@ CopySwapValuatorClass(ClientPtr client, DeviceIntPtr dev, char **buf)
xAxisInfoPtr a2; xAxisInfoPtr a2;
for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC); for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC);
i++, axes -= VPC) { i++, axes -= VPC) {
t_axes = axes < VPC ? axes : VPC; t_axes = axes < VPC ? axes : VPC;
if (t_axes < 0) if (t_axes < 0)
t_axes = v->numAxes % VPC; t_axes = v->numAxes % VPC;
v2 = (xValuatorInfoPtr) * buf; v2 = (xValuatorInfoPtr) * buf;
v2->class = ValuatorClass; v2->class = ValuatorClass;
v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo); v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
v2->num_axes = t_axes; v2->num_axes = t_axes;
v2->mode = valuator_get_mode(dev, 0); v2->mode = valuator_get_mode(dev, 0);
v2->motion_buffer_size = v->numMotionEvents; v2->motion_buffer_size = v->numMotionEvents;
if (client && client->swapped) { if (client && client->swapped) {
swapl(&v2->motion_buffer_size); swapl(&v2->motion_buffer_size);
} }
*buf += sizeof(xValuatorInfo); *buf += sizeof(xValuatorInfo);
a = v->axes + (VPC * i); a = v->axes + (VPC * i);
a2 = (xAxisInfoPtr) * buf; a2 = (xAxisInfoPtr) * buf;
for (j = 0; j < t_axes; j++) { for (j = 0; j < t_axes; j++) {
a2->min_value = a->min_value; a2->min_value = a->min_value;
a2->max_value = a->max_value; a2->max_value = a->max_value;
a2->resolution = a->resolution; a2->resolution = a->resolution;
if (client && client->swapped) { if (client && client->swapped) {
swapl(&a2->min_value); swapl(&a2->min_value);
swapl(&a2->max_value); swapl(&a2->max_value);
swapl(&a2->resolution); swapl(&a2->resolution);
} }
a2++; a2++;
a++; a++;
*buf += sizeof(xAxisInfo); *buf += sizeof(xAxisInfo);
} }
} }
return i; return i;
} }
static void static void
CopySwapClasses(ClientPtr client, DeviceIntPtr dev, CARD8 *num_classes, CopySwapClasses(ClientPtr client, DeviceIntPtr dev, CARD8 *num_classes,
char** classbuf) char **classbuf)
{ {
if (dev->key != NULL) { if (dev->key != NULL) {
CopySwapKeyClass(client, dev->key, classbuf); CopySwapKeyClass(client, dev->key, classbuf);
(*num_classes)++; (*num_classes)++;
} }
if (dev->button != NULL) { if (dev->button != NULL) {
CopySwapButtonClass(client, dev->button, classbuf); CopySwapButtonClass(client, dev->button, classbuf);
(*num_classes)++; (*num_classes)++;
} }
if (dev->valuator != NULL) { if (dev->valuator != NULL) {
(*num_classes) += (*num_classes) += CopySwapValuatorClass(client, dev, classbuf);
CopySwapValuatorClass(client, dev, classbuf);
} }
} }
@ -293,7 +291,7 @@ CopySwapClasses(ClientPtr client, DeviceIntPtr dev, CARD8 *num_classes,
static void static void
ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev, ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev,
char **devbuf, char **classbuf, char **namebuf) char **devbuf, char **classbuf, char **namebuf)
{ {
CopyDeviceName(namebuf, d->name); CopyDeviceName(namebuf, d->name);
CopySwapDevice(client, d, 0, devbuf); CopySwapDevice(client, d, 0, devbuf);
@ -310,16 +308,15 @@ static Bool
ShouldSkipDevice(ClientPtr client, DeviceIntPtr d) ShouldSkipDevice(ClientPtr client, DeviceIntPtr d)
{ {
/* don't send master devices other than VCP/VCK */ /* don't send master devices other than VCP/VCK */
if (!IsMaster(d) || d == inputInfo.pointer || d == inputInfo.keyboard) if (!IsMaster(d) || d == inputInfo.pointer ||d == inputInfo.keyboard) {
{
int rc = XaceHook(XACE_DEVICE_ACCESS, client, d, DixGetAttrAccess); int rc = XaceHook(XACE_DEVICE_ACCESS, client, d, DixGetAttrAccess);
if (rc == Success) if (rc == Success)
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
/*********************************************************************** /***********************************************************************
* *
* This procedure lists the input devices available to the server. * This procedure lists the input devices available to the server.
@ -335,7 +332,7 @@ ProcXListInputDevices(ClientPtr client)
{ {
xListInputDevicesReply rep; xListInputDevicesReply rep;
int numdevs = 0; int numdevs = 0;
int namesize = 1; /* need 1 extra byte for strcpy */ int namesize = 1; /* need 1 extra byte for strcpy */
int i = 0, size = 0; int i = 0, size = 0;
int total_length; int total_length;
char *devbuf, *classbuf, *namebuf, *savbuf; char *devbuf, *classbuf, *namebuf, *savbuf;
@ -378,7 +375,7 @@ ProcXListInputDevices(ClientPtr client)
/* allocate space for reply */ /* allocate space for reply */
total_length = numdevs * sizeof(xDeviceInfo) + size + namesize; total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
devbuf = (char *)calloc(1, total_length); devbuf = (char *) calloc(1, total_length);
classbuf = devbuf + (numdevs * sizeof(xDeviceInfo)); classbuf = devbuf + (numdevs * sizeof(xDeviceInfo));
namebuf = classbuf + size; namebuf = classbuf + size;
savbuf = devbuf; savbuf = devbuf;
@ -420,5 +417,5 @@ SRepXListInputDevices(ClientPtr client, int size, xListInputDevicesReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

12
Xi/listdev.h
View File

@ -30,17 +30,17 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef LISTDEV_H #ifndef LISTDEV_H
#define LISTDEV_H 1 #define LISTDEV_H 1
#define VPC 20 /* Max # valuators per chunk */ #define VPC 20 /* Max # valuators per chunk */
int SProcXListInputDevices(ClientPtr /* client */ int SProcXListInputDevices(ClientPtr /* client */
); );
int ProcXListInputDevices(ClientPtr /* client */ int ProcXListInputDevices(ClientPtr /* client */
); );
void SRepXListInputDevices(ClientPtr /* client */ , void SRepXListInputDevices(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xListInputDevicesReply * /* rep */ xListInputDevicesReply * /* rep */
); );
#endif /* LISTDEV_H */ #endif /* LISTDEV_H */

53
Xi/opendev.c
View File

@ -54,11 +54,11 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "XIstubs.h" #include "XIstubs.h"
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include "exglobals.h" #include "exglobals.h"
#include "exevents.h" #include "exevents.h"
@ -102,55 +102,56 @@ ProcXOpenDevice(ClientPtr client)
status = dixLookupDevice(&dev, stuff->deviceid, client, DixUseAccess); status = dixLookupDevice(&dev, stuff->deviceid, client, DixUseAccess);
if (status == BadDevice) { /* not open */ if (status == BadDevice) { /* not open */
for (dev = inputInfo.off_devices; dev; dev = dev->next) for (dev = inputInfo.off_devices; dev; dev = dev->next)
if (dev->id == stuff->deviceid) if (dev->id == stuff->deviceid)
break; break;
if (dev == NULL) if (dev == NULL)
return BadDevice; return BadDevice;
} else if (status != Success) }
return status; else if (status != Success)
return status;
if (IsMaster(dev)) if (IsMaster(dev))
return BadDevice; return BadDevice;
if (status != Success) if (status != Success)
return status; return status;
memset(&rep, 0, sizeof(xOpenDeviceReply)); memset(&rep, 0, sizeof(xOpenDeviceReply));
rep.repType = X_Reply; rep.repType = X_Reply;
rep.RepType = X_OpenDevice; rep.RepType = X_OpenDevice;
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
if (dev->key != NULL) { if (dev->key != NULL) {
evbase[j].class = KeyClass; evbase[j].class = KeyClass;
evbase[j++].event_type_base = event_base[KeyClass]; evbase[j++].event_type_base = event_base[KeyClass];
} }
if (dev->button != NULL) { if (dev->button != NULL) {
evbase[j].class = ButtonClass; evbase[j].class = ButtonClass;
evbase[j++].event_type_base = event_base[ButtonClass]; evbase[j++].event_type_base = event_base[ButtonClass];
} }
if (dev->valuator != NULL) { if (dev->valuator != NULL) {
evbase[j].class = ValuatorClass; evbase[j].class = ValuatorClass;
evbase[j++].event_type_base = event_base[ValuatorClass]; evbase[j++].event_type_base = event_base[ValuatorClass];
} }
if (dev->kbdfeed != NULL || dev->ptrfeed != NULL || dev->leds != NULL || if (dev->kbdfeed != NULL || dev->ptrfeed != NULL || dev->leds != NULL ||
dev->intfeed != NULL || dev->bell != NULL || dev->stringfeed != NULL) { dev->intfeed != NULL || dev->bell != NULL || dev->stringfeed != NULL) {
evbase[j].class = FeedbackClass; evbase[j].class = FeedbackClass;
evbase[j++].event_type_base = event_base[FeedbackClass]; evbase[j++].event_type_base = event_base[FeedbackClass];
} }
if (dev->focus != NULL) { if (dev->focus != NULL) {
evbase[j].class = FocusClass; evbase[j].class = FocusClass;
evbase[j++].event_type_base = event_base[FocusClass]; evbase[j++].event_type_base = event_base[FocusClass];
} }
if (dev->proximity != NULL) { if (dev->proximity != NULL) {
evbase[j].class = ProximityClass; evbase[j].class = ProximityClass;
evbase[j++].event_type_base = event_base[ProximityClass]; evbase[j++].event_type_base = event_base[ProximityClass];
} }
evbase[j].class = OtherClass; evbase[j].class = OtherClass;
evbase[j++].event_type_base = event_base[OtherClass]; evbase[j++].event_type_base = event_base[OtherClass];
rep.length = bytes_to_int32(j * sizeof(xInputClassInfo)); rep.length = bytes_to_int32(j * sizeof(xInputClassInfo));
rep.num_classes = j; rep.num_classes = j;
WriteReplyToClient(client, sizeof(xOpenDeviceReply), &rep); WriteReplyToClient(client, sizeof(xOpenDeviceReply), &rep);
WriteToClient(client, j * sizeof(xInputClassInfo), (char *)evbase); WriteToClient(client, j * sizeof(xInputClassInfo), (char *) evbase);
return Success; return Success;
} }
@ -166,5 +167,5 @@ SRepXOpenDevice(ClientPtr client, int size, xOpenDeviceReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/opendev.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef OPENDEV_H #ifndef OPENDEV_H
#define OPENDEV_H 1 #define OPENDEV_H 1
int SProcXOpenDevice(ClientPtr /* client */ int SProcXOpenDevice(ClientPtr /* client */
); );
int ProcXOpenDevice(ClientPtr /* client */ int ProcXOpenDevice(ClientPtr /* client */
); );
void SRepXOpenDevice(ClientPtr /* client */ , void SRepXOpenDevice(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xOpenDeviceReply * /* rep */ xOpenDeviceReply * /* rep */
); );
#endif /* OPENDEV_H */ #endif /* OPENDEV_H */

93
Xi/queryst.c
View File

@ -36,8 +36,8 @@ from The Open Group.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -94,79 +94,80 @@ ProcXQueryDeviceState(ClientPtr client)
rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess); rc = dixLookupDevice(&dev, stuff->deviceid, client, DixReadAccess);
if (rc != Success && rc != BadAccess) if (rc != Success && rc != BadAccess)
return rc; return rc;
v = dev->valuator; v = dev->valuator;
if (v != NULL && v->motionHintWindow != NULL) if (v != NULL && v->motionHintWindow != NULL)
MaybeStopDeviceHint(dev, client); MaybeStopDeviceHint(dev, client);
k = dev->key; k = dev->key;
if (k != NULL) { if (k != NULL) {
total_length += sizeof(xKeyState); total_length += sizeof(xKeyState);
num_classes++; num_classes++;
} }
b = dev->button; b = dev->button;
if (b != NULL) { if (b != NULL) {
total_length += sizeof(xButtonState); total_length += sizeof(xButtonState);
num_classes++; num_classes++;
} }
if (v != NULL) { if (v != NULL) {
total_length += (sizeof(xValuatorState) + (v->numAxes * sizeof(int))); total_length += (sizeof(xValuatorState) + (v->numAxes * sizeof(int)));
num_classes++; num_classes++;
} }
buf = (char *)calloc(total_length, 1); buf = (char *) calloc(total_length, 1);
if (!buf) if (!buf)
return BadAlloc; return BadAlloc;
savbuf = buf; savbuf = buf;
if (k != NULL) { if (k != NULL) {
tk = (xKeyState *) buf; tk = (xKeyState *) buf;
tk->class = KeyClass; tk->class = KeyClass;
tk->length = sizeof(xKeyState); tk->length = sizeof(xKeyState);
tk->num_keys = k->xkbInfo->desc->max_key_code - tk->num_keys = k->xkbInfo->desc->max_key_code -
k->xkbInfo->desc->min_key_code + 1; k->xkbInfo->desc->min_key_code + 1;
if (rc != BadAccess) if (rc != BadAccess)
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
tk->keys[i] = k->down[i]; tk->keys[i] = k->down[i];
buf += sizeof(xKeyState); buf += sizeof(xKeyState);
} }
if (b != NULL) { if (b != NULL) {
tb = (xButtonState *) buf; tb = (xButtonState *) buf;
tb->class = ButtonClass; tb->class = ButtonClass;
tb->length = sizeof(xButtonState); tb->length = sizeof(xButtonState);
tb->num_buttons = b->numButtons; tb->num_buttons = b->numButtons;
if (rc != BadAccess) if (rc != BadAccess)
memcpy(tb->buttons, b->down, sizeof(b->down)); memcpy(tb->buttons, b->down, sizeof(b->down));
buf += sizeof(xButtonState); buf += sizeof(xButtonState);
} }
if (v != NULL) { if (v != NULL) {
tv = (xValuatorState *) buf; tv = (xValuatorState *) buf;
tv->class = ValuatorClass; tv->class = ValuatorClass;
tv->length = sizeof(xValuatorState) + v->numAxes * 4; tv->length = sizeof(xValuatorState) + v->numAxes * 4;
tv->num_valuators = v->numAxes; tv->num_valuators = v->numAxes;
tv->mode = valuator_get_mode(dev, 0); tv->mode = valuator_get_mode(dev, 0);
tv->mode |= (dev->proximity && !dev->proximity->in_proximity) ? OutOfProximity : 0; tv->mode |= (dev->proximity &&
buf += sizeof(xValuatorState); !dev->proximity->in_proximity) ? OutOfProximity : 0;
for (i = 0, values = v->axisVal; i < v->numAxes; i++) { buf += sizeof(xValuatorState);
if (rc != BadAccess) for (i = 0, values = v->axisVal; i < v->numAxes; i++) {
*((int *)buf) = *values; if (rc != BadAccess)
values++; *((int *) buf) = *values;
if (client->swapped) { values++;
swapl((int *)buf); if (client->swapped) {
} swapl((int *) buf);
buf += sizeof(int); }
} buf += sizeof(int);
}
} }
rep.num_classes = num_classes; rep.num_classes = num_classes;
rep.length = bytes_to_int32(total_length); rep.length = bytes_to_int32(total_length);
WriteReplyToClient(client, sizeof(xQueryDeviceStateReply), &rep); WriteReplyToClient(client, sizeof(xQueryDeviceStateReply), &rep);
if (total_length > 0) if (total_length > 0)
WriteToClient(client, total_length, savbuf); WriteToClient(client, total_length, savbuf);
free(savbuf); free(savbuf);
return Success; return Success;
} }
@ -183,5 +184,5 @@ SRepXQueryDeviceState(ClientPtr client, int size, xQueryDeviceStateReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/queryst.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef QUERYST_H #ifndef QUERYST_H
#define QUERYST_H 1 #define QUERYST_H 1
int SProcXQueryDeviceState(ClientPtr /* client */ int SProcXQueryDeviceState(ClientPtr /* client */
); );
int ProcXQueryDeviceState(ClientPtr /* client */ int ProcXQueryDeviceState(ClientPtr /* client */
); );
void SRepXQueryDeviceState(ClientPtr /* client */ , void SRepXQueryDeviceState(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xQueryDeviceStateReply * /* rep */ xQueryDeviceStateReply * /* rep */
); );
#endif /* QUERYST_H */ #endif /* QUERYST_H */

41
Xi/selectev.c
View File

@ -50,13 +50,12 @@ SOFTWARE.
* *
*/ */
#ifdef HAVE_DIX_CONFIG_H #ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* window structure */ #include "windowstr.h" /* window structure */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XI2.h> #include <X11/extensions/XI2.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
@ -70,7 +69,7 @@ extern Mask ExtExclusiveMasks[];
static int static int
HandleDevicePresenceMask(ClientPtr client, WindowPtr win, HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
XEventClass *cls, CARD16 *count) XEventClass * cls, CARD16 *count)
{ {
int i, j; int i, j;
Mask mask; Mask mask;
@ -106,7 +105,7 @@ HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
/* We always only use mksidx = AllDevices for events not bound to /* We always only use mksidx = AllDevices for events not bound to
* devices */ * devices */
if (AddExtensionClient (win, client, mask, XIAllDevices) != Success) if (AddExtensionClient(win, client, mask, XIAllDevices) != Success)
return BadAlloc; return BadAlloc;
RecalculateDeviceDeliverableEvents(win); RecalculateDeviceDeliverableEvents(win);
@ -128,8 +127,7 @@ SProcXSelectExtensionEvent(ClientPtr client)
REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq); REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
swapl(&stuff->window); swapl(&stuff->window);
swaps(&stuff->count); swaps(&stuff->count);
REQUEST_FIXED_SIZE(xSelectExtensionEventReq, REQUEST_FIXED_SIZE(xSelectExtensionEventReq, stuff->count * sizeof(CARD32));
stuff->count * sizeof(CARD32));
SwapLongs((CARD32 *) (&stuff[1]), stuff->count); SwapLongs((CARD32 *) (&stuff[1]), stuff->count);
return (ProcXSelectExtensionEvent(client)); return (ProcXSelectExtensionEvent(client));
@ -152,33 +150,34 @@ ProcXSelectExtensionEvent(ClientPtr client)
REQUEST(xSelectExtensionEventReq); REQUEST(xSelectExtensionEventReq);
REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq); REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
if (stuff->length != bytes_to_int32(sizeof(xSelectExtensionEventReq)) + stuff->count) if (stuff->length !=
return BadLength; bytes_to_int32(sizeof(xSelectExtensionEventReq)) + stuff->count)
return BadLength;
ret = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess); ret = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1], if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
&stuff->count) != Success) &stuff->count) != Success)
return BadAlloc; return BadAlloc;
if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1], if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
stuff->count, tmp, NULL, stuff->count, tmp, NULL,
X_SelectExtensionEvent)) != Success) X_SelectExtensionEvent)) != Success)
return ret; return ret;
for (i = 0; i < EMASKSIZE; i++) for (i = 0; i < EMASKSIZE; i++)
if (tmp[i].dev != NULL) { if (tmp[i].dev != NULL) {
if (tmp[i].mask & ~XIAllMasks) { if (tmp[i].mask & ~XIAllMasks) {
client->errorValue = tmp[i].mask; client->errorValue = tmp[i].mask;
return BadValue; return BadValue;
} }
if ((ret = if ((ret =
SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client, SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
tmp[i].mask, ExtExclusiveMasks[i]))!= Success) tmp[i].mask, ExtExclusiveMasks[i])) != Success)
return ret; return ret;
} }
return Success; return Success;
} }

6
Xi/selectev.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef SELECTEV_H #ifndef SELECTEV_H
#define SELECTEV_H 1 #define SELECTEV_H 1
int SProcXSelectExtensionEvent(ClientPtr /* client */ int SProcXSelectExtensionEvent(ClientPtr /* client */
); );
int ProcXSelectExtensionEvent(ClientPtr /* client */ int ProcXSelectExtensionEvent(ClientPtr /* client */
); );
#endif /* SELECTEV_H */ #endif /* SELECTEV_H */

54
Xi/sendexev.c
View File

@ -54,9 +54,9 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include "windowstr.h" /* Window */ #include "windowstr.h" /* Window */
#include "extnsionst.h" /* EventSwapPtr */ #include "extnsionst.h" /* EventSwapPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -65,7 +65,7 @@ SOFTWARE.
#include "grabdev.h" #include "grabdev.h"
#include "sendexev.h" #include "sendexev.h"
extern int lastEvent; /* Defined in extension.c */ extern int lastEvent; /* Defined in extension.c */
/*********************************************************************** /***********************************************************************
* *
@ -88,20 +88,21 @@ SProcXSendExtensionEvent(ClientPtr client)
swapl(&stuff->destination); swapl(&stuff->destination);
swaps(&stuff->count); swaps(&stuff->count);
if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count + if (stuff->length !=
bytes_to_int32(stuff->num_events * sizeof(xEvent))) bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
return BadLength; bytes_to_int32(stuff->num_events * sizeof(xEvent)))
return BadLength;
eventP = (xEvent *) & stuff[1]; eventP = (xEvent *) &stuff[1];
for (i = 0; i < stuff->num_events; i++, eventP++) { for (i = 0; i < stuff->num_events; i++, eventP++) {
proc = EventSwapVector[eventP->u.u.type & 0177]; proc = EventSwapVector[eventP->u.u.type & 0177];
if (proc == NotImplemented) /* no swapping proc; invalid event type? */ if (proc == NotImplemented) /* no swapping proc; invalid event type? */
return BadValue; return BadValue;
(*proc) (eventP, &eventT); (*proc) (eventP, &eventT);
*eventP = eventT; *eventP = eventT;
} }
p = (CARD32 *)(((xEvent *) & stuff[1]) + stuff->num_events); p = (CARD32 *) (((xEvent *) &stuff[1]) + stuff->num_events);
SwapLongs(p, stuff->count); SwapLongs(p, stuff->count);
return (ProcXSendExtensionEvent(client)); return (ProcXSendExtensionEvent(client));
} }
@ -125,31 +126,32 @@ ProcXSendExtensionEvent(ClientPtr client)
REQUEST(xSendExtensionEventReq); REQUEST(xSendExtensionEventReq);
REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq); REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
if (stuff->length != bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count + if (stuff->length !=
(stuff->num_events * bytes_to_int32(sizeof(xEvent)))) bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
return BadLength; (stuff->num_events * bytes_to_int32(sizeof(xEvent))))
return BadLength;
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixWriteAccess); ret = dixLookupDevice(&dev, stuff->deviceid, client, DixWriteAccess);
if (ret != Success) if (ret != Success)
return ret; return ret;
/* The client's event type must be one defined by an extension. */ /* The client's event type must be one defined by an extension. */
first = ((xEvent *) & stuff[1]); first = ((xEvent *) &stuff[1]);
if (!((EXTENSION_EVENT_BASE <= first->u.u.type) && if (!((EXTENSION_EVENT_BASE <= first->u.u.type) &&
(first->u.u.type < lastEvent))) { (first->u.u.type < lastEvent))) {
client->errorValue = first->u.u.type; client->errorValue = first->u.u.type;
return BadValue; return BadValue;
} }
list = (XEventClass *) (first + stuff->num_events); list = (XEventClass *) (first + stuff->num_events);
if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev, if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev,
X_SendExtensionEvent)) != Success) X_SendExtensionEvent)) != Success)
return ret; return ret;
ret = (SendEvent(client, dev, stuff->destination, ret = (SendEvent(client, dev, stuff->destination,
stuff->propagate, (xEvent *) & stuff[1], stuff->propagate, (xEvent *) &stuff[1],
tmp[stuff->deviceid].mask, stuff->num_events)); tmp[stuff->deviceid].mask, stuff->num_events));
return ret; return ret;
} }

6
Xi/sendexev.h
View File

@ -30,10 +30,10 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef SENDEXEV_H #ifndef SENDEXEV_H
#define SENDEXEV_H 1 #define SENDEXEV_H 1
int SProcXSendExtensionEvent(ClientPtr /* client */ int SProcXSendExtensionEvent(ClientPtr /* client */
); );
int ProcXSendExtensionEvent(ClientPtr /* client */ int ProcXSendExtensionEvent(ClientPtr /* client */
); );
#endif /* SENDEXEV_H */ #endif /* SENDEXEV_H */

12
Xi/setbmap.c
View File

@ -54,7 +54,7 @@ SOFTWARE.
#include <dix-config.h> #include <dix-config.h>
#endif #endif
#include "inputstr.h" /* DeviceIntPtr */ #include "inputstr.h" /* DeviceIntPtr */
#include <X11/extensions/XI.h> #include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h> #include <X11/extensions/XIproto.h>
#include "exevents.h" #include "exevents.h"
@ -94,7 +94,7 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
if (stuff->length != if (stuff->length !=
bytes_to_int32(sizeof(xSetDeviceButtonMappingReq) + stuff->map_length)) bytes_to_int32(sizeof(xSetDeviceButtonMappingReq) + stuff->map_length))
return BadLength; return BadLength;
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess); ret = dixLookupDevice(&dev, stuff->deviceid, client, DixManageAccess);
if (ret != Success) if (ret != Success)
@ -106,7 +106,9 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
rep.sequenceNumber = client->sequence; rep.sequenceNumber = client->sequence;
rep.status = MappingSuccess; rep.status = MappingSuccess;
ret = ApplyPointerMapping(dev, (CARD8 *) &stuff[1], stuff->map_length, client); ret =
ApplyPointerMapping(dev, (CARD8 *) &stuff[1], stuff->map_length,
client);
if (ret == -1) if (ret == -1)
return BadValue; return BadValue;
else if (ret == MappingBusy) else if (ret == MappingBusy)
@ -128,9 +130,9 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
void void
SRepXSetDeviceButtonMapping(ClientPtr client, int size, SRepXSetDeviceButtonMapping(ClientPtr client, int size,
xSetDeviceButtonMappingReply * rep) xSetDeviceButtonMappingReply * rep)
{ {
swaps(&rep->sequenceNumber); swaps(&rep->sequenceNumber);
swapl(&rep->length); swapl(&rep->length);
WriteToClient(client, size, (char *)rep); WriteToClient(client, size, (char *) rep);
} }

10
Xi/setbmap.h
View File

@ -30,15 +30,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef SETBMAP_H #ifndef SETBMAP_H
#define SETBMAP_H 1 #define SETBMAP_H 1
int SProcXSetDeviceButtonMapping(ClientPtr /* client */ int SProcXSetDeviceButtonMapping(ClientPtr /* client */
); );
int ProcXSetDeviceButtonMapping(ClientPtr /* client */ int ProcXSetDeviceButtonMapping(ClientPtr /* client */
); );
void SRepXSetDeviceButtonMapping(ClientPtr /* client */ , void SRepXSetDeviceButtonMapping(ClientPtr /* client */ ,
int /* size */ , int /* size */ ,
xSetDeviceButtonMappingReply * /* rep */ xSetDeviceButtonMappingReply * /* rep */
); );
#endif /* SETBMAP_H */ #endif /* SETBMAP_H */

Some files were not shown because too many files have changed in this diff Show More