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