client.c - tmux - Rivoreo Source Code Repositories

 /* $OpenBSD$ */

 /*
  * Copyright (c) 2007 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/socket.h>
 #include <sys/uio.h>
 #include <sys/un.h>
 #include <sys/wait.h>

 #include <errno.h>
 #include <event.h>
 #include <fcntl.h>
 #include <imsg.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #include "tmux.h"

 static struct tmuxproc	*client_proc;
 static struct tmuxpeer	*client_peer;
 static uint64_t		 client_flags;
 static int		 client_suspended;
 static enum {
 	CLIENT_EXIT_NONE,
 	CLIENT_EXIT_DETACHED,
 	CLIENT_EXIT_DETACHED_HUP,
 	CLIENT_EXIT_LOST_TTY,
 	CLIENT_EXIT_TERMINATED,
 	CLIENT_EXIT_LOST_SERVER,
 	CLIENT_EXIT_EXITED,
 	CLIENT_EXIT_SERVER_EXITED,
 	CLIENT_EXIT_MESSAGE_PROVIDED
 } client_exitreason = CLIENT_EXIT_NONE;
 static int		 client_exitflag;
 static int		 client_exitval;
 static enum msgtype	 client_exittype;
 static const char	*client_exitsession;
 static char		*client_exitmessage;
 static const char	*client_execshell;
 static const char	*client_execcmd;
 static int		 client_attached;
 static struct client_files client_files = RB_INITIALIZER(&client_files);

 static __dead void	 client_exec(const char *,const char *);
 static int		 client_get_lock(char *);
 static int		 client_connect(struct event_base *, const char *,
 			     uint64_t);
 static void		 client_send_identify(const char *, const char *, int);
 static void		 client_signal(int);
 static void		 client_dispatch(struct imsg *, void *);
 static void		 client_dispatch_attached(struct imsg *);
 static void		 client_dispatch_wait(struct imsg *);
 static const char	*client_exit_message(void);

 /*
  * Get server create lock. If already held then server start is happening in
  * another client, so block until the lock is released and return -2 to
  * retry. Return -1 on failure to continue and start the server anyway.
  */
 static int
 client_get_lock(char *lockfile)
 {
 	int lockfd;

 	log_debug("lock file is %s", lockfile);

 	if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1) {
 		log_debug("open failed: %s", strerror(errno));
 		return (-1);
 	}

 	if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {
 		log_debug("flock failed: %s", strerror(errno));
 		if (errno != EAGAIN)
 			return (lockfd);
 		while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)
 			/* nothing */;
 		close(lockfd);
 		return (-2);
 	}
 	log_debug("flock succeeded");

 	return (lockfd);
 }

 /* Connect client to server. */
 static int
 client_connect(struct event_base *base, const char *path, uint64_t flags)
 {
 	struct sockaddr_un	sa;
 	size_t			size;
 	int			fd, lockfd = -1, locked = 0;
 	char		       *lockfile = NULL;

 	memset(&sa, 0, sizeof sa);
 	sa.sun_family = AF_UNIX;
 	size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
 	if (size >= sizeof sa.sun_path) {
 		errno = ENAMETOOLONG;
 		return (-1);
 	}
 	log_debug("socket is %s", path);

 retry:
 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 		return (-1);

 	log_debug("trying connect");
 	if (connect(fd, (struct sockaddr *)&sa, sizeof sa) == -1) {
 		log_debug("connect failed: %s", strerror(errno));
 		if (errno != ECONNREFUSED && errno != ENOENT)
 			goto failed;
 		if (flags & CLIENT_NOSTARTSERVER)
 			goto failed;
 		if (~flags & CLIENT_STARTSERVER)
 			goto failed;
 		close(fd);

 		if (!locked) {
 			xasprintf(&lockfile, "%s.lock", path);
 			if ((lockfd = client_get_lock(lockfile)) < 0) {
 				log_debug("didn't get lock (%d)", lockfd);

 				free(lockfile);
 				lockfile = NULL;

 				if (lockfd == -2)
 					goto retry;
 			}
 			log_debug("got lock (%d)", lockfd);

 			/*
 			 * Always retry at least once, even if we got the lock,
 			 * because another client could have taken the lock,
 			 * started the server and released the lock between our
 			 * connect() and flock().
 			 */
 			locked = 1;
 			goto retry;
 		}

 		if (lockfd >= 0 && unlink(path) != 0 && errno != ENOENT) {
 			free(lockfile);
 			close(lockfd);
 			return (-1);
 		}
 		fd = server_start(client_proc, flags, base, lockfd, lockfile);
 	}

 	if (locked && lockfd >= 0) {
 		free(lockfile);
 		close(lockfd);
 	}
 	setblocking(fd, 0);
 	return (fd);

 failed:
 	if (locked) {
 		free(lockfile);
 		close(lockfd);
 	}
 	close(fd);
 	return (-1);
 }

 /* Get exit string from reason number. */
 const char *
 client_exit_message(void)
 {
 	static char msg[256];

 	switch (client_exitreason) {
 	case CLIENT_EXIT_NONE:
 		break;
 	case CLIENT_EXIT_DETACHED:
 		if (client_exitsession != NULL) {
 			xsnprintf(msg, sizeof msg, "detached "
 			    "(from session %s)", client_exitsession);
 			return (msg);
 		}
 		return ("detached");
 	case CLIENT_EXIT_DETACHED_HUP:
 		if (client_exitsession != NULL) {
 			xsnprintf(msg, sizeof msg, "detached and SIGHUP "
 			    "(from session %s)", client_exitsession);
 			return (msg);
 		}
 		return ("detached and SIGHUP");
 	case CLIENT_EXIT_LOST_TTY:
 		return ("lost tty");
 	case CLIENT_EXIT_TERMINATED:
 		return ("terminated");
 	case CLIENT_EXIT_LOST_SERVER:
 		return ("server exited unexpectedly");
 	case CLIENT_EXIT_EXITED:
 		return ("exited");
 	case CLIENT_EXIT_SERVER_EXITED:
 		return ("server exited");
 	case CLIENT_EXIT_MESSAGE_PROVIDED:
 		return (client_exitmessage);
 	}
 	return ("unknown reason");
 }

 /* Exit if all streams flushed. */
 static void
 client_exit(void)
 {
 	struct client_file	*cf;
 	size_t			 left;
 	int			 waiting = 0;

 	RB_FOREACH (cf, client_files, &client_files) {
 		if (cf->event == NULL)
 			continue;
 		left = EVBUFFER_LENGTH(cf->event->output);
 		if (left != 0) {
 			waiting++;
 			log_debug("file %u %zu bytes left", cf->stream, left);
 		}
 	}
 	if (waiting == 0)
 		proc_exit(client_proc);
 }

 /* Client main loop. */
 int
 client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
     int feat)
 {
 	struct cmd_parse_result	*pr;
 	struct msg_command	*data;
 	int			 fd, i;
 	const char		*ttynam, *cwd;
 	pid_t			 ppid;
 	enum msgtype		 msg;
 	struct termios		 tio, saved_tio;
 	size_t			 size, linesize = 0;
 	ssize_t			 linelen;
 	char			*line = NULL;

 	/* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
 	signal(SIGCHLD, SIG_IGN);

 	/* Set up the initial command. */
 	if (shell_command != NULL) {
 		msg = MSG_SHELL;
 		flags |= CLIENT_STARTSERVER;
 	} else if (argc == 0) {
 		msg = MSG_COMMAND;
 		flags |= CLIENT_STARTSERVER;
 	} else {
 		msg = MSG_COMMAND;

 		/*
 		 * It sucks parsing the command string twice (in client and
 		 * later in server) but it is necessary to get the start server
 		 * flag.
 		 */
 		pr = cmd_parse_from_arguments(argc, argv, NULL);
 		if (pr->status == CMD_PARSE_SUCCESS) {
 			if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
 				flags |= CLIENT_STARTSERVER;
 			cmd_list_free(pr->cmdlist);
 		} else
 			free(pr->error);
 	}

 	/* Create client process structure (starts logging). */
 	client_proc = proc_start("client");
 	proc_set_signals(client_proc, client_signal);

 	/* Save the flags. */
 	client_flags = flags;
 	log_debug("flags are %#llx", (unsigned long long)client_flags);

 	/* Initialize the client socket and start the server. */
 	fd = client_connect(base, socket_path, client_flags);
 	if (fd == -1) {
 		if (errno == ECONNREFUSED) {
 			fprintf(stderr, "no server running on %s\n",
 			    socket_path);
 		} else {
 			fprintf(stderr, "error connecting to %s (%s)\n",
 			    socket_path, strerror(errno));
 		}
 		return (1);
 	}
 	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);

 	/* Save these before pledge(). */
 	if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
 		cwd = "/";
 	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 		ttynam = "";

 	/*
 	 * Drop privileges for client. "proc exec" is needed for -c and for
 	 * locking (which uses system(3)).
 	 *
 	 * "tty" is needed to restore termios(4) and also for some reason -CC
 	 * does not work properly without it (input is not recognised).
 	 *
 	 * "sendfd" is dropped later in client_dispatch_wait().
 	 */
 	if (pledge(
 	    "stdio rpath wpath cpath unix sendfd proc exec tty",
 	    NULL) != 0)
 		fatal("pledge failed");

 	/* Free stuff that is not used in the client. */
 	if (ptm_fd != -1)
 		close(ptm_fd);
 	options_free(global_options);
 	options_free(global_s_options);
 	options_free(global_w_options);
 	environ_free(global_environ);

 	/* Set up control mode. */
 	if (client_flags & CLIENT_CONTROLCONTROL) {
 		if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
 			fprintf(stderr, "tcgetattr failed: %s\n",
 			    strerror(errno));
 			return (1);
 		}
 		cfmakeraw(&tio);
 		tio.c_iflag = ICRNL|IXANY;
 		tio.c_oflag = OPOST|ONLCR;
 		tio.c_lflag = NOKERNINFO;
 		tio.c_cflag = CREAD|CS8|HUPCL;
 		tio.c_cc[VMIN] = 1;
 		tio.c_cc[VTIME] = 0;
 		cfsetispeed(&tio, cfgetispeed(&saved_tio));
 		cfsetospeed(&tio, cfgetospeed(&saved_tio));
 		tcsetattr(STDIN_FILENO, TCSANOW, &tio);
 	}

 	/* Send identify messages. */
 	client_send_identify(ttynam, cwd, feat);

 	/* Send first command. */
 	if (msg == MSG_COMMAND) {
 		/* How big is the command? */
 		size = 0;
 		for (i = 0; i < argc; i++)
 			size += strlen(argv[i]) + 1;
 		if (size > MAX_IMSGSIZE - (sizeof *data)) {
 			fprintf(stderr, "command too long\n");
 			return (1);
 		}
 		data = xmalloc((sizeof *data) + size);

 		/* Prepare command for server. */
 		data->argc = argc;
 		if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {
 			fprintf(stderr, "command too long\n");
 			free(data);
 			return (1);
 		}
 		size += sizeof *data;

 		/* Send the command. */
 		if (proc_send(client_peer, msg, -1, data, size) != 0) {
 			fprintf(stderr, "failed to send command\n");
 			free(data);
 			return (1);
 		}
 		free(data);
 	} else if (msg == MSG_SHELL)
 		proc_send(client_peer, msg, -1, NULL, 0);

 	/* Start main loop. */
 	proc_loop(client_proc, NULL);

 	/* Run command if user requested exec, instead of exiting. */
 	if (client_exittype == MSG_EXEC) {
 		if (client_flags & CLIENT_CONTROLCONTROL)
 			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 		client_exec(client_execshell, client_execcmd);
 	}

 	/* Restore streams to blocking. */
 	setblocking(STDIN_FILENO, 1);
 	setblocking(STDOUT_FILENO, 1);
 	setblocking(STDERR_FILENO, 1);

 	/* Print the exit message, if any, and exit. */
 	if (client_attached) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
 			printf("[%s]\n", client_exit_message());

 		ppid = getppid();
 		if (client_exittype == MSG_DETACHKILL && ppid > 1)
 			kill(ppid, SIGHUP);
 	} else if (client_flags & CLIENT_CONTROL) {
 		if (client_exitreason != CLIENT_EXIT_NONE)
 			printf("%%exit %s\n", client_exit_message());
 		else
 			printf("%%exit\n");
 		fflush(stdout);
 		if (client_flags & CLIENT_CONTROL_WAITEXIT) {
 			setvbuf(stdin, NULL, _IOLBF, 0);
 			for (;;) {
 				linelen = getline(&line, &linesize, stdin);
 				if (linelen <= 1)
 					break;
 			}
 			free(line);
 		}
 		if (client_flags & CLIENT_CONTROLCONTROL) {
 			printf("\033\\");
 			fflush(stdout);
 			tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 		}
 	} else if (client_exitreason != CLIENT_EXIT_NONE)
 		fprintf(stderr, "%s\n", client_exit_message());
 	return (client_exitval);
 }

 /* Send identify messages to server. */
 static void
 client_send_identify(const char *ttynam, const char *cwd, int feat)
 {
 	const char	 *s;
 	char		**ss;
 	size_t		  sslen;
 	int		  fd, flags = client_flags;
 	pid_t		  pid;

 	proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
 	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
 	    sizeof client_flags);

 	if ((s = getenv("TERM")) == NULL)
 		s = "";
 	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
 	proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);

 	proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
 	    strlen(ttynam) + 1);
 	proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);

 	if ((fd = dup(STDIN_FILENO)) == -1)
 		fatal("dup failed");
 	proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
 	if ((fd = dup(STDOUT_FILENO)) == -1)
 		fatal("dup failed");
 	proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);

 	pid = getpid();
 	proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);

 	for (ss = environ; *ss != NULL; ss++) {
 		sslen = strlen(*ss) + 1;
 		if (sslen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
 			continue;
 		proc_send(client_peer, MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);
 	}

 	proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
 }

 /* Run command in shell; used for -c. */
 static __dead void
 client_exec(const char *shell, const char *shellcmd)
 {
 	const char	*name, *ptr;
 	char		*argv0;

 	log_debug("shell %s, command %s", shell, shellcmd);

 	ptr = strrchr(shell, '/');
 	if (ptr != NULL && *(ptr + 1) != '\0')
 		name = ptr + 1;
 	else
 		name = shell;
 	if (client_flags & CLIENT_LOGIN)
 		xasprintf(&argv0, "-%s", name);
 	else
 		xasprintf(&argv0, "%s", name);
 	setenv("SHELL", shell, 1);

 	proc_clear_signals(client_proc, 1);

 	setblocking(STDIN_FILENO, 1);
 	setblocking(STDOUT_FILENO, 1);
 	setblocking(STDERR_FILENO, 1);
 	closefrom(STDERR_FILENO + 1);

 	execl(shell, argv0, "-c", shellcmd, (char *) NULL);
 	fatal("execl failed");
 }

 /* Callback to handle signals in the client. */
 static void
 client_signal(int sig)
 {
 	struct sigaction sigact;
 	int		 status;

 	log_debug("%s: %s", __func__, strsignal(sig));
 	if (sig == SIGCHLD)
 		waitpid(WAIT_ANY, &status, WNOHANG);
 	else if (!client_attached) {
 		if (sig == SIGTERM)
 			proc_exit(client_proc);
 	} else {
 		switch (sig) {
 		case SIGHUP:
 			client_exitreason = CLIENT_EXIT_LOST_TTY;
 			client_exitval = 1;
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
 		case SIGTERM:
 			if (!client_suspended)
 				client_exitreason = CLIENT_EXIT_TERMINATED;
 			client_exitval = 1;
 			proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 			break;
 		case SIGWINCH:
 			proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
 			break;
 		case SIGCONT:
 			memset(&sigact, 0, sizeof sigact);
 			sigemptyset(&sigact.sa_mask);
 			sigact.sa_flags = SA_RESTART;
 			sigact.sa_handler = SIG_IGN;
 			if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 				fatal("sigaction failed");
 			proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
 			client_suspended = 0;
 			break;
 		}
 	}
 }

 /* Callback for file write error or close. */
 static void
 client_file_check_cb(__unused struct client *c, __unused const char *path,
     __unused int error, __unused int closed, __unused struct evbuffer *buffer,
     __unused void *data)
 {
 	if (client_exitflag)
 		client_exit();
 }

 /* Callback for client read events. */
 static void
 client_dispatch(struct imsg *imsg, __unused void *arg)
 {
 	if (imsg == NULL) {
 		client_exitreason = CLIENT_EXIT_LOST_SERVER;
 		client_exitval = 1;
 		proc_exit(client_proc);
 		return;
 	}

 	if (client_attached)
 		client_dispatch_attached(imsg);
 	else
 		client_dispatch_wait(imsg);
 }

 /* Process an exit message. */
 static void
 client_dispatch_exit_message(char *data, size_t datalen)
 {
 	int	retval;

 	if (datalen < sizeof retval && datalen != 0)
 		fatalx("bad MSG_EXIT size");

 	if (datalen >= sizeof retval) {
 		memcpy(&retval, data, sizeof retval);
 		client_exitval = retval;
 	}

 	if (datalen > sizeof retval) {
 		datalen -= sizeof retval;
 		data += sizeof retval;

 		client_exitmessage = xmalloc(datalen);
 		memcpy(client_exitmessage, data, datalen);
 		client_exitmessage[datalen - 1] = '\0';

 		client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
 	}
 }

 /* Dispatch imsgs when in wait state (before MSG_READY). */
 static void
 client_dispatch_wait(struct imsg *imsg)
 {
 	char		*data;
 	ssize_t		 datalen;
 	static int	 pledge_applied;

 	/*
 	 * "sendfd" is no longer required once all of the identify messages
 	 * have been sent. We know the server won't send us anything until that
 	 * point (because we don't ask it to), so we can drop "sendfd" once we
 	 * get the first message from the server.
 	 */
 	if (!pledge_applied) {
 		if (pledge(
 		    "stdio rpath wpath cpath unix proc exec tty",
 		    NULL) != 0)
 			fatal("pledge failed");
 		pledge_applied = 1;
 	}

 	data = imsg->data;
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

 	switch (imsg->hdr.type) {
 	case MSG_EXIT:
 	case MSG_SHUTDOWN:
 		client_dispatch_exit_message(data, datalen);
 		client_exitflag = 1;
 		client_exit();
 		break;
 	case MSG_READY:
 		if (datalen != 0)
 			fatalx("bad MSG_READY size");

 		client_attached = 1;
 		proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
 		break;
 	case MSG_VERSION:
 		if (datalen != 0)
 			fatalx("bad MSG_VERSION size");

 		fprintf(stderr, "protocol version mismatch "
 		    "(client %d, server %u)\n", PROTOCOL_VERSION,
 		    imsg->hdr.peerid & 0xff);
 		client_exitval = 1;
 		proc_exit(client_proc);
 		break;
 	case MSG_FLAGS:
 		if (datalen != sizeof client_flags)
 			fatalx("bad MSG_FLAGS string");

 		memcpy(&client_flags, data, sizeof client_flags);
 		log_debug("new flags are %#llx",
 		    (unsigned long long)client_flags);
 		break;
 	case MSG_SHELL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_SHELL string");

 		client_exec(data, shell_command);
 		/* NOTREACHED */
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXITED:
 		proc_exit(client_proc);
 		break;
 	case MSG_READ_OPEN:
 		file_read_open(&client_files, client_peer, imsg, 1,
 		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
 		    NULL);
 		break;
 	case MSG_WRITE_OPEN:
 		file_write_open(&client_files, client_peer, imsg, 1,
 		    !(client_flags & CLIENT_CONTROL), client_file_check_cb,
 		    NULL);
 		break;
 	case MSG_WRITE:
 		file_write_data(&client_files, imsg);
 		break;
 	case MSG_WRITE_CLOSE:
 		file_write_close(&client_files, imsg);
 		break;
 	case MSG_OLDSTDERR:
 	case MSG_OLDSTDIN:
 	case MSG_OLDSTDOUT:
 		fprintf(stderr, "server version is too old for client\n");
 		proc_exit(client_proc);
 		break;
 	}
 }

 /* Dispatch imsgs in attached state (after MSG_READY). */
 static void
 client_dispatch_attached(struct imsg *imsg)
 {
 	struct sigaction	 sigact;
 	char			*data;
 	ssize_t			 datalen;

 	data = imsg->data;
 	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

 	switch (imsg->hdr.type) {
 	case MSG_FLAGS:
 		if (datalen != sizeof client_flags)
 			fatalx("bad MSG_FLAGS string");

 		memcpy(&client_flags, data, sizeof client_flags);
 		log_debug("new flags are %#llx",
 		    (unsigned long long)client_flags);
 		break;
 	case MSG_DETACH:
 	case MSG_DETACHKILL:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_DETACH string");

 		client_exitsession = xstrdup(data);
 		client_exittype = imsg->hdr.type;
 		if (imsg->hdr.type == MSG_DETACHKILL)
 			client_exitreason = CLIENT_EXIT_DETACHED_HUP;
 		else
 			client_exitreason = CLIENT_EXIT_DETACHED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXEC:
 		if (datalen == 0 || data[datalen - 1] != '\0' ||
 		    strlen(data) + 1 == (size_t)datalen)
 			fatalx("bad MSG_EXEC string");
 		client_execcmd = xstrdup(data);
 		client_execshell = xstrdup(data + strlen(data) + 1);

 		client_exittype = imsg->hdr.type;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXIT:
 		client_dispatch_exit_message(data, datalen);
 		if (client_exitreason == CLIENT_EXIT_NONE)
 			client_exitreason = CLIENT_EXIT_EXITED;
 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		break;
 	case MSG_EXITED:
 		if (datalen != 0)
 			fatalx("bad MSG_EXITED size");

 		proc_exit(client_proc);
 		break;
 	case MSG_SHUTDOWN:
 		if (datalen != 0)
 			fatalx("bad MSG_SHUTDOWN size");

 		proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 		client_exitreason = CLIENT_EXIT_SERVER_EXITED;
 		client_exitval = 1;
 		break;
 	case MSG_SUSPEND:
 		if (datalen != 0)
 			fatalx("bad MSG_SUSPEND size");

 		memset(&sigact, 0, sizeof sigact);
 		sigemptyset(&sigact.sa_mask);
 		sigact.sa_flags = SA_RESTART;
 		sigact.sa_handler = SIG_DFL;
 		if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 			fatal("sigaction failed");
 		client_suspended = 1;
 		kill(getpid(), SIGTSTP);
 		break;
 	case MSG_LOCK:
 		if (datalen == 0 || data[datalen - 1] != '\0')
 			fatalx("bad MSG_LOCK string");

 		system(data);
 		proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);
 		break;
 	}
 }
	/* $OpenBSD$ */

	/*
	* Copyright (c) 2007 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/socket.h>
	#include <sys/uio.h>
	#include <sys/un.h>
	#include <sys/wait.h>

	#include <errno.h>
	#include <event.h>
	#include <fcntl.h>
	#include <imsg.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#include "tmux.h"

	static struct tmuxproc *client_proc;
	static struct tmuxpeer *client_peer;
	static uint64_t client_flags;
	static int client_suspended;
	static enum {
	CLIENT_EXIT_NONE,
	CLIENT_EXIT_DETACHED,
	CLIENT_EXIT_DETACHED_HUP,
	CLIENT_EXIT_LOST_TTY,
	CLIENT_EXIT_TERMINATED,
	CLIENT_EXIT_LOST_SERVER,
	CLIENT_EXIT_EXITED,
	CLIENT_EXIT_SERVER_EXITED,
	CLIENT_EXIT_MESSAGE_PROVIDED
	} client_exitreason = CLIENT_EXIT_NONE;
	static int client_exitflag;
	static int client_exitval;
	static enum msgtype client_exittype;
	static const char *client_exitsession;
	static char *client_exitmessage;
	static const char *client_execshell;
	static const char *client_execcmd;
	static int client_attached;
	static struct client_files client_files = RB_INITIALIZER(&client_files);

	static __dead void client_exec(const char ,const char );
	static int client_get_lock(char *);
	static int client_connect(struct event_base , const char ,
	uint64_t);
	static void client_send_identify(const char , const char , int);
	static void client_signal(int);
	static void client_dispatch(struct imsg , void );
	static void client_dispatch_attached(struct imsg *);
	static void client_dispatch_wait(struct imsg *);
	static const char *client_exit_message(void);

	/*
	* Get server create lock. If already held then server start is happening in
	* another client, so block until the lock is released and return -2 to
	* retry. Return -1 on failure to continue and start the server anyway.
	*/
	static int
	client_get_lock(char *lockfile)
	{
	int lockfd;

	log_debug("lock file is %s", lockfile);

	if ((lockfd = open(lockfile, O_WRONLY\|O_CREAT, 0600)) == -1) {
	log_debug("open failed: %s", strerror(errno));
	return (-1);
	}

	if (flock(lockfd, LOCK_EX\|LOCK_NB) == -1) {
	log_debug("flock failed: %s", strerror(errno));
	if (errno != EAGAIN)
	return (lockfd);
	while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)
	/* nothing */;
	close(lockfd);
	return (-2);
	}
	log_debug("flock succeeded");

	return (lockfd);
	}

	/* Connect client to server. */
	static int
	client_connect(struct event_base base, const char path, uint64_t flags)
	{
	struct sockaddr_un sa;
	size_t size;
	int fd, lockfd = -1, locked = 0;
	char *lockfile = NULL;

	memset(&sa, 0, sizeof sa);
	sa.sun_family = AF_UNIX;
	size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
	if (size >= sizeof sa.sun_path) {
	errno = ENAMETOOLONG;
	return (-1);
	}
	log_debug("socket is %s", path);

	retry:
	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
	return (-1);

	log_debug("trying connect");
	if (connect(fd, (struct sockaddr *)&sa, sizeof sa) == -1) {
	log_debug("connect failed: %s", strerror(errno));
	if (errno != ECONNREFUSED && errno != ENOENT)
	goto failed;
	if (flags & CLIENT_NOSTARTSERVER)
	goto failed;
	if (~flags & CLIENT_STARTSERVER)
	goto failed;
	close(fd);

	if (!locked) {
	xasprintf(&lockfile, "%s.lock", path);
	if ((lockfd = client_get_lock(lockfile)) < 0) {
	log_debug("didn't get lock (%d)", lockfd);

	free(lockfile);
	lockfile = NULL;

	if (lockfd == -2)
	goto retry;
	}
	log_debug("got lock (%d)", lockfd);

	/*
	* Always retry at least once, even if we got the lock,
	* because another client could have taken the lock,
	* started the server and released the lock between our
	* connect() and flock().
	*/
	locked = 1;
	goto retry;
	}

	if (lockfd >= 0 && unlink(path) != 0 && errno != ENOENT) {
	free(lockfile);
	close(lockfd);
	return (-1);
	}
	fd = server_start(client_proc, flags, base, lockfd, lockfile);
	}

	if (locked && lockfd >= 0) {
	free(lockfile);
	close(lockfd);
	}
	setblocking(fd, 0);
	return (fd);

	failed:
	if (locked) {
	free(lockfile);
	close(lockfd);
	}
	close(fd);
	return (-1);
	}

	/* Get exit string from reason number. */
	const char *
	client_exit_message(void)
	{
	static char msg[256];

	switch (client_exitreason) {
	case CLIENT_EXIT_NONE:
	break;
	case CLIENT_EXIT_DETACHED:
	if (client_exitsession != NULL) {
	xsnprintf(msg, sizeof msg, "detached "
	"(from session %s)", client_exitsession);
	return (msg);
	}
	return ("detached");
	case CLIENT_EXIT_DETACHED_HUP:
	if (client_exitsession != NULL) {
	xsnprintf(msg, sizeof msg, "detached and SIGHUP "
	"(from session %s)", client_exitsession);
	return (msg);
	}
	return ("detached and SIGHUP");
	case CLIENT_EXIT_LOST_TTY:
	return ("lost tty");
	case CLIENT_EXIT_TERMINATED:
	return ("terminated");
	case CLIENT_EXIT_LOST_SERVER:
	return ("server exited unexpectedly");
	case CLIENT_EXIT_EXITED:
	return ("exited");
	case CLIENT_EXIT_SERVER_EXITED:
	return ("server exited");
	case CLIENT_EXIT_MESSAGE_PROVIDED:
	return (client_exitmessage);
	}
	return ("unknown reason");
	}

	/* Exit if all streams flushed. */
	static void
	client_exit(void)
	{
	struct client_file *cf;
	size_t left;
	int waiting = 0;

	RB_FOREACH (cf, client_files, &client_files) {
	if (cf->event == NULL)
	continue;
	left = EVBUFFER_LENGTH(cf->event->output);
	if (left != 0) {
	waiting++;
	log_debug("file %u %zu bytes left", cf->stream, left);
	}
	}
	if (waiting == 0)
	proc_exit(client_proc);
	}

	/* Client main loop. */
	int
	client_main(struct event_base base, int argc, char *argv, uint64_t flags,
	int feat)
	{
	struct cmd_parse_result *pr;
	struct msg_command *data;
	int fd, i;
	const char ttynam, cwd;
	pid_t ppid;
	enum msgtype msg;
	struct termios tio, saved_tio;
	size_t size, linesize = 0;
	ssize_t linelen;
	char *line = NULL;

	/* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
	signal(SIGCHLD, SIG_IGN);

	/* Set up the initial command. */
	if (shell_command != NULL) {
	msg = MSG_SHELL;
	flags \|= CLIENT_STARTSERVER;
	} else if (argc == 0) {
	msg = MSG_COMMAND;
	flags \|= CLIENT_STARTSERVER;
	} else {
	msg = MSG_COMMAND;

	/*
	* It sucks parsing the command string twice (in client and
	* later in server) but it is necessary to get the start server
	* flag.
	*/
	pr = cmd_parse_from_arguments(argc, argv, NULL);
	if (pr->status == CMD_PARSE_SUCCESS) {
	if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
	flags \|= CLIENT_STARTSERVER;
	cmd_list_free(pr->cmdlist);
	} else
	free(pr->error);
	}

	/* Create client process structure (starts logging). */
	client_proc = proc_start("client");
	proc_set_signals(client_proc, client_signal);

	/* Save the flags. */
	client_flags = flags;
	log_debug("flags are %#llx", (unsigned long long)client_flags);

	/* Initialize the client socket and start the server. */
	fd = client_connect(base, socket_path, client_flags);
	if (fd == -1) {
	if (errno == ECONNREFUSED) {
	fprintf(stderr, "no server running on %s\n",
	socket_path);
	} else {
	fprintf(stderr, "error connecting to %s (%s)\n",
	socket_path, strerror(errno));
	}
	return (1);
	}
	client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);

	/* Save these before pledge(). */
	if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
	cwd = "/";
	if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
	ttynam = "";

	/*
	* Drop privileges for client. "proc exec" is needed for -c and for
	* locking (which uses system(3)).
	*
	* "tty" is needed to restore termios(4) and also for some reason -CC
	* does not work properly without it (input is not recognised).
	*
	* "sendfd" is dropped later in client_dispatch_wait().
	*/
	if (pledge(
	"stdio rpath wpath cpath unix sendfd proc exec tty",
	NULL) != 0)
	fatal("pledge failed");

	/* Free stuff that is not used in the client. */
	if (ptm_fd != -1)
	close(ptm_fd);
	options_free(global_options);
	options_free(global_s_options);
	options_free(global_w_options);
	environ_free(global_environ);

	/* Set up control mode. */
	if (client_flags & CLIENT_CONTROLCONTROL) {
	if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
	fprintf(stderr, "tcgetattr failed: %s\n",
	strerror(errno));
	return (1);
	}
	cfmakeraw(&tio);
	tio.c_iflag = ICRNL\|IXANY;
	tio.c_oflag = OPOST\|ONLCR;
	tio.c_lflag = NOKERNINFO;
	tio.c_cflag = CREAD\|CS8\|HUPCL;
	tio.c_cc[VMIN] = 1;
	tio.c_cc[VTIME] = 0;
	cfsetispeed(&tio, cfgetispeed(&saved_tio));
	cfsetospeed(&tio, cfgetospeed(&saved_tio));
	tcsetattr(STDIN_FILENO, TCSANOW, &tio);
	}

	/* Send identify messages. */
	client_send_identify(ttynam, cwd, feat);

	/* Send first command. */
	if (msg == MSG_COMMAND) {
	/* How big is the command? */
	size = 0;
	for (i = 0; i < argc; i++)
	size += strlen(argv[i]) + 1;
	if (size > MAX_IMSGSIZE - (sizeof *data)) {
	fprintf(stderr, "command too long\n");
	return (1);
	}
	data = xmalloc((sizeof *data) + size);

	/* Prepare command for server. */
	data->argc = argc;
	if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {
	fprintf(stderr, "command too long\n");
	free(data);
	return (1);
	}
	size += sizeof *data;

	/* Send the command. */
	if (proc_send(client_peer, msg, -1, data, size) != 0) {
	fprintf(stderr, "failed to send command\n");
	free(data);
	return (1);
	}
	free(data);
	} else if (msg == MSG_SHELL)
	proc_send(client_peer, msg, -1, NULL, 0);

	/* Start main loop. */
	proc_loop(client_proc, NULL);

	/* Run command if user requested exec, instead of exiting. */
	if (client_exittype == MSG_EXEC) {
	if (client_flags & CLIENT_CONTROLCONTROL)
	tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
	client_exec(client_execshell, client_execcmd);
	}

	/* Restore streams to blocking. */
	setblocking(STDIN_FILENO, 1);
	setblocking(STDOUT_FILENO, 1);
	setblocking(STDERR_FILENO, 1);

	/* Print the exit message, if any, and exit. */
	if (client_attached) {
	if (client_exitreason != CLIENT_EXIT_NONE)
	printf("[%s]\n", client_exit_message());

	ppid = getppid();
	if (client_exittype == MSG_DETACHKILL && ppid > 1)
	kill(ppid, SIGHUP);
	} else if (client_flags & CLIENT_CONTROL) {
	if (client_exitreason != CLIENT_EXIT_NONE)
	printf("%%exit %s\n", client_exit_message());
	else
	printf("%%exit\n");
	fflush(stdout);
	if (client_flags & CLIENT_CONTROL_WAITEXIT) {
	setvbuf(stdin, NULL, _IOLBF, 0);
	for (;;) {
	linelen = getline(&line, &linesize, stdin);
	if (linelen <= 1)
	break;
	}
	free(line);
	}
	if (client_flags & CLIENT_CONTROLCONTROL) {
	printf("\033\\");
	fflush(stdout);
	tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
	}
	} else if (client_exitreason != CLIENT_EXIT_NONE)
	fprintf(stderr, "%s\n", client_exit_message());
	return (client_exitval);
	}

	/* Send identify messages to server. */
	static void
	client_send_identify(const char ttynam, const char cwd, int feat)
	{
	const char *s;
	char **ss;
	size_t sslen;
	int fd, flags = client_flags;
	pid_t pid;

	proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
	proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
	sizeof client_flags);

	if ((s = getenv("TERM")) == NULL)
	s = "";
	proc_send(client_peer, MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
	proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);

	proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
	strlen(ttynam) + 1);
	proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);

	if ((fd = dup(STDIN_FILENO)) == -1)
	fatal("dup failed");
	proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
	if ((fd = dup(STDOUT_FILENO)) == -1)
	fatal("dup failed");
	proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);

	pid = getpid();
	proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);

	for (ss = environ; *ss != NULL; ss++) {
	sslen = strlen(*ss) + 1;
	if (sslen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
	continue;
	proc_send(client_peer, MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);
	}

	proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
	}

	/* Run command in shell; used for -c. */
	static __dead void
	client_exec(const char shell, const char shellcmd)
	{
	const char name, ptr;
	char *argv0;

	log_debug("shell %s, command %s", shell, shellcmd);

	ptr = strrchr(shell, '/');
	if (ptr != NULL && *(ptr + 1) != '\0')
	name = ptr + 1;
	else
	name = shell;
	if (client_flags & CLIENT_LOGIN)
	xasprintf(&argv0, "-%s", name);
	else
	xasprintf(&argv0, "%s", name);
	setenv("SHELL", shell, 1);

	proc_clear_signals(client_proc, 1);

	setblocking(STDIN_FILENO, 1);
	setblocking(STDOUT_FILENO, 1);
	setblocking(STDERR_FILENO, 1);
	closefrom(STDERR_FILENO + 1);

	execl(shell, argv0, "-c", shellcmd, (char *) NULL);
	fatal("execl failed");
	}

	/* Callback to handle signals in the client. */
	static void
	client_signal(int sig)
	{
	struct sigaction sigact;
	int status;

	log_debug("%s: %s", __func__, strsignal(sig));
	if (sig == SIGCHLD)
	waitpid(WAIT_ANY, &status, WNOHANG);
	else if (!client_attached) {
	if (sig == SIGTERM)
	proc_exit(client_proc);
	} else {
	switch (sig) {
	case SIGHUP:
	client_exitreason = CLIENT_EXIT_LOST_TTY;
	client_exitval = 1;
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case SIGTERM:
	if (!client_suspended)
	client_exitreason = CLIENT_EXIT_TERMINATED;
	client_exitval = 1;
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case SIGWINCH:
	proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
	break;
	case SIGCONT:
	memset(&sigact, 0, sizeof sigact);
	sigemptyset(&sigact.sa_mask);
	sigact.sa_flags = SA_RESTART;
	sigact.sa_handler = SIG_IGN;
	if (sigaction(SIGTSTP, &sigact, NULL) != 0)
	fatal("sigaction failed");
	proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
	client_suspended = 0;
	break;
	}
	}
	}

	/* Callback for file write error or close. */
	static void
	client_file_check_cb(__unused struct client c, __unused const char path,
	__unused int error, __unused int closed, __unused struct evbuffer *buffer,
	__unused void *data)
	{
	if (client_exitflag)
	client_exit();
	}

	/* Callback for client read events. */
	static void
	client_dispatch(struct imsg imsg, __unused void arg)
	{
	if (imsg == NULL) {
	client_exitreason = CLIENT_EXIT_LOST_SERVER;
	client_exitval = 1;
	proc_exit(client_proc);
	return;
	}

	if (client_attached)
	client_dispatch_attached(imsg);
	else
	client_dispatch_wait(imsg);
	}

	/* Process an exit message. */
	static void
	client_dispatch_exit_message(char *data, size_t datalen)
	{
	int retval;

	if (datalen < sizeof retval && datalen != 0)
	fatalx("bad MSG_EXIT size");

	if (datalen >= sizeof retval) {
	memcpy(&retval, data, sizeof retval);
	client_exitval = retval;
	}

	if (datalen > sizeof retval) {
	datalen -= sizeof retval;
	data += sizeof retval;

	client_exitmessage = xmalloc(datalen);
	memcpy(client_exitmessage, data, datalen);
	client_exitmessage[datalen - 1] = '\0';

	client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
	}
	}

	/* Dispatch imsgs when in wait state (before MSG_READY). */
	static void
	client_dispatch_wait(struct imsg *imsg)
	{
	char *data;
	ssize_t datalen;
	static int pledge_applied;

	/*
	* "sendfd" is no longer required once all of the identify messages
	* have been sent. We know the server won't send us anything until that
	* point (because we don't ask it to), so we can drop "sendfd" once we
	* get the first message from the server.
	*/
	if (!pledge_applied) {
	if (pledge(
	"stdio rpath wpath cpath unix proc exec tty",
	NULL) != 0)
	fatal("pledge failed");
	pledge_applied = 1;
	}

	data = imsg->data;
	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

	switch (imsg->hdr.type) {
	case MSG_EXIT:
	case MSG_SHUTDOWN:
	client_dispatch_exit_message(data, datalen);
	client_exitflag = 1;
	client_exit();
	break;
	case MSG_READY:
	if (datalen != 0)
	fatalx("bad MSG_READY size");

	client_attached = 1;
	proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
	break;
	case MSG_VERSION:
	if (datalen != 0)
	fatalx("bad MSG_VERSION size");

	fprintf(stderr, "protocol version mismatch "
	"(client %d, server %u)\n", PROTOCOL_VERSION,
	imsg->hdr.peerid & 0xff);
	client_exitval = 1;
	proc_exit(client_proc);
	break;
	case MSG_FLAGS:
	if (datalen != sizeof client_flags)
	fatalx("bad MSG_FLAGS string");

	memcpy(&client_flags, data, sizeof client_flags);
	log_debug("new flags are %#llx",
	(unsigned long long)client_flags);
	break;
	case MSG_SHELL:
	if (datalen == 0 \|\| data[datalen - 1] != '\0')
	fatalx("bad MSG_SHELL string");

	client_exec(data, shell_command);
	/* NOTREACHED */
	case MSG_DETACH:
	case MSG_DETACHKILL:
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case MSG_EXITED:
	proc_exit(client_proc);
	break;
	case MSG_READ_OPEN:
	file_read_open(&client_files, client_peer, imsg, 1,
	!(client_flags & CLIENT_CONTROL), client_file_check_cb,
	NULL);
	break;
	case MSG_WRITE_OPEN:
	file_write_open(&client_files, client_peer, imsg, 1,
	!(client_flags & CLIENT_CONTROL), client_file_check_cb,
	NULL);
	break;
	case MSG_WRITE:
	file_write_data(&client_files, imsg);
	break;
	case MSG_WRITE_CLOSE:
	file_write_close(&client_files, imsg);
	break;
	case MSG_OLDSTDERR:
	case MSG_OLDSTDIN:
	case MSG_OLDSTDOUT:
	fprintf(stderr, "server version is too old for client\n");
	proc_exit(client_proc);
	break;
	}
	}

	/* Dispatch imsgs in attached state (after MSG_READY). */
	static void
	client_dispatch_attached(struct imsg *imsg)
	{
	struct sigaction sigact;
	char *data;
	ssize_t datalen;

	data = imsg->data;
	datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

	switch (imsg->hdr.type) {
	case MSG_FLAGS:
	if (datalen != sizeof client_flags)
	fatalx("bad MSG_FLAGS string");

	memcpy(&client_flags, data, sizeof client_flags);
	log_debug("new flags are %#llx",
	(unsigned long long)client_flags);
	break;
	case MSG_DETACH:
	case MSG_DETACHKILL:
	if (datalen == 0 \|\| data[datalen - 1] != '\0')
	fatalx("bad MSG_DETACH string");

	client_exitsession = xstrdup(data);
	client_exittype = imsg->hdr.type;
	if (imsg->hdr.type == MSG_DETACHKILL)
	client_exitreason = CLIENT_EXIT_DETACHED_HUP;
	else
	client_exitreason = CLIENT_EXIT_DETACHED;
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case MSG_EXEC:
	if (datalen == 0 \|\| data[datalen - 1] != '\0' \|\|
	strlen(data) + 1 == (size_t)datalen)
	fatalx("bad MSG_EXEC string");
	client_execcmd = xstrdup(data);
	client_execshell = xstrdup(data + strlen(data) + 1);

	client_exittype = imsg->hdr.type;
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case MSG_EXIT:
	client_dispatch_exit_message(data, datalen);
	if (client_exitreason == CLIENT_EXIT_NONE)
	client_exitreason = CLIENT_EXIT_EXITED;
	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	break;
	case MSG_EXITED:
	if (datalen != 0)
	fatalx("bad MSG_EXITED size");

	proc_exit(client_proc);
	break;
	case MSG_SHUTDOWN:
	if (datalen != 0)
	fatalx("bad MSG_SHUTDOWN size");

	proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
	client_exitreason = CLIENT_EXIT_SERVER_EXITED;
	client_exitval = 1;
	break;
	case MSG_SUSPEND:
	if (datalen != 0)
	fatalx("bad MSG_SUSPEND size");

	memset(&sigact, 0, sizeof sigact);
	sigemptyset(&sigact.sa_mask);
	sigact.sa_flags = SA_RESTART;
	sigact.sa_handler = SIG_DFL;
	if (sigaction(SIGTSTP, &sigact, NULL) != 0)
	fatal("sigaction failed");
	client_suspended = 1;
	kill(getpid(), SIGTSTP);
	break;
	case MSG_LOCK:
	if (datalen == 0 \|\| data[datalen - 1] != '\0')
	fatalx("bad MSG_LOCK string");

	system(data);
	proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);
	break;
	}
	}