1/* $OpenBSD$ */ 2 3/* 4 * Copyright (c) 2007 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/time.h> 21 22#include <string.h> 23#include <stdlib.h> 24#include <unistd.h> 25#include <time.h> 26 27#include "tmux.h" 28 29struct sessions sessions; 30u_int next_session_id; 31struct session_groups session_groups = RB_INITIALIZER(&session_groups); 32 33static void session_free(int, short, void *); 34 35static void session_lock_timer(int, short, void *); 36 37static struct winlink *session_next_alert(struct winlink *); 38static struct winlink *session_previous_alert(struct winlink *); 39 40static void session_group_remove(struct session *); 41static void session_group_synchronize1(struct session *, struct session *); 42 43int 44session_cmp(struct session *s1, struct session *s2) 45{ 46 return (strcmp(s1->name, s2->name)); 47} 48RB_GENERATE(sessions, session, entry, session_cmp); 49 50static int 51session_group_cmp(struct session_group *s1, struct session_group *s2) 52{ 53 return (strcmp(s1->name, s2->name)); 54} 55RB_GENERATE_STATIC(session_groups, session_group, entry, session_group_cmp); 56 57/* 58 * Find if session is still alive. This is true if it is still on the global 59 * sessions list. 60 */ 61int 62session_alive(struct session *s) 63{ 64 struct session *s_loop; 65 66 RB_FOREACH(s_loop, sessions, &sessions) { 67 if (s_loop == s) 68 return (1); 69 } 70 return (0); 71} 72 73/* Find session by name. */ 74struct session * 75session_find(const char *name) 76{ 77 struct session s; 78 79 s.name = __UNCONST(name); 80 return (RB_FIND(sessions, &sessions, &s)); 81} 82 83/* Find session by id parsed from a string. */ 84struct session * 85session_find_by_id_str(const char *s) 86{ 87 const char *errstr; 88 u_int id; 89 90 if (*s != '$') 91 return (NULL); 92 93 id = strtonum(s + 1, 0, UINT_MAX, &errstr); 94 if (errstr != NULL) 95 return (NULL); 96 return (session_find_by_id(id)); 97} 98 99/* Find session by id. */ 100struct session * 101session_find_by_id(u_int id) 102{ 103 struct session *s; 104 105 RB_FOREACH(s, sessions, &sessions) { 106 if (s->id == id) 107 return (s); 108 } 109 return (NULL); 110} 111 112/* Create a new session. */ 113struct session * 114session_create(const char *prefix, const char *name, const char *cwd, 115 struct environ *env, struct options *oo, struct termios *tio) 116{ 117 struct session *s; 118 119 s = xcalloc(1, sizeof *s); 120 s->references = 1; 121 s->flags = 0; 122 123 s->cwd = xstrdup(cwd); 124 125 TAILQ_INIT(&s->lastw); 126 RB_INIT(&s->windows); 127 128 s->environ = env; 129 s->options = oo; 130 131 status_update_cache(s); 132 133 s->tio = NULL; 134 if (tio != NULL) { 135 s->tio = xmalloc(sizeof *s->tio); 136 memcpy(s->tio, tio, sizeof *s->tio); 137 } 138 139 if (name != NULL) { 140 s->name = xstrdup(name); 141 s->id = next_session_id++; 142 } else { 143 do { 144 s->id = next_session_id++; 145 free(s->name); 146 if (prefix != NULL) 147 xasprintf(&s->name, "%s-%u", prefix, s->id); 148 else 149 xasprintf(&s->name, "%u", s->id); 150 } while (RB_FIND(sessions, &sessions, s) != NULL); 151 } 152 RB_INSERT(sessions, &sessions, s); 153 154 log_debug("new session %s $%u", s->name, s->id); 155 156 if (gettimeofday(&s->creation_time, NULL) != 0) 157 fatal("gettimeofday failed"); 158 session_update_activity(s, &s->creation_time); 159 160 return (s); 161} 162 163/* Add a reference to a session. */ 164void 165session_add_ref(struct session *s, const char *from) 166{ 167 s->references++; 168 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references); 169} 170 171/* Remove a reference from a session. */ 172void 173session_remove_ref(struct session *s, const char *from) 174{ 175 s->references--; 176 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references); 177 178 if (s->references == 0) 179 event_once(-1, EV_TIMEOUT, session_free, s, NULL); 180} 181 182/* Free session. */ 183static void 184session_free(__unused int fd, __unused short events, void *arg) 185{ 186 struct session *s = arg; 187 188 log_debug("session %s freed (%d references)", s->name, s->references); 189 190 if (s->references == 0) { 191 environ_free(s->environ); 192 options_free(s->options); 193 194 free(s->name); 195 free(s); 196 } 197} 198 199/* Destroy a session. */ 200void 201session_destroy(struct session *s, int notify, const char *from) 202{ 203 struct winlink *wl; 204 205 log_debug("session %s destroyed (%s)", s->name, from); 206 207 if (s->curw == NULL) 208 return; 209 s->curw = NULL; 210 211 RB_REMOVE(sessions, &sessions, s); 212 if (notify) 213 notify_session("session-closed", s); 214 215 free(s->tio); 216 217 if (event_initialized(&s->lock_timer)) 218 event_del(&s->lock_timer); 219 220 session_group_remove(s); 221 222 while (!TAILQ_EMPTY(&s->lastw)) 223 winlink_stack_remove(&s->lastw, TAILQ_FIRST(&s->lastw)); 224 while (!RB_EMPTY(&s->windows)) { 225 wl = RB_ROOT(&s->windows); 226 notify_session_window("window-unlinked", s, wl->window); 227 winlink_remove(&s->windows, wl); 228 } 229 230 free(__UNCONST(s->cwd)); 231 232 session_remove_ref(s, __func__); 233} 234 235/* Sanitize session name. */ 236char * 237session_check_name(const char *name) 238{ 239 char *copy, *cp, *new_name; 240 241 if (*name == '\0') 242 return (NULL); 243 copy = xstrdup(name); 244 for (cp = copy; *cp != '\0'; cp++) { 245 if (*cp == ':' || *cp == '.') 246 *cp = '_'; 247 } 248 utf8_stravis(&new_name, copy, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL); 249 free(copy); 250 return (new_name); 251} 252 253/* Lock session if it has timed out. */ 254static void 255session_lock_timer(__unused int fd, __unused short events, void *arg) 256{ 257 struct session *s = arg; 258 259 if (s->attached == 0) 260 return; 261 262 log_debug("session %s locked, activity time %lld", s->name, 263 (long long)s->activity_time.tv_sec); 264 265 server_lock_session(s); 266 recalculate_sizes(); 267} 268 269/* Update activity time. */ 270void 271session_update_activity(struct session *s, struct timeval *from) 272{ 273 struct timeval *last = &s->last_activity_time; 274 struct timeval tv; 275 276 memcpy(last, &s->activity_time, sizeof *last); 277 if (from == NULL) 278 gettimeofday(&s->activity_time, NULL); 279 else 280 memcpy(&s->activity_time, from, sizeof s->activity_time); 281 282 log_debug("session $%u %s activity %lld.%06d (last %lld.%06d)", s->id, 283 s->name, (long long)s->activity_time.tv_sec, 284 (int)s->activity_time.tv_usec, (long long)last->tv_sec, 285 (int)last->tv_usec); 286 287 if (evtimer_initialized(&s->lock_timer)) 288 evtimer_del(&s->lock_timer); 289 else 290 evtimer_set(&s->lock_timer, session_lock_timer, s); 291 292 if (s->attached != 0) { 293 timerclear(&tv); 294 tv.tv_sec = options_get_number(s->options, "lock-after-time"); 295 if (tv.tv_sec != 0) 296 evtimer_add(&s->lock_timer, &tv); 297 } 298} 299 300/* Find the next usable session. */ 301struct session * 302session_next_session(struct session *s) 303{ 304 struct session *s2; 305 306 if (RB_EMPTY(&sessions) || !session_alive(s)) 307 return (NULL); 308 309 s2 = RB_NEXT(sessions, &sessions, s); 310 if (s2 == NULL) 311 s2 = RB_MIN(sessions, &sessions); 312 if (s2 == s) 313 return (NULL); 314 return (s2); 315} 316 317/* Find the previous usable session. */ 318struct session * 319session_previous_session(struct session *s) 320{ 321 struct session *s2; 322 323 if (RB_EMPTY(&sessions) || !session_alive(s)) 324 return (NULL); 325 326 s2 = RB_PREV(sessions, &sessions, s); 327 if (s2 == NULL) 328 s2 = RB_MAX(sessions, &sessions); 329 if (s2 == s) 330 return (NULL); 331 return (s2); 332} 333 334/* Attach a window to a session. */ 335struct winlink * 336session_attach(struct session *s, struct window *w, int idx, char **cause) 337{ 338 struct winlink *wl; 339 340 if ((wl = winlink_add(&s->windows, idx)) == NULL) { 341 xasprintf(cause, "index in use: %d", idx); 342 return (NULL); 343 } 344 wl->session = s; 345 winlink_set_window(wl, w); 346 notify_session_window("window-linked", s, w); 347 348 session_group_synchronize_from(s); 349 return (wl); 350} 351 352/* Detach a window from a session. */ 353int 354session_detach(struct session *s, struct winlink *wl) 355{ 356 if (s->curw == wl && 357 session_last(s) != 0 && 358 session_previous(s, 0) != 0) 359 session_next(s, 0); 360 361 wl->flags &= ~WINLINK_ALERTFLAGS; 362 notify_session_window("window-unlinked", s, wl->window); 363 winlink_stack_remove(&s->lastw, wl); 364 winlink_remove(&s->windows, wl); 365 366 session_group_synchronize_from(s); 367 368 if (RB_EMPTY(&s->windows)) { 369 session_destroy(s, 1, __func__); 370 return (1); 371 } 372 return (0); 373} 374 375/* Return if session has window. */ 376int 377session_has(struct session *s, struct window *w) 378{ 379 struct winlink *wl; 380 381 TAILQ_FOREACH(wl, &w->winlinks, wentry) { 382 if (wl->session == s) 383 return (1); 384 } 385 return (0); 386} 387 388/* 389 * Return 1 if a window is linked outside this session (not including session 390 * groups). The window must be in this session! 391 */ 392int 393session_is_linked(struct session *s, struct window *w) 394{ 395 struct session_group *sg; 396 397 if ((sg = session_group_contains(s)) != NULL) 398 return (w->references != session_group_count(sg)); 399 return (w->references != 1); 400} 401 402static struct winlink * 403session_next_alert(struct winlink *wl) 404{ 405 while (wl != NULL) { 406 if (wl->flags & WINLINK_ALERTFLAGS) 407 break; 408 wl = winlink_next(wl); 409 } 410 return (wl); 411} 412 413/* Move session to next window. */ 414int 415session_next(struct session *s, int alert) 416{ 417 struct winlink *wl; 418 419 if (s->curw == NULL) 420 return (-1); 421 422 wl = winlink_next(s->curw); 423 if (alert) 424 wl = session_next_alert(wl); 425 if (wl == NULL) { 426 wl = RB_MIN(winlinks, &s->windows); 427 if (alert && ((wl = session_next_alert(wl)) == NULL)) 428 return (-1); 429 } 430 return (session_set_current(s, wl)); 431} 432 433static struct winlink * 434session_previous_alert(struct winlink *wl) 435{ 436 while (wl != NULL) { 437 if (wl->flags & WINLINK_ALERTFLAGS) 438 break; 439 wl = winlink_previous(wl); 440 } 441 return (wl); 442} 443 444/* Move session to previous window. */ 445int 446session_previous(struct session *s, int alert) 447{ 448 struct winlink *wl; 449 450 if (s->curw == NULL) 451 return (-1); 452 453 wl = winlink_previous(s->curw); 454 if (alert) 455 wl = session_previous_alert(wl); 456 if (wl == NULL) { 457 wl = RB_MAX(winlinks, &s->windows); 458 if (alert && (wl = session_previous_alert(wl)) == NULL) 459 return (-1); 460 } 461 return (session_set_current(s, wl)); 462} 463 464/* Move session to specific window. */ 465int 466session_select(struct session *s, int idx) 467{ 468 struct winlink *wl; 469 470 wl = winlink_find_by_index(&s->windows, idx); 471 return (session_set_current(s, wl)); 472} 473 474/* Move session to last used window. */ 475int 476session_last(struct session *s) 477{ 478 struct winlink *wl; 479 480 wl = TAILQ_FIRST(&s->lastw); 481 if (wl == NULL) 482 return (-1); 483 if (wl == s->curw) 484 return (1); 485 486 return (session_set_current(s, wl)); 487} 488 489/* Set current winlink to wl .*/ 490int 491session_set_current(struct session *s, struct winlink *wl) 492{ 493 struct winlink *old = s->curw; 494 495 if (wl == NULL) 496 return (-1); 497 if (wl == s->curw) 498 return (1); 499 500 winlink_stack_remove(&s->lastw, wl); 501 winlink_stack_push(&s->lastw, s->curw); 502 s->curw = wl; 503 if (options_get_number(global_options, "focus-events")) { 504 if (old != NULL) 505 window_update_focus(old->window); 506 window_update_focus(wl->window); 507 } 508 winlink_clear_flags(wl); 509 window_update_activity(wl->window); 510 tty_update_window_offset(wl->window); 511 notify_session("session-window-changed", s); 512 return (0); 513} 514 515/* Find the session group containing a session. */ 516struct session_group * 517session_group_contains(struct session *target) 518{ 519 struct session_group *sg; 520 struct session *s; 521 522 RB_FOREACH(sg, session_groups, &session_groups) { 523 TAILQ_FOREACH(s, &sg->sessions, gentry) { 524 if (s == target) 525 return (sg); 526 } 527 } 528 return (NULL); 529} 530 531/* Find session group by name. */ 532struct session_group * 533session_group_find(const char *name) 534{ 535 struct session_group sg; 536 537 sg.name = name; 538 return (RB_FIND(session_groups, &session_groups, &sg)); 539} 540 541/* Create a new session group. */ 542struct session_group * 543session_group_new(const char *name) 544{ 545 struct session_group *sg; 546 547 if ((sg = session_group_find(name)) != NULL) 548 return (sg); 549 550 sg = xcalloc(1, sizeof *sg); 551 sg->name = xstrdup(name); 552 TAILQ_INIT(&sg->sessions); 553 554 RB_INSERT(session_groups, &session_groups, sg); 555 return (sg); 556} 557 558/* Add a session to a session group. */ 559void 560session_group_add(struct session_group *sg, struct session *s) 561{ 562 if (session_group_contains(s) == NULL) 563 TAILQ_INSERT_TAIL(&sg->sessions, s, gentry); 564} 565 566/* Remove a session from its group and destroy the group if empty. */ 567static void 568session_group_remove(struct session *s) 569{ 570 struct session_group *sg; 571 572 if ((sg = session_group_contains(s)) == NULL) 573 return; 574 TAILQ_REMOVE(&sg->sessions, s, gentry); 575 if (TAILQ_EMPTY(&sg->sessions)) { 576 RB_REMOVE(session_groups, &session_groups, sg); 577 free(__UNCONST(sg->name)); 578 free(sg); 579 } 580} 581 582/* Count number of sessions in session group. */ 583u_int 584session_group_count(struct session_group *sg) 585{ 586 struct session *s; 587 u_int n; 588 589 n = 0; 590 TAILQ_FOREACH(s, &sg->sessions, gentry) 591 n++; 592 return (n); 593} 594 595/* Count number of clients attached to sessions in session group. */ 596u_int 597session_group_attached_count(struct session_group *sg) 598{ 599 struct session *s; 600 u_int n; 601 602 n = 0; 603 TAILQ_FOREACH(s, &sg->sessions, gentry) 604 n += s->attached; 605 return (n); 606} 607 608/* Synchronize a session to its session group. */ 609void 610session_group_synchronize_to(struct session *s) 611{ 612 struct session_group *sg; 613 struct session *target; 614 615 if ((sg = session_group_contains(s)) == NULL) 616 return; 617 618 target = NULL; 619 TAILQ_FOREACH(target, &sg->sessions, gentry) { 620 if (target != s) 621 break; 622 } 623 if (target != NULL) 624 session_group_synchronize1(target, s); 625} 626 627/* Synchronize a session group to a session. */ 628void 629session_group_synchronize_from(struct session *target) 630{ 631 struct session_group *sg; 632 struct session *s; 633 634 if ((sg = session_group_contains(target)) == NULL) 635 return; 636 637 TAILQ_FOREACH(s, &sg->sessions, gentry) { 638 if (s != target) 639 session_group_synchronize1(target, s); 640 } 641} 642 643/* 644 * Synchronize a session with a target session. This means destroying all 645 * winlinks then recreating them, then updating the current window, last window 646 * stack and alerts. 647 */ 648static void 649session_group_synchronize1(struct session *target, struct session *s) 650{ 651 struct winlinks old_windows, *ww; 652 struct winlink_stack old_lastw; 653 struct winlink *wl, *wl2; 654 655 /* Don't do anything if the session is empty (it'll be destroyed). */ 656 ww = &target->windows; 657 if (RB_EMPTY(ww)) 658 return; 659 660 /* If the current window has vanished, move to the next now. */ 661 if (s->curw != NULL && 662 winlink_find_by_index(ww, s->curw->idx) == NULL && 663 session_last(s) != 0 && session_previous(s, 0) != 0) 664 session_next(s, 0); 665 666 /* Save the old pointer and reset it. */ 667 memcpy(&old_windows, &s->windows, sizeof old_windows); 668 RB_INIT(&s->windows); 669 670 /* Link all the windows from the target. */ 671 RB_FOREACH(wl, winlinks, ww) { 672 wl2 = winlink_add(&s->windows, wl->idx); 673 wl2->session = s; 674 winlink_set_window(wl2, wl->window); 675 notify_session_window("window-linked", s, wl2->window); 676 wl2->flags |= wl->flags & WINLINK_ALERTFLAGS; 677 } 678 679 /* Fix up the current window. */ 680 if (s->curw != NULL) 681 s->curw = winlink_find_by_index(&s->windows, s->curw->idx); 682 else 683 s->curw = winlink_find_by_index(&s->windows, target->curw->idx); 684 685 /* Fix up the last window stack. */ 686 memcpy(&old_lastw, &s->lastw, sizeof old_lastw); 687 TAILQ_INIT(&s->lastw); 688 TAILQ_FOREACH(wl, &old_lastw, sentry) { 689 wl2 = winlink_find_by_index(&s->windows, wl->idx); 690 if (wl2 != NULL) 691 TAILQ_INSERT_TAIL(&s->lastw, wl2, sentry); 692 } 693 694 /* Then free the old winlinks list. */ 695 while (!RB_EMPTY(&old_windows)) { 696 wl = RB_ROOT(&old_windows); 697 wl2 = winlink_find_by_window_id(&s->windows, wl->window->id); 698 if (wl2 == NULL) 699 notify_session_window("window-unlinked", s, wl->window); 700 winlink_remove(&old_windows, wl); 701 } 702} 703 704/* Renumber the windows across winlinks attached to a specific session. */ 705void 706session_renumber_windows(struct session *s) 707{ 708 struct winlink *wl, *wl1, *wl_new; 709 struct winlinks old_wins; 710 struct winlink_stack old_lastw; 711 int new_idx, new_curw_idx; 712 713 /* Save and replace old window list. */ 714 memcpy(&old_wins, &s->windows, sizeof old_wins); 715 RB_INIT(&s->windows); 716 717 /* Start renumbering from the base-index if it's set. */ 718 new_idx = options_get_number(s->options, "base-index"); 719 new_curw_idx = 0; 720 721 /* Go through the winlinks and assign new indexes. */ 722 RB_FOREACH(wl, winlinks, &old_wins) { 723 wl_new = winlink_add(&s->windows, new_idx); 724 wl_new->session = s; 725 winlink_set_window(wl_new, wl->window); 726 wl_new->flags |= wl->flags & WINLINK_ALERTFLAGS; 727 728 if (wl == s->curw) 729 new_curw_idx = wl_new->idx; 730 731 new_idx++; 732 } 733 734 /* Fix the stack of last windows now. */ 735 memcpy(&old_lastw, &s->lastw, sizeof old_lastw); 736 TAILQ_INIT(&s->lastw); 737 TAILQ_FOREACH(wl, &old_lastw, sentry) { 738 wl_new = winlink_find_by_window(&s->windows, wl->window); 739 if (wl_new != NULL) 740 TAILQ_INSERT_TAIL(&s->lastw, wl_new, sentry); 741 } 742 743 /* Set the current window. */ 744 s->curw = winlink_find_by_index(&s->windows, new_curw_idx); 745 746 /* Free the old winlinks (reducing window references too). */ 747 RB_FOREACH_SAFE(wl, winlinks, &old_wins, wl1) 748 winlink_remove(&old_wins, wl); 749} 750