svn merge ^/branches/released .

1 files changed, 1099 insertions, 1099 deletions

diff --git a/xorg-server/dix/swapreq.c b/xorg-server/dix/swapreq.c
index 5d7d71c8f..4fbb6ebda 100644
--- a/xorg-server/dix/swapreq.c
+++ b/xorg-server/dix/swapreq.c
@@ -1,1099 +1,1099 @@
-/************************************************************
-
-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>
-#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 */
-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 */
-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));
-
-}
-
-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);
-}
+/************************************************************

+

+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>

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

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

+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));

+

+}

+

+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);

+}