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
spawn_log(const char * from,struct spawn_context * sc)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 *
spawn_window(struct spawn_context * sc,char ** cause)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 *
spawn_pane(struct spawn_context * sc,char ** cause)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 = __UNCONST(&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 }
498