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 static 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
);
210 RB_REMOVE(sessions
, &sessions
, s
);
212 notify_session("session-closed", s
);
216 if (event_initialized(&s
->lock_timer
))
217 event_del(&s
->lock_timer
);
219 session_group_remove(s
);
221 while (!TAILQ_EMPTY(&s
->lastw
))
222 winlink_stack_remove(&s
->lastw
, TAILQ_FIRST(&s
->lastw
));
223 while (!RB_EMPTY(&s
->windows
)) {
224 wl
= RB_ROOT(&s
->windows
);
225 notify_session_window("window-unlinked", s
, wl
->window
);
226 winlink_remove(&s
->windows
, wl
);
229 free((void *)s
->cwd
);
231 session_remove_ref(s
, __func__
);
234 /* Sanitize session name. */
236 session_check_name(const char *name
)
238 char *copy
, *cp
, *new_name
;
242 copy
= xstrdup(name
);
243 for (cp
= copy
; *cp
!= '\0'; cp
++) {
244 if (*cp
== ':' || *cp
== '.')
247 utf8_stravis(&new_name
, copy
, VIS_OCTAL
|VIS_CSTYLE
|VIS_TAB
|VIS_NL
);
252 /* Lock session if it has timed out. */
254 session_lock_timer(__unused
int fd
, __unused
short events
, void *arg
)
256 struct session
*s
= arg
;
258 if (s
->attached
== 0)
261 log_debug("session %s locked, activity time %lld", s
->name
,
262 (long long)s
->activity_time
.tv_sec
);
264 server_lock_session(s
);
268 /* Update activity time. */
270 session_update_activity(struct session
*s
, struct timeval
*from
)
272 struct timeval
*last
= &s
->last_activity_time
;
275 memcpy(last
, &s
->activity_time
, sizeof *last
);
277 gettimeofday(&s
->activity_time
, NULL
);
279 memcpy(&s
->activity_time
, from
, sizeof s
->activity_time
);
281 log_debug("session $%u %s activity %lld.%06d (last %lld.%06d)", s
->id
,
282 s
->name
, (long long)s
->activity_time
.tv_sec
,
283 (int)s
->activity_time
.tv_usec
, (long long)last
->tv_sec
,
286 if (evtimer_initialized(&s
->lock_timer
))
287 evtimer_del(&s
->lock_timer
);
289 evtimer_set(&s
->lock_timer
, session_lock_timer
, s
);
291 if (s
->attached
!= 0) {
293 tv
.tv_sec
= options_get_number(s
->options
, "lock-after-time");
295 evtimer_add(&s
->lock_timer
, &tv
);
299 /* Find the next usable session. */
301 session_next_session(struct session
*s
)
305 if (RB_EMPTY(&sessions
) || !session_alive(s
))
308 s2
= RB_NEXT(sessions
, &sessions
, s
);
310 s2
= RB_MIN(sessions
, &sessions
);
316 /* Find the previous usable session. */
318 session_previous_session(struct session
*s
)
322 if (RB_EMPTY(&sessions
) || !session_alive(s
))
325 s2
= RB_PREV(sessions
, &sessions
, s
);
327 s2
= RB_MAX(sessions
, &sessions
);
333 /* Attach a window to a session. */
335 session_attach(struct session
*s
, struct window
*w
, int idx
, char **cause
)
339 if ((wl
= winlink_add(&s
->windows
, idx
)) == NULL
) {
340 xasprintf(cause
, "index in use: %d", idx
);
344 winlink_set_window(wl
, w
);
345 notify_session_window("window-linked", s
, w
);
347 session_group_synchronize_from(s
);
351 /* Detach a window from a session. */
353 session_detach(struct session
*s
, struct winlink
*wl
)
356 session_last(s
) != 0 &&
357 session_previous(s
, 0) != 0)
360 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
361 notify_session_window("window-unlinked", s
, wl
->window
);
362 winlink_stack_remove(&s
->lastw
, wl
);
363 winlink_remove(&s
->windows
, wl
);
365 session_group_synchronize_from(s
);
367 if (RB_EMPTY(&s
->windows
)) {
368 session_destroy(s
, 1, __func__
);
374 /* Return if session has window. */
376 session_has(struct session
*s
, struct window
*w
)
380 TAILQ_FOREACH(wl
, &w
->winlinks
, wentry
) {
381 if (wl
->session
== s
)
388 * Return 1 if a window is linked outside this session (not including session
389 * groups). The window must be in this session!
392 session_is_linked(struct session
*s
, struct window
*w
)
394 struct session_group
*sg
;
396 if ((sg
= session_group_contains(s
)) != NULL
)
397 return (w
->references
!= session_group_count(sg
));
398 return (w
->references
!= 1);
401 static struct winlink
*
402 session_next_alert(struct winlink
*wl
)
405 if (wl
->flags
& WINLINK_ALERTFLAGS
)
407 wl
= winlink_next(wl
);
412 /* Move session to next window. */
414 session_next(struct session
*s
, int alert
)
421 wl
= winlink_next(s
->curw
);
423 wl
= session_next_alert(wl
);
425 wl
= RB_MIN(winlinks
, &s
->windows
);
426 if (alert
&& ((wl
= session_next_alert(wl
)) == NULL
))
429 return (session_set_current(s
, wl
));
432 static struct winlink
*
433 session_previous_alert(struct winlink
*wl
)
436 if (wl
->flags
& WINLINK_ALERTFLAGS
)
438 wl
= winlink_previous(wl
);
443 /* Move session to previous window. */
445 session_previous(struct session
*s
, int alert
)
452 wl
= winlink_previous(s
->curw
);
454 wl
= session_previous_alert(wl
);
456 wl
= RB_MAX(winlinks
, &s
->windows
);
457 if (alert
&& (wl
= session_previous_alert(wl
)) == NULL
)
460 return (session_set_current(s
, wl
));
463 /* Move session to specific window. */
465 session_select(struct session
*s
, int idx
)
469 wl
= winlink_find_by_index(&s
->windows
, idx
);
470 return (session_set_current(s
, wl
));
473 /* Move session to last used window. */
475 session_last(struct session
*s
)
479 wl
= TAILQ_FIRST(&s
->lastw
);
485 return (session_set_current(s
, wl
));
488 /* Set current winlink to wl .*/
490 session_set_current(struct session
*s
, struct winlink
*wl
)
492 struct winlink
*old
= s
->curw
;
499 winlink_stack_remove(&s
->lastw
, wl
);
500 winlink_stack_push(&s
->lastw
, s
->curw
);
502 if (options_get_number(global_options
, "focus-events")) {
503 window_update_focus(old
->window
);
504 window_update_focus(wl
->window
);
506 winlink_clear_flags(wl
);
507 window_update_activity(wl
->window
);
508 tty_update_window_offset(wl
->window
);
509 notify_session("session-window-changed", s
);
513 /* Find the session group containing a session. */
514 struct session_group
*
515 session_group_contains(struct session
*target
)
517 struct session_group
*sg
;
520 RB_FOREACH(sg
, session_groups
, &session_groups
) {
521 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
529 /* Find session group by name. */
530 struct session_group
*
531 session_group_find(const char *name
)
533 struct session_group sg
;
536 return (RB_FIND(session_groups
, &session_groups
, &sg
));
539 /* Create a new session group. */
540 struct session_group
*
541 session_group_new(const char *name
)
543 struct session_group
*sg
;
545 if ((sg
= session_group_find(name
)) != NULL
)
548 sg
= xcalloc(1, sizeof *sg
);
549 sg
->name
= xstrdup(name
);
550 TAILQ_INIT(&sg
->sessions
);
552 RB_INSERT(session_groups
, &session_groups
, sg
);
556 /* Add a session to a session group. */
558 session_group_add(struct session_group
*sg
, struct session
*s
)
560 if (session_group_contains(s
) == NULL
)
561 TAILQ_INSERT_TAIL(&sg
->sessions
, s
, gentry
);
564 /* Remove a session from its group and destroy the group if empty. */
566 session_group_remove(struct session
*s
)
568 struct session_group
*sg
;
570 if ((sg
= session_group_contains(s
)) == NULL
)
572 TAILQ_REMOVE(&sg
->sessions
, s
, gentry
);
573 if (TAILQ_EMPTY(&sg
->sessions
)) {
574 RB_REMOVE(session_groups
, &session_groups
, sg
);
575 free((void *)sg
->name
);
580 /* Count number of sessions in session group. */
582 session_group_count(struct session_group
*sg
)
588 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
593 /* Count number of clients attached to sessions in session group. */
595 session_group_attached_count(struct session_group
*sg
)
601 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
606 /* Synchronize a session to its session group. */
608 session_group_synchronize_to(struct session
*s
)
610 struct session_group
*sg
;
611 struct session
*target
;
613 if ((sg
= session_group_contains(s
)) == NULL
)
617 TAILQ_FOREACH(target
, &sg
->sessions
, gentry
) {
622 session_group_synchronize1(target
, s
);
625 /* Synchronize a session group to a session. */
627 session_group_synchronize_from(struct session
*target
)
629 struct session_group
*sg
;
632 if ((sg
= session_group_contains(target
)) == NULL
)
635 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
637 session_group_synchronize1(target
, s
);
642 * Synchronize a session with a target session. This means destroying all
643 * winlinks then recreating them, then updating the current window, last window
647 session_group_synchronize1(struct session
*target
, struct session
*s
)
649 struct winlinks old_windows
, *ww
;
650 struct winlink_stack old_lastw
;
651 struct winlink
*wl
, *wl2
;
653 /* Don't do anything if the session is empty (it'll be destroyed). */
654 ww
= &target
->windows
;
658 /* If the current window has vanished, move to the next now. */
659 if (s
->curw
!= NULL
&&
660 winlink_find_by_index(ww
, s
->curw
->idx
) == NULL
&&
661 session_last(s
) != 0 && session_previous(s
, 0) != 0)
664 /* Save the old pointer and reset it. */
665 memcpy(&old_windows
, &s
->windows
, sizeof old_windows
);
666 RB_INIT(&s
->windows
);
668 /* Link all the windows from the target. */
669 RB_FOREACH(wl
, winlinks
, ww
) {
670 wl2
= winlink_add(&s
->windows
, wl
->idx
);
672 winlink_set_window(wl2
, wl
->window
);
673 notify_session_window("window-linked", s
, wl2
->window
);
674 wl2
->flags
|= wl
->flags
& WINLINK_ALERTFLAGS
;
677 /* Fix up the current window. */
679 s
->curw
= winlink_find_by_index(&s
->windows
, s
->curw
->idx
);
681 s
->curw
= winlink_find_by_index(&s
->windows
, target
->curw
->idx
);
683 /* Fix up the last window stack. */
684 memcpy(&old_lastw
, &s
->lastw
, sizeof old_lastw
);
685 TAILQ_INIT(&s
->lastw
);
686 TAILQ_FOREACH(wl
, &old_lastw
, sentry
) {
687 wl2
= winlink_find_by_index(&s
->windows
, wl
->idx
);
689 TAILQ_INSERT_TAIL(&s
->lastw
, wl2
, sentry
);
692 /* Then free the old winlinks list. */
693 while (!RB_EMPTY(&old_windows
)) {
694 wl
= RB_ROOT(&old_windows
);
695 wl2
= winlink_find_by_window_id(&s
->windows
, wl
->window
->id
);
697 notify_session_window("window-unlinked", s
, wl
->window
);
698 winlink_remove(&old_windows
, wl
);
702 /* Renumber the windows across winlinks attached to a specific session. */
704 session_renumber_windows(struct session
*s
)
706 struct winlink
*wl
, *wl1
, *wl_new
;
707 struct winlinks old_wins
;
708 struct winlink_stack old_lastw
;
709 int new_idx
, new_curw_idx
;
711 /* Save and replace old window list. */
712 memcpy(&old_wins
, &s
->windows
, sizeof old_wins
);
713 RB_INIT(&s
->windows
);
715 /* Start renumbering from the base-index if it's set. */
716 new_idx
= options_get_number(s
->options
, "base-index");
719 /* Go through the winlinks and assign new indexes. */
720 RB_FOREACH(wl
, winlinks
, &old_wins
) {
721 wl_new
= winlink_add(&s
->windows
, new_idx
);
723 winlink_set_window(wl_new
, wl
->window
);
724 wl_new
->flags
|= wl
->flags
& WINLINK_ALERTFLAGS
;
727 new_curw_idx
= wl_new
->idx
;
732 /* Fix the stack of last windows now. */
733 memcpy(&old_lastw
, &s
->lastw
, sizeof old_lastw
);
734 TAILQ_INIT(&s
->lastw
);
735 TAILQ_FOREACH(wl
, &old_lastw
, sentry
) {
736 wl_new
= winlink_find_by_window(&s
->windows
, wl
->window
);
738 TAILQ_INSERT_TAIL(&s
->lastw
, wl_new
, sentry
);
741 /* Set the current window. */
742 s
->curw
= winlink_find_by_index(&s
->windows
, new_curw_idx
);
744 /* Free the old winlinks (reducing window references too). */
745 RB_FOREACH_SAFE(wl
, winlinks
, &old_wins
, wl1
)
746 winlink_remove(&old_wins
, wl
);