git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/Xext/xf86misc.c

   1 /* $XFree86: xc/programs/Xserver/Xext/xf86misc.c,v 3.21.2.4 1998/02/25 14:26:43 dawes Exp $ */
   2
   3 /*
   4  * Copyright (c) 1995, 1996  The XFree86 Project, Inc
   5  */
   6
   7 /* THIS IS NOT AN X CONSORTIUM STANDARD */
   8
   9 #define NEED_REPLIES
  10 #define NEED_EVENTS
  11 #include "X.h"
  12 #include "Xproto.h"
  13 #include "misc.h"
  14 #include "dixstruct.h"
  15 #include "extnsionst.h"
  16 #include "scrnintstr.h"
  17 #include "inputstr.h"
  18 #include "servermd.h"
  19 #define _XF86MISC_SERVER_
  20 #define _XF86MISC_SAVER_COMPAT_
  21 #include "xf86mscstr.h"
  22 #include "Xfuncproto.h"
  23 #include "xf86.h"
  24 #include "xf86Priv.h"
  25 #include "xf86_OSlib.h"
  26
  27 #include <X11/Xtrans.h>
  28 #include "../os/osdep.h"
  29 #include <X11/Xauth.h>
  30 #ifndef ESIX
  31 #ifndef Lynx
  32 #include <sys/socket.h>
  33 #else
  34 #include <socket.h>
  35 #endif
  36 #else
  37 #include <lan/socket.h>
  38 #endif
  39
  40 #include "swaprep.h"
  41
  42 extern int xf86ScreenIndex;
  43 extern Bool xf86MiscModInDevEnabled;
  44 extern Bool xf86MiscModInDevAllowNonLocal;
  45
  46 static int miscErrorBase;
  47
  48 static void XF86MiscResetProc(
  49 #if NeedFunctionPrototypes
  50     ExtensionEntry* /* extEntry */
  51 #endif
  52 );
  53
  54 static DISPATCH_PROC(ProcXF86MiscDispatch);
  55 static DISPATCH_PROC(ProcXF86MiscGetKbdSettings);
  56 static DISPATCH_PROC(ProcXF86MiscGetMouseSettings);
  57 static DISPATCH_PROC(ProcXF86MiscGetSaver);
  58 static DISPATCH_PROC(ProcXF86MiscQueryVersion);
  59 static DISPATCH_PROC(ProcXF86MiscSetKbdSettings);
  60 static DISPATCH_PROC(ProcXF86MiscSetMouseSettings);
  61 static DISPATCH_PROC(ProcXF86MiscSetSaver);
  62 static DISPATCH_PROC(SProcXF86MiscDispatch);
  63 static DISPATCH_PROC(SProcXF86MiscGetKbdSettings);
  64 static DISPATCH_PROC(SProcXF86MiscGetMouseSettings);
  65 static DISPATCH_PROC(SProcXF86MiscGetSaver);
  66 static DISPATCH_PROC(SProcXF86MiscQueryVersion);
  67 static DISPATCH_PROC(SProcXF86MiscSetKbdSettings);
  68 static DISPATCH_PROC(SProcXF86MiscSetMouseSettings);
  69 static DISPATCH_PROC(SProcXF86MiscSetSaver);
  70
  71 static unsigned char XF86MiscReqCode = 0;
  72
  73 extern InputInfo inputInfo;
  74
  75 void
  76 XFree86MiscExtensionInit()
  77 {
  78     ExtensionEntry* extEntry;
  79
  80     if (
  81         (extEntry = AddExtension(XF86MISCNAME,
  82                                 XF86MiscNumberEvents,
  83                                 XF86MiscNumberErrors,
  84                                 ProcXF86MiscDispatch,
  85                                 SProcXF86MiscDispatch,
  86                                 XF86MiscResetProc,
  87                                 StandardMinorOpcode))) {
  88         XF86MiscReqCode = (unsigned char)extEntry->base;
  89         miscErrorBase = extEntry->errorBase;
  90     }
  91 }
  92
  93 /*ARGSUSED*/
  94 static void
  95 XF86MiscResetProc (extEntry)
  96     ExtensionEntry* extEntry;
  97 {
  98 }
  99
 100 static int
 101 ProcXF86MiscQueryVersion(client)
 102     register ClientPtr client;
 103 {
 104     xXF86MiscQueryVersionReply rep;
 105     register int n;
 106
 107     REQUEST_SIZE_MATCH(xXF86MiscQueryVersionReq);
 108     rep.type = X_Reply;
 109     rep.length = 0;
 110     rep.sequenceNumber = client->sequence;
 111     rep.majorVersion = XF86MISC_MAJOR_VERSION;
 112     rep.minorVersion = XF86MISC_MINOR_VERSION;
 113     if (client->swapped) {
 114         swaps(&rep.sequenceNumber, n);
 115         swapl(&rep.length, n);
 116         swaps(&rep.majorVersion, n);
 117         swaps(&rep.minorVersion, n);
 118     }
 119     WriteToClient(client, sizeof(xXF86MiscQueryVersionReply), (char *)&rep);
 120     return (client->noClientException);
 121 }
 122
 123 /*
 124  * This will go away, but remains for now for compatibility with older
 125  * clients.
 126  */
 127 static int
 128 ProcXF86MiscSetSaver(client)
 129     register ClientPtr client;
 130 {
 131     REQUEST(xXF86MiscSetSaverReq);
 132     ScrnInfoPtr vptr;
 133
 134     if (stuff->screen > screenInfo.numScreens)
 135         return BadValue;
 136
 137     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 138
 139     REQUEST_SIZE_MATCH(xXF86MiscSetSaverReq);
 140
 141     if (stuff->suspendTime < 0)
 142         return BadValue;
 143     if (stuff->offTime < 0)
 144         return BadValue;
 145
 146     return (client->noClientException);
 147 }
 148
 149 /*
 150  * This will go away, but remains for now for compatibility with older
 151  * clients.
 152  */
 153 static int
 154 ProcXF86MiscGetSaver(client)
 155     register ClientPtr client;
 156 {
 157     REQUEST(xXF86MiscGetSaverReq);
 158     xXF86MiscGetSaverReply rep;
 159     register int n;
 160     ScrnInfoPtr vptr;
 161
 162     if (stuff->screen > screenInfo.numScreens)
 163         return BadValue;
 164
 165     vptr = (ScrnInfoPtr) screenInfo.screens[stuff->screen]->devPrivates[xf86ScreenIndex].ptr;
 166
 167     REQUEST_SIZE_MATCH(xXF86MiscGetSaverReq);
 168     rep.type = X_Reply;
 169     rep.length = 0;
 170     rep.sequenceNumber = client->sequence;
 171     rep.suspendTime = 0;
 172     rep.offTime = 0;
 173
 174     if (client->swapped) {
 175         swaps(&rep.sequenceNumber, n);
 176         swapl(&rep.length, n);
 177         swapl(&rep.suspendTime, n);
 178         swapl(&rep.offTime, n);
 179     }
 180     WriteToClient(client, SIZEOF(xXF86MiscGetSaverReply), (char *)&rep);
 181     return (client->noClientException);
 182 }
 183
 184 static int
 185 ProcXF86MiscGetMouseSettings(client)
 186     register ClientPtr client;
 187 {
 188     xXF86MiscGetMouseSettingsReply rep;
 189     register int n;
 190
 191     REQUEST_SIZE_MATCH(xXF86MiscGetMouseSettingsReq);
 192     rep.type = X_Reply;
 193     rep.sequenceNumber = client->sequence;
 194     rep.mousetype = xf86Info.mouseDev->mseType;
 195 #ifdef XQUEUE
 196     if (xf86Info.mouseDev->mseProc == xf86XqueMseProc)
 197         rep.mousetype = MTYPE_XQUEUE;
 198 #endif
 199 #if defined(USE_OSMOUSE) || defined(OSMOUSE_ONLY)
 200     if (xf86Info.mouseDev->mseProc == xf86OsMouseProc)
 201         rep.mousetype = MTYPE_OSMOUSE;
 202 #endif
 203     rep.baudrate = xf86Info.mouseDev->baudRate;
 204     rep.samplerate = xf86Info.mouseDev->sampleRate;
 205     rep.resolution = xf86Info.mouseDev->resolution;
 206     rep.buttons = xf86Info.mouseDev->buttons;
 207     rep.emulate3buttons = xf86Info.mouseDev->emulate3Buttons;
 208     rep.emulate3timeout = xf86Info.mouseDev->emulate3Timeout;
 209     rep.chordmiddle = xf86Info.mouseDev->chordMiddle;
 210     rep.flags = xf86Info.mouseDev->mouseFlags;
 211     if (xf86Info.mouseDev->mseDevice)
 212         rep.devnamelen = strlen(xf86Info.mouseDev->mseDevice);
 213     else
 214         rep.devnamelen = 0;
 215     rep.length = (sizeof(xXF86MiscGetMouseSettingsReply) -
 216                   sizeof(xGenericReply) + ((rep.devnamelen+3) & ~3)) >> 2;
 217
 218     if (client->swapped) {
 219         swaps(&rep.sequenceNumber, n);
 220         swapl(&rep.length, n);
 221         swapl(&rep.mousetype, n);
 222         swapl(&rep.baudrate, n);
 223         swapl(&rep.samplerate, n);
 224         swapl(&rep.resolution, n);
 225         swapl(&rep.buttons, n);
 226         swapl(&rep.emulate3buttons, n);
 227         swapl(&rep.emulate3timeout, n);
 228         swapl(&rep.chordmiddle, n);
 229         swapl(&rep.flags, n);
 230     }
 231     WriteToClient(client, SIZEOF(xXF86MiscGetMouseSettingsReply), (char *)&rep);
 232     if (rep.devnamelen)
 233         WriteToClient(client, rep.devnamelen, xf86Info.mouseDev->mseDevice);
 234     return (client->noClientException);
 235 }
 236
 237 static int
 238 ProcXF86MiscGetKbdSettings(client)
 239     register ClientPtr client;
 240 {
 241     xXF86MiscGetKbdSettingsReply rep;
 242     register int n;
 243
 244     REQUEST_SIZE_MATCH(xXF86MiscGetKbdSettingsReq);
 245     rep.type = X_Reply;
 246     rep.length = 0;
 247     rep.sequenceNumber = client->sequence;
 248     rep.kbdtype = xf86Info.kbdType;
 249 #ifdef XQUEUE
 250     if (xf86Info.kbdProc == xf86XqueKbdProc)
 251         rep.kbdtype = KTYPE_XQUEUE;
 252 #endif
 253     rep.rate = xf86Info.kbdRate;
 254     rep.delay = xf86Info.kbdDelay;
 255     rep.servnumlock = xf86Info.serverNumLock;
 256     if (client->swapped) {
 257         swaps(&rep.sequenceNumber, n);
 258         swapl(&rep.length, n);
 259         swapl(&rep.kbdtype, n);
 260         swapl(&rep.rate, n);
 261         swapl(&rep.delay, n);
 262     }
 263     WriteToClient(client, SIZEOF(xXF86MiscGetKbdSettingsReply), (char *)&rep);
 264     return (client->noClientException);
 265 }
 266
 267 static int
 268 ProcXF86MiscSetMouseSettings(client)
 269     register ClientPtr client;
 270 {
 271     int reopen, msetype, flags, baudrate, samplerate, resolution;
 272
 273     REQUEST(xXF86MiscSetMouseSettingsReq);
 274
 275     REQUEST_SIZE_MATCH(xXF86MiscSetMouseSettingsReq);
 276
 277     if (xf86Verbose) {
 278         ErrorF("SetMouseSettings - type: %d brate: %d srate: %d chdmid: %d\n",
 279                 stuff->mousetype, stuff->baudrate,
 280                 stuff->samplerate, stuff->chordmiddle);
 281         ErrorF("                   em3but: %d em3tim: %d res: %d flags: %d\n",
 282                 stuff->emulate3buttons, stuff->emulate3timeout,
 283                 stuff->resolution, stuff->flags);
 284     }
 285     if (stuff->mousetype > MTYPE_OSMOUSE
 286             || stuff->mousetype < MTYPE_MICROSOFT)
 287         return miscErrorBase + XF86MiscBadMouseProtocol;
 288 #ifdef OSMOUSE_ONLY
 289     if (stuff->mousetype != MTYPE_OSMOUSE)
 290         return miscErrorBase + XF86MiscBadMouseProtocol;
 291 #else
 292 #ifndef XQUEUE
 293     if (stuff->mousetype == MTYPE_XQUEUE)
 294         return miscErrorBase + XF86MiscBadMouseProtocol;
 295 #endif
 296 #ifndef USE_OSMOUSE
 297     if (stuff->mousetype == MTYPE_OSMOUSE)
 298         return miscErrorBase + XF86MiscBadMouseProtocol;
 299 #endif
 300 #endif /* OSMOUSE_ONLY */
 301
 302     if (stuff->emulate3timeout < 0)
 303         return BadValue;
 304
 305     if (stuff->mousetype == MTYPE_LOGIMAN
 306             && !(stuff->baudrate == 1200 || stuff->baudrate == 9600) )
 307         return miscErrorBase + XF86MiscBadMouseBaudRate;
 308     if (stuff->mousetype == MTYPE_LOGIMAN && stuff->samplerate)
 309         return miscErrorBase + XF86MiscBadMouseCombo;
 310
 311     samplerate = xf86Info.mouseDev->sampleRate;
 312     resolution = xf86Info.mouseDev->resolution;
 313     baudrate   = xf86Info.mouseDev->baudRate;
 314     flags      = xf86Info.mouseDev->mouseFlags;
 315     msetype    = xf86Info.mouseDev->mseType;
 316 #ifdef XQUEUE
 317     if (xf86Info.mouseDev->mseProc == xf86XqueMseProc)
 318         msetype = MTYPE_XQUEUE;
 319 #endif
 320 #if defined(USE_OSMOUSE) || defined(OSMOUSE_ONLY)
 321     if (xf86Info.mouseDev->mseProc == xf86OsMouseProc)
 322         msetype = MTYPE_OSMOUSE;
 323 #endif
 324
 325     reopen     = 0;
 326
 327     if (stuff->mousetype != msetype)
 328         if (stuff->mousetype == MTYPE_XQUEUE
 329                 || stuff->mousetype == MTYPE_OSMOUSE
 330                 || msetype == MTYPE_XQUEUE
 331                 || msetype == MTYPE_OSMOUSE)
 332             return miscErrorBase + XF86MiscBadMouseProtocol;
 333         else {
 334             reopen++;
 335             msetype = stuff->mousetype;
 336         }
 337
 338     if (stuff->flags & MF_REOPEN) {
 339         reopen++;
 340         stuff->flags &= ~MF_REOPEN;
 341     }
 342     if (stuff->mousetype != MTYPE_OSMOUSE
 343             && stuff->mousetype != MTYPE_XQUEUE
 344             && stuff->mousetype != MTYPE_PS_2
 345             && stuff->mousetype != MTYPE_BUSMOUSE
 346             && stuff->mousetype != MTYPE_IMPS2
 347             && stuff->mousetype != MTYPE_THINKINGPS2
 348             && stuff->mousetype != MTYPE_MMANPLUSPS2
 349             && stuff->mousetype != MTYPE_GLIDEPOINTPS2
 350             && stuff->mousetype != MTYPE_NETPS2
 351             && stuff->mousetype != MTYPE_NETSCROLLPS2
 352             && stuff->mousetype != MTYPE_SYSMOUSE)
 353     {
 354         if (stuff->baudrate < 1200)
 355             return miscErrorBase + XF86MiscBadMouseBaudRate;
 356         if (stuff->baudrate % 1200 != 0
 357                 || stuff->baudrate < 1200 || stuff->baudrate > 9600)
 358             return miscErrorBase + XF86MiscBadMouseBaudRate;
 359         if (xf86Info.mouseDev->baudRate != stuff->baudrate) {
 360                 reopen++;
 361                 baudrate = stuff->baudrate;
 362         }
 363     }
 364     if (stuff->flags & (MF_CLEAR_DTR|MF_CLEAR_RTS))
 365         if (stuff->mousetype != MTYPE_MOUSESYS)
 366             return miscErrorBase + XF86MiscBadMouseFlags;
 367         else if (xf86Info.mouseDev->mouseFlags != stuff->flags) {
 368             reopen++;
 369             flags = stuff->flags;
 370         }
 371
 372     if (stuff->mousetype != MTYPE_OSMOUSE
 373             && stuff->mousetype != MTYPE_XQUEUE
 374             && stuff->mousetype != MTYPE_BUSMOUSE)
 375     {
 376         if (stuff->samplerate < 0)
 377             return BadValue;
 378
 379         if (xf86Info.mouseDev->sampleRate != stuff->samplerate) {
 380                 reopen++;
 381                 samplerate = stuff->samplerate;
 382         }
 383     }
 384
 385     if (stuff->resolution < 0)
 386         return BadValue;
 387     if (xf86Info.mouseDev->resolution != stuff->resolution) {
 388         reopen++;
 389         resolution = stuff->resolution;
 390     }
 391
 392 #if 0
 393     /* Ignore the buttons field */
 394     if (xf86Info.mouseDev->buttons != stuff->buttons)
 395         /* we cannot change this field on the fly... */
 396         return BadValue;
 397 #endif
 398
 399     if (stuff->chordmiddle)
 400         if (stuff->emulate3buttons
 401                 || !(stuff->mousetype == MTYPE_MICROSOFT
 402                      || stuff->mousetype == MTYPE_LOGIMAN) )
 403             return miscErrorBase + XF86MiscBadMouseCombo;
 404
 405     xf86Info.mouseDev->chordMiddle = stuff->chordmiddle!=0;
 406     xf86Info.mouseDev->emulate3Buttons = stuff->emulate3buttons!=0;
 407     xf86Info.mouseDev->emulate3Timeout = stuff->emulate3timeout;
 408
 409     if (reopen && msetype != MTYPE_OSMOUSE && msetype != MTYPE_XQUEUE) {
 410
 411         (xf86Info.mouseDev->mseProc)(xf86Info.pMouse, DEVICE_CLOSE);
 412
 413         xf86Info.mouseDev->mseType    = msetype;
 414         xf86Info.mouseDev->mouseFlags = flags;
 415         xf86Info.mouseDev->baudRate   = baudrate;
 416         xf86Info.mouseDev->sampleRate = samplerate;
 417         xf86Info.mouseDev->resolution = resolution;
 418
 419         xf86Info.pMouse->public.on = FALSE;
 420         xf86AllowMouseOpenFail = TRUE;
 421         xf86MouseInit(xf86Info.mouseDev);
 422         (xf86Info.mouseDev->mseProc)(xf86Info.pMouse, DEVICE_ON);
 423     }
 424
 425     if (xf86Verbose)
 426         ErrorF("SetMouseSettings - Succeeded\n");
 427     return (client->noClientException);
 428 }
 429
 430 static int
 431 ProcXF86MiscSetKbdSettings(client)
 432     register ClientPtr client;
 433 {
 434     REQUEST(xXF86MiscSetKbdSettingsReq);
 435
 436     REQUEST_SIZE_MATCH(xXF86MiscSetKbdSettingsReq);
 437
 438     if (xf86Verbose)
 439         ErrorF("SetKbdSettings - type: %d rate: %d delay: %d snumlk: %d\n",
 440                 stuff->kbdtype, stuff->rate,
 441                 stuff->delay, stuff->servnumlock);
 442     if (stuff->rate < 0)
 443         return BadValue;
 444     if (stuff->delay < 0)
 445         return BadValue;
 446     if (stuff->kbdtype < KTYPE_UNKNOWN || stuff->kbdtype > KTYPE_XQUEUE)
 447         return miscErrorBase + XF86MiscBadKbdType;
 448
 449     if (xf86Info.kbdRate!=stuff->rate || xf86Info.kbdDelay!=stuff->delay) {
 450         char rad;
 451
 452         xf86Info.kbdRate = stuff->rate;
 453         xf86Info.kbdDelay = stuff->delay;
 454         if      (xf86Info.kbdDelay <= 375) rad = 0x00;
 455         else if (xf86Info.kbdDelay <= 625) rad = 0x20;
 456         else if (xf86Info.kbdDelay <= 875) rad = 0x40;
 457         else                               rad = 0x60;
 458
 459         if      (xf86Info.kbdRate <=  2)   rad |= 0x1F;
 460         else if (xf86Info.kbdRate >= 30)   rad |= 0x00;
 461         else                               rad |= ((58/xf86Info.kbdRate)-2);
 462
 463         xf86SetKbdRepeat(rad);
 464     }
 465 #if 0   /* Not done yet */
 466     xf86Info.kbdType = stuff->kbdtype;
 467     xf86Info.serverNumLock = stuff->servnumlock!=0;
 468 #endif
 469
 470     if (xf86Verbose)
 471         ErrorF("SetKbdSettings - Succeeded\n");
 472     return (client->noClientException);
 473 }
 474
 475 static int
 476 ProcXF86MiscDispatch (client)
 477     register ClientPtr  client;
 478 {
 479     REQUEST(xReq);
 480     switch (stuff->data)
 481     {
 482     case X_XF86MiscQueryVersion:
 483         return ProcXF86MiscQueryVersion(client);
 484     case X_XF86MiscGetSaver:
 485         return ProcXF86MiscGetSaver(client);
 486     case X_XF86MiscSetSaver:
 487         return ProcXF86MiscSetSaver(client);
 488     case X_XF86MiscGetMouseSettings:
 489         return ProcXF86MiscGetMouseSettings(client);
 490     case X_XF86MiscGetKbdSettings:
 491         return ProcXF86MiscGetKbdSettings(client);
 492     default:
 493         if (!xf86MiscModInDevEnabled)
 494             return miscErrorBase + XF86MiscModInDevDisabled;
 495         if (xf86MiscModInDevAllowNonLocal || LocalClient (client)) {
 496             switch (stuff->data) {
 497                 case X_XF86MiscSetMouseSettings:
 498                     return ProcXF86MiscSetMouseSettings(client);
 499                 case X_XF86MiscSetKbdSettings:
 500                     return ProcXF86MiscSetKbdSettings(client);
 501                 default:
 502                     return BadRequest;
 503             }
 504         } else
 505             return miscErrorBase + XF86MiscModInDevClientNotLocal;
 506     }
 507 }
 508
 509 static int
 510 SProcXF86MiscQueryVersion(client)
 511     register ClientPtr  client;
 512 {
 513     register int n;
 514     REQUEST(xXF86MiscQueryVersionReq);
 515     swaps(&stuff->length, n);
 516     return ProcXF86MiscQueryVersion(client);
 517 }
 518
 519 static int
 520 SProcXF86MiscGetSaver(client)
 521     ClientPtr client;
 522 {
 523     register int n;
 524     REQUEST(xXF86MiscGetSaverReq);
 525     swaps(&stuff->length, n);
 526     REQUEST_SIZE_MATCH(xXF86MiscGetSaverReq);
 527     swaps(&stuff->screen, n);
 528     return ProcXF86MiscGetSaver(client);
 529 }
 530
 531 static int
 532 SProcXF86MiscSetSaver(client)
 533     ClientPtr client;
 534 {
 535     register int n;
 536     REQUEST(xXF86MiscSetSaverReq);
 537     swaps(&stuff->length, n);
 538     REQUEST_SIZE_MATCH(xXF86MiscSetSaverReq);
 539     swaps(&stuff->screen, n);
 540     swapl(&stuff->suspendTime, n);
 541     swapl(&stuff->offTime, n);
 542     return ProcXF86MiscSetSaver(client);
 543 }
 544
 545 static int
 546 SProcXF86MiscGetMouseSettings(client)
 547     ClientPtr client;
 548 {
 549     register int n;
 550     REQUEST(xXF86MiscGetMouseSettingsReq);
 551     swaps(&stuff->length, n);
 552     REQUEST_SIZE_MATCH(xXF86MiscGetMouseSettingsReq);
 553     return ProcXF86MiscGetMouseSettings(client);
 554 }
 555
 556 static int
 557 SProcXF86MiscGetKbdSettings(client)
 558     ClientPtr client;
 559 {
 560     register int n;
 561     REQUEST(xXF86MiscGetKbdSettingsReq);
 562     swaps(&stuff->length, n);
 563     REQUEST_SIZE_MATCH(xXF86MiscGetKbdSettingsReq);
 564     return ProcXF86MiscGetKbdSettings(client);
 565 }
 566
 567 static int
 568 SProcXF86MiscSetMouseSettings(client)
 569     ClientPtr client;
 570 {
 571     register int n;
 572     REQUEST(xXF86MiscSetMouseSettingsReq);
 573     swaps(&stuff->length, n);
 574     REQUEST_SIZE_MATCH(xXF86MiscSetMouseSettingsReq);
 575     swapl(&stuff->mousetype, n);
 576     swapl(&stuff->baudrate, n);
 577     swapl(&stuff->samplerate, n);
 578     swapl(&stuff->resolution, n);
 579     swapl(&stuff->buttons, n);
 580     swapl(&stuff->emulate3timeout, n);
 581     swapl(&stuff->flags, n);
 582     return ProcXF86MiscSetMouseSettings(client);
 583 }
 584
 585 static int
 586 SProcXF86MiscSetKbdSettings(client)
 587     ClientPtr client;
 588 {
 589     register int n;
 590     REQUEST(xXF86MiscSetKbdSettingsReq);
 591     swaps(&stuff->length, n);
 592     REQUEST_SIZE_MATCH(xXF86MiscSetKbdSettingsReq);
 593     swapl(&stuff->kbdtype, n);
 594     swapl(&stuff->rate, n);
 595     swapl(&stuff->delay, n);
 596     return ProcXF86MiscSetKbdSettings(client);
 597 }
 598
 599 static int
 600 SProcXF86MiscDispatch (client)
 601     register ClientPtr  client;
 602 {
 603     REQUEST(xReq);
 604     switch (stuff->data)
 605     {
 606     case X_XF86MiscQueryVersion:
 607         return SProcXF86MiscQueryVersion(client);
 608     case X_XF86MiscGetSaver:
 609         return SProcXF86MiscGetSaver(client);
 610     case X_XF86MiscSetSaver:
 611         return SProcXF86MiscSetSaver(client);
 612     case X_XF86MiscGetMouseSettings:
 613         return SProcXF86MiscGetMouseSettings(client);
 614     case X_XF86MiscGetKbdSettings:
 615         return SProcXF86MiscGetKbdSettings(client);
 616     default:
 617         if (!xf86MiscModInDevEnabled)
 618             return miscErrorBase + XF86MiscModInDevDisabled;
 619         if (xf86MiscModInDevAllowNonLocal || LocalClient (client)) {
 620             switch (stuff->data) {
 621                 case X_XF86MiscSetMouseSettings:
 622                     return SProcXF86MiscSetMouseSettings(client);
 623                 case X_XF86MiscSetKbdSettings:
 624                     return SProcXF86MiscSetKbdSettings(client);
 625                 default:
 626                     return BadRequest;
 627             }
 628         } else
 629             return miscErrorBase + XF86MiscModInDevClientNotLocal;
 630     }
 631 }
 632