job.c - tmux - Rivoreo Source Code Repositories

 /* $OpenBSD$ */

 /*
  * Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

 #include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/wait.h>

 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #include "tmux.h"

 /*
  * Job scheduling. Run queued commands in the background and record their
  * output.
  */

 static void	job_read_callback(struct bufferevent *, void *);
 static void	job_write_callback(struct bufferevent *, void *);
 static void	job_error_callback(struct bufferevent *, short, void *);

 /* A single job. */
 struct job {
 	enum {
 		JOB_RUNNING,
 		JOB_DEAD,
 		JOB_CLOSED
 	} state;

 	int			 flags;

 	char			*cmd;
 	pid_t			 pid;
 	int			 status;

 	int			 fd;
 	struct bufferevent	*event;

 	job_update_cb		 updatecb;
 	job_complete_cb		 completecb;
 	job_free_cb		 freecb;
 	void			*data;

 	LIST_ENTRY(job)		 entry;
 };

 /* All jobs list. */
 static LIST_HEAD(joblist, job) all_jobs = LIST_HEAD_INITIALIZER(all_jobs);

 /* Start a job running. */
 struct job *
 job_run(const char *cmd, int argc, char **argv, struct session *s,
     const char *cwd, job_update_cb updatecb, job_complete_cb completecb,
     job_free_cb freecb, void *data, int flags, int sx, int sy)
 {
 	struct job	 *job;
 	struct environ	 *env;
 	pid_t		  pid;
 	int		  nullfd, out[2], master;
 	const char	 *home;
 	sigset_t	  set, oldset;
 	struct winsize	  ws;
 	char		**argvp;

 	/*
 	 * Do not set TERM during .tmux.conf, it is nice to be able to use
 	 * if-shell to decide on default-terminal based on outside TERM.
 	 */
 	env = environ_for_session(s, !cfg_finished);

 	sigfillset(&set);
 	sigprocmask(SIG_BLOCK, &set, &oldset);

 	if (flags & JOB_PTY) {
 		memset(&ws, 0, sizeof ws);
 		ws.ws_col = sx;
 		ws.ws_row = sy;
 		pid = fdforkpty(ptm_fd, &master, NULL, NULL, &ws);
 	} else {
 		if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0)
 			goto fail;
 		pid = fork();
 	}
 	if (cmd == NULL) {
 		cmd_log_argv(argc, argv, "%s:", __func__);
 		log_debug("%s: cwd=%s", __func__, cwd == NULL ? "" : cwd);
 	} else {
 		log_debug("%s: cmd=%s, cwd=%s", __func__, cmd,
 		    cwd == NULL ? "" : cwd);
 	}

 	switch (pid) {
 	case -1:
 		if (~flags & JOB_PTY) {
 			close(out[0]);
 			close(out[1]);
 		}
 		goto fail;
 	case 0:
 		proc_clear_signals(server_proc, 1);
 		sigprocmask(SIG_SETMASK, &oldset, NULL);

 		if ((cwd == NULL || chdir(cwd) != 0) &&
 		    ((home = find_home()) == NULL || chdir(home) != 0) &&
 		    chdir("/") != 0)
 			fatal("chdir failed");

 		environ_push(env);
 		environ_free(env);

 		if (~flags & JOB_PTY) {
 			if (dup2(out[1], STDIN_FILENO) == -1)
 				fatal("dup2 failed");
 			if (dup2(out[1], STDOUT_FILENO) == -1)
 				fatal("dup2 failed");
 			if (out[1] != STDIN_FILENO && out[1] != STDOUT_FILENO)
 				close(out[1]);
 			close(out[0]);

 			nullfd = open(_PATH_DEVNULL, O_RDWR, 0);
 			if (nullfd == -1)
 				fatal("open failed");
 			if (dup2(nullfd, STDERR_FILENO) == -1)
 				fatal("dup2 failed");
 			if (nullfd != STDERR_FILENO)
 				close(nullfd);
 		}
 		closefrom(STDERR_FILENO + 1);

 		if (cmd != NULL) {
 			execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
 			fatal("execl failed");
 		} else {
 			argvp = cmd_copy_argv(argc, argv);
 			execvp(argvp[0], argvp);
 			fatal("execvp failed");
 		}
 	}

 	sigprocmask(SIG_SETMASK, &oldset, NULL);
 	environ_free(env);

 	job = xmalloc(sizeof *job);
 	job->state = JOB_RUNNING;
 	job->flags = flags;

 	if (cmd != NULL)
 		job->cmd = xstrdup(cmd);
 	else
 		job->cmd = cmd_stringify_argv(argc, argv);
 	job->pid = pid;
 	job->status = 0;

 	LIST_INSERT_HEAD(&all_jobs, job, entry);

 	job->updatecb = updatecb;
 	job->completecb = completecb;
 	job->freecb = freecb;
 	job->data = data;

 	if (~flags & JOB_PTY) {
 		close(out[1]);
 		job->fd = out[0];
 	} else
 		job->fd = master;
 	setblocking(job->fd, 0);

 	job->event = bufferevent_new(job->fd, job_read_callback,
 	    job_write_callback, job_error_callback, job);
 	if (job->event == NULL)
 		fatalx("out of memory");
 	bufferevent_enable(job->event, EV_READ|EV_WRITE);

 	log_debug("run job %p: %s, pid %ld", job, job->cmd, (long) job->pid);
 	return (job);

 fail:
 	sigprocmask(SIG_SETMASK, &oldset, NULL);
 	environ_free(env);
 	return (NULL);
 }

 /* Kill and free an individual job. */
 void
 job_free(struct job *job)
 {
 	log_debug("free job %p: %s", job, job->cmd);

 	LIST_REMOVE(job, entry);
 	free(job->cmd);

 	if (job->freecb != NULL && job->data != NULL)
 		job->freecb(job->data);

 	if (job->pid != -1)
 		kill(job->pid, SIGTERM);
 	if (job->event != NULL)
 		bufferevent_free(job->event);
 	if (job->fd != -1)
 		close(job->fd);

 	free(job);
 }

 /* Resize job. */
 void
 job_resize(struct job *job, u_int sx, u_int sy)
 {
 	struct winsize	 ws;

 	if (job->fd == -1 || (~job->flags & JOB_PTY))
 		return;

 	log_debug("resize job %p: %ux%u", job, sx, sy);

 	memset(&ws, 0, sizeof ws);
 	ws.ws_col = sx;
 	ws.ws_row = sy;
 	if (ioctl(job->fd, TIOCSWINSZ, &ws) == -1)
 		fatal("ioctl failed");
 }

 /* Job buffer read callback. */
 static void
 job_read_callback(__unused struct bufferevent *bufev, void *data)
 {
 	struct job	*job = data;

 	if (job->updatecb != NULL)
 		job->updatecb(job);
 }

 /*
  * Job buffer write callback. Fired when the buffer falls below watermark
  * (default is empty). If all the data has been written, disable the write
  * event.
  */
 static void
 job_write_callback(__unused struct bufferevent *bufev, void *data)
 {
 	struct job	*job = data;
 	size_t		 len = EVBUFFER_LENGTH(EVBUFFER_OUTPUT(job->event));

 	log_debug("job write %p: %s, pid %ld, output left %zu", job, job->cmd,
 	    (long) job->pid, len);

 	if (len == 0 && (~job->flags & JOB_KEEPWRITE)) {
 		shutdown(job->fd, SHUT_WR);
 		bufferevent_disable(job->event, EV_WRITE);
 	}
 }

 /* Job buffer error callback. */
 static void
 job_error_callback(__unused struct bufferevent *bufev, __unused short events,
     void *data)
 {
 	struct job	*job = data;

 	log_debug("job error %p: %s, pid %ld", job, job->cmd, (long) job->pid);

 	if (job->state == JOB_DEAD) {
 		if (job->completecb != NULL)
 			job->completecb(job);
 		job_free(job);
 	} else {
 		bufferevent_disable(job->event, EV_READ);
 		job->state = JOB_CLOSED;
 	}
 }

 /* Job died (waitpid() returned its pid). */
 void
 job_check_died(pid_t pid, int status)
 {
 	struct job	*job;

 	LIST_FOREACH(job, &all_jobs, entry) {
 		if (pid == job->pid)
 			break;
 	}
 	if (job == NULL)
 		return;
 	if (WIFSTOPPED(status)) {
 		if (WSTOPSIG(status) == SIGTTIN || WSTOPSIG(status) == SIGTTOU)
 			return;
 		killpg(job->pid, SIGCONT);
 		return;
 	}
 	log_debug("job died %p: %s, pid %ld", job, job->cmd, (long) job->pid);

 	job->status = status;

 	if (job->state == JOB_CLOSED) {
 		if (job->completecb != NULL)
 			job->completecb(job);
 		job_free(job);
 	} else {
 		job->pid = -1;
 		job->state = JOB_DEAD;
 	}
 }

 /* Get job status. */
 int
 job_get_status(struct job *job)
 {
 	return (job->status);
 }

 /* Get job data. */
 void *
 job_get_data(struct job *job)
 {
 	return (job->data);
 }

 /* Get job event. */
 struct bufferevent *
 job_get_event(struct job *job)
 {
 	return (job->event);
 }

 /* Kill all jobs. */
 void
 job_kill_all(void)
 {
 	struct job	*job;

 	LIST_FOREACH(job, &all_jobs, entry) {
 		if (job->pid != -1)
 			kill(job->pid, SIGTERM);
 	}
 }

 /* Are any jobs still running? */
 int
 job_still_running(void)
 {
 	struct job	*job;

 	LIST_FOREACH(job, &all_jobs, entry) {
 		if ((~job->flags & JOB_NOWAIT) && job->state == JOB_RUNNING)
 			return (1);
 	}
 	return (0);
 }

 /* Print job summary. */
 void
 job_print_summary(struct cmdq_item *item, int blank)
 {
 	struct job	*job;
 	u_int		 n = 0;

 	LIST_FOREACH(job, &all_jobs, entry) {
 		if (blank) {
 			cmdq_print(item, "%s", "");
 			blank = 0;
 		}
 		cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
 		    n, job->cmd, job->fd, (long)job->pid, job->status);
 		n++;
 	}
 }
	/* $OpenBSD$ */

	/*
	* Copyright (c) 2009 Nicholas Marriott <nicholas.marriott@gmail.com>
	*
	* Permission to use, copy, modify, and distribute this software for any
	* purpose with or without fee is hereby granted, provided that the above
	* copyright notice and this permission notice appear in all copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
	* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
	* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	*/

	#include <sys/types.h>
	#include <sys/ioctl.h>
	#include <sys/socket.h>
	#include <sys/wait.h>

	#include <fcntl.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#include "tmux.h"

	/*
	* Job scheduling. Run queued commands in the background and record their
	* output.
	*/

	static void job_read_callback(struct bufferevent , void );
	static void job_write_callback(struct bufferevent , void );
	static void job_error_callback(struct bufferevent , short, void );

	/* A single job. */
	struct job {
	enum {
	JOB_RUNNING,
	JOB_DEAD,
	JOB_CLOSED
	} state;

	int flags;

	char *cmd;
	pid_t pid;
	int status;

	int fd;
	struct bufferevent *event;

	job_update_cb updatecb;
	job_complete_cb completecb;
	job_free_cb freecb;
	void *data;

	LIST_ENTRY(job) entry;
	};

	/* All jobs list. */
	static LIST_HEAD(joblist, job) all_jobs = LIST_HEAD_INITIALIZER(all_jobs);

	/* Start a job running. */
	struct job *
	job_run(const char cmd, int argc, char argv, struct session s,
	const char *cwd, job_update_cb updatecb, job_complete_cb completecb,
	job_free_cb freecb, void *data, int flags, int sx, int sy)
	{
	struct job *job;
	struct environ *env;
	pid_t pid;
	int nullfd, out[2], master;
	const char *home;
	sigset_t set, oldset;
	struct winsize ws;
	char **argvp;

	/*
	* Do not set TERM during .tmux.conf, it is nice to be able to use
	* if-shell to decide on default-terminal based on outside TERM.
	*/
	env = environ_for_session(s, !cfg_finished);

	sigfillset(&set);
	sigprocmask(SIG_BLOCK, &set, &oldset);

	if (flags & JOB_PTY) {
	memset(&ws, 0, sizeof ws);
	ws.ws_col = sx;
	ws.ws_row = sy;
	pid = fdforkpty(ptm_fd, &master, NULL, NULL, &ws);
	} else {
	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, out) != 0)
	goto fail;
	pid = fork();
	}
	if (cmd == NULL) {
	cmd_log_argv(argc, argv, "%s:", __func__);
	log_debug("%s: cwd=%s", __func__, cwd == NULL ? "" : cwd);
	} else {
	log_debug("%s: cmd=%s, cwd=%s", __func__, cmd,
	cwd == NULL ? "" : cwd);
	}

	switch (pid) {
	case -1:
	if (~flags & JOB_PTY) {
	close(out[0]);
	close(out[1]);
	}
	goto fail;
	case 0:
	proc_clear_signals(server_proc, 1);
	sigprocmask(SIG_SETMASK, &oldset, NULL);

	if ((cwd == NULL \|\| chdir(cwd) != 0) &&
	((home = find_home()) == NULL \|\| chdir(home) != 0) &&
	chdir("/") != 0)
	fatal("chdir failed");

	environ_push(env);
	environ_free(env);

	if (~flags & JOB_PTY) {
	if (dup2(out[1], STDIN_FILENO) == -1)
	fatal("dup2 failed");
	if (dup2(out[1], STDOUT_FILENO) == -1)
	fatal("dup2 failed");
	if (out[1] != STDIN_FILENO && out[1] != STDOUT_FILENO)
	close(out[1]);
	close(out[0]);

	nullfd = open(_PATH_DEVNULL, O_RDWR, 0);
	if (nullfd == -1)
	fatal("open failed");
	if (dup2(nullfd, STDERR_FILENO) == -1)
	fatal("dup2 failed");
	if (nullfd != STDERR_FILENO)
	close(nullfd);
	}
	closefrom(STDERR_FILENO + 1);

	if (cmd != NULL) {
	execl(_PATH_BSHELL, "sh", "-c", cmd, (char *) NULL);
	fatal("execl failed");
	} else {
	argvp = cmd_copy_argv(argc, argv);
	execvp(argvp[0], argvp);
	fatal("execvp failed");
	}
	}

	sigprocmask(SIG_SETMASK, &oldset, NULL);
	environ_free(env);

	job = xmalloc(sizeof *job);
	job->state = JOB_RUNNING;
	job->flags = flags;

	if (cmd != NULL)
	job->cmd = xstrdup(cmd);
	else
	job->cmd = cmd_stringify_argv(argc, argv);
	job->pid = pid;
	job->status = 0;

	LIST_INSERT_HEAD(&all_jobs, job, entry);

	job->updatecb = updatecb;
	job->completecb = completecb;
	job->freecb = freecb;
	job->data = data;

	if (~flags & JOB_PTY) {
	close(out[1]);
	job->fd = out[0];
	} else
	job->fd = master;
	setblocking(job->fd, 0);

	job->event = bufferevent_new(job->fd, job_read_callback,
	job_write_callback, job_error_callback, job);
	if (job->event == NULL)
	fatalx("out of memory");
	bufferevent_enable(job->event, EV_READ\|EV_WRITE);

	log_debug("run job %p: %s, pid %ld", job, job->cmd, (long) job->pid);
	return (job);

	fail:
	sigprocmask(SIG_SETMASK, &oldset, NULL);
	environ_free(env);
	return (NULL);
	}

	/* Kill and free an individual job. */
	void
	job_free(struct job *job)
	{
	log_debug("free job %p: %s", job, job->cmd);

	LIST_REMOVE(job, entry);
	free(job->cmd);

	if (job->freecb != NULL && job->data != NULL)
	job->freecb(job->data);

	if (job->pid != -1)
	kill(job->pid, SIGTERM);
	if (job->event != NULL)
	bufferevent_free(job->event);
	if (job->fd != -1)
	close(job->fd);

	free(job);
	}

	/* Resize job. */
	void
	job_resize(struct job *job, u_int sx, u_int sy)
	{
	struct winsize ws;

	if (job->fd == -1 \|\| (~job->flags & JOB_PTY))
	return;

	log_debug("resize job %p: %ux%u", job, sx, sy);

	memset(&ws, 0, sizeof ws);
	ws.ws_col = sx;
	ws.ws_row = sy;
	if (ioctl(job->fd, TIOCSWINSZ, &ws) == -1)
	fatal("ioctl failed");
	}

	/* Job buffer read callback. */
	static void
	job_read_callback(__unused struct bufferevent bufev, void data)
	{
	struct job *job = data;

	if (job->updatecb != NULL)
	job->updatecb(job);
	}

	/*
	* Job buffer write callback. Fired when the buffer falls below watermark
	* (default is empty). If all the data has been written, disable the write
	* event.
	*/
	static void
	job_write_callback(__unused struct bufferevent bufev, void data)
	{
	struct job *job = data;
	size_t len = EVBUFFER_LENGTH(EVBUFFER_OUTPUT(job->event));

	log_debug("job write %p: %s, pid %ld, output left %zu", job, job->cmd,
	(long) job->pid, len);

	if (len == 0 && (~job->flags & JOB_KEEPWRITE)) {
	shutdown(job->fd, SHUT_WR);
	bufferevent_disable(job->event, EV_WRITE);
	}
	}

	/* Job buffer error callback. */
	static void
	job_error_callback(__unused struct bufferevent *bufev, __unused short events,
	void *data)
	{
	struct job *job = data;

	log_debug("job error %p: %s, pid %ld", job, job->cmd, (long) job->pid);

	if (job->state == JOB_DEAD) {
	if (job->completecb != NULL)
	job->completecb(job);
	job_free(job);
	} else {
	bufferevent_disable(job->event, EV_READ);
	job->state = JOB_CLOSED;
	}
	}

	/* Job died (waitpid() returned its pid). */
	void
	job_check_died(pid_t pid, int status)
	{
	struct job *job;

	LIST_FOREACH(job, &all_jobs, entry) {
	if (pid == job->pid)
	break;
	}
	if (job == NULL)
	return;
	if (WIFSTOPPED(status)) {
	if (WSTOPSIG(status) == SIGTTIN \|\| WSTOPSIG(status) == SIGTTOU)
	return;
	killpg(job->pid, SIGCONT);
	return;
	}
	log_debug("job died %p: %s, pid %ld", job, job->cmd, (long) job->pid);

	job->status = status;

	if (job->state == JOB_CLOSED) {
	if (job->completecb != NULL)
	job->completecb(job);
	job_free(job);
	} else {
	job->pid = -1;
	job->state = JOB_DEAD;
	}
	}

	/* Get job status. */
	int
	job_get_status(struct job *job)
	{
	return (job->status);
	}

	/* Get job data. */
	void *
	job_get_data(struct job *job)
	{
	return (job->data);
	}

	/* Get job event. */
	struct bufferevent *
	job_get_event(struct job *job)
	{
	return (job->event);
	}

	/* Kill all jobs. */
	void
	job_kill_all(void)
	{
	struct job *job;

	LIST_FOREACH(job, &all_jobs, entry) {
	if (job->pid != -1)
	kill(job->pid, SIGTERM);
	}
	}

	/* Are any jobs still running? */
	int
	job_still_running(void)
	{
	struct job *job;

	LIST_FOREACH(job, &all_jobs, entry) {
	if ((~job->flags & JOB_NOWAIT) && job->state == JOB_RUNNING)
	return (1);
	}
	return (0);
	}

	/* Print job summary. */
	void
	job_print_summary(struct cmdq_item *item, int blank)
	{
	struct job *job;
	u_int n = 0;

	LIST_FOREACH(job, &all_jobs, entry) {
	if (blank) {
	cmdq_print(item, "%s", "");
	blank = 0;
	}
	cmdq_print(item, "Job %u: %s [fd=%d, pid=%ld, status=%d]",
	n, job->cmd, job->fd, (long)job->pid, job->status);
	n++;
	}
	}