xkb: use REQUEST_HEAD_STRUCT and REQUEST_FIELD_* macros

Use the new macros to make request struct parsing / field swapping
much easier.

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>

xkb/meson.build

@@ -12,7 +12,6 @@ srcs_xkb = [
     'xkbUtils.c',
     'xkbEvents.c',
     'xkbAccessX.c',
-    'xkbSwap.c',
     'xkbLEDs.c',
     'xkbInit.c',
     'xkbActions.c',

xkb/xkb.c

@@ -33,6 +33,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #include <X11/extensions/XKMformat.h>
 
 #include "dix/dix_priv.h"
+#include "dix/request_priv.h"
 #include "os/osdep.h"
 #include "xkb/xkbfmisc_priv.h"
 
@@ -172,10 +173,13 @@ _XkbCheckRequestBounds(ClientPtr client, void *stuff, void *from, void *to) {
 int
 ProcXkbUseExtension(ClientPtr client)
 {
-    REQUEST(xkbUseExtensionReq);
+    REQUEST_HEAD_STRUCT(xkbUseExtensionReq);
+    REQUEST_SIZE_MATCH(xkbUseExtensionReq);
+    REQUEST_FIELD_CARD16(wantedMajor);
+    REQUEST_FIELD_CARD16(wantedMinor);
+
     int supported;
 
-    REQUEST_SIZE_MATCH(xkbUseExtensionReq);
     if (stuff->wantedMajor != SERVER_XKB_MAJOR_VERSION) {
         /* pre-release version 0.65 is compatible with 1.00 */
         supported = ((SERVER_XKB_MAJOR_VERSION == 1) &&
@@ -218,14 +222,19 @@ ProcXkbUseExtension(ClientPtr client)
 int
 ProcXkbSelectEvents(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSelectEventsReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(affectWhich);
+    REQUEST_FIELD_CARD16(clear);
+    REQUEST_FIELD_CARD16(selectAll);
+    REQUEST_FIELD_CARD16(affectMap);
+    REQUEST_FIELD_CARD16(map);
+    /* more swapping done down below */
+
     unsigned legal;
     DeviceIntPtr dev;
     XkbInterestPtr masks;
 
-    REQUEST(xkbSelectEventsReq);
-
-    REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -247,11 +256,7 @@ ProcXkbSelectEvents(ClientPtr client)
         masks = XkbAddClientResource((DevicePtr) dev, client, id);
     }
     if (masks) {
-        union {
+        union { CARD8 *c8; CARD16 *c16; CARD32 *c32; } from, to;
-            CARD8 *c8;
-            CARD16 *c16;
-            CARD32 *c32;
-        } from, to;
         register unsigned bit, ndx, maskLeft, dataLeft, size;
 
         from.c8 = (CARD8 *) &stuff[1];
@@ -342,12 +347,14 @@ ProcXkbSelectEvents(ClientPtr client)
                 if (dataLeft < (size * 2))
                     return BadLength;
                 if (size == 2) {
+                    CLIENT_STRUCT_CARD16_2(&from, c16[0], c16[1]);
                     CHK_MASK_MATCH(ndx, from.c16[0], from.c16[1]);
                     CHK_MASK_LEGAL(ndx, from.c16[0], legal);
                     to.c16[0] &= ~from.c16[0];
                     to.c16[0] |= (from.c16[0] & from.c16[1]);
                 }
                 else if (size == 4) {
+                    REQUEST_BUF_CARD32(from.c32, 2);
                     CHK_MASK_MATCH(ndx, from.c32[0], from.c32[1]);
                     CHK_MASK_LEGAL(ndx, from.c32[0], legal);
                     to.c32[0] &= ~from.c32[0];
@@ -492,13 +499,19 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
 int
 ProcXkbBell(ClientPtr client)
 {
-    REQUEST(xkbBellReq);
+    REQUEST_HEAD_STRUCT(xkbBellReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(bellClass);
+    REQUEST_FIELD_CARD16(bellID);
+    REQUEST_FIELD_CARD32(name);
+    REQUEST_FIELD_CARD32(window);
+    REQUEST_FIELD_CARD16(pitch);
+    REQUEST_FIELD_CARD16(duration);
+
     DeviceIntPtr dev;
     WindowPtr pWin;
     int rc;
 
-    REQUEST_SIZE_MATCH(xkbBellReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -580,12 +593,12 @@ ProcXkbBell(ClientPtr client)
 int
 ProcXkbGetState(ClientPtr client)
 {
-    REQUEST(xkbGetStateReq);
+    REQUEST_HEAD_STRUCT(xkbGetStateReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+
     DeviceIntPtr dev;
     XkbStateRec *xkb;
 
-    REQUEST_SIZE_MATCH(xkbGetStateReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -621,6 +634,10 @@ ProcXkbGetState(ClientPtr client)
 int
 ProcXkbLatchLockState(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbLatchLockStateReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(groupLatch);
+
     int status;
     DeviceIntPtr dev, tmpd;
     XkbStateRec oldState, *newState;
@@ -628,9 +645,6 @@ ProcXkbLatchLockState(ClientPtr client)
     xkbStateNotify sn;
     XkbEventCauseRec cause;
 
-    REQUEST(xkbLatchLockStateReq);
-    REQUEST_SIZE_MATCH(xkbLatchLockStateReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -691,12 +705,12 @@ ProcXkbLatchLockState(ClientPtr client)
 int
 ProcXkbGetControls(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetControlsReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+
     XkbControlsPtr xkb;
     DeviceIntPtr dev;
 
-    REQUEST(xkbGetControlsReq);
-    REQUEST_SIZE_MATCH(xkbGetControlsReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -766,6 +780,31 @@ ProcXkbGetControls(ClientPtr client)
 int
 ProcXkbSetControls(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbSetControlsReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(affectInternalVMods);
+    REQUEST_FIELD_CARD16(internalVMods);
+    REQUEST_FIELD_CARD16(affectIgnoreLockVMods);
+    REQUEST_FIELD_CARD16(ignoreLockVMods);
+    REQUEST_FIELD_CARD16(axOptions);
+    REQUEST_FIELD_CARD32(affectEnabledCtrls);
+    REQUEST_FIELD_CARD32(enabledCtrls);
+    REQUEST_FIELD_CARD32(changeCtrls);
+    REQUEST_FIELD_CARD16(repeatDelay);
+    REQUEST_FIELD_CARD16(repeatInterval);
+    REQUEST_FIELD_CARD16(slowKeysDelay);
+    REQUEST_FIELD_CARD16(debounceDelay);
+    REQUEST_FIELD_CARD16(mkDelay);
+    REQUEST_FIELD_CARD16(mkInterval);
+    REQUEST_FIELD_CARD16(mkTimeToMax);
+    REQUEST_FIELD_CARD16(mkMaxSpeed);
+    REQUEST_FIELD_CARD16(mkCurve);
+    REQUEST_FIELD_CARD16(axTimeout);
+    REQUEST_FIELD_CARD32(axtCtrlsMask);
+    REQUEST_FIELD_CARD32(axtCtrlsValues);
+    REQUEST_FIELD_CARD16(axtOptsMask);
+    REQUEST_FIELD_CARD16(axtOptsValues);
+
     DeviceIntPtr dev, tmpd;
     XkbSrvInfoPtr xkbi;
     XkbControlsPtr ctrl;
@@ -774,9 +813,6 @@ ProcXkbSetControls(ClientPtr client)
     XkbEventCauseRec cause;
     XkbSrvLedInfoPtr sli;
 
-    REQUEST(xkbSetControlsReq);
-    REQUEST_SIZE_MATCH(xkbSetControlsReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -1435,13 +1471,16 @@ XkbAssembleMap(ClientPtr client, XkbDescPtr xkb, xkbGetMapReply rep, char *desc)
 int
 ProcXkbGetMap(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(full);
+    REQUEST_FIELD_CARD16(partial);
+    REQUEST_FIELD_CARD16(virtualMods);
+
     DeviceIntPtr dev;
     XkbDescRec *xkb;
     int n, status;
 
-    REQUEST(xkbGetMapReq);
-    REQUEST_SIZE_MATCH(xkbGetMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -2682,13 +2721,18 @@ _XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, char *values)
 int
 ProcXkbSetMap(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(present);
+    REQUEST_FIELD_CARD16(flags);
+    REQUEST_FIELD_CARD16(totalSyms);
+    REQUEST_FIELD_CARD16(totalActs);
+    REQUEST_FIELD_CARD16(virtualMods);
+
     DeviceIntPtr dev, master;
     char *tmp;
     int rc;
 
-    REQUEST(xkbSetMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -2843,13 +2887,15 @@ XkbAssembleCompatMap(ClientPtr client,
 int
 ProcXkbGetCompatMap(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetCompatMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(firstSI);
+    REQUEST_FIELD_CARD16(nSI);
+
     DeviceIntPtr dev;
     XkbDescPtr xkb;
     XkbCompatMapPtr compat;
 
-    REQUEST(xkbGetCompatMapReq);
-    REQUEST_SIZE_MATCH(xkbGetCompatMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3057,13 +3103,15 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetCompatMap(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetCompatMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(firstSI);
+    REQUEST_FIELD_CARD16(nSI);
+
     DeviceIntPtr dev;
     char *data;
     int rc;
 
-    REQUEST(xkbSetCompatMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3120,12 +3168,12 @@ ProcXkbSetCompatMap(ClientPtr client)
 int
 ProcXkbGetIndicatorState(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetIndicatorStateReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+
     XkbSrvLedInfoPtr sli;
     DeviceIntPtr dev;
 
-    REQUEST(xkbGetIndicatorStateReq);
-    REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3206,13 +3254,14 @@ XkbAssembleIndicatorMap(ClientPtr client,
 int
 ProcXkbGetIndicatorMap(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetIndicatorMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(which);
+
     DeviceIntPtr dev;
     XkbDescPtr xkb;
     XkbIndicatorPtr leds;
 
-    REQUEST(xkbGetIndicatorMapReq);
-    REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3298,15 +3347,16 @@ _XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetIndicatorMap(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetIndicatorMapReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(which);
+
     int i, bit;
     int nIndicators;
     DeviceIntPtr dev;
     xkbIndicatorMapWireDesc *from;
     int rc;
 
-    REQUEST(xkbSetIndicatorMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3364,14 +3414,17 @@ ProcXkbSetIndicatorMap(ClientPtr client)
 int
 ProcXkbGetNamedIndicator(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetNamedIndicatorReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(ledClass);
+    REQUEST_FIELD_CARD16(ledID);
+    REQUEST_FIELD_CARD32(indicator);
+
     DeviceIntPtr dev;
     register int i = 0;
     XkbSrvLedInfoPtr sli;
     XkbIndicatorMapPtr map = NULL;
 
-    REQUEST(xkbGetNamedIndicatorReq);
-    REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3565,14 +3618,19 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetNamedIndicator(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbSetNamedIndicatorReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(ledClass);
+    REQUEST_FIELD_CARD16(ledID);
+    REQUEST_FIELD_CARD32(indicator);
+    REQUEST_FIELD_CARD16(virtualMods);
+    REQUEST_FIELD_CARD32(ctrls);
+
     int rc;
     DeviceIntPtr dev;
     int led = 0;
     XkbIndicatorMapPtr map;
 
-    REQUEST(xkbSetNamedIndicatorReq);
-    REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -3881,12 +3939,13 @@ XkbAssembleNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply rep, char *b
 int
 ProcXkbGetNames(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetNamesReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(which);
+
     DeviceIntPtr dev;
     XkbDescPtr xkb;
 
-    REQUEST(xkbGetNamesReq);
-    REQUEST_SIZE_MATCH(xkbGetNamesReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -4333,14 +4392,18 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq * stuff)
 int
 ProcXkbSetNames(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetNamesReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(virtualMods);
+    REQUEST_FIELD_CARD32(which);
+    REQUEST_FIELD_CARD32(indicators);
+    REQUEST_FIELD_CARD16(totalKTLevelNames);
+
     DeviceIntPtr dev;
     CARD32 *tmp;
     Atom bad;
     int rc;
 
-    REQUEST(xkbSetNamesReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetNamesReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -4942,14 +5005,15 @@ XkbAssembleGeometry(ClientPtr client,
 int
 ProcXkbGetGeometry(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetGeometryReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(name);
+
     DeviceIntPtr dev;
     XkbGeometryPtr geom;
     Bool shouldFree;
     Status status;
 
-    REQUEST(xkbGetGeometryReq);
-    REQUEST_SIZE_MATCH(xkbGetGeometryReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -5546,12 +5610,19 @@ _XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
 int
 ProcXkbSetGeometry(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetGeometryReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(name);
+    REQUEST_FIELD_CARD16(widthMM);
+    REQUEST_FIELD_CARD16(heightMM);
+    REQUEST_FIELD_CARD16(nProperties);
+    REQUEST_FIELD_CARD16(nColors);
+    REQUEST_FIELD_CARD16(nDoodads);
+    REQUEST_FIELD_CARD16(nKeyAliases);
+
     DeviceIntPtr dev;
     int rc;
 
-    REQUEST(xkbSetGeometryReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -5583,13 +5654,18 @@ ProcXkbSetGeometry(ClientPtr client)
 int
 ProcXkbPerClientFlags(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbPerClientFlagsReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD32(change);
+    REQUEST_FIELD_CARD32(value);
+    REQUEST_FIELD_CARD32(ctrlsToChange);
+    REQUEST_FIELD_CARD32(autoCtrls);
+    REQUEST_FIELD_CARD32(autoCtrlValues);
+
     DeviceIntPtr dev;
     XkbInterestPtr interest;
     Mask access_mode = DixGetAttrAccess | DixSetAttrAccess;
 
-    REQUEST(xkbPerClientFlagsReq);
-    REQUEST_SIZE_MATCH(xkbPerClientFlagsReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -5728,15 +5804,16 @@ GetComponentSpec(ClientPtr client, xkbGetKbdByNameReq *stuff,
 int
 ProcXkbListComponents(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbListComponentsReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(maxNames);
+
     DeviceIntPtr dev;
     unsigned len;
     unsigned char *str;
     uint8_t size;
     int i;
 
-    REQUEST(xkbListComponentsReq);
-    REQUEST_AT_LEAST_SIZE(xkbListComponentsReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -5815,6 +5892,11 @@ XkbConvertGetByNameComponents(Bool toXkm, unsigned orig)
 int
 ProcXkbGetKbdByName(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbGetKbdByNameReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(want);
+    REQUEST_FIELD_CARD16(need);
+
     DeviceIntPtr dev;
     DeviceIntPtr tmpd;
     DeviceIntPtr master;
@@ -5830,9 +5912,6 @@ ProcXkbGetKbdByName(ClientPtr client)
     XkbSrvLedInfoPtr sli;
     Mask access_mode = DixGetAttrAccess | DixManageAccess;
 
-    REQUEST(xkbGetKbdByNameReq);
-    REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -6423,15 +6502,18 @@ FillDeviceLedFBs(DeviceIntPtr dev, int class, int id, unsigned wantLength,
 int
 ProcXkbGetDeviceInfo(ClientPtr client)
 {
+    REQUEST_HEAD_STRUCT(xkbGetDeviceInfoReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(wanted);
+    REQUEST_FIELD_CARD16(ledClass);
+    REQUEST_FIELD_CARD16(ledID);
+
     DeviceIntPtr dev;
     int status;
     unsigned length, nameLen;
     CARD16 ledClass, ledID;
     unsigned wanted;
 
-    REQUEST(xkbGetDeviceInfoReq);
-    REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -6843,12 +6925,14 @@ _XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
 int
 ProcXkbSetDeviceInfo(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetDeviceInfoReq);
+    REQUEST_FIELD_CARD16(deviceSpec);
+    REQUEST_FIELD_CARD16(change);
+    REQUEST_FIELD_CARD16(nDeviceLedFBs);
+
     DeviceIntPtr dev;
     int rc;
 
-    REQUEST(xkbSetDeviceInfoReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq);
-
     if (!(client->xkbClientFlags & _XkbClientInitialized))
         return BadAccess;
 
@@ -6911,12 +6995,16 @@ ProcXkbSetDeviceInfo(ClientPtr client)
 int
 ProcXkbSetDebuggingFlags(ClientPtr client)
 {
+    REQUEST_HEAD_AT_LEAST(xkbSetDebuggingFlagsReq);
+    REQUEST_FIELD_CARD32(affectFlags);
+    REQUEST_FIELD_CARD32(flags);
+    REQUEST_FIELD_CARD32(affectCtrls);
+    REQUEST_FIELD_CARD32(ctrls);
+    REQUEST_FIELD_CARD16(msgLength);
+
     CARD32 newFlags, newCtrls, extraLength;
     int rc;
 
-    REQUEST(xkbSetDebuggingFlagsReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq);
-
     rc = XaceHookServerAccess(client, DixDebugAccess);
     if (rc != Success)
         return rc;
@@ -7061,7 +7149,7 @@ XkbExtensionInit(void)
         return;
 
     if ((extEntry = AddExtension(XkbName, XkbNumberEvents, XkbNumberErrors,
-                                 ProcXkbDispatch, SProcXkbDispatch,
+                                 ProcXkbDispatch, ProcXkbDispatch,
                                  NULL, StandardMinorOpcode))) {
         XkbReqCode = (unsigned char) extEntry->base;
         XkbEventBase = (unsigned char) extEntry->eventBase;

xkb/xkbSwap.c

@@ -1,486 +0,0 @@
-/************************************************************
-Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
-
-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 Silicon Graphics not be
-used in advertising or publicity pertaining to distribution
-of the software without specific prior written permission.
-Silicon Graphics makes no representation about the suitability
-of this software for any purpose. It is provided "as is"
-without any express or implied warranty.
-
-SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
-GRAPHICS 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 <dix-config.h>
-
-#include "stdio.h"
-#include <X11/X.h>
-#include <X11/Xproto.h>
-#include "misc.h"
-#include "inputstr.h"
-#include <xkbsrv.h>
-#include "xkbstr.h"
-#include "extnsionst.h"
-#include "xkb-procs.h"
-
-        /*
-         * REQUEST SWAPPING
-         */
-static int _X_COLD
-SProcXkbUseExtension(ClientPtr client)
-{
-    REQUEST(xkbUseExtensionReq);
-    REQUEST_SIZE_MATCH(xkbUseExtensionReq);
-    swaps(&stuff->wantedMajor);
-    swaps(&stuff->wantedMinor);
-    return ProcXkbUseExtension(client);
-}
-
-static int _X_COLD
-SProcXkbSelectEvents(ClientPtr client)
-{
-    REQUEST(xkbSelectEventsReq);
-    REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->affectWhich);
-    swaps(&stuff->clear);
-    swaps(&stuff->selectAll);
-    swaps(&stuff->affectMap);
-    swaps(&stuff->map);
-    if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) {
-        union {
-            BOOL *b;
-            CARD8 *c8;
-            CARD16 *c16;
-            CARD32 *c32;
-        } from;
-        register unsigned bit, ndx, maskLeft, dataLeft;
-
-        from.c8 = (CARD8 *) &stuff[1];
-        dataLeft = (client->req_len * 4) - sizeof(xkbSelectEventsReq);
-        maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask));
-        for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) {
-            if (((bit & maskLeft) == 0) || (ndx == XkbMapNotify))
-                continue;
-            maskLeft &= ~bit;
-            if ((stuff->selectAll & bit) || (stuff->clear & bit))
-                continue;
-            switch (ndx) {
-            // CARD16
-            case XkbNewKeyboardNotify:
-            case XkbStateNotify:
-            case XkbNamesNotify:
-            case XkbAccessXNotify:
-            case XkbExtensionDeviceNotify:
-                if (dataLeft < sizeof(CARD16)*2)
-                    return BadLength;
-                swaps(&from.c16[0]);
-                swaps(&from.c16[1]);
-                from.c8 += sizeof(CARD16)*2;
-                dataLeft -= sizeof(CARD16)*2;
-                break;
-            // CARD32
-            case XkbControlsNotify:
-            case XkbIndicatorStateNotify:
-            case XkbIndicatorMapNotify:
-                if (dataLeft < sizeof(CARD32)*2)
-                    return BadLength;
-                swapl(&from.c32[0]);
-                swapl(&from.c32[1]);
-                from.c8 += sizeof(CARD32)*2;
-                dataLeft -= sizeof(CARD32)*2;
-                break;
-            // CARD8
-            case XkbBellNotify:
-            case XkbActionMessage:
-            case XkbCompatMapNotify:
-                if (dataLeft < 2)
-                    return BadLength;
-                from.c8 += 4;
-                dataLeft -= 4;
-                break;
-            default:
-                client->errorValue = _XkbErrCode2(0x1, bit);
-                return BadValue;
-            }
-        }
-        if (dataLeft > 2) {
-            ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n",
-                   dataLeft);
-            return BadLength;
-        }
-    }
-    return ProcXkbSelectEvents(client);
-}
-
-static int _X_COLD
-SProcXkbBell(ClientPtr client)
-{
-    REQUEST(xkbBellReq);
-    REQUEST_SIZE_MATCH(xkbBellReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->bellClass);
-    swaps(&stuff->bellID);
-    swapl(&stuff->name);
-    swapl(&stuff->window);
-    swaps(&stuff->pitch);
-    swaps(&stuff->duration);
-    return ProcXkbBell(client);
-}
-
-static int _X_COLD
-SProcXkbGetState(ClientPtr client)
-{
-    REQUEST(xkbGetStateReq);
-    REQUEST_SIZE_MATCH(xkbGetStateReq);
-    swaps(&stuff->deviceSpec);
-    return ProcXkbGetState(client);
-}
-
-static int _X_COLD
-SProcXkbLatchLockState(ClientPtr client)
-{
-    REQUEST(xkbLatchLockStateReq);
-    REQUEST_SIZE_MATCH(xkbLatchLockStateReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->groupLatch);
-    return ProcXkbLatchLockState(client);
-}
-
-static int _X_COLD
-SProcXkbGetControls(ClientPtr client)
-{
-    REQUEST(xkbGetControlsReq);
-    REQUEST_SIZE_MATCH(xkbGetControlsReq);
-    swaps(&stuff->deviceSpec);
-    return ProcXkbGetControls(client);
-}
-
-static int _X_COLD
-SProcXkbSetControls(ClientPtr client)
-{
-    REQUEST(xkbSetControlsReq);
-    REQUEST_SIZE_MATCH(xkbSetControlsReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->affectInternalVMods);
-    swaps(&stuff->internalVMods);
-    swaps(&stuff->affectIgnoreLockVMods);
-    swaps(&stuff->ignoreLockVMods);
-    swaps(&stuff->axOptions);
-    swapl(&stuff->affectEnabledCtrls);
-    swapl(&stuff->enabledCtrls);
-    swapl(&stuff->changeCtrls);
-    swaps(&stuff->repeatDelay);
-    swaps(&stuff->repeatInterval);
-    swaps(&stuff->slowKeysDelay);
-    swaps(&stuff->debounceDelay);
-    swaps(&stuff->mkDelay);
-    swaps(&stuff->mkInterval);
-    swaps(&stuff->mkTimeToMax);
-    swaps(&stuff->mkMaxSpeed);
-    swaps(&stuff->mkCurve);
-    swaps(&stuff->axTimeout);
-    swapl(&stuff->axtCtrlsMask);
-    swapl(&stuff->axtCtrlsValues);
-    swaps(&stuff->axtOptsMask);
-    swaps(&stuff->axtOptsValues);
-    return ProcXkbSetControls(client);
-}
-
-static int _X_COLD
-SProcXkbGetMap(ClientPtr client)
-{
-    REQUEST(xkbGetMapReq);
-    REQUEST_SIZE_MATCH(xkbGetMapReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->full);
-    swaps(&stuff->partial);
-    swaps(&stuff->virtualMods);
-    return ProcXkbGetMap(client);
-}
-
-static int _X_COLD
-SProcXkbSetMap(ClientPtr client)
-{
-    REQUEST(xkbSetMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetMapReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->present);
-    swaps(&stuff->flags);
-    swaps(&stuff->totalSyms);
-    swaps(&stuff->totalActs);
-    swaps(&stuff->virtualMods);
-    return ProcXkbSetMap(client);
-}
-
-static int _X_COLD
-SProcXkbGetCompatMap(ClientPtr client)
-{
-    REQUEST(xkbGetCompatMapReq);
-    REQUEST_SIZE_MATCH(xkbGetCompatMapReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->firstSI);
-    swaps(&stuff->nSI);
-    return ProcXkbGetCompatMap(client);
-}
-
-static int _X_COLD
-SProcXkbSetCompatMap(ClientPtr client)
-{
-    REQUEST(xkbSetCompatMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->firstSI);
-    swaps(&stuff->nSI);
-    return ProcXkbSetCompatMap(client);
-}
-
-static int _X_COLD
-SProcXkbGetIndicatorState(ClientPtr client)
-{
-    REQUEST(xkbGetIndicatorStateReq);
-    REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq);
-    swaps(&stuff->deviceSpec);
-    return ProcXkbGetIndicatorState(client);
-}
-
-static int _X_COLD
-SProcXkbGetIndicatorMap(ClientPtr client)
-{
-    REQUEST(xkbGetIndicatorMapReq);
-    REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->which);
-    return ProcXkbGetIndicatorMap(client);
-}
-
-static int _X_COLD
-SProcXkbSetIndicatorMap(ClientPtr client)
-{
-    REQUEST(xkbSetIndicatorMapReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->which);
-    return ProcXkbSetIndicatorMap(client);
-}
-
-static int _X_COLD
-SProcXkbGetNamedIndicator(ClientPtr client)
-{
-    REQUEST(xkbGetNamedIndicatorReq);
-    REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->ledClass);
-    swaps(&stuff->ledID);
-    swapl(&stuff->indicator);
-    return ProcXkbGetNamedIndicator(client);
-}
-
-static int _X_COLD
-SProcXkbSetNamedIndicator(ClientPtr client)
-{
-    REQUEST(xkbSetNamedIndicatorReq);
-    REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->ledClass);
-    swaps(&stuff->ledID);
-    swapl(&stuff->indicator);
-    swaps(&stuff->virtualMods);
-    swapl(&stuff->ctrls);
-    return ProcXkbSetNamedIndicator(client);
-}
-
-static int _X_COLD
-SProcXkbGetNames(ClientPtr client)
-{
-    REQUEST(xkbGetNamesReq);
-    REQUEST_SIZE_MATCH(xkbGetNamesReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->which);
-    return ProcXkbGetNames(client);
-}
-
-static int _X_COLD
-SProcXkbSetNames(ClientPtr client)
-{
-    REQUEST(xkbSetNamesReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetNamesReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->virtualMods);
-    swapl(&stuff->which);
-    swapl(&stuff->indicators);
-    swaps(&stuff->totalKTLevelNames);
-    return ProcXkbSetNames(client);
-}
-
-static int _X_COLD
-SProcXkbGetGeometry(ClientPtr client)
-{
-    REQUEST(xkbGetGeometryReq);
-    REQUEST_SIZE_MATCH(xkbGetGeometryReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->name);
-    return ProcXkbGetGeometry(client);
-}
-
-static int _X_COLD
-SProcXkbSetGeometry(ClientPtr client)
-{
-    REQUEST(xkbSetGeometryReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->name);
-    swaps(&stuff->widthMM);
-    swaps(&stuff->heightMM);
-    swaps(&stuff->nProperties);
-    swaps(&stuff->nColors);
-    swaps(&stuff->nDoodads);
-    swaps(&stuff->nKeyAliases);
-    return ProcXkbSetGeometry(client);
-}
-
-static int _X_COLD
-SProcXkbPerClientFlags(ClientPtr client)
-{
-    REQUEST(xkbPerClientFlagsReq);
-    REQUEST_SIZE_MATCH(xkbPerClientFlagsReq);
-    swaps(&stuff->deviceSpec);
-    swapl(&stuff->change);
-    swapl(&stuff->value);
-    swapl(&stuff->ctrlsToChange);
-    swapl(&stuff->autoCtrls);
-    swapl(&stuff->autoCtrlValues);
-    return ProcXkbPerClientFlags(client);
-}
-
-static int _X_COLD
-SProcXkbListComponents(ClientPtr client)
-{
-    REQUEST(xkbListComponentsReq);
-    REQUEST_AT_LEAST_SIZE(xkbListComponentsReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->maxNames);
-    return ProcXkbListComponents(client);
-}
-
-static int _X_COLD
-SProcXkbGetKbdByName(ClientPtr client)
-{
-    REQUEST(xkbGetKbdByNameReq);
-    REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->want);
-    swaps(&stuff->need);
-    return ProcXkbGetKbdByName(client);
-}
-
-static int _X_COLD
-SProcXkbGetDeviceInfo(ClientPtr client)
-{
-    REQUEST(xkbGetDeviceInfoReq);
-    REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->wanted);
-    swaps(&stuff->ledClass);
-    swaps(&stuff->ledID);
-    return ProcXkbGetDeviceInfo(client);
-}
-
-static int _X_COLD
-SProcXkbSetDeviceInfo(ClientPtr client)
-{
-    REQUEST(xkbSetDeviceInfoReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq);
-    swaps(&stuff->deviceSpec);
-    swaps(&stuff->change);
-    swaps(&stuff->nDeviceLedFBs);
-    return ProcXkbSetDeviceInfo(client);
-}
-
-static int _X_COLD
-SProcXkbSetDebuggingFlags(ClientPtr client)
-{
-    REQUEST(xkbSetDebuggingFlagsReq);
-    REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq);
-    swapl(&stuff->affectFlags);
-    swapl(&stuff->flags);
-    swapl(&stuff->affectCtrls);
-    swapl(&stuff->ctrls);
-    swaps(&stuff->msgLength);
-    return ProcXkbSetDebuggingFlags(client);
-}
-
-int _X_COLD
-SProcXkbDispatch(ClientPtr client)
-{
-    REQUEST(xReq);
-    switch (stuff->data) {
-    case X_kbUseExtension:
-        return SProcXkbUseExtension(client);
-    case X_kbSelectEvents:
-        return SProcXkbSelectEvents(client);
-    case X_kbBell:
-        return SProcXkbBell(client);
-    case X_kbGetState:
-        return SProcXkbGetState(client);
-    case X_kbLatchLockState:
-        return SProcXkbLatchLockState(client);
-    case X_kbGetControls:
-        return SProcXkbGetControls(client);
-    case X_kbSetControls:
-        return SProcXkbSetControls(client);
-    case X_kbGetMap:
-        return SProcXkbGetMap(client);
-    case X_kbSetMap:
-        return SProcXkbSetMap(client);
-    case X_kbGetCompatMap:
-        return SProcXkbGetCompatMap(client);
-    case X_kbSetCompatMap:
-        return SProcXkbSetCompatMap(client);
-    case X_kbGetIndicatorState:
-        return SProcXkbGetIndicatorState(client);
-    case X_kbGetIndicatorMap:
-        return SProcXkbGetIndicatorMap(client);
-    case X_kbSetIndicatorMap:
-        return SProcXkbSetIndicatorMap(client);
-    case X_kbGetNamedIndicator:
-        return SProcXkbGetNamedIndicator(client);
-    case X_kbSetNamedIndicator:
-        return SProcXkbSetNamedIndicator(client);
-    case X_kbGetNames:
-        return SProcXkbGetNames(client);
-    case X_kbSetNames:
-        return SProcXkbSetNames(client);
-    case X_kbGetGeometry:
-        return SProcXkbGetGeometry(client);
-    case X_kbSetGeometry:
-        return SProcXkbSetGeometry(client);
-    case X_kbPerClientFlags:
-        return SProcXkbPerClientFlags(client);
-    case X_kbListComponents:
-        return SProcXkbListComponents(client);
-    case X_kbGetKbdByName:
-        return SProcXkbGetKbdByName(client);
-    case X_kbGetDeviceInfo:
-        return SProcXkbGetDeviceInfo(client);
-    case X_kbSetDeviceInfo:
-        return SProcXkbSetDeviceInfo(client);
-    case X_kbSetDebuggingFlags:
-        return SProcXkbSetDebuggingFlags(client);
-    default:
-        return BadRequest;
-    }
-}