/************************************************************
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, 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 names of Digital or MIT 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.

********************************************************/

/* $Header: swapreq.c,v 1.18 87/06/11 23:10:16 sue Exp $ */

#include "X.h"
#define NEED_REPLIES
#define NEED_EVENTS
#include "Xproto.h"
#include "Xprotostr.h"
#include "windowstr.h"
#include "font.h"
#include "gc.h"
#include "os.h"
#include "resource.h"
#include "selection.h"
#include "colormap.h"
#include "dixstruct.h"
#include "extension.h"
#include "input.h"
#include "cursor.h"

extern WindowRec WindowTable[];
extern xConnSetupPrefix connSetupPrefix;
extern char *ConnectionInfo;
extern char *SwappedConnInfo;
extern int (* ProcVector[256]) ();

/* Thanks to Jack Palevich for testing and subsequently rewriting all this */

#define LengthRestB(stuff) \
    ((stuff->length << 2) - sizeof(*stuff))

#define LengthRestS(stuff) \
    ((stuff->length << 1)  - (sizeof(*stuff) >> 1))

#define LengthRestL(stuff) \
    (stuff->length  - (sizeof(*stuff) >> 2))

#define SwapRestS(stuff) \
    SwapShorts((short *)(stuff + 1), (int)LengthRestS(stuff))

#define SwapRestL(stuff) \
    SwapLongs((long *)(stuff + 1), (int)LengthRestL(stuff))


int
SProcCopyPlane(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xCopyPlaneReq);
    swaps(&stuff->length, n);
    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));
}

int
SProcPolyPoint(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolyPointReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolyPoint])(client));
}

int
SProcPolyLine(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolyLineReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolyLine])(client));
}

int
SProcPolySegment(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolySegmentReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolySegment])(client));
}

int
SProcPolyRectangle (client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolyRectangleReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolyRectangle])(client));
}

int
SProcPolyArc(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xPolyArcReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolyArc])(client));
}

int
SProcFillPoly(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xFillPolyReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_FillPoly])(client));

}

int
SProcPolyFillRectangle(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolyFillRectangleReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolyFillRectangle])(client));
}

int
SProcPolyFillArc               (client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xPolyFillArcReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    SwapRestS(stuff);
    return((* ProcVector[X_PolySegment])(client));
}

int
SProcPutImage(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xPutImageReq);
    swaps(&stuff->length, n);
    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(client)
    register ClientPtr	client;
{
    register int n;
    REQUEST(xGetImageReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swaps(&stuff->x, n);
    swaps(&stuff->y, n);
    swaps(&stuff->width, n);
    swaps(&stuff->height, n);
    return((* ProcVector[X_GetImage])(client));
}

int
SProcPolyText(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xPolyTextReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    swaps(&stuff->x, n);
    swaps(&stuff->y, n);
    /* We don't swap the TextElt list here because it's simpler to do it as
     * a special case in ProcPolyText.
     */
    return((* ProcVector[X_PolyText8])(client));
}

int
SProcImageText(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xImageTextReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swapl(&stuff->gc, n);
    swaps(&stuff->x, n);
    swaps(&stuff->y, n);
    /* Check if we're ImageText8 or ImageText16 */
    switch(stuff->reqType)
    {
	case X_ImageText8:
            return((* ProcVector[X_ImageText8])(client));
	case X_ImageText16:
	    SwapRestS(stuff);
            return((* ProcVector[X_ImageText16])(client));
    }
    return BadValue;
}

int
SProcCreateColormap(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xCreateColormapReq);
    swaps(&stuff->length, n);
    swapl(&stuff->mid, n);
    swapl(&stuff->window, n);
    swapl(&stuff->visual, n);
    return((* ProcVector[X_CreateColormap])(client));
}

int
SProcFreeColormap(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_FreeColormap])(client));
}


int
SProcCopyColormapAndFree(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xCopyColormapAndFreeReq);
    swaps(&stuff->length, n);
    swapl(&stuff->mid, n);
    swapl(&stuff->srcCmap, n);
    return((* ProcVector[X_CopyColormapAndFree])(client));

}

int
SProcInstallColormap(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_InstallColormap])(client));

}

int
SProcUninstallColormap(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_UninstallColormap])(client));
}

int
SProcListInstalledColormaps(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_ListInstalledColormaps])(client));
}

int
SProcAllocColor                (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xAllocColorReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swaps(&stuff->red, n);
    swaps(&stuff->green, n);
    swaps(&stuff->blue, n);
    return((* ProcVector[X_AllocColor])(client));
}

