Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | /************************************************************ |
2 | Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. | |
3 | ||
4 | Permission to use, copy, modify, and distribute this | |
5 | software and its documentation for any purpose and without | |
6 | fee is hereby granted, provided that the above copyright | |
7 | notice appear in all copies and that both that copyright | |
8 | notice and this permission notice appear in supporting | |
9 | documentation, and that the name of Silicon Graphics not be | |
10 | used in advertising or publicity pertaining to distribution | |
11 | of the software without specific prior written permission. | |
12 | Silicon Graphics makes no representation about the suitability | |
13 | of this software for any purpose. It is provided "as is" | |
14 | without any express or implied warranty. | |
15 | ||
16 | SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS | |
17 | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY | |
18 | AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON | |
19 | GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL | |
20 | DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, | |
21 | DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE | |
22 | OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH | |
23 | THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
24 | ||
25 | ********************************************************/ | |
26 | ||
27 | #ifdef HAVE_DIX_CONFIG_H | |
28 | #include <dix-config.h> | |
29 | #endif | |
30 | ||
31 | #include "stdio.h" | |
32 | #include <X11/X.h> | |
33 | #include <X11/Xproto.h> | |
34 | #include "misc.h" | |
35 | #include "inputstr.h" | |
36 | #include <xkbsrv.h> | |
37 | #include "xkbstr.h" | |
38 | #include "extnsionst.h" | |
39 | #include "xkb.h" | |
40 | ||
41 | /* | |
42 | * REQUEST SWAPPING | |
43 | */ | |
44 | static int | |
45 | SProcXkbUseExtension(ClientPtr client) | |
46 | { | |
47 | REQUEST(xkbUseExtensionReq); | |
48 | ||
49 | swaps(&stuff->length); | |
50 | REQUEST_SIZE_MATCH(xkbUseExtensionReq); | |
51 | swaps(&stuff->wantedMajor); | |
52 | swaps(&stuff->wantedMinor); | |
53 | return ProcXkbUseExtension(client); | |
54 | } | |
55 | ||
56 | static int | |
57 | SProcXkbSelectEvents(ClientPtr client) | |
58 | { | |
59 | REQUEST(xkbSelectEventsReq); | |
60 | ||
61 | swaps(&stuff->length); | |
62 | REQUEST_AT_LEAST_SIZE(xkbSelectEventsReq); | |
63 | swaps(&stuff->deviceSpec); | |
64 | swaps(&stuff->affectWhich); | |
65 | swaps(&stuff->clear); | |
66 | swaps(&stuff->selectAll); | |
67 | swaps(&stuff->affectMap); | |
68 | swaps(&stuff->map); | |
69 | if ((stuff->affectWhich & (~XkbMapNotifyMask)) != 0) { | |
70 | union { | |
71 | BOOL *b; | |
72 | CARD8 *c8; | |
73 | CARD16 *c16; | |
74 | CARD32 *c32; | |
75 | } from; | |
76 | register unsigned bit, ndx, maskLeft, dataLeft, size; | |
77 | ||
78 | from.c8 = (CARD8 *) &stuff[1]; | |
79 | dataLeft = (stuff->length * 4) - SIZEOF(xkbSelectEventsReq); | |
80 | maskLeft = (stuff->affectWhich & (~XkbMapNotifyMask)); | |
81 | for (ndx = 0, bit = 1; (maskLeft != 0); ndx++, bit <<= 1) { | |
82 | if (((bit & maskLeft) == 0) || (ndx == XkbMapNotify)) | |
83 | continue; | |
84 | maskLeft &= ~bit; | |
85 | if ((stuff->selectAll & bit) || (stuff->clear & bit)) | |
86 | continue; | |
87 | switch (ndx) { | |
88 | case XkbNewKeyboardNotify: | |
89 | case XkbStateNotify: | |
90 | case XkbNamesNotify: | |
91 | case XkbAccessXNotify: | |
92 | case XkbExtensionDeviceNotify: | |
93 | size = 2; | |
94 | break; | |
95 | case XkbControlsNotify: | |
96 | case XkbIndicatorStateNotify: | |
97 | case XkbIndicatorMapNotify: | |
98 | size = 4; | |
99 | break; | |
100 | case XkbBellNotify: | |
101 | case XkbActionMessage: | |
102 | case XkbCompatMapNotify: | |
103 | size = 1; | |
104 | break; | |
105 | default: | |
106 | client->errorValue = _XkbErrCode2(0x1, bit); | |
107 | return BadValue; | |
108 | } | |
109 | if (dataLeft < (size * 2)) | |
110 | return BadLength; | |
111 | if (size == 2) { | |
112 | swaps(&from.c16[0]); | |
113 | swaps(&from.c16[1]); | |
114 | } | |
115 | else if (size == 4) { | |
116 | swapl(&from.c32[0]); | |
117 | swapl(&from.c32[1]); | |
118 | } | |
119 | else { | |
120 | size = 2; | |
121 | } | |
122 | from.c8 += (size * 2); | |
123 | dataLeft -= (size * 2); | |
124 | } | |
125 | if (dataLeft > 2) { | |
126 | ErrorF("[xkb] Extra data (%d bytes) after SelectEvents\n", | |
127 | dataLeft); | |
128 | return BadLength; | |
129 | } | |
130 | } | |
131 | return ProcXkbSelectEvents(client); | |
132 | } | |
133 | ||
134 | static int | |
135 | SProcXkbBell(ClientPtr client) | |
136 | { | |
137 | REQUEST(xkbBellReq); | |
138 | ||
139 | swaps(&stuff->length); | |
140 | REQUEST_SIZE_MATCH(xkbBellReq); | |
141 | swaps(&stuff->deviceSpec); | |
142 | swaps(&stuff->bellClass); | |
143 | swaps(&stuff->bellID); | |
144 | swapl(&stuff->name); | |
145 | swapl(&stuff->window); | |
146 | swaps(&stuff->pitch); | |
147 | swaps(&stuff->duration); | |
148 | return ProcXkbBell(client); | |
149 | } | |
150 | ||
151 | static int | |
152 | SProcXkbGetState(ClientPtr client) | |
153 | { | |
154 | REQUEST(xkbGetStateReq); | |
155 | ||
156 | swaps(&stuff->length); | |
157 | REQUEST_SIZE_MATCH(xkbGetStateReq); | |
158 | swaps(&stuff->deviceSpec); | |
159 | return ProcXkbGetState(client); | |
160 | } | |
161 | ||
162 | static int | |
163 | SProcXkbLatchLockState(ClientPtr client) | |
164 | { | |
165 | REQUEST(xkbLatchLockStateReq); | |
166 | ||
167 | swaps(&stuff->length); | |
168 | REQUEST_SIZE_MATCH(xkbLatchLockStateReq); | |
169 | swaps(&stuff->deviceSpec); | |
170 | swaps(&stuff->groupLatch); | |
171 | return ProcXkbLatchLockState(client); | |
172 | } | |
173 | ||
174 | static int | |
175 | SProcXkbGetControls(ClientPtr client) | |
176 | { | |
177 | REQUEST(xkbGetControlsReq); | |
178 | ||
179 | swaps(&stuff->length); | |
180 | REQUEST_SIZE_MATCH(xkbGetControlsReq); | |
181 | swaps(&stuff->deviceSpec); | |
182 | return ProcXkbGetControls(client); | |
183 | } | |
184 | ||
185 | static int | |
186 | SProcXkbSetControls(ClientPtr client) | |
187 | { | |
188 | REQUEST(xkbSetControlsReq); | |
189 | ||
190 | swaps(&stuff->length); | |
191 | REQUEST_SIZE_MATCH(xkbSetControlsReq); | |
192 | swaps(&stuff->deviceSpec); | |
193 | swaps(&stuff->affectInternalVMods); | |
194 | swaps(&stuff->internalVMods); | |
195 | swaps(&stuff->affectIgnoreLockVMods); | |
196 | swaps(&stuff->ignoreLockVMods); | |
197 | swaps(&stuff->axOptions); | |
198 | swapl(&stuff->affectEnabledCtrls); | |
199 | swapl(&stuff->enabledCtrls); | |
200 | swapl(&stuff->changeCtrls); | |
201 | swaps(&stuff->repeatDelay); | |
202 | swaps(&stuff->repeatInterval); | |
203 | swaps(&stuff->slowKeysDelay); | |
204 | swaps(&stuff->debounceDelay); | |
205 | swaps(&stuff->mkDelay); | |
206 | swaps(&stuff->mkInterval); | |
207 | swaps(&stuff->mkTimeToMax); | |
208 | swaps(&stuff->mkMaxSpeed); | |
209 | swaps(&stuff->mkCurve); | |
210 | swaps(&stuff->axTimeout); | |
211 | swapl(&stuff->axtCtrlsMask); | |
212 | swapl(&stuff->axtCtrlsValues); | |
213 | swaps(&stuff->axtOptsMask); | |
214 | swaps(&stuff->axtOptsValues); | |
215 | return ProcXkbSetControls(client); | |
216 | } | |
217 | ||
218 | static int | |
219 | SProcXkbGetMap(ClientPtr client) | |
220 | { | |
221 | REQUEST(xkbGetMapReq); | |
222 | ||
223 | swaps(&stuff->length); | |
224 | REQUEST_SIZE_MATCH(xkbGetMapReq); | |
225 | swaps(&stuff->deviceSpec); | |
226 | swaps(&stuff->full); | |
227 | swaps(&stuff->partial); | |
228 | swaps(&stuff->virtualMods); | |
229 | return ProcXkbGetMap(client); | |
230 | } | |
231 | ||
232 | static int | |
233 | SProcXkbSetMap(ClientPtr client) | |
234 | { | |
235 | REQUEST(xkbSetMapReq); | |
236 | ||
237 | swaps(&stuff->length); | |
238 | REQUEST_AT_LEAST_SIZE(xkbSetMapReq); | |
239 | swaps(&stuff->deviceSpec); | |
240 | swaps(&stuff->present); | |
241 | swaps(&stuff->flags); | |
242 | swaps(&stuff->totalSyms); | |
243 | swaps(&stuff->totalActs); | |
244 | swaps(&stuff->virtualMods); | |
245 | return ProcXkbSetMap(client); | |
246 | } | |
247 | ||
248 | static int | |
249 | SProcXkbGetCompatMap(ClientPtr client) | |
250 | { | |
251 | REQUEST(xkbGetCompatMapReq); | |
252 | ||
253 | swaps(&stuff->length); | |
254 | REQUEST_SIZE_MATCH(xkbGetCompatMapReq); | |
255 | swaps(&stuff->deviceSpec); | |
256 | swaps(&stuff->firstSI); | |
257 | swaps(&stuff->nSI); | |
258 | return ProcXkbGetCompatMap(client); | |
259 | } | |
260 | ||
261 | static int | |
262 | SProcXkbSetCompatMap(ClientPtr client) | |
263 | { | |
264 | REQUEST(xkbSetCompatMapReq); | |
265 | ||
266 | swaps(&stuff->length); | |
267 | REQUEST_AT_LEAST_SIZE(xkbSetCompatMapReq); | |
268 | swaps(&stuff->deviceSpec); | |
269 | swaps(&stuff->firstSI); | |
270 | swaps(&stuff->nSI); | |
271 | return ProcXkbSetCompatMap(client); | |
272 | } | |
273 | ||
274 | static int | |
275 | SProcXkbGetIndicatorState(ClientPtr client) | |
276 | { | |
277 | REQUEST(xkbGetIndicatorStateReq); | |
278 | ||
279 | swaps(&stuff->length); | |
280 | REQUEST_SIZE_MATCH(xkbGetIndicatorStateReq); | |
281 | swaps(&stuff->deviceSpec); | |
282 | return ProcXkbGetIndicatorState(client); | |
283 | } | |
284 | ||
285 | static int | |
286 | SProcXkbGetIndicatorMap(ClientPtr client) | |
287 | { | |
288 | REQUEST(xkbGetIndicatorMapReq); | |
289 | ||
290 | swaps(&stuff->length); | |
291 | REQUEST_SIZE_MATCH(xkbGetIndicatorMapReq); | |
292 | swaps(&stuff->deviceSpec); | |
293 | swapl(&stuff->which); | |
294 | return ProcXkbGetIndicatorMap(client); | |
295 | } | |
296 | ||
297 | static int | |
298 | SProcXkbSetIndicatorMap(ClientPtr client) | |
299 | { | |
300 | REQUEST(xkbSetIndicatorMapReq); | |
301 | ||
302 | swaps(&stuff->length); | |
303 | REQUEST_AT_LEAST_SIZE(xkbSetIndicatorMapReq); | |
304 | swaps(&stuff->deviceSpec); | |
305 | swapl(&stuff->which); | |
306 | return ProcXkbSetIndicatorMap(client); | |
307 | } | |
308 | ||
309 | static int | |
310 | SProcXkbGetNamedIndicator(ClientPtr client) | |
311 | { | |
312 | REQUEST(xkbGetNamedIndicatorReq); | |
313 | ||
314 | swaps(&stuff->length); | |
315 | REQUEST_SIZE_MATCH(xkbGetNamedIndicatorReq); | |
316 | swaps(&stuff->deviceSpec); | |
317 | swaps(&stuff->ledClass); | |
318 | swaps(&stuff->ledID); | |
319 | swapl(&stuff->indicator); | |
320 | return ProcXkbGetNamedIndicator(client); | |
321 | } | |
322 | ||
323 | static int | |
324 | SProcXkbSetNamedIndicator(ClientPtr client) | |
325 | { | |
326 | REQUEST(xkbSetNamedIndicatorReq); | |
327 | ||
328 | swaps(&stuff->length); | |
329 | REQUEST_SIZE_MATCH(xkbSetNamedIndicatorReq); | |
330 | swaps(&stuff->deviceSpec); | |
331 | swaps(&stuff->ledClass); | |
332 | swaps(&stuff->ledID); | |
333 | swapl(&stuff->indicator); | |
334 | swaps(&stuff->virtualMods); | |
335 | swapl(&stuff->ctrls); | |
336 | return ProcXkbSetNamedIndicator(client); | |
337 | } | |
338 | ||
339 | static int | |
340 | SProcXkbGetNames(ClientPtr client) | |
341 | { | |
342 | REQUEST(xkbGetNamesReq); | |
343 | ||
344 | swaps(&stuff->length); | |
345 | REQUEST_SIZE_MATCH(xkbGetNamesReq); | |
346 | swaps(&stuff->deviceSpec); | |
347 | swapl(&stuff->which); | |
348 | return ProcXkbGetNames(client); | |
349 | } | |
350 | ||
351 | static int | |
352 | SProcXkbSetNames(ClientPtr client) | |
353 | { | |
354 | REQUEST(xkbSetNamesReq); | |
355 | ||
356 | swaps(&stuff->length); | |
357 | REQUEST_AT_LEAST_SIZE(xkbSetNamesReq); | |
358 | swaps(&stuff->deviceSpec); | |
359 | swaps(&stuff->virtualMods); | |
360 | swapl(&stuff->which); | |
361 | swapl(&stuff->indicators); | |
362 | swaps(&stuff->totalKTLevelNames); | |
363 | return ProcXkbSetNames(client); | |
364 | } | |
365 | ||
366 | static int | |
367 | SProcXkbGetGeometry(ClientPtr client) | |
368 | { | |
369 | REQUEST(xkbGetGeometryReq); | |
370 | ||
371 | swaps(&stuff->length); | |
372 | REQUEST_SIZE_MATCH(xkbGetGeometryReq); | |
373 | swaps(&stuff->deviceSpec); | |
374 | swapl(&stuff->name); | |
375 | return ProcXkbGetGeometry(client); | |
376 | } | |
377 | ||
378 | static int | |
379 | SProcXkbSetGeometry(ClientPtr client) | |
380 | { | |
381 | REQUEST(xkbSetGeometryReq); | |
382 | ||
383 | swaps(&stuff->length); | |
384 | REQUEST_AT_LEAST_SIZE(xkbSetGeometryReq); | |
385 | swaps(&stuff->deviceSpec); | |
386 | swapl(&stuff->name); | |
387 | swaps(&stuff->widthMM); | |
388 | swaps(&stuff->heightMM); | |
389 | swaps(&stuff->nProperties); | |
390 | swaps(&stuff->nColors); | |
391 | swaps(&stuff->nDoodads); | |
392 | swaps(&stuff->nKeyAliases); | |
393 | return ProcXkbSetGeometry(client); | |
394 | } | |
395 | ||
396 | static int | |
397 | SProcXkbPerClientFlags(ClientPtr client) | |
398 | { | |
399 | REQUEST(xkbPerClientFlagsReq); | |
400 | ||
401 | swaps(&stuff->length); | |
402 | REQUEST_SIZE_MATCH(xkbPerClientFlagsReq); | |
403 | swaps(&stuff->deviceSpec); | |
404 | swapl(&stuff->change); | |
405 | swapl(&stuff->value); | |
406 | swapl(&stuff->ctrlsToChange); | |
407 | swapl(&stuff->autoCtrls); | |
408 | swapl(&stuff->autoCtrlValues); | |
409 | return ProcXkbPerClientFlags(client); | |
410 | } | |
411 | ||
412 | static int | |
413 | SProcXkbListComponents(ClientPtr client) | |
414 | { | |
415 | REQUEST(xkbListComponentsReq); | |
416 | ||
417 | swaps(&stuff->length); | |
418 | REQUEST_AT_LEAST_SIZE(xkbListComponentsReq); | |
419 | swaps(&stuff->deviceSpec); | |
420 | swaps(&stuff->maxNames); | |
421 | return ProcXkbListComponents(client); | |
422 | } | |
423 | ||
424 | static int | |
425 | SProcXkbGetKbdByName(ClientPtr client) | |
426 | { | |
427 | REQUEST(xkbGetKbdByNameReq); | |
428 | ||
429 | swaps(&stuff->length); | |
430 | REQUEST_AT_LEAST_SIZE(xkbGetKbdByNameReq); | |
431 | swaps(&stuff->deviceSpec); | |
432 | swaps(&stuff->want); | |
433 | swaps(&stuff->need); | |
434 | return ProcXkbGetKbdByName(client); | |
435 | } | |
436 | ||
437 | static int | |
438 | SProcXkbGetDeviceInfo(ClientPtr client) | |
439 | { | |
440 | REQUEST(xkbGetDeviceInfoReq); | |
441 | ||
442 | swaps(&stuff->length); | |
443 | REQUEST_SIZE_MATCH(xkbGetDeviceInfoReq); | |
444 | swaps(&stuff->deviceSpec); | |
445 | swaps(&stuff->wanted); | |
446 | swaps(&stuff->ledClass); | |
447 | swaps(&stuff->ledID); | |
448 | return ProcXkbGetDeviceInfo(client); | |
449 | } | |
450 | ||
451 | static int | |
452 | SProcXkbSetDeviceInfo(ClientPtr client) | |
453 | { | |
454 | REQUEST(xkbSetDeviceInfoReq); | |
455 | ||
456 | swaps(&stuff->length); | |
457 | REQUEST_AT_LEAST_SIZE(xkbSetDeviceInfoReq); | |
458 | swaps(&stuff->deviceSpec); | |
459 | swaps(&stuff->change); | |
460 | swaps(&stuff->nDeviceLedFBs); | |
461 | return ProcXkbSetDeviceInfo(client); | |
462 | } | |
463 | ||
464 | static int | |
465 | SProcXkbSetDebuggingFlags(ClientPtr client) | |
466 | { | |
467 | REQUEST(xkbSetDebuggingFlagsReq); | |
468 | ||
469 | swaps(&stuff->length); | |
470 | REQUEST_AT_LEAST_SIZE(xkbSetDebuggingFlagsReq); | |
471 | swapl(&stuff->affectFlags); | |
472 | swapl(&stuff->flags); | |
473 | swapl(&stuff->affectCtrls); | |
474 | swapl(&stuff->ctrls); | |
475 | swaps(&stuff->msgLength); | |
476 | return ProcXkbSetDebuggingFlags(client); | |
477 | } | |
478 | ||
479 | int | |
480 | SProcXkbDispatch(ClientPtr client) | |
481 | { | |
482 | REQUEST(xReq); | |
483 | switch (stuff->data) { | |
484 | case X_kbUseExtension: | |
485 | return SProcXkbUseExtension(client); | |
486 | case X_kbSelectEvents: | |
487 | return SProcXkbSelectEvents(client); | |
488 | case X_kbBell: | |
489 | return SProcXkbBell(client); | |
490 | case X_kbGetState: | |
491 | return SProcXkbGetState(client); | |
492 | case X_kbLatchLockState: | |
493 | return SProcXkbLatchLockState(client); | |
494 | case X_kbGetControls: | |
495 | return SProcXkbGetControls(client); | |
496 | case X_kbSetControls: | |
497 | return SProcXkbSetControls(client); | |
498 | case X_kbGetMap: | |
499 | return SProcXkbGetMap(client); | |
500 | case X_kbSetMap: | |
501 | return SProcXkbSetMap(client); | |
502 | case X_kbGetCompatMap: | |
503 | return SProcXkbGetCompatMap(client); | |
504 | case X_kbSetCompatMap: | |
505 | return SProcXkbSetCompatMap(client); | |
506 | case X_kbGetIndicatorState: | |
507 | return SProcXkbGetIndicatorState(client); | |
508 | case X_kbGetIndicatorMap: | |
509 | return SProcXkbGetIndicatorMap(client); | |
510 | case X_kbSetIndicatorMap: | |
511 | return SProcXkbSetIndicatorMap(client); | |
512 | case X_kbGetNamedIndicator: | |
513 | return SProcXkbGetNamedIndicator(client); | |
514 | case X_kbSetNamedIndicator: | |
515 | return SProcXkbSetNamedIndicator(client); | |
516 | case X_kbGetNames: | |
517 | return SProcXkbGetNames(client); | |
518 | case X_kbSetNames: | |
519 | return SProcXkbSetNames(client); | |
520 | case X_kbGetGeometry: | |
521 | return SProcXkbGetGeometry(client); | |
522 | case X_kbSetGeometry: | |
523 | return SProcXkbSetGeometry(client); | |
524 | case X_kbPerClientFlags: | |
525 | return SProcXkbPerClientFlags(client); | |
526 | case X_kbListComponents: | |
527 | return SProcXkbListComponents(client); | |
528 | case X_kbGetKbdByName: | |
529 | return SProcXkbGetKbdByName(client); | |
530 | case X_kbGetDeviceInfo: | |
531 | return SProcXkbGetDeviceInfo(client); | |
532 | case X_kbSetDeviceInfo: | |
533 | return SProcXkbSetDeviceInfo(client); | |
534 | case X_kbSetDebuggingFlags: | |
535 | return SProcXkbSetDebuggingFlags(client); | |
536 | default: | |
537 | return BadRequest; | |
538 | } | |
539 | } |