1: /* $OpenBSD$ */
2:
3: /*
4: * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
5: *
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.
9: *
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.
17: */
18:
19: #include <sys/types.h>
20: #include <sys/uio.h>
21:
22: #include <stdlib.h>
23: #include <string.h>
24: #include <time.h>
25: #include <unistd.h>
26:
27: #include "tmux.h"
28:
29: static struct session *server_next_session(struct session *);
30: static void server_destroy_session_group(struct session *);
31:
32: void
33: server_redraw_client(struct client *c)
34: {
35: c->flags |= CLIENT_REDRAW;
36: }
37:
38: void
39: server_status_client(struct client *c)
40: {
41: c->flags |= CLIENT_STATUS;
42: }
43:
44: void
45: server_redraw_session(struct session *s)
46: {
47: struct client *c;
48:
49: TAILQ_FOREACH(c, &clients, entry) {
50: if (c->session == s)
51: server_redraw_client(c);
52: }
53: }
54:
55: void
56: server_redraw_session_group(struct session *s)
57: {
58: struct session_group *sg;
59:
60: if ((sg = session_group_contains(s)) == NULL)
61: server_redraw_session(s);
62: else {
63: TAILQ_FOREACH(s, &sg->sessions, gentry)
64: server_redraw_session(s);
65: }
66: }
67:
68: void
69: server_status_session(struct session *s)
70: {
71: struct client *c;
72:
73: TAILQ_FOREACH(c, &clients, entry) {
74: if (c->session == s)
75: server_status_client(c);
76: }
77: }
78:
79: void
80: server_status_session_group(struct session *s)
81: {
82: struct session_group *sg;
83:
84: if ((sg = session_group_contains(s)) == NULL)
85: server_status_session(s);
86: else {
87: TAILQ_FOREACH(s, &sg->sessions, gentry)
88: server_status_session(s);
89: }
90: }
91:
92: void
93: server_redraw_window(struct window *w)
94: {
95: struct client *c;
96:
97: TAILQ_FOREACH(c, &clients, entry) {
98: if (c->session != NULL && c->session->curw->window == w)
99: server_redraw_client(c);
100: }
101: }
102:
103: void
104: server_redraw_window_borders(struct window *w)
105: {
106: struct client *c;
107:
108: TAILQ_FOREACH(c, &clients, entry) {
109: if (c->session != NULL && c->session->curw->window == w)
110: c->flags |= CLIENT_BORDERS;
111: }
112: }
113:
114: void
115: server_status_window(struct window *w)
116: {
117: struct session *s;
118:
119: /*
120: * This is slightly different. We want to redraw the status line of any
121: * clients containing this window rather than anywhere it is the
122: * current window.
123: */
124:
125: RB_FOREACH(s, sessions, &sessions) {
126: if (session_has(s, w))
127: server_status_session(s);
128: }
129: }
130:
131: void
132: server_lock(void)
133: {
134: struct client *c;
135:
136: TAILQ_FOREACH(c, &clients, entry) {
137: if (c->session != NULL)
138: server_lock_client(c);
139: }
140: }
141:
142: void
143: server_lock_session(struct session *s)
144: {
145: struct client *c;
146:
147: TAILQ_FOREACH(c, &clients, entry) {
148: if (c->session == s)
149: server_lock_client(c);
150: }
151: }
152:
153: void
154: server_lock_client(struct client *c)
155: {
156: const char *cmd;
157:
158: if (c->flags & CLIENT_CONTROL)
159: return;
160:
161: if (c->flags & CLIENT_SUSPENDED)
162: return;
163:
164: cmd = options_get_string(c->session->options, "lock-command");
165: if (strlen(cmd) + 1 > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
166: return;
167:
168: tty_stop_tty(&c->tty);
169: tty_raw(&c->tty, tty_term_string(c->tty.term, TTYC_SMCUP));
170: tty_raw(&c->tty, tty_term_string(c->tty.term, TTYC_CLEAR));
171: tty_raw(&c->tty, tty_term_string(c->tty.term, TTYC_E3));
172:
173: c->flags |= CLIENT_SUSPENDED;
174: proc_send_s(c->peer, MSG_LOCK, cmd);
175: }
176:
177: void
178: server_kill_window(struct window *w)
179: {
180: struct session *s, *next_s, *target_s;
181: struct session_group *sg;
182: struct winlink *wl;
183:
184: next_s = RB_MIN(sessions, &sessions);
185: while (next_s != NULL) {
186: s = next_s;
187: next_s = RB_NEXT(sessions, &sessions, s);
188:
189: if (!session_has(s, w))
190: continue;
191: server_unzoom_window(w);
192: while ((wl = winlink_find_by_window(&s->windows, w)) != NULL) {
193: if (session_detach(s, wl)) {
194: server_destroy_session_group(s);
195: break;
196: } else
197: server_redraw_session_group(s);
198: }
199:
200: if (options_get_number(s->options, "renumber-windows")) {
201: if ((sg = session_group_contains(s)) != NULL) {
202: TAILQ_FOREACH(target_s, &sg->sessions, gentry)
203: session_renumber_windows(target_s);
204: } else
205: session_renumber_windows(s);
206: }
207: }
208: recalculate_sizes();
209: }
210:
211: int
212: server_link_window(struct session *src, struct winlink *srcwl,
213: struct session *dst, int dstidx, int killflag, int selectflag,
214: char **cause)
215: {
216: struct winlink *dstwl;
217: struct session_group *srcsg, *dstsg;
218:
219: srcsg = session_group_contains(src);
220: dstsg = session_group_contains(dst);
221: if (src != dst && srcsg != NULL && dstsg != NULL && srcsg == dstsg) {
222: xasprintf(cause, "sessions are grouped");
223: return (-1);
224: }
225:
226: dstwl = NULL;
227: if (dstidx != -1)
228: dstwl = winlink_find_by_index(&dst->windows, dstidx);
229: if (dstwl != NULL) {
230: if (dstwl->window == srcwl->window) {
231: xasprintf(cause, "same index: %d", dstidx);
232: return (-1);
233: }
234: if (killflag) {
235: /*
236: * Can't use session_detach as it will destroy session
237: * if this makes it empty.
238: */
239: notify_session_window("window-unlinked", dst,
240: dstwl->window);
241: dstwl->flags &= ~WINLINK_ALERTFLAGS;
242: winlink_stack_remove(&dst->lastw, dstwl);
243: winlink_remove(&dst->windows, dstwl);
244:
245: /* Force select/redraw if current. */
246: if (dstwl == dst->curw) {
247: selectflag = 1;
248: dst->curw = NULL;
249: }
250: }
251: }
252:
253: if (dstidx == -1)
254: dstidx = -1 - options_get_number(dst->options, "base-index");
255: dstwl = session_attach(dst, srcwl->window, dstidx, cause);
256: if (dstwl == NULL)
257: return (-1);
258:
259: if (selectflag)
260: session_select(dst, dstwl->idx);
261: server_redraw_session_group(dst);
262:
263: return (0);
264: }
265:
266: void
267: server_unlink_window(struct session *s, struct winlink *wl)
268: {
269: if (session_detach(s, wl))
270: server_destroy_session_group(s);
271: else
272: server_redraw_session_group(s);
273: }
274:
275: void
276: server_destroy_pane(struct window_pane *wp, int notify)
277: {
278: struct window *w = wp->window;
279: int old_fd;
280: struct screen_write_ctx ctx;
281: struct grid_cell gc;
282:
283: old_fd = wp->fd;
284: if (wp->fd != -1) {
285: #ifdef HAVE_UTEMPTER
286: utempter_remove_record(wp->fd);
287: #endif
288: bufferevent_free(wp->event);
289: close(wp->fd);
290: wp->fd = -1;
291: }
292:
293: if (options_get_number(w->options, "remain-on-exit")) {
294: if (old_fd == -1)
295: return;
296:
297: if (notify)
298: notify_pane("pane-died", wp);
299:
300: screen_write_start(&ctx, wp, &wp->base);
301: screen_write_scrollregion(&ctx, 0, screen_size_y(ctx.s) - 1);
302: screen_write_cursormove(&ctx, 0, screen_size_y(ctx.s) - 1);
303: screen_write_linefeed(&ctx, 1);
304: memcpy(&gc, &grid_default_cell, sizeof gc);
305: gc.attr |= GRID_ATTR_BRIGHT;
306: screen_write_puts(&ctx, &gc, "Pane is dead");
307: screen_write_stop(&ctx);
308: wp->flags |= PANE_REDRAW;
309:
310: return;
311: }
312:
313: if (notify)
314: notify_pane("pane-exited", wp);
315:
316: server_unzoom_window(w);
317: layout_close_pane(wp);
318: window_remove_pane(w, wp);
319:
320: if (TAILQ_EMPTY(&w->panes))
321: server_kill_window(w);
322: else
323: server_redraw_window(w);
324: }
325:
326: static void
327: server_destroy_session_group(struct session *s)
328: {
329: struct session_group *sg;
330: struct session *s1;
331:
332: if ((sg = session_group_contains(s)) == NULL)
333: server_destroy_session(s);
334: else {
335: TAILQ_FOREACH_SAFE(s, &sg->sessions, gentry, s1) {
336: server_destroy_session(s);
337: session_destroy(s);
338: }
339: }
340: }
341:
342: static struct session *
343: server_next_session(struct session *s)
344: {
345: struct session *s_loop, *s_out;
346:
347: s_out = NULL;
348: RB_FOREACH(s_loop, sessions, &sessions) {
349: if (s_loop == s)
350: continue;
351: if (s_out == NULL ||
352: timercmp(&s_loop->activity_time, &s_out->activity_time, <))
353: s_out = s_loop;
354: }
355: return (s_out);
356: }
357:
358: void
359: server_destroy_session(struct session *s)
360: {
361: struct client *c;
362: struct session *s_new;
363:
364: if (!options_get_number(s->options, "detach-on-destroy"))
365: s_new = server_next_session(s);
366: else
367: s_new = NULL;
368:
369: TAILQ_FOREACH(c, &clients, entry) {
370: if (c->session != s)
371: continue;
372: if (s_new == NULL) {
373: c->session = NULL;
374: c->flags |= CLIENT_EXIT;
375: } else {
376: c->last_session = NULL;
377: c->session = s_new;
378: server_client_set_key_table(c, NULL);
379: status_timer_start(c);
380: notify_client("client-session-changed", c);
381: session_update_activity(s_new, NULL);
382: gettimeofday(&s_new->last_attached_time, NULL);
383: server_redraw_client(c);
384: alerts_check_session(s_new);
385: }
386: }
387: recalculate_sizes();
388: }
389:
390: void
391: server_check_unattached(void)
392: {
393: struct session *s;
394:
395: /*
396: * If any sessions are no longer attached and have destroy-unattached
397: * set, collect them.
398: */
399: RB_FOREACH(s, sessions, &sessions) {
400: if (!(s->flags & SESSION_UNATTACHED))
401: continue;
402: if (options_get_number (s->options, "destroy-unattached"))
403: session_destroy(s);
404: }
405: }
406:
407: /* Set stdin callback. */
408: int
409: server_set_stdin_callback(struct client *c, void (*cb)(struct client *, int,
410: void *), void *cb_data, char **cause)
411: {
412: if (c == NULL || c->session != NULL) {
413: *cause = xstrdup("no client with stdin");
414: return (-1);
415: }
416: if (c->flags & CLIENT_TERMINAL) {
417: *cause = xstrdup("stdin is a tty");
418: return (-1);
419: }
420: if (c->stdin_callback != NULL) {
421: *cause = xstrdup("stdin in use");
422: return (-1);
423: }
424:
425: c->stdin_callback_data = cb_data;
426: c->stdin_callback = cb;
427:
428: c->references++;
429:
430: if (c->stdin_closed)
431: c->stdin_callback(c, 1, c->stdin_callback_data);
432:
433: proc_send(c->peer, MSG_STDIN, -1, NULL, 0);
434:
435: return (0);
436: }
437:
438: void
439: server_unzoom_window(struct window *w)
440: {
441: if (window_unzoom(w) == 0) {
442: server_redraw_window(w);
443: server_status_window(w);
444: }
445: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to server-fn.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / tmux