spawn.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2019 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
  21 #include <errno.h>
  22 #include <signal.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include "tmux.h"
  28
  29 /*
  30  * Set up the environment and create a new window and pane or a new pane.
  31  *
  32  * We need to set up the following items:
  33  *
  34  * - history limit, comes from the session;
  35  *
  36  * - base index, comes from the session;
  37  *
  38  * - current working directory, may be specified - if it isn't it comes from
  39  *   either the client or the session;
  40  *
  41  * - PATH variable, comes from the client if any, otherwise from the session
  42  *   environment;
  43  *
  44  * - shell, comes from default-shell;
  45  *
  46  * - termios, comes from the session;
  47  *
  48  * - remaining environment, comes from the session.
  49  */
  50
  51 static void
  52 spawn_log(const char *from, struct spawn_context *sc)
  53 {
  54         struct session          *s = sc->s;
  55         struct winlink          *wl = sc->wl;
  56         struct window_pane      *wp0 = sc->wp0;
  57         const char              *name = cmdq_get_name(sc->item);
  58         char                     tmp[128];
  59
  60         log_debug("%s: %s, flags=%#x", from, name, sc->flags);
  61
  62         if (wl != NULL && wp0 != NULL)
  63                 xsnprintf(tmp, sizeof tmp, "wl=%d wp0=%%%u", wl->idx, wp0->id);
  64         else if (wl != NULL)
  65                 xsnprintf(tmp, sizeof tmp, "wl=%d wp0=none", wl->idx);
  66         else if (wp0 != NULL)
  67                 xsnprintf(tmp, sizeof tmp, "wl=none wp0=%%%u", wp0->id);
  68         else
  69                 xsnprintf(tmp, sizeof tmp, "wl=none wp0=none");
  70         log_debug("%s: s=$%u %s idx=%d", from, s->id, tmp, sc->idx);
  71         log_debug("%s: name=%s", from, sc->name == NULL ? "none" : sc->name);
  72 }
  73
  74 struct winlink *
  75 spawn_window(struct spawn_context *sc, char **cause)
  76 {
  77         struct cmdq_item        *item = sc->item;
  78         struct client           *c = cmdq_get_client(item);
  79         struct session          *s = sc->s;
  80         struct window           *w;
  81         struct window_pane      *wp;
  82         struct winlink          *wl;
  83         int                      idx = sc->idx;
  84         u_int                    sx, sy, xpixel, ypixel;
  85
  86         spawn_log(__func__, sc);
  87
  88         /*
  89          * If the window already exists, we are respawning, so destroy all the
  90          * panes except one.
  91          */
  92         if (sc->flags & SPAWN_RESPAWN) {
  93                 w = sc->wl->window;
  94                 if (~sc->flags & SPAWN_KILL) {
  95                         TAILQ_FOREACH(wp, &w->panes, entry) {
  96                                 if (wp->fd != -1)
  97                                         break;
  98                         }
  99                         if (wp != NULL) {
 100                                 xasprintf(cause, "window %s:%d still active",
 101                                     s->name, sc->wl->idx);
 102                                 return (NULL);
 103                         }
 104                 }
 105
 106                 sc->wp0 = TAILQ_FIRST(&w->panes);
 107                 TAILQ_REMOVE(&w->panes, sc->wp0, entry);
 108
 109                 layout_free(w);
 110                 window_destroy_panes(w);
 111
 112                 TAILQ_INSERT_HEAD(&w->panes, sc->wp0, entry);
 113                 window_pane_resize(sc->wp0, w->sx, w->sy);
 114
 115                 layout_init(w, sc->wp0);
 116                 w->active = NULL;
 117                 window_set_active_pane(w, sc->wp0, 0);
 118         }
 119
 120         /*
 121          * Otherwise we have no window so we will need to create one. First
 122          * check if the given index already exists and destroy it if so.
 123          */
 124         if ((~sc->flags & SPAWN_RESPAWN) && idx != -1) {
 125                 wl = winlink_find_by_index(&s->windows, idx);
 126                 if (wl != NULL && (~sc->flags & SPAWN_KILL)) {
 127                         xasprintf(cause, "index %d in use", idx);
 128                         return (NULL);
 129                 }
 130                 if (wl != NULL) {
 131                         /*
 132                          * Can't use session_detach as it will destroy session
 133                          * if this makes it empty.
 134                          */
 135                         wl->flags &= ~WINLINK_ALERTFLAGS;
 136                         notify_session_window("window-unlinked", s, wl->window);
 137                         winlink_stack_remove(&s->lastw, wl);
 138                         winlink_remove(&s->windows, wl);
 139
 140                         if (s->curw == wl) {
 141                                 s->curw = NULL;
 142                                 sc->flags &= ~SPAWN_DETACHED;
 143                         }
 144                 }
 145         }
 146
 147         /* Then create a window if needed. */
 148         if (~sc->flags & SPAWN_RESPAWN) {
 149                 if (idx == -1)
 150                         idx = -1 - options_get_number(s->options, "base-index");
 151                 if ((sc->wl = winlink_add(&s->windows, idx)) == NULL) {
 152                         xasprintf(cause, "couldn't add window %d", idx);
 153                         return (NULL);
 154                 }
 155                 default_window_size(sc->tc, s, NULL, &sx, &sy, &xpixel, &ypixel,
 156                     -1);
 157                 if ((w = window_create(sx, sy, xpixel, ypixel)) == NULL) {
 158                         winlink_remove(&s->windows, sc->wl);
 159                         xasprintf(cause, "couldn't create window %d", idx);
 160                         return (NULL);
 161                 }
 162                 if (s->curw == NULL)
 163                         s->curw = sc->wl;
 164                 sc->wl->session = s;
 165                 w->latest = sc->tc;
 166                 winlink_set_window(sc->wl, w);
 167         } else
 168                 w = NULL;
 169         sc->flags |= SPAWN_NONOTIFY;
 170
 171         /* Spawn the pane. */
 172         wp = spawn_pane(sc, cause);
 173         if (wp == NULL) {
 174                 if (~sc->flags & SPAWN_RESPAWN)
 175                         winlink_remove(&s->windows, sc->wl);
 176                 return (NULL);
 177         }
 178
 179         /* Set the name of the new window. */
 180         if (~sc->flags & SPAWN_RESPAWN) {
 181                 free(w->name);
 182                 if (sc->name != NULL) {
 183                         w->name = format_single(item, sc->name, c, s, NULL,
 184                             NULL);
 185                         options_set_number(w->options, "automatic-rename", 0);
 186                 } else
 187                         w->name = default_window_name(w);
 188         }
 189
 190         /* Switch to the new window if required. */
 191         if (~sc->flags & SPAWN_DETACHED)
 192                 session_select(s, sc->wl->idx);
 193
 194         /* Fire notification if new window. */
 195         if (~sc->flags & SPAWN_RESPAWN)
 196                 notify_session_window("window-linked", s, w);
 197
 198         session_group_synchronize_from(s);
 199         return (sc->wl);
 200 }
 201
 202 struct window_pane *
 203 spawn_pane(struct spawn_context *sc, char **cause)
 204 {
 205         struct cmdq_item         *item = sc->item;
 206         struct cmd_find_state    *target = cmdq_get_target(item);
 207         struct client            *c = cmdq_get_client(item);
 208         struct session           *s = sc->s;
 209         struct window            *w = sc->wl->window;
 210         struct window_pane       *new_wp;
 211         struct environ           *child;
 212         struct environ_entry     *ee;
 213         char                    **argv, *cp, **argvp, *argv0, *cwd, *new_cwd;
 214         const char               *cmd, *tmp;
 215         int                       argc;
 216         u_int                     idx;
 217         struct termios            now;
 218         u_int                     hlimit;
 219         struct winsize            ws;
 220         sigset_t                  set, oldset;
 221         key_code                  key;
 222
 223         spawn_log(__func__, sc);
 224
 225         /*
 226          * Work out the current working directory. If respawning, use
 227          * the pane's stored one unless specified.
 228          */
 229         if (sc->cwd != NULL) {
 230                 cwd = format_single(item, sc->cwd, c, target->s, NULL, NULL);
 231                 if (*cwd != '/') {
 232                         xasprintf(&new_cwd, "%s/%s", server_client_get_cwd(c,
 233                             target->s), cwd);
 234                         free(cwd);
 235                         cwd = new_cwd;
 236                 }
 237         } else if (~sc->flags & SPAWN_RESPAWN)
 238                 cwd = xstrdup(server_client_get_cwd(c, target->s));
 239         else
 240                 cwd = NULL;
 241
 242         /*
 243          * If we are respawning then get rid of the old process. Otherwise
 244          * either create a new cell or assign to the one we are given.
 245          */
 246         hlimit = options_get_number(s->options, "history-limit");
 247         if (sc->flags & SPAWN_RESPAWN) {
 248                 if (sc->wp0->fd != -1 && (~sc->flags & SPAWN_KILL)) {
 249                         window_pane_index(sc->wp0, &idx);
 250                         xasprintf(cause, "pane %s:%d.%u still active",
 251                             s->name, sc->wl->idx, idx);
 252                         free(cwd);
 253                         return (NULL);
 254                 }
 255                 if (sc->wp0->fd != -1) {
 256                         bufferevent_free(sc->wp0->event);
 257                         close(sc->wp0->fd);
 258                 }
 259                 window_pane_reset_mode_all(sc->wp0);
 260                 screen_reinit(&sc->wp0->base);
 261                 input_free(sc->wp0->ictx);
 262                 sc->wp0->ictx = NULL;
 263                 new_wp = sc->wp0;
 264                 new_wp->flags &= ~(PANE_STATUSREADY|PANE_STATUSDRAWN);
 265         } else if (sc->lc == NULL) {
 266                 new_wp = window_add_pane(w, NULL, hlimit, sc->flags);
 267                 layout_init(w, new_wp);
 268         } else {
 269                 new_wp = window_add_pane(w, sc->wp0, hlimit, sc->flags);
 270                 if (sc->flags & SPAWN_ZOOM)
 271                         layout_assign_pane(sc->lc, new_wp, 1);
 272                 else
 273                         layout_assign_pane(sc->lc, new_wp, 0);
 274         }
 275
 276         /*
 277          * Now we have a pane with nothing running in it ready for the new
 278          * process. Work out the command and arguments and store the working
 279          * directory.
 280          */
 281         if (sc->argc == 0 && (~sc->flags & SPAWN_RESPAWN)) {
 282                 cmd = options_get_string(s->options, "default-command");
 283                 if (cmd != NULL && *cmd != '\0') {
 284                         argc = 1;
 285                         argv = (char **)&cmd;
 286                 } else {
 287                         argc = 0;
 288                         argv = NULL;
 289                 }
 290         } else {
 291                 argc = sc->argc;
 292                 argv = sc->argv;
 293         }
 294         if (cwd != NULL) {
 295                 free(new_wp->cwd);
 296                 new_wp->cwd = cwd;
 297         }
 298
 299         /*
 300          * Replace the stored arguments if there are new ones. If not, the
 301          * existing ones will be used (they will only exist for respawn).
 302          */
 303         if (argc > 0) {
 304                 cmd_free_argv(new_wp->argc, new_wp->argv);
 305                 new_wp->argc = argc;
 306                 new_wp->argv = cmd_copy_argv(argc, argv);
 307         }
 308
 309         /* Create an environment for this pane. */
 310         child = environ_for_session(s, 0);
 311         if (sc->environ != NULL)
 312                 environ_copy(sc->environ, child);
 313         environ_set(child, "TMUX_PANE", 0, "%%%u", new_wp->id);
 314
 315         /*
 316          * Then the PATH environment variable. The session one is replaced from
 317          * the client if there is one because otherwise running "tmux new
 318          * myprogram" wouldn't work if myprogram isn't in the session's path.
 319          */
 320         if (c != NULL && c->session == NULL) { /* only unattached clients */
 321                 ee = environ_find(c->environ, "PATH");
 322                 if (ee != NULL)
 323                         environ_set(child, "PATH", 0, "%s", ee->value);
 324         }
 325         if (environ_find(child, "PATH") == NULL)
 326                 environ_set(child, "PATH", 0, "%s", _PATH_DEFPATH);
 327
 328         /* Then the shell. If respawning, use the old one. */
 329         if (~sc->flags & SPAWN_RESPAWN) {
 330                 tmp = options_get_string(s->options, "default-shell");
 331                 if (!checkshell(tmp))
 332                         tmp = _PATH_BSHELL;
 333                 free(new_wp->shell);
 334                 new_wp->shell = xstrdup(tmp);
 335         }
 336         environ_set(child, "SHELL", 0, "%s", new_wp->shell);
 337
 338         /* Log the arguments we are going to use. */
 339         log_debug("%s: shell=%s", __func__, new_wp->shell);
 340         if (new_wp->argc != 0) {
 341                 cp = cmd_stringify_argv(new_wp->argc, new_wp->argv);
 342                 log_debug("%s: cmd=%s", __func__, cp);
 343                 free(cp);
 344         }
 345         log_debug("%s: cwd=%s", __func__, new_wp->cwd);
 346         cmd_log_argv(new_wp->argc, new_wp->argv, "%s", __func__);
 347         environ_log(child, "%s: environment ", __func__);
 348
 349         /* Initialize the window size. */
 350         memset(&ws, 0, sizeof ws);
 351         ws.ws_col = screen_size_x(&new_wp->base);
 352         ws.ws_row = screen_size_y(&new_wp->base);
 353         ws.ws_xpixel = w->xpixel * ws.ws_col;
 354         ws.ws_ypixel = w->ypixel * ws.ws_row;
 355
 356         /* Block signals until fork has completed. */
 357         sigfillset(&set);
 358         sigprocmask(SIG_BLOCK, &set, &oldset);
 359
 360         /* If the command is empty, don't fork a child process. */
 361         if (sc->flags & SPAWN_EMPTY) {
 362                 new_wp->flags |= PANE_EMPTY;
 363                 new_wp->base.mode &= ~MODE_CURSOR;
 364                 new_wp->base.mode |= MODE_CRLF;
 365                 goto complete;
 366         }
 367
 368         /* Fork the new process. */
 369         new_wp->pid = fdforkpty(ptm_fd, &new_wp->fd, new_wp->tty, NULL, &ws);
 370         if (new_wp->pid == -1) {
 371                 xasprintf(cause, "fork failed: %s", strerror(errno));
 372                 new_wp->fd = -1;
 373                 if (~sc->flags & SPAWN_RESPAWN) {
 374                         server_client_remove_pane(new_wp);
 375                         layout_close_pane(new_wp);
 376                         window_remove_pane(w, new_wp);
 377                 }
 378                 sigprocmask(SIG_SETMASK, &oldset, NULL);
 379                 environ_free(child);
 380                 return (NULL);
 381         }
 382
 383         /* In the parent process, everything is done now. */
 384         if (new_wp->pid != 0) {
 385 #if defined(HAVE_SYSTEMD) && defined(ENABLE_CGROUPS)
 386                 /*
 387                  * Move the child process into a new cgroup for systemd-oomd
 388                  * isolation.
 389                  */
 390                 if (systemd_move_pid_to_new_cgroup(new_wp->pid, cause) < 0) {
 391                         log_debug("%s: moving pane to new cgroup failed: %s",
 392                             __func__, *cause);
 393                         free (*cause);
 394                 }
 395 #endif
 396                 goto complete;
 397         }
 398
 399         /*
 400          * Child process. Change to the working directory or home if that
 401          * fails.
 402          */
 403         if (chdir(new_wp->cwd) == 0)
 404                 environ_set(child, "PWD", 0, "%s", new_wp->cwd);
 405         else if ((tmp = find_home()) != NULL && chdir(tmp) == 0)
 406                 environ_set(child, "PWD", 0, "%s", tmp);
 407         else if (chdir("/") == 0)
 408                 environ_set(child, "PWD", 0, "/");
 409         else
 410                 fatal("chdir failed");
 411
 412         /*
 413          * Update terminal escape characters from the session if available and
 414          * force VERASE to tmux's backspace.
 415          */
 416         if (tcgetattr(STDIN_FILENO, &now) != 0)
 417                 _exit(1);
 418         if (s->tio != NULL)
 419                 memcpy(now.c_cc, s->tio->c_cc, sizeof now.c_cc);
 420         key = options_get_number(global_options, "backspace");
 421         if (key >= 0x7f)
 422                 now.c_cc[VERASE] = '\177';
 423         else
 424                 now.c_cc[VERASE] = key;
 425 #ifdef IUTF8
 426         now.c_iflag |= IUTF8;
 427 #endif
 428         if (tcsetattr(STDIN_FILENO, TCSANOW, &now) != 0)
 429                 _exit(1);
 430
 431         /* Clean up file descriptors and signals and update the environment. */
 432         proc_clear_signals(server_proc, 1);
 433         closefrom(STDERR_FILENO + 1);
 434         sigprocmask(SIG_SETMASK, &oldset, NULL);
 435         log_close();
 436         environ_push(child);
 437
 438         /*
 439          * If given multiple arguments, use execvp(). Copy the arguments to
 440          * ensure they end in a NULL.
 441          */
 442         if (new_wp->argc != 0 && new_wp->argc != 1) {
 443                 argvp = cmd_copy_argv(new_wp->argc, new_wp->argv);
 444                 execvp(argvp[0], argvp);
 445                 _exit(1);
 446         }
 447
 448         /*
 449          * If one argument, pass it to $SHELL -c. Otherwise create a login
 450          * shell.
 451          */
 452         cp = strrchr(new_wp->shell, '/');
 453         if (new_wp->argc == 1) {
 454                 tmp = new_wp->argv[0];
 455                 if (cp != NULL && cp[1] != '\0')
 456                         xasprintf(&argv0, "%s", cp + 1);
 457                 else
 458                         xasprintf(&argv0, "%s", new_wp->shell);
 459                 execl(new_wp->shell, argv0, "-c", tmp, (char *)NULL);
 460                 _exit(1);
 461         }
 462         if (cp != NULL && cp[1] != '\0')
 463                 xasprintf(&argv0, "-%s", cp + 1);
 464         else
 465                 xasprintf(&argv0, "-%s", new_wp->shell);
 466         execl(new_wp->shell, argv0, (char *)NULL);
 467         _exit(1);
 468
 469 complete:
 470 #ifdef HAVE_UTEMPTER
 471         if (~new_wp->flags & PANE_EMPTY) {
 472                 xasprintf(&cp, "tmux(%lu).%%%u", (long)getpid(), new_wp->id);
 473                 utempter_add_record(new_wp->fd, cp);
 474                 kill(getpid(), SIGCHLD);
 475                 free(cp);
 476         }
 477 #endif
 478
 479         new_wp->flags &= ~PANE_EXITED;
 480
 481         sigprocmask(SIG_SETMASK, &oldset, NULL);
 482         window_pane_set_event(new_wp);
 483
 484         environ_free(child);
 485
 486         if (sc->flags & SPAWN_RESPAWN)
 487                 return (new_wp);
 488         if ((~sc->flags & SPAWN_DETACHED) || w->active == NULL) {
 489                 if (sc->flags & SPAWN_NONOTIFY)
 490                         window_set_active_pane(w, new_wp, 0);
 491                 else
 492                         window_set_active_pane(w, new_wp, 1);
 493         }
 494         if (~sc->flags & SPAWN_NONOTIFY)
 495                 notify_window("window-layout-changed", w);
 496         return (new_wp);
 497 }