4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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>
30 /* Global session list. */
31 struct sessions sessions
;
32 struct sessions dead_sessions
;
34 struct session_groups session_groups
;
36 struct winlink
*session_next_alert(struct winlink
*);
37 struct winlink
*session_previous_alert(struct winlink
*);
39 RB_GENERATE(sessions
, session
, entry
, session_cmp
);
42 session_cmp(struct session
*s1
, struct session
*s2
)
44 return (strcmp(s1
->name
, s2
->name
));
48 * Find if session is still alive. This is true if it is still on the global
52 session_alive(struct session
*s
)
54 struct session
*s_loop
;
56 RB_FOREACH(s_loop
, sessions
, &sessions
) {
63 /* Find session by name. */
65 session_find(const char *name
)
69 s
.name
= (char *) name
;
70 return (RB_FIND(sessions
, &sessions
, &s
));
73 /* Find session by index. */
75 session_find_by_index(u_int idx
)
79 RB_FOREACH(s
, sessions
, &sessions
) {
86 /* Create a new session. */
88 session_create(const char *name
, const char *cmd
, const char *cwd
,
89 struct environ
*env
, struct termios
*tio
, int idx
, u_int sx
, u_int sy
,
94 s
= xmalloc(sizeof *s
);
98 if (gettimeofday(&s
->creation_time
, NULL
) != 0)
99 fatal("gettimeofday failed");
100 session_update_activity(s
);
102 s
->cwd
= xstrdup(cwd
);
105 TAILQ_INIT(&s
->lastw
);
106 RB_INIT(&s
->windows
);
108 options_init(&s
->options
, &global_s_options
);
109 environ_init(&s
->environ
);
111 environ_copy(env
, &s
->environ
);
115 s
->tio
= xmalloc(sizeof *s
->tio
);
116 memcpy(s
->tio
, tio
, sizeof *s
->tio
);
123 s
->name
= xstrdup(name
);
124 s
->idx
= next_session
++;
128 s
->idx
= next_session
++;
131 xasprintf(&s
->name
, "%u", s
->idx
);
132 } while (RB_FIND(sessions
, &sessions
, s
) != NULL
);
134 RB_INSERT(sessions
, &sessions
, s
);
137 if (session_new(s
, NULL
, cmd
, cwd
, idx
, cause
) == NULL
) {
141 session_select(s
, RB_ROOT(&s
->windows
)->idx
);
144 log_debug("session %s created", s
->name
);
149 /* Destroy a session. */
151 session_destroy(struct session
*s
)
153 log_debug("session %s destroyed", s
->name
);
155 RB_REMOVE(sessions
, &sessions
, s
);
160 session_group_remove(s
);
161 environ_free(&s
->environ
);
162 options_free(&s
->options
);
164 while (!TAILQ_EMPTY(&s
->lastw
))
165 winlink_stack_remove(&s
->lastw
, TAILQ_FIRST(&s
->lastw
));
166 while (!RB_EMPTY(&s
->windows
))
167 winlink_remove(&s
->windows
, RB_ROOT(&s
->windows
));
171 RB_INSERT(sessions
, &dead_sessions
, s
);
174 /* Check a session name is valid: not empty and no colons. */
176 session_check_name(const char *name
)
178 return (*name
!= '\0' && strchr(name
, ':') == NULL
);
181 /* Update session active time. */
183 session_update_activity(struct session
*s
)
185 if (gettimeofday(&s
->activity_time
, NULL
) != 0)
186 fatal("gettimeofday");
189 /* Find the next usable session. */
191 session_next_session(struct session
*s
)
195 if (RB_EMPTY(&sessions
) || !session_alive(s
))
198 s2
= RB_NEXT(sessions
, &sessions
, s
);
200 s2
= RB_MIN(sessions
, &sessions
);
206 /* Find the previous usable session. */
208 session_previous_session(struct session
*s
)
212 if (RB_EMPTY(&sessions
) || !session_alive(s
))
215 s2
= RB_PREV(sessions
, &sessions
, s
);
217 s2
= RB_MAX(sessions
, &sessions
);
223 /* Create a new window on a session. */
225 session_new(struct session
*s
,
226 const char *name
, const char *cmd
, const char *cwd
, int idx
, char **cause
)
234 if ((wl
= winlink_add(&s
->windows
, idx
)) == NULL
) {
235 xasprintf(cause
, "index in use: %d", idx
);
240 environ_copy(&global_environ
, &env
);
241 environ_copy(&s
->environ
, &env
);
242 server_fill_environ(s
, &env
);
244 shell
= options_get_string(&s
->options
, "default-shell");
245 if (*shell
== '\0' || areshell(shell
))
246 shell
= _PATH_BSHELL
;
248 hlimit
= options_get_number(&s
->options
, "history-limit");
250 name
, cmd
, shell
, cwd
, &env
, s
->tio
, s
->sx
, s
->sy
, hlimit
, cause
);
252 winlink_remove(&s
->windows
, wl
);
256 winlink_set_window(wl
, w
);
259 if (options_get_number(&s
->options
, "set-remain-on-exit"))
260 options_set_number(&w
->options
, "remain-on-exit", 1);
262 session_group_synchronize_from(s
);
266 /* Attach a window to a session. */
268 session_attach(struct session
*s
, struct window
*w
, int idx
, char **cause
)
272 if ((wl
= winlink_add(&s
->windows
, idx
)) == NULL
) {
273 xasprintf(cause
, "index in use: %d", idx
);
276 winlink_set_window(wl
, w
);
278 session_group_synchronize_from(s
);
282 /* Detach a window from a session. */
284 session_detach(struct session
*s
, struct winlink
*wl
)
287 session_last(s
) != 0 && session_previous(s
, 0) != 0)
290 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
291 winlink_stack_remove(&s
->lastw
, wl
);
292 winlink_remove(&s
->windows
, wl
);
293 session_group_synchronize_from(s
);
294 if (RB_EMPTY(&s
->windows
)) {
301 /* Return if session has window. */
303 session_has(struct session
*s
, struct window
*w
)
307 RB_FOREACH(wl
, winlinks
, &s
->windows
) {
315 session_next_alert(struct winlink
*wl
)
318 if (wl
->flags
& WINLINK_ALERTFLAGS
)
320 wl
= winlink_next(wl
);
325 /* Move session to next window. */
327 session_next(struct session
*s
, int alert
)
334 wl
= winlink_next(s
->curw
);
336 wl
= session_next_alert(wl
);
338 wl
= RB_MIN(winlinks
, &s
->windows
);
339 if (alert
&& ((wl
= session_next_alert(wl
)) == NULL
))
344 winlink_stack_remove(&s
->lastw
, wl
);
345 winlink_stack_push(&s
->lastw
, s
->curw
);
347 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
352 session_previous_alert(struct winlink
*wl
)
355 if (wl
->flags
& WINLINK_ALERTFLAGS
)
357 wl
= winlink_previous(wl
);
362 /* Move session to previous window. */
364 session_previous(struct session
*s
, int alert
)
371 wl
= winlink_previous(s
->curw
);
373 wl
= session_previous_alert(wl
);
375 wl
= RB_MAX(winlinks
, &s
->windows
);
376 if (alert
&& (wl
= session_previous_alert(wl
)) == NULL
)
381 winlink_stack_remove(&s
->lastw
, wl
);
382 winlink_stack_push(&s
->lastw
, s
->curw
);
384 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
388 /* Move session to specific window. */
390 session_select(struct session
*s
, int idx
)
394 wl
= winlink_find_by_index(&s
->windows
, idx
);
399 winlink_stack_remove(&s
->lastw
, wl
);
400 winlink_stack_push(&s
->lastw
, s
->curw
);
402 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
406 /* Move session to last used window. */
408 session_last(struct session
*s
)
412 wl
= TAILQ_FIRST(&s
->lastw
);
418 winlink_stack_remove(&s
->lastw
, wl
);
419 winlink_stack_push(&s
->lastw
, s
->curw
);
421 wl
->flags
&= ~WINLINK_ALERTFLAGS
;
425 /* Find the session group containing a session. */
426 struct session_group
*
427 session_group_find(struct session
*target
)
429 struct session_group
*sg
;
432 TAILQ_FOREACH(sg
, &session_groups
, entry
) {
433 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
441 /* Find session group index. */
443 session_group_index(struct session_group
*sg
)
445 struct session_group
*sg2
;
449 TAILQ_FOREACH(sg2
, &session_groups
, entry
) {
455 fatalx("session group not found");
459 * Add a session to the session group containing target, creating it if
463 session_group_add(struct session
*target
, struct session
*s
)
465 struct session_group
*sg
;
467 if ((sg
= session_group_find(target
)) == NULL
) {
468 sg
= xmalloc(sizeof *sg
);
469 TAILQ_INSERT_TAIL(&session_groups
, sg
, entry
);
470 TAILQ_INIT(&sg
->sessions
);
471 TAILQ_INSERT_TAIL(&sg
->sessions
, target
, gentry
);
473 TAILQ_INSERT_TAIL(&sg
->sessions
, s
, gentry
);
476 /* Remove a session from its group and destroy the group if empty. */
478 session_group_remove(struct session
*s
)
480 struct session_group
*sg
;
482 if ((sg
= session_group_find(s
)) == NULL
)
484 TAILQ_REMOVE(&sg
->sessions
, s
, gentry
);
485 if (TAILQ_NEXT(TAILQ_FIRST(&sg
->sessions
), gentry
) == NULL
)
486 TAILQ_REMOVE(&sg
->sessions
, TAILQ_FIRST(&sg
->sessions
), gentry
);
487 if (TAILQ_EMPTY(&sg
->sessions
)) {
488 TAILQ_REMOVE(&session_groups
, sg
, entry
);
493 /* Synchronize a session to its session group. */
495 session_group_synchronize_to(struct session
*s
)
497 struct session_group
*sg
;
498 struct session
*target
;
500 if ((sg
= session_group_find(s
)) == NULL
)
504 TAILQ_FOREACH(target
, &sg
->sessions
, gentry
) {
508 session_group_synchronize1(target
, s
);
511 /* Synchronize a session group to a session. */
513 session_group_synchronize_from(struct session
*target
)
515 struct session_group
*sg
;
518 if ((sg
= session_group_find(target
)) == NULL
)
521 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
) {
523 session_group_synchronize1(target
, s
);
528 * Synchronize a session with a target session. This means destroying all
529 * winlinks then recreating them, then updating the current window, last window
533 session_group_synchronize1(struct session
*target
, struct session
*s
)
535 struct winlinks old_windows
, *ww
;
536 struct winlink_stack old_lastw
;
537 struct winlink
*wl
, *wl2
;
539 /* Don't do anything if the session is empty (it'll be destroyed). */
540 ww
= &target
->windows
;
544 /* If the current window has vanished, move to the next now. */
545 if (s
->curw
!= NULL
&&
546 winlink_find_by_index(ww
, s
->curw
->idx
) == NULL
&&
547 session_last(s
) != 0 && session_previous(s
, 0) != 0)
550 /* Save the old pointer and reset it. */
551 memcpy(&old_windows
, &s
->windows
, sizeof old_windows
);
552 RB_INIT(&s
->windows
);
554 /* Link all the windows from the target. */
555 RB_FOREACH(wl
, winlinks
, ww
) {
556 wl2
= winlink_add(&s
->windows
, wl
->idx
);
557 winlink_set_window(wl2
, wl
->window
);
558 wl2
->flags
|= wl
->flags
& WINLINK_ALERTFLAGS
;
561 /* Fix up the current window. */
563 s
->curw
= winlink_find_by_index(&s
->windows
, s
->curw
->idx
);
565 s
->curw
= winlink_find_by_index(&s
->windows
, target
->curw
->idx
);
567 /* Fix up the last window stack. */
568 memcpy(&old_lastw
, &s
->lastw
, sizeof old_lastw
);
569 TAILQ_INIT(&s
->lastw
);
570 TAILQ_FOREACH(wl
, &old_lastw
, sentry
) {
571 wl2
= winlink_find_by_index(&s
->windows
, wl
->idx
);
573 TAILQ_INSERT_TAIL(&s
->lastw
, wl2
, sentry
);
576 /* Then free the old winlinks list. */
577 while (!RB_EMPTY(&old_windows
)) {
578 wl
= RB_ROOT(&old_windows
);
579 winlink_remove(&old_windows
, wl
);