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