1 /* $OpenBSD: server-client.c,v 1.264 2018/12/18 13:20:44 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 #include <sys/ioctl.h> 21 #include <sys/uio.h> 22 23 #include <errno.h> 24 #include <event.h> 25 #include <fcntl.h> 26 #include <imsg.h> 27 #include <paths.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <time.h> 31 #include <unistd.h> 32 33 #include "tmux.h" 34 35 static void server_client_free(int, short, void *); 36 static void server_client_check_focus(struct window_pane *); 37 static void server_client_check_resize(struct window_pane *); 38 static key_code server_client_check_mouse(struct client *); 39 static void server_client_repeat_timer(int, short, void *); 40 static void server_client_click_timer(int, short, void *); 41 static void server_client_check_exit(struct client *); 42 static void server_client_check_redraw(struct client *); 43 static void server_client_set_title(struct client *); 44 static void server_client_reset_state(struct client *); 45 static int server_client_assume_paste(struct session *); 46 static void server_client_clear_identify(struct client *, 47 struct window_pane *); 48 49 static void server_client_dispatch(struct imsg *, void *); 50 static void server_client_dispatch_command(struct client *, struct imsg *); 51 static void server_client_dispatch_identify(struct client *, struct imsg *); 52 static void server_client_dispatch_shell(struct client *); 53 54 /* Number of attached clients. */ 55 u_int 56 server_client_how_many(void) 57 { 58 struct client *c; 59 u_int n; 60 61 n = 0; 62 TAILQ_FOREACH(c, &clients, entry) { 63 if (c->session != NULL && (~c->flags & CLIENT_DETACHING)) 64 n++; 65 } 66 return (n); 67 } 68 69 /* Identify mode callback. */ 70 static void 71 server_client_callback_identify(__unused int fd, __unused short events, 72 void *data) 73 { 74 server_client_clear_identify(data, NULL); 75 } 76 77 /* Set identify mode on client. */ 78 void 79 server_client_set_identify(struct client *c, u_int delay) 80 { 81 struct timeval tv; 82 83 tv.tv_sec = delay / 1000; 84 tv.tv_usec = (delay % 1000) * 1000L; 85 86 if (event_initialized(&c->identify_timer)) 87 evtimer_del(&c->identify_timer); 88 evtimer_set(&c->identify_timer, server_client_callback_identify, c); 89 if (delay != 0) 90 evtimer_add(&c->identify_timer, &tv); 91 92 c->flags |= CLIENT_IDENTIFY; 93 c->tty.flags |= (TTY_FREEZE|TTY_NOCURSOR); 94 server_redraw_client(c); 95 } 96 97 /* Clear identify mode on client. */ 98 static void 99 server_client_clear_identify(struct client *c, struct window_pane *wp) 100 { 101 if (~c->flags & CLIENT_IDENTIFY) 102 return; 103 c->flags &= ~CLIENT_IDENTIFY; 104 105 if (c->identify_callback != NULL) 106 c->identify_callback(c, wp); 107 108 c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR); 109 server_redraw_client(c); 110 } 111 112 /* Check if this client is inside this server. */ 113 int 114 server_client_check_nested(struct client *c) 115 { 116 struct environ_entry *envent; 117 struct window_pane *wp; 118 119 envent = environ_find(c->environ, "TMUX"); 120 if (envent == NULL || *envent->value == '\0') 121 return (0); 122 123 RB_FOREACH(wp, window_pane_tree, &all_window_panes) { 124 if (strcmp(wp->tty, c->ttyname) == 0) 125 return (1); 126 } 127 return (0); 128 } 129 130 /* Set client key table. */ 131 void 132 server_client_set_key_table(struct client *c, const char *name) 133 { 134 if (name == NULL) 135 name = server_client_get_key_table(c); 136 137 key_bindings_unref_table(c->keytable); 138 c->keytable = key_bindings_get_table(name, 1); 139 c->keytable->references++; 140 } 141 142 /* Get default key table. */ 143 const char * 144 server_client_get_key_table(struct client *c) 145 { 146 struct session *s = c->session; 147 const char *name; 148 149 if (s == NULL) 150 return ("root"); 151 152 name = options_get_string(s->options, "key-table"); 153 if (*name == '\0') 154 return ("root"); 155 return (name); 156 } 157 158 /* Is this table the default key table? */ 159 static int 160 server_client_is_default_key_table(struct client *c, struct key_table *table) 161 { 162 return (strcmp(table->name, server_client_get_key_table(c)) == 0); 163 } 164 165 /* Create a new client. */ 166 struct client * 167 server_client_create(int fd) 168 { 169 struct client *c; 170 171 setblocking(fd, 0); 172 173 c = xcalloc(1, sizeof *c); 174 c->references = 1; 175 c->peer = proc_add_peer(server_proc, fd, server_client_dispatch, c); 176 177 if (gettimeofday(&c->creation_time, NULL) != 0) 178 fatal("gettimeofday failed"); 179 memcpy(&c->activity_time, &c->creation_time, sizeof c->activity_time); 180 181 c->environ = environ_create(); 182 183 c->fd = -1; 184 c->cwd = NULL; 185 186 TAILQ_INIT(&c->queue); 187 188 c->stdin_data = evbuffer_new(); 189 if (c->stdin_data == NULL) 190 fatalx("out of memory"); 191 c->stdout_data = evbuffer_new(); 192 if (c->stdout_data == NULL) 193 fatalx("out of memory"); 194 c->stderr_data = evbuffer_new(); 195 if (c->stderr_data == NULL) 196 fatalx("out of memory"); 197 198 c->tty.fd = -1; 199 c->title = NULL; 200 201 c->session = NULL; 202 c->last_session = NULL; 203 204 c->tty.sx = 80; 205 c->tty.sy = 24; 206 207 screen_init(&c->status.status, c->tty.sx, 1, 0); 208 209 c->message_string = NULL; 210 TAILQ_INIT(&c->message_log); 211 212 c->prompt_string = NULL; 213 c->prompt_buffer = NULL; 214 c->prompt_index = 0; 215 216 c->flags |= CLIENT_FOCUSED; 217 218 c->keytable = key_bindings_get_table("root", 1); 219 c->keytable->references++; 220 221 evtimer_set(&c->repeat_timer, server_client_repeat_timer, c); 222 evtimer_set(&c->click_timer, server_client_click_timer, c); 223 224 TAILQ_INSERT_TAIL(&clients, c, entry); 225 log_debug("new client %p", c); 226 return (c); 227 } 228 229 /* Open client terminal if needed. */ 230 int 231 server_client_open(struct client *c, char **cause) 232 { 233 if (c->flags & CLIENT_CONTROL) 234 return (0); 235 236 if (strcmp(c->ttyname, "/dev/tty") == 0) { 237 *cause = xstrdup("can't use /dev/tty"); 238 return (-1); 239 } 240 241 if (!(c->flags & CLIENT_TERMINAL)) { 242 *cause = xstrdup("not a terminal"); 243 return (-1); 244 } 245 246 if (tty_open(&c->tty, cause) != 0) 247 return (-1); 248 249 return (0); 250 } 251 252 /* Lost a client. */ 253 void 254 server_client_lost(struct client *c) 255 { 256 struct message_entry *msg, *msg1; 257 258 c->flags |= CLIENT_DEAD; 259 260 server_client_clear_identify(c, NULL); 261 status_prompt_clear(c); 262 status_message_clear(c); 263 264 if (c->stdin_callback != NULL) 265 c->stdin_callback(c, 1, c->stdin_callback_data); 266 267 TAILQ_REMOVE(&clients, c, entry); 268 log_debug("lost client %p", c); 269 270 /* 271 * If CLIENT_TERMINAL hasn't been set, then tty_init hasn't been called 272 * and tty_free might close an unrelated fd. 273 */ 274 if (c->flags & CLIENT_TERMINAL) 275 tty_free(&c->tty); 276 free(c->ttyname); 277 free(c->term); 278 279 evbuffer_free(c->stdin_data); 280 evbuffer_free(c->stdout_data); 281 if (c->stderr_data != c->stdout_data) 282 evbuffer_free(c->stderr_data); 283 284 if (event_initialized(&c->status.timer)) 285 evtimer_del(&c->status.timer); 286 screen_free(&c->status.status); 287 if (c->status.old_status != NULL) { 288 screen_free(c->status.old_status); 289 free(c->status.old_status); 290 } 291 292 free(c->title); 293 free((void *)c->cwd); 294 295 evtimer_del(&c->repeat_timer); 296 evtimer_del(&c->click_timer); 297 298 key_bindings_unref_table(c->keytable); 299 300 if (event_initialized(&c->identify_timer)) 301 evtimer_del(&c->identify_timer); 302 303 free(c->message_string); 304 if (event_initialized(&c->message_timer)) 305 evtimer_del(&c->message_timer); 306 TAILQ_FOREACH_SAFE(msg, &c->message_log, entry, msg1) { 307 free(msg->msg); 308 TAILQ_REMOVE(&c->message_log, msg, entry); 309 free(msg); 310 } 311 312 free(c->prompt_saved); 313 free(c->prompt_string); 314 free(c->prompt_buffer); 315 316 format_lost_client(c); 317 environ_free(c->environ); 318 319 proc_remove_peer(c->peer); 320 c->peer = NULL; 321 322 server_client_unref(c); 323 324 server_add_accept(0); /* may be more file descriptors now */ 325 326 recalculate_sizes(); 327 server_check_unattached(); 328 server_update_socket(); 329 } 330 331 /* Remove reference from a client. */ 332 void 333 server_client_unref(struct client *c) 334 { 335 log_debug("unref client %p (%d references)", c, c->references); 336 337 c->references--; 338 if (c->references == 0) 339 event_once(-1, EV_TIMEOUT, server_client_free, c, NULL); 340 } 341 342 /* Free dead client. */ 343 static void 344 server_client_free(__unused int fd, __unused short events, void *arg) 345 { 346 struct client *c = arg; 347 348 log_debug("free client %p (%d references)", c, c->references); 349 350 if (!TAILQ_EMPTY(&c->queue)) 351 fatalx("queue not empty"); 352 353 if (c->references == 0) { 354 free((void *)c->name); 355 free(c); 356 } 357 } 358 359 /* Suspend a client. */ 360 void 361 server_client_suspend(struct client *c) 362 { 363 struct session *s = c->session; 364 365 if (s == NULL || (c->flags & CLIENT_DETACHING)) 366 return; 367 368 tty_stop_tty(&c->tty); 369 c->flags |= CLIENT_SUSPENDED; 370 proc_send(c->peer, MSG_SUSPEND, -1, NULL, 0); 371 } 372 373 /* Detach a client. */ 374 void 375 server_client_detach(struct client *c, enum msgtype msgtype) 376 { 377 struct session *s = c->session; 378 379 if (s == NULL || (c->flags & CLIENT_DETACHING)) 380 return; 381 382 c->flags |= CLIENT_DETACHING; 383 notify_client("client-detached", c); 384 proc_send(c->peer, msgtype, -1, s->name, strlen(s->name) + 1); 385 } 386 387 /* Execute command to replace a client. */ 388 void 389 server_client_exec(struct client *c, const char *cmd) 390 { 391 struct session *s = c->session; 392 char *msg; 393 const char *shell; 394 size_t cmdsize, shellsize; 395 396 if (*cmd == '\0') 397 return; 398 cmdsize = strlen(cmd) + 1; 399 400 if (s != NULL) 401 shell = options_get_string(s->options, "default-shell"); 402 else 403 shell = options_get_string(global_s_options, "default-shell"); 404 shellsize = strlen(shell) + 1; 405 406 msg = xmalloc(cmdsize + shellsize); 407 memcpy(msg, cmd, cmdsize); 408 memcpy(msg + cmdsize, shell, shellsize); 409 410 proc_send(c->peer, MSG_EXEC, -1, msg, cmdsize + shellsize); 411 free(msg); 412 } 413 414 /* Check for mouse keys. */ 415 static key_code 416 server_client_check_mouse(struct client *c) 417 { 418 struct session *s = c->session; 419 struct mouse_event *m = &c->tty.mouse; 420 struct window *w; 421 struct window_pane *wp; 422 u_int x, y, b, sx, sy, px, py; 423 int flag; 424 key_code key; 425 struct timeval tv; 426 enum { NOTYPE, MOVE, DOWN, UP, DRAG, WHEEL, DOUBLE, TRIPLE } type; 427 enum { NOWHERE, PANE, STATUS, STATUS_LEFT, STATUS_RIGHT, BORDER } where; 428 429 type = NOTYPE; 430 where = NOWHERE; 431 432 log_debug("%s mouse %02x at %u,%u (last %u,%u) (%d)", c->name, m->b, 433 m->x, m->y, m->lx, m->ly, c->tty.mouse_drag_flag); 434 435 /* What type of event is this? */ 436 if ((m->sgr_type != ' ' && 437 MOUSE_DRAG(m->sgr_b) && 438 MOUSE_BUTTONS(m->sgr_b) == 3) || 439 (m->sgr_type == ' ' && 440 MOUSE_DRAG(m->b) && 441 MOUSE_BUTTONS(m->b) == 3 && 442 MOUSE_BUTTONS(m->lb) == 3)) { 443 type = MOVE; 444 x = m->x, y = m->y, b = 0; 445 log_debug("move at %u,%u", x, y); 446 } else if (MOUSE_DRAG(m->b)) { 447 type = DRAG; 448 if (c->tty.mouse_drag_flag) { 449 x = m->x, y = m->y, b = m->b; 450 log_debug("drag update at %u,%u", x, y); 451 } else { 452 x = m->lx - m->ox, y = m->ly - m->oy, b = m->lb; 453 log_debug("drag start at %u,%u", x, y); 454 } 455 } else if (MOUSE_WHEEL(m->b)) { 456 type = WHEEL; 457 x = m->x, y = m->y, b = m->b; 458 log_debug("wheel at %u,%u", x, y); 459 } else if (MOUSE_RELEASE(m->b)) { 460 type = UP; 461 x = m->x, y = m->y, b = m->lb; 462 log_debug("up at %u,%u", x, y); 463 } else { 464 if (c->flags & CLIENT_DOUBLECLICK) { 465 evtimer_del(&c->click_timer); 466 c->flags &= ~CLIENT_DOUBLECLICK; 467 if (m->b == c->click_button) { 468 type = DOUBLE; 469 x = m->x, y = m->y, b = m->b; 470 log_debug("double-click at %u,%u", x, y); 471 flag = CLIENT_TRIPLECLICK; 472 goto add_timer; 473 } 474 } else if (c->flags & CLIENT_TRIPLECLICK) { 475 evtimer_del(&c->click_timer); 476 c->flags &= ~CLIENT_TRIPLECLICK; 477 if (m->b == c->click_button) { 478 type = TRIPLE; 479 x = m->x, y = m->y, b = m->b; 480 log_debug("triple-click at %u,%u", x, y); 481 goto have_event; 482 } 483 } 484 485 type = DOWN; 486 x = m->x, y = m->y, b = m->b; 487 log_debug("down at %u,%u", x, y); 488 flag = CLIENT_DOUBLECLICK; 489 490 add_timer: 491 if (KEYC_CLICK_TIMEOUT != 0) { 492 c->flags |= flag; 493 c->click_button = m->b; 494 495 tv.tv_sec = KEYC_CLICK_TIMEOUT / 1000; 496 tv.tv_usec = (KEYC_CLICK_TIMEOUT % 1000) * 1000L; 497 evtimer_del(&c->click_timer); 498 evtimer_add(&c->click_timer, &tv); 499 } 500 } 501 502 have_event: 503 if (type == NOTYPE) 504 return (KEYC_UNKNOWN); 505 506 /* Save the session. */ 507 m->s = s->id; 508 m->w = -1; 509 510 /* Is this on the status line? */ 511 m->statusat = status_at_line(c); 512 if (m->statusat != -1 && y == (u_int)m->statusat) { 513 if (x < c->status.left_size) 514 where = STATUS_LEFT; 515 else if (x > c->tty.sx - c->status.right_size) 516 where = STATUS_RIGHT; 517 else { 518 w = status_get_window_at(c, x); 519 if (w == NULL) 520 return (KEYC_UNKNOWN); 521 m->w = w->id; 522 where = STATUS; 523 } 524 } 525 526 /* Not on status line. Adjust position and check for border or pane. */ 527 if (where == NOWHERE) { 528 px = x; 529 if (m->statusat == 0 && y > 0) 530 py = y - 1; 531 else if (m->statusat > 0 && y >= (u_int)m->statusat) 532 py = m->statusat - 1; 533 else 534 py = y; 535 536 tty_window_offset(&c->tty, &m->ox, &m->oy, &sx, &sy); 537 log_debug("mouse window @%u at %u,%u (%ux%u)", 538 s->curw->window->id, m->ox, m->oy, sx, sy); 539 if (px > sx || py > sy) 540 return (KEYC_UNKNOWN); 541 px = px + m->ox; 542 py = py + m->oy; 543 m->x = x + m->ox; 544 m->y = y + m->oy; 545 546 /* Try the pane borders if not zoomed. */ 547 if (~s->curw->window->flags & WINDOW_ZOOMED) { 548 TAILQ_FOREACH(wp, &s->curw->window->panes, entry) { 549 if ((wp->xoff + wp->sx == px && 550 wp->yoff <= 1 + py && 551 wp->yoff + wp->sy >= py) || 552 (wp->yoff + wp->sy == py && 553 wp->xoff <= 1 + px && 554 wp->xoff + wp->sx >= px)) 555 break; 556 } 557 if (wp != NULL) 558 where = BORDER; 559 } 560 561 /* Otherwise try inside the pane. */ 562 if (where == NOWHERE) { 563 wp = window_get_active_at(s->curw->window, px, py); 564 if (wp != NULL) 565 where = PANE; 566 } 567 568 if (where == NOWHERE) 569 return (KEYC_UNKNOWN); 570 if (where == PANE) 571 log_debug("mouse %u,%u on pane %%%u", x, y, wp->id); 572 else if (where == BORDER) 573 log_debug("mouse on pane %%%u border", wp->id); 574 m->wp = wp->id; 575 m->w = wp->window->id; 576 } else 577 m->wp = -1; 578 579 /* Stop dragging if needed. */ 580 if (type != DRAG && type != WHEEL && c->tty.mouse_drag_flag) { 581 if (c->tty.mouse_drag_release != NULL) 582 c->tty.mouse_drag_release(c, m); 583 584 c->tty.mouse_drag_update = NULL; 585 c->tty.mouse_drag_release = NULL; 586 587 /* 588 * End a mouse drag by passing a MouseDragEnd key corresponding 589 * to the button that started the drag. 590 */ 591 switch (c->tty.mouse_drag_flag) { 592 case 1: 593 if (where == PANE) 594 key = KEYC_MOUSEDRAGEND1_PANE; 595 if (where == STATUS) 596 key = KEYC_MOUSEDRAGEND1_STATUS; 597 if (where == STATUS_LEFT) 598 key = KEYC_MOUSEDRAGEND1_STATUS_LEFT; 599 if (where == STATUS_RIGHT) 600 key = KEYC_MOUSEDRAGEND1_STATUS_RIGHT; 601 if (where == BORDER) 602 key = KEYC_MOUSEDRAGEND1_BORDER; 603 break; 604 case 2: 605 if (where == PANE) 606 key = KEYC_MOUSEDRAGEND2_PANE; 607 if (where == STATUS) 608 key = KEYC_MOUSEDRAGEND2_STATUS; 609 if (where == STATUS_LEFT) 610 key = KEYC_MOUSEDRAGEND2_STATUS_LEFT; 611 if (where == STATUS_RIGHT) 612 key = KEYC_MOUSEDRAGEND2_STATUS_RIGHT; 613 if (where == BORDER) 614 key = KEYC_MOUSEDRAGEND2_BORDER; 615 break; 616 case 3: 617 if (where == PANE) 618 key = KEYC_MOUSEDRAGEND3_PANE; 619 if (where == STATUS) 620 key = KEYC_MOUSEDRAGEND3_STATUS; 621 if (where == STATUS_LEFT) 622 key = KEYC_MOUSEDRAGEND3_STATUS_LEFT; 623 if (where == STATUS_RIGHT) 624 key = KEYC_MOUSEDRAGEND3_STATUS_RIGHT; 625 if (where == BORDER) 626 key = KEYC_MOUSEDRAGEND3_BORDER; 627 break; 628 default: 629 key = KEYC_MOUSE; 630 break; 631 } 632 c->tty.mouse_drag_flag = 0; 633 634 return (key); 635 } 636 637 /* Convert to a key binding. */ 638 key = KEYC_UNKNOWN; 639 switch (type) { 640 case NOTYPE: 641 break; 642 case MOVE: 643 if (where == PANE) 644 key = KEYC_MOUSEMOVE_PANE; 645 if (where == STATUS) 646 key = KEYC_MOUSEMOVE_STATUS; 647 if (where == BORDER) 648 key = KEYC_MOUSEMOVE_BORDER; 649 break; 650 case DRAG: 651 if (c->tty.mouse_drag_update != NULL) 652 key = KEYC_DRAGGING; 653 else { 654 switch (MOUSE_BUTTONS(b)) { 655 case 0: 656 if (where == PANE) 657 key = KEYC_MOUSEDRAG1_PANE; 658 if (where == STATUS) 659 key = KEYC_MOUSEDRAG1_STATUS; 660 if (where == STATUS_LEFT) 661 key = KEYC_MOUSEDRAG1_STATUS_LEFT; 662 if (where == STATUS_RIGHT) 663 key = KEYC_MOUSEDRAG1_STATUS_RIGHT; 664 if (where == BORDER) 665 key = KEYC_MOUSEDRAG1_BORDER; 666 break; 667 case 1: 668 if (where == PANE) 669 key = KEYC_MOUSEDRAG2_PANE; 670 if (where == STATUS) 671 key = KEYC_MOUSEDRAG2_STATUS; 672 if (where == STATUS_LEFT) 673 key = KEYC_MOUSEDRAG2_STATUS_LEFT; 674 if (where == STATUS_RIGHT) 675 key = KEYC_MOUSEDRAG2_STATUS_RIGHT; 676 if (where == BORDER) 677 key = KEYC_MOUSEDRAG2_BORDER; 678 break; 679 case 2: 680 if (where == PANE) 681 key = KEYC_MOUSEDRAG3_PANE; 682 if (where == STATUS) 683 key = KEYC_MOUSEDRAG3_STATUS; 684 if (where == STATUS_LEFT) 685 key = KEYC_MOUSEDRAG3_STATUS_LEFT; 686 if (where == STATUS_RIGHT) 687 key = KEYC_MOUSEDRAG3_STATUS_RIGHT; 688 if (where == BORDER) 689 key = KEYC_MOUSEDRAG3_BORDER; 690 break; 691 } 692 } 693 694 /* 695 * Begin a drag by setting the flag to a non-zero value that 696 * corresponds to the mouse button in use. 697 */ 698 c->tty.mouse_drag_flag = MOUSE_BUTTONS(b) + 1; 699 break; 700 case WHEEL: 701 if (MOUSE_BUTTONS(b) == MOUSE_WHEEL_UP) { 702 if (where == PANE) 703 key = KEYC_WHEELUP_PANE; 704 if (where == STATUS) 705 key = KEYC_WHEELUP_STATUS; 706 if (where == STATUS_LEFT) 707 key = KEYC_WHEELUP_STATUS_LEFT; 708 if (where == STATUS_RIGHT) 709 key = KEYC_WHEELUP_STATUS_RIGHT; 710 if (where == BORDER) 711 key = KEYC_WHEELUP_BORDER; 712 } else { 713 if (where == PANE) 714 key = KEYC_WHEELDOWN_PANE; 715 if (where == STATUS) 716 key = KEYC_WHEELDOWN_STATUS; 717 if (where == BORDER) 718 key = KEYC_WHEELDOWN_BORDER; 719 } 720 break; 721 case UP: 722 switch (MOUSE_BUTTONS(b)) { 723 case 0: 724 if (where == PANE) 725 key = KEYC_MOUSEUP1_PANE; 726 if (where == STATUS) 727 key = KEYC_MOUSEUP1_STATUS; 728 if (where == STATUS_LEFT) 729 key = KEYC_MOUSEUP1_STATUS_LEFT; 730 if (where == STATUS_RIGHT) 731 key = KEYC_MOUSEUP1_STATUS_RIGHT; 732 if (where == BORDER) 733 key = KEYC_MOUSEUP1_BORDER; 734 break; 735 case 1: 736 if (where == PANE) 737 key = KEYC_MOUSEUP2_PANE; 738 if (where == STATUS) 739 key = KEYC_MOUSEUP2_STATUS; 740 if (where == STATUS_LEFT) 741 key = KEYC_MOUSEUP2_STATUS_LEFT; 742 if (where == STATUS_RIGHT) 743 key = KEYC_MOUSEUP2_STATUS_RIGHT; 744 if (where == BORDER) 745 key = KEYC_MOUSEUP2_BORDER; 746 break; 747 case 2: 748 if (where == PANE) 749 key = KEYC_MOUSEUP3_PANE; 750 if (where == STATUS) 751 key = KEYC_MOUSEUP3_STATUS; 752 if (where == STATUS_LEFT) 753 key = KEYC_MOUSEUP3_STATUS_LEFT; 754 if (where == STATUS_RIGHT) 755 key = KEYC_MOUSEUP3_STATUS_RIGHT; 756 if (where == BORDER) 757 key = KEYC_MOUSEUP3_BORDER; 758 break; 759 } 760 break; 761 case DOWN: 762 switch (MOUSE_BUTTONS(b)) { 763 case 0: 764 if (where == PANE) 765 key = KEYC_MOUSEDOWN1_PANE; 766 if (where == STATUS) 767 key = KEYC_MOUSEDOWN1_STATUS; 768 if (where == STATUS_LEFT) 769 key = KEYC_MOUSEDOWN1_STATUS_LEFT; 770 if (where == STATUS_RIGHT) 771 key = KEYC_MOUSEDOWN1_STATUS_RIGHT; 772 if (where == BORDER) 773 key = KEYC_MOUSEDOWN1_BORDER; 774 break; 775 case 1: 776 if (where == PANE) 777 key = KEYC_MOUSEDOWN2_PANE; 778 if (where == STATUS) 779 key = KEYC_MOUSEDOWN2_STATUS; 780 if (where == STATUS_LEFT) 781 key = KEYC_MOUSEDOWN2_STATUS_LEFT; 782 if (where == STATUS_RIGHT) 783 key = KEYC_MOUSEDOWN2_STATUS_RIGHT; 784 if (where == BORDER) 785 key = KEYC_MOUSEDOWN2_BORDER; 786 break; 787 case 2: 788 if (where == PANE) 789 key = KEYC_MOUSEDOWN3_PANE; 790 if (where == STATUS) 791 key = KEYC_MOUSEDOWN3_STATUS; 792 if (where == STATUS_LEFT) 793 key = KEYC_MOUSEDOWN3_STATUS_LEFT; 794 if (where == STATUS_RIGHT) 795 key = KEYC_MOUSEDOWN3_STATUS_RIGHT; 796 if (where == BORDER) 797 key = KEYC_MOUSEDOWN3_BORDER; 798 break; 799 } 800 break; 801 case DOUBLE: 802 switch (MOUSE_BUTTONS(b)) { 803 case 0: 804 if (where == PANE) 805 key = KEYC_DOUBLECLICK1_PANE; 806 if (where == STATUS) 807 key = KEYC_DOUBLECLICK1_STATUS; 808 if (where == STATUS_LEFT) 809 key = KEYC_DOUBLECLICK1_STATUS_LEFT; 810 if (where == STATUS_RIGHT) 811 key = KEYC_DOUBLECLICK1_STATUS_RIGHT; 812 if (where == BORDER) 813 key = KEYC_DOUBLECLICK1_BORDER; 814 break; 815 case 1: 816 if (where == PANE) 817 key = KEYC_DOUBLECLICK2_PANE; 818 if (where == STATUS) 819 key = KEYC_DOUBLECLICK2_STATUS; 820 if (where == STATUS_LEFT) 821 key = KEYC_DOUBLECLICK2_STATUS_LEFT; 822 if (where == STATUS_RIGHT) 823 key = KEYC_DOUBLECLICK2_STATUS_RIGHT; 824 if (where == BORDER) 825 key = KEYC_DOUBLECLICK2_BORDER; 826 break; 827 case 2: 828 if (where == PANE) 829 key = KEYC_DOUBLECLICK3_PANE; 830 if (where == STATUS) 831 key = KEYC_DOUBLECLICK3_STATUS; 832 if (where == STATUS_LEFT) 833 key = KEYC_DOUBLECLICK3_STATUS_LEFT; 834 if (where == STATUS_RIGHT) 835 key = KEYC_DOUBLECLICK3_STATUS_RIGHT; 836 if (where == BORDER) 837 key = KEYC_DOUBLECLICK3_BORDER; 838 break; 839 } 840 break; 841 case TRIPLE: 842 switch (MOUSE_BUTTONS(b)) { 843 case 0: 844 if (where == PANE) 845 key = KEYC_TRIPLECLICK1_PANE; 846 if (where == STATUS) 847 key = KEYC_TRIPLECLICK1_STATUS; 848 if (where == STATUS_LEFT) 849 key = KEYC_TRIPLECLICK1_STATUS_LEFT; 850 if (where == STATUS_RIGHT) 851 key = KEYC_TRIPLECLICK1_STATUS_RIGHT; 852 if (where == BORDER) 853 key = KEYC_TRIPLECLICK1_BORDER; 854 break; 855 case 1: 856 if (where == PANE) 857 key = KEYC_TRIPLECLICK2_PANE; 858 if (where == STATUS) 859 key = KEYC_TRIPLECLICK2_STATUS; 860 if (where == STATUS_LEFT) 861 key = KEYC_TRIPLECLICK2_STATUS_LEFT; 862 if (where == STATUS_RIGHT) 863 key = KEYC_TRIPLECLICK2_STATUS_RIGHT; 864 if (where == BORDER) 865 key = KEYC_TRIPLECLICK2_BORDER; 866 break; 867 case 2: 868 if (where == PANE) 869 key = KEYC_TRIPLECLICK3_PANE; 870 if (where == STATUS) 871 key = KEYC_TRIPLECLICK3_STATUS; 872 if (where == STATUS_LEFT) 873 key = KEYC_TRIPLECLICK3_STATUS_LEFT; 874 if (where == STATUS_RIGHT) 875 key = KEYC_TRIPLECLICK3_STATUS_RIGHT; 876 if (where == BORDER) 877 key = KEYC_TRIPLECLICK3_BORDER; 878 break; 879 } 880 break; 881 } 882 if (key == KEYC_UNKNOWN) 883 return (KEYC_UNKNOWN); 884 885 /* Apply modifiers if any. */ 886 if (b & MOUSE_MASK_META) 887 key |= KEYC_ESCAPE; 888 if (b & MOUSE_MASK_CTRL) 889 key |= KEYC_CTRL; 890 if (b & MOUSE_MASK_SHIFT) 891 key |= KEYC_SHIFT; 892 893 return (key); 894 } 895 896 /* Is this fast enough to probably be a paste? */ 897 static int 898 server_client_assume_paste(struct session *s) 899 { 900 struct timeval tv; 901 int t; 902 903 if ((t = options_get_number(s->options, "assume-paste-time")) == 0) 904 return (0); 905 906 timersub(&s->activity_time, &s->last_activity_time, &tv); 907 if (tv.tv_sec == 0 && tv.tv_usec < t * 1000) { 908 log_debug("session %s pasting (flag %d)", s->name, 909 !!(s->flags & SESSION_PASTING)); 910 if (s->flags & SESSION_PASTING) 911 return (1); 912 s->flags |= SESSION_PASTING; 913 return (0); 914 } 915 log_debug("session %s not pasting", s->name); 916 s->flags &= ~SESSION_PASTING; 917 return (0); 918 } 919 920 /* Handle data key input from client. */ 921 void 922 server_client_handle_key(struct client *c, key_code key) 923 { 924 struct mouse_event *m = &c->tty.mouse; 925 struct session *s = c->session; 926 struct winlink *wl; 927 struct window *w; 928 struct window_pane *wp; 929 struct timeval tv; 930 struct key_table *table, *first; 931 struct key_binding *bd; 932 int xtimeout, flags; 933 struct cmd_find_state fs; 934 key_code key0; 935 936 /* Check the client is good to accept input. */ 937 if (s == NULL || (c->flags & (CLIENT_DEAD|CLIENT_SUSPENDED)) != 0) 938 return; 939 wl = s->curw; 940 w = wl->window; 941 942 /* Update the activity timer. */ 943 if (gettimeofday(&c->activity_time, NULL) != 0) 944 fatal("gettimeofday failed"); 945 session_update_activity(s, &c->activity_time); 946 947 /* Number keys jump to pane in identify mode. */ 948 if (c->flags & CLIENT_IDENTIFY && key >= '0' && key <= '9') { 949 if (c->flags & CLIENT_READONLY) 950 return; 951 window_unzoom(w); 952 wp = window_pane_at_index(w, key - '0'); 953 server_client_clear_identify(c, wp); 954 return; 955 } 956 957 /* Handle status line. */ 958 if (!(c->flags & CLIENT_READONLY)) { 959 status_message_clear(c); 960 server_client_clear_identify(c, NULL); 961 } 962 if (c->prompt_string != NULL) { 963 if (c->flags & CLIENT_READONLY) 964 return; 965 if (status_prompt_key(c, key) == 0) 966 return; 967 } 968 969 /* Check for mouse keys. */ 970 m->valid = 0; 971 if (key == KEYC_MOUSE) { 972 if (c->flags & CLIENT_READONLY) 973 return; 974 key = server_client_check_mouse(c); 975 if (key == KEYC_UNKNOWN) 976 return; 977 978 m->valid = 1; 979 m->key = key; 980 981 /* 982 * Mouse drag is in progress, so fire the callback (now that 983 * the mouse event is valid). 984 */ 985 if (key == KEYC_DRAGGING) { 986 c->tty.mouse_drag_update(c, m); 987 return; 988 } 989 } else 990 m->valid = 0; 991 992 /* Find affected pane. */ 993 if (!KEYC_IS_MOUSE(key) || cmd_find_from_mouse(&fs, m, 0) != 0) 994 cmd_find_from_session(&fs, s, 0); 995 wp = fs.wp; 996 997 /* Forward mouse keys if disabled. */ 998 if (KEYC_IS_MOUSE(key) && !options_get_number(s->options, "mouse")) 999 goto forward_key; 1000 1001 /* Treat everything as a regular key when pasting is detected. */ 1002 if (!KEYC_IS_MOUSE(key) && server_client_assume_paste(s)) 1003 goto forward_key; 1004 1005 /* 1006 * Work out the current key table. If the pane is in a mode, use 1007 * the mode table instead of the default key table. 1008 */ 1009 if (server_client_is_default_key_table(c, c->keytable) && 1010 wp != NULL && 1011 wp->mode != NULL && 1012 wp->mode->key_table != NULL) 1013 table = key_bindings_get_table(wp->mode->key_table(wp), 1); 1014 else 1015 table = c->keytable; 1016 first = table; 1017 1018 table_changed: 1019 /* 1020 * The prefix always takes precedence and forces a switch to the prefix 1021 * table, unless we are already there. 1022 */ 1023 key0 = (key & ~KEYC_XTERM); 1024 if ((key0 == (key_code)options_get_number(s->options, "prefix") || 1025 key0 == (key_code)options_get_number(s->options, "prefix2")) && 1026 strcmp(table->name, "prefix") != 0) { 1027 server_client_set_key_table(c, "prefix"); 1028 server_status_client(c); 1029 return; 1030 } 1031 flags = c->flags; 1032 1033 try_again: 1034 /* Log key table. */ 1035 if (wp == NULL) 1036 log_debug("key table %s (no pane)", table->name); 1037 else 1038 log_debug("key table %s (pane %%%u)", table->name, wp->id); 1039 if (c->flags & CLIENT_REPEAT) 1040 log_debug("currently repeating"); 1041 1042 /* Try to see if there is a key binding in the current table. */ 1043 bd = key_bindings_get(table, key0); 1044 if (bd != NULL) { 1045 /* 1046 * Key was matched in this table. If currently repeating but a 1047 * non-repeating binding was found, stop repeating and try 1048 * again in the root table. 1049 */ 1050 if ((c->flags & CLIENT_REPEAT) && 1051 (~bd->flags & KEY_BINDING_REPEAT)) { 1052 log_debug("found in key table %s (not repeating)", 1053 table->name); 1054 server_client_set_key_table(c, NULL); 1055 first = table = c->keytable; 1056 c->flags &= ~CLIENT_REPEAT; 1057 server_status_client(c); 1058 goto table_changed; 1059 } 1060 log_debug("found in key table %s", table->name); 1061 1062 /* 1063 * Take a reference to this table to make sure the key binding 1064 * doesn't disappear. 1065 */ 1066 table->references++; 1067 1068 /* 1069 * If this is a repeating key, start the timer. Otherwise reset 1070 * the client back to the root table. 1071 */ 1072 xtimeout = options_get_number(s->options, "repeat-time"); 1073 if (xtimeout != 0 && (bd->flags & KEY_BINDING_REPEAT)) { 1074 c->flags |= CLIENT_REPEAT; 1075 1076 tv.tv_sec = xtimeout / 1000; 1077 tv.tv_usec = (xtimeout % 1000) * 1000L; 1078 evtimer_del(&c->repeat_timer); 1079 evtimer_add(&c->repeat_timer, &tv); 1080 } else { 1081 c->flags &= ~CLIENT_REPEAT; 1082 server_client_set_key_table(c, NULL); 1083 } 1084 server_status_client(c); 1085 1086 /* Execute the key binding. */ 1087 key_bindings_dispatch(bd, NULL, c, m, &fs); 1088 key_bindings_unref_table(table); 1089 return; 1090 } 1091 1092 /* 1093 * No match, try the ANY key. 1094 */ 1095 if (key0 != KEYC_ANY) { 1096 key0 = KEYC_ANY; 1097 goto try_again; 1098 } 1099 1100 /* 1101 * No match in this table. If not in the root table or if repeating, 1102 * switch the client back to the root table and try again. 1103 */ 1104 log_debug("not found in key table %s", table->name); 1105 if (!server_client_is_default_key_table(c, table) || 1106 (c->flags & CLIENT_REPEAT)) { 1107 log_debug("trying in root table"); 1108 server_client_set_key_table(c, NULL); 1109 table = c->keytable; 1110 if (c->flags & CLIENT_REPEAT) 1111 first = table; 1112 c->flags &= ~CLIENT_REPEAT; 1113 server_status_client(c); 1114 goto table_changed; 1115 } 1116 1117 /* 1118 * No match in the root table either. If this wasn't the first table 1119 * tried, don't pass the key to the pane. 1120 */ 1121 if (first != table && (~flags & CLIENT_REPEAT)) { 1122 server_client_set_key_table(c, NULL); 1123 server_status_client(c); 1124 return; 1125 } 1126 1127 forward_key: 1128 if (c->flags & CLIENT_READONLY) 1129 return; 1130 if (wp != NULL) 1131 window_pane_key(wp, c, s, wl, key, m); 1132 } 1133 1134 /* Client functions that need to happen every loop. */ 1135 void 1136 server_client_loop(void) 1137 { 1138 struct client *c; 1139 struct window *w; 1140 struct window_pane *wp; 1141 int focus; 1142 1143 TAILQ_FOREACH(c, &clients, entry) { 1144 server_client_check_exit(c); 1145 if (c->session != NULL) { 1146 server_client_check_redraw(c); 1147 server_client_reset_state(c); 1148 } 1149 } 1150 1151 /* 1152 * Any windows will have been redrawn as part of clients, so clear 1153 * their flags now. Also check pane focus and resize. 1154 */ 1155 focus = options_get_number(global_options, "focus-events"); 1156 RB_FOREACH(w, windows, &windows) { 1157 TAILQ_FOREACH(wp, &w->panes, entry) { 1158 if (wp->fd != -1) { 1159 if (focus) 1160 server_client_check_focus(wp); 1161 server_client_check_resize(wp); 1162 } 1163 wp->flags &= ~PANE_REDRAW; 1164 } 1165 check_window_name(w); 1166 } 1167 } 1168 1169 /* Check if we need to force a resize. */ 1170 static int 1171 server_client_resize_force(struct window_pane *wp) 1172 { 1173 struct timeval tv = { .tv_usec = 100000 }; 1174 struct winsize ws; 1175 1176 /* 1177 * If we are resizing to the same size as when we entered the loop 1178 * (that is, to the same size the application currently thinks it is), 1179 * tmux may have gone through several resizes internally and thrown 1180 * away parts of the screen. So we need the application to actually 1181 * redraw even though its final size has not changed. 1182 */ 1183 1184 if (wp->flags & PANE_RESIZEFORCE) { 1185 wp->flags &= ~PANE_RESIZEFORCE; 1186 return (0); 1187 } 1188 1189 if (wp->sx != wp->osx || 1190 wp->sy != wp->osy || 1191 wp->sx <= 1 || 1192 wp->sy <= 1) 1193 return (0); 1194 1195 memset(&ws, 0, sizeof ws); 1196 ws.ws_col = wp->sx; 1197 ws.ws_row = wp->sy - 1; 1198 if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1) 1199 fatal("ioctl failed"); 1200 log_debug("%s: %%%u forcing resize", __func__, wp->id); 1201 1202 evtimer_add(&wp->resize_timer, &tv); 1203 wp->flags |= PANE_RESIZEFORCE; 1204 return (1); 1205 } 1206 1207 /* Resize timer event. */ 1208 static void 1209 server_client_resize_event(__unused int fd, __unused short events, void *data) 1210 { 1211 struct window_pane *wp = data; 1212 struct winsize ws; 1213 1214 evtimer_del(&wp->resize_timer); 1215 1216 if (!(wp->flags & PANE_RESIZE)) 1217 return; 1218 if (server_client_resize_force(wp)) 1219 return; 1220 1221 memset(&ws, 0, sizeof ws); 1222 ws.ws_col = wp->sx; 1223 ws.ws_row = wp->sy; 1224 if (wp->fd != -1 && ioctl(wp->fd, TIOCSWINSZ, &ws) == -1) 1225 fatal("ioctl failed"); 1226 log_debug("%s: %%%u resize to %u,%u", __func__, wp->id, wp->sx, wp->sy); 1227 1228 wp->flags &= ~PANE_RESIZE; 1229 1230 wp->osx = wp->sx; 1231 wp->osy = wp->sy; 1232 } 1233 1234 /* Check if pane should be resized. */ 1235 static void 1236 server_client_check_resize(struct window_pane *wp) 1237 { 1238 struct timeval tv = { .tv_usec = 250000 }; 1239 1240 if (!(wp->flags & PANE_RESIZE)) 1241 return; 1242 log_debug("%s: %%%u resize to %u,%u", __func__, wp->id, wp->sx, wp->sy); 1243 1244 if (!event_initialized(&wp->resize_timer)) 1245 evtimer_set(&wp->resize_timer, server_client_resize_event, wp); 1246 1247 /* 1248 * The first resize should happen immediately, so if the timer is not 1249 * running, do it now. 1250 */ 1251 if (!evtimer_pending(&wp->resize_timer, NULL)) 1252 server_client_resize_event(-1, 0, wp); 1253 1254 /* 1255 * If the pane is in the alternate screen, let the timer expire and 1256 * resize to give the application a chance to redraw. If not, keep 1257 * pushing the timer back. 1258 */ 1259 if (wp->saved_grid != NULL && evtimer_pending(&wp->resize_timer, NULL)) 1260 return; 1261 evtimer_del(&wp->resize_timer); 1262 evtimer_add(&wp->resize_timer, &tv); 1263 } 1264 1265 /* Check whether pane should be focused. */ 1266 static void 1267 server_client_check_focus(struct window_pane *wp) 1268 { 1269 struct client *c; 1270 int push; 1271 1272 /* Do we need to push the focus state? */ 1273 push = wp->flags & PANE_FOCUSPUSH; 1274 wp->flags &= ~PANE_FOCUSPUSH; 1275 1276 /* If we're not the active pane in our window, we're not focused. */ 1277 if (wp->window->active != wp) 1278 goto not_focused; 1279 1280 /* If we're in a mode, we're not focused. */ 1281 if (wp->screen != &wp->base) 1282 goto not_focused; 1283 1284 /* 1285 * If our window is the current window in any focused clients with an 1286 * attached session, we're focused. 1287 */ 1288 TAILQ_FOREACH(c, &clients, entry) { 1289 if (c->session == NULL || !(c->flags & CLIENT_FOCUSED)) 1290 continue; 1291 if (c->session->attached == 0) 1292 continue; 1293 1294 if (c->session->curw->window == wp->window) 1295 goto focused; 1296 } 1297 1298 not_focused: 1299 if (push || (wp->flags & PANE_FOCUSED)) { 1300 if (wp->base.mode & MODE_FOCUSON) 1301 bufferevent_write(wp->event, "\033[O", 3); 1302 notify_pane("pane-focus-out", wp); 1303 } 1304 wp->flags &= ~PANE_FOCUSED; 1305 return; 1306 1307 focused: 1308 if (push || !(wp->flags & PANE_FOCUSED)) { 1309 if (wp->base.mode & MODE_FOCUSON) 1310 bufferevent_write(wp->event, "\033[I", 3); 1311 notify_pane("pane-focus-in", wp); 1312 } 1313 wp->flags |= PANE_FOCUSED; 1314 } 1315 1316 /* 1317 * Update cursor position and mode settings. The scroll region and attributes 1318 * are cleared when idle (waiting for an event) as this is the most likely time 1319 * a user may interrupt tmux, for example with ~^Z in ssh(1). This is a 1320 * compromise between excessive resets and likelihood of an interrupt. 1321 * 1322 * tty_region/tty_reset/tty_update_mode already take care of not resetting 1323 * things that are already in their default state. 1324 */ 1325 static void 1326 server_client_reset_state(struct client *c) 1327 { 1328 struct window *w = c->session->curw->window; 1329 struct window_pane *wp = w->active, *loop; 1330 struct screen *s = wp->screen; 1331 struct options *oo = c->session->options; 1332 int mode, cursor = 0; 1333 u_int cx = 0, cy = 0, ox, oy, sx, sy; 1334 1335 if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED)) 1336 return; 1337 mode = s->mode; 1338 1339 tty_region_off(&c->tty); 1340 tty_margin_off(&c->tty); 1341 1342 /* Move cursor to pane cursor and offset. */ 1343 cursor = 0; 1344 tty_window_offset(&c->tty, &ox, &oy, &sx, &sy); 1345 if (wp->xoff + s->cx >= ox && wp->xoff + s->cx <= ox + sx && 1346 wp->yoff + s->cy >= oy && wp->yoff + s->cy <= oy + sy) { 1347 cursor = 1; 1348 1349 cx = wp->xoff + s->cx - ox; 1350 cy = wp->yoff + s->cy - oy; 1351 1352 if (status_at_line(c) == 0) 1353 cy += status_line_size(c); 1354 } 1355 if (!cursor) 1356 mode &= ~MODE_CURSOR; 1357 tty_cursor(&c->tty, cx, cy); 1358 1359 /* 1360 * Set mouse mode if requested. To support dragging, always use button 1361 * mode. 1362 */ 1363 if (options_get_number(oo, "mouse")) { 1364 mode &= ~ALL_MOUSE_MODES; 1365 TAILQ_FOREACH(loop, &w->panes, entry) { 1366 if (loop->screen->mode & MODE_MOUSE_ALL) 1367 mode |= MODE_MOUSE_ALL; 1368 } 1369 if (~mode & MODE_MOUSE_ALL) 1370 mode |= MODE_MOUSE_BUTTON; 1371 } 1372 1373 /* Clear bracketed paste mode if at the prompt. */ 1374 if (c->prompt_string != NULL) 1375 mode &= ~MODE_BRACKETPASTE; 1376 1377 /* Set the terminal mode and reset attributes. */ 1378 tty_update_mode(&c->tty, mode, s); 1379 tty_reset(&c->tty); 1380 } 1381 1382 /* Repeat time callback. */ 1383 static void 1384 server_client_repeat_timer(__unused int fd, __unused short events, void *data) 1385 { 1386 struct client *c = data; 1387 1388 if (c->flags & CLIENT_REPEAT) { 1389 server_client_set_key_table(c, NULL); 1390 c->flags &= ~CLIENT_REPEAT; 1391 server_status_client(c); 1392 } 1393 } 1394 1395 /* Double-click callback. */ 1396 static void 1397 server_client_click_timer(__unused int fd, __unused short events, void *data) 1398 { 1399 struct client *c = data; 1400 1401 c->flags &= ~(CLIENT_DOUBLECLICK|CLIENT_TRIPLECLICK); 1402 } 1403 1404 /* Check if client should be exited. */ 1405 static void 1406 server_client_check_exit(struct client *c) 1407 { 1408 if (!(c->flags & CLIENT_EXIT)) 1409 return; 1410 1411 if (EVBUFFER_LENGTH(c->stdin_data) != 0) 1412 return; 1413 if (EVBUFFER_LENGTH(c->stdout_data) != 0) 1414 return; 1415 if (EVBUFFER_LENGTH(c->stderr_data) != 0) 1416 return; 1417 1418 if (c->flags & CLIENT_ATTACHED) 1419 notify_client("client-detached", c); 1420 proc_send(c->peer, MSG_EXIT, -1, &c->retval, sizeof c->retval); 1421 c->flags &= ~CLIENT_EXIT; 1422 } 1423 1424 /* Redraw timer callback. */ 1425 static void 1426 server_client_redraw_timer(__unused int fd, __unused short events, 1427 __unused void* data) 1428 { 1429 log_debug("redraw timer fired"); 1430 } 1431 1432 /* Check for client redraws. */ 1433 static void 1434 server_client_check_redraw(struct client *c) 1435 { 1436 struct session *s = c->session; 1437 struct tty *tty = &c->tty; 1438 struct window_pane *wp; 1439 int needed, flags; 1440 struct timeval tv = { .tv_usec = 1000 }; 1441 static struct event ev; 1442 size_t left; 1443 1444 if (c->flags & (CLIENT_CONTROL|CLIENT_SUSPENDED)) 1445 return; 1446 if (c->flags & CLIENT_ALLREDRAWFLAGS) { 1447 log_debug("%s: redraw%s%s%s", c->name, 1448 (c->flags & CLIENT_REDRAWWINDOW) ? " window" : "", 1449 (c->flags & CLIENT_REDRAWSTATUS) ? " status" : "", 1450 (c->flags & CLIENT_REDRAWBORDERS) ? " borders" : ""); 1451 } 1452 1453 /* 1454 * If there is outstanding data, defer the redraw until it has been 1455 * consumed. We can just add a timer to get out of the event loop and 1456 * end up back here. 1457 */ 1458 needed = 0; 1459 if (c->flags & CLIENT_ALLREDRAWFLAGS) 1460 needed = 1; 1461 else { 1462 TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) { 1463 if (wp->flags & PANE_REDRAW) { 1464 needed = 1; 1465 break; 1466 } 1467 } 1468 } 1469 if (needed && (left = EVBUFFER_LENGTH(tty->out)) != 0) { 1470 log_debug("%s: redraw deferred (%zu left)", c->name, left); 1471 if (!evtimer_initialized(&ev)) 1472 evtimer_set(&ev, server_client_redraw_timer, NULL); 1473 if (!evtimer_pending(&ev, NULL)) { 1474 log_debug("redraw timer started"); 1475 evtimer_add(&ev, &tv); 1476 } 1477 1478 /* 1479 * We may have got here for a single pane redraw, but force a 1480 * full redraw next time in case other panes have been updated. 1481 */ 1482 c->flags |= CLIENT_ALLREDRAWFLAGS; 1483 return; 1484 } else if (needed) 1485 log_debug("%s: redraw needed", c->name); 1486 1487 flags = tty->flags & (TTY_BLOCK|TTY_FREEZE|TTY_NOCURSOR); 1488 tty->flags = (tty->flags & ~(TTY_BLOCK|TTY_FREEZE)) | TTY_NOCURSOR; 1489 1490 if (~c->flags & CLIENT_REDRAWWINDOW) { 1491 /* 1492 * If not redrawing the entire window, check whether each pane 1493 * needs to be redrawn. 1494 */ 1495 TAILQ_FOREACH(wp, &c->session->curw->window->panes, entry) { 1496 if (wp->flags & PANE_REDRAW) { 1497 tty_update_mode(tty, tty->mode, NULL); 1498 screen_redraw_pane(c, wp); 1499 } 1500 } 1501 } 1502 1503 if (c->flags & CLIENT_ALLREDRAWFLAGS) { 1504 if (options_get_number(s->options, "set-titles")) 1505 server_client_set_title(c); 1506 screen_redraw_screen(c); 1507 } 1508 1509 tty->flags = (tty->flags & ~(TTY_FREEZE|TTY_NOCURSOR)) | flags; 1510 tty_update_mode(tty, tty->mode, NULL); 1511 1512 c->flags &= ~(CLIENT_ALLREDRAWFLAGS|CLIENT_STATUSFORCE); 1513 1514 if (needed) { 1515 /* 1516 * We would have deferred the redraw unless the output buffer 1517 * was empty, so we can record how many bytes the redraw 1518 * generated. 1519 */ 1520 c->redraw = EVBUFFER_LENGTH(tty->out); 1521 log_debug("%s: redraw added %zu bytes", c->name, c->redraw); 1522 } 1523 } 1524 1525 /* Set client title. */ 1526 static void 1527 server_client_set_title(struct client *c) 1528 { 1529 struct session *s = c->session; 1530 const char *template; 1531 char *title; 1532 struct format_tree *ft; 1533 1534 template = options_get_string(s->options, "set-titles-string"); 1535 1536 ft = format_create(c, NULL, FORMAT_NONE, 0); 1537 format_defaults(ft, c, NULL, NULL, NULL); 1538 1539 title = format_expand_time(ft, template, time(NULL)); 1540 if (c->title == NULL || strcmp(title, c->title) != 0) { 1541 free(c->title); 1542 c->title = xstrdup(title); 1543 tty_set_title(&c->tty, c->title); 1544 } 1545 free(title); 1546 1547 format_free(ft); 1548 } 1549 1550 /* Dispatch message from client. */ 1551 static void 1552 server_client_dispatch(struct imsg *imsg, void *arg) 1553 { 1554 struct client *c = arg; 1555 struct msg_stdin_data stdindata; 1556 const char *data; 1557 ssize_t datalen; 1558 struct session *s; 1559 1560 if (c->flags & CLIENT_DEAD) 1561 return; 1562 1563 if (imsg == NULL) { 1564 server_client_lost(c); 1565 return; 1566 } 1567 1568 data = imsg->data; 1569 datalen = imsg->hdr.len - IMSG_HEADER_SIZE; 1570 1571 switch (imsg->hdr.type) { 1572 case MSG_IDENTIFY_FLAGS: 1573 case MSG_IDENTIFY_TERM: 1574 case MSG_IDENTIFY_TTYNAME: 1575 case MSG_IDENTIFY_CWD: 1576 case MSG_IDENTIFY_STDIN: 1577 case MSG_IDENTIFY_ENVIRON: 1578 case MSG_IDENTIFY_CLIENTPID: 1579 case MSG_IDENTIFY_DONE: 1580 server_client_dispatch_identify(c, imsg); 1581 break; 1582 case MSG_COMMAND: 1583 server_client_dispatch_command(c, imsg); 1584 break; 1585 case MSG_STDIN: 1586 if (datalen != sizeof stdindata) 1587 fatalx("bad MSG_STDIN size"); 1588 memcpy(&stdindata, data, sizeof stdindata); 1589 1590 if (c->stdin_callback == NULL) 1591 break; 1592 if (stdindata.size <= 0) 1593 c->stdin_closed = 1; 1594 else { 1595 evbuffer_add(c->stdin_data, stdindata.data, 1596 stdindata.size); 1597 } 1598 c->stdin_callback(c, c->stdin_closed, 1599 c->stdin_callback_data); 1600 break; 1601 case MSG_RESIZE: 1602 if (datalen != 0) 1603 fatalx("bad MSG_RESIZE size"); 1604 1605 if (c->flags & CLIENT_CONTROL) 1606 break; 1607 tty_resize(&c->tty); 1608 recalculate_sizes(); 1609 server_redraw_client(c); 1610 if (c->session != NULL) 1611 notify_client("client-resized", c); 1612 break; 1613 case MSG_EXITING: 1614 if (datalen != 0) 1615 fatalx("bad MSG_EXITING size"); 1616 1617 c->session = NULL; 1618 tty_close(&c->tty); 1619 proc_send(c->peer, MSG_EXITED, -1, NULL, 0); 1620 break; 1621 case MSG_WAKEUP: 1622 case MSG_UNLOCK: 1623 if (datalen != 0) 1624 fatalx("bad MSG_WAKEUP size"); 1625 1626 if (!(c->flags & CLIENT_SUSPENDED)) 1627 break; 1628 c->flags &= ~CLIENT_SUSPENDED; 1629 1630 if (c->tty.fd == -1) /* exited in the meantime */ 1631 break; 1632 s = c->session; 1633 1634 if (gettimeofday(&c->activity_time, NULL) != 0) 1635 fatal("gettimeofday failed"); 1636 1637 tty_start_tty(&c->tty); 1638 server_redraw_client(c); 1639 recalculate_sizes(); 1640 1641 if (s != NULL) 1642 session_update_activity(s, &c->activity_time); 1643 break; 1644 case MSG_SHELL: 1645 if (datalen != 0) 1646 fatalx("bad MSG_SHELL size"); 1647 1648 server_client_dispatch_shell(c); 1649 break; 1650 } 1651 } 1652 1653 /* Callback when command is done. */ 1654 static enum cmd_retval 1655 server_client_command_done(struct cmdq_item *item, __unused void *data) 1656 { 1657 struct client *c = item->client; 1658 1659 if (~c->flags & CLIENT_ATTACHED) 1660 c->flags |= CLIENT_EXIT; 1661 return (CMD_RETURN_NORMAL); 1662 } 1663 1664 /* Show an error message. */ 1665 static enum cmd_retval 1666 server_client_command_error(struct cmdq_item *item, void *data) 1667 { 1668 char *error = data; 1669 1670 cmdq_error(item, "%s", error); 1671 free(error); 1672 1673 return (CMD_RETURN_NORMAL); 1674 } 1675 1676 /* Handle command message. */ 1677 static void 1678 server_client_dispatch_command(struct client *c, struct imsg *imsg) 1679 { 1680 struct msg_command_data data; 1681 char *buf; 1682 size_t len; 1683 struct cmd_list *cmdlist = NULL; 1684 int argc; 1685 char **argv, *cause; 1686 1687 if (c->flags & CLIENT_EXIT) 1688 return; 1689 1690 if (imsg->hdr.len - IMSG_HEADER_SIZE < sizeof data) 1691 fatalx("bad MSG_COMMAND size"); 1692 memcpy(&data, imsg->data, sizeof data); 1693 1694 buf = (char *)imsg->data + sizeof data; 1695 len = imsg->hdr.len - IMSG_HEADER_SIZE - sizeof data; 1696 if (len > 0 && buf[len - 1] != '\0') 1697 fatalx("bad MSG_COMMAND string"); 1698 1699 argc = data.argc; 1700 if (cmd_unpack_argv(buf, len, argc, &argv) != 0) { 1701 cause = xstrdup("command too long"); 1702 goto error; 1703 } 1704 1705 if (argc == 0) { 1706 argc = 1; 1707 argv = xcalloc(1, sizeof *argv); 1708 *argv = xstrdup("new-session"); 1709 } 1710 1711 if ((cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause)) == NULL) { 1712 cmd_free_argv(argc, argv); 1713 goto error; 1714 } 1715 cmd_free_argv(argc, argv); 1716 1717 cmdq_append(c, cmdq_get_command(cmdlist, NULL, NULL, 0)); 1718 cmdq_append(c, cmdq_get_callback(server_client_command_done, NULL)); 1719 cmd_list_free(cmdlist); 1720 return; 1721 1722 error: 1723 cmdq_append(c, cmdq_get_callback(server_client_command_error, cause)); 1724 1725 if (cmdlist != NULL) 1726 cmd_list_free(cmdlist); 1727 1728 c->flags |= CLIENT_EXIT; 1729 } 1730 1731 /* Handle identify message. */ 1732 static void 1733 server_client_dispatch_identify(struct client *c, struct imsg *imsg) 1734 { 1735 const char *data, *home; 1736 size_t datalen; 1737 int flags; 1738 char *name; 1739 1740 if (c->flags & CLIENT_IDENTIFIED) 1741 fatalx("out-of-order identify message"); 1742 1743 data = imsg->data; 1744 datalen = imsg->hdr.len - IMSG_HEADER_SIZE; 1745 1746 switch (imsg->hdr.type) { 1747 case MSG_IDENTIFY_FLAGS: 1748 if (datalen != sizeof flags) 1749 fatalx("bad MSG_IDENTIFY_FLAGS size"); 1750 memcpy(&flags, data, sizeof flags); 1751 c->flags |= flags; 1752 log_debug("client %p IDENTIFY_FLAGS %#x", c, flags); 1753 break; 1754 case MSG_IDENTIFY_TERM: 1755 if (datalen == 0 || data[datalen - 1] != '\0') 1756 fatalx("bad MSG_IDENTIFY_TERM string"); 1757 c->term = xstrdup(data); 1758 log_debug("client %p IDENTIFY_TERM %s", c, data); 1759 break; 1760 case MSG_IDENTIFY_TTYNAME: 1761 if (datalen == 0 || data[datalen - 1] != '\0') 1762 fatalx("bad MSG_IDENTIFY_TTYNAME string"); 1763 c->ttyname = xstrdup(data); 1764 log_debug("client %p IDENTIFY_TTYNAME %s", c, data); 1765 break; 1766 case MSG_IDENTIFY_CWD: 1767 if (datalen == 0 || data[datalen - 1] != '\0') 1768 fatalx("bad MSG_IDENTIFY_CWD string"); 1769 if (access(data, X_OK) == 0) 1770 c->cwd = xstrdup(data); 1771 else if ((home = find_home()) != NULL) 1772 c->cwd = xstrdup(home); 1773 else 1774 c->cwd = xstrdup("/"); 1775 log_debug("client %p IDENTIFY_CWD %s", c, data); 1776 break; 1777 case MSG_IDENTIFY_STDIN: 1778 if (datalen != 0) 1779 fatalx("bad MSG_IDENTIFY_STDIN size"); 1780 c->fd = imsg->fd; 1781 log_debug("client %p IDENTIFY_STDIN %d", c, imsg->fd); 1782 break; 1783 case MSG_IDENTIFY_ENVIRON: 1784 if (datalen == 0 || data[datalen - 1] != '\0') 1785 fatalx("bad MSG_IDENTIFY_ENVIRON string"); 1786 if (strchr(data, '=') != NULL) 1787 environ_put(c->environ, data); 1788 log_debug("client %p IDENTIFY_ENVIRON %s", c, data); 1789 break; 1790 case MSG_IDENTIFY_CLIENTPID: 1791 if (datalen != sizeof c->pid) 1792 fatalx("bad MSG_IDENTIFY_CLIENTPID size"); 1793 memcpy(&c->pid, data, sizeof c->pid); 1794 log_debug("client %p IDENTIFY_CLIENTPID %ld", c, (long)c->pid); 1795 break; 1796 default: 1797 break; 1798 } 1799 1800 if (imsg->hdr.type != MSG_IDENTIFY_DONE) 1801 return; 1802 c->flags |= CLIENT_IDENTIFIED; 1803 1804 if (*c->ttyname != '\0') 1805 name = xstrdup(c->ttyname); 1806 else 1807 xasprintf(&name, "client-%ld", (long)c->pid); 1808 c->name = name; 1809 log_debug("client %p name is %s", c, c->name); 1810 1811 if (c->flags & CLIENT_CONTROL) { 1812 c->stdin_callback = control_callback; 1813 1814 evbuffer_free(c->stderr_data); 1815 c->stderr_data = c->stdout_data; 1816 1817 if (c->flags & CLIENT_CONTROLCONTROL) 1818 evbuffer_add_printf(c->stdout_data, "\033P1000p"); 1819 proc_send(c->peer, MSG_STDIN, -1, NULL, 0); 1820 1821 c->tty.fd = -1; 1822 1823 close(c->fd); 1824 c->fd = -1; 1825 1826 return; 1827 } 1828 1829 if (c->fd == -1) 1830 return; 1831 if (tty_init(&c->tty, c, c->fd, c->term) != 0) { 1832 close(c->fd); 1833 c->fd = -1; 1834 return; 1835 } 1836 if (c->flags & CLIENT_UTF8) 1837 c->tty.flags |= TTY_UTF8; 1838 if (c->flags & CLIENT_256COLOURS) 1839 c->tty.term_flags |= TERM_256COLOURS; 1840 1841 tty_resize(&c->tty); 1842 1843 if (!(c->flags & CLIENT_CONTROL)) 1844 c->flags |= CLIENT_TERMINAL; 1845 } 1846 1847 /* Handle shell message. */ 1848 static void 1849 server_client_dispatch_shell(struct client *c) 1850 { 1851 const char *shell; 1852 1853 shell = options_get_string(global_s_options, "default-shell"); 1854 if (*shell == '\0' || areshell(shell)) 1855 shell = _PATH_BSHELL; 1856 proc_send(c->peer, MSG_SHELL, -1, shell, strlen(shell) + 1); 1857 1858 proc_kill_peer(c->peer); 1859 } 1860 1861 /* Event callback to push more stdout data if any left. */ 1862 static void 1863 server_client_stdout_cb(__unused int fd, __unused short events, void *arg) 1864 { 1865 struct client *c = arg; 1866 1867 if (~c->flags & CLIENT_DEAD) 1868 server_client_push_stdout(c); 1869 server_client_unref(c); 1870 } 1871 1872 /* Push stdout to client if possible. */ 1873 void 1874 server_client_push_stdout(struct client *c) 1875 { 1876 struct msg_stdout_data data; 1877 size_t sent, left; 1878 1879 left = EVBUFFER_LENGTH(c->stdout_data); 1880 while (left != 0) { 1881 sent = left; 1882 if (sent > sizeof data.data) 1883 sent = sizeof data.data; 1884 memcpy(data.data, EVBUFFER_DATA(c->stdout_data), sent); 1885 data.size = sent; 1886 1887 if (proc_send(c->peer, MSG_STDOUT, -1, &data, sizeof data) != 0) 1888 break; 1889 evbuffer_drain(c->stdout_data, sent); 1890 1891 left = EVBUFFER_LENGTH(c->stdout_data); 1892 log_debug("%s: client %p, sent %zu, left %zu", __func__, c, 1893 sent, left); 1894 } 1895 if (left != 0) { 1896 c->references++; 1897 event_once(-1, EV_TIMEOUT, server_client_stdout_cb, c, NULL); 1898 log_debug("%s: client %p, queued", __func__, c); 1899 } 1900 } 1901 1902 /* Event callback to push more stderr data if any left. */ 1903 static void 1904 server_client_stderr_cb(__unused int fd, __unused short events, void *arg) 1905 { 1906 struct client *c = arg; 1907 1908 if (~c->flags & CLIENT_DEAD) 1909 server_client_push_stderr(c); 1910 server_client_unref(c); 1911 } 1912 1913 /* Push stderr to client if possible. */ 1914 void 1915 server_client_push_stderr(struct client *c) 1916 { 1917 struct msg_stderr_data data; 1918 size_t sent, left; 1919 1920 if (c->stderr_data == c->stdout_data) { 1921 server_client_push_stdout(c); 1922 return; 1923 } 1924 1925 left = EVBUFFER_LENGTH(c->stderr_data); 1926 while (left != 0) { 1927 sent = left; 1928 if (sent > sizeof data.data) 1929 sent = sizeof data.data; 1930 memcpy(data.data, EVBUFFER_DATA(c->stderr_data), sent); 1931 data.size = sent; 1932 1933 if (proc_send(c->peer, MSG_STDERR, -1, &data, sizeof data) != 0) 1934 break; 1935 evbuffer_drain(c->stderr_data, sent); 1936 1937 left = EVBUFFER_LENGTH(c->stderr_data); 1938 log_debug("%s: client %p, sent %zu, left %zu", __func__, c, 1939 sent, left); 1940 } 1941 if (left != 0) { 1942 c->references++; 1943 event_once(-1, EV_TIMEOUT, server_client_stderr_cb, c, NULL); 1944 log_debug("%s: client %p, queued", __func__, c); 1945 } 1946 } 1947 1948 /* Add to client message log. */ 1949 void 1950 server_client_add_message(struct client *c, const char *fmt, ...) 1951 { 1952 struct message_entry *msg, *msg1; 1953 char *s; 1954 va_list ap; 1955 u_int limit; 1956 1957 va_start(ap, fmt); 1958 xvasprintf(&s, fmt, ap); 1959 va_end(ap); 1960 1961 log_debug("message %s (client %p)", s, c); 1962 1963 msg = xcalloc(1, sizeof *msg); 1964 msg->msg_time = time(NULL); 1965 msg->msg_num = c->message_next++; 1966 msg->msg = s; 1967 TAILQ_INSERT_TAIL(&c->message_log, msg, entry); 1968 1969 limit = options_get_number(global_options, "message-limit"); 1970 TAILQ_FOREACH_SAFE(msg, &c->message_log, entry, msg1) { 1971 if (msg->msg_num + limit >= c->message_next) 1972 break; 1973 free(msg->msg); 1974 TAILQ_REMOVE(&c->message_log, msg, entry); 1975 free(msg); 1976 } 1977 } 1978 1979 /* Get client working directory. */ 1980 const char * 1981 server_client_get_cwd(struct client *c, struct session *s) 1982 { 1983 const char *home; 1984 1985 if (c != NULL && c->session == NULL && c->cwd != NULL) 1986 return (c->cwd); 1987 if (s != NULL && s->cwd != NULL) 1988 return (s->cwd); 1989 if (c != NULL && (s = c->session) != NULL && s->cwd != NULL) 1990 return (s->cwd); 1991 if ((home = find_home()) != NULL) 1992 return (home); 1993 return ("/"); 1994 } 1995 1996 /* Resolve an absolute path or relative to client working directory. */ 1997 char * 1998 server_client_get_path(struct client *c, const char *file) 1999 { 2000 char *path, resolved[PATH_MAX]; 2001 2002 if (*file == '/') 2003 path = xstrdup(file); 2004 else 2005 xasprintf(&path, "%s/%s", server_client_get_cwd(c, NULL), file); 2006 if (realpath(path, resolved) == NULL) 2007 return (path); 2008 free(path); 2009 return (xstrdup(resolved)); 2010 } 2011