diff options
Diffstat (limited to 'x11vnc/keyboard.c')
| -rw-r--r-- | x11vnc/keyboard.c | 2817 |
1 files changed, 2817 insertions, 0 deletions
diff --git a/x11vnc/keyboard.c b/x11vnc/keyboard.c new file mode 100644 index 0000000..1fba4c9 --- /dev/null +++ b/x11vnc/keyboard.c @@ -0,0 +1,2817 @@ +/* -- keyboard.c -- */ + +#include "x11vnc.h" +#include "xwrappers.h" +#include "xrecord.h" +#include "xinerama.h" +#include "pointer.h" +#include "userinput.h" +#include "win_utils.h" +#include "rates.h" +#include "cleanup.h" +#include "allowed_input_t.h" + +void get_keystate(int *keystate); +void clear_modifiers(int init); +int track_mod_state(rfbKeySym keysym, rfbBool down, rfbBool set); +void clear_keys(void); +int get_autorepeat_state(void); +int get_initial_autorepeat_state(void); +void autorepeat(int restore, int bequiet); +void check_add_keysyms(void); +int add_keysym(KeySym keysym); +void delete_added_keycodes(int bequiet); +void initialize_remap(char *infile); +int sloppy_key_check(int key, rfbBool down, rfbKeySym keysym, int *new); +void switch_to_xkb_if_better(void); +char *short_kmb(char *str); +void initialize_allowed_input(void); +void initialize_modtweak(void); +void initialize_keyboard_and_pointer(void); +void get_allowed_input(rfbClientPtr client, allowed_input_t *input); +double typing_rate(double time_window, int *repeating); +int skip_cr_when_scaling(char *mode); +void keyboard(rfbBool down, rfbKeySym keysym, rfbClientPtr client); + + +static void delete_keycode(KeyCode kc, int bequiet); +static int count_added_keycodes(void); +static void add_remap(char *line); +static void add_dead_keysyms(char *str); +static void initialize_xkb_modtweak(void); +static void xkb_tweak_keyboard(rfbBool down, rfbKeySym keysym, + rfbClientPtr client); +static void tweak_mod(signed char mod, rfbBool down); +static void modifier_tweak_keyboard(rfbBool down, rfbKeySym keysym, + rfbClientPtr client); +static void pipe_keyboard(rfbBool down, rfbKeySym keysym, rfbClientPtr client); + + +/* + * Routine to retreive current state keyboard. 1 means down, 0 up. + */ +void get_keystate(int *keystate) { + int i, k; + char keys[32]; + + /* n.b. caller decides to X_LOCK or not. */ + XQueryKeymap(dpy, keys); + for (i=0; i<32; i++) { + char c = keys[i]; + + for (k=0; k < 8; k++) { + if (c & 0x1) { + keystate[8*i + k] = 1; + } else { + keystate[8*i + k] = 0; + } + c = c >> 1; + } + } +} + +/* + * Try to KeyRelease any non-Lock modifiers that are down. + */ +void clear_modifiers(int init) { + static KeyCode keycodes[256]; + static KeySym keysyms[256]; + static char *keystrs[256]; + static int kcount = 0, first = 1; + int keystate[256]; + int i, j, minkey, maxkey, syms_per_keycode; + KeySym *keymap; + KeySym keysym; + KeyCode keycode; + + /* n.b. caller decides to X_LOCK or not. */ + if (first) { + /* + * we store results in static arrays, to aid interrupted + * case, but modifiers could have changed during session... + */ + XDisplayKeycodes(dpy, &minkey, &maxkey); + + keymap = XGetKeyboardMapping(dpy, minkey, (maxkey - minkey + 1), + &syms_per_keycode); + + for (i = minkey; i <= maxkey; i++) { + for (j = 0; j < syms_per_keycode; j++) { + keysym = keymap[ (i - minkey) * syms_per_keycode + j ]; + if (keysym == NoSymbol || ! ismodkey(keysym)) { + continue; + } + keycode = XKeysymToKeycode(dpy, keysym); + if (keycode == NoSymbol) { + continue; + } + keycodes[kcount] = keycode; + keysyms[kcount] = keysym; + keystrs[kcount] = strdup(XKeysymToString(keysym)); + kcount++; + } + } + XFree((void *) keymap); + first = 0; + } + if (init) { + return; + } + + get_keystate(keystate); + for (i=0; i < kcount; i++) { + keysym = keysyms[i]; + keycode = keycodes[i]; + + if (! keystate[(int) keycode]) { + continue; + } + + if (clear_mods) { + rfbLog("clear_modifiers: up: %-10s (0x%x) " + "keycode=0x%x\n", keystrs[i], keysym, keycode); + } + XTestFakeKeyEvent_wr(dpy, keycode, False, CurrentTime); + } + XFlush(dpy); +} + +static KeySym simple_mods[] = { + XK_Shift_L, XK_Shift_R, + XK_Control_L, XK_Control_R, + XK_Meta_L, XK_Meta_R, + XK_Alt_L, XK_Alt_R, + XK_Super_L, XK_Super_R, + XK_Hyper_L, XK_Hyper_R, + XK_Mode_switch, + NoSymbol +}; +#define NSIMPLE_MODS 13 + +int track_mod_state(rfbKeySym keysym, rfbBool down, rfbBool set) { + KeySym sym = (KeySym) keysym; + static rfbBool isdown[NSIMPLE_MODS]; + static int first = 1; + int i, cnt = 0; + + /* + * simple tracking method for the modifier state without + * contacting the Xserver. Ignores, of course what keys are + * pressed on the physical display. + * + * This is unrelated to our mod_tweak and xkb stuff. + * Just a simple thing for wireframe/scroll heuristics, + * sloppy keys etc. + */ + + if (first) { + for (i=0; i<NSIMPLE_MODS; i++) { + isdown[i] = FALSE; + } + first = 0; + } + + if (sym != NoSymbol) { + for (i=0; i<NSIMPLE_MODS; i++) { + if (sym == simple_mods[i]) { + if (set) { + isdown[i] = down; + return 1; + } else { + if (isdown[i]) { + return 1; + } else { + return 0; + } + } + break; + } + } + /* not a modifier */ + if (set) { + return 0; + } else { + return -1; + } + } + + /* called with NoSymbol: return number currently pressed: */ + for (i=0; i<NSIMPLE_MODS; i++) { + if (isdown[i]) { + cnt++; + } + } + return cnt; +} + +/* + * Attempt to set all keys to Up position. Can mess up typing at the + * physical keyboard so use with caution. + */ +void clear_keys(void) { + int k, keystate[256]; + + /* n.b. caller decides to X_LOCK or not. */ + get_keystate(keystate); + for (k=0; k<256; k++) { + if (keystate[k]) { + KeyCode keycode = (KeyCode) k; + rfbLog("clear_keys: keycode=%d\n", keycode); + XTestFakeKeyEvent_wr(dpy, keycode, False, CurrentTime); + } + } + XFlush(dpy); +} + +/* + * Kludge for -norepeat option: we turn off keystroke autorepeat in + * the X server when clients are connected. This may annoy people at + * the physical display. We do this because 'key down' and 'key up' + * user input events may be separated by 100s of ms due to screen fb + * processing or link latency, thereby inducing the X server to apply + * autorepeat when it should not. Since the *client* is likely doing + * keystroke autorepeating as well, it kind of makes sense to shut it + * off if no one is at the physical display... + */ +static int save_auto_repeat = -1; + +int get_autorepeat_state(void) { + XKeyboardState kstate; + X_LOCK; + XGetKeyboardControl(dpy, &kstate); + X_UNLOCK; + return kstate.global_auto_repeat; +} + +int get_initial_autorepeat_state(void) { + if (save_auto_repeat < 0) { + save_auto_repeat = get_autorepeat_state(); + } + return save_auto_repeat; +} + +void autorepeat(int restore, int bequiet) { + int global_auto_repeat; + XKeyboardControl kctrl; + + if (raw_fb && ! dpy) return; /* raw_fb hack */ + + if (restore) { + if (save_auto_repeat < 0) { + return; /* nothing to restore */ + } + global_auto_repeat = get_autorepeat_state(); + X_LOCK; + /* read state and skip restore if equal (e.g. no clients) */ + if (global_auto_repeat == save_auto_repeat) { + X_UNLOCK; + return; + } + + kctrl.auto_repeat_mode = save_auto_repeat; + XChangeKeyboardControl(dpy, KBAutoRepeatMode, &kctrl); + XFlush(dpy); + X_UNLOCK; + + if (! bequiet && ! quiet) { + rfbLog("Restored X server key autorepeat to: %d\n", + save_auto_repeat); + } + } else { + global_auto_repeat = get_autorepeat_state(); + if (save_auto_repeat < 0) { + /* + * we only remember the state at startup + * to avoid confusing ourselves later on. + */ + save_auto_repeat = global_auto_repeat; + } + + X_LOCK; + kctrl.auto_repeat_mode = AutoRepeatModeOff; + XChangeKeyboardControl(dpy, KBAutoRepeatMode, &kctrl); + XFlush(dpy); + X_UNLOCK; + + if (! bequiet && ! quiet) { + rfbLog("Disabled X server key autorepeat.\n"); + if (no_repeat_countdown >= 0) { + rfbLog(" to force back on run: 'xset r on' (%d " + "times)\n", no_repeat_countdown+1); + } + } + } +} + +/* + * We periodically delete any keysyms we have added, this is to + * lessen our effect on the X server state if we are terminated abruptly + * and cannot clear them and also to clear out any strange little used + * ones that would just fill up the keymapping. + */ +void check_add_keysyms(void) { + static time_t last_check = 0; + int clear_freq = 300, quiet = 1, count; + time_t now = time(0); + if (now > last_check + clear_freq) { + count = count_added_keycodes(); + /* + * only really delete if they have not typed recently + * and we have added 8 or more. + */ + if (now > last_keyboard_input + 5 && count >= 8) { + X_LOCK; + delete_added_keycodes(quiet); + X_UNLOCK; + } + last_check = now; + } +} + +static KeySym added_keysyms[0x100]; + +/* these are just for rfbLog messages: */ +static KeySym alltime_added_keysyms[1024]; +static int alltime_len = 1024; +static int alltime_num = 0; + +int add_keysym(KeySym keysym) { + int minkey, maxkey, syms_per_keycode; + int kc, n, ret = 0; + static int first = 1; + KeySym *keymap; + + if (first) { + for (n=0; n < 0x100; n++) { + added_keysyms[n] = NoSymbol; + } + first = 0; + } + + if (raw_fb && ! dpy) return 0; /* raw_fb hack */ + + if (keysym == NoSymbol) { + return 0; + } + /* there can be a race before MappingNotify */ + for (n=0; n < 0x100; n++) { + if (added_keysyms[n] == keysym) { + return n; + } + } + + XDisplayKeycodes(dpy, &minkey, &maxkey); + keymap = XGetKeyboardMapping(dpy, minkey, (maxkey - minkey + 1), + &syms_per_keycode); + + for (kc = minkey+1; kc <= maxkey; kc++) { + int i, j, didmsg = 0, is_empty = 1; + char *str; + KeySym new[8]; + + for (n=0; n < syms_per_keycode; n++) { + if (keymap[ (kc-minkey) * syms_per_keycode + n] + != NoSymbol) { + is_empty = 0; + break; + } + } + if (! is_empty) { + continue; + } + + for (i=0; i<8; i++) { + new[i] = NoSymbol; + } + if (add_keysyms == 2) { + new[0] = keysym; /* XXX remove me */ + } else { + for(i=0; i < syms_per_keycode; i++) { + new[i] = keysym; + if (i >= 7) break; + } + } + + XChangeKeyboardMapping(dpy, kc, syms_per_keycode, + new, 1); + + if (alltime_num >= alltime_len) { + didmsg = 1; /* something weird */ + } else { + for (j=0; j<alltime_num; j++) { + if (alltime_added_keysyms[j] == keysym) { + didmsg = 1; + break; + } + } + } + if (! didmsg) { + str = XKeysymToString(keysym); + rfbLog("added missing keysym to X display: %03d " + "0x%x \"%s\"\n", kc, keysym, str ? str : "null"); + + if (alltime_num < alltime_len) { + alltime_added_keysyms[alltime_num++] = keysym; + } + } + + XFlush(dpy); + added_keysyms[kc] = keysym; + ret = kc; + break; + } + XFree(keymap); + return ret; +} + +static void delete_keycode(KeyCode kc, int bequiet) { + int minkey, maxkey, syms_per_keycode, i; + KeySym *keymap; + KeySym ksym, new[8]; + char *str; + + if (raw_fb && ! dpy) return; /* raw_fb hack */ + + XDisplayKeycodes(dpy, &minkey, &maxkey); + keymap = XGetKeyboardMapping(dpy, minkey, (maxkey - minkey + 1), + &syms_per_keycode); + + for (i=0; i<8; i++) { + new[i] = NoSymbol; + } + + XChangeKeyboardMapping(dpy, kc, syms_per_keycode, new, 1); + + if (! bequiet && ! quiet) { + ksym = XKeycodeToKeysym(dpy, kc, 0); + str = XKeysymToString(ksym); + rfbLog("deleted keycode from X display: %03d 0x%x \"%s\"\n", + kc, ksym, str ? str : "null"); + } + + XFree(keymap); + XFlush(dpy); +} + +static int count_added_keycodes(void) { + int kc, count = 0; + for (kc = 0; kc < 0x100; kc++) { + if (added_keysyms[kc] != NoSymbol) { + count++; + } + } + return count; +} + +void delete_added_keycodes(int bequiet) { + int kc; + for (kc = 0; kc < 0x100; kc++) { + if (added_keysyms[kc] != NoSymbol) { + delete_keycode(kc, bequiet); + added_keysyms[kc] = NoSymbol; + } + } +} + +/* + * The following is for an experimental -remap option to allow the user + * to remap keystrokes. It is currently confusing wrt modifiers... + */ +typedef struct keyremap { + KeySym before; + KeySym after; + int isbutton; + struct keyremap *next; +} keyremap_t; + +static keyremap_t *keyremaps = NULL; + +static void add_remap(char *line) { + char str1[256], str2[256]; + KeySym ksym1, ksym2; + int isbtn = 0; + unsigned int i; + static keyremap_t *current = NULL; + keyremap_t *remap; + + if (sscanf(line, "%s %s", str1, str2) != 2) { + rfbLogEnable(1); + rfbLog("remap: invalid line: %s\n", line); + clean_up_exit(1); + } + if (sscanf(str1, "0x%x", &i) == 1) { + ksym1 = (KeySym) i; + } else { + ksym1 = XStringToKeysym(str1); + } + if (sscanf(str2, "0x%x", &i) == 1) { + ksym2 = (KeySym) i; + } else { + ksym2 = XStringToKeysym(str2); + } + if (ksym2 == NoSymbol) { + if (sscanf(str2, "Button%u", &i) == 1) { + ksym2 = (KeySym) i; + isbtn = 1; + } + } + if (ksym1 == NoSymbol || ksym2 == NoSymbol) { + rfbLog("warning: skipping invalid remap line: %s", line); + return; + } + remap = (keyremap_t *) malloc((size_t) sizeof(keyremap_t)); + remap->before = ksym1; + remap->after = ksym2; + remap->isbutton = isbtn; + remap->next = NULL; + + rfbLog("remapping: (%s, 0x%x) -> (%s, 0x%x) isbtn=%d\n", str1, + ksym1, str2, ksym2, isbtn); + + if (keyremaps == NULL) { + keyremaps = remap; + } else { + current->next = remap; + } + current = remap; +} + +static void add_dead_keysyms(char *str) { + char *p, *q; + int i; + char *list[] = { + "g grave dead_grave", + "a acute dead_acute", + "c asciicircum dead_circumflex", + "t asciitilde dead_tilde", + "m macron dead_macron", + "b breve dead_breve", + "D abovedot dead_abovedot", + "d diaeresis dead_diaeresis", + "o degree dead_abovering", + "A doubleacute dead_doubleacute", + "r caron dead_caron", + "e cedilla dead_cedilla", +/* "x XXX-ogonek dead_ogonek", */ +/* "x XXX-belowdot dead_belowdot", */ +/* "x XXX-hook dead_hook", */ +/* "x XXX-horn dead_horn", */ + NULL + }; + + p = str; + + while (*p != '\0') { + if (isspace(*p)) { + *p = '\0'; + } + p++; + } + + if (!strcmp(str, "DEAD")) { + for (i = 0; list[i] != NULL; i++) { + p = list[i] + 2; + add_remap(p); + } + } else if (!strcmp(str, "DEAD=missing")) { + for (i = 0; list[i] != NULL; i++) { + KeySym ksym, ksym2; + int inmap = 0; + + p = strdup(list[i] + 2); + q = strchr(p, ' '); + if (q == NULL) { + free(p); + continue; + } + *q = '\0'; + ksym = XStringToKeysym(p); + *q = ' '; + if (ksym == NoSymbol) { + free(p); + continue; + } + if (XKeysymToKeycode(dpy, ksym)) { + inmap = 1; + } +#if LIBVNCSERVER_HAVE_XKEYBOARD + if (! inmap && xkb_present) { + int kc, grp, lvl; + for (kc = 0; kc < 0x100; kc++) { + for (grp = 0; grp < 4; grp++) { + for (lvl = 0; lvl < 8; lvl++) { + ksym2 = XkbKeycodeToKeysym(dpy, + kc, grp, lvl); + if (ksym2 == NoSymbol) { + continue; + } + if (ksym2 == ksym) { + inmap = 1; + break; + } + } + } + } + } +#endif + if (! inmap) { + add_remap(p); + } + free(p); + } + } else if ((p = strchr(str, '=')) != NULL) { + while (*p != '\0') { + for (i = 0; list[i] != NULL; i++) { + q = list[i]; + if (*p == *q) { + q += 2; + add_remap(q); + break; + } + } + p++; + } + } +} + +/* + * process the -remap string (file or mapping string) + */ +void initialize_remap(char *infile) { + FILE *in; + char *p, *q, line[256]; + + if (keyremaps != NULL) { + /* free last remapping */ + keyremap_t *next_remap, *curr_remap = keyremaps; + while (curr_remap != NULL) { + next_remap = curr_remap->next; + free(curr_remap); + curr_remap = next_remap; + } + keyremaps = NULL; + } + if (infile == NULL || *infile == '\0') { + /* just unset remapping */ + return; + } + + in = fopen(infile, "r"); + if (in == NULL) { + /* assume cmd line key1-key2,key3-key4 */ + if (strstr(infile, "DEAD") == infile) { + ; + } else if (!strchr(infile, '-')) { + rfbLogEnable(1); + rfbLog("remap: cannot open: %s\n", infile); + rfbLogPerror("fopen"); + clean_up_exit(1); + } + if ((in = tmpfile()) == NULL) { + rfbLogEnable(1); + rfbLog("remap: cannot open tmpfile for %s\n", infile); + rfbLogPerror("tmpfile"); + clean_up_exit(1); + } + + /* copy in the string to file format */ + p = infile; + while (*p) { + if (*p == '-') { + fprintf(in, " "); + } else if (*p == ',' || *p == ' ' || *p == '\t') { + fprintf(in, "\n"); + } else { + fprintf(in, "%c", *p); + } + p++; + } + fprintf(in, "\n"); + fflush(in); + rewind(in); + } + + while (fgets(line, 256, in) != NULL) { + p = lblanks(line); + if (*p == '\0') { + continue; + } + if (strchr(line, '#')) { + continue; + } + + if (strstr(p, "DEAD") == p) { + add_dead_keysyms(p); + continue; + } + if ((q = strchr(line, '-')) != NULL) { + /* allow Keysym1-Keysym2 notation */ + *q = ' '; + } + add_remap(p); + } + fclose(in); +} + +/* + * preliminary support for using the Xkb (XKEYBOARD) extension for handling + * user input. inelegant, slow, and incomplete currently... but initial + * tests show it is useful for some setups. + */ +typedef struct keychar { + KeyCode code; + int group; + int level; +} keychar_t; + +/* max number of key groups and shift levels we consider */ +#define GRP 4 +#define LVL 8 +static int lvl_max, grp_max, kc_min, kc_max; +static KeySym xkbkeysyms[0x100][GRP][LVL]; +static unsigned int xkbstate[0x100][GRP][LVL]; +static unsigned int xkbignore[0x100][GRP][LVL]; +static unsigned int xkbmodifiers[0x100][GRP][LVL]; +static int multi_key[0x100], mode_switch[0x100], skipkeycode[0x100]; +static int shift_keys[0x100]; + +/* + * for trying to order the keycodes to avoid problems, note the + * *first* keycode bound to it. kc_vec will be a permutation + * of 1...256 to get them in the preferred order. + */ +static int kc_vec[0x100]; +static int kc1_shift, kc1_control, kc1_caplock, kc1_alt; +static int kc1_meta, kc1_numlock, kc1_super, kc1_hyper; +static int kc1_mode_switch, kc1_iso_level3_shift, kc1_multi_key; + +int sloppy_key_check(int key, rfbBool down, rfbKeySym keysym, int *new) { + if (!sloppy_keys) { + return 0; + } + + if (!down && !keycode_state[key] && !IsModifierKey(keysym)) { + int i, cnt = 0, downkey; + int nmods_down = track_mod_state(NoSymbol, FALSE, FALSE); + int mods_down[256]; + + if (nmods_down) { + /* tracking to skip down modifier keycodes. */ + for(i=0; i<256; i++) { + mods_down[i] = 0; + } + i = 0; + while (simple_mods[i] != NoSymbol) { + KeySym ksym = simple_mods[i]; + KeyCode k = XKeysymToKeycode(dpy, ksym); + if (k != NoSymbol && keycode_state[(int) k]) { + mods_down[(int) k] = 1; + } + + i++; + } + } + /* + * the keycode is already up... look for a single one + * (non modifier) that is down + */ + for (i=0; i<256; i++) { + if (keycode_state[i]) { + if (nmods_down && mods_down[i]) { + continue; + } + cnt++; + downkey = i; + } + } + if (cnt == 1) { + if (debug_keyboard) { + fprintf(stderr, " sloppy_keys: %d/0x%x " + "-> %d/0x%x (nmods: %d)\n", (int) key, + (int) key, downkey, downkey, nmods_down); + } + *new = downkey; + return 1; + } + } + return 0; +} + +#if !LIBVNCSERVER_HAVE_XKEYBOARD + +/* empty functions for no xkb */ +static void initialize_xkb_modtweak(void) {} +static void xkb_tweak_keyboard(rfbBool down, rfbKeySym keysym, + rfbClientPtr client) { +} +void switch_to_xkb_if_better(void) {} + +#else + +void switch_to_xkb_if_better(void) { + KeySym keysym, *keymap; + int miss_noxkb[256], miss_xkb[256], missing_noxkb = 0, missing_xkb = 0; + int i, j, k, n, minkey, maxkey, syms_per_keycode; + int syms_gt_4 = 0; + int kc, grp, lvl; + + /* non-alphanumeric on us keyboard */ + KeySym must_have[] = { + XK_exclam, + XK_at, + XK_numbersign, + XK_dollar, + XK_percent, +/* XK_asciicircum, */ + XK_ampersand, + XK_asterisk, + XK_parenleft, + XK_parenright, + XK_underscore, + XK_plus, + XK_minus, + XK_equal, + XK_bracketleft, + XK_bracketright, + XK_braceleft, + XK_braceright, + XK_bar, + XK_backslash, + XK_semicolon, +/* XK_apostrophe, */ + XK_colon, + XK_quotedbl, + XK_comma, + XK_period, + XK_less, + XK_greater, + XK_slash, + XK_question, +/* XK_asciitilde, */ +/* XK_grave, */ + NoSymbol + }; + + if (! use_modifier_tweak || got_noxkb) { + return; + } + if (use_xkb_modtweak) { + /* already using it */ + return; + } + + XDisplayKeycodes(dpy, &minkey, &maxkey); + + keymap = XGetKeyboardMapping(dpy, minkey, (maxkey - minkey + 1), + &syms_per_keycode); + + /* handle alphabetic char with only one keysym (no upper + lower) */ + for (i = minkey; i <= maxkey; i++) { + KeySym lower, upper; + /* 2nd one */ + keysym = keymap[(i - minkey) * syms_per_keycode + 1]; + if (keysym != NoSymbol) { + continue; + } + /* 1st one */ + keysym = keymap[(i - minkey) * syms_per_keycode + 0]; + if (keysym == NoSymbol) { + continue; + } + XConvertCase(keysym, &lower, &upper); + if (lower != upper) { + keymap[(i - minkey) * syms_per_keycode + 0] = lower; + keymap[(i - minkey) * syms_per_keycode + 1] = upper; + } + } + + k = 0; + while (must_have[k] != NoSymbol) { + int gotit = 0; + KeySym must = must_have[k]; + for (i = minkey; i <= maxkey; i++) { + for (j = 0; j < syms_per_keycode; j++) { + keysym = keymap[(i-minkey) * syms_per_keycode + j]; + if (j >= 4) { + if (k == 0 && keysym != NoSymbol) { + /* for k=0 count the high keysyms */ + syms_gt_4++; + if (debug_keyboard > 1) { + char *str = XKeysymToString(keysym); + fprintf(stderr, "- high keysym mapping" + ": at %3d j=%d " + "'%s'\n", i, j, str ? str:"null"); + } + } + continue; + } + if (keysym == must) { + if (debug_keyboard > 1) { + char *str = XKeysymToString(must); + fprintf(stderr, "- at %3d j=%d found " + "'%s'\n", i, j, str ? str:"null"); + } + /* n.b. do not break, see syms_gt_4 above. */ + gotit = 1; + } + } + } + if (! gotit) { + if (debug_keyboard > 1) { + char *str = XKeysymToString(must); + KeyCode kc = XKeysymToKeycode(dpy, must); + fprintf(stderr, "- did not find 0x%lx '%s'\t" + "Ks2Kc: %d\n", must, str ? str:"null", kc); + if (kc != None) { + int j2; + for(j2=0; j2<syms_per_keycode; j2++) { + keysym = keymap[(kc-minkey) * + syms_per_keycode + j2]; + fprintf(stderr, " %d=0x%lx", + j2, keysym); + } + fprintf(stderr, "\n"); + } + } + missing_noxkb++; + miss_noxkb[k] = 1; + } else { + miss_noxkb[k] = 0; + } + k++; + } + n = k; + + XFree(keymap); + if (missing_noxkb == 0 && syms_gt_4 >= 8) { + rfbLog("XKEYBOARD: number of keysyms per keycode %d " + "is greater\n", syms_per_keycode); + rfbLog(" than 4 and %d keysyms are mapped above 4.\n", + syms_gt_4); + rfbLog(" Automatically switching to -xkb mode.\n"); + rfbLog(" If this makes the key mapping worse you can\n"); + rfbLog(" disable it with the \"-noxkb\" option.\n"); + rfbLog(" Also, remember \"-remap DEAD\" for accenting" + " characters.\n"); + + use_xkb_modtweak = 1; + return; + + } else if (missing_noxkb == 0) { + rfbLog("XKEYBOARD: all %d \"must have\" keysyms accounted" + " for.\n", n); + rfbLog(" Not automatically switching to -xkb mode.\n"); + rfbLog(" If some keys still cannot be typed, try using" + " -xkb.\n"); + rfbLog(" Also, remember \"-remap DEAD\" for accenting" + " characters.\n"); + return; + } + + for (k=0; k<n; k++) { + miss_xkb[k] = 1; + } + + for (kc = 0; kc < 0x100; kc++) { + for (grp = 0; grp < GRP; grp++) { + for (lvl = 0; lvl < LVL; lvl++) { + /* look up the Keysym, if any */ + keysym = XkbKeycodeToKeysym(dpy, kc, grp, lvl); + if (keysym == NoSymbol) { + continue; + } + for (k=0; k<n; k++) { + if (keysym == must_have[k]) { + miss_xkb[k] = 0; + } + } + } + } + } + + for (k=0; k<n; k++) { + if (miss_xkb[k]) { + missing_xkb++; + } + } + + rfbLog("\n"); + if (missing_xkb < missing_noxkb) { + rfbLog("XKEYBOARD:\n"); + rfbLog("Switching to -xkb mode to recover these keysyms:\n"); + } else { + rfbLog("XKEYBOARD: \"must have\" keysyms better accounted" + " for\n"); + rfbLog("under -noxkb mode: not switching to -xkb mode:\n"); + } + + rfbLog(" xkb noxkb Keysym (\"X\" means present)\n"); + rfbLog(" --- ----- -----------------------------\n"); + for (k=0; k<n; k++) { + char *xx, *xn, *name; + + keysym = must_have[k]; + if (keysym == NoSymbol) { + continue; + } + if (!miss_xkb[k] && !miss_noxkb[k]) { + continue; + } + if (miss_xkb[k]) { + xx = " "; + } else { + xx = " X "; + } + if (miss_noxkb[k]) { + xn = " "; + } else { + xn = " X "; + } + name = XKeysymToString(keysym); + rfbLog(" %s %s 0x%lx %s\n", xx, xn, keysym, + name ? name : "null"); + } + rfbLog("\n"); + + if (missing_xkb < missing_noxkb) { + rfbLog(" If this makes the key mapping worse you can\n"); + rfbLog(" disable it with the \"-noxkb\" option.\n"); + rfbLog("\n"); + + use_xkb_modtweak = 1; + + } else { + rfbLog(" If some keys still cannot be typed, try using" + " -xkb.\n"); + rfbLog(" Also, remember \"-remap DEAD\" for accenting" + " characters.\n"); + } +} + +/* sets up all the keymapping info via Xkb API */ + +static void initialize_xkb_modtweak(void) { + KeySym ks; + int kc, grp, lvl, k; + unsigned int state; + +/* + * Here is a guide: + +Workarounds arrays: + +multi_key[] indicates which keycodes have Multi_key (Compose) + bound to them. +mode_switch[] indicates which keycodes have Mode_switch (AltGr) + bound to them. +shift_keys[] indicates which keycodes have Shift bound to them. +skipkeycode[] indicates which keycodes are to be skipped + for any lookups from -skip_keycodes option. + +Groups and Levels, here is an example: + + ^ -------- + | L2 | A AE | + shift | | + level L1 | a ae | + -------- + G1 G2 + + group -> + +Traditionally this it all a key could do. L1 vs. L2 selected via Shift +and G1 vs. G2 selected via Mode_switch. Up to 4 Keysyms could be bound +to a key. See initialize_modtweak() for an example of using that type +of keymap from XGetKeyboardMapping(). + +Xkb gives us up to 4 groups and 63 shift levels per key, with the +situation being potentially different for each key. This is complicated, +and I don't claim to understand it all, but in the following we just think +of ranging over the group and level indices as covering all of the cases. +This gives us an accurate view of the keymap. The main tricky part +is mapping between group+level and modifier state. + +On current linux/XFree86 setups (Xkb is enabled by default) the +information from XGetKeyboardMapping() (evidently the compat map) +is incomplete and inaccurate, so we are really forced to use the +Xkb API. + +xkbkeysyms[] For a (keycode,group,level) holds the KeySym (0 for none) +xkbstate[] For a (keycode,group,level) holds the corresponding + modifier state needed to get that KeySym +xkbignore[] For a (keycode,group,level) which modifiers can be + ignored (the 0 bits can be ignored). +xkbmodifiers[] For the KeySym bound to this (keycode,group,level) store + the modifier mask. + * + */ + + /* initialize all the arrays: */ + for (kc = 0; kc < 0x100; kc++) { + multi_key[kc] = 0; + mode_switch[kc] = 0; + skipkeycode[kc] = 0; + shift_keys[kc] = 0; + + for (grp = 0; grp < GRP; grp++) { + for (lvl = 0; lvl < LVL; lvl++) { + xkbkeysyms[kc][grp][lvl] = NoSymbol; + xkbmodifiers[kc][grp][lvl] = -1; + xkbstate[kc][grp][lvl] = -1; + } + } + } + + /* + * the array is 256*LVL*GRP, but we can make the searched region + * smaller by computing the actual ranges. + */ + lvl_max = 0; + grp_max = 0; + kc_max = 0; + kc_min = 0x100; + + /* first keycode for a modifier type (multi_key too) */ + kc1_shift = -1; + kc1_control = -1; + kc1_caplock = -1; + kc1_alt = -1; + kc1_meta = -1; + kc1_numlock = -1; + kc1_super = -1; + kc1_hyper = -1; + kc1_mode_switch = -1; + kc1_iso_level3_shift = -1; + kc1_multi_key = -1; + + /* + * loop over all possible (keycode, group, level) triples + * and record what we find for it: + */ + if (debug_keyboard > 1) { + rfbLog("initialize_xkb_modtweak: XKB keycode -> keysyms " + "mapping info:\n"); + } + for (kc = 0; kc < 0x100; kc++) { + for (grp = 0; grp < GRP; grp++) { + for (lvl = 0; lvl < LVL; lvl++) { + unsigned int ms, mods; + int state_save = -1, mods_save; + KeySym ks2; + + /* look up the Keysym, if any */ + ks = XkbKeycodeToKeysym(dpy, kc, grp, lvl); + xkbkeysyms[kc][grp][lvl] = ks; + + /* if no Keysym, on to next */ + if (ks == NoSymbol) { + continue; + } + /* + * for various workarounds, note where these special + * keys are bound to. + */ + if (ks == XK_Multi_key) { + multi_key[kc] = lvl+1; + } + if (ks == XK_Mode_switch) { + mode_switch[kc] = lvl+1; + } + if (ks == XK_Shift_L || ks == XK_Shift_R) { + shift_keys[kc] = lvl+1; + } + + if (ks == XK_Shift_L || ks == XK_Shift_R) { + if (kc1_shift == -1) { + kc1_shift = kc; + } + } + if (ks == XK_Control_L || ks == XK_Control_R) { + if (kc1_control == -1) { + kc1_control = kc; + } + } + if (ks == XK_Caps_Lock || ks == XK_Caps_Lock) { + if (kc1_caplock == -1) { + kc1_caplock = kc; + } + } + if (ks == XK_Alt_L || ks == XK_Alt_R) { + if (kc1_alt == -1) { + kc1_alt = kc; + } + } + if (ks == XK_Meta_L || ks == XK_Meta_R) { + if (kc1_meta == -1) { + kc1_meta = kc; + } + } + if (ks == XK_Num_Lock) { + if (kc1_numlock == -1) { + kc1_numlock = kc; + } + } + if (ks == XK_Super_L || ks == XK_Super_R) { + if (kc1_super == -1) { + kc1_super = kc; + } + } + if (ks == XK_Hyper_L || ks == XK_Hyper_R) { + if (kc1_hyper == -1) { + kc1_hyper = kc; + } + } + if (ks == XK_Mode_switch) { + if (kc1_mode_switch == -1) { + kc1_mode_switch = kc; + } + } + if (ks == XK_ISO_Level3_Shift) { + if (kc1_iso_level3_shift == -1) { + kc1_iso_level3_shift = kc; + } + } + if (ks == XK_Multi_key) { /* not a modifier.. */ + if (kc1_multi_key == -1) { + kc1_multi_key = kc; + } + } + + /* + * record maximum extent for group/level indices + * and keycode range: + */ + if (grp > grp_max) { + grp_max = grp; + } + if (lvl > lvl_max) { + lvl_max = lvl; + } + if (kc > kc_max) { + kc_max = kc; + } + if (kc < kc_min) { + kc_min = kc; + } + + /* + * lookup on *keysym* (i.e. not kc, grp, lvl) + * and get the modifier mask. this is 0 for + * most keysyms, only non zero for modifiers. + */ + ms = XkbKeysymToModifiers(dpy, ks); + xkbmodifiers[kc][grp][lvl] = ms; + + /* + * Amusing heuristic (may have bugs). There are + * 8 modifier bits, so 256 possible modifier + * states. We loop over all of them for this + * keycode (simulating Key "events") and ask + * XkbLookupKeySym to tell us the Keysym. Once it + * matches the Keysym we have for this (keycode, + * group, level), gotten via XkbKeycodeToKeysym() + * above, we then (hopefully...) know that state + * of modifiers needed to generate this keysym. + * + * Yes... keep your fingers crossed. + * + * Note that many of the 256 states give the + * Keysym, we just need one, and we take the + * first one found. + */ + state = 0; + while(state < 256) { + if (XkbLookupKeySym(dpy, kc, state, &mods, + &ks2)) { + + /* save these for workaround below */ + if (state_save == -1) { + state_save = state; + mods_save = mods; + } + if (ks2 == ks) { + /* + * zero the irrelevant bits + * by anding with mods. + */ + xkbstate[kc][grp][lvl] + = state & mods; + /* + * also remember the irrelevant + * bits since it is handy. + */ + xkbignore[kc][grp][lvl] = mods; + + break; + } + } + state++; + } + if (xkbstate[kc][grp][lvl] == (unsigned int) -1 + && grp == 1) { + /* + * Hack on Solaris 9 for Mode_switch + * for Group2 characters. We force the + * Mode_switch modifier bit on. + * XXX Need to figure out better what is + * happening here. Is compat on somehow?? + */ + unsigned int ms2; + ms2 = XkbKeysymToModifiers(dpy, XK_Mode_switch); + + xkbstate[kc][grp][lvl] + = (state_save & mods_save) | ms2; + + xkbignore[kc][grp][lvl] = mods_save | ms2; + } + + if (debug_keyboard > 1) { + fprintf(stderr, " %03d G%d L%d mod=%s ", + kc, grp+1, lvl+1, bitprint(ms, 8)); + fprintf(stderr, "state=%s ", + bitprint(xkbstate[kc][grp][lvl], 8)); + fprintf(stderr, "ignore=%s ", + bitprint(xkbignore[kc][grp][lvl], 8)); + fprintf(stderr, " ks=0x%08lx \"%s\"\n", + ks, XKeysymToString(ks)); + } + } + } + } + + /* + * kc_vec will be used in some places to find modifiers, etc + * we apply some permutations to it as workarounds. + */ + for (kc = 0; kc < 0x100; kc++) { + kc_vec[kc] = kc; + } + + if (kc1_mode_switch != -1 && kc1_iso_level3_shift != -1) { + if (kc1_mode_switch < kc1_iso_level3_shift) { + /* we prefer XK_ISO_Level3_Shift: */ + kc_vec[kc1_mode_switch] = kc1_iso_level3_shift; + kc_vec[kc1_iso_level3_shift] = kc1_mode_switch; + } + } + /* any more? need to watch for undoing the above. */ + + /* + * process the user supplied -skip_keycodes string. + * This is presumably a list if "ghost" keycodes, the X server + * thinks they exist, but they do not. ghosts can lead to + * ambiguities in the reverse map: Keysym -> KeyCode + Modstate, + * so if we can ignore them so much the better. Presumably the + * user can never generate them from the physical keyboard. + * There may be other reasons to deaden some keys. + */ + if (skip_keycodes != NULL) { + char *p, *str = strdup(skip_keycodes); + p = strtok(str, ", \t\n\r"); + while (p) { + k = 1; + if (sscanf(p, "%d", &k) != 1 || k < 0 || k >= 0x100) { + rfbLogEnable(1); + rfbLog("invalid skip_keycodes: %s %s\n", + skip_keycodes, p); + clean_up_exit(1); + } + skipkeycode[k] = 1; + p = strtok(NULL, ", \t\n\r"); + } + free(str); + } + if (debug_keyboard > 1) { + fprintf(stderr, "grp_max=%d lvl_max=%d\n", grp_max, lvl_max); + } +} + +/* + * Called on user keyboard input. Try to solve the reverse mapping + * problem: KeySym (from VNC client) => KeyCode(s) to press to generate + * it. The one-to-many KeySym => KeyCode mapping makes it difficult, as + * does working out what changes to the modifier keypresses are needed. + */ +static void xkb_tweak_keyboard(rfbBool down, rfbKeySym keysym, + rfbClientPtr client) { + + int kc, grp, lvl, i, kci; + int kc_f[0x100], grp_f[0x100], lvl_f[0x100], state_f[0x100], found; + int ignore_f[0x100]; + unsigned int state; + + + /* these are used for finding modifiers, etc */ + XkbStateRec kbstate; + int got_kbstate = 0; + int Kc_f, Grp_f, Lvl_f; + static int Kc_last_down = -1; + static KeySym Ks_last_down = NoSymbol; + + if (client) {} /* unused vars warning: */ + + X_LOCK; + + if (debug_keyboard) { + char *str = XKeysymToString(keysym); + + if (debug_keyboard > 1) { + rfbLog("----------start-xkb_tweak_keyboard (%s) " + "--------\n", down ? "DOWN" : "UP"); + } + + rfbLog("xkb_tweak_keyboard: %s keysym=0x%x \"%s\"\n", + down ? "down" : "up", (int) keysym, str ? str : "null"); + } + + /* + * set everything to not-yet-found. + * these "found" arrays (*_f) let us dynamically consider the + * one-to-many Keysym -> Keycode issue. we set the size at 256, + * but of course only very few will be found. + */ + for (i = 0; i < 0x100; i++) { + kc_f[i] = -1; + grp_f[i] = -1; + lvl_f[i] = -1; + state_f[i] = -1; + ignore_f[i] = -1; + } + found = 0; + + /* + * loop over all (keycode, group, level) triples looking for + * matching keysyms. Amazingly this isn't slow (but maybe if + * you type really fast...). Hash lookup into a linked list of + * (keycode,grp,lvl) triples would be the way to improve this + * in the future if needed. + */ + for (kc = kc_min; kc <= kc_max; kc++) { + for (grp = 0; grp < grp_max+1; grp++) { + for (lvl = 0; lvl < lvl_max+1; lvl++) { + if (keysym != xkbkeysyms[kc][grp][lvl]) { + continue; + } + /* got a keysym match */ + state = xkbstate[kc][grp][lvl]; + + if (debug_keyboard > 1) { + fprintf(stderr, " got match kc=%03d=0x%02x G%d" + " L%d ks=0x%x \"%s\" (basesym: \"%s\")\n", + kc, kc, grp+1, lvl+1, keysym, + XKeysymToString(keysym), XKeysymToString( + XKeycodeToKeysym(dpy, kc, 0))); + fprintf(stderr, " need state: %s\n", + bitprint(state, 8)); + fprintf(stderr, " ignorable : %s\n", + bitprint(xkbignore[kc][grp][lvl], 8)); + } + + /* save it if state is OK and not told to skip */ + if (state == (unsigned int) -1) { + continue; + } + if (skipkeycode[kc] && debug_keyboard) { + fprintf(stderr, " xxx skipping keycode: %d " + "G%d/L%d\n", kc, grp+1, lvl+1); + } + if (skipkeycode[kc]) { + continue; + } + if (found > 0 && kc == kc_f[found-1]) { + /* ignore repeats for same keycode */ + continue; + } + kc_f[found] = kc; + grp_f[found] = grp; + lvl_f[found] = lvl; + state_f[found] = state; + ignore_f[found] = xkbignore[kc][grp][lvl]; + found++; + } + } + } + +#define PKBSTATE \ + fprintf(stderr, " --- current mod state:\n"); \ + fprintf(stderr, " mods : %s\n", bitprint(kbstate.mods, 8)); \ + fprintf(stderr, " base_mods : %s\n", bitprint(kbstate.base_mods, 8)); \ + fprintf(stderr, " latch_mods: %s\n", bitprint(kbstate.latched_mods, 8)); \ + fprintf(stderr, " lock_mods : %s\n", bitprint(kbstate.locked_mods, 8)); \ + fprintf(stderr, " compat : %s\n", bitprint(kbstate.compat_state, 8)); + + /* + * Now get the current state of the keyboard from the X server. + * This seems to be the safest way to go as opposed to our + * keeping track of the modifier state on our own. Again, + * this is fortunately not too slow. + */ + + if (debug_keyboard > 1) { + /* get state early for debug output */ + XkbGetState(dpy, XkbUseCoreKbd, &kbstate); + got_kbstate = 1; + PKBSTATE + } + + if (!found && add_keysyms && keysym && ! IsModifierKey(keysym)) { + int new_kc = add_keysym(keysym); + if (new_kc != 0) { + found = 1; + kc_f[0] = new_kc; + grp_f[0] = 0; + lvl_f[0] = 0; + state_f[0] = 0; + } + } + + if (!found && debug_keyboard) { + char *str = XKeysymToString(keysym); + fprintf(stderr, " *** NO key found for: 0x%x %s " + "*keystroke ignored*\n", keysym, str ? str : "null"); + } + if (!found) { + X_UNLOCK; + return; + } + + /* + * we try to optimize here if found > 1 + * e.g. minimize lvl or grp, or other things to give + * "safest" scenario to simulate the keystrokes. + */ + + if (found > 1) { + if (down) { + int l, score[0x100]; + int best, best_score = -1; + /* need to break the tie... */ + if (! got_kbstate) { + XkbGetState(dpy, XkbUseCoreKbd, &kbstate); + got_kbstate = 1; + } + for (l=0; l < found; l++) { + int myscore = 0, b = 0x1, i; + int curr, curr_state = kbstate.mods; + int need, need_state = state_f[l]; + int ignore_state = ignore_f[l]; + + /* see how many modifiers need to be changed */ + for (i=0; i<8; i++) { + curr = b & curr_state; + need = b & need_state; + if (! (b & ignore_state)) { + ; + } else if (curr == need) { + ; + } else { + myscore++; + } + b = b << 1; + } + myscore *= 100; + + /* throw in some minimization of lvl too: */ + myscore += 2*lvl_f[l] + grp_f[l]; + + /* + * XXX since we now internally track + * keycode_state[], we could throw that into + * the score as well. I.e. if it is already + * down, it is pointless to think we can + * press it down further! E.g. + * myscore += 1000 * keycode_state[kc_f[l]]; + * Also could watch multiple modifier + * problem, e.g. Shift+key -> Alt + * keycode = 125 on my keyboard. + */ + + score[l] = myscore; + if (debug_keyboard > 1) { + fprintf(stderr, " *** score for " + "keycode %03d: %4d\n", + kc_f[l], myscore); + } + } + for (l=0; l < found; l++) { + int myscore = score[l]; + if (best_score == -1 || myscore < best_score) { + best = l; + best_score = myscore; + } + } + Kc_f = kc_f[best]; + Grp_f = grp_f[best]; + Lvl_f = lvl_f[best]; + state = state_f[best]; + + } else { + /* up */ + Kc_f = -1; + if (keysym == Ks_last_down) { + int l; + for (l=0; l < found; l++) { + if (Kc_last_down == kc_f[l]) { + Kc_f = Kc_last_down; + break; + } + } + } + if (Kc_f == -1) { + int l; + /* + * If it is already down, that is + * a great hint. Use it. + * + * note: keycode_state in internal and + * ignores someone pressing keys on the + * physical display (but is updated + * periodically to clean out stale info). + */ + for (l=0; l < found; l++) { + int key = (int) kc_f[l]; + if (keycode_state[key]) { + Kc_f = kc_f[l]; + break; + } + } + } + + if (Kc_f == -1) { + /* hope for the best... XXX check mods */ + Kc_f = kc_f[0]; + } + } + } else { + Kc_f = kc_f[0]; + Grp_f = grp_f[0]; + Lvl_f = lvl_f[0]; + state = state_f[0]; + } + + if (debug_keyboard && found > 1) { + int l; + char *str; + fprintf(stderr, " *** found more than one keycode: "); + for (l = 0; l < found; l++) { + fprintf(stderr, "%03d ", kc_f[l]); + } + for (l = 0; l < found; l++) { + str = XKeysymToString(XKeycodeToKeysym(dpy,kc_f[l],0)); + fprintf(stderr, " \"%s\"", str ? str : "null"); + } + fprintf(stderr, ", picked this one: %03d (last down: %03d)\n", + Kc_f, Kc_last_down); + } + + if (sloppy_keys) { + int new_kc; + if (sloppy_key_check(Kc_f, down, keysym, &new_kc)) { + Kc_f = new_kc; + } + } + + if (down) { + /* + * need to set up the mods for tweaking and other workarounds + */ + int needmods[8], sentmods[8], Ilist[8], keystate[256]; + int involves_multi_key, shift_is_down; + int i, j, b, curr, need; + unsigned int ms; + KeySym ks; + Bool dn; + + /* remember these to aid the subsequent up case: */ + Ks_last_down = keysym; + Kc_last_down = Kc_f; + + if (! got_kbstate) { + /* get the current modifier state if we haven't yet */ + XkbGetState(dpy, XkbUseCoreKbd, &kbstate); + got_kbstate = 1; + } + + /* + * needmods[] whether or not that modifier bit needs + * something done to it. + * < 0 means no, + * 0 means needs to go up. + * 1 means needs to go down. + * + * -1, -2, -3 are used for debugging info to indicate + * why nothing needs to be done with the modifier, see below. + * + * sentmods[] is the corresponding keycode to use + * to acheive the needmods[] requirement for the bit. + */ + + for (i=0; i<8; i++) { + needmods[i] = -1; + sentmods[i] = 0; + } + + /* + * Loop over the 8 modifier bits and check if the current + * setting is what we need it to be or whether it should + * be changed (by us sending some keycode event) + * + * If nothing needs to be done to it record why: + * -1 the modifier bit is ignored. + * -2 the modifier bit is ignored, but is correct anyway. + * -3 the modifier bit is correct. + */ + + b = 0x1; + for (i=0; i<8; i++) { + curr = b & kbstate.mods; + need = b & state; + + if (! (b & xkbignore[Kc_f][Grp_f][Lvl_f])) { + /* irrelevant modifier bit */ + needmods[i] = -1; + if (curr == need) needmods[i] = -2; + } else if (curr == need) { + /* already correct */ + needmods[i] = -3; + } else if (! curr && need) { + /* need it down */ + needmods[i] = 1; + } else if (curr && ! need) { + /* need it up */ + needmods[i] = 0; + } + + b = b << 1; + } + + /* + * Again we dynamically probe the X server for information, + * this time for the state of all the keycodes. Useful + * info, and evidently is not too slow... + */ + get_keystate(keystate); + + /* + * We try to determine if Shift is down (since that can + * screw up ISO_Level3_Shift manipulations). + */ + shift_is_down = 0; + + for (kc = kc_min; kc <= kc_max; kc++) { + if (skipkeycode[kc] && debug_keyboard) { + fprintf(stderr, " xxx skipping keycode: " + "%d\n", kc); + } + if (skipkeycode[kc]) { + continue; + } + if (shift_keys[kc] && keystate[kc]) { + shift_is_down = kc; + break; + } + } + + /* + * Now loop over the modifier bits and try to deduce the + * keycode presses/release require to match the desired + * state. + */ + for (i=0; i<8; i++) { + if (needmods[i] < 0 && debug_keyboard > 1) { + int k = -needmods[i] - 1; + char *words[] = {"ignorable", + "bitset+ignorable", "bitset"}; + fprintf(stderr, " +++ needmods: mod=%d is " + "OK (%s)\n", i, words[k]); + } + if (needmods[i] < 0) { + continue; + } + + b = 1 << i; + + if (debug_keyboard > 1) { + fprintf(stderr, " +++ needmods: mod=%d %s " + "need it to be: %d %s\n", i, bitprint(b, 8), + needmods[i], needmods[i] ? "down" : "up"); + } + + /* + * Again, an inefficient loop, this time just + * looking for modifiers... + * + * note the use of kc_vec to prefer XK_ISO_Level3_Shift + * over XK_Mode_switch. + */ + for (kci = kc_min; kci <= kc_max; kci++) { + for (grp = 0; grp < grp_max+1; grp++) { + for (lvl = 0; lvl < lvl_max+1; lvl++) { + int skip = 1, dbmsg = 0; + + kc = kc_vec[kci]; + + ms = xkbmodifiers[kc][grp][lvl]; + if (! ms || ms != (unsigned int) b) { + continue; + } + + if (skipkeycode[kc] && debug_keyboard) { + fprintf(stderr, " xxx skipping keycode:" + " %d G%d/L%d\n", kc, grp+1, lvl+1); + } + if (skipkeycode[kc]) { + continue; + } + + ks = xkbkeysyms[kc][grp][lvl]; + if (! ks) { + continue; + } + + if (ks == XK_Shift_L) { + skip = 0; + } else if (ks == XK_Shift_R) { + skip = 0; + } else if (ks == XK_Mode_switch) { + skip = 0; + } else if (ks == XK_ISO_Level3_Shift) { + skip = 0; + } + /* + * Alt, Meta, Control, Super, + * Hyper, Num, Caps are skipped. + * + * XXX need more work on Locks, + * and non-standard modifiers. + * (e.g. XF86_Next_VMode using + * Ctrl+Alt) + */ + if (debug_keyboard > 1) { + char *str = XKeysymToString(ks); + int kt = keystate[kc]; + fprintf(stderr, " === for mod=%s " + "found kc=%03d/G%d/L%d it is %d " + "%s skip=%d (%s)\n", bitprint(b,8), + kc, grp+1, lvl+1, kt, kt ? + "down" : "up ", skip, str ? + str : "null"); + } + + if (! skip && needmods[i] != + keystate[kc] && sentmods[i] == 0) { + sentmods[i] = kc; + dbmsg = 1; + } + + if (debug_keyboard > 1 && dbmsg) { + int nm = needmods[i]; + fprintf(stderr, " >>> we choose " + "kc=%03d=0x%02x to change it to: " + "%d %s\n", kc, kc, nm, nm ? + "down" : "up"); + } + + } + } + } + } + for (i=0; i<8; i++) { + /* + * reverse order is useful for tweaking + * ISO_Level3_Shift before Shift, but assumes they + * are in that order (i.e. Shift is first bit). + */ + int reverse = 1; + if (reverse) { + Ilist[i] = 7 - i; + } else { + Ilist[i] = i; + } + } + + /* + * check to see if Multi_key is bound to one of the Mods + * we have to tweak + */ + involves_multi_key = 0; + for (j=0; j<8; j++) { + i = Ilist[j]; + if (sentmods[i] == 0) continue; + dn = (Bool) needmods[i]; + if (!dn) continue; + if (multi_key[sentmods[i]]) { + involves_multi_key = i+1; + } + } + + if (involves_multi_key && shift_is_down && needmods[0] < 0) { + /* + * Workaround for Multi_key and shift. + * Assumes Shift is bit 1 (needmods[0]) + */ + if (debug_keyboard) { + fprintf(stderr, " ^^^ trying to avoid " + "inadvertent Multi_key from Shift " + "(doing %03d up now)\n", shift_is_down); + } + XTestFakeKeyEvent_wr(dpy, shift_is_down, False, + CurrentTime); + } else { + involves_multi_key = 0; + } + + for (j=0; j<8; j++) { + /* do the Mod ups */ + i = Ilist[j]; + if (sentmods[i] == 0) continue; + dn = (Bool) needmods[i]; + if (dn) continue; + XTestFakeKeyEvent_wr(dpy, sentmods[i], dn, CurrentTime); + } + for (j=0; j<8; j++) { + /* next, do the Mod downs */ + i = Ilist[j]; + if (sentmods[i] == 0) continue; + dn = (Bool) needmods[i]; + if (!dn) continue; + XTestFakeKeyEvent_wr(dpy, sentmods[i], dn, CurrentTime); + } + + if (involves_multi_key) { + /* + * Reverse workaround for Multi_key and shift. + */ + if (debug_keyboard) { + fprintf(stderr, " vvv trying to avoid " + "inadvertent Multi_key from Shift " + "(doing %03d down now)\n", shift_is_down); + } + XTestFakeKeyEvent_wr(dpy, shift_is_down, True, + CurrentTime); + } + + /* + * With the above modifier work done, send the actual keycode: + */ + XTestFakeKeyEvent_wr(dpy, Kc_f, (Bool) down, CurrentTime); + + /* + * Now undo the modifier work: + */ + for (j=7; j>=0; j--) { + /* reverse Mod downs we did */ + i = Ilist[j]; + if (sentmods[i] == 0) continue; + dn = (Bool) needmods[i]; + if (!dn) continue; + XTestFakeKeyEvent_wr(dpy, sentmods[i], !dn, + CurrentTime); + } + for (j=7; j>=0; j--) { + /* finally reverse the Mod ups we did */ + i = Ilist[j]; + if (sentmods[i] == 0) continue; + dn = (Bool) needmods[i]; + if (dn) continue; + XTestFakeKeyEvent_wr(dpy, sentmods[i], !dn, + CurrentTime); + } + + } else { /* for up case, hopefully just need to pop it up: */ + + XTestFakeKeyEvent_wr(dpy, Kc_f, (Bool) down, CurrentTime); + } + X_UNLOCK; +} +#endif + +/* + * For tweaking modifiers wrt the Alt-Graph key, etc. + */ +#define LEFTSHIFT 1 +#define RIGHTSHIFT 2 +#define ALTGR 4 +static char mod_state = 0; + +static char modifiers[0x100]; +static KeyCode keycodes[0x100]; +static KeyCode left_shift_code, right_shift_code, altgr_code, iso_level3_code; + +/* workaround for X11R5, Latin 1 only */ +#ifndef XConvertCase +#define XConvertCase(sym, lower, upper) \ +*(lower) = sym; \ +*(upper) = sym; \ +if (sym >> 8 == 0) { \ + if ((sym >= XK_A) && (sym <= XK_Z)) \ + *(lower) += (XK_a - XK_A); \ + else if ((sym >= XK_a) && (sym <= XK_z)) \ + *(upper) -= (XK_a - XK_A); \ + else if ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) \ + *(lower) += (XK_agrave - XK_Agrave); \ + else if ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) \ + *(upper) -= (XK_agrave - XK_Agrave); \ + else if ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) \ + *(lower) += (XK_oslash - XK_Ooblique); \ + else if ((sym >= XK_oslash) && (sym <= XK_thorn)) \ + *(upper) -= (XK_oslash - XK_Ooblique); \ +} +#endif + +char *short_kmb(char *str) { + int i, saw_k = 0, saw_m = 0, saw_b = 0, n = 10; + char *p, tmp[10]; + + for (i=0; i<n; i++) { + tmp[i] = '\0'; + } + + p = str; + i = 0; + while (*p) { + if ((*p == 'K' || *p == 'k') && !saw_k) { + tmp[i++] = 'K'; + saw_k = 1; + } else if ((*p == 'M' || *p == 'm') && !saw_m) { + tmp[i++] = 'M'; + saw_m = 1; + } else if ((*p == 'B' || *p == 'b') && !saw_b) { + tmp[i++] = 'B'; + saw_b = 1; + } + p++; + } + return(strdup(tmp)); +} + +void initialize_allowed_input(void) { + char *str; + + if (allowed_input_normal) { + free(allowed_input_normal); + allowed_input_normal = NULL; + } + if (allowed_input_view_only) { + free(allowed_input_view_only); + allowed_input_view_only = NULL; + } + + if (! allowed_input_str) { + allowed_input_normal = strdup("KMB"); + allowed_input_view_only = strdup(""); + } else { + char *p, *str = strdup(allowed_input_str); + p = strchr(str, ','); + if (p) { + allowed_input_view_only = strdup(p+1); + *p = '\0'; + allowed_input_normal = strdup(str); + } else { + allowed_input_normal = strdup(str); + allowed_input_view_only = strdup(""); + } + free(str); + } + + /* shorten them */ + str = short_kmb(allowed_input_normal); + free(allowed_input_normal); + allowed_input_normal = str; + + str = short_kmb(allowed_input_view_only); + free(allowed_input_view_only); + allowed_input_view_only = str; + + if (screen) { + rfbClientIteratorPtr iter; + rfbClientPtr cl; + + iter = rfbGetClientIterator(screen); + while( (cl = rfbClientIteratorNext(iter)) ) { + ClientData *cd = (ClientData *) cl->clientData; + + if (cd->input[0] == '=') { + ; /* custom setting */ + } else if (cd->login_viewonly) { + if (*allowed_input_view_only != '\0') { + cl->viewOnly = FALSE; + cd->input[0] = '\0'; + strncpy(cd->input, + allowed_input_view_only, CILEN); + } else { + cl->viewOnly = TRUE; + } + } else { + if (allowed_input_normal) { + cd->input[0] = '\0'; + strncpy(cd->input, + allowed_input_normal, CILEN); + } + } + } + rfbReleaseClientIterator(iter); + } +} + +void initialize_modtweak(void) { + KeySym keysym, *keymap; + int i, j, minkey, maxkey, syms_per_keycode; + + if (use_xkb_modtweak) { + initialize_xkb_modtweak(); + return; + } + memset(modifiers, -1, sizeof(modifiers)); + for (i=0; i<0x100; i++) { + keycodes[i] = NoSymbol; + } + + X_LOCK; + XDisplayKeycodes(dpy, &minkey, &maxkey); + + keymap = XGetKeyboardMapping(dpy, minkey, (maxkey - minkey + 1), + &syms_per_keycode); + + /* handle alphabetic char with only one keysym (no upper + lower) */ + for (i = minkey; i <= maxkey; i++) { + KeySym lower, upper; + /* 2nd one */ + keysym = keymap[(i - minkey) * syms_per_keycode + 1]; + if (keysym != NoSymbol) { + continue; + } + /* 1st one */ + keysym = keymap[(i - minkey) * syms_per_keycode + 0]; + if (keysym == NoSymbol) { + continue; + } + XConvertCase(keysym, &lower, &upper); + if (lower != upper) { + keymap[(i - minkey) * syms_per_keycode + 0] = lower; + keymap[(i - minkey) * syms_per_keycode + 1] = upper; + } + } + for (i = minkey; i <= maxkey; i++) { + if (debug_keyboard) { + if (i == minkey) { + rfbLog("initialize_modtweak: keycode -> " + "keysyms mapping info:\n"); + } + fprintf(stderr, " %03d ", i); + } + for (j = 0; j < syms_per_keycode; j++) { + if (debug_keyboard) { + char *sym; +#if 0 + sym =XKeysymToString(XKeycodeToKeysym(dpy,i,j)); +#else + keysym = keymap[(i-minkey)*syms_per_keycode+j]; + sym = XKeysymToString(keysym); +#endif + fprintf(stderr, "%-18s ", sym ? sym : "null"); + if (j == syms_per_keycode - 1) { + fprintf(stderr, "\n"); + } + } + if (j >= 4) { + /* + * Something wacky in the keymapping. + * Ignore these non Shift/AltGr chords + * for now... n.b. we try to automatically + * switch to -xkb for this case. + */ + continue; + } + keysym = keymap[ (i - minkey) * syms_per_keycode + j ]; + if ( keysym >= ' ' && keysym < 0x100 + && i == XKeysymToKeycode(dpy, keysym) ) { + keycodes[keysym] = i; + modifiers[keysym] = j; + } + } + } + + left_shift_code = XKeysymToKeycode(dpy, XK_Shift_L); + right_shift_code = XKeysymToKeycode(dpy, XK_Shift_R); + altgr_code = XKeysymToKeycode(dpy, XK_Mode_switch); + iso_level3_code = NoSymbol; +#ifdef XK_ISO_Level3_Shift + iso_level3_code = XKeysymToKeycode(dpy, XK_ISO_Level3_Shift); +#endif + + XFree ((void *) keymap); + + X_UNLOCK; +} + +/* + * does the actual tweak: + */ +static void tweak_mod(signed char mod, rfbBool down) { + rfbBool is_shift = mod_state & (LEFTSHIFT|RIGHTSHIFT); + Bool dn = (Bool) down; + KeyCode altgr = altgr_code; + + if (mod < 0) { + if (debug_keyboard) { + rfbLog("tweak_mod: Skip: down=%d index=%d\n", down, + (int) mod); + } + return; + } + if (debug_keyboard) { + rfbLog("tweak_mod: Start: down=%d index=%d mod_state=0x%x" + " is_shift=%d\n", down, (int) mod, (int) mod_state, + is_shift); + } + + if (use_iso_level3 && iso_level3_code) { + altgr = iso_level3_code; + } + + X_LOCK; + if (is_shift && mod != 1) { + if (mod_state & LEFTSHIFT) { + XTestFakeKeyEvent_wr(dpy, left_shift_code, !dn, CurrentTime); + } + if (mod_state & RIGHTSHIFT) { + XTestFakeKeyEvent_wr(dpy, right_shift_code, !dn, CurrentTime); + } + } + if ( ! is_shift && mod == 1 ) { + XTestFakeKeyEvent_wr(dpy, left_shift_code, dn, CurrentTime); + } + if ( altgr && (mod_state & ALTGR) && mod != 2 ) { + XTestFakeKeyEvent_wr(dpy, altgr, !dn, CurrentTime); + } + if ( altgr && ! (mod_state & ALTGR) && mod == 2 ) { + XTestFakeKeyEvent_wr(dpy, altgr, dn, CurrentTime); + } + X_UNLOCK; + if (debug_keyboard) { + rfbLog("tweak_mod: Finish: down=%d index=%d mod_state=0x%x" + " is_shift=%d\n", down, (int) mod, (int) mod_state, + is_shift); + } +} + +/* + * tweak the modifier under -modtweak + */ +static void modifier_tweak_keyboard(rfbBool down, rfbKeySym keysym, + rfbClientPtr client) { + KeyCode k; + int tweak = 0; + + if (use_xkb_modtweak) { + xkb_tweak_keyboard(down, keysym, client); + return; + } + if (debug_keyboard) { + rfbLog("modifier_tweak_keyboard: %s keysym=0x%x\n", + down ? "down" : "up", (int) keysym); + } + +#define ADJUSTMOD(sym, state) \ + if (keysym == sym) { \ + if (down) { \ + mod_state |= state; \ + } else { \ + mod_state &= ~state; \ + } \ + } + + ADJUSTMOD(XK_Shift_L, LEFTSHIFT) + ADJUSTMOD(XK_Shift_R, RIGHTSHIFT) + ADJUSTMOD(XK_Mode_switch, ALTGR) + + if ( down && keysym >= ' ' && keysym < 0x100 ) { + tweak = 1; + tweak_mod(modifiers[keysym], True); + k = keycodes[keysym]; + } else { + X_LOCK; + k = XKeysymToKeycode(dpy, (KeySym) keysym); + X_UNLOCK; + } + if (k == NoSymbol && add_keysyms && ! IsModifierKey(keysym)) { + int new_kc = add_keysym(keysym); + if (new_kc) { + k = new_kc; + } + } + + if (sloppy_keys) { + int new_kc; + if (sloppy_key_check((int) k, down, keysym, &new_kc)) { + k = (KeyCode) new_kc; + } + } + + if (debug_keyboard) { + rfbLog("modifier_tweak_keyboard: KeySym 0x%x \"%s\" -> " + "KeyCode 0x%x%s\n", (int) keysym, XKeysymToString(keysym), + (int) k, k ? "" : " *ignored*"); + } + if ( k != NoSymbol ) { + X_LOCK; + XTestFakeKeyEvent_wr(dpy, k, (Bool) down, CurrentTime); + X_UNLOCK; + } + + if ( tweak ) { + tweak_mod(modifiers[keysym], False); + } +} + +void initialize_keyboard_and_pointer(void) { + + if (raw_fb && ! dpy) return; /* raw_fb hack */ + + if (use_modifier_tweak) { + initialize_modtweak(); + } + if (remap_file != NULL) { + initialize_remap(remap_file); + } + + initialize_pointer_map(pointer_remap); + + clear_modifiers(1); + if (clear_mods == 1) { + clear_modifiers(0); + } +} + +void get_allowed_input(rfbClientPtr client, allowed_input_t *input) { + ClientData *cd; + char *str; + + input->keystroke = 0; + input->motion = 0; + input->button = 0; + + if (! client) { + return; + } + + cd = (ClientData *) client->clientData; + + if (cd->input[0] != '-') { + str = cd->input; + } else if (client->viewOnly) { + if (allowed_input_view_only) { + str = allowed_input_view_only; + } else { + str = ""; + } + } else { + if (allowed_input_normal) { + str = allowed_input_normal; + } else { + str = "KMB"; + } + } + + while (*str) { + if (*str == 'K') { + input->keystroke = 1; + } else if (*str == 'M') { + input->motion = 1; + } else if (*str == 'B') { + input->button = 1; + } + str++; + } +} + +/* for -pipeinput mode */ +static void pipe_keyboard(rfbBool down, rfbKeySym keysym, rfbClientPtr client) { + int can_input = 0, uid; + allowed_input_t input; + char *name; + ClientData *cd = (ClientData *) client->clientData; + + if (pipeinput_fh == NULL) { + return; + } + + if (! view_only) { + get_allowed_input(client, &input); + if (input.motion || input.button) { + can_input = 1; /* XXX distinguish later */ + } + } + uid = cd->uid; + if (! can_input) { + uid = -uid; + } + + X_LOCK; + name = XKeysymToString(keysym); + X_UNLOCK; + + fprintf(pipeinput_fh, "Keysym %d %d %u %s %s\n", uid, down, + keysym, name, down ? "KeyPress" : "KeyRelease"); + + fflush(pipeinput_fh); + check_pipeinput(); +} + +typedef struct keyevent { + rfbKeySym sym; + rfbBool down; + double time; +} keyevent_t; + +#define KEY_HIST 256 +static int key_history_idx = -1; +static keyevent_t key_history[KEY_HIST]; + +double typing_rate(double time_window, int *repeating) { + double dt = 1.0, now = dnow(); + KeySym key = NoSymbol; + int i, idx, cnt = 0, repeat_keys = 0; + + if (key_history_idx == -1) { + if (repeating) { + *repeating = 0; + } + return 0.0; + } + if (time_window > 0.0) { + dt = time_window; + } + for (i=0; i<KEY_HIST; i++) { + idx = key_history_idx - i; + if (idx < 0) { + idx += KEY_HIST; + } + if (! key_history[idx].down) { + continue; + } + if (now > key_history[idx].time + dt) { + break; + } + cnt++; + if (key == NoSymbol) { + key = key_history[idx].sym; + repeat_keys = 1; + } else if (key == key_history[idx].sym) { + repeat_keys++; + } + } + + if (repeating) { + if (repeat_keys >= 2) { + *repeating = repeat_keys; + } else { + *repeating = 0; + } + } + + /* + * n.b. keyrate could seem very high with libvncserver buffering them + * so avoid using small dt. + */ + return ((double) cnt)/dt; +} + +int skip_cr_when_scaling(char *mode) { + int got = 0; + + if (!scaling) { + return 0; + } + + if (scaling_copyrect != scaling_copyrect0) { + /* user override via -scale: */ + if (! scaling_copyrect) { + return 1; + } else { + return 0; + } + } + if (*mode == 's') { + got = got_scrollcopyrect; + } else if (*mode == 'w') { + got = got_wirecopyrect; + } + if (scaling_copyrect || got) { + int lat, rate; + int link = link_rate(&lat, &rate); + if (link == LR_DIALUP) { + return 1; + } else if (rate < 25) { + /* the fill-in of the repair may be too slow */ + return 1; + } else { + return 0; + } + } else { + return 1; + } +} + +/* + * key event handler. See the above functions for contortions for + * running under -modtweak. + */ +static rfbClientPtr last_keyboard_client = NULL; + +void keyboard(rfbBool down, rfbKeySym keysym, rfbClientPtr client) { + KeyCode k; + int idx, isbutton = 0; + allowed_input_t input; + time_t now = time(0); + double tnow; + static int skipped_last_down; + static rfbBool last_down; + static rfbKeySym last_keysym = NoSymbol; + static rfbKeySym max_keyrepeat_last_keysym = NoSymbol; + static double max_keyrepeat_last_time = 0.0; + + dtime0(&tnow); + got_keyboard_calls++; + + if (debug_keyboard) { + char *str; + X_LOCK; + str = XKeysymToString(keysym); + rfbLog("# keyboard(%s, 0x%x \"%s\") %.4f\n", down ? "down":"up", + (int) keysym, str ? str : "null", tnow - x11vnc_start); + X_UNLOCK; + } + + if (skip_duplicate_key_events) { + if (keysym == last_keysym && down == last_down) { + if (debug_keyboard) { + rfbLog("skipping dup key event: %d 0x%x\n", + down, keysym); + } + return; + } + } + + last_down = down; + last_keysym = keysym; + last_keyboard_time = tnow; + + last_rfb_down = down; + last_rfb_keysym = keysym; + last_rfb_keytime = tnow; + last_rfb_key_accepted = FALSE; + + if (key_history_idx == -1) { + for (idx=0; idx<KEY_HIST; idx++) { + key_history[idx].sym = NoSymbol; + key_history[idx].down = FALSE; + key_history[idx].time = 0.0; + } + } + idx = ++key_history_idx; + if (key_history_idx >= KEY_HIST) { + key_history_idx = 0; + idx = 0; + } + key_history[idx].sym = keysym; + key_history[idx].down = down; + key_history[idx].time = tnow; + + if (down && (keysym == XK_Alt_L || keysym == XK_Super_L)) { + int i, k, run = 0, ups = 0; + double delay = 1.0; + KeySym ks; + for (i=0; i<16; i++) { + k = idx - i; + if (k < 0) k += KEY_HIST; + if (!key_history[k].down) { + ups++; + continue; + } + ks = key_history[k].sym; + if (key_history[k].time < tnow - delay) { + break; + } else if (ks == keysym && ks == XK_Alt_L) { + run++; + } else if (ks == keysym && ks == XK_Super_L) { + run++; + } else { + break; + } + } + if (ups < 2) { + ; + } else if (run == 3 && keysym == XK_Alt_L) { + rfbLog("3*Alt_L, calling: refresh_screen(0)\n"); + refresh_screen(0); + } else if (run == 4 && keysym == XK_Alt_L) { + rfbLog("4*Alt_L, setting: do_copy_screen\n"); + do_copy_screen = 1; + } else if (run == 5 && keysym == XK_Alt_L) { + ; + } else if (run == 3 && keysym == XK_Super_L) { + rfbLog("3*Super_L, calling: set_xdamage_mark()\n"); + set_xdamage_mark(0, 0, dpy_x, dpy_y); + } else if (run == 4 && keysym == XK_Super_L) { + rfbLog("4*Super_L, calling: check_xrecord_reset()\n"); + check_xrecord_reset(1); + } else if (run == 5 && keysym == XK_Super_L) { + rfbLog("5*Super_L, calling: push_black_screen(0)\n"); + push_black_screen(0); + } + } + + if (!down && skipped_last_down) { + int db = debug_scroll; + if (keysym == max_keyrepeat_last_keysym) { + skipped_last_down = 0; + if (db) rfbLog("--- scroll keyrate skipping 0x%lx %s " + "%.4f %.4f\n", keysym, down ? "down":"up ", + tnow - x11vnc_start, tnow - max_keyrepeat_last_time); + return; + } + } + if (down && max_keyrepeat_time > 0.0) { + int skip = 0; + int db = debug_scroll; + + if (max_keyrepeat_last_keysym != NoSymbol && + max_keyrepeat_last_keysym != keysym) { + ; + } else { + if (tnow < max_keyrepeat_last_time+max_keyrepeat_time) { + skip = 1; + } + } + max_keyrepeat_time = 0.0; + if (skip) { + if (db) rfbLog("--- scroll keyrate skipping 0x%lx %s " + "%.4f %.4f\n", keysym, down ? "down":"up ", + tnow - x11vnc_start, tnow - max_keyrepeat_last_time); + max_keyrepeat_last_keysym = keysym; + skipped_last_down = 1; + return; + } else { + if (db) rfbLog("--- scroll keyrate KEEPING 0x%lx %s " + "%.4f %.4f\n", keysym, down ? "down":"up ", + tnow - x11vnc_start, tnow - max_keyrepeat_last_time); + } + } + max_keyrepeat_last_keysym = keysym; + max_keyrepeat_last_time = tnow; + skipped_last_down = 0; + last_rfb_key_accepted = TRUE; + + if (pipeinput_fh != NULL) { + pipe_keyboard(down, keysym, client); + if (! pipeinput_tee) { + if (! view_only || raw_fb) { /* raw_fb hack */ + last_keyboard_client = client; + last_event = last_input = now; + last_keyboard_input = now; + + last_keysym = keysym; + + last_rfb_down = down; + last_rfb_keysym = keysym; + last_rfb_keytime = tnow; + + got_user_input++; + got_keyboard_input++; + } + return; + } + } + + if (view_only) { + return; + } + get_allowed_input(client, &input); + if (! input.keystroke) { + return; + } + + track_mod_state(keysym, down, TRUE); /* ignores remaps */ + + last_keyboard_client = client; + last_event = last_input = now; + last_keyboard_input = now; + + last_keysym = keysym; + + last_rfb_down = down; + last_rfb_keysym = keysym; + last_rfb_keytime = tnow; + + got_user_input++; + got_keyboard_input++; + + if (raw_fb && ! dpy) return; /* raw_fb hack */ + + if (keyremaps) { + keyremap_t *remap = keyremaps; + while (remap != NULL) { + if (remap->before == keysym) { + keysym = remap->after; + isbutton = remap->isbutton; + if (debug_keyboard) { + X_LOCK; + rfbLog("keyboard(): remapping keysym: " + "0x%x \"%s\" -> 0x%x \"%s\"\n", + (int) remap->before, + XKeysymToString(remap->before), + (int) remap->after, + remap->isbutton ? "button" : + XKeysymToString(remap->after)); + X_UNLOCK; + } + break; + } + remap = remap->next; + } + } + + if (use_xrecord && ! xrecording && down) { + + if (!strcmp(scroll_copyrect, "never")) { + ; + } else if (!strcmp(scroll_copyrect, "mouse")) { + ; + } else if (skip_cr_when_scaling("scroll")) { + ; + } else if (! xrecord_skip_keysym(keysym)) { + snapshot_stack_list(0, 0.25); + xrecord_watch(1, SCR_KEY); + xrecord_set_by_keys = 1; + xrecord_keysym = keysym; + } else { + if (debug_scroll) { + char *str = XKeysymToString(keysym); + rfbLog("xrecord_skip_keysym: %s\n", + str ? str : "NoSymbol"); + } + } + } + + if (isbutton) { + int mask, button = (int) keysym; + if (! down) { + return; /* nothing to send */ + } + if (debug_keyboard) { + rfbLog("keyboard(): remapping keystroke to button %d" + " click\n", button); + } + dtime0(&last_key_to_button_remap_time); + + X_LOCK; + /* + * This in principle can be a little dicey... i.e. even + * remap the button click to keystroke sequences! + * Usually just will simulate the button click. + */ + mask = 1<<(button-1); + do_button_mask_change(mask, button); /* down */ + mask = 0; + do_button_mask_change(mask, button); /* up */ + XFlush(dpy); + X_UNLOCK; + return; + } + + if (use_modifier_tweak) { + modifier_tweak_keyboard(down, keysym, client); + X_LOCK; + XFlush(dpy); + X_UNLOCK; + return; + } + + X_LOCK; + + k = XKeysymToKeycode(dpy, (KeySym) keysym); + + if (k == NoSymbol && add_keysyms && ! IsModifierKey(keysym)) { + int new_kc = add_keysym(keysym); + if (new_kc) { + k = new_kc; + } + } + if (debug_keyboard) { + char *str = XKeysymToString(keysym); + rfbLog("keyboard(): KeySym 0x%x \"%s\" -> KeyCode 0x%x%s\n", + (int) keysym, str ? str : "null", (int) k, + k ? "" : " *ignored*"); + } + + if ( k != NoSymbol ) { + XTestFakeKeyEvent_wr(dpy, k, (Bool) down, CurrentTime); + XFlush(dpy); + } + + X_UNLOCK; +} + + |