int
SProcAllocNamedColor           (client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xAllocNamedColorReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swaps(&stuff->nbytes, n);
    return((* ProcVector[X_AllocNamedColor])(client));
}

int
SProcAllocColorCells           (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xAllocColorCellsReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swaps(&stuff->colors, n);
    swaps(&stuff->planes, n);
    return((* ProcVector[X_AllocColorCells])(client));
}

int
SProcAllocColorPlanes(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xAllocColorPlanesReq);
    swaps(&stuff->length, n);
    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          (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xFreeColorsReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swapl(&stuff->planeMask, n);
    SwapRestL(stuff);
    return((* ProcVector[X_FreeColors])(client));

}

int
SProcStoreColors               (client)
    register ClientPtr client;
{
    register int n;
    xColorItem 	*pItem;

    REQUEST(xStoreColorsReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    pItem = (xColorItem *) &stuff[1];
    for(n = 0; n < LengthRestB(stuff)/sizeof(xColorItem); n++)
	SwapColorItem(pItem++);
    return((* ProcVector[X_StoreColors])(client));
}

int
SProcStoreNamedColor           (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xStoreNamedColorReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swapl(&stuff->pixel, n);
    swaps(&stuff->nbytes, n);
    return((* ProcVector[X_StoreNamedColor])(client));
}

int
SProcQueryColors(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xQueryColorsReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    SwapRestL(stuff);
    return((* ProcVector[X_QueryColors])(client));
} 

int
SProcLookupColor(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xLookupColorReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cmap, n);
    swaps(&stuff->nbytes, n);
    return((* ProcVector[X_GetWindowAttributes])(client));
}

int
SProcCreateCursor( client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xCreateCursorReq);
    swaps(&stuff->length, n);
    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( client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xCreateGlyphCursorReq);
    swaps(&stuff->length, n);
    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(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xRecolorCursorReq);
    swaps(&stuff->length, n);
    swapl(&stuff->cursor, n);
    swaps(&stuff->foreRed, n);
    swaps(&stuff->foreGreen, n);
    swaps(&stuff->foreBlue, n);
    swaps(&stuff->foreRed, n);
    swaps(&stuff->foreGreen, n);
    swaps(&stuff->backBlue, n);
    return((* ProcVector[X_RecolorCursor])(client));
}

int
SProcFreeCursor(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_FreeCursor])(client));

}

int
SProcQueryBestSize   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xQueryBestSizeReq);
    swaps(&stuff->length, n);
    swapl(&stuff->drawable, n);
    swaps(&stuff->width, n);
    swaps(&stuff->height, n);
    return((* ProcVector[X_QueryBestSize])(client));

}

int
SProcListExtensions(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_ListExtensions])(client));

}

int
SProcQueryExtension   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xQueryExtensionReq);
    swaps(&stuff->length, n);
    swapl(&stuff->nbytes, n);
    return((* ProcVector[X_QueryExtension])(client));
}

int
SProcChangeKeyboardMapping   (client)
    register ClientPtr client;
{
    register int n;
    register long *p;
    register int i, count;

    REQUEST(xChangeKeyboardMappingReq);
    swaps(&stuff->length, n);
    p = (long *)&stuff[1];
    count = stuff->keyCodes * stuff->keySymsPerKeyCode;
    for(i = 0; i < count; i++)
    {
        swapl(p, n);
	p++;
    }
    return((* ProcVector[X_ChangeKeyboardMapping])(client));
}

int
SProcSetPointerMapping   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xSetPointerMappingReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_SetPointerMapping])(client));
}

int
SProcGetKeyboardMapping(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetKeyboardMapping])(client));
}

int
SProcGetPointerMapping(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetPointerMapping])(client));
}

int
SProcChangeKeyboardControl   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xChangeKeyboardControlReq);
    swaps(&stuff->length, n);
    swapl(&stuff->mask, n);
    SwapRestL(stuff);
    return((* ProcVector[X_ChangeKeyboardControl])(client));
}

int
SProcGetKeyboardControl(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetKeyboardControl])(client));

}

int
SProcBell   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xBellReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_Bell])(client));
}

int
SProcChangePointerControl   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xChangePointerControlReq);
    swaps(&stuff->length, n);
    swaps(&stuff->accelNum, n);
    swaps(&stuff->accelDenum, n);
    swaps(&stuff->threshold, n);
    return((* ProcVector[X_ChangePointerControl])(client));
}

int
SProcGetPointerControl(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetPointerControl])(client));

}

int
SProcListHosts(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xListHostsReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_ListHosts])(client));

}

