server-fn.c

   1 /* $OpenBSD$ */
   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>
  22 #include <time.h>
  23 #include <unistd.h>
  24
  25 #include "tmux.h"
  26
  27 struct session *server_next_session(struct session *);
  28 void            server_callback_identify(int, short, void *);
  29
  30 void
  31 server_fill_environ(struct session *s, struct environ *env)
  32 {
  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);
  47 }
  48
  49 void
  50 server_write_client(
  51     struct client *c, enum msgtype type, const void *buf, size_t len)
  52 {
  53         struct imsgbuf  *ibuf = &c->ibuf;
  54
  55         if (c->flags & CLIENT_BAD)
  56                 return;
  57         log_debug("writing %d to client %d", type, c->ibuf.fd);
  58         imsg_compose(ibuf, type, PROTOCOL_VERSION, -1, -1, (void *) buf, len);
  59         server_update_event(c);
  60 }
  61
  62 void
  63 server_write_session(
  64     struct session *s, enum msgtype type, const void *buf, size_t len)
  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
 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
 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
 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
 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;
 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         }
 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
 188         RB_FOREACH(s, sessions, &sessions) {
 189                 if (session_has(s, w) != NULL)
 190                         server_status_session(s);
 191         }
 192 }
 193
 194 void
 195 server_lock(void)
 196 {
 197         struct client   *c;
 198         u_int            i;
 199
 200         for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
 201                 c = ARRAY_ITEM(&clients, i);
 202                 if (c == NULL || c->session == NULL)
 203                         continue;
 204                 server_lock_client(c);
 205         }
 206 }
 207
 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);
 219         }
 220 }
 221
 222 void
 223 server_lock_client(struct client *c)
 224 {
 225         const char              *cmd;
 226         size_t                   cmdlen;
 227         struct msg_lock_data     lockdata;
 228
 229         if (c->flags & CLIENT_SUSPENDED)
 230                 return;
 231
 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;
 236
 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));
 240         tty_raw(&c->tty, tty_term_string(c->tty.term, TTYC_E3));
 241
 242         c->flags |= CLIENT_SUSPENDED;
 243         server_write_client(c, MSG_LOCK, &lockdata, sizeof lockdata);
 244 }
 245
 246 void
 247 server_kill_window(struct window *w)
 248 {
 249         struct session  *s, *next_s;
 250         struct winlink  *wl;
 251
 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
 257                 if (session_has(s, w) == NULL)
 258                         continue;
 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                 }
 266         }
 267 }
 268
 269 int
 270 server_link_window(struct session *src, struct winlink *srcwl,
 271     struct session *dst, int dstidx, int killflag, int selectflag, char **cause)
 272 {
 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         }
 282
 283         dstwl = NULL;
 284         if (dstidx != -1)
 285                 dstwl = winlink_find_by_index(&dst->windows, dstidx);
 286         if (dstwl != NULL) {
 287                 if (dstwl->window == srcwl->window) {
 288                         xasprintf(cause, "same index: %d", dstidx);
 289                         return (-1);
 290                 }
 291                 if (killflag) {
 292                         /*
 293                          * Can't use session_detach as it will destroy session
 294                          * if this makes it empty.
 295                          */
 296                         notify_window_unlinked(dst, dstwl->window);
 297                         dstwl->flags &= ~WINLINK_ALERTFLAGS;
 298                         winlink_stack_remove(&dst->lastw, dstwl);
 299                         winlink_remove(&dst->windows, dstwl);
 300
 301                         /* Force select/redraw if current. */
 302                         if (dstwl == dst->curw) {
 303                                 selectflag = 1;
 304                                 dst->curw = NULL;
 305                         }
 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
 315         if (selectflag)
 316                 session_select(dst, dstwl->idx);
 317         server_redraw_session_group(dst);
 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))
 326                 server_destroy_session_group(s);
 327         else
 328                 server_redraw_session_group(s);
 329 }
 330
 331 void
 332 server_destroy_pane(struct window_pane *wp)
 333 {
 334         struct window           *w = wp->window;
 335         int                      old_fd;
 336         struct screen_write_ctx  ctx;
 337         struct grid_cell         gc;
 338
 339         old_fd = wp->fd;
 340         if (wp->fd != -1) {
 341                 bufferevent_free(wp->event);
 342                 close(wp->fd);
 343                 wp->fd = -1;
 344         }
 345
 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;
 358                 return;
 359         }
 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);
 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)
 376                 server_destroy_session(s);
 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         }
 383 }
 384
 385 struct session *
 386 server_next_session(struct session *s)
 387 {
 388         struct session *s_loop, *s_out;
 389
 390         s_out = NULL;
 391         RB_FOREACH(s_loop, sessions, &sessions) {
 392                 if (s_loop == s)
 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
 401 void
 402 server_destroy_session(struct session *s)
 403 {
 404         struct client   *c;
 405         struct session  *s_new;
 406         u_int            i;
 407
 408         if (!options_get_number(&s->options, "detach-on-destroy"))
 409                 s_new = server_next_session(s);
 410         else
 411                 s_new = NULL;
 412
 413         for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
 414                 c = ARRAY_ITEM(&clients, i);
 415                 if (c == NULL || c->session != s)
 416                         continue;
 417                 if (s_new == NULL) {
 418                         c->session = NULL;
 419                         c->flags |= CLIENT_EXIT;
 420                 } else {
 421                         c->last_session = NULL;
 422                         c->session = s_new;
 423                         notify_attached_session_changed(c);
 424                         session_update_activity(s_new);
 425                         server_redraw_client(c);
 426                 }
 427         }
 428         recalculate_sizes();
 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          */
 440         RB_FOREACH(s, sessions, &sessions) {
 441                 if (!(s->flags & SESSION_UNATTACHED))
 442                         continue;
 443                 if (options_get_number (&s->options, "destroy-unattached"))
 444                         session_destroy(s);
 445         }
 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;
 457
 458         if (event_initialized (&c->identify_timer))
 459                 evtimer_del(&c->identify_timer);
 460         evtimer_set(&c->identify_timer, server_callback_identify, c);
 461         evtimer_add(&c->identify_timer, &tv);
 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         }
 476 }
 477
 478 /* ARGSUSED */
 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);
 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;
 497         if (event_initialized(&c->event))
 498                 event_del(&c->event);
 499         event_set(&c->event, c->ibuf.fd, events, server_client_callback, c);
 500         event_add(&c->event, NULL);
 501 }