Checked in the following released items:

xkeyboard-config-1.4.tar.gz
ttf-bitstream-vera-1.10.tar.gz
font-alias-1.0.1.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sun-misc-1.0.0.tar.gz
font-sony-misc-1.0.0.tar.gz
font-schumacher-misc-1.0.0.tar.gz
font-mutt-misc-1.0.0.tar.gz
font-misc-misc-1.0.0.tar.gz
font-misc-meltho-1.0.0.tar.gz
font-micro-misc-1.0.0.tar.gz
font-jis-misc-1.0.0.tar.gz
font-isas-misc-1.0.0.tar.gz
font-dec-misc-1.0.0.tar.gz
font-daewoo-misc-1.0.0.tar.gz
font-cursor-misc-1.0.0.tar.gz
font-arabic-misc-1.0.0.tar.gz
font-winitzki-cyrillic-1.0.0.tar.gz
font-misc-cyrillic-1.0.0.tar.gz
font-cronyx-cyrillic-1.0.0.tar.gz
font-screen-cyrillic-1.0.1.tar.gz
font-xfree86-type1-1.0.1.tar.gz
font-adobe-utopia-type1-1.0.1.tar.gz
font-ibm-type1-1.0.0.tar.gz
font-bitstream-type1-1.0.0.tar.gz
font-bitstream-speedo-1.0.0.tar.gz
font-bh-ttf-1.0.0.tar.gz
font-bh-type1-1.0.0.tar.gz
font-bitstream-100dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz
font-bh-100dpi-1.0.0.tar.gz
font-adobe-utopia-100dpi-1.0.1.tar.gz
font-adobe-100dpi-1.0.0.tar.gz
font-util-1.0.1.tar.gz
font-bitstream-75dpi-1.0.0.tar.gz
font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz
font-adobe-utopia-75dpi-1.0.1.tar.gz
font-bh-75dpi-1.0.0.tar.gz
bdftopcf-1.0.1.tar.gz
font-adobe-75dpi-1.0.0.tar.gz
mkfontscale-1.0.6.tar.gz
openssl-0.9.8k.tar.gz
bigreqsproto-1.0.2.tar.gz
xtrans-1.2.2.tar.gz
resourceproto-1.0.2.tar.gz
inputproto-1.4.4.tar.gz
compositeproto-0.4.tar.gz
damageproto-1.1.0.tar.gz
zlib-1.2.3.tar.gz
xkbcomp-1.0.5.tar.gz
freetype-2.3.9.tar.gz
pthreads-w32-2-8-0-release.tar.gz
pixman-0.12.0.tar.gz
kbproto-1.0.3.tar.gz
evieext-1.0.2.tar.gz
fixesproto-4.0.tar.gz
recordproto-1.13.2.tar.gz
randrproto-1.2.2.tar.gz
scrnsaverproto-1.1.0.tar.gz
renderproto-0.9.3.tar.gz
xcmiscproto-1.1.2.tar.gz
fontsproto-2.0.2.tar.gz
xextproto-7.0.3.tar.gz
xproto-7.0.14.tar.gz
libXdmcp-1.0.2.tar.gz
libxkbfile-1.0.5.tar.gz
libfontenc-1.0.4.tar.gz
libXfont-1.3.4.tar.gz
libX11-1.1.5.tar.gz
libXau-1.0.4.tar.gz
libxcb-1.1.tar.gz
xorg-server-1.5.3.tar.gz

1 files changed, 1100 insertions, 0 deletions

