1 /* $OpenBSD$ */ 2 3 /* 4 * Copyright (c) 2009 Nicholas Marriott <nicm@users.sourceforge.net> 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/socket.h> 21 22 #include <fcntl.h> 23 #include <signal.h> 24 #include <stdlib.h> 25 #include <string.h> 26 #include <unistd.h> 27 28 #include "tmux.h" 29 30 /* 31 * Job scheduling. Run queued commands in the background and record their 32 * output. 33 */ 34 35 void job_callback(struct bufferevent *, short, void *); 36 void job_write_callback(struct bufferevent *, void *); 37 38 /* All jobs list. */ 39 struct joblist all_jobs = LIST_HEAD_INITIALIZER(all_jobs); 40 41 /* Start a job running, if it isn't already. */ 42 struct job * 43 job_run(const char *cmd, struct session *s, int cwd, 44 void (*callbackfn)(struct job *), void (*freefn)(void *), void *data) 45 { 46 struct job *job; 47 struct environ env; 48 pid_t pid; 49 int nullfd, out[2]; 50 51 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0) 52 return (NULL); 53 54 environ_init(&env); 55 environ_copy(&global_environ, &env); 56 if (s != NULL) 57 environ_copy(&s->environ, &env); 58 server_fill_environ(s, &env); 59 60 switch (pid = fork()) { 61 case -1: 62 environ_free(&env); 63 close(out[0]); 64 close(out[1]); 65 return (NULL); 66 case 0: /* child */ 67 clear_signals(1); 68 69 if (cwd != -1 && fchdir(cwd) != 0) 70 chdir("/"); 71 72 environ_push(&env); 73 environ_free(&env); 74 75 if (dup2(out[1], STDIN_FILENO) == -1) 76 fatal("dup2 failed"); 77 if (dup2(out[1], STDOUT_FILENO) == -1) 78 fatal("dup2 failed"); 79 if (out[1] != STDIN_FILENO && out[1] != STDOUT_FILENO) 80 close(out[1]); 81 close(out[0]); 82 83 nullfd = open(_PATH_DEVNULL, O_RDWR, 0); 84 if (nullfd < 0) 85 fatal("open failed"); 86 if (dup2(nullfd, STDERR_FILENO) == -1) 87 fatal("dup2 failed"); 88 if (nullfd != STDERR_FILENO) 89 close(nullfd); 90 91 closefrom(STDERR_FILENO + 1); 92 93 execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL); 94 fatal("execl failed"); 95 } 96 97 /* parent */ 98 environ_free(&env); 99 close(out[1]); 100 101 job = xmalloc(sizeof *job); 102 job->state = JOB_RUNNING; 103 104 job->cmd = xstrdup(cmd); 105 job->pid = pid; 106 job->status = 0; 107 108 LIST_INSERT_HEAD(&all_jobs, job, lentry); 109 110 job->callbackfn = callbackfn; 111 job->freefn = freefn; 112 job->data = data; 113 114 job->fd = out[0]; 115 setblocking(job->fd, 0); 116 117 job->event = bufferevent_new(job->fd, NULL, job_write_callback, 118 job_callback, job); 119 bufferevent_enable(job->event, EV_READ|EV_WRITE); 120 121 log_debug("run job %p: %s, pid %ld", job, job->cmd, (long) job->pid); 122 return (job); 123 } 124 125 /* Kill and free an individual job. */ 126 void 127 job_free(struct job *job) 128 { 129 log_debug("free job %p: %s", job, job->cmd); 130 131 LIST_REMOVE(job, lentry); 132 free(job->cmd); 133 134 if (job->freefn != NULL && job->data != NULL) 135 job->freefn(job->data); 136 137 if (job->pid != -1) 138 kill(job->pid, SIGTERM); 139 if (job->event != NULL) 140 bufferevent_free(job->event); 141 if (job->fd != -1) 142 close(job->fd); 143 144 free(job); 145 } 146 147 /* Called when output buffer falls below low watermark (default is 0). */ 148 void 149 job_write_callback(unused struct bufferevent *bufev, void *data) 150 { 151 struct job *job = data; 152 size_t len = EVBUFFER_LENGTH(EVBUFFER_OUTPUT(job->event)); 153 154 log_debug("job write %p: %s, pid %ld, output left %zu", job, job->cmd, 155 (long) job->pid, len); 156 157 if (len == 0) { 158 shutdown(job->fd, SHUT_WR); 159 bufferevent_disable(job->event, EV_WRITE); 160 } 161 } 162 163 /* Job buffer error callback. */ 164 void 165 job_callback(unused struct bufferevent *bufev, unused short events, void *data) 166 { 167 struct job *job = data; 168 169 log_debug("job error %p: %s, pid %ld", job, job->cmd, (long) job->pid); 170 171 if (job->state == JOB_DEAD) { 172 if (job->callbackfn != NULL) 173 job->callbackfn(job); 174 job_free(job); 175 } else { 176 bufferevent_disable(job->event, EV_READ); 177 job->state = JOB_CLOSED; 178 } 179 } 180 181 /* Job died (waitpid() returned its pid). */ 182 void 183 job_died(struct job *job, int status) 184 { 185 log_debug("job died %p: %s, pid %ld", job, job->cmd, (long) job->pid); 186 187 job->status = status; 188 189 if (job->state == JOB_CLOSED) { 190 if (job->callbackfn != NULL) 191 job->callbackfn(job); 192 job_free(job); 193 } else { 194 job->pid = -1; 195 job->state = JOB_DEAD; 196 } 197 } 198