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