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