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