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 | |
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 | 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 | |
78 | struct winlink * |
79 | spawn_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 | |
204 | struct window_pane * |
205 | spawn_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 | |
439 | complete: |
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 | |