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>
27 struct session
*server_next_session(struct session
*);
28 void server_callback_identify(int, short, void *);
31 server_fill_environ(struct session
*s
, struct environ
*env
)
33 char var
[MAXPATHLEN
], *term
;
38 term
= options_get_string(&s
->options
, "default-terminal");
39 environ_set(env
, "TERM", term
);
45 xsnprintf(var
, sizeof var
, "%s,%ld,%d", socket_path
, pid
, idx
);
46 environ_set(env
, "TMUX", var
);
51 struct client
*c
, enum msgtype type
, const void *buf
, size_t len
)
53 struct imsgbuf
*ibuf
= &c
->ibuf
;
55 if (c
->flags
& CLIENT_BAD
)
57 log_debug("writing %d to client %d", type
, c
->ibuf
.fd
);
58 imsg_compose(ibuf
, type
, PROTOCOL_VERSION
, -1, -1, (void *) buf
, len
);
59 server_update_event(c
);
64 struct session
*s
, enum msgtype type
, const void *buf
, size_t len
)
69 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
70 c
= ARRAY_ITEM(&clients
, i
);
71 if (c
== NULL
|| c
->session
== NULL
)
74 server_write_client(c
, type
, buf
, len
);
79 server_redraw_client(struct client
*c
)
81 c
->flags
|= CLIENT_REDRAW
;
85 server_status_client(struct client
*c
)
87 c
->flags
|= CLIENT_STATUS
;
91 server_redraw_session(struct session
*s
)
96 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
97 c
= ARRAY_ITEM(&clients
, i
);
98 if (c
== NULL
|| c
->session
== NULL
)
101 server_redraw_client(c
);
106 server_redraw_session_group(struct session
*s
)
108 struct session_group
*sg
;
110 if ((sg
= session_group_find(s
)) == NULL
)
111 server_redraw_session(s
);
113 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
114 server_redraw_session(s
);
119 server_status_session(struct session
*s
)
124 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
125 c
= ARRAY_ITEM(&clients
, i
);
126 if (c
== NULL
|| c
->session
== NULL
)
129 server_status_client(c
);
134 server_status_session_group(struct session
*s
)
136 struct session_group
*sg
;
138 if ((sg
= session_group_find(s
)) == NULL
)
139 server_status_session(s
);
141 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
142 server_status_session(s
);
147 server_redraw_window(struct window
*w
)
152 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
153 c
= ARRAY_ITEM(&clients
, i
);
154 if (c
== NULL
|| c
->session
== NULL
)
156 if (c
->session
->curw
->window
== w
)
157 server_redraw_client(c
);
159 w
->flags
|= WINDOW_REDRAW
;
163 server_redraw_window_borders(struct window
*w
)
168 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
169 c
= ARRAY_ITEM(&clients
, i
);
170 if (c
== NULL
|| c
->session
== NULL
)
172 if (c
->session
->curw
->window
== w
)
173 c
->flags
|= CLIENT_BORDERS
;
178 server_status_window(struct window
*w
)
183 * This is slightly different. We want to redraw the status line of any
184 * clients containing this window rather than any where it is the
188 RB_FOREACH(s
, sessions
, &sessions
) {
189 if (session_has(s
, w
) != NULL
)
190 server_status_session(s
);
200 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
201 c
= ARRAY_ITEM(&clients
, i
);
202 if (c
== NULL
|| c
->session
== NULL
)
204 server_lock_client(c
);
209 server_lock_session(struct session
*s
)
214 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
215 c
= ARRAY_ITEM(&clients
, i
);
216 if (c
== NULL
|| c
->session
== NULL
|| c
->session
!= s
)
218 server_lock_client(c
);
223 server_lock_client(struct client
*c
)
227 struct msg_lock_data lockdata
;
229 if (c
->flags
& CLIENT_SUSPENDED
)
232 cmd
= options_get_string(&c
->session
->options
, "lock-command");
233 cmdlen
= strlcpy(lockdata
.cmd
, cmd
, sizeof lockdata
.cmd
);
234 if (cmdlen
>= sizeof lockdata
.cmd
)
237 tty_stop_tty(&c
->tty
);
238 tty_raw(&c
->tty
, tty_term_string(c
->tty
.term
, TTYC_SMCUP
));
239 tty_raw(&c
->tty
, tty_term_string(c
->tty
.term
, TTYC_CLEAR
));
240 tty_raw(&c
->tty
, tty_term_string(c
->tty
.term
, TTYC_E3
));
242 c
->flags
|= CLIENT_SUSPENDED
;
243 server_write_client(c
, MSG_LOCK
, &lockdata
, sizeof lockdata
);
247 server_kill_window(struct window
*w
)
249 struct session
*s
, *next_s
;
252 next_s
= RB_MIN(sessions
, &sessions
);
253 while (next_s
!= NULL
) {
255 next_s
= RB_NEXT(sessions
, &sessions
, s
);
257 if (session_has(s
, w
) == NULL
)
259 while ((wl
= winlink_find_by_window(&s
->windows
, w
)) != NULL
) {
260 if (session_detach(s
, wl
)) {
261 server_destroy_session_group(s
);
264 server_redraw_session_group(s
);
270 server_link_window(struct session
*src
, struct winlink
*srcwl
,
271 struct session
*dst
, int dstidx
, int killflag
, int selectflag
, char **cause
)
273 struct winlink
*dstwl
;
274 struct session_group
*srcsg
, *dstsg
;
276 srcsg
= session_group_find(src
);
277 dstsg
= session_group_find(dst
);
278 if (src
!= dst
&& srcsg
!= NULL
&& dstsg
!= NULL
&& srcsg
== dstsg
) {
279 xasprintf(cause
, "sessions are grouped");
285 dstwl
= winlink_find_by_index(&dst
->windows
, dstidx
);
287 if (dstwl
->window
== srcwl
->window
) {
288 xasprintf(cause
, "same index: %d", dstidx
);
293 * Can't use session_detach as it will destroy session
294 * if this makes it empty.
296 dstwl
->flags
&= ~WINLINK_ALERTFLAGS
;
297 winlink_stack_remove(&dst
->lastw
, dstwl
);
298 winlink_remove(&dst
->windows
, dstwl
);
300 /* Force select/redraw if current. */
301 if (dstwl
== dst
->curw
) {
309 dstidx
= -1 - options_get_number(&dst
->options
, "base-index");
310 dstwl
= session_attach(dst
, srcwl
->window
, dstidx
, cause
);
315 session_select(dst
, dstwl
->idx
);
316 server_redraw_session_group(dst
);
322 server_unlink_window(struct session
*s
, struct winlink
*wl
)
324 if (session_detach(s
, wl
))
325 server_destroy_session_group(s
);
327 server_redraw_session_group(s
);
331 server_destroy_pane(struct window_pane
*wp
)
333 struct window
*w
= wp
->window
;
335 struct screen_write_ctx ctx
;
340 bufferevent_free(wp
->event
);
345 if (options_get_number(&w
->options
, "remain-on-exit")) {
348 screen_write_start(&ctx
, wp
, &wp
->base
);
349 screen_write_scrollregion(&ctx
, 0, screen_size_y(ctx
.s
) - 1);
350 screen_write_cursormove(&ctx
, 0, screen_size_y(ctx
.s
) - 1);
351 screen_write_linefeed(&ctx
, 1);
352 memcpy(&gc
, &grid_default_cell
, sizeof gc
);
353 gc
.attr
|= GRID_ATTR_BRIGHT
;
354 screen_write_puts(&ctx
, &gc
, "Pane is dead");
355 screen_write_stop(&ctx
);
356 wp
->flags
|= PANE_REDRAW
;
360 layout_close_pane(wp
);
361 window_remove_pane(w
, wp
);
363 if (TAILQ_EMPTY(&w
->panes
))
364 server_kill_window(w
);
366 server_redraw_window(w
);
370 server_destroy_session_group(struct session
*s
)
372 struct session_group
*sg
;
374 if ((sg
= session_group_find(s
)) == NULL
)
375 server_destroy_session(s
);
377 TAILQ_FOREACH(s
, &sg
->sessions
, gentry
)
378 server_destroy_session(s
);
379 TAILQ_REMOVE(&session_groups
, sg
, entry
);
385 server_next_session(struct session
*s
)
387 struct session
*s_loop
, *s_out
;
390 RB_FOREACH(s_loop
, sessions
, &sessions
) {
394 timercmp(&s_loop
->activity_time
, &s_out
->activity_time
, <))
401 server_destroy_session(struct session
*s
)
404 struct session
*s_new
;
407 if (!options_get_number(&s
->options
, "detach-on-destroy"))
408 s_new
= server_next_session(s
);
412 for (i
= 0; i
< ARRAY_LENGTH(&clients
); i
++) {
413 c
= ARRAY_ITEM(&clients
, i
);
414 if (c
== NULL
|| c
->session
!= s
)
418 c
->flags
|= CLIENT_EXIT
;
420 c
->last_session
= NULL
;
422 session_update_activity(s_new
);
423 server_redraw_client(c
);
430 server_check_unattached (void)
435 * If any sessions are no longer attached and have destroy-unattached
438 RB_FOREACH(s
, sessions
, &sessions
) {
439 if (!(s
->flags
& SESSION_UNATTACHED
))
441 if (options_get_number (&s
->options
, "destroy-unattached"))
447 server_set_identify(struct client
*c
)
452 delay
= options_get_number(&c
->session
->options
, "display-panes-time");
453 tv
.tv_sec
= delay
/ 1000;
454 tv
.tv_usec
= (delay
% 1000) * 1000L;
456 evtimer_del(&c
->identify_timer
);
457 evtimer_set(&c
->identify_timer
, server_callback_identify
, c
);
458 evtimer_add(&c
->identify_timer
, &tv
);
460 c
->flags
|= CLIENT_IDENTIFY
;
461 c
->tty
.flags
|= (TTY_FREEZE
|TTY_NOCURSOR
);
462 server_redraw_client(c
);
466 server_clear_identify(struct client
*c
)
468 if (c
->flags
& CLIENT_IDENTIFY
) {
469 c
->flags
&= ~CLIENT_IDENTIFY
;
470 c
->tty
.flags
&= ~(TTY_FREEZE
|TTY_NOCURSOR
);
471 server_redraw_client(c
);
477 server_callback_identify(unused
int fd
, unused
short events
, void *data
)
479 struct client
*c
= data
;
481 server_clear_identify(c
);
485 server_update_event(struct client
*c
)
490 if (!(c
->flags
& CLIENT_BAD
))
492 if (c
->ibuf
.w
.queued
> 0)
494 event_del(&c
->event
);
495 event_set(&c
->event
, c
->ibuf
.fd
, events
, server_client_callback
, c
);
496 event_add(&c
->event
, NULL
);