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>
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
*);
46 session_cmp(struct session
*s1
, struct session
*s2
)
48 return (strcmp(s1
->name
, s2
->name
));
50 RB_GENERATE(sessions
, session
, entry
, session_cmp
);
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
64 session_alive(struct session
*s
)
66 struct session
*s_loop
;
68 RB_FOREACH(s_loop
, sessions
, &sessions
) {
75 /* Find session by name. */
77 session_find(const char *name
)
81 s
.name
= (char *) name
;
82 return (RB_FIND(sessions
, &sessions
, &s
));
85 /* Find session by id parsed from a string. */
87 session_find_by_id_str(const char *s
)
95 id
= strtonum(s
+ 1, 0, UINT_MAX
, &errstr
);
98 return (session_find_by_id(id
));
101 /* Find session by id. */
103 session_find_by_id(u_int id
)
107 RB_FOREACH(s
, sessions
, &sessions
) {
114 /* Create a new session. */
116 session_create(const char *prefix
, const char *name
, const char *cwd
,
117 struct environ
*env
, struct options
*oo
, struct termios
*tio
)
121 s
= xcalloc(1, sizeof *s
);
125 s
->cwd
= xstrdup(cwd
);
127 TAILQ_INIT(&s
->lastw
);
128 RB_INIT(&s
->windows
);
133 status_update_cache(s
);
137 s
->tio
= xmalloc(sizeof *s
->tio
);
138 memcpy(s
->tio
, tio
, sizeof *s
->tio
);
142 s
->name
= xstrdup(name
);
143 s
->id
= next_session_id
++;
146 s
->id
= next_session_id
++;
149 xasprintf(&s
->name
, "%s-%u", prefix
, s
->id
);
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
);
165 /* Add a reference to a session. */
167 session_add_ref(struct session
*s
, const char *from
)
170 log_debug("%s: %s %s, now %d", __func__
, s
->name
, from
, s
->references
);
173 /* Remove a reference from a session. */
175 session_remove_ref(struct session
*s
, const char *from
)
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
);
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
);
201 /* Destroy a session. */
203 session_destroy(struct session
*s
, int notify
, const char *from
)
207 log_debug("session %s destroyed (%s)", s
->name
, from
);
213 RB_REMOVE(sessions
, &sessions
, s
);
215 notify_session("session-closed", s
);
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. */
239 session_check_name(const char *name
)
241 char *copy
, *cp
, *new_name
;
245 copy
= xstrdup(name
);
246 for (cp
= copy
; *cp
!= '\0'; cp
++) {
247 if (*cp
== ':' || *cp
== '.')
250 utf8_stravis(&new_name
, copy
, VIS_OCTAL
|VIS_CSTYLE
|VIS_TAB
|VIS_NL
);
255 /* Lock session if it has timed out. */
257 session_lock_timer(__unused
int fd
, __unused
short events
, void *arg
)
259 struct session
*s
= arg
;
261 if (s
->attached
== 0)
264 log_debug("session %s locked, activity time %lld", s
->name
,
265 (long long)s
->activity_time
.tv_sec
);
267 server_lock_session(s
);
271 /* Update activity time. */
273 session_update_activity(struct session
*s
, struct timeval
*from
)
275 struct timeval
*last
= &s
->last_activity_time
;
278 memcpy(last
, &s
->activity_time
, sizeof *last
);
280 gettimeofday(&s
->activity_time
, NULL
);
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
,
289 if (evtimer_initialized(&s
->lock_timer
))
290 evtimer_del(&s
->lock_timer
);
292 evtimer_set(&s
->lock_timer
, session_lock_timer
, s
);
294 if (s
->attached
!= 0) {
296 tv
.tv_sec
= options_get_number(s
->options
, "lock-after-time");
298 evtimer_add(&s
->lock_timer
, &tv
);
302 /* Find the next usable session. */
304 session_next_session(struct session
*s
)
308 if (RB_EMPTY(&sessions
) || !session_alive(s
))
311 s2
= RB_NEXT(sessions
, &sessions
, s
);
313 s2
= RB_MIN(sessions
, &sessions
);
319 /* Find the previous usable session. */
321 session_previous_session(struct session
*s
)
325 if (RB_EMPTY(&sessions
) || !session_alive(s
))
328 s2
= RB_PREV(sessions
, &sessions
, s
);
330 s2
= RB_MAX(sessions
, &sessions
);
336 /* Attach a window to a session. */
338 session_attach(struct session
*s
, struct window
*w
, int idx
, char **cause
)
342 if ((wl
= winlink_add(&s
->windows
, idx
)) == NULL
) {
343 xasprintf(cause
, "index in use: %d", idx
);
347 winlink_set_window(wl
, w
);
348 notify_session_window("window-linked", s
, w
);
350 session_group_synchronize_from(s
);
354 /* Detach a window from a session. */
356 session_detach(struct session
*s
, struct winlink
*wl
)
359 session_last(s
) != 0 &&
360 session_previous(s
, 0) != 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__
);
377 /* Return if session has window. */
379 session_has(struct session
*s
, struct window
*w
)
383 TAILQ_FOREACH(wl
, &w
->winlinks
, wentry
) {
384 if (wl
->session
== s
)
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
)
408 if (wl
->flags
& WINLINK_ALERTFLAGS
)
410 wl
= winlink_next(wl
);
415 /* Move session to next window. */
417 session_next(struct session
*s
, int alert
)
424 wl
= winlink_next(s
->curw
);
426 wl
= session_next_alert(wl
);
428 wl
= RB_MIN(winlinks
, &s
->windows
);
429 if (alert
&& ((wl
= session_next_alert(wl
)) == NULL
))
432 return (session_set_current(s
, wl
));
435 static struct winlink
*
436 session_previous_alert(struct winlink
*wl
)
439 if (wl
->flags
& WINLINK_ALERTFLAGS
)
441 wl
= winlink_previous(wl
);
446 /* Move session to previous window. */
448 session_previous(struct session
*s
, int alert
)
455 wl
= winlink_previous(s
->curw
);
457 wl
= session_previous_alert(wl
);
459 wl
= RB_MAX(winlinks
, &s
->windows
);
460 if (alert
&& (wl
= session_previous_alert(wl
)) == NULL
)
463 return (session_set_current(s
, wl
));
466 /* Move session to specific window. */
468 session_select(struct session
*s
, int idx
)
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
)
482 wl
= TAILQ_FIRST(&s
->lastw
);
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
;
502 winlink_stack_remove(&s
->lastw
, wl
);
503 winlink_stack_push(&s
->lastw
, s
->curw
);
505 if (options_get_number(global_options
, "focus-events")) {
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
);
517 /* Find the session group containing a session. */
518 struct session_group
*
519 session_group_contains(struct session
*target
)
521 struct session_group
*sg
;
524 RB_FOREACH(sg
, session_groups
, &session_groups
) {
525 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
533 /* Find session group by name. */
534 struct session_group
*
535 session_group_find(const char *name
)
537 struct session_group sg
;
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
)
552 sg
= xcalloc(1, sizeof *sg
);
553 sg
->name
= xstrdup(name
);
554 TAILQ_INIT(&sg
->sessions
);
556 RB_INSERT(session_groups
, &session_groups
, sg
);
560 /* Add a session to a session group. */
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. */
570 session_group_remove(struct session
*s
)
572 struct session_group
*sg
;
574 if ((sg
= session_group_contains(s
)) == NULL
)
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
);
584 /* Count number of sessions in session group. */
586 session_group_count(struct session_group
*sg
)
592 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
597 /* Count number of clients attached to sessions in session group. */
599 session_group_attached_count(struct session_group
*sg
)
605 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
610 /* Synchronize a session to its session group. */
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
)
621 TAILQ_FOREACH(target
, &sg
->sessions
, gentry
) {
626 session_group_synchronize1(target
, s
);
629 /* Synchronize a session group to a session. */
631 session_group_synchronize_from(struct session
*target
)
633 struct session_group
*sg
;
636 if ((sg
= session_group_contains(target
)) == NULL
)
639 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
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
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
;
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)
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
);
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. */
683 s
->curw
= winlink_find_by_index(&s
->windows
, s
->curw
->idx
);
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
);
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
);
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. */
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");
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
);
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
;
733 new_curw_idx
= wl_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
);
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
);