Annotation of src/usr.bin/tmux/spawn.c, Revision 1.7
1.7 ! nicm 1: /* $OpenBSD: spawn.c,v 1.6 2019/06/30 19:21:53 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;
59: char tmp[128];
60: const char *name;
61:
62: log_debug("%s: %s, flags=%#x", from, sc->item->name, sc->flags);
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);
73:
74: name = sc->name;
75: if (name == NULL)
76: name = "none";
77: log_debug("%s: name=%s", from, name);
78: }
79:
80: struct winlink *
81: spawn_window(struct spawn_context *sc, char **cause)
82: {
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;
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(s, NULL, &sx, &sy, -1);
159: if ((w = window_create(sx, sy)) == NULL) {
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;
167: winlink_set_window(sc->wl, w);
168: } else
169: w = NULL;
170: sc->flags |= SPAWN_NONOTIFY;
171:
172: /* Spawn the pane. */
173: wp = spawn_pane(sc, cause);
174: if (wp == NULL) {
1.6 nicm 175: if (~sc->flags & SPAWN_RESPAWN)
1.1 nicm 176: winlink_remove(&s->windows, sc->wl);
177: return (NULL);
178: }
179:
180: /* Set the name of the new window. */
181: if (~sc->flags & SPAWN_RESPAWN) {
182: if (sc->name != NULL) {
183: w->name = xstrdup(sc->name);
184: options_set_number(w->options, "automatic-rename", 0);
185: } else
186: w->name = xstrdup(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 client *c = item->client;
206: struct session *s = sc->s;
207: struct window *w = sc->wl->window;
208: struct window_pane *new_wp;
209: struct environ *child;
210: struct environ_entry *ee;
211: char **argv, *cp, **argvp, *argv0, *cwd;
212: const char *cmd, *tmp;
213: int argc;
214: u_int idx;
215: struct termios now;
216: u_int hlimit;
217: struct winsize ws;
218: sigset_t set, oldset;
219:
220: spawn_log(__func__, sc);
221:
222: /*
223: * If we are respawning then get rid of the old process. Otherwise
224: * either create a new cell or assign to the one we are given.
225: */
226: hlimit = options_get_number(s->options, "history-limit");
227: if (sc->flags & SPAWN_RESPAWN) {
228: if (sc->wp0->fd != -1 && (~sc->flags & SPAWN_KILL)) {
229: window_pane_index(sc->wp0, &idx);
230: xasprintf(cause, "pane %s:%d.%u still active",
231: s->name, sc->wl->idx, idx);
232: return (NULL);
233: }
234: if (sc->wp0->fd != -1) {
235: bufferevent_free(sc->wp0->event);
236: close(sc->wp0->fd);
237: }
238: window_pane_reset_mode_all(sc->wp0);
239: screen_reinit(&sc->wp0->base);
240: input_init(sc->wp0);
241: new_wp = sc->wp0;
242: new_wp->flags &= ~(PANE_STATUSREADY|PANE_STATUSDRAWN);
243: } else if (sc->lc == NULL) {
244: new_wp = window_add_pane(w, NULL, hlimit, sc->flags);
245: layout_init(w, new_wp);
246: } else {
247: new_wp = window_add_pane(w, sc->wp0, hlimit, sc->flags);
248: layout_assign_pane(sc->lc, new_wp);
249: }
250:
251: /*
252: * Now we have a pane with nothing running in it ready for the new
253: * process. Work out the command and arguments.
254: */
255: if (sc->argc == 0) {
256: cmd = options_get_string(s->options, "default-command");
257: if (cmd != NULL && *cmd != '\0') {
258: argc = 1;
259: argv = (char **)&cmd;
260: } else {
261: argc = 0;
262: argv = NULL;
263: }
264: } else {
265: argc = sc->argc;
266: argv = sc->argv;
267: }
268:
269: /*
270: * Replace the stored arguments if there are new ones. If not, the
271: * existing ones will be used (they will only exist for respawn).
272: */
273: if (argc > 0) {
274: cmd_free_argv(new_wp->argc, new_wp->argv);
275: new_wp->argc = argc;
276: new_wp->argv = cmd_copy_argv(argc, argv);
277: }
278:
279: /*
280: * Work out the current working directory. If respawning, use
281: * the pane's stored one unless specified.
282: */
283: if (sc->cwd != NULL)
284: cwd = format_single(item, sc->cwd, c, s, NULL, NULL);
285: else if (~sc->flags & SPAWN_RESPAWN)
286: cwd = xstrdup(server_client_get_cwd(c, s));
287: else
288: cwd = NULL;
289: if (cwd != NULL) {
290: free(new_wp->cwd);
291: new_wp->cwd = cwd;
292: }
293:
294: /* Create an environment for this pane. */
295: child = environ_for_session(s, 0);
1.2 nicm 296: if (sc->environ != NULL)
297: environ_copy(sc->environ, child);
1.1 nicm 298: environ_set(child, "TMUX_PANE", "%%%u", new_wp->id);
299:
300: /*
301: * Then the PATH environment variable. The session one is replaced from
302: * the client if there is one because otherwise running "tmux new
303: * myprogram" wouldn't work if myprogram isn't in the session's path.
304: */
305: if (c != NULL && c->session == NULL) { /* only unattached clients */
306: ee = environ_find(c->environ, "PATH");
307: if (ee != NULL)
308: environ_set(child, "PATH", "%s", ee->value);
309: }
310: if (environ_find(child, "PATH") == NULL)
311: environ_set(child, "%s", _PATH_DEFPATH);
312:
313: /* Then the shell. If respawning, use the old one. */
314: if (~sc->flags & SPAWN_RESPAWN) {
315: tmp = options_get_string(s->options, "default-shell");
316: if (*tmp == '\0' || areshell(tmp))
317: tmp = _PATH_BSHELL;
318: free(new_wp->shell);
319: new_wp->shell = xstrdup(tmp);
320: }
321: environ_set(child, "SHELL", "%s", new_wp->shell);
322:
323: /* Log the arguments we are going to use. */
324: log_debug("%s: shell=%s", __func__, new_wp->shell);
325: if (new_wp->argc != 0) {
326: cp = cmd_stringify_argv(new_wp->argc, new_wp->argv);
327: log_debug("%s: cmd=%s", __func__, cp);
328: free(cp);
329: }
330: if (cwd != NULL)
331: log_debug("%s: cwd=%s", __func__, cwd);
1.4 nicm 332: cmd_log_argv(new_wp->argc, new_wp->argv, "%s", __func__);
1.1 nicm 333: environ_log(child, "%s: environment ", __func__);
334:
335: /* Initialize the window size. */
336: memset(&ws, 0, sizeof ws);
337: ws.ws_col = screen_size_x(&new_wp->base);
338: ws.ws_row = screen_size_y(&new_wp->base);
339:
340: /* Block signals until fork has completed. */
341: sigfillset(&set);
342: sigprocmask(SIG_BLOCK, &set, &oldset);
1.7 ! nicm 343:
! 344: /* If the command is empty, don't fork a child process. */
! 345: if (sc->flags & SPAWN_EMPTY) {
! 346: new_wp->flags |= PANE_EMPTY;
! 347: new_wp->base.mode &= ~MODE_CURSOR;
! 348: new_wp->base.mode |= MODE_CRLF;
! 349: goto complete;
! 350: }
1.1 nicm 351:
352: /* Fork the new process. */
353: new_wp->pid = fdforkpty(ptm_fd, &new_wp->fd, new_wp->tty, NULL, &ws);
354: if (new_wp->pid == -1) {
355: xasprintf(cause, "fork failed: %s", strerror(errno));
356: new_wp->fd = -1;
357: if (~sc->flags & SPAWN_RESPAWN) {
358: layout_close_pane(new_wp);
359: window_remove_pane(w, new_wp);
360: }
361: sigprocmask(SIG_SETMASK, &oldset, NULL);
362: return (NULL);
363: }
364:
365: /* In the parent process, everything is done now. */
1.3 nicm 366: if (new_wp->pid != 0)
367: goto complete;
1.1 nicm 368:
369: /*
370: * Child process. Change to the working directory or home if that
371: * fails.
372: */
373: if (chdir(new_wp->cwd) != 0) {
374: if ((tmp = find_home()) == NULL || chdir(tmp) != 0)
375: chdir("/");
376: }
377:
378: /*
379: * Update terminal escape characters from the session if available and
380: * force VERASE to tmux's \177.
381: */
382: if (tcgetattr(STDIN_FILENO, &now) != 0)
383: _exit(1);
384: if (s->tio != NULL)
385: memcpy(now.c_cc, s->tio->c_cc, sizeof now.c_cc);
386: now.c_cc[VERASE] = '\177';
387: if (tcsetattr(STDIN_FILENO, TCSANOW, &now) != 0)
388: _exit(1);
389:
390: /* Clean up file descriptors and signals and update the environment. */
391: closefrom(STDERR_FILENO + 1);
392: proc_clear_signals(server_proc, 1);
393: sigprocmask(SIG_SETMASK, &oldset, NULL);
394: log_close();
395: environ_push(child);
396:
397: /*
398: * If given multiple arguments, use execvp(). Copy the arguments to
399: * ensure they end in a NULL.
400: */
401: if (new_wp->argc != 0 && new_wp->argc != 1) {
402: argvp = cmd_copy_argv(new_wp->argc, new_wp->argv);
403: execvp(argvp[0], argvp);
404: _exit(1);
405: }
406:
407: /*
408: * If one argument, pass it to $SHELL -c. Otherwise create a login
409: * shell.
410: */
411: cp = strrchr(new_wp->shell, '/');
412: if (new_wp->argc == 1) {
413: tmp = new_wp->argv[0];
414: if (cp != NULL && cp[1] != '\0')
415: xasprintf(&argv0, "%s", cp + 1);
416: else
417: xasprintf(&argv0, "%s", new_wp->shell);
418: execl(new_wp->shell, argv0, "-c", tmp, (char *)NULL);
419: _exit(1);
420: }
421: if (cp != NULL && cp[1] != '\0')
422: xasprintf(&argv0, "-%s", cp + 1);
423: else
424: xasprintf(&argv0, "-%s", new_wp->shell);
425: execl(new_wp->shell, argv0, (char *)NULL);
426: _exit(1);
1.3 nicm 427:
428: complete:
429: new_wp->pipe_off = 0;
430: new_wp->flags &= ~PANE_EXITED;
431:
432: sigprocmask(SIG_SETMASK, &oldset, NULL);
433: window_pane_set_event(new_wp);
434:
435: if (sc->flags & SPAWN_RESPAWN)
436: return (new_wp);
437: if ((~sc->flags & SPAWN_DETACHED) || w->active == NULL) {
438: if (sc->flags & SPAWN_NONOTIFY)
439: window_set_active_pane(w, new_wp, 0);
440: else
441: window_set_active_pane(w, new_wp, 1);
442: }
443: if (~sc->flags & SPAWN_NONOTIFY)
444: notify_window("window-layout-changed", w);
445: return (new_wp);
1.1 nicm 446: }
![[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