1 /* 2 Copyright (C) 2002-2010 Karl J. Runge <runge (at) 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 /* -- win_utils.c -- */ 34 35 #include "x11vnc.h" 36 #include "xinerama.h" 37 #include "winattr_t.h" 38 #include "cleanup.h" 39 #include "xwrappers.h" 40 #include "connections.h" 41 #include "xrandr.h" 42 #include "macosx.h" 43 44 winattr_t *stack_list = NULL; 45 int stack_list_len = 0; 46 int stack_list_num = 0; 47 48 49 Window parent_window(Window win, char **name); 50 int valid_window(Window win, XWindowAttributes *attr_ret, int bequiet); 51 Bool xtranslate(Window src, Window dst, int src_x, int src_y, int *dst_x, 52 int *dst_y, Window *child, int bequiet); 53 int get_window_size(Window win, int *w, int *h); 54 void snapshot_stack_list(int free_only, double allowed_age); 55 int get_boff(void); 56 int get_bwin(void); 57 void update_stack_list(void); 58 Window query_pointer(Window start); 59 unsigned int mask_state(void); 60 int pick_windowid(unsigned long *num); 61 Window descend_pointer(int depth, Window start, char *name_info, int len); 62 void id_cmd(char *cmd); 63 64 65 Window parent_window(Window win, char **name) { 66 #if !NO_X11 67 Window r, parent; 68 Window *list; 69 XErrorHandler old_handler; 70 unsigned int nchild; 71 int rc; 72 #endif 73 74 if (name != NULL) { 75 *name = NULL; 76 } 77 RAWFB_RET(None) 78 #if NO_X11 79 nox11_exit(1); 80 if (!name || !win) {} 81 return None; 82 #else 83 84 old_handler = XSetErrorHandler(trap_xerror); 85 trapped_xerror = 0; 86 rc = XQueryTree_wr(dpy, win, &r, &parent, &list, &nchild); 87 XSetErrorHandler(old_handler); 88 89 if (! rc || trapped_xerror) { 90 trapped_xerror = 0; 91 return None; 92 } 93 trapped_xerror = 0; 94 95 if (list) { 96 XFree_wr(list); 97 } 98 if (parent && name) { 99 XFetchName(dpy, parent, name); 100 } 101 return parent; 102 #endif /* NO_X11 */ 103 } 104 105 /* trapping utility to check for a valid window: */ 106 int valid_window(Window win, XWindowAttributes *attr_ret, int bequiet) { 107 XWindowAttributes attr, *pattr; 108 #if !NO_X11 109 XErrorHandler old_handler; 110 int ok = 0; 111 #endif 112 113 if (attr_ret == NULL) { 114 pattr = &attr; 115 } else { 116 pattr = attr_ret; 117 } 118 119 if (win == None) { 120 return 0; 121 } 122 123 #ifdef MACOSX 124 if (macosx_console) { 125 return macosx_valid_window(win, attr_ret); 126 } 127 #endif 128 129 RAWFB_RET(0) 130 131 #if NO_X11 132 nox11_exit(1); 133 if (!win || !attr_ret || !bequiet) {} 134 return 0; 135 #else 136 137 old_handler = XSetErrorHandler(trap_xerror); 138 trapped_xerror = 0; 139 if (XGetWindowAttributes(dpy, win, pattr)) { 140 ok = 1; 141 } 142 if (trapped_xerror && trapped_xerror_event) { 143 if (! quiet && ! bequiet) { 144 rfbLog("valid_window: trapped XError: %s (0x%lx)\n", 145 xerror_string(trapped_xerror_event), win); 146 } 147 ok = 0; 148 } 149 XSetErrorHandler(old_handler); 150 trapped_xerror = 0; 151 152 return ok; 153 #endif /* NO_X11 */ 154 } 155 156 Bool xtranslate(Window src, Window dst, int src_x, int src_y, int *dst_x, 157 int *dst_y, Window *child, int bequiet) { 158 XErrorHandler old_handler = NULL; 159 Bool ok = False; 160 161 RAWFB_RET(False) 162 #if NO_X11 163 nox11_exit(1); 164 if (!src || !dst || !src_x || !src_y || !dst_x || !dst_y || !child || !bequiet) {} 165 if (!old_handler || !ok) {} 166 return False; 167 #else 168 169 trapped_xerror = 0; 170 old_handler = XSetErrorHandler(trap_xerror); 171 if (XTranslateCoordinates(dpy, src, dst, src_x, src_y, dst_x, 172 dst_y, child)) { 173 ok = True; 174 } 175 if (trapped_xerror && trapped_xerror_event) { 176 if (! quiet && ! bequiet) { 177 rfbLog("xtranslate: trapped XError: %s (0x%lx)\n", 178 xerror_string(trapped_xerror_event), src); 179 } 180 ok = False; 181 } 182 XSetErrorHandler(old_handler); 183 trapped_xerror = 0; 184 185 return ok; 186 #endif /* NO_X11 */ 187 } 188 189 int get_window_size(Window win, int *w, int *h) { 190 XWindowAttributes attr; 191 /* valid_window? */ 192 if (valid_window(win, &attr, 1)) { 193 *w = attr.width; 194 *h = attr.height; 195 return 1; 196 } else { 197 return 0; 198 } 199 } 200 201 /* 202 * For use in the -wireframe stuff, save the stacking order of the direct 203 * children of the root window. Ideally done before we send ButtonPress 204 * to the X server. 205 */ 206 void snapshot_stack_list(int free_only, double allowed_age) { 207 static double last_snap = 0.0, last_free = 0.0; 208 double now; 209 int num, rc, i, j; 210 unsigned int ui; 211 Window r, w; 212 Window *list; 213 214 if (! stack_list) { 215 stack_list = (winattr_t *) malloc(256*sizeof(winattr_t)); 216 stack_list_num = 0; 217 stack_list_len = 256; 218 } 219 220 dtime0(&now); 221 if (free_only) { 222 /* we really don't free it, just reset to zero windows */ 223 stack_list_num = 0; 224 last_free = now; 225 return; 226 } 227 228 if (stack_list_num && now < last_snap + allowed_age) { 229 return; 230 } 231 232 stack_list_num = 0; 233 last_free = now; 234 235 #ifdef MACOSX 236 if (! macosx_console) { 237 RAWFB_RET_VOID 238 } 239 #else 240 RAWFB_RET_VOID 241 #endif 242 243 #if NO_X11 && !defined(MACOSX) 244 num = rc = i = j = 0; /* compiler warnings */ 245 ui = 0; 246 r = w = None; 247 list = NULL; 248 return; 249 #else 250 251 X_LOCK; 252 /* no need to trap error since rootwin */ 253 rc = XQueryTree_wr(dpy, rootwin, &r, &w, &list, &ui); 254 num = (int) ui; 255 256 if (! rc) { 257 stack_list_num = 0; 258 last_free = now; 259 last_snap = 0.0; 260 X_UNLOCK; 261 return; 262 } 263 264 last_snap = now; 265 if (num > stack_list_len + blackouts) { 266 int n = 2*num; 267 free(stack_list); 268 stack_list = (winattr_t *) malloc(n*sizeof(winattr_t)); 269 stack_list_len = n; 270 } 271 j = 0; 272 for (i=0; i<num; i++) { 273 stack_list[j].win = list[i]; 274 stack_list[j].fetched = 0; 275 stack_list[j].valid = 0; 276 stack_list[j].time = now; 277 j++; 278 } 279 for (i=0; i<blackouts; i++) { 280 stack_list[j].win = get_boff() + 1; 281 stack_list[j].fetched = 1; 282 stack_list[j].valid = 1; 283 stack_list[j].x = blackr[i].x1; 284 stack_list[j].y = blackr[i].y1; 285 stack_list[j].width = blackr[i].x2 - blackr[i].x1; 286 stack_list[j].height = blackr[i].y2 - blackr[i].y1; 287 stack_list[j].time = now; 288 stack_list[j].map_state = IsViewable; 289 stack_list[j].rx = -1; 290 stack_list[j].ry = -1; 291 j++; 292 293 if (0) fprintf(stderr, "blackr: %d %dx%d+%d+%d\n", i, 294 stack_list[j-1].width, stack_list[j-1].height, 295 stack_list[j-1].x, stack_list[j-1].y); 296 297 } 298 stack_list_num = num + blackouts; 299 if (debug_wireframe > 1) { 300 fprintf(stderr, "snapshot_stack_list: num=%d len=%d\n", 301 stack_list_num, stack_list_len); 302 } 303 304 XFree_wr(list); 305 X_UNLOCK; 306 #endif /* NO_X11 */ 307 } 308 309 int get_boff(void) { 310 if (macosx_console) { 311 return 0x1000000; 312 } else { 313 return 0; 314 } 315 } 316 317 int get_bwin(void) { 318 return 10; 319 } 320 321 void update_stack_list(void) { 322 int k; 323 double now; 324 XWindowAttributes attr; 325 int boff, bwin; 326 327 if (! stack_list) { 328 return; 329 } 330 if (! stack_list_num) { 331 return; 332 } 333 334 dtime0(&now); 335 336 boff = get_boff(); 337 bwin = get_bwin(); 338 339 X_LOCK; 340 for (k=0; k < stack_list_num; k++) { 341 Window win = stack_list[k].win; 342 if (win != None && boff <= (int) win && (int) win < boff + bwin) { 343 ; /* special, blackout */ 344 } else if (!valid_window(win, &attr, 1)) { 345 stack_list[k].valid = 0; 346 } else { 347 stack_list[k].valid = 1; 348 stack_list[k].x = attr.x; 349 stack_list[k].y = attr.y; 350 stack_list[k].width = attr.width; 351 stack_list[k].height = attr.height; 352 stack_list[k].border_width = attr.border_width; 353 stack_list[k].depth = attr.depth; 354 stack_list[k].class = attr.class; 355 stack_list[k].backing_store = attr.backing_store; 356 stack_list[k].map_state = attr.map_state; 357 358 /* root_x, root_y not used for stack_list usage: */ 359 stack_list[k].rx = -1; 360 stack_list[k].ry = -1; 361 } 362 stack_list[k].fetched = 1; 363 stack_list[k].time = now; 364 } 365 X_UNLOCK; 366 if (0) fprintf(stderr, "update_stack_list[%d]: %.4f %.4f\n", stack_list_num, now - x11vnc_start, dtime(&now)); 367 } 368 369 Window query_pointer(Window start) { 370 int rx, ry; 371 #if !NO_X11 372 Window r, c; /* compiler warnings */ 373 int wx, wy; 374 unsigned int mask; 375 #endif 376 377 #ifdef MACOSX 378 if (macosx_console) { 379 macosx_get_cursor_pos(&rx, &ry); 380 } 381 #endif 382 383 RAWFB_RET(None) 384 385 #if NO_X11 386 if (!start) { rx = ry = 0; } 387 return None; 388 #else 389 if (start == None) { 390 start = rootwin; 391 } 392 if (XQueryPointer_wr(dpy, start, &r, &c, &rx, &ry, &wx, &wy, &mask)) { 393 return c; 394 } else { 395 return None; 396 } 397 #endif /* NO_X11 */ 398 } 399 400 unsigned int mask_state(void) { 401 #if NO_X11 402 RAWFB_RET(0) 403 return 0; 404 #else 405 Window r, c; 406 int rx, ry, wx, wy; 407 unsigned int mask; 408 409 RAWFB_RET(0) 410 411 if (XQueryPointer_wr(dpy, rootwin, &r, &c, &rx, &ry, &wx, &wy, &mask)) { 412 return mask; 413 } else { 414 return 0; 415 } 416 #endif /* NO_X11 */ 417 } 418 419 int pick_windowid(unsigned long *num) { 420 char line[512]; 421 int ok = 0, n = 0, msec = 10, secmax = 15; 422 FILE *p; 423 424 RAWFB_RET(0) 425 426 if (use_dpy) { 427 set_env("DISPLAY", use_dpy); 428 } 429 /* id */ 430 if (no_external_cmds || !cmd_ok("id")) { 431 rfbLogEnable(1); 432 rfbLog("cannot run external commands in -nocmds mode:\n"); 433 rfbLog(" \"%s\"\n", "xwininfo"); 434 rfbLog(" exiting.\n"); 435 clean_up_exit(1); 436 } 437 close_exec_fds(); 438 p = popen("xwininfo", "r"); 439 440 if (! p) { 441 return 0; 442 } 443 444 fprintf(stderr, "\n"); 445 fprintf(stderr, " Please select the window for x11vnc to poll\n"); 446 fprintf(stderr, " by clicking the mouse in that window.\n"); 447 fprintf(stderr, "\n"); 448 449 while (msec * n++ < 1000 * secmax) { 450 unsigned long tmp; 451 char *q; 452 fd_set set; 453 struct timeval tv; 454 455 if (screen && screen->clientHead) { 456 /* they may be doing the pointer-pick thru vnc: */ 457 int nfds; 458 tv.tv_sec = 0; 459 tv.tv_usec = msec * 1000; 460 FD_ZERO(&set); 461 FD_SET(fileno(p), &set); 462 463 nfds = select(fileno(p)+1, &set, NULL, NULL, &tv); 464 465 if (nfds == 0 || nfds < 0) { 466 /* 467 * select timedout or error. 468 * note this rfbPE takes about 30ms too: 469 */ 470 rfbPE(-1); 471 XFlush_wr(dpy); 472 continue; 473 } 474 } 475 476 if (fgets(line, 512, p) == NULL) { 477 break; 478 } 479 q = strstr(line, " id: 0x"); 480 if (q) { 481 q += 5; 482 if (sscanf(q, "0x%lx ", &tmp) == 1) { 483 ok = 1; 484 *num = tmp; 485 fprintf(stderr, " Picked: 0x%lx\n\n", tmp); 486 break; 487 } 488 } 489 } 490 pclose(p); 491 return ok; 492 } 493 494 Window descend_pointer(int depth, Window start, char *name_info, int len) { 495 #if NO_X11 496 RAWFB_RET(None) 497 if (!depth || !start || !name_info || !len) {} 498 return None; 499 #else 500 Window r, c, clast = None; 501 int i, rx, ry, wx, wy; 502 int written = 0, filled = 0; 503 char *store = NULL; 504 unsigned int m; 505 static XClassHint *classhint = NULL; 506 static char *nm_cache = NULL; 507 static int nm_cache_len = 0; 508 static Window prev_start = None; 509 510 RAWFB_RET(None) 511 512 if (! classhint) { 513 classhint = XAllocClassHint(); 514 } 515 516 if (! nm_cache) { 517 nm_cache = (char *) malloc(1024); 518 nm_cache_len = 1024; 519 nm_cache[0] = '\0'; 520 } 521 if (name_info && nm_cache_len < len) { 522 if (nm_cache) { 523 free(nm_cache); 524 } 525 nm_cache_len = 2*len; 526 nm_cache = (char *) malloc(nm_cache_len); 527 } 528 529 if (name_info) { 530 if (start != None && start == prev_start) { 531 store = NULL; 532 strncpy(name_info, nm_cache, len); 533 } else { 534 store = name_info; 535 name_info[0] = '\0'; 536 } 537 } 538 539 if (start != None) { 540 c = start; 541 if (name_info) { 542 prev_start = start; 543 } 544 } else { 545 c = rootwin; 546 } 547 548 for (i=0; i<depth; i++) { 549 clast = c; 550 if (store && ! filled) { 551 char *name; 552 if (XFetchName(dpy, clast, &name) && name != NULL) { 553 int l = strlen(name); 554 if (written + l+2 < len) { 555 strcat(store, "^^"); 556 written += 2; 557 strcat(store, name); 558 written += l; 559 } else { 560 filled = 1; 561 } 562 XFree_wr(name); 563 } 564 } 565 if (store && classhint && ! filled) { 566 classhint->res_name = NULL; 567 classhint->res_class = NULL; 568 if (XGetClassHint(dpy, clast, classhint)) { 569 int l = 0; 570 if (classhint->res_class) { 571 l += strlen(classhint->res_class); 572 } 573 if (classhint->res_name) { 574 l += strlen(classhint->res_name); 575 } 576 if (written + l+4 < len) { 577 strcat(store, "##"); 578 if (classhint->res_class) { 579 strcat(store, 580 classhint->res_class); 581 } 582 strcat(store, "++"); 583 if (classhint->res_name) { 584 strcat(store, 585 classhint->res_name); 586 } 587 written += l+4; 588 } else { 589 filled = 1; 590 } 591 if (classhint->res_class) { 592 XFree_wr(classhint->res_class); 593 } 594 if (classhint->res_name) { 595 XFree_wr(classhint->res_name); 596 } 597 } 598 } 599 if (! XQueryPointer_wr(dpy, c, &r, &c, &rx, &ry, &wx, &wy, &m)) { 600 break; 601 } 602 if (! c) { 603 break; 604 } 605 } 606 if (start != None && name_info) { 607 strncpy(nm_cache, name_info, nm_cache_len); 608 } 609 610 return clast; 611 #endif /* NO_X11 */ 612 } 613 614 void id_cmd(char *cmd) { 615 int rc, dx = 0, dy = 0, dw = 0, dh = 0; 616 int x0, y0, w0, h0; 617 int x, y, w, h, do_move = 0, do_resize = 0; 618 int disp_x = DisplayWidth(dpy, scr); 619 int disp_y = DisplayHeight(dpy, scr); 620 Window win = subwin; 621 XWindowAttributes attr; 622 XErrorHandler old_handler = NULL; 623 Window twin; 624 625 if (!cmd || !strcmp(cmd, "")) { 626 return; 627 } 628 if (strstr(cmd, "win=") == cmd) { 629 if (! scan_hexdec(cmd + strlen("win="), &win)) { 630 rfbLog("id_cmd: incorrect win= hex/dec number: %s\n", cmd); 631 return; 632 } else { 633 char *q = strchr(cmd, ':'); 634 if (!q) { 635 rfbLog("id_cmd: incorrect win=...: hex/dec number: %s\n", cmd); 636 return; 637 } 638 rfbLog("id_cmd:%s set window id to 0x%lx\n", cmd, win); 639 cmd = q+1; 640 } 641 } 642 if (!win) { 643 rfbLog("id_cmd:%s not in sub-window mode or no win=0xNNNN.\n", cmd); 644 return; 645 } 646 #if !NO_X11 647 X_LOCK; 648 if (!valid_window(win, &attr, 1)) { 649 X_UNLOCK; 650 return; 651 } 652 w0 = w = attr.width; 653 h0 = h = attr.height; 654 old_handler = XSetErrorHandler(trap_xerror); 655 trapped_xerror = 0; 656 XTranslateCoordinates(dpy, win, rootwin, 0, 0, &x, &y, &twin); 657 x0 = x; 658 y0 = y; 659 if (strstr(cmd, "move:") == cmd) { 660 if (sscanf(cmd, "move:%d%d", &dx, &dy) == 2) { 661 x = x + dx; 662 y = y + dy; 663 do_move = 1; 664 } 665 } else if (strstr(cmd, "resize:") == cmd) { 666 if (sscanf(cmd, "resize:%d%d", &dw, &dh) == 2) { 667 w = w + dw; 668 h = h + dh; 669 do_move = 1; 670 do_resize = 1; 671 } 672 } else if (strstr(cmd, "geom:") == cmd) { 673 if (parse_geom(cmd+strlen("geom:"), &w, &h, &x, &y, disp_x, disp_y)) { 674 do_move = 1; 675 do_resize = 1; 676 if (w <= 0) { 677 w = w0; 678 } 679 if (h <= 0) { 680 h = h0; 681 } 682 if (scaling && getenv("X11VNC_APPSHARE_ACTIVE")) { 683 x /= scale_fac_x; 684 y /= scale_fac_y; 685 } 686 } 687 } else if (!strcmp(cmd, "raise")) { 688 rc = XRaiseWindow(dpy, win); 689 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 690 } else if (!strcmp(cmd, "lower")) { 691 rc = XLowerWindow(dpy, win); 692 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 693 } else if (!strcmp(cmd, "map")) { 694 rc= XMapRaised(dpy, win); 695 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 696 } else if (!strcmp(cmd, "unmap")) { 697 rc= XUnmapWindow(dpy, win); 698 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 699 } else if (!strcmp(cmd, "iconify")) { 700 rc= XIconifyWindow(dpy, win, scr); 701 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 702 } else if (strstr(cmd, "wm_name:") == cmd) { 703 rc= XStoreName(dpy, win, cmd+strlen("wm_name:")); 704 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 705 } else if (strstr(cmd, "icon_name:") == cmd) { 706 rc= XSetIconName(dpy, win, cmd+strlen("icon_name:")); 707 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 708 } else if (!strcmp(cmd, "wm_delete")) { 709 XClientMessageEvent ev; 710 memset(&ev, 0, sizeof(ev)); 711 ev.type = ClientMessage; 712 ev.send_event = True; 713 ev.display = dpy; 714 ev.window = win; 715 ev.message_type = XInternAtom(dpy, "WM_PROTOCOLS", False); 716 ev.format = 32; 717 ev.data.l[0] = XInternAtom(dpy, "WM_DELETE_WINDOW", False); 718 rc = XSendEvent(dpy, win, False, 0, (XEvent *) &ev); 719 rfbLog("id_cmd:%s rc=%d\n", cmd, rc); 720 } else { 721 rfbLog("id_cmd:%s unrecognized command.\n", cmd); 722 } 723 if (do_move || do_resize) { 724 if (w >= disp_x) { 725 w = disp_x - 4; 726 } 727 if (h >= disp_y) { 728 h = disp_y - 4; 729 } 730 if (w < 1) { 731 w = 1; 732 } 733 if (h < 1) { 734 h = 1; 735 } 736 if (x + w > disp_x) { 737 x = disp_x - w - 1; 738 } 739 if (y + h > disp_y) { 740 y = disp_y - h - 1; 741 } 742 if (x < 0) { 743 x = 1; 744 } 745 if (y < 0) { 746 y = 1; 747 } 748 rc = 0; 749 rc += XMoveWindow(dpy, win, x, y); 750 off_x = x; 751 off_y = y; 752 753 rc += XResizeWindow(dpy, win, w, h); 754 755 rfbLog("id_cmd:%s rc=%d dx=%d dy=%d dw=%d dh=%d %dx%d+%d+%d -> %dx%d+%d+%d\n", 756 cmd, rc, dx, dy, dw, dh, w0, h0, x0, y0, w, h, x, h); 757 } 758 XSync(dpy, False); 759 XSetErrorHandler(old_handler); 760 if (trapped_xerror) { 761 rfbLog("id_cmd:%s trapped_xerror.\n", cmd); 762 } 763 trapped_xerror = 0; 764 if (do_resize) { 765 rfbLog("id_cmd:%s calling check_xrandr_event.\n", cmd); 766 check_xrandr_event("id_cmd"); 767 } 768 X_UNLOCK; 769 #endif 770 } 771 772
