/* $Id: requests.c,v 1.2 90/11/29 10:04:58 altenhof Exp $ */
/************************************************************
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.

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

#include <X11/Xatom.h>

#define NEED_EVENTS

#include "Xlibint.h"

#include "XmuXlibint.h"
#include "build.h"
#include "map.h"

#include "X11RequestNames.h"	/* mapping req type -> req string */

#define REQUEST_LENGTH( buf )  ( ( ( xReq * )buf )->length << 2 )

static Mask XmuXSpecificMask = 0L;

int
ProcBadRequest (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...bad request!\n ",
	     X11RequestNames[((xReq *) buffer)->reqType]);
}

int
ProcCreateWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreateWindowReq *req;
  register Window window;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xCreateWindowReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }

  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->parent = XmuXMapID (dpy, req->parent, FromClient);
  /* --create a new ID on this display -- */
  window = XAllocID (dpy);
  XmuXInsertID (dpy, window, req->wid, FromServer);
  XmuXInsertID (dpy, req->wid, window, FromClient);
  req->wid = window;

  /* -- map the depth -- */
  req->depth = XmuXMapDepth (dpy, req->depth, req->wid, IsWindow);

  if (req->visual != CopyFromParent)
    req->visual = XmuXMapID (dpy, req->visual, FromClient);
  CheckWindowAttributes (dpy, window, req->mask,
			 (XSetWindowAttributes *) & req[1]);

  if (req->parent == DefaultRootWindow (dpy))
    XmuXdebug (debug_requests, "top level window :\n");

  XmuXdebug (debug_requests,
	     "(wid=0x%lx)(size=%ux%u) send (# 0x%lx)...",
	     window, req->width, req->height, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcChangeWindowAttributes (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xChangeWindowAttributesReq *req;
  XSetWindowAttributes attributes;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xChangeWindowAttributesReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }

  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->window = XmuXMapID (dpy, req->window, FromClient);
  CheckWindowAttributes (dpy, req->window, req->valueMask,
			 (XSetWindowAttributes *) & req[1]);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...",
	     req->window, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcDestroyWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (DestroyWindow,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);

  /*
   * -- remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);
  XmuXdebug (debug_requests, "(win=0%lx) send (#0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcDestroySubwindows (dpy, buffer)	/* 5 */
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (DestroySubwindows,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}


int
ProcChangeSaveSet (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xChangeSaveSetReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ChangeSaveSet, req);
  req->mode = ((xChangeSaveSetReq *) buffer)->mode;
  req->window = XmuXMapID (dpy, ((xChangeSaveSetReq *) buffer)->window,
			   FromClient);
  XmuXdebug (debug_requests, "(win=0x%lx mode=%u) send (# 0x%lx)...done\n",
	     req->window, req->mode, NextRequest (dpy) - 1);
}

int
ProcReparentWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xReparentWindowReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ReparentWindow, req);

  req->window = XmuXMapID (dpy, ((xReparentWindowReq *) buffer)->window,
			   FromClient);
  req->parent = XmuXMapID (dpy, ((xReparentWindowReq *) buffer)->parent,
			   FromClient);
  req->x = ((xReparentWindowReq *) buffer)->x;
  req->y = ((xReparentWindowReq *) buffer)->y;

  XmuXdebug (debug_requests, "(win=0x%lx p=0x%lx) send (# 0x%lx)...done\n",
	     req->window, req->parent, NextRequest (dpy) - 1);
}

