aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver/XTrap/xtrapdi.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/Xserver/XTrap/xtrapdi.c')
-rw-r--r--nx-X11/programs/Xserver/XTrap/xtrapdi.c2157
1 files changed, 2157 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/XTrap/xtrapdi.c b/nx-X11/programs/Xserver/XTrap/xtrapdi.c
new file mode 100644
index 000000000..1055429d4
--- /dev/null
+++ b/nx-X11/programs/Xserver/XTrap/xtrapdi.c
@@ -0,0 +1,2157 @@
+/* $XdotOrg: xc/programs/Xserver/XTrap/xtrapdi.c,v 1.5 2005/07/03 08:53:36 daniels Exp $ */
+/* $XFree86: xc/programs/Xserver/XTrap/xtrapdi.c,v 1.6tsi Exp $ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+X11R6 Changes Copyright (c) 1994 by Robert Chesler of Absol-Puter, Hudson, NH.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL AND ABSOL-PUTER DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL DIGITAL OR ABSOL-PUTER BE LIABLE FOR ANY
+SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*****************************************************************************/
+/*
+ * ABSTRACT:
+ *
+ * This module is the main module for extension initialization and setup.
+ * It is called by the server and by clients using the extension.
+ * This is shared code and is subject to change only by team approval.
+ *
+ * CONTRIBUTORS:
+ *
+ * Dick Annicchiarico
+ * Robert Chesler
+ * Gene Durso
+ * Marc Evans
+ * Alan Jamison
+ * Mark Henry
+ * Ken Miller
+ *
+ * CHANGES:
+ *
+ * Robert Chesler - grab-impreviousness patch to improve grab behavior
+ * Robert Chesler - add client arg to swapping routines for X11R6 port
+ *
+ */
+
+/*-----------------*
+ * Include Files *
+ *-----------------*/
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#ifndef EXTMODULE
+#include <stdio.h>
+#include <errno.h>
+#include <X11/Xos.h>
+#else
+#include "xf86_ansic.h"
+#endif
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include "input.h" /* Server DevicePtr definitions */
+#include "misc.h" /* Server swapping macros */
+#include "dixstruct.h" /* Server ClientRec definitions */
+#include "resource.h" /* Used with the MakeAtom call */
+#ifdef PC
+# include "scrintst.h" /* Screen struct */
+# include "extnsist.h"
+#else
+# include "extnsionst.h" /* Server ExtensionEntry definitions */
+# include "scrnintstr.h" /* Screen struct */
+#endif
+#include "pixmapstr.h" /* DrawableRec */
+#include "windowstr.h" /* Drawable Lookup structures */
+#include <X11/extensions/xtrapdi.h>
+#include <X11/extensions/xtrapddmi.h>
+#include <X11/extensions/xtrapproto.h>
+#include "colormapst.h"
+#ifdef PANORAMIX
+#include "panoramiX.h"
+#include "panoramiXsrv.h"
+#include "cursor.h"
+#endif
+
+
+/*----------------------------*
+ * Global Data Declarations *
+ *----------------------------*/
+
+DevicePtr XETrapKbdDev = NULL;
+DevicePtr XETrapPtrDev = NULL;
+int XETrapErrorBase = 0L;
+xXTrapGetAvailReply XETrap_avail; /* What's available to clients */
+
+globalref int_function XETrapDispatchVector[10L]; /* Vector of XTrap Rtns */
+globalref int_function XETSwDispatchVector[10L]; /* Swapped XTrap Rtns */
+
+globalref int_function XETrapProcVector[256L]; /* The "shadowed" ProcVector */
+ /* The "real" EventVector (XTrap creates it till events
+ * truly become vectored
+ */
+#ifndef VECTORED_EVENTS
+globalref int_function EventProcVector[XETrapCoreEvents];
+#else
+extern WindowPtr GetCurrentRootWindow();
+globalref int_function EventProcVector[128L];
+#endif
+static int_function keybd_process_inp = NULL; /* Used for VECTORED_EVENTS */
+ /* The "shadowed" Event Vector */
+globalref int_function XETrapEventProcVector[XETrapCoreEvents];
+
+globalref void_function XETSwProcVector[256L];/* Vector of Req swapping rtns */
+
+/* This macro returns a true/false indicator based on whether it changes the
+ * environment state bits local to the server extension. This is based on the
+ * idea that if a valid flag is set and the corresponding data bit is not in
+ * the same state as desired, then true is returned, otherwise false is
+ * returned.
+ */
+#define _CheckChangeBit(valid,data,local,bit) \
+ (BitIsFalse(valid,bit) ? 0L : \
+ (((BitIsTrue(data,bit) && BitIsTrue(local,bit)) || \
+ (BitIsFalse(data,bit) && BitIsFalse(local,bit))) ? 0L : \
+ (BitToggle(local,bit), 1L)))
+
+/* This macro is designed to return the number of elements in an
+ * automatically allocated array.
+ */
+#ifndef ASIZE
+#define ASIZE(array) (sizeof(array)/sizeof(array[0L]))
+#endif
+
+/* This macro is designed to return the number of long words beyond
+ * XETrapMinRepSize contained in a data structure.
+ */
+#ifndef XEXTRA
+#define XEXTRA(s) \
+ ((sizeof(s)+(sizeof(CARD32)-1L)-XETrapMinRepSize)/sizeof(CARD32))
+#endif
+
+/* Static Declarations known to XTrap Only
+ * All XTrap clients refer to these single copies!
+ */
+/* This carries all of the information XTrap uses for internal information */
+static XETrapEnv *XETenv[MAXCLIENTS] = {NULL};
+#ifndef RESTYPE
+#define RESTYPE unsigned long
+#endif
+static RESTYPE XETrapClass = 0L; /* Resource class for this extension */
+static RESTYPE XETrapType = 0L; /* Resource type for this extension */
+static Bool gate_closed = False; /* The global "gatekeeper" */
+static Bool key_ignore = False; /* The global "keymaster" */
+static Bool ignore_grabs = False;
+static CARD8 next_key = XEKeyIsClear; /* Echo, Clear, or Other */
+#ifdef VECTORED_EVENTS
+static INT16 current_screen = -1L; /* Current screen for events */
+#endif
+static INT16 vectored_requests[256L] = {0L}; /* cnt of vectoring clients */
+static INT16 vectored_events[KeyPress+MotionNotify] = {0L};
+typedef struct _client_list
+{
+ struct _client_list *next;
+ ClientPtr client;
+} ClientList;
+static ClientList io_clients; /* Linked-list of clients currently doing I/O */
+static ClientList stats_clients; /* Linked-list of clients collecting stats */
+static ClientList cmd_clients; /* Linked-list of clients using command key */
+
+/*----------------------------*
+ * Forward Declarations
+ *----------------------------*/
+static void _SwapProc (int (**f1 )(), int (**f2 )());
+static void sXETrapEvent (xETrapDataEvent *from , xETrapDataEvent *to );
+static int add_accelerator_node (ClientPtr client , ClientList *accel );
+static void remove_accelerator_node (ClientPtr client , ClientList *accel );
+static void update_protocol (xXTrapGetReq *reqptr , ClientPtr client );
+#ifdef COLOR_REPLIES
+static void GetSendColorRep (ClientPtr client , xResourceReq *req );
+static void GetSendNamedColorRep (ClientPtr client , xResourceReq *req );
+static void GetSendColorCellsRep (ClientPtr client , xResourceReq *req );
+static void GetSendColorPlanesRep (ClientPtr client , xResourceReq *req );
+#endif
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine is called by the server when a given client
+ * goes away (as identified by the first argument). All
+ * memory allocations, misc. values specific to a given
+ * client would be reset here.
+ *
+ */
+int XETrapDestroyEnv(pointer value, XID id)
+{
+ xXTrapReq request;
+ XETrapEnv *penv = XETenv[(long)value];
+
+ XETrapReset(&request,penv->client);
+ /* Free any memory malloc'd for a particular client here */
+ /* In case stop I/O wasn't received for this client */
+ if (penv->stats)
+ { /* Remove from client accelerator list */
+ remove_accelerator_node(penv->client, &stats_clients);
+ Xfree(penv->stats); /* Free the stats buckets */
+ }
+ if (cmd_clients.next == NULL)
+ { /* No more command key clients! Let's reset the gate */
+ gate_closed = False;
+ key_ignore = False;
+ next_key = XEKeyIsClear;
+ }
+
+#ifdef VECTORED_EVENTS
+ current_screen = -1L; /* Invalidate current screen */
+#endif
+
+#ifdef VERBOSE
+ ErrorF("%s: Client '%d' Disconnected\n", XTrapExtName,
+ penv->client->index);
+#endif
+
+ Xfree(penv);
+ XETenv[(long)value] = NULL;
+
+ return 0;
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine is called by the server when the last client
+ * (the session manager in most cases) goes away. This is server
+ * reset. When the server comes back up, this extension will not
+ * be loaded unless this routine makes the proper arrangements.
+ *
+ * The real concern here is to unload the extension
+ * and possibly make arragements to be called upon
+ * server restart.
+ *
+ */
+void XETrapCloseDown(ExtensionEntry *extEntry)
+{
+ long i;
+
+ for (i=0L; i<MAXCLIENTS; i++)
+ {
+ if (XETenv[i] != NULL)
+ {
+ XETrapDestroyEnv((pointer)i,0L);
+ }
+ }
+ ignore_grabs = False;
+ return;
+}
+
+/*
+ *
+ * DESCRIPTION:
+ *
+ * This routine has been created because of the initialization
+ * order that X uses, such that extensions are initialized before
+ * devices. This means that this extension must perform a second
+ * level of initialization to obtain the device references at some
+ * point after they have been initialized. It is assumed that when
+ * a client establishes communication with the extension that the
+ * devices havae been initialized, and therefore this function can
+ * obtain the information it needs.
+ *
+ * In obtaining the information, this function also places its own
+ * functions in place of the *standard* functions. The original
+ * functions are retained for vectoring purposes.
+ */
+
+Bool XETrapRedirectDevices()
+{
+ Bool retval = True;
+
+ /* Do we need to redirect the keyboard device? */
+ if (XETrapKbdDev == NULL)
+ {
+ if ((XETrapKbdDev = LookupKeyboardDevice()) == NULL)
+ {
+ retval = False;
+ }
+ else
+ {
+ EventProcVector[KeyPress] =
+ (int_function)XETrapKbdDev->realInputProc;
+ EventProcVector[KeyRelease] =
+ (int_function)XETrapKbdDev->realInputProc;
+ }
+#ifdef VECTORED_EVENTS
+ keybd_process_inp = EventProcVector[KeyPress];
+ EventProcVector[KeyPress] = EventProcVector[KeyRelease] = NULL;
+ XETrapEventProcVector[KeyPress] = XETrapEventVector;
+ XETrapEventProcVector[KeyRelease] = XETrapEventVector;
+#else /* !VECTORED_EVENTS */
+ XETrapEventProcVector[KeyPress] = XETrapKeyboard;
+ XETrapEventProcVector[KeyRelease] = XETrapKeyboard;
+#endif /* !VECTORED_EVENTS */
+ }
+ /* Do we need to redirect the pointer device? */
+#ifndef VECTORED_EVENTS
+ if (XETrapPtrDev == NULL)
+ {
+ if ((XETrapPtrDev = LookupPointerDevice()) == 0L)
+ {
+ retval = False;
+ }
+ else
+ {
+ EventProcVector[ButtonPress] =
+ (int_function)XETrapPtrDev->realInputProc;
+ EventProcVector[ButtonRelease] =
+ (int_function)XETrapPtrDev->realInputProc;
+ EventProcVector[MotionNotify] =
+ (int_function)XETrapPtrDev->realInputProc;
+ }
+ XETrapEventProcVector[ButtonPress] = XETrapPointer;
+ XETrapEventProcVector[ButtonRelease] = XETrapPointer;
+ XETrapEventProcVector[MotionNotify] = XETrapPointer;
+ }
+#endif /* !VECTORED_EVENTS */
+ return(retval);
+}
+
+/*
+ *
+ * DESCRIPTION:
+ *
+ * This routine is the main entry point for the Xtrap extension. It is
+ * called by the server to inititalize the Xtrap extension. Once the
+ * extension is initialized, life is controlled by the XtrapDispatch
+ * routine by the requests it will handle.
+ *
+ * Initializes all the XTrap data structures with the proper
+ * addresses of defined routines that will help control the extension.
+ * It is vital that the extension state be kept accurate so that only
+ * one call to this routine be made.
+ *
+ */
+
+void DEC_XTRAPInit()
+{
+ register ExtensionEntry *extEntry;
+ unsigned int i;
+ Atom a;
+
+ /* Make the extension known to the server. Must be done every time
+ * DEC_XTRAPInit is called, else server will think it failed.
+ */
+ if ((extEntry = AddExtension(XTrapExtName,XETrapNumEvents,
+ XETrapNumErrors,XETrapDispatch,sXETrapDispatch,XETrapCloseDown
+ ,StandardMinorOpcode)) == NULL)
+ {
+ ErrorF("%s: AddExtension Failed!\n", XTrapExtName);
+ return;
+ }
+#ifdef VERBOSE
+ ErrorF("%s: AddExtension assigned Major Opcode '%d'\n",
+ XTrapExtName, extEntry->base);
+#endif
+ XETrap_avail.data.major_opcode = extEntry->base;
+ XETrapErrorBase = extEntry->errorBase;
+ XETrap_avail.data.event_base = extEntry->eventBase;
+
+ /* Set up our swapped reply vector */
+ ReplySwapVector[XETrap_avail.data.major_opcode] =
+ (void_function) sReplyXTrapDispatch;
+
+ /* Set up our swapped event vector */
+ EventSwapVector[extEntry->eventBase + XETrapData] =
+ (EventSwapPtr) sXETrapEvent;
+
+ /* make an atom saying that the extension is present. The
+ * adding of the resource occurs during XETrapCreateEnv().
+ */
+ if ((a = MakeAtom(XTrapExtName,strlen(XTrapExtName),1L)) == None ||
+ (XETrapType = CreateNewResourceType(XETrapDestroyEnv)) == 0L)
+ {
+ ErrorF("%s: Setup can't create new resource type (%d,%d,%d)\n",
+ XTrapExtName, (int)a,(int)XETrapClass,(int)XETrapType);
+ return;
+ }
+ /* initialize the GetAvailable info reply here */
+ XETrap_avail.hdr.type = X_Reply;
+ XETrap_avail.hdr.length = XEXTRA(xXTrapGetAvailReply);
+ XETrap_avail.data.xtrap_release = XETrapRelease;
+ XETrap_avail.data.xtrap_version = XETrapVersion;
+ XETrap_avail.data.xtrap_revision = XETrapRevision;
+ XETrap_avail.data.pf_ident = XETrapPlatform;
+ XETrap_avail.data.max_pkt_size = 0xFFFF; /* very large number */
+ for (i=0L; i<ASIZE(XETrap_avail.data.valid); i++)
+ {
+ XETrap_avail.data.valid[i] = 0L; /* Clear bits initially */
+ }
+ BitTrue(XETrap_avail.data.valid,XETrapTimestamp);
+ BitTrue(XETrap_avail.data.valid,XETrapCmd);
+ BitTrue(XETrap_avail.data.valid,XETrapCmdKeyMod);
+ BitTrue(XETrap_avail.data.valid,XETrapRequest);
+ BitTrue(XETrap_avail.data.valid,XETrapEvent);
+ BitTrue(XETrap_avail.data.valid,XETrapMaxPacket);
+ BitTrue(XETrap_avail.data.valid,XETrapStatistics);
+ BitTrue(XETrap_avail.data.valid,XETrapWinXY);
+ /* Not yet implemented */
+ BitFalse(XETrap_avail.data.valid,XETrapCursor);
+#ifndef _XINPUT
+ BitFalse(XETrap_avail.data.valid,XETrapXInput);
+#else
+ BitTrue(XETrap_avail.data.valid,XETrapXInput);
+#endif
+#ifndef VECTORED_EVENTS
+ BitFalse(XETrap_avail.data.valid,XETrapVectorEvents);
+#else
+ BitTrue(XETrap_avail.data.valid,XETrapVectorEvents);
+#endif /* VECTORED_EVENTS */
+#ifndef COLOR_REPLIES
+ BitFalse(XETrap_avail.data.valid,XETrapColorReplies);
+#else
+ BitTrue(XETrap_avail.data.valid,XETrapColorReplies);
+#endif /* COLOR_REPLIES */
+ BitTrue(XETrap_avail.data.valid,XETrapGrabServer);
+ /* initialize multi-client accelerator lists */
+ io_clients.next = NULL;
+ stats_clients.next = NULL;
+ cmd_clients.next = NULL;
+ for (i=0L; i<256L; i++)
+ {
+ vectored_requests[i] = 0L;
+ }
+ for (i=KeyPress; i<=MotionNotify; i++)
+ {
+ vectored_events[i] = 0L;
+ }
+ gate_closed = False;
+ key_ignore = False;
+ next_key = XEKeyIsClear;
+
+ XETrapPlatformSetup();
+ /* Initialize any local memory we use */
+ for (i=0L; i<ASIZE(EventProcVector); i++)
+ {
+ EventProcVector[i] = NULL;
+#ifndef VECTORED_EVENTS
+ XETrapEventProcVector[i] = NULL;
+#else
+ XETrapEventProcVector[i] = XETrapEventVector;
+#endif
+ }
+ XETrapKbdDev = NULL;
+ XETrapPtrDev = NULL;
+ for (i=0L; i<ASIZE(XETrapProcVector); i++)
+ {
+ XETrapProcVector[i] = XETrapRequestVector;
+ }
+ for (i=128L; i<=255L; i++)
+ { /* Extension "swapped" requests are not implemented */
+ XETSwProcVector[i] = NotImplemented;
+ }
+#ifdef VERBOSE
+ ErrorF("%s: Vers. %d.%d-%d successfully loaded\n", XTrapExtName,
+ XETrap_avail.data.xtrap_release,
+ XETrap_avail.data.xtrap_version,
+ XETrap_avail.data.xtrap_revision);
+#endif
+
+ return;
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This procedure is called upon dispatch to allocate an
+ * environment structure for a new XTrap client. The XETenv[]
+ * entry is allocated and initialized with default values.
+ * XETrapDestroyEnv() is responsible for deallocating this memory
+ * upon client termination.
+ *
+ * Note: the status of this routine is returned to the caller of
+ * the Dispatch routine which will in turn SendErrorToClient if
+ * necessary.
+ *
+ */
+
+int XETrapCreateEnv(ClientPtr client)
+{
+ XETrapEnv *penv = NULL;
+ int status = Success;
+
+ if (client->index > MAXCLIENTS)
+ {
+ status = BadImplementation;
+ }
+ else if ((XETenv[client->index] = (XETrapEnv *)Xcalloc(sizeof(XETrapEnv)))
+ == NULL)
+ {
+ status = BadAlloc;
+ }
+ if (status == Success)
+ {
+ penv = XETenv[client->index];
+ penv->client = client;
+ penv->protocol = 31; /* default to backwards compatibility */
+ /* prep for client's departure (for memory dealloc, cleanup) */
+ AddResource(FakeClientID(client->index),XETrapType,
+ (pointer)(long)(client->index));
+ if (XETrapRedirectDevices() == False)
+ {
+ status = XETrapErrorBase + BadDevices;
+ }
+ /* Initialize the current state */
+ if (status == Success)
+ {
+ status = XETrapReset(NULL, penv->client);
+ }
+ }
+
+#ifdef VECTORED_EVENTS
+ current_screen = -1L; /* Invalidate current screen */
+#endif
+
+#ifdef VERBOSE
+ if (status == Success)
+ {
+ ErrorF("%s: Client '%d' Connection Accepted\n", XTrapExtName,
+ penv->client->index);
+ }
+#endif
+
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This procedure is defined for the call to AddExtension()
+ * in which it is expected to be a parameter of the call.
+ *
+ * This routine will be called by the server dispatcher
+ * when a client makes a request that is handled
+ * by the extension and the byte ordering of the client is the
+ * SAME as that of the extension.
+ *
+ * Note: the status of the requests is returned to the caller of
+ * the Dispatch routine which will in turn SendErrorToClient if
+ * necessary.
+ */
+
+int XETrapDispatch(ClientPtr client)
+{
+
+ REQUEST(xXTrapReq);
+ register int status = Success;
+
+ REQUEST_AT_LEAST_SIZE(xXTrapReq);
+
+ /* Have we seen this client before? */
+ if (XETenv[client->index] == NULL)
+ {
+ status = XETrapCreateEnv(client);
+ }
+ /* Do we have a valid request? */
+ if (status == Success)
+ {
+ if (stuff->minor_opcode < ASIZE(XETrapDispatchVector))
+ {
+ /* Then vector to the pointed to function */
+ status =
+ (*(XETrapDispatchVector[stuff->minor_opcode]))(stuff,client);
+ }
+ else
+ {
+ status = BadRequest;
+ }
+ }
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This procedure is defined for the call to AddExtension()
+ * in which it is expected to be a parameter of the call.
+ *
+ * This routine would ordinarily be called by the server
+ * dispatcher when a client makes a request that is handled
+ * by the extension and the byte ordering of the client is
+ * DIFFERENT than that of the extension.
+ */
+
+int sXETrapDispatch(ClientPtr client)
+{
+
+ REQUEST(xXTrapReq);
+ register int status = Success;
+
+ REQUEST_AT_LEAST_SIZE(xXTrapReq);
+
+ /* Have we seen this client before? */
+ if (XETenv[client->index] == NULL)
+ {
+ status = XETrapCreateEnv(client);
+ }
+ /* Do we have a valid request? */
+ if (status == Success)
+ {
+ if (stuff->minor_opcode < ASIZE(XETSwDispatchVector))
+ {
+ /* Then vector to the pointed to function */
+ status =
+ (*(XETSwDispatchVector[stuff->minor_opcode]))(stuff,client);
+ }
+ else
+ {
+ status = BadRequest;
+ }
+ }
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine will place the extension in a steady and known
+ * state. Any current state will be reset. This is called either
+ * by a client request (dispatched) or when a new client environment
+ * is created.
+ *
+ */
+int XETrapReset(xXTrapReq *request, ClientPtr client)
+{
+ static xXTrapConfigReq DummyReq;
+ register int i;
+ register int status = Success;
+ XETrapEnv *penv = XETenv[client->index];
+
+ /* in case any i/o's pending */
+ (void)XETrapStopTrap((xXTrapReq *)NULL, client);
+ penv->cur.hdr.type = X_Reply;
+ penv->cur.hdr.length = XEXTRA(xXTrapGetCurReply);
+ /* Fill in a dummy config request to clear all elements */
+ for (i=0L; i<ASIZE(DummyReq.config_flags_valid); i++)
+ {
+ DummyReq.config_flags_valid[i] = 0xFFL; /* set all the valid flags */
+ DummyReq.config_flags_data[i] = 0L; /* clear all data flags */
+ }
+ /* Don't reset grab server arbitrarily, it must be explicitly
+ * de-configured.
+ */
+ BitSet(DummyReq.config_flags_data, XETrapGrabServer, ignore_grabs);
+ for (i=0L; i< ASIZE(DummyReq.config_flags_req); i++)
+ {
+ DummyReq.config_flags_req[i] = 0xFF; /* Clear all protocol requests */
+ }
+ for (i=0L; i< ASIZE(DummyReq.config_flags_event); i++)
+ {
+ DummyReq.config_flags_event[i] = 0xFF; /* Clear all protocol events */
+ }
+ /* Call config routine to clear all configurable fields */
+ status = XETrapConfig(&DummyReq, client);
+ /* reset the environment */
+ for (i=0L; i<ASIZE(penv->cur.data_state_flags); i++)
+ {
+ penv->cur.data_state_flags[i] = 0L; /* Clear all env flags */
+ }
+ penv->cur.data_config_max_pkt_size = XETrap_avail.data.max_pkt_size;
+
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sends a reply back to the requesting client indicating
+ * the available states of the extension can be configured for.
+ */
+int XETrapGetAvailable(xXTrapGetReq *request, ClientPtr client)
+{
+ XETrapEnv *penv = XETenv[client->index];
+ update_protocol(request, client);
+ /* Initialize the reply as needed */
+ XETrap_avail.data.xtrap_protocol = penv->protocol;
+ XETrap_avail.hdr.detail = XETrap_GetAvailable;
+ XETrap_avail.hdr.sequenceNumber = client->sequence;
+ WriteReplyToClient(client, sizeof(xXTrapGetAvailReply), &XETrap_avail);
+ return(Success);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sends a reply back to the requesting client indicating
+ * the current state of the extension.
+ */
+int XETrapGetCurrent(xXTrapReq *request, ClientPtr client)
+{
+ XETrapEnv *penv = XETenv[client->index];
+ int rep_size = (penv->protocol == 31 ? 284 : sz_xXTrapGetCurReply);
+ penv->cur.hdr.length = (rep_size - 32L) / SIZEOF(CARD32);
+
+ /* Initialize the reply as needed */
+ penv->cur.hdr.detail = XETrap_GetCurrent;
+ penv->cur.hdr.sequenceNumber = client->sequence;
+ WriteReplyToClient(client, rep_size, &(penv->cur));
+
+ return(Success);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sends a reply back to the requesting client dumping
+ * statistics (counts) of requests and events. If stat's isn't
+ * configured, return failure.
+ */
+int XETrapGetStatistics(xXTrapReq *request, ClientPtr client)
+{
+ int status = Success;
+ XETrapEnv *penv = XETenv[client->index];
+
+ if ((BitIsTrue(penv->cur.data_config_flags_data, XETrapStatistics)) &&
+ (penv->stats))
+ {
+ /* Initialize the reply as needed */
+ int rep_size = sizeof(xXTrapGetStatsReply);
+ penv->stats->detail = XETrap_GetStatistics;
+ penv->stats->sequenceNumber = client->sequence;
+ if (penv->protocol == 31)
+ {
+ xXTrapGetStatsReply rep_stats;
+ rep_stats = *penv->stats;
+#ifndef VECTORED_EVENTS
+ rep_size = 1060;
+#else
+ rep_size = 1544;
+#endif
+ rep_stats.length = (rep_size - 32L) / SIZEOF(CARD32);
+ /*
+ * Now we need to shift the data *into* the header area
+ * for bug compatibility.
+ */
+ memcpy(&(rep_stats.pad0),&(penv->stats->data),
+ sizeof(XETrapGetStatsRep));
+ WriteReplyToClient(client, rep_size, &rep_stats);
+ }
+ else
+ {
+ WriteReplyToClient(client, rep_size, penv->stats);
+ }
+ }
+ else
+ {
+ status = XETrapErrorBase + BadStatistics;
+ }
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function is dispatched when a client requests the extension to
+ * be configured in some manner.
+ */
+int XETrapConfig(xXTrapConfigReq *request, ClientPtr client)
+{
+ UByteP vflags = request->config_flags_valid;
+ UByteP dflags = request->config_flags_data;
+ UByteP req_flags = request->config_flags_req;
+ UByteP event_flags = request->config_flags_event;
+ XETrapEnv *penv = XETenv[client->index];
+ UByteP bit_flags = penv->cur.data_config_flags_data;
+ int status = Success;
+ CARD32 i = 0L;
+
+ /* Check events and swap if desired */
+ if (BitIsTrue(vflags,XETrapEvent))
+ { /* Loop through all of the events */
+ for (i=0L; i<ASIZE(EventProcVector); i++)
+ {
+ if (BitIsTrue(event_flags,i) && /* Do we care about this one? */
+ (BitValue(dflags,XETrapEvent) ^ /* Exclusive Or */
+ (BitValue(penv->cur.data_config_flags_event,i))))
+ { /* At this point we *know* there's a change. The
+ * only question remaining is are there any more
+ * clients interested in this specific event. If
+ * so, *don't* swap this process!
+ */
+ if (BitIsTrue(dflags,XETrapEvent))
+ { /* Client wants the XTrap rtn */
+ if (++(vectored_events[i]) <= 1L)
+ { /* first client, so do it */
+ _SwapProc(&(XETrapEventProcVector[i]),
+ &(EventProcVector[i]));
+ }
+ }
+ else
+ { /* Client wants the *real* rtn */
+ if (--(vectored_events[i]) <= 0L)
+ { /* No more clients using, so do it */
+ _SwapProc(&(XETrapEventProcVector[i]),
+ &(EventProcVector[i]));
+ }
+ }
+ switch(i)
+ {
+ case KeyPress: /* needed for command key processing */
+ case KeyRelease:
+ XETrapKbdDev->processInputProc =
+ (void_function)(EventProcVector[i] ?
+ (void_function)EventProcVector[i] :
+ (void_function)keybd_process_inp);
+ XETrapKbdDev->realInputProc =
+ (void_function)(EventProcVector[i] ?
+ (void_function)EventProcVector[i] :
+ (void_function)keybd_process_inp);
+ break;
+#ifndef VECTORED_EVENTS
+ case ButtonPress: /* hack until events become vectored */
+ case ButtonRelease:
+ case MotionNotify:
+ XETrapPtrDev->processInputProc =
+ (void_function)EventProcVector[i];
+ XETrapPtrDev->realInputProc =
+ (void_function)EventProcVector[i];
+ break;
+ default:
+ status = BadImplementation;
+ break;
+#endif /* !VECTORED_EVENTS */
+ }
+ BitToggle(penv->cur.data_config_flags_event,i);
+ }
+ }
+ }
+ if ((status == Success) &&
+ (_CheckChangeBit(vflags,dflags,bit_flags,XETrapCmd)))
+ {
+ if (BitIsTrue(dflags, XETrapCmd))
+ { /* Add accelerator entry to cmd_clients list iff necessary */
+ penv->cur.data_config_cmd_key = request->config_cmd_key;
+ status = add_accelerator_node(penv->client, &cmd_clients);
+ }
+ else
+ {
+ penv->cur.data_config_cmd_key = 0L; /* default no KeyCode */
+ remove_accelerator_node(penv->client, &cmd_clients);
+ }
+ }
+ if ((status == Success) &&
+ (_CheckChangeBit(vflags,dflags,bit_flags,XETrapMaxPacket)))
+ {
+ if (BitIsTrue(dflags,XETrapMaxPacket))
+ { /* Set size to what's passed in */
+ if (request->config_max_pkt_size < XETrapMinPktSize)
+ { /* Tell them the value is too small */
+ status = BadValue;
+ }
+ else
+ {
+ penv->cur.data_config_max_pkt_size =
+ request->config_max_pkt_size;
+ }
+ }
+ else
+ { /* Set it to the default (a *very* big number) */
+ penv->cur.data_config_max_pkt_size = 0xFFFF;
+ }
+ }
+ /* If the valid flag is set for requests, then each of the
+ * requests is swapped if it's different from current state.
+ */
+ if (BitIsTrue(vflags,XETrapRequest) && status == Success)
+ { /* Loop through all of the core requests */
+ for (i=0L; i<ASIZE(XETrapProcVector); i++)
+ {
+ if (BitIsTrue(req_flags,i) && /* Do we care about this one? */
+ (BitValue(dflags,XETrapRequest) ^ /* Exclusive Or */
+ (BitValue(penv->cur.data_config_flags_req,i))))
+ { /* At this point we *know* there's a change. The
+ * only question remaining is are there any more
+ * clients interested in this specific request. If
+ * so, *don't* swap this process!
+ */
+ if (BitIsTrue(dflags,XETrapRequest))
+ { /* Client wants the XTrap rtn */
+ if (++(vectored_requests[i]) <= 1L)
+ { /* first client, so do it */
+ _SwapProc(&(XETrapProcVector[i]), &(ProcVector[i]));
+ }
+ }
+ else
+ { /* Client wants the *real* rtn */
+ if (--(vectored_requests[i]) <= 0L)
+ { /* No more clients using, so do it */
+ _SwapProc(&(XETrapProcVector[i]), &(ProcVector[i]));
+ }
+ }
+ if (status == Success)
+ {
+ BitToggle(penv->cur.data_config_flags_req,i);
+ }
+ }
+ }
+ }
+ /* Check & Set the boolean flags */
+ if (status == Success)
+ {
+ _CheckChangeBit(vflags,dflags,bit_flags,XETrapCmdKeyMod);
+ _CheckChangeBit(vflags,dflags,bit_flags,XETrapTimestamp);
+ _CheckChangeBit(vflags,dflags,bit_flags,XETrapWinXY);
+/* _CheckChangeBit(vflags,dflags,bit_flags,XETrapCursor); */
+#ifdef COLOR_REPLIES
+ _CheckChangeBit(vflags,dflags,bit_flags,XETrapColorReplies);
+#endif /* COLOR_REPLIES */
+ if (_CheckChangeBit(vflags,dflags,bit_flags,XETrapGrabServer))
+ { /* Let any client uncoditionally set/clear Grabs */
+ ignore_grabs = BitValue(dflags, XETrapGrabServer);
+ }
+ }
+ /* The statistics vflag/dflag mechanism is a little different
+ * from most. The dflag is initially set to 0 to indicate no
+ * statistics. When a config request comes in to request
+ * statistics, memory's allocated and the dflag is set.
+ * Thereafter, whenever a client wants to clear the counters, he
+ * simply sets the vflag and clears the dflag. Multiple requests
+ * for statistics configuration are ignored, and the stats memory is
+ * free'd only when the client disconnects.
+ */
+ if (status == Success)
+ {
+ if (_CheckChangeBit(vflags,dflags,bit_flags,XETrapStatistics))
+ {
+ if (BitIsTrue(dflags,XETrapStatistics))
+ { /* Do we need to allocate memory? */
+ if (penv->stats == NULL && (penv->stats =
+ (xXTrapGetStatsReply *)Xcalloc(sizeof(xXTrapGetStatsReply)))
+ != NULL)
+ { /* Set up the reply header */
+ penv->stats->type = X_Reply;
+ penv->stats->length = XEXTRA(xXTrapGetStatsReply);
+ /* add accelerator node for stats clients list */
+ status = add_accelerator_node(penv->client, &stats_clients);
+ }
+ else if (penv->stats == NULL)
+ { /* No Memory! */
+ status = BadAlloc;
+ }
+ }
+ else
+ { /* Zero out counters */
+ (void)memset(penv->stats->data.requests, 0L,
+ sizeof(penv->stats->data.requests));
+ (void)memset(penv->stats->data.events, 0L,
+ sizeof(penv->stats->data.events));
+ /* Re-cock the Stat's flag so that it'll
+ * sense a change for next zero'ing out
+ * of the counters.
+ */
+ BitTrue(penv->cur.data_config_flags_data, XETrapStatistics);
+ }
+ }
+ }
+ return(status);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sets the XETrapTrapActive bit to indicate that Trapping
+ * of requests and/or core events to the client may take place.
+ *
+ */
+int XETrapStartTrap(xXTrapReq *request, ClientPtr client)
+{
+ XETrapEnv *penv = XETenv[client->index];
+ int status = add_accelerator_node(penv->client, &io_clients);
+ if (status == Success)
+ {
+ BitTrue(penv->cur.data_state_flags, XETrapTrapActive);
+ }
+ return(status);
+}
+/*
+ * DESCRIPTION:
+ *
+ * This function clears the XETrapTrapActive bit to indicate that Trapping
+ * of requests and/or core events to the client may *not* take place.
+ *
+ */
+int XETrapStopTrap(xXTrapReq *request, ClientPtr client)
+{
+ XETrapEnv *penv = XETenv[client->index];
+
+ remove_accelerator_node(penv->client, &io_clients);
+ BitFalse(penv->cur.data_state_flags, XETrapTrapActive);
+ return(Success);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sends a reply back to the requesting client indicating
+ * the specific XTrap version of this extension.
+ */
+int XETrapGetVersion(xXTrapGetReq *request, ClientPtr client)
+{
+ xXTrapGetVersReply ver_rep;
+ XETrapEnv *penv = XETenv[client->index];
+
+ update_protocol(request,client); /* to agree on protocol version */
+ /* Initialize the reply as needed */
+ ver_rep.hdr.type = X_Reply;
+ ver_rep.hdr.detail = XETrap_GetVersion;
+ ver_rep.hdr.sequenceNumber = client->sequence;
+ ver_rep.hdr.length = XEXTRA(xXTrapGetVersReply);
+ ver_rep.data.xtrap_release = XETrap_avail.data.xtrap_release;
+ ver_rep.data.xtrap_version = XETrap_avail.data.xtrap_version;
+ ver_rep.data.xtrap_revision = XETrap_avail.data.xtrap_revision;
+ ver_rep.data.xtrap_protocol = penv->protocol; /* return agreed protocol */
+ WriteReplyToClient(client, sizeof(xXTrapGetVersReply), &ver_rep);
+ return(Success);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function sends a reply back to the requesting client indicating
+ * the specific XTrap version of this extension.
+ */
+int XETrapGetLastInpTime(xXTrapReq *request, ClientPtr client)
+{
+ xXTrapGetLITimReply tim_rep;
+ XETrapEnv *penv = XETenv[client->index];
+
+ /* Initialize the reply as needed */
+ tim_rep.hdr.type = X_Reply;
+ tim_rep.hdr.detail = XETrap_GetLastInpTime;
+ tim_rep.hdr.sequenceNumber = client->sequence;
+ tim_rep.hdr.length = XEXTRA(xXTrapGetLITimReply);
+ tim_rep.data_last_time = penv->last_input_time;
+ WriteReplyToClient(client, sizeof(xXTrapGetLITimReply), &tim_rep);
+ return(Success);
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine is swapped in for the server's output request vectors.
+ * After writing the request to one (or more) XTrap client(s), this
+ * routine ALWAYS returns by calling the REAL output request vector rtn.
+ *
+ * Note: Swapped Requests are handled automatically since the unswapped
+ * vectored routine is called after the request has been swapped.
+ * IOW, all requests are directed through ProcVector eventually and are
+ * "unswapped" at that point. It is necessary to swap the data
+ * back if writing to a swapped client, however, and this is done
+ * by calling the appropriate XETSwProcVector[] routine.
+ */
+int XETrapRequestVector(ClientPtr client)
+{
+ int status = True;
+ XETrapDatum *pdata, *spdata = NULL;
+ REQUEST(xResourceReq);
+ WindowPtr window_ptr;
+ XETrapEnv *penv;
+ BYTE *tptr;
+ ClientList *ioc = &io_clients;
+ ClientList *stc = &stats_clients;
+ INT32 asize = sizeof(pdata->hdr) + stuff->length * sizeof(CARD32);
+ INT32 size = MAX(asize,XETrapMinPktSize); /* Must be at least */
+ INT32 csize; /* size of request to send to the XTrap client */
+
+ /* Get memory for the data to be sent */
+ if ((pdata = (XETrapDatum *)Xcalloc(size)) == NULL)
+ { /* Can't do anything accept set a flag since we don't
+ * know who to send the error to yet.
+ */
+ status = False;
+ }
+
+ while (ioc->next != NULL)
+ {
+ ioc = ioc->next;
+ penv = XETenv[ioc->client->index];
+ if (status == False)
+ { /* We didn't get the memory! Complain */
+ SendErrorToClient(penv->client,XETrap_avail.data.major_opcode,
+ stuff->reqType, 0L, BadAlloc);
+ break;
+ }
+ if (BitIsTrue(penv->cur.data_config_flags_req,stuff->reqType))
+ { /* This particular client is interested in *this* request */
+ pdata->hdr.client = client->index; /* stuff client index in hdr */
+ if (BitIsTrue(penv->cur.data_config_flags_data,XETrapWinXY))
+ {
+ window_ptr = (WindowPtr) LookupDrawable(stuff->id, client);
+ if (window_ptr == 0L)
+ { /* Failed...invalidate the X and Y coordinate data. */
+ pdata->hdr.win_x = -1L;
+ pdata->hdr.win_y = -1L;
+ }
+ else
+ {
+ pdata->hdr.screen = window_ptr->drawable.pScreen->myNum;
+ pdata->hdr.win_x = window_ptr->drawable.x;
+ pdata->hdr.win_y = window_ptr->drawable.y;
+ }
+ }
+ if (BitIsTrue(penv->cur.data_config_flags_data,XETrapTimestamp))
+ {
+ pdata->hdr.timestamp = GetTimeInMillis();
+ }
+ /* Copy the information to a location we can write it from */
+ (void) memcpy(&(pdata->u.req),stuff,stuff->length*sizeof(CARD32));
+ pdata->hdr.count = MIN(penv->cur.data_config_max_pkt_size,asize);
+ XETrapSetHeaderRequest(&(pdata->hdr));
+
+ /* Perform any needed byte/word swapping. NOTE: This is not
+ * the "normal" technique that should be used to perform the
+ * swapping. The reason that we do it here is to be sure to
+ * do it only once in a controlled manner, which we can not
+ * guarentee in the case of the Xlib transport. Notice that
+ * we don't swap the XTRAP EVENT information. This is done
+ * in the XETrapWriteXLib() routine.
+ */
+
+ if (penv->client->swapped)
+ { /* need to deal with swapped clients */
+ if (spdata == NULL)
+ { /* Get memory for the swapped data to be sent */
+ if ((spdata = (XETrapDatum *)Xcalloc(size)) == NULL)
+ {
+ SendErrorToClient(penv->client,
+ XETrap_avail.data.major_opcode,
+ stuff->reqType, 0L, BadAlloc);
+ break;
+ }
+
+ memcpy(spdata,pdata,size); /* fill in the info */
+ /* Now call the request-specific rtn to swap the request */
+ if (stuff->reqType < 128)
+ { /* a core request, good */
+ (*XETSwProcVector[stuff->reqType])(&(spdata->u.req),
+ penv->client); /* RTC X11R6 */
+ }
+ else if (penv->cur.data_config_max_pkt_size ==
+ XETrapMinPktSize)
+ { /* Minimum size, so swap it as an ResourceReq */
+ XETSwResourceReq(&(spdata->u.req));
+ }
+ else
+ { /* trying to swap an extension request! */
+ SendErrorToClient(penv->client,
+ XETrap_avail.data.major_opcode,
+ stuff->reqType, 0L, XETrapErrorBase + BadSwapReq);
+ }
+ }
+ /* need to stow in the latest header (count) */
+ memcpy(spdata,pdata,SIZEOF(XETrapHeader));
+ sXETrapHeader(&(spdata->hdr)); /* swap the XTrap Header */
+ }
+ /* Write as many bytes of information as the client wants */
+ tptr = (BYTE *)(penv->client->swapped ? spdata : pdata);
+ csize = MAX(pdata->hdr.count, XETrapMinPktSize);
+ if (XETrapWriteXLib(penv, tptr, csize) != csize)
+ {
+ SendErrorToClient(penv->client,XETrap_avail.data.major_opcode,
+ stuff->reqType, 0L, XETrapErrorBase + BadIO);
+ }
+#ifdef COLOR_REPLIES
+ /* Process Color Replies, if desired, and applicable */
+ if (BitIsTrue(penv->cur.data_config_flags_data,XETrapColorReplies))
+ { /* wants color replies */
+ switch(stuff->reqType)
+ {
+ case X_AllocColor:
+ GetSendColorRep(client, stuff);
+ break;
+ case X_AllocNamedColor:
+ GetSendNamedColorRep(client, stuff);
+ break;
+ case X_AllocColorCells:
+ GetSendColorCellsRep(client, stuff);
+ break;
+ case X_AllocColorPlanes:
+ GetSendColorPlanesRep(client, stuff);
+ break;
+ default:
+ break;
+ }
+ }
+#endif /* COLOR_REPLIES */
+ }
+ }
+ while (stc->next != NULL)
+ { /* increment appropriate stats bucket for each interested client */
+ stc = stc->next;
+ penv = XETenv[stc->client->index];
+ if (BitIsTrue(penv->cur.data_config_flags_req,stuff->reqType))
+ { /* This particular client would like this particular stat */
+ penv->stats->data.requests[stuff->reqType]++;
+ }
+ }
+
+ if (pdata)
+ {
+ Xfree(pdata);
+ }
+ if (spdata)
+ {
+ Xfree(spdata);
+ }
+ if (ignore_grabs == True &&
+ (stuff->reqType == X_GrabServer || stuff->reqType == X_UngrabServer))
+ { /* doesn't want Grab's! Note: this is a "last configured" setting */
+#ifndef NO_NEW_XTRAP
+ int status;
+
+ if (stuff->reqType == X_GrabServer)
+ {
+ ClientList *pclient;
+
+ /* first call grab server procedure */
+ status = (*XETrapProcVector[stuff->reqType])(client);
+
+ /* then add XTrap controlling clients */
+ for (pclient = &io_clients; pclient; pclient = pclient->next)
+ if (pclient->client)
+ MakeClientGrabImpervious(pclient->client);
+ }
+ else
+ {
+ ClientList *pclient;
+
+ /* first drop XTrap controlling clients */
+ for (pclient = &io_clients; pclient; pclient = pclient->next)
+ if (pclient->client)
+ MakeClientGrabPervious(pclient->client);
+
+ /* then call ungrab server procedure */
+ status = (*XETrapProcVector[stuff->reqType])(client);
+ }
+ return status;
+#else /* NO_NEW_XTRAP */
+ return(Success);
+#endif /* NO_NEW_XTRAP */
+ }
+ else
+ {
+ return((*XETrapProcVector[stuff->reqType])(client));
+ }
+}
+/*
+ *
+ * DESCRIPTION:
+ *
+ * This routine intercepts input xEvents from the keyboard.
+ * if XETrapTrapActive, will write record to client(s)
+ * and then pass the event to the server iff not command
+ * key and gate is open. If it's a command key, then twiddle
+ * the gate state as required (optional, see below).
+ *
+ * This routine implements an optional user specified command key
+ * that can be used to close the input pipe into the server
+ * while a client command is generated. The keypress of the
+ * command key places this routine in command mode, the keyrelease
+ * exits command mode.
+ *
+ * A keypress of the command key followed by the
+ * optionally specified lock key will place this routine in continuous
+ * command mode until the command key and lock key are pressed again
+ * to exit command mode. In the locked state, the client interprets
+ * keystrokes as it wishes, as commands or as input to a prior command.
+ *
+ * Both mechanisms can be used alternately.
+ *
+ * IMPLICIT INPUTS :
+ *
+ * penv->cur.data_config_cmd_key :
+ * This is the keycode of the key that is used to stop
+ * and restart the transmission of intercepted input
+ * events to the server. If specified, the gate_state
+ * flag will be set or cleared depending on the state of
+ * the command_key.
+ *
+ * penv->cur.data_config_flags_data.XETrapCmdKeyMod:
+ * This is the value of the mode in which the command_key
+ * will operate. It currently has two values: MODIFIER and
+ * COMMAND_LOCK. MODIFIER mode clears gate_state on
+ * keypress, and sets gate_state on keyrelease.
+ * COMMAND_LOCK mode toggles gate_state on
+ * or off.
+ *
+ * gate_closed:
+ * A flag that is set/cleared in the xtrap_keyboard
+ * routine that indicates whether intercepted input
+ * should be passed to the server at any particular
+ * instance.
+ *
+ *
+ * next_key:
+ * This variable tracks the state of the next key to be
+ * pressed or released. It allows the checking of double
+ * presses of the command key to be sent to the server and
+ * keeps good state order when the command key is used.
+ *
+ * key_ignore:
+ * This variable indicates whether or not the specific
+ * key should be ignored for subsequent server processing.
+ *
+ */
+int XETrapKeyboard(xEvent *x_event, DevicePtr keybd, int count)
+{
+ register BYTE type = x_event->u.u.type;
+ register BYTE detail = x_event->u.u.detail;
+ XETrapEnv *penv;
+ ClientList *stc = &stats_clients;
+ ClientList *cmc = &cmd_clients;
+ int_function cur_func = XETrapKeyboard;
+
+#ifdef VERBOSE
+ if (count != 1L)
+ { /* We haven't coded for this situation yet! */
+ ErrorF("Warning! Event count != 1 (%d)\n", count);
+ }
+#endif
+ while (stc->next != NULL)
+ { /* increment appropriate stats bucket for each interested client */
+ stc = stc->next;
+ penv = XETenv[stc->client->index];
+ if (BitIsTrue(penv->cur.data_config_flags_event,type))
+ { /* This particular client would like this particular stat */
+ penv->stats->data.events[type]++;
+ }
+ }
+#ifndef VECTORED_EVENTS
+ /* We *only* StampAndMail command keys with vectored events since
+ * we get much more data by waiting till we get called in XETrapEventVector
+ */
+ XETrapStampAndMail(x_event); /* send to XTrap client if necessry */
+#endif
+ while (cmc->next != NULL)
+ {
+ cmc = cmc->next;
+ penv = XETenv[cmc->client->index];
+ key_ignore = False;
+ if (detail == penv->cur.data_config_cmd_key)
+ {
+ if (BitIsTrue(penv->cur.data_config_flags_data, XETrapCmdKeyMod))
+ {
+ switch (type)
+ {
+ case KeyPress:
+ if (next_key == XEKeyIsEcho)
+ {
+ break;
+ }
+ gate_closed = True;
+ next_key = XEKeyIsClear;
+ break;
+
+ case KeyRelease:
+ if (next_key == XEKeyIsEcho)
+ {
+ next_key = XEKeyIsClear;
+ break;
+ }
+ if (next_key == XEKeyIsClear)
+ {
+ next_key = XEKeyIsEcho;
+ }
+ else
+ { /* it's Other, so Clear it */
+ next_key = XEKeyIsClear;
+ }
+ gate_closed = False;
+ key_ignore = True;
+ break;
+
+ default: break;
+ }
+ }
+ else
+ {
+ switch (type)
+ {
+ case KeyPress:
+ if (next_key == XEKeyIsEcho)
+ {
+ gate_closed = False;
+ break;
+ }
+ /* Open gate on cmd key release */
+ if ((next_key == XEKeyIsOther) &&
+ gate_closed == True)
+ {
+ break;
+ }
+ gate_closed = True;
+ next_key = XEKeyIsClear;
+ break;
+
+ case KeyRelease:
+ if (next_key == XEKeyIsClear)
+ {
+ next_key = XEKeyIsEcho;
+ break;
+ }
+
+ if (next_key == XEKeyIsEcho)
+ {
+ next_key = XEKeyIsClear;
+ break;
+ }
+
+ gate_closed = False;
+ key_ignore = True;
+ next_key = XEKeyIsClear;
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ else
+ {
+ next_key = XEKeyIsOther;
+ }
+ }
+
+ /*
+ * If the gate to the server is open,
+ * and we are not ignoring a keyrelease,
+ * pass the event to the server for normal processing.
+ */
+#ifndef VECTORED_EVENTS
+ if ((gate_closed == False) && (key_ignore == False))
+ {
+ if (XETrapEventProcVector[type] != cur_func)
+ { /* to protect us from infinite loops */
+ (void)(*XETrapEventProcVector[type])(x_event,keybd,count);
+ }
+ else
+ {
+ (void)(*EventProcVector[type])(x_event,keybd,count);
+ }
+ }
+#else /* VECTORED_EVENTS */
+ if ((gate_closed == False) && (key_ignore == False))
+ { /* send event on to server to be trapped again in XETrapEventVector */
+ (void)(*keybd_process_inp)(x_event,keybd,count);
+ }
+ else
+ {
+ XETrapStampAndMail(x_event); /* send to XTrap client if necessry */
+ }
+#endif
+ key_ignore = False; /* reset for next time around */
+ return 0;
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine intercepts input xEvents from the pointer device
+ * and passes the input event back to the server for normal processing.
+ *
+ * This routine is sensitive to whether input is being passed
+ * up to the server or not. This state is set by the keyboard
+ * input routine.
+ *
+ *
+ */
+#ifndef VECTORED_EVENTS
+int XETrapPointer(xEvent *x_event, DevicePtr ptrdev, int count)
+{
+ XETrapEnv *penv;
+ ClientList *stc = &stats_clients;
+ int_function cur_func = XETrapPointer;
+
+#ifdef VERBOSE
+ if (count != 1L)
+ { /* We haven't coded for this situation yet! */
+ ErrorF("Warning! Event count != 1 (%d)\n", count);
+ }
+#endif
+ while (stc->next != NULL)
+ { /* increment appropriate stats bucket for each interested client */
+ stc = stc->next;
+ penv = XETenv[stc->client->index];
+ if (BitIsTrue(penv->cur.data_config_flags_event,x_event->u.u.type))
+ { /* This particular client would like this particular stat */
+ penv->stats->data.events[x_event->u.u.type]++;
+ }
+ }
+ XETrapStampAndMail(x_event); /* send to XTrap client if necessry */
+ /*
+ * If the gate to the server is open,
+ * pass the event up like nothing has happened.
+ */
+ if (gate_closed == False)
+ {
+ if (XETrapEventProcVector[x_event->u.u.type] != cur_func)
+ { /* to protect us from infinite loops */
+ (void)(*XETrapEventProcVector[x_event->u.u.type])(x_event,ptrdev,
+ count);
+ }
+ else
+ {
+ (void)(*EventProcVector[x_event->u.u.type])(x_event,ptrdev,count);
+ }
+ }
+ return 0;
+}
+#endif /* !VECTORED_EVENTS */
+
+
+/*
+ * DESCRIPTION:
+ *
+ * This routine determines whether it needs to send event data
+ * to the XTrap Client(s). If so, it timestamps it appropriately
+ * and writes out both the header and detail information.
+ *
+ */
+void XETrapStampAndMail(xEvent *x_event)
+{
+ XETrapDatum data;
+ register CARD32 size;
+ XETrapEnv *penv;
+ ClientList *ioc = &io_clients;
+
+ /* Currently, we're intercepting core events *before* most
+ * of the event information's filled in. Specifically, the
+ * only fields that are valid at this level are: type, detail,
+ * time, rootX, rootY, and state.
+ */
+ /* Loop through all clients wishing I/O */
+ while (ioc->next != NULL)
+ {
+ ioc = ioc->next;
+ penv = XETenv[ioc->client->index];
+ /* Do we have a valid fd? Do we care about this event? */
+ if (BitIsTrue(penv->cur.data_config_flags_event, x_event->u.u.type))
+ {
+ XETrapSetHeaderEvent(&(data.hdr));
+ data.hdr.win_x = data.hdr.win_y = -1L; /* Invalidate req draw */
+ data.hdr.screen = 0L; /* not till Events are vectored! */
+ data.hdr.client = 0L; /* not till Events are vectored! */
+ if (BitIsTrue(penv->cur.data_config_flags_data,
+ XETrapTimestamp))
+ {
+ data.hdr.timestamp = GetTimeInMillis();
+ }
+ size = data.hdr.count = XETrapMinPktSize; /* Always for evts */
+ penv->last_input_time = x_event->u.keyButtonPointer.time;
+ /* Copy the event information into our local memory */
+ (void)memcpy(&(data.u.event),x_event,sizeof(xEvent));
+
+#ifdef PANORAMIX
+ if (!noPanoramiXExtension &&
+ (data.u.event.u.u.type == MotionNotify ||
+ data.u.event.u.u.type == ButtonPress ||
+ data.u.event.u.u.type == ButtonRelease ||
+ data.u.event.u.u.type == KeyPress ||
+ data.u.event.u.u.type == KeyRelease)) {
+ int scr = XineramaGetCursorScreen();
+ data.u.event.u.keyButtonPointer.rootX +=
+ panoramiXdataPtr[scr].x - panoramiXdataPtr[0].x;
+ data.u.event.u.keyButtonPointer.rootY +=
+ panoramiXdataPtr[scr].y - panoramiXdataPtr[0].y;
+ }
+#endif
+
+ if (penv->client->swapped)
+ { /*
+ * Notice that we don't swap the XTRAP EVENT information.
+ * This is done in the XETrapWriteXLib() routine.
+ */
+ xEvent ToEvent;
+ (*EventSwapVector[data.u.event.u.u.type & 0177])
+ (&data.u.event,&ToEvent);
+ (void)memcpy(&(data.u.event),&ToEvent,sizeof(ToEvent));
+ sXETrapHeader(&(data.hdr)); /* swap the XTrap Header */
+ }
+ /* From this point on, the contents of data is swapped and
+ * therefore we should not refer to it for information.
+ */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, size) != size)
+ {
+ SendErrorToClient(penv->client,
+ XETrap_avail.data.major_opcode,
+ x_event->u.u.type, 0L, XETrapErrorBase + BadIO);
+ }
+ }
+ }
+ return;
+}
+#ifdef VECTORED_EVENTS
+int XETrapEventVector(ClientPtr client, xEvent *x_event)
+{
+ XETrapDatum data;
+ register CARD32 size;
+ XETrapEnv *penv;
+ ClientList *ioc = &io_clients;
+
+ /* Loop through all clients wishing I/O */
+ while (ioc->next != NULL)
+ {
+ ioc = ioc->next;
+ penv = XETenv[ioc->client->index];
+ /* Do we care about this event? */
+ if (BitIsTrue(penv->cur.data_config_flags_event, x_event->u.u.type))
+ {
+ XETrapSetHeaderEvent(&(data.hdr));
+ data.hdr.client = client->index;
+ data.hdr.win_x = data.hdr.win_y = -1L; /* Invalidate req draw */
+ if ((current_screen < 0L) || ((x_event->u.u.type >= KeyPress) &&
+ (x_event->u.u.type <= MotionNotify) &&
+ (!x_event->u.keyButtonPointer.sameScreen)))
+ { /* we've moved/warped to another screen */
+ WindowPtr root_win = GetCurrentRootWindow();
+ current_screen = root_win->drawable.pScreen->myNum;
+ }
+ data.hdr.screen = current_screen;
+ if (BitIsTrue(penv->cur.data_config_flags_data,
+ XETrapTimestamp))
+ {
+ data.hdr.timestamp = GetTimeInMillis();
+ }
+ size = data.hdr.count = XETrapMinPktSize; /* Always for evts */
+ penv->last_input_time = x_event->u.keyButtonPointer.time;
+ /* Copy the event information into our local memory */
+ (void)memcpy(&(data.u.event),x_event,sizeof(xEvent));
+
+ if (penv->client->swapped)
+ {
+ xEvent ToEvent;
+ (*EventSwapVector[data.u.event.u.u.type & 0177])
+ (&data.u.event,&ToEvent);
+ (void)memcpy(&(data.u.event),&ToEvent,sizeof(ToEvent));
+ sXETrapHeader(&(data.hdr)); /* swap the XTrap Header */
+ }
+ /* From this point on, the contents of pdata is swapped and
+ * therefore we should not refer to it for information.
+ */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, size) != size)
+ {
+ SendErrorToClient(penv->client,
+ XETrap_avail.data.major_opcode,
+ x_event->u.u.type, 0L, XETrapErrorBase + BadIO);
+ }
+ }
+ }
+ return;
+}
+#endif /* VECTORED_EVENTS */
+void sReplyXTrapDispatch(ClientPtr client, int size, char *reply)
+{
+ register XETrapRepHdr *rep = (XETrapRepHdr *)reply;
+
+ switch(rep->detail)
+ {
+ case XETrap_GetAvailable:
+ {
+ xXTrapGetAvailReply lrep;
+ (void)memcpy((char *)&lrep,reply,sizeof(lrep));
+ sReplyXETrapGetAvail(client,size,(char *)&lrep);
+ }
+ break;
+ case XETrap_GetCurrent:
+ {
+ xXTrapGetCurReply lrep;
+ (void)memcpy((char *)&lrep,reply,sizeof(lrep));
+ sReplyXETrapGetCur(client,size,(char *)&lrep);
+ }
+ break;
+ case XETrap_GetStatistics:
+ {
+ xXTrapGetStatsReply lrep;
+ (void)memcpy((char *)&lrep,reply,sizeof(lrep));
+ sReplyXETrapGetStats(client,size,(char *)&lrep);
+ }
+ break;
+ case XETrap_GetVersion:
+ {
+ xXTrapGetVersReply lrep;
+ (void)memcpy((char *)&lrep,reply,sizeof(lrep));
+ sReplyXETrapGetVers(client,size,(char *)&lrep);
+ }
+ break;
+ case XETrap_GetLastInpTime:
+ {
+ xXTrapGetLITimReply lrep;
+ (void)memcpy((char *)&lrep,reply,sizeof(lrep));
+ sReplyXETrapGetLITim(client,size,(char *)&lrep);
+ }
+ break;
+ default:
+ SendErrorToClient(client,XETrap_avail.data.major_opcode,
+ rep->detail, 0L, BadImplementation);
+ break;
+ }
+ return;
+}
+
+/*
+ * XLib communications routines
+ */
+
+/*
+ * DESCRIPTION:
+ *
+ * This function performs the transport specific functions required
+ * for writing data back to an XTrap client over XLib. The trick is
+ * packaging the data into <=32 byte packets to conform to the sizeof
+ * an X Event. nbytes must be at least equal to XETrapMinPktSize
+ *
+ */
+int XETrapWriteXLib(XETrapEnv *penv, BYTE *data, CARD32 nbytes)
+{
+ CARD32 size, total = 0L;
+ xETrapDataEvent event;
+
+ /* Initialize the detail field to show the beginning of a datum */
+ event.detail = XETrapDataStart;
+ event.idx = 0L;
+
+ /* This loop could be optimized by not calling Write until after all
+ * of the events are packaged. However, this would require memory
+ * games, and may not therefore be a win.
+ */
+ while (nbytes > 0L)
+ { /* How many bytes can we send in this packet */
+ size = (nbytes > sz_EventData) ? sz_EventData : nbytes;
+
+ /* Initialize the event */
+ event.type = XETrapData + XETrap_avail.data.event_base;
+ event.sequenceNumber = penv->client->sequence;
+
+ /* Copy the data we are sending */
+ (void)memcpy(event.data,data,size);
+ if (size < sz_EventData)
+ (void)memset(event.data+size,0L,sz_EventData-size);
+ data += size;
+ nbytes -= size;
+ total += size;
+
+ /* Set the detail field to show the continuation of datum */
+ if (total != size)
+ { /* this is not the first one */
+ event.detail = (nbytes > 0) ? XETrapDataContinued : XETrapDataLast;
+ }
+
+ /* Send this part to the client */
+ WriteEventsToClient(penv->client, 1L, (xEvent *) &event);
+ event.idx++; /* Bump the index for the next event */
+ }
+ return(total);
+}
+
+/*----------------------------*
+ * Static Functions
+ *----------------------------*/
+
+static void update_protocol(xXTrapGetReq *reqptr, ClientPtr client)
+{
+ XETrapEnv *penv = XETenv[client->index];
+ /* update protocol number */
+ switch (reqptr->protocol)
+ {
+ /* known acceptable protocols */
+ case 31:
+ case XETrapProtocol:
+ penv->protocol = reqptr->protocol;
+ break;
+ /* all else */
+ default: /* stay backwards compatible */
+ penv->protocol = 31;
+ break;
+ }
+}
+
+/* Swap 2 functions. This is a function instead of a macro to help to keep
+ * lint from complaining about mixed types. It seems to work, but I would
+ * probably classify this as a hack.
+ */
+static void _SwapProc( register int (**f1)(), register int (**f2)())
+{
+ register int (*t1)() = *f1;
+ *f1 = *f2;
+ *f2 = t1;
+
+ return;
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function swaps the byte order of fields within
+ * the XTrap Event Header. It assumes the data will be
+ * swapped by code in XETrapRequestVector().
+ *
+ */
+static void sXETrapEvent(xETrapDataEvent *from, xETrapDataEvent *to)
+{
+ to->type = from->type;
+ to->detail = from->detail;
+ cpswaps(from->sequenceNumber,to->sequenceNumber);
+ cpswapl(from->idx,to->idx);
+ /* Assumes that the data's already been swapped by XETrapRequestVector */
+ memcpy(to->data, from->data, SIZEOF(EventData));
+}
+
+/*
+ * DESCRIPTION:
+ *
+ * This function adds a node from an accelerator linked-list
+ * (either io_clients, stats_clients, or cmd_clients).
+ *
+ */
+static int add_accelerator_node(ClientPtr client, ClientList *accel)
+{
+ Bool found = False;
+ int status = Success;
+
+ while (accel->next != NULL)
+ {
+ if (accel->client == client)
+ {
+ found = True; /* Client's already known */
+ break;
+ }
+ else
+ {
+ accel = accel->next;
+ }
+ }
+ if (found == False)
+ {
+ if ((accel->next = (ClientList *)Xcalloc(sizeof(ClientList))) == NULL)
+ {
+ status = BadAlloc;
+ }
+ else
+ { /* fill in the node */
+ accel = accel->next;
+ accel->next = NULL;
+ accel->client = client;
+ }
+ }
+ return(status);
+}
+/*
+ * DESCRIPTION:
+ *
+ * This function removes a node from an accelerator linked-list
+ * (either io_clients, stats_clients, or cmd_clients).
+ *
+ */
+static void remove_accelerator_node(ClientPtr client, ClientList *accel)
+{
+ while (accel->next != NULL)
+ {
+ if (accel->next->client == client)
+ {
+ ClientList *tmp = accel->next->next;
+ Xfree(accel->next);
+ accel->next = tmp;
+ break;
+ }
+ else
+ {
+ accel = accel->next;
+ }
+ }
+
+ return;
+}
+
+#ifdef COLOR_REPLIES
+static void GetSendColorRep(ClientPtr client, xResourceReq *req)
+{ /* adapted from ProcAllocColor() in dispatch.c */
+ XETrapDatum data;
+ int retval;
+ XETrapEnv *penv = XETenv[client->index];
+ xAllocColorReply *crep = (xAllocColorReply *)&(data.u.reply);
+ xAllocColorReq *creq = (xAllocColorReq *)req;
+ ColormapPtr pmap = (ColormapPtr )LookupIDByType(creq->cmap, RT_COLORMAP);
+
+ /* Fill in the header fields */
+ data.hdr.count = XETrapMinPktSize; /* The color replies are 32 bytes */
+ XETrapSetHeaderReply(&(data.hdr));
+ /* Hack alert:
+ * We need to pass the "reply" type in the header since replies don't
+ * contain the id's themselves. However, we're not changing the
+ * protocol to support this until we decide exactly how we want to
+ * do *all* replies (e.g. not just ColorReplies). So until then, stow
+ * the reply id in the screen field which wouldn't normally be used in
+ * this context.
+ */
+ data.hdr.screen = req->reqType;
+ if (!pmap)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadColor);
+ return;
+ }
+ crep->red = creq->red;
+ crep->green = creq->green;
+ crep->blue = creq->blue;
+ crep->pixel = 0;
+ if ((retval = AllocColor(pmap, &(crep->red), &(crep->green),
+ &(crep->blue), &(crep->pixel), client->index)) != Success)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, retval);
+ return;
+ }
+ /* Swap data if necessary */
+ if (client->swapped)
+ {
+ INT32 n;
+ swaps(&(crep->red), n);
+ swaps(&(crep->green), n);
+ swaps(&(crep->blue), n);
+ swapl(&(crep->pixel), n);
+ }
+ /* Send data to client */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, XETrapMinPktSize)
+ != XETrapMinPktSize)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, XETrapErrorBase + BadIO);
+ }
+}
+
+static void GetSendNamedColorRep(ClientPtr client, xResourceReq *req)
+{ /* adapted from ProcAllocNamedColor() in dispatch.c */
+ XETrapDatum data;
+ XETrapEnv *penv = XETenv[client->index];
+ int retval;
+ xAllocNamedColorReply *nrep = (xAllocNamedColorReply *)&(data.u.reply);
+ xAllocNamedColorReq *nreq = (xAllocNamedColorReq *)req;
+ ColormapPtr pcmp = (ColormapPtr )LookupIDByType(nreq->cmap, RT_COLORMAP);
+
+ data.hdr.count = XETrapMinPktSize; /* The color replies are 32 bytes */
+ XETrapSetHeaderReply(&(data.hdr));
+ /* Hack alert:
+ * We need to pass the "reply" type in the header since replies don't
+ * contain the id's themselves. However, we're not changing the
+ * protocol to support this until we decide exactly how we want to
+ * do *all* replies (e.g. not just ColorReplies). So until then, stow
+ * the reply id in the screen field which wouldn't normally be used in
+ * this context.
+ */
+ data.hdr.screen = req->reqType;
+ if (!pcmp)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadColor);
+ return;
+ }
+ if (!OsLookupColor(pcmp->pScreen->myNum, (char *)&nreq[1],
+ nreq->nbytes, &(nrep->exactRed), &(nrep->exactGreen),
+ &(nrep->exactBlue)))
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadName);
+ return;
+ }
+ nrep->screenRed = nrep->exactRed;
+ nrep->screenGreen = nrep->exactGreen;
+ nrep->screenBlue = nrep->exactBlue;
+ nrep->pixel = 0;
+ if ((retval = AllocColor(pcmp, &(nrep->screenRed),
+ &(nrep->screenGreen), &(nrep->screenBlue), &(nrep->pixel),
+ client->index)) != Success)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, retval);
+ return;
+ }
+ /* Swap data if necessary */
+ if (client->swapped)
+ {
+ INT32 n;
+ swapl(&(nrep->pixel), n);
+ swaps(&(nrep->exactRed), n);
+ swaps(&(nrep->exactGreen), n);
+ swaps(&(nrep->exactBlue), n);
+ swaps(&(nrep->screenRed), n);
+ swaps(&(nrep->screenGreen), n);
+ swaps(&(nrep->screenBlue), n);
+ }
+
+ /* Send data to client */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, XETrapMinPktSize)
+ != XETrapMinPktSize)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, XETrapErrorBase + BadIO);
+ }
+}
+
+static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
+{ /* adapted from ProcAllocColorCells() in dispatch.c */
+ int retval;
+ int npixels, nmasks;
+ unsigned long *ppixels, *pmasks;
+ long length;
+ XETrapDatum *data;
+ XETrapEnv *penv = XETenv[client->index];
+ xAllocColorCellsReply *crep;
+ xAllocColorCellsReq *creq = (xAllocColorCellsReq *)req;
+ ColormapPtr pmap = (ColormapPtr )LookupIDByType(creq->cmap, RT_COLORMAP);
+
+ if (!pmap)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadColor);
+ return;
+ }
+ npixels = creq->colors;
+ if (!npixels)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadValue);
+ return;
+ }
+ nmasks = creq->planes;
+ length = ((long)npixels + (long)nmasks) * sizeof(Pixel);
+ data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
+ if (!data)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadAlloc);
+ return;
+ }
+ data->hdr.count = MIN(penv->cur.data_config_max_pkt_size,
+ sizeof(XETrapDatum)+length);
+ XETrapSetHeaderReply(&(data->hdr));
+ data->hdr.screen = req->reqType; /* hack! but necessary */
+ ppixels = (unsigned long *)((char *)data + sizeof(XETrapDatum));
+ pmasks = ppixels + npixels;
+ if ((retval = AllocColorCells(client->index, pmap, npixels,
+ nmasks, (Bool)creq->contiguous, ppixels, pmasks)) != Success)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, retval);
+ DEALLOCATE_LOCAL(data);
+ return;
+ }
+ crep = (xAllocColorCellsReply *)&(data->u.reply);
+ crep->nPixels = npixels;
+ crep->nMasks = nmasks;
+ /* Swap data if necessary */
+ if (client->swapped)
+ {
+ INT32 n, i, *ptr;
+ ptr=(INT32 *)ppixels;
+ swaps(&(crep->nPixels), n);
+ swaps(&(crep->nMasks), n);
+ for (i=0; i<length; i++)
+ {
+ swapl(&(ptr[i]), n);
+ }
+ }
+ /* Send data to client */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, data->hdr.count)
+ != data->hdr.count)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, XETrapErrorBase + BadIO);
+ }
+ DEALLOCATE_LOCAL(data);
+}
+static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
+{ /* adapted from ProcAllocColorPlanes() in dispatch.c */
+ int retval;
+ int npixels, nmasks;
+ unsigned long *ppixels, *pmasks;
+ long length;
+ XETrapDatum *data;
+ XETrapEnv *penv = XETenv[client->index];
+ xAllocColorPlanesReply *crep;
+ xAllocColorPlanesReq *creq = (xAllocColorPlanesReq *)req;
+ ColormapPtr pmap = (ColormapPtr )LookupIDByType(creq->cmap, RT_COLORMAP);
+
+ if (!pmap)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadColor);
+ return;
+ }
+ npixels = creq->colors;
+ if (!npixels)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadValue);
+ return;
+ }
+ length = (long)npixels * sizeof(Pixel);
+ data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
+ if (!data)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, BadAlloc);
+ return;
+ }
+ data->hdr.count = MIN(penv->cur.data_config_max_pkt_size,
+ sizeof(XETrapDatum)+length);
+ XETrapSetHeaderReply(&(data->hdr));
+ data->hdr.screen = req->reqType; /* hack! but necessary */
+ ppixels = (unsigned long *)((char *)data + sizeof(XETrapDatum));
+ crep = (xAllocColorPlanesReply *)&(data->u.reply);
+ if ((retval = AllocColorPlanes(client->index, pmap, npixels,
+ (int)creq->red, (int)creq->green, (int)creq->blue,
+ (int)creq->contiguous, ppixels, &(crep->redMask), &(crep->greenMask),
+ &(crep->blueMask))) != Success)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, retval);
+ DEALLOCATE_LOCAL(data);
+ return;
+ }
+ crep->nPixels = npixels;
+ /* Swap data if necessary */
+ if (client->swapped)
+ {
+ INT32 n, i, *ptr;
+ ptr=(INT32 *)ppixels;
+ swaps(&(crep->nPixels), n);
+ swapl(&(crep->redMask), n);
+ swapl(&(crep->greenMask), n);
+ swapl(&(crep->blueMask), n);
+ for (i=0; i<length; i++)
+ {
+ swapl(&(ptr[i]), n);
+ }
+ }
+ /* Send data to client */
+ if (XETrapWriteXLib(penv, (BYTE *)&data, data->hdr.count)
+ != data->hdr.count)
+ {
+ SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
+ req->reqType, 0L, XETrapErrorBase + BadIO);
+ }
+ DEALLOCATE_LOCAL(data);
+}
+#endif /* COLOR_REPLIES */