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