diff options
Diffstat (limited to 'spawn.c')
| -rw-r--r-- | spawn.c | 484 |
1 files changed, 484 insertions, 0 deletions
@@ -0,0 +1,484 @@ +/* $OpenBSD$ */ + +/* + * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER + * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <sys/types.h> + +#include <errno.h> +#include <signal.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "tmux.h" + +/* + * Set up the environment and create a new window and pane or a new pane. + * + * We need to set up the following items: + * + * - history limit, comes from the session; + * + * - base index, comes from the session; + * + * - current working directory, may be specified - if it isn't it comes from + * either the client or the session; + * + * - PATH variable, comes from the client if any, otherwise from the session + * environment; + * + * - shell, comes from default-shell; + * + * - termios, comes from the session; + * + * - remaining environment, comes from the session. + */ + +static void +spawn_log(const char *from, struct spawn_context *sc) +{ + struct session *s = sc->s; + struct winlink *wl = sc->wl; + struct window_pane *wp0 = sc->wp0; + const char *name = cmdq_get_name(sc->item); + char tmp[128]; + + log_debug("%s: %s, flags=%#x", from, name, sc->flags); + + if (wl != NULL && wp0 != NULL) + xsnprintf(tmp, sizeof tmp, "wl=%d wp0=%%%u", wl->idx, wp0->id); + else if (wl != NULL) + xsnprintf(tmp, sizeof tmp, "wl=%d wp0=none", wl->idx); + else if (wp0 != NULL) + xsnprintf(tmp, sizeof tmp, "wl=none wp0=%%%u", wp0->id); + else + xsnprintf(tmp, sizeof tmp, "wl=none wp0=none"); + log_debug("%s: s=$%u %s idx=%d", from, s->id, tmp, sc->idx); + log_debug("%s: name=%s", from, sc->name == NULL ? "none" : sc->name); +} + +struct winlink * +spawn_window(struct spawn_context *sc, char **cause) +{ + struct cmdq_item *item = sc->item; + struct client *c = cmdq_get_client(item); + struct session *s = sc->s; + struct window *w; + struct window_pane *wp; + struct winlink *wl; + int idx = sc->idx; + u_int sx, sy, xpixel, ypixel; + + spawn_log(__func__, sc); + + /* + * If the window already exists, we are respawning, so destroy all the + * panes except one. + */ + if (sc->flags & SPAWN_RESPAWN) { + w = sc->wl->window; + if (~sc->flags & SPAWN_KILL) { + TAILQ_FOREACH(wp, &w->panes, entry) { + if (wp->fd != -1) + break; + } + if (wp != NULL) { + xasprintf(cause, "window %s:%d still active", + s->name, sc->wl->idx); + return (NULL); + } + } + + sc->wp0 = TAILQ_FIRST(&w->panes); + TAILQ_REMOVE(&w->panes, sc->wp0, entry); + + layout_free(w); + window_destroy_panes(w); + + TAILQ_INSERT_HEAD(&w->panes, sc->wp0, entry); + window_pane_resize(sc->wp0, w->sx, w->sy); + + layout_init(w, sc->wp0); + window_set_active_pane(w, sc->wp0, 0); + } + + /* + * Otherwise we have no window so we will need to create one. First + * check if the given index already exists and destroy it if so. + */ + if ((~sc->flags & SPAWN_RESPAWN) && idx != -1) { + wl = winlink_find_by_index(&s->windows, idx); + if (wl != NULL && (~sc->flags & SPAWN_KILL)) { + xasprintf(cause, "index %d in use", idx); + return (NULL); + } + if (wl != NULL) { + /* + * Can't use session_detach as it will destroy session + * if this makes it empty. + */ + wl->flags &= ~WINLINK_ALERTFLAGS; + notify_session_window("window-unlinked", s, wl->window); + winlink_stack_remove(&s->lastw, wl); + winlink_remove(&s->windows, wl); + + if (s->curw == wl) { + s->curw = NULL; + sc->flags &= ~SPAWN_DETACHED; + } + } + } + + /* Then create a window if needed. */ + if (~sc->flags & SPAWN_RESPAWN) { + if (idx == -1) + idx = -1 - options_get_number(s->options, "base-index"); + if ((sc->wl = winlink_add(&s->windows, idx)) == NULL) { + xasprintf(cause, "couldn't add window %d", idx); + return (NULL); + } + default_window_size(sc->tc, s, NULL, &sx, &sy, &xpixel, &ypixel, + -1); + if ((w = window_create(sx, sy, xpixel, ypixel)) == NULL) { + winlink_remove(&s->windows, sc->wl); + xasprintf(cause, "couldn't create window %d", idx); + return (NULL); + } + if (s->curw == NULL) + s->curw = sc->wl; + sc->wl->session = s; + w->latest = sc->tc; + winlink_set_window(sc->wl, w); + } else + w = NULL; + sc->flags |= SPAWN_NONOTIFY; + + /* Spawn the pane. */ + wp = spawn_pane(sc, cause); + if (wp == NULL) { + if (~sc->flags & SPAWN_RESPAWN) + winlink_remove(&s->windows, sc->wl); + return (NULL); + } + + /* Set the name of the new window. */ + if (~sc->flags & SPAWN_RESPAWN) { + free(w->name); + if (sc->name != NULL) { + w->name = format_single(item, sc->name, c, s, NULL, + NULL); + options_set_number(w->options, "automatic-rename", 0); + } else + w->name = default_window_name(w); + } + + /* Switch to the new window if required. */ + if (~sc->flags & SPAWN_DETACHED) + session_select(s, sc->wl->idx); + + /* Fire notification if new window. */ + if (~sc->flags & SPAWN_RESPAWN) + notify_session_window("window-linked", s, w); + + session_group_synchronize_from(s); + return (sc->wl); +} + +struct window_pane * +spawn_pane(struct spawn_context *sc, char **cause) +{ + struct cmdq_item *item = sc->item; + struct cmd_find_state *target = cmdq_get_target(item); + struct client *c = cmdq_get_client(item); + struct session *s = sc->s; + struct window *w = sc->wl->window; + struct window_pane *new_wp; + struct environ *child; + struct environ_entry *ee; + char **argv, *cp, **argvp, *argv0, *cwd, *new_cwd; + const char *cmd, *tmp; + int argc; + u_int idx; + struct termios now; + u_int hlimit; + struct winsize ws; + sigset_t set, oldset; + key_code key; + + spawn_log(__func__, sc); + + /* + * Work out the current working directory. If respawning, use + * the pane's stored one unless specified. + */ + if (sc->cwd != NULL) { + cwd = format_single(item, sc->cwd, c, target->s, NULL, NULL); + if (*cwd != '/') { + xasprintf(&new_cwd, "%s/%s", server_client_get_cwd(c, + target->s), cwd); + free(cwd); + cwd = new_cwd; + } + } else if (~sc->flags & SPAWN_RESPAWN) + cwd = xstrdup(server_client_get_cwd(c, target->s)); + else + cwd = NULL; + + /* + * If we are respawning then get rid of the old process. Otherwise + * either create a new cell or assign to the one we are given. + */ + hlimit = options_get_number(s->options, "history-limit"); + if (sc->flags & SPAWN_RESPAWN) { + if (sc->wp0->fd != -1 && (~sc->flags & SPAWN_KILL)) { + window_pane_index(sc->wp0, &idx); + xasprintf(cause, "pane %s:%d.%u still active", + s->name, sc->wl->idx, idx); + free(cwd); + return (NULL); + } + if (sc->wp0->fd != -1) { + bufferevent_free(sc->wp0->event); + close(sc->wp0->fd); + } + window_pane_reset_mode_all(sc->wp0); + screen_reinit(&sc->wp0->base); + input_free(sc->wp0->ictx); + sc->wp0->ictx = NULL; + new_wp = sc->wp0; + new_wp->flags &= ~(PANE_STATUSREADY|PANE_STATUSDRAWN); + } else if (sc->lc == NULL) { + new_wp = window_add_pane(w, NULL, hlimit, sc->flags); + layout_init(w, new_wp); + } else { + new_wp = window_add_pane(w, sc->wp0, hlimit, sc->flags); + if (sc->flags & SPAWN_ZOOM) + layout_assign_pane(sc->lc, new_wp, 1); + else + layout_assign_pane(sc->lc, new_wp, 0); + } + + /* + * Now we have a pane with nothing running in it ready for the new + * process. Work out the command and arguments and store the working + * directory. + */ + if (sc->argc == 0 && (~sc->flags & SPAWN_RESPAWN)) { + cmd = options_get_string(s->options, "default-command"); + if (cmd != NULL && *cmd != '\0') { + argc = 1; + argv = (char **)&cmd; + } else { + argc = 0; + argv = NULL; + } + } else { + argc = sc->argc; + argv = sc->argv; + } + if (cwd != NULL) { + free(new_wp->cwd); + new_wp->cwd = cwd; + } + + /* + * Replace the stored arguments if there are new ones. If not, the + * existing ones will be used (they will only exist for respawn). + */ + if (argc > 0) { + cmd_free_argv(new_wp->argc, new_wp->argv); + new_wp->argc = argc; + new_wp->argv = cmd_copy_argv(argc, argv); + } + + /* Create an environment for this pane. */ + child = environ_for_session(s, 0); + if (sc->environ != NULL) + environ_copy(sc->environ, child); + environ_set(child, "TMUX_PANE", 0, "%%%u", new_wp->id); + + /* + * Then the PATH environment variable. The session one is replaced from + * the client if there is one because otherwise running "tmux new + * myprogram" wouldn't work if myprogram isn't in the session's path. + */ + if (c != NULL && c->session == NULL) { /* only unattached clients */ + ee = environ_find(c->environ, "PATH"); + if (ee != NULL) + environ_set(child, "PATH", 0, "%s", ee->value); + } + if (environ_find(child, "PATH") == NULL) + environ_set(child, "PATH", 0, "%s", _PATH_DEFPATH); + + /* Then the shell. If respawning, use the old one. */ + if (~sc->flags & SPAWN_RESPAWN) { + tmp = options_get_string(s->options, "default-shell"); + if (!checkshell(tmp)) + tmp = _PATH_BSHELL; + free(new_wp->shell); + new_wp->shell = xstrdup(tmp); + } + environ_set(child, "SHELL", 0, "%s", new_wp->shell); + + /* Log the arguments we are going to use. */ + log_debug("%s: shell=%s", __func__, new_wp->shell); + if (new_wp->argc != 0) { + cp = cmd_stringify_argv(new_wp->argc, new_wp->argv); + log_debug("%s: cmd=%s", __func__, cp); + free(cp); + } + log_debug("%s: cwd=%s", __func__, new_wp->cwd); + cmd_log_argv(new_wp->argc, new_wp->argv, "%s", __func__); + environ_log(child, "%s: environment ", __func__); + + /* Initialize the window size. */ + memset(&ws, 0, sizeof ws); + ws.ws_col = screen_size_x(&new_wp->base); + ws.ws_row = screen_size_y(&new_wp->base); + ws.ws_xpixel = w->xpixel * ws.ws_col; + ws.ws_ypixel = w->ypixel * ws.ws_row; + + /* Block signals until fork has completed. */ + sigfillset(&set); + sigprocmask(SIG_BLOCK, &set, &oldset); + + /* If the command is empty, don't fork a child process. */ + if (sc->flags & SPAWN_EMPTY) { + new_wp->flags |= PANE_EMPTY; + new_wp->base.mode &= ~MODE_CURSOR; + new_wp->base.mode |= MODE_CRLF; + goto complete; + } + + /* Fork the new process. */ + new_wp->pid = fdforkpty(ptm_fd, &new_wp->fd, new_wp->tty, NULL, &ws); + if (new_wp->pid == -1) { + xasprintf(cause, "fork failed: %s", strerror(errno)); + new_wp->fd = -1; + if (~sc->flags & SPAWN_RESPAWN) { + server_client_remove_pane(new_wp); + layout_close_pane(new_wp); + window_remove_pane(w, new_wp); + } + sigprocmask(SIG_SETMASK, &oldset, NULL); + environ_free(child); + return (NULL); + } + + /* In the parent process, everything is done now. */ + if (new_wp->pid != 0) + goto complete; + + /* + * Child process. Change to the working directory or home if that + * fails. + */ + if (chdir(new_wp->cwd) == 0) + environ_set(child, "PWD", 0, "%s", new_wp->cwd); + else if ((tmp = find_home()) != NULL || chdir(tmp) == 0) + environ_set(child, "PWD", 0, "%s", tmp); + else if (chdir("/") == 0) + environ_set(child, "PWD", 0, "/"); + else + fatal("chdir failed"); + + /* + * Update terminal escape characters from the session if available and + * force VERASE to tmux's backspace. + */ + if (tcgetattr(STDIN_FILENO, &now) != 0) + _exit(1); + if (s->tio != NULL) + memcpy(now.c_cc, s->tio->c_cc, sizeof now.c_cc); + key = options_get_number(global_options, "backspace"); + if (key >= 0x7f) + now.c_cc[VERASE] = '\177'; + else + now.c_cc[VERASE] = key; +#ifdef IUTF8 + now.c_iflag |= IUTF8; +#endif + if (tcsetattr(STDIN_FILENO, TCSANOW, &now) != 0) + _exit(1); + + /* Clean up file descriptors and signals and update the environment. */ + closefrom(STDERR_FILENO + 1); + proc_clear_signals(server_proc, 1); + sigprocmask(SIG_SETMASK, &oldset, NULL); + log_close(); + environ_push(child); + + /* + * If given multiple arguments, use execvp(). Copy the arguments to + * ensure they end in a NULL. + */ + if (new_wp->argc != 0 && new_wp->argc != 1) { + argvp = cmd_copy_argv(new_wp->argc, new_wp->argv); + execvp(argvp[0], argvp); + _exit(1); + } + + /* + * If one argument, pass it to $SHELL -c. Otherwise create a login + * shell. + */ + cp = strrchr(new_wp->shell, '/'); + if (new_wp->argc == 1) { + tmp = new_wp->argv[0]; + if (cp != NULL && cp[1] != '\0') + xasprintf(&argv0, "%s", cp + 1); + else + xasprintf(&argv0, "%s", new_wp->shell); + execl(new_wp->shell, argv0, "-c", tmp, (char *)NULL); + _exit(1); + } + if (cp != NULL && cp[1] != '\0') + xasprintf(&argv0, "-%s", cp + 1); + else + xasprintf(&argv0, "-%s", new_wp->shell); + execl(new_wp->shell, argv0, (char *)NULL); + _exit(1); + +complete: +#ifdef HAVE_UTEMPTER + if (~new_wp->flags & PANE_EMPTY) { + xasprintf(&cp, "tmux(%lu).%%%u", (long)getpid(), new_wp->id); + utempter_add_record(new_wp->fd, cp); + kill(getpid(), SIGCHLD); + free(cp); + } +#endif + + new_wp->flags &= ~PANE_EXITED; + + sigprocmask(SIG_SETMASK, &oldset, NULL); + window_pane_set_event(new_wp); + + environ_free(child); + + if (sc->flags & SPAWN_RESPAWN) + return (new_wp); + if ((~sc->flags & SPAWN_DETACHED) || w->active == NULL) { + if (sc->flags & SPAWN_NONOTIFY) + window_set_active_pane(w, new_wp, 0); + else + window_set_active_pane(w, new_wp, 1); + } + if (~sc->flags & SPAWN_NONOTIFY) + notify_window("window-layout-changed", w); + return (new_wp); +} |