server-fn.c

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