1 /* $OpenBSD: job.c,v 1.65 2021/10/11 10:55:30 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2009 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 #include <sys/ioctl.h> 21 #include <sys/socket.h> 22 #include <sys/wait.h> 23 24 #include <fcntl.h> 25 #include <paths.h> 26 #include <signal.h> 27 #include <stdlib.h> 28 #include <string.h> 29 #include <unistd.h> 30 #include <util.h> 31 32 #include "tmux.h" 33 34 /* 35 * Job scheduling. Run queued commands in the background and record their 36 * output. 37 */ 38 39 static void job_read_callback(struct bufferevent *, void *); 40 static void job_write_callback(struct bufferevent *, void *); 41 static void job_error_callback(struct bufferevent *, short, void *); 42 43 /* A single job. */ 44 struct job { 45 enum { 46 JOB_RUNNING, 47 JOB_DEAD, 48 JOB_CLOSED 49 } state; 50 51 int flags; 52 53 char *cmd; 54 pid_t pid; 55 char tty[TTY_NAME_MAX]; 56 int status; 57 58 int fd; 59 struct bufferevent *event; 60 61 job_update_cb updatecb; 62 job_complete_cb completecb; 63 job_free_cb freecb; 64 void *data; 65 66 LIST_ENTRY(job) entry; 67 }; 68 69 /* All jobs list. */ 70 static LIST_HEAD(joblist, job) all_jobs = LIST_HEAD_INITIALIZER(all_jobs); 71 72 /* Start a job running. */ 73 struct job * 74 job_run(const char *cmd, int argc, char **argv, struct environ *e, struct session *s, 75 const char *cwd, job_update_cb updatecb, job_complete_cb completecb, 76 job_free_cb freecb, void *data, int flags, int sx, int sy) 77 { 78 struct job *job; 79 struct environ *env; 80 pid_t pid; 81 int nullfd, out[2], master; 82 const char *home; 83 sigset_t set, oldset; 84 struct winsize ws; 85 char **argvp, tty[TTY_NAME_MAX]; 86 87 /* 88 * Do not set TERM during .tmux.conf, it is nice to be able to use 89 * if-shell to decide on default-terminal based on outside TERM. 90 */ 91 env = environ_for_session(s, !cfg_finished); 92 if (e != NULL) { 93 environ_copy(e, env); 94 } 95 96 sigfillset(&set); 97 sigprocmask(SIG_BLOCK, &set, &oldset); 98 99 if (flags & JOB_PTY) { 100 memset(&ws, 0, sizeof ws); 101 ws.ws_col = sx; 102 ws.ws_row = sy; 103 pid = fdforkpty(ptm_fd, &master, tty, NULL, &ws); 104 } else { 105 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0) 106 goto fail; 107 pid = fork(); 108 } 109 if (cmd == NULL) { 110 cmd_log_argv(argc, argv, "%s:", __func__); 111 log_debug("%s: cwd=%s", __func__, cwd == NULL ? "" : cwd); 112 } else { 113 log_debug("%s: cmd=%s, cwd=%s", __func__, cmd, 114 cwd == NULL ? "" : cwd); 115 } 116 117 switch (pid) { 118 case -1: 119 if (~flags & JOB_PTY) { 120 close(out[0]); 121 close(out[1]); 122 } 123 goto fail; 124 case 0: 125 proc_clear_signals(server_proc, 1); 126 sigprocmask(SIG_SETMASK, &oldset, NULL); 127 128 if ((cwd == NULL || chdir(cwd) != 0) && 129 ((home = find_home()) == NULL || chdir(home) != 0) && 130 chdir("/") != 0) 131 fatal("chdir failed"); 132 133 environ_push(env); 134 environ_free(env); 135 136 if (~flags & JOB_PTY) { 137 if (dup2(out[1], STDIN_FILENO) == -1) 138 fatal("dup2 failed"); 139 if (dup2(out[1], STDOUT_FILENO) == -1) 140 fatal("dup2 failed"); 141 if (out[1] != STDIN_FILENO && out[1] != STDOUT_FILENO) 142 close(out[1]); 143 close(out[0]); 144 145 nullfd = open(_PATH_DEVNULL, O_RDWR, 0); 146 if (nullfd == -1) 147 fatal("open failed"); 148 if (dup2(nullfd, STDERR_FILENO) == -1) 149 fatal("dup2 failed"); 150 if (nullfd != STDERR_FILENO) 151 close(nullfd); 152 } 153 closefrom(STDERR_FILENO + 1); 154 155 if (cmd != NULL) { 156 execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL); 157 fatal("execl failed"); 158 } else { 159 argvp = cmd_copy_argv(argc, argv); 160 execvp(argvp[0], argvp); 161 fatal("execvp failed"); 162 } 163 } 164 165 sigprocmask(SIG_SETMASK, &oldset, NULL); 166 environ_free(env); 167 168 job = xmalloc(sizeof *job); 169 job->state = JOB_RUNNING; 170 job->flags = flags; 171 172 if (cmd != NULL) 173 job->cmd = xstrdup(cmd); 174 else 175 job->cmd = cmd_stringify_argv(argc, argv); 176 job->pid = pid; 177 strlcpy(job->tty, tty, sizeof job->tty); 178 job->status = 0; 179 180 LIST_INSERT_HEAD(&all_jobs, job, entry); 181 182 job->updatecb = updatecb; 183 job->completecb = completecb; 184 job->freecb = freecb; 185 job->data = data; 186 187 if (~flags & JOB_PTY) { 188 close(out[1]); 189 job->fd = out[0]; 190 } else 191 job->fd = master; 192 setblocking(job->fd, 0); 193 194 job->event = bufferevent_new(job->fd, job_read_callback, 195 job_write_callback, job_error_callback, job); 196 if (job->event == NULL) 197 fatalx("out of memory"); 198 bufferevent_enable(job->event, EV_READ|EV_WRITE); 199 200 log_debug("run job %p: %s, pid %ld", job, job->cmd, (long) job->pid); 201 return (job); 202 203 fail: 204 sigprocmask(SIG_SETMASK, &oldset, NULL); 205 environ_free(env); 206 return (NULL); 207 } 208 209 /* Take job's file descriptor and free the job. */ 210 int 211 job_transfer(struct job *job, pid_t *pid, char *tty, size_t ttylen) 212 { 213 int fd = job->fd; 214 215 log_debug("transfer job %p: %s", job, job->cmd); 216 217 if (pid != NULL) 218 *pid = job->pid; 219 if (tty != NULL) 220 strlcpy(tty, job->tty, ttylen); 221 222 LIST_REMOVE(job, entry); 223 free(job->cmd); 224 225 if (job->freecb != NULL && job->data != NULL) 226 job->freecb(job->data); 227 228 if (job->event != NULL) 229 bufferevent_free(job->event); 230 231 free(job); 232 return (fd); 233 } 234 235 /* Kill and free an individual job. */ 236 void 237 job_free(struct job *job) 238 { 239 log_debug("free job %p: %s", job, job->cmd); 240 241 LIST_REMOVE(job, entry); 242 free(job->cmd); 243 244 if (job->freecb != NULL && job->data != NULL) 245 job->freecb(job->data); 246 247 if (job->pid != -1) 248 kill(job->pid, SIGTERM); 249 if (job->event != NULL) 250 bufferevent_free(job->event); 251 if (job->fd != -1) 252 close(job->fd); 253 254 free(job); 255 } 256 257 /* Resize job. */ 258 void 259 job_resize(struct job *job, u_int sx, u_int sy) 260 { 261 struct winsize ws; 262 263 if (job->fd == -1 || (~job->flags & JOB_PTY)) 264 return; 265 266 log_debug("resize job %p: %ux%u", job, sx, sy); 267 268 memset(&ws, 0, sizeof ws); 269 ws.ws_col = sx; 270 ws.ws_row = sy; 271 if (ioctl(job->fd, TIOCSWINSZ, &ws) == -1) 272 fatal("ioctl failed"); 273 } 274 275 /* Job buffer read callback. */ 276 static void 277 job_read_callback(__unused struct bufferevent *bufev, void *data) 278 { 279 struct job *job = data; 280 281 if (job->updatecb != NULL) 282 job->updatecb(job); 283 } 284 285 /* 286 * Job buffer write callback. Fired when the buffer falls below watermark 287 * (default is empty). If all the data has been written, disable the write 288 * event. 289 */ 290 static void 291 job_write_callback(__unused struct bufferevent *bufev, void *data) 292 { 293 struct job *job = data; 294 size_t len = EVBUFFER_LENGTH(EVBUFFER_OUTPUT(job->event)); 295 296 log_debug("job write %p: %s, pid %ld, output left %zu", job, job->cmd, 297 (long) job->pid, len); 298 299 if (len == 0 && (~job->flags & JOB_KEEPWRITE)) { 300 shutdown(job->fd, SHUT_WR); 301 bufferevent_disable(job->event, EV_WRITE); 302 } 303 } 304 305 /* Job buffer error callback. */ 306 static void 307 job_error_callback(__unused struct bufferevent *bufev, __unused short events, 308 void *data) 309 { 310 struct job *job = data; 311 312 log_debug("job error %p: %s, pid %ld", job, job->cmd, (long) job->pid); 313 314 if (job->state == JOB_DEAD) { 315 if (job->completecb != NULL) 316 job->completecb(job); 317 job_free(job); 318 } else { 319 bufferevent_disable(job->event, EV_READ); 320 job->state = JOB_CLOSED; 321 } 322 } 323 324 /* Job died (waitpid() returned its pid). */ 325 void 326 job_check_died(pid_t pid, int status) 327 { 328 struct job *job; 329 330 LIST_FOREACH(job, &all_jobs, entry) { 331 if (pid == job->pid) 332 break; 333 } 334 if (job == NULL) 335 return; 336 if (WIFSTOPPED(status)) { 337 if (WSTOPSIG(status) == SIGTTIN || WSTOPSIG(status) == SIGTTOU) 338 return; 339 killpg(job->pid, SIGCONT); 340 return; 341 } 342 log_debug("job died %p: %s, pid %ld", job, job->cmd, (long) job->pid); 343 344 job->status = status; 345 346 if (job->state == JOB_CLOSED) { 347 if (job->completecb != NULL) 348 job->completecb(job); 349 job_free(job); 350 } else { 351 job->pid = -1; 352 job->state = JOB_DEAD; 353 } 354 } 355 356 /* Get job status. */ 357 int 358 job_get_status(struct job *job) 359 { 360 return (job->status); 361 } 362 363 /* Get job data. */ 364 void * 365 job_get_data(struct job *job) 366 { 367 return (job->data); 368 } 369 370 /* Get job event. */ 371 struct bufferevent * 372 job_get_event(struct job *job) 373 { 374 return (job->event); 375 } 376 377 /* Kill all jobs. */ 378 void 379 job_kill_all(void) 380 { 381 struct job *job; 382 383 LIST_FOREACH(job, &all_jobs, entry) { 384 if (job->pid != -1) 385 kill(job->pid, SIGTERM); 386 } 387 } 388 389 /* Are any jobs still running? */ 390 int 391 job_still_running(void) 392 { 393 struct job *job; 394 395 LIST_FOREACH(job, &all_jobs, entry) { 396 if ((~job->flags & JOB_NOWAIT) && job->state == JOB_RUNNING) 397 return (1); 398 } 399 return (0); 400 } 401 402 /* Print job summary. */ 403 void 404 job_print_summary(struct cmdq_item *item, int blank) 405 { 406 struct job *job; 407 u_int n = 0; 408 409 LIST_FOREACH(job, &all_jobs, entry) { 410 if (blank) { 411 cmdq_print(item, "%s", ""); 412 blank = 0; 413 } 414 cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]", 415 n, job->cmd, job->fd, (long)job->pid, job->status); 416 n++; 417 } 418 } 419