1/* $OpenBSD: session.c,v 1.96 2023/09/02 08:38:37 nicm Exp $ */ 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 <paths.h> 23#include <string.h> 24#include <stdlib.h> 25#include <unistd.h> 26#include <vis.h> 27#include <time.h> 28 29#include "tmux.h" 30 31struct sessions sessions; 32u_int next_session_id; 33struct session_groups session_groups = RB_INITIALIZER(&session_groups); 34 35static void session_free(int, short, void *); 36 37static void session_lock_timer(int, short, void *); 38 39static struct winlink *session_next_alert(struct winlink *); 40static struct winlink *session_previous_alert(struct winlink *); 41 42static void session_group_remove(struct session *); 43static void session_group_synchronize1(struct session *, struct session *); 44 45int 46session_cmp(struct session *s1, struct session *s2) 47{ 48 return (strcmp(s1->name, s2->name)); 49} 50RB_GENERATE(sessions, session, entry, session_cmp); 51 52static int 53session_group_cmp(struct session_group *s1, struct session_group *s2) 54{ 55 return (strcmp(s1->name, s2->name)); 56} 57RB_GENERATE_STATIC(session_groups, session_group, entry, session_group_cmp); 58 59/* 60 * Find if session is still alive. This is true if it is still on the global 61 * sessions list. 62 */ 63int 64session_alive(struct session *s) 65{ 66 struct session *s_loop; 67 68 RB_FOREACH(s_loop, sessions, &sessions) { 69 if (s_loop == s) 70 return (1); 71 } 72 return (0); 73} 74 75/* Find session by name. */ 76struct session * 77session_find(const char *name) 78{ 79 struct session s; 80 81 s.name = (char *) name; 82 return (RB_FIND(sessions, &sessions, &s)); 83} 84 85/* Find session by id parsed from a string. */ 86struct session * 87session_find_by_id_str(const char *s) 88{ 89 const char *errstr; 90 u_int id; 91 92 if (*s != '$') 93 return (NULL); 94 95 id = strtonum(s + 1, 0, UINT_MAX, &errstr); 96 if (errstr != NULL) 97 return (NULL); 98 return (session_find_by_id(id)); 99} 100 101/* Find session by id. */ 102struct session * 103session_find_by_id(u_int id) 104{ 105 struct session *s; 106 107 RB_FOREACH(s, sessions, &sessions) { 108 if (s->id == id) 109 return (s); 110 } 111 return (NULL); 112} 113 114/* Create a new session. */ 115struct session * 116session_create(const char *prefix, const char *name, const char *cwd, 117 struct environ *env, struct options *oo, struct termios *tio) 118{ 119 struct session *s; 120 121 s = xcalloc(1, sizeof *s); 122 s->references = 1; 123 s->flags = 0; 124 125 s->cwd = xstrdup(cwd); 126 127 TAILQ_INIT(&s->lastw); 128 RB_INIT(&s->windows); 129 130 s->environ = env; 131 s->options = oo; 132 133 status_update_cache(s); 134 135 s->tio = NULL; 136 if (tio != NULL) { 137 s->tio = xmalloc(sizeof *s->tio); 138 memcpy(s->tio, tio, sizeof *s->tio); 139 } 140 141 if (name != NULL) { 142 s->name = xstrdup(name); 143 s->id = next_session_id++; 144 } else { 145 do { 146 s->id = next_session_id++; 147 free(s->name); 148 if (prefix != NULL) 149 xasprintf(&s->name, "%s-%u", prefix, s->id); 150 else 151 xasprintf(&s->name, "%u", s->id); 152 } while (RB_FIND(sessions, &sessions, s) != NULL); 153 } 154 RB_INSERT(sessions, &sessions, s); 155 156 log_debug("new session %s $%u", s->name, s->id); 157 158 if (gettimeofday(&s->creation_time, NULL) != 0) 159 fatal("gettimeofday failed"); 160 session_update_activity(s, &s->creation_time); 161 162 return (s); 163} 164 165/* Add a reference to a session. */ 166void 167session_add_ref(struct session *s, const char *from) 168{ 169 s->references++; 170 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references); 171} 172 173/* Remove a reference from a session. */ 174void 175session_remove_ref(struct session *s, const char *from) 176{ 177 s->references--; 178 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references); 179 180 if (s->references == 0) 181 event_once(-1, EV_TIMEOUT, session_free, s, NULL); 182} 183 184/* Free session. */ 185static void 186session_free(__unused int fd, __unused short events, void *arg) 187{ 188 struct session *s = arg; 189 190 log_debug("session %s freed (%d references)", s->name, s->references); 191 192 if (s->references == 0) { 193 environ_free(s->environ); 194 options_free(s->options); 195 196 free(s->name); 197 free(s); 198 } 199} 200 201/* Destroy a session. */ 202void 203session_destroy(struct session *s, int notify, const char *from) 204{ 205 struct winlink *wl; 206 207 log_debug("session %s destroyed (%s)", s->name, from); 208 209 if (s->curw == NULL) 210 return; 211 s->curw = NULL; 212 213 RB_REMOVE(sessions, &sessions, s); 214 if (notify) 215 notify_session("session-closed", s); 216 217 free(s->tio); 218 219 if (event_initialized(&s->lock_timer)) 220 event_del(&s->lock_timer); 221 222 session_group_remove(s); 223 224 while (!TAILQ_EMPTY(&s->lastw)) 225 winlink_stack_remove(&s->lastw, TAILQ_FIRST(&s->lastw)); 226 while (!RB_EMPTY(&s->windows)) { 227 wl = RB_ROOT(&s->windows); 228 notify_session_window("window-unlinked", s, wl->window); 229 winlink_remove(&s->windows, wl); 230 } 231 232 free((void *)s->cwd); 233 234 session_remove_ref(s, __func__); 235} 236 237/* Sanitize session name. */ 238char * 239session_check_name(const char *name) 240{ 241 char *copy, *cp, *new_name; 242 243 if (*name == '\0') 244 return (NULL); 245 copy = xstrdup(name); 246 for (cp = copy; *cp != '\0'; cp++) { 247 if (*cp == ':' || *cp == '.') 248 *cp = '_'; 249 } 250 utf8_stravis(&new_name, copy, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL); 251 free(copy); 252 return (new_name); 253} 254 255/* Lock session if it has timed out. */ 256static void 257session_lock_timer(__unused int fd, __unused short events, void *arg) 258{ 259 struct session *s = arg; 260 261 if (s->attached == 0) 262 return; 263 264 log_debug("session %s locked, activity time %lld", s->name, 265 (long long)s->activity_time.tv_sec); 266 267 server_lock_session(s); 268 recalculate_sizes(); 269} 270 271/* Update activity time. */ 272void 273session_update_activity(struct session *s, struct timeval *from) 274{ 275 struct timeval *last = &s->last_activity_time; 276 struct timeval tv; 277 278 memcpy(last, &s->activity_time, sizeof *last); 279 if (from == NULL) 280 gettimeofday(&s->activity_time, NULL); 281 else 282 memcpy(&s->activity_time, from, sizeof s->activity_time); 283 284 log_debug("session $%u %s activity %lld.%06d (last %lld.%06d)", s->id, 285 s->name, (long long)s->activity_time.tv_sec, 286 (int)s->activity_time.tv_usec, (long long)last->tv_sec, 287 (int)last->tv_usec); 288 289 if (evtimer_initialized(&s->lock_timer)) 290 evtimer_del(&s->lock_timer); 291 else 292 evtimer_set(&s->lock_timer, session_lock_timer, s); 293 294 if (s->attached != 0) { 295 timerclear(&tv); 296 tv.tv_sec = options_get_number(s->options, "lock-after-time"); 297 if (tv.tv_sec != 0) 298 evtimer_add(&s->lock_timer, &tv); 299 } 300} 301 302/* Find the next usable session. */ 303struct session * 304session_next_session(struct session *s) 305{ 306 struct session *s2; 307 308 if (RB_EMPTY(&sessions) || !session_alive(s)) 309 return (NULL); 310 311 s2 = RB_NEXT(sessions, &sessions, s); 312 if (s2 == NULL) 313 s2 = RB_MIN(sessions, &sessions); 314 if (s2 == s) 315 return (NULL); 316 return (s2); 317} 318 319/* Find the previous usable session. */ 320struct session * 321session_previous_session(struct session *s) 322{ 323 struct session *s2; 324 325 if (RB_EMPTY(&sessions) || !session_alive(s)) 326 return (NULL); 327 328 s2 = RB_PREV(sessions, &sessions, s); 329 if (s2 == NULL) 330 s2 = RB_MAX(sessions, &sessions); 331 if (s2 == s) 332 return (NULL); 333 return (s2); 334} 335 336/* Attach a window to a session. */ 337struct winlink * 338session_attach(struct session *s, struct window *w, int idx, char **cause) 339{ 340 struct winlink *wl; 341 342 if ((wl = winlink_add(&s->windows, idx)) == NULL) { 343 xasprintf(cause, "index in use: %d", idx); 344 return (NULL); 345 } 346 wl->session = s; 347 winlink_set_window(wl, w); 348 notify_session_window("window-linked", s, w); 349 350 session_group_synchronize_from(s); 351 return (wl); 352} 353 354/* Detach a window from a session. */ 355int 356session_detach(struct session *s, struct winlink *wl) 357{ 358 if (s->curw == wl && 359 session_last(s) != 0 && 360 session_previous(s, 0) != 0) 361 session_next(s, 0); 362 363 wl->flags &= ~WINLINK_ALERTFLAGS; 364 notify_session_window("window-unlinked", s, wl->window); 365 winlink_stack_remove(&s->lastw, wl); 366 winlink_remove(&s->windows, wl); 367 368 session_group_synchronize_from(s); 369 370 if (RB_EMPTY(&s->windows)) 371 return (1); 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((void *)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 wl2->flags |= WINLINK_VISITED; 693 } 694 } 695 696 /* Then free the old winlinks list. */ 697 while (!RB_EMPTY(&old_windows)) { 698 wl = RB_ROOT(&old_windows); 699 wl2 = winlink_find_by_window_id(&s->windows, wl->window->id); 700 if (wl2 == NULL) 701 notify_session_window("window-unlinked", s, wl->window); 702 winlink_remove(&old_windows, wl); 703 } 704} 705 706/* Renumber the windows across winlinks attached to a specific session. */ 707void 708session_renumber_windows(struct session *s) 709{ 710 struct winlink *wl, *wl1, *wl_new; 711 struct winlinks old_wins; 712 struct winlink_stack old_lastw; 713 int new_idx, new_curw_idx, marked_idx = -1; 714 715 /* Save and replace old window list. */ 716 memcpy(&old_wins, &s->windows, sizeof old_wins); 717 RB_INIT(&s->windows); 718 719 /* Start renumbering from the base-index if it's set. */ 720 new_idx = options_get_number(s->options, "base-index"); 721 new_curw_idx = 0; 722 723 /* Go through the winlinks and assign new indexes. */ 724 RB_FOREACH(wl, winlinks, &old_wins) { 725 wl_new = winlink_add(&s->windows, new_idx); 726 wl_new->session = s; 727 winlink_set_window(wl_new, wl->window); 728 wl_new->flags |= wl->flags & WINLINK_ALERTFLAGS; 729 730 if (wl == marked_pane.wl) 731 marked_idx = wl_new->idx; 732 if (wl == s->curw) 733 new_curw_idx = wl_new->idx; 734 735 new_idx++; 736 } 737 738 /* Fix the stack of last windows now. */ 739 memcpy(&old_lastw, &s->lastw, sizeof old_lastw); 740 TAILQ_INIT(&s->lastw); 741 TAILQ_FOREACH(wl, &old_lastw, sentry) { 742 wl->flags &= ~WINLINK_VISITED; 743 wl_new = winlink_find_by_window(&s->windows, wl->window); 744 if (wl_new != NULL) { 745 TAILQ_INSERT_TAIL(&s->lastw, wl_new, sentry); 746 wl_new->flags |= WINLINK_VISITED; 747 } 748 } 749 750 /* Set the current window. */ 751 if (marked_idx != -1) { 752 marked_pane.wl = winlink_find_by_index(&s->windows, marked_idx); 753 if (marked_pane.wl == NULL) 754 server_clear_marked(); 755 } 756 s->curw = winlink_find_by_index(&s->windows, new_curw_idx); 757 758 /* Free the old winlinks (reducing window references too). */ 759 RB_FOREACH_SAFE(wl, winlinks, &old_wins, wl1) 760 winlink_remove(&old_wins, wl); 761} 762