1 /*
2 * Copyright © 2013 Ran Benita
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "config.h"
25
26 #include "x11-priv.h"
27
28 /*
29 * References for the lonesome traveler:
30 * Xkb protocol specification:
31 * https://www.x.org/releases/current/doc/kbproto/xkbproto.html
32 * The XCB xkb XML protocol file:
33 * /user/share/xcb/xkb.xml
34 * The XCB xkb header file:
35 * /usr/include/xcb/xkb.h
36 * The old kbproto header files:
37 * /usr/include/X11/extensions/XKB{,proto,str}.h
38 * Xlib XKB source code:
39 * <libX11>/src/xkb/XKBGetMap.c (and friends)
40 * X server XKB protocol handling:
41 * <xserver>/xkb/xkb.c
42 * Man pages:
43 * XkbGetMap(3), XkbGetCompatMap(3), etc.
44 */
45
46 /* Constants from /usr/include/X11/extensions/XKB.h */
47 /* XkbNumModifiers. */
48 #define NUM_REAL_MODS 8u
49 /* XkbNumVirtualMods. */
50 #define NUM_VMODS 16u
51 /* XkbNoModifier. */
52 #define NO_MODIFIER 0xff
53 /* XkbNumIndicators. */
54 #define NUM_INDICATORS 32u
55 /* XkbAllIndicatorsMask. */
56 #define ALL_INDICATORS_MASK 0xffffffff
57
58 /* Some macros. Not very nice but it'd be worse without them. */
59
60 /*
61 * We try not to trust the server too much and be paranoid. If we get
62 * something which we definitely shouldn't, we fail.
63 */
64 #define STRINGIFY(expr) #expr
65 #define FAIL_UNLESS(expr) do { \
66 if (!(expr)) { \
67 log_err(keymap->ctx, \
68 "x11: failed to get keymap from X server: unmet condition in %s(): %s\n", \
69 __func__, STRINGIFY(expr)); \
70 goto fail; \
71 } \
72 } while (0)
73
74 #define FAIL_IF_BAD_REPLY(reply, request_name) do { \
75 if (!reply) { \
76 log_err(keymap->ctx, \
77 "x11: failed to get keymap from X server: %s request failed\n", \
78 (request_name)); \
79 goto fail; \
80 } \
81 } while (0)
82
83 #define ALLOC_OR_FAIL(arr, nmemb) do { \
84 if ((nmemb) > 0) { \
85 (arr) = calloc((nmemb), sizeof(*(arr))); \
86 if (!(arr)) \
87 goto fail; \
88 } \
89 } while (0)
90
91 static const xcb_xkb_map_part_t get_map_required_components =
92 (XCB_XKB_MAP_PART_KEY_TYPES |
93 XCB_XKB_MAP_PART_KEY_SYMS |
94 XCB_XKB_MAP_PART_MODIFIER_MAP |
95 XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
96 XCB_XKB_MAP_PART_KEY_ACTIONS |
97 XCB_XKB_MAP_PART_VIRTUAL_MODS |
98 XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
99
100 static const xcb_xkb_name_detail_t get_names_wanted =
101 (XCB_XKB_NAME_DETAIL_KEYCODES |
102 XCB_XKB_NAME_DETAIL_SYMBOLS |
103 XCB_XKB_NAME_DETAIL_TYPES |
104 XCB_XKB_NAME_DETAIL_COMPAT |
105 XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES |
106 XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES |
107 XCB_XKB_NAME_DETAIL_INDICATOR_NAMES |
108 XCB_XKB_NAME_DETAIL_KEY_NAMES |
109 XCB_XKB_NAME_DETAIL_KEY_ALIASES |
110 XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES |
111 XCB_XKB_NAME_DETAIL_GROUP_NAMES);
112 static const xcb_xkb_name_detail_t get_names_required =
113 (XCB_XKB_NAME_DETAIL_KEY_TYPE_NAMES |
114 XCB_XKB_NAME_DETAIL_KT_LEVEL_NAMES |
115 XCB_XKB_NAME_DETAIL_KEY_NAMES |
116 XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES);
117
118
119 static xkb_mod_mask_t
translate_mods(uint8_t rmods,uint16_t vmods_low,uint16_t vmods_high)120 translate_mods(uint8_t rmods, uint16_t vmods_low, uint16_t vmods_high)
121 {
122 /* We represent mod masks in a single uint32_t value, with real mods
123 * first and vmods after (though we don't make these distinctions). */
124 return
125 ((xkb_mod_mask_t) rmods) |
126 ((xkb_mod_mask_t) vmods_low << 8) |
127 ((xkb_mod_mask_t) vmods_high << 16);
128 }
129
130 static enum xkb_action_controls
translate_controls_mask(uint32_t wire)131 translate_controls_mask(uint32_t wire)
132 {
133 enum xkb_action_controls ret = 0;
134 if (wire & XCB_XKB_BOOL_CTRL_REPEAT_KEYS)
135 ret |= CONTROL_REPEAT;
136 if (wire & XCB_XKB_BOOL_CTRL_SLOW_KEYS)
137 ret |= CONTROL_SLOW;
138 if (wire & XCB_XKB_BOOL_CTRL_BOUNCE_KEYS)
139 ret |= CONTROL_DEBOUNCE;
140 if (wire & XCB_XKB_BOOL_CTRL_STICKY_KEYS)
141 ret |= CONTROL_STICKY;
142 if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS)
143 ret |= CONTROL_MOUSEKEYS;
144 if (wire & XCB_XKB_BOOL_CTRL_MOUSE_KEYS_ACCEL)
145 ret |= CONTROL_MOUSEKEYS_ACCEL;
146 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_KEYS)
147 ret |= CONTROL_AX;
148 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_TIMEOUT_MASK)
149 ret |= CONTROL_AX_TIMEOUT;
150 if (wire & XCB_XKB_BOOL_CTRL_ACCESS_X_FEEDBACK_MASK)
151 ret |= CONTROL_AX_FEEDBACK;
152 if (wire & XCB_XKB_BOOL_CTRL_AUDIBLE_BELL_MASK)
153 ret |= CONTROL_BELL;
154 if (wire & XCB_XKB_BOOL_CTRL_IGNORE_GROUP_LOCK_MASK)
155 ret |= CONTROL_IGNORE_GROUP_LOCK;
156 /* Some controls are not supported and don't appear here. */
157 return ret;
158 }
159
160 static void
translate_action(union xkb_action * action,const xcb_xkb_action_t * wire)161 translate_action(union xkb_action *action, const xcb_xkb_action_t *wire)
162 {
163 switch (wire->type) {
164 case XCB_XKB_SA_TYPE_SET_MODS:
165 action->type = ACTION_TYPE_MOD_SET;
166
167 action->mods.mods.mods = translate_mods(wire->setmods.realMods,
168 wire->setmods.vmodsLow,
169 wire->setmods.vmodsHigh);
170 action->mods.mods.mask = translate_mods(wire->setmods.mask, 0, 0);
171
172 if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
173 action->mods.flags |= ACTION_LOCK_CLEAR;
174 if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
175 action->mods.flags |= ACTION_LATCH_TO_LOCK;
176 if (wire->setmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
177 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
178
179 break;
180 case XCB_XKB_SA_TYPE_LATCH_MODS:
181 action->type = ACTION_TYPE_MOD_LATCH;
182
183 action->mods.mods.mods = translate_mods(wire->latchmods.realMods,
184 wire->latchmods.vmodsLow,
185 wire->latchmods.vmodsHigh);
186 action->mods.mods.mask = translate_mods(wire->latchmods.mask, 0, 0);
187
188 if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
189 action->mods.flags |= ACTION_LOCK_CLEAR;
190 if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
191 action->mods.flags |= ACTION_LATCH_TO_LOCK;
192 if (wire->latchmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
193 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
194
195 break;
196 case XCB_XKB_SA_TYPE_LOCK_MODS:
197 action->type = ACTION_TYPE_MOD_LOCK;
198
199 action->mods.mods.mods = translate_mods(wire->lockmods.realMods,
200 wire->lockmods.vmodsLow,
201 wire->lockmods.vmodsHigh);
202 action->mods.mods.mask = translate_mods(wire->lockmods.mask, 0, 0);
203
204 if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
205 action->mods.flags |= ACTION_LOCK_NO_LOCK;
206 if (wire->lockmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
207 action->mods.flags |= ACTION_LOCK_NO_UNLOCK;
208 if (wire->lockmods.flags & XCB_XKB_SA_USE_MOD_MAP_MODS)
209 action->mods.flags |= ACTION_MODS_LOOKUP_MODMAP;
210
211 break;
212 case XCB_XKB_SA_TYPE_SET_GROUP:
213 action->type = ACTION_TYPE_GROUP_SET;
214
215 action->group.group = wire->setgroup.group;
216
217 if (wire->setmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
218 action->group.flags |= ACTION_LOCK_CLEAR;
219 if (wire->setmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
220 action->group.flags |= ACTION_LATCH_TO_LOCK;
221 if (wire->setmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
222 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
223
224 break;
225 case XCB_XKB_SA_TYPE_LATCH_GROUP:
226 action->type = ACTION_TYPE_GROUP_LATCH;
227
228 action->group.group = wire->latchgroup.group;
229
230 if (wire->latchmods.flags & XCB_XKB_SA_CLEAR_LOCKS)
231 action->group.flags |= ACTION_LOCK_CLEAR;
232 if (wire->latchmods.flags & XCB_XKB_SA_LATCH_TO_LOCK)
233 action->group.flags |= ACTION_LATCH_TO_LOCK;
234 if (wire->latchmods.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
235 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
236
237 break;
238 case XCB_XKB_SA_TYPE_LOCK_GROUP:
239 action->type = ACTION_TYPE_GROUP_LOCK;
240
241 action->group.group = wire->lockgroup.group;
242
243 if (wire->lockgroup.flags & XCB_XKB_SA_ISO_LOCK_FLAG_GROUP_ABSOLUTE)
244 action->group.flags |= ACTION_ABSOLUTE_SWITCH;
245
246 break;
247 case XCB_XKB_SA_TYPE_MOVE_PTR:
248 action->type = ACTION_TYPE_PTR_MOVE;
249
250 action->ptr.x = (int16_t) (wire->moveptr.xLow | ((uint16_t) wire->moveptr.xHigh << 8));
251 action->ptr.y = (int16_t) (wire->moveptr.yLow | ((uint16_t) wire->moveptr.yHigh << 8));
252
253 if (!(wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_NO_ACCELERATION))
254 action->ptr.flags |= ACTION_ACCEL;
255 if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_X)
256 action->ptr.flags |= ACTION_ABSOLUTE_X;
257 if (wire->moveptr.flags & XCB_XKB_SA_MOVE_PTR_FLAG_MOVE_ABSOLUTE_Y)
258 action->ptr.flags |= ACTION_ABSOLUTE_Y;
259
260 break;
261 case XCB_XKB_SA_TYPE_PTR_BTN:
262 action->type = ACTION_TYPE_PTR_BUTTON;
263
264 action->btn.count = wire->ptrbtn.count;
265 action->btn.button = wire->ptrbtn.button;
266 action->btn.flags = 0;
267
268 break;
269 case XCB_XKB_SA_TYPE_LOCK_PTR_BTN:
270 action->type = ACTION_TYPE_PTR_LOCK;
271
272 action->btn.button = wire->lockptrbtn.button;
273
274 if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_LOCK)
275 action->btn.flags |= ACTION_LOCK_NO_LOCK;
276 if (wire->lockptrbtn.flags & XCB_XKB_SA_ISO_LOCK_FLAG_NO_UNLOCK)
277 action->btn.flags |= ACTION_LOCK_NO_UNLOCK;
278
279 break;
280 case XCB_XKB_SA_TYPE_SET_PTR_DFLT:
281 action->type = ACTION_TYPE_PTR_DEFAULT;
282
283 action->dflt.value = wire->setptrdflt.value;
284
285 if (wire->setptrdflt.flags & XCB_XKB_SA_SET_PTR_DFLT_FLAG_DFLT_BTN_ABSOLUTE)
286 action->dflt.flags |= ACTION_ABSOLUTE_SWITCH;
287
288 break;
289 case XCB_XKB_SA_TYPE_TERMINATE:
290 action->type = ACTION_TYPE_TERMINATE;
291
292 break;
293 case XCB_XKB_SA_TYPE_SWITCH_SCREEN:
294 action->type = ACTION_TYPE_SWITCH_VT;
295
296 action->screen.screen = wire->switchscreen.newScreen;
297
298 if (!(wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_APPLICATION))
299 action->screen.flags |= ACTION_SAME_SCREEN;
300 if (wire->switchscreen.flags & XCB_XKB_SWITCH_SCREEN_FLAG_ABSOLUTE)
301 action->screen.flags |= ACTION_ABSOLUTE_SWITCH;
302
303 break;
304 case XCB_XKB_SA_TYPE_SET_CONTROLS:
305 action->type = ACTION_TYPE_CTRL_SET;
306 {
307 const uint16_t mask = (wire->setcontrols.boolCtrlsLow |
308 (wire->setcontrols.boolCtrlsHigh << 8));
309 action->ctrls.ctrls = translate_controls_mask(mask);
310 }
311 break;
312 case XCB_XKB_SA_TYPE_LOCK_CONTROLS:
313 action->type = ACTION_TYPE_CTRL_LOCK;
314 {
315 const uint16_t mask = (wire->lockcontrols.boolCtrlsLow |
316 (wire->lockcontrols.boolCtrlsHigh << 8));
317 action->ctrls.ctrls = translate_controls_mask(mask);
318 }
319 break;
320
321 case XCB_XKB_SA_TYPE_NO_ACTION:
322 /* We don't support these. */
323 case XCB_XKB_SA_TYPE_ISO_LOCK:
324 case XCB_XKB_SA_TYPE_REDIRECT_KEY:
325 case XCB_XKB_SA_TYPE_ACTION_MESSAGE:
326 case XCB_XKB_SA_TYPE_DEVICE_BTN:
327 case XCB_XKB_SA_TYPE_LOCK_DEVICE_BTN:
328 case XCB_XKB_SA_TYPE_DEVICE_VALUATOR:
329 action->type = ACTION_TYPE_NONE;
330 break;
331
332 default:
333 if (wire->type < ACTION_TYPE_PRIVATE) {
334 action->type = ACTION_TYPE_NONE;
335 break;
336 }
337
338 /* Treat high unknown actions as Private actions. */
339 action->priv.type = wire->noaction.type;
340 STATIC_ASSERT(sizeof(action->priv.data) == 7 &&
341 sizeof(wire->noaction.pad0) == 7,
342 "The private action data must be 7 bytes long!");
343 memcpy(action->priv.data, wire->noaction.pad0, 7);
344 break;
345 }
346 }
347
348 static bool
get_types(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)349 get_types(struct xkb_keymap *keymap, xcb_connection_t *conn,
350 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
351 {
352 int types_length = xcb_xkb_get_map_map_types_rtrn_length(reply, map);
353 xcb_xkb_key_type_iterator_t types_iter =
354 xcb_xkb_get_map_map_types_rtrn_iterator(reply, map);
355
356 FAIL_UNLESS(reply->firstType == 0);
357
358 keymap->num_types = reply->nTypes;
359 ALLOC_OR_FAIL(keymap->types, keymap->num_types);
360
361 for (int i = 0; i < types_length; i++) {
362 xcb_xkb_key_type_t *wire_type = types_iter.data;
363 struct xkb_key_type *type = &keymap->types[i];
364
365 FAIL_UNLESS(wire_type->numLevels > 0);
366
367 type->mods.mods = translate_mods(wire_type->mods_mods,
368 wire_type->mods_vmods, 0);
369 type->mods.mask = translate_mods(wire_type->mods_mask, 0, 0);
370 type->num_levels = wire_type->numLevels;
371
372 {
373 int entries_length = xcb_xkb_key_type_map_length(wire_type);
374 xcb_xkb_kt_map_entry_iterator_t entries_iter =
375 xcb_xkb_key_type_map_iterator(wire_type);
376
377 type->num_entries = wire_type->nMapEntries;
378 ALLOC_OR_FAIL(type->entries, type->num_entries);
379
380 for (int j = 0; j < entries_length; j++) {
381 xcb_xkb_kt_map_entry_t *wire_entry = entries_iter.data;
382 struct xkb_key_type_entry *entry = &type->entries[j];
383
384 FAIL_UNLESS(wire_entry->level < type->num_levels);
385
386 entry->level = wire_entry->level;
387 entry->mods.mods = translate_mods(wire_entry->mods_mods,
388 wire_entry->mods_vmods, 0);
389 entry->mods.mask = translate_mods(wire_entry->mods_mask, 0, 0);
390
391 xcb_xkb_kt_map_entry_next(&entries_iter);
392 }
393 }
394
395 {
396 int preserves_length = xcb_xkb_key_type_preserve_length(wire_type);
397 xcb_xkb_mod_def_iterator_t preserves_iter =
398 xcb_xkb_key_type_preserve_iterator(wire_type);
399
400 FAIL_UNLESS((unsigned) preserves_length <= type->num_entries);
401
402 for (int j = 0; j < preserves_length; j++) {
403 xcb_xkb_mod_def_t *wire_preserve = preserves_iter.data;
404 struct xkb_key_type_entry *entry = &type->entries[j];
405
406 entry->preserve.mods = translate_mods(wire_preserve->realMods,
407 wire_preserve->vmods, 0);
408 entry->preserve.mask = translate_mods(wire_preserve->mask, 0, 0);
409
410 xcb_xkb_mod_def_next(&preserves_iter);
411 }
412 }
413
414 xcb_xkb_key_type_next(&types_iter);
415 }
416
417 return true;
418
419 fail:
420 return false;
421 }
422
423 static bool
get_sym_maps(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)424 get_sym_maps(struct xkb_keymap *keymap, xcb_connection_t *conn,
425 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
426 {
427 int sym_maps_length = xcb_xkb_get_map_map_syms_rtrn_length(reply, map);
428 xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
429 xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
430
431 FAIL_UNLESS(reply->minKeyCode <= reply->maxKeyCode);
432 FAIL_UNLESS(reply->firstKeySym >= reply->minKeyCode);
433 FAIL_UNLESS(reply->firstKeySym + reply->nKeySyms <= reply->maxKeyCode + 1);
434
435 keymap->min_key_code = reply->minKeyCode;
436 keymap->max_key_code = reply->maxKeyCode;
437
438 ALLOC_OR_FAIL(keymap->keys, keymap->max_key_code + 1);
439
440 for (xkb_keycode_t kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++)
441 keymap->keys[kc].keycode = kc;
442
443 for (int i = 0; i < sym_maps_length; i++) {
444 xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
445 struct xkb_key *key = &keymap->keys[reply->firstKeySym + i];
446
447 key->num_groups = wire_sym_map->groupInfo & 0x0f;
448 FAIL_UNLESS(key->num_groups <= ARRAY_SIZE(wire_sym_map->kt_index));
449 ALLOC_OR_FAIL(key->groups, key->num_groups);
450
451 for (unsigned j = 0; j < key->num_groups; j++) {
452 FAIL_UNLESS(wire_sym_map->kt_index[j] < keymap->num_types);
453 key->groups[j].type = &keymap->types[wire_sym_map->kt_index[j]];
454
455 ALLOC_OR_FAIL(key->groups[j].levels, key->groups[j].type->num_levels);
456 }
457
458 key->out_of_range_group_number = (wire_sym_map->groupInfo & 0x30) >> 4;
459
460 FAIL_UNLESS(key->out_of_range_group_number <= key->num_groups);
461
462 if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_CLAMP_INTO_RANGE)
463 key->out_of_range_group_action = RANGE_SATURATE;
464 else if (wire_sym_map->groupInfo & XCB_XKB_GROUPS_WRAP_REDIRECT_INTO_RANGE)
465 key->out_of_range_group_action = RANGE_REDIRECT;
466 else
467 key->out_of_range_group_action = RANGE_WRAP;
468
469 {
470 int syms_length = xcb_xkb_key_sym_map_syms_length(wire_sym_map);
471 xcb_keysym_t *syms_iter = xcb_xkb_key_sym_map_syms(wire_sym_map);
472
473 FAIL_UNLESS((unsigned) syms_length == wire_sym_map->width * key->num_groups);
474
475 for (xkb_layout_index_t group = 0; group < key->num_groups; group++) {
476 for (xkb_level_index_t level = 0; level < wire_sym_map->width; level++) {
477 xcb_keysym_t wire_keysym = *syms_iter;
478
479 assert(key->groups[group].type != NULL);
480 if (level < key->groups[group].type->num_levels &&
481 wire_keysym != XKB_KEY_NoSymbol) {
482 key->groups[group].levels[level].num_syms = 1;
483 key->groups[group].levels[level].u.sym = wire_keysym;
484 }
485
486 syms_iter++;
487 }
488 }
489 }
490
491 xcb_xkb_key_sym_map_next(&sym_maps_iter);
492 }
493
494 return true;
495
496 fail:
497 return false;
498 }
499
500 static bool
get_actions(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)501 get_actions(struct xkb_keymap *keymap, xcb_connection_t *conn,
502 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
503 {
504 int acts_count_length =
505 xcb_xkb_get_map_map_acts_rtrn_count_length(reply, map);
506 uint8_t *acts_count_iter = xcb_xkb_get_map_map_acts_rtrn_count(map);
507 xcb_xkb_action_iterator_t acts_iter =
508 xcb_xkb_get_map_map_acts_rtrn_acts_iterator(reply, map);
509 xcb_xkb_key_sym_map_iterator_t sym_maps_iter =
510 xcb_xkb_get_map_map_syms_rtrn_iterator(reply, map);
511
512 FAIL_UNLESS(reply->firstKeyAction == keymap->min_key_code);
513 FAIL_UNLESS(reply->firstKeyAction + reply->nKeyActions ==
514 keymap->max_key_code + 1);
515
516 for (int i = 0; i < acts_count_length; i++) {
517 xcb_xkb_key_sym_map_t *wire_sym_map = sym_maps_iter.data;
518 int syms_length = xcb_xkb_key_sym_map_syms_length(wire_sym_map);
519 uint8_t wire_count = *acts_count_iter;
520 struct xkb_key *key = &keymap->keys[reply->firstKeyAction + i];
521
522 FAIL_UNLESS((unsigned) syms_length == wire_sym_map->width * key->num_groups);
523 FAIL_UNLESS(wire_count == 0 || wire_count == syms_length);
524
525 if (wire_count != 0) {
526 for (xkb_layout_index_t group = 0; group < key->num_groups; group++) {
527 for (xkb_level_index_t level = 0; level < wire_sym_map->width; level++) {
528 xcb_xkb_action_t *wire_action = acts_iter.data;
529
530 if (level < key->groups[group].type->num_levels) {
531 union xkb_action *action = &key->groups[group].levels[level].action;
532
533 translate_action(action, wire_action);
534 }
535
536 xcb_xkb_action_next(&acts_iter);
537 }
538 }
539 }
540
541 acts_count_iter++;
542 xcb_xkb_key_sym_map_next(&sym_maps_iter);
543 }
544
545 return true;
546
547 fail:
548 return false;
549 }
550
551 static bool
get_vmods(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)552 get_vmods(struct xkb_keymap *keymap, xcb_connection_t *conn,
553 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
554 {
555 uint8_t *iter = xcb_xkb_get_map_map_vmods_rtrn(map);
556
557 keymap->mods.num_mods =
558 NUM_REAL_MODS + MIN(msb_pos(reply->virtualMods), NUM_VMODS);
559
560 for (unsigned i = 0; i < NUM_VMODS; i++) {
561 if (reply->virtualMods & (1u << i)) {
562 uint8_t wire = *iter;
563 struct xkb_mod *mod = &keymap->mods.mods[NUM_REAL_MODS + i];
564
565 mod->type = MOD_VIRT;
566 mod->mapping = translate_mods(wire, 0, 0);
567
568 iter++;
569 }
570 }
571
572 return true;
573 }
574
575 static bool
get_explicits(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)576 get_explicits(struct xkb_keymap *keymap, xcb_connection_t *conn,
577 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
578 {
579 int length = xcb_xkb_get_map_map_explicit_rtrn_length(reply, map);
580 xcb_xkb_set_explicit_iterator_t iter =
581 xcb_xkb_get_map_map_explicit_rtrn_iterator(reply, map);
582
583 for (int i = 0; i < length; i++) {
584 xcb_xkb_set_explicit_t *wire = iter.data;
585 struct xkb_key *key;
586
587 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
588 wire->keycode <= keymap->max_key_code);
589
590 key = &keymap->keys[wire->keycode];
591
592 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_1) &&
593 key->num_groups > 0)
594 key->groups[0].explicit_type = true;
595 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_2) &&
596 key->num_groups > 1)
597 key->groups[1].explicit_type = true;
598 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_3) &&
599 key->num_groups > 2)
600 key->groups[2].explicit_type = true;
601 if ((wire->explicit & XCB_XKB_EXPLICIT_KEY_TYPE_4) &&
602 key->num_groups > 3)
603 key->groups[3].explicit_type = true;
604 if (wire->explicit & XCB_XKB_EXPLICIT_INTERPRET)
605 key->explicit |= EXPLICIT_INTERP;
606 if (wire->explicit & XCB_XKB_EXPLICIT_AUTO_REPEAT)
607 key->explicit |= EXPLICIT_REPEAT;
608 if (wire->explicit & XCB_XKB_EXPLICIT_V_MOD_MAP)
609 key->explicit |= EXPLICIT_VMODMAP;
610
611 xcb_xkb_set_explicit_next(&iter);
612 }
613
614 return true;
615
616 fail:
617 return false;
618 }
619
620 static bool
get_modmaps(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)621 get_modmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
622 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
623 {
624 int length = xcb_xkb_get_map_map_modmap_rtrn_length(reply, map);
625 xcb_xkb_key_mod_map_iterator_t iter =
626 xcb_xkb_get_map_map_modmap_rtrn_iterator(reply, map);
627
628 for (int i = 0; i < length; i++) {
629 xcb_xkb_key_mod_map_t *wire = iter.data;
630 struct xkb_key *key;
631
632 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
633 wire->keycode <= keymap->max_key_code);
634
635 key = &keymap->keys[wire->keycode];
636 key->modmap = wire->mods;
637
638 xcb_xkb_key_mod_map_next(&iter);
639 }
640
641 return true;
642
643 fail:
644 return false;
645 }
646
647 static bool
get_vmodmaps(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_reply_t * reply,xcb_xkb_get_map_map_t * map)648 get_vmodmaps(struct xkb_keymap *keymap, xcb_connection_t *conn,
649 xcb_xkb_get_map_reply_t *reply, xcb_xkb_get_map_map_t *map)
650 {
651 int length = xcb_xkb_get_map_map_vmodmap_rtrn_length(reply, map);
652 xcb_xkb_key_v_mod_map_iterator_t iter =
653 xcb_xkb_get_map_map_vmodmap_rtrn_iterator(reply, map);
654
655 for (int i = 0; i < length; i++) {
656 xcb_xkb_key_v_mod_map_t *wire = iter.data;
657 struct xkb_key *key;
658
659 FAIL_UNLESS(wire->keycode >= keymap->min_key_code &&
660 wire->keycode <= keymap->max_key_code);
661
662 key = &keymap->keys[wire->keycode];
663 key->vmodmap = translate_mods(0, wire->vmods, 0);
664
665 xcb_xkb_key_v_mod_map_next(&iter);
666 }
667
668 return true;
669
670 fail:
671 return false;
672 }
673
674 static bool
get_map(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_map_cookie_t cookie)675 get_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
676 xcb_xkb_get_map_cookie_t cookie)
677 {
678 xcb_xkb_get_map_reply_t *reply = xcb_xkb_get_map_reply(conn, cookie, NULL);
679 xcb_xkb_get_map_map_t map;
680
681 FAIL_IF_BAD_REPLY(reply, "XkbGetMap");
682
683 if ((reply->present & get_map_required_components) != get_map_required_components)
684 goto fail;
685
686 xcb_xkb_get_map_map_unpack(xcb_xkb_get_map_map(reply),
687 reply->nTypes,
688 reply->nKeySyms,
689 reply->nKeyActions,
690 reply->totalActions,
691 reply->totalKeyBehaviors,
692 reply->virtualMods,
693 reply->totalKeyExplicit,
694 reply->totalModMapKeys,
695 reply->totalVModMapKeys,
696 reply->present,
697 &map);
698
699 if (!get_types(keymap, conn, reply, &map) ||
700 !get_sym_maps(keymap, conn, reply, &map) ||
701 !get_actions(keymap, conn, reply, &map) ||
702 !get_vmods(keymap, conn, reply, &map) ||
703 !get_explicits(keymap, conn, reply, &map) ||
704 !get_modmaps(keymap, conn, reply, &map) ||
705 !get_vmodmaps(keymap, conn, reply, &map))
706 goto fail;
707
708 free(reply);
709 return true;
710
711 fail:
712 free(reply);
713 return false;
714 }
715
716 static bool
get_indicators(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_indicator_map_reply_t * reply)717 get_indicators(struct xkb_keymap *keymap, xcb_connection_t *conn,
718 xcb_xkb_get_indicator_map_reply_t *reply)
719 {
720 xcb_xkb_indicator_map_iterator_t iter =
721 xcb_xkb_get_indicator_map_maps_iterator(reply);
722
723 keymap->num_leds = msb_pos(reply->which);
724
725 for (unsigned i = 0; i < NUM_INDICATORS; i++) {
726 if (reply->which & (1u << i)) {
727 xcb_xkb_indicator_map_t *wire = iter.data;
728 struct xkb_led *led = &keymap->leds[i];
729
730 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_BASE)
731 led->which_groups |= XKB_STATE_LAYOUT_DEPRESSED;
732 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LATCHED)
733 led->which_groups |= XKB_STATE_LAYOUT_LATCHED;
734 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_LOCKED)
735 led->which_groups |= XKB_STATE_LAYOUT_LOCKED;
736 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_EFFECTIVE)
737 led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
738 if (wire->whichGroups & XCB_XKB_IM_GROUPS_WHICH_USE_COMPAT)
739 led->which_groups |= XKB_STATE_LAYOUT_EFFECTIVE;
740
741 led->groups = wire->groups;
742
743 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_BASE)
744 led->which_mods |= XKB_STATE_MODS_DEPRESSED;
745 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LATCHED)
746 led->which_mods |= XKB_STATE_MODS_LATCHED;
747 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_LOCKED)
748 led->which_mods |= XKB_STATE_MODS_LOCKED;
749 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_EFFECTIVE)
750 led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
751 if (wire->whichMods & XCB_XKB_IM_MODS_WHICH_USE_COMPAT)
752 led->which_mods |= XKB_STATE_MODS_EFFECTIVE;
753
754 led->mods.mods = translate_mods(wire->realMods, wire->vmods, 0);
755 led->mods.mask = translate_mods(wire->mods, 0, 0);
756
757 led->ctrls = translate_controls_mask(wire->ctrls);
758
759 xcb_xkb_indicator_map_next(&iter);
760 }
761 }
762
763 return true;
764 }
765
766 static bool
get_indicator_map(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_indicator_map_cookie_t cookie)767 get_indicator_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
768 xcb_xkb_get_indicator_map_cookie_t cookie)
769 {
770 xcb_xkb_get_indicator_map_reply_t *reply =
771 xcb_xkb_get_indicator_map_reply(conn, cookie, NULL);
772
773 FAIL_IF_BAD_REPLY(reply, "XkbGetIndicatorMap");
774
775 if (!get_indicators(keymap, conn, reply))
776 goto fail;
777
778 free(reply);
779 return true;
780
781 fail:
782 free(reply);
783 return false;
784 }
785
786 static bool
get_sym_interprets(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_compat_map_reply_t * reply)787 get_sym_interprets(struct xkb_keymap *keymap, xcb_connection_t *conn,
788 xcb_xkb_get_compat_map_reply_t *reply)
789 {
790 int length = xcb_xkb_get_compat_map_si_rtrn_length(reply);
791 xcb_xkb_sym_interpret_iterator_t iter =
792 xcb_xkb_get_compat_map_si_rtrn_iterator(reply);
793
794 FAIL_UNLESS(reply->firstSIRtrn == 0);
795 FAIL_UNLESS(reply->nSIRtrn == reply->nTotalSI);
796
797 keymap->num_sym_interprets = reply->nSIRtrn;
798 ALLOC_OR_FAIL(keymap->sym_interprets, keymap->num_sym_interprets);
799
800 for (int i = 0; i < length; i++) {
801 xcb_xkb_sym_interpret_t *wire = iter.data;
802 struct xkb_sym_interpret *sym_interpret = &keymap->sym_interprets[i];
803
804 sym_interpret->sym = wire->sym;
805
806 switch (wire->match & XCB_XKB_SYM_INTERP_MATCH_OP_MASK) {
807 case XCB_XKB_SYM_INTERPRET_MATCH_NONE_OF:
808 sym_interpret->match = MATCH_NONE;
809 break;
810 case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF_OR_NONE:
811 sym_interpret->match = MATCH_ANY_OR_NONE;
812 break;
813 case XCB_XKB_SYM_INTERPRET_MATCH_ANY_OF:
814 sym_interpret->match = MATCH_ANY;
815 break;
816 case XCB_XKB_SYM_INTERPRET_MATCH_ALL_OF:
817 sym_interpret->match = MATCH_ALL;
818 break;
819 case XCB_XKB_SYM_INTERPRET_MATCH_EXACTLY:
820 sym_interpret->match = MATCH_EXACTLY;
821 break;
822 }
823
824 sym_interpret->level_one_only =
825 (wire->match & XCB_XKB_SYM_INTERP_MATCH_LEVEL_ONE_ONLY);
826 sym_interpret->mods = wire->mods;
827
828 if (wire->virtualMod == NO_MODIFIER)
829 sym_interpret->virtual_mod = XKB_MOD_INVALID;
830 else
831 sym_interpret->virtual_mod = NUM_REAL_MODS + wire->virtualMod;
832
833 sym_interpret->repeat = (wire->flags & 0x01);
834 translate_action(&sym_interpret->action,
835 (xcb_xkb_action_t *) &wire->action);
836
837 xcb_xkb_sym_interpret_next(&iter);
838 }
839
840 return true;
841
842 fail:
843 return false;
844 }
845
846 static bool
get_compat_map(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_compat_map_cookie_t cookie)847 get_compat_map(struct xkb_keymap *keymap, xcb_connection_t *conn,
848 xcb_xkb_get_compat_map_cookie_t cookie)
849 {
850 xcb_xkb_get_compat_map_reply_t *reply =
851 xcb_xkb_get_compat_map_reply(conn, cookie, NULL);
852
853 FAIL_IF_BAD_REPLY(reply, "XkbGetCompatMap");
854
855 if (!get_sym_interprets(keymap, conn, reply))
856 goto fail;
857
858 free(reply);
859 return true;
860
861 fail:
862 free(reply);
863 return false;
864 }
865
866 static bool
get_type_names(struct xkb_keymap * keymap,struct x11_atom_interner * interner,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)867 get_type_names(struct xkb_keymap *keymap, struct x11_atom_interner *interner,
868 xcb_xkb_get_names_reply_t *reply,
869 xcb_xkb_get_names_value_list_t *list)
870 {
871 int key_type_names_length =
872 xcb_xkb_get_names_value_list_type_names_length(reply, list);
873 xcb_atom_t *key_type_names_iter =
874 xcb_xkb_get_names_value_list_type_names(list);
875 int n_levels_per_type_length =
876 xcb_xkb_get_names_value_list_n_levels_per_type_length(reply, list);
877 uint8_t *n_levels_per_type_iter =
878 xcb_xkb_get_names_value_list_n_levels_per_type(list);
879 xcb_atom_t *kt_level_names_iter =
880 xcb_xkb_get_names_value_list_kt_level_names(list);
881
882 FAIL_UNLESS(reply->nTypes == keymap->num_types);
883 FAIL_UNLESS(key_type_names_length == n_levels_per_type_length);
884
885 for (int i = 0; i < key_type_names_length; i++) {
886 xcb_atom_t wire_type_name = *key_type_names_iter;
887 uint8_t wire_num_levels = *n_levels_per_type_iter;
888 struct xkb_key_type *type = &keymap->types[i];
889
890 /* Levels must have names. */
891 FAIL_UNLESS(type->num_levels == wire_num_levels);
892
893 ALLOC_OR_FAIL(type->level_names, type->num_levels);
894
895 x11_atom_interner_adopt_atom(interner, wire_type_name, &type->name);
896 for (size_t j = 0; j < wire_num_levels; j++) {
897 x11_atom_interner_adopt_atom(interner, kt_level_names_iter[j],
898 &type->level_names[j]);
899 }
900
901 type->num_level_names = type->num_levels;
902 kt_level_names_iter += wire_num_levels;
903 key_type_names_iter++;
904 n_levels_per_type_iter++;
905 }
906
907 return true;
908
909 fail:
910 return false;
911 }
912
913 static bool
get_indicator_names(struct xkb_keymap * keymap,struct x11_atom_interner * interner,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)914 get_indicator_names(struct xkb_keymap *keymap,
915 struct x11_atom_interner *interner,
916 xcb_xkb_get_names_reply_t *reply,
917 xcb_xkb_get_names_value_list_t *list)
918 {
919 xcb_atom_t *iter = xcb_xkb_get_names_value_list_indicator_names(list);
920
921 FAIL_UNLESS(msb_pos(reply->indicators) <= keymap->num_leds);
922
923 for (unsigned i = 0; i < NUM_INDICATORS; i++) {
924 if (reply->indicators & (1u << i)) {
925 xcb_atom_t wire = *iter;
926 struct xkb_led *led = &keymap->leds[i];
927
928 x11_atom_interner_adopt_atom(interner, wire, &led->name);
929
930 iter++;
931 }
932 }
933
934 return true;
935
936 fail:
937 return false;
938 }
939
940 static bool
get_vmod_names(struct xkb_keymap * keymap,struct x11_atom_interner * interner,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)941 get_vmod_names(struct xkb_keymap *keymap, struct x11_atom_interner *interner,
942 xcb_xkb_get_names_reply_t *reply,
943 xcb_xkb_get_names_value_list_t *list)
944 {
945 xcb_atom_t *iter = xcb_xkb_get_names_value_list_virtual_mod_names(list);
946
947 /*
948 * GetMap's reply->virtualMods is always 0xffff. This one really
949 * tells us which vmods exist (a vmod must have a name), so we fix
950 * up the size here.
951 */
952 keymap->mods.num_mods =
953 NUM_REAL_MODS + MIN(msb_pos(reply->virtualMods), NUM_VMODS);
954
955 for (unsigned i = 0; i < NUM_VMODS; i++) {
956 if (reply->virtualMods & (1u << i)) {
957 xcb_atom_t wire = *iter;
958 struct xkb_mod *mod = &keymap->mods.mods[NUM_REAL_MODS + i];
959
960 x11_atom_interner_adopt_atom(interner, wire, &mod->name);
961
962 iter++;
963 }
964 }
965
966 return true;
967 }
968
969 static bool
get_group_names(struct xkb_keymap * keymap,struct x11_atom_interner * interner,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)970 get_group_names(struct xkb_keymap *keymap, struct x11_atom_interner *interner,
971 xcb_xkb_get_names_reply_t *reply,
972 xcb_xkb_get_names_value_list_t *list)
973 {
974 int length = xcb_xkb_get_names_value_list_groups_length(reply, list);
975 xcb_atom_t *iter = xcb_xkb_get_names_value_list_groups(list);
976
977 keymap->num_group_names = msb_pos(reply->groupNames);
978 ALLOC_OR_FAIL(keymap->group_names, keymap->num_group_names);
979
980 for (int i = 0; i < length; i++) {
981 x11_atom_interner_adopt_atom(interner, iter[i],
982 &keymap->group_names[i]);
983 }
984
985 return true;
986
987 fail:
988 return false;
989 }
990
991 static bool
get_key_names(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)992 get_key_names(struct xkb_keymap *keymap, xcb_connection_t *conn,
993 xcb_xkb_get_names_reply_t *reply,
994 xcb_xkb_get_names_value_list_t *list)
995 {
996 int length = xcb_xkb_get_names_value_list_key_names_length(reply, list);
997 xcb_xkb_key_name_iterator_t iter =
998 xcb_xkb_get_names_value_list_key_names_iterator(reply, list);
999
1000 FAIL_UNLESS(reply->minKeyCode == keymap->min_key_code);
1001 FAIL_UNLESS(reply->maxKeyCode == keymap->max_key_code);
1002 FAIL_UNLESS(reply->firstKey == keymap->min_key_code);
1003 FAIL_UNLESS(reply->firstKey + reply->nKeys - 1U == keymap->max_key_code);
1004
1005 for (int i = 0; i < length; i++) {
1006 xcb_xkb_key_name_t *wire = iter.data;
1007 xkb_atom_t *key_name = &keymap->keys[reply->firstKey + i].name;
1008
1009 if (wire->name[0] == '\0') {
1010 *key_name = XKB_ATOM_NONE;
1011 }
1012 else {
1013 *key_name = xkb_atom_intern(keymap->ctx, wire->name,
1014 strnlen(wire->name,
1015 XCB_XKB_CONST_KEY_NAME_LENGTH));
1016 if (!*key_name)
1017 return false;
1018 }
1019
1020 xcb_xkb_key_name_next(&iter);
1021 }
1022
1023 return true;
1024
1025 fail:
1026 return false;
1027 }
1028
1029 static bool
get_aliases(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_names_reply_t * reply,xcb_xkb_get_names_value_list_t * list)1030 get_aliases(struct xkb_keymap *keymap, xcb_connection_t *conn,
1031 xcb_xkb_get_names_reply_t *reply,
1032 xcb_xkb_get_names_value_list_t *list)
1033 {
1034 int length = xcb_xkb_get_names_value_list_key_aliases_length(reply, list);
1035 xcb_xkb_key_alias_iterator_t iter =
1036 xcb_xkb_get_names_value_list_key_aliases_iterator(reply, list);
1037
1038 keymap->num_key_aliases = reply->nKeyAliases;
1039 ALLOC_OR_FAIL(keymap->key_aliases, keymap->num_key_aliases);
1040
1041 for (int i = 0; i < length; i++) {
1042 xcb_xkb_key_alias_t *wire = iter.data;
1043 struct xkb_key_alias *alias = &keymap->key_aliases[i];
1044
1045 alias->real =
1046 xkb_atom_intern(keymap->ctx, wire->real,
1047 strnlen(wire->real, XCB_XKB_CONST_KEY_NAME_LENGTH));
1048 alias->alias =
1049 xkb_atom_intern(keymap->ctx, wire->alias,
1050 strnlen(wire->alias, XCB_XKB_CONST_KEY_NAME_LENGTH));
1051 if (!alias->real || !alias->alias)
1052 goto fail;
1053
1054 xcb_xkb_key_alias_next(&iter);
1055 }
1056
1057 return true;
1058
1059 fail:
1060 return false;
1061 }
1062
1063 static bool
get_names(struct xkb_keymap * keymap,struct x11_atom_interner * interner,xcb_xkb_get_names_cookie_t cookie)1064 get_names(struct xkb_keymap *keymap, struct x11_atom_interner *interner,
1065 xcb_xkb_get_names_cookie_t cookie)
1066 {
1067 xcb_connection_t *conn = interner->conn;
1068 xcb_xkb_get_names_reply_t *reply =
1069 xcb_xkb_get_names_reply(conn, cookie, NULL);
1070 xcb_xkb_get_names_value_list_t list;
1071
1072 FAIL_IF_BAD_REPLY(reply, "XkbGetNames");
1073
1074 FAIL_UNLESS((reply->which & get_names_required) == get_names_required);
1075
1076 xcb_xkb_get_names_value_list_unpack(xcb_xkb_get_names_value_list(reply),
1077 reply->nTypes,
1078 reply->indicators,
1079 reply->virtualMods,
1080 reply->groupNames,
1081 reply->nKeys,
1082 reply->nKeyAliases,
1083 reply->nRadioGroups,
1084 reply->which,
1085 &list);
1086
1087 x11_atom_interner_get_escaped_atom_name(interner, list.keycodesName,
1088 &keymap->keycodes_section_name);
1089 x11_atom_interner_get_escaped_atom_name(interner, list.symbolsName,
1090 &keymap->symbols_section_name);
1091 x11_atom_interner_get_escaped_atom_name(interner, list.typesName,
1092 &keymap->types_section_name);
1093 x11_atom_interner_get_escaped_atom_name(interner, list.compatName,
1094 &keymap->compat_section_name);
1095 if (!get_type_names(keymap, interner, reply, &list) ||
1096 !get_indicator_names(keymap, interner, reply, &list) ||
1097 !get_vmod_names(keymap, interner, reply, &list) ||
1098 !get_group_names(keymap, interner, reply, &list) ||
1099 !get_key_names(keymap, conn, reply, &list) ||
1100 !get_aliases(keymap, conn, reply, &list))
1101 goto fail;
1102
1103 free(reply);
1104 return true;
1105
1106 fail:
1107 free(reply);
1108 return false;
1109 }
1110
1111 static bool
get_controls(struct xkb_keymap * keymap,xcb_connection_t * conn,xcb_xkb_get_controls_cookie_t cookie)1112 get_controls(struct xkb_keymap *keymap, xcb_connection_t *conn,
1113 xcb_xkb_get_controls_cookie_t cookie)
1114 {
1115 xcb_xkb_get_controls_reply_t *reply =
1116 xcb_xkb_get_controls_reply(conn, cookie, NULL);
1117
1118 FAIL_IF_BAD_REPLY(reply, "XkbGetControls");
1119 FAIL_UNLESS(reply->numGroups > 0 && reply->numGroups <= 4);
1120
1121 keymap->enabled_ctrls = translate_controls_mask(reply->enabledControls);
1122 keymap->num_groups = reply->numGroups;
1123
1124 FAIL_UNLESS(keymap->max_key_code < XCB_XKB_CONST_PER_KEY_BIT_ARRAY_SIZE * 8);
1125
1126 for (xkb_keycode_t i = keymap->min_key_code; i <= keymap->max_key_code; i++)
1127 keymap->keys[i].repeats = (reply->perKeyRepeat[i / 8] & (1 << (i % 8)));
1128
1129 free(reply);
1130 return true;
1131
1132 fail:
1133 free(reply);
1134 return false;
1135 }
1136
1137 XKB_EXPORT struct xkb_keymap *
xkb_x11_keymap_new_from_device(struct xkb_context * ctx,xcb_connection_t * conn,int32_t device_id,enum xkb_keymap_compile_flags flags)1138 xkb_x11_keymap_new_from_device(struct xkb_context *ctx,
1139 xcb_connection_t *conn,
1140 int32_t device_id,
1141 enum xkb_keymap_compile_flags flags)
1142 {
1143 struct xkb_keymap *keymap;
1144 const enum xkb_keymap_format format = XKB_KEYMAP_FORMAT_TEXT_V1;
1145
1146 if (flags & ~(XKB_KEYMAP_COMPILE_NO_FLAGS)) {
1147 log_err_func(ctx, "unrecognized flags: %#x\n", flags);
1148 return NULL;
1149 }
1150
1151 if (device_id < 0 || device_id > 127) {
1152 log_err_func(ctx, "illegal device ID: %d\n", device_id);
1153 return NULL;
1154 }
1155
1156 keymap = xkb_keymap_new(ctx, format, flags);
1157 if (!keymap)
1158 return NULL;
1159
1160 struct x11_atom_interner interner;
1161 x11_atom_interner_init(&interner, ctx, conn);
1162
1163 /*
1164 * Send all requests together so only one roundtrip is needed
1165 * to get the replies.
1166 */
1167 xcb_xkb_get_map_cookie_t map_cookie =
1168 xcb_xkb_get_map(conn, device_id, get_map_required_components,
1169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
1170 xcb_xkb_get_indicator_map_cookie_t indicator_map_cookie =
1171 xcb_xkb_get_indicator_map(conn, device_id, ALL_INDICATORS_MASK);
1172 xcb_xkb_get_compat_map_cookie_t compat_map_cookie =
1173 xcb_xkb_get_compat_map(conn, device_id, 0, true, 0, 0);
1174 xcb_xkb_get_names_cookie_t names_cookie =
1175 xcb_xkb_get_names(conn, device_id, get_names_wanted);
1176 xcb_xkb_get_controls_cookie_t controls_cookie =
1177 xcb_xkb_get_controls(conn, device_id);
1178
1179 if (!get_map(keymap, conn, map_cookie))
1180 goto err_map;
1181 if (!get_indicator_map(keymap, conn, indicator_map_cookie))
1182 goto err_indicator_map;
1183 if (!get_compat_map(keymap, conn, compat_map_cookie))
1184 goto err_compat_map;
1185 if (!get_names(keymap, &interner, names_cookie))
1186 goto err_names;
1187 if (!get_controls(keymap, conn, controls_cookie))
1188 goto err_controls;
1189 x11_atom_interner_round_trip(&interner);
1190 if (interner.had_error)
1191 goto err_interner;
1192
1193 return keymap;
1194
1195 err_map:
1196 xcb_discard_reply(conn, indicator_map_cookie.sequence);
1197 err_indicator_map:
1198 xcb_discard_reply(conn, compat_map_cookie.sequence);
1199 err_compat_map:
1200 xcb_discard_reply(conn, names_cookie.sequence);
1201 err_names:
1202 xcb_discard_reply(conn, controls_cookie.sequence);
1203 err_controls:
1204 x11_atom_interner_round_trip(&interner);
1205 err_interner:
1206 xkb_keymap_unref(keymap);
1207 return NULL;
1208 }
1209