circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2025-01-15 05:09:04 +00:00
Code Issues Projects Releases Wiki Activity

Merge the before and after attach client code into one in client.c

Browse Source 
(instead of two in tmux.c and client.c).
This commit is contained in:
Nicholas Marriott 2010-10-18 20:00:02 +00:00
parent 31954339d1
commit 248fb14f08
4 changed files with 297 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
client.c
View File

@ -28,7 +28,6 @@
#include <pwd.h> #include <pwd.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <syslog.h>
#include <unistd.h> #include <unistd.h>
#include "tmux.h" #include "tmux.h"
@ -37,77 +36,171 @@ struct imsgbuf client_ibuf;
struct event client_event; struct event client_event;
const char *client_exitmsg; const char *client_exitmsg;
int client_exitval; int client_exitval;
int client_attached;
int client_connect(char *, int);
void client_send_identify(int); void client_send_identify(int);
void client_send_environ(void); void client_send_environ(void);
void client_write_server(enum msgtype, void *, size_t); void client_write_server(enum msgtype, void *, size_t);
void client_update_event(void); void client_update_event(void);
void client_signal(int, short, void *); void client_signal(int, short, void *);
void client_callback(int, short, void *); void client_callback(int, short, void *);
int client_dispatch(void); int client_dispatch_attached(void);
int client_dispatch_wait(void *);
struct imsgbuf * /* Connect client to server. */
client_init(char *path, int cmdflags, int flags) int
client_connect(char *path, int start_server)
{ {
struct sockaddr_un sa; struct sockaddr_un sa;
size_t size; size_t size;
int fd, mode; int fd, mode;
char rpathbuf[MAXPATHLEN];
if (realpath(path, rpathbuf) == NULL)
strlcpy(rpathbuf, path, sizeof rpathbuf);
setproctitle("client (%s)", rpathbuf);
memset(&sa, 0, sizeof sa); memset(&sa, 0, sizeof sa);
sa.sun_family = AF_UNIX; sa.sun_family = AF_UNIX;
size = strlcpy(sa.sun_path, path, sizeof sa.sun_path); size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
if (size >= sizeof sa.sun_path) { if (size >= sizeof sa.sun_path) {
errno = ENAMETOOLONG; errno = ENAMETOOLONG;
goto not_found; return (-1);
} }
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
fatal("socket failed"); fatal("socket failed");
if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1) { if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1) {
if (!(cmdflags & CMD_STARTSERVER)) if (!start_server)
goto not_found; goto failed;
switch (errno) { switch (errno) {
case ECONNREFUSED: case ECONNREFUSED:
if (unlink(path) != 0) if (unlink(path) != 0)
goto not_found; goto failed;
/* FALLTHROUGH */ /* FALLTHROUGH */
case ENOENT: case ENOENT:
if ((fd = server_start(path)) == -1) if ((fd = server_start()) == -1)
goto start_failed; goto failed;
goto server_started; break;
default:
goto failed;
} }
goto not_found;
} }
server_started:
if ((mode = fcntl(fd, F_GETFL)) == -1) if ((mode = fcntl(fd, F_GETFL)) == -1)
fatal("fcntl failed"); fatal("fcntl failed");
if (fcntl(fd, F_SETFL, mode|O_NONBLOCK) == -1) if (fcntl(fd, F_SETFL, mode|O_NONBLOCK) == -1)
fatal("fcntl failed"); fatal("fcntl failed");
imsg_init(&client_ibuf, fd); return (fd);
event_set(&client_event, fd, EV_READ, client_callback, NULL);
failed:
close(fd);
return (-1);
}
/* Client main loop. */
int
client_main(int argc, char **argv, int flags)
{
struct cmd *cmd;
struct cmd_list *cmdlist;
struct msg_command_data cmddata;
int cmdflags, fd;
enum msgtype msg;
char *cause;
/* Set up the initial command. */
cmdflags = 0;
if (shell_cmd != NULL) {
msg = MSG_SHELL;
cmdflags = CMD_STARTSERVER;
} else if (argc == 0) {
msg = MSG_COMMAND;
cmdflags = CMD_STARTSERVER|CMD_SENDENVIRON|CMD_CANTNEST;
} 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.
*/
if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) {
log_warnx("%s", cause);
return (1);
}
cmdflags &= ~CMD_STARTSERVER;
TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
if (cmd->entry->flags & CMD_STARTSERVER)
cmdflags |= CMD_STARTSERVER;
if (cmd->entry->flags & CMD_SENDENVIRON)
cmdflags |= CMD_SENDENVIRON;
if (cmd->entry->flags & CMD_CANTNEST)
cmdflags |= CMD_CANTNEST;
}
cmd_list_free(cmdlist);
}
/*
* Check if this could be a nested session, if the command can't nest:
* if the socket path matches $TMUX, this is probably the same server.
*/
if (shell_cmd == NULL && environ_path != NULL &&
cmdflags & CMD_CANTNEST && strcmp(socket_path, environ_path) == 0) {
log_warnx("sessions should be nested with care. "
"unset $TMUX to force.");
return (1);
}
/* Initialise the client socket and start the server. */
fd = client_connect(socket_path, cmdflags & CMD_STARTSERVER);
if (fd == -1) {
log_warn("failed to connect to server");
return (1);
}
/* Set process title, log and signals now this is the client. */
setproctitle("client (%s)", socket_path);
logfile("client");
/* Create imsg. */
imsg_init(&client_ibuf, fd);
event_set(&client_event, fd, EV_READ, client_callback, shell_cmd);
/* Establish signal handlers. */
set_signals(client_signal);
/* Send initial environment. */
if (cmdflags & CMD_SENDENVIRON) if (cmdflags & CMD_SENDENVIRON)
client_send_environ(); client_send_environ();
client_send_identify(flags); client_send_identify(flags);
return (&client_ibuf); /* Send first command. */
if (msg == MSG_COMMAND) {
/* Fill in command line arguments. */
cmddata.pid = environ_pid;
cmddata.idx = environ_idx;
start_failed: /* Prepare command for server. */
log_warnx("server failed to start"); cmddata.argc = argc;
return (NULL); if (cmd_pack_argv(
argc, argv, cmddata.argv, sizeof cmddata.argv) != 0) {
not_found: log_warnx("command too long");
log_warn("server not found"); return (1);
return (NULL);
} }
client_write_server(msg, &cmddata, sizeof cmddata);
} else if (msg == MSG_SHELL)
client_write_server(msg, NULL, 0);
/* Set the event and dispatch. */
client_update_event();
event_dispatch();
/* Print the exit message, if any, and exit. */
if (client_attached && client_exitmsg != NULL && !login_shell)
printf("[%s]\n", client_exitmsg);
return (client_exitval);
}
/* Send identify message to server with the file descriptors. */
void void
client_send_identify(int flags) client_send_identify(int flags)
{ {
@ -132,13 +225,16 @@ client_send_identify(int flags)
if ((fd = dup(STDOUT_FILENO)) == -1) if ((fd = dup(STDOUT_FILENO)) == -1)
fatal("dup failed"); fatal("dup failed");
imsg_compose(&client_ibuf, MSG_STDOUT, PROTOCOL_VERSION, -1, fd, NULL, 0); imsg_compose(&client_ibuf,
MSG_STDOUT, PROTOCOL_VERSION, -1, fd, NULL, 0);
if ((fd = dup(STDERR_FILENO)) == -1) if ((fd = dup(STDERR_FILENO)) == -1)
fatal("dup failed"); fatal("dup failed");
imsg_compose(&client_ibuf, MSG_STDERR, PROTOCOL_VERSION, -1, fd, NULL, 0); imsg_compose(&client_ibuf,
MSG_STDERR, PROTOCOL_VERSION, -1, fd, NULL, 0);
} }
/* Forward entire environment to server. */
void void
client_send_environ(void) client_send_environ(void)
{ {
@ -152,12 +248,14 @@ client_send_environ(void)
} }
} }
/* Write a message to the server without a file descriptor. */
void void
client_write_server(enum msgtype type, void *buf, size_t len) client_write_server(enum msgtype type, void *buf, size_t len)
{ {
imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, -1, buf, len); imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, -1, buf, len);
} }
/* Update client event based on whether it needs to read or read and write. */
void void
client_update_event(void) client_update_event(void)
{ {
@ -167,53 +265,29 @@ client_update_event(void)
events = EV_READ; events = EV_READ;
if (client_ibuf.w.queued > 0) if (client_ibuf.w.queued > 0)
events |= EV_WRITE; events |= EV_WRITE;
event_set(&client_event, client_ibuf.fd, events, client_callback, NULL); event_set(
&client_event, client_ibuf.fd, events, client_callback, shell_cmd);
event_add(&client_event, NULL); event_add(&client_event, NULL);
} }
__dead void /* Callback to handle signals in the client. */
client_main(void)
{
logfile("client");
/* Note: event_init() has already been called. */
/* Set up signals. */
set_signals(client_signal);
/*
* Send a resize message immediately in case the terminal size has
* changed between the identify message to the server and the MSG_READY
* telling us to move into the client code.
*/
client_write_server(MSG_RESIZE, NULL, 0);
/*
* imsg_read in the first client poll loop (before the terminal has
* been initialised) may have read messages into the buffer after the
* MSG_READY switched to here. Process anything outstanding now to
* avoid hanging waiting for messages that have already arrived.
*/
if (client_dispatch() != 0)
goto out;
/* Set the event and dispatch. */
client_update_event();
event_dispatch();
out:
/* Print the exit message, if any, and exit. */
if (client_exitmsg != NULL && !login_shell)
printf("[%s]\n", client_exitmsg);
exit(client_exitval);
}
/* ARGSUSED */ /* ARGSUSED */
void void
client_signal(int sig, unused short events, unused void *data) client_signal(int sig, unused short events, unused void *data)
{ {
struct sigaction sigact; struct sigaction sigact;
int status;
if (!client_attached) {
switch (sig) {
case SIGCHLD:
waitpid(WAIT_ANY, &status, WNOHANG);
break;
case SIGTERM:
event_loopexit(NULL);
break;
}
} else {
switch (sig) { switch (sig) {
case SIGHUP: case SIGHUP:
client_exitmsg = "lost tty"; client_exitmsg = "lost tty";
@ -238,20 +312,27 @@ client_signal(int sig, unused short events, unused void *data)
client_write_server(MSG_WAKEUP, NULL, 0); client_write_server(MSG_WAKEUP, NULL, 0);
break; break;
} }
}
client_update_event(); client_update_event();
} }
/* Callback for client imsg read events. */
/* ARGSUSED */ /* ARGSUSED */
void void
client_callback(unused int fd, short events, unused void *data) client_callback(unused int fd, short events, void *data)
{ {
ssize_t n; ssize_t n;
int retval;
if (events & EV_READ) { if (events & EV_READ) {
if ((n = imsg_read(&client_ibuf)) == -1 || n == 0) if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
goto lost_server; goto lost_server;
if (client_dispatch() != 0) { if (client_attached)
retval = client_dispatch_attached();
else
retval = client_dispatch_wait(data);
if (retval != 0) {
event_loopexit(NULL); event_loopexit(NULL);
return; return;
} }
@ -271,8 +352,76 @@ lost_server:
event_loopexit(NULL); event_loopexit(NULL);
} }
/* Dispatch imsgs when in wait state (before MSG_READY). */
int int
client_dispatch(void) client_dispatch_wait(void *data)
{
struct imsg imsg;
ssize_t n, datalen;
struct msg_shell_data shelldata;
struct msg_exit_data exitdata;
const char *shellcmd = data;
if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
fatalx("imsg_read failed");
for (;;) {
if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
fatalx("imsg_get failed");
if (n == 0)
return (0);
datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
switch (imsg.hdr.type) {
case MSG_EXIT:
case MSG_SHUTDOWN:
if (datalen != sizeof exitdata) {
if (datalen != 0)
fatalx("bad MSG_EXIT size");
} else {
memcpy(&exitdata, imsg.data, sizeof exitdata);
client_exitval = exitdata.retcode;
}
imsg_free(&imsg);
return (-1);
case MSG_READY:
if (datalen != 0)
fatalx("bad MSG_READY size");
client_attached = 1;
break;
case MSG_VERSION:
if (datalen != 0)
fatalx("bad MSG_VERSION size");
log_warnx("protocol version mismatch (client %u, "
"server %u)", PROTOCOL_VERSION, imsg.hdr.peerid);
client_exitval = 1;
imsg_free(&imsg);
return (-1);
case MSG_SHELL:
if (datalen != sizeof shelldata)
fatalx("bad MSG_SHELL size");
memcpy(&shelldata, imsg.data, sizeof shelldata);
shelldata.shell[(sizeof shelldata.shell) - 1] = '\0';
clear_signals(0);
shell_exec(shelldata.shell, shellcmd);
/* NOTREACHED */
default:
fatalx("unexpected message");
}
imsg_free(&imsg);
}
}
/* Dispatch imsgs in attached state (after MSG_READY). */
/* ARGSUSED */
int
client_dispatch_attached(void)
{ {
struct imsg imsg; struct imsg imsg;
struct msg_lock_data lockdata; struct msg_lock_data lockdata;

10
server.c
View File

@ -106,11 +106,11 @@ server_create_socket(void)
/* Fork new server. */ /* Fork new server. */
int int
server_start(char *path) server_start(void)
{ {
struct window_pane *wp; struct window_pane *wp;
int pair[2]; int pair[2];
char rpathbuf[MAXPATHLEN], *cause; char *cause;
struct timeval tv; struct timeval tv;
u_int i; u_int i;
@ -155,12 +155,8 @@ server_start(char *path)
utf8_build(); utf8_build();
start_time = time(NULL); start_time = time(NULL);
socket_path = path;
if (realpath(socket_path, rpathbuf) == NULL)
strlcpy(rpathbuf, socket_path, sizeof rpathbuf);
log_debug("socket path %s", socket_path); log_debug("socket path %s", socket_path);
setproctitle("server (%s)", rpathbuf); setproctitle("server (%s)", socket_path);
server_fd = server_create_socket(); server_fd = server_create_socket();
server_client_create(pair[1]); server_client_create(pair[1]);

266
tmux.c
View File

@ -18,17 +18,14 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/wait.h>
#include <errno.h> #include <errno.h>
#include <event.h> #include <event.h>
#include <fcntl.h> #include <fcntl.h>
#include <paths.h> #include <paths.h>
#include <pwd.h> #include <pwd.h>
#include <signal.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <syslog.h>
#include <unistd.h> #include <unistd.h>
#include "tmux.h" #include "tmux.h"
@ -37,7 +34,6 @@
extern char *malloc_options; extern char *malloc_options;
#endif #endif
char *cfg_file;
struct options global_options; /* server options */ struct options global_options; /* server options */
struct options global_s_options; /* session options */ struct options global_s_options; /* session options */
struct options global_w_options; /* window options */ struct options global_w_options; /* window options */
@ -45,28 +41,19 @@ struct environ global_environ;
struct event_base *ev_base; struct event_base *ev_base;
char *cfg_file;
char *shell_cmd;
int debug_level; int debug_level;
time_t start_time; time_t start_time;
char *socket_path; char socket_path[MAXPATHLEN];
int login_shell; int login_shell;
char *environ_path;
struct env_data { pid_t environ_pid;
char *path; u_int environ_idx;
pid_t pid;
u_int idx;
};
__dead void usage(void); __dead void usage(void);
void parse_env(struct env_data *); void parseenvironment(void);
char *makesockpath(const char *); char *makesocketpath(const char *);
__dead void shell_exec(const char *, const char *);
struct imsgbuf *main_ibuf;
struct event main_event;
void main_signal(int, short, unused void *);
void main_callback(int, short, void *);
void main_dispatch(const char *);
__dead void __dead void
usage(void) usage(void)
@ -136,14 +123,14 @@ areshell(const char *shell)
} }
void void
parse_env(struct env_data *data) parseenvironment(void)
{ {
char *env, *path_pid, *pid_idx, buf[256]; char *env, *path_pid, *pid_idx, buf[256];
size_t len; size_t len;
const char *errstr; const char *errstr;
long long ll; long long ll;
data->pid = -1; environ_pid = -1;
if ((env = getenv("TMUX")) == NULL) if ((env = getenv("TMUX")) == NULL)
return; return;
@ -156,9 +143,9 @@ parse_env(struct env_data *data)
/* path */ /* path */
len = path_pid - env; len = path_pid - env;
data->path = xmalloc (len + 1); environ_path = xmalloc(len + 1);
memcpy(data->path, env, len); memcpy(environ_path, env, len);
data->path[len] = '\0'; environ_path[len] = '\0';
/* pid */ /* pid */
len = pid_idx - path_pid - 1; len = pid_idx - path_pid - 1;
@ -170,17 +157,17 @@ parse_env(struct env_data *data)
ll = strtonum(buf, 0, LONG_MAX, &errstr); ll = strtonum(buf, 0, LONG_MAX, &errstr);
if (errstr != NULL) if (errstr != NULL)
return; return;
data->pid = ll; environ_pid = ll;
/* idx */ /* idx */
ll = strtonum(pid_idx + 1, 0, UINT_MAX, &errstr); ll = strtonum(pid_idx + 1, 0, UINT_MAX, &errstr);
if (errstr != NULL) if (errstr != NULL)
return; return;
data->idx = ll; environ_idx = ll;
} }
char * char *
makesockpath(const char *label) makesocketpath(const char *label)
{ {
char base[MAXPATHLEN], *path; char base[MAXPATHLEN], *path;
struct stat sb; struct stat sb;
@ -240,28 +227,18 @@ shell_exec(const char *shell, const char *shellcmd)
int int
main(int argc, char **argv) main(int argc, char **argv)
{ {
struct cmd_list *cmdlist;
struct cmd *cmd;
enum msgtype msg;
struct passwd *pw; struct passwd *pw;
struct options *oo, *so, *wo; struct options *oo, *so, *wo;
struct keylist *keylist; struct keylist *keylist;
struct env_data envdata; char *s, *path, *label, *home, **var;
struct msg_command_data cmddata; int opt, flags, quiet = 0;
char *s, *shellcmd, *path, *label, *home, *cause;
char **var;
void *buf;
size_t len;
int opt, flags, quiet = 0, cmdflags = 0;
short events;
#ifdef DEBUG #ifdef DEBUG
malloc_options = (char *) "AFGJPX"; malloc_options = (char *) "AFGJPX";
#endif #endif
flags = 0; flags = 0;
shellcmd = label = path = NULL; label = path = NULL;
envdata.path = NULL;
login_shell = (**argv == '-'); login_shell = (**argv == '-');
while ((opt = getopt(argc, argv, "28c:df:lL:qS:uUv")) != -1) { while ((opt = getopt(argc, argv, "28c:df:lL:qS:uUv")) != -1) {
switch (opt) { switch (opt) {
@ -274,9 +251,9 @@ main(int argc, char **argv)
flags &= ~IDENTIFY_256COLOURS; flags &= ~IDENTIFY_256COLOURS;
break; break;
case 'c': case 'c':
if (shellcmd != NULL) if (shell_cmd != NULL)
xfree(shellcmd); xfree(shell_cmd);
shellcmd = xstrdup(optarg); shell_cmd = xstrdup(optarg);
break; break;
case 'f': case 'f':
if (cfg_file != NULL) if (cfg_file != NULL)
@ -312,7 +289,7 @@ main(int argc, char **argv)
argc -= optind; argc -= optind;
argv += optind; argv += optind;
if (shellcmd != NULL && argc != 0) if (shell_cmd != NULL && argc != 0)
usage(); usage();
log_open_tty(debug_level); log_open_tty(debug_level);
@ -448,6 +425,7 @@ main(int argc, char **argv)
options_set_number(wo, "utf8", 0); options_set_number(wo, "utf8", 0);
} }
/* Locate the configuration file. */
if (cfg_file == NULL) { if (cfg_file == NULL) {
home = getenv("HOME"); home = getenv("HOME");
if (home == NULL || *home == '\0') { if (home == NULL || *home == '\0') {
@ -463,21 +441,22 @@ main(int argc, char **argv)
} }
/* /*
* Figure out the socket path. If specified on the command-line with * Figure out the socket path. If specified on the command-line with -S
* -S or -L, use it, otherwise try $TMUX or assume -L default. * or -L, use it, otherwise try $TMUX or assume -L default.
*/ */
parse_env(&envdata); parseenvironment();
if (path == NULL) { if (path == NULL) {
/* No -L. Try $TMUX, or default. */ /* If no -L, use the environment. */
if (label == NULL) { if (label == NULL) {
path = envdata.path; if (environ_path != NULL)
if (path == NULL) path = xstrdup(environ_path);
else
label = xstrdup("default"); label = xstrdup("default");
} }
/* -L or default set. */ /* -L or default set. */
if (label != NULL) { if (label != NULL) {
if ((path = makesockpath(label)) == NULL) { if ((path = makesocketpath(label)) == NULL) {
log_warn("can't create socket"); log_warn("can't create socket");
exit(1); exit(1);
} }
@ -485,181 +464,14 @@ main(int argc, char **argv)
} }
if (label != NULL) if (label != NULL)
xfree(label); xfree(label);
if (realpath(path, socket_path) == NULL)
if (shellcmd != NULL) { strlcpy(socket_path, path, sizeof socket_path);
msg = MSG_SHELL;
buf = NULL;
len = 0;
} else {
cmddata.pid = envdata.pid;
cmddata.idx = envdata.idx;
/* Prepare command for server. */
cmddata.argc = argc;
if (cmd_pack_argv(
argc, argv, cmddata.argv, sizeof cmddata.argv) != 0) {
log_warnx("command too long");
exit(1);
}
msg = MSG_COMMAND;
buf = &cmddata;
len = sizeof cmddata;
}
if (shellcmd != NULL)
cmdflags |= CMD_STARTSERVER;
else if (argc == 0) /* new-session is the default */
cmdflags |= CMD_STARTSERVER|CMD_SENDENVIRON|CMD_CANTNEST;
else {
/*
* It sucks parsing the command string twice (in client and
* later in server) but it is necessary to get the start server
* flag.
*/
if ((cmdlist = cmd_list_parse(argc, argv, &cause)) == NULL) {
log_warnx("%s", cause);
exit(1);
}
cmdflags &= ~CMD_STARTSERVER;
TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
if (cmd->entry->flags & CMD_STARTSERVER)
cmdflags |= CMD_STARTSERVER;
if (cmd->entry->flags & CMD_SENDENVIRON)
cmdflags |= CMD_SENDENVIRON;
if (cmd->entry->flags & CMD_CANTNEST)
cmdflags |= CMD_CANTNEST;
}
cmd_list_free(cmdlist);
}
/*
* Check if this could be a nested session, if the command can't nest:
* if the socket path matches $TMUX, this is probably the same server.
*/
if (shellcmd == NULL && envdata.path != NULL &&
cmdflags & CMD_CANTNEST &&
(path == envdata.path || strcmp(path, envdata.path) == 0)) {
log_warnx("sessions should be nested with care. "
"unset $TMUX to force.");
exit(1);
}
ev_base = event_init();
set_signals(main_signal);
/* Initialise the client socket/start the server. */
if ((main_ibuf = client_init(path, cmdflags, flags)) == NULL)
exit(1);
xfree(path); xfree(path);
imsg_compose(main_ibuf, msg, PROTOCOL_VERSION, -1, -1, buf, len); /* Set process title. */
setproctitle("%s (%s)", __progname, socket_path);
events = EV_READ; /* Pass control to the client. */
if (main_ibuf->w.queued > 0) ev_base = event_init();
events |= EV_WRITE; exit(client_main(argc, argv, flags));
event_set(&main_event, main_ibuf->fd, events, main_callback, shellcmd);
event_add(&main_event, NULL);
event_dispatch();
event_del(&main_event);
clear_signals(0);
client_main(); /* doesn't return */
}
/* ARGSUSED */
void
main_signal(int sig, unused short events, unused void *data)
{
int status;
switch (sig) {
case SIGTERM:
exit(1);
case SIGCHLD:
waitpid(WAIT_ANY, &status, WNOHANG);
break;
}
}
/* ARGSUSED */
void
main_callback(unused int fd, short events, void *data)
{
char *shellcmd = data;
if (events & EV_READ)
main_dispatch(shellcmd);
if (events & EV_WRITE) {
if (msgbuf_write(&main_ibuf->w) < 0)
fatalx("msgbuf_write failed");
}
event_del(&main_event);
events = EV_READ;
if (main_ibuf->w.queued > 0)
events |= EV_WRITE;
event_set(&main_event, main_ibuf->fd, events, main_callback, shellcmd);
event_add(&main_event, NULL);
}
void
main_dispatch(const char *shellcmd)
{
struct imsg imsg;
ssize_t n, datalen;
struct msg_shell_data shelldata;
struct msg_exit_data exitdata;
if ((n = imsg_read(main_ibuf)) == -1 || n == 0)
fatalx("imsg_read failed");
for (;;) {
if ((n = imsg_get(main_ibuf, &imsg)) == -1)
fatalx("imsg_get failed");
if (n == 0)
return;
datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
switch (imsg.hdr.type) {
case MSG_EXIT:
case MSG_SHUTDOWN:
if (datalen != sizeof exitdata) {
if (datalen != 0)
fatalx("bad MSG_EXIT size");
exit(0);
}
memcpy(&exitdata, imsg.data, sizeof exitdata);
exit(exitdata.retcode);
case MSG_READY:
if (datalen != 0)
fatalx("bad MSG_READY size");
event_loopexit(NULL); /* move to client_main() */
break;
case MSG_VERSION:
if (datalen != 0)
fatalx("bad MSG_VERSION size");
log_warnx("protocol version mismatch (client %u, "
"server %u)", PROTOCOL_VERSION, imsg.hdr.peerid);
exit(1);
case MSG_SHELL:
if (datalen != sizeof shelldata)
fatalx("bad MSG_SHELL size");
memcpy(&shelldata, imsg.data, sizeof shelldata);
shelldata.shell[(sizeof shelldata.shell) - 1] = '\0';
clear_signals(0);
shell_exec(shelldata.shell, shellcmd);
default:
fatalx("unexpected message");
}
imsg_free(&imsg);
}
} }

13
tmux.h
View File

@ -1291,15 +1291,19 @@ extern struct options global_w_options;
extern struct environ global_environ; extern struct environ global_environ;
extern struct event_base *ev_base; extern struct event_base *ev_base;
extern char *cfg_file; extern char *cfg_file;
extern char *shell_cmd;
extern int debug_level; extern int debug_level;
extern int be_quiet;
extern time_t start_time; extern time_t start_time;
extern char *socket_path; extern char socket_path[MAXPATHLEN];
extern int login_shell; extern int login_shell;
extern char *environ_path;
extern pid_t environ_pid;
extern u_int environ_idx;
void logfile(const char *); void logfile(const char *);
const char *getshell(void); const char *getshell(void);
int checkshell(const char *); int checkshell(const char *);
int areshell(const char *); int areshell(const char *);
__dead void shell_exec(const char *, const char *);
/* cfg.c */ /* cfg.c */
extern int cfg_finished; extern int cfg_finished;
@ -1598,8 +1602,7 @@ void cmd_buffer_free(struct cmd *);
size_t cmd_buffer_print(struct cmd *, char *, size_t); size_t cmd_buffer_print(struct cmd *, char *, size_t);
/* client.c */ /* client.c */
struct imsgbuf *client_init(char *, int, int); int client_main(int, char **, int);
__dead void client_main(void);
/* key-bindings.c */ /* key-bindings.c */
extern struct key_bindings key_bindings; extern struct key_bindings key_bindings;
@ -1622,7 +1625,7 @@ const char *key_string_lookup_key(int);
/* server.c */ /* server.c */
extern struct clients clients; extern struct clients clients;
extern struct clients dead_clients; extern struct clients dead_clients;
int server_start(char *); int server_start(void);
void server_update_socket(void); void server_update_socket(void);
/* server-client.c */ /* server-client.c */