[BACK]Return to job.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/job.c, Revision 1.40

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