int
ProcMapWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
     
  /* don't map hidden windows on other displays! */
  if (XmuXWindowIsHidden (dpy, ((xResourceReq *) buffer)->id))
    return;
  GetResReq (MapWindow,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcMapSubwindows (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (MapSubwindows,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcUnmapWindow (dpy, buffer)	/* 10 */
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (UnmapWindow,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcUnmapSubwindows (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (UnmapSubwindows,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcConfigureWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xConfigureWindowReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xConfigureWindowReq *) Xmalloc (REQUEST_LENGTH (buffer));

  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  req->window = XmuXMapID (dpy, req->window, FromClient);
  BuildWindowChanges (dpy, req->mask,
		      (XWindowChanges *) & req[1]);

  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->window, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  Xfree ((char *) req);
}

int
ProcCirculateWindow (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCirculateWindowReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (CirculateWindow, req);
  req->window = XmuXMapID (dpy,
			   ((xCirculateWindowReq *) buffer)->window,
			   FromClient);
  req->direction = ((xCirculateWindowReq *) buffer)->direction;
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->window, NextRequest (dpy) - 1);
}

int
ProcChangeProperty (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xChangePropertyReq *req;

  XmuXdebug (debug_requests, "%s...\n",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xChangePropertyReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->window = XmuXMapID (dpy, req->window, FromClient);
  req->property = XmuXMapID (dpy, req->property, FromClient);
  XmuXdebug (debug_requests, "(prop=%d items=%d) send (# 0x%lx)...",
	     req->property, req->nUnits, NextRequest (dpy) - 1);

  /*
   * Check "long" (format == 32) properties, they may contain resource
   * ID's!
   */
  if (req->format == 32)
    CheckProperty (dpy, req->type, (char *) &req[1], req->nUnits,
		   FromClient);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");
  Xfree ((char *) req);
}

int
ProcDeleteProperty (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xDeletePropertyReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
  GetReq (DeleteProperty, req);
  req->window = XmuXMapID (dpy,
			   ((xDeletePropertyReq *) buffer)->window,
			   FromClient);
  req->property = XmuXMapID (dpy,
			     ((xDeletePropertyReq *) buffer)->property,
			     FromClient);
  XmuXdebug (debug_requests, "(prop=%d) (win=0x%lx) send (# 0x%lx)...done\n",
	     req->property, req->window, NextRequest (dpy) - 1);
}

int
ProcSetSelectionOwner (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetSelectionOwnerReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (SetSelectionOwner, req);
  req->selection =
    XmuXMapID (dpy,
	       ((xSetSelectionOwnerReq *) buffer)->selection,
	       FromClient);
  req->time = ((xSetSelectionOwnerReq *) buffer)->time;
  XmuXdebug (debug_requests, "(sel=%u) send (# 0x%lx)...done\n",
	     req->selection, NextRequest (dpy) - 1);

  /*
   * We are not interested to make the application selection owner; we
   * pass owner = None
   */
  req->window = None;
}

int
ProcConvertSelection (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xConvertSelectionReq *req;

  XmuXdebug (debug_requests, "%s...done\n",
	     X11RequestNames[((xReq *) buffer)->reqType]);

 /*****************************************************************
  GetReq (ConvertSelection, req);
  req->requestor =
    XmuXMapID (dpy,
	       ((xConvertSelectionReq *) buffer)->requestor,
	       FromClient);
  req->target =
    XmuXMapID (dpy,
	       ((xConvertSelectionReq *) buffer)->target,
	       FromClient);
  req->property =
    XmuXMapID (dpy,
	       ((xConvertSelectionReq *) buffer)->property,
	       FromClient);
  req->selection =
    XmuXMapID (dpy,
	       ((xConvertSelectionReq *) buffer)->selection,
	       FromClient);
  req->time = ((xConvertSelectionReq *) buffer)->time;
  XmuXdebug (debug_requests, "(sel=%u) (win=0x%lx) send (# 0x%lx)...done\n",
	     req->selection, req->requestor, NextRequest (dpy) - 1);
  *****************************************************************/
}

int
ProcSendEvent (dpy, buffer)	/* 25 */
  Display *dpy;
  char *buffer;
{
  register xSendEventReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xSendEventReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  if ((req->destination != PointerWindow) &&
      (req->destination != InputFocus))
    req->destination = XmuXMapID (dpy, req->destination, FromClient);
  if (!CheckWire (dpy, &req->event, &req->event))
    XmuXErrorF ("Event translation failed!\n");

  XmuXdebug (debug_requests, "(e_type=%u) (win=0x%lx) send (# 0x%lx)...",
	     req->event.u.u.type, req->destination,
	     NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcUngrabPointer (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (UngrabPointer,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id,
			FromClient),
	     req);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcGrabButton (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xGrabButtonReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
  GetReq (GrabButton, req);
  req->grabWindow =
    XmuXMapID (dpy,
	       ((xGrabButtonReq *) buffer)->grabWindow,
	       FromClient);
  req->button = ((xGrabButtonReq *) buffer)->button;
  req->modifiers = ((xGrabButtonReq *) buffer)->modifiers;
  req->ownerEvents = ((xGrabButtonReq *) buffer)->ownerEvents;
  req->eventMask = ((xGrabButtonReq *) buffer)->eventMask;
  req->pointerMode = ((xGrabButtonReq *) buffer)->pointerMode;
  req->keyboardMode = ((xGrabButtonReq *) buffer)->keyboardMode;
  req->confineTo =
    XmuXMapID (dpy, ((xGrabButtonReq *) buffer)->confineTo,
	       FromClient);
  req->cursor =
    XmuXMapID (dpy, ((xGrabButtonReq *) buffer)->cursor,
	       FromClient);
  XmuXdebug (debug_requests, "(grab=0x%lx) send (# 0x%lx)...done\n",
	     req->grabWindow, NextRequest (dpy) - 1);
}

int
ProcUngrabButton (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xUngrabButtonReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (UngrabButton, req);
  req->grabWindow =
    XmuXMapID (dpy, ((xUngrabButtonReq *) buffer)->grabWindow,
	       FromClient);
  req->button = ((xUngrabButtonReq *) buffer)->button;
  req->modifiers = ((xUngrabButtonReq *) buffer)->modifiers;
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...done\n",
	     req->grabWindow, NextRequest (dpy) - 1);
}

int
ProcChangeActivePointerGrab (dpy, buffer)	/* 30 */
  Display *dpy;
  char *buffer;
{
  register xChangeActivePointerGrabReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ChangeActivePointerGrab, req);
  req->eventMask = ((xChangeActivePointerGrabReq *) buffer)->eventMask;
  req->time = ((xChangeActivePointerGrabReq *) buffer)->time;
  req->cursor =
    XmuXMapID (dpy,
	       ((xChangeActivePointerGrabReq *) buffer)->cursor,
	       FromClient);
  XmuXdebug (debug_requests, "send (0x%lx) done\n",
	     NextRequest (dpy) - 1);
}

int
ProcUngrabKeyboard (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetEmptyReq (UngrabKeyboard, req);
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcGrabKey (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xGrabKeyReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (GrabKey, req);
  req->grabWindow =
    XmuXMapID (dpy, ((xGrabKeyReq *) buffer)->grabWindow,
	       FromClient);
  req->ownerEvents = ((xGrabKeyReq *) buffer)->ownerEvents;
  req->modifiers = ((xGrabKeyReq *) buffer)->modifiers;
  req->key = ((xGrabKeyReq *) buffer)->key;
  req->pointerMode = ((xGrabKeyReq *) buffer)->pointerMode;
  req->keyboardMode = ((xGrabKeyReq *) buffer)->keyboardMode;

  XmuXdebug (debug_requests, "(grab=0x%lx) send (# 0x%lx)...done\n",
	     req->grabWindow, NextRequest (dpy) - 1);
}

int
ProcUngrabKey (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xUngrabKeyReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (UngrabKey, req);
  req->grabWindow = XmuXMapID (dpy,
			       ((xUngrabKeyReq *) buffer)->grabWindow,
			       FromClient);
  req->modifiers = ((xUngrabKeyReq *) buffer)->modifiers;
  req->key = ((xUngrabKeyReq *) buffer)->key;
  XmuXdebug (debug_requests, "(grab=0x%lx) send (# 0x%lx)...done\n",
	     req->grabWindow, NextRequest (dpy) - 1);
}

int
ProcAllowEvents (dpy, buffer)	/* 35 */
  Display *dpy;
  char *buffer;
{
  register xAllowEventsReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (AllowEvents, req);
  req->mode = ((xAllowEventsReq *) buffer)->mode;
  req->time = ((xAllowEventsReq *) buffer)->time;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcGrabServer (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetEmptyReq (GrabServer, req);

  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcUngrabServer (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetEmptyReq (UngrabServer, req);
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcWarpPointer (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xWarpPointerReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (WarpPointer, req);
  req->srcWid = XmuXMapID (dpy, ((xWarpPointerReq *) buffer)->srcWid,
			   FromClient);
  req->dstWid = XmuXMapID (dpy, ((xWarpPointerReq *) buffer)->dstWid,
			   FromClient);
  req->srcX = ((xWarpPointerReq *) buffer)->srcX;
  req->srcY = ((xWarpPointerReq *) buffer)->srcY;
  req->srcWidth = ((xWarpPointerReq *) buffer)->srcWidth;
  req->srcHeight = ((xWarpPointerReq *) buffer)->srcHeight;
  req->dstX = ((xWarpPointerReq *) buffer)->dstX;
  req->dstY = ((xWarpPointerReq *) buffer)->dstY;

  XmuXdebug (debug_requests,
	     "(src=0x%lx) (dst=0x%lx) send (# 0x%lx)...done\n",
	     req->srcWid, req->dstWid, NextRequest (dpy) - 1);
}

int
ProcSetInputFocus (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetInputFocusReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
  GetReq (SetInputFocus, req);

  if (((xSetInputFocusReq *) buffer)->focus == PointerRoot)
    req->focus = PointerRoot;
  else
    req->focus = XmuXMapID (dpy,
			    ((xSetInputFocusReq *) buffer)->focus,
			    FromClient);
  req->revertTo = ((xSetInputFocusReq *) buffer)->revertTo;
  req->time = ((xSetInputFocusReq *) buffer)->time;

  XmuXdebug (debug_requests, "(focus=0x%lx) send (# 0x%lx)...done\n",
	     req->focus, NextRequest (dpy) - 1);
}

int
ProcOpenFont (dpy, buffer)	/* 45 */
  Display *dpy;
  char *buffer;
{
  register xOpenFontReq *req;
  char *name = NULL;
  register Font font;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xOpenFontReq *) buffer;
  if ((name = (char *) Xmalloc (req->nbytes + 1)) == NULL) {
    XmuXErrorF ("Out of memory!\n");
    return;
  }
  bcopy ((char *) &req[1], name, req->nbytes);
  name[req->nbytes] = '\0';
  XmuXdebug (debug_requests, "\"%s\"", name);
  Xfree (name);

  req = (xOpenFontReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can't allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* create a new ID on this display */
  font = XAllocID (dpy);
  XmuXInsertID (dpy, font, req->fid, FromServer);
  XmuXInsertID (dpy, req->fid, font, FromClient);
  req->fid = font;

  XmuXdebug (debug_requests, " (font=0x%lx) send (# 0x%lx)...",
	     font, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  XFree ((char *) req);
}

int
ProcCloseFont (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (CloseFont,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id,
			FromClient),
	     req);

  /*
   * remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);
  XmuXdebug (debug_requests, "(font=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcSetFontPath (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  Data (dpy, buffer, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "send (0x%lx) done\n",
	     NextRequest (dpy) - 1);
}

int
ProcCreatePixmap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreatePixmapReq *req;
  register Pixmap pixmap;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
  GetReq (CreatePixmap, req);

  req->width = ((xCreatePixmapReq *) buffer)->width;
  req->height = ((xCreatePixmapReq *) buffer)->height;
  req->depth = XmuXMapDepth (dpy,
			     ((xCreatePixmapReq *) buffer)->depth,
			     None, IsPixmap);

  req->drawable = XmuXMapID (dpy,
			     ((xCreatePixmapReq *) buffer)->drawable,
			     FromClient);

  /* create a new ID on this display */
  pixmap = XAllocID (dpy);
  XmuXInsertID (dpy, pixmap,
		((xCreatePixmapReq *) buffer)->pid, FromServer);
  XmuXInsertID (dpy, ((xCreatePixmapReq *) buffer)->pid, pixmap,
		FromClient);
  req->pid = pixmap;

  XmuXdebug (debug_requests,
	     "(pid=0x%lx)(d=0x%lx) send (# 0x%lx)...done\n",
	     pixmap, req->drawable, NextRequest (dpy) - 1);
}

int
ProcFreePixmap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (FreePixmap,
	     XmuXMapID (dpy,
			((xResourceReq *) buffer)->id, FromClient),
	     req);

  /*
   * remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);
  XmuXdebug (debug_requests, "(pixmap=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcCreateGC (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreateGCReq *req;
  register GContext gid;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xCreateGCReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);

  /* --create a new ID on this display -- */
  gid = XAllocID (dpy);
  XmuXInsertID (dpy, gid, req->gc, FromServer);
  XmuXInsertID (dpy, req->gc, gid, FromClient);
  req->gc = gid;

  /*
   * ID's  MUST be mapped !! Last argument tells CheckGCValues that
   * GCPixelInfo has to be inserted by all means !
   */
  CheckGCValues (dpy, req->mask, (XGCValues *) & req[1],
		 req->gc, req->drawable, True);

  XmuXdebug (debug_requests, "(gid=0x%lx) send (# 0x%lx)...",
	     gid, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcChangeGC (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xChangeGCReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xChangeGCReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->gc = XmuXMapID (dpy, req->gc, FromClient);

  /* ID's MUST be mapped !! */
  CheckGCValues (dpy, req->mask, (XGCValues *) & req[1],
		 req->gc, None, False);
  XmuXdebug (debug_requests, "(gc=0x%lx) send (# 0x%lx)...",
	     req->gc, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcCopyGC (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCopyGCReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xCopyGCReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->srcGC = XmuXMapID (dpy, req->srcGC, FromClient);
  req->dstGC = XmuXMapID (dpy, req->dstGC, FromClient);
  XmuXdebug (debug_requests,
	     "(src_gc=0x%lx) (dst_gc=0x%lx) send (# 0x%lx)...",
	     req->srcGC, req->dstGC, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcSetDashes (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetDashesReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xSetDashesReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  XmuXdebug (debug_requests, "(gc=0x%lx) send (# 0x%lx) ...",
	     req->gc, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcSetClipRectangles (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetClipRectanglesReq *req;
  register int num_rects;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xSetClipRectanglesReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_rects = ((req->length << 2) - sizeof (xSetClipRectanglesReq)) /
    sizeof (XRectangle);
  XmuXdebug (debug_requests, "(gc=0x%lx)(num_rects=%d) send (# 0x%lx)...",
	     req->gc, num_rects, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcFreeGC (dpy, buffer)	/* 60 */
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);
  GetResReq (FreeGC,
	     XmuXMapID (dpy,
			((xResourceReq *) buffer)->id, FromClient),
	     req);

  /*
   * -- remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);
  XmuXdebug (debug_requests, "(gc=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcClearToBackground (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xClearAreaReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ClearArea, req);
  req->window = XmuXMapID (dpy, ((xClearAreaReq *) buffer)->window,
			   FromClient);
  req->x = ((xClearAreaReq *) buffer)->x;
  req->y = ((xClearAreaReq *) buffer)->y;
  req->width = ((xClearAreaReq *) buffer)->width;
  req->height = ((xClearAreaReq *) buffer)->height;
  req->exposures = ((xClearAreaReq *) buffer)->exposures;

  XmuXdebug (debug_requests, "(d=0x%lx) send (# 0x%lx)...done\n",
	     req->window, NextRequest (dpy) - 1);
}

int
ProcCopyArea (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  /* if colors have changed ... */
  XmuXFlushGC (dpy,
	       ((xCopyAreaReq *) buffer)->gc,
	       ((xCopyAreaReq *) buffer)->dstDrawable);

  if (XmuXMapDepth (dpy, ((xCopyAreaReq *) buffer)->srcDrawable, DontKnow)
      !=
      XmuXMapDepth (dpy, ((xCopyAreaReq *) buffer)->dstDrawable, DontKnow)) {
    register xCopyPlaneReq *req;

    /*
     * If we are trying to copy a bitmap area in an deeper dest drawable
     * mimic that by xCopyPlane
     */
    GetReq (CopyPlane, req);
    req->srcX = ((xCopyAreaReq *) buffer)->srcX;
    req->srcY = ((xCopyAreaReq *) buffer)->srcY;
    req->dstX = ((xCopyAreaReq *) buffer)->dstX;
    req->dstY = ((xCopyAreaReq *) buffer)->dstY;
    req->width = ((xCopyAreaReq *) buffer)->width;
    req->height = ((xCopyAreaReq *) buffer)->height;
    req->bitPlane = 1L;		/* -- always use plane one ! - */
    req->srcDrawable = XmuXMapID (dpy,
				  ((xCopyAreaReq *) buffer)->srcDrawable,
				  FromClient);
    req->dstDrawable = XmuXMapID (dpy,
				  ((xCopyAreaReq *) buffer)->dstDrawable,
				  FromClient);
    /* XXX maybe we should change the gc */
    req->gc = XmuXMapID (dpy, ((xCopyAreaReq *) buffer)->gc,
			 FromClient);
    XmuXdebug (debug_requests,
    "(src=0x%lx dst=0x%lx )(gc=0x%lx) (area=%dx%d) send (# 0x%lx)...done\n",
	       req->srcDrawable, req->dstDrawable, req->gc,
	       req->width, req->height, NextRequest (dpy) - 1);
  }
  else {
    register xCopyAreaReq *req;

    GetReq (CopyArea, req);
    req->srcDrawable = XmuXMapID (dpy,
				  ((xCopyAreaReq *) buffer)->srcDrawable,
				  FromClient);
    req->dstDrawable = XmuXMapID (dpy,
				  ((xCopyAreaReq *) buffer)->dstDrawable,
				  FromClient);
    req->gc = XmuXMapID (dpy, ((xCopyAreaReq *) buffer)->gc,
			 FromClient);
    req->srcX = ((xCopyAreaReq *) buffer)->srcX;
    req->srcY = ((xCopyAreaReq *) buffer)->srcY;
    req->dstX = ((xCopyAreaReq *) buffer)->dstX;
    req->dstY = ((xCopyAreaReq *) buffer)->dstY;
    req->width = ((xCopyAreaReq *) buffer)->width;
    req->height = ((xCopyAreaReq *) buffer)->height;
    XmuXdebug (debug_requests,
    "(src=0x%lx dst=0x%lx )(gc=0x%lx) (area=%dx%d) send (# 0x%lx)...done\n",
	       req->srcDrawable, req->dstDrawable, req->gc,
	       req->width, req->height, NextRequest (dpy) - 1);
  }
}

int
ProcCopyPlane (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCopyPlaneReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  /* if colors have changed ... */
  XmuXFlushGC (dpy,
	       ((xCopyPlaneReq *) buffer)->gc,
	       ((xCopyPlaneReq *) buffer)->dstDrawable);


  GetReq (CopyPlane, req);
  req->srcDrawable = XmuXMapID (dpy,
				((xCopyPlaneReq *) buffer)->srcDrawable,
				FromClient);
  req->dstDrawable = XmuXMapID (dpy,
				((xCopyPlaneReq *) buffer)->dstDrawable,
				FromClient);
  req->gc = XmuXMapID (dpy, ((xCopyPlaneReq *) buffer)->gc,
		       FromClient);
  req->srcX = ((xCopyPlaneReq *) buffer)->srcX;
  req->srcY = ((xCopyPlaneReq *) buffer)->srcY;
  req->dstX = ((xCopyPlaneReq *) buffer)->dstX;
  req->dstY = ((xCopyPlaneReq *) buffer)->dstY;
  req->width = ((xCopyPlaneReq *) buffer)->width;
  req->height = ((xCopyPlaneReq *) buffer)->height;
  req->bitPlane = ((xCopyPlaneReq *) buffer)->bitPlane;
  XmuXdebug (debug_requests,
	"(src=0x%lx dst=0x%lx)(gc=0x%lx)(plane=%d) send (# 0x%lx)...done\n",
	     req->srcDrawable, req->dstDrawable,
	     req->gc, req->bitPlane, NextRequest (dpy) - 1);
}

int
ProcPolyPoint (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xPolyPointReq *req;
  register int num_points;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyPointReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_points = ((req->length << 2) - sizeof (xPolyPointReq)) /
    sizeof (XPoint);
  XmuXdebug (debug_requests,
	     "(gc=0x%lx) (#pts=%d) send (# 0x%lx)...",
	     req->gc, num_points, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolyLine (dpy, buffer)	/* 65 */
  Display *dpy;
  char *buffer;
{
  register xPolyLineReq *req;
  register num_lines;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyLineReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_lines = ((req->length << 2) - sizeof (xPolyLineReq)) /
    sizeof (XPoint);
  XmuXdebug (debug_requests,
	     "(gc=0x%lx)(# lines=%d)send (# 0x%lx)...",
	     req->gc, num_lines, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolySegment (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xPolySegmentReq *req;
  register int num_segs;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolySegmentReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_segs = ((req->length << 2) - sizeof (xPolySegmentReq)) /
    sizeof (XSegment);
  XmuXdebug (debug_requests,
	     "(gc=0x%lx)(#segs=%d) send (# 0x%lx)...",
	     req->gc, num_segs, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolyRectangle (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xPolyRectangleReq *req;
  register int num_rects;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyRectangleReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_rects = ((req->length << 2) - sizeof (xPolyRectangleReq)) /
    sizeof (XRectangle);
  XmuXdebug (debug_requests,
	     "(gc=0x%lx)(#rects=%d) send (# 0x%lx)...",
	     req->gc, num_rects, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolyArc (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xPolyArcReq *req;
  register int num_arcs;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyArcReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_arcs = ((req->length << 2) - sizeof (xPolyArcReq)) /
    sizeof (XArc);
  XmuXdebug (debug_requests, "(gc=0x%lx)(# arcs=%d) send (# 0x%lx)...",
	     req->gc, num_arcs, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcFillPoly (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xFillPolyReq *req;
  register int num_points;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xFillPolyReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_points = ((req->length << 2) - sizeof (xFillPolyReq)) /
    sizeof (XPoint);
  XmuXdebug (debug_requests, "(gc=0x%lx)(#pts=%d) send (# 0x%lx)...",
	     req->gc, num_points, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolyFillRectangle (dpy, buffer)	/* 70 */
  Display *dpy;
  char *buffer;
{
  register xPolyFillRectangleReq *req;
  register int num_rects;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyFillRectangleReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_rects = ((req->length << 2) - sizeof (xPolyRectangleReq)) /
    sizeof (XRectangle);
  XmuXdebug (debug_requests, "(gc=0x%lx)(#rects=%d)send (# 0x%lx)...",
	     req->gc, num_rects, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPolyFillArc (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xPolyFillArcReq *req;
  register int num_arcs;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyFillArcReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  num_arcs = ((req->length << 2) - sizeof (xPolyFillArcReq)) /
    sizeof (xArc);
  XmuXdebug (debug_requests,
	     "(gc=0x%lx)(#arcs=%d) send (# 0x%lx)...",
	     req->gc, num_arcs, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcPutImage (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  XmuXdebug (debug_requests, "done\n");
}

int
ProcPolyText (dpy, buffer)	/* 75 */
  Display *dpy;
  char *buffer;
{
  register xPolyTextReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xPolyTextReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  XmuXdebug (debug_requests, "(d=0x%lx gc=0x%lx) send (# 0x%lx)...",
	     req->drawable, req->gc, NextRequest (dpy) - 1);
  CheckPolyText (dpy, req);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcImageText (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xImageTextReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xImageTextReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  /* if colors have changed ... */
  XmuXFlushGC (dpy, req->gc, req->drawable);

  req->drawable = XmuXMapID (dpy, req->drawable, FromClient);
  req->gc = XmuXMapID (dpy, req->gc, FromClient);
  XmuXdebug (debug_requests, "(d=0x%lx gc=0x%lx) send (# 0x%lx)...",
	     req->drawable, req->gc, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcCreateColormap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreateColormapReq *req;
  register Colormap cmap;
  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (CreateColormap, req);
  req->window = XmuXMapID (dpy,
			   ((xCreateColormapReq *) buffer)->window,
			   FromClient);
  req->visual = XmuXMapID (dpy,
			   ((xCreateColormapReq *) buffer)->visual,
			   FromClient);
  req->alloc = ((xCreateColormapReq *) buffer)->alloc;

  /* must create a new ID */
  cmap = XAllocID (dpy);

  XmuXInsertID (dpy, cmap,
		((xCreateColormapReq *) buffer)->mid, FromServer);
  XmuXInsertID (dpy, ((xCreateColormapReq *) buffer)->mid,
		cmap, FromClient);
  req->mid = cmap;
  XmuXdebug (debug_requests, "(cmap=0x%lx) send (# 0x%lx)...done\n",
	     cmap, NextRequest (dpy) - 1);
}

int
ProcFreeColormap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (FreeColormap,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id,
			FromClient),
	     req);

  /*
   * remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);
  XmuXdebug (debug_requests, "(cmap=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);

}

int
ProcCopyColormapAndFree (dpy, buffer)	/* 80 */
  Display *dpy;
  char *buffer;
{
  register xCopyColormapAndFreeReq *req;
  register Colormap cmap;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (CopyColormapAndFree, req);

  /*
   * alloc a new resource ID
   */
  cmap = XAllocID (dpy);

  XmuXInsertID (dpy, cmap,
		((xCopyColormapAndFreeReq *) buffer)->mid,
		FromServer);
  XmuXInsertID (dpy, ((xCopyColormapAndFreeReq *) buffer)->mid,
		cmap, FromClient);
  req->mid = cmap;

  req->srcCmap =
    XmuXMapID (dpy,
	       ((xCopyColormapAndFreeReq *) buffer)->srcCmap,
	       FromClient);
  XmuXdebug (debug_requests,
	     "(old=0x%lx new=0x%lx) send (# 0x%lx)...done\n",
	     req->srcCmap, req->mid, NextRequest (dpy) - 1);

}

int
ProcInstallColormap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (InstallColormap,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id,
			FromClient),
	     req);

  XmuXdebug (debug_requests, "(cmap=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);

}

int
ProcUninstallColormap (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (UninstallColormap,
	     XmuXMapID (dpy, ((xResourceReq *) buffer)->id,
			FromClient),
	     req);

  XmuXdebug (debug_requests, "(cmap=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);

}

int
ProcFreeColors (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  xFreeColorsReq *req;
  register int npixels;
  unsigned long planes;

  XmuXdebug (debug_requests, "Handle request %s...\n",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xFreeColorsReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  req->cmap = XmuXMapID (dpy, req->cmap, FromClient);
  planes = req->planeMask;
  npixels = ((req->length << 2) - sizeof (xFreeColorsReq)) /
    sizeof (unsigned long);

  if (XmuXMapPixelsAndPlanes (dpy, req->cmap,
			      (unsigned long *) &req[1], npixels,
			      &planes)) {
    req->planeMask = planes;
    Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
    XmuXdebug (debug_requests,
	       "(cmap=0x%lx) (#pix=%d planes=%lx) send (0x%lx)...done\n",
	       req->cmap, npixels, planes, NextRequest (dpy) - 1);
  }
  else
    XmuXdebug (debug_requests, "NOT send (can't map pixels)!\n");
  Xfree ((char *) req);
}

int
ProcStoreColors (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xStoreColorsReq *req;
  register int ncolors;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xStoreColorsReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  req->cmap = XmuXMapID (dpy, req->cmap, FromClient);

  ncolors = ((req->length << 2) - sizeof (xStoreColorsReq)) /
    sizeof (XColor);
  /* must map the pixel values */
  XmuXMapColors (dpy, req->cmap, (XColor *) & req[1], ncolors);
  XmuXdebug (debug_requests, "(cmap=0x%lx) (#col=%d) send (#0x%lx)...",
	     req->cmap, ncolors, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcStoreNamedColor (dpy, buffer)	/* 90 */
  Display *dpy;
  char *buffer;
{
  register xStoreNamedColorReq *req;
  XColor color;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xStoreNamedColorReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));

  req->cmap = XmuXMapID (dpy, req->cmap, FromClient);

  /*
   * map the pixel
   */
  color.pixel = req->pixel;
  XmuXMapColors (dpy, req->cmap, &color, 1);
  req->pixel = color.pixel;

  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));

  XmuXdebug (debug_requests, "(cmap=0x%lx) send (# 0x%lx)...done\n",
	     req->cmap, NextRequest (dpy) - 1);
  Xfree ((char *) req);
}

int
ProcCreateCursor (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreateCursorReq *req;
  register Cursor cursor;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (CreateCursor, req);
  req->source = XmuXMapID (dpy, ((xCreateCursorReq *) buffer)->source,
			   FromClient);
  req->mask = XmuXMapID (dpy, ((xCreateCursorReq *) buffer)->mask,
			 FromClient);

  /* --create a new ID on this display */
  cursor = XAllocID (dpy);
  XmuXInsertID (dpy, cursor,
		((xCreateCursorReq *) buffer)->cid, FromServer);
  XmuXInsertID (dpy, ((xCreateCursorReq *) buffer)->cid,
		cursor, FromClient);
  req->cid = cursor;

  req->foreRed = ((xCreateCursorReq *) buffer)->foreRed;
  req->foreGreen = ((xCreateCursorReq *) buffer)->foreGreen;
  req->foreBlue = ((xCreateCursorReq *) buffer)->foreBlue;

  req->backRed = ((xCreateCursorReq *) buffer)->backRed;
  req->backGreen = ((xCreateCursorReq *) buffer)->backGreen;
  req->backBlue = ((xCreateCursorReq *) buffer)->backBlue;

  req->x = ((xCreateCursorReq *) buffer)->x;
  req->y = ((xCreateCursorReq *) buffer)->y;
  XmuXdebug (debug_requests, "(cid=0x%lx src_pmap=0x%lx msk_pmap=0x%lx) ",
	     req->cid, req->source, req->mask);
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcCreateGlyphCursor (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xCreateGlyphCursorReq *req;
  register Cursor cursor;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (CreateGlyphCursor, req);
  req->source = XmuXMapID (dpy,
			   ((xCreateGlyphCursorReq *) buffer)->source,
			   FromClient);
  req->mask = XmuXMapID (dpy,
			 ((xCreateGlyphCursorReq *) buffer)->mask,
			 FromClient);

  /* create a new ID on this display */
  cursor = XAllocID (dpy);

  XmuXInsertID (dpy, cursor,
		((xCreateGlyphCursorReq *) buffer)->cid, FromServer);
  XmuXInsertID (dpy, ((xCreateGlyphCursorReq *) buffer)->cid,
		cursor, FromClient);

  req->cid = cursor;

  req->foreRed = ((xCreateGlyphCursorReq *) buffer)->foreRed;
  req->foreGreen = ((xCreateGlyphCursorReq *) buffer)->foreGreen;
  req->foreBlue = ((xCreateGlyphCursorReq *) buffer)->foreBlue;

  req->backRed = ((xCreateGlyphCursorReq *) buffer)->backRed;
  req->backGreen = ((xCreateGlyphCursorReq *) buffer)->backGreen;
  req->backBlue = ((xCreateGlyphCursorReq *) buffer)->backBlue;

  req->sourceChar = ((xCreateGlyphCursorReq *) buffer)->sourceChar;
  req->maskChar = ((xCreateGlyphCursorReq *) buffer)->maskChar;

  XmuXdebug (debug_requests, "(cid=0x%lx src_font=0x%lx msk_font=0x%lx) ",
	     cursor, req->source, req->mask);
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcFreeCursor (dpy, buffer)	/* 95 */
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (FreeCursor,
	     XmuXMapID (dpy,
			((xResourceReq *) buffer)->id, FromClient),
	     req);

  /*
   * remove the ID's
   */
  XmuXRemoveID (dpy, req->id, FromServer);

  XmuXdebug (debug_requests, "(cur=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);
}

int
ProcRecolorCursor (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xRecolorCursorReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (RecolorCursor, req);

  req->cursor = XmuXMapID (dpy,
			   ((xRecolorCursorReq *) buffer)->cursor,
			   FromClient);

  req->foreRed = ((xRecolorCursorReq *) buffer)->foreRed;
  req->foreGreen = ((xRecolorCursorReq *) buffer)->foreGreen;
  req->foreBlue = ((xRecolorCursorReq *) buffer)->foreBlue;

  req->backRed = ((xRecolorCursorReq *) buffer)->backRed;
  req->backGreen = ((xRecolorCursorReq *) buffer)->backGreen;
  req->backBlue = ((xRecolorCursorReq *) buffer)->backBlue;

  XmuXdebug (debug_requests, "(cur=0x%lx) send (# 0x%lx)...done\n",
	     req->cursor, NextRequest (dpy) - 1);
}

int
ProcChangeKeyboardMapping (dpy, buffer)	/* 100 */
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  Data (dpy, buffer, REQUEST_LENGTH (buffer));

  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);

}

int
ProcChangeKeyboardControl (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  Data (dpy, buffer, REQUEST_LENGTH (buffer));

  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcBell (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xBellReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (Bell, req);
  req->percent = ((xBellReq *) buffer)->percent;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcChangePointerControl (dpy, buffer)	/* 105 */
  Display *dpy;
  char *buffer;
{
  register xChangePointerControlReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ChangePointerControl, req);
  req->doAccel = ((xChangePointerControlReq *) buffer)->doAccel;
  req->doThresh = ((xChangePointerControlReq *) buffer)->doThresh;
  req->accelNum = ((xChangePointerControlReq *) buffer)->accelNum;
  req->accelDenum = ((xChangePointerControlReq *) buffer)->accelDenum;
  req->threshold = ((xChangePointerControlReq *) buffer)->threshold;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcSetScreenSaver (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetScreenSaverReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (SetScreenSaver, req);
  req->timeout = ((xSetScreenSaverReq *) buffer)->timeout;
  req->interval = ((xSetScreenSaverReq *) buffer)->interval;
  req->preferBlank = ((xSetScreenSaverReq *) buffer)->preferBlank;
  req->allowExpose = ((xSetScreenSaverReq *) buffer)->allowExpose;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcChangeHosts (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  Data (dpy, buffer, REQUEST_LENGTH (buffer));

  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);

}

int
ProcChangeAccessControl (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetAccessControlReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (SetAccessControl, req);
  req->mode = ((xSetAccessControlReq *) buffer)->mode;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);

}

int
ProcChangeCloseDownMode (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xSetCloseDownModeReq *req;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (SetCloseDownMode, req);
  req->mode = ((xSetCloseDownModeReq *) buffer)->mode;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);

}

int
ProcKillClient (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xResourceReq *req;

  XmuXdebug (debug_requests, "Handle request %s\n",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetResReq (KillClient,
	     XmuXMapID (dpy,
			((xResourceReq *) buffer)->id, FromClient),
	     req);
  XmuXdebug (debug_requests, "(res=0x%lx) send (# 0x%lx)...done\n",
	     req->id, NextRequest (dpy) - 1);

}

int
ProcRotateProperties (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  register xRotatePropertiesReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  req = (xRotatePropertiesReq *) Xmalloc (REQUEST_LENGTH (buffer));
  if (req == NULL) {
    XmuXErrorF ("Can' t allocate memory!\n");
    return;
  }
  bcopy (buffer, (char *) req, REQUEST_LENGTH (buffer));
  req->window = XmuXMapID (dpy, req->window, FromClient);
  XmuXdebug (debug_requests, "(win=0x%lx) send (# 0x%lx)...",
	     req->window, NextRequest (dpy) - 1);
  Data (dpy, (char *) req, REQUEST_LENGTH (buffer));
  XmuXdebug (debug_requests, "done\n");

  Xfree ((char *) req);
}

int
ProcForceScreenSaver (dpy, buffer)	/* 115 */
  Display *dpy;
  char *buffer;
{
  register xForceScreenSaverReq *req;

  XmuXdebug (debug_requests, "Handle request %s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetReq (ForceScreenSaver, req);
  req->mode = ((xForceScreenSaverReq *) buffer)->mode;
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcNoOperation (dpy, buffer)	/* 127 */
  Display *dpy;
  char *buffer;
{
  register xReq *req;

  XmuXdebug (debug_requests, "%s...",
	     X11RequestNames[((xReq *) buffer)->reqType]);

  GetEmptyReq (NoOperation, req);
  XmuXdebug (debug_requests, "send (# 0x%lx)...done\n",
	     NextRequest (dpy) - 1);
}

int
ProcNotImplemented (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXErrorF (" Oops! Request %d currently not implemented!\n",
	      ((xReq *) buffer)->reqType);
}


int
Dummy (dpy, buffer)
  Display *dpy;
  char *buffer;
{
  XmuXdebug (debug_requests, "%s...done\n",
	     X11RequestNames[((xReq *) buffer)->reqType]);

}