int
SProcSetScreenSaver            (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xSetScreenSaverReq);
    swaps(&stuff->length, n);
    swaps(&stuff->timeout, n);
    swaps(&stuff->interval, n);
    return((* ProcVector[X_SetScreenSaver])(client));
}

int
SProcGetScreenSaver(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetWindowAttributes])(client));
}

int
SProcChangeHosts(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xChangeHostsReq);
    swaps(&stuff->length, n);
    swaps(&stuff->hostLength, n);
    return((* ProcVector[X_ChangeHosts])(client));

}

int
SProcChangeAccessControl(client)
    register ClientPtr client;
{
    register int n;

    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_SetAccessControl])(client));

}

SProcKillClient(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_KillClient])(client));
}
int
SProcGetFontPath(client)
    register ClientPtr client;
{
    register int n;
    REQUEST (xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetFontPath])(client));
}

int
SProcChangeCloseDownMode(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xResourceReq);
    swaps(&stuff->length, n);
    swapl(&stuff->id, n);
    return((* ProcVector[X_SetCloseDownMode])(client));
}

int SProcForceScreenSaver(client)
    register ClientPtr client;
{    
    register int n;
    REQUEST (xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_ForceScreenSaver])(client));
}

int SProcRotateProperties(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xRotatePropertiesReq);
    swaps(&stuff->length, n);
    swapl(&stuff->window, n);
    swaps(&stuff->nAtoms, n);
    swaps(&stuff->nPositions, n);
    return ((* ProcVector[X_RotateProperties])(client));
}

int
SProcSetModifierMapping   (client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xSetModifierMappingReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_SetModifierMapping])(client));
}

int
SProcGetModifierMapping(client)
    register ClientPtr client;
{
    register int n;
    REQUEST(xReq);
    swaps(&stuff->length, n);
    return((* ProcVector[X_GetModifierMapping])(client));
}

int SProcNoOperation(client)
    register ClientPtr client;
{
    /* noop -- don't do anything */
    return(Success);
}

SwapTimecoord(pCoord)
    xTimecoord *pCoord;
{
    register int n;

    swapl(&pCoord->time, n);
    swaps(&pCoord->x, n);
    swaps(&pCoord->y, n);
}

#ifdef ELSEWHERE
SwapCharInfo(pInfo)
    xCharInfo	*pInfo;
{
    register int n;

    swaps(&pInfo->leftSideBearing, n);
    swaps(&pInfo->rightSideBearing, n);
    swaps(&pInfo->characterWidth, n);
    swaps(&pInfo->ascent, n);
    swaps(&pInfo->descent, n);
    swaps(&pInfo->attributes, n);
}
#endif /* ELSEWHERE */

SwapFontProp(pProp)
    xFontProp  *pProp;
{
    register int n;

    swapl(&pProp->name, n);
    swapl(&pProp->value, n);
}

SwapRGB(prgb)
    xrgb	*prgb;
{
    register int n;

    swaps(&prgb->red, n);
    swaps(&prgb->green, n);
    swaps(&prgb->blue, n);
}
SwapColorItem(pItem)
    xColorItem	*pItem;
{
    register int n;

    swapl(&pItem->pixel, n);
    swaps(&pItem->red, n);
    swaps(&pItem->green, n);
    swaps(&pItem->blue, n);
}

SwapSegment(pSeg)
    xSegment	*pSeg;
{
    register int n;

    swaps(&pSeg->x1, n);
    swaps(&pSeg->y1, n);
    swaps(&pSeg->x2, n);
    swaps(&pSeg->y2, n);
}

SwapPoint(pPoint)
    xPoint	*pPoint;
{
    register int n;

    swaps(&pPoint->x, n);
    swaps(&pPoint->y, n);
}

SwapRectangle(pRect)
    xRectangle	*pRect;
{
    register int n;

    swaps(&pRect->x, n);
    swaps(&pRect->y, n);
    swaps(&pRect->width, n);
    swaps(&pRect->height, n);
}
SwapArc(pArc)
    xArc	*pArc;
{
    register int n;

    swaps(&pArc->x, n);
    swaps(&pArc->y, n);
    swaps(&pArc->width, n);
    swaps(&pArc->height, n);
    swaps(&pArc->angle1, n);
    swaps(&pArc->angle2, n);
}


SwapConnClientPrefix(pCCP)
    xConnClientPrefix	*pCCP;
{
    register int n;

    swaps(&pCCP->majorVersion, n);
    swaps(&pCCP->minorVersion, n);
    swaps(&pCCP->nbytesAuthProto, n);
    swaps(&pCCP->nbytesAuthString, n);
}