1 /* $OpenBSD$ */
2
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include <sys/types.h>
20 #include <sys/time.h>
21
22 #include <netinet/in.h>
23
24 #include <ctype.h>
25 #include <limits.h>
26 #include <resolv.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <termios.h>
30 #include <unistd.h>
31
32 #include "tmux.h"
33
34 /*
35 * Handle keys input from the outside terminal. tty_default_*_keys[] are a base
36 * table of supported keys which are looked up in terminfo(5) and translated
37 * into a ternary tree.
38 */
39
40 static void tty_keys_add1(struct tty_key **, const char *, key_code);
41 static void tty_keys_add(struct tty *, const char *, key_code);
42 static void tty_keys_free1(struct tty_key *);
43 static struct tty_key *tty_keys_find1(struct tty_key *, const char *, size_t,
44 size_t *);
45 static struct tty_key *tty_keys_find(struct tty *, const char *, size_t,
46 size_t *);
47 static int tty_keys_next1(struct tty *, const char *, size_t, key_code *,
48 size_t *, int);
49 static void tty_keys_callback(int, short, void *);
50 static int tty_keys_extended_key(struct tty *, const char *, size_t,
51 size_t *, key_code *);
52 static int tty_keys_mouse(struct tty *, const char *, size_t, size_t *,
53 struct mouse_event *);
54 static int tty_keys_clipboard(struct tty *, const char *, size_t,
55 size_t *);
56 static int tty_keys_device_attributes(struct tty *, const char *, size_t,
57 size_t *);
58 static int tty_keys_device_attributes2(struct tty *, const char *, size_t,
59 size_t *);
60 static int tty_keys_extended_device_attributes(struct tty *, const char *,
61 size_t, size_t *);
62
63 /* A key tree entry. */
64 struct tty_key {
65 char ch;
66 key_code key;
67
68 struct tty_key *left;
69 struct tty_key *right;
70
71 struct tty_key *next;
72 };
73
74 /* Default raw keys. */
75 struct tty_default_key_raw {
76 const char *string;
77 key_code key;
78 };
79 static const struct tty_default_key_raw tty_default_raw_keys[] = {
80 /* Application escape. */
81 { "\033O[", '\033' },
82
83 /*
84 * Numeric keypad. Just use the vt100 escape sequences here and always
85 * put the terminal into keypad_xmit mode. Translation of numbers
86 * mode/applications mode is done in input-keys.c.
87 */
88 { "\033Oo", KEYC_KP_SLASH|KEYC_KEYPAD },
89 { "\033Oj", KEYC_KP_STAR|KEYC_KEYPAD },
90 { "\033Om", KEYC_KP_MINUS|KEYC_KEYPAD },
91 { "\033Ow", KEYC_KP_SEVEN|KEYC_KEYPAD },
92 { "\033Ox", KEYC_KP_EIGHT|KEYC_KEYPAD },
93 { "\033Oy", KEYC_KP_NINE|KEYC_KEYPAD },
94 { "\033Ok", KEYC_KP_PLUS|KEYC_KEYPAD },
95 { "\033Ot", KEYC_KP_FOUR|KEYC_KEYPAD },
96 { "\033Ou", KEYC_KP_FIVE|KEYC_KEYPAD },
97 { "\033Ov", KEYC_KP_SIX|KEYC_KEYPAD },
98 { "\033Oq", KEYC_KP_ONE|KEYC_KEYPAD },
99 { "\033Or", KEYC_KP_TWO|KEYC_KEYPAD },
100 { "\033Os", KEYC_KP_THREE|KEYC_KEYPAD },
101 { "\033OM", KEYC_KP_ENTER|KEYC_KEYPAD },
102 { "\033Op", KEYC_KP_ZERO|KEYC_KEYPAD },
103 { "\033On", KEYC_KP_PERIOD|KEYC_KEYPAD },
104
105 /* Arrow keys. */
106 { "\033OA", KEYC_UP|KEYC_CURSOR },
107 { "\033OB", KEYC_DOWN|KEYC_CURSOR },
108 { "\033OC", KEYC_RIGHT|KEYC_CURSOR },
109 { "\033OD", KEYC_LEFT|KEYC_CURSOR },
110
111 { "\033[A", KEYC_UP|KEYC_CURSOR },
112 { "\033[B", KEYC_DOWN|KEYC_CURSOR },
113 { "\033[C", KEYC_RIGHT|KEYC_CURSOR },
114 { "\033[D", KEYC_LEFT|KEYC_CURSOR },
115
116 /*
117 * Meta arrow keys. These do not get the IMPLIED_META flag so they
118 * don't match the xterm-style meta keys in the output tree - Escape+Up
119 * should stay as Escape+Up and not become M-Up.
120 */
121 { "\033\033OA", KEYC_UP|KEYC_CURSOR|KEYC_META },
122 { "\033\033OB", KEYC_DOWN|KEYC_CURSOR|KEYC_META },
123 { "\033\033OC", KEYC_RIGHT|KEYC_CURSOR|KEYC_META },
124 { "\033\033OD", KEYC_LEFT|KEYC_CURSOR|KEYC_META },
125
126 { "\033\033[A", KEYC_UP|KEYC_CURSOR|KEYC_META },
127 { "\033\033[B", KEYC_DOWN|KEYC_CURSOR|KEYC_META },
128 { "\033\033[C", KEYC_RIGHT|KEYC_CURSOR|KEYC_META },
129 { "\033\033[D", KEYC_LEFT|KEYC_CURSOR|KEYC_META },
130
131 /* Other xterm keys. */
132 { "\033OH", KEYC_HOME },
133 { "\033OF", KEYC_END },
134
135 { "\033\033OH", KEYC_HOME|KEYC_META|KEYC_IMPLIED_META },
136 { "\033\033OF", KEYC_END|KEYC_META|KEYC_IMPLIED_META },
137
138 { "\033[H", KEYC_HOME },
139 { "\033[F", KEYC_END },
140
141 { "\033\033[H", KEYC_HOME|KEYC_META|KEYC_IMPLIED_META },
142 { "\033\033[F", KEYC_END|KEYC_META|KEYC_IMPLIED_META },
143
144 /* rxvt arrow keys. */
145 { "\033Oa", KEYC_UP|KEYC_CTRL },
146 { "\033Ob", KEYC_DOWN|KEYC_CTRL },
147 { "\033Oc", KEYC_RIGHT|KEYC_CTRL },
148 { "\033Od", KEYC_LEFT|KEYC_CTRL },
149
150 { "\033[a", KEYC_UP|KEYC_SHIFT },
151 { "\033[b", KEYC_DOWN|KEYC_SHIFT },
152 { "\033[c", KEYC_RIGHT|KEYC_SHIFT },
153 { "\033[d", KEYC_LEFT|KEYC_SHIFT },
154
155 /* rxvt function keys. */
156 { "\033[11~", KEYC_F1 },
157 { "\033[12~", KEYC_F2 },
158 { "\033[13~", KEYC_F3 },
159 { "\033[14~", KEYC_F4 },
160 { "\033[15~", KEYC_F5 },
161 { "\033[17~", KEYC_F6 },
162 { "\033[18~", KEYC_F7 },
163 { "\033[19~", KEYC_F8 },
164 { "\033[20~", KEYC_F9 },
165 { "\033[21~", KEYC_F10 },
166
167 { "\033[23~", KEYC_F1|KEYC_SHIFT },
168 { "\033[24~", KEYC_F2|KEYC_SHIFT },
169 { "\033[25~", KEYC_F3|KEYC_SHIFT },
170 { "\033[26~", KEYC_F4|KEYC_SHIFT },
171 { "\033[28~", KEYC_F5|KEYC_SHIFT },
172 { "\033[29~", KEYC_F6|KEYC_SHIFT },
173 { "\033[31~", KEYC_F7|KEYC_SHIFT },
174 { "\033[32~", KEYC_F8|KEYC_SHIFT },
175 { "\033[33~", KEYC_F9|KEYC_SHIFT },
176 { "\033[34~", KEYC_F10|KEYC_SHIFT },
177 { "\033[23$", KEYC_F11|KEYC_SHIFT },
178 { "\033[24$", KEYC_F12|KEYC_SHIFT },
179
180 { "\033[11^", KEYC_F1|KEYC_CTRL },
181 { "\033[12^", KEYC_F2|KEYC_CTRL },
182 { "\033[13^", KEYC_F3|KEYC_CTRL },
183 { "\033[14^", KEYC_F4|KEYC_CTRL },
184 { "\033[15^", KEYC_F5|KEYC_CTRL },
185 { "\033[17^", KEYC_F6|KEYC_CTRL },
186 { "\033[18^", KEYC_F7|KEYC_CTRL },
187 { "\033[19^", KEYC_F8|KEYC_CTRL },
188 { "\033[20^", KEYC_F9|KEYC_CTRL },
189 { "\033[21^", KEYC_F10|KEYC_CTRL },
190 { "\033[23^", KEYC_F11|KEYC_CTRL },
191 { "\033[24^", KEYC_F12|KEYC_CTRL },
192
193 { "\033[11@", KEYC_F1|KEYC_CTRL|KEYC_SHIFT },
194 { "\033[12@", KEYC_F2|KEYC_CTRL|KEYC_SHIFT },
195 { "\033[13@", KEYC_F3|KEYC_CTRL|KEYC_SHIFT },
196 { "\033[14@", KEYC_F4|KEYC_CTRL|KEYC_SHIFT },
197 { "\033[15@", KEYC_F5|KEYC_CTRL|KEYC_SHIFT },
198 { "\033[17@", KEYC_F6|KEYC_CTRL|KEYC_SHIFT },
199 { "\033[18@", KEYC_F7|KEYC_CTRL|KEYC_SHIFT },
200 { "\033[19@", KEYC_F8|KEYC_CTRL|KEYC_SHIFT },
201 { "\033[20@", KEYC_F9|KEYC_CTRL|KEYC_SHIFT },
202 { "\033[21@", KEYC_F10|KEYC_CTRL|KEYC_SHIFT },
203 { "\033[23@", KEYC_F11|KEYC_CTRL|KEYC_SHIFT },
204 { "\033[24@", KEYC_F12|KEYC_CTRL|KEYC_SHIFT },
205
206 /* Focus tracking. */
207 { "\033[I", KEYC_FOCUS_IN },
208 { "\033[O", KEYC_FOCUS_OUT },
209
210 /* Paste keys. */
211 { "\033[200~", KEYC_PASTE_START },
212 { "\033[201~", KEYC_PASTE_END },
213
214 /* Extended keys. */
215 { "\033[1;5Z", '\011'|KEYC_CTRL|KEYC_SHIFT },
216 };
217
218 /* Default xterm keys. */
219 struct tty_default_key_xterm {
220 const char *template;
221 key_code key;
222 };
223 static const struct tty_default_key_xterm tty_default_xterm_keys[] = {
224 { "\033[1;_P", KEYC_F1 },
225 { "\033O1;_P", KEYC_F1 },
226 { "\033O_P", KEYC_F1 },
227 { "\033[1;_Q", KEYC_F2 },
228 { "\033O1;_Q", KEYC_F2 },
229 { "\033O_Q", KEYC_F2 },
230 { "\033[1;_R", KEYC_F3 },
231 { "\033O1;_R", KEYC_F3 },
232 { "\033O_R", KEYC_F3 },
233 { "\033[1;_S", KEYC_F4 },
234 { "\033O1;_S", KEYC_F4 },
235 { "\033O_S", KEYC_F4 },
236 { "\033[15;_~", KEYC_F5 },
237 { "\033[17;_~", KEYC_F6 },
238 { "\033[18;_~", KEYC_F7 },
239 { "\033[19;_~", KEYC_F8 },
240 { "\033[20;_~", KEYC_F9 },
241 { "\033[21;_~", KEYC_F10 },
242 { "\033[23;_~", KEYC_F11 },
243 { "\033[24;_~", KEYC_F12 },
244 { "\033[1;_A", KEYC_UP },
245 { "\033[1;_B", KEYC_DOWN },
246 { "\033[1;_C", KEYC_RIGHT },
247 { "\033[1;_D", KEYC_LEFT },
248 { "\033[1;_H", KEYC_HOME },
249 { "\033[1;_F", KEYC_END },
250 { "\033[5;_~", KEYC_PPAGE },
251 { "\033[6;_~", KEYC_NPAGE },
252 { "\033[2;_~", KEYC_IC },
253 { "\033[3;_~", KEYC_DC },
254 };
255 static const key_code tty_default_xterm_modifiers[] = {
256 0,
257 0,
258 KEYC_SHIFT,
259 KEYC_META|KEYC_IMPLIED_META,
260 KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META,
261 KEYC_CTRL,
262 KEYC_SHIFT|KEYC_CTRL,
263 KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL,
264 KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL,
265 KEYC_META|KEYC_IMPLIED_META
266 };
267
268 /*
269 * Default terminfo(5) keys. Any keys that have builtin modifiers (that is,
270 * where the key itself contains the modifiers) has the KEYC_XTERM flag set so
271 * a leading escape is not treated as meta (and probably removed).
272 */
273 struct tty_default_key_code {
274 enum tty_code_code code;
275 key_code key;
276 };
277 static const struct tty_default_key_code tty_default_code_keys[] = {
278 /* Function keys. */
279 { TTYC_KF1, KEYC_F1 },
280 { TTYC_KF2, KEYC_F2 },
281 { TTYC_KF3, KEYC_F3 },
282 { TTYC_KF4, KEYC_F4 },
283 { TTYC_KF5, KEYC_F5 },
284 { TTYC_KF6, KEYC_F6 },
285 { TTYC_KF7, KEYC_F7 },
286 { TTYC_KF8, KEYC_F8 },
287 { TTYC_KF9, KEYC_F9 },
288 { TTYC_KF10, KEYC_F10 },
289 { TTYC_KF11, KEYC_F11 },
290 { TTYC_KF12, KEYC_F12 },
291
292 { TTYC_KF13, KEYC_F1|KEYC_SHIFT },
293 { TTYC_KF14, KEYC_F2|KEYC_SHIFT },
294 { TTYC_KF15, KEYC_F3|KEYC_SHIFT },
295 { TTYC_KF16, KEYC_F4|KEYC_SHIFT },
296 { TTYC_KF17, KEYC_F5|KEYC_SHIFT },
297 { TTYC_KF18, KEYC_F6|KEYC_SHIFT },
298 { TTYC_KF19, KEYC_F7|KEYC_SHIFT },
299 { TTYC_KF20, KEYC_F8|KEYC_SHIFT },
300 { TTYC_KF21, KEYC_F9|KEYC_SHIFT },
301 { TTYC_KF22, KEYC_F10|KEYC_SHIFT },
302 { TTYC_KF23, KEYC_F11|KEYC_SHIFT },
303 { TTYC_KF24, KEYC_F12|KEYC_SHIFT },
304
305 { TTYC_KF25, KEYC_F1|KEYC_CTRL },
306 { TTYC_KF26, KEYC_F2|KEYC_CTRL },
307 { TTYC_KF27, KEYC_F3|KEYC_CTRL },
308 { TTYC_KF28, KEYC_F4|KEYC_CTRL },
309 { TTYC_KF29, KEYC_F5|KEYC_CTRL },
310 { TTYC_KF30, KEYC_F6|KEYC_CTRL },
311 { TTYC_KF31, KEYC_F7|KEYC_CTRL },
312 { TTYC_KF32, KEYC_F8|KEYC_CTRL },
313 { TTYC_KF33, KEYC_F9|KEYC_CTRL },
314 { TTYC_KF34, KEYC_F10|KEYC_CTRL },
315 { TTYC_KF35, KEYC_F11|KEYC_CTRL },
316 { TTYC_KF36, KEYC_F12|KEYC_CTRL },
317
318 { TTYC_KF37, KEYC_F1|KEYC_SHIFT|KEYC_CTRL },
319 { TTYC_KF38, KEYC_F2|KEYC_SHIFT|KEYC_CTRL },
320 { TTYC_KF39, KEYC_F3|KEYC_SHIFT|KEYC_CTRL },
321 { TTYC_KF40, KEYC_F4|KEYC_SHIFT|KEYC_CTRL },
322 { TTYC_KF41, KEYC_F5|KEYC_SHIFT|KEYC_CTRL },
323 { TTYC_KF42, KEYC_F6|KEYC_SHIFT|KEYC_CTRL },
324 { TTYC_KF43, KEYC_F7|KEYC_SHIFT|KEYC_CTRL },
325 { TTYC_KF44, KEYC_F8|KEYC_SHIFT|KEYC_CTRL },
326 { TTYC_KF45, KEYC_F9|KEYC_SHIFT|KEYC_CTRL },
327 { TTYC_KF46, KEYC_F10|KEYC_SHIFT|KEYC_CTRL },
328 { TTYC_KF47, KEYC_F11|KEYC_SHIFT|KEYC_CTRL },
329 { TTYC_KF48, KEYC_F12|KEYC_SHIFT|KEYC_CTRL },
330
331 { TTYC_KF49, KEYC_F1|KEYC_META|KEYC_IMPLIED_META },
332 { TTYC_KF50, KEYC_F2|KEYC_META|KEYC_IMPLIED_META },
333 { TTYC_KF51, KEYC_F3|KEYC_META|KEYC_IMPLIED_META },
334 { TTYC_KF52, KEYC_F4|KEYC_META|KEYC_IMPLIED_META },
335 { TTYC_KF53, KEYC_F5|KEYC_META|KEYC_IMPLIED_META },
336 { TTYC_KF54, KEYC_F6|KEYC_META|KEYC_IMPLIED_META },
337 { TTYC_KF55, KEYC_F7|KEYC_META|KEYC_IMPLIED_META },
338 { TTYC_KF56, KEYC_F8|KEYC_META|KEYC_IMPLIED_META },
339 { TTYC_KF57, KEYC_F9|KEYC_META|KEYC_IMPLIED_META },
340 { TTYC_KF58, KEYC_F10|KEYC_META|KEYC_IMPLIED_META },
341 { TTYC_KF59, KEYC_F11|KEYC_META|KEYC_IMPLIED_META },
342 { TTYC_KF60, KEYC_F12|KEYC_META|KEYC_IMPLIED_META },
343
344 { TTYC_KF61, KEYC_F1|KEYC_META|KEYC_IMPLIED_META|KEYC_SHIFT },
345 { TTYC_KF62, KEYC_F2|KEYC_META|KEYC_IMPLIED_META|KEYC_SHIFT },
346 { TTYC_KF63, KEYC_F3|KEYC_META|KEYC_IMPLIED_META|KEYC_SHIFT },
347
348 { TTYC_KICH1, KEYC_IC },
349 { TTYC_KDCH1, KEYC_DC },
350 { TTYC_KHOME, KEYC_HOME },
351 { TTYC_KEND, KEYC_END },
352 { TTYC_KNP, KEYC_NPAGE },
353 { TTYC_KPP, KEYC_PPAGE },
354 { TTYC_KCBT, KEYC_BTAB },
355
356 /* Arrow keys from terminfo. */
357 { TTYC_KCUU1, KEYC_UP|KEYC_CURSOR },
358 { TTYC_KCUD1, KEYC_DOWN|KEYC_CURSOR },
359 { TTYC_KCUB1, KEYC_LEFT|KEYC_CURSOR },
360 { TTYC_KCUF1, KEYC_RIGHT|KEYC_CURSOR },
361
362 /* Key and modifier capabilities. */
363 { TTYC_KDC2, KEYC_DC|KEYC_SHIFT },
364 { TTYC_KDC3, KEYC_DC|KEYC_META|KEYC_IMPLIED_META },
365 { TTYC_KDC4, KEYC_DC|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
366 { TTYC_KDC5, KEYC_DC|KEYC_CTRL },
367 { TTYC_KDC6, KEYC_DC|KEYC_SHIFT|KEYC_CTRL },
368 { TTYC_KDC7, KEYC_DC|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
369 { TTYC_KIND, KEYC_DOWN|KEYC_SHIFT },
370 { TTYC_KDN2, KEYC_DOWN|KEYC_SHIFT },
371 { TTYC_KDN3, KEYC_DOWN|KEYC_META|KEYC_IMPLIED_META },
372 { TTYC_KDN4, KEYC_DOWN|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
373 { TTYC_KDN5, KEYC_DOWN|KEYC_CTRL },
374 { TTYC_KDN6, KEYC_DOWN|KEYC_SHIFT|KEYC_CTRL },
375 { TTYC_KDN7, KEYC_DOWN|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
376 { TTYC_KEND2, KEYC_END|KEYC_SHIFT },
377 { TTYC_KEND3, KEYC_END|KEYC_META|KEYC_IMPLIED_META },
378 { TTYC_KEND4, KEYC_END|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
379 { TTYC_KEND5, KEYC_END|KEYC_CTRL },
380 { TTYC_KEND6, KEYC_END|KEYC_SHIFT|KEYC_CTRL },
381 { TTYC_KEND7, KEYC_END|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
382 { TTYC_KHOM2, KEYC_HOME|KEYC_SHIFT },
383 { TTYC_KHOM3, KEYC_HOME|KEYC_META|KEYC_IMPLIED_META },
384 { TTYC_KHOM4, KEYC_HOME|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
385 { TTYC_KHOM5, KEYC_HOME|KEYC_CTRL },
386 { TTYC_KHOM6, KEYC_HOME|KEYC_SHIFT|KEYC_CTRL },
387 { TTYC_KHOM7, KEYC_HOME|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
388 { TTYC_KIC2, KEYC_IC|KEYC_SHIFT },
389 { TTYC_KIC3, KEYC_IC|KEYC_META|KEYC_IMPLIED_META },
390 { TTYC_KIC4, KEYC_IC|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
391 { TTYC_KIC5, KEYC_IC|KEYC_CTRL },
392 { TTYC_KIC6, KEYC_IC|KEYC_SHIFT|KEYC_CTRL },
393 { TTYC_KIC7, KEYC_IC|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
394 { TTYC_KLFT2, KEYC_LEFT|KEYC_SHIFT },
395 { TTYC_KLFT3, KEYC_LEFT|KEYC_META|KEYC_IMPLIED_META },
396 { TTYC_KLFT4, KEYC_LEFT|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
397 { TTYC_KLFT5, KEYC_LEFT|KEYC_CTRL },
398 { TTYC_KLFT6, KEYC_LEFT|KEYC_SHIFT|KEYC_CTRL },
399 { TTYC_KLFT7, KEYC_LEFT|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
400 { TTYC_KNXT2, KEYC_NPAGE|KEYC_SHIFT },
401 { TTYC_KNXT3, KEYC_NPAGE|KEYC_META|KEYC_IMPLIED_META },
402 { TTYC_KNXT4, KEYC_NPAGE|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
403 { TTYC_KNXT5, KEYC_NPAGE|KEYC_CTRL },
404 { TTYC_KNXT6, KEYC_NPAGE|KEYC_SHIFT|KEYC_CTRL },
405 { TTYC_KNXT7, KEYC_NPAGE|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
406 { TTYC_KPRV2, KEYC_PPAGE|KEYC_SHIFT },
407 { TTYC_KPRV3, KEYC_PPAGE|KEYC_META|KEYC_IMPLIED_META },
408 { TTYC_KPRV4, KEYC_PPAGE|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
409 { TTYC_KPRV5, KEYC_PPAGE|KEYC_CTRL },
410 { TTYC_KPRV6, KEYC_PPAGE|KEYC_SHIFT|KEYC_CTRL },
411 { TTYC_KPRV7, KEYC_PPAGE|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
412 { TTYC_KRIT2, KEYC_RIGHT|KEYC_SHIFT },
413 { TTYC_KRIT3, KEYC_RIGHT|KEYC_META|KEYC_IMPLIED_META },
414 { TTYC_KRIT4, KEYC_RIGHT|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
415 { TTYC_KRIT5, KEYC_RIGHT|KEYC_CTRL },
416 { TTYC_KRIT6, KEYC_RIGHT|KEYC_SHIFT|KEYC_CTRL },
417 { TTYC_KRIT7, KEYC_RIGHT|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
418 { TTYC_KRI, KEYC_UP|KEYC_SHIFT },
419 { TTYC_KUP2, KEYC_UP|KEYC_SHIFT },
420 { TTYC_KUP3, KEYC_UP|KEYC_META|KEYC_IMPLIED_META },
421 { TTYC_KUP4, KEYC_UP|KEYC_SHIFT|KEYC_META|KEYC_IMPLIED_META },
422 { TTYC_KUP5, KEYC_UP|KEYC_CTRL },
423 { TTYC_KUP6, KEYC_UP|KEYC_SHIFT|KEYC_CTRL },
424 { TTYC_KUP7, KEYC_UP|KEYC_META|KEYC_IMPLIED_META|KEYC_CTRL },
425 };
426
427 /* Add key to tree. */
428 static void
tty_keys_add(struct tty * tty,const char * s,key_code key)429 tty_keys_add(struct tty *tty, const char *s, key_code key)
430 {
431 struct tty_key *tk;
432 size_t size;
433 const char *keystr;
434
435 keystr = key_string_lookup_key(key, 1);
436 if ((tk = tty_keys_find(tty, s, strlen(s), &size)) == NULL) {
437 log_debug("new key %s: 0x%llx (%s)", s, key, keystr);
438 tty_keys_add1(&tty->key_tree, s, key);
439 } else {
440 log_debug("replacing key %s: 0x%llx (%s)", s, key, keystr);
441 tk->key = key;
442 }
443 }
444
445 /* Add next node to the tree. */
446 static void
tty_keys_add1(struct tty_key ** tkp,const char * s,key_code key)447 tty_keys_add1(struct tty_key **tkp, const char *s, key_code key)
448 {
449 struct tty_key *tk;
450
451 /* Allocate a tree entry if there isn't one already. */
452 tk = *tkp;
453 if (tk == NULL) {
454 tk = *tkp = xcalloc(1, sizeof *tk);
455 tk->ch = *s;
456 tk->key = KEYC_UNKNOWN;
457 }
458
459 /* Find the next entry. */
460 if (*s == tk->ch) {
461 /* Move forward in string. */
462 s++;
463
464 /* If this is the end of the string, no more is necessary. */
465 if (*s == '\0') {
466 tk->key = key;
467 return;
468 }
469
470 /* Use the child tree for the next character. */
471 tkp = &tk->next;
472 } else {
473 if (*s < tk->ch)
474 tkp = &tk->left;
475 else if (*s > tk->ch)
476 tkp = &tk->right;
477 }
478
479 /* And recurse to add it. */
480 tty_keys_add1(tkp, s, key);
481 }
482
483 /* Initialise a key tree from the table. */
484 void
tty_keys_build(struct tty * tty)485 tty_keys_build(struct tty *tty)
486 {
487 const struct tty_default_key_raw *tdkr;
488 const struct tty_default_key_xterm *tdkx;
489 const struct tty_default_key_code *tdkc;
490 u_int i, j;
491 const char *s;
492 struct options_entry *o;
493 struct options_array_item *a;
494 union options_value *ov;
495 char copy[16];
496 key_code key;
497
498 if (tty->key_tree != NULL)
499 tty_keys_free(tty);
500 tty->key_tree = NULL;
501
502 for (i = 0; i < nitems(tty_default_xterm_keys); i++) {
503 tdkx = &tty_default_xterm_keys[i];
504 for (j = 2; j < nitems(tty_default_xterm_modifiers); j++) {
505 strlcpy(copy, tdkx->template, sizeof copy);
506 copy[strcspn(copy, "_")] = '0' + j;
507
508 key = tdkx->key|tty_default_xterm_modifiers[j];
509 tty_keys_add(tty, copy, key);
510 }
511 }
512 for (i = 0; i < nitems(tty_default_raw_keys); i++) {
513 tdkr = &tty_default_raw_keys[i];
514
515 s = tdkr->string;
516 if (*s != '\0')
517 tty_keys_add(tty, s, tdkr->key);
518 }
519 for (i = 0; i < nitems(tty_default_code_keys); i++) {
520 tdkc = &tty_default_code_keys[i];
521
522 s = tty_term_string(tty->term, tdkc->code);
523 if (*s != '\0')
524 tty_keys_add(tty, s, tdkc->key);
525
526 }
527
528 o = options_get(global_options, "user-keys");
529 if (o != NULL) {
530 a = options_array_first(o);
531 while (a != NULL) {
532 i = options_array_item_index(a);
533 ov = options_array_item_value(a);
534 tty_keys_add(tty, ov->string, KEYC_USER + i);
535 a = options_array_next(a);
536 }
537 }
538 }
539
540 /* Free the entire key tree. */
541 void
tty_keys_free(struct tty * tty)542 tty_keys_free(struct tty *tty)
543 {
544 tty_keys_free1(tty->key_tree);
545 }
546
547 /* Free a single key. */
548 static void
tty_keys_free1(struct tty_key * tk)549 tty_keys_free1(struct tty_key *tk)
550 {
551 if (tk->next != NULL)
552 tty_keys_free1(tk->next);
553 if (tk->left != NULL)
554 tty_keys_free1(tk->left);
555 if (tk->right != NULL)
556 tty_keys_free1(tk->right);
557 free(tk);
558 }
559
560 /* Lookup a key in the tree. */
561 static struct tty_key *
tty_keys_find(struct tty * tty,const char * buf,size_t len,size_t * size)562 tty_keys_find(struct tty *tty, const char *buf, size_t len, size_t *size)
563 {
564 *size = 0;
565 return (tty_keys_find1(tty->key_tree, buf, len, size));
566 }
567
568 /* Find the next node. */
569 static struct tty_key *
tty_keys_find1(struct tty_key * tk,const char * buf,size_t len,size_t * size)570 tty_keys_find1(struct tty_key *tk, const char *buf, size_t len, size_t *size)
571 {
572 /* If no data, no match. */
573 if (len == 0)
574 return (NULL);
575
576 /* If the node is NULL, this is the end of the tree. No match. */
577 if (tk == NULL)
578 return (NULL);
579
580 /* Pick the next in the sequence. */
581 if (tk->ch == *buf) {
582 /* Move forward in the string. */
583 buf++; len--;
584 (*size)++;
585
586 /* At the end of the string, return the current node. */
587 if (len == 0 || (tk->next == NULL && tk->key != KEYC_UNKNOWN))
588 return (tk);
589
590 /* Move into the next tree for the following character. */
591 tk = tk->next;
592 } else {
593 if (*buf < tk->ch)
594 tk = tk->left;
595 else if (*buf > tk->ch)
596 tk = tk->right;
597 }
598
599 /* Move to the next in the tree. */
600 return (tty_keys_find1(tk, buf, len, size));
601 }
602
603 /* Look up part of the next key. */
604 static int
tty_keys_next1(struct tty * tty,const char * buf,size_t len,key_code * key,size_t * size,int expired)605 tty_keys_next1(struct tty *tty, const char *buf, size_t len, key_code *key,
606 size_t *size, int expired)
607 {
608 struct client *c = tty->client;
609 struct tty_key *tk, *tk1;
610 struct utf8_data ud;
611 enum utf8_state more;
612 utf8_char uc;
613 u_int i;
614
615 log_debug("%s: next key is %zu (%.*s) (expired=%d)", c->name, len,
616 (int)len, buf, expired);
617
618 /* Is this a known key? */
619 tk = tty_keys_find(tty, buf, len, size);
620 if (tk != NULL && tk->key != KEYC_UNKNOWN) {
621 tk1 = tk;
622 do
623 log_debug("%s: keys in list: %#llx", c->name, tk1->key);
624 while ((tk1 = tk1->next) != NULL);
625 if (tk->next != NULL && !expired)
626 return (1);
627 *key = tk->key;
628 return (0);
629 }
630
631 /* Is this valid UTF-8? */
632 more = utf8_open(&ud, (u_char)*buf);
633 if (more == UTF8_MORE) {
634 *size = ud.size;
635 if (len < ud.size) {
636 if (!expired)
637 return (1);
638 return (-1);
639 }
640 for (i = 1; i < ud.size; i++)
641 more = utf8_append(&ud, (u_char)buf[i]);
642 if (more != UTF8_DONE)
643 return (-1);
644
645 if (utf8_from_data(&ud, &uc) != UTF8_DONE)
646 return (-1);
647 *key = uc;
648
649 log_debug("%s: UTF-8 key %.*s %#llx", c->name, (int)ud.size,
650 ud.data, *key);
651 return (0);
652 }
653
654 return (-1);
655 }
656
657 /* Process at least one key in the buffer. Return 0 if no keys present. */
658 int
tty_keys_next(struct tty * tty)659 tty_keys_next(struct tty *tty)
660 {
661 struct client *c = tty->client;
662 struct timeval tv;
663 const char *buf;
664 size_t len, size;
665 cc_t bspace;
666 int delay, expired = 0, n;
667 key_code key, onlykey;
668 struct mouse_event m = { 0 };
669 struct key_event *event;
670
671 /* Get key buffer. */
672 buf = (const char *)EVBUFFER_DATA(tty->in);
673 len = EVBUFFER_LENGTH(tty->in);
674 if (len == 0)
675 return (0);
676 log_debug("%s: keys are %zu (%.*s)", c->name, len, (int)len, buf);
677
678 /* Is this a clipboard response? */
679 switch (tty_keys_clipboard(tty, buf, len, &size)) {
680 case 0: /* yes */
681 key = KEYC_UNKNOWN;
682 goto complete_key;
683 case -1: /* no, or not valid */
684 break;
685 case 1: /* partial */
686 goto partial_key;
687 }
688
689 /* Is this a primary device attributes response? */
690 switch (tty_keys_device_attributes(tty, buf, len, &size)) {
691 case 0: /* yes */
692 key = KEYC_UNKNOWN;
693 goto complete_key;
694 case -1: /* no, or not valid */
695 break;
696 case 1: /* partial */
697 goto partial_key;
698 }
699
700 /* Is this a secondary device attributes response? */
701 switch (tty_keys_device_attributes2(tty, buf, len, &size)) {
702 case 0: /* yes */
703 key = KEYC_UNKNOWN;
704 goto complete_key;
705 case -1: /* no, or not valid */
706 break;
707 case 1: /* partial */
708 goto partial_key;
709 }
710
711 /* Is this an extended device attributes response? */
712 switch (tty_keys_extended_device_attributes(tty, buf, len, &size)) {
713 case 0: /* yes */
714 key = KEYC_UNKNOWN;
715 goto complete_key;
716 case -1: /* no, or not valid */
717 break;
718 case 1: /* partial */
719 goto partial_key;
720 }
721
722 /* Is this a colours response? */
723 switch (tty_keys_colours(tty, buf, len, &size, &tty->fg, &tty->bg)) {
724 case 0: /* yes */
725 key = KEYC_UNKNOWN;
726 goto complete_key;
727 case -1: /* no, or not valid */
728 break;
729 case 1: /* partial */
730 goto partial_key;
731 }
732
733 /* Is this a mouse key press? */
734 switch (tty_keys_mouse(tty, buf, len, &size, &m)) {
735 case 0: /* yes */
736 key = KEYC_MOUSE;
737 goto complete_key;
738 case -1: /* no, or not valid */
739 break;
740 case -2: /* yes, but we don't care. */
741 key = KEYC_MOUSE;
742 goto discard_key;
743 case 1: /* partial */
744 goto partial_key;
745 }
746
747 /* Is this an extended key press? */
748 switch (tty_keys_extended_key(tty, buf, len, &size, &key)) {
749 case 0: /* yes */
750 goto complete_key;
751 case -1: /* no, or not valid */
752 break;
753 case 1: /* partial */
754 goto partial_key;
755 }
756
757 first_key:
758 /* Try to lookup complete key. */
759 n = tty_keys_next1(tty, buf, len, &key, &size, expired);
760 if (n == 0) /* found */
761 goto complete_key;
762 if (n == 1)
763 goto partial_key;
764
765 /*
766 * If not a complete key, look for key with an escape prefix (meta
767 * modifier).
768 */
769 if (*buf == '\033' && len > 1) {
770 /* Look for a key without the escape. */
771 n = tty_keys_next1(tty, buf + 1, len - 1, &key, &size, expired);
772 if (n == 0) { /* found */
773 if (key & KEYC_IMPLIED_META) {
774 /*
775 * We want the escape key as well as the xterm
776 * key, because the xterm sequence implicitly
777 * includes the escape (so if we see
778 * \033\033[1;3D we know it is an Escape
779 * followed by M-Left, not just M-Left).
780 */
781 key = '\033';
782 size = 1;
783 goto complete_key;
784 }
785 key |= KEYC_META;
786 size++;
787 goto complete_key;
788 }
789 if (n == 1) /* partial */
790 goto partial_key;
791 }
792
793 /*
794 * At this point, we know the key is not partial (with or without
795 * escape). So pass it through even if the timer has not expired.
796 */
797 if (*buf == '\033' && len >= 2) {
798 key = (u_char)buf[1] | KEYC_META;
799 size = 2;
800 } else {
801 key = (u_char)buf[0];
802 size = 1;
803 }
804
805 /* C-Space is special. */
806 if ((key & KEYC_MASK_KEY) == C0_NUL)
807 key = ' ' | KEYC_CTRL | (key & KEYC_META);
808
809 /*
810 * Fix up all C0 control codes that don't have a dedicated key into
811 * corresponding Ctrl keys. Convert characters in the A-Z range into
812 * lowercase, so ^A becomes a|CTRL.
813 */
814 onlykey = key & KEYC_MASK_KEY;
815 if (onlykey < 0x20 &&
816 onlykey != C0_HT &&
817 onlykey != C0_CR &&
818 onlykey != C0_ESC) {
819 onlykey |= 0x40;
820 if (onlykey >= 'A' && onlykey <= 'Z')
821 onlykey |= 0x20;
822 key = onlykey | KEYC_CTRL | (key & KEYC_META);
823 }
824
825 goto complete_key;
826
827 partial_key:
828 log_debug("%s: partial key %.*s", c->name, (int)len, buf);
829
830 /* If timer is going, check for expiration. */
831 if (tty->flags & TTY_TIMER) {
832 if (evtimer_initialized(&tty->key_timer) &&
833 !evtimer_pending(&tty->key_timer, NULL)) {
834 expired = 1;
835 goto first_key;
836 }
837 return (0);
838 }
839
840 /* Get the time period. */
841 delay = options_get_number(global_options, "escape-time");
842 if (delay == 0)
843 delay = 1;
844 tv.tv_sec = delay / 1000;
845 tv.tv_usec = (delay % 1000) * 1000L;
846
847 /* Start the timer. */
848 if (event_initialized(&tty->key_timer))
849 evtimer_del(&tty->key_timer);
850 evtimer_set(&tty->key_timer, tty_keys_callback, tty);
851 evtimer_add(&tty->key_timer, &tv);
852
853 tty->flags |= TTY_TIMER;
854 return (0);
855
856 complete_key:
857 log_debug("%s: complete key %.*s %#llx", c->name, (int)size, buf, key);
858
859 /*
860 * Check for backspace key using termios VERASE - the terminfo
861 * kbs entry is extremely unreliable, so cannot be safely
862 * used. termios should have a better idea.
863 */
864 bspace = tty->tio.c_cc[VERASE];
865 if (bspace != _POSIX_VDISABLE && (key & KEYC_MASK_KEY) == bspace)
866 key = (key & KEYC_MASK_MODIFIERS)|KEYC_BSPACE;
867
868 /* Remove data from buffer. */
869 evbuffer_drain(tty->in, size);
870
871 /* Remove key timer. */
872 if (event_initialized(&tty->key_timer))
873 evtimer_del(&tty->key_timer);
874 tty->flags &= ~TTY_TIMER;
875
876 /* Check for focus events. */
877 if (key == KEYC_FOCUS_OUT) {
878 c->flags &= ~CLIENT_FOCUSED;
879 window_update_focus(c->session->curw->window);
880 notify_client("client-focus-out", c);
881 } else if (key == KEYC_FOCUS_IN) {
882 c->flags |= CLIENT_FOCUSED;
883 notify_client("client-focus-in", c);
884 window_update_focus(c->session->curw->window);
885 }
886
887 /* Fire the key. */
888 if (key != KEYC_UNKNOWN) {
889 event = xmalloc(sizeof *event);
890 event->key = key;
891 memcpy(&event->m, &m, sizeof event->m);
892 if (!server_client_handle_key(c, event))
893 free(event);
894 }
895
896 return (1);
897
898 discard_key:
899 log_debug("%s: discard key %.*s %#llx", c->name, (int)size, buf, key);
900
901 /* Remove data from buffer. */
902 evbuffer_drain(tty->in, size);
903
904 return (1);
905 }
906
907 /* Key timer callback. */
908 static void
tty_keys_callback(__unused int fd,__unused short events,void * data)909 tty_keys_callback(__unused int fd, __unused short events, void *data)
910 {
911 struct tty *tty = data;
912
913 if (tty->flags & TTY_TIMER) {
914 while (tty_keys_next(tty))
915 ;
916 }
917 }
918
919 /*
920 * Handle extended key input. This has two forms: \033[27;m;k~ and \033[k;mu,
921 * where k is key as a number and m is a modifier. Returns 0 for success, -1
922 * for failure, 1 for partial;
923 */
924 static int
tty_keys_extended_key(struct tty * tty,const char * buf,size_t len,size_t * size,key_code * key)925 tty_keys_extended_key(struct tty *tty, const char *buf, size_t len,
926 size_t *size, key_code *key)
927 {
928 struct client *c = tty->client;
929 size_t end;
930 u_int number, modifiers;
931 char tmp[64];
932 cc_t bspace;
933 key_code nkey, onlykey;
934 struct utf8_data ud;
935 utf8_char uc;
936
937 *size = 0;
938
939 /* First two bytes are always \033[. */
940 if (buf[0] != '\033')
941 return (-1);
942 if (len == 1)
943 return (1);
944 if (buf[1] != '[')
945 return (-1);
946 if (len == 2)
947 return (1);
948
949 /*
950 * Look for a terminator. Stop at either '~' or anything that isn't a
951 * number or ';'.
952 */
953 for (end = 2; end < len && end != sizeof tmp; end++) {
954 if (buf[end] == '~')
955 break;
956 if (!isdigit((u_char)buf[end]) && buf[end] != ';')
957 break;
958 }
959 if (end == len)
960 return (1);
961 if (end == sizeof tmp || (buf[end] != '~' && buf[end] != 'u'))
962 return (-1);
963
964 /* Copy to the buffer. */
965 memcpy(tmp, buf + 2, end);
966 tmp[end] = '\0';
967
968 /* Try to parse either form of key. */
969 if (buf[end] == '~') {
970 if (sscanf(tmp, "27;%u;%u", &modifiers, &number) != 2)
971 return (-1);
972 } else {
973 if (sscanf(tmp ,"%u;%u", &number, &modifiers) != 2)
974 return (-1);
975 }
976 *size = end + 1;
977
978 /* Store the key. */
979 bspace = tty->tio.c_cc[VERASE];
980 if (bspace != _POSIX_VDISABLE && number == bspace)
981 nkey = KEYC_BSPACE;
982 else
983 nkey = number;
984
985 /* Convert UTF-32 codepoint into internal representation. */
986 if (nkey != KEYC_BSPACE && nkey & ~0x7f) {
987 if (utf8_fromwc(nkey, &ud) == UTF8_DONE &&
988 utf8_from_data(&ud, &uc) == UTF8_DONE)
989 nkey = uc;
990 else
991 return (-1);
992 }
993
994 /* Update the modifiers. */
995 if (modifiers > 0) {
996 modifiers--;
997 if (modifiers & 1)
998 nkey |= KEYC_SHIFT;
999 if (modifiers & 2)
1000 nkey |= (KEYC_META|KEYC_IMPLIED_META); /* Alt */
1001 if (modifiers & 4)
1002 nkey |= KEYC_CTRL;
1003 if (modifiers & 8)
1004 nkey |= (KEYC_META|KEYC_IMPLIED_META); /* Meta */
1005 }
1006
1007 /* Convert S-Tab into Backtab. */
1008 if ((nkey & KEYC_MASK_KEY) == '\011' && (nkey & KEYC_SHIFT))
1009 nkey = KEYC_BTAB | (nkey & ~KEYC_MASK_KEY & ~KEYC_SHIFT);
1010
1011 /*
1012 * Deal with the Shift modifier when present alone. The problem is that
1013 * in mode 2 some terminals would report shifted keys, like S-a, as
1014 * just A, and some as S-A.
1015 *
1016 * Because we need an unambiguous internal representation, and because
1017 * restoring the Shift modifier when it's missing would require knowing
1018 * the keyboard layout, and because S-A would cause a lot of issues
1019 * downstream, we choose to lose the Shift for all printable
1020 * characters.
1021 *
1022 * That still leaves some ambiguity, such as C-S-A vs. C-A, but that's
1023 * OK, and applications can handle that.
1024 */
1025 onlykey = nkey & KEYC_MASK_KEY;
1026 if (((onlykey > 0x20 && onlykey < 0x7f) ||
1027 KEYC_IS_UNICODE(nkey)) &&
1028 (nkey & KEYC_MASK_MODIFIERS) == KEYC_SHIFT)
1029 nkey &= ~KEYC_SHIFT;
1030
1031 if (log_get_level() != 0) {
1032 log_debug("%s: extended key %.*s is %llx (%s)", c->name,
1033 (int)*size, buf, nkey, key_string_lookup_key(nkey, 1));
1034 }
1035
1036 *key = nkey;
1037 return (0);
1038 }
1039
1040 /*
1041 * Handle mouse key input. Returns 0 for success, -1 for failure, 1 for partial
1042 * (probably a mouse sequence but need more data), -2 if an invalid mouse
1043 * sequence.
1044 */
1045 static int
tty_keys_mouse(struct tty * tty,const char * buf,size_t len,size_t * size,struct mouse_event * m)1046 tty_keys_mouse(struct tty *tty, const char *buf, size_t len, size_t *size,
1047 struct mouse_event *m)
1048 {
1049 struct client *c = tty->client;
1050 u_int i, x, y, b, sgr_b;
1051 u_char sgr_type, ch;
1052
1053 /*
1054 * Standard mouse sequences are \033[M followed by three characters
1055 * indicating button, X and Y, all based at 32 with 1,1 top-left.
1056 *
1057 * UTF-8 mouse sequences are similar but the three are expressed as
1058 * UTF-8 characters.
1059 *
1060 * SGR extended mouse sequences are \033[< followed by three numbers in
1061 * decimal and separated by semicolons indicating button, X and Y. A
1062 * trailing 'M' is click or scroll and trailing 'm' release. All are
1063 * based at 0 with 1,1 top-left.
1064 */
1065
1066 *size = 0;
1067 x = y = b = sgr_b = 0;
1068 sgr_type = ' ';
1069
1070 /* First two bytes are always \033[. */
1071 if (buf[0] != '\033')
1072 return (-1);
1073 if (len == 1)
1074 return (1);
1075 if (buf[1] != '[')
1076 return (-1);
1077 if (len == 2)
1078 return (1);
1079
1080 /*
1081 * Third byte is M in old standard (and UTF-8 extension which we do not
1082 * support), < in SGR extension.
1083 */
1084 if (buf[2] == 'M') {
1085 /* Read the three inputs. */
1086 *size = 3;
1087 for (i = 0; i < 3; i++) {
1088 if (len <= *size)
1089 return (1);
1090 ch = (u_char)buf[(*size)++];
1091 if (i == 0)
1092 b = ch;
1093 else if (i == 1)
1094 x = ch;
1095 else
1096 y = ch;
1097 }
1098 log_debug("%s: mouse input: %.*s", c->name, (int)*size, buf);
1099
1100 /* Check and return the mouse input. */
1101 if (b < MOUSE_PARAM_BTN_OFF ||
1102 x < MOUSE_PARAM_POS_OFF ||
1103 y < MOUSE_PARAM_POS_OFF)
1104 return (-2);
1105 b -= MOUSE_PARAM_BTN_OFF;
1106 x -= MOUSE_PARAM_POS_OFF;
1107 y -= MOUSE_PARAM_POS_OFF;
1108 } else if (buf[2] == '<') {
1109 /* Read the three inputs. */
1110 *size = 3;
1111 while (1) {
1112 if (len <= *size)
1113 return (1);
1114 ch = (u_char)buf[(*size)++];
1115 if (ch == ';')
1116 break;
1117 if (ch < '0' || ch > '9')
1118 return (-1);
1119 sgr_b = 10 * sgr_b + (ch - '0');
1120 }
1121 while (1) {
1122 if (len <= *size)
1123 return (1);
1124 ch = (u_char)buf[(*size)++];
1125 if (ch == ';')
1126 break;
1127 if (ch < '0' || ch > '9')
1128 return (-1);
1129 x = 10 * x + (ch - '0');
1130 }
1131 while (1) {
1132 if (len <= *size)
1133 return (1);
1134 ch = (u_char)buf[(*size)++];
1135 if (ch == 'M' || ch == 'm')
1136 break;
1137 if (ch < '0' || ch > '9')
1138 return (-1);
1139 y = 10 * y + (ch - '0');
1140 }
1141 log_debug("%s: mouse input (SGR): %.*s", c->name, (int)*size,
1142 buf);
1143
1144 /* Check and return the mouse input. */
1145 if (x < 1 || y < 1)
1146 return (-2);
1147 x--;
1148 y--;
1149 b = sgr_b;
1150
1151 /* Type is M for press, m for release. */
1152 sgr_type = ch;
1153 if (sgr_type == 'm')
1154 b = 3;
1155
1156 /*
1157 * Some terminals (like PuTTY 0.63) mistakenly send
1158 * button-release events for scroll-wheel button-press event.
1159 * Discard it before it reaches any program running inside
1160 * tmux.
1161 */
1162 if (sgr_type == 'm' && MOUSE_WHEEL(sgr_b))
1163 return (-2);
1164 } else
1165 return (-1);
1166
1167 /* Fill mouse event. */
1168 m->lx = tty->mouse_last_x;
1169 m->x = x;
1170 m->ly = tty->mouse_last_y;
1171 m->y = y;
1172 m->lb = tty->mouse_last_b;
1173 m->b = b;
1174 m->sgr_type = sgr_type;
1175 m->sgr_b = sgr_b;
1176
1177 /* Update last mouse state. */
1178 tty->mouse_last_x = x;
1179 tty->mouse_last_y = y;
1180 tty->mouse_last_b = b;
1181
1182 return (0);
1183 }
1184
1185 /*
1186 * Handle OSC 52 clipboard input. Returns 0 for success, -1 for failure, 1 for
1187 * partial.
1188 */
1189 static int
tty_keys_clipboard(struct tty * tty,const char * buf,size_t len,size_t * size)1190 tty_keys_clipboard(struct tty *tty, const char *buf, size_t len, size_t *size)
1191 {
1192 struct client *c = tty->client;
1193 struct window_pane *wp;
1194 size_t end, terminator = 0, needed;
1195 char *copy, *out;
1196 int outlen;
1197 u_int i;
1198
1199 *size = 0;
1200
1201 /* First five bytes are always \033]52;. */
1202 if (buf[0] != '\033')
1203 return (-1);
1204 if (len == 1)
1205 return (1);
1206 if (buf[1] != ']')
1207 return (-1);
1208 if (len == 2)
1209 return (1);
1210 if (buf[2] != '5')
1211 return (-1);
1212 if (len == 3)
1213 return (1);
1214 if (buf[3] != '2')
1215 return (-1);
1216 if (len == 4)
1217 return (1);
1218 if (buf[4] != ';')
1219 return (-1);
1220 if (len == 5)
1221 return (1);
1222
1223 /* Find the terminator if any. */
1224 terminator = 0; /* XXX: appease gcc (this value is never used) */
1225 for (end = 5; end < len; end++) {
1226 if (buf[end] == '\007') {
1227 terminator = 1;
1228 break;
1229 }
1230 if (end > 5 && buf[end - 1] == '\033' && buf[end] == '\\') {
1231 terminator = 2;
1232 break;
1233 }
1234 }
1235 if (end == len)
1236 return (1);
1237 *size = end + 1;
1238
1239 /* Skip the initial part. */
1240 buf += 5;
1241 end -= 5;
1242
1243 /* Adjust end so that it points to the start of the terminator. */
1244 end -= terminator - 1;
1245
1246 /* Get the second argument. */
1247 while (end != 0 && *buf != ';') {
1248 buf++;
1249 end--;
1250 }
1251 if (end == 0 || end == 1)
1252 return (0);
1253 buf++;
1254 end--;
1255
1256 /* If we did not request this, ignore it. */
1257 if (~tty->flags & TTY_OSC52QUERY)
1258 return (0);
1259 tty->flags &= ~TTY_OSC52QUERY;
1260 evtimer_del(&tty->clipboard_timer);
1261
1262 /* It has to be a string so copy it. */
1263 copy = xmalloc(end + 1);
1264 memcpy(copy, buf, end);
1265 copy[end] = '\0';
1266
1267 /* Convert from base64. */
1268 needed = (end / 4) * 3;
1269 out = xmalloc(needed);
1270 if ((outlen = b64_pton(copy, (u_char *)out, len)) == -1) {
1271 free(out);
1272 free(copy);
1273 return (0);
1274 }
1275 free(copy);
1276
1277 /* Create a new paste buffer and forward to panes. */
1278 log_debug("%s: %.*s", __func__, outlen, out);
1279 if (c->flags & CLIENT_CLIPBOARDBUFFER) {
1280 paste_add(NULL, out, outlen);
1281 c->flags &= ~CLIENT_CLIPBOARDBUFFER;
1282 }
1283 for (i = 0; i < c->clipboard_npanes; i++) {
1284 wp = window_pane_find_by_id(c->clipboard_panes[i]);
1285 if (wp != NULL)
1286 input_reply_clipboard(wp->event, out, outlen, "\033\\");
1287 }
1288 free(c->clipboard_panes);
1289 c->clipboard_panes = NULL;
1290 c->clipboard_npanes = 0;
1291
1292 return (0);
1293 }
1294
1295 /*
1296 * Handle primary device attributes input. Returns 0 for success, -1 for
1297 * failure, 1 for partial.
1298 */
1299 static int
tty_keys_device_attributes(struct tty * tty,const char * buf,size_t len,size_t * size)1300 tty_keys_device_attributes(struct tty *tty, const char *buf, size_t len,
1301 size_t *size)
1302 {
1303 struct client *c = tty->client;
1304 int *features = &c->term_features;
1305 u_int i, n = 0;
1306 char tmp[128], *endptr, p[32] = { 0 }, *cp, *next;
1307
1308 *size = 0;
1309 if (tty->flags & TTY_HAVEDA)
1310 return (-1);
1311
1312 /* First three bytes are always \033[?. */
1313 if (buf[0] != '\033')
1314 return (-1);
1315 if (len == 1)
1316 return (1);
1317 if (buf[1] != '[')
1318 return (-1);
1319 if (len == 2)
1320 return (1);
1321 if (buf[2] != '?')
1322 return (-1);
1323 if (len == 3)
1324 return (1);
1325
1326 /* Copy the rest up to a c. */
1327 for (i = 0; i < (sizeof tmp); i++) {
1328 if (3 + i == len)
1329 return (1);
1330 if (buf[3 + i] == 'c')
1331 break;
1332 tmp[i] = buf[3 + i];
1333 }
1334 if (i == (sizeof tmp))
1335 return (-1);
1336 tmp[i] = '\0';
1337 *size = 4 + i;
1338
1339 /* Convert all arguments to numbers. */
1340 cp = tmp;
1341 while ((next = strsep(&cp, ";")) != NULL) {
1342 p[n] = strtoul(next, &endptr, 10);
1343 if (*endptr != '\0')
1344 p[n] = 0;
1345 if (++n == nitems(p))
1346 break;
1347 }
1348
1349 /* Add terminal features. */
1350 switch (p[0]) {
1351 case 61: /* level 1 */
1352 case 62: /* level 2 */
1353 case 63: /* level 3 */
1354 case 64: /* level 4 */
1355 case 65: /* level 5 */
1356 for (i = 1; i < n; i++) {
1357 log_debug("%s: DA feature: %d", c->name, p[i]);
1358 if (p[i] == 4)
1359 tty_add_features(features, "sixel", ",");
1360 if (p[i] == 21)
1361 tty_add_features(features, "margins", ",");
1362 if (p[i] == 28)
1363 tty_add_features(features, "rectfill", ",");
1364 }
1365 break;
1366 }
1367 log_debug("%s: received primary DA %.*s", c->name, (int)*size, buf);
1368
1369 tty_update_features(tty);
1370 tty->flags |= TTY_HAVEDA;
1371
1372 return (0);
1373 }
1374
1375 /*
1376 * Handle secondary device attributes input. Returns 0 for success, -1 for
1377 * failure, 1 for partial.
1378 */
1379 static int
tty_keys_device_attributes2(struct tty * tty,const char * buf,size_t len,size_t * size)1380 tty_keys_device_attributes2(struct tty *tty, const char *buf, size_t len,
1381 size_t *size)
1382 {
1383 struct client *c = tty->client;
1384 int *features = &c->term_features;
1385 u_int i, n = 0;
1386 char tmp[128], *endptr, p[32] = { 0 }, *cp, *next;
1387
1388 *size = 0;
1389 if (tty->flags & TTY_HAVEDA2)
1390 return (-1);
1391
1392 /* First three bytes are always \033[>. */
1393 if (buf[0] != '\033')
1394 return (-1);
1395 if (len == 1)
1396 return (1);
1397 if (buf[1] != '[')
1398 return (-1);
1399 if (len == 2)
1400 return (1);
1401 if (buf[2] != '>')
1402 return (-1);
1403 if (len == 3)
1404 return (1);
1405
1406 /* Copy the rest up to a c. */
1407 for (i = 0; i < (sizeof tmp); i++) {
1408 if (3 + i == len)
1409 return (1);
1410 if (buf[3 + i] == 'c')
1411 break;
1412 tmp[i] = buf[3 + i];
1413 }
1414 if (i == (sizeof tmp))
1415 return (-1);
1416 tmp[i] = '\0';
1417 *size = 4 + i;
1418
1419 /* Convert all arguments to numbers. */
1420 cp = tmp;
1421 while ((next = strsep(&cp, ";")) != NULL) {
1422 p[n] = strtoul(next, &endptr, 10);
1423 if (*endptr != '\0')
1424 p[n] = 0;
1425 if (++n == nitems(p))
1426 break;
1427 }
1428
1429 /*
1430 * Add terminal features. We add DECSLRM and DECFRA for some
1431 * identification codes here, notably 64 will catch VT520, even though
1432 * we can't use level 5 from DA because of VTE.
1433 */
1434 switch (p[0]) {
1435 case 'M': /* mintty */
1436 tty_default_features(features, "mintty", 0);
1437 break;
1438 case 'T': /* tmux */
1439 tty_default_features(features, "tmux", 0);
1440 break;
1441 case 'U': /* rxvt-unicode */
1442 tty_default_features(features, "rxvt-unicode", 0);
1443 break;
1444 }
1445 log_debug("%s: received secondary DA %.*s", c->name, (int)*size, buf);
1446
1447 tty_update_features(tty);
1448 tty->flags |= TTY_HAVEDA2;
1449
1450 return (0);
1451 }
1452
1453 /*
1454 * Handle extended device attributes input. Returns 0 for success, -1 for
1455 * failure, 1 for partial.
1456 */
1457 static int
tty_keys_extended_device_attributes(struct tty * tty,const char * buf,size_t len,size_t * size)1458 tty_keys_extended_device_attributes(struct tty *tty, const char *buf,
1459 size_t len, size_t *size)
1460 {
1461 struct client *c = tty->client;
1462 int *features = &c->term_features;
1463 u_int i;
1464 char tmp[128];
1465
1466 *size = 0;
1467 if (tty->flags & TTY_HAVEXDA)
1468 return (-1);
1469
1470 /* First four bytes are always \033P>|. */
1471 if (buf[0] != '\033')
1472 return (-1);
1473 if (len == 1)
1474 return (1);
1475 if (buf[1] != 'P')
1476 return (-1);
1477 if (len == 2)
1478 return (1);
1479 if (buf[2] != '>')
1480 return (-1);
1481 if (len == 3)
1482 return (1);
1483 if (buf[3] != '|')
1484 return (-1);
1485 if (len == 4)
1486 return (1);
1487
1488 /* Copy the rest up to \033\. */
1489 for (i = 0; i < (sizeof tmp) - 1; i++) {
1490 if (4 + i == len)
1491 return (1);
1492 if (buf[4 + i - 1] == '\033' && buf[4 + i] == '\\')
1493 break;
1494 tmp[i] = buf[4 + i];
1495 }
1496 if (i == (sizeof tmp) - 1)
1497 return (-1);
1498 tmp[i - 1] = '\0';
1499 *size = 5 + i;
1500
1501 /* Add terminal features. */
1502 if (strncmp(tmp, "iTerm2 ", 7) == 0)
1503 tty_default_features(features, "iTerm2", 0);
1504 else if (strncmp(tmp, "tmux ", 5) == 0)
1505 tty_default_features(features, "tmux", 0);
1506 else if (strncmp(tmp, "XTerm(", 6) == 0)
1507 tty_default_features(features, "XTerm", 0);
1508 else if (strncmp(tmp, "mintty ", 7) == 0)
1509 tty_default_features(features, "mintty", 0);
1510 log_debug("%s: received extended DA %.*s", c->name, (int)*size, buf);
1511
1512 free(c->term_type);
1513 c->term_type = xstrdup(tmp);
1514
1515 tty_update_features(tty);
1516 tty->flags |= TTY_HAVEXDA;
1517
1518 return (0);
1519 }
1520
1521 /*
1522 * Handle foreground or background input. Returns 0 for success, -1 for
1523 * failure, 1 for partial.
1524 */
1525 int
tty_keys_colours(struct tty * tty,const char * buf,size_t len,size_t * size,int * fg,int * bg)1526 tty_keys_colours(struct tty *tty, const char *buf, size_t len, size_t *size,
1527 int *fg, int *bg)
1528 {
1529 struct client *c = tty->client;
1530 u_int i;
1531 char tmp[128];
1532 int n;
1533
1534 *size = 0;
1535
1536 /* First four bytes are always \033]1 and 0 or 1 and ;. */
1537 if (buf[0] != '\033')
1538 return (-1);
1539 if (len == 1)
1540 return (1);
1541 if (buf[1] != ']')
1542 return (-1);
1543 if (len == 2)
1544 return (1);
1545 if (buf[2] != '1')
1546 return (-1);
1547 if (len == 3)
1548 return (1);
1549 if (buf[3] != '0' && buf[3] != '1')
1550 return (-1);
1551 if (len == 4)
1552 return (1);
1553 if (buf[4] != ';')
1554 return (-1);
1555 if (len == 5)
1556 return (1);
1557
1558 /* Copy the rest up to \033\ or \007. */
1559 for (i = 0; i < (sizeof tmp) - 1; i++) {
1560 if (5 + i == len)
1561 return (1);
1562 if (buf[5 + i - 1] == '\033' && buf[5 + i] == '\\')
1563 break;
1564 if (buf[5 + i] == '\007')
1565 break;
1566 tmp[i] = buf[5 + i];
1567 }
1568 if (i == (sizeof tmp) - 1)
1569 return (-1);
1570 if (tmp[i - 1] == '\033')
1571 tmp[i - 1] = '\0';
1572 else
1573 tmp[i] = '\0';
1574 *size = 6 + i;
1575
1576 n = colour_parseX11(tmp);
1577 if (n != -1 && buf[3] == '0') {
1578 if (c != NULL)
1579 log_debug("%s fg is %s", c->name, colour_tostring(n));
1580 else
1581 log_debug("fg is %s", colour_tostring(n));
1582 *fg = n;
1583 } else if (n != -1) {
1584 if (c != NULL)
1585 log_debug("%s bg is %s", c->name, colour_tostring(n));
1586 else
1587 log_debug("bg is %s", colour_tostring(n));
1588 *bg = n;
1589 }
1590
1591 return (0);
1592 }
1593