Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 | 2 | /* |
1da177e4 LT |
3 | * This module exports the functions: |
4 | * | |
496124e5 OK |
5 | * 'int set_selection_user(struct tiocl_selection __user *, |
6 | * struct tty_struct *)' | |
7 | * 'int set_selection_kernel(struct tiocl_selection *, struct tty_struct *)' | |
1da177e4 LT |
8 | * 'void clear_selection(void)' |
9 | * 'int paste_selection(struct tty_struct *)' | |
10 | * 'int sel_loadlut(char __user *)' | |
11 | * | |
12 | * Now that /dev/vcs exists, most of this can disappear again. | |
13 | */ | |
14 | ||
15 | #include <linux/module.h> | |
16 | #include <linux/tty.h> | |
17 | #include <linux/sched.h> | |
18 | #include <linux/mm.h> | |
19 | #include <linux/slab.h> | |
20 | #include <linux/types.h> | |
21 | ||
7c0f6ba6 | 22 | #include <linux/uaccess.h> |
1da177e4 | 23 | |
759448f4 | 24 | #include <linux/kbd_kern.h> |
1da177e4 LT |
25 | #include <linux/vt_kern.h> |
26 | #include <linux/consolemap.h> | |
27 | #include <linux/selection.h> | |
28 | #include <linux/tiocl.h> | |
29 | #include <linux/console.h> | |
a7c8d58c | 30 | #include <linux/tty_flip.h> |
1da177e4 LT |
31 | |
32 | /* Don't take this from <ctype.h>: 011-015 on the screen aren't spaces */ | |
33 | #define isspace(c) ((c) == ' ') | |
34 | ||
35 | extern void poke_blanked_console(void); | |
36 | ||
079c9534 | 37 | /* FIXME: all this needs locking */ |
1da177e4 LT |
38 | /* Variables for selection control. */ |
39 | /* Use a dynamic buffer, instead of static (Dec 1994) */ | |
ca9bda00 | 40 | struct vc_data *sel_cons; /* must not be deallocated */ |
759448f4 | 41 | static int use_unicode; |
1da177e4 LT |
42 | static volatile int sel_start = -1; /* cleared by clear_selection */ |
43 | static int sel_end; | |
44 | static int sel_buffer_lth; | |
45 | static char *sel_buffer; | |
46 | ||
47 | /* clear_selection, highlight and highlight_pointer can be called | |
48 | from interrupt (via scrollback/front) */ | |
49 | ||
50 | /* set reverse video on characters s-e of console with selection. */ | |
51 | static inline void highlight(const int s, const int e) | |
52 | { | |
53 | invert_screen(sel_cons, s, e-s+2, 1); | |
54 | } | |
55 | ||
56 | /* use complementary color to show the pointer */ | |
57 | static inline void highlight_pointer(const int where) | |
58 | { | |
59 | complement_pos(sel_cons, where); | |
60 | } | |
61 | ||
9bfdc261 | 62 | static u32 |
1da177e4 LT |
63 | sel_pos(int n) |
64 | { | |
9bfdc261 AB |
65 | if (use_unicode) |
66 | return screen_glyph_unicode(sel_cons, n / 2); | |
759448f4 | 67 | return inverse_translate(sel_cons, screen_glyph(sel_cons, n), |
9bfdc261 | 68 | 0); |
1da177e4 LT |
69 | } |
70 | ||
5289475d AC |
71 | /** |
72 | * clear_selection - remove current selection | |
73 | * | |
74 | * Remove the current selection highlight, if any from the console | |
75 | * holding the selection. The caller must hold the console lock. | |
76 | */ | |
77 | void clear_selection(void) | |
78 | { | |
1da177e4 LT |
79 | highlight_pointer(-1); /* hide the pointer */ |
80 | if (sel_start != -1) { | |
81 | highlight(sel_start, sel_end); | |
82 | sel_start = -1; | |
83 | } | |
84 | } | |
496124e5 | 85 | EXPORT_SYMBOL_GPL(clear_selection); |
1da177e4 LT |
86 | |
87 | /* | |
88 | * User settable table: what characters are to be considered alphabetic? | |
7f1534e1 | 89 | * 128 bits. Locked by the console lock. |
1da177e4 | 90 | */ |
7f1534e1 | 91 | static u32 inwordLut[]={ |
1da177e4 | 92 | 0x00000000, /* control chars */ |
7d6d44ae | 93 | 0x03FFE000, /* digits and "-./" */ |
1da177e4 LT |
94 | 0x87FFFFFE, /* uppercase and '_' */ |
95 | 0x07FFFFFE, /* lowercase */ | |
1da177e4 LT |
96 | }; |
97 | ||
9bfdc261 AB |
98 | static inline int inword(const u32 c) |
99 | { | |
7f1534e1 | 100 | return c > 0x7f || (( inwordLut[c>>5] >> (c & 0x1F) ) & 1); |
1da177e4 LT |
101 | } |
102 | ||
5289475d AC |
103 | /** |
104 | * set loadlut - load the LUT table | |
105 | * @p: user table | |
106 | * | |
107 | * Load the LUT table from user space. The caller must hold the console | |
108 | * lock. Make a temporary copy so a partial update doesn't make a mess. | |
109 | */ | |
1da177e4 LT |
110 | int sel_loadlut(char __user *p) |
111 | { | |
7f1534e1 AB |
112 | u32 tmplut[ARRAY_SIZE(inwordLut)]; |
113 | if (copy_from_user(tmplut, (u32 __user *)(p+4), sizeof(inwordLut))) | |
5289475d | 114 | return -EFAULT; |
7f1534e1 | 115 | memcpy(inwordLut, tmplut, sizeof(inwordLut)); |
5289475d | 116 | return 0; |
1da177e4 LT |
117 | } |
118 | ||
119 | /* does screen address p correspond to character at LH/RH edge of screen? */ | |
120 | static inline int atedge(const int p, int size_row) | |
121 | { | |
122 | return (!(p % size_row) || !((p + 2) % size_row)); | |
123 | } | |
124 | ||
df155d2d AB |
125 | /* stores the char in UTF8 and returns the number of bytes used (1-4) */ |
126 | static int store_utf8(u32 c, char *p) | |
759448f4 JE |
127 | { |
128 | if (c < 0x80) { | |
129 | /* 0******* */ | |
130 | p[0] = c; | |
131 | return 1; | |
132 | } else if (c < 0x800) { | |
133 | /* 110***** 10****** */ | |
134 | p[0] = 0xc0 | (c >> 6); | |
135 | p[1] = 0x80 | (c & 0x3f); | |
136 | return 2; | |
df155d2d | 137 | } else if (c < 0x10000) { |
759448f4 JE |
138 | /* 1110**** 10****** 10****** */ |
139 | p[0] = 0xe0 | (c >> 12); | |
140 | p[1] = 0x80 | ((c >> 6) & 0x3f); | |
141 | p[2] = 0x80 | (c & 0x3f); | |
142 | return 3; | |
df155d2d AB |
143 | } else if (c < 0x110000) { |
144 | /* 11110*** 10****** 10****** 10****** */ | |
145 | p[0] = 0xf0 | (c >> 18); | |
146 | p[1] = 0x80 | ((c >> 12) & 0x3f); | |
147 | p[2] = 0x80 | ((c >> 6) & 0x3f); | |
148 | p[3] = 0x80 | (c & 0x3f); | |
149 | return 4; | |
150 | } else { | |
151 | /* outside Unicode, replace with U+FFFD */ | |
152 | p[0] = 0xef; | |
153 | p[1] = 0xbf; | |
154 | p[2] = 0xbd; | |
155 | return 3; | |
156 | } | |
759448f4 JE |
157 | } |
158 | ||
5289475d | 159 | /** |
496124e5 | 160 | * set_selection_user - set the current selection. |
5289475d AC |
161 | * @sel: user selection info |
162 | * @tty: the console tty | |
163 | * | |
164 | * Invoked by the ioctl handle for the vt layer. | |
165 | * | |
166 | * The entire selection process is managed under the console_lock. It's | |
167 | * a lot under the lock but its hardly a performance path | |
168 | */ | |
496124e5 OK |
169 | int set_selection_user(const struct tiocl_selection __user *sel, |
170 | struct tty_struct *tty) | |
171 | { | |
172 | struct tiocl_selection v; | |
173 | ||
174 | if (copy_from_user(&v, sel, sizeof(*sel))) | |
175 | return -EFAULT; | |
176 | ||
177 | return set_selection_kernel(&v, tty); | |
178 | } | |
179 | ||
180 | int set_selection_kernel(struct tiocl_selection *v, struct tty_struct *tty) | |
1da177e4 LT |
181 | { |
182 | struct vc_data *vc = vc_cons[fg_console].d; | |
2a479aa8 | 183 | int new_sel_start, new_sel_end, spc; |
1da177e4 | 184 | char *bp, *obp; |
759448f4 | 185 | int i, ps, pe, multiplier; |
9bfdc261 | 186 | u32 c; |
079c9534 | 187 | int mode; |
1da177e4 LT |
188 | |
189 | poke_blanked_console(); | |
190 | ||
496124e5 OK |
191 | v->xs = min_t(u16, v->xs - 1, vc->vc_cols - 1); |
192 | v->ys = min_t(u16, v->ys - 1, vc->vc_rows - 1); | |
193 | v->xe = min_t(u16, v->xe - 1, vc->vc_cols - 1); | |
194 | v->ye = min_t(u16, v->ye - 1, vc->vc_rows - 1); | |
195 | ps = v->ys * vc->vc_size_row + (v->xs << 1); | |
196 | pe = v->ye * vc->vc_size_row + (v->xe << 1); | |
1da177e4 | 197 | |
496124e5 | 198 | if (v->sel_mode == TIOCL_SELCLEAR) { |
2a479aa8 AV |
199 | /* useful for screendump without selection highlights */ |
200 | clear_selection(); | |
201 | return 0; | |
202 | } | |
203 | ||
496124e5 OK |
204 | if (mouse_reporting() && (v->sel_mode & TIOCL_SELMOUSEREPORT)) { |
205 | mouse_report(tty, v->sel_mode & TIOCL_SELBUTTONMASK, v->xs, | |
206 | v->ys); | |
2a479aa8 AV |
207 | return 0; |
208 | } | |
1da177e4 LT |
209 | |
210 | if (ps > pe) /* make sel_start <= sel_end */ | |
df3d9a5b | 211 | swap(ps, pe); |
1da177e4 LT |
212 | |
213 | if (sel_cons != vc_cons[fg_console].d) { | |
214 | clear_selection(); | |
215 | sel_cons = vc_cons[fg_console].d; | |
216 | } | |
079c9534 AC |
217 | mode = vt_do_kdgkbmode(fg_console); |
218 | if (mode == K_UNICODE) | |
219 | use_unicode = 1; | |
220 | else | |
221 | use_unicode = 0; | |
1da177e4 | 222 | |
496124e5 | 223 | switch (v->sel_mode) |
1da177e4 LT |
224 | { |
225 | case TIOCL_SELCHAR: /* character-by-character selection */ | |
226 | new_sel_start = ps; | |
227 | new_sel_end = pe; | |
228 | break; | |
229 | case TIOCL_SELWORD: /* word-by-word selection */ | |
230 | spc = isspace(sel_pos(ps)); | |
231 | for (new_sel_start = ps; ; ps -= 2) | |
232 | { | |
233 | if ((spc && !isspace(sel_pos(ps))) || | |
234 | (!spc && !inword(sel_pos(ps)))) | |
235 | break; | |
236 | new_sel_start = ps; | |
237 | if (!(ps % vc->vc_size_row)) | |
238 | break; | |
239 | } | |
240 | spc = isspace(sel_pos(pe)); | |
241 | for (new_sel_end = pe; ; pe += 2) | |
242 | { | |
243 | if ((spc && !isspace(sel_pos(pe))) || | |
244 | (!spc && !inword(sel_pos(pe)))) | |
245 | break; | |
246 | new_sel_end = pe; | |
247 | if (!((pe + 2) % vc->vc_size_row)) | |
248 | break; | |
249 | } | |
250 | break; | |
251 | case TIOCL_SELLINE: /* line-by-line selection */ | |
252 | new_sel_start = ps - ps % vc->vc_size_row; | |
253 | new_sel_end = pe + vc->vc_size_row | |
254 | - pe % vc->vc_size_row - 2; | |
255 | break; | |
256 | case TIOCL_SELPOINTER: | |
257 | highlight_pointer(pe); | |
258 | return 0; | |
259 | default: | |
260 | return -EINVAL; | |
261 | } | |
262 | ||
263 | /* remove the pointer */ | |
264 | highlight_pointer(-1); | |
265 | ||
266 | /* select to end of line if on trailing space */ | |
267 | if (new_sel_end > new_sel_start && | |
268 | !atedge(new_sel_end, vc->vc_size_row) && | |
269 | isspace(sel_pos(new_sel_end))) { | |
270 | for (pe = new_sel_end + 2; ; pe += 2) | |
271 | if (!isspace(sel_pos(pe)) || | |
272 | atedge(pe, vc->vc_size_row)) | |
273 | break; | |
274 | if (isspace(sel_pos(pe))) | |
275 | new_sel_end = pe; | |
276 | } | |
277 | if (sel_start == -1) /* no current selection */ | |
278 | highlight(new_sel_start, new_sel_end); | |
279 | else if (new_sel_start == sel_start) | |
280 | { | |
281 | if (new_sel_end == sel_end) /* no action required */ | |
282 | return 0; | |
283 | else if (new_sel_end > sel_end) /* extend to right */ | |
284 | highlight(sel_end + 2, new_sel_end); | |
285 | else /* contract from right */ | |
286 | highlight(new_sel_end + 2, sel_end); | |
287 | } | |
288 | else if (new_sel_end == sel_end) | |
289 | { | |
290 | if (new_sel_start < sel_start) /* extend to left */ | |
291 | highlight(new_sel_start, sel_start - 2); | |
292 | else /* contract from left */ | |
293 | highlight(sel_start, new_sel_start - 2); | |
294 | } | |
295 | else /* some other case; start selection from scratch */ | |
296 | { | |
297 | clear_selection(); | |
298 | highlight(new_sel_start, new_sel_end); | |
299 | } | |
300 | sel_start = new_sel_start; | |
301 | sel_end = new_sel_end; | |
302 | ||
303 | /* Allocate a new buffer before freeing the old one ... */ | |
df155d2d | 304 | multiplier = use_unicode ? 4 : 1; /* chars can take up to 4 bytes */ |
6da2ec56 KC |
305 | bp = kmalloc_array((sel_end - sel_start) / 2 + 1, multiplier, |
306 | GFP_KERNEL); | |
1da177e4 LT |
307 | if (!bp) { |
308 | printk(KERN_WARNING "selection: kmalloc() failed\n"); | |
309 | clear_selection(); | |
310 | return -ENOMEM; | |
311 | } | |
735d5661 | 312 | kfree(sel_buffer); |
1da177e4 LT |
313 | sel_buffer = bp; |
314 | ||
315 | obp = bp; | |
316 | for (i = sel_start; i <= sel_end; i += 2) { | |
759448f4 JE |
317 | c = sel_pos(i); |
318 | if (use_unicode) | |
319 | bp += store_utf8(c, bp); | |
320 | else | |
321 | *bp++ = c; | |
322 | if (!isspace(c)) | |
1da177e4 LT |
323 | obp = bp; |
324 | if (! ((i + 2) % vc->vc_size_row)) { | |
325 | /* strip trailing blanks from line and add newline, | |
326 | unless non-space at end of line. */ | |
327 | if (obp != bp) { | |
328 | bp = obp; | |
329 | *bp++ = '\r'; | |
330 | } | |
331 | obp = bp; | |
332 | } | |
333 | } | |
334 | sel_buffer_lth = bp - sel_buffer; | |
335 | return 0; | |
336 | } | |
496124e5 | 337 | EXPORT_SYMBOL_GPL(set_selection_kernel); |
1da177e4 LT |
338 | |
339 | /* Insert the contents of the selection buffer into the | |
340 | * queue of the tty associated with the current console. | |
341 | * Invoked by ioctl(). | |
906cbe13 | 342 | * |
20f62579 AC |
343 | * Locking: called without locks. Calls the ldisc wrongly with |
344 | * unsafe methods, | |
1da177e4 LT |
345 | */ |
346 | int paste_selection(struct tty_struct *tty) | |
347 | { | |
c9f19e96 | 348 | struct vc_data *vc = tty->driver_data; |
33f0f88f AC |
349 | int pasted = 0; |
350 | unsigned int count; | |
1da177e4 LT |
351 | struct tty_ldisc *ld; |
352 | DECLARE_WAITQUEUE(wait, current); | |
353 | ||
ac751efa | 354 | console_lock(); |
1da177e4 | 355 | poke_blanked_console(); |
ac751efa | 356 | console_unlock(); |
1da177e4 | 357 | |
7ee00fdb | 358 | ld = tty_ldisc_ref_wait(tty); |
e55afd11 PH |
359 | if (!ld) |
360 | return -EIO; /* ldisc was hung up */ | |
a7c8d58c | 361 | tty_buffer_lock_exclusive(&vc->port); |
60af22d2 | 362 | |
1da177e4 LT |
363 | add_wait_queue(&vc->paste_wait, &wait); |
364 | while (sel_buffer && sel_buffer_lth > pasted) { | |
365 | set_current_state(TASK_INTERRUPTIBLE); | |
97ef38b8 | 366 | if (tty_throttled(tty)) { |
1da177e4 LT |
367 | schedule(); |
368 | continue; | |
369 | } | |
61e86cc9 | 370 | __set_current_state(TASK_RUNNING); |
1da177e4 | 371 | count = sel_buffer_lth - pasted; |
24a89d1c PH |
372 | count = tty_ldisc_receive_buf(ld, sel_buffer + pasted, NULL, |
373 | count); | |
1da177e4 LT |
374 | pasted += count; |
375 | } | |
376 | remove_wait_queue(&vc->paste_wait, &wait); | |
cc0a8fbb | 377 | __set_current_state(TASK_RUNNING); |
1da177e4 | 378 | |
a7c8d58c | 379 | tty_buffer_unlock_exclusive(&vc->port); |
1da177e4 LT |
380 | tty_ldisc_deref(ld); |
381 | return 0; | |
382 | } | |
496124e5 | 383 | EXPORT_SYMBOL_GPL(paste_selection); |