1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/tty.h>
15#include <linux/sched.h>
16#include <linux/mm.h>
17#include <linux/slab.h>
18#include <linux/types.h>
19
20#include <linux/uaccess.h>
21
22#include <linux/kbd_kern.h>
23#include <linux/vt_kern.h>
24#include <linux/consolemap.h>
25#include <linux/selection.h>
26#include <linux/tiocl.h>
27#include <linux/console.h>
28#include <linux/tty_flip.h>
29
30
31#define isspace(c) ((c) == ' ')
32
33extern void poke_blanked_console(void);
34
35
36
37
38struct vc_data *sel_cons;
39static int use_unicode;
40static volatile int sel_start = -1;
41static int sel_end;
42static int sel_buffer_lth;
43static char *sel_buffer;
44
45
46
47
48
49static inline void highlight(const int s, const int e)
50{
51 invert_screen(sel_cons, s, e-s+2, 1);
52}
53
54
55static inline void highlight_pointer(const int where)
56{
57 complement_pos(sel_cons, where);
58}
59
60static u16
61sel_pos(int n)
62{
63 return inverse_translate(sel_cons, screen_glyph(sel_cons, n),
64 use_unicode);
65}
66
67
68
69
70
71
72
73void clear_selection(void)
74{
75 highlight_pointer(-1);
76 if (sel_start != -1) {
77 highlight(sel_start, sel_end);
78 sel_start = -1;
79 }
80}
81
82
83
84
85
86static u32 inwordLut[]={
87 0x00000000,
88 0x03FFE000,
89 0x87FFFFFE,
90 0x07FFFFFE,
91};
92
93static inline int inword(const u16 c) {
94 return c > 0x7f || (( inwordLut[c>>5] >> (c & 0x1F) ) & 1);
95}
96
97
98
99
100
101
102
103
104int sel_loadlut(char __user *p)
105{
106 u32 tmplut[ARRAY_SIZE(inwordLut)];
107 if (copy_from_user(tmplut, (u32 __user *)(p+4), sizeof(inwordLut)))
108 return -EFAULT;
109 memcpy(inwordLut, tmplut, sizeof(inwordLut));
110 return 0;
111}
112
113
114static inline int atedge(const int p, int size_row)
115{
116 return (!(p % size_row) || !((p + 2) % size_row));
117}
118
119
120static inline unsigned short limit(const unsigned short v, const unsigned short u)
121{
122 return (v > u) ? u : v;
123}
124
125
126static int store_utf8(u16 c, char *p)
127{
128 if (c < 0x80) {
129
130 p[0] = c;
131 return 1;
132 } else if (c < 0x800) {
133
134 p[0] = 0xc0 | (c >> 6);
135 p[1] = 0x80 | (c & 0x3f);
136 return 2;
137 } else {
138
139 p[0] = 0xe0 | (c >> 12);
140 p[1] = 0x80 | ((c >> 6) & 0x3f);
141 p[2] = 0x80 | (c & 0x3f);
142 return 3;
143 }
144}
145
146
147
148
149
150
151
152
153
154
155
156int set_selection(const struct tiocl_selection __user *sel, struct tty_struct *tty)
157{
158 struct vc_data *vc = vc_cons[fg_console].d;
159 int new_sel_start, new_sel_end, spc;
160 struct tiocl_selection v;
161 char *bp, *obp;
162 int i, ps, pe, multiplier;
163 u16 c;
164 int mode;
165
166 poke_blanked_console();
167 if (copy_from_user(&v, sel, sizeof(*sel)))
168 return -EFAULT;
169
170 v.xs = limit(v.xs - 1, vc->vc_cols - 1);
171 v.ys = limit(v.ys - 1, vc->vc_rows - 1);
172 v.xe = limit(v.xe - 1, vc->vc_cols - 1);
173 v.ye = limit(v.ye - 1, vc->vc_rows - 1);
174 ps = v.ys * vc->vc_size_row + (v.xs << 1);
175 pe = v.ye * vc->vc_size_row + (v.xe << 1);
176
177 if (v.sel_mode == TIOCL_SELCLEAR) {
178
179 clear_selection();
180 return 0;
181 }
182
183 if (mouse_reporting() && (v.sel_mode & TIOCL_SELMOUSEREPORT)) {
184 mouse_report(tty, v.sel_mode & TIOCL_SELBUTTONMASK, v.xs, v.ys);
185 return 0;
186 }
187
188 if (ps > pe)
189 {
190 int tmp = ps;
191 ps = pe;
192 pe = tmp;
193 }
194
195 if (sel_cons != vc_cons[fg_console].d) {
196 clear_selection();
197 sel_cons = vc_cons[fg_console].d;
198 }
199 mode = vt_do_kdgkbmode(fg_console);
200 if (mode == K_UNICODE)
201 use_unicode = 1;
202 else
203 use_unicode = 0;
204
205 switch (v.sel_mode)
206 {
207 case TIOCL_SELCHAR:
208 new_sel_start = ps;
209 new_sel_end = pe;
210 break;
211 case TIOCL_SELWORD:
212 spc = isspace(sel_pos(ps));
213 for (new_sel_start = ps; ; ps -= 2)
214 {
215 if ((spc && !isspace(sel_pos(ps))) ||
216 (!spc && !inword(sel_pos(ps))))
217 break;
218 new_sel_start = ps;
219 if (!(ps % vc->vc_size_row))
220 break;
221 }
222 spc = isspace(sel_pos(pe));
223 for (new_sel_end = pe; ; pe += 2)
224 {
225 if ((spc && !isspace(sel_pos(pe))) ||
226 (!spc && !inword(sel_pos(pe))))
227 break;
228 new_sel_end = pe;
229 if (!((pe + 2) % vc->vc_size_row))
230 break;
231 }
232 break;
233 case TIOCL_SELLINE:
234 new_sel_start = ps - ps % vc->vc_size_row;
235 new_sel_end = pe + vc->vc_size_row
236 - pe % vc->vc_size_row - 2;
237 break;
238 case TIOCL_SELPOINTER:
239 highlight_pointer(pe);
240 return 0;
241 default:
242 return -EINVAL;
243 }
244
245
246 highlight_pointer(-1);
247
248
249 if (new_sel_end > new_sel_start &&
250 !atedge(new_sel_end, vc->vc_size_row) &&
251 isspace(sel_pos(new_sel_end))) {
252 for (pe = new_sel_end + 2; ; pe += 2)
253 if (!isspace(sel_pos(pe)) ||
254 atedge(pe, vc->vc_size_row))
255 break;
256 if (isspace(sel_pos(pe)))
257 new_sel_end = pe;
258 }
259 if (sel_start == -1)
260 highlight(new_sel_start, new_sel_end);
261 else if (new_sel_start == sel_start)
262 {
263 if (new_sel_end == sel_end)
264 return 0;
265 else if (new_sel_end > sel_end)
266 highlight(sel_end + 2, new_sel_end);
267 else
268 highlight(new_sel_end + 2, sel_end);
269 }
270 else if (new_sel_end == sel_end)
271 {
272 if (new_sel_start < sel_start)
273 highlight(new_sel_start, sel_start - 2);
274 else
275 highlight(sel_start, new_sel_start - 2);
276 }
277 else
278 {
279 clear_selection();
280 highlight(new_sel_start, new_sel_end);
281 }
282 sel_start = new_sel_start;
283 sel_end = new_sel_end;
284
285
286 multiplier = use_unicode ? 3 : 1;
287 bp = kmalloc(((sel_end-sel_start)/2+1)*multiplier, GFP_KERNEL);
288 if (!bp) {
289 printk(KERN_WARNING "selection: kmalloc() failed\n");
290 clear_selection();
291 return -ENOMEM;
292 }
293 kfree(sel_buffer);
294 sel_buffer = bp;
295
296 obp = bp;
297 for (i = sel_start; i <= sel_end; i += 2) {
298 c = sel_pos(i);
299 if (use_unicode)
300 bp += store_utf8(c, bp);
301 else
302 *bp++ = c;
303 if (!isspace(c))
304 obp = bp;
305 if (! ((i + 2) % vc->vc_size_row)) {
306
307
308 if (obp != bp) {
309 bp = obp;
310 *bp++ = '\r';
311 }
312 obp = bp;
313 }
314 }
315 sel_buffer_lth = bp - sel_buffer;
316 return 0;
317}
318
319
320
321
322
323
324
325
326int paste_selection(struct tty_struct *tty)
327{
328 struct vc_data *vc = tty->driver_data;
329 int pasted = 0;
330 unsigned int count;
331 struct tty_ldisc *ld;
332 DECLARE_WAITQUEUE(wait, current);
333
334 console_lock();
335 poke_blanked_console();
336 console_unlock();
337
338 ld = tty_ldisc_ref_wait(tty);
339 if (!ld)
340 return -EIO;
341 tty_buffer_lock_exclusive(&vc->port);
342
343 add_wait_queue(&vc->paste_wait, &wait);
344 while (sel_buffer && sel_buffer_lth > pasted) {
345 set_current_state(TASK_INTERRUPTIBLE);
346 if (tty_throttled(tty)) {
347 schedule();
348 continue;
349 }
350 __set_current_state(TASK_RUNNING);
351 count = sel_buffer_lth - pasted;
352 count = tty_ldisc_receive_buf(ld, sel_buffer + pasted, NULL,
353 count);
354 pasted += count;
355 }
356 remove_wait_queue(&vc->paste_wait, &wait);
357 __set_current_state(TASK_RUNNING);
358
359 tty_buffer_unlock_exclusive(&vc->port);
360 tty_ldisc_deref(ld);
361 return 0;
362}
363