XLibre/xserver
1
1
Fork 0
mirror of https://github.com/X11Libre/xserver.git synced 2026-03-24 03:44:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

xkb: use REQUEST_HEAD_STRUCT and REQUEST_FIELD_* macros

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

Signed-off-by: Enrico Weigelt, metux IT consult <info@metux.net>
This commit is contained in:
Enrico Weigelt, metux IT consult
2024-07-15 18:03:25 +02:00
committed by Enrico Weigelt
parent 08e62055ce
commit 3780ef3ef1
1 changed files with 140 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

377
xkb/xkb.c
View File

@@ -171,13 +171,9 @@ _XkbCheckRequestBounds(ClientPtr client, void *stuff, void *from, void *to) {
int int
ProcXkbUseExtension(ClientPtr client) ProcXkbUseExtension(ClientPtr client)
{ {
REQUEST(xkbUseExtensionReq); X_REQUEST_HEAD_STRUCT(xkbUseExtensionReq);
REQUEST_SIZE_MATCH(xkbUseExtensionReq); X_REQUEST_FIELD_CARD16(wantedMajor);
X_REQUEST_FIELD_CARD16(wantedMinor);
if (client->swapped) {
swaps(&stuff->wantedMajor);
swaps(&stuff->wantedMinor);
}
int supported; int supported;
@@ -218,16 +214,16 @@ ProcXkbUseExtension(ClientPtr client)
int int
ProcXkbSelectEvents(ClientPtr client) ProcXkbSelectEvents(ClientPtr client)
{ {
REQUEST(xkbSelectEventsReq); X_REQUEST_HEAD_AT_LEAST(xkbSelectEventsReq);
REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(affectWhich);
X_REQUEST_FIELD_CARD16(clear);
X_REQUEST_FIELD_CARD16(selectAll);
X_REQUEST_FIELD_CARD16(affectMap);
X_REQUEST_FIELD_CARD16(map);
/* more swapping done down below */
if (client->swapped) { if (client->swapped) {
swaps(&stuff->deviceSpec);
swaps(&stuff->affectWhich);
swaps(&stuff->clear);
swaps(&stuff->selectAll);
swaps(&stuff->affectMap);
swaps(&stuff->map);
if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) { if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) {
union { union {
BOOL *b; BOOL *b;
@@ -561,18 +557,14 @@ _XkbBell(ClientPtr client, DeviceIntPtr dev, WindowPtr pWin,
int int
ProcXkbBell(ClientPtr client) ProcXkbBell(ClientPtr client)
{ {
REQUEST(xkbBellReq); X_REQUEST_HEAD_STRUCT(xkbBellReq);
REQUEST_SIZE_MATCH(xkbBellReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(bellClass);
if (client->swapped) { X_REQUEST_FIELD_CARD16(bellID);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD32(name);
swaps(&stuff->bellClass); X_REQUEST_FIELD_CARD32(window);
swaps(&stuff->bellID); X_REQUEST_FIELD_CARD16(pitch);
swapl(&stuff->name); X_REQUEST_FIELD_CARD16(duration);
swapl(&stuff->window);
swaps(&stuff->pitch);
swaps(&stuff->duration);
}
DeviceIntPtr dev; DeviceIntPtr dev;
WindowPtr pWin; WindowPtr pWin;
@@ -657,11 +649,8 @@ ProcXkbBell(ClientPtr client)
int int
ProcXkbGetState(ClientPtr client) ProcXkbGetState(ClientPtr client)
{ {
REQUEST(xkbGetStateReq); X_REQUEST_HEAD_STRUCT(xkbGetStateReq);
REQUEST_SIZE_MATCH(xkbGetStateReq); X_REQUEST_FIELD_CARD16(deviceSpec);
if (client->swapped)
swaps(&stuff->deviceSpec);
DeviceIntPtr dev; DeviceIntPtr dev;
XkbStateRec *xkb; XkbStateRec *xkb;
@@ -696,13 +685,9 @@ ProcXkbGetState(ClientPtr client)
int int
ProcXkbLatchLockState(ClientPtr client) ProcXkbLatchLockState(ClientPtr client)
{ {
REQUEST(xkbLatchLockStateReq); X_REQUEST_HEAD_STRUCT(xkbLatchLockStateReq);
REQUEST_SIZE_MATCH(xkbLatchLockStateReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(groupLatch);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swaps(&stuff->groupLatch);
}
if (!(client->xkbClientFlags & _XkbClientInitialized)) if (!(client->xkbClientFlags & _XkbClientInitialized))
return BadAccess; return BadAccess;
@@ -766,11 +751,8 @@ ProcXkbLatchLockState(ClientPtr client)
int int
ProcXkbGetControls(ClientPtr client) ProcXkbGetControls(ClientPtr client)
{ {
REQUEST(xkbGetControlsReq); X_REQUEST_HEAD_STRUCT(xkbGetControlsReq);
REQUEST_SIZE_MATCH(xkbGetControlsReq); X_REQUEST_FIELD_CARD16(deviceSpec);
if (client->swapped)
swaps(&stuff->deviceSpec);
XkbControlsPtr xkb; XkbControlsPtr xkb;
DeviceIntPtr dev; DeviceIntPtr dev;
@@ -838,34 +820,30 @@ ProcXkbGetControls(ClientPtr client)
int int
ProcXkbSetControls(ClientPtr client) ProcXkbSetControls(ClientPtr client)
{ {
REQUEST(xkbSetControlsReq); X_REQUEST_HEAD_STRUCT(xkbSetControlsReq);
REQUEST_SIZE_MATCH(xkbSetControlsReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(affectInternalVMods);
if (client->swapped) { X_REQUEST_FIELD_CARD16(internalVMods);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD16(affectIgnoreLockVMods);
swaps(&stuff->affectInternalVMods); X_REQUEST_FIELD_CARD16(ignoreLockVMods);
swaps(&stuff->internalVMods); X_REQUEST_FIELD_CARD16(axOptions);
swaps(&stuff->affectIgnoreLockVMods); X_REQUEST_FIELD_CARD32(affectEnabledCtrls);
swaps(&stuff->ignoreLockVMods); X_REQUEST_FIELD_CARD32(enabledCtrls);
swaps(&stuff->axOptions); X_REQUEST_FIELD_CARD32(changeCtrls);
swapl(&stuff->affectEnabledCtrls); X_REQUEST_FIELD_CARD16(repeatDelay);
swapl(&stuff->enabledCtrls); X_REQUEST_FIELD_CARD16(repeatInterval);
swapl(&stuff->changeCtrls); X_REQUEST_FIELD_CARD16(slowKeysDelay);
swaps(&stuff->repeatDelay); X_REQUEST_FIELD_CARD16(debounceDelay);
swaps(&stuff->repeatInterval); X_REQUEST_FIELD_CARD16(mkDelay);
swaps(&stuff->slowKeysDelay); X_REQUEST_FIELD_CARD16(mkInterval);
swaps(&stuff->debounceDelay); X_REQUEST_FIELD_CARD16(mkTimeToMax);
swaps(&stuff->mkDelay); X_REQUEST_FIELD_CARD16(mkMaxSpeed);
swaps(&stuff->mkInterval); X_REQUEST_FIELD_CARD16(mkCurve);
swaps(&stuff->mkTimeToMax); X_REQUEST_FIELD_CARD16(axTimeout);
swaps(&stuff->mkMaxSpeed); X_REQUEST_FIELD_CARD32(axtCtrlsMask);
swaps(&stuff->mkCurve); X_REQUEST_FIELD_CARD32(axtCtrlsValues);
swaps(&stuff->axTimeout); X_REQUEST_FIELD_CARD16(axtOptsMask);
swapl(&stuff->axtCtrlsMask); X_REQUEST_FIELD_CARD16(axtOptsValues);
swapl(&stuff->axtCtrlsValues);
swaps(&stuff->axtOptsMask);
swaps(&stuff->axtOptsValues);
}
DeviceIntPtr dev, tmpd; DeviceIntPtr dev, tmpd;
XkbSrvInfoPtr xkbi; XkbSrvInfoPtr xkbi;
@@ -1482,15 +1460,11 @@ static void XkbAssembleMap(ClientPtr client, XkbDescPtr xkb,
int int
ProcXkbGetMap(ClientPtr client) ProcXkbGetMap(ClientPtr client)
{ {
REQUEST(xkbGetMapReq); X_REQUEST_HEAD_STRUCT(xkbGetMapReq);
REQUEST_SIZE_MATCH(xkbGetMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(full);
if (client->swapped) { X_REQUEST_FIELD_CARD16(partial);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD16(virtualMods);
swaps(&stuff->full);
swaps(&stuff->partial);
swaps(&stuff->virtualMods);
}
if (!(client->xkbClientFlags & _XkbClientInitialized)) if (!(client->xkbClientFlags & _XkbClientInitialized))
return BadAccess; return BadAccess;
@@ -2723,17 +2697,13 @@ _XkbSetMap(ClientPtr client, DeviceIntPtr dev, xkbSetMapReq * req, char *values)
int int
ProcXkbSetMap(ClientPtr client) ProcXkbSetMap(ClientPtr client)
{ {
REQUEST(xkbSetMapReq); X_REQUEST_HEAD_AT_LEAST(xkbSetMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(present);
if (client->swapped) { X_REQUEST_FIELD_CARD16(flags);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD16(totalSyms);
swaps(&stuff->present); X_REQUEST_FIELD_CARD16(totalActs);
swaps(&stuff->flags); X_REQUEST_FIELD_CARD16(virtualMods);
swaps(&stuff->totalSyms);
swaps(&stuff->totalActs);
swaps(&stuff->virtualMods);
}
DeviceIntPtr dev, master; DeviceIntPtr dev, master;
char *tmp; char *tmp;
@@ -2882,14 +2852,10 @@ XkbAssembleCompatMap(ClientPtr client,
int int
ProcXkbGetCompatMap(ClientPtr client) ProcXkbGetCompatMap(ClientPtr client)
{ {
REQUEST(xkbGetCompatMapReq); X_REQUEST_HEAD_STRUCT(xkbGetCompatMapReq);
REQUEST_SIZE_MATCH(xkbGetCompatMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(firstSI);
if (client->swapped) { X_REQUEST_FIELD_CARD16(nSI);
swaps(&stuff->deviceSpec);
swaps(&stuff->firstSI);
swaps(&stuff->nSI);
}
if (!(client->xkbClientFlags & _XkbClientInitialized)) if (!(client->xkbClientFlags & _XkbClientInitialized))
return BadAccess; return BadAccess;
@@ -3095,14 +3061,10 @@ _XkbSetCompatMap(ClientPtr client, DeviceIntPtr dev,
int int
ProcXkbSetCompatMap(ClientPtr client) ProcXkbSetCompatMap(ClientPtr client)
{ {
REQUEST(xkbSetCompatMapReq); X_REQUEST_HEAD_AT_LEAST(xkbSetCompatMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(firstSI);
if (client->swapped) { X_REQUEST_FIELD_CARD16(nSI);
swaps(&stuff->deviceSpec);
swaps(&stuff->firstSI);
swaps(&stuff->nSI);
}
DeviceIntPtr dev; DeviceIntPtr dev;
char *data; char *data;
@@ -3162,11 +3124,8 @@ ProcXkbSetCompatMap(ClientPtr client)
int int
ProcXkbGetIndicatorState(ClientPtr client) ProcXkbGetIndicatorState(ClientPtr client)
{ {
REQUEST(xkbGetIndicatorStateReq); X_REQUEST_HEAD_STRUCT(xkbGetIndicatorStateReq);
REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq); X_REQUEST_FIELD_CARD16(deviceSpec);
if (client->swapped)
swaps(&stuff->deviceSpec);
XkbSrvLedInfoPtr sli; XkbSrvLedInfoPtr sli;
DeviceIntPtr dev; DeviceIntPtr dev;
@@ -3237,13 +3196,9 @@ XkbAssembleIndicatorMap(ClientPtr client,
int int
ProcXkbGetIndicatorMap(ClientPtr client) ProcXkbGetIndicatorMap(ClientPtr client)
{ {
REQUEST(xkbGetIndicatorMapReq); X_REQUEST_HEAD_STRUCT(xkbGetIndicatorMapReq);
REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(which);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swapl(&stuff->which);
}
DeviceIntPtr dev; DeviceIntPtr dev;
XkbDescPtr xkb; XkbDescPtr xkb;
@@ -3327,13 +3282,9 @@ _XkbSetIndicatorMap(ClientPtr client, DeviceIntPtr dev,
int int
ProcXkbSetIndicatorMap(ClientPtr client) ProcXkbSetIndicatorMap(ClientPtr client)
{ {
REQUEST(xkbSetIndicatorMapReq); X_REQUEST_HEAD_AT_LEAST(xkbSetIndicatorMapReq);
REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(which);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swapl(&stuff->which);
}
int i, bit; int i, bit;
int nIndicators; int nIndicators;
@@ -3396,15 +3347,11 @@ ProcXkbSetIndicatorMap(ClientPtr client)
int int
ProcXkbGetNamedIndicator(ClientPtr client) ProcXkbGetNamedIndicator(ClientPtr client)
{ {
REQUEST(xkbGetNamedIndicatorReq); X_REQUEST_HEAD_STRUCT(xkbGetNamedIndicatorReq);
REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(ledClass);
if (client->swapped) { X_REQUEST_FIELD_CARD16(ledID);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD32(indicator);
swaps(&stuff->ledClass);
swaps(&stuff->ledID);
swapl(&stuff->indicator);
}
DeviceIntPtr dev; DeviceIntPtr dev;
register int i = 0; register int i = 0;
@@ -3599,17 +3546,13 @@ _XkbSetNamedIndicator(ClientPtr client, DeviceIntPtr dev,
int int
ProcXkbSetNamedIndicator(ClientPtr client) ProcXkbSetNamedIndicator(ClientPtr client)
{ {
REQUEST(xkbSetNamedIndicatorReq); X_REQUEST_HEAD_STRUCT(xkbSetNamedIndicatorReq);
REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(ledClass);
if (client->swapped) { X_REQUEST_FIELD_CARD16(ledID);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD32(indicator);
swaps(&stuff->ledClass); X_REQUEST_FIELD_CARD16(virtualMods);
swaps(&stuff->ledID); X_REQUEST_FIELD_CARD32(ctrls);
swapl(&stuff->indicator);
swaps(&stuff->virtualMods);
swapl(&stuff->ctrls);
}
int rc; int rc;
DeviceIntPtr dev; DeviceIntPtr dev;
@@ -3890,13 +3833,9 @@ XkbAssembleNames(ClientPtr client, XkbDescPtr xkb, xkbGetNamesReply rep, x_rpcbu
int int
ProcXkbGetNames(ClientPtr client) ProcXkbGetNames(ClientPtr client)
{ {
REQUEST(xkbGetNamesReq); X_REQUEST_HEAD_STRUCT(xkbGetNamesReq);
REQUEST_SIZE_MATCH(xkbGetNamesReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(which);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swapl(&stuff->which);
}
DeviceIntPtr dev; DeviceIntPtr dev;
XkbDescPtr xkb; XkbDescPtr xkb;
@@ -4338,16 +4277,12 @@ _XkbSetNames(ClientPtr client, DeviceIntPtr dev, xkbSetNamesReq * stuff)
int int
ProcXkbSetNames(ClientPtr client) ProcXkbSetNames(ClientPtr client)
{ {
REQUEST(xkbSetNamesReq); X_REQUEST_HEAD_AT_LEAST(xkbSetNamesReq);
REQUEST_AT_LEAST_SIZE(xkbSetNamesReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(virtualMods);
if (client->swapped) { X_REQUEST_FIELD_CARD32(which);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD32(indicators);
swaps(&stuff->virtualMods); X_REQUEST_FIELD_CARD16(totalKTLevelNames);
swapl(&stuff->which);
swapl(&stuff->indicators);
swaps(&stuff->totalKTLevelNames);
}
DeviceIntPtr dev; DeviceIntPtr dev;
CARD32 *tmp; CARD32 *tmp;
@@ -4894,13 +4829,9 @@ XkbAssembleGeometry(ClientPtr client,
int int
ProcXkbGetGeometry(ClientPtr client) ProcXkbGetGeometry(ClientPtr client)
{ {
REQUEST(xkbGetGeometryReq); X_REQUEST_HEAD_STRUCT(xkbGetGeometryReq);
REQUEST_SIZE_MATCH(xkbGetGeometryReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(name);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swapl(&stuff->name);
}
DeviceIntPtr dev; DeviceIntPtr dev;
XkbGeometryPtr geom; XkbGeometryPtr geom;
@@ -5490,19 +5421,15 @@ _XkbSetGeometry(ClientPtr client, DeviceIntPtr dev, xkbSetGeometryReq * stuff)
int int
ProcXkbSetGeometry(ClientPtr client) ProcXkbSetGeometry(ClientPtr client)
{ {
REQUEST(xkbSetGeometryReq); X_REQUEST_HEAD_AT_LEAST(xkbSetGeometryReq);
REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(name);
if (client->swapped) { X_REQUEST_FIELD_CARD16(widthMM);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD16(heightMM);
swapl(&stuff->name); X_REQUEST_FIELD_CARD16(nProperties);
swaps(&stuff->widthMM); X_REQUEST_FIELD_CARD16(nColors);
swaps(&stuff->heightMM); X_REQUEST_FIELD_CARD16(nDoodads);
swaps(&stuff->nProperties); X_REQUEST_FIELD_CARD16(nKeyAliases);
swaps(&stuff->nColors);
swaps(&stuff->nDoodads);
swaps(&stuff->nKeyAliases);
}
DeviceIntPtr dev; DeviceIntPtr dev;
int rc; int rc;
@@ -5536,17 +5463,13 @@ ProcXkbSetGeometry(ClientPtr client)
int int
ProcXkbPerClientFlags(ClientPtr client) ProcXkbPerClientFlags(ClientPtr client)
{ {
REQUEST(xkbPerClientFlagsReq); X_REQUEST_HEAD_STRUCT(xkbPerClientFlagsReq);
REQUEST_SIZE_MATCH(xkbPerClientFlagsReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD32(change);
if (client->swapped) { X_REQUEST_FIELD_CARD32(value);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD32(ctrlsToChange);
swapl(&stuff->change); X_REQUEST_FIELD_CARD32(autoCtrls);
swapl(&stuff->value); X_REQUEST_FIELD_CARD32(autoCtrlValues);
swapl(&stuff->ctrlsToChange);
swapl(&stuff->autoCtrls);
swapl(&stuff->autoCtrlValues);
}
DeviceIntPtr dev; DeviceIntPtr dev;
XkbInterestPtr interest; XkbInterestPtr interest;
@@ -5684,13 +5607,9 @@ GetComponentSpec(ClientPtr client, xkbGetKbdByNameReq *stuff,
int int
ProcXkbListComponents(ClientPtr client) ProcXkbListComponents(ClientPtr client)
{ {
REQUEST(xkbListComponentsReq); X_REQUEST_HEAD_AT_LEAST(xkbListComponentsReq);
REQUEST_AT_LEAST_SIZE(xkbListComponentsReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(maxNames);
if (client->swapped) {
swaps(&stuff->deviceSpec);
swaps(&stuff->maxNames);
}
DeviceIntPtr dev; DeviceIntPtr dev;
unsigned len; unsigned len;
@@ -5769,14 +5688,10 @@ XkbConvertGetByNameComponents(Bool toXkm, unsigned orig)
int int
ProcXkbGetKbdByName(ClientPtr client) ProcXkbGetKbdByName(ClientPtr client)
{ {
REQUEST(xkbGetKbdByNameReq); X_REQUEST_HEAD_AT_LEAST(xkbGetKbdByNameReq);
REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(want);
if (client->swapped) { X_REQUEST_FIELD_CARD16(need);
swaps(&stuff->deviceSpec);
swaps(&stuff->want);
swaps(&stuff->need);
}
DeviceIntPtr dev; DeviceIntPtr dev;
DeviceIntPtr tmpd; DeviceIntPtr tmpd;
@@ -6371,15 +6286,11 @@ FillDeviceLedFBs(DeviceIntPtr dev, int class, int id, unsigned wantLength,
int int
ProcXkbGetDeviceInfo(ClientPtr client) ProcXkbGetDeviceInfo(ClientPtr client)
{ {
REQUEST(xkbGetDeviceInfoReq); X_REQUEST_HEAD_STRUCT(xkbGetDeviceInfoReq);
REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(wanted);
if (client->swapped) { X_REQUEST_FIELD_CARD16(ledClass);
swaps(&stuff->deviceSpec); X_REQUEST_FIELD_CARD16(ledID);
swaps(&stuff->wanted);
swaps(&stuff->ledClass);
swaps(&stuff->ledID);
}
DeviceIntPtr dev; DeviceIntPtr dev;
int status; int status;
@@ -6799,14 +6710,10 @@ _XkbSetDeviceInfo(ClientPtr client, DeviceIntPtr dev,
int int
ProcXkbSetDeviceInfo(ClientPtr client) ProcXkbSetDeviceInfo(ClientPtr client)
{ {
REQUEST(xkbSetDeviceInfoReq); X_REQUEST_HEAD_AT_LEAST(xkbSetDeviceInfoReq);
REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq); X_REQUEST_FIELD_CARD16(deviceSpec);
X_REQUEST_FIELD_CARD16(change);
if (client->swapped) { X_REQUEST_FIELD_CARD16(nDeviceLedFBs);
swaps(&stuff->deviceSpec);
swaps(&stuff->change);
swaps(&stuff->nDeviceLedFBs);
}
DeviceIntPtr dev; DeviceIntPtr dev;
int rc; int rc;
@@ -6871,16 +6778,12 @@ ProcXkbSetDeviceInfo(ClientPtr client)
int int
ProcXkbSetDebuggingFlags(ClientPtr client) ProcXkbSetDebuggingFlags(ClientPtr client)
{ {
REQUEST(xkbSetDebuggingFlagsReq); X_REQUEST_HEAD_AT_LEAST(xkbSetDebuggingFlagsReq);
REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq); X_REQUEST_FIELD_CARD32(affectFlags);
X_REQUEST_FIELD_CARD32(flags);
if (client->swapped) { X_REQUEST_FIELD_CARD32(affectCtrls);
swapl(&stuff->affectFlags); X_REQUEST_FIELD_CARD32(ctrls);
swapl(&stuff->flags); X_REQUEST_FIELD_CARD16(msgLength);
swapl(&stuff->affectCtrls);
swapl(&stuff->ctrls);
swaps(&stuff->msgLength);
}
CARD32 newFlags, newCtrls, extraLength; CARD32 newFlags, newCtrls, extraLength;
int rc; int rc;