FreeRDP
Loading...
Searching...
No Matches
xf_keyboard.c
1
20#include <freerdp/config.h>
21
22#include <ctype.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <stdint.h>
27
28#include <winpr/crt.h>
29#include <winpr/path.h>
30#include <winpr/assert.h>
31#include <winpr/cast.h>
32#include <winpr/collections.h>
33
34#include <freerdp/utils/string.h>
35
36#include <X11/Xlib.h>
37#include <X11/Xutil.h>
38#include <X11/keysym.h>
39#include <X11/XKBlib.h>
40
41#include <freerdp/locale/keyboard.h>
42#include <freerdp/locale/locale.h>
43
44#include "xf_event.h"
45
46#include "xf_keyboard.h"
47
48#include "xf_utils.h"
49#include "keyboard_x11.h"
50
51#include <freerdp/log.h>
52#define TAG CLIENT_TAG("x11")
53
54typedef struct
55{
56 BOOL Shift;
57 BOOL LeftShift;
58 BOOL RightShift;
59 BOOL Alt;
60 BOOL LeftAlt;
61 BOOL RightAlt;
62 BOOL Ctrl;
63 BOOL LeftCtrl;
64 BOOL RightCtrl;
65 BOOL Super;
66 BOOL LeftSuper;
67 BOOL RightSuper;
68} XF_MODIFIER_KEYS;
69
70struct x11_key_scancode_t
71{
72 const char* name;
73 DWORD sc;
74};
75
76static const struct x11_key_scancode_t XKB_KEY_NAME_SCANCODE_TABLE[] = {
77 { "AB01", RDP_SCANCODE_KEY_Z }, /* 052: AB01 [z] */
78 { "AB02", RDP_SCANCODE_KEY_X }, /* 053: AB02 [x] */
79 { "AB03", RDP_SCANCODE_KEY_C }, /* 054: AB03 [c] */
80 { "AB04", RDP_SCANCODE_KEY_V }, /* 055: AB04 [v] */
81 { "AB05", RDP_SCANCODE_KEY_B }, /* 056: AB05 [b] */
82 { "AB06", RDP_SCANCODE_KEY_N }, /* 057: AB06 [n] */
83 { "AB07", RDP_SCANCODE_KEY_M }, /* 058: AB07 [m] */
84 { "AB08", RDP_SCANCODE_OEM_COMMA }, /* 059: AB08 [comma] */
85 { "AB09", RDP_SCANCODE_OEM_PERIOD }, /* 060: AB09 [period] */
86 { "AB10", RDP_SCANCODE_OEM_2 }, /* 061: AB10 [slash] */
87 { "AB11", RDP_SCANCODE_ABNT_C1 }, /* 097: AB11 [(null)] */
88 { "AC01", RDP_SCANCODE_KEY_A }, /* 038: AC01 [a] */
89 { "AC02", RDP_SCANCODE_KEY_S }, /* 039: AC02 [s] */
90 { "AC03", RDP_SCANCODE_KEY_D }, /* 040: AC03 [d] */
91 { "AC04", RDP_SCANCODE_KEY_F }, /* 041: AC04 [f] */
92 { "AC05", RDP_SCANCODE_KEY_G }, /* 042: AC05 [g] */
93 { "AC06", RDP_SCANCODE_KEY_H }, /* 043: AC06 [h] */
94 { "AC07", RDP_SCANCODE_KEY_J }, /* 044: AC07 [j] */
95 { "AC08", RDP_SCANCODE_KEY_K }, /* 045: AC08 [k] */
96 { "AC09", RDP_SCANCODE_KEY_L }, /* 046: AC09 [l] */
97 { "AC10", RDP_SCANCODE_OEM_1 }, /* 047: AC10 [semicolon] */
98 { "AC11", RDP_SCANCODE_OEM_7 }, /* 048: AC11 [dead_acute] */
99 { "AD01", RDP_SCANCODE_KEY_Q }, /* 024: AD01 [q] */
100 { "AD02", RDP_SCANCODE_KEY_W }, /* 025: AD02 [w] */
101 { "AD03", RDP_SCANCODE_KEY_E }, /* 026: AD03 [e] */
102 { "AD04", RDP_SCANCODE_KEY_R }, /* 027: AD04 [r] */
103 { "AD05", RDP_SCANCODE_KEY_T }, /* 028: AD05 [t] */
104 { "AD06", RDP_SCANCODE_KEY_Y }, /* 029: AD06 [y] */
105 { "AD07", RDP_SCANCODE_KEY_U }, /* 030: AD07 [u] */
106 { "AD08", RDP_SCANCODE_KEY_I }, /* 031: AD08 [i] */
107 { "AD09", RDP_SCANCODE_KEY_O }, /* 032: AD09 [o] */
108 { "AD10", RDP_SCANCODE_KEY_P }, /* 033: AD10 [p] */
109 { "AD11", RDP_SCANCODE_OEM_4 }, /* 034: AD11 [bracketleft] */
110 { "AD12", RDP_SCANCODE_OEM_6 }, /* 035: AD12 [bracketright] */
111 { "AE01", RDP_SCANCODE_KEY_1 }, /* 010: AE01 [1] */
112 { "AE02", RDP_SCANCODE_KEY_2 }, /* 011: AE02 [2] */
113 { "AE03", RDP_SCANCODE_KEY_3 }, /* 012: AE03 [3] */
114 { "AE04", RDP_SCANCODE_KEY_4 }, /* 013: AE04 [4] */
115 { "AE05", RDP_SCANCODE_KEY_5 }, /* 014: AE05 [5] */
116 { "AE06", RDP_SCANCODE_KEY_6 }, /* 015: AE06 [6] */
117 { "AE07", RDP_SCANCODE_KEY_7 }, /* 016: AE07 [7] */
118 { "AE08", RDP_SCANCODE_KEY_8 }, /* 017: AE08 [8] */
119 { "AE09", RDP_SCANCODE_KEY_9 }, /* 018: AE09 [9] */
120 { "AE10", RDP_SCANCODE_KEY_0 }, /* 019: AE10 [0] */
121 { "AE11", RDP_SCANCODE_OEM_MINUS }, /* 020: AE11 [minus] */
122 { "AE12", RDP_SCANCODE_OEM_PLUS }, /* 021: AE12 [equal] */
123 { "AE13", RDP_SCANCODE_BACKSLASH_JP }, /* 132: AE13 [(null)] */
124 { "AGAI" /* codespell:ignore */, RDP_SCANCODE_UNKNOWN },
125 { "ALT", RDP_SCANCODE_LMENU }, /* 204: ALT [(null)] */
126 { "BKSL", RDP_SCANCODE_OEM_5 }, /* 051: BKSL [backslash] */
127 { "BKSP", RDP_SCANCODE_BACKSPACE }, /* 022: BKSP [BackSpace] */
128 { "CAPS", RDP_SCANCODE_CAPSLOCK }, /* 066: CAPS [Caps_Lock] */
129 { "COMP", RDP_SCANCODE_APPS }, /* 135: COMP [Menu] */
130 { "COPY", RDP_SCANCODE_UNKNOWN }, /* 141: COPY [XF86Copy] */
131 { "CUT", RDP_SCANCODE_UNKNOWN }, /* 145: CUT [XF86Cut] */
132 { "DELE", RDP_SCANCODE_DELETE }, /* 119: DELE [Delete] */
133 { "DOWN", RDP_SCANCODE_DOWN }, /* 116: DOWN [Down] */
134 { "END", RDP_SCANCODE_END }, /* 115: END [End] */
135 { "ESC", RDP_SCANCODE_ESCAPE }, /* 009: ESC [Escape] */
136 { "FIND", RDP_SCANCODE_UNKNOWN }, /* 144: FIND [Find] */
137 { "FK01", RDP_SCANCODE_F1 }, /* 067: FK01 [F1] */
138 { "FK02", RDP_SCANCODE_F2 }, /* 068: FK02 [F2] */
139 { "FK03", RDP_SCANCODE_F3 }, /* 069: FK03 [F3] */
140 { "FK04", RDP_SCANCODE_F4 }, /* 070: FK04 [F4] */
141 { "FK05", RDP_SCANCODE_F5 }, /* 071: FK05 [F5] */
142 { "FK06", RDP_SCANCODE_F6 }, /* 072: FK06 [F6] */
143 { "FK07", RDP_SCANCODE_F7 }, /* 073: FK07 [F7] */
144 { "FK08", RDP_SCANCODE_F8 }, /* 074: FK08 [F8] */
145 { "FK09", RDP_SCANCODE_F9 }, /* 075: FK09 [F9] */
146 { "FK10", RDP_SCANCODE_F10 }, /* 076: FK10 [F10] */
147 { "FK11", RDP_SCANCODE_F11 }, /* 095: FK11 [F11] */
148 { "FK12", RDP_SCANCODE_F12 }, /* 096: FK12 [F12] */
149 { "FK13", RDP_SCANCODE_F13 }, /* 191: FK13 [XF86Tools] */
150 { "FK14", RDP_SCANCODE_F14 }, /* 192: FK14 [XF86Launch5] */
151 { "FK15", RDP_SCANCODE_F15 }, /* 193: FK15 [XF86Launch6] */
152 { "FK16", RDP_SCANCODE_F16 }, /* 194: FK16 [XF86Launch7] */
153 { "FK17", RDP_SCANCODE_F17 }, /* 195: FK17 [XF86Launch8] */
154 { "FK18", RDP_SCANCODE_F18 }, /* 196: FK18 [XF86Launch9] */
155 { "FK19", RDP_SCANCODE_F19 }, /* 197: FK19 [(null)] */
156 { "FK20", RDP_SCANCODE_F20 }, /* 198: FK20 [XF86AudioMicMute] */
157 { "FK21", RDP_SCANCODE_F21 }, /* 199: FK21 [XF86TouchpadToggle] */
158 { "FK22", RDP_SCANCODE_F22 }, /* 200: FK22 [XF86TouchpadOn] */
159 { "FK23", RDP_SCANCODE_F23 }, /* 201: FK23 [XF86TouchpadOff] */
160 { "FK24", RDP_SCANCODE_F24 }, /* 202: FK24 [(null)] */
161 { "FRNT", RDP_SCANCODE_UNKNOWN }, /* 140: FRNT [SunFront] */
162 { "HELP", RDP_SCANCODE_HELP }, /* 146: HELP [Help] */
163 { "HENK", RDP_SCANCODE_CONVERT_JP }, /* 100: HENK [Henkan_Mode] */
164 { "HIRA", RDP_SCANCODE_HIRAGANA }, /* 099: HIRA [Hiragana] */
165 { "HJCV", RDP_SCANCODE_HANJA }, /* 131: HJCV [Hangul_Hanja] */
166 { "HKTG", RDP_SCANCODE_HIRAGANA }, /* 101: HKTG [Hiragana_Katakana] */
167 { "HNGL", RDP_SCANCODE_HANGUL }, /* 130: HNGL [Hangul] */
168 { "HOME", RDP_SCANCODE_HOME }, /* 110: HOME [Home] */
169 { "HYPR", RDP_SCANCODE_LWIN }, /* 207: HYPR [(null)] */
170 { "I120", RDP_SCANCODE_UNKNOWN }, /* 120: I120 [(null)] */
171 { "I126", RDP_SCANCODE_UNKNOWN }, /* 126: I126 [plusminus] */
172 { "I128", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 128: I128 [XF86LaunchA] */
173 { "I129", RDP_SCANCODE_ABNT_C2 }, /* 129: I129 [KP_Decimal] */
174 { "I147", RDP_SCANCODE_UNKNOWN }, /* 147: I147 [XF86MenuKB] */
175 { "I148", RDP_SCANCODE_UNKNOWN }, /* 148: I148 [XF86Calculator] */
176 { "I149", RDP_SCANCODE_UNKNOWN }, /* 149: I149 [(null)] */
177 { "I150", RDP_SCANCODE_SLEEP }, /* 150: I150 [XF86Sleep] */
178 { "I151", RDP_SCANCODE_UNKNOWN }, /* 151: I151 [XF86WakeUp] */
179 { "I152", RDP_SCANCODE_UNKNOWN }, /* 152: I152 [XF86Explorer] */
180 { "I153", RDP_SCANCODE_UNKNOWN }, /* 153: I153 [XF86Send] */
181 { "I154", RDP_SCANCODE_UNKNOWN }, /* 154: I154 [(null)] */
182 { "I155", RDP_SCANCODE_UNKNOWN }, /* 155: I155 [XF86Xfer] */
183 { "I156", RDP_SCANCODE_LAUNCH_APP1 }, /* 156: I156 [XF86Launch1] */
184 { "I157", RDP_SCANCODE_LAUNCH_APP2 }, /* 157: I157 [XF86Launch2] */
185 { "I158", RDP_SCANCODE_BROWSER_HOME }, /* 158: I158 [XF86WWW] */
186 { "I159", RDP_SCANCODE_UNKNOWN }, /* 159: I159 [XF86DOS] */
187 { "I160", RDP_SCANCODE_UNKNOWN }, /* 160: I160 [XF86ScreenSaver] */
188 { "I161", RDP_SCANCODE_UNKNOWN }, /* 161: I161 [XF86RotateWindows] */
189 { "I162", RDP_SCANCODE_UNKNOWN }, /* 162: I162 [XF86TaskPane] */
190 { "I163", RDP_SCANCODE_LAUNCH_MAIL }, /* 163: I163 [XF86Mail] */
191 { "I164", RDP_SCANCODE_BROWSER_FAVORITES }, /* 164: I164 [XF86Favorites] */
192 { "I165", RDP_SCANCODE_UNKNOWN }, /* 165: I165 [XF86MyComputer] */
193 { "I166", RDP_SCANCODE_BROWSER_BACK }, /* 166: I166 [XF86Back] */
194 { "I167", RDP_SCANCODE_BROWSER_FORWARD }, /* 167: I167 [XF86Forward] */
195 { "I168", RDP_SCANCODE_UNKNOWN }, /* 168: I168 [(null)] */
196 { "I169", RDP_SCANCODE_UNKNOWN }, /* 169: I169 [XF86Eject] */
197 { "I170", RDP_SCANCODE_UNKNOWN }, /* 170: I170 [XF86Eject] */
198 { "I171", RDP_SCANCODE_MEDIA_NEXT_TRACK }, /* 171: I171 [XF86AudioNext] */
199 { "I172", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 172: I172 [XF86AudioPlay] */
200 { "I173", RDP_SCANCODE_MEDIA_PREV_TRACK }, /* 173: I173 [XF86AudioPrev] */
201 { "I174", RDP_SCANCODE_MEDIA_STOP }, /* 174: I174 [XF86AudioStop] */
202 { "I175", RDP_SCANCODE_UNKNOWN }, /* 175: I175 [XF86AudioRecord] */
203 { "I176", RDP_SCANCODE_UNKNOWN }, /* 176: I176 [XF86AudioRewind] */
204 { "I177", RDP_SCANCODE_UNKNOWN }, /* 177: I177 [XF86Phone] */
205 { "I178", RDP_SCANCODE_UNKNOWN }, /* 178: I178 [(null)] */
206 { "I179", RDP_SCANCODE_UNKNOWN }, /* 179: I179 [XF86Tools] */
207 { "I180", RDP_SCANCODE_BROWSER_HOME }, /* 180: I180 [XF86HomePage] */
208 { "I181", RDP_SCANCODE_BROWSER_REFRESH }, /* 181: I181 [XF86Reload] */
209 { "I182", RDP_SCANCODE_UNKNOWN }, /* 182: I182 [XF86Close] */
210 { "I183", RDP_SCANCODE_UNKNOWN }, /* 183: I183 [(null)] */
211 { "I184", RDP_SCANCODE_UNKNOWN }, /* 184: I184 [(null)] */
212 { "I185", RDP_SCANCODE_UNKNOWN }, /* 185: I185 [XF86ScrollUp] */
213 { "I186", RDP_SCANCODE_UNKNOWN }, /* 186: I186 [XF86ScrollDown] */
214 { "I187", RDP_SCANCODE_UNKNOWN }, /* 187: I187 [parenleft] */
215 { "I188", RDP_SCANCODE_UNKNOWN }, /* 188: I188 [parenright] */
216 { "I189", RDP_SCANCODE_UNKNOWN }, /* 189: I189 [XF86New] */
217 { "I190", RDP_SCANCODE_UNKNOWN }, /* 190: I190 [Redo] */
218 { "I208", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 208: I208 [XF86AudioPlay] */
219 { "I209", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 209: I209 [XF86AudioPause] */
220 { "I210", RDP_SCANCODE_UNKNOWN }, /* 210: I210 [XF86Launch3] */
221 { "I211", RDP_SCANCODE_UNKNOWN }, /* 211: I211 [XF86Launch4] */
222 { "I212", RDP_SCANCODE_UNKNOWN }, /* 212: I212 [XF86LaunchB] */
223 { "I213", RDP_SCANCODE_UNKNOWN }, /* 213: I213 [XF86Suspend] */
224 { "I214", RDP_SCANCODE_UNKNOWN }, /* 214: I214 [XF86Close] */
225 { "I215", RDP_SCANCODE_MEDIA_PLAY_PAUSE }, /* 215: I215 [XF86AudioPlay] */
226 { "I216", RDP_SCANCODE_MEDIA_NEXT_TRACK }, /* 216: I216 [XF86AudioForward] */
227 { "I217", RDP_SCANCODE_UNKNOWN }, /* 217: I217 [(null)] */
228 { "I218", RDP_SCANCODE_UNKNOWN }, /* 218: I218 [Print] */
229 { "I219", RDP_SCANCODE_UNKNOWN }, /* 219: I219 [(null)] */
230 { "I220", RDP_SCANCODE_UNKNOWN }, /* 220: I220 [XF86WebCam] */
231 { "I221", RDP_SCANCODE_UNKNOWN }, /* 221: I221 [XF86AudioPreset] */
232 { "I222", RDP_SCANCODE_UNKNOWN }, /* 222: I222 [(null)] */
233 { "I223", RDP_SCANCODE_LAUNCH_MAIL }, /* 223: I223 [XF86Mail] */
234 { "I224", RDP_SCANCODE_UNKNOWN }, /* 224: I224 [XF86Messenger] */
235 { "I225", RDP_SCANCODE_BROWSER_SEARCH }, /* 225: I225 [XF86Search] */
236 { "I226", RDP_SCANCODE_UNKNOWN }, /* 226: I226 [XF86Go] */
237 { "I227", RDP_SCANCODE_UNKNOWN }, /* 227: I227 [XF86Finance] */
238 { "I228", RDP_SCANCODE_UNKNOWN }, /* 228: I228 [XF86Game] */
239 { "I229", RDP_SCANCODE_UNKNOWN }, /* 229: I229 [XF86Shop] */
240 { "I230", RDP_SCANCODE_UNKNOWN }, /* 230: I230 [(null)] */
241 { "I231", RDP_SCANCODE_UNKNOWN }, /* 231: I231 [Cancel] */
242 { "I232", RDP_SCANCODE_UNKNOWN }, /* 232: I232 [XF86MonBrightnessDown] */
243 { "I233", RDP_SCANCODE_UNKNOWN }, /* 233: I233 [XF86MonBrightnessUp] */
244 { "I234", RDP_SCANCODE_LAUNCH_MEDIA_SELECT }, /* 234: I234 [XF86AudioMedia] */
245 { "I235", RDP_SCANCODE_UNKNOWN }, /* 235: I235 [XF86Display] */
246 { "I236", RDP_SCANCODE_UNKNOWN }, /* 236: I236 [XF86KbdLightOnOff] */
247 { "I237", RDP_SCANCODE_UNKNOWN }, /* 237: I237 [XF86KbdBrightnessDown] */
248 { "I238", RDP_SCANCODE_UNKNOWN }, /* 238: I238 [XF86KbdBrightnessUp] */
249 { "I239", RDP_SCANCODE_UNKNOWN }, /* 239: I239 [XF86Send] */
250 { "I240", RDP_SCANCODE_UNKNOWN }, /* 240: I240 [XF86Reply] */
251 { "I241", RDP_SCANCODE_UNKNOWN }, /* 241: I241 [XF86MailForward] */
252 { "I242", RDP_SCANCODE_UNKNOWN }, /* 242: I242 [XF86Save] */
253 { "I243", RDP_SCANCODE_UNKNOWN }, /* 243: I243 [XF86Documents] */
254 { "I244", RDP_SCANCODE_UNKNOWN }, /* 244: I244 [XF86Battery] */
255 { "I245", RDP_SCANCODE_UNKNOWN }, /* 245: I245 [XF86Bluetooth] */
256 { "I246", RDP_SCANCODE_UNKNOWN }, /* 246: I246 [XF86WLAN] */
257 { "I247", RDP_SCANCODE_UNKNOWN }, /* 247: I247 [XF86UWB] */
258 { "I248", RDP_SCANCODE_UNKNOWN }, /* 248: I248 [(null)] */
259 { "I249", RDP_SCANCODE_UNKNOWN }, /* 249: I249 [XF86Next_VMode] */
260 { "I250", RDP_SCANCODE_UNKNOWN }, /* 250: I250 [XF86Prev_VMode] */
261 { "I251", RDP_SCANCODE_UNKNOWN }, /* 251: I251 [XF86MonBrightnessCycle] */
262 { "I252", RDP_SCANCODE_UNKNOWN }, /* 252: I252 [XF86BrightnessAuto] */
263 { "I253", RDP_SCANCODE_UNKNOWN }, /* 253: I253 [XF86DisplayOff] */
264 { "I254", RDP_SCANCODE_UNKNOWN }, /* 254: I254 [XF86WWAN] */
265 { "I255", RDP_SCANCODE_UNKNOWN }, /* 255: I255 [XF86RFKill] */
266 { "INS", RDP_SCANCODE_INSERT }, /* 118: INS [Insert] */
267 { "JPCM", RDP_SCANCODE_UNKNOWN }, /* 103: JPCM [(null)] */
268 { "KATA", RDP_SCANCODE_KANA_HANGUL }, /* 098: KATA [Katakana] */
269 { "KP0", RDP_SCANCODE_NUMPAD0 }, /* 090: KP0 [KP_Insert] */
270 { "KP1", RDP_SCANCODE_NUMPAD1 }, /* 087: KP1 [KP_End] */
271 { "KP2", RDP_SCANCODE_NUMPAD2 }, /* 088: KP2 [KP_Down] */
272 { "KP3", RDP_SCANCODE_NUMPAD3 }, /* 089: KP3 [KP_Next] */
273 { "KP4", RDP_SCANCODE_NUMPAD4 }, /* 083: KP4 [KP_Left] */
274 { "KP5", RDP_SCANCODE_NUMPAD5 }, /* 084: KP5 [KP_Begin] */
275 { "KP6", RDP_SCANCODE_NUMPAD6 }, /* 085: KP6 [KP_Right] */
276 { "KP7", RDP_SCANCODE_NUMPAD7 }, /* 079: KP7 [KP_Home] */
277 { "KP8", RDP_SCANCODE_NUMPAD8 }, /* 080: KP8 [KP_Up] */
278 { "KP9", RDP_SCANCODE_NUMPAD9 }, /* 081: KP9 [KP_Prior] */
279 { "KPAD", RDP_SCANCODE_ADD }, /* 086: KPAD [KP_Add] */
280 { "KPDL", RDP_SCANCODE_DECIMAL }, /* 091: KPDL [KP_Delete] */
281 { "KPDV", RDP_SCANCODE_DIVIDE }, /* 106: KPDV [KP_Divide] */
282 { "KPEN", RDP_SCANCODE_RETURN_KP }, /* 104: KPEN [KP_Enter] */
283 { "KPEQ", RDP_SCANCODE_UNKNOWN }, /* 125: KPEQ [KP_Equal] */
284 { "KPMU", RDP_SCANCODE_MULTIPLY }, /* 063: KPMU [KP_Multiply] */
285 { "KPSU", RDP_SCANCODE_SUBTRACT }, /* 082: KPSU [KP_Subtract] */
286 { "LALT", RDP_SCANCODE_LMENU }, /* 064: LALT [Alt_L] */
287 { "LCTL", RDP_SCANCODE_LCONTROL }, /* 037: LCTL [Control_L] */
288 { "LEFT", RDP_SCANCODE_LEFT }, /* 113: LEFT [Left] */
289 { "LFSH", RDP_SCANCODE_LSHIFT }, /* 050: LFSH [Shift_L] */
290 { "LNFD", RDP_SCANCODE_UNKNOWN }, /* 109: LNFD [Linefeed] */
291 { "LSGT", RDP_SCANCODE_OEM_102 }, /* 094: LSGT [backslash] */
292 { "LVL3", RDP_SCANCODE_RMENU }, /* 092: LVL3 [ISO_Level3_Shift] */
293 { "LVL5", RDP_SCANCODE_UNKNOWN }, /* 203: LVL5 [ISO_Level5_Shift] */
294 { "LWIN", RDP_SCANCODE_LWIN }, /* 133: LWIN [Super_L] */
295 { "META", RDP_SCANCODE_LMENU }, /* 205: META [(null)] */
296 { "MUHE", RDP_SCANCODE_NONCONVERT_JP }, /* 102: MUHE [Muhenkan] */
297 { "MUTE", RDP_SCANCODE_VOLUME_MUTE }, /* 121: MUTE [XF86AudioMute] */
298 { "NMLK", RDP_SCANCODE_NUMLOCK }, /* 077: NMLK [Num_Lock] */
299 { "OPEN", RDP_SCANCODE_UNKNOWN }, /* 142: OPEN [XF86Open] */
300 { "PAST", RDP_SCANCODE_UNKNOWN }, /* 143: PAST [XF86Paste] */
301 { "PAUS", RDP_SCANCODE_PAUSE }, /* 127: PAUS [Pause] */
302 { "PGDN", RDP_SCANCODE_NEXT }, /* 117: PGDN [Next] */
303 { "PGUP", RDP_SCANCODE_PRIOR }, /* 112: PGUP [Prior] */
304 { "POWR", RDP_SCANCODE_UNKNOWN }, /* 124: POWR [XF86PowerOff] */
305 { "PROP", RDP_SCANCODE_UNKNOWN }, /* 138: PROP [SunProps] */
306 { "PRSC", RDP_SCANCODE_PRINTSCREEN }, /* 107: PRSC [Print] */
307 { "RALT", RDP_SCANCODE_RMENU }, /* 108: RALT [ISO_Level3_Shift] */
308 { "RCTL", RDP_SCANCODE_RCONTROL }, /* 105: RCTL [Control_R] */
309 { "RGHT", RDP_SCANCODE_RIGHT }, /* 114: RGHT [Right] */
310 { "RTRN", RDP_SCANCODE_RETURN }, /* 036: RTRN [Return] */
311 { "RTSH", RDP_SCANCODE_RSHIFT }, /* 062: RTSH [Shift_R] */
312 { "RWIN", RDP_SCANCODE_RWIN }, /* 134: RWIN [Super_R] */
313 { "SCLK", RDP_SCANCODE_SCROLLLOCK }, /* 078: SCLK [Multi_key] */
314 { "SPCE", RDP_SCANCODE_SPACE }, /* 065: SPCE [space] */
315 { "STOP", RDP_SCANCODE_BROWSER_STOP }, /* 136: STOP [Cancel] */
316 { "SUPR", RDP_SCANCODE_LWIN }, /* 206: SUPR [(null)] */
317 { "TAB", RDP_SCANCODE_TAB }, /* 023: TAB [Tab] */
318 { "TLDE", RDP_SCANCODE_OEM_3 }, /* 049: TLDE [dead_grave] */
319 { "UNDO", RDP_SCANCODE_UNKNOWN }, /* 139: UNDO [Undo] */
320 { "UP", RDP_SCANCODE_UP }, /* 111: UP [Up] */
321 { "VOL+", RDP_SCANCODE_VOLUME_UP }, /* 123: VOL+ [XF86AudioRaiseVolume] */
322 { "VOL-", RDP_SCANCODE_VOLUME_DOWN } /* 122: VOL- [XF86AudioLowerVolume] */
323};
324
325typedef struct
326{
327 KeySym keysym;
328 DWORD sc;
329} x11_keysym_scancode_t;
330
331static const x11_keysym_scancode_t KEYSYM_SCANCODE_TABLE[] = {
332 { XK_space, RDP_SCANCODE_SPACE },
333 { XK_apostrophe, RDP_SCANCODE_OEM_7 },
334 { XK_comma, RDP_SCANCODE_OEM_COMMA },
335 { XK_minus, RDP_SCANCODE_OEM_MINUS },
336 { XK_period, RDP_SCANCODE_OEM_PERIOD },
337 { XK_slash, RDP_SCANCODE_OEM_2 },
338 { XK_0, RDP_SCANCODE_KEY_0 },
339 { XK_1, RDP_SCANCODE_KEY_1 },
340 { XK_2, RDP_SCANCODE_KEY_2 },
341 { XK_3, RDP_SCANCODE_KEY_3 },
342 { XK_4, RDP_SCANCODE_KEY_4 },
343 { XK_5, RDP_SCANCODE_KEY_5 },
344 { XK_6, RDP_SCANCODE_KEY_6 },
345 { XK_7, RDP_SCANCODE_KEY_7 },
346 { XK_8, RDP_SCANCODE_KEY_8 },
347 { XK_9, RDP_SCANCODE_KEY_9 },
348 { XK_semicolon, RDP_SCANCODE_OEM_1 },
349 { XK_less, RDP_SCANCODE_OEM_102 },
350 { XK_equal, RDP_SCANCODE_OEM_PLUS },
351 { XK_A, RDP_SCANCODE_KEY_A },
352 { XK_B, RDP_SCANCODE_KEY_B },
353 { XK_C, RDP_SCANCODE_KEY_C },
354 { XK_D, RDP_SCANCODE_KEY_D },
355 { XK_E, RDP_SCANCODE_KEY_E },
356 { XK_F, RDP_SCANCODE_KEY_F },
357 { XK_G, RDP_SCANCODE_KEY_G },
358 { XK_H, RDP_SCANCODE_KEY_H },
359 { XK_I, RDP_SCANCODE_KEY_I },
360 { XK_J, RDP_SCANCODE_KEY_J },
361 { XK_K, RDP_SCANCODE_KEY_K },
362 { XK_L, RDP_SCANCODE_KEY_L },
363 { XK_M, RDP_SCANCODE_KEY_M },
364 { XK_N, RDP_SCANCODE_KEY_N },
365 { XK_O, RDP_SCANCODE_KEY_O },
366 { XK_P, RDP_SCANCODE_KEY_P },
367 { XK_Q, RDP_SCANCODE_KEY_Q },
368 { XK_R, RDP_SCANCODE_KEY_R },
369 { XK_S, RDP_SCANCODE_KEY_S },
370 { XK_T, RDP_SCANCODE_KEY_T },
371 { XK_U, RDP_SCANCODE_KEY_U },
372 { XK_V, RDP_SCANCODE_KEY_V },
373 { XK_W, RDP_SCANCODE_KEY_W },
374 { XK_X, RDP_SCANCODE_KEY_X },
375 { XK_Y, RDP_SCANCODE_KEY_Y },
376 { XK_Z, RDP_SCANCODE_KEY_Z },
377 { XK_bracketleft, RDP_SCANCODE_OEM_4 },
378 { XK_backslash, RDP_SCANCODE_OEM_5 },
379 { XK_bracketright, RDP_SCANCODE_OEM_6 },
380 { XK_grave, RDP_SCANCODE_OEM_3 },
381 { XK_a, RDP_SCANCODE_KEY_A },
382 { XK_b, RDP_SCANCODE_KEY_B },
383 { XK_c, RDP_SCANCODE_KEY_C },
384 { XK_d, RDP_SCANCODE_KEY_D },
385 { XK_e, RDP_SCANCODE_KEY_E },
386 { XK_f, RDP_SCANCODE_KEY_F },
387 { XK_g, RDP_SCANCODE_KEY_G },
388 { XK_h, RDP_SCANCODE_KEY_H },
389 { XK_i, RDP_SCANCODE_KEY_I },
390 { XK_j, RDP_SCANCODE_KEY_J },
391 { XK_k, RDP_SCANCODE_KEY_K },
392 { XK_l, RDP_SCANCODE_KEY_L },
393 { XK_m, RDP_SCANCODE_KEY_M },
394 { XK_n, RDP_SCANCODE_KEY_N },
395 { XK_o, RDP_SCANCODE_KEY_O },
396 { XK_p, RDP_SCANCODE_KEY_P },
397 { XK_q, RDP_SCANCODE_KEY_Q },
398 { XK_r, RDP_SCANCODE_KEY_R },
399 { XK_s, RDP_SCANCODE_KEY_S },
400 { XK_t, RDP_SCANCODE_KEY_T },
401 { XK_u, RDP_SCANCODE_KEY_U },
402 { XK_v, RDP_SCANCODE_KEY_V },
403 { XK_w, RDP_SCANCODE_KEY_W },
404 { XK_x, RDP_SCANCODE_KEY_X },
405 { XK_y, RDP_SCANCODE_KEY_Y },
406 { XK_z, RDP_SCANCODE_KEY_Z },
407 { XK_ISO_Level3_Shift, RDP_SCANCODE_RMENU },
408 { XK_ISO_Left_Tab, RDP_SCANCODE_TAB },
409 { XK_BackSpace, RDP_SCANCODE_BACKSPACE },
410 { XK_Tab, RDP_SCANCODE_TAB },
411 { XK_Return, RDP_SCANCODE_RETURN },
412 { XK_Pause, RDP_SCANCODE_PAUSE },
413 { XK_Scroll_Lock, RDP_SCANCODE_SCROLLLOCK },
414 { XK_Escape, RDP_SCANCODE_ESCAPE },
415 { XK_Home, RDP_SCANCODE_HOME },
416 { XK_Left, RDP_SCANCODE_LEFT },
417 { XK_Up, RDP_SCANCODE_UP },
418 { XK_Right, RDP_SCANCODE_RIGHT },
419 { XK_Down, RDP_SCANCODE_DOWN },
420 { XK_Prior, RDP_SCANCODE_PRIOR },
421 { XK_Next, RDP_SCANCODE_NEXT },
422 { XK_End, RDP_SCANCODE_END },
423 { XK_Print, RDP_SCANCODE_PRINTSCREEN },
424 { XK_Insert, RDP_SCANCODE_INSERT },
425 { XK_Menu, RDP_SCANCODE_APPS },
426 { XK_Help, RDP_SCANCODE_HELP },
427 { XK_Mode_switch, RDP_SCANCODE_RMENU },
428 { XK_Num_Lock, RDP_SCANCODE_NUMLOCK },
429 { XK_KP_Enter, RDP_SCANCODE_RETURN_KP },
430 { XK_KP_Home, RDP_SCANCODE_NUMPAD7 },
431 { XK_KP_Left, RDP_SCANCODE_NUMPAD4 },
432 { XK_KP_Up, RDP_SCANCODE_NUMPAD8 },
433 { XK_KP_Right, RDP_SCANCODE_NUMPAD6 },
434 { XK_KP_Down, RDP_SCANCODE_NUMPAD2 },
435 { XK_KP_Prior, RDP_SCANCODE_NUMPAD9 },
436 { XK_KP_Next, RDP_SCANCODE_NUMPAD3 },
437 { XK_KP_End, RDP_SCANCODE_NUMPAD1 },
438 { XK_KP_Begin, RDP_SCANCODE_NUMPAD5 },
439 { XK_KP_Insert, RDP_SCANCODE_NUMPAD0 },
440 { XK_KP_Delete, RDP_SCANCODE_DECIMAL },
441 { XK_KP_Multiply, RDP_SCANCODE_MULTIPLY },
442 { XK_KP_Add, RDP_SCANCODE_ADD },
443 { XK_KP_Separator, RDP_SCANCODE_DECIMAL },
444 { XK_KP_Subtract, RDP_SCANCODE_SUBTRACT },
445 { XK_KP_Decimal, RDP_SCANCODE_DECIMAL },
446 { XK_KP_Divide, RDP_SCANCODE_DIVIDE },
447 { XK_KP_0, RDP_SCANCODE_NUMPAD0 },
448 { XK_KP_1, RDP_SCANCODE_NUMPAD1 },
449 { XK_KP_2, RDP_SCANCODE_NUMPAD2 },
450 { XK_KP_3, RDP_SCANCODE_NUMPAD3 },
451 { XK_KP_4, RDP_SCANCODE_NUMPAD4 },
452 { XK_KP_5, RDP_SCANCODE_NUMPAD5 },
453 { XK_KP_6, RDP_SCANCODE_NUMPAD6 },
454 { XK_KP_7, RDP_SCANCODE_NUMPAD7 },
455 { XK_KP_8, RDP_SCANCODE_NUMPAD8 },
456 { XK_KP_9, RDP_SCANCODE_NUMPAD9 },
457 { XK_F1, RDP_SCANCODE_F1 },
458 { XK_F2, RDP_SCANCODE_F2 },
459 { XK_F3, RDP_SCANCODE_F3 },
460 { XK_F4, RDP_SCANCODE_F4 },
461 { XK_F5, RDP_SCANCODE_F5 },
462 { XK_F6, RDP_SCANCODE_F6 },
463 { XK_F7, RDP_SCANCODE_F7 },
464 { XK_F8, RDP_SCANCODE_F8 },
465 { XK_F9, RDP_SCANCODE_F9 },
466 { XK_F10, RDP_SCANCODE_F10 },
467 { XK_F11, RDP_SCANCODE_F11 },
468 { XK_F12, RDP_SCANCODE_F12 },
469 { XK_F13, RDP_SCANCODE_F13 },
470 { XK_F14, RDP_SCANCODE_F14 },
471 { XK_F15, RDP_SCANCODE_F15 },
472 { XK_F16, RDP_SCANCODE_F16 },
473 { XK_F17, RDP_SCANCODE_F17 },
474 { XK_F18, RDP_SCANCODE_F18 },
475 { XK_F19, RDP_SCANCODE_F19 },
476 { XK_F20, RDP_SCANCODE_F20 },
477 { XK_F21, RDP_SCANCODE_F21 },
478 { XK_F22, RDP_SCANCODE_F22 },
479 { XK_F23, RDP_SCANCODE_F23 },
480 { XK_F24, RDP_SCANCODE_F24 },
481 { XK_Shift_L, RDP_SCANCODE_LSHIFT },
482 { XK_Shift_R, RDP_SCANCODE_RSHIFT },
483 { XK_Control_L, RDP_SCANCODE_LCONTROL },
484 { XK_Control_R, RDP_SCANCODE_RCONTROL },
485 { XK_Caps_Lock, RDP_SCANCODE_CAPSLOCK },
486 { XK_Meta_L, RDP_SCANCODE_LWIN },
487 { XK_Meta_R, RDP_SCANCODE_RWIN },
488 { XK_Alt_L, RDP_SCANCODE_LMENU },
489 { XK_Alt_R, RDP_SCANCODE_RMENU },
490 { XK_Super_L, RDP_SCANCODE_LWIN },
491 { XK_Super_R, RDP_SCANCODE_RWIN },
492 { XK_Hyper_L, RDP_SCANCODE_LWIN },
493 { XK_Hyper_R, RDP_SCANCODE_RWIN },
494 { XK_Delete, RDP_SCANCODE_DELETE }
495};
496
497static UINT32 xf_keyboard_get_toggle_keys_state(xfContext* xfc);
498static BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym);
499static void xf_keyboard_handle_special_keys_release(xfContext* xfc, KeySym keysym);
500
501static void xf_keyboard_modifier_map_free(xfContext* xfc)
502{
503 WINPR_ASSERT(xfc);
504 if (xfc->modifierMap)
505 {
506 XFreeModifiermap(xfc->modifierMap);
507 xfc->modifierMap = nullptr;
508 }
509}
510
511BOOL xf_keyboard_update_modifier_map(xfContext* xfc)
512{
513 WINPR_ASSERT(xfc);
514 xf_keyboard_modifier_map_free(xfc);
515 xfc->modifierMap = XGetModifierMapping(xfc->display);
516 return xfc->modifierMap != nullptr;
517}
518
519static void xf_keyboard_send_key(xfContext* xfc, BOOL down, BOOL repeat, const XKeyEvent* ev);
520static DWORD get_rdp_scancode_from_x11_keycode(xfContext* xfc, DWORD keycode);
521
522static BOOL xf_sync_kbd_state(xfContext* xfc)
523{
524 const UINT32 syncFlags = xf_keyboard_get_toggle_keys_state(xfc);
525
526 WINPR_ASSERT(xfc);
527 return freerdp_input_send_synchronize_event(xfc->common.context.input, syncFlags);
528}
529
530static void xf_keyboard_clear(xfContext* xfc)
531{
532 WINPR_ASSERT(xfc);
533 ZeroMemory(xfc->KeyboardState, sizeof(xfc->KeyboardState));
534}
535
536static BOOL xf_keyboard_mapping_is_set(const xfContext* xfc)
537{
538 WINPR_ASSERT(xfc);
539
540 for (size_t i = 0; i < ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE); i++)
541 {
542 if (xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[i] != RDP_SCANCODE_UNKNOWN)
543 return TRUE;
544 }
545
546 return FALSE;
547}
548
549static void xf_keyboard_clear_mapping(xfContext* xfc)
550{
551 WINPR_ASSERT(xfc);
552 ZeroMemory(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE, sizeof(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE));
553}
554
555static BOOL xf_action_script_append(xfContext* xfc, const char* buffer, size_t size,
556 WINPR_ATTR_UNUSED void* user, const char* what, const char* arg)
557{
558 WINPR_ASSERT(xfc);
559 WINPR_UNUSED(what);
560 WINPR_UNUSED(arg);
561
562 if (!buffer || (size == 0))
563 return TRUE;
564 return ArrayList_Append(xfc->keyCombinations, buffer);
565}
566
567static void xf_keyboard_action_script_free(xfContext* xfc)
568{
569 xf_event_action_script_free(xfc);
570
571 if (xfc->keyCombinations)
572 {
573 ArrayList_Free(xfc->keyCombinations);
574 xfc->keyCombinations = nullptr;
575 xfc->actionScriptExists = FALSE;
576 }
577}
578
579BOOL xf_keyboard_action_script_init(xfContext* xfc)
580{
581 WINPR_ASSERT(xfc);
582
583 xf_keyboard_action_script_free(xfc);
584 xfc->keyCombinations = ArrayList_New(TRUE);
585
586 if (!xfc->keyCombinations)
587 return FALSE;
588
589 wObject* obj = ArrayList_Object(xfc->keyCombinations);
590 WINPR_ASSERT(obj);
591 obj->fnObjectNew = winpr_ObjectStringClone;
592 obj->fnObjectFree = winpr_ObjectStringFree;
593
594 if (!run_action_script(xfc, "key", nullptr, xf_action_script_append, nullptr))
595 return FALSE;
596
597 return xf_event_action_script_init(xfc);
598}
599
600static int xkb_cmp(const void* pva, const void* pvb)
601{
602 const struct x11_key_scancode_t* a = pva;
603 const struct x11_key_scancode_t* b = pvb;
604
605 if (!a && !b)
606 return 0;
607 if (!a)
608 return 1;
609 if (!b)
610 return -1;
611 return strcmp(a->name, b->name);
612}
613
614static int keysym_cmp(const void* pva, const void* pvb)
615{
616 const x11_keysym_scancode_t* a = pva;
617 const x11_keysym_scancode_t* b = pvb;
618
619 if (!a && !b)
620 return 0;
621 if (!a)
622 return 1;
623 if (!b)
624 return -1;
625 if (a->keysym < b->keysym)
626 return -1;
627 if (a->keysym > b->keysym)
628 return 1;
629 return 0;
630}
631
632static BOOL try_add(xfContext* xfc, size_t offset, const char* xkb_keyname)
633{
634 WINPR_ASSERT(xfc);
635
636 struct x11_key_scancode_t key = { .name = xkb_keyname,
637 .sc = WINPR_ASSERTING_INT_CAST(uint32_t, offset) };
638
639 struct x11_key_scancode_t* found =
640 bsearch(&key, XKB_KEY_NAME_SCANCODE_TABLE, ARRAYSIZE(XKB_KEY_NAME_SCANCODE_TABLE),
641 sizeof(struct x11_key_scancode_t), xkb_cmp);
642 if (found)
643 {
644 WLog_Print(xfc->log, WLOG_DEBUG,
645 "%4s: keycode: 0x%02" PRIuz " -> rdp scancode: 0x%08" PRIx32 "", xkb_keyname,
646 offset, found->sc);
647 xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[offset] = found->sc;
648 return TRUE;
649 }
650
651 return FALSE;
652}
653
654/* Keysym fallback for X11 forwarding where XKB key names don't match evdev */
655static DWORD xf_keysym_to_rdp_scancode(KeySym keysym)
656{
657 x11_keysym_scancode_t key = { .keysym = keysym, .sc = 0 };
658 x11_keysym_scancode_t* found =
659 bsearch(&key, KEYSYM_SCANCODE_TABLE, ARRAYSIZE(KEYSYM_SCANCODE_TABLE),
660 sizeof(x11_keysym_scancode_t), keysym_cmp);
661 if (found)
662 return found->sc;
663
664 return RDP_SCANCODE_UNKNOWN;
665}
666
667static int load_map_from_xkbfile(xfContext* xfc)
668{
669 WINPR_ASSERT(xfc);
670 int status = -1;
671
672 if (!xfc->display)
673 return -2;
674
675 XkbDescPtr xkb = XkbGetMap(xfc->display, 0, XkbUseCoreKbd);
676 if (!xkb)
677 {
678 WLog_Print(xfc->log, WLOG_WARN, "XkbGetMap() == nullptr");
679 return -3;
680 }
681
682 const int rc = XkbGetNames(xfc->display, XkbKeyNamesMask, xkb);
683 if (rc != Success)
684 {
685 char buffer[64] = WINPR_C_ARRAY_INIT;
686 WLog_Print(xfc->log, WLOG_WARN, "XkbGetNames() != Success: [%s]",
687 x11_error_to_string(xfc, rc, buffer, sizeof(buffer)));
688 }
689 else
690 {
691 char xkb_keyname[XkbKeyNameLength + 1] = { 42, 42, 42, 42,
692 0 }; /* end-of-string at index 5 */
693
694 WLog_Print(xfc->log, WLOG_TRACE, "XkbGetNames() == Success, min=%" PRIu8 ", max=%" PRIu8,
695 xkb->min_key_code, xkb->max_key_code);
696 for (size_t i = xkb->min_key_code; i < xkb->max_key_code; i++)
697 {
698 BOOL found = FALSE;
699 strncpy(xkb_keyname, xkb->names->keys[i].name, XkbKeyNameLength);
700
701 WLog_Print(xfc->log, WLOG_TRACE, "KeyCode %" PRIuz " -> %s", i, xkb_keyname);
702 if (strnlen(xkb_keyname, ARRAYSIZE(xkb_keyname)) >= 1)
703 found = try_add(xfc, i, xkb_keyname);
704
705 if (!found)
706 {
707#if defined(__APPLE__)
708 const DWORD vkcode =
709 GetVirtualKeyCodeFromKeycode((UINT32)i - 8u, WINPR_KEYCODE_TYPE_APPLE);
710 xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[i] =
711 GetVirtualScanCodeFromVirtualKeyCode(vkcode, WINPR_KBD_TYPE_IBM_ENHANCED);
712 found = TRUE;
713#endif
714 }
715 if (!found)
716 {
717 WLog_Print(xfc->log, WLOG_WARN,
718 "%4s: keycode: 0x%02" PRIx32 " -> no RDP scancode found", xkb_keyname,
719 WINPR_ASSERTING_INT_CAST(UINT32, i));
720 }
721 else
722 status = 0;
723 }
724 }
725
726 XkbFreeKeyboard(xkb, 0, 1);
727
728 return status;
729}
730
731/* Keysym-based fallback for unmapped keycodes (e.g. X11 forwarding) */
732static BOOL load_map_from_keysym(xfContext* xfc)
733{
734 WINPR_ASSERT(xfc);
735
736 if (!xfc->display)
737 return FALSE;
738
739 BOOL mapped = FALSE;
740 int min_kc = 0;
741 int max_kc = 0;
742 XDisplayKeycodes(xfc->display, &min_kc, &max_kc);
743
744 for (int i = min_kc; i <= max_kc; i++)
745 {
746 if ((i < 0) || ((size_t)i >= ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE)))
747 continue;
748
749 if (xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[i] != RDP_SCANCODE_UNKNOWN)
750 continue;
751
752 const KeySym ks = XkbKeycodeToKeysym(xfc->display, (KeyCode)i, 0, 0);
753 if (ks == NoSymbol)
754 continue;
755
756 const DWORD sc = xf_keysym_to_rdp_scancode(ks);
757 if (sc != RDP_SCANCODE_UNKNOWN)
758 {
759 xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[i] = sc;
760 mapped = TRUE;
761 WLog_Print(xfc->log, WLOG_DEBUG,
762 "keycode: 0x%02x -> keysym: 0x%04lx -> rdp scancode: 0x%08" PRIx32
763 " (keysym fallback)",
764 (unsigned)i, (unsigned long)ks, sc);
765 }
766 }
767
768 return mapped;
769}
770
771#if defined(WITH_VERBOSE_WINPR_ASSERT)
772static BOOL compareKeySym(const x11_keysym_scancode_t* a, size_t counta,
773 const x11_keysym_scancode_t* b, size_t countb)
774{
775 WINPR_ASSERT(a || (counta == 0));
776 WINPR_ASSERT(b || (countb == 0));
777
778 if (counta != countb)
779 return FALSE;
780
781 for (size_t x = 0; x < counta; x++)
782 {
783 const x11_keysym_scancode_t* ca = &a[x];
784 const x11_keysym_scancode_t* cb = &b[x];
785 if (keysym_cmp(ca, cb) != 0)
786 {
787 WLog_ERR(TAG, "%" PRIuz "\ta=%lx, should be %lx", x, ca->keysym, cb->keysym);
788 WLog_ERR(TAG, "KEYSYM_SCANCODE_TABLE is not properly sorted!");
789 return FALSE;
790 }
791 }
792 return TRUE;
793}
794
795static BOOL compareKey(const struct x11_key_scancode_t* a, size_t counta,
796 const struct x11_key_scancode_t* b, size_t countb)
797{
798 WINPR_ASSERT(a || (counta == 0));
799 WINPR_ASSERT(b || (countb == 0));
800
801 if (counta != countb)
802 return FALSE;
803
804 for (size_t x = 0; x < counta; x++)
805 {
806 const struct x11_key_scancode_t* ca = &a[x];
807 const struct x11_key_scancode_t* cb = &b[x];
808 if (xkb_cmp(ca, cb) != 0)
809 {
810 WLog_ERR(TAG, "%" PRIuz "\ta=%s [%" PRIu32 "], should be %s [%" PRIu32 "]", x, a->name,
811 a->sc, b->name, b->sc);
812 WLog_ERR(TAG, "XKB_KEY_NAME_SCANCODE_TABLE is not properly sorted!");
813 return FALSE;
814 }
815 }
816 return TRUE;
817}
818#endif
819
820BOOL xf_keyboard_init(xfContext* xfc)
821{
822 rdpSettings* settings = nullptr;
823 DWORD previous_mapping[ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE)] = WINPR_C_ARRAY_INIT;
824 BOOL previous_mapping_is_set = FALSE;
825
826 WINPR_ASSERT(xfc);
827
828/* When assertions are enabled assert the lists are sorted. */
829#if defined(WITH_VERBOSE_WINPR_ASSERT)
830 {
831 x11_keysym_scancode_t copy[ARRAYSIZE(KEYSYM_SCANCODE_TABLE)] = WINPR_C_ARRAY_INIT;
832 memcpy(copy, KEYSYM_SCANCODE_TABLE, sizeof(copy));
833 qsort(copy, ARRAYSIZE(copy), sizeof(x11_keysym_scancode_t), keysym_cmp);
834
835 if (!compareKeySym(KEYSYM_SCANCODE_TABLE, ARRAYSIZE(KEYSYM_SCANCODE_TABLE), copy,
836 ARRAYSIZE(copy)))
837 return FALSE;
838 }
839 {
840 struct x11_key_scancode_t copy[ARRAYSIZE(XKB_KEY_NAME_SCANCODE_TABLE)] = WINPR_C_ARRAY_INIT;
841 memcpy(copy, XKB_KEY_NAME_SCANCODE_TABLE, sizeof(copy));
842 qsort(copy, ARRAYSIZE(copy), sizeof(struct x11_key_scancode_t), xkb_cmp);
843
844 if (!compareKey(XKB_KEY_NAME_SCANCODE_TABLE, ARRAYSIZE(XKB_KEY_NAME_SCANCODE_TABLE), copy,
845 ARRAYSIZE(copy)))
846 return FALSE;
847 }
848#endif
849
850 settings = xfc->common.context.settings;
851 WINPR_ASSERT(settings);
852
853 xf_keyboard_clear(xfc);
854
855 /* Layout detection algorithm:
856 *
857 * 1. If one was supplied, use that one
858 * 2. Try to determine current X11 keyboard layout
859 * 3. Try to determine default layout for current system language
860 * 4. Fall back to ENGLISH_UNITED_STATES
861 */
862 UINT32 KeyboardLayout = freerdp_settings_get_uint32(settings, FreeRDP_KeyboardLayout);
863 if (KeyboardLayout == 0)
864 {
865 xf_detect_keyboard_layout_from_xkb(xfc->log, &KeyboardLayout);
866 if (KeyboardLayout == 0)
867 freerdp_detect_keyboard_layout_from_system_locale(&KeyboardLayout);
868 if (KeyboardLayout == 0)
869 KeyboardLayout = ENGLISH_UNITED_STATES;
870 if (!freerdp_settings_set_uint32(settings, FreeRDP_KeyboardLayout, KeyboardLayout))
871 return FALSE;
872 }
873
874 previous_mapping_is_set = xf_keyboard_mapping_is_set(xfc);
875 memcpy(previous_mapping, xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE, sizeof(previous_mapping));
876 xf_keyboard_clear_mapping(xfc);
877
878 const int rc = load_map_from_xkbfile(xfc);
879
880 const BOOL keysym_mapped = load_map_from_keysym(xfc);
881
882 if (rc != 0 && !keysym_mapped)
883 {
884 if (!previous_mapping_is_set)
885 return FALSE;
886
887 /* A MappingNotify may carry a keymap without names or usable keysyms.
888 * Keep the last working physical-key mapping instead of ending the RDP
889 * session just because the new map cannot be decoded. */
890 memcpy(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE, previous_mapping,
891 sizeof(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE));
892 WLog_Print(xfc->log, WLOG_WARN,
893 "Could not map the new X11 keyboard map, keeping the previous mapping");
894 }
895
896 return xf_keyboard_update_modifier_map(xfc);
897}
898
899void xf_keyboard_free(xfContext* xfc)
900{
901 xf_keyboard_modifier_map_free(xfc);
902 xf_keyboard_action_script_free(xfc);
903}
904
905/* Only ordinary Alt is deferred. Shift keeps the existing immediate path. */
906enum
907{
908 XF_ALT_LEFT = 0x01,
909 XF_ALT_RIGHT = 0x02
910};
911
912static UINT32 xf_keyboard_alt_mask(xfContext* xfc, KeyCode code)
913{
914 if (!code || (code == XKeysymToKeycode(xfc->display, XK_ISO_Level3_Shift)) ||
915 (code == XKeysymToKeycode(xfc->display, XK_Mode_switch)))
916 return 0;
917
918 const DWORD scancode = get_rdp_scancode_from_x11_keycode(xfc, code);
919 if ((code == XKeysymToKeycode(xfc->display, XK_Alt_L)) && (scancode == RDP_SCANCODE_LMENU))
920 return XF_ALT_LEFT;
921 if ((code == XKeysymToKeycode(xfc->display, XK_Alt_R)) && (scancode == RDP_SCANCODE_RMENU))
922 return XF_ALT_RIGHT;
923 return 0;
924}
925
926BOOL xf_keyboard_flush_deferred_alt(xfContext* xfc)
927{
928 if (!xfc->deferAlt)
929 return TRUE;
930
931 /* A fixed left/right order is sufficient; no modifier press queue is kept. */
932 const UINT32 masks[] = { XF_ALT_LEFT, XF_ALT_RIGHT };
933 for (size_t i = 0; i < ARRAYSIZE(masks); i++)
934 {
935 const UINT32 mask = masks[i];
936 if (!(xfc->deferredAlt.pending & mask))
937 continue;
938 const DWORD scancode = (mask == XF_ALT_LEFT) ? RDP_SCANCODE_LMENU : RDP_SCANCODE_RMENU;
939 if (!freerdp_input_send_keyboard_event_ex(xfc->common.context.input, TRUE, FALSE, scancode))
940 return FALSE;
941 xfc->deferredAlt.pending &= ~mask;
942 xfc->deferredAlt.sent |= mask;
943 }
944 return TRUE;
945}
946
947void xf_keyboard_key_press(xfContext* xfc, const XKeyEvent* event, KeySym keysym)
948{
949 WINPR_ASSERT(xfc);
950 WINPR_ASSERT(event);
951 WINPR_ASSERT(event->keycode < ARRAYSIZE(xfc->KeyboardState));
952
953 const BOOL defer = xfc->deferAlt;
954 const BOOL last = xfc->KeyboardState[event->keycode];
955 xfc->KeyboardState[event->keycode] = TRUE;
956
957 if (xf_keyboard_handle_special_keys(xfc, keysym))
958 {
959 if (defer)
960 {
961 xfc->deferredAlt.pending = 0;
962 xfc->KeyboardState[event->keycode] = last;
963 }
964 return;
965 }
966 if (defer)
967 {
968 const UINT32 mask = xf_keyboard_alt_mask(xfc, (KeyCode)event->keycode);
969 if (mask)
970 {
971 if (!(xfc->deferredAlt.sent & mask))
972 {
973 xfc->deferredAlt.pending |= mask;
974 return;
975 }
976 const DWORD scancode = get_rdp_scancode_from_x11_keycode(xfc, event->keycode);
977 (void)freerdp_input_send_keyboard_event_ex(xfc->common.context.input, TRUE, last,
978 scancode);
979 return;
980 }
981 /* Shift must not commit Alt before a host Alt+Shift+Tab shortcut. */
982 if ((keysym != XK_Shift_L) && (keysym != XK_Shift_R) &&
983 !xf_keyboard_flush_deferred_alt(xfc))
984 {
985 xfc->KeyboardState[event->keycode] = last;
986 return;
987 }
988 }
989 xf_keyboard_send_key(xfc, TRUE, last, event);
990}
991
992void xf_keyboard_key_release(xfContext* xfc, const XKeyEvent* event, KeySym keysym)
993{
994 WINPR_ASSERT(xfc);
995 WINPR_ASSERT(event);
996 WINPR_ASSERT(event->keycode < ARRAYSIZE(xfc->KeyboardState));
997
998 const BOOL last = xfc->KeyboardState[event->keycode];
999 xfc->KeyboardState[event->keycode] = FALSE;
1000 xf_keyboard_handle_special_keys_release(xfc, keysym);
1001 if (xfc->deferAlt)
1002 {
1003 const UINT32 mask = xf_keyboard_alt_mask(xfc, (KeyCode)event->keycode);
1004 if (mask)
1005 {
1006 /* An unmatched release after cancellation must not create an Alt tap. */
1007 if (xfc->deferredAlt.pending & mask)
1008 (void)xf_keyboard_flush_deferred_alt(xfc);
1009 if (xfc->deferredAlt.sent & mask)
1010 {
1011 const DWORD scancode = get_rdp_scancode_from_x11_keycode(xfc, event->keycode);
1012 (void)freerdp_input_send_keyboard_event_ex(xfc->common.context.input, FALSE, FALSE,
1013 scancode);
1014 }
1015 xfc->deferredAlt.pending &= ~mask;
1016 xfc->deferredAlt.sent &= ~mask;
1017 return;
1018 }
1019 if (!last)
1020 return;
1021 /* Shift release commits Alt before Windows interprets Alt+Shift. */
1022 if (((keysym == XK_Shift_L) || (keysym == XK_Shift_R)) &&
1023 !xf_keyboard_flush_deferred_alt(xfc))
1024 return;
1025 }
1026 xf_keyboard_send_key(xfc, FALSE, last, event);
1027}
1028
1029static DWORD get_rdp_scancode_from_x11_keycode(xfContext* xfc, DWORD keycode)
1030{
1031 WINPR_ASSERT(xfc);
1032 if (keycode >= ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE))
1033 {
1034 WLog_ERR(TAG, "KeyCode %" PRIu32 " exceeds allowed value range [0,%" PRIuz "]", keycode,
1035 ARRAYSIZE(xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE));
1036 return 0;
1037 }
1038
1039 const DWORD scancode = xfc->X11_KEYCODE_TO_VIRTUAL_SCANCODE[keycode];
1040 const DWORD remapped = freerdp_keyboard_remap_key(xfc->remap_table, scancode);
1041
1042#if defined(WITH_DEBUG_KBD)
1043 {
1044 const BOOL ex = RDP_SCANCODE_EXTENDED(scancode);
1045 const DWORD sc = RDP_SCANCODE_CODE(scancode);
1046 WLog_DBG(TAG, "x11 keycode: %02" PRIX32 " -> rdp code: [%04" PRIx16 "] %02" PRIX8 "%s",
1047 keycode, scancode, sc, ex ? " extended" : "");
1048 }
1049#endif
1050
1051 if (remapped != 0)
1052 {
1053#if defined(WITH_DEBUG_KBD)
1054 {
1055 const BOOL ex = RDP_SCANCODE_EXTENDED(remapped);
1056 const DWORD sc = RDP_SCANCODE_CODE(remapped);
1057 WLog_DBG(TAG,
1058 "x11 keycode: %02" PRIX32 " -> remapped rdp code: [%04" PRIx16 "] %02" PRIX8
1059 "%s",
1060 keycode, remapped, sc, ex ? " extended" : "");
1061 }
1062#endif
1063 return remapped;
1064 }
1065
1066 return scancode;
1067}
1068
1069static BOOL isModifier(DWORD scancode)
1070{
1071 const DWORD modifiers[] = { RDP_SCANCODE_LWIN, RDP_SCANCODE_RWIN, RDP_SCANCODE_LMENU,
1072 RDP_SCANCODE_RMENU, RDP_SCANCODE_LCONTROL, RDP_SCANCODE_RCONTROL,
1073 RDP_SCANCODE_APPS };
1074
1075 for (size_t x = 0; x < ARRAYSIZE(modifiers); x++)
1076 {
1077 if (modifiers[x] == scancode)
1078 return TRUE;
1079 }
1080
1081 return FALSE;
1082}
1083
1084static void release_keys(xfContext* xfc, BOOL modifiers)
1085{
1086 WINPR_ASSERT(xfc);
1087
1088 WINPR_STATIC_ASSERT(ARRAYSIZE(xfc->KeyboardState) <= UINT32_MAX);
1089 for (size_t keycode = 0; keycode < ARRAYSIZE(xfc->KeyboardState); keycode++)
1090 {
1091 if (xfc->KeyboardState[keycode])
1092 {
1093 /* Physical Alt may never have been sent to the remote. */
1094 if (xfc->deferAlt)
1095 {
1096 const UINT32 mask = xf_keyboard_alt_mask(xfc, (KeyCode)keycode);
1097 if (mask && !(xfc->deferredAlt.sent & mask))
1098 {
1099 xfc->KeyboardState[keycode] = FALSE;
1100 continue;
1101 }
1102 }
1103 const DWORD rdp_scancode =
1104 get_rdp_scancode_from_x11_keycode(xfc, WINPR_ASSERTING_INT_CAST(UINT32, keycode));
1105
1106 if (isModifier(rdp_scancode) == modifiers)
1107 {
1108 (void)freerdp_input_send_keyboard_event_ex(xfc->common.context.input, FALSE, FALSE,
1109 rdp_scancode);
1110 xfc->KeyboardState[keycode] = FALSE;
1111 }
1112 }
1113 }
1114}
1115
1116void xf_keyboard_release_all_keypress(xfContext* xfc)
1117{
1118 WINPR_ASSERT(xfc);
1119
1120 if (xfc->deferAlt)
1121 xfc->deferredAlt.pending = 0;
1122 release_keys(xfc, FALSE);
1123 release_keys(xfc, TRUE);
1124 xfc->deferredAlt.sent = 0;
1125}
1126
1127static BOOL xf_keyboard_key_pressed(xfContext* xfc, KeySym keysym)
1128{
1129 KeyCode keycode = XKeysymToKeycode(xfc->display, keysym);
1130 WINPR_ASSERT(keycode < ARRAYSIZE(xfc->KeyboardState));
1131 return xfc->KeyboardState[keycode];
1132}
1133
1134static int xk_keyboard_get_modifier_keys(xfContext* xfc, XF_MODIFIER_KEYS* mod);
1135
1136static BOOL xf_keyboard_has_system_modifier(xfContext* xfc)
1137{
1138 XF_MODIFIER_KEYS mod = WINPR_C_ARRAY_INIT;
1139
1140 WINPR_ASSERT(xfc);
1141
1142 (void)xk_keyboard_get_modifier_keys(xfc, &mod);
1143 return mod.Ctrl || mod.Alt || mod.Super;
1144}
1145
1146void xf_keyboard_send_key(xfContext* xfc, BOOL down, BOOL repeat, const XKeyEvent* event)
1147{
1148 WINPR_ASSERT(xfc);
1149 WINPR_ASSERT(event);
1150
1151 rdpInput* input = xfc->common.context.input;
1152 WINPR_ASSERT(input);
1153
1154 const DWORD rdp_scancode = get_rdp_scancode_from_x11_keycode(xfc, event->keycode);
1155 if (rdp_scancode == RDP_SCANCODE_PAUSE && !xf_keyboard_key_pressed(xfc, XK_Control_L) &&
1156 !xf_keyboard_key_pressed(xfc, XK_Control_R))
1157 {
1158 /* Pause without Ctrl has to be sent as a series of keycodes
1159 * in a single input PDU. Pause only happens on "press";
1160 * no code is sent on "release".
1161 */
1162 if (down)
1163 {
1164 freerdp_input_send_keyboard_pause_event(input);
1165 }
1166 }
1167 else
1168 {
1169 if (freerdp_settings_get_bool(xfc->common.context.settings, FreeRDP_UnicodeInput) &&
1170 !xf_keyboard_has_system_modifier(xfc))
1171 {
1172 wchar_t buffer[32] = WINPR_C_ARRAY_INIT;
1173 int xwc = -1;
1174
1175 switch (rdp_scancode)
1176 {
1177 case RDP_SCANCODE_BACKSPACE:
1178 case RDP_SCANCODE_DELETE:
1179 case RDP_SCANCODE_RETURN:
1180 break;
1181 default:
1182 {
1183 XIM xim = XOpenIM(xfc->display, nullptr, nullptr, nullptr);
1184 if (!xim)
1185 {
1186 WLog_WARN(TAG, "Failed to XOpenIM");
1187 }
1188 else
1189 {
1190 XIC xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
1191 nullptr);
1192 if (!xic)
1193 {
1194 WLog_WARN(TAG, "XCreateIC failed");
1195 }
1196 else
1197 {
1198 KeySym ignore = WINPR_C_ARRAY_INIT;
1199 Status return_status = 0;
1200 XKeyEvent ev = *event;
1201 ev.type = KeyPress;
1202 xwc = XwcLookupString(xic, &ev, buffer, ARRAYSIZE(buffer), &ignore,
1203 &return_status);
1204 XDestroyIC(xic);
1205 }
1206 XCloseIM(xim);
1207 }
1208 }
1209 break;
1210 }
1211
1212 if (xwc < 1)
1213 {
1214 if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
1215 WLog_ERR(TAG, "Unknown key with X keycode 0x%02" PRIx8 "", event->keycode);
1216 else
1217 freerdp_input_send_keyboard_event_ex(input, down, repeat, rdp_scancode);
1218 }
1219 else
1220 {
1221 char str[3 * ARRAYSIZE(buffer)] = WINPR_C_ARRAY_INIT;
1222 // NOLINTNEXTLINE(concurrency-mt-unsafe)
1223 const size_t rc = wcstombs(str, buffer, ARRAYSIZE(buffer));
1224
1225 WCHAR wbuffer[ARRAYSIZE(buffer)] = WINPR_C_ARRAY_INIT;
1226 (void)ConvertUtf8ToWChar(str, wbuffer, rc);
1227 freerdp_input_send_unicode_keyboard_event(input, down ? 0 : KBD_FLAGS_RELEASE,
1228 wbuffer[0]);
1229 }
1230 }
1231 else if (rdp_scancode == RDP_SCANCODE_UNKNOWN)
1232 WLog_ERR(TAG, "Unknown key with X keycode 0x%02" PRIx8 "", event->keycode);
1233 else
1234 freerdp_input_send_keyboard_event_ex(input, down, repeat, rdp_scancode);
1235 }
1236}
1237
1238static int xf_keyboard_read_keyboard_state(xfContext* xfc)
1239{
1240 int dummy = 0;
1241 Window wdummy = 0;
1242 UINT32 state = 0;
1243
1244 if (!xfc->remote_app && xfc->window)
1245 {
1246 XQueryPointer(xfc->display, xfc->window->handle, &wdummy, &wdummy, &dummy, &dummy, &dummy,
1247 &dummy, &state);
1248 }
1249 else
1250 {
1251 XQueryPointer(xfc->display, DefaultRootWindow(xfc->display), &wdummy, &wdummy, &dummy,
1252 &dummy, &dummy, &dummy, &state);
1253 }
1254
1255 return WINPR_ASSERTING_INT_CAST(int, state);
1256}
1257
1258static int xf_keyboard_get_keymask(xfContext* xfc, KeySym keysym)
1259{
1260 int keysymMask = 0;
1261 KeyCode keycode = XKeysymToKeycode(xfc->display, keysym);
1262
1263 if (keycode == NoSymbol)
1264 return 0;
1265
1266 WINPR_ASSERT(xfc->modifierMap);
1267 for (int modifierpos = 0; modifierpos < 8; modifierpos++)
1268 {
1269 int offset = xfc->modifierMap->max_keypermod * modifierpos;
1270
1271 for (int key = 0; key < xfc->modifierMap->max_keypermod; key++)
1272 {
1273 if (xfc->modifierMap->modifiermap[offset + key] == keycode)
1274 {
1275 keysymMask |= 1 << modifierpos;
1276 }
1277 }
1278 }
1279
1280 return keysymMask;
1281}
1282
1283static BOOL xf_keyboard_get_key_state(xfContext* xfc, int state, KeySym keysym)
1284{
1285 int keysymMask = xf_keyboard_get_keymask(xfc, keysym);
1286
1287 if (!keysymMask)
1288 return FALSE;
1289
1290 return (state & keysymMask) != 0;
1291}
1292
1293static BOOL xf_keyboard_set_key_state(xfContext* xfc, BOOL on, KeySym keysym)
1294{
1295 if (!xfc->xkbAvailable)
1296 return FALSE;
1297
1298 const int keysymMask = xf_keyboard_get_keymask(xfc, keysym);
1299
1300 if (!keysymMask)
1301 {
1302 return FALSE;
1303 }
1304
1305 return XkbLockModifiers(xfc->display, XkbUseCoreKbd,
1306 WINPR_ASSERTING_INT_CAST(uint32_t, keysymMask),
1307 on ? WINPR_ASSERTING_INT_CAST(uint32_t, keysymMask) : 0);
1308}
1309
1310UINT32 xf_keyboard_get_toggle_keys_state(xfContext* xfc)
1311{
1312 UINT32 toggleKeysState = 0;
1313 const int state = xf_keyboard_read_keyboard_state(xfc);
1314
1315 if (xf_keyboard_get_key_state(xfc, state, XK_Scroll_Lock))
1316 toggleKeysState |= KBD_SYNC_SCROLL_LOCK;
1317
1318 if (xf_keyboard_get_key_state(xfc, state, XK_Num_Lock))
1319 toggleKeysState |= KBD_SYNC_NUM_LOCK;
1320
1321 if (xf_keyboard_get_key_state(xfc, state, XK_Caps_Lock))
1322 toggleKeysState |= KBD_SYNC_CAPS_LOCK;
1323
1324 if (xf_keyboard_get_key_state(xfc, state, XK_Kana_Lock))
1325 toggleKeysState |= KBD_SYNC_KANA_LOCK;
1326
1327 return toggleKeysState;
1328}
1329
1330static void xk_keyboard_update_modifier_keys(xfContext* xfc)
1331{
1332 const KeySym keysyms[] = { XK_Shift_L, XK_Shift_R, XK_Alt_L, XK_Alt_R,
1333 XK_Control_L, XK_Control_R, XK_Super_L, XK_Super_R };
1334
1335 xf_keyboard_clear(xfc);
1336 if (xfc->deferAlt)
1337 {
1338 /* Focus return starts a new sequence; do not restore held modifiers. */
1339 xfc->deferredAlt.pending = 0;
1340 xfc->deferredAlt.sent = 0;
1341 return;
1342 }
1343
1344 const int state = xf_keyboard_read_keyboard_state(xfc);
1345
1346 for (size_t i = 0; i < ARRAYSIZE(keysyms); i++)
1347 {
1348 if (xf_keyboard_get_key_state(xfc, state, keysyms[i]))
1349 {
1350 const KeyCode keycode = XKeysymToKeycode(xfc->display, keysyms[i]);
1351 WINPR_ASSERT(keycode < ARRAYSIZE(xfc->KeyboardState));
1352 xfc->KeyboardState[keycode] = TRUE;
1353 }
1354 }
1355}
1356
1357void xf_keyboard_focus_in(xfContext* xfc)
1358{
1359 UINT32 state = 0;
1360 Window w = None;
1361 int d = 0;
1362 int x = 0;
1363 int y = 0;
1364
1365 WINPR_ASSERT(xfc);
1366 if (!xfc->display || !xfc->window)
1367 return;
1368
1369 rdpInput* input = xfc->common.context.input;
1370 WINPR_ASSERT(input);
1371
1372 const UINT32 syncFlags = xf_keyboard_get_toggle_keys_state(xfc);
1373 freerdp_input_send_focus_in_event(input, WINPR_ASSERTING_INT_CAST(UINT16, syncFlags));
1374 xk_keyboard_update_modifier_keys(xfc);
1375
1376 /* finish with a mouse pointer position like mstsc.exe if required */
1377
1378 if (xfc->remote_app || !xfc->window)
1379 return;
1380
1381 if (XQueryPointer(xfc->display, xfc->window->handle, &w, &w, &d, &d, &x, &y, &state))
1382 {
1383 if ((x >= 0) && (x < xfc->window->width) && (y >= 0) && (y < xfc->window->height))
1384 {
1385 xf_event_adjust_coordinates(xfc, &x, &y);
1386 freerdp_client_send_button_event(&xfc->common, FALSE, PTR_FLAGS_MOVE, x, y);
1387 }
1388 }
1389}
1390
1391static BOOL action_script_run(xfContext* xfc, const char* buffer, size_t size, void* user,
1392 const char* what, const char* arg)
1393{
1394 WINPR_UNUSED(xfc);
1395 WINPR_UNUSED(what);
1396 WINPR_UNUSED(arg);
1397 WINPR_ASSERT(user);
1398 int* pstatus = user;
1399
1400 if (size == 0)
1401 {
1402 WLog_WARN(TAG, "ActionScript key: script did not return data");
1403 return FALSE;
1404 }
1405
1406 if (strcmp(buffer, "key-local") == 0)
1407 *pstatus = 0;
1408 else if (winpr_PathFileExists(buffer))
1409 {
1410 // NOLINTNEXTLINE(bugprone-command-processor)
1411 FILE* fp = popen(buffer, "w");
1412 if (!fp)
1413 {
1414 WLog_ERR(TAG, "Failed to execute '%s'", buffer);
1415 return FALSE;
1416 }
1417
1418 *pstatus = pclose(fp);
1419 if (*pstatus < 0)
1420 {
1421 WLog_ERR(TAG, "Command '%s' returned %d", buffer, *pstatus);
1422 return FALSE;
1423 }
1424 }
1425 else
1426 {
1427 WLog_WARN(TAG, "ActionScript key: no such file '%s'", buffer);
1428 return FALSE;
1429 }
1430 return TRUE;
1431}
1432
1433static int xf_keyboard_execute_action_script(xfContext* xfc, XF_MODIFIER_KEYS* mod, KeySym keysym)
1434{
1435 int status = 1;
1436 BOOL match = FALSE;
1437 char command[2048] = WINPR_C_ARRAY_INIT;
1438 char combination[1024] = WINPR_C_ARRAY_INIT;
1439
1440 if (!xfc->actionScriptExists)
1441 return 1;
1442
1443 if ((keysym == XK_Shift_L) || (keysym == XK_Shift_R) || (keysym == XK_Alt_L) ||
1444 (keysym == XK_Alt_R) || (keysym == XK_Control_L) || (keysym == XK_Control_R))
1445 {
1446 return 1;
1447 }
1448
1449 const char* keyStr = XKeysymToString(keysym);
1450
1451 if (keyStr == nullptr)
1452 {
1453 return 1;
1454 }
1455
1456 if (mod->Shift)
1457 winpr_str_append("Shift", combination, sizeof(combination), "+");
1458
1459 if (mod->Ctrl)
1460 winpr_str_append("Ctrl", combination, sizeof(combination), "+");
1461
1462 if (mod->Alt)
1463 winpr_str_append("Alt", combination, sizeof(combination), "+");
1464
1465 if (mod->Super)
1466 winpr_str_append("Super", combination, sizeof(combination), "+");
1467
1468 winpr_str_append(keyStr, combination, sizeof(combination), "+");
1469
1470 for (size_t i = 0; i < strnlen(combination, sizeof(combination)); i++)
1471 combination[i] = WINPR_ASSERTING_INT_CAST(char, tolower(combination[i]));
1472
1473 const size_t count = ArrayList_Count(xfc->keyCombinations);
1474
1475 for (size_t index = 0; index < count; index++)
1476 {
1477 const char* keyCombination = (const char*)ArrayList_GetItem(xfc->keyCombinations, index);
1478
1479 if (_stricmp(keyCombination, combination) == 0)
1480 {
1481 match = TRUE;
1482 break;
1483 }
1484 }
1485
1486 if (!match)
1487 return 1;
1488
1489 (void)sprintf_s(command, sizeof(command), "key %s", combination);
1490 if (!run_action_script(xfc, command, nullptr, action_script_run, &status))
1491 return -1;
1492
1493 return status;
1494}
1495
1496static int xk_keyboard_get_modifier_keys(xfContext* xfc, XF_MODIFIER_KEYS* mod)
1497{
1498 mod->LeftShift = xf_keyboard_key_pressed(xfc, XK_Shift_L);
1499 mod->RightShift = xf_keyboard_key_pressed(xfc, XK_Shift_R);
1500 mod->Shift = mod->LeftShift || mod->RightShift;
1501 mod->LeftAlt = xf_keyboard_key_pressed(xfc, XK_Alt_L);
1502 mod->RightAlt = xf_keyboard_key_pressed(xfc, XK_Alt_R);
1503 mod->Alt = mod->LeftAlt || mod->RightAlt;
1504 mod->LeftCtrl = xf_keyboard_key_pressed(xfc, XK_Control_L);
1505 mod->RightCtrl = xf_keyboard_key_pressed(xfc, XK_Control_R);
1506 mod->Ctrl = mod->LeftCtrl || mod->RightCtrl;
1507 mod->LeftSuper = xf_keyboard_key_pressed(xfc, XK_Super_L);
1508 mod->RightSuper = xf_keyboard_key_pressed(xfc, XK_Super_R);
1509 mod->Super = mod->LeftSuper || mod->RightSuper;
1510 return 0;
1511}
1512
1513BOOL xf_keyboard_handle_special_keys(xfContext* xfc, KeySym keysym)
1514{
1515 XF_MODIFIER_KEYS mod = WINPR_C_ARRAY_INIT;
1516 xk_keyboard_get_modifier_keys(xfc, &mod);
1517
1518 // remember state of RightCtrl to ungrab keyboard if next action is release of RightCtrl
1519 // do not return anything such that the key could be used by client if ungrab is not the goal
1520 if (keysym == XK_Control_R)
1521 {
1522 if (mod.RightCtrl && !xfc->wasRightCtrlAlreadyPressed)
1523 {
1524 // Right Ctrl is pressed, getting ready to ungrab
1525 xfc->ungrabKeyboardWithRightCtrl = TRUE;
1526 xfc->wasRightCtrlAlreadyPressed = TRUE;
1527 }
1528 }
1529 else
1530 {
1531 // some other key has been pressed, abort ungrabbing
1532 if (xfc->ungrabKeyboardWithRightCtrl)
1533 xfc->ungrabKeyboardWithRightCtrl = FALSE;
1534 }
1535
1536 const int rc = xf_keyboard_execute_action_script(xfc, &mod, keysym);
1537 if (rc < 0)
1538 return FALSE;
1539 if (rc == 0)
1540 return TRUE;
1541
1542 if (!xfc->remote_app && xfc->fullscreen_toggle)
1543 {
1544 switch (keysym)
1545 {
1546 case XK_Return:
1547 if (mod.Ctrl && mod.Alt)
1548 {
1549 /* Ctrl-Alt-Enter: toggle full screen */
1550 WLog_INFO(TAG, "<ctrl>+<alt>+<enter> pressed, toggling fullscreen state...");
1551 xf_sync_kbd_state(xfc);
1552 xf_toggle_fullscreen(xfc);
1553 return TRUE;
1554 }
1555 break;
1556 default:
1557 break;
1558 }
1559 }
1560
1561 if (mod.Ctrl && mod.Alt)
1562 {
1563 switch (keysym)
1564 {
1565 case XK_m:
1566 case XK_M:
1567 WLog_INFO(TAG, "<ctrl>+<alt>+m pressed, minimizing RDP session...");
1568 xf_sync_kbd_state(xfc);
1569 xf_minimize(xfc);
1570 return TRUE;
1571 case XK_c:
1572 case XK_C:
1573 /* Ctrl-Alt-C: toggle control */
1574 WLog_INFO(TAG, "<ctrl>+<alt>+c pressed, toggle encomps control...");
1575 if (freerdp_client_encomsp_toggle_control(xfc->common.encomsp))
1576 return TRUE;
1577 break;
1578 case XK_d:
1579 case XK_D:
1580 /* <ctrl>+<alt>+d: disconnect session */
1581 WLog_INFO(TAG, "<ctrl>+<alt>+d pressed, terminating RDP session...");
1582 xf_sync_kbd_state(xfc);
1583 return freerdp_abort_connect_context(&xfc->common.context);
1584
1585 default:
1586 break;
1587 }
1588 }
1589
1590#if 0 /* set to 1 to enable multi touch gesture simulation via keyboard */
1591#ifdef WITH_XRENDER
1592
1593 if (!xfc->remote_app && freerdp_settings_get_bool(xfc->common.context.settings, FreeRDP_MultiTouchGestures))
1594 {
1595 rdpContext* ctx = &xfc->common.context;
1596
1597 if (mod.Ctrl && mod.Alt)
1598 {
1599 int pdx = 0;
1600 int pdy = 0;
1601 int zdx = 0;
1602 int zdy = 0;
1603
1604 switch (keysym)
1605 {
1606 case XK_0: /* Ctrl-Alt-0: Reset scaling and panning */{
1607 const UINT32 sessionWidth = freerdp_settings_get_uint32(xfc->common.context.settings, FreeRDP_DesktopWidth);
1608 const UINT32 sessionHeight = freerdp_settings_get_uint32(xfc->common.context.settings, FreeRDP_DesktopHeight);
1609
1610 xfc->scaledWidth = sessionWidth;
1611 xfc->scaledHeight = sessionHeight;
1612 xfc->offset_x = 0;
1613 xfc->offset_y = 0;
1614
1615 if (!xfc->fullscreen && (sessionWidth != xfc->window->width ||
1616 sessionHeight != xfc->window->height))
1617 {
1618 xf_ResizeDesktopWindow(xfc, xfc->window, sessionWidth, sessionHeight);
1619 }
1620
1621 xf_draw_screen(xfc, 0, 0, sessionWidth, sessionHeight);
1622 return TRUE;
1623}
1624
1625 case XK_1: /* Ctrl-Alt-1: Zoom in */
1626 zdx = zdy = 10;
1627 break;
1628
1629 case XK_2: /* Ctrl-Alt-2: Zoom out */
1630 zdx = zdy = -10;
1631 break;
1632
1633 case XK_3: /* Ctrl-Alt-3: Pan left */
1634 pdx = -10;
1635 break;
1636
1637 case XK_4: /* Ctrl-Alt-4: Pan right */
1638 pdx = 10;
1639 break;
1640
1641 case XK_5: /* Ctrl-Alt-5: Pan up */
1642 pdy = -10;
1643 break;
1644
1645 case XK_6: /* Ctrl-Alt-6: Pan up */
1646 pdy = 10;
1647 break;
1648 }
1649
1650 if (pdx != 0 || pdy != 0)
1651 {
1652 PanningChangeEventArgs e;
1653 EventArgsInit(&e, "xfreerdp");
1654 e.dx = pdx;
1655 e.dy = pdy;
1656 if (PubSub_OnPanningChange(ctx->pubSub, xfc, &e)<0)
1657 return FALSE;
1658 return TRUE;
1659 }
1660
1661 if (zdx != 0 || zdy != 0)
1662 {
1663 ZoomingChangeEventArgs e;
1664 EventArgsInit(&e, "xfreerdp");
1665 e.dx = zdx;
1666 e.dy = zdy;
1667 if (PubSub_OnZoomingChange(ctx->pubSub, xfc, &e)<0)
1668 return FALSE;
1669 return TRUE;
1670 }
1671 }
1672 }
1673
1674#endif /* WITH_XRENDER defined */
1675#endif /* pinch/zoom/pan simulation */
1676 return FALSE;
1677}
1678
1679void xf_keyboard_handle_special_keys_release(xfContext* xfc, KeySym keysym)
1680{
1681 if (keysym != XK_Control_R)
1682 return;
1683
1684 xfc->wasRightCtrlAlreadyPressed = FALSE;
1685
1686 if (!xfc->ungrabKeyboardWithRightCtrl)
1687 return;
1688
1689 // all requirements for ungrab are fulfilled, ungrabbing now
1690 XF_MODIFIER_KEYS mod = WINPR_C_ARRAY_INIT;
1691 xk_keyboard_get_modifier_keys(xfc, &mod);
1692
1693 if (!mod.RightCtrl)
1694 {
1695 if (!xfc->fullscreen)
1696 {
1697 xf_sync_kbd_state(xfc);
1698 freerdp_client_encomsp_toggle_control(xfc->common.encomsp);
1699 }
1700
1701 xfc->mouse_active = FALSE;
1702 xf_ungrab(xfc);
1703 }
1704
1705 // ungrabbed
1706 xfc->ungrabKeyboardWithRightCtrl = FALSE;
1707}
1708
1709BOOL xf_keyboard_set_indicators(rdpContext* context, UINT16 led_flags)
1710{
1711 xfContext* xfc = (xfContext*)context;
1712 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_SCROLL_LOCK, XK_Scroll_Lock);
1713 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_NUM_LOCK, XK_Num_Lock);
1714 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_CAPS_LOCK, XK_Caps_Lock);
1715 xf_keyboard_set_key_state(xfc, led_flags & KBD_SYNC_KANA_LOCK, XK_Kana_Lock);
1716 return TRUE;
1717}
1718
1719BOOL xf_keyboard_set_ime_status(rdpContext* context, UINT16 imeId, UINT32 imeState,
1720 UINT32 imeConvMode)
1721{
1722 if (!context)
1723 return FALSE;
1724
1725 WLog_WARN(TAG,
1726 "KeyboardSetImeStatus(unitId=%04" PRIx16 ", imeState=%08" PRIx32
1727 ", imeConvMode=%08" PRIx32 ") ignored",
1728 imeId, imeState, imeConvMode);
1729 return TRUE;
1730}
1731
1732BOOL xf_ungrab(xfContext* xfc)
1733{
1734 WINPR_ASSERT(xfc);
1735 if (xfc->deferAlt)
1736 xf_keyboard_release_all_keypress(xfc);
1737 XUngrabKeyboard(xfc->display, CurrentTime);
1738 XUngrabPointer(xfc->display, CurrentTime);
1739 xfc->common.mouse_grabbed = FALSE;
1740 return TRUE;
1741}
freerdp_settings_set_uint32
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 val)
Sets a UINT32 settings value.
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
wObject
This struct contains function pointer to initialize/free objects.
Definition collections.h:52
wObject::fnObjectFree
OBJECT_FREE_FN fnObjectFree
Definition collections.h:59
wObject::fnObjectNew
WINPR_ATTR_NODISCARD OBJECT_NEW_FN fnObjectNew
Definition collections.h:54