#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include "windowstr.h"
#include <X11/extensions/ge.h>
#include "geint.h"
#include "geext.h"
#include "protocol-versions.h"
DevPrivateKeyRec GEClientPrivateKeyRec;
int RT_GECLIENT = 0;
GEExtension GEExtensions[MAXEXTENSIONS];
static const int version_requests[] = {
X_GEQueryVersion,
X_GEQueryVersion,
};
static void SGEGenericEvent(xEvent* from, xEvent* to);
#define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0]))
static int
ProcGEQueryVersion(ClientPtr client)
{
int n;
GEClientInfoPtr pGEClient = GEGetClient(client);
xGEQueryVersionReply rep;
REQUEST(xGEQueryVersionReq);
REQUEST_SIZE_MATCH(xGEQueryVersionReq);
rep.repType = X_Reply;
rep.RepType = X_GEQueryVersion;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.majorVersion = SERVER_GE_MAJOR_VERSION;
rep.minorVersion = SERVER_GE_MINOR_VERSION;
pGEClient->major_version = stuff->majorVersion;
pGEClient->minor_version = stuff->minorVersion;
if (client->swapped)
{
swaps(&rep.sequenceNumber, n);
swapl(&rep.length, n);
swaps(&rep.majorVersion, n);
swaps(&rep.minorVersion, n);
}
WriteToClient(client, sizeof(xGEQueryVersionReply), (char*)&rep);
return Success;
}
int (*ProcGEVector[GENumberRequests])(ClientPtr) = {
ProcGEQueryVersion
};
static int
SProcGEQueryVersion(ClientPtr client)
{
int n;
REQUEST(xGEQueryVersionReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGEQueryVersionReq);
swaps(&stuff->majorVersion, n);
swaps(&stuff->minorVersion, n);
return(*ProcGEVector[stuff->ReqType])(client);
}
int (*SProcGEVector[GENumberRequests])(ClientPtr) = {
SProcGEQueryVersion
};
static int
ProcGEDispatch(ClientPtr client)
{
GEClientInfoPtr pGEClient = GEGetClient(client);
REQUEST(xGEReq);
if (pGEClient->major_version >= NUM_VERSION_REQUESTS)
return BadRequest;
if (stuff->ReqType > version_requests[pGEClient->major_version])
return BadRequest;
return (ProcGEVector[stuff->ReqType])(client);
}
static int
SProcGEDispatch(ClientPtr client)
{
REQUEST(xGEReq);
if (stuff->ReqType >= GENumberRequests)
return BadRequest;
return (*SProcGEVector[stuff->ReqType])(client);
}
static void
GEClientCallback(CallbackListPtr *list,
pointer closure,
pointer data)
{
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client;
GEClientInfoPtr pGEClient = GEGetClient(pClient);
pGEClient->major_version = 0;
pGEClient->minor_version = 0;
}
static void
GEResetProc(ExtensionEntry *extEntry)
{
DeleteCallback(&ClientStateCallback, GEClientCallback, 0);
EventSwapVector[GenericEvent] = NotImplemented;
}
static void
SGEGenericEvent(xEvent* from, xEvent* to)
{
xGenericEvent* gefrom = (xGenericEvent*)from;
xGenericEvent* geto = (xGenericEvent*)to;
if ((gefrom->extension & 0x7f) > MAXEXTENSIONS)
{
ErrorF("GE: Invalid extension offset for event.\n");
return;
}
if (GEExtensions[gefrom->extension & 0x7F].evswap)
GEExtensions[gefrom->extension & 0x7F].evswap(gefrom, geto);
}
void
GEExtensionInit(void)
{
ExtensionEntry *extEntry;
if (!dixRegisterPrivateKey(&GEClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(GEClientInfoRec)))
FatalError("GEExtensionInit: GE private request failed.\n");
if(!AddCallback(&ClientStateCallback, GEClientCallback, 0))
{
FatalError("GEExtensionInit: register client callback failed.\n");
}
if((extEntry = AddExtension(GE_NAME,
0, GENumberErrors,
ProcGEDispatch, SProcGEDispatch,
GEResetProc, StandardMinorOpcode)) != 0)
{
memset(GEExtensions, 0, sizeof(GEExtensions));
EventSwapVector[GenericEvent] = (EventSwapPtr) SGEGenericEvent;
} else {
FatalError("GEInit: AddExtensions failed.\n");
}
}
void
GERegisterExtension(int extension,
void (*ev_swap)(xGenericEvent* from, xGenericEvent* to))
{
if ((extension & 0x7F) >= MAXEXTENSIONS)
FatalError("GE: extension > MAXEXTENSIONS. This should not happen.\n");
GEExtensions[extension & 0x7f].evswap = ev_swap;
}
void
GEInitEvent(xGenericEvent* ev, int extension)
{
ev->type = GenericEvent;
ev->extension = extension;
ev->length = 0;
}