Use active pane in target window not current window for +/-. GitHub
[tmux-openbsd.git] / session.c
blobc9a98d2385c1e33dc2211cfad68c150623f1e059
1 /* $OpenBSD$ */
3 /*
4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
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.
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.
19 #include <sys/types.h>
20 #include <sys/time.h>
22 #include <paths.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <vis.h>
27 #include <time.h>
29 #include "tmux.h"
31 struct sessions sessions;
32 u_int next_session_id;
33 struct session_groups session_groups = RB_INITIALIZER(&session_groups);
35 static void session_free(int, short, void *);
37 static void session_lock_timer(int, short, void *);
39 static struct winlink *session_next_alert(struct winlink *);
40 static struct winlink *session_previous_alert(struct winlink *);
42 static void session_group_remove(struct session *);
43 static void session_group_synchronize1(struct session *, struct session *);
45 int
46 session_cmp(struct session *s1, struct session *s2)
48 return (strcmp(s1->name, s2->name));
50 RB_GENERATE(sessions, session, entry, session_cmp);
52 static int
53 session_group_cmp(struct session_group *s1, struct session_group *s2)
55 return (strcmp(s1->name, s2->name));
57 RB_GENERATE_STATIC(session_groups, session_group, entry, session_group_cmp);
60 * Find if session is still alive. This is true if it is still on the global
61 * sessions list.
63 int
64 session_alive(struct session *s)
66 struct session *s_loop;
68 RB_FOREACH(s_loop, sessions, &sessions) {
69 if (s_loop == s)
70 return (1);
72 return (0);
75 /* Find session by name. */
76 struct session *
77 session_find(const char *name)
79 struct session s;
81 s.name = (char *) name;
82 return (RB_FIND(sessions, &sessions, &s));
85 /* Find session by id parsed from a string. */
86 struct session *
87 session_find_by_id_str(const char *s)
89 const char *errstr;
90 u_int id;
92 if (*s != '$')
93 return (NULL);
95 id = strtonum(s + 1, 0, UINT_MAX, &errstr);
96 if (errstr != NULL)
97 return (NULL);
98 return (session_find_by_id(id));
101 /* Find session by id. */
102 struct session *
103 session_find_by_id(u_int id)
105 struct session *s;
107 RB_FOREACH(s, sessions, &sessions) {
108 if (s->id == id)
109 return (s);
111 return (NULL);
114 /* Create a new session. */
115 struct session *
116 session_create(const char *prefix, const char *name, const char *cwd,
117 struct environ *env, struct options *oo, struct termios *tio)
119 struct session *s;
121 s = xcalloc(1, sizeof *s);
122 s->references = 1;
123 s->flags = 0;
125 s->cwd = xstrdup(cwd);
127 TAILQ_INIT(&s->lastw);
128 RB_INIT(&s->windows);
130 s->environ = env;
131 s->options = oo;
133 status_update_cache(s);
135 s->tio = NULL;
136 if (tio != NULL) {
137 s->tio = xmalloc(sizeof *s->tio);
138 memcpy(s->tio, tio, sizeof *s->tio);
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);
154 RB_INSERT(sessions, &sessions, s);
156 log_debug("new session %s $%u", s->name, s->id);
158 if (gettimeofday(&s->creation_time, NULL) != 0)
159 fatal("gettimeofday failed");
160 session_update_activity(s, &s->creation_time);
162 return (s);
165 /* Add a reference to a session. */
166 void
167 session_add_ref(struct session *s, const char *from)
169 s->references++;
170 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references);
173 /* Remove a reference from a session. */
174 void
175 session_remove_ref(struct session *s, const char *from)
177 s->references--;
178 log_debug("%s: %s %s, now %d", __func__, s->name, from, s->references);
180 if (s->references == 0)
181 event_once(-1, EV_TIMEOUT, session_free, s, NULL);
184 /* Free session. */
185 static void
186 session_free(__unused int fd, __unused short events, void *arg)
188 struct session *s = arg;
190 log_debug("session %s freed (%d references)", s->name, s->references);
192 if (s->references == 0) {
193 environ_free(s->environ);
194 options_free(s->options);
196 free(s->name);
197 free(s);
201 /* Destroy a session. */
202 void
203 session_destroy(struct session *s, int notify, const char *from)
205 struct winlink *wl;
207 log_debug("session %s destroyed (%s)", s->name, from);
209 if (s->curw == NULL)
210 return;
211 s->curw = NULL;
213 RB_REMOVE(sessions, &sessions, s);
214 if (notify)
215 notify_session("session-closed", s);
217 free(s->tio);
219 if (event_initialized(&s->lock_timer))
220 event_del(&s->lock_timer);
222 session_group_remove(s);
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);
232 free((void *)s->cwd);
234 session_remove_ref(s, __func__);
237 /* Sanitize session name. */
238 char *
239 session_check_name(const char *name)
241 char *copy, *cp, *new_name;
243 if (*name == '\0')
244 return (NULL);
245 copy = xstrdup(name);
246 for (cp = copy; *cp != '\0'; cp++) {
247 if (*cp == ':' || *cp == '.')
248 *cp = '_';
250 utf8_stravis(&new_name, copy, VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL);
251 free(copy);
252 return (new_name);
255 /* Lock session if it has timed out. */
256 static void
257 session_lock_timer(__unused int fd, __unused short events, void *arg)
259 struct session *s = arg;
261 if (s->attached == 0)
262 return;
264 log_debug("session %s locked, activity time %lld", s->name,
265 (long long)s->activity_time.tv_sec);
267 server_lock_session(s);
268 recalculate_sizes();
271 /* Update activity time. */
272 void
273 session_update_activity(struct session *s, struct timeval *from)
275 struct timeval *last = &s->last_activity_time;
276 struct timeval tv;
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);
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);
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);
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);
302 /* Find the next usable session. */
303 struct session *
304 session_next_session(struct session *s)
306 struct session *s2;
308 if (RB_EMPTY(&sessions) || !session_alive(s))
309 return (NULL);
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);
319 /* Find the previous usable session. */
320 struct session *
321 session_previous_session(struct session *s)
323 struct session *s2;
325 if (RB_EMPTY(&sessions) || !session_alive(s))
326 return (NULL);
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);
336 /* Attach a window to a session. */
337 struct winlink *
338 session_attach(struct session *s, struct window *w, int idx, char **cause)
340 struct winlink *wl;
342 if ((wl = winlink_add(&s->windows, idx)) == NULL) {
343 xasprintf(cause, "index in use: %d", idx);
344 return (NULL);
346 wl->session = s;
347 winlink_set_window(wl, w);
348 notify_session_window("window-linked", s, w);
350 session_group_synchronize_from(s);
351 return (wl);
354 /* Detach a window from a session. */
356 session_detach(struct session *s, struct winlink *wl)
358 if (s->curw == wl &&
359 session_last(s) != 0 &&
360 session_previous(s, 0) != 0)
361 session_next(s, 0);
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);
368 session_group_synchronize_from(s);
370 if (RB_EMPTY(&s->windows)) {
371 session_destroy(s, 1, __func__);
372 return (1);
374 return (0);
377 /* Return if session has window. */
379 session_has(struct session *s, struct window *w)
381 struct winlink *wl;
383 TAILQ_FOREACH(wl, &w->winlinks, wentry) {
384 if (wl->session == s)
385 return (1);
387 return (0);
391 * Return 1 if a window is linked outside this session (not including session
392 * groups). The window must be in this session!
395 session_is_linked(struct session *s, struct window *w)
397 struct session_group *sg;
399 if ((sg = session_group_contains(s)) != NULL)
400 return (w->references != session_group_count(sg));
401 return (w->references != 1);
404 static struct winlink *
405 session_next_alert(struct winlink *wl)
407 while (wl != NULL) {
408 if (wl->flags & WINLINK_ALERTFLAGS)
409 break;
410 wl = winlink_next(wl);
412 return (wl);
415 /* Move session to next window. */
417 session_next(struct session *s, int alert)
419 struct winlink *wl;
421 if (s->curw == NULL)
422 return (-1);
424 wl = winlink_next(s->curw);
425 if (alert)
426 wl = session_next_alert(wl);
427 if (wl == NULL) {
428 wl = RB_MIN(winlinks, &s->windows);
429 if (alert && ((wl = session_next_alert(wl)) == NULL))
430 return (-1);
432 return (session_set_current(s, wl));
435 static struct winlink *
436 session_previous_alert(struct winlink *wl)
438 while (wl != NULL) {
439 if (wl->flags & WINLINK_ALERTFLAGS)
440 break;
441 wl = winlink_previous(wl);
443 return (wl);
446 /* Move session to previous window. */
448 session_previous(struct session *s, int alert)
450 struct winlink *wl;
452 if (s->curw == NULL)
453 return (-1);
455 wl = winlink_previous(s->curw);
456 if (alert)
457 wl = session_previous_alert(wl);
458 if (wl == NULL) {
459 wl = RB_MAX(winlinks, &s->windows);
460 if (alert && (wl = session_previous_alert(wl)) == NULL)
461 return (-1);
463 return (session_set_current(s, wl));
466 /* Move session to specific window. */
468 session_select(struct session *s, int idx)
470 struct winlink *wl;
472 wl = winlink_find_by_index(&s->windows, idx);
473 return (session_set_current(s, wl));
476 /* Move session to last used window. */
478 session_last(struct session *s)
480 struct winlink *wl;
482 wl = TAILQ_FIRST(&s->lastw);
483 if (wl == NULL)
484 return (-1);
485 if (wl == s->curw)
486 return (1);
488 return (session_set_current(s, wl));
491 /* Set current winlink to wl .*/
493 session_set_current(struct session *s, struct winlink *wl)
495 struct winlink *old = s->curw;
497 if (wl == NULL)
498 return (-1);
499 if (wl == s->curw)
500 return (1);
502 winlink_stack_remove(&s->lastw, wl);
503 winlink_stack_push(&s->lastw, s->curw);
504 s->curw = wl;
505 if (options_get_number(global_options, "focus-events")) {
506 if (old != NULL)
507 window_update_focus(old->window);
508 window_update_focus(wl->window);
510 winlink_clear_flags(wl);
511 window_update_activity(wl->window);
512 tty_update_window_offset(wl->window);
513 notify_session("session-window-changed", s);
514 return (0);
517 /* Find the session group containing a session. */
518 struct session_group *
519 session_group_contains(struct session *target)
521 struct session_group *sg;
522 struct session *s;
524 RB_FOREACH(sg, session_groups, &session_groups) {
525 TAILQ_FOREACH(s, &sg->sessions, gentry) {
526 if (s == target)
527 return (sg);
530 return (NULL);
533 /* Find session group by name. */
534 struct session_group *
535 session_group_find(const char *name)
537 struct session_group sg;
539 sg.name = name;
540 return (RB_FIND(session_groups, &session_groups, &sg));
543 /* Create a new session group. */
544 struct session_group *
545 session_group_new(const char *name)
547 struct session_group *sg;
549 if ((sg = session_group_find(name)) != NULL)
550 return (sg);
552 sg = xcalloc(1, sizeof *sg);
553 sg->name = xstrdup(name);
554 TAILQ_INIT(&sg->sessions);
556 RB_INSERT(session_groups, &session_groups, sg);
557 return (sg);
560 /* Add a session to a session group. */
561 void
562 session_group_add(struct session_group *sg, struct session *s)
564 if (session_group_contains(s) == NULL)
565 TAILQ_INSERT_TAIL(&sg->sessions, s, gentry);
568 /* Remove a session from its group and destroy the group if empty. */
569 static void
570 session_group_remove(struct session *s)
572 struct session_group *sg;
574 if ((sg = session_group_contains(s)) == NULL)
575 return;
576 TAILQ_REMOVE(&sg->sessions, s, gentry);
577 if (TAILQ_EMPTY(&sg->sessions)) {
578 RB_REMOVE(session_groups, &session_groups, sg);
579 free((void *)sg->name);
580 free(sg);
584 /* Count number of sessions in session group. */
585 u_int
586 session_group_count(struct session_group *sg)
588 struct session *s;
589 u_int n;
591 n = 0;
592 TAILQ_FOREACH(s, &sg->sessions, gentry)
593 n++;
594 return (n);
597 /* Count number of clients attached to sessions in session group. */
598 u_int
599 session_group_attached_count(struct session_group *sg)
601 struct session *s;
602 u_int n;
604 n = 0;
605 TAILQ_FOREACH(s, &sg->sessions, gentry)
606 n += s->attached;
607 return (n);
610 /* Synchronize a session to its session group. */
611 void
612 session_group_synchronize_to(struct session *s)
614 struct session_group *sg;
615 struct session *target;
617 if ((sg = session_group_contains(s)) == NULL)
618 return;
620 target = NULL;
621 TAILQ_FOREACH(target, &sg->sessions, gentry) {
622 if (target != s)
623 break;
625 if (target != NULL)
626 session_group_synchronize1(target, s);
629 /* Synchronize a session group to a session. */
630 void
631 session_group_synchronize_from(struct session *target)
633 struct session_group *sg;
634 struct session *s;
636 if ((sg = session_group_contains(target)) == NULL)
637 return;
639 TAILQ_FOREACH(s, &sg->sessions, gentry) {
640 if (s != target)
641 session_group_synchronize1(target, s);
646 * Synchronize a session with a target session. This means destroying all
647 * winlinks then recreating them, then updating the current window, last window
648 * stack and alerts.
650 static void
651 session_group_synchronize1(struct session *target, struct session *s)
653 struct winlinks old_windows, *ww;
654 struct winlink_stack old_lastw;
655 struct winlink *wl, *wl2;
657 /* Don't do anything if the session is empty (it'll be destroyed). */
658 ww = &target->windows;
659 if (RB_EMPTY(ww))
660 return;
662 /* If the current window has vanished, move to the next now. */
663 if (s->curw != NULL &&
664 winlink_find_by_index(ww, s->curw->idx) == NULL &&
665 session_last(s) != 0 && session_previous(s, 0) != 0)
666 session_next(s, 0);
668 /* Save the old pointer and reset it. */
669 memcpy(&old_windows, &s->windows, sizeof old_windows);
670 RB_INIT(&s->windows);
672 /* Link all the windows from the target. */
673 RB_FOREACH(wl, winlinks, ww) {
674 wl2 = winlink_add(&s->windows, wl->idx);
675 wl2->session = s;
676 winlink_set_window(wl2, wl->window);
677 notify_session_window("window-linked", s, wl2->window);
678 wl2->flags |= wl->flags & WINLINK_ALERTFLAGS;
681 /* Fix up the current window. */
682 if (s->curw != NULL)
683 s->curw = winlink_find_by_index(&s->windows, s->curw->idx);
684 else
685 s->curw = winlink_find_by_index(&s->windows, target->curw->idx);
687 /* Fix up the last window stack. */
688 memcpy(&old_lastw, &s->lastw, sizeof old_lastw);
689 TAILQ_INIT(&s->lastw);
690 TAILQ_FOREACH(wl, &old_lastw, sentry) {
691 wl2 = winlink_find_by_index(&s->windows, wl->idx);
692 if (wl2 != NULL)
693 TAILQ_INSERT_TAIL(&s->lastw, wl2, sentry);
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);
706 /* Renumber the windows across winlinks attached to a specific session. */
707 void
708 session_renumber_windows(struct session *s)
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;
715 /* Save and replace old window list. */
716 memcpy(&old_wins, &s->windows, sizeof old_wins);
717 RB_INIT(&s->windows);
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;
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;
730 if (wl == marked_pane.wl)
731 marked_idx = wl_new->idx;
732 if (wl == s->curw)
733 new_curw_idx = wl_new->idx;
735 new_idx++;
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_new = winlink_find_by_window(&s->windows, wl->window);
743 if (wl_new != NULL)
744 TAILQ_INSERT_TAIL(&s->lastw, wl_new, sentry);
747 /* Set the current window. */
748 if (marked_idx != -1) {
749 marked_pane.wl = winlink_find_by_index(&s->windows, marked_idx);
750 if (marked_pane.wl == NULL)
751 server_clear_marked();
753 s->curw = winlink_find_by_index(&s->windows, new_curw_idx);
755 /* Free the old winlinks (reducing window references too). */
756 RB_FOREACH_SAFE(wl, winlinks, &old_wins, wl1)
757 winlink_remove(&old_wins, wl);