From 71cbcb6f02d61529f2c270f438c89f748db85ec9 Mon Sep 17 00:00:00 2001 From: "Enrico Weigelt, metux IT consult" Date: Mon, 15 Jul 2024 18:03:25 +0200 Subject: [PATCH] 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 --- xkb/meson.build | 1 - xkb/xkb.c | 256 ++++++++++++++++--------- xkb/xkbSwap.c | 486 ------------------------------------------------ 3 files changed, 172 insertions(+), 571 deletions(-) delete mode 100644 xkb/xkbSwap.c diff --git a/xkb/meson.build b/xkb/meson.build index c21868c2b..6cf06f120 100644 --- a/xkb/meson.build +++ b/xkb/meson.build @@ -12,7 +12,6 @@ srcs_xkb = [ 'xkbUtils.c', 'xkbEvents.c', 'xkbAccessX.c', - 'xkbSwap.c', 'xkbLEDs.c', 'xkbInit.c', 'xkbActions.c', diff --git a/xkb/xkb.c b/xkb/xkb.c index 2410c6cc6..5563ef83f 100644 --- a/xkb/xkb.c +++ b/xkb/xkb.c @@ -33,6 +33,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE. #include #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 { - CARD8 *c8; - CARD16 *c16; - CARD32 *c32; - } from, to; + union { 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; diff --git a/xkb/xkbSwap.c b/xkb/xkbSwap.c deleted file mode 100644 index 9a4c17e57..000000000 --- a/xkb/xkbSwap.c +++ /dev/null @@ -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 - -#include "stdio.h" -#include -#include -#include "misc.h" -#include "inputstr.h" -#include -#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; - } -}