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 /* -- xevents.c -- */
34
35 #include "x11vnc.h"
36 #include "xwrappers.h"
37 #include "xkb_bell.h"
38 #include "xrandr.h"
39 #include "xdamage.h"
40 #include "xrecord.h"
41 #include "selection.h"
42 #include "keyboard.h"
43 #include "cursor.h"
44 #include "gui.h"
45 #include "connections.h"
46 #include "unixpw.h"
47 #include "cleanup.h"
48 #include "macosx.h"
49 #include "screen.h"
50 #include "pm.h"
51 #include "pointer.h"
52 #include "remote.h"
53 #include "inet.h"
54
55 /* XXX CHECK BEFORE RELEASE */
56 int grab_buster = 0;
57 int grab_kbd = 0;
58 int grab_ptr = 0;
59 int grab_always = 0;
60 int ungrab_both = 0;
61 int grab_local = 0;
62 int sync_tod_delay = 20;
63
64 void initialize_vnc_connect_prop(void);
65 void initialize_x11vnc_remote_prop(void);
66 void initialize_clipboard_atom(void);
67 void spawn_grab_buster(void);
68 void sync_tod_with_servertime(void);
69 void check_keycode_state(void);
70 void check_autorepeat(void);
71 void set_prop_atom(Atom atom);
72 void check_xevents(int reset);
73 void xcut_receive(char *text, int len, rfbClientPtr cl);
74
75 void kbd_release_all_keys(rfbClientPtr cl);
76 void set_single_window(rfbClientPtr cl, int x, int y);
77 void set_server_input(rfbClientPtr cl, int s);
78 void set_text_chat(rfbClientPtr cl, int l, char *t);
79 int get_keyboard_led_state_hook(rfbScreenInfoPtr s);
80 int get_file_transfer_permitted(rfbClientPtr cl);
81 void get_prop(char *str, int len, Atom prop, Window w);
82 int guess_dm_gone(int t1, int t2);
83
84 static void initialize_xevents(int reset);
85 static void print_xevent_bases(void);
86 static void bust_grab(int reset);
87 static int process_watch(char *str, int parent, int db);
88 static void grab_buster_watch(int parent, char *dstr);
89
90
initialize_vnc_connect_prop(void)91 void initialize_vnc_connect_prop(void) {
92 char *prop_str;
93 vnc_connect_str[0] = '\0';
94 RAWFB_RET_VOID
95 #if !NO_X11
96 prop_str = getenv("VNC_CONNECT");
97 if (prop_str == NULL) {
98 prop_str = "VNC_CONNECT";
99 }
100 vnc_connect_prop = XInternAtom(dpy, "VNC_CONNECT", False);
101 #endif
102 }
103
initialize_x11vnc_remote_prop(void)104 void initialize_x11vnc_remote_prop(void) {
105 char *prop_str;
106 x11vnc_remote_str[0] = '\0';
107 RAWFB_RET_VOID
108 #if !NO_X11
109 prop_str = getenv("X11VNC_REMOTE");
110 if (prop_str == NULL) {
111 prop_str = "X11VNC_REMOTE";
112 }
113 x11vnc_remote_prop = XInternAtom(dpy, prop_str, False);
114 #endif
115 }
116
initialize_clipboard_atom(void)117 void initialize_clipboard_atom(void) {
118 RAWFB_RET_VOID
119 #if NO_X11
120 return;
121 #else
122 clipboard_atom = XInternAtom(dpy, "CLIPBOARD", False);
123 if (clipboard_atom == None) {
124 if (! quiet) rfbLog("could not find atom CLIPBOARD\n");
125 if (watch_clipboard) {
126 watch_clipboard = 0;
127 }
128 if (set_clipboard) {
129 set_clipboard = 0;
130 }
131 }
132 #endif /* NO_X11 */
133 }
134
135 /*
136 we observed these strings:
137
138 6 gdm_string: Gnome-power-manager
139 6 gdm_string: Gnome-session
140 6 gdm_string: Gnome-settings-daemon
141 6 gdm_string: Login Window
142 6 gdm_string: Notify-osd
143 6 gdm_string: Panel
144 12 gdm_string: Metacity
145 12 gdm_string: gnome-power-manager
146 12 gdm_string: gnome-session
147 12 gdm_string: gnome-settings-daemon
148 12 gdm_string: notify-osd
149 18 gdm_string: Gdm-simple-greeter
150 24 gdm_string: metacity
151 36 gdm_string: gdm-simple-greeter
152
153 kdmgreet
154 Kdmgreet
155 */
156
dm_string(char * str)157 static int dm_string(char *str) {
158 char *s = getenv("DEBUG_WM_RUNNING");
159 if (str == NULL) {
160 return 0;
161 }
162 if (str[0] == '\0') {
163 return 0;
164 }
165 if (0) fprintf(stderr, "dm_string: %s\n", str);
166 if (strstr(str, "gdm-") == str || strstr(str, "Gdm-") == str) {
167 if (strstr(str, "-greeter") != NULL) {
168 if (s) rfbLog("dm_string: %s\n", str);
169 return 1;
170 }
171 }
172 if (!strcmp(str, "kdmgreet") || !strcmp(str, "Kdmgreet")) {
173 if (s) rfbLog("dm_string: %s\n", str);
174 return 1;
175 }
176 return 0;
177 }
178
dm_still_running(void)179 static int dm_still_running(void) {
180 #if NO_X11
181 return 0;
182 #else
183 Window r, parent;
184 Window *winlist;
185 unsigned int nc;
186 int rc, i;
187 static XClassHint *classhint = NULL;
188 XErrorHandler old_handler;
189 int saw_gdm_name = 0;
190
191 /* some times a window can go away before we get to it */
192 trapped_xerror = 0;
193 old_handler = XSetErrorHandler(trap_xerror);
194
195 if (! classhint) {
196 classhint = XAllocClassHint();
197 }
198
199 /* we are xlocked. */
200 rc = XQueryTree_wr(dpy, DefaultRootWindow(dpy), &r, &parent, &winlist, &nc);
201 if (!rc || winlist == NULL || nc == 0) {
202 nc = 0;
203 }
204 for (i=0; i < (int) nc; i++) {
205 char *name = NULL;
206 Window w = winlist[i];
207 if (XFetchName(dpy, w, &name) && name != NULL) {
208 saw_gdm_name += dm_string(name);
209 XFree_wr(name);
210 }
211 classhint->res_name = NULL;
212 classhint->res_class = NULL;
213 if (XGetClassHint(dpy, w, classhint)) {
214 name = classhint->res_name;
215 if (name != NULL) {
216 saw_gdm_name += dm_string(name);
217 XFree_wr(name);
218 }
219 name = classhint->res_class;
220 if (name != NULL) {
221 saw_gdm_name += dm_string(name);
222 XFree_wr(name);
223 }
224 }
225 if (saw_gdm_name > 0) {
226 break;
227 }
228 }
229 if (winlist != NULL) {
230 XFree_wr(winlist);
231 }
232
233 XSync(dpy, False);
234 XSetErrorHandler(old_handler);
235 trapped_xerror = 0;
236
237 return saw_gdm_name;
238 #endif
239 }
240
wm_running(void)241 static int wm_running(void) {
242 char *s = getenv("DEBUG_WM_RUNNING");
243 int ret = 0;
244 RAWFB_RET(0)
245 #if NO_X11
246 return 0;
247 #else
248 /*
249 * Unfortunately with recent GDM (v2.28), they run gnome-session,
250 * dbus-launch, and metacity for the Login greeter! So the simple
251 * XInternAtom checks below no longer work.
252 * We also see a similar thing with KDE.
253 */
254 if (dm_still_running()) {
255 return 0;
256 }
257
258 /* we are xlocked. */
259 if (XInternAtom(dpy, "_NET_SUPPORTED", True) != None) {
260 if (s) rfbLog("wm is running (_NET_SUPPORTED).\n");
261 ret++;
262 }
263 if (XInternAtom(dpy, "_WIN_PROTOCOLS", True) != None) {
264 if (s) rfbLog("wm is running (_WIN_PROTOCOLS).\n");
265 ret++;
266 }
267 if (XInternAtom(dpy, "_XROOTPMAP_ID", True) != None) {
268 if (s) rfbLog("wm is running (_XROOTPMAP_ID).\n");
269 ret++;
270 }
271 if (XInternAtom(dpy, "_MIT_PRIORITY_COLORS", True) != None) {
272 if (s) rfbLog("wm is running (_MIT_PRIORITY_COLORS).\n");
273 ret++;
274 }
275 if (!ret) {
276 if (s) rfbLog("wm is not running.\n");
277 return 0;
278 } else {
279 if (s) rfbLog("wm is running ret=%d.\n", ret);
280 return 1;
281 }
282 #endif /* NO_X11 */
283
284 }
285
guess_dm_gone(int t1,int t2)286 int guess_dm_gone(int t1, int t2) {
287 int wait = t2;
288 char *avoid = getenv("X11VNC_AVOID_WINDOWS");
289 time_t tcheck = last_client;
290
291 if (last_open_xdisplay > last_client) {
292 /* better time for -display WAIT:... */
293 tcheck = last_open_xdisplay;
294 }
295
296 if (avoid && !strcmp(avoid, "never")) {
297 return 1;
298 }
299 if (!screen || !screen->clientHead) {
300 return 0;
301 }
302 if (avoid) {
303 int n = atoi(avoid);
304 if (n > 1) {
305 wait = n;
306 } else {
307 wait = 90;
308 }
309 } else {
310 static time_t saw_wm = 0;
311
312 wait = t2;
313
314 X_LOCK;
315 if (wm_running()) {
316 if (saw_wm == 0) {
317 saw_wm = time(NULL);
318 } else if (time(NULL) <= saw_wm + 2) {
319 /* try to wait a few seconds after transition */
320 ;
321 } else {
322 wait = t1;
323 }
324 }
325 X_UNLOCK;
326 }
327 if (getenv("DEBUG_WM_RUNNING")) {
328 rfbLog("guess_dm_gone: wait=%d\n", wait);
329 }
330 /* we assume they've logged in OK after wait seconds... */
331 if (time(NULL) <= tcheck + wait) {
332 return 0;
333 }
334 return 1;
335 }
336
initialize_xevents(int reset)337 static void initialize_xevents(int reset) {
338 #if NO_X11
339 RAWFB_RET_VOID
340 if (!reset) {}
341 return;
342 #else
343 static int did_xselect_input = 0;
344 static int did_xcreate_simple_window = 0;
345 static int did_vnc_connect_prop = 0;
346 static int did_x11vnc_remote_prop = 0;
347 static int did_clipboard_atom = 0;
348 static int did_xfixes = 0;
349 static int did_xdamage = 0;
350 static int did_xrandr = 0;
351
352 RAWFB_RET_VOID
353
354 if (reset) {
355 did_xselect_input = 0;
356 did_xcreate_simple_window = 0;
357 did_vnc_connect_prop = 0;
358 did_x11vnc_remote_prop = 0;
359 did_clipboard_atom = 0;
360 did_xfixes = 0;
361 did_xdamage = 0;
362 did_xrandr = 0;
363 }
364
365 if ((watch_selection || vnc_connect) && !did_xselect_input) {
366 /*
367 * register desired event(s) for notification.
368 * PropertyChangeMask is for CUT_BUFFER0 changes.
369 * XXX: does this cause a flood of other stuff?
370 */
371 X_LOCK;
372 xselectinput_rootwin |= PropertyChangeMask;
373 XSelectInput_wr(dpy, rootwin, xselectinput_rootwin);
374
375 if (subwin && freeze_when_obscured) {
376 XSelectInput_wr(dpy, subwin, VisibilityChangeMask);
377 }
378 X_UNLOCK;
379 did_xselect_input = 1;
380 }
381 if (watch_selection && !did_xcreate_simple_window) {
382 /* create fake window for our selection ownership, etc */
383
384 /*
385 * We try to delay creating selwin until we are past
386 * any GDM, (or other KillInitClients=true) manager.
387 */
388 if (guess_dm_gone(8, 45)) {
389 X_LOCK;
390 selwin = XCreateSimpleWindow(dpy, rootwin, 3, 2, 1, 1, 0, 0, 0);
391 X_UNLOCK;
392 did_xcreate_simple_window = 1;
393 if (! quiet) rfbLog("created selwin: 0x%lx\n", selwin);
394 }
395 }
396
397 if ((xrandr || xrandr_maybe) && !did_xrandr) {
398 initialize_xrandr();
399 did_xrandr = 1;
400 }
401 if (vnc_connect && !did_vnc_connect_prop) {
402 initialize_vnc_connect_prop();
403 did_vnc_connect_prop = 1;
404 }
405 if (vnc_connect && !did_x11vnc_remote_prop) {
406 initialize_x11vnc_remote_prop();
407 did_x11vnc_remote_prop = 1;
408 }
409 if (run_gui_pid > 0) {
410 kill(run_gui_pid, SIGUSR1);
411 run_gui_pid = 0;
412 }
413 if (!did_clipboard_atom) {
414 initialize_clipboard_atom();
415 did_clipboard_atom = 1;
416 }
417 if (xfixes_present && use_xfixes && !did_xfixes) {
418 /*
419 * We try to delay creating initializing xfixes until
420 * we are past the display manager, due to Xorg bug:
421 * http://bugs.freedesktop.org/show_bug.cgi?id=18451
422 */
423 if (guess_dm_gone(8, 45)) {
424 initialize_xfixes();
425 did_xfixes = 1;
426 if (! quiet) rfbLog("called initialize_xfixes()\n");
427 }
428 }
429 if (xdamage_present && !did_xdamage) {
430 initialize_xdamage();
431 did_xdamage = 1;
432 }
433 #endif /* NO_X11 */
434 }
435
print_xevent_bases(void)436 static void print_xevent_bases(void) {
437 fprintf(stderr, "X event bases: xkb=%d, xtest=%d, xrandr=%d, "
438 "xfixes=%d, xdamage=%d, xtrap=%d\n", xkb_base_event_type,
439 xtest_base_event_type, xrandr_base_event_type,
440 xfixes_base_event_type, xdamage_base_event_type,
441 xtrap_base_event_type);
442 fprintf(stderr, " MapNotify=%d, ClientMsg=%d PropNotify=%d "
443 "SelNotify=%d, SelRequest=%d\n", MappingNotify, ClientMessage,
444 PropertyNotify, SelectionNotify, SelectionRequest);
445 fprintf(stderr, " SelClear=%d, Expose=%d\n", SelectionClear, Expose);
446 }
447
get_prop(char * str,int len,Atom prop,Window w)448 void get_prop(char *str, int len, Atom prop, Window w) {
449 int i;
450 #if !NO_X11
451 Atom type;
452 int format, slen, dlen;
453 unsigned long nitems = 0, bytes_after = 0;
454 unsigned char* data = NULL;
455 #endif
456
457 for (i=0; i<len; i++) {
458 str[i] = '\0';
459 }
460 if (prop == None) {
461 return;
462 }
463
464 RAWFB_RET_VOID
465
466 #if NO_X11
467 return;
468 #else
469
470 slen = 0;
471 if (w == None) {
472 w = DefaultRootWindow(dpy);
473 }
474
475 do {
476 if (XGetWindowProperty(dpy, w,
477 prop, nitems/4, len/16, False,
478 AnyPropertyType, &type, &format, &nitems, &bytes_after,
479 &data) == Success) {
480
481 dlen = nitems * (format/8);
482 if (slen + dlen > len) {
483 /* too big */
484 XFree_wr(data);
485 break;
486 }
487 memcpy(str+slen, data, dlen);
488 slen += dlen;
489 str[slen] = '\0';
490 XFree_wr(data);
491 }
492 } while (bytes_after > 0);
493 #endif /* NO_X11 */
494 }
495
bust_grab(int reset)496 static void bust_grab(int reset) {
497 #if NO_X11
498 if (!reset) {}
499 return;
500 #else
501 static int bust_count = 0;
502 static time_t last_bust = 0;
503 time_t now = time(NULL);
504 KeyCode key;
505 int button, x, y, nb;
506
507 if (now > last_bust + 180) {
508 bust_count = 0;
509 }
510 if (reset) {
511 bust_count = 0;
512 return;
513 }
514
515 x = 0;
516 y = 0;
517 button = 0;
518 key = NoSymbol;
519
520 nb = 8;
521 if (bust_count >= 3 * nb) {
522 fprintf(stderr, "too many bust_grab's %d for me\n", bust_count);
523 exit(0);
524 }
525 if (bust_count % nb == 0) {
526 button = 1;
527 } else if (bust_count % nb == 1) {
528 button = 1;
529 } else if (bust_count % nb == 2) {
530 key = XKeysymToKeycode(dpy, XK_Escape);
531 } else if (bust_count % nb == 3) {
532 button = 3;
533 } else if (bust_count % nb == 4) {
534 key = XKeysymToKeycode(dpy, XK_space);
535 } else if (bust_count % nb == 5) {
536 x = bust_count * 23;
537 y = bust_count * 17;
538 } else if (bust_count % nb == 5) {
539 button = 2;
540 } else if (bust_count % nb == 6) {
541 key = XKeysymToKeycode(dpy, XK_a);
542 }
543
544 if (key == NoSymbol) {
545 key = XKeysymToKeycode(dpy, XK_a);
546 if (key == NoSymbol) {
547 button = 1;
548 }
549 }
550
551 bust_count++;
552
553 if (button) {
554 /* try button press+release */
555 fprintf(stderr, "**bust_grab: button%d %.4f\n",
556 button, dnowx());
557 XTestFakeButtonEvent_wr(dpy, button, True, CurrentTime);
558 XFlush_wr(dpy);
559 usleep(50 * 1000);
560 XTestFakeButtonEvent_wr(dpy, button, False, CurrentTime);
561 } else if (x > 0) {
562 /* try button motion*/
563 int scr = DefaultScreen(dpy);
564
565 fprintf(stderr, "**bust_grab: x=%d y=%d %.4f\n", x, y,
566 dnowx());
567 XTestFakeMotionEvent_wr(dpy, scr, x, y, CurrentTime);
568 XFlush_wr(dpy);
569 usleep(50 * 1000);
570
571 /* followed by button press */
572 button = 1;
573 fprintf(stderr, "**bust_grab: button%d\n", button);
574 XTestFakeButtonEvent_wr(dpy, button, True, CurrentTime);
575 XFlush_wr(dpy);
576 usleep(50 * 1000);
577 XTestFakeButtonEvent_wr(dpy, button, False, CurrentTime);
578 } else {
579 /* try Escape or Space press+release */
580 fprintf(stderr, "**bust_grab: keycode: %d %.4f\n",
581 (int) key, dnowx());
582 XTestFakeKeyEvent_wr(dpy, key, True, CurrentTime);
583 XFlush_wr(dpy);
584 usleep(50 * 1000);
585 XTestFakeKeyEvent_wr(dpy, key, False, CurrentTime);
586 }
587 XFlush_wr(dpy);
588 last_bust = time(NULL);
589 #endif /* NO_X11 */
590 }
591
592 typedef struct _grabwatch {
593 int pid;
594 int tick;
595 unsigned long time;
596 time_t change;
597 } grabwatch_t;
598 #define GRABWATCH 16
599
600 static int grab_buster_delay = 20;
601 static pid_t grab_buster_pid = 0;
602
603 static int grab_npids = 1;
604
process_watch(char * str,int parent,int db)605 static int process_watch(char *str, int parent, int db) {
606 int i, pid, ticker, npids;
607 char diff[128];
608 unsigned long xtime;
609 static grabwatch_t watches[GRABWATCH];
610 static int first = 1;
611 time_t now = time(NULL);
612 static time_t last_bust = 0;
613 int too_long, problems = 0;
614
615 if (first) {
616 for (i=0; i < GRABWATCH; i++) {
617 watches[i].pid = 0;
618 watches[i].tick = 0;
619 watches[i].time = 0;
620 watches[i].change = 0;
621 }
622 first = 0;
623 }
624
625 /* record latest value of prop */
626 if (str && *str != '\0') {
627 if (sscanf(str, "%d/%d/%lu/%s", &pid, &ticker, &xtime, diff)
628 == 4) {
629 int got = -1, free = -1;
630
631 if (db) fprintf(stderr, "grab_buster %d - %d - %lu - %s"
632 "\n", pid, ticker, xtime, diff);
633
634 if (pid == parent && !strcmp(diff, "QUIT")) {
635 /* that's it. */
636 return 0;
637 }
638 if (pid == 0 || ticker == 0 || xtime == 0) {
639 /* bad prop read. */
640 goto badtickerstr;
641 }
642 for (i=0; i < GRABWATCH; i++) {
643 if (watches[i].pid == pid) {
644 got = i;
645 break;
646 }
647 if (free == -1 && watches[i].pid == 0) {
648 free = i;
649 }
650 }
651 if (got == -1) {
652 if (free == -1) {
653 /* bad news */;
654 free = GRABWATCH - 1;
655 }
656 watches[free].pid = pid;
657 watches[free].tick = ticker;
658 watches[free].time = xtime;
659 watches[free].change = now;
660 if (db) fprintf(stderr, "grab_buster free slot: %d\n", free);
661 } else {
662 if (db) fprintf(stderr, "grab_buster got slot: %d\n", got);
663 if (watches[got].tick != ticker) {
664 watches[got].change = now;
665 }
666 if (watches[got].time != xtime) {
667 watches[got].change = now;
668 }
669 watches[got].tick = ticker;
670 watches[got].time = xtime;
671 }
672 } else {
673 if (db) fprintf(stderr, "grab_buster bad prop str: %s\n", str);
674 }
675 }
676
677 badtickerstr:
678
679 too_long = grab_buster_delay;
680 if (too_long < 3 * sync_tod_delay) {
681 too_long = 3 * sync_tod_delay;
682 }
683
684 npids = 0;
685 for (i=0; i < GRABWATCH; i++) {
686 if (watches[i].pid) {
687 npids++;
688 }
689 }
690 grab_npids = npids;
691 if (npids > 4) {
692 npids = 4;
693 }
694
695 /* now check everyone we are tracking */
696 for (i=0; i < GRABWATCH; i++) {
697 int fac = 1;
698 if (!watches[i].pid) {
699 continue;
700 }
701 if (watches[i].change == 0) {
702 watches[i].change = now; /* just to be sure */
703 continue;
704 }
705
706 pid = watches[i].pid;
707
708 if (pid != parent) {
709 fac = 2;
710 }
711 if (npids > 0) {
712 fac *= npids;
713 }
714
715 if (now > watches[i].change + fac*too_long) {
716 int process_alive = 1;
717
718 fprintf(stderr, "grab_buster: problem with pid: "
719 "%d - %d/%d/%d\n", pid, (int) now,
720 (int) watches[i].change, too_long);
721
722 if (kill((pid_t) pid, 0) != 0) {
723 if (1 || errno == ESRCH) {
724 process_alive = 0;
725 }
726 }
727
728 if (!process_alive) {
729 watches[i].pid = 0;
730 watches[i].tick = 0;
731 watches[i].time = 0;
732 watches[i].change = 0;
733 fprintf(stderr, "grab_buster: pid gone: %d\n",
734 pid);
735 if (pid == parent) {
736 /* that's it */
737 return 0;
738 }
739 } else {
740 int sleep = sync_tod_delay * 1000 * 1000;
741
742 bust_grab(0);
743 problems++;
744 last_bust = now;
745 usleep(1 * sleep);
746 break;
747 }
748 }
749 }
750
751 if (!problems) {
752 bust_grab(1);
753 }
754 return 1;
755 }
756
grab_buster_watch(int parent,char * dstr)757 static void grab_buster_watch(int parent, char *dstr) {
758 #if NO_X11
759 RAWFB_RET_VOID
760 if (!parent || !dstr) {}
761 return;
762 #else
763 Atom ticker_atom = None;
764 int sleep = sync_tod_delay * 921 * 1000;
765 char propval[200];
766 int ev, er, maj, min;
767 int db = 0;
768 char *ticker_str = "X11VNC_TICKER";
769
770 RAWFB_RET_VOID
771
772 if (grab_buster > 1) {
773 db = 1;
774 }
775
776 /* overwrite original dpy, we let orig connection sit unused. */
777 dpy = XOpenDisplay_wr(dstr);
778 if (!dpy) {
779 fprintf(stderr, "grab_buster_watch: could not reopen: %s\n",
780 dstr);
781 return;
782 }
783 rfbLogEnable(0);
784
785 /* check for XTEST, etc, and then disable grabs for us */
786 if (! XTestQueryExtension_wr(dpy, &ev, &er, &maj, &min)) {
787 xtest_present = 0;
788 } else {
789 xtest_present = 1;
790 }
791 if (! XETrapQueryExtension_wr(dpy, &ev, &er, &maj)) {
792 xtrap_present = 0;
793 } else {
794 xtrap_present = 1;
795 }
796
797 if (! xtest_present && ! xtrap_present) {
798 fprintf(stderr, "grab_buster_watch: no grabserver "
799 "protection on display: %s\n", dstr);
800 return;
801 }
802 disable_grabserver(dpy, 0);
803
804 usleep(3 * sleep);
805
806 if (getenv("X11VNC_TICKER")) {
807 ticker_str = getenv("X11VNC_TICKER");
808 }
809 ticker_atom = XInternAtom(dpy, ticker_str, False);
810 if (! ticker_atom) {
811 fprintf(stderr, "grab_buster_watch: no ticker atom\n");
812 return;
813 }
814
815 while(1) {
816 int slp = sleep;
817 if (grab_npids > 1) {
818 slp = slp / 8;
819 }
820 usleep(slp);
821 usleep((int) (0.60 * rfac() * slp));
822
823 if (kill((pid_t) parent, 0) != 0) {
824 break;
825 }
826
827 get_prop(propval, 128, ticker_atom, None);
828 if (db) fprintf(stderr, "got_prop: %s\n", propval);
829
830 if (!process_watch(propval, parent, db)) {
831 break;
832 }
833 }
834 #endif /* NO_X11 */
835 }
836
spawn_grab_buster(void)837 void spawn_grab_buster(void) {
838 #if LIBVNCSERVER_HAVE_FORK
839 pid_t pid;
840 int parent = (int) getpid();
841 char *dstr = strdup(DisplayString(dpy));
842
843 RAWFB_RET_VOID
844
845 XCloseDisplay_wr(dpy);
846 dpy = NULL;
847
848 if ((pid = fork()) > 0) {
849 grab_buster_pid = pid;
850 if (! quiet) {
851 rfbLog("grab_buster pid is: %d\n", (int) pid);
852 }
853 } else if (pid == -1) {
854 fprintf(stderr, "spawn_grab_buster: could not fork\n");
855 rfbLogPerror("fork");
856 } else {
857 signal(SIGHUP, SIG_DFL);
858 signal(SIGINT, SIG_DFL);
859 signal(SIGQUIT, SIG_DFL);
860 signal(SIGTERM, SIG_DFL);
861
862 grab_buster_watch(parent, dstr);
863 exit(0);
864 }
865
866 dpy = XOpenDisplay_wr(dstr);
867 if (!dpy) {
868 rfbLog("failed to reopen display %s in spawn_grab_buster\n",
869 dstr);
870 exit(1);
871 }
872 #endif
873 }
874
sync_tod_with_servertime(void)875 void sync_tod_with_servertime(void) {
876 #if NO_X11
877 RAWFB_RET_VOID
878 return;
879 #else
880 static Atom ticker_atom = None;
881 XEvent xev;
882 char diff[128];
883 static int seq = 0;
884 static unsigned long xserver_ticks = 1;
885 int i, db = 0;
886
887 RAWFB_RET_VOID
888
889 if (atom_NET_ACTIVE_WINDOW == None) {
890 atom_NET_ACTIVE_WINDOW = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", True);
891 }
892 if (atom_NET_CURRENT_DESKTOP == None) {
893 atom_NET_CURRENT_DESKTOP = XInternAtom(dpy, "_NET_CURRENT_DESKTOP", True);
894 }
895 if (atom_NET_CLIENT_LIST_STACKING == None) {
896 atom_NET_CLIENT_LIST_STACKING = XInternAtom(dpy, "_NET_CLIENT_LIST_STACKING", True);
897 }
898 if (atom_XROOTPMAP_ID == None) {
899 atom_XROOTPMAP_ID = XInternAtom(dpy, "_XROOTPMAP_ID", True);
900 }
901
902 if (! ticker_atom) {
903 char *ticker_str = "X11VNC_TICKER";
904 if (getenv("X11VNC_TICKER")) {
905 ticker_str = getenv("X11VNC_TICKER");
906 }
907 ticker_atom = XInternAtom(dpy, ticker_str, False);
908 }
909 if (! ticker_atom) {
910 return;
911 }
912
913 XSync(dpy, False);
914 while (XCheckTypedEvent(dpy, PropertyNotify, &xev)) {
915 set_prop_atom(xev.xproperty.atom);
916 }
917
918 snprintf(diff, 128, "%d/%08d/%lu/%.6f", (int) getpid(), seq++,
919 xserver_ticks, servertime_diff);
920 XChangeProperty(dpy, rootwin, ticker_atom, XA_STRING, 8,
921 PropModeReplace, (unsigned char *) diff, strlen(diff));
922 XSync(dpy, False);
923
924 for (i=0; i < 10; i++) {
925 int k, got = 0;
926
927 for (k=0; k < 5; k++) {
928 while (XCheckTypedEvent(dpy, PropertyNotify, &xev)) {
929 if (xev.xproperty.atom == ticker_atom) {
930 double stime;
931
932 xserver_ticks = xev.xproperty.time;
933 stime = (double) xev.xproperty.time;
934 stime = stime/1000.0;
935 servertime_diff = dnow() - stime;
936 if (db) rfbLog("set servertime_diff: "
937 "%.6f\n", servertime_diff);
938 got = 1;
939 }
940 }
941 }
942 if (got) {
943 break;
944 }
945 usleep(1000);
946 }
947 #endif /* NO_X11 */
948 }
949
check_keycode_state(void)950 void check_keycode_state(void) {
951 static time_t last_check = 0;
952 int delay = 10, noinput = 3;
953 time_t now = time(NULL);
954
955 if (! client_count) {
956 return;
957 }
958 if (unixpw_in_progress) return;
959
960 RAWFB_RET_VOID
961
962 /*
963 * periodically update our model of the keycode_state[]
964 * by correlating with the Xserver. wait for a pause in
965 * keyboard input to be on the safe side. the idea here
966 * is to remove stale keycode state, not to be perfectly
967 * in sync with the Xserver at every instant of time.
968 */
969 if (now > last_check + delay && now > last_keyboard_input + noinput) {
970 X_LOCK;
971 init_track_keycode_state();
972 X_UNLOCK;
973 last_check = now;
974 }
975 }
976
977 /*
978 * To use the experimental -grablocal option configure like this:
979 * env CPPFLAGS=-DENABLE_GRABLOCAL LDFLAGS=-lXss ./configure
980 */
981 #ifdef ENABLE_GRABLOCAL
982 #include <X11/extensions/scrnsaver.h>
983
check_local_grab(void)984 void check_local_grab(void) {
985 static double last_check = 0.0;
986 double now;
987
988 if (grab_local <= 0) {
989 return;
990 }
991 if (! client_count) {
992 return;
993 }
994 if (unixpw_in_progress) return;
995
996 if (last_rfb_key_injected <= 0.0 && last_rfb_ptr_injected <= 0.0) {
997 return;
998 }
999
1000 RAWFB_RET_VOID
1001
1002 now = dnow();
1003
1004 if (now > last_check + 0.1) {
1005 #if !NO_X11
1006 int ret;
1007 double idle;
1008 XScreenSaverInfo info;
1009 static int save_viewonly = -1, local_is_idle = -1, db = -1;
1010
1011 if (debug_keyboard) db = debug_keyboard;
1012 if (debug_pointer ) db = debug_pointer;
1013
1014 if (db < 0) {
1015 if (getenv("LOCAL_GRAB_DEBUG")) {
1016 db = atoi(getenv("LOCAL_GRAB_DEBUG"));
1017 } else {
1018 db = 0;
1019 }
1020 }
1021
1022 ret = XScreenSaverQueryInfo(dpy, RootWindowOfScreen(
1023 ScreenOfDisplay(dpy, 0)), &info);
1024
1025 if (ret) {
1026 double tlatest_rfb = 0.0;
1027
1028 idle = ((double) info.idle)/1000.0;
1029 now = dnow();
1030
1031 if (last_rfb_key_injected > 0.0) {
1032 tlatest_rfb = last_rfb_key_injected;
1033 }
1034 if (last_rfb_ptr_injected > tlatest_rfb) {
1035 tlatest_rfb = last_rfb_ptr_injected;
1036 }
1037 if (db > 1) fprintf(stderr, "idle: %.4f latest: %.4f dt: %.4f\n", idle, now - tlatest_rfb, idle - (now - tlatest_rfb));
1038
1039 if (now - tlatest_rfb <= idle + 0.005) {
1040 /* 0.005 is 5ms tolerance */
1041 } else if (idle < grab_local) {
1042 if (local_is_idle < 0 || local_is_idle) {
1043 save_viewonly = view_only;
1044 view_only = 1;
1045 if (db) {
1046 rfbLog("check_local_grab: set viewonly\n");
1047 }
1048 }
1049
1050 local_is_idle = 0;
1051 } else {
1052 if (!local_is_idle && save_viewonly >= 0) {
1053 view_only = save_viewonly;
1054 if (db) {
1055 rfbLog("check_local_grab: restored viewonly; %d\n", view_only);
1056 }
1057 }
1058 local_is_idle = 1;
1059 }
1060 }
1061 #endif
1062 last_check = dnow();
1063 }
1064 }
1065 #endif
1066
check_autorepeat(void)1067 void check_autorepeat(void) {
1068 static time_t last_check = 0;
1069 static int idle_timeout = -300, idle_reset = 0;
1070 time_t now = time(NULL);
1071 int autorepeat_is_on, autorepeat_initially_on;
1072
1073 if (! no_autorepeat || ! client_count) {
1074 return;
1075 }
1076 if (now <= last_check + 1) {
1077 return;
1078 }
1079
1080 if (unixpw_in_progress) return;
1081
1082 if (idle_timeout < 0) {
1083 if (getenv("X11VNC_IDLE_TIMEOUT")) {
1084 idle_timeout = atoi(getenv("X11VNC_IDLE_TIMEOUT"));
1085 }
1086 if (idle_timeout < 0) {
1087 idle_timeout = -idle_timeout;
1088 }
1089 }
1090
1091 last_check = now;
1092
1093 autorepeat_is_on = get_autorepeat_state();
1094 autorepeat_initially_on = get_initial_autorepeat_state();
1095
1096 if (view_only) {
1097 if (! autorepeat_is_on) {
1098 autorepeat(1, 1);
1099 }
1100 return;
1101 }
1102
1103 if (now > last_keyboard_input + idle_timeout) {
1104 /* autorepeat should be on when idle */
1105 if (! autorepeat_is_on && autorepeat_initially_on) {
1106 static time_t last_msg = 0;
1107 static int cnt = 0;
1108 if (now > last_msg + idle_timeout && cnt++ < 10) {
1109 rfbLog("idle keyboard: turning X autorepeat"
1110 " back on.\n");
1111 last_msg = now;
1112 }
1113 autorepeat(1, 1);
1114 idle_reset = 1;
1115 }
1116 } else {
1117 if (idle_reset) {
1118 int i, state[256], didmsg = 0, pressed = 0;
1119 int mwt = 600, mmax = 20;
1120 static int msgcnt = 0;
1121 static double lastmsg = 0.0;
1122
1123 for (i=0; i<256; i++) {
1124 state[i] = 0;
1125 }
1126 if (use_threads) {X_LOCK;}
1127 get_keystate(state);
1128 if (use_threads) {X_UNLOCK;}
1129
1130 for (i=0; i<256; i++) {
1131 if (state[i] != 0) {
1132 /* better wait until all keys are up */
1133 pressed++;
1134 if (msgcnt < mmax || dnow() > lastmsg + mwt) {
1135 char *str = "unset";
1136 #if !NO_X11
1137 if (use_threads) {X_LOCK;}
1138 str = XKeysymToString(XKeycodeToKeysym(dpy, i, 0));
1139 if (use_threads) {X_UNLOCK;}
1140 #endif
1141 str = str ? str : "nosymbol";
1142 didmsg++;
1143 rfbLog("active keyboard: waiting until "
1144 "all keys are up. key_down=%d %s. "
1145 "If the key is inaccessible via keyboard, "
1146 "consider 'x11vnc -R clear_all'\n", i, str);
1147 }
1148 }
1149 }
1150 if (didmsg > 0) {
1151 msgcnt++;
1152 if (msgcnt == mmax) {
1153 rfbLog("active keyboard: last such "
1154 "message for %d secs.\n", mwt);
1155 }
1156 lastmsg = dnow();
1157 }
1158 if (pressed > 0) {
1159 return;
1160 }
1161 }
1162 if (idle_reset) {
1163 static time_t last_msg = 0;
1164 static int cnt = 0;
1165 if (now > last_msg + idle_timeout && cnt++ < 10) {
1166 rfbLog("active keyboard: turning X autorepeat"
1167 " off.\n");
1168 last_msg = now;
1169 }
1170 autorepeat(0, 1);
1171 idle_reset = 0;
1172
1173 } else if (no_repeat_countdown && autorepeat_is_on) {
1174 int n = no_repeat_countdown - 1;
1175 if (n >= 0) {
1176 rfbLog("Battling with something for "
1177 "-norepeat!! (%d resets left)\n", n);
1178 } else {
1179 rfbLog("Battling with something for "
1180 "-norepeat!!\n");
1181 }
1182 if (no_repeat_countdown > 0) {
1183 no_repeat_countdown--;
1184 }
1185 autorepeat(1, 0);
1186 autorepeat(0, 0);
1187 }
1188 }
1189 }
1190
set_prop_atom(Atom atom)1191 void set_prop_atom(Atom atom) {
1192 if (atom == None) return;
1193 if (atom == atom_NET_ACTIVE_WINDOW) got_NET_ACTIVE_WINDOW = dnow();
1194 if (atom == atom_NET_CURRENT_DESKTOP) got_NET_CURRENT_DESKTOP = dnow();
1195 if (atom == atom_NET_CLIENT_LIST_STACKING) got_NET_CLIENT_LIST_STACKING = dnow();
1196 if (atom == atom_XROOTPMAP_ID) got_XROOTPMAP_ID = dnow();
1197 }
1198
1199 /*
1200 * This routine is periodically called to check for selection related
1201 * and other X11 events and respond to them as needed.
1202 */
check_xevents(int reset)1203 void check_xevents(int reset) {
1204 #if NO_X11
1205 RAWFB_RET_VOID
1206 if (!reset) {}
1207 return;
1208 #else
1209 XEvent xev;
1210 int tmp, have_clients = 0;
1211 static int sent_some_sel = 0;
1212 static time_t last_call = 0;
1213 static time_t last_bell = 0;
1214 static time_t last_init_check = 0;
1215 static time_t last_sync = 0;
1216 static time_t last_time_sync = 0;
1217 time_t now = time(NULL);
1218 static double last_request = 0.0;
1219 static double last_xrefresh = 0.0;
1220 XErrorHandler old_handler;
1221
1222 if (unixpw_in_progress) return;
1223
1224 RAWFB_RET_VOID
1225
1226 if (now > last_init_check+1 || reset) {
1227 last_init_check = now;
1228 initialize_xevents(reset);
1229 if (reset) {
1230 return;
1231 }
1232 }
1233
1234 if (screen && screen->clientHead) {
1235 have_clients = 1;
1236 }
1237
1238 X_LOCK;
1239 /*
1240 * There is a bug where we have to wait before sending text to
1241 * the client... so instead of sending right away we wait a
1242 * the few seconds.
1243 */
1244
1245 if (have_clients && watch_selection && !sent_some_sel
1246 && now > last_client + sel_waittime) {
1247 if (XGetSelectionOwner(dpy, XA_PRIMARY) == None) {
1248 cutbuffer_send();
1249 }
1250 sent_some_sel = 1;
1251 }
1252 if (! have_clients) {
1253 /*
1254 * If we don't have clients we can miss the X server
1255 * going away until a client connects.
1256 */
1257 static time_t last_X_ping = 0;
1258 if (now > last_X_ping + 5) {
1259 last_X_ping = now;
1260 XGetSelectionOwner(dpy, XA_PRIMARY);
1261 }
1262 }
1263
1264 if (have_clients && xrefresh > 0.0 && dnow() > last_xrefresh + xrefresh) {
1265 XSetWindowAttributes swa;
1266 Visual visual;
1267 Window xrf;
1268 unsigned long mask;
1269
1270 swa.override_redirect = True;
1271 swa.backing_store = NotUseful;
1272 swa.save_under = False;
1273 swa.background_pixmap = None;
1274 visual.visualid = CopyFromParent;
1275 mask = (CWOverrideRedirect|CWBackingStore|CWSaveUnder|CWBackPixmap);
1276
1277 xrf = XCreateWindow(dpy, window, coff_x, coff_y, dpy_x, dpy_y, 0, CopyFromParent,
1278 InputOutput, &visual, mask, &swa);
1279 if (xrf != None) {
1280 if (0) fprintf(stderr, "XCreateWindow(%d, %d, %d, %d) 0x%lx\n", coff_x, coff_y, dpy_x, dpy_y, xrf);
1281 XMapWindow(dpy, xrf);
1282 XFlush_wr(dpy);
1283 XDestroyWindow(dpy, xrf);
1284 XFlush_wr(dpy);
1285 }
1286 last_xrefresh = dnow();
1287 }
1288
1289 if (now > last_call+1) {
1290 /* we only check these once a second or so. */
1291 int n = 0;
1292
1293 trapped_xerror = 0;
1294 old_handler = XSetErrorHandler(trap_xerror);
1295
1296 while (XCheckTypedEvent(dpy, MappingNotify, &xev)) {
1297 XRefreshKeyboardMapping((XMappingEvent *) &xev);
1298 n++;
1299 }
1300 if (n && use_modifier_tweak) {
1301 X_UNLOCK;
1302 initialize_modtweak();
1303 X_LOCK;
1304 }
1305 if (xtrap_base_event_type) {
1306 int base = xtrap_base_event_type;
1307 while (XCheckTypedEvent(dpy, base, &xev)) {
1308 ;
1309 }
1310 }
1311 if (xtest_base_event_type) {
1312 int base = xtest_base_event_type;
1313 while (XCheckTypedEvent(dpy, base, &xev)) {
1314 ;
1315 }
1316 }
1317 /*
1318 * we can get ClientMessage from our XSendEvent() call in
1319 * selection_request().
1320 */
1321 while (XCheckTypedEvent(dpy, ClientMessage, &xev)) {
1322 ;
1323 }
1324
1325 XSetErrorHandler(old_handler);
1326 trapped_xerror = 0;
1327 last_call = now;
1328 }
1329
1330 if (freeze_when_obscured) {
1331 if (XCheckTypedEvent(dpy, VisibilityNotify, &xev)) {
1332 if (xev.type == VisibilityNotify && xev.xany.window == subwin) {
1333 int prev = subwin_obscured;
1334 if (xev.xvisibility.state == VisibilityUnobscured) {
1335 subwin_obscured = 0;
1336 } else if (xev.xvisibility.state == VisibilityPartiallyObscured) {
1337 subwin_obscured = 1;
1338 } else {
1339 subwin_obscured = 2;
1340 }
1341 rfbLog("subwin_obscured: %d -> %d\n", prev, subwin_obscured);
1342 }
1343 }
1344 }
1345
1346 /* check for CUT_BUFFER0, VNC_CONNECT, X11VNC_REMOTE changes: */
1347 if (XCheckTypedEvent(dpy, PropertyNotify, &xev)) {
1348 int got_cutbuffer = 0;
1349 int got_vnc_connect = 0;
1350 int got_x11vnc_remote = 0;
1351 static int prop_dbg = -1;
1352
1353 /* to avoid piling up between calls, read all PropertyNotify now */
1354 do {
1355 if (xev.type == PropertyNotify) {
1356 if (xev.xproperty.atom == XA_CUT_BUFFER0) {
1357 got_cutbuffer++;
1358 } else if (vnc_connect && vnc_connect_prop != None
1359 && xev.xproperty.atom == vnc_connect_prop) {
1360 got_vnc_connect++;
1361 } else if (vnc_connect && x11vnc_remote_prop != None
1362 && xev.xproperty.atom == x11vnc_remote_prop) {
1363 got_x11vnc_remote++;
1364 }
1365 set_prop_atom(xev.xproperty.atom);
1366 }
1367 } while (XCheckTypedEvent(dpy, PropertyNotify, &xev));
1368
1369 if (prop_dbg < 0) {
1370 prop_dbg = 0;
1371 if (getenv("PROP_DBG")) {
1372 prop_dbg = 1;
1373 }
1374 }
1375
1376 if (prop_dbg && (got_cutbuffer > 1 || got_vnc_connect > 1 || got_x11vnc_remote > 1)) {
1377 static double lastmsg = 0.0;
1378 static int count = 0;
1379 double now = dnow();
1380
1381 if (1 && now > lastmsg + 300.0) {
1382 if (got_cutbuffer > 1) {
1383 rfbLog("check_xevents: warning: %d cutbuffer events since last check.\n", got_cutbuffer);
1384 }
1385 if (got_vnc_connect > 1) {
1386 rfbLog("check_xevents: warning: %d vnc_connect events since last check.\n", got_vnc_connect);
1387 }
1388 if (got_x11vnc_remote > 1) {
1389 rfbLog("check_xevents: warning: %d x11vnc_remote events since last check.\n", got_x11vnc_remote);
1390 }
1391 count++;
1392 if (count >= 3) {
1393 lastmsg = now;
1394 count = 0;
1395 }
1396 }
1397 }
1398
1399 if (got_cutbuffer) {
1400 /*
1401 * Go retrieve CUT_BUFFER0 and send it.
1402 *
1403 * set_cutbuffer is a flag to try to avoid
1404 * processing our own cutbuffer changes.
1405 */
1406 if (have_clients && watch_selection && !set_cutbuffer) {
1407 cutbuffer_send();
1408 sent_some_sel = 1;
1409 }
1410 set_cutbuffer = 0;
1411 }
1412 if (got_vnc_connect) {
1413 /*
1414 * Go retrieve VNC_CONNECT string.
1415 */
1416 read_vnc_connect_prop(0);
1417 }
1418 if (got_x11vnc_remote) {
1419 /*
1420 * Go retrieve X11VNC_REMOTE string.
1421 */
1422 read_x11vnc_remote_prop(0);
1423 }
1424 }
1425
1426 /* do this now that we have just cleared PropertyNotify */
1427 tmp = 0;
1428 if (rfac() < 0.6) {
1429 tmp = 1;
1430 }
1431 if (now > last_time_sync + sync_tod_delay + tmp) {
1432 sync_tod_with_servertime();
1433 last_time_sync = now;
1434 }
1435
1436 #if LIBVNCSERVER_HAVE_LIBXRANDR
1437 if (xrandr || xrandr_maybe) {
1438 check_xrandr_event("check_xevents");
1439 }
1440 #endif
1441 #if LIBVNCSERVER_HAVE_LIBXFIXES
1442 if (xfixes_present && use_xfixes && xfixes_first_initialized && xfixes_base_event_type) {
1443 if (XCheckTypedEvent(dpy, xfixes_base_event_type +
1444 XFixesCursorNotify, &xev)) {
1445 got_xfixes_cursor_notify++;
1446 }
1447 }
1448 #endif
1449
1450 /* check for our PRIMARY request notification: */
1451 if (watch_primary || watch_clipboard) {
1452 int doprimary = 1, doclipboard = 2, which, own = 0;
1453 double delay = 1.0;
1454 Atom atom;
1455 char *req;
1456
1457 if (XCheckTypedEvent(dpy, SelectionNotify, &xev)) {
1458 if (xev.type == SelectionNotify &&
1459 xev.xselection.requestor == selwin &&
1460 xev.xselection.property != None &&
1461 xev.xselection.target == XA_STRING) {
1462 Atom s = xev.xselection.selection;
1463 if (s == XA_PRIMARY || s == clipboard_atom) {
1464 /* go retrieve it and check it */
1465 if (now > last_client + sel_waittime
1466 || sent_some_sel) {
1467 selection_send(&xev);
1468 }
1469 }
1470 }
1471 }
1472 /*
1473 * Every second or so, request PRIMARY or CLIPBOARD,
1474 * unless we already own it or there is no owner or we
1475 * have no clients.
1476 * TODO: even at this low rate we should look into
1477 * and performance problems in odds cases (large text,
1478 * modem, etc.)
1479 */
1480 which = 0;
1481 if (watch_primary && watch_clipboard && ! own_clipboard &&
1482 ! own_primary) {
1483 delay = 0.6;
1484 }
1485 if (dnow() > last_request + delay) {
1486 /*
1487 * It is not a good idea to do both at the same
1488 * time so we must choose one:
1489 */
1490 if (watch_primary && watch_clipboard) {
1491 static int count = 0;
1492 if (own_clipboard) {
1493 which = doprimary;
1494 } else if (own_primary) {
1495 which = doclipboard;
1496 } else if (count++ % 3 == 0) {
1497 which = doclipboard;
1498 } else {
1499 which = doprimary;
1500 }
1501 } else if (watch_primary) {
1502 which = doprimary;
1503 } else if (watch_clipboard) {
1504 which = doclipboard;
1505 }
1506 last_request = dnow();
1507 }
1508 atom = None;
1509 req = "none";
1510 if (which == doprimary) {
1511 own = own_primary;
1512 atom = XA_PRIMARY;
1513 req = "PRIMARY";
1514 } else if (which == doclipboard) {
1515 own = own_clipboard;
1516 atom = clipboard_atom;
1517 req = "CLIPBOARD";
1518 }
1519 if (which != 0 && ! own && have_clients &&
1520 XGetSelectionOwner(dpy, atom) != None && selwin != None) {
1521 XConvertSelection(dpy, atom, XA_STRING, XA_STRING,
1522 selwin, CurrentTime);
1523 if (debug_sel) {
1524 rfbLog("request %s\n", req);
1525 }
1526 }
1527 }
1528
1529 if (own_primary || own_clipboard) {
1530 /* we own PRIMARY or CLIPBOARD, see if someone requested it: */
1531 trapped_xerror = 0;
1532 old_handler = XSetErrorHandler(trap_xerror);
1533
1534 if (XCheckTypedEvent(dpy, SelectionRequest, &xev)) {
1535 if (own_primary && xev.type == SelectionRequest &&
1536 xev.xselectionrequest.selection == XA_PRIMARY) {
1537 selection_request(&xev, "PRIMARY");
1538 }
1539 if (own_clipboard && xev.type == SelectionRequest &&
1540 xev.xselectionrequest.selection == clipboard_atom) {
1541 selection_request(&xev, "CLIPBOARD");
1542 }
1543 }
1544
1545 /* we own PRIMARY or CLIPBOARD, see if we no longer own it: */
1546 if (XCheckTypedEvent(dpy, SelectionClear, &xev)) {
1547 if (own_primary && xev.type == SelectionClear &&
1548 xev.xselectionclear.selection == XA_PRIMARY) {
1549 own_primary = 0;
1550 if (xcut_str_primary) {
1551 free(xcut_str_primary);
1552 xcut_str_primary = NULL;
1553 }
1554 if (debug_sel) {
1555 rfbLog("Released PRIMARY.\n");
1556 }
1557 }
1558 if (own_clipboard && xev.type == SelectionClear &&
1559 xev.xselectionclear.selection == clipboard_atom) {
1560 own_clipboard = 0;
1561 if (xcut_str_clipboard) {
1562 free(xcut_str_clipboard);
1563 xcut_str_clipboard = NULL;
1564 }
1565 if (debug_sel) {
1566 rfbLog("Released CLIPBOARD.\n");
1567 }
1568 }
1569 }
1570
1571 XSetErrorHandler(old_handler);
1572 trapped_xerror = 0;
1573 }
1574
1575 if (watch_bell || now > last_bell+1) {
1576 last_bell = now;
1577 check_bell_event();
1578 }
1579 if (tray_request != None) {
1580 static time_t last_tray_request = 0;
1581 if (now > last_tray_request + 2) {
1582 last_tray_request = now;
1583 if (tray_embed(tray_request, tray_unembed)) {
1584 tray_window = tray_request;
1585 tray_request = None;
1586 }
1587 }
1588 }
1589
1590 #ifndef DEBUG_XEVENTS
1591 #define DEBUG_XEVENTS 1
1592 #endif
1593 #if DEBUG_XEVENTS
1594 if (debug_xevents) {
1595 static time_t last_check = 0;
1596 static time_t reminder = 0;
1597 static int freq = 0;
1598
1599 if (! freq) {
1600 if (getenv("X11VNC_REMINDER_RATE")) {
1601 freq = atoi(getenv("X11VNC_REMINDER_RATE"));
1602 } else {
1603 freq = 300;
1604 }
1605 }
1606
1607 if (now > last_check + 1) {
1608 int ev_type_max = 300, ev_size = 400;
1609 XEvent xevs[400];
1610 int i, tot = XEventsQueued(dpy, QueuedAlready);
1611
1612 if (reminder == 0 || (tot && now > reminder + freq)) {
1613 print_xevent_bases();
1614 reminder = now;
1615 }
1616 last_check = now;
1617
1618 if (tot) {
1619 fprintf(stderr, "Total events queued: %d\n",
1620 tot);
1621 }
1622 for (i=1; i<ev_type_max; i++) {
1623 int k, n = 0;
1624 while (XCheckTypedEvent(dpy, i, xevs+n)) {
1625 if (++n >= ev_size) {
1626 break;
1627 }
1628 }
1629 if (n) {
1630 fprintf(stderr, " %d%s events of type"
1631 " %d queued\n", n,
1632 (n >= ev_size) ? "+" : "", i);
1633 }
1634 for (k=n-1; k >= 0; k--) {
1635 XPutBackEvent(dpy, xevs+k);
1636 }
1637 }
1638 }
1639 }
1640 #endif
1641
1642 if (now > last_sync + 1200) {
1643 /* kludge for any remaining event leaks */
1644 int bugout = use_xdamage ? 500 : 50;
1645 int qlen, i;
1646 if (last_sync != 0) {
1647 qlen = XEventsQueued(dpy, QueuedAlready);
1648 if (qlen >= bugout) {
1649 rfbLog("event leak: %d queued, "
1650 " calling XSync(dpy, True)\n", qlen);
1651 rfbLog(" for diagnostics run: 'x11vnc -R"
1652 " debug_xevents:1'\n");
1653 XSync(dpy, True);
1654 }
1655 }
1656 last_sync = now;
1657
1658 /* clear these, we don't want any events on them */
1659 if (rdpy_ctrl) {
1660 qlen = XEventsQueued(rdpy_ctrl, QueuedAlready);
1661 for (i=0; i<qlen; i++) {
1662 XNextEvent(rdpy_ctrl, &xev);
1663 }
1664 }
1665 if (gdpy_ctrl) {
1666 qlen = XEventsQueued(gdpy_ctrl, QueuedAlready);
1667 for (i=0; i<qlen; i++) {
1668 XNextEvent(gdpy_ctrl, &xev);
1669 }
1670 }
1671 }
1672 X_UNLOCK;
1673
1674 #endif /* NO_X11 */
1675 }
1676
1677 extern int rawfb_vnc_reflect;
1678 /*
1679 * hook called when a VNC client sends us some "XCut" text (rfbClientCutText).
1680 */
xcut_receive(char * text,int len,rfbClientPtr cl)1681 void xcut_receive(char *text, int len, rfbClientPtr cl) {
1682 allowed_input_t input;
1683
1684 if (threads_drop_input) {
1685 return;
1686 }
1687
1688 if (unixpw_in_progress) {
1689 rfbLog("xcut_receive: unixpw_in_progress, skipping.\n");
1690 return;
1691 }
1692
1693 if (!watch_selection) {
1694 return;
1695 }
1696 if (view_only) {
1697 return;
1698 }
1699 if (text == NULL || len == 0) {
1700 return;
1701 }
1702 get_allowed_input(cl, &input);
1703 if (!input.clipboard) {
1704 return;
1705 }
1706 INPUT_LOCK;
1707
1708 if (remote_prefix != NULL && strstr(text, remote_prefix) == text) {
1709 char *result, *rcmd = text + strlen(remote_prefix);
1710 char *tmp = (char *) calloc(len + 8, 1);
1711
1712 if (strstr(rcmd, "cmd=") != rcmd && strstr(rcmd, "qry=") != rcmd) {
1713 strcat(tmp, "qry=");
1714 }
1715 strncat(tmp, rcmd, len - strlen(remote_prefix));
1716 rfbLog("remote_prefix command: '%s'\n", tmp);
1717
1718 if (use_threads) {
1719 if (client_connect_file) {
1720 FILE *f = fopen(client_connect_file, "w");
1721 if (f) {
1722 fprintf(f, "%s\n", tmp);
1723 fclose(f);
1724 free(tmp);
1725 INPUT_UNLOCK;
1726 return;
1727 }
1728 }
1729 if (vnc_connect) {
1730 sprintf(x11vnc_remote_str, "%s", tmp);
1731 free(tmp);
1732 INPUT_UNLOCK;
1733 return;
1734 }
1735 }
1736 INPUT_UNLOCK;
1737
1738
1739 result = process_remote_cmd(tmp, 1);
1740 if (result == NULL ) {
1741 result = strdup("null");
1742 } else if (!strcmp(result, "")) {
1743 free(result);
1744 result = strdup("none");
1745 }
1746 rfbLog("remote_prefix result: '%s'\n", result);
1747
1748 free(tmp);
1749 tmp = (char *) calloc(strlen(remote_prefix) + strlen(result) + 1, 1);
1750
1751 strcat(tmp, remote_prefix);
1752 strcat(tmp, result);
1753 free(result);
1754
1755 rfbSendServerCutText(screen, tmp, strlen(tmp));
1756 free(tmp);
1757
1758 return;
1759 }
1760
1761 if (! check_sel_direction("recv", "xcut_receive", text, len)) {
1762 INPUT_UNLOCK;
1763 return;
1764 }
1765
1766 #ifdef MACOSX
1767 if (macosx_console) {
1768 macosx_set_sel(text, len);
1769 INPUT_UNLOCK;
1770 return;
1771 }
1772 #endif
1773
1774 if (rawfb_vnc_reflect) {
1775 vnc_reflect_send_cuttext(text, len);
1776 INPUT_UNLOCK;
1777 return;
1778 }
1779
1780 RAWFB_RET_VOID
1781
1782 #if NO_X11
1783 INPUT_UNLOCK;
1784 return;
1785 #else
1786
1787 X_LOCK;
1788
1789 /* associate this text with PRIMARY (and SECONDARY...) */
1790 if (set_primary && ! own_primary && selwin != None) {
1791 own_primary = 1;
1792 /* we need to grab the PRIMARY selection */
1793 XSetSelectionOwner(dpy, XA_PRIMARY, selwin, CurrentTime);
1794 XFlush_wr(dpy);
1795 if (debug_sel) {
1796 rfbLog("Own PRIMARY.\n");
1797 }
1798 }
1799
1800 if (set_clipboard && ! own_clipboard && clipboard_atom != None && selwin != None) {
1801 own_clipboard = 1;
1802 /* we need to grab the CLIPBOARD selection */
1803 XSetSelectionOwner(dpy, clipboard_atom, selwin, CurrentTime);
1804 XFlush_wr(dpy);
1805 if (debug_sel) {
1806 rfbLog("Own CLIPBOARD.\n");
1807 }
1808 }
1809
1810 /* duplicate the text string for our own use. */
1811 if (set_primary) {
1812 if (xcut_str_primary != NULL) {
1813 free(xcut_str_primary);
1814 xcut_str_primary = NULL;
1815 }
1816 xcut_str_primary = (char *) malloc((size_t) (len+1));
1817 strncpy(xcut_str_primary, text, len);
1818 xcut_str_primary[len] = '\0'; /* make sure null terminated */
1819 if (debug_sel) {
1820 rfbLog("Set PRIMARY '%s'\n", xcut_str_primary);
1821 }
1822 }
1823 if (set_clipboard) {
1824 if (xcut_str_clipboard != NULL) {
1825 free(xcut_str_clipboard);
1826 xcut_str_clipboard = NULL;
1827 }
1828 xcut_str_clipboard = (char *) malloc((size_t) (len+1));
1829 strncpy(xcut_str_clipboard, text, len);
1830 xcut_str_clipboard[len] = '\0'; /* make sure null terminated */
1831 if (debug_sel) {
1832 rfbLog("Set CLIPBOARD '%s'\n", xcut_str_clipboard);
1833 }
1834 }
1835
1836 /* copy this text to CUT_BUFFER0 as well: */
1837 XChangeProperty(dpy, rootwin, XA_CUT_BUFFER0, XA_STRING, 8,
1838 PropModeReplace, (unsigned char *) text, len);
1839 XFlush_wr(dpy);
1840
1841 X_UNLOCK;
1842 INPUT_UNLOCK;
1843
1844 set_cutbuffer = 1;
1845 #endif /* NO_X11 */
1846 }
1847
kbd_release_all_keys(rfbClientPtr cl)1848 void kbd_release_all_keys(rfbClientPtr cl) {
1849 if (unixpw_in_progress) {
1850 rfbLog("kbd_release_all_keys: unixpw_in_progress, skipping.\n");
1851 return;
1852 }
1853 if (cl->viewOnly) {
1854 return;
1855 }
1856
1857 RAWFB_RET_VOID
1858
1859 #if NO_X11
1860 return;
1861 #else
1862 if (use_threads) {
1863 X_LOCK;
1864 }
1865
1866 clear_keys();
1867 clear_modifiers(0);
1868
1869 if (use_threads) {
1870 X_UNLOCK;
1871 }
1872 #endif
1873 }
1874
set_single_window(rfbClientPtr cl,int x,int y)1875 void set_single_window(rfbClientPtr cl, int x, int y) {
1876 int ok = 0;
1877 if (no_ultra_ext) {
1878 return;
1879 }
1880 if (unixpw_in_progress) {
1881 rfbLog("set_single_window: unixpw_in_progress, dropping client.\n");
1882 rfbCloseClient(cl);
1883 return;
1884 }
1885 if (cl->viewOnly) {
1886 return;
1887 }
1888
1889 RAWFB_RET_VOID
1890
1891 #if NO_X11
1892 return;
1893 #else
1894 if (x==1 && y==1) {
1895 if (subwin) {
1896 subwin = 0x0;
1897 ok = 1;
1898 }
1899 } else {
1900 Window r, c;
1901 int rootx, rooty, wx, wy;
1902 unsigned int mask;
1903
1904 update_x11_pointer_position(x, y);
1905 XSync(dpy, False);
1906
1907 if (XQueryPointer_wr(dpy, rootwin, &r, &c, &rootx, &rooty,
1908 &wx, &wy, &mask)) {
1909 if (c != None) {
1910 subwin = c;
1911 ok = 1;
1912 }
1913 }
1914 }
1915
1916 if (ok) {
1917 check_black_fb();
1918 do_new_fb(1);
1919 }
1920 #endif
1921
1922 }
set_server_input(rfbClientPtr cl,int grab)1923 void set_server_input(rfbClientPtr cl, int grab) {
1924 if (no_ultra_ext) {
1925 return;
1926 }
1927 if (unixpw_in_progress) {
1928 rfbLog("set_server_input: unixpw_in_progress, dropping client.\n");
1929 rfbCloseClient(cl);
1930 return;
1931 }
1932 if (cl->viewOnly) {
1933 return;
1934 }
1935
1936 RAWFB_RET_VOID
1937
1938 #if NO_X11
1939 return;
1940 #else
1941 if (grab) {
1942 if (!no_ultra_dpms) {
1943 set_dpms_mode("enable");
1944 set_dpms_mode("off");
1945 force_dpms = 1;
1946 }
1947
1948 process_remote_cmd("cmd=grabkbd", 0);
1949 process_remote_cmd("cmd=grabptr", 0);
1950
1951 } else {
1952 process_remote_cmd("cmd=nograbkbd", 0);
1953 process_remote_cmd("cmd=nograbptr", 0);
1954
1955 if (!no_ultra_dpms) {
1956 force_dpms = 0;
1957 }
1958 }
1959 #endif
1960 }
1961
1962 static int wsock_timeout_sock = -1;
1963
wsock_timeout(int sig)1964 static void wsock_timeout (int sig) {
1965 rfbLog("sig: %d, wsock_timeout.\n", sig);
1966 if (wsock_timeout_sock >= 0) {
1967 close(wsock_timeout_sock);
1968 wsock_timeout_sock = -1;
1969 }
1970 }
1971
try_local_chat_window(void)1972 static void try_local_chat_window(void) {
1973 int i, port, lsock;
1974 char cmd[100];
1975 struct sockaddr_in addr;
1976 pid_t pid = -1;
1977 #ifdef __hpux
1978 int addrlen = sizeof(addr);
1979 #else
1980 socklen_t addrlen = sizeof(addr);
1981 #endif
1982
1983 for (i = 0; i < 90; i++) {
1984 /* find an open port */
1985 port = 7300 + i;
1986 /* XXX ::1 fallback */
1987 lsock = listen_tcp(port, htonl(INADDR_LOOPBACK), 0);
1988 if (lsock >= 0) {
1989 break;
1990 }
1991 port = 0;
1992 }
1993
1994 if (port == 0) {
1995 return;
1996 }
1997
1998 /* have ssvncvncviewer connect back to us (n.b. sockpair fails) */
1999
2000 sprintf(cmd, "ssvnc -cmd VNC://localhost:%d -chatonly", port);
2001
2002 #if LIBVNCSERVER_HAVE_FORK
2003 pid = fork();
2004 #endif
2005
2006 if (pid == -1) {
2007 perror("fork");
2008 return;
2009 } else if (pid == 0) {
2010 char *args[4];
2011 int d;
2012 args[0] = "/bin/sh";
2013 args[1] = "-c";
2014 /* "ssvnc -cmd VNC://fd=0 -chatonly"; not working */
2015 args[2] = cmd;
2016 args[3] = NULL;
2017
2018 set_env("VNCVIEWER_PASSWORD", "moo");
2019 #if !NO_X11
2020 if (dpy != NULL) {
2021 set_env("DISPLAY", DisplayString(dpy));
2022 }
2023 #endif
2024 for (d = 3; d < 256; d++) {
2025 close(d);
2026 }
2027
2028 execvp(args[0], args);
2029 perror("exec");
2030 exit(1);
2031 } else {
2032 int i, sock = -1;
2033 rfbNewClientHookPtr new_save;
2034
2035 signal(SIGALRM, wsock_timeout);
2036 wsock_timeout_sock = lsock;
2037
2038 alarm(10);
2039 sock = accept(lsock, (struct sockaddr *)&addr, &addrlen);
2040 alarm(0);
2041
2042 signal(SIGALRM, SIG_DFL);
2043 close(lsock);
2044
2045 if (sock < 0) {
2046 return;
2047 }
2048
2049 /* mutex */
2050 new_save = screen->newClientHook;
2051 screen->newClientHook = new_client_chat_helper;
2052
2053 chat_window_client = create_new_client(sock, 1);
2054
2055 screen->newClientHook = new_save;
2056
2057 if (chat_window_client != NULL) {
2058 rfbPasswordCheckProcPtr pwchk_save = screen->passwordCheck;
2059 rfbBool save_shared1 = screen->alwaysShared;
2060 rfbBool save_shared2 = screen->neverShared;
2061
2062 screen->alwaysShared = TRUE;
2063 screen->neverShared = FALSE;
2064
2065 screen->passwordCheck = password_check_chat_helper;
2066 for (i=0; i<30; i++) {
2067 rfbPE(-1);
2068 if (!chat_window_client) {
2069 break;
2070 }
2071 if (chat_window_client->state == RFB_NORMAL) {
2072 break;
2073 }
2074 }
2075
2076 screen->passwordCheck = pwchk_save;
2077 screen->alwaysShared = save_shared1;
2078 screen->neverShared = save_shared2;
2079 }
2080 }
2081 }
2082
set_text_chat(rfbClientPtr cl,int len,char * txt)2083 void set_text_chat(rfbClientPtr cl, int len, char *txt) {
2084 int dochat = 1;
2085 rfbClientIteratorPtr iter;
2086 rfbClientPtr cl2;
2087 unsigned int ulen = (unsigned int) len;
2088
2089 if (no_ultra_ext || ! dochat) {
2090 return;
2091 }
2092
2093 if (unixpw_in_progress) {
2094 rfbLog("set_text_chat: unixpw_in_progress, dropping client.\n");
2095 rfbCloseClient(cl);
2096 return;
2097 }
2098 #if LIBVNCSERVER_HAS_TEXTCHAT
2099
2100 if (chat_window && chat_window_client == NULL && ulen == rfbTextChatOpen) {
2101 try_local_chat_window();
2102 }
2103
2104 saw_ultra_chat = 1;
2105
2106 iter = rfbGetClientIterator(screen);
2107 while( (cl2 = rfbClientIteratorNext(iter)) ) {
2108 unsigned int ulen = (unsigned int) len;
2109 if (cl2 == cl) {
2110 continue;
2111 }
2112 if (cl2->state != RFB_NORMAL) {
2113 continue;
2114 }
2115
2116 SEND_LOCK(cl2);
2117
2118 if (ulen == rfbTextChatOpen) {
2119 rfbSendTextChatMessage(cl2, rfbTextChatOpen, "");
2120 } else if (ulen == rfbTextChatClose) {
2121 rfbSendTextChatMessage(cl2, rfbTextChatClose, "");
2122 /* not clear what is going on WRT close and finished... */
2123 rfbSendTextChatMessage(cl2, rfbTextChatFinished, "");
2124 } else if (ulen == rfbTextChatFinished) {
2125 rfbSendTextChatMessage(cl2, rfbTextChatFinished, "");
2126 } else if (len <= rfbTextMaxSize) {
2127 rfbSendTextChatMessage(cl2, len, txt);
2128 }
2129
2130 SEND_UNLOCK(cl2);
2131 }
2132 rfbReleaseClientIterator(iter);
2133
2134 if (ulen == rfbTextChatClose && cl != NULL) {
2135 /* not clear what is going on WRT close and finished... */
2136 SEND_LOCK(cl);
2137 rfbSendTextChatMessage(cl, rfbTextChatFinished, "");
2138 SEND_UNLOCK(cl);
2139 }
2140 #endif
2141 }
2142
get_keyboard_led_state_hook(rfbScreenInfoPtr s)2143 int get_keyboard_led_state_hook(rfbScreenInfoPtr s) {
2144 if (s) {}
2145 if (unixpw_in_progress) {
2146 rfbLog("get_keyboard_led_state_hook: unixpw_in_progress, skipping.\n");
2147 return 0;
2148 }
2149 return 0;
2150 }
get_file_transfer_permitted(rfbClientPtr cl)2151 int get_file_transfer_permitted(rfbClientPtr cl) {
2152 allowed_input_t input;
2153 if (unixpw_in_progress) {
2154 rfbLog("get_file_transfer_permitted: unixpw_in_progress, dropping client.\n");
2155 rfbCloseClient(cl);
2156 return FALSE;
2157 }
2158 if (0) fprintf(stderr, "get_file_transfer_permitted called\n");
2159 if (view_only) {
2160 return FALSE;
2161 }
2162 if (cl->viewOnly) {
2163 return FALSE;
2164 }
2165 get_allowed_input(cl, &input);
2166 if (!input.files) {
2167 return FALSE;
2168 }
2169 if (screen->permitFileTransfer) {
2170 saw_ultra_file = 1;
2171 }
2172 return screen->permitFileTransfer;
2173 }
2174
2175
2176