Annotation of src/usr.bin/tmux/server-fn.c, Revision 1.54
1.54 ! nicm 1: /* $OpenBSD: server-fn.c,v 1.53 2012/01/29 02:22:11 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
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:
21: #include <string.h>
1.5 nicm 22: #include <time.h>
1.1 nicm 23: #include <unistd.h>
24:
25: #include "tmux.h"
26:
1.39 nicm 27: struct session *server_next_session(struct session *);
28: void server_callback_identify(int, short, void *);
1.28 nicm 29:
1.13 nicm 30: void
31: server_fill_environ(struct session *s, struct environ *env)
1.1 nicm 32: {
1.50 nicm 33: char var[MAXPATHLEN], *term;
34: u_int idx;
35: long pid;
36:
37: if (s != NULL) {
38: term = options_get_string(&s->options, "default-terminal");
39: environ_set(env, "TERM", term);
40:
41: idx = s->idx;
42: } else
43: idx = -1;
44: pid = getpid();
45: xsnprintf(var, sizeof var, "%s,%ld,%d", socket_path, pid, idx);
46: environ_set(env, "TMUX", var);
1.10 nicm 47: }
48:
49: void
1.1 nicm 50: server_write_client(
1.11 nicm 51: struct client *c, enum msgtype type, const void *buf, size_t len)
1.1 nicm 52: {
1.14 nicm 53: struct imsgbuf *ibuf = &c->ibuf;
1.1 nicm 54:
1.12 nicm 55: if (c->flags & CLIENT_BAD)
56: return;
1.14 nicm 57: log_debug("writing %d to client %d", type, c->ibuf.fd);
58: imsg_compose(ibuf, type, PROTOCOL_VERSION, -1, -1, (void *) buf, len);
1.31 nicm 59: server_update_event(c);
1.1 nicm 60: }
61:
62: void
63: server_write_session(
1.11 nicm 64: struct session *s, enum msgtype type, const void *buf, size_t len)
1.1 nicm 65: {
66: struct client *c;
67: u_int i;
68:
69: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
70: c = ARRAY_ITEM(&clients, i);
71: if (c == NULL || c->session == NULL)
72: continue;
73: if (c->session == s)
74: server_write_client(c, type, buf, len);
75: }
76: }
77:
78: void
79: server_redraw_client(struct client *c)
80: {
81: c->flags |= CLIENT_REDRAW;
82: }
83:
84: void
85: server_status_client(struct client *c)
86: {
87: c->flags |= CLIENT_STATUS;
88: }
89:
90: void
91: server_redraw_session(struct session *s)
92: {
93: struct client *c;
94: u_int i;
95:
96: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
97: c = ARRAY_ITEM(&clients, i);
98: if (c == NULL || c->session == NULL)
99: continue;
100: if (c->session == s)
101: server_redraw_client(c);
102: }
103: }
104:
105: void
1.25 nicm 106: server_redraw_session_group(struct session *s)
107: {
108: struct session_group *sg;
109:
110: if ((sg = session_group_find(s)) == NULL)
111: server_redraw_session(s);
112: else {
113: TAILQ_FOREACH(s, &sg->sessions, gentry)
114: server_redraw_session(s);
115: }
116: }
117:
118: void
1.1 nicm 119: server_status_session(struct session *s)
120: {
121: struct client *c;
122: u_int i;
123:
124: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
125: c = ARRAY_ITEM(&clients, i);
126: if (c == NULL || c->session == NULL)
127: continue;
128: if (c->session == s)
129: server_status_client(c);
130: }
131: }
132:
133: void
1.25 nicm 134: server_status_session_group(struct session *s)
135: {
136: struct session_group *sg;
137:
138: if ((sg = session_group_find(s)) == NULL)
139: server_status_session(s);
140: else {
141: TAILQ_FOREACH(s, &sg->sessions, gentry)
142: server_status_session(s);
143: }
144: }
145:
146: void
1.1 nicm 147: server_redraw_window(struct window *w)
148: {
149: struct client *c;
150: u_int i;
151:
152: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
153: c = ARRAY_ITEM(&clients, i);
154: if (c == NULL || c->session == NULL)
155: continue;
156: if (c->session->curw->window == w)
157: server_redraw_client(c);
158: }
159: w->flags |= WINDOW_REDRAW;
1.33 nicm 160: }
161:
162: void
163: server_redraw_window_borders(struct window *w)
164: {
165: struct client *c;
166: u_int i;
167:
168: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
169: c = ARRAY_ITEM(&clients, i);
170: if (c == NULL || c->session == NULL)
171: continue;
172: if (c->session->curw->window == w)
173: c->flags |= CLIENT_BORDERS;
174: }
1.1 nicm 175: }
176:
177: void
178: server_status_window(struct window *w)
179: {
180: struct session *s;
181:
182: /*
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
185: * current window.
186: */
187:
1.47 nicm 188: RB_FOREACH(s, sessions, &sessions) {
189: if (session_has(s, w) != NULL)
1.1 nicm 190: server_status_session(s);
191: }
192: }
193:
194: void
195: server_lock(void)
196: {
1.23 nicm 197: struct client *c;
198: u_int i;
1.17 nicm 199:
1.1 nicm 200: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
201: c = ARRAY_ITEM(&clients, i);
202: if (c == NULL || c->session == NULL)
203: continue;
1.23 nicm 204: server_lock_client(c);
205: }
206: }
1.1 nicm 207:
1.23 nicm 208: void
209: server_lock_session(struct session *s)
210: {
211: struct client *c;
212: u_int i;
213:
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)
217: continue;
218: server_lock_client(c);
1.31 nicm 219: }
1.23 nicm 220: }
1.1 nicm 221:
1.23 nicm 222: void
223: server_lock_client(struct client *c)
224: {
225: const char *cmd;
226: size_t cmdlen;
227: struct msg_lock_data lockdata;
1.24 nicm 228:
229: if (c->flags & CLIENT_SUSPENDED)
230: return;
1.1 nicm 231:
1.23 nicm 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)
235: return;
1.31 nicm 236:
1.23 nicm 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));
1.52 nicm 240: tty_raw(&c->tty, tty_term_string(c->tty.term, TTYC_E3));
1.23 nicm 241:
242: c->flags |= CLIENT_SUSPENDED;
243: server_write_client(c, MSG_LOCK, &lockdata, sizeof lockdata);
1.8 nicm 244: }
245:
246: void
247: server_kill_window(struct window *w)
248: {
1.48 nicm 249: struct session *s, *next_s;
1.8 nicm 250: struct winlink *wl;
1.31 nicm 251:
1.48 nicm 252: next_s = RB_MIN(sessions, &sessions);
253: while (next_s != NULL) {
254: s = next_s;
255: next_s = RB_NEXT(sessions, &sessions, s);
256:
1.47 nicm 257: if (session_has(s, w) == NULL)
1.8 nicm 258: continue;
1.34 nicm 259: while ((wl = winlink_find_by_window(&s->windows, w)) != NULL) {
260: if (session_detach(s, wl)) {
261: server_destroy_session_group(s);
262: break;
263: } else
264: server_redraw_session_group(s);
265: }
1.8 nicm 266: }
1.21 nicm 267: }
268:
269: int
1.25 nicm 270: server_link_window(struct session *src, struct winlink *srcwl,
271: struct session *dst, int dstidx, int killflag, int selectflag, char **cause)
1.21 nicm 272: {
1.25 nicm 273: struct winlink *dstwl;
274: struct session_group *srcsg, *dstsg;
275:
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");
280: return (-1);
281: }
1.21 nicm 282:
283: dstwl = NULL;
284: if (dstidx != -1)
285: dstwl = winlink_find_by_index(&dst->windows, dstidx);
286: if (dstwl != NULL) {
1.44 nicm 287: if (dstwl->window == srcwl->window) {
288: xasprintf(cause, "same index: %d", dstidx);
1.41 nicm 289: return (-1);
1.44 nicm 290: }
1.21 nicm 291: if (killflag) {
292: /*
293: * Can't use session_detach as it will destroy session
294: * if this makes it empty.
295: */
1.37 nicm 296: dstwl->flags &= ~WINLINK_ALERTFLAGS;
1.21 nicm 297: winlink_stack_remove(&dst->lastw, dstwl);
298: winlink_remove(&dst->windows, dstwl);
299:
300: /* Force select/redraw if current. */
1.26 nicm 301: if (dstwl == dst->curw) {
1.21 nicm 302: selectflag = 1;
1.26 nicm 303: dst->curw = NULL;
304: }
1.21 nicm 305: }
306: }
307:
308: if (dstidx == -1)
309: dstidx = -1 - options_get_number(&dst->options, "base-index");
310: dstwl = session_attach(dst, srcwl->window, dstidx, cause);
311: if (dstwl == NULL)
312: return (-1);
313:
1.25 nicm 314: if (selectflag)
1.21 nicm 315: session_select(dst, dstwl->idx);
1.25 nicm 316: server_redraw_session_group(dst);
1.21 nicm 317:
318: return (0);
319: }
320:
321: void
322: server_unlink_window(struct session *s, struct winlink *wl)
323: {
324: if (session_detach(s, wl))
1.25 nicm 325: server_destroy_session_group(s);
326: else
327: server_redraw_session_group(s);
1.29 nicm 328: }
329:
330: void
331: server_destroy_pane(struct window_pane *wp)
332: {
1.51 nicm 333: struct window *w = wp->window;
334: int old_fd;
335: struct screen_write_ctx ctx;
336: struct grid_cell gc;
1.29 nicm 337:
1.51 nicm 338: old_fd = wp->fd;
1.36 nicm 339: if (wp->fd != -1) {
1.53 nicm 340: bufferevent_free(wp->event);
1.36 nicm 341: close(wp->fd);
342: wp->fd = -1;
343: }
1.29 nicm 344:
1.51 nicm 345: if (options_get_number(&w->options, "remain-on-exit")) {
346: if (old_fd == -1)
347: return;
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;
1.29 nicm 357: return;
1.51 nicm 358: }
1.29 nicm 359:
360: layout_close_pane(wp);
361: window_remove_pane(w, wp);
362:
363: if (TAILQ_EMPTY(&w->panes))
364: server_kill_window(w);
365: else
366: server_redraw_window(w);
1.25 nicm 367: }
368:
369: void
370: server_destroy_session_group(struct session *s)
371: {
372: struct session_group *sg;
373:
374: if ((sg = session_group_find(s)) == NULL)
1.21 nicm 375: server_destroy_session(s);
1.25 nicm 376: else {
377: TAILQ_FOREACH(s, &sg->sessions, gentry)
378: server_destroy_session(s);
379: TAILQ_REMOVE(&session_groups, sg, entry);
380: xfree(sg);
381: }
1.19 nicm 382: }
383:
1.39 nicm 384: struct session *
385: server_next_session(struct session *s)
386: {
387: struct session *s_loop, *s_out;
388:
389: s_out = NULL;
1.47 nicm 390: RB_FOREACH(s_loop, sessions, &sessions) {
391: if (s_loop == s)
1.39 nicm 392: continue;
393: if (s_out == NULL ||
394: timercmp(&s_loop->activity_time, &s_out->activity_time, <))
395: s_out = s_loop;
396: }
397: return (s_out);
398: }
399:
1.19 nicm 400: void
401: server_destroy_session(struct session *s)
402: {
403: struct client *c;
1.39 nicm 404: struct session *s_new;
1.19 nicm 405: u_int i;
1.31 nicm 406:
1.39 nicm 407: if (!options_get_number(&s->options, "detach-on-destroy"))
408: s_new = server_next_session(s);
409: else
410: s_new = NULL;
411:
1.19 nicm 412: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
413: c = ARRAY_ITEM(&clients, i);
414: if (c == NULL || c->session != s)
415: continue;
1.39 nicm 416: if (s_new == NULL) {
417: c->session = NULL;
1.40 nicm 418: c->flags |= CLIENT_EXIT;
1.39 nicm 419: } else {
1.46 nicm 420: c->last_session = NULL;
1.39 nicm 421: c->session = s_new;
1.49 nicm 422: session_update_activity(s_new);
1.39 nicm 423: server_redraw_client(c);
424: }
1.19 nicm 425: }
1.38 nicm 426: recalculate_sizes();
1.42 nicm 427: }
428:
429: void
430: server_check_unattached (void)
431: {
432: struct session *s;
433:
434: /*
435: * If any sessions are no longer attached and have destroy-unattached
436: * set, collect them.
437: */
1.47 nicm 438: RB_FOREACH(s, sessions, &sessions) {
439: if (!(s->flags & SESSION_UNATTACHED))
1.42 nicm 440: continue;
441: if (options_get_number (&s->options, "destroy-unattached"))
442: session_destroy(s);
443: }
1.15 nicm 444: }
445:
446: void
447: server_set_identify(struct client *c)
448: {
449: struct timeval tv;
450: int delay;
451:
452: delay = options_get_number(&c->session->options, "display-panes-time");
453: tv.tv_sec = delay / 1000;
454: tv.tv_usec = (delay % 1000) * 1000L;
1.31 nicm 455:
1.54 ! nicm 456: if (event_initialized (&c->identify_timer))
! 457: evtimer_del(&c->identify_timer);
1.28 nicm 458: evtimer_set(&c->identify_timer, server_callback_identify, c);
459: evtimer_add(&c->identify_timer, &tv);
1.15 nicm 460:
461: c->flags |= CLIENT_IDENTIFY;
462: c->tty.flags |= (TTY_FREEZE|TTY_NOCURSOR);
463: server_redraw_client(c);
464: }
465:
466: void
467: server_clear_identify(struct client *c)
468: {
469: if (c->flags & CLIENT_IDENTIFY) {
470: c->flags &= ~CLIENT_IDENTIFY;
471: c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR);
472: server_redraw_client(c);
473: }
1.28 nicm 474: }
475:
1.30 nicm 476: /* ARGSUSED */
1.28 nicm 477: void
478: server_callback_identify(unused int fd, unused short events, void *data)
479: {
480: struct client *c = data;
481:
482: server_clear_identify(c);
1.27 nicm 483: }
484:
485: void
486: server_update_event(struct client *c)
487: {
488: short events;
489:
490: events = 0;
491: if (!(c->flags & CLIENT_BAD))
492: events |= EV_READ;
493: if (c->ibuf.w.queued > 0)
494: events |= EV_WRITE;
1.54 ! nicm 495: if (event_initialized(&c->event))
! 496: event_del(&c->event);
1.27 nicm 497: event_set(&c->event, c->ibuf.fd, events, server_client_callback, c);
1.31 nicm 498: event_add(&c->event, NULL);
1.1 nicm 499: }
![[BACK]](/icons/back.gif){kind=icon}
Return to server-fn.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux