Annotation of src/usr.bin/tmux/server-fn.c, Revision 1.55
1.55 ! nicm 1: /* $OpenBSD: server-fn.c,v 1.54 2012/03/17 18:24:07 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.55 ! nicm 296: notify_window_unlinked(dst, dstwl->window);
1.37 nicm 297: dstwl->flags &= ~WINLINK_ALERTFLAGS;
1.21 nicm 298: winlink_stack_remove(&dst->lastw, dstwl);
299: winlink_remove(&dst->windows, dstwl);
300:
301: /* Force select/redraw if current. */
1.26 nicm 302: if (dstwl == dst->curw) {
1.21 nicm 303: selectflag = 1;
1.26 nicm 304: dst->curw = NULL;
305: }
1.21 nicm 306: }
307: }
308:
309: if (dstidx == -1)
310: dstidx = -1 - options_get_number(&dst->options, "base-index");
311: dstwl = session_attach(dst, srcwl->window, dstidx, cause);
312: if (dstwl == NULL)
313: return (-1);
314:
1.25 nicm 315: if (selectflag)
1.21 nicm 316: session_select(dst, dstwl->idx);
1.25 nicm 317: server_redraw_session_group(dst);
1.21 nicm 318:
319: return (0);
320: }
321:
322: void
323: server_unlink_window(struct session *s, struct winlink *wl)
324: {
325: if (session_detach(s, wl))
1.25 nicm 326: server_destroy_session_group(s);
327: else
328: server_redraw_session_group(s);
1.29 nicm 329: }
330:
331: void
332: server_destroy_pane(struct window_pane *wp)
333: {
1.51 nicm 334: struct window *w = wp->window;
335: int old_fd;
336: struct screen_write_ctx ctx;
337: struct grid_cell gc;
1.29 nicm 338:
1.51 nicm 339: old_fd = wp->fd;
1.36 nicm 340: if (wp->fd != -1) {
1.53 nicm 341: bufferevent_free(wp->event);
1.36 nicm 342: close(wp->fd);
343: wp->fd = -1;
344: }
1.29 nicm 345:
1.51 nicm 346: if (options_get_number(&w->options, "remain-on-exit")) {
347: if (old_fd == -1)
348: return;
349: screen_write_start(&ctx, wp, &wp->base);
350: screen_write_scrollregion(&ctx, 0, screen_size_y(ctx.s) - 1);
351: screen_write_cursormove(&ctx, 0, screen_size_y(ctx.s) - 1);
352: screen_write_linefeed(&ctx, 1);
353: memcpy(&gc, &grid_default_cell, sizeof gc);
354: gc.attr |= GRID_ATTR_BRIGHT;
355: screen_write_puts(&ctx, &gc, "Pane is dead");
356: screen_write_stop(&ctx);
357: wp->flags |= PANE_REDRAW;
1.29 nicm 358: return;
1.51 nicm 359: }
1.29 nicm 360:
361: layout_close_pane(wp);
362: window_remove_pane(w, wp);
363:
364: if (TAILQ_EMPTY(&w->panes))
365: server_kill_window(w);
366: else
367: server_redraw_window(w);
1.25 nicm 368: }
369:
370: void
371: server_destroy_session_group(struct session *s)
372: {
373: struct session_group *sg;
374:
375: if ((sg = session_group_find(s)) == NULL)
1.21 nicm 376: server_destroy_session(s);
1.25 nicm 377: else {
378: TAILQ_FOREACH(s, &sg->sessions, gentry)
379: server_destroy_session(s);
380: TAILQ_REMOVE(&session_groups, sg, entry);
381: xfree(sg);
382: }
1.19 nicm 383: }
384:
1.39 nicm 385: struct session *
386: server_next_session(struct session *s)
387: {
388: struct session *s_loop, *s_out;
389:
390: s_out = NULL;
1.47 nicm 391: RB_FOREACH(s_loop, sessions, &sessions) {
392: if (s_loop == s)
1.39 nicm 393: continue;
394: if (s_out == NULL ||
395: timercmp(&s_loop->activity_time, &s_out->activity_time, <))
396: s_out = s_loop;
397: }
398: return (s_out);
399: }
400:
1.19 nicm 401: void
402: server_destroy_session(struct session *s)
403: {
404: struct client *c;
1.39 nicm 405: struct session *s_new;
1.19 nicm 406: u_int i;
1.31 nicm 407:
1.39 nicm 408: if (!options_get_number(&s->options, "detach-on-destroy"))
409: s_new = server_next_session(s);
410: else
411: s_new = NULL;
412:
1.19 nicm 413: for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
414: c = ARRAY_ITEM(&clients, i);
415: if (c == NULL || c->session != s)
416: continue;
1.39 nicm 417: if (s_new == NULL) {
418: c->session = NULL;
1.40 nicm 419: c->flags |= CLIENT_EXIT;
1.39 nicm 420: } else {
1.46 nicm 421: c->last_session = NULL;
1.39 nicm 422: c->session = s_new;
1.55 ! nicm 423: notify_attached_session_changed(c);
1.49 nicm 424: session_update_activity(s_new);
1.39 nicm 425: server_redraw_client(c);
426: }
1.19 nicm 427: }
1.38 nicm 428: recalculate_sizes();
1.42 nicm 429: }
430:
431: void
432: server_check_unattached (void)
433: {
434: struct session *s;
435:
436: /*
437: * If any sessions are no longer attached and have destroy-unattached
438: * set, collect them.
439: */
1.47 nicm 440: RB_FOREACH(s, sessions, &sessions) {
441: if (!(s->flags & SESSION_UNATTACHED))
1.42 nicm 442: continue;
443: if (options_get_number (&s->options, "destroy-unattached"))
444: session_destroy(s);
445: }
1.15 nicm 446: }
447:
448: void
449: server_set_identify(struct client *c)
450: {
451: struct timeval tv;
452: int delay;
453:
454: delay = options_get_number(&c->session->options, "display-panes-time");
455: tv.tv_sec = delay / 1000;
456: tv.tv_usec = (delay % 1000) * 1000L;
1.31 nicm 457:
1.54 nicm 458: if (event_initialized (&c->identify_timer))
459: evtimer_del(&c->identify_timer);
1.28 nicm 460: evtimer_set(&c->identify_timer, server_callback_identify, c);
461: evtimer_add(&c->identify_timer, &tv);
1.15 nicm 462:
463: c->flags |= CLIENT_IDENTIFY;
464: c->tty.flags |= (TTY_FREEZE|TTY_NOCURSOR);
465: server_redraw_client(c);
466: }
467:
468: void
469: server_clear_identify(struct client *c)
470: {
471: if (c->flags & CLIENT_IDENTIFY) {
472: c->flags &= ~CLIENT_IDENTIFY;
473: c->tty.flags &= ~(TTY_FREEZE|TTY_NOCURSOR);
474: server_redraw_client(c);
475: }
1.28 nicm 476: }
477:
1.30 nicm 478: /* ARGSUSED */
1.28 nicm 479: void
480: server_callback_identify(unused int fd, unused short events, void *data)
481: {
482: struct client *c = data;
483:
484: server_clear_identify(c);
1.27 nicm 485: }
486:
487: void
488: server_update_event(struct client *c)
489: {
490: short events;
491:
492: events = 0;
493: if (!(c->flags & CLIENT_BAD))
494: events |= EV_READ;
495: if (c->ibuf.w.queued > 0)
496: events |= EV_WRITE;
1.54 nicm 497: if (event_initialized(&c->event))
498: event_del(&c->event);
1.27 nicm 499: event_set(&c->event, c->ibuf.fd, events, server_client_callback, c);
1.31 nicm 500: event_add(&c->event, NULL);
1.1 nicm 501: }
![[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