diff --git a/xorg-server/dix/swapreq.c b/xorg-server/dix/swapreq.c
new file mode 100644
index 000000000..ad60d17da
--- /dev/null
+++ b/xorg-server/dix/swapreq.c
@@ -0,0 +1,1100 @@
+/************************************************************
+
+Copyright 1987, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from The Open Group.
+
+
+Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
+
+                        All Rights Reserved
+
+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 DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL 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.
+
+********************************************************/
+
+
+#ifdef HAVE_DIX_CONFIG_H
+#include <dix-config.h>
+#endif
+
+#include <X11/X.h>
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#include <X11/Xprotostr.h>
+#include "misc.h"
+#include "dixstruct.h"
+#include "extnsionst.h"	/* for SendEvent */
+#include "swapreq.h"
+
+/* Thanks to Jack Palevich for testing and subsequently rewriting all this */
+
+/* Byte swap a list of longs */
+_X_EXPORT void
+SwapLongs (CARD32 *list, unsigned long count)
+{
+	char n;
+
+	while (count >= 8) {
+	    swapl(list+0, n);
+	    swapl(list+1, n);
+	    swapl(list+2, n);
+	    swapl(list+3, n);
+	    swapl(list+4, n);
+	    swapl(list+5, n);
+	    swapl(list+6, n);
+	    swapl(list+7, n);
+	    list += 8;
+	    count -= 8;
+	}
+	if (count != 0) {
+	    do {
+		swapl(list, n);
+		list++;
+	    } while (--count != 0);
+	}
+}
+
+/* Byte swap a list of shorts */
+_X_EXPORT void
+SwapShorts (short *list, unsigned long count)
+{
+	char n;
+
+	while (count >= 16) {
+	    swaps(list+0, n);
+	    swaps(list+1, n);
+	    swaps(list+2, n);
+	    swaps(list+3, n);
+	    swaps(list+4, n);
+	    swaps(list+5, n);
+	    swaps(list+6, n);
+	    swaps(list+7, n);
+	    swaps(list+8, n);
+	    swaps(list+9, n);
+	    swaps(list+10, n);
+	    swaps(list+11, n);
+	    swaps(list+12, n);
+	    swaps(list+13, n);
+	    swaps(list+14, n);
+	    swaps(list+15, n);
+	    list += 16;
+	    count -= 16;
+	}
+	if (count != 0) {
+	    do {
+		swaps(list, n);
+		list++;
+	    } while (--count != 0);
+	}
+}
+
+/* The following is used for all requests that have
+   no fields to be swapped (except "length") */
+int
+SProcSimpleReq(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xReq);
+    swaps(&stuff->length, n);
+    return(*ProcVector[stuff->reqType])(client);
+}
+
+/* The following is used for all requests that have
+   only a single 32-bit field to be swapped, coming
+   right after the "length" field */
+int
+SProcResourceReq(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xResourceReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xResourceReq); /* not EXACT */
+    swapl(&stuff->id, n);
+    return(*ProcVector[stuff->reqType])(client);
+}
+
+int
+SProcCreateWindow(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xCreateWindowReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
+    swapl(&stuff->wid, n);
+    swapl(&stuff->parent, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    swaps(&stuff->borderWidth, n);
+    swaps(&stuff->class, n);
+    swapl(&stuff->visual, n);
+    swapl(&stuff->mask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_CreateWindow])(client));
+}
+
+int
+SProcChangeWindowAttributes(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xChangeWindowAttributesReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->valueMask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_ChangeWindowAttributes])(client));
+}
+
+int
+SProcReparentWindow(ClientPtr client)
+{
+    char n;
+    REQUEST(xReparentWindowReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xReparentWindowReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->parent, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    return((* ProcVector[X_ReparentWindow])(client));
+}
+
+int
+SProcConfigureWindow(ClientPtr client)
+{
+    char n;
+    REQUEST(xConfigureWindowReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
+    swapl(&stuff->window, n);
+    swaps(&stuff->mask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_ConfigureWindow])(client));
+
+}
+
+
+int
+SProcInternAtom(ClientPtr client)
+{
+    char n;
+    REQUEST(xInternAtomReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xInternAtomReq);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_InternAtom])(client));
+}
+
+int
+SProcChangeProperty(ClientPtr client)
+{
+    char n;
+    REQUEST(xChangePropertyReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->property, n);
+    swapl(&stuff->type, n);
+    swapl(&stuff->nUnits, n);
+    switch ( stuff->format ) {
+        case 8 :
+	    break;
+        case 16:
+	    SwapRestS(stuff);
+	    break;
+	case 32:
+	    SwapRestL(stuff);
+	    break;
+	}
+    return((* ProcVector[X_ChangeProperty])(client));
+}
+
+int 
+SProcDeleteProperty(ClientPtr client)
+{
+    char n;
+    REQUEST(xDeletePropertyReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xDeletePropertyReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->property, n);
+    return((* ProcVector[X_DeleteProperty])(client));
+              
+}
+
+int 
+SProcGetProperty(ClientPtr client)
+{
+    char n;
+    REQUEST(xGetPropertyReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetPropertyReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->property, n);
+    swapl(&stuff->type, n);
+    swapl(&stuff->longOffset, n);
+    swapl(&stuff->longLength, n);
+    return((* ProcVector[X_GetProperty])(client));
+}
+
+int
+SProcSetSelectionOwner(ClientPtr client)
+{
+    char n;
+    REQUEST(xSetSelectionOwnerReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->selection, n);
+    swapl(&stuff->time, n);
+    return((* ProcVector[X_SetSelectionOwner])(client));
+}
+
+int
+SProcConvertSelection(ClientPtr client)
+{
+    char n;
+    REQUEST(xConvertSelectionReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xConvertSelectionReq);
+    swapl(&stuff->requestor, n);
+    swapl(&stuff->selection, n);
+    swapl(&stuff->target, n);
+    swapl(&stuff->property, n);
+    swapl(&stuff->time, n);
+    return((* ProcVector[X_ConvertSelection])(client));
+}
+
+int
+SProcSendEvent(ClientPtr client)
+{
+    char n;
+    xEvent eventT;
+    EventSwapPtr proc;
+    REQUEST(xSendEventReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xSendEventReq);
+    swapl(&stuff->destination, n);
+    swapl(&stuff->eventMask, n);
+
+    /* Swap event */
+    proc = EventSwapVector[stuff->event.u.u.type & 0177];
+    if (!proc ||  proc == NotImplemented)    /* no swapping proc; invalid event type? */
+       return (BadValue);
+    (*proc)(&stuff->event, &eventT);
+    stuff->event = eventT;
+
+    return((* ProcVector[X_SendEvent])(client));
+}
+
+int
+SProcGrabPointer(ClientPtr client)
+{
+    char n;
+    REQUEST(xGrabPointerReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGrabPointerReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->eventMask, n);
+    swapl(&stuff->confineTo, n);
+    swapl(&stuff->cursor, n);
+    swapl(&stuff->time, n);
+    return((* ProcVector[X_GrabPointer])(client));
+}
+
+int
+SProcGrabButton(ClientPtr client)
+{
+    char n;
+    REQUEST(xGrabButtonReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGrabButtonReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->eventMask, n);
+    swapl(&stuff->confineTo, n);
+    swapl(&stuff->cursor, n);
+    swaps(&stuff->modifiers, n);
+    return((* ProcVector[X_GrabButton])(client));
+}
+
+int
+SProcUngrabButton(ClientPtr client)
+{
+    char n;
+    REQUEST(xUngrabButtonReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xUngrabButtonReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    return((* ProcVector[X_UngrabButton])(client));
+}
+
+int
+SProcChangeActivePointerGrab(ClientPtr client)
+{
+    char n;
+    REQUEST(xChangeActivePointerGrabReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);
+    swapl(&stuff->cursor, n);
+    swapl(&stuff->time, n);
+    swaps(&stuff->eventMask, n);
+    return((* ProcVector[X_ChangeActivePointerGrab])(client));
+}
+
+int
+SProcGrabKeyboard(ClientPtr client)
+{
+    char n;
+    REQUEST(xGrabKeyboardReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGrabKeyboardReq);
+    swapl(&stuff->grabWindow, n);
+    swapl(&stuff->time, n);
+    return((* ProcVector[X_GrabKeyboard])(client));
+}
+
+int
+SProcGrabKey(ClientPtr client)
+{
+    char n;
+    REQUEST(xGrabKeyReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGrabKeyReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    return((* ProcVector[X_GrabKey])(client));
+}
+
+int
+SProcUngrabKey(ClientPtr client)
+{
+    char n;
+    REQUEST(xUngrabKeyReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xUngrabKeyReq);
+    swapl(&stuff->grabWindow, n);
+    swaps(&stuff->modifiers, n);
+    return((* ProcVector[X_UngrabKey])(client));
+}
+
+int
+SProcGetMotionEvents(ClientPtr client)
+{
+    char n;
+    REQUEST(xGetMotionEventsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetMotionEventsReq);
+    swapl(&stuff->window, n);
+    swapl(&stuff->start, n);
+    swapl(&stuff->stop, n);
+    return((* ProcVector[X_GetMotionEvents])(client));
+}
+
+int
+SProcTranslateCoords(ClientPtr client)
+{
+    char n;
+    REQUEST(xTranslateCoordsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xTranslateCoordsReq);
+    swapl(&stuff->srcWid, n);
+    swapl(&stuff->dstWid, n);
+    swaps(&stuff->srcX, n);
+    swaps(&stuff->srcY, n);
+    return((* ProcVector[X_TranslateCoords])(client));
+}
+
+int
+SProcWarpPointer(ClientPtr client)
+{
+    char n;
+    REQUEST(xWarpPointerReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xWarpPointerReq);
+    swapl(&stuff->srcWid, n);
+    swapl(&stuff->dstWid, n);
+    swaps(&stuff->srcX, n);
+    swaps(&stuff->srcY, n);
+    swaps(&stuff->srcWidth, n);
+    swaps(&stuff->srcHeight, n);
+    swaps(&stuff->dstX, n);
+    swaps(&stuff->dstY, n);
+    return((* ProcVector[X_WarpPointer])(client));
+}
+
+int
+SProcSetInputFocus(ClientPtr client)
+{
+    char n;
+    REQUEST(xSetInputFocusReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xSetInputFocusReq);
+    swapl(&stuff->focus, n);
+    swapl(&stuff->time, n);
+    return((* ProcVector[X_SetInputFocus])(client));
+}
+
+int
+SProcOpenFont(ClientPtr client)
+{
+    char n;
+    REQUEST(xOpenFontReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xOpenFontReq);
+    swapl(&stuff->fid, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_OpenFont])(client));
+}
+
+int
+SProcListFonts(ClientPtr client)
+{
+    char n;
+    REQUEST(xListFontsReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xListFontsReq);
+    swaps(&stuff->maxNames, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_ListFonts])(client));
+}
+
+int
+SProcListFontsWithInfo(ClientPtr client)
+{
+    char n;
+    REQUEST(xListFontsWithInfoReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);
+    swaps(&stuff->maxNames, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_ListFontsWithInfo])(client));
+}
+
+int
+SProcSetFontPath(ClientPtr client)
+{
+    char n;
+    REQUEST(xSetFontPathReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
+    swaps(&stuff->nFonts, n);
+    return((* ProcVector[X_SetFontPath])(client));
+}
+
+int
+SProcCreatePixmap(ClientPtr client)
+{
+    char n;
+    REQUEST(xCreatePixmapReq);
+
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCreatePixmapReq);
+    swapl(&stuff->pid, n);
+    swapl(&stuff->drawable, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    return((* ProcVector[X_CreatePixmap])(client));
+}
+
+int
+SProcCreateGC(ClientPtr client)
+{
+    char n;
+    REQUEST(xCreateGCReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xCreateGCReq);
+    swapl(&stuff->gc, n);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->mask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_CreateGC])(client));
+}
+
+int
+SProcChangeGC(ClientPtr client)
+{
+    char n;
+    REQUEST(xChangeGCReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeGCReq);
+    swapl(&stuff->gc, n);
+    swapl(&stuff->mask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_ChangeGC])(client));
+}
+
+int
+SProcCopyGC(ClientPtr client)
+{
+    char n;
+    REQUEST(xCopyGCReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCopyGCReq);
+    swapl(&stuff->srcGC, n);
+    swapl(&stuff->dstGC, n);
+    swapl(&stuff->mask, n);
+    return((* ProcVector[X_CopyGC])(client));
+}
+
+int
+SProcSetDashes(ClientPtr client)
+{
+    char n;
+    REQUEST(xSetDashesReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xSetDashesReq);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->dashOffset, n);
+    swaps(&stuff->nDashes, n);
+    return((* ProcVector[X_SetDashes])(client));
+
+}
+
+int
+SProcSetClipRectangles(ClientPtr client)
+{
+    char n;
+    REQUEST(xSetClipRectanglesReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->xOrigin, n);
+    swaps(&stuff->yOrigin, n);
+    SwapRestS(stuff);
+    return((* ProcVector[X_SetClipRectangles])(client));
+}
+
+int
+SProcClearToBackground(ClientPtr client)
+{
+    char n;
+    REQUEST(xClearAreaReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xClearAreaReq);
+    swapl(&stuff->window, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    return((* ProcVector[X_ClearArea])(client));
+}
+
+int
+SProcCopyArea(ClientPtr client)
+{
+    char n;
+    REQUEST(xCopyAreaReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCopyAreaReq);
+    swapl(&stuff->srcDrawable, n);
+    swapl(&stuff->dstDrawable, n);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->srcX, n);
+    swaps(&stuff->srcY, n);
+    swaps(&stuff->dstX, n);
+    swaps(&stuff->dstY, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    return((* ProcVector[X_CopyArea])(client));
+}
+
+int
+SProcCopyPlane(ClientPtr client)
+{
+    char n;
+    REQUEST(xCopyPlaneReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCopyPlaneReq);
+    swapl(&stuff->srcDrawable, n);
+    swapl(&stuff->dstDrawable, n);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->srcX, n);
+    swaps(&stuff->srcY, n);
+    swaps(&stuff->dstX, n);
+    swaps(&stuff->dstY, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    swapl(&stuff->bitPlane, n);
+    return((* ProcVector[X_CopyPlane])(client));
+}
+
+/* The following routine is used for all Poly drawing requests
+   (except FillPoly, which uses a different request format) */
+int
+SProcPoly(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xPolyPointReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xPolyPointReq);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->gc, n);
+    SwapRestS(stuff);
+    return((* ProcVector[stuff->reqType])(client));
+}
+
+/* cannot use SProcPoly for this one, because xFillPolyReq
+   is longer than xPolyPointReq, and we don't want to swap
+   the difference as shorts! */
+int
+SProcFillPoly(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xFillPolyReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xFillPolyReq);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->gc, n);
+    SwapRestS(stuff);
+    return((* ProcVector[X_FillPoly])(client));
+}
+
+int
+SProcPutImage(ClientPtr client)
+{
+    char n;
+    REQUEST(xPutImageReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xPutImageReq);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    swaps(&stuff->dstX, n);
+    swaps(&stuff->dstY, n);
+    /* Image should already be swapped */
+    return((* ProcVector[X_PutImage])(client));
+
+}
+
+int
+SProcGetImage(ClientPtr client)
+{
+    char n;
+    REQUEST(xGetImageReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xGetImageReq);
+    swapl(&stuff->drawable, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    swapl(&stuff->planeMask, n);
+    return((* ProcVector[X_GetImage])(client));
+}
+
+/* ProcPolyText used for both PolyText8 and PolyText16 */
+
+int
+SProcPolyText(ClientPtr client)
+{
+    char n;
+    REQUEST(xPolyTextReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xPolyTextReq);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    return((* ProcVector[stuff->reqType])(client));
+}
+
+/* ProcImageText used for both ImageText8 and ImageText16 */
+
+int
+SProcImageText(ClientPtr client)
+{
+    char n;
+    REQUEST(xImageTextReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xImageTextReq);
+    swapl(&stuff->drawable, n);
+    swapl(&stuff->gc, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    return((* ProcVector[stuff->reqType])(client));
+}
+
+int
+SProcCreateColormap(ClientPtr client)
+{
+    char n;
+    REQUEST(xCreateColormapReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCreateColormapReq);
+    swapl(&stuff->mid, n);
+    swapl(&stuff->window, n);
+    swapl(&stuff->visual, n);
+    return((* ProcVector[X_CreateColormap])(client));
+}
+
+
+int
+SProcCopyColormapAndFree(ClientPtr client)
+{
+    char n;
+    REQUEST(xCopyColormapAndFreeReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
+    swapl(&stuff->mid, n);
+    swapl(&stuff->srcCmap, n);
+    return((* ProcVector[X_CopyColormapAndFree])(client));
+
+}
+
+int
+SProcAllocColor(ClientPtr client)
+{
+    char n;
+    REQUEST(xAllocColorReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xAllocColorReq);
+    swapl(&stuff->cmap, n);
+    swaps(&stuff->red, n);
+    swaps(&stuff->green, n);
+    swaps(&stuff->blue, n);
+    return((* ProcVector[X_AllocColor])(client));
+}
+
+int
+SProcAllocNamedColor(ClientPtr client)
+{
+    char n;
+
+    REQUEST(xAllocNamedColorReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xAllocNamedColorReq);
+    swapl(&stuff->cmap, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_AllocNamedColor])(client));
+}
+
+int
+SProcAllocColorCells(ClientPtr client)
+{
+    char n;
+    REQUEST(xAllocColorCellsReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xAllocColorCellsReq);
+    swapl(&stuff->cmap, n);
+    swaps(&stuff->colors, n);
+    swaps(&stuff->planes, n);
+    return((* ProcVector[X_AllocColorCells])(client));
+}
+
+int
+SProcAllocColorPlanes(ClientPtr client)
+{
+    char n;
+    REQUEST(xAllocColorPlanesReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
+    swapl(&stuff->cmap, n);
+    swaps(&stuff->colors, n);
+    swaps(&stuff->red, n);
+    swaps(&stuff->green, n);
+    swaps(&stuff->blue, n);
+    return((* ProcVector[X_AllocColorPlanes])(client));
+}
+
+int
+SProcFreeColors(ClientPtr client)
+{
+    char n;
+    REQUEST(xFreeColorsReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
+    swapl(&stuff->cmap, n);
+    swapl(&stuff->planeMask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_FreeColors])(client));
+
+}
+
+_X_EXPORT void
+SwapColorItem(xColorItem *pItem)
+{
+    char n;
+
+    swapl(&pItem->pixel, n);
+    swaps(&pItem->red, n);
+    swaps(&pItem->green, n);
+    swaps(&pItem->blue, n);
+}
+
+int
+SProcStoreColors(ClientPtr client)
+{
+    char n;
+    long count;
+    xColorItem 	*pItem;
+
+    REQUEST(xStoreColorsReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xStoreColorsReq);
+    swapl(&stuff->cmap, n);
+    pItem = (xColorItem *) &stuff[1];
+    for(count = LengthRestB(stuff)/sizeof(xColorItem); --count >= 0; )
+	SwapColorItem(pItem++);
+    return((* ProcVector[X_StoreColors])(client));
+}
+
+int
+SProcStoreNamedColor (ClientPtr client)
+{
+    char n;
+    REQUEST(xStoreNamedColorReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);
+    swapl(&stuff->cmap, n);
+    swapl(&stuff->pixel, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_StoreNamedColor])(client));
+}
+
+int
+SProcQueryColors (ClientPtr client)
+{
+    char n;
+    REQUEST(xQueryColorsReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
+    swapl(&stuff->cmap, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_QueryColors])(client));
+} 
+
+int
+SProcLookupColor (ClientPtr client)
+{
+    char n;
+    REQUEST(xLookupColorReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xLookupColorReq);
+    swapl(&stuff->cmap, n);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_LookupColor])(client));
+}
+
+int
+SProcCreateCursor (ClientPtr client)
+{
+    char n;
+    REQUEST(xCreateCursorReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCreateCursorReq);
+    swapl(&stuff->cid, n);
+    swapl(&stuff->source, n);
+    swapl(&stuff->mask, n);
+    swaps(&stuff->foreRed, n);
+    swaps(&stuff->foreGreen, n);
+    swaps(&stuff->foreBlue, n);
+    swaps(&stuff->backRed, n);
+    swaps(&stuff->backGreen, n);
+    swaps(&stuff->backBlue, n);
+    swaps(&stuff->x, n);
+    swaps(&stuff->y, n);
+    return((* ProcVector[X_CreateCursor])(client));
+}
+
+int
+SProcCreateGlyphCursor (ClientPtr client)
+{
+    char n;
+    REQUEST(xCreateGlyphCursorReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
+    swapl(&stuff->cid, n);
+    swapl(&stuff->source, n);
+    swapl(&stuff->mask, n);
+    swaps(&stuff->sourceChar, n);
+    swaps(&stuff->maskChar, n);
+    swaps(&stuff->foreRed, n);
+    swaps(&stuff->foreGreen, n);
+    swaps(&stuff->foreBlue, n);
+    swaps(&stuff->backRed, n);
+    swaps(&stuff->backGreen, n);
+    swaps(&stuff->backBlue, n);
+    return((* ProcVector[X_CreateGlyphCursor])(client));
+}
+
+
+int
+SProcRecolorCursor (ClientPtr client)
+{
+    char n;
+    REQUEST(xRecolorCursorReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xRecolorCursorReq);
+    swapl(&stuff->cursor, n);
+    swaps(&stuff->foreRed, n);
+    swaps(&stuff->foreGreen, n);
+    swaps(&stuff->foreBlue, n);
+    swaps(&stuff->backRed, n);
+    swaps(&stuff->backGreen, n);
+    swaps(&stuff->backBlue, n);
+    return((* ProcVector[X_RecolorCursor])(client));
+}
+
+int
+SProcQueryBestSize (ClientPtr client)
+{
+    char n;
+    REQUEST(xQueryBestSizeReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xQueryBestSizeReq);
+    swapl(&stuff->drawable, n);
+    swaps(&stuff->width, n);
+    swaps(&stuff->height, n);
+    return((* ProcVector[X_QueryBestSize])(client));
+
+}
+
+int
+SProcQueryExtension (ClientPtr client)
+{
+    char n;
+    REQUEST(xQueryExtensionReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
+    swaps(&stuff->nbytes, n);
+    return((* ProcVector[X_QueryExtension])(client));
+}
+
+int
+SProcChangeKeyboardMapping (ClientPtr client)
+{
+    char n;
+    REQUEST(xChangeKeyboardMappingReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
+    SwapRestL(stuff);
+    return((* ProcVector[X_ChangeKeyboardMapping])(client));
+}
+
+
+int
+SProcChangeKeyboardControl (ClientPtr client)
+{
+    char n;
+    REQUEST(xChangeKeyboardControlReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
+    swapl(&stuff->mask, n);
+    SwapRestL(stuff);
+    return((* ProcVector[X_ChangeKeyboardControl])(client));
+}
+
+int
+SProcChangePointerControl (ClientPtr client)
+{
+    char n;
+    REQUEST(xChangePointerControlReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xChangePointerControlReq);
+    swaps(&stuff->accelNum, n);
+    swaps(&stuff->accelDenum, n);
+    swaps(&stuff->threshold, n);
+    return((* ProcVector[X_ChangePointerControl])(client));
+}
+
+
+int
+SProcSetScreenSaver (ClientPtr client)
+{
+    char n;
+    REQUEST(xSetScreenSaverReq);
+    swaps(&stuff->length, n);
+    REQUEST_SIZE_MATCH(xSetScreenSaverReq);
+    swaps(&stuff->timeout, n);
+    swaps(&stuff->interval, n);
+    return((* ProcVector[X_SetScreenSaver])(client));
+}
+
+int
+SProcChangeHosts (ClientPtr client)
+{
+    char n;
+
+    REQUEST(xChangeHostsReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xChangeHostsReq);
+    swaps(&stuff->hostLength, n);
+    return((* ProcVector[X_ChangeHosts])(client));
+
+}
+
+int SProcRotateProperties (ClientPtr client)
+{
+    char n;
+    REQUEST(xRotatePropertiesReq);
+    swaps(&stuff->length, n);
+    REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);
+    swapl(&stuff->window, n);
+    swaps(&stuff->nAtoms, n);
+    swaps(&stuff->nPositions, n);
+    SwapRestL(stuff);
+    return ((* ProcVector[X_RotateProperties])(client));
+}
+
+int
+SProcNoOperation(ClientPtr client)
+{
+    char n;
+    REQUEST(xReq);
+    swaps(&stuff->length, n);
+    return ((* ProcVector[X_NoOperation])(client));
+}
+
+void
+SwapConnClientPrefix(xConnClientPrefix *pCCP)
+{
+    char n;
+
+    swaps(&pCCP->majorVersion, n);
+    swaps(&pCCP->minorVersion, n);
+    swaps(&pCCP->nbytesAuthProto, n);
+    swaps(&pCCP->nbytesAuthString, n);
+}