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