Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

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 */