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