src/x11/keymap.c

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