1 /*
2 Copyright (C) 2002-2010 Karl J. Runge <runge@karlrunge.com>
3 All rights reserved.
4
5 This file is part of x11vnc.
6
7 x11vnc is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or (at
10 your option) any later version.
11
12 x11vnc is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with x11vnc; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA
20 or see <http://www.gnu.org/licenses/>.
21
22 In addition, as a special exception, Karl J. Runge
23 gives permission to link the code of its release of x11vnc with the
24 OpenSSL project's "OpenSSL" library (or with modified versions of it
25 that use the same license as the "OpenSSL" library), and distribute
26 the linked executables. You must obey the GNU General Public License
27 in all respects for all of the code used other than "OpenSSL". If you
28 modify this file, you may extend this exception to your version of the
29 file, but you are not obligated to do so. If you do not wish to do
30 so, delete this exception statement from your version.
31 */
32
33 /* -- pointer.c -- */
34
35 #include "x11vnc.h"
36 #include "xwrappers.h"
37 #include "keyboard.h"
38 #include "xinerama.h"
39 #include "xrecord.h"
40 #include "win_utils.h"
41 #include "cursor.h"
42 #include "userinput.h"
43 #include "connections.h"
44 #include "cleanup.h"
45 #include "unixpw.h"
46 #include "v4l.h"
47 #include "linuxfb.h"
48 #include "uinput.h"
49 #include "scan.h"
50 #include "macosx.h"
51 #include "screen.h"
52
53 int pointer_queued_sent = 0;
54
55 void initialize_pointer_map(char *pointer_remap);
56 void do_button_mask_change(int mask, int button);
57 void pointer_event(int mask, int x, int y, rfbClientPtr client);
58 void initialize_pipeinput(void);
59 int check_pipeinput(void);
60 void update_x11_pointer_position(int x, int y);
61
62
63 static void buttonparse(int from, char **s);
64 static void update_x11_pointer_mask(int mask);
65 static void pipe_pointer(int mask, int x, int y, rfbClientPtr client);
66
67 /*
68 * pointer event (motion and button click) handling routines.
69 */
70 typedef struct ptrremap {
71 KeySym keysym;
72 KeyCode keycode;
73 int end;
74 int button;
75 int down;
76 int up;
77 } prtremap_t;
78
79 #define MAX_BUTTON_EVENTS 50
80 static prtremap_t pointer_map[MAX_BUTTONS+1][MAX_BUTTON_EVENTS];
81
82 /*
83 * For parsing the -buttonmap sections, e.g. "4" or ":Up+Up+Up:"
84 */
buttonparse(int from,char ** s)85 static void buttonparse(int from, char **s) {
86 #if (0 && NO_X11)
87 if (!from || !s) {}
88 return;
89 #else
90 char *q;
91 int to, i;
92 int modisdown[256];
93
94 q = *s;
95
96 for (i=0; i<256; i++) {
97 modisdown[i] = 0;
98 }
99
100 if (*q == ':') {
101 /* :sym1+sym2+...+symN: format */
102 int l = 0, n = 0;
103 char list[1000];
104 char *t, *kp = q + 1;
105 KeyCode kcode;
106
107 while (*(kp+l) != ':' && *(kp+l) != '\0') {
108 /* loop to the matching ':' */
109 l++;
110 if (l >= 1000) {
111 rfbLog("buttonparse: keysym list too long: "
112 "%s\n", q);
113 break;
114 }
115 }
116 *(kp+l) = '\0';
117 strncpy(list, kp, l);
118 list[l] = '\0';
119 rfbLog("remap button %d using \"%s\"\n", from, list);
120
121 /* loop over tokens separated by '+' */
122 t = strtok(list, "+");
123 while (t) {
124 KeySym ksym;
125 unsigned int ui;
126 int i;
127 if (n >= MAX_BUTTON_EVENTS - 20) {
128 rfbLog("buttonparse: too many button map "
129 "events: %s\n", list);
130 break;
131 }
132 if (sscanf(t, "0x%x", &ui) == 1) {
133 ksym = (KeySym) ui; /* hex value */
134 } else {
135 X_LOCK;
136 ksym = XStringToKeysym(t); /* string value */
137 X_UNLOCK;
138 }
139 if (ksym == NoSymbol) {
140 /* see if Button<N> "keysym" was used: */
141 if (sscanf(t, "Button%d", &i) == 1) {
142 rfbLog(" event %d: button %d\n",
143 from, n+1, i);
144 if (i == 0) i = -1; /* bah */
145 pointer_map[from][n].keysym = NoSymbol;
146 pointer_map[from][n].keycode = NoSymbol;
147 pointer_map[from][n].button = i;
148 pointer_map[from][n].end = 0;
149 pointer_map[from][n].down = 0;
150 pointer_map[from][n].up = 0;
151 } else {
152 rfbLog("buttonparse: ignoring unknown "
153 "keysym: %s\n", t);
154 n--;
155 }
156 } else if (dpy) {
157 /*
158 * XXX may not work with -modtweak or -xkb
159 */
160 char *str;
161 X_LOCK;
162 #if NO_X11
163 kcode = NoSymbol;
164 #else
165 kcode = XKeysymToKeycode(dpy, ksym);
166 #endif
167
168 pointer_map[from][n].keysym = ksym;
169 pointer_map[from][n].keycode = kcode;
170 pointer_map[from][n].button = 0;
171 pointer_map[from][n].end = 0;
172 if (! ismodkey(ksym) ) {
173 /* do both down then up */
174 pointer_map[from][n].down = 1;
175 pointer_map[from][n].up = 1;
176 } else {
177 if (modisdown[kcode]) {
178 pointer_map[from][n].down = 0;
179 pointer_map[from][n].up = 1;
180 modisdown[kcode] = 0;
181 } else {
182 pointer_map[from][n].down = 1;
183 pointer_map[from][n].up = 0;
184 modisdown[kcode] = 1;
185 }
186 }
187 str = XKeysymToString(ksym);
188 rfbLog(" event %d: keysym %s (0x%x) -> "
189 "keycode 0x%x down=%d up=%d\n", n+1,
190 str ? str : "null", ksym, kcode,
191 pointer_map[from][n].down,
192 pointer_map[from][n].up);
193 X_UNLOCK;
194 }
195 t = strtok(NULL, "+");
196 n++;
197 }
198
199 /* we must release any modifiers that are still down: */
200 for (i=0; i<256; i++) {
201 kcode = (KeyCode) i;
202 if (n >= MAX_BUTTON_EVENTS) {
203 rfbLog("buttonparse: too many button map "
204 "events: %s\n", list);
205 break;
206 }
207 if (modisdown[kcode]) {
208 pointer_map[from][n].keysym = NoSymbol;
209 pointer_map[from][n].keycode = kcode;
210 pointer_map[from][n].button = 0;
211 pointer_map[from][n].end = 0;
212 pointer_map[from][n].down = 0;
213 pointer_map[from][n].up = 1;
214 modisdown[kcode] = 0;
215 n++;
216 }
217 }
218
219 /* advance the source pointer position */
220 (*s) += l+2;
221 } else {
222 /* single digit format */
223 char str[2];
224 str[0] = *q;
225 str[1] = '\0';
226
227 to = atoi(str);
228 if (to < 1) {
229 rfbLog("skipping invalid remap button \"%d\" for button"
230 " %d from string \"%s\"\n",
231 to, from, str);
232 } else {
233 rfbLog("remap button %d using \"%s\"\n", from, str);
234 rfbLog(" button: %d -> %d\n", from, to);
235 pointer_map[from][0].keysym = NoSymbol;
236 pointer_map[from][0].keycode = NoSymbol;
237 pointer_map[from][0].button = to;
238 pointer_map[from][0].end = 0;
239 pointer_map[from][0].down = 0;
240 pointer_map[from][0].up = 0;
241 }
242 /* advance the source pointer position */
243 (*s)++;
244 }
245 #endif /* NO_X11 */
246 }
247
248 /*
249 * process the -buttonmap string
250 */
initialize_pointer_map(char * pointer_remap)251 void initialize_pointer_map(char *pointer_remap) {
252 unsigned char map[MAX_BUTTONS];
253 int i, k;
254 /*
255 * This routine counts the number of pointer buttons on the X
256 * server (to avoid problems, even crashes, if a client has more
257 * buttons). And also initializes any pointer button remapping
258 * from -buttonmap option.
259 */
260
261 if (!raw_fb_str) {
262 #if NO_X11
263 num_buttons = 5;
264 #else
265 X_LOCK;
266 num_buttons = XGetPointerMapping(dpy, map, MAX_BUTTONS);
267 X_UNLOCK;
268 rfbLog("The X server says there are %d mouse buttons.\n", num_buttons);
269 #endif
270 } else {
271 num_buttons = 5;
272 rfbLog("Manually set num_buttons to: %d\n", num_buttons);
273 }
274
275 if (num_buttons < 0) {
276 num_buttons = 0;
277 }
278
279 /* FIXME: should use info in map[] */
280 for (i=1; i<= MAX_BUTTONS; i++) {
281 for (k=0; k < MAX_BUTTON_EVENTS; k++) {
282 pointer_map[i][k].end = 1;
283 }
284 pointer_map[i][0].keysym = NoSymbol;
285 pointer_map[i][0].keycode = NoSymbol;
286 pointer_map[i][0].button = i;
287 pointer_map[i][0].end = 0;
288 pointer_map[i][0].down = 0;
289 pointer_map[i][0].up = 0;
290 }
291
292 if (pointer_remap && *pointer_remap != '\0') {
293 /* -buttonmap, format is like: 12-21=2 */
294 char *p, *q, *remap = strdup(pointer_remap);
295 int n;
296
297 if ((p = strchr(remap, '=')) != NULL) {
298 /* undocumented max button number */
299 n = atoi(p+1);
300 *p = '\0';
301 if (n < num_buttons || num_buttons == 0) {
302 num_buttons = n;
303 } else {
304 rfbLog("warning: increasing number of mouse "
305 "buttons from %d to %d\n", num_buttons, n);
306 num_buttons = n;
307 }
308 }
309 if ((q = strchr(remap, '-')) != NULL) {
310 /*
311 * The '-' separates the 'from' and 'to' lists,
312 * then it is kind of like tr(1).
313 */
314 char str[2];
315 int from;
316
317 rfbLog("remapping pointer buttons using string:\n");
318 rfbLog(" \"%s\"\n", remap);
319
320 p = remap;
321 q++;
322 i = 0;
323 str[1] = '\0';
324 while (*p != '-') {
325 str[0] = *p;
326 from = atoi(str);
327 buttonparse(from, &q);
328 p++;
329 }
330 }
331 free(remap);
332 }
333 }
334
335 /*
336 * Send a pointer position event to the X server.
337 */
update_x11_pointer_position(int x,int y)338 void update_x11_pointer_position(int x, int y) {
339 #if NO_X11
340 RAWFB_RET_VOID
341 if (!x || !y) {}
342 return;
343 #else
344 int rc;
345
346 RAWFB_RET_VOID
347
348 X_LOCK;
349 if (!always_inject && cursor_x == x && cursor_y == y) {
350 ;
351 } else if (use_xwarppointer) {
352 /*
353 * off_x and off_y not needed with XWarpPointer since
354 * window is used:
355 */
356 XWarpPointer(dpy, None, window, 0, 0, 0, 0, x + coff_x,
357 y + coff_y);
358 } else {
359 XTestFakeMotionEvent_wr(dpy, scr, x + off_x + coff_x,
360 y + off_y + coff_y, CurrentTime);
361 }
362 X_UNLOCK;
363
364 if (cursor_x != x || cursor_y != y) {
365 last_pointer_motion_time = dnow();
366 }
367
368 cursor_x = x;
369 cursor_y = y;
370
371 /* record the x, y position for the rfb screen as well. */
372 cursor_position(x, y);
373
374 /* change the cursor shape if necessary */
375 rc = set_cursor(x, y, get_which_cursor());
376 cursor_changes += rc;
377
378 last_event = last_input = last_pointer_input = time(NULL);
379 #endif /* NO_X11 */
380 }
381
do_button_mask_change(int mask,int button)382 void do_button_mask_change(int mask, int button) {
383 #if NO_X11
384 if (!mask || !button) {}
385 return;
386 #else
387 int mb, k, i = button-1;
388
389 /*
390 * this expands to any pointer_map button -> keystrokes
391 * remappings. Usually just k=0 and we send one button event.
392 */
393 for (k=0; k < MAX_BUTTON_EVENTS; k++) {
394 int bmask = (mask & (1<<i));
395
396 if (pointer_map[i+1][k].end) {
397 break;
398 }
399
400 if (pointer_map[i+1][k].button) {
401 /* send button up or down */
402
403 mb = pointer_map[i+1][k].button;
404 if ((num_buttons && mb > num_buttons) || mb < 1) {
405 rfbLog("ignoring mouse button out of "
406 "bounds: %d>%d mask: 0x%x -> 0x%x\n",
407 mb, num_buttons, button_mask, mask);
408 continue;
409 }
410 if (debug_pointer) {
411 rfbLog("pointer(): sending button %d"
412 " %s (event %d)\n", mb, bmask
413 ? "down" : "up", k+1);
414 }
415 XTestFakeButtonEvent_wr(dpy, mb, (mask & (1<<i))
416 ? True : False, CurrentTime);
417 } else {
418 /* send keysym up or down */
419 KeyCode key = pointer_map[i+1][k].keycode;
420 int up = pointer_map[i+1][k].up;
421 int down = pointer_map[i+1][k].down;
422
423 if (! bmask) {
424 /* do not send keysym on button up */
425 continue;
426 }
427 if (debug_pointer && dpy) {
428 char *str = XKeysymToString(XKeycodeToKeysym(
429 dpy, key, 0));
430 rfbLog("pointer(): sending button %d "
431 "down as keycode 0x%x (event %d)\n",
432 i+1, key, k+1);
433 rfbLog(" down=%d up=%d keysym: "
434 "%s\n", down, up, str ? str : "null");
435 }
436 if (down) {
437 XTestFakeKeyEvent_wr(dpy, key, True,
438 CurrentTime);
439 }
440 if (up) {
441 XTestFakeKeyEvent_wr(dpy, key, False,
442 CurrentTime);
443 }
444 }
445 }
446 #endif /* NO_X11 */
447 }
448
449 /*
450 * Send a pointer button event to the X server.
451 */
update_x11_pointer_mask(int mask)452 static void update_x11_pointer_mask(int mask) {
453 #if NO_X11
454 last_event = last_input = last_pointer_input = time(NULL);
455
456 RAWFB_RET_VOID
457 if (!mask) {}
458 return;
459 #else
460 int snapped = 0, xr_mouse = 1, i;
461 last_event = last_input = last_pointer_input = time(NULL);
462
463 RAWFB_RET_VOID
464
465 if (mask != button_mask) {
466 last_pointer_click_time = dnow();
467 }
468
469 if (nofb) {
470 xr_mouse = 0;
471 } else if (!strcmp(scroll_copyrect, "never")) {
472 xr_mouse = 0;
473 } else if (!strcmp(scroll_copyrect, "keys")) {
474 xr_mouse = 0;
475 } else if (skip_cr_when_scaling("scroll")) {
476 xr_mouse = 0;
477 } else if (xrecord_skip_button(mask, button_mask)) {
478 xr_mouse = 0;
479 }
480
481 if (mask && use_xrecord && ! xrecording && xr_mouse) {
482 static int px, py, x, y, w, h, got_wm_frame;
483 static XWindowAttributes attr;
484 Window frame = None, mwin = None;
485 int skip = 0;
486
487 if (!button_mask) {
488 X_LOCK;
489 if (get_wm_frame_pos(&px, &py, &x, &y, &w, &h,
490 &frame, &mwin)) {
491 got_wm_frame = 1;
492 if (debug_scroll > 1) fprintf(stderr, "wm_win: 0x%lx\n", mwin);
493 if (mwin != None) {
494 if (!valid_window(mwin, &attr, 1)) {
495 mwin = None;
496 }
497 }
498 } else {
499 got_wm_frame = 0;
500 }
501 X_UNLOCK;
502 }
503 if (got_wm_frame) {
504 if (wireframe && near_wm_edge(x, y, w, h, px, py)) {
505 /* step out of wireframe's way */
506 skip = 1;
507 } else {
508 int ok = 0;
509 int btn4 = (1<<3);
510 int btn5 = (1<<4);
511
512 if (near_scrollbar_edge(x, y, w, h, px, py)) {
513 ok = 1;
514 }
515 if (mask & (btn4|btn5)) {
516 /* scroll wheel mouse */
517 ok = 1;
518 }
519 if (mwin != None) {
520 /* skinny internal window */
521 int w = attr.width;
522 int h = attr.height;
523 if (h > 10 * w || w > 10 * h) {
524 if (debug_scroll > 1) fprintf(stderr, "internal scrollbar: %dx%d\n", w, h);
525 ok = 1;
526 }
527 }
528 if (! ok) {
529 skip = 1;
530 }
531 }
532 }
533
534 if (! skip) {
535 xrecord_watch(1, SCR_MOUSE);
536 snapshot_stack_list(0, 0.50);
537 snapped = 1;
538 if (button_mask) {
539 xrecord_set_by_mouse = 1;
540 } else {
541 update_stack_list();
542 xrecord_set_by_mouse = 2;
543 }
544 }
545 }
546
547 if (mask && !button_mask) {
548 /* button down, snapshot the stacking list before flushing */
549 if (wireframe && !wireframe_in_progress &&
550 strcmp(wireframe_copyrect, "never")) {
551 if (! snapped) {
552 snapshot_stack_list(0, 0.0);
553 }
554 }
555 }
556
557 X_LOCK;
558
559 /* look for buttons that have be clicked or released: */
560 for (i=0; i < MAX_BUTTONS; i++) {
561 if ( (button_mask & (1<<i)) != (mask & (1<<i)) ) {
562 if (debug_pointer) {
563 rfbLog("pointer(): mask change: mask: 0x%x -> "
564 "0x%x button: %d\n", button_mask, mask,i+1);
565 }
566 do_button_mask_change(mask, i+1); /* button # is i+1 */
567 }
568 }
569
570 X_UNLOCK;
571
572 /*
573 * Remember the button state for next time and also for the
574 * -nodragging case:
575 */
576 button_mask_prev = button_mask;
577 button_mask = mask;
578 #endif /* NO_X11 */
579 }
580
581 /* for -pipeinput */
582
583
pipe_pointer(int mask,int x,int y,rfbClientPtr client)584 static void pipe_pointer(int mask, int x, int y, rfbClientPtr client) {
585 int can_input = 0, uid = 0;
586 allowed_input_t input;
587 ClientData *cd = (ClientData *) client->clientData;
588 char hint[MAX_BUTTONS * 20];
589
590 if (pipeinput_int == PIPEINPUT_VID) {
591 v4l_pointer_command(mask, x, y, client);
592 } else if (pipeinput_int == PIPEINPUT_CONSOLE) {
593 console_pointer_command(mask, x, y, client);
594 } else if (pipeinput_int == PIPEINPUT_UINPUT) {
595 uinput_pointer_command(mask, x, y, client);
596 } else if (pipeinput_int == PIPEINPUT_MACOSX) {
597 macosx_pointer_command(mask, x, y, client);
598 } else if (pipeinput_int == PIPEINPUT_VNC) {
599 vnc_reflect_send_pointer(x, y, mask);
600 }
601 if (pipeinput_fh == NULL) {
602 return;
603 }
604
605 if (! view_only) {
606 get_allowed_input(client, &input);
607 if (input.motion || input.button) {
608 can_input = 1; /* XXX distinguish later */
609 }
610 }
611
612 if (cd) {
613 uid = cd->uid;
614 }
615 if (! can_input) {
616 uid = -uid;
617 }
618
619 hint[0] = '\0';
620 if (mask == button_mask) {
621 strcat(hint, "None");
622 } else {
623 int i, old, newb, m = 1, cnt = 0;
624 for (i=0; i<MAX_BUTTONS; i++) {
625 char s[20];
626
627 old = button_mask & m;
628 newb = mask & m;
629 m = m << 1;
630
631 if (old == newb) {
632 continue;
633 }
634 if (hint[0] != '\0') {
635 strcat(hint, ",");
636 }
637 if (newb && ! old) {
638 sprintf(s, "ButtonPress-%d", i+1);
639 cnt++;
640 } else if (! newb && old) {
641 sprintf(s, "ButtonRelease-%d", i+1);
642 cnt++;
643 }
644 strcat(hint, s);
645 }
646 if (! cnt) {
647 strcpy(hint, "None");
648 }
649 }
650
651 fprintf(pipeinput_fh, "Pointer %d %d %d %d %s\n", uid, x, y,
652 mask, hint);
653 fflush(pipeinput_fh);
654 check_pipeinput();
655 }
656
657 /*
658 * Actual callback from libvncserver when it gets a pointer event.
659 * This may queue pointer events rather than sending them immediately
660 * to the X server. (see update_x11_pointer*())
661 */
pointer_event(int mask,int x,int y,rfbClientPtr client)662 void pointer_event(int mask, int x, int y, rfbClientPtr client) {
663 allowed_input_t input;
664 int sent = 0, buffer_it = 0;
665 double now;
666
667 if (threads_drop_input) {
668 return;
669 }
670
671 if (mask >= 0) {
672 got_pointer_calls++;
673 }
674
675 if (debug_pointer && mask >= 0) {
676 static int show_motion = -1;
677 static double last_pointer = 0.0;
678 double tnow, dt;
679 static int last_x, last_y;
680 if (show_motion == -1) {
681 if (getenv("X11VNC_DB_NOMOTION")) {
682 show_motion = 0;
683 } else {
684 show_motion = 1;
685 }
686 }
687 dtime0(&tnow);
688 tnow -= x11vnc_start;
689 dt = tnow - last_pointer;
690 last_pointer = tnow;
691 if (show_motion) {
692 rfbLog("# pointer(mask: 0x%x, x:%4d, y:%4d) "
693 "dx: %3d dy: %3d dt: %.4f t: %.4f\n", mask, x, y,
694 x - last_x, y - last_y, dt, tnow);
695 }
696 last_x = x;
697 last_y = y;
698 }
699
700 if (unixpw_in_progress) {
701 return;
702 }
703
704 get_allowed_input(client, &input);
705
706 if (rotating) {
707 rotate_coords_inverse(x, y, &x, &y, -1, -1);
708 }
709
710 if (scaling) {
711 /* map from rfb size to X11 size: */
712 x = ((double) x / scaled_x) * dpy_x;
713 x = nfix(x, dpy_x);
714 y = ((double) y / scaled_y) * dpy_y;
715 y = nfix(y, dpy_y);
716 }
717
718 INPUT_LOCK;
719
720 if ((pipeinput_fh != NULL || pipeinput_int) && mask >= 0) {
721 pipe_pointer(mask, x, y, client); /* MACOSX here. */
722 if (! pipeinput_tee) {
723 if (! view_only || raw_fb) { /* raw_fb hack */
724 got_user_input++;
725 got_pointer_input++;
726 last_pointer_client = client;
727 last_pointer_time = dnow();
728 last_event = last_input = last_pointer_input = time(NULL);
729 }
730 if (input.motion) {
731 /* raw_fb hack track button state */
732 button_mask_prev = button_mask;
733 button_mask = mask;
734 }
735 if (!view_only && (input.motion || input.button)) {
736 last_rfb_ptr_injected = dnow();
737 }
738 INPUT_UNLOCK;
739 return;
740 }
741 }
742
743 if (view_only) {
744 INPUT_UNLOCK;
745 return;
746 }
747
748 now = dnow();
749
750 if (mask >= 0) {
751 /*
752 * mask = -1 is a special case call from scan_for_updates()
753 * to flush the event queue; there is no real pointer event.
754 */
755 if (! input.motion && ! input.button) {
756 INPUT_UNLOCK;
757 return;
758 }
759
760 got_user_input++;
761 got_pointer_input++;
762 last_pointer_client = client;
763
764 last_pointer_time = now;
765 last_rfb_ptr_injected = dnow();
766
767 if (blackout_ptr && blackouts) {
768 int b, ok = 1;
769 /* see if it goes into the blacked out region */
770 for (b=0; b < blackouts; b++) {
771 if (x < blackr[b].x1 || x > blackr[b].x2) {
772 continue;
773 }
774 if (y < blackr[b].y1 || y > blackr[b].y2) {
775 continue;
776 }
777 /* x1 <= x <= x2 and y1 <= y <= y2 */
778 ok = 0;
779 break;
780 }
781 if (! ok) {
782 if (debug_pointer) {
783 rfbLog("pointer(): blackout_ptr skipping "
784 "x=%d y=%d in rectangle %d,%d %d,%d\n", x, y,
785 blackr[b].x1, blackr[b].y1,
786 blackr[b].x2, blackr[b].y2);
787 }
788 INPUT_UNLOCK;
789 return;
790 }
791 }
792 }
793
794 /*
795 * The following is hopefully an improvement wrt response during
796 * pointer user input (window drags) for the threaded case.
797 * See check_user_input() for the more complicated things we do
798 * in the non-threaded case.
799 */
800 if ((use_threads && pointer_mode != 1) || pointer_flush_delay > 0.0) {
801 # define NEV 32
802 /* storage for the event queue */
803 static int nevents = 0;
804 static int ev[NEV][3];
805 int i;
806 /* timer things */
807 static double dt = 0.0, tmr = 0.0, maxwait = 0.4;
808
809 if (pointer_flush_delay > 0.0) {
810 maxwait = pointer_flush_delay;
811 }
812 if (mask >= 0) {
813 if (fb_copy_in_progress || pointer_flush_delay > 0.0) {
814 buffer_it = 1;
815 }
816 }
817
818 POINTER_LOCK;
819
820 /*
821 * If the framebuffer is being copied in another thread
822 * (scan_for_updates()), we will queue up to 32 pointer
823 * events for later. The idea is by delaying these input
824 * events, the screen is less likely to change during the
825 * copying period, and so will give rise to less window
826 * "tearing".
827 *
828 * Tearing is not completely eliminated because we do
829 * not suspend work in the other libvncserver threads.
830 * Maybe that is a possibility with a mutex...
831 */
832 if (buffer_it) {
833 /*
834 * mask = -1 is an all-clear signal from
835 * scan_for_updates().
836 *
837 * dt is a timer in seconds; we only queue for so long.
838 */
839 dt += dtime(&tmr);
840
841 if (nevents < NEV && dt < maxwait) {
842 i = nevents++;
843 ev[i][0] = mask;
844 ev[i][1] = x;
845 ev[i][2] = y;
846 if (! input.button) {
847 ev[i][0] = -1;
848 }
849 if (! input.motion) {
850 ev[i][1] = -1;
851 ev[i][2] = -1;
852 }
853 if (debug_pointer) {
854 rfbLog("pointer(): deferring event %d"
855 " %.4f\n", i, tmr - x11vnc_start);
856 }
857 POINTER_UNLOCK;
858 INPUT_UNLOCK;
859 return;
860 }
861 }
862
863 /* time to send the queue */
864 for (i=0; i<nevents; i++) {
865 int sent = 0;
866 if (mask < 0 && client != NULL) {
867 /* hack to only push the latest event */
868 if (i < nevents - 1) {
869 if (debug_pointer) {
870 rfbLog("- skip deferred event:"
871 " %d\n", i);
872 }
873 continue;
874 }
875 }
876 if (debug_pointer) {
877 rfbLog("pointer(): sending event %d %.4f\n",
878 i+1, dnowx());
879 }
880 if (ev[i][1] >= 0) {
881 update_x11_pointer_position(ev[i][1], ev[i][2]);
882 sent = 1;
883 }
884 if (ev[i][0] >= 0) {
885 update_x11_pointer_mask(ev[i][0]);
886 sent = 1;
887 }
888
889 if (sent) {
890 pointer_queued_sent++;
891 }
892 }
893 if (nevents && dt > maxwait) {
894 if (dpy) { /* raw_fb hack */
895 if (mask < 0) {
896 if (debug_pointer) {
897 rfbLog("pointer(): calling XFlush "
898 "%.4f\n", dnowx());
899 }
900 X_LOCK;
901 XFlush_wr(dpy);
902 X_UNLOCK;
903 }
904 }
905 }
906 nevents = 0; /* reset everything */
907 dt = 0.0;
908 dtime0(&tmr);
909
910 POINTER_UNLOCK;
911 }
912 if (mask < 0) { /* -1 just means flush the event queue */
913 if (debug_pointer) {
914 rfbLog("pointer(): flush only. %.4f\n",
915 dnowx());
916 }
917 INPUT_UNLOCK;
918 return;
919 }
920
921 /* update the X display with the event: */
922 if (input.motion) {
923 update_x11_pointer_position(x, y);
924 sent = 1;
925 }
926 if (input.button) {
927 if (mask != button_mask) {
928 button_change_x = cursor_x;
929 button_change_y = cursor_y;
930 }
931 update_x11_pointer_mask(mask);
932 sent = 1;
933 }
934
935 if (! dpy) {
936 ;
937 } else if (nofb && sent) {
938 /*
939 * nofb is for, e.g. Win2VNC, where fastest pointer
940 * updates are desired.
941 */
942 X_LOCK;
943 XFlush_wr(dpy);
944 X_UNLOCK;
945 } else if (buffer_it) {
946 if (debug_pointer) {
947 rfbLog("pointer(): calling XFlush+"
948 "%.4f\n", dnowx());
949 }
950 X_LOCK;
951 XFlush_wr(dpy);
952 X_UNLOCK;
953 }
954 INPUT_UNLOCK;
955 }
956
initialize_pipeinput(void)957 void initialize_pipeinput(void) {
958 char *p = NULL;
959
960 if (pipeinput_fh != NULL) {
961 rfbLog("closing pipeinput stream: %p\n", pipeinput_fh);
962 pclose(pipeinput_fh);
963 pipeinput_fh = NULL;
964 }
965
966 pipeinput_tee = 0;
967 if (pipeinput_opts) {
968 free(pipeinput_opts);
969 pipeinput_opts = NULL;
970 }
971
972 if (! pipeinput_str) {
973 return;
974 }
975
976 /* look for options: tee, reopen, ... */
977 if (strstr(pipeinput_str, "UINPUT") == pipeinput_str) {
978 ;
979 } else {
980 p = strchr(pipeinput_str, ':');
981 }
982 if (p != NULL) {
983 char *str, *opt, *q;
984 int got = 0;
985 *p = '\0';
986 str = strdup(pipeinput_str);
987 opt = strdup(pipeinput_str);
988 *p = ':';
989 q = strtok(str, ",");
990 while (q) {
991 if (!strcmp(q, "key") || !strcmp(q, "keycodes")) {
992 got = 1;
993 }
994 if (!strcmp(q, "reopen")) {
995 got = 1;
996 }
997 if (!strcmp(q, "tee")) {
998 pipeinput_tee = 1;
999 got = 1;
1000 }
1001 q = strtok(NULL, ",");
1002 }
1003 if (got) {
1004 pipeinput_opts = opt;
1005 } else {
1006 free(opt);
1007 }
1008 free(str);
1009 p++;
1010 } else {
1011 p = pipeinput_str;
1012 }
1013 if (0) fprintf(stderr, "initialize_pipeinput: %s -- %s\n", pipeinput_str, p);
1014
1015 if (!strcmp(p, "VID")) {
1016 pipeinput_int = PIPEINPUT_VID;
1017 return;
1018 } else if (strstr(p, "CONSOLE") == p) {
1019 int tty = 0, n;
1020 char dev[32];
1021 if (sscanf(p, "CONSOLE%d", &n) == 1) {
1022 tty = n;
1023 }
1024 sprintf(dev, "/dev/tty%d", tty);
1025 pipeinput_cons_fd = open(dev, O_WRONLY);
1026 if (pipeinput_cons_fd >= 0) {
1027 rfbLog("pipeinput: using linux console: %s\n", dev);
1028 if (pipeinput_cons_dev) {
1029 free(pipeinput_cons_dev);
1030 }
1031 pipeinput_cons_dev = strdup(dev);
1032 pipeinput_int = PIPEINPUT_CONSOLE;
1033 } else {
1034 rfbLog("pipeinput: could not open: %s\n", dev);
1035 rfbLogPerror("open");
1036 rfbLog("You may need to be root to open %s.\n", dev);
1037 rfbLog("\n");
1038 }
1039 return;
1040 } else if (strstr(p, "UINPUT") == p) {
1041 char *q = strchr(p, ':');
1042 if (q) {
1043 parse_uinput_str(q+1);
1044 }
1045 pipeinput_int = PIPEINPUT_UINPUT;
1046 initialize_uinput();
1047 return;
1048 } else if (strstr(p, "MACOSX") == p) {
1049 pipeinput_int = PIPEINPUT_MACOSX;
1050 return;
1051 } else if (strstr(p, "VNC") == p) {
1052 pipeinput_int = PIPEINPUT_VNC;
1053 return;
1054 }
1055
1056 set_child_info();
1057 /* pipeinput */
1058 if (no_external_cmds || !cmd_ok("pipeinput")) {
1059 rfbLogEnable(1);
1060 rfbLog("cannot run external commands in -nocmds mode:\n");
1061 rfbLog(" \"%s\"\n", p);
1062 rfbLog(" exiting.\n");
1063 clean_up_exit(1);
1064 }
1065 rfbLog("pipeinput: starting: \"%s\"...\n", p);
1066 close_exec_fds();
1067 pipeinput_fh = popen(p, "w");
1068
1069 if (! pipeinput_fh) {
1070 rfbLog("popen(\"%s\", \"w\") failed.\n", p);
1071 rfbLogPerror("popen");
1072 rfbLog("Disabling -pipeinput mode.\n");
1073 return;
1074 }
1075
1076 fprintf(pipeinput_fh, "%s",
1077 "# \n"
1078 "# Format of the -pipeinput stream:\n"
1079 "# --------------------------------\n"
1080 "#\n"
1081 "# Lines like these beginning with '#' are to be ignored.\n"
1082 "#\n"
1083 "# Pointer events (mouse motion and button clicks) come in the form:\n"
1084 "#\n"
1085 "#\n"
1086 "# Pointer <client#> <x> <y> <mask> <hint>\n"
1087 "#\n"
1088 "#\n"
1089 "# The <client#> is a decimal integer uniquely identifying the client\n"
1090 "# that generated the event. If it is negative that means this event\n"
1091 "# would have been discarded since the client was viewonly.\n"
1092 "#\n"
1093 "# <x> and <y> are decimal integers reflecting the position on the screen\n"
1094 "# the event took place at.\n"
1095 "#\n"
1096 "# <mask> is the button mask indicating the button press state, as normal\n"
1097 "# 0 means no buttons pressed, 1 means button 1 is down 3 (11) means buttons\n"
1098 "# 1 and 2 are down, etc.\n"
1099 "#\n"
1100 "# <hint> is a string containing no spaces and may be ignored.\n"
1101 "# It contains some interpretation about what has happened.\n"
1102 "# It can be:\n"
1103 "#\n"
1104 "# None (nothing to report)\n"
1105 "# ButtonPress-N (this event will cause button-N to be pressed) \n"
1106 "# ButtonRelease-N (this event will cause button-N to be released) \n"
1107 "#\n"
1108 "# if two more more buttons change state in one event they are listed\n"
1109 "# separated by commas.\n"
1110 "#\n"
1111 "# One might parse a Pointer line with:\n"
1112 "#\n"
1113 "# int client, x, y, mask; char hint[100];\n"
1114 "# sscanf(line, \"Pointer %d %d %d %d %s\", &client, &x, &y, &mask, hint);\n"
1115 "#\n"
1116 "#\n"
1117 "# Keysym events (keyboard presses and releases) come in the form:\n"
1118 "#\n"
1119 "#\n"
1120 "# Keysym <client#> <down> <keysym#> <keysym-name> <hint>\n"
1121 "#\n"
1122 "#\n"
1123 "# The <client#> is as with Pointer.\n"
1124 "#\n"
1125 "# <down> is a decimal either 1 or 0 indicating KeyPress or KeyRelease,\n"
1126 "# respectively.\n"
1127 "#\n"
1128 "# <keysym#> is a decimal integer incidating the Keysym of the event.\n"
1129 "#\n"
1130 "# <keysym-name> is the corresponding Keysym name.\n"
1131 "#\n"
1132 "# See the file /usr/include/X11/keysymdef.h for the mappings.\n"
1133 "# You basically remove the leading 'XK_' prefix from the macro name in\n"
1134 "# that file to get the Keysym name.\n"
1135 "#\n"
1136 "# One might parse a Keysym line with:\n"
1137 "#\n"
1138 "# int client, down, keysym; char name[100], hint[100];\n"
1139 "# sscanf(line, \"Keysym %d %d %d %s %s\", &client, &down, &keysym, name, hint);\n"
1140 "#\n"
1141 "# The <hint> value is currently just None, KeyPress, or KeyRelease.\n"
1142 "#\n"
1143 "# In the future <hint> will provide a hint for the sequence of KeyCodes\n"
1144 "# (i.e. keyboard scancodes) that x11vnc would inject to an X display to\n"
1145 "# simulate the Keysym.\n"
1146 "#\n"
1147 "# You see, some Keysyms will require more than one injected Keycode to\n"
1148 "# generate the symbol. E.g. the Keysym \"ampersand\" going down usually\n"
1149 "# requires a Shift key going down, then the key with the \"&\" on it going\n"
1150 "# down, and, perhaps, the Shift key going up (that is how x11vnc does it).\n"
1151 "#\n"
1152 "# The Keysym => Keycode(s) stuff gets pretty messy. Hopefully the Keysym\n"
1153 "# info will be enough for most purposes (having identical keyboards on\n"
1154 "# both sides helps).\n"
1155 "#\n"
1156 "# Parsing example for perl:\n"
1157 "#\n"
1158 "# while (<>) {\n"
1159 "# chomp;\n"
1160 "# if (/^Pointer/) {\n"
1161 "# my ($p, $client, $x, $y, $mask, $hint) = split(' ', $_, 6);\n"
1162 "# do_pointer($client, $x, $y, $mask, $hint);\n"
1163 "# } elsif (/^Keysym/) {\n"
1164 "# my ($k, $client, $down, $keysym, $name, $hint) = split(' ', $_, 6);\n"
1165 "# do_keysym($client, $down, $keysym, $name, $hint);\n"
1166 "# }\n"
1167 "# }\n"
1168 "#\n"
1169 "#\n"
1170 "# Here comes your stream. The following token will always indicate the\n"
1171 "# end of this informational text:\n"
1172 "# END_OF_TOP\n"
1173 );
1174 fflush(pipeinput_fh);
1175 if (raw_fb_str) {
1176 /* the pipe program may actually create the fb */
1177 sleep(1);
1178 }
1179 }
1180
check_pipeinput(void)1181 int check_pipeinput(void) {
1182 if (! pipeinput_fh) {
1183 return 1;
1184 }
1185 if (ferror(pipeinput_fh)) {
1186 rfbLog("pipeinput pipe has ferror. %p\n", pipeinput_fh);
1187
1188 if (pipeinput_opts && strstr(pipeinput_opts, "reopen")) {
1189 rfbLog("restarting -pipeinput pipe...\n");
1190 initialize_pipeinput();
1191 if (pipeinput_fh) {
1192 return 1;
1193 } else {
1194 return 0;
1195 }
1196 } else {
1197 rfbLog("closing -pipeinput pipe...\n");
1198 pclose(pipeinput_fh);
1199 pipeinput_fh = NULL;
1200 return 0;
1201 }
1202 }
1203 return 1;
1204 }
1205
1